Taller Kubernetes: Trabajando con Deployments

    2023, Feb 04

    Introducción

    En este taller vamos a trabajar con Deployments, que es un objeto de Kubernetes que nos permite crear un conjunto de Pods idénticos. En este caso, vamos a crear un Deployment que va a controlar un conjunto de Pods.

    Ejercicio 1: Trabajando con Deployments

    • Crearemos un fichero yaml con la descripción del recurso Deployment, teniendo en cuenta los siguientes aspectos:

      • Indicaremos nombres distintos para el Deployment y para el contenedor de los Pods que va a controlar.
      • El Deployment va a crear 2 réplicas.
      • La imagen que debemos desplegar es iesgn/test_web:latest.
      • Indicaremos de manera adecuada una etiqueta en la especificación del Pod que vas a definir que coincida con el selector del Deployment.
        apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: test-web-deployment
      labels:
        app: web
    spec:
      revisionHistoryLimit: 5
      strategy:
        type: RollingUpdate
      replicas: 2
      selector:
        matchLabels:
          app: web
      template:
        metadata:
          labels:
            app: web
        spec:
          containers:
          - image: iesgn/test_web:latest
            name: container-testweb
            ports:
            - name: http
              containerPort: 80

    0

    • Creamos el deployment:
        kubectl apply -f test-web-deployment.yaml
    • Comprobamos los recursos que se han creado, en nuestro caso, Deployment, ReplicaSet y Pods.
        kubectl get all

    1

    • Obtenemos la información detallada del Deployment:
        kubectl describe deployments.apps/test-web-deployment

    2

    • Crearemos un una redirección utilizando el port-forward para acceder a la aplicación, sabiendo que la aplicación ofrece el servicio en el puerto 80, y accede a la aplicación con un navegador web.
        kubectl port-forward deployments.apps/test-web-deployment 8080:80

    3

    4

    • Accederemos a los logs del despliegue para comprobar el acceso que has hecho en el punto anterior.
        kubectl logs deployments.apps/test-web-deployment

    5

    • Elimina el Deployment y comprueba que se han borrado todos los recursos creados.
        kubectl delete deployments.apps/test-web-deployment

    6

    Ejercicio 2: Actualización y desactualización de nuestra aplicación.

    Primera verisón

    El equipo de desarrollo ha creado una primera versión preliminar de una aplicación web y ha creado una imagen de contenedor con el siguiente nombre: iesgn/test_web:version1.

    Vamos a desplegar esta primera versión de la aplicación. Recuerda que primero debemos descargarnos la imagen del contenedor con un docker pull iesgn/test_web:version1.

    • Creamos un fichero yaml para desplegar la imagen: iesgn/test_web:version1.
        apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: test-web-deployment
      labels:
        app: web
    spec:
      revisionHistoryLimit: 5
      strategy:
        type: RollingUpdate
      replicas: 3
      selector:
        matchLabels:
          app: web
      template:
        metadata:
          labels:
            app: web
        spec:
          containers:
          - image: iesgn/test_web:version1
            name: contendor-testweb
            ports:
            - name: http
              containerPort: 80

    7

    • Creamos el deployment:
        kubectl apply -f test-web-deployment2.yaml

    NOTA: Anotaremos el despliegue para tener un registro de los cambios que se han ido realizando.

        kubectl annotate deployment/test-web-deployment kubernetes.io/change-cause="Deployment version 1"

    8

    • Creamos una redirección utilizando el port-forward para acceder a la aplicación, sabiendo que la aplicación ofrece el servicio en el puerto 80, y accedemos a la aplicación con un navegador web.
        kubectl port-forward deployment.apps/test-web-deployment 8080:80

    9

    Segunda versión

    Nuestro equipo de desarrollo ha seguido trabajando y ya tiene lista la versión 2 de nuestra aplicación, han creado una imagen que se llama: iesgn/test_web:version2. Recuerda que primero debemos descargarnos la imagen del contenedor con un docker pull iesgn/test_web:version2.Vamos a actualizar nuestro despliegue con la nueva versión, para ello:

    • Realiza la actualización del despliegue utilizando la nueva imagen y anotamos el registro de cambios.

    • Cambiamos el fichero yaml y cambiamos lo siguiente:

        ...
    containers:
        - image: iesgn/test_web:version2
    ...
    • Anotamos la versión 2 de la aplicación.
        kubectl annotate deployment/test-web-deployment2 kubernetes.io/change-cause="Deployment version 2"
    • Actualizamos el deployment:
        kubectl apply -f test-web-deployment2.yaml
    • Comprobamos que se han creado los recursos.
      kubectl get all

    10

    • Visualizamos el historial de actualizaciones.
      kubectl rollout history deployment/test-web-deployment

    11

    1. Creamos una redirección utilizando el port-forward para acceder a la aplicación, sabiendo que la aplicación ofrece el servicio en el puerto 80, y accedemos a la aplicación con un navegador web.
      kubectl port-forward deployment.apps/test-web-deployment2 8080:80

    12

    Tercera versión

    Finalmente después de un trabajo muy duro, el equipo de desarrollo ha creado la imagen iesgn/test_web:version3. Recuerda que primero debemos descargarnos la imagen del contenedor con un docker pull iesgn/test_web:version3 y la vamos a poner en producción, para ello:

    • Realizamos la actualización del despliegue utilizando la nueva imagen y anotamos el registro de cambios.

      • Cambiamos el fichero yaml y cambiamos lo siguiente:
        ...
    containers:
        - image: iesgn/test_web:version3
    ...
    • Anotamos la versión 3 de la aplicación.
        kubectl annotate deployment/test-web-deployment kubernetes.io/change-cause="Deployment version 3"
    • Actualizamos el deployment:
        kubectl apply -f test-web-deployment2.yaml
    • Comprobamos que se han creado los recursos.
        kubectl get all

    13

    • Visualizamos el historial de actualizaciones.
        kubectl rollout history deployment/test-web-deployment2

    14

    • Creamos una redirección utilizando el port-forward para acceder a la aplicación, sabiendo que la aplicación ofrece el servicio en el puerto 80, y accedemos a la aplicación con un navegador web.
      kubectl port-forward deployment.apps/test-web-deployment 8080:80

    15

    Rollback

    ¡Vaya!, parece que esta versión tiene un fallo, y no se ve de forma adecuada la hoja de estilos, tenemos que volver a la versión anterior:

    • Realizamos el rollback a la versión anterior.
      kubectl rollout undo deployment/test-web-deployment

    16

    • Anotamos el rollback.
      kubectl annotate deployment/test-web-deployment2 kubernetes.io/change-cause="Deployment rollback"

    17

    • Comprobamos que se han creado los recursos.
      kubectl rollout history deployment/test-web-deployment

    18

    • Creamos una redirección utilizando el port-forward para acceder a la aplicación, sabiendo que la aplicación ofrece el servicio en el puerto 80, y accedemos a la aplicación con un navegador web.
      kubectl port-forward deployment.apps/test-web-deployment 8080:80

    19

    Ejercicio 3: Despliegue de la aplicación GuestBook

    En esta tarea vamos a desplegar una aplicación web que requiere de dos servicios para su ejecución. La aplicación se llama GuestBook y necesita los siguientes servicios:

    • La aplicación Guestbook es una aplicación web desarrollada en python que es servida en el puerto 5000/tcp. Utilizaremos la imagen iesgn/guestbook.

    • Esta aplicación guarda la información en una base de datos no relacional redis, que utiliza el puerto 6379/tcp para recibir las conexiones. Usaremos la imagen redis.

    Por lo tanto si tenemos dos servicios distintos, tendremos dos ficheros yaml para crear dos recursos Deployment, uno para cada servicio. Con esta manera de trabajar podemos obtener las siguientes características:

    • Cada conjunto de Pods creado en cada despliegue ejecutarán un solo proceso para ofrecer el servicio.

    • Cada conjunto de Pods se puede escalar de manera independiente. Esto es importante, si identificamos que al acceder a alguno de los servicios se crea un cuello de botella, podemos escalarlo para tener más Pods ejecutando el servicio.

    • Las actualizaciones de los distintos servicios no interfieren en el resto.

    • Lo estudiaremos en un módulo posterior, pero podremos gestionar el almacenamiento de cada servicio de forma independiente.

    Por lo tanto para desplegar la aplicaciones tendremos dos ficheros.yaml:

    • guestbook-deployment.yaml
        apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: guestbook
      labels:
        app: guestbook
        tier: frontend
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: guestbook
          tier: frontend
      template:
        metadata:
          labels:
            app: guestbook
            tier: frontend
        spec:
          containers:
          - name: contenedor-guestbook
            image: iesgn/guestbook
            ports:
              - name: http-server
                containerPort: 5000
    • redis-deployment.yaml
        apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: redis
      labels:
        app: redis
        tier: backend
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: redis
          tier: backend
      template:
        metadata:
          labels:
            app: redis
            tier: backend
        spec:
          containers:
            - name: contenedor-redis
              image: redis
              ports:
                - name: redis-server
                  containerPort: 6379

    Para realizar el despliegue realiza los siguientes pasos:

    • Usando los ficheros anteriores, creamos los dos Deployments.
      kubectl apply -f guestbook-deployment.yaml
  kubectl apply -f redis-deployment.yaml
    • Comprobamos que se han creado los recursos.
      kubectl get all

    20

    • Crea una redirección utilizando el port-forward para acceder a la aplicación, sabiendo que la aplicación ofrece el servicio en el puerto 5000, y accede a la aplicación con un navegador web.
      kubectl port-forward deployment.apps/guestbook 8080:5000

    21

    22

    Para eliminarlo ejecuta:

        kubectl delete -f guestbook-deployment.yaml
    kubectl delete -f redis-deployment.yaml

    ¿Qué aparece en la página principal de la aplicación?.

    Aparece el siguiente mensaje: Waiting for database connection…. Por lo tanto podemos indicar varias conclusiones:

    1. Hasta ahora no estamos accediendo de forma “normal” a las aplicaciones. El uso de la opción port-forward es un mecanismo que realmente nos posibilita acceder a la aplicación, pero utilizando un proxy. Deberíamos acceder a las aplicaciones usando una ip y un puerto determinado.

    2. Parece que tampoco hay acceso entre los Pods de los distintos despliegues. Parece que los Pods de la aplicación guestbook no pueden acceder al Pod donde se está ejecutando la base de datos redis.

    # kubernetes # deployment