Implementa una aplicación web en contenedor

En este instructivo, se muestra cómo empaquetar una aplicación web en una imagen de contenedor de Docker y ejecutar esa imagen en un clúster de Google Kubernetes Engine (GKE) como un conjunto de réplicas con balanceo de cargas que puede escalar según las necesidades de tus usuarios.

Objetivos

Para empaquetar e implementar tu aplicación en GKE, debes seguir los siguientes pasos:

  1. Empaqueta la app en una imagen de Docker.
  2. Sube la imagen a un registro.
  3. Ejecuta el contenedor de manera local en tu máquina (opcional).
  4. Crea un clúster de contenedor.
  5. Implementa tu aplicación en el clúster.
  6. Expón la app en Internet.
  7. Escala verticalmente tu implementación.
  8. Implementa una nueva versión de la app.

Antes de comenzar

Sigue los pasos que se indican a continuación para habilitar la API de Kubernetes Engine:
  1. Consulta la página de Kubernetes Engine en Google Cloud Console.
  2. Crea o selecciona un proyecto.
  3. Espera a que la API y los servicios relacionados se habiliten. Esto puede tomar varios minutos.
  4. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

Opción A: Usa Cloud Shell

Puedes seguir este instructivo mediante Cloud Shell, que viene preinstalado con las herramientas de línea de comandos de gcloud, docker y kubectl que se usan en este instructivo. Si usas Cloud Shell, no necesitas instalar estas herramientas de línea de comandos en tu estación de trabajo.

Para usar Cloud Shell, sigue estos pasos:

  1. Dirígete a Google Cloud Console.
  2. Haz clic en el botón Activar Cloud Shell Botón de activar Shell que se encuentra en la parte superior de la ventana de Console.

    Se abrirá una sesión de Cloud Shell en un marco nuevo en la parte inferior de la consola, que mostrará una ventana emergente con una línea de comandos.

    Sesión de Cloud Shell

Opción B: Usa las herramientas de línea de comandos de manera local

Si prefieres seguir este instructivo en tu estación de trabajo, necesitas instalar las siguientes herramientas:

  1. Instala el SDK de Google Cloud, que incluye la herramienta de línea de comandos de gcloud.
  2. Con la herramienta de línea de comandos de gcloud, instala la herramienta de línea de comandos deKubernetes. kubectl se usa para comunicarse con Kubernetes, que es el sistema de organización de clústeres de los clústeres de GKE:

    gcloud components install kubectl
  3. Instala la edición de la comunidad de Docker (CE) en tu estación de trabajo. Usarás esto a fin de compilar una imagen de contenedor para la aplicación.

  4. Instala la herramienta de control de fuente Git para obtener la aplicación de muestra de GitHub.

Paso 1: Compila la imagen del contenedor

GKE acepta imágenes de Docker como el formato de implementación de la aplicación. Para crear una imagen de Docker, necesitas tener una aplicación y un Dockerfile.

En este instructivo, implementarás una aplicación web de muestra llamada hello-app, un servidor web escrito en Go que responde a todas las solicitudes con el mensaje “¡Hello, World!” en el puerto 80.

La aplicación está empaquetada como una imagen de Docker mediante el uso de Dockerfile que contiene instrucciones para compilar la imagen. Usarás este Dockerfile para empaquetar tu aplicación.

  1. Descarga el código fuente hello-app. Para ello, ejecuta los siguientes comandos:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
    cd kubernetes-engine-samples/hello-app
    
  2. Establece la variable de entorno PROJECT_ID en el ID de tu proyecto de Google Cloud (project-id). Se usará la variable PROJECT_ID a fin de asociar la imagen de contenedor con el Container Registry de tu proyecto.

    export PROJECT_ID=project-id
    
  3. Compila la imagen de contenedor de esta aplicación y etiquétala para subirla:

    docker build -t gcr.io/${PROJECT_ID}/hello-app:v1 .
    

    Con este comando, se le indica a Docker que compile la imagen mediante el Dockerfile en el directorio actual y que la etiquete con un nombre, como gcr.io/my-project/hello-app:v1. El prefijo gcr.io se refiere a Container Registry, donde se alojará la imagen. Ejecutar este comando no subirá la imagen todavía.

  4. Ejecuta el comando docker images a fin de verificar que la compilación se realizó de forma correcta:

    docker images
    
    Resultado:
    REPOSITORY                     TAG                 IMAGE ID            CREATED             SIZE
    gcr.io/my-project/hello-app    v1                  25cfadb1bf28        10 seconds ago      54 MB
    

Paso 2: Sube la imagen del contenedor

Debes subir la imagen del contenedor en un registro para que GKE pueda descargarla y ejecutarla.

  1. Configura la herramienta de línea de comandos de Docker para autenticar en Container Registry (debes ejecutar este comando solo una vez):

    gcloud auth configure-docker
    
  2. Ahora puedes usar la herramienta de línea de comandos de Docker para subir la imagen en tu Container Registry:

    docker push gcr.io/${PROJECT_ID}/hello-app:v1
    

Paso 3: Ejecuta tu contenedor de manera local (opcional)

  1. Prueba tu imagen de contenedor mediante el motor de Docker local:

    docker run --rm -p 8080:8080 gcr.io/${PROJECT_ID}/hello-app:v1
    
  2. Si usas Cloud Shell, haz clic en el botón Vista previa en la Web Botón Vista previa en la Web y selecciona el número de puerto 8080. GKE abre la URL de vista previa en su servicio de proxy en una nueva ventana del navegador.

  3. De lo contrario, abre una nueva ventana de la terminal (o una pestaña de Cloud Shell) y ejecuta para verificar si el contenedor funciona y responde a las solicitudes con “Hello, Word!”:

    curl http://localhost:8080

    Cuando obtengas una respuesta exitosa, puedes cerrar el contenedor mediante Ctrl+C en la pestaña donde se ejecuta el comando docker run.

Paso 4: Crea un clúster de contenedor

Ahora que la imagen de contenedor está almacenada en un registro, debes crear un clúster para ejecutar la imagen de contenedor. Un clúster consiste en un grupo de instancias de VM de Compute Engine que ejecutan Kubernetes, el sistema de organización de clústeres de código abierto que se usa en GKE.

Una vez que creaste un clúster de GKE, usa Kubernetes para implementar aplicaciones en el clúster y administrar el ciclo de vida de las aplicaciones.

  1. Configura las opciones del ID del proyecto y de la zona de Compute Engine para la herramienta de gcloud:

    gcloud config set project $PROJECT_ID
    gcloud config set compute/zone compute-zone
  2. Crea un clúster de dos nodos llamado hello-cluster:

    gcloud container clusters create hello-cluster --num-nodes=2
    

    La creación del clúster puede tomar varios minutos.

  3. Cuando se complete el comando, ejecuta el siguiente comando para ver las dos instancias de VM de trabajador del clúster:

    gcloud compute instances list
    
    Resultado:
    NAME                                          ZONE           MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP     STATUS
    gke-hello-cluster-default-pool-07a63240-822n  us-central1-b  n1-standard-1               10.128.0.7   35.192.16.148   RUNNING
    gke-hello-cluster-default-pool-07a63240-kbtq  us-central1-b  n1-standard-1               10.128.0.4   35.193.136.140  RUNNING
    

Paso 5: Implementa tu aplicación

Para implementar y administrar aplicaciones en un clúster de GKE, debes comunicarte con el sistema de administración de clústeres de Kubernetes. Por lo general, puedes usar la herramienta de línea de comandos de kubectl.

Kubernetes representa aplicaciones como Pods, que son unidades que representan un contenedor (o grupo de contenedores estrechamente vinculados). El pod es la unidad más pequeña que se puede implementar en Kubernetes. En este instructivo, cada pod contiene solo tu contenedor hello-app.

Con el siguiente comando kubectl create deployment, se puede hacer que Kubernetes cree una implementación llamada hello-web en tu clúster. La implementación administra varias copias de tu aplicación llamadas réplicas y las programa para que se ejecuten en los nodos individuales de tu clúster. En este caso, la implementación ejecutará solo un pod de tu aplicación.

  1. Ejecuta el siguiente comando para implementar tu aplicación:

    kubectl create deployment hello-web --image=gcr.io/${PROJECT_ID}/hello-app:v1
    
  2. Para ver el pod creado por la implementación, ejecuta el siguiente comando:

    kubectl get pods
    
    Resultado:
    NAME                         READY     STATUS    RESTARTS   AGE
    hello-web-4017757401-px7tx   1/1       Running   0          3s
    

Paso 6: Expón la aplicación en Internet

Según la configuración predeterminada, los contenedores que ejecutas en GKE no son accesibles desde Internet, ya que no tienen direcciones IP externas. Debes exponer de forma explícita tu aplicación al tráfico de Internet.

Ejecuta el siguiente comando para exponer tu aplicación al tráfico de Internet:

kubectl expose deployment hello-web --type=LoadBalancer --port 80 --target-port 8080

Este comando crea un recurso Service, que proporciona herramientas de redes y compatibilidad con IP a los pods de tu aplicación. GKE crea una IP externa y un balanceador de cargas (sujeto a facturación) para tu aplicación.

La marca --port especifica el número de puerto configurado en el balanceador de cargas, y la marca --target-port especifica el número de puerto en el que escucha el contenedor hello-app.

Cuando hayas determinado la dirección IP externa para tu aplicación, toma nota de ella. Dirige tu navegador a esta URL (como http://203.0.113.0) para verificar si la aplicación es accesible.

Paso 7: Escala verticalmente tu aplicación

Para agregar más réplicas al recurso de implementación Deployment de la aplicación, usa el comando kubectl scale.

  1. Agrega dos réplicas adicionales a tu Deployment (para obtener un total de tres):

    kubectl scale deployment hello-web --replicas=3
    
  2. Visualiza las réplicas nuevas que se ejecutan en tu clúster:

    kubectl get deployment hello-web
    
    Resultado:
    NAME        DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
    hello-web   3         3         3            2           1m
  3. Visualiza los pods para tu implementación:

    kubectl get pods
    
    Resultado:
    NAME                         READY     STATUS    RESTARTS   AGE
    hello-web-4017757401-ntgdb   1/1       Running   0          9s
    hello-web-4017757401-pc4j9   1/1       Running   0          9s
    hello-web-4017757401-px7tx   1/1       Running   0          1m

Ahora, tienes varias instancias de tu aplicación en ejecución independientes una de otra y puedes usar el comando kubectl scale para ajustar la capacidad de tu aplicación.

El balanceador de cargas aprovisionado en el paso anterior comenzará a enrutar el tráfico automáticamente a estas nuevas réplicas.

Paso 8: Implementa una nueva versión de tu aplicación

El mecanismo de actualización progresiva de GKE garantiza que tu aplicación se mantenga activa y disponible incluso cuando el sistema reemplace las instancias de tu imagen de contenedor anterior por la nueva en todas las réplicas en ejecución.

  1. Puedes crear una imagen para la versión v2 de la aplicación si compilas el mismo código fuente y lo etiquetas como v2 (o puedes cambiar la string "Hello, World!" a "Hello, GKE!" antes de compilar la imagen):

    docker build -t gcr.io/${PROJECT_ID}/hello-app:v2 .
    
  2. Envía la imagen a Container Registry:

    docker push gcr.io/${PROJECT_ID}/hello-app:v2
    
  3. Aplica una actualización progresiva a la implementación existente con una actualización de imagen:

    kubectl set image deployment/hello-web hello-app=gcr.io/${PROJECT_ID}/hello-app:v2
    
  4. Visita tu aplicación otra vez en http://external-ip y observa que los cambios que aplicaste.

Realiza una limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo:

Después de completar este instructivo, sigue estos pasos para quitar los siguientes recursos y evitar que se apliquen cargos no deseados en tu cuenta:

  1. Borra el Service: De este modo, se desasigna el balanceador de cargas de Cloud creado para él:

    kubectl delete service hello-web
  2. Borra el clúster: De este modo, se borran los recursos que conforman el clúster, como las instancias de procesamiento, los discos y los recursos de red:

    gcloud container clusters delete hello-cluster

Próximos pasos