Cómo compilar y ejecutar una aplicación con Docker y Kubernetes

Introducción

Bienvenido a este tutorial sobre Docker y Kubernetes, dos herramientas esenciales para desarrollar e implementar aplicaciones en una arquitectura de microservicios. Estas dos herramientas se han convertido en estándares de la industria para la gestión de contenedores y la orquestación de clústeres, respectivamente.

En este tutorial, lo guiaremos a través de los pasos para crear y ejecutar una aplicación simple con Docker y Kubernetes. Aprenderá a crear una imagen de Docker para su aplicación, ejecutar la imagen en un contenedor de Docker y finalmente implementar su contenedor en un clúster de Kubernetes.

Este tutorial está destinado a aquellos que ya tienen un conocimiento básico de Docker y Kubernetes. Si es nuevo en estas herramientas, le recomendamos que se familiarice con los conceptos básicos antes de continuar. Si por el contrario ya estás familiarizado con Docker y Kubernetes y quieres profundizar en tus conocimientos, este tutorial es ideal para ti.

Antes de comenzar, asegúrese de tener Docker y Kubernetes instalados en su computadora. Además, necesitará un editor de texto para escribir el código de su aplicación.

Parte 1: ventana acoplable

Docker nos permite contener nuestras aplicaciones, lo que hace posible que se ejecuten en cualquier entorno que admita Docker.

Paso 1: Instalar Docker

Visite el sitio oficial de Docker y siga las instrucciones para instalar Docker en su sistema operativo.

Paso 2: Crea un Dockerfile

Un Dockerfile es un script que contiene instrucciones para crear una imagen de Docker. Vamos a crear un Dockerfile simple para una aplicación Node.js.

Cree un nuevo archivo llamado Dockerfile e inserte el siguiente código:

# Usa l'immagine ufficiale Node.js per la fase di build
 FROM node:14 AS build
 WORKDIR /app
 COPY package*.json./RUN npm install
 COPY..

 # Fase di esecuzione
 FROM node:14-alpine
 WORKDIR /app
 COPY --from=build /app.
 EXPOSE 8080
 CMD [ "node", "app.js" ]

Este Dockerfile primero crea una imagen con Node.js y copia su código fuente en la imagen (fase de construcción). Luego, cree una imagen más pequeña basada en Node.js Alpine y copie la aplicación desde la etapa de compilación. La aplicación se ejecuta en el puerto 8080.

Paso 3: Crear la imagen de Docker

Ejecute el siguiente comando para crear la imagen de Docker:

docker build -t my-node-app.

Paso 4: Ejecute la imagen de Docker

Una vez que se crea la imagen, puede ejecutarla con el siguiente comando:

docker run -p 8080:8080 my-node-app

Su aplicación ahora debería estar ejecutándose y accesible en el puerto 8080.

Parte 2: Kubernetes

Kubernetes nos permite administrar, escalar e implementar fácilmente nuestras aplicaciones en contenedores.

Paso 1: Instalar Kubernetes

Visite el sitio oficial de Kubernetes y siga las instrucciones para instalar Kubernetes en su sistema operativo.

Paso 2: Cree un archivo de configuración de Kubernetes

Un archivo de configuración de Kubernetes (también llamado manifiesto) define los recursos que desea crear en su clúster de Kubernetes. Creemos un archivo de configuración simple para nuestra aplicación Node.js.

Cree un nuevo archivo llamado my-node-app.yaml e inserte el siguiente código:

apiVersion: v1
 kind: Service
 metadata:
 name: my-node-app
 labels:
 app: my-node-app
 spec:
 ports:
 - port: 8080
 targetPort: 8080
 selector:
 app: my-node-app
 ---
 apiVersion: apps/v1
 kind: Deployment
 metadata:
 name: my-node-app
 spec:
 replicas: 3
 selector:
 matchLabels:
 app: my-node-app
 template:
 metadata:
 labels:
 app: my-node-app
 spec:
 containers:
 - name: my-node-app
 image: my-node-app:latest
 ports:
 - containerPort: 8080

Este archivo define un servicio y una implementación para nuestra aplicación. La implementación crea tres pods, cada uno con una copia de nuestra aplicación, y el servicio hace que la aplicación sea accesible en el puerto 8080.

Paso 3: Ejecute la aplicación en el clúster de Kubernetes

Ejecute el siguiente comando para crear los recursos definidos en el archivo de configuración:

kubectl apply -f my-node-app.yaml

Su aplicación ahora debería estar ejecutándose en su clúster de Kubernetes y accesible en el puerto 8080.

Conclusión

¡Felicidades! Acaba de crear una aplicación en contenedores con Docker y ejecutar esa aplicación en un clúster de Kubernetes. Recuerde, esto es solo un tutorial básico. Docker y Kubernetes ofrecen muchas otras funciones que le permiten crear aplicaciones potentes y escalables.