Descripción general

En este lab, compilarás una imagen de contenedor de Docker a partir del código proporcionado y un Dockerfile con Cloud Build. Luego, subirás el contenedor a Artifact Registry.

Objetivos

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

• Usar Cloud Build para compilar y enviar contenedores
• Usar Artifact Registry para almacenar e implementar contenedores

Configuración del lab

Accede al lab

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

1. Haz clic en el botón Comenzar lab. Si debes pagar por el lab, se abrirá una ventana emergente para que selecciones tu 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 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. 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 o escribe el nombre del servicio o producto en el campo Búsqueda.

Después de completar los pasos iniciales de acceso, se abrirá 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. Confirma que estén habilitadas las APIs necesarias

1. Anota el nombre de tu proyecto de Google Cloud. Este valor se muestra en la barra superior de la consola de Google Cloud. Comenzará con qwiklabs-gcp-, seguido de números hexadecimales.

2. En la consola de Google Cloud, en el menú de navegación(), haz clic en APIs y servicios.

3. Haz clic en Biblioteca.

4. En el recuadro Buscar APIs y servicios, escribe Cloud Build.

5. En la tarjeta resultante de la API de Cloud Build, si no ves un mensaje que confirme que está habilitada la API, haz clic en el botón Habilitar.

6. Usa el botón Atrás para volver a la pantalla anterior con un cuadro de búsqueda. En el cuadro de búsqueda, escribe Artifact Registry.

7. En la tarjeta resultante de la API de Google Artifact Registry, si no ves un mensaje que confirme que está habilitada la API, haz clic en el botón Habilitar.

Tarea 2. Compila contenedores con Dockerfile y Cloud Build

Puedes escribir archivos de configuración de compilación para brindar instrucciones a Cloud Build sobre qué tareas realizar cuando se compila un contenedor. Estos archivos de compilación se pueden usar para recuperar dependencias, ejecutar pruebas de unidades, realizar análisis y mucho más. En esta tarea, crearás un Dockerfile y lo usarás como una secuencia de comandos de configuración de compilación con Cloud Build. También crearás una secuencia de comandos de shell simple (quickstart.sh), que representará una aplicación dentro del contenedor.

1. En la barra de título de la consola de Google Cloud, haz clic en Activar Cloud Shell.

2. Cuando se te solicite, haz clic en Autorizar.

Cloud Shell se abrirá en la parte inferior de la ventana de la consola de Google Cloud.

3. Crea un archivo quickstart.sh vacío con el editor de texto nano:

nano quickstart.sh

4. Agrega las siguientes líneas al archivo quickstart.sh:

#!/bin/sh echo "Hello, world! The time is $(date)."

5. Guarda el archivo y cierra nano presionando las teclas CTRL + X. Luego, presiona Y seguido de INTRO.

6. Crea un archivo Dockerfile vacío con el editor de texto nano:

nano Dockerfile

7. Agrega el siguiente comando de Dockerfile:

FROM alpine

Esto le indica a la compilación que use la imagen base de Alpine Linux.

8. Agrega el siguiente comando al final del Dockerfile:

COPY quickstart.sh /

Esto agrega la secuencia de comandos quickstart.sh al directorio / de la imagen.

9. Agrega el siguiente comando al final del Dockerfile:

CMD ["/quickstart.sh"]

Esto configura la imagen para ejecutar la secuencia de comandos /quickstart.sh cuando se crea y se ejecuta el contenedor asociado.

Ahora, el Dockerfile debería verse de la siguiente manera:

FROM alpine COPY quickstart.sh / CMD ["/quickstart.sh"]

10. Guarda el archivo y cierra nano presionando las teclas CTRL + X. Luego, presiona Y seguido de INTRO.

11. En Cloud Shell, ejecuta el siguiente comando para hacer que la secuencia de comandos quickstart.sh sea ejecutable:

chmod +x quickstart.sh

12. Crea un nuevo repositorio de Docker llamado quickstart-docker-repo en la ubicación y con la descripción “Docker repository”:

gcloud artifacts repositories create quickstart-docker-repo --repository-format=docker \ --location={{{project_0.default_region | "REGION"}}} --description="Docker repository"

13. En Cloud Shell, ejecuta el siguiente comando para compilar la imagen de contenedor de Docker en Cloud Build:

gcloud builds submit --tag {{{project_0.default_region | "REGION"}}}-docker.pkg.dev/${DEVSHELL_PROJECT_ID}/quickstart-docker-repo/quickstart-image:tag1

Cuando se completa la compilación, tu imagen de Docker compilada se envía a Artifact Registry.

14. En la consola de Google Cloud, ve a la barra de búsqueda (ubicada en la parte superior de la ventana de la consola) y busca Artifact Registry.

15. Haz clic en el repositorio llamado quickstart-docker-repo.

La imagen de Docker quickstart-image aparecerá en la lista.

Tarea 3. Compila contenedores con un archivo de configuración de compilación y Cloud Build

Cloud Build también admite archivos de configuración de compilación personalizados. En esta tarea, incorporarás un contenedor de Docker existente usando un archivo de compilación personalizado con formato YAML con Cloud Build.

Creemos un archivo de configuración de Cloud Build personalizado de muestra llamado cloudbuild.yaml.

1. Crea y abre un archivo llamado cloudbuild.yaml con nano usando el siguiente comando:

nano cloudbuild.yaml

2. Una vez que nano se abra, pega lo siguiente en el archivo cloudbuild.yaml:

steps: - name: 'gcr.io/cloud-builders/docker' args: [ 'build', '-t', 'YourRegionHere-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1', '.' ] images: - 'YourRegionHere-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1'

3. Presiona Ctrl + O y, luego, Intro para guardar el archivo editado.

4. Presiona Ctrl + X para salir del editor de texto nano.

5. Ejecuta el siguiente comando para configurar nuestra variable de región y, luego, inserta ese valor en el archivo YAML.

export REGION={{{project_0.default_region | "REGION"}}} sed -i "s/YourRegionHere/$REGION/g" cloudbuild.yaml

6. En Cloud Shell, ejecuta el siguiente comando para ver el contenido de cloudbuild.yaml.

cat cloudbuild.yaml

Verás lo siguiente:

steps: - name: 'gcr.io/cloud-builders/docker' args: [ 'build', '-t', '{{{project_0.default_region | "REGION"}}}-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1', '.' ] images: - '{{{project_0.default_region | "REGION"}}}-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1'

Este archivo le indica a Cloud Build que use Docker para compilar una imagen con la especificación del Dockerfile en el directorio local actual, que la etiquete con gcr.io/$PROJECT_ID/quickstart-image ($PROJECT_ID es una variable de sustitución que Cloud Build completa automáticamente con el ID del proyecto asociado) y que, luego, envíe esa imagen a Artifact Registry.

7. En Cloud Shell, ejecuta el siguiente comando para iniciar Cloud Build usando cloudbuild.yaml como el archivo de configuración de compilación:

gcloud builds submit --config cloudbuild.yaml

El resultado de la compilación en Cloud Shell debería ser el mismo que antes. Cuando se completa la compilación, se envía una versión nueva de la misma imagen a Artifact Registry.

8. En la consola de Google Cloud, ve a la barra de búsqueda (ubicada en la parte superior de la ventana de la consola) y busca Artifact Registry.

9. En los resultados de la búsqueda, haz clic en Artifact Registry.

10. Haz clic en el repositorio llamado quickstart-docker-repo > quickstart-image.

Ahora habrá dos versiones de quickstart-image en la lista.

Haz clic en Revisar mi progreso para verificar el objetivo. Compilar dos imágenes de contenedor en Cloud Build

11. En la consola de Google Cloud, ve a la barra de búsqueda (ubicada en la parte superior de la ventana de la consola) y busca Cloud Build.

12. En los resultados de la búsqueda, haz clic en Cloud Build.

13. En Cloud Build, haz clic en Historial. Aparecerán dos compilaciones en la lista.

14. Haz clic en el ID de la compilación que se encuentra al principio de la lista. Se muestran los detalles de la compilación, incluido su registro.

Tarea 4. Compila y prueba contenedores con un archivo de configuración de compilación y Cloud Build

El verdadero poder de los archivos de configuración de compilación personalizados es su capacidad de realizar otras acciones, en paralelo o en secuencia, además de solo compilar contenedores: ejecutar pruebas en tus contenedores recientemente compilados, enviarlos a varios destinos y, también, implementarlos en Kubernetes Engine.

En esta tarea, veremos un ejemplo simple; un archivo de configuración de compilación que prueba el contenedor que compiló y, luego, informa el resultado a su entorno de llamada. El primer paso es modificar el archivo quickstart.sh.

1. En Cloud Shell, abre quickstart.sh en nano.

   nano quickstart.sh

2. Reemplaza lo existente por lo siguiente:

#!/bin/sh if [ -z "$1" ] then echo "Hello, world! The time is $(date)." exit 0 else exit 1 fi

3. Presiona Ctrl + O y, luego, Intro para guardar el archivo editado.

4. Presiona Ctrl + X para salir del editor de texto nano.

Creemos un nuevo archivo de configuración de Cloud Build personalizado llamado cloudbuild2.yaml. Esto se modificó ligeramente para demostrar la capacidad de Cloud Build para probar los contenedores que compiló.

1. Crea y abre un archivo llamado cloudbuild2.yaml con nano usando el siguiente comando:

nano cloudbuild2.yaml

2. Una vez que nano se abra, pega lo siguiente en el archivo cloudbuild2.yaml:

steps: - name: 'gcr.io/cloud-builders/docker' args: [ 'build', '-t', 'YourRegionHere-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1', '.' ] - name: 'YourRegionHere-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1' args: ['fail'] images: - 'YourRegionHere-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1'

3. Presiona Ctrl + O y, luego, Intro para guardar el archivo editado.

4. Presiona Ctrl + X para salir del editor de texto nano.

5. Ejecuta el siguiente comando para insertar el valor de nuestra región en el archivo YAML.

sed -i "s/YourRegionHere/$REGION/g" cloudbuild2.yaml

6. En Cloud Shell, ejecuta el siguiente comando para ver el contenido de cloudbuild2.yaml:

cat cloudbuild2.yaml

Verás lo siguiente:

steps: - name: 'gcr.io/cloud-builders/docker' args: [ 'build', '-t', '{{{project_0.default_region | "REGION"}}}-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1', '.' ] - name: 'gcr.io/$PROJECT_ID/quickstart-image' args: ['fail'] images: - '{{{project_0.default_region | "REGION"}}}-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1'

Además de sus acciones anteriores, este archivo de configuración de compilación ejecuta la imagen quickstart-image que creó. En esta tarea, se modificó la secuencia de comandos quickstart.sh para que simule una prueba fallida cuando se le pasa un argumento ['fail'].

7. En Cloud Shell, ejecuta el siguiente comando para iniciar Cloud Build usando cloudbuild.yaml como el archivo de configuración de compilación:

gcloud builds submit --config cloudbuild2.yaml

Verás el resultado del comando, que finaliza con un texto como el siguiente:

Resultado

BUILD FAILURE: Build step failure: build step 1 "us-east1-docker.pkg.dev/qwiklabs-gcp-02-1c7ba5c697a0/quickstart-docker-repo/quickstart-image:tag1" failed: starting step container failed: Error response from daemon: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: exec: "fail": executable file not found in $PATH: unknown ERROR: (gcloud.builds.submit) build 96c4a454-be06-4010-aa7c-da57c14165f4 completed with status "FAILURE"

8. Confirma que tu shell de comandos detecte que no se pudo realizar la compilación:

echo $?

El comando responderá con un valor distinto de cero. Si hubieras incorporado esta compilación a una secuencia de comandos, tu secuencia podría responder de manera inesperada ante el error en la compilación.

Haz clic en Revisar mi progreso para verificar el objetivo. Compilar y probar contenedores con un archivo de configuración de compilación y Cloud Build

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