Migrar un Docker Compose a Kubernetes

por
Tiempo de lectura: 5 minutos

Hoy vamos a aprender con un ejemplo, cómo podemos migrar un Docker Compose (https://www.docker.com/) a Kubernetes (https://kubernetes.io/es).

Primero voy a explicar que son las dos tecnologías mencionadas:

Docker Compose:

Docker Compose es una herramienta que permite definir y ejecutar aplicaciones Docker de manera multi-contenedor. Con Docker Compose, puedes describir toda la configuración de tus servicios, redes y volúmenes en un archivo YAML (docker-compose.yaml). Este archivo puede contener información sobre imágenes de contenedores, puertos expuestos, variables de entorno, volúmenes compartidos y más. Al utilizar docker-compose up, puedes iniciar y desplegar fácilmente una aplicación multi-contenedor en tu entorno local.

Un ejemplo de docker-compose.yaml para una aplicación web y una base de datos MySQL podría verse así:

version: '3'
services:
  webapp:
    image: tu-imagen-webapp:latest
    ports:
      - "8080:80"
  database:
    image: tu-imagen-mysql:latest
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: mydatabase
      MYSQL_USER: user
      MYSQL_PASSWORD: password

Kubernetes:

Kubernetes es una plataforma de orquestación de contenedores de código abierto que automatiza el despliegue, escalado y operación de aplicaciones en contenedores. Permite administrar y orquestar contenedores en clústeres, facilitando la implementación y gestión de aplicaciones distribuidas y escalables.

En Kubernetes, defines los recursos de la aplicación, como Pods (instancias de contenedores), Deployments (conjuntos de Pods), Services (puntos de entrada a la aplicación), ConfigMaps (configuraciones) y más, mediante archivos de configuración YAML o JSON.

Diferencias y Uso conjunto:

  • Docker Compose es para desarrollo local: Docker Compose es excelente para entornos de desarrollo local, donde puedes definir y probar fácilmente tus aplicaciones multi-contenedor. Puedes utilizarlo para crear entornos consistentes entre desarrolladores y desplegar rápidamente aplicaciones en un solo host.
  • Kubernetes es para orquestación en producción: Kubernetes es ideal para entornos de producción y escenarios en los que necesitas gestionar aplicaciones en clústeres de servidores. Proporciona características avanzadas como el escalado automático, la autoreparación, el despliegue de versiones sin tiempo de inactividad y la administración de recursos.
  • Uso conjunto: A menudo, se utiliza Docker Compose para desarrollar y probar aplicaciones localmente, y luego se migra a Kubernetes para la implementación en entornos de producción. Herramientas como kompose pueden ayudar en la conversión de archivos de Docker Compose a configuraciones de Kubernetes, facilitando así la transición entre entornos de desarrollo y producción.

Ahora vamos a poner un ejemplo para ver cómo podemos pasar nuestro Docker Compose a una configuración de Kubernetes:

Supongamos que tienes una aplicación compuesta por dos servicios en tu Docker Compose: un servicio web llamado «webapp» y una base de datos llamada «database». Aquí está el Docker Compose original:

version: '3'
services:
  webapp:
    image: tu-imagen-webapp:latest
    ports:
      - "8080:80"
  database:
    image: tu-imagen-database:latest
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: mydatabase
      MYSQL_USER: user
      MYSQL_PASSWORD: password

*Sí, es el código del primer ejemplo.

Paso 1: Preparación

Antes de comenzar, asegúrate de tener instalado Kubernetes en tu entorno local. Puedes usar herramientas como Minikube o Docker Desktop con soporte para Kubernetes (https://devcodelight.com/instalar-docker-y-docker-compose-en-oracle-linux/). También necesitarás kubectl, la herramienta de línea de comandos de Kubernetes.

Paso 2: Convertir Docker Compose a Kubernetes

2.1 Convertir docker-compose.yaml a Recursos de Kubernetes

Divide tu archivo docker-compose.yaml en varios archivos de configuración de Kubernetes: uno para cada servicio. Puedes crear archivos separados para Deployment y Service.

Recuerda que para que se pueda pasar a Kubernetes, deberás tener tu imagen docker creada y hospedada o utilizar una ya hospedada (https://devcodelight.com/desplegar-un-servidor-de-imagenes-docker-en-un-docker-compose-docker-registry/)

Por ejemplo, para un servicio llamado «webapp»:

webapp-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: webapp
        image: tu-imagen-webapp:latest
        ports:
        - containerPort: 80

webapp-service.yaml:

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

database-deploiment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: database
spec:
  replicas: 1
  selector:
    matchLabels:
      app: database
  template:
    metadata:
      labels:
        app: database
    spec:
      containers:
      - name: database
        image: tu-imagen-database:latest
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: rootpass
        - name: MYSQL_DATABASE
          value: mydatabase
        - name: MYSQL_USER
          value: user
        - name: MYSQL_PASSWORD
          value: password

database-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: database
spec:
  selector:
    app: database
  ports:
    - protocol: TCP
      port: 3306
      targetPort: 3306

Ahora aplicamos estos archivos a cluster de Kubernetes:

kubectl apply -f webapp-deployment.yaml
kubectl apply -f webapp-service.yaml
kubectl apply -f database-deployment.yaml
kubectl apply -f database-service.yaml

2.2 Convertir Variables de Entorno

Si tu Docker Compose utiliza variables de entorno, asegúrate de convertirlas a configuraciones equivalentes en Kubernetes. En el ejemplo anterior, las variables de entorno para el servicio de base de datos se convirtieron así:

database-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: database
spec:
  replicas: 1
  selector:
    matchLabels:
      app: database
  template:
    metadata:
      labels:
        app: database
    spec:
      containers:
      - name: database
        image: tu-imagen-database:latest
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: rootpass
        - name: MYSQL_DATABASE
          value: mydatabase
        - name: MYSQL_USER
          value: user
        - name: MYSQL_PASSWORD
          value: password

Paso 3: Aplicar Configuraciones en Kubernetes

Aplica las configuraciones convertidas en tu clúster Kubernetes utilizando kubectl.

kubectl apply -f webapp-deployment.yaml
kubectl apply -f webapp-service.yaml
kubectl apply -f database-deployment.yaml
kubectl apply -f database-service.yaml

Paso 4: Verificar el Estado

Usa los siguientes comandos para verificar que tus recursos se hayan desplegado correctamente:

kubectl get pods
kubectl get services
kubectl get deployments

¡Listo!

¡Has migrado con éxito tu sistema de Docker Compose a Kubernetes! Puedes acceder a tu aplicación a través de la dirección IP o nombre de servicio proporcionado por Kubernetes para el servicio «webapp». Recuerda ajustar estos pasos según las necesidades específicas de tu aplicación.

Nota: Como detener los pods creados.

Para detener (o más precisamente, eliminar) pods en Kubernetes, puedes utilizar el comando kubectl delete pod. Aquí tienes algunas formas de hacerlo:

Detener un Solo Pod:

kubectl delete pod NOMBRE_DEL_POD

Reemplaza NOMBRE_DEL_POD con el nombre del pod que deseas detener.

Detener Todos los Pods en un Namespace Específico:

kubectl delete pods --all -n NOMBRE_DEL_NAMESPACE

Reemplaza NOMBRE_DEL_NAMESPACE con el nombre del namespace en el que deseas detener todos los pods.

Detener Todos los Pods en Todos los Namespaces:

kubectl delete pods --all --all-namespaces

Este comando eliminará todos los pods en todos los namespaces.

Ten en cuenta que al eliminar un pod, Kubernetes intentará crear un nuevo pod para mantener el estado deseado. Si deseas detener un pod y evitar que se reemplace, puedes escalar el número de replicas del deployment o replicaset a cero, pero ten cuidado al hacer esto en entornos de producción.

Escalar Replicas a Cero para Detener un Deployment:

kubectl scale deployment NOMBRE_DEL_DEPLOYMENT --replicas=0 -n NOMBRE_DEL_NAMESPACE

Reemplaza NOMBRE_DEL_DEPLOYMENT y NOMBRE_DEL_NAMESPACE con los nombres adecuados.

Ten en cuenta que estas operaciones eliminarán los pods, y si tienes configurado un controlador de replicación, se crearán nuevos pods para mantener el número deseado. Si deseas detener completamente una aplicación, podrías necesitar desmontar o eliminar los recursos relacionados, como servicios y despliegues.

Otra opción es modificar el número de replicas dentro del pod y ponerlas a 0:

metadata:
  name: webapp
spec:
  replicas: 0

Y después aplicarlo:

kubectl apply -f webapp-deployment.yaml
Post Views: 22

Deja un comentario