DevOps

Cómo usar Kubernetes para orquestar contenedores en un entorno DevOps

Virgílio Borges

• 9 min read
Cómo usar Kubernetes para orquestar contenedores en un entorno DevOps

Kubernetes es una plataforma de código abierto que permite automatizar la implementación, el escalado y la gestión de aplicaciones en contenedores. En este artículo, vamos explicar qué son los contenedores, por qué son útiles para el desarrollo de software, cómo funciona Kubernetes y cómo puede facilitar la integración y entrega continuas (CI/CD) en un entorno DevOps.

¿Qué son los contenedores y por qué usarlos?

Los contenedores son unidades de software que empaquetan el código y todas sus dependencias, lo que permite que las aplicaciones se ejecuten de manera aislada y consistente en cualquier entorno. Son diferentes de las máquinas virtuales (VMs), que requieren un sistema operativo (SO) completo para cada aplicación. Los contenedores comparten el mismo SO del host, lo que reduce el consumo de recursos y aumenta el rendimiento.

Los contenedores ofrecen varias ventajas para el desarrollo de software, tales como:

  • Portabilidad: los contenedores se pueden mover fácilmente entre diferentes plataformas, nubes o entornos locales sin alterar su funcionamiento.
  • Estandarización: los contenedores siguen un formato común, lo que facilita la colaboración entre equipos y la integración con otras herramientas.
  • Modularidad: los contenedores permiten dividir las aplicaciones en componentes más pequeños e independientes, que se pueden actualizar, probar e implementar de manera ágil y segura.
  • Escalabilidad: los contenedores se pueden replicar o eliminar rápidamente, según la demanda, optimizando el uso de los recursos y la disponibilidad de las aplicaciones.

¿Qué es Kubernetes y cómo funciona?

Kubernetes es un sistema que orquesta los contenedores, es decir, gestiona su ciclo de vida, su comunicación y su distribución en un clúster de máquinas. Un clúster es un conjunto de nodos (nodes), que pueden ser físicos o virtuales, donde se ejecutan los contenedores. Kubernetes tiene una arquitectura basada en maestro/esclavo (master/worker), donde hay uno o más nodos maestros responsables del control del clúster y varios nodos esclavos encargados de ejecutar los contenedores.

Kubernetes utiliza algunos conceptos clave para organizar y gestionar los contenedores en el clúster, como:

  • Pod: es la unidad más pequeña de implementación en Kubernetes, que consiste en uno o más contenedores relacionados, que comparten el mismo espacio de red y almacenamiento. Cada pod tiene una dirección IP única dentro del clúster y puede comunicarse con otros pods a través de servicios.
  • Servicio: es una abstracción que define un conjunto lógico de pods y una política de acceso a ellos. Un servicio permite que los pods sean accesibles mediante un nombre o una dirección IP estable, independientemente de su ubicación en el clúster.
  • Controlador: es un componente que monitorea el estado actual del clúster y garantiza que esté en línea con el estado deseado, definido por el usuario. Existen varios tipos de controladores en Kubernetes, como ReplicaSet, Deployment, StatefulSet, DaemonSet, Job y CronJob.
  • Namespace: es un mecanismo que permite aislar y agrupar recursos del clúster en diferentes contextos. Cada namespace tiene un nombre único en el clúster y puede contener pods, servicios, controladores y otros objetos. Los namespaces permiten organizar las aplicaciones por proyectos, equipos o entornos.

¿Cómo usar Kubernetes en un entorno DevOps?

DevOps es una cultura que busca integrar los equipos de desarrollo y operaciones de software, con el objetivo de agilizar la entrega de valor a los clientes. Para ello, DevOps utiliza prácticas como integración continua (CI), entrega continua (CD), infraestructura como código (IaC), monitoreo y feedback.

Kubernetes encaja perfectamente en esta cultura, ya que ofrece recursos que facilitan la implementación y gestión de aplicaciones en contenedores en cualquier entorno. Además, Kubernetes se integra con varias herramientas de DevOps, como Jenkins, GitLab CI/CD, Helm, Terraform, Prometheus y Grafana.

A continuación, mostraremos algunos ejemplos de cómo usar Kubernetes en un entorno DevOps, utilizando minikube, una herramienta que permite ejecutar un clúster de Kubernetes localmente, y kubectl, una herramienta que permite interactuar con el clúster mediante comandos.

Creando un pod con un contenedor

Para crear un pod con un contenedor, podemos usar el comando kubectl run, especificando el nombre del pod, la imagen del contenedor y los argumentos opcionales. Por ejemplo, para crear un pod llamado hello-pod con un contenedor que ejecuta el comando echo "Hello, Kubernetes!", podemos usar el siguiente comando:

> kubectl run hello-pod --image=busybox --restart=Never -- echo "Hello, Kubernetes!"

Para verificar si el pod se creó con éxito, podemos usar el comando kubectl get pods, que lista todos los pods del namespace actual:

> kubectl get pods
NAME        READY   STATUS      RESTARTS   AGE
hello-pod   0/1     Completed   0          10s

Para ver los logs del contenedor dentro del pod, podemos usar el comando kubectl logs, especificando el nombre del pod:

> kubectl logs hello-pod
Hello, Kubernetes!

Creando un servicio para exponer un pod

Para exponer un pod para acceso externo, podemos usar el comando kubectl expose, especificando el nombre del pod, el tipo de servicio y el puerto. Por ejemplo, para crear un servicio llamado hello-service de tipo NodePort, que expone el puerto 8080 del pod hello-pod en el puerto 30000 del nodo, podemos usar el siguiente comando:

kubectl expose pod hello-pod --name=hello-service --type=NodePort --port=8080

Para verificar si el servicio se creó con éxito, podemos usar el comando kubectl get services, que lista todos los servicios del namespace actual:

> kubectl get services
NAME           TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
hello-service  NodePort    10.108.147.26   <none>        8080:30000/TCP   10s
kubernetes     ClusterIP   10.96.0.1       <none>        443/TCP          5m23s

Para acceder al servicio, podemos usar la dirección IP del nodo y el puerto del servicio. Para obtener la dirección IP del nodo, podemos usar el comando minikube ip, que devuelve la IP del clúster de minikube:

> minikube ip
192.168.49.2

Para acceder al servicio, podemos usar el comando curl, especificando la IP del nodo y el puerto del servicio:

> curl http://192.168.49.2:30000
Hello, Kubernetes!

Creando un deployment para gestionar un conjunto de pods

Para gestionar un conjunto de pods que ejecutan la misma aplicación, podemos usar un deployment, que es un controlador que garantiza que el número deseado de réplicas esté siempre disponible y actualizado. Para crear un deployment, podemos usar el comando kubectl create deployment, especificando el nombre del deployment, la imagen del contenedor y los argumentos opcionales. Por ejemplo, para crear un deployment llamado hello-deployment con tres réplicas de un contenedor que ejecuta una aplicación web simple en Python, podemos usar el siguiente comando:

> kubectl create deployment hello-deployment --image=gcr.io/google-samples/hello-app:1.0 --replicas=3

Para verificar si el deployment se creó con éxito, podemos usar el comando kubectl get deployments, que lista todos los deployments del namespace actual:

> kubectl get deployments
NAME              READY   UP-TO-DATE   AVAILABLE   AGE
hello-deployment  3/3     3            3           10s

Para ver los pods creados por el deployment, podemos usar el comando kubectl get pods, que lista todos los pods del namespace actual:

> kubectl get pods
NAME                               READY   STATUS    RESTARTS   AGE
hello-deployment-8579f694c-7gq8n   1/1     Running   0          10s
hello-deployment-8579f694c-d6z4x   1/1     Running   0          10s
hello-deployment-8579f694c-zl8xw   1/1     Running   0          10s

Para exponer el deployment para acceso externo, podemos usar el mismo comando kubectl expose, especificando el nombre del deployment, el tipo de servicio y el puerto. Por ejemplo, para crear un servicio llamado hello-service de tipo LoadBalancer, que expone el puerto 8080 del deployment hello-deployment en el puerto 80 del balanceador de carga, podemos usar el siguiente comando:

> kubectl expose deployment hello-deployment --name=hello-service --type=LoadBalancer --port=80 --target-port=8080

Para verificar si el servicio se creó con éxito, podemos usar el comando kubectl get services, que lista todos los servicios del namespace actual:

> kubectl get services
NAME           TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
hello-service  LoadBalancer   10.109.14.231   <pending>     80:32369/TCP   10s
kubernetes     ClusterIP      10.96.0.1       <none>        443/TCP        10m23s

Para acceder al servicio, podemos usar el comando minikube service, que abre una ventana del navegador con la dirección IP del servicio. Por ejemplo, para acceder al servicio hello-service, podemos usar el siguiente comando:

> minikube service hello-service

El navegador debería mostrar una página con el mensaje "Hello, world!" y el nombre del pod que atendió la solicitud.

Actualizando un deployment a una nueva versión de la aplicación

Para actualizar un deployment a una nueva versión de la aplicación, podemos usar el comando kubectl set image, especificando el nombre del deployment, el nombre del contenedor y la nueva imagen del contenedor. Por ejemplo, para actualizar el deployment hello-deployment a la versión 2.0 de la aplicación web en Python, podemos usar el siguiente comando:

> kubectl set image deployment hello-deployment hello-app=gcr.io/google-samples/hello-app:2.0

Para verificar si el deployment se actualizó con éxito, podemos usar el comando kubectl rollout status, que muestra el progreso de la actualización:

> kubectl rollout status deployment hello-deployment
Waiting for deployment "hello-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "hello-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "hello-deployment" rollout to finish: 1 old replicas are pending termination...
Waiting for deployment "hello-deployment" rollout to finish: 2 old replicas are pending termination...
Waiting for deployment "hello-deployment" rollout to finish: 3 of 3 updated replicas are available...
deployment "hello-deployment" successfully rolled out

Para ver la nueva versión de la aplicación, podemos acceder nuevamente al servicio hello-service con el comando minikube service:

> minikube service hello-service

El navegador debe mostrar una página con el mensaje “Hello, Kubernetes!” y el nombre del pod que atendió la solicitud.

Manifestos

Un manifiesto de Kubernetes es un archivo YAML o JSON que define uno o más recursos de Kubernetes, como pods, servicios, deployments, configmaps, secrets, etc. Un manifiesto de Kubernetes especifica el estado deseado del recurso, como el número de réplicas, la imagen del contenedor, los parámetros de configuración, etc. Kubernetes usa el manifiesto para crear y gestionar el recurso en el clúster.

Aquí algunos ejemplos de manifestos de Kubernetes:

  • Un manifiesto que crea un pod con un contenedor que ejecuta el comando echo "Hello, world!":

apiVersion: v1
kind: Pod
metadata:
  name: hello-pod
spec:
  containers:
  - name: hello-container
    image: busybox
    command: ["echo", "Hello, world!"]

  • Un manifiesto que crea un servicio de tipo NodePort que expone el puerto 80 del pod hello-pod en el puerto 30000 del nodo:

apiVersion: v1
kind: Service
metadata:
  name: hello-service
spec:
  type: NodePort
  selector:
    app: hello-pod
  ports:
  - protocol: TCP
    port: 80
    nodePort: 30000

  • Un manifiesto que crea un deployment que gestiona tres réplicas de un pod que ejecuta una aplicación web en Python:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-pod
  template:
    metadata:
      labels:
        app: web-pod
    spec:
      containers:
      - name: web-container
        image: gcr.io/google-samples/hello-app:1.0
        ports:
        - containerPort: 8080

Puedes encontrar más ejemplos de manifestos de Kubernetes en la documentación oficial (https://www.digitalocean.com/community/cheatsheets/getting-started-with-kubernetes-a-kubectl-cheat-sheet-pt) o en sitios de referencia (https://learn.microsoft.com/pt-br/azure/devops/pipelines/tasks/reference/kubernetes-manifest-v0?view=azure-pipelines).

Conclusión

En este artículo, vimos cómo usar Kubernetes para orquestar contenedores en un entorno DevOps. Aprendimos qué son los contenedores y por qué son útiles para el desarrollo de software, cómo funciona Kubernetes y cómo puede facilitar la integración y entrega continuas (CI/CD) en un entorno DevOps. También vimos algunos ejemplos de cómo crear y gestionar pods, servicios y deployments con Kubernetes, utilizando minikube y kubectl.

Kubernetes es una herramienta poderosa y flexible que permite automatizar la implementación, escalado y gestión de aplicaciones en contenedores en cualquier entorno. Se integra con diversas herramientas de DevOps, como Jenkins, GitLab CI/CD, Helm, Terraform, Prometheus y Grafana. Con Kubernetes, es posible crear aplicaciones más portátiles, estandarizadas, modulares y escalables.

Referencias Bibliográficas:

  • Kubernetes Documentation - https://kubernetes.io/docs/home/
  • What is Kubernetes? - https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/
  • What is a Container? - https://www.docker.com/resources/what-container
  • Kubernetes Concepts - https://kubernetes.io/docs/concepts/
  • Kubernetes Tutorials - https://kubernetes.io/docs/tutorials/
  • Minikube - https://minikube.sigs.k8s.io/docs/start/
  • Kubectl Cheat Sheet - https://kubernetes.io/docs/reference/kubectl/cheatsheet/

💡
Las opiniones y comentarios emitidos en este artículo son propiedad única de su autor y no necesariamente representan el punto de vista de Listopro.

Listopro Community da la bienvenida a todas las razas, etnias, nacionalidades, credos, géneros, orientaciones, puntos de vista e ideologías, siempre y cuando promuevan la diversidad, la equidad, la inclusión y el crecimiento profesional de los profesionales en tecnología.