Tutorial de Docker y Kubernetes

Introducción

Docker es una plataforma que simplifica la implementación de software al permitirle agrupar una aplicación con su entorno de tiempo de ejecución en un solo paquete llamado contenedor. Esto garantiza que la aplicación se ejecutará de la misma manera independientemente de dónde se implemente.

Kubernetes (a menudo abreviado como K8s) es un sistema de orquestación de contenedores de código abierto. Se utiliza para automatizar la implementación, el escalado y la gestión de aplicaciones en contenedores, como las creadas con Docker.

requisitos previos

• Comprensión básica de los comandos de Linux
• Docker instalado en su máquina. Siga la guía de instalación de Docker para configurarlo.
• Kubernetes instalado en su máquina. Siga la guía de instalación oficial de Kubernetes.

Paso 1: Docker - Creación de una imagen

Primero, creemos un Dockerfile simple para una aplicación Node.js.

Cree un nuevo directorio en su máquina local y navegue hasta él.

mkdir my-node-app && cd my-node-app

Cree un archivo llamado Dockerfile.

touch Dockerfile

Abra el Dockerfile y agregue el siguiente código:

# Use an official Node.js runtime as the base image
 FROM node:14

 # Set the working directory in the container to /app
 WORKDIR /app

 # Copy package.json and package-lock.json to the working directory
 COPY package*.json./# Install the application dependencies
 RUN npm install

 # Copy the rest of your application's source code to the working directory
 COPY..

 # Make the container listen on port 8080 at runtime
 EXPOSE 8080

 # Define the command to run the app
 CMD [ "node", "server.js" ]

Compile la imagen de Docker con el comando docker build.

docker build -t my-node-app.

Paso 2: Docker: ejecución de un contenedor

Una vez que se crea la imagen, puede ejecutarla como un contenedor usando docker run.

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

Este comando le dice a Docker que ejecute un contenedor con la imagen de mi aplicación de nodo, asigne el puerto 8080 dentro del contenedor de Docker al puerto 8080 en la máquina host y ejecute el contenedor en segundo plano (modo separado).

Paso 3: Kubernetes: creación de una implementación

Kubernetes administra contenedores Docker a través de objetos como Pods e Implementaciones. Un Pod es el objeto de Kubernetes más pequeño y simple. Representa una sola instancia de un proceso en ejecución en un clúster y puede contener uno o más contenedores.

Cree un archivo llamado deployment.yaml con el siguiente contenido:

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

Aplique esta implementación a su clúster de Kubernetes mediante el comando kubectl apply.

kubectl apply -f deployment.yaml

Esta implementación crea tres pods replicados que ejecutan el contenedor my-node-app. Si un Pod falla, la Implementación lo recreará automáticamente para mantener una cuenta de tres.

Paso 4: Kubernetes: exposición de su implementación

Una vez que la implementación esté activa, es posible que desee exponerla a Internet. En Kubernetes, puede hacer esto usando un Servicio, que es una abstracción que define un conjunto de Pods y una política para acceder a ellos.

Crea un archivo llamado service.yaml con el siguiente contenido:

apiVersion: v1
 kind: Service
 metadata:
 name: my-node-app
 spec:
 selector:
 app: my-node-app
 ports:
 - protocol: TCP
 port: 80
 targetPort: 8080
 type: LoadBalancer

Aplique este servicio a su clúster de Kubernetes mediante el comando kubectl apply.

kubectl apply -f service.yaml

Este servicio expone la implementación de my-node-app fuera del clúster. El tipo "LoadBalancer" garantiza que se pueda acceder al Servicio a través de una IP de red dedicada en la nube, si su proveedor de nube lo admite.

Paso 5: Kubernetes: verificación de la implementación y el servicio

Para verificar si la implementación está funcionando como se esperaba, ejecute el siguiente comando:

kubectl get deployments

Debería ver la implementación "my-node-app" con tres réplicas.

De manera similar, para verificar el Servicio, use el siguiente comando:

kubectl get services

Debería ver el servicio "my-node-app" con una dirección IP externa. Puede usar esta dirección IP para acceder a su aplicación desde un navegador web.

Conclusión

¡Y eso es! Este es un ejemplo muy básico, pero debería darle una idea de cómo usar Docker y Kubernetes para contener una aplicación e implementarla en un clúster de Kubernetes.