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

• app: contiene el código fuente de la aplicación
• env: contiene los manifiestos de implementación de Kubernetes

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 específica; el repositorio app no.

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 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 realizar las siguientes tareas:

• Crear clústeres de Kubernetes Engine
• Crear repositorios de GitHub
• Activar Cloud Build desde repositorios de GitHub.
• Automatizar 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 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 izquierda, se encuentra el panel Detalles del lab, que tiene estos elementos:

   • El botón para abrir la consola de Google Cloud
   • El tiempo restante
   • Las credenciales temporales que debes 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: Ordena 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 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 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 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 y el número del proyecto como variables.
• Habilita las APIs para 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 en este lab.

1. En Cloud Shell, ejecuta el siguiente comando para establecer el ID y el número del proyecto. 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

Luego, 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 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 y GitHub en Cloud Shell: curl -sS https://webi.sh/gh | sh gh auth login gh api user -q ".login" GITHUB_USERNAME=$(gh api user -q ".login") git config --global user.name "${GITHUB_USERNAME}" git config --global user.email "${USER_EMAIL}" echo ${GITHUB_USERNAME} echo ${USER_EMAIL}

Presiona INTRO para aceptar las opciones predeterminadas. Lee las instrucciones en la herramienta de la CLI para acceder a GitHub con un navegador web. Si accediste correctamente, se mostrará tu nombre de usuario de GitHub.

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 repositorios de GitHub

GitHub es una plataforma en la que puedes almacenar, compartir y trabajar con otras personas para escribir código. Git es un sistema de control de versiones. Cuando subes archivos a GitHub, los almacenas en un “repositorio de Git”. Esto significa que cuando haces cambios (o "confirmaciones") en tus archivos en GitHub, Git automáticamente comienza a hacer un seguimiento de los cambios y administrarlos. Para obtener más detalles, consulta Acerca de GitHub y Git.

En esta tarea crearás dos repositorios de Git (hello-cloudbuild-app y hello-cloudbuild-env) y, luego, inicializarás hello-cloudbuild-app con algún código de muestra.

1. Ejecuta los siguientes comandos en Cloud Shell para crear los dos repositorios de Git:

gh repo create hello-cloudbuild-app --private gh repo create hello-cloudbuild-env --private

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

cd ~ mkdir hello-cloudbuild-app gcloud storage cp -r gs://spls/gsp1077/gke-gitops-tutorial-cloudbuild/* hello-cloudbuild-app

3. Configura el repositorio de GitHub 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 init git config credential.helper gcloud.sh git remote add google https://github.com/${GITHUB_USERNAME}/hello-cloudbuild-app git branch -m master git add . && git commit -m "initial commit"

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.7-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 búsqueda 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 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. Enviar una nueva confirmación a los repositorios de GitHub 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 barra de búsqueda de la consola, escribe Cloud Build triggers en el campo Buscar y, luego, haz clic en Activadores, Cloud Build en los resultados de la búsqueda.

2. Haz clic en Crear activador.

3. En Nombre, escribe hello-cloudbuild. Establece la Región en .

4. Establece el Evento en Enviar a una rama.

5. En Fuente, en Repositorio, haz clic en Conectar repositorio nuevo.

   a. Selecciona GitHub (app de GitHub de Cloud Build). Haz clic en Continuar.

   b. Autentícate en tu repositorio de código fuente con tu nombre de usuario y contraseña.

   c. Si aparece la ventana emergente “La app de GitHub no está instalada en ninguno de tus repositorios”, sigue estos pasos.

   i. Click **Install Google Cloud Build**. Install the Cloud Build GitHub App in your personal account. Permit the installation using your GitHub account. ii. Under **Repository access**. Choose **Only select repositories**. Click the **Select the repositories** menu and select `${GITHUB_USERNAME}/hello-cloudbuild-app` and `${GITHUB_USERNAME}/hello-cloudbuild-env`. iii. Click **Install**.

   d. Selecciona ${GITHUB_USERNAME}/hello-cloudbuild-app para Repositorio. Haz clic en Aceptar.

   e. Acepta Entiendo que se transferirá el contenido de GitHub de los repositorios seleccionados...

   f. Haz clic en Conectar.

6. Si la app de GitHub de Cloud Build ya está instalada en tu cuenta, tendrás la opción de Editar repositorios en GitHub.

   a. En Acceso al repositorio, elige Solo repositorios seleccionados. Haz clic en el menú Selecciona repositorios y selecciona los repositorios **$${GITHUB_USERNAME}/hello-cloudbuild-app** y **$${GITHUB_USERNAME}/hello-cloudbuild-env**.

   b. Haz clic en Guardar.

7. En la página Activador, en la Lista de repositorios, haz clic en ${GITHUB_USERNAME}/hello-cloudbuild-app.

8. En Rama, escribe .* (cualquier rama).

9. En la sección Configuración, establece Tipo en Archivo de configuración de Cloud Build.

10. En el campo Ubicación, escribe cloudbuild.yaml después de /.

11. Establece Cuenta de servicio en la cuenta de servicio predeterminada de Compute Engine.

12. 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 los repositorios de GitHub para activar la canalización de CI en Cloud Build.

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

14. En el panel de la izquierda, haz clic en Panel.

15. 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: Accede a GitHub desde una compilación mediante claves SSH

En este paso, usa Secret Manager con Cloud Build para acceder a repositorios privados de GitHub.

Crea una clave SSH

1. En Cloud Shell, cambia al directorio principal.

   cd ~

2. Crea un directorio nuevo llamado workingdir y ve a él:

   mkdir workingdir cd workingdir

3. Crea una nueva clave SSH de GitHub y reemplaza [your-github-email] por tu dirección de correo electrónico personal de GitHub:

   ssh-keygen -t rsa -b 4096 -N '' -f id_github -C [your-github-email]

En este paso, se crean dos archivos: id_github y id_github.pub.

4. En la barra de acciones de Cloud Shell, haz clic en Más () y, luego, en Descargar > Activar o desactivar el navegador de archivos. Selecciona la carpeta dropdown y workingdir para descargar el archivo id_github en tu máquina local.

Almacena la clave SSH privada en Secret Manager

1. En la barra de búsqueda de la consola, escribe Secret Manager y, luego, haz clic en Secret Manager en los resultados de la búsqueda.

2. Haz clic en Crear secreto.

3. Establece el Nombre como ssh_key_secret.

4. Establece Valor secreto en Subir archivo y sube tu archivo id_github.

5. Deja el resto de la configuración con sus valores predeterminados.

6. Haz clic en Crear secreto.

Esto sube tu archivo id_github a Secret Manager.

Agrega la clave SSH pública a las claves de implementación de tu repositorio privado

1. Accede a tu cuenta personal de GitHub.

2. En la esquina superior derecha, haz clic en tu foto de perfil y, luego, en Your profile.

3. En tu página de perfil, haz clic en Repositories y, luego, en el repositorio hello-cloudbuild-env.

4. En tu repositorio, haz clic en Settings.

5. En el panel izquierdo, haz clic en Deploy Keys y, luego, en Add deploy key.

6. Proporciona el título SSH_KEY, pega tu clave SSH pública de workingdir/id_github.pub desde Cloud Shell.

7. Selecciona Allow write access para que esta clave tenga acceso de escritura al repositorio. Una clave de implementación con acceso de escritura permite que una implementación envíe contenido al repositorio.

8. Haz clic en Add key.

9. Borra la clave SSH de tu disco:

   rm id_github*

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

Ingresa el siguiente comando para darle acceso a Secret Manager a la cuenta de servicio:

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. Acceder a GitHub desde una compilación mediante claves SSH

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

1. En Cloud Shell, ejecuta el siguiente comando:

cd ~ 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, que aún está vacía.

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

mkdir hello-cloudbuild-env gcloud storage cp -r gs://spls/gsp1077/gke-gitops-tutorial-cloudbuild/* hello-cloudbuild-env cd hello-cloudbuild-env 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

3. Para que Cloud Build se conecte a GitHub, debes agregar la clave SSH pública al archivo known_hosts en el entorno de compilación de Cloud Build. En tu directorio hello-cloudbuild-env, crea un archivo llamado known_hosts.github, agrega la clave SSH pública a este archivo y otorga el permiso necesario al archivo:

cd ~/hello-cloudbuild-env ssh-keyscan -t rsa github.com > known_hosts.github chmod +x known_hosts.github git init git config credential.helper gcloud.sh git remote add google https://github.com/${GITHUB_USERNAME}/hello-cloudbuild-env git branch -m master git add . && git commit -m "initial commit" git push google master cd ~/hello-cloudbuild-env git checkout -b production

4. A continuación, reemplaza el archivo cloudbuild.yaml disponible en el repositorio hello-cloudbuild-env y confirma el cambio:

cd ~/hello-cloudbuild-env

5. Reemplaza el archivo cloudbuild.yaml en el repositorio hello-cloudbuild-env por el siguiente código. Reemplaza {GITHUB-USERNAME} por tu nombre de usuario personal de GitHub:

# 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. # [START cloudbuild-delivery] 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' # Access the id_github file from Secret Manager, and setup SSH - name: 'gcr.io/cloud-builders/git' secretEnv: ['SSH_KEY'] entrypoint: 'bash' args: - -c - | echo "$$SSH_KEY" >> /root/.ssh/id_rsa chmod 400 /root/.ssh/id_rsa cp known_hosts.github /root/.ssh/known_hosts volumes: - name: 'ssh' path: /root/.ssh # Clone the repository - name: 'gcr.io/cloud-builders/git' args: - clone - --recurse-submodules - git@github.com:${GITHUB-USERNAME}/hello-cloudbuild-env.git volumes: - name: ssh path: /root/.ssh # This step copies the applied manifest to the production branch # The COMMIT_SHA variable is automatically # replaced by Cloud Build. - name: 'gcr.io/cloud-builders/gcloud' id: Copy to production branch entrypoint: /bin/sh args: - '-c' - | set -x && \ cd hello-cloudbuild-env && \ git config user.email $(gcloud auth list --filter=status:ACTIVE --format='value(account)') sed "s/GOOGLE_CLOUD_PROJECT/${PROJECT_ID}/g" kubernetes.yaml.tpl | \ git fetch origin production && \ # Switch to the production branch and copy the kubernetes.yaml file from the candidate branch git checkout production && \ git checkout $COMMIT_SHA kubernetes.yaml && \ # Commit the kubernetes.yaml file with a descriptive commit message git commit -m "Manifest from commit $COMMIT_SHA $(git log --format=%B -n 1 $COMMIT_SHA)" && \ # Push the changes back to Cloud Source Repository git push origin production volumes: - name: ssh path: /root/.ssh availableSecrets: secretManager: - versionName: projects/${PROJECT_NUMBER}/secrets/ssh_key_secret/versions/1 env: 'SSH_KEY' # [END cloudbuild-delivery] options: logging: CLOUD_LOGGING_ONLY git add . git commit -m "Create cloudbuild.yaml for deployment"

El archivo cloudbuild.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.

6. Crea la rama candidate y envía ambas ramas para que estén disponibles en los repositorios de GitHub:

git checkout -b candidate git push google production git push google candidate

Crea un activador para la canalización de entrega continua

1. En la barra de búsqueda de la consola, escribe Cloud Build Triggers y, luego, haz clic en Activadores, Cloud Build.

2. Haz clic en Crear activador.

3. Establece el Nombre como hello-cloudbuild-deploy. Establece la Región en .

4. En Evento, selecciona Enviar a una rama.

5. En Fuente, en Repositorio, haz clic en Conectar repositorio nuevo.

   a. Selecciona GitHub (app de GitHub de Cloud Build). Haz clic en Continuar.

   b. Autentica el repositorio de código fuente con tu nombre de usuario y contraseña de GitHub.

   c. Selecciona el repositorio ${GITHUB_USERNAME}/hello-cloudbuild-env. Haz clic en Aceptar.

   d. Selecciona Entiendo que se transferirá el contenido de GitHub de los repositorios seleccionados...

   e. Haz clic en Conectar.

6. En Repositorio, selecciona ${GITHUB_USERNAME}/hello-cloudbuild-env.

7. En Fuente, selecciona ^candidate$ como tu Rama.

8. En Configuración de compilación, selecciona Archivo de configuración de Cloud Build.

9. En el campo Ubicación del archivo de configuración de Cloud Build, escribe cloudbuild.yaml después de /.

10. Establece la Cuenta de servicio en la cuenta de servicio predeterminada de Compute Engine.

11. Haz clic en Crear.

12. En tu directorio hello-cloudbuild-app, crea un archivo llamado known_hosts.github, agrega la clave SSH pública a este archivo y otorga el permiso necesario al archivo:

cd ~/hello-cloudbuild-app ssh-keyscan -t rsa github.com > known_hosts.github chmod +x known_hosts.github git add . git commit -m "Adding known_host file." git push google master

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.

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

cd ~/hello-cloudbuild-app

El archivo cloudbuild.yaml agrega los pasos que generan el nuevo manifiesto de Kubernetes y activan la canalización de entrega continua.

Configura la compilación

1. Reemplaza el archivo cloudbuild.yaml en el repositorio hello-cloudbuild-app por el siguiente código. Reemplaza ${GITHUB_USERNAME} por tu nombre de usuario de GitHub:

# 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. # [START cloudbuild] steps: # This step runs the unit tests on the app - name: 'python:3.7-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 # The PROJECT_ID and SHORT_SHA variables are automatically # replaced by Cloud Build. - 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' # [END cloudbuild] # Access the id_github file from Secret Manager, and setup SSH - name: 'gcr.io/cloud-builders/git' secretEnv: ['SSH_KEY'] entrypoint: 'bash' args: - -c - | echo "$$SSH_KEY" >> /root/.ssh/id_rsa chmod 400 /root/.ssh/id_rsa cp known_hosts.github /root/.ssh/known_hosts volumes: - name: 'ssh' path: /root/.ssh # Clone the repository - name: 'gcr.io/cloud-builders/git' args: - clone - --recurse-submodules - git@github.com:${GITHUB-USERNAME}/hello-cloudbuild-env.git volumes: - name: ssh path: /root/.ssh # [START cloudbuild-trigger-cd] # This step clones the hello-cloudbuild-env repository - name: 'gcr.io/cloud-builders/gcloud' id: Change directory entrypoint: /bin/sh args: - '-c' - | cd hello-cloudbuild-env && \ git checkout candidate && \ git config user.email $(gcloud auth list --filter=status:ACTIVE --format='value(account)') volumes: - name: ssh path: /root/.ssh # 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 volumes: - name: ssh path: /root/.ssh # This step pushes the manifest back to hello-cloudbuild-env - 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 volumes: - name: ssh path: /root/.ssh availableSecrets: secretManager: - versionName: projects/${PROJECT_NUMBER}/secrets/ssh_key_secret/versions/1 env: 'SSH_KEY' # [END cloudbuild-trigger-cd] options: logging: CLOUD_LOGGING_ONLY Nota: Esta canalización usa un comando sed sencillo para renderizar la plantilla del manifiesto. En realidad, te beneficiarás con el uso de herramientas dedicadas, como kustomize o skaffold, ya que permiten tener más control sobre la renderización de las plantillas de manifiesto.

2. Confirma las modificaciones y envíalas a los repositorios de GitHub:

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 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, aún en la página de Cloud Build, haz clic en Panel en el panel izquierdo.
2. Haz clic en el activador hello-cloudbuild-app para seguir su 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 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 Service > 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 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 los repositorios de GitHub:

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, 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 búsqueda de la consola, escribe Cloud Build Dashboard en el campo Buscar y, luego, haz clic en Cloud Build en los resultados de la búsqueda. Asegúrate de que el Panel esté seleccionado en el panel izquierdo.
2. Haz clic en el vínculo Ver todo en el 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: 19 de febrero de 2025

Prueba más reciente del lab: 19 de febrero de 2025

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