GSP1077

Descripción general

Cloud Build es un servicio que ejecuta tus compilaciones en Google Cloud. Puede importar código fuente, ejecutar compilaciones y mucho más.

En este lab, crearás una canalización de integración continua y de implementación continua (CI/CD) que automáticamente compila una imagen de contenedor desde el código confirmado, la almacena en Artifact 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, usarás 2 repositorios de Git alojados en un servidor Git de Gitea dedicado y autoalojado (git-server):

• app: Contiene el código fuente de la aplicación (hello-cloudbuild-app).
• env: Contiene los manifiestos de implementación de Kubernetes (hello-cloudbuild-env).

Cuando envías un cambio al repositorio app, la canalización de Cloud Build ejecuta pruebas, compila una imagen de contenedor y envía el cambio a Artifact Registry. Después de enviar la imagen, Cloud Build actualiza el manifiesto de implementación 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 se mantienen separados porque tienen distintos ciclos de vida y usos. El repositorio app está dedicado a una aplicación específica y lo usan principalmente personas reales. El repositorio env puede ser compartido por varias aplicaciones y lo usan sistemas automatizados (como Cloud Build). El repositorio env puede tener varias ramas, cada una asignada a un entorno específico y que hace referencia a una imagen de contenedor determinada; este no es el caso del repositorio app.

Cuando termines este lab, tu sistema podrá realizar fácilmente las siguientes acciones:

• Lograr distinguir entre 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

Objetivos

En este lab, aprenderás a realizar las siguientes tareas:

• Crear clústeres de Kubernetes Engine
• Conectarse a un servidor Git dedicado y, luego, inicializar repositorios de Git
• Ejecutar canalizaciones de Cloud Build desde repositorios de código fuente
• 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 con Cloud Build

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs cuentan con un temporizador que no se puede pausar. El temporizador, 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 del navegador privada o de incógnito (opción recomendada) para ejecutar el lab. Así evitarás conflictos 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: Usa solo la cuenta de estudiante para este lab. Si usas otra cuenta de Google Cloud, es posible que se apliquen cargos a esa cuenta.

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

1. Haz clic en el botón Comenzar lab. Si debes pagar por el lab, se abrirá un diálogo para que selecciones la forma de pago. A la derecha, se encuentra el panel Configuración del lab y acceso, que tiene los siguientes elementos:

   • El botón Abrir la consola de Google Cloud
   • Las credenciales temporales (nombre de usuario y contraseña) que debes usar para este lab
   • Otra información para completar el lab (si es necesaria)

   Ten en cuenta que el cronómetro del lab se encuentra cerca de la parte superior de la página y muestra el tiempo restante.

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 los recursos y abre otra pestaña, en la que se muestra la página de acceso.

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

   Nota: Si ves el diálogo Elegir una cuenta, haz clic en Usa 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 Configuración del lab y acceso.

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 Configuración del lab y acceso.

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 Cloud para este lab podría generar cargos adicionales.

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

   • Acepta los Términos y Condiciones.
   • No agregues opciones de recuperación ni autenticación de dos factores, ya que esta cuenta es 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 acceder a los productos y servicios de Google Cloud, haz clic en el menú de navegación o escribe el nombre del servicio o producto en el campo Buscar.

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.

2. Haz clic para avanzar por las siguientes ventanas:

   • Continúa en la ventana de información de Cloud Shell.
   • Autoriza a Cloud Shell para que use tus credenciales para realizar llamadas a la API 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 {{{project_0.project_id | "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.

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

gcloud auth list

4. Haz clic en Autorizar.

Resultado:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} 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_0.project_id | "PROJECT_ID"}}} Nota: Para obtener toda la documentación de gcloud, en Google Cloud, consulta la guía con la descripción general de gcloud CLI.

Tarea 1: Inicializa tu lab

En esta tarea, configurarás tu entorno:

• Importa el ID del proyecto, el número del proyecto y la IP del servidor Git como variables.
• Habilita las APIs de GKE, Cloud Build, Secret Manager y Artifact Analysis.
• Crea un repositorio de Docker de Artifact Registry.
• Crea un clúster de GKE para implementar la aplicación de ejemplo de este lab.

1. En Cloud Shell, ejecuta el siguiente comando para establecer el ID y el número del proyecto, y la región:

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 export GIT_SERVER_IP=$(gcloud compute instances describe git-server --zone={{{ project_0.default_zone }}} --format='get(networkInterfaces[0].accessConfigs[0].natIP)') echo "Git Server IP is: ${GIT_SERVER_IP}"

2. Ejecuta el siguiente comando para habilitar las APIs de GKE, Cloud Build, Secret Manager y Artifact Analysis:

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

3. Crea un repositorio de Docker de 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=$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. Ejecuta el siguiente comando para configurar Git en Cloud Shell: git config --global user.name "giteaadmin" git config --global user.email "student@qwiklabs.net"

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

Tarea 2: Conéctate a los repositorios de Git en el servidor Git

En esta tarea, inicializarás los dos repositorios de Git (hello-cloudbuild-app y hello-cloudbuild-env) en tu servidor Git dedicado (git-server) y enviarás el código de muestra inicial.

1. Descarga el código de muestra de Cloud Storage:

cd ~ git clone http://${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-app.git

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)

Tarea 3: Crea una imagen de contenedor con Cloud Build

En esta tarea, con un Dockerfile existente, usarás Cloud Build para crear y almacenar una imagen de contenedor.

El código que clonaste previamente contiene el Dockerfile:

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

Con este Dockerfile, puedes usar Cloud Build para crear una imagen de contenedor y almacenarla 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 ejecutas el comando.

2. Una vez que finalice la compilación, en la barra de título de la consola de Google Cloud, escribe Artifact Registry en el campo Buscar y, luego, haz clic en Artifact Registry en los resultados de la búsqueda. Verifica que tu nueva imagen de contenedor esté disponible en Artifact Registry. Haz clic en my-repository para ver la imagen hello-cloudbuild en la lista Imagen.

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

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

En esta tarea, configurarás y ejecutarás Cloud Build para ejecutar automáticamente pruebas de unidades, compilar la imagen de contenedor y enviarla a Artifact Registry.

El archivo cloudbuild.yaml, ya incluido en el código, es la configuración de la canalización.

1. Confirma los cambios y envíalos al servidor Git:

cd ~/hello-cloudbuild-app git add . git commit -m "Trigger CI pipeline" git push http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-app.git main

2. Envía la compilación a Cloud Build con el siguiente comando:

gcloud builds submit --config=cloudbuild.yaml --substitutions=SHORT_SHA=$(git rev-parse --short=7 HEAD) .

3. En la consola de Google Cloud, busca Cloud Build y haz clic en Historial en el panel izquierdo. Puedes examinar el registro de ejecución de tu compilación de CI.

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

Tarea 5: Almacena el Secret de la clave SSH en Secret Manager

En este paso, almacenarás un Secret de clave privada en Secret Manager y otorgarás permisos de Cloud Build para acceder a Secret Manager.

Crea una clave SSH y almacénala en Secret Manager

1. En Cloud Shell, crea una clave SSH:

   mkdir -p ~/workingdir && cd ~/workingdir ssh-keygen -t rsa -b 4096 -N '' -f id_rsa -C "student@qwiklabs.net"

2. Almacena la clave SSH privada en Secret Manager ejecutando el siguiente comando en Cloud Shell:

gcloud secrets create ssh_key_secret --data-file=$HOME/workingdir/id_rsa

Como alternativa, puedes seguir estos pasos en la consola de Google Cloud: a. Primero, descarga id_rsa en tu computadora: en Cloud Shell, haz clic en Más () > Descargar archivo, ingresa workingdir/id_rsa y haz clic en Descargar. b. Busca Secret Manager y haz clic en Secret Manager. c. Haz clic en Crear Secret. d. Establece el Nombre como ssh_key_secret. e. En Valor secreto, selecciona Subir y sube el archivo id_rsa descargado. f. Haz clic en Crear Secret.

Otorga permiso a la cuenta de servicio para acceder a Secret Manager

Ejecuta el siguiente comando en Cloud Shell para otorgarle a la cuenta de servicio predeterminada de Compute Engine permiso para acceder a Secret Manager:

PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format='value(projectNumber)') gcloud projects add-iam-policy-binding ${PROJECT_NUMBER} \ --member=serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com \ --role=roles/secretmanager.secretAccessor

Haz clic en Revisar mi progreso para verificar el objetivo. Almacenar el Secret de la clave SSH en Secret Manager

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

También puedes usar Cloud Build 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 volviendo 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, debes modificar 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 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.

2. En Cloud Shell, descarga el código de muestra desde Cloud Storage:

cd ~ git clone http://${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git

3. En Cloud Shell, reemplaza el contenido de cloudbuild.yaml en el repositorio hello-cloudbuild-env ejecutando el siguiente comando:

cd ~/hello-cloudbuild-env cat <<'EOF' > cloudbuild.yaml # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. substitutions: _COMMIT_SHA: 'v1.0' steps: # This step deploys the new version of our container image # in the hello-cloudbuild Kubernetes Engine cluster. - name: 'gcr.io/cloud-builders/kubectl' id: Deploy args: - 'apply' - '-f' - 'kubernetes.yaml' env: - 'CLOUDSDK_COMPUTE_REGION={{{ project_0.default_region }}}' - 'CLOUDSDK_CONTAINER_CLUSTER=hello-cloudbuild' # This step copies the applied manifest to the production branch - name: 'gcr.io/cloud-builders/gcloud' id: Copy to production branch entrypoint: /bin/sh args: - '-c' - | set -x && \ git clone -b production http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git prod_repo && \ cd prod_repo && \ git config user.email "student@qwiklabs.net" && \ git config user.name "Cloud Build" && \ cp ../kubernetes.yaml kubernetes.yaml && \ git add kubernetes.yaml && \ git commit -m "Deployed manifest from commit $_COMMIT_SHA" && \ git push origin production options: logging: CLOUD_LOGGING_ONLY EOF sed -i "s/\${GIT_SERVER_IP}/$GIT_SERVER_IP/g" cloudbuild.yaml

Confirma y envía la actualización a hello-cloudbuild-env:

cd ~/hello-cloudbuild-env git checkout candidate git add cloudbuild.yaml git commit -m "Create cloudbuild.yaml for deployment" git push http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git candidate

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

Luego, actualiza la canalización de integración continua en hello-cloudbuild-app para generar una nueva versión del manifiesto de Kubernetes y enviarla a hello-cloudbuild-env con el objetivo de activar la canalización de CD.

1. En Cloud Shell, reemplaza cloudbuild.yaml en hello-cloudbuild-app y sustituye la IP de tu servidor Git ejecutando los siguientes comandos:

cd ~/hello-cloudbuild-app cat <<'EOF' > cloudbuild.yaml # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. substitutions: _SHORT_SHA: 'v1.0' _COMMIT_SHA: 'v1.0' steps: # This step runs the unit tests on the app - name: 'python:3.11-slim' id: Test entrypoint: /bin/sh args: - -c - 'pip install flask && python test_app.py -v' # This step builds the container image. - name: 'gcr.io/cloud-builders/docker' id: Build args: - 'build' - '-t' - '{{{ project_0.default_region }}}-docker.pkg.dev/$PROJECT_ID/my-repository/hello-cloudbuild:$_SHORT_SHA' - '.' # This step pushes the image to Artifact Registry - name: 'gcr.io/cloud-builders/docker' id: Push args: - 'push' - '{{{ project_0.default_region }}}-docker.pkg.dev/$PROJECT_ID/my-repository/hello-cloudbuild:$_SHORT_SHA' # This step clones the hello-cloudbuild-env repository - name: 'gcr.io/cloud-builders/gcloud' id: Clone env repo entrypoint: /bin/sh args: - '-c' - | git clone http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git && \ cd hello-cloudbuild-env && \ git checkout candidate && \ git config user.email "student@qwiklabs.net" && \ git config user.name "Cloud Build" # This step generates the new manifest - name: 'gcr.io/cloud-builders/gcloud' id: Generate manifest entrypoint: /bin/sh args: - '-c' - | sed "s/GOOGLE_CLOUD_PROJECT/${PROJECT_ID}/g" kubernetes.yaml.tpl | \ sed "s/COMMIT_SHA/${_SHORT_SHA}/g" > hello-cloudbuild-env/kubernetes.yaml # This step pushes the manifest back to hello-cloudbuild-env candidate branch - name: 'gcr.io/cloud-builders/gcloud' id: Push manifest entrypoint: /bin/sh args: - '-c' - | set -x && \ cd hello-cloudbuild-env && \ git add kubernetes.yaml && \ git commit -m "Deploying image {{{ project_0.default_region }}}-docker.pkg.dev/$PROJECT_ID/my-repository/hello-cloudbuild:${_SHORT_SHA} Built from commit ${_COMMIT_SHA} of repository hello-cloudbuild-app Author: $(git log --format='%an <%ae>' -n 1 HEAD)" && \ git push origin candidate options: logging: CLOUD_LOGGING_ONLY EOF sed -i "s/\${GIT_SERVER_IP}/$GIT_SERVER_IP/g" cloudbuild.yaml

2. Confirma las modificaciones, envíalas al servidor Git y manda la compilación de la canalización:

cd ~/hello-cloudbuild-app git add cloudbuild.yaml git commit -m "Trigger CD pipeline" git push http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-app.git main gcloud builds submit --config=cloudbuild.yaml --substitutions=_SHORT_SHA=$(git rev-parse --short=7 HEAD),_COMMIT_SHA=$(git rev-parse HEAD) .

Esto activa la canalización de integración continua en Cloud Build, que compila la imagen de la aplicación y envía un nuevo manifiesto kubernetes.yaml a tu repositorio hello-cloudbuild-env.

3. Extrae el manifiesto generado en hello-cloudbuild-env y activa la compilación de implementación de entrega continua (CD):

cd ~/hello-cloudbuild-env git pull http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git candidate gcloud builds submit --config=cloudbuild.yaml --substitutions=_COMMIT_SHA=$(git rev-parse HEAD) .

Haz clic en Revisar mi progreso para verificar el objetivo. Crear el entorno de pruebas y la canalización de CD

Tarea 7: Revisa la canalización de Cloud Build

En esta tarea, revisarás la canalización de Cloud Build en la consola.

1. En la consola, navega a Cloud Build > Historial.
2. Haz clic en la compilación más reciente para rastrear su ejecución y examinar sus registros.
3. Verifica que la canalización de compilación haya ejecutado todos los pasos correctamente.

Tarea 8: Prueba la canalización completa

Ya configuraste la canalización de CI/CD completa. En esta tarea, realizarás una prueba de extremo a extremo.

1. En la consola, en el menú de navegación (), haz clic en Kubernetes Engine > Puertas de enlace, Ingress y Services > Servicios.

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 ves un error del balanceador de cargas, es posible que debas esperar algunos minutos para que el balanceador de cargas se inicialice por completo. Si es necesario, haz clic en Actualizar para que la página se actualice.

3. En Cloud Shell, reemplaza "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 al servidor Git; luego, envía la compilación de CI:

git add app.py test_app.py git commit -m "Hello Cloud Build" git push http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-app.git main gcloud builds submit --config=cloudbuild.yaml --substitutions=_SHORT_SHA=$(git rev-parse --short=7 HEAD),_COMMIT_SHA=$(git rev-parse HEAD) .

5. Extrae el manifiesto actualizado en hello-cloudbuild-env y envía la compilación de la canalización de implementación para aplicar la nueva versión de la aplicación:

cd ~/hello-cloudbuild-env git pull http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git candidate gcloud builds submit --config=cloudbuild.yaml --substitutions=_COMMIT_SHA=$(git rev-parse HEAD) .

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

Tarea 9: 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 barra de título de la consola, escribe Panel de Cloud Build en el campo Buscar y, luego, haz clic en Cloud Build en los resultados de la búsqueda. Asegúrate de que el Historial esté seleccionado en el panel izquierdo.
2. Haz clic en la segunda compilación más reciente disponible en Historial de compilaciones.
3. Haz clic en Volver a compilar.

Cuando finalice 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: 20 de julio de 2026

Prueba más reciente del lab: 20 de julio de 2026

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