Descripción general

En este lab, crearás una canalización de CI/CD que automáticamente compila una imagen de contenedor desde el código confirmado, la almacena en Container Registry, actualiza un manifiesto de Kubernetes en un repositorio de Git y, luego, implementa la aplicación en Google Kubernetes Engine con ese manifiesto.

En este lab, crearás 2 repositorios de Git:

• Repositorio app: Contiene el código fuente de la aplicación.
• Repositorio env: Contiene los manifiestos para el objeto Deployment de Kubernetes.

Cuando envías un cambio al repositorio app, la canalización de Cloud Build ejecuta pruebas y compila una imagen de contenedor, que luego envía a Artifact Registry. Después de enviar la imagen, Cloud Build actualiza el manifiesto de Deployment y lo envía al repositorio env. Esto activa otra canalización de Cloud Build que aplica el manifiesto al clúster de GKE y, si se aplica correctamente, lo almacena en otra rama del repositorio env.

Los repositorios app y env deben estar separados porque tienen diferentes ciclos de vida y usos. Los usuarios principales del repositorio app son personas reales, y este repositorio está dedicado a una aplicación específica. Los usuarios principales del repositorio env son sistemas automatizados (como Cloud Build) y varias aplicaciones pueden compartir este repositorio. El repositorio env puede tener varias ramas, y cada una se asigna a un entorno específico (en este lab, solo utilizas la rama production) y hace referencia a una imagen de contenedor determinada, mientras que el repositorio app no.

Cuando termines este lab, obtendrás un sistema en el que podrás realizar fácilmente las siguientes acciones:

• Diferenciar las implementaciones fallidas y correctas observando el historial de Cloud Build
• Acceder al manifiesto utilizado en este momento observando la rama production del repositorio env
• Efectuar una reversión a cualquier versión anterior a través de una nueva ejecución de la compilación correspondiente de Cloud Build

Nota: En este lab, se usa Cloud Build para ejecutar las canalizaciones, pero hay otras herramientas populares de automatización de compilaciones que pueden servir como alternativas, como Spinnaker y Jenkins. Por ahora, algunas de estas otras herramientas tienen una compatibilidad superior con las implementaciones azul-verde, el análisis de versiones canary y otras funciones similares que pueden ser necesarias en implementaciones de CI/CD más avanzadas.

Objetivos

En este lab, aprenderás a hacer lo siguiente:

• Crear clústeres de Kubernetes Engine
• Crear Cloud Source Repositories
• Activar Cloud Build desde Cloud Source Repositories
• Automatizar las pruebas y publicar una imagen de contenedor implementable a través de Cloud Build
• Administrar recursos implementados en un clúster de Kubernetes Engine mediante Cloud Build

Configuración y requisitos

Accede a Qwiklabs

En cada lab, recibirá un proyecto de Google Cloud y un conjunto de recursos nuevos por tiempo limitado y sin costo adicional.

1. Accede a Qwiklabs desde una ventana de incógnito.

2. Ten en cuenta el tiempo de acceso del lab (por ejemplo, 1:15:00) y asegúrate de finalizarlo en el plazo asignado.
   No existe una función de pausa. Si lo necesita, puede reiniciar el lab, pero deberá hacerlo desde el comienzo.

3. Cuando esté listo, haga clic en Comenzar lab.

4. Anote las credenciales del lab (el nombre de usuario y la contraseña). Las usarás para acceder a la consola de Google Cloud.

5. Haga clic en Abrir Google Console.

6. Haga clic en Usar otra cuenta, copie las credenciales para este lab y péguelas en el mensaje emergente que aparece.
   Si usa otras credenciales, se generarán errores o incurrirá en cargos.

7. Acepta las condiciones y omite la página de recursos de recuperación.

Después de completar los pasos iniciales de acceso, aparecerá el panel del proyecto.

Activa Google Cloud Shell

Google Cloud Shell es una máquina virtual que cuenta con herramientas para desarrolladores. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud.

Google Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.

1. En la consola de Cloud, en la barra de herramientas superior derecha, haz clic en el botón Abrir Cloud Shell.

   

2. Haz clic en Continuar.

El aprovisionamiento y la conexión al entorno demorarán unos minutos. Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu PROJECT_ID. Por ejemplo:

gcloud es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con el completado de línea de comando.

• Puedes solicitar el nombre de la cuenta activa con este comando:

gcloud auth list

Resultado:

Credentialed accounts: - @.com (active)

Resultado de ejemplo:

Credentialed accounts: - google1623327_student@qwiklabs.net

• Puedes solicitar el ID del proyecto con este comando:

gcloud config list project

Resultado:

[core] project =

Resultado de ejemplo:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: La documentación completa de gcloud está disponible en la guía de descripción general de gcloud CLI .

Tarea 1: Inicializa tu lab

En esta tarea, prepararás tu proyecto de Google Cloud habilitando las APIs necesarias, inicializando la configuración de Git en Cloud Shell y descargando el código de muestra que usarás luego en el lab.

1. En Cloud Shell, ejecuta el siguiente comando, que habilitará las APIs para GKE, Cloud Build, Cloud Source Repositories y Container Analysis:

gcloud services enable container.googleapis.com \ cloudbuild.googleapis.com \ sourcerepo.googleapis.com \ containeranalysis.googleapis.com

2. Crea un repositorio de Docker en Artifact Registry llamado my-repository en la región para almacenar tus imágenes de contenedor.

gcloud artifacts repositories create my-repository \ --repository-format=docker \ --location={{{project_0.default_region | REGION}}}

3. En Cloud Shell, crea un clúster de GKE que usarás para implementar la aplicación de ejemplo de este lab.

gcloud container clusters create hello-cloudbuild \ --num-nodes 1 --region {{{project_0.default_region | REGION}}}

4. Si nunca usaste Git en Cloud Shell, configúralo con tu nombre y dirección de correo electrónico.

git config --global user.email "you@example.com" git config --global user.name "Your Name"

Git usará estos datos para identificarte como el autor de las confirmaciones que crearás en Cloud Shell.

Haz clic en Revisar mi progreso para verificar el objetivo. Inicializar tu lab

Tarea 2: Crea repositorios de Git en Cloud Source Repositories

En esta tarea, crearás los dos repositorios de Git (hello-cloudbuild-app y hello-cloudbuild-env) utilizados en este lab, además de inicializar hello-cloudbuild-app con código de muestra.

1. En Cloud Shell, crea los dos repositorios de Git:

gcloud source repos create hello-cloudbuild-app gcloud source repos create hello-cloudbuild-env

2. Clona el repositorio hello-cloudbuild-app.

PROJECT_ID=$(gcloud config get-value project) gcloud source repos clone hello-cloudbuild-app --project=$PROJECT_ID

3. Para copiar el código de muestra de Cloud Storage y extraer el contenido del archivo en tu directorio principal, ejecuta los siguientes comandos:

cd ~ gcloud storage cp gs://cloud-training/gke-gitops/hello-cloudbuild-app.zip ~ && unzip ~/hello-cloudbuild-app.zip -d ~ && rm ~/hello-cloudbuild-app.zip

3. Configura Cloud Source Repositories como remoto:

cd ~/hello-cloudbuild-app REGION={{{project_0.default_region | REGION}}} sed -i s/us-central1/$REGION/g cloudbuild.yaml sed -i s/us-central1/$REGION/g cloudbuild-trigger-cd.yaml sed -i s/us-central1/$REGION/g cloudbuild-delivery.yaml sed -i s/us-central1/$REGION/g kubernetes.yaml.tpl git init git add . git commit -m "first commit" git remote add google \ "https://source.developers.google.com/p/${PROJECT_ID}/r/hello-cloudbuild-app"

El código que clonaste contiene una aplicación "Hello World" simple:

from flask import Flask app = Flask('hello-cloudbuild') @app.route('/') def hello(): return "Hello World!\n" if __name__ == '__main__': app.run(host = '0.0.0.0', port = 8080)

Haz clic en Revisar mi progreso para verificar el objetivo. Crear repositorios de Git en Cloud Source Repositories

Tarea 3: Crea una imagen de contenedor con Cloud Build

El código que clonaste ya contiene el siguiente Dockerfile:

FROM python:3.7-slim RUN pip install flask WORKDIR /app COPY app.py /app/app.py ENTRYPOINT ["python"] CMD ["/app/app.py"]

Con este Dockerfile, puedes crear una imagen de contenedor con Cloud Build y guardarla en Container Registry.

1. Con el siguiente comando, crea en Cloud Shell una compilación de Cloud Build basada en la confirmación más reciente:

cd ~/hello-cloudbuild-app COMMIT_ID="$(git rev-parse --short=7 HEAD)" gcloud builds submit --tag="{{{project_0.default_region | REGION}}}-docker.pkg.dev/${PROJECT_ID}/my-repository/hello-cloudbuild:${COMMIT_ID}" .

Cloud Build transmite los registros que generó la creación de la imagen de contenedor a tu terminal cuando ejecutas este comando.

2. Luego de que finalice la compilación, en la consola de Google Cloud, ve a Artifact Registry > Repositorios (Repositories) para verificar que tu nueva imagen de contenedor esté disponible en Artifact Registry.

3. Haz clic en my-repository.

Haz clic en Revisar mi progreso para verificar el objetivo. Crear una imagen de contenedor con Cloud Build

Tarea 4: Crea la canalización de integración continua (CI)

En esta tarea, configurarás Cloud Build para ejecutar automáticamente una prueba de unidades pequeñas, compilarás la imagen de contenedor y la enviarás a Container Registry. Enviar una confirmación nueva a Cloud Source Repositories activa automáticamente esta canalización. El archivo cloudbuild.yaml ya incluido en el código es la configuración de la canalización.

1. En la consola de Google Cloud, ve a Cloud Build > Activadores.
2. Haz clic en Crear activador (Create Trigger).
3. En el campo Nombre (Name), escribe hello-cloudbuild.
4. En Evento (Event), selecciona Enviar a una rama (Push to a branch).
5. En Fuente (Source), selecciona hello-cloudbuild-app como tu Repositorio (Repository) y escribe ^master$ para tu Rama (Branch).
6. En Configuración de compilación (Build configuration), selecciona Archivo de configuración de Cloud Build (Cloud Build configuration file).
7. En el campo Ubicación del archivo de configuración de Cloud Build, escribe cloudbuild.yaml después de /.
8. En Cuenta de servicio, selecciona la cuenta de servicio que comienza con el ID de tu proyecto y que es similar a (@.iam.gserviceaccount.com).
9. Haz clic en Crear (Create).

Cuando se haya creado el activador, regresa a Cloud Shell. Ahora debes enviar el código de la aplicación a Cloud Source Repositories para activar la canalización de CI en Cloud Build.

10. Para iniciar este activador, ejecuta el siguiente comando:

cd ~/hello-cloudbuild-app git push google master

11. En la consola de Google Cloud, ve a Cloud Build > Panel.

Deberías ver una compilación en ejecución o finalizada recientemente.

Puedes hacer clic en la compilación para seguir la ejecución y examinar sus registros.

Haz clic en Revisar mi progreso para verificar el objetivo. Crear la canalización de integración continua (CI)

Tarea 5: Crea el entorno de pruebas y la canalización de CD

Cloud Build también se usa para la canalización de entrega continua. La canalización se ejecuta cada vez que se envía una confirmación a la rama candidate del repositorio __hello-cloudbuild-env__. La canalización aplica la versión nueva del manifiesto al clúster de Kubernetes y, si lo hace correctamente, copia el manifiesto en la rama production. Este proceso tiene las siguientes propiedades:

• La rama candidate es un historial de los intentos de implementación.
• La rama production es un historial de las implementaciones correctas.
• En Cloud Build, tienes una vista de las implementaciones fallidas y correctas.
• Puedes realizar una reversión a cualquier implementación anterior si vuelves a ejecutar la compilación correspondiente en Cloud Build. Una reversión también actualiza la rama production para reflejar verdaderamente el historial de implementaciones.

Modificarás la canalización de integración continua para actualizar la rama candidate del repositorio hello-cloudbuild-env, lo que activa la canalización de entrega continua.

Otorga a Cloud Build acceso a GKE

Para implementar la aplicación en el clúster de Kubernetes, Cloud Build necesita el rol de administración de Identity and Access Management de desarrollador de Kubernetes Engine.

• En Cloud Shell, ejecuta el siguiente comando:

PROJECT_NUMBER="$(gcloud projects describe ${PROJECT_ID} --format='get(projectNumber)')" gcloud projects add-iam-policy-binding ${PROJECT_NUMBER} \ --member=serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com \ --role=roles/container.developer

Inicializa el repositorio hello-cloudbuild-env

Debes inicializar el repositorio hello-cloudbuild-env con dos ramas (production y candidate) y un archivo de configuración de Cloud Build que describa el proceso de implementación.

El primer paso es clonar el repositorio hello-cloudbuild-env y crear la rama production, que todavía estará vacía.

1. En Cloud Shell, ejecuta el siguiente comando:

cd ~ gcloud source repos clone hello-cloudbuild-env cd ~/hello-cloudbuild-env git checkout -b production

2. A continuación, debes copiar el archivo cloudbuild-delivery.yaml disponible en el repositorio hello-cloudbuild-app y confirmar el cambio:

cd ~/hello-cloudbuild-env cp ~/hello-cloudbuild-app/cloudbuild-delivery.yaml ~/hello-cloudbuild-env/cloudbuild.yaml git add . git commit -m "Create cloudbuild.yaml for deployment" Nota: El archivo cloudbuild-delivery.yaml describe el proceso de implementación que debe ejecutarse en Cloud Build.

Este tiene dos pasos:

• Cloud Build aplica el manifiesto en el clúster de GKE.
• Si se aplica de forma correcta, Cloud Build lo copia en la rama production.

3. Crea la rama candidate y envía ambas ramas para que estén disponibles en Cloud Source Repositories:

git checkout -b candidate git push origin production git push origin candidate

4. Otorga el rol de IAM de escritor de repositorio de código fuente a la cuenta de servicio de Cloud Build para el repositorio hello-cloudbuild-env:

PROJECT_NUMBER="$(gcloud projects describe ${PROJECT_ID} \ --format='get(projectNumber)')" cat >/tmp/hello-cloudbuild-env-policy.yaml <<EOF bindings: - members: - serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com role: roles/source.writer EOF gcloud source repos set-iam-policy \ hello-cloudbuild-env /tmp/hello-cloudbuild-env-policy.yaml

Haz clic en Revisar mi progreso para verificar el objetivo. Otorgar la función de desarrollador de Kubernetes Engine y la función de IAM de escritor del repositorio de código fuente a Cloud Build

Crea un activador para la canalización de entrega continua

1. En la consola de Google Cloud, ve a Cloud Build > Activadores.
2. Haz clic en Crear activador.
3. En el campo Nombre, escribe hello-cloudbuild-deploy.
4. En Evento, selecciona Enviar a una rama.
5. Debajo de Fuente, seleccionahello-cloudbuild-env como tu Repositorio y ^candidate$ como tu Rama.
6. En Configuración de compilación, selecciona Archivo de configuración de Cloud Build.
7. En el campo Ubicación del archivo de configuración de Cloud Build, escribe cloudbuild.yaml después de /.
8. En Cuenta de servicio, selecciona la cuenta de servicio que comienza con el ID de tu proyecto y que es similar a (@.iam.gserviceaccount.com).
9. Haz clic en Crear.

Modifica la canalización de integración continua para activar la canalización de entrega continua

En esta sección, agregarás algunos pasos a la canalización de integración continua que generará una versión nueva del manifiesto de Kubernetes y lo enviará al repositorio __hello-cloudbuild-env__ para activar la canalización de entrega continua.

1. Copia la versión extendida del archivo cloudbuild.yaml para el repositorio app:

cd ~/hello-cloudbuild-app cp cloudbuild-trigger-cd.yaml cloudbuild.yaml

El archivo cloudbuild-trigger-cd.yaml es una versión extendida del archivo cloudbuild.yaml. Este agrega los pasos que se detallan a continuación, que generan el manifiesto nuevo de Kubernetes y activan la canalización de entrega continua.

Nota: Esta canalización usa un sed sencillo para renderizar la plantilla del manifiesto. En realidad, te beneficiarás con el uso de herramientas dedicadas, como kustomize o skaffold. Estas permiten tener más control sobre la renderización de las plantillas del manifiesto.

2. Confirma las modificaciones y envíalas a Cloud Source Repositories:

cd ~/hello-cloudbuild-app git add cloudbuild.yaml git commit -m "Trigger CD pipeline" git push google master

Esto activa la canalización de integración continua en Cloud Build.

Haz clic en Revisar mi progreso para verificar el objetivo. Crear un activador para la canalización de entrega continua

Tarea 6: Revisa las canalizaciones de Cloud Build

1. En la consola de Google Cloud, ve a Cloud Build > Panel.
2. Haz clic en el activador hello-cloudbuild-app para seguir su ejecución y examinar sus registros.

El último paso de esta canalización envía el manifiesto nuevo al repositorio hello-cloudbuild-env, que activa la canalización de entrega continua.

3. Regresa al Panel principal.
4. Deberías ver una compilación en ejecución o finalizada recientemente para el repositorio hello-cloudbuild-env. Puedes hacer clic en la compilación para seguir la ejecución y examinar sus registros.

Tarea 7: Prueba la canalización completa

La canalización de CI/CD ahora está configurada. En esta sección, la probarás de extremo a extremo.

1. En la consola de Google Cloud, ve a Kubernetes Engine > Puertas de enlace, Ingress y Service.

2. Selecciona Servicios en el menú superior

Debe haber un solo servicio llamado hello-cloudbuild en la lista. Se creó con la compilación de entrega continua que se acaba de ejecutar.

3. Haz clic en el extremo del servicio hello-cloudbuild.

Deberías ver "Hello World!". Si no existe el extremo, o si ves un error del balanceador de cargas, es posible que debas esperar algunos minutos para que el balanceador de cargas se inicialice por completo. Haz clic en Actualizar para que la página se actualice, si es necesario.

4. En Cloud Shell, reemplaza "Hello World" por "Hello Cloud Build" en la aplicación y en la prueba de unidades:

cd ~/hello-cloudbuild-app sed -i 's/Hello World/Hello Cloud Build/g' app.py sed -i 's/Hello World/Hello Cloud Build/g' test_app.py

5. Confirma y envía el cambio a Cloud Source Repositories:

git add app.py test_app.py git commit -m "Hello Cloud Build" git push google master

6. Esto activa la canalización de CI/CD completa.

Después de unos minutos, vuelve a cargar la aplicación en tu navegador. Ahora deberías ver "Hello Cloud Build!".

Haz clic en Revisar mi progreso para verificar el objetivo. Probar la canalización completa

Tarea 8: Prueba la reversión

En esta tarea, revertirás a la versión de la aplicación que decía “Hello World!”.

1. En la consola de Google Cloud, ve a Cloud Build > Panel.

2. Haz clic en el vínculo Ver todo en Historial de compilaciones para el repositorio hello-cloudbuild-env.

3. Haz clic en la segunda compilación más reciente disponible.

4. Haz clic en Reintentar compilación.

5. Cuando se termine la compilación, vuelve a cargar la aplicación en tu navegador.

Ahora deberías ver nuevamente "Hello World!".

Haz clic en Revisar mi progreso para verificar el objetivo. Probar la reversión

Finalice su lab

Cuando haya completado el lab, haga clic en Finalizar lab. Google Cloud Skills Boost quitará los recursos que usó y limpiará la cuenta.

Tendrá la oportunidad de calificar su experiencia en el lab. Seleccione la cantidad de estrellas que corresponda, ingrese un comentario y haga clic en Enviar.

La cantidad de estrellas indica lo siguiente:

• 1 estrella = Muy insatisfecho
• 2 estrellas = Insatisfecho
• 3 estrellas = Neutral
• 4 estrellas = Satisfecho
• 5 estrellas = Muy satisfecho

Puede cerrar el cuadro de diálogo si no desea proporcionar comentarios.

Para enviar comentarios, sugerencias o correcciones, use la pestaña Asistencia.

Copyright 2025 Google LLC. Todos los derechos reservados. Google y el logotipo de Google son marcas de Google LLC. El resto de los nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que están asociados.