Desplegar una aplicación web en contenedores de Docker en GKE

Autopilot Standard

---

En este tutorial se muestra cómo desplegar 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 en la nube, y despliegan aplicaciones y servicios. Para obtener más información sobre los roles habituales y las tareas de ejemplo que se mencionan en el contenido, consulta Roles y tareas habituales de los usuarios de GKE. Google Cloud

Antes de leer esta página, asegúrate de que conoces Kubernetes.

Objetivos

• Empaqueta una aplicación web de muestra en una imagen de Docker.
• Sube la imagen Docker a Artifact Registry.
• Crea un clúster de GKE.
• Despliega la aplicación de ejemplo en el clúster.
• Gestiona el autoescalado de la implementación.
• Expón la aplicación de ejemplo en Internet.
• Despliega una nueva versión de la aplicación de ejemplo.

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

• GKE
• Artifact Registry

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Activar Cloud Shell

Cloud Shell tiene preinstaladas las herramientas de línea de comandos gcloud, docker y kubectl que se usan en este tutorial.

1. Ve a la Google Cloud consola.

2. Haz clic en el botón Activar Cloud Shell situado en la parte superior de la ventana de la consola Google Cloud .

   Se abrirá una sesión de Cloud Shell dentro de un nuevo marco en la parte inferior de la consola de Google Cloud y se mostrará en ella un mensaje de la línea de comandos.

   

Crear un repositorio

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

1. Asigna a la variable de entorno PROJECT_ID el Google Cloud ID de tu proyecto (PROJECT_ID). Usarás esta variable de entorno cuando compiles la imagen del contenedor y la envíes a tu repositorio.

   export PROJECT_ID=PROJECT_ID
   

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

   echo $PROJECT_ID
   

3. Define el ID de proyecto para Google Cloud CLI:

   gcloud config set project $PROJECT_ID
   

   Resultado:

   Updated property [core/project].
   

   Nota: Es posible que tu CLI de gcloud ya esté configurada en tu $PROJECT_ID. Aun así, verás el resultado 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"
   

   Sustituye REGION por una región del 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 hello-app

En este tutorial, desplegarás una aplicación web de ejemplo 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 formato de despliegue de aplicaciones. Antes de desplegar hello-app en GKE, debes empaquetar el código fuente de hello-app como una imagen de Docker.

Para crear una imagen Docker, necesitas código fuente y un Dockerfile. Un Dockerfile contiene instrucciones sobre cómo se crea la imagen.

1. Descarga el código fuente de hello-app y el archivo Dockerfile ejecutando 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 Docker de hello-app:

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

   Este comando indica a Docker que compile la imagen usando el Dockerfile del directorio actual, que la guarde en tu entorno local y que 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 del contenedor con el repositorio hello-repo de 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 pueda hacer llamadas a la API. Google Cloud

3. Ejecuta el comando docker images para verificar que la compilación se ha realizado correctamente:

   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 representan capas de imagen intermedias.

4. Añada enlaces de políticas de gestión de identidades y accesos a su cuenta de servicio:

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

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

(Opcional) Ejecuta tu contenedor Docker de forma local

1. Prueba la imagen de contenedor con tu motor 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 web y, a continuación, selecciona el número de puerto 8080. GKE abre la URL de vista previa con su servicio de proxy en una nueva ventana del navegador.

Enviar una imagen 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 tutorial, almacenarás tu contenedor en Artifact Registry.

1. Configura la herramienta de línea de comandos de Docker para autenticarte en Artifact Registry:

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

   Nota: Puedes ignorar las advertencias sobre tener una lista larga de gestores 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
   

Crear un clúster de GKE

Ahora que la imagen de Docker está almacenada en Artifact Registry, crea un clúster de GKE para ejecutar hello-app. Un clúster de GKE consta de un grupo de instancias de VM de Compute Engine que ejecutan Kubernetes, el sistema de orquestación de clústeres de código abierto que impulsa GKE.

Cloud Shell

1. Define la región de Compute Engine:

    gcloud config set compute/region REGION
   

   En el caso de los clústeres zonales estándar, define una zona de Compute Engine que esté lo más cerca posible del repositorio de Artifact Registry.

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

    gcloud container clusters create-auto hello-cluster
   

   El clúster de GKE tarda unos minutos en crearse y en comprobarse su estado. Para seguir este tutorial en un clúster estándar de GKE, usa el comando gcloud container clusters create.

Consola

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

   Ir a Crear un clúster de Autopilot

2. En el campo Name (Nombre), introduce el nombre hello-cluster.

3. Seleccione 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, aparecerá una marca de verificación junto a su nombre.

Desplegar el hello-app en GKE

Ahora ya puedes desplegar la imagen de Docker que has creado en tu clúster de GKE.

Kubernetes representa las aplicaciones como pods, que son unidades escalables que contienen uno o varios contenedores. El pod es la unidad desplegable más pequeña de Kubernetes. Normalmente, los pods se implementan como un conjunto de réplicas que se pueden escalar y distribuir conjuntamente en tu clúster. Una forma de desplegar un conjunto de réplicas es mediante un Deployment de Kubernetes.

En esta sección, crearás un Deployment 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 creas un recurso HorizontalPodAutoscaler que escala el número de pods de 3 a un número entre 1 y 5, en función de la carga de la CPU.

Cloud Shell

1. Asegúrate de que estás conectado a tu clúster de GKE.

   gcloud container clusters get-credentials hello-cluster
   

2. Crea un despliegue de Kubernetes para tu imagen de Docker hello-app.

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

3. Define el número de réplicas de Deployment de referencia en 3.

   kubectl scale deployment hello-app --replicas=3
   

4. Crea un recurso HorizontalPodAutoscaler para tu 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 empezar a ejecutarse. Hasta que empiece, en la columna Status se muestra Pending.

Consola

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

   Visitar cargas de trabajo

2. Haz clic en Desplegar.

3. En la sección Especificar contenedor, selecciona Imagen de contenedor que ya existe.

4. En el campo Ruta de la imagen, haga clic en Seleccionar.

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

6. En la sección Contenedor, haga clic en Hecho y, a continuación, en Continuar.

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

8. En YAML de configuración, haz clic en Ver YAML. Se abrirá un archivo de configuración YAML que representa los dos recursos de la API de Kubernetes que se van a desplegar en tu clúster: un Deployment y un HorizontalPodAutoscaler para ese Deployment.

9. Haz clic en Cerrar y, a continuación, en Desplegar.

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

11. En Pods gestionados, fíjate en los tres pods en ejecución de la hello-app implementación.

Exponer la aplicación a Internet

Aunque los pods tienen direcciones IP asignadas individualmente, solo se puede acceder a esas IPs desde dentro del clúster. Además, los pods de GKE están diseñados para ser efímeros, es decir, para iniciarse o detenerse en función de las necesidades de escalado. Además, cuando un pod falla debido a un error, GKE vuelve a desplegarlo automáticamente y le asigna una nueva dirección IP de pod cada vez.

Esto significa que, en cualquier Deployment, 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, en Internet.

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

El tipo de servicio predeterminado en GKE se llama ClusterIP, donde el servicio obtiene una dirección IP a la que solo se puede acceder desde dentro del clúster. Para exponer un servicio de Kubernetes fuera del clúster, crea un servicio de tipo LoadBalancer. Este tipo de servicio genera una IP de balanceador de carga externo para un conjunto de pods, a los que se puede acceder a través de Internet.

En esta sección, expondrás la hello-app Deployment a Internet mediante un servicio de tipo LoadBalancer.

Nota: Los balanceadores de carga de aplicaciones externos están sujetos a facturación) y son independientes de los costes de GKE.

Cloud Shell

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

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

   En este caso, la marca --port especifica el número de puerto configurado en el balanceador de carga y la marca --target-port especifica el número de puerto en el que está escuchando el contenedor hello-app.

2. Ejecuta el siguiente comando para obtener los detalles del servicio 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 carga puede tardar unos minutos en aprovisionarse. Hasta que se aprovisione el balanceador de carga, es posible que veas una <pending> dirección IP
   .

Consola

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

   Ve a Cargas de trabajo.

2. Haz clic en hello-app.

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

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

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

6. Haz clic en Expose (Exponer) para crear un servicio de Kubernetes para hello-app.

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

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

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

Desplegar una nueva versión de hello-app

En esta sección, actualizarás hello-app a una nueva versión creando e implementando una nueva imagen de Docker en tu clúster de GKE.

La actualización continua de Kubernetes te permite actualizar tus implementaciones sin tiempo de inactividad. Durante una actualización continua, tu clúster de GKE sustituye de forma incremental los hello-app pods por pods que contienen la imagen de Docker de la nueva versión. Durante la actualización, el servicio de balanceador de carga solo dirige el tráfico a los pods disponibles.

1. Vuelve a Cloud Shell, donde has clonado el código fuente de la aplicación hello y el Dockerfile. Actualiza la función hello() del archivo main.go para que informe de la nueva versión 2.0.0.

2. Compila y etiqueta una nueva imagen de Docker 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
   

Ahora puedes actualizar tu hello-appdespliegue de Kubernetes para usar una nueva imagen de Docker.

Nota: Como has creado un HorizontalPodAutoscaler anteriormente, es posible que el número de hello-app pods que se ejecutan en esta sección sea inferior a los tres pods que se han implementado inicialmente. Es posible que tu clúster de GKE haya reducido el número de pods en función del bajo uso de la CPU.

Cloud Shell

1. Aplica una actualización continua a la implementación de hello-app 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. Verás cómo se detienen los pods que ejecutan la imagen v1 y cómo se inician los nuevos pods 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 otra pestaña, vuelve a la hello-app-service IP externa. Ahora deberías ver que Version está configurado como 2.0.0.

Consola

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

   Ve a Cargas de trabajo.

2. Haz clic en hello-app.

3. En la página Deployment details (Detalles de la implementación), haga clic en Actions > Rolling update (Acciones > Actualización gradual).

4. En el cuadro de diálogo Actualización continua, asigna el valor REGION-docker.pkg.dev/PROJECT_ID/hello-repo/hello-app:v2 al campo Imagen de hello-app.

5. Haz clic en Actualizar.

6. En la página Detalles de la implementación, consulta la sección Revisiones activas. Ahora deberías ver dos revisiones, 1 y 2. La revisión 1 corresponde al despliegue inicial que has creado anteriormente. La revisión 2 es la actualización acumulativa que acabas de iniciar.

7. Al cabo de unos instantes, actualiza la página. En Pods gestionados, todas las réplicas de hello-app ahora corresponden a la revisión 2.

8. En otra pestaña, vuelve a la dirección IP del servicio que has copiado. El Version debe ser 2.0.0.

Limpieza

Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud, elimina el proyecto que contiene los recursos o conserva el proyecto y elimina los recursos.

1. Elimina el servicio: se desasignará el balanceador de carga de Cloud creado para tu servicio:

   kubectl delete service hello-app-service
   

2. Eliminar el clúster: se eliminan los recursos que componen el clúster, como las instancias de computación, los discos y los recursos de red.

   gcloud container clusters delete hello-cluster
   

3. Elimina tus imágenes de contenedor: se eliminarán las imágenes Docker que hayas enviado a Artifact Registry.

   gcloud artifacts docker images delete \
       REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 \
       --delete-tags --quiet
   gcloud artifacts docker images delete \
       REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 \
       --delete-tags --quiet
   

Siguientes pasos

• Consulta los precios de GKE y usa la calculadora de precios para estimar los costes.

• Lee el tutorial de balanceadores de carga, que contiene configuraciones avanzadas de balanceo de carga para aplicaciones web.

• Configura una IP estática y un nombre de dominio para tu aplicación.

• Consulta otros tutoriales de Kubernetes Engine.

• Consulta arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Centro de arquitectura de Cloud.

Pruébalo

Si es la primera vez que utilizas Google Cloud, crea una cuenta para evaluar el rendimiento de GKE en situaciones reales. Los nuevos clientes también reciben 300 USD en crédito gratuito para ejecutar, probar y desplegar cargas de trabajo.

Probar GKE gratis