GSP1077

Descripción general

En este lab, crearás una canalización de CI/CD que compile de forma automática una imagen de contenedor desde el código confirmado, la almacene en Artifact Registry, actualice un manifiesto de Kubernetes en un repositorio de Git y, luego, implemente la aplicación para 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 de aplicaciones, 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 de aplicaciones y los repositorios de variables de entorno se mantienen separados porque tienen distintos 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 específica, mientras que el repositorio app no.

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

• Lograr distinguir entre implementaciones fallidas y correctas observando el historial de Cloud Build.
• Acceder al manifiesto en uso en este momento observando la rama production del repositorio env.
• Efectuar una reversión a cualquier versión anterior mediante una nueva ejecución de la compilación correspondiente de Cloud Build

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

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs son cronometrados y no se pueden pausar. El cronómetro, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

Este lab práctico te permitirá realizar las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, se te proporcionan credenciales temporales nuevas que utilizarás para acceder a Google Cloud durante todo el lab.

Para completar este lab, necesitarás lo siguiente:

• Acceso a un navegador de Internet estándar (se recomienda el navegador Chrome)

Nota: Usa una ventana de navegador privada o de Incógnito para ejecutar este lab. Así evitarás cualquier conflicto entre tu cuenta personal y la cuenta de estudiante, lo que podría generar cargos adicionales en tu cuenta personal.

• Tiempo para completar el lab: Recuerda que, una vez que comienzas un lab, no puedes pausarlo.

Nota: Si ya tienes un proyecto o una cuenta personal de Google Cloud, no los uses en este lab para evitar cargos adicionales en tu cuenta.

Cómo iniciar tu lab y acceder a la consola de Google Cloud

1. Haga clic en el botón Comenzar lab. Si debe pagar por el lab, se abrirá una ventana emergente para que seleccione su forma de pago. A la izquierda, se encuentra el panel Detalles del lab, que tiene estos elementos:

   • El botón Abrir la consola de Google Cloud
   • El tiempo restante
   • Las credenciales temporales que debe usar para el lab
   • Otra información para completar el lab, si es necesaria

2. Haz clic en Abrir la consola de Google Cloud (o haz clic con el botón derecho y selecciona Abrir el vínculo en una ventana de incógnito si ejecutas el navegador Chrome).

   El lab inicia recursos y abre otra pestaña en la que se muestra la página de acceso.

   Sugerencia: Ordene las pestañas en ventanas separadas, una junto a la otra.

   Nota: Si ves el diálogo Elegir una cuenta, haz clic en Usar otra cuenta.

3. De ser necesario, copia el nombre de usuario a continuación y pégalo en el diálogo Acceder.

   {{{user_0.username | "Username"}}}

   También puedes encontrar el nombre de usuario en el panel Detalles del lab.

4. Haz clic en Siguiente.

5. Copia la contraseña que aparece a continuación y pégala en el diálogo Te damos la bienvenida.

   {{{user_0.password | "Password"}}}

   También puedes encontrar la contraseña en el panel Detalles del lab.

6. Haz clic en Siguiente.

   Importante: Debes usar las credenciales que te proporciona el lab. No uses las credenciales de tu cuenta de Google Cloud. Nota: Usar tu propia Cuenta de Google podría generar cargos adicionales.

7. Haga clic para avanzar por las páginas siguientes:

   • Acepta los Términos y Condiciones.
   • No agregues opciones de recuperación o autenticación de dos factores (esta es una cuenta temporal).
   • No te registres para obtener pruebas gratuitas.

Después de un momento, se abrirá la consola de Google Cloud en esta pestaña.

Nota: Para ver un menú con una lista de productos y servicios de Google Cloud, haz clic en el menú de navegación que se encuentra en la parte superior izquierda.

Activa Cloud Shell

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. Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.

1. Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.

Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu PROJECT_ID. El resultado contiene una línea que declara el PROJECT_ID para esta sesión:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con la función de autocompletado con tabulador.

2. Puedes solicitar el nombre de la cuenta activa con este comando (opcional):

gcloud auth list

3. Haz clic en Autorizar.

4. Ahora, el resultado debería verse de la siguiente manera:

Resultado:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. Puedes solicitar el ID del proyecto con este comando (opcional):

gcloud config list project

Resultado:

[core] project = <project_ID>

Resultado de ejemplo:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: Para obtener toda la documentación de gcloud, consulta la guía con la descripción general de gcloud CLI en Google Cloud.

Tarea 1. Inicializa tu lab

1. Establece el ID y número del proyecto en Cloud Shell. Guárdalos como variables PROJECT_ID y PROJECT_NUMBER:

export PROJECT_ID=$(gcloud config get-value project) export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)') export REGION={{{ project_0.default_region }}} gcloud config set compute/region $REGION

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.

2. Ejecuta el siguiente comando para que se habiliten 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

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

gcloud artifacts repositories create my-repository \ --repository-format=docker \ --location=$REGION

4. Crea un clúster de GKE para implementar la aplicación de ejemplo en este lab:

gcloud container clusters create hello-cloudbuild --num-nodes 1 --region $REGION

5. Si nunca usaste Git en Cloud Shell, configúralo con tu nombre y dirección de correo electrónico. Git los usará para identificarte como el autor de las confirmaciones que crearás en Cloud Shell (si no tienes una cuenta de GitHub, puedes completar este paso con tu información actual. No se necesita una cuenta para este lab):

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

Haz clic en Revisar mi progreso para verificar el objetivo. Habilitar servicios, crear un Artifact Registry y el clúster de GKE

Tarea 2: Crea repositorios de Git en Cloud Source Repositories

En esta tarea creas los dos repositorios de Git (hello-cloudbuild-app y hello-cloudbuild-env) y, luego, inicializas hello-cloudbuild-app con algún código de muestra.

1. Ejecuta lo siguiente en Cloud Shell para crear los dos repositorios de Git:

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

2. Clona el código de muestra desde GitHub:

cd ~ git clone https://github.com/GoogleCloudPlatform/gke-gitops-tutorial-cloudbuild hello-cloudbuild-app

3. Configura Cloud Source Repositories como remoto:

cd ~/hello-cloudbuild-app export REGION={{{project_0.default_region | "REGION"}}} sed -i "s/us-central1/$REGION/g" cloudbuild.yaml sed -i "s/us-central1/$REGION/g" cloudbuild-delivery.yaml sed -i "s/us-central1/$REGION/g" cloudbuild-trigger-cd.yaml sed -i "s/us-central1/$REGION/g" kubernetes.yaml.tpl PROJECT_ID=$(gcloud config get-value project) 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

Tarea 3. Cree 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 Artifact 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="${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 ejecutes este comando.

2. Luego de que finalice la compilación, en la consola de Cloud ve hacia Artifact Registry > Repositorios para verificar que tu nueva imagen de contenedor en efecto esté disponible en Artifact Registry. Haz clic en mi-repositorio.

Haz clic en Revisar mi progreso para verificar el objetivo. Crear la 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 una prueba de unidades pequeñas de forma automática, compilarás la imagen de contenedor y la enviarás a Artifact Registry. El envío de esta nueva confirmación a Cloud Source Repositories activa esta canalización de forma automática. El archivo cloudbuild.yaml ya incluido en el código es la configuración de la canalización.

1. En la consola de Cloud ve hacia Cloud Build > Activadores.
2. Haz clic en Crear activador.
3. En el campo Nombre, escribe hello-cloudbuild.
4. En Evento, selecciona Enviar a una rama.
5. Debajo de Fuente, elige hello-cloudbuild-app como tu Repositorio y .*(cualquier rama) 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. Haz clic en Crear.

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.

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

cd ~/hello-cloudbuild-app git add . git commit -m "Type Any Commit Message here" git push google master

10. En la consola de Cloud, ve hacia Cloud Build > Panel.

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

Luego 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 desarrollador del Identity and Access Management de Kubernetes Engine.

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

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. Todavía estará vacía.

2. En Cloud Shell, ejecuta el siguiente comando:

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

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

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.

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

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

Crea un activador para la canalización de entrega continua

1. En la consola de Cloud ve hacia 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. Bajo la Fuente, elige hello-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. Haz clic en Crear.

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

Luego, agrega algunos pasos a la canalización de integración continua. Estos generarán una nueva versión del manifiesto de Kubernetes y la enviarán 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 de aplicaciones.

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.

Esta canalización usa un sedsencillo para renderizar la plantilla del manifiesto. En realidad, se beneficiará 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 el entorno de pruebas y la canalización de CD

Tarea 6. Revisa las canalizaciones de Cloud Build

1. En la consola de Cloud, ve hacia Cloud Build > Panel.
2. Haz clic en el activador hello-cloudbuild-app para seguir esta ejecución y examinar los 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. Pruébala de punta a punta.

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

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.

2. Haz clic en el extremo del servicio hello-cloudbuild. Deberías ver "Hello World!". Si no existe el extremo, o si ve 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.

3. En Cloud Shell, reemplaza el “Hello World” por “Hello Cloud Build” tanto en la aplicación como 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

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

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

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

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 Cloud, ve hacia Cloud Build > Panel.
2. Haga 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 Volver a compilar.

Cuando se termine la compilación, vuelve a cargar la aplicación en tu navegador. Ahora deberías ver nuevamente “Hello World!”.

¡Felicitaciones!

Ahora puedes usar Cloud Build para crear y revertir las canalizaciones de la integración continua con GKE en Google Cloud.

Capacitación y certificación de Google Cloud

Recibe la formación que necesitas para aprovechar al máximo las tecnologías de Google Cloud. Nuestras clases incluyen habilidades técnicas y recomendaciones para ayudarte a avanzar rápidamente y a seguir aprendiendo. Para que puedas realizar nuestros cursos cuando más te convenga, ofrecemos distintos tipos de capacitación de nivel básico a avanzado: a pedido, presenciales y virtuales. Las certificaciones te ayudan a validar y demostrar tus habilidades y tu conocimiento técnico respecto a las tecnologías de Google Cloud.

Última actualización del manual: 26 de enero de 2024

Prueba más reciente del lab: 19 de enero de 2024

Copyright 2024 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.