Implementa una app web alojada en un contenedor de Docker en GKE

En este instructivo, se muestra cómo implementar una aplicación web en contenedores en un clúster de Google Kubernetes Engine (GKE).

Esta página está dirigida a operadores y desarrolladores que aprovisionan y configuran recursos de la nube, y que implementan apps y servicios. Para obtener más información sobre los roles comunes y las tareas de ejemplo a las que se hace referencia en el contenido de Google Cloud, consulta Roles y tareas comunes de los usuarios de GKE.

Antes de leer esta página, asegúrate de estar familiarizado con Kubernetes.

Crea un repositorio

En este instructivo, almacenarás una imagen en Artifact Registry y la implementarás desde el registro. En esta guía de inicio rápido, crearás un repositorio llamado hello-repo.

1. Establece la variable de entorno PROJECT_ID en tu ID del proyectoGoogle Cloud (PROJECT_ID). Usarás esta variable de entorno cuando compiles la imagen de contenedor y la envíes a tu repositorio.

   export PROJECT_ID=PROJECT_ID
   

2. Confirma que la variable de entorno PROJECT_ID tenga el valor correcto:

   echo $PROJECT_ID
   

3. Configura el ID del proyecto para Google Cloud CLI:

   gcloud config set project $PROJECT_ID
   

   Resultado:

   Updated property [core/project].
   

   Nota: Es posible que gcloud CLI ya esté configurada en tu $PROJECT_ID: aún verás el resultado de Updated property.

4. Crea el repositorio hello-repo con el siguiente comando:

   gcloud artifacts repositories create hello-repo \
      --repository-format=docker \
      --location=REGION \
      --description="Docker repository"
   

   Reemplaza REGION por una región para el repositorio, como us-west1. Para ver una lista de las ubicaciones disponibles, ejecuta el siguiente comando:

    gcloud artifacts locations list
   

Compila la imagen de Docker de hello-app

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 8080.

GKE acepta imágenes de Docker como el formato de implementación de la aplicación. Antes de implementar hello-app en GKE, debes empaquetar el código fuente de hello-app como una imagen de Docker.

Para compilar una imagen de Docker, necesitas un código fuente y un Dockerfile. Un Dockerfile contiene instrucciones para compilar la imagen.

1. Descarga el código fuente de hello-app y el Dockerfile mediante la ejecución de los siguientes comandos:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   cd kubernetes-engine-samples/quickstarts/hello-app
   

2. Compila y etiqueta la imagen de Docker para hello-app:

   docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 .
   

   Con este comando, se le indica a Docker que compile la imagen mediante el Dockerfile en el directorio actual, que la guarde en tu entorno local y la etiquete con un nombre, como us-west1-docker.pkg.dev/my-project/hello-repo/hello-app:v1. La imagen se envía a Artifact Registry en la siguiente sección.

   • La variable PROJECT_ID asocia la imagen de contenedor con el repositorio hello-repo en tu proyecto Google Cloud .
   • El prefijo us-west1-docker.pkg.dev hace referencia a Artifact Registry, el host regional de tu repositorio.
   Nota: Si se te solicita, autoriza a Cloud Shell para que realice llamadas a la Google Cloud API.

3. 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
   us-west1-docker.pkg.dev/my-project/hello-repo/hello-app    v1      25cfadb1bf28   10 seconds ago   54 MB
   

   Nota: También es posible que veas imágenes adicionales que representen capas de imágenes intermedias.

4. Agrega vinculaciones de políticas de IAM a tu cuenta de servicio:

   gcloud artifacts repositories add-iam-policy-binding hello-repo \
       --location=REGION \
       --member=serviceAccount:[e-mail] \
       --role="roles/artifactregistry.reader"
   

   Reemplaza PROJECT_NUMBER por el número de proyecto de tu proyecto.

Ejecuta tu contenedor de Docker de forma local (opcional)

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

   docker run --rm -p 8080:8080 REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
   

2. Haz clic en el 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.

Envía tu imagen de Docker a Artifact Registry

Debes subir la imagen de contenedor a un registro para que tu clúster de GKE pueda descargarla y ejecutarla. En este instructivo, almacenarás tu contenedor en Artifact Registry.

1. Configura la herramienta de línea de comandos de Docker para que se autentique en Container Registry:

   gcloud auth configure-docker REGION-docker.pkg.dev
   

   Nota: Puedes ignorar las advertencias sobre una lista larga de asistentes de credenciales.

2. Envía la imagen de Docker que acabas de compilar al repositorio:

   docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
   

Crea un clúster de GKE

Ahora que la imagen de Docker está almacenada en Container Registry, crea un clúster de GKE para ejecutar hello-app. Un clúster de GKE 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.

Cloud Shell

1. Configura tu región de Compute Engine:

    gcloud config set compute/region REGION
   

   Para los clústeres zonales estándar, establece una zona de Compute Engine más cercana al repositorio de Artifact Registry.

2. Crea un clúster llamado hello-cluster:

    gcloud container clusters create-auto hello-cluster
   

   La creación de tu clúster de GKE y la verificación de su estado toma unos minutos. Para ejecutar este instructivo en un clúster de GKE Standard, usa el comando gcloud container clusters create en su lugar.

Console

1. En la consola de Google Cloud , ve a la página Crea un clúster de Autopilot.

   Ir a Crea un clúster de Autopilot

2. En el campo Nombre, ingresa el nombre hello-cluster.

3. Selecciona una región de Compute Engine de la lista desplegable Región, como us-west1.

4. Haz clic en Crear.

5. Espera a que se cree el clúster. Cuando el clúster está listo, aparece una marca de verificación junto al nombre del clúster.

Implementa el hello-app en GKE

Ya estás listo para implementar la imagen de Docker que compilaste en el clúster de GKE.

Kubernetes representa las aplicaciones como Pods, que son unidades escalables que contienen uno o más contenedores. Un Pod es la unidad más pequeña que se puede implementar en Kubernetes. Por lo general, implementas los Pods como un conjunto de réplicas que se pueden escalar y distribuir juntas en el clúster. Una forma de implementar un conjunto de réplicas es mediante una implementación de Kubernetes.

En esta sección, crearás una implementación de Kubernetes para ejecutar hello-app en tu clúster. Esta implementación tiene réplicas (Pods). Un pod de implementación contiene solo un contenedor: la imagen de Docker hello-app. También crearás un recurso HorizontalPodAutoscaler que escale la cantidad de pods de 3 a un número entre 1 y 5 según la carga de la CPU.

Cloud Shell

1. Asegúrate de estar conectado a tu clúster de GKE.

   gcloud container clusters get-credentials hello-cluster
   

2. Crea una implementación de Kubernetes para la imagen de Docker de hello-app.

   kubectl create deployment hello-app --image=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
   

3. Establece en 3 el número del modelo de referencia de las réplicas de la implementación.

   kubectl scale deployment hello-app --replicas=3
   

4. Crea un recurso HorizontalPodAutoscaler para la implementación.

   kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=5
   

5. Para ver los Pods creados, ejecuta el siguiente comando:

   kubectl get pods
   

   Resultado:

   NAME                         READY   STATUS    RESTARTS   AGE
   hello-app-784d7569bc-hgmpx   1/1     Running   0          90s
   hello-app-784d7569bc-jfkz5   1/1     Running   0          90s
   hello-app-784d7569bc-mnrrl   1/1     Running   0          95s
   

   Nota: Los Pods pueden tardar hasta dos minutos en comenzar a ejecutarse. Hasta que comiencen, la columna Status muestra Pending.

Console

1. Accede a la página Cargas de trabajo de la consola de Google Cloud .

   Visitar Cargas de trabajo

2. Haz clic en Implementar.

3. En la sección Especificar contenedor, selecciona Imagen de contenedor existente.

4. En el campo Ruta de acceso a la imagen, haz clic en Seleccionar.

5. En el panel Seleccionar imagen del contenedor, selecciona la imagen hello-app que enviaste a Artifact Registry y haz clic en Seleccionar.

6. En la sección Contenedor, haz clic en Listo y, luego, en Continuar.

7. En la sección Configuración, en Etiquetas, ingresa app en Clave y hello-app en Valor.

8. En YAML de configuración, haz clic en Ver YAML. De esta forma, se abrirá un archivo de configuración YAML que representa los dos recursos de la API de Kubernetes que se están por implementar en el clúster: una implementación y un HorizontalPodAutoscaler para la implementación.

9. Haz clic en Cerrar y, luego, en Implementar.

10. Cuando los pods de implementación estén listos, se abrirá la página Detalles de la implementación.

11. En Pods administrados, ten en cuenta los tres pods en ejecución para la implementación hello-app.

Expón la app a Internet

Si bien los Pods tienen direcciones IP asignadas de forma individual, solo se puede acceder a estas desde el interior del clúster. Además, los pods de GKE están diseñados para ser efímeros y para iniciarse o detenerse según las necesidades de escalamiento. Cuando un Pod falla debido a un error, GKE volverá a implementarlo de forma automática y le asignará una dirección IP nueva cada vez que esto suceda.

Esto significa que, en cualquier implementación, el conjunto de direcciones IP correspondiente al conjunto activo de Pods es dinámico. Necesitamos una forma de: 1) agrupar los Pods en un nombre de host estático y 2) exponer un grupo de Pods fuera del clúster a la Internet.

Los Servicios de Kubernetes resuelven estos dos problemas. Los servicios agrupan los Pods en una dirección IP estática, a la que se puede acceder desde cualquier Pod dentro del clúster. GKE también asigna un nombre de host de DNS a esa IP estática. Por ejemplo, hello-app.default.svc.cluster.local.

El tipo de servicio predeterminado en GKE se llama ClusterIP. En este tipo, el servicio obtiene una dirección IP a la que solo se puede acceder desde interior del clúster. Para exponer un servicio de Kubernetes fuera del clúster, debes crear un servicio de tipo LoadBalancer. Este tipo de servicio genera una IP del balanceador de cargas externo para un conjunto de Pods, a la que se puede acceder a través de Internet.

En esta sección, debes exponer la implementación hello-app a Internet mediante un servicio de tipo LoadBalancer.

Nota: Los balanceadores de cargas de aplicaciones externos son independientes (sujetos a facturación) de los costos de GKE.

Cloud Shell

1. Usa el comando kubectl expose a fin de generar un servicio de Kubernetes para la implementación de hello-app.

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

   Aquí, 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 de hello-app.

2. Ejecuta el siguiente comando con el fin de obtener los detalles del servicio para hello-app-service.

   kubectl get service
   

   Resultado:

   NAME                 CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
   hello-app-service    10.3.251.122    203.0.113.0     80:30877/TCP     10s
   

3. Copia la dirección EXTERNAL_IP en el portapapeles (por ejemplo, 203.0.113.0).

   Nota: El balanceador de cargas puede tardar unos minutos en aprovisionarse. Hasta que se haya aprovisionado el balanceador de cargas, es posible que veas una dirección IP <pending>.

Console

1. Accede a la página Cargas de trabajo de la consola de Google Cloud .

   Ir a Cargas de trabajo

2. Haz clic en hello-app.

3. En la página Detalles de la implementación, haz clic en Acciones > Exponer.

4. En el cuadro de diálogo Exponer, configura el Puerto de destino como 8080. Este es el puerto en el que escucha el contenedor de hello-app.

5. En la lista desplegable Tipo de servicio, selecciona Balanceador de cargas.

6. Haz clic en Exponer a fin de crear un servicio de Kubernetes para hello-app.

7. Cuando el balanceador de cargas esté listo, se abrirá la página Detalles del servicio.

8. Desplázate hacia abajo hasta el campo Extremos externos y copia la dirección IP.

Ahora que los Pods de hello-app están expuestos a la Internet a través de un servicio de Kubernetes, puedes abrir una pestaña nueva del navegador y navegar a la dirección IP del servicio que copiaste en el portapapeles. Aparecerá un mensaje Hello, World!, junto con un campo Hostname. El Hostname corresponde a uno de los tres Pods de hello-app que entregan la solicitud HTTP al navegador.

Implementa una versión nueva de hello-app

En esta sección, deberás actualizar hello-app a una versión nueva mediante la compilación y la implementación de una imagen de Docker nueva en el clúster de GKE.

La actualización progresiva de Kubernetes te permite actualizar tus objetos Deployment sin tiempo de inactividad. Durante una actualización progresiva, el clúster de GKE reemplaza de forma incremental los Pods de hello-app existentes por Pods que contengan la imagen de Docker de la versión nueva. Durante la actualización, el servicio del balanceador de cargas enruta el tráfico solo a los Pods disponibles.

1. Regresa a Cloud Shell, donde clonaste el código fuente de hello-app y el Dockerfile. Actualiza la función hello() en el archivo main.go para informar la versión nueva 2.0.0.

2. Compila y etiqueta una nueva imagen de Docker de hello-app.

   docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 .
   

3. Envía la imagen a Artifact Registry

   docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2
   

Ya estás listo para actualizar la implementación de Kubernetes de hello-app con el fin de usar una imagen de Docker nueva.

Nota: Como creaste un HorizontalPodAutoscaler antes, la cantidad de pods hello-app que se ejecutan en esta sección podría ser menor que los tres pods implementados inicialmente. Es posible que tu clúster de GKE haya reducido la cantidad de pods en función del uso de CPU bajo.

Cloud Shell

1. Aplica una actualización progresiva a la Deployment de hello-app existente con una actualización de imagen mediante el comando kubectl set image:

   kubectl set image deployment/hello-app hello-app=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2
   

2. Mira cómo finalizan los Pods en ejecución que ejecutan la imagen v1 y cómo inician los Pods nuevos que ejecutan la imagen v2.

   watch kubectl get pods
   

   Resultado:

   NAME                        READY   STATUS    RESTARTS   AGE
   hello-app-89dc45f48-5bzqp   1/1     Running   0          2m42s
   hello-app-89dc45f48-scm66   1/1     Running   0          2m40s
   

3. En una pestaña diferente, vuelve a navegar a la IP externa hello-app-service. Ahora deberías ver la Version configurada como 2.0.0..

Console

1. Accede a la página Cargas de trabajo de la consola de Google Cloud .

   Ir a Cargas de trabajo

2. Haz clic en hello-app.

3. En la página Detalles de la implementación, haz clic en Acciones > Actualización progresiva.

4. En el cuadro de diálogo Actualización progresiva, establece el campo Imagen de hello-app en REGION-docker.pkg.dev/PROJECT_ID/hello-repo/hello-app:v2.

5. Haz clic en Actualizar.

6. En la página Detalles de la implementación, inspecciona la sección Revisiones activas. Ahora deberías ver dos revisiones: 1 y 2. La revisión 1 corresponde a la implementación inicial que creaste antes. La revisión 2 es la actualización progresiva que acabas de iniciar.

7. Después de unos momentos, actualiza la página. En Pods administrados, todas las réplicas de hello-app ahora corresponden a la revisión 2.

8. En otra pestaña, navega nuevamente a la dirección IP del servicio que copiaste. El Version debe ser 2.0.0..