Implementa una aplicación web alojada en contenedores

Autopilot Estándar

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). Luego, deberás implementar la aplicación web como un conjunto de réplicas con balanceo de cargas que puede escalar según las necesidades de los usuarios.

Objetivos

Empaquetar una aplicación web de muestra en una imagen de Docker
Subir la imagen de Docker a Artifact Registry
Crear un clúster de GKE
Implementar la app de muestra en el clúster
Administrar el ajuste de escala automático para la implementación
Exponer la app de muestra a la Internet
Implementar una versión nueva de la app de ejemplo

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

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

Go to project selector

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

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

Enable the APIs

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

Go to project selector

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

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

Enable the APIs

Activar Cloud Shell

Cloud Shell viene preinstalado con las herramientas de línea de comandos de gcloud, docker y kubectl que se usan en este instructivo.

Ve a la consola de Google Cloud.
Haz clic en el botón Activar Cloud Shell en la parte superior de la consola de Google Cloud.

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

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.

Configura la variable de entorno PROJECT_ID como el ID del proyecto de Google 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
```
Confirma que la variable de entorno PROJECT_ID tenga el valor correcto:
```
echo $PROJECT_ID
```
Configura el ID del proyecto para Google Cloud CLI:
```
gcloud config set project $PROJECT_ID
```
Resultado:
```
Updated property [core/project].
```
Nota: Es posible que la CLI de gcloud ya esté configurada en tu $PROJECT_ID: aún verás el resultado de Updated property.

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 contenedor

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.

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

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 de 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 API de Google Cloud.

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

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:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
    --role="roles/artifactregistry.reader"

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

Ejecuta tu contenedor de manera local (opcional)

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

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

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.

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

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

Consola

Ve a la página de Google Kubernetes Engine en la consola de Google Cloud.

Ir a Google Kubernetes Engine
Haz clic en Crear.
En Autopilot de GKE, haz clic en Configurar.
En el campo Nombre, ingresa el nombre hello-cluster.
Selecciona una región de Compute Engine de la lista desplegable Región, como us-west1.
Haz clic en Crear.
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.

Cómo implementar la aplicación de muestra 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

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

gcloud container clusters get-credentials hello-cluster --region REGION

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

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
```

Crea un recurso HorizontalPodAutoscaler para la implementación.

kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=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

Consola

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

Visitar Cargas de trabajo
Haz clic en Implementar.
En la sección Especificar contenedor, selecciona Imagen de contenedor existente.
En el campo Ruta de acceso a la imagen, haz clic en Seleccionar.
En el panel Seleccionar imagen del contenedor, selecciona la imagen hello-app que enviaste a Artifact Registry y haz clic en Seleccionar.
En la sección Contenedor, haz clic en Listo y, luego, en Continuar.
En la sección Configuración, en Etiquetas, ingresa app en Clave y hello-app en Valor.
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.
Haz clic en Cerrar y, luego, en Implementar.
Cuando los pods de implementación estén listos, se abrirá la página Detalles de la implementación.
En Pods administrados, ten en cuenta los tres pods en ejecución para la implementación hello-app.

Expón la app de muestra a la 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.

Cloud Shell

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.

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

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

Consola

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

Ir a Cargas de trabajo
Haz clic en hello-app.
En la página Detalles de la implementación, haz clic en Acciones > Exponer.
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.
En la lista desplegable Tipo de servicio, selecciona Balanceador de cargas.
Haz clic en Exponer a fin de crear un servicio de Kubernetes para hello-app.
Cuando el balanceador de cargas esté listo, se abrirá la página Detalles del servicio.
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 la app de muestra

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 función de actualización progresiva de GKE te permite actualizar las implementaciones 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.

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.

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 .

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.

Cloud Shell

Aplica una actualización progresiva a la implementación 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
```

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

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

Consola

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

Ir a Cargas de trabajo
Haz clic en hello-app.
En la página Detalles de la implementación, haz clic en Acciones > Actualización progresiva.
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.
Haz clic en Actualizar.
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.
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.
En otra pestaña, navega nuevamente a la dirección IP del servicio que copiaste. El Version debe ser 2.0.0..

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el Service: De este modo, se desasigna el balanceador de cargas de Cloud creado para él:
```
kubectl delete service hello-app-service
```
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 --region REGION
```

Borra tus imágenes de contenedor: Esto borra las imágenes de Docker que enviaste a Container 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

¿Qué sigue?

Obtén más información sobre los Precios de GKE y usa la Calculadora de precios para estimar los costos.
Lee el instructivo Balanceadores de cargas, que muestra las configuraciones avanzadas de balanceo de cargas para aplicaciones web.
Configura una IP estática y un nombre de dominio para la aplicación.
Explora otros instructivos de Kubernetes Engine.
Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.

Pruébalo tú mismo

Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de GKE en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Probar GKE gratis