Kubernetes Tutorial: Guía para principiantes sobre el despliegue de aplicaciones

Conceptos básicos de Kubernetes: Pods, despliegues, servicios y espacios de nombres

Así que, ahora que hemos configurado un clúster y comprobado que todo funciona, es hora de crear nuestra primera aplicación.

Pero antes de crear la primera aplicación, es esencial comprender los fundamentos de Kubernetes. Si quieres una introducción más profunda a Kubernetes, te recomiendo que consultes el curso Introducción a Kubernetes.

Los conceptos más básicos de Kubernetes son Pods, Despliegues y Servicios. Conocer estos tres tipos de recursos puede ayudarte a crear aplicaciones potentes. Por tanto, vamos a profundizar en ellas.

¿Qué son los Pods?

Un Pod es la unidad desplegable más pequeña de Kubernetes. Ejecuta uno o más contenedores estrechamente acoplados con el mismo almacenamiento, red y espacio de nombres. Un Pod siempre se programa en un nodo de Kubernetes. 

Puedes definir cuántos recursos debe obtener tu Pod (por ejemplo, CPU y memoria). 

Un ejemplo de aplicación con dos contenedores podría ser el contenedor de tu aplicación y un contenedor ayudante que agregue los registros y los envíe a algún sitio. 

Características de una cápsula:

• Instancia única: Cada Pod ejecuta una única instancia de tu aplicación.
• Efímero por naturaleza: Los módulos están diseñados para ser temporales y se sustituyen si fallan o se actualizan.

Ejemplo de YAML para crear un Pod:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: nginx-container
    image: nginx:1.21
    ports:
    - containerPort: 80

A continuación, puedes instalar el Pod utilizando kubectl:

kubectl apply -f pod.yaml

Esto iniciaría un Pod llamado my-pod, que ejecutaría un servidor web nginx por ti.

¿Qué son las implantaciones?

Un Despliegue es un objeto Kubernetes de nivel superior que se utiliza para gestionar el ciclo de vida de los Pods. Garantiza que se ejecuta el número deseado de réplicas Pod y gestiona las actualizaciones y retrocesos. 

Características de un despliegue:

• Gestión de réplicas: Garantiza que el número deseado de vainas esté siempre en funcionamiento.
• Autocuración: Sustituye automáticamente los Pods insanos.
• Actualizaciones continuas: Actualiza la versión de la aplicación paso a paso sin tiempo de inactividad (si está configurado).

Veamos cómo sería un archivo YAML de despliegue que crea de nuevo un servidor web nginx, pero esta vez con tres réplicas:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80

Puedes instalar ese Despliegue con kubectl:

kubectl apply -f deployment.yaml

Lo anterior crearía un Despliegue llamado nginx-deployment que crearía tres Pods, cada uno ejecutando el contenedor nginx. 

¿Qué son los Servicios?

Ahora vamos a la última parte: Los servicios. 

Un Servicio es una abstracción que proporciona un acceso de red estable a los Pods, aunque cambien sus direcciones IP. Actúa como puente entre tus aplicaciones y los clientes externos. 

Pero, ¿por qué es necesario? Cada Pod tiene su dirección IP. Entonces, ¿por qué no podemos utilizar directamente esa dirección IP? 

¡Podemos hacerlo! Pero no deberíamos. ¿Por qué? 

Como un Pod es efímero, el Despliegue lo mata, y se escala un nuevo Pod siempre que tu Pod no esté sano. Este nuevo Pod tiene entonces una dirección IP diferente. Esto significaría que el cliente que quiera utilizar tu aplicación tendría que alterar permanentemente la dirección IP cada vez que un Pod se bloquee, lo que puede ocurrir a menudo.

Aquí es donde entra en juego un Servicio: busca todos los Pods que coincidan con una etiqueta determinada y dirige automáticamente el tráfico hacia ellos. Si un Pod deja de estar sano, el Servicio deja de enviar tráfico a ese Pod. Y si aparece un nuevo Pod, empezará a enviar tráfico al nuevo Pod. 

El Servicio también distribuye el tráfico entre todas las réplicas de tu Implementación, lo que es fantástico, ya que significa que puedes crear más instancias de tu aplicación para distribuir el tráfico sin tener que gestionarlo a través de la lógica de tu aplicación.

Tipos de servicios:

• ClusterIP (por defecto): Expone el Servicio dentro del clúster.
• PuertoNodo: Expone el Servicio en un puerto accesible fuera del clúster.
• LoadBalancer: Se integra con los proveedores de la nube para exponer el Servicio a través de un equilibrador de carga.

Ejemplo de YAML para exponer nuestro servidor web nginx al exterior del clúster:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort

Puedes volver a crear ese servicio utilizando kubectl:

kubectl apply -f service.yaml

Este Servicio distribuiría ahora el tráfico entrante a todos los Pods con la etiqueta app=nginx en el Puerto 80. 

Si ejecutas un comando describe en tu Servicio recién creado, deberías ver que ahora hay tres puntos finales, donde cada punto final representa la dirección IP del Pod que se está ejecutando en ese momento:

kubectl describe service nginx-service

El comando anterior debería devolver algo similar a 

Name:                     nginx-service
Namespace:                default
Labels:                   <none>
Annotations:              <none>
Selector:                 app=nginx
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.104.53.131
IPs:                      10.104.53.131
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  32256/TCP
Endpoints:                10.244.0.5:80,10.244.0.6:80,10.244.0.7:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

Relaciones entre Pods, Despliegues y Servicios

Así que, para resumir rápidamente:

• Vainas: Representan instancias de aplicación individuales.
• Despliegues: Gestiona el ciclo de vida de los Pods y asegúrate de que están sanos.
• Servicios: Proporciona un acceso estable a los Pods y permite la comunicación externa o interna.

¿Qué son los espacios de nombres?

Los espacios de nombres en Kubernetes te permiten organizar y aislar recursos dentro de un clúster. Puedes pensar en ellos como clusters virtuales dentro del mismo cluster físico. 

Ventajas de utilizar espacios de nombres:

• Separación de preocupaciones: Los distintos equipos o aplicaciones pueden operar dentro de su propio espacio de nombres sin afectar a los demás. 
• Gestión de recursos: Puedes establecer cuotas y límites de recursos para diferentes espacios de nombres.
• Seguridad y control de acceso: Las políticas pueden aplicarse a nivel de espacio de nombres.

Por defecto, Kubernetes viene con unos cuantos espacios de nombres incorporados:

• por defecto: Los espacios de nombres por defecto donde se crean los recursos, a menos que se especifique lo contrario
• sistema-kube: Se utiliza para componentes internos de Kubernetes (por ejemplo, servidor API, programador, etc.).
• kube-public: Un espacio de nombres de lectura pública.
• kube-node-lease: Se utiliza para seguir los latidos de los nodos.

Puedes crear un espacio de nombres utilizando un archivo YAML: 

apiVersion: v1
kind: Namespace
metadata:
  name: my-namespace

Guárdalo en un archivo llamado namespace.yaml y aplícalo utilizando: 

kubectl apply -f namespace.yaml

Al ejecutar el comando siguiente, deberías ver una lista de todos los espacios de nombres predeterminados listados y del recién creado: 

kubectl get namespaces

A continuación, puedes crear recursos en ese espacio de nombres simplemente estableciendo el espacio de nombres en la sección de metadatos de tu recurso. 

Nuestro Despliegue nginx tendría el siguiente aspecto si queremos crearlo en tu espacio de nombres recién creado:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: my-namespace
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80

Ahora, tienes que indicar explícitamente que quieres recuperar recursos de tu espacio de nombres recién creado utilizando elargumento -n :

kubectl get deployment -n my-namespace

Gestionar tu primera aplicación con Kubernetes

Bien, ahora que ya conoces los conceptos básicos de Kubernetes, es hora de desplegar nuestra primera aplicación web en Kubernetes e intentar acceder a ella. 

En este capítulo, crearemos un servidor web nginx, expondremos ese servidor web mediante un Servicio al mundo exterior, escalaremos esa aplicación para simular un comportamiento de alto tráfico y actualizaremos la aplicación mediante una actualización continua a una versión más reciente.

Así que, ¡empecemos a hacer cosas divertidas!

Crear un despliegue de aplicación web sencillo

El primer paso es crear un Despliegue para nuestro servidor web que cree un contenedor utilizando la imagen Nginx.

Copia el código siguiente y guárdalo en un archivo llamado nginx-deployment.yaml.

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

A continuación, aplica esa Implementación a tu clúster utilizando el siguiente comando:

kubectl apply -f nginx-deployment.yaml

A continuación, puedes comprobar que el Pod está funcionando: 

kubectl get pods

Exponer la aplicación con un servicio

Debemos exponer el servidor web nginx mediante un Servicio al mundo exterior. Para ello, vamos a crear un Servicio de tipo NodePort, ya que queremos acceder al servidor web nginx desde nuestra máquina local fuera del clúster Kubernetes.

Así que crea un archivo llamado nginx-service.yaml y añade el siguiente contenido:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort

A continuación, puedes aplicar el Servicio con el comando siguiente:

kubectl apply -f nginx-service.yaml

Por último, puedes utilizar minikube para obtener la URL de tu servidor web nginx:

minikube service nginx-service --url

Abre esa URL en tu navegador, y deberías ver la página de bienvenida de tu servidor web nginx.

Captura de pantalla de la página de bienvenida de un servidor web nginx en un navegador local.

Escalar la aplicación

Por lo tanto, tenemos un Pod en funcionamiento. Pero puede haber una carga masiva de usuarios visitando nuestra página web. Por eso, en Kubernetes, puedes escalar rápidamente tu aplicación para tener más Pods en funcionamiento. 

El Servicio detectará automáticamente todos los Pods pertenecientes a ese Despliegue y, a continuación, equilibrará la carga de las peticiones entrantes en todos los Pods que ejecuten el servidor web nginx. Esto ayuda a mejorar el rendimiento general de nuestra página web en caso de que entre mucho tráfico.

Por lo tanto, vamos a escalar nuestra aplicación a 3 réplicas utilizando el siguiente comando:

kubectl scale deployment nginx-deployment --replicas=3

Ahora puedes conseguir de nuevo todos los Pods en funcionamiento, que deberían ser tres:

kubectl get pods

También puedes utilizar el siguiente comando para obtener todos los puntos finales a los que está conectado nuestro nginx-service. Esto debería devolver tres puntos finales, siendo cada punto final su propia dirección IP interna del clúster:

kubectl get endpoints nginx-service

Actualizaciones continuas

Ahora, tenemos otra ventaja importante de utilizar Kubernetes: Actualizaciones continuas.

Una actualización continua tiene como objetivo evitar cualquier tiempo de inactividad de tu aplicación web. Imagínate las pérdidas económicas que sufrirían empresas como Amazon si su página web no funcionara cada vez que Amazon lanzara una nueva versión.

Mediante una actualización continua, Kubernetes escala un Pod nuevo, comprueba si está en buen estado y luego reduce el antiguo. 

Por defecto, Kubernetes garantiza que al menos el 75% del número deseado de Pods esté en funcionamiento, con un 25% como número máximo no disponible. Esto significa que, en nuestro caso, en el que tenemos tres réplicas en funcionamiento, Kubernetes sólo añadirá un nuevo Pod cada vez, comprobará si está en buen estado y, en caso afirmativo, reducirá otro Pod. Repetirá el proceso hasta que todos los Pods estén actualizados a la nueva versión.

Así que vamos a hacerlo ahora cambiando la versión de nuestra imagen nginx de latest a 1.23:

kubectl set image deployment/nginx-deployment nginx=nginx:1.23

A continuación, puedes controlar el estado del despliegue utilizando: 

kubectl rollout status deployment/nginx-deployment

El resultado debería ser similar a 

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

Y mientras dure el despliegue, ¡tu página web estará accesible todo el tiempo sin ningún tiempo de inactividad!

¿No es estupendo?

Gestionar los recursos de Kubernetes

Kubernetes proporciona potentes herramientas para inspeccionar, modificar y eliminar recursos de todo tipo. Comprender cómo gestionar los recursos de forma eficaz garantiza una mejor resolución de problemas, asignación de recursos y mantenimiento general del clúster. 

En esta sección, nos sumergiremos en otros comandos esenciales que te ayudarán a gestionar tus recursos con eficacia y a solucionar problemas en caso de incidencias.

Ver los recursos del clúster

Antes de cambiar cualquier recurso, es esencial ver e inspeccionar los recursos que se están ejecutando actualmente en tu clúster.

Puedes, por ejemplo, listar todos los Pods, Servicios e Implementaciones en ejecución para ver qué está pasando en tu clúster: 

# list running Pods
kubectl get pods

# list running Services 
kubectl get services

# list running Deployments
kubectl get deployments

Si quieres profundizar en un recurso concreto, puedes utilizar elcomando describe :

kubectl describe deployment nginx-deployment

Esto mostrará más información, incluyendo actualizaciones continuas, escalado o eventos de extracción de imágenes. Este es el primer punto al que puedes dirigirte si algo va mal.

También puedes comprobar los logs de un Pod en ejecución para ver qué está pasando dentro de ese Pod utilizando el siguiente comando:

kubectl logs <pod-name>

Borrar recursos

También es esencial limpiar los recursos en caso de que ya no se utilicen para liberar recursos del clúster para nuevas aplicaciones. 

Puedes eliminar un Pod utilizando:

kubectl delete pod <pod-name>

Podemos hacer esto para uno de nuestros pods nginx. Sin embargo, un nuevo Pod debe escalarse al instante, ya que se gestionan mediante un Despliegue, que siempre intenta tener tres réplicas en funcionamiento. 

Así que aquí tendríamos que borrar el nginx-deployment: 

kubectl delete deployment nginx-deployment

Después de ejecutar este comando, todos los Pods nginx en ejecución deberían eliminarse. 

También podemos eliminar todos los recursos de un Espacio de Nombres. El siguiente comando eliminaría todos nuestros recursos, que se crearon en el espacio de nombres default , por defecto:

kubectl delete all --all

Conclusión

¡Enhorabuena! Has llegado al final y has dado con éxito tus primeros pasos en Kubernetes. 

Siguiendo este tutorial, habrás aprendido a:

• Configura un clúster local de Kubernetes utilizando minikube.
• Trabaja con Pods, Despliegues, Servicios y Namespaces (los bloques de construcción esenciales de Kubernetes).
• Despliega y gestiona una aplicación web sencilla dentro de Kubernetes.
• Escala las aplicaciones dinámicamente y realiza actualizaciones continuas sin tiempo de inactividad.
• Gestiona los recursos de Kubernetes enumerándolos, describiéndolos y eliminándolos.

Al principio, Kubernetes puede parecer complejo (al menos a mí me lo pareció). Pero desglosarlo en conceptos fundamentales lo hace más accesible. 

Sigue experimentando y despliega más aplicaciones. 

La mejor forma de aprender Kubernetes es haciendo, así que ¡empieza a construir!

Para mejorar aún más tus conocimientos sobre Kubernetes, considera la posibilidad de explorar:

• Trabajar con ConfigMaps y Secretos: Almacena y gestiona los ajustes de configuración de forma segura.
• Volúmenes persistentes: Aprende a almacenar datos que sobrevivan a los reinicios de Pod utilizando volúmenes persistentes.
• Red y controladores de entrada: Configura el enrutamiento basado en dominios y gestiona el tráfico externo.
• Timón: Utiliza los gráficos de Helm para empaquetar y desplegar aplicaciones complejas con eficacia.
• Kubernetes en la nube: Experimenta con servicios gestionados de Kubernetes como AWS EKS, Azure AKS o Google GKE.

Por último, el tema Containerization and Virtualization with Docker and Kubernetes en DataCamp es un recurso excelente para practicar tanto con Docker como con Kubernetes.