GSP055

Descripción general

Docker es una plataforma abierta para desarrollar, enviar y ejecutar aplicaciones. Permite separar las aplicaciones de la infraestructura y tratar a la infraestructura como una aplicación administrada. Docker ayuda a enviar, implementar y probar código más rápido y a acortar el ciclo entre su escritura y ejecución.

Para esto, combina las funciones de creación de contenedores de kernel con flujos de trabajo y herramientas que ayudan a implementar y administrar aplicaciones.

Los contenedores de Docker pueden usarse directamente en Kubernetes, lo que permite ejecutarlos de manera sencilla en Kubernetes Engine. Después de aprender los aspectos esenciales de Docker, contarás con las habilidades para empezar a desarrollar aplicaciones de Kubernetes y alojadas en contenedores.

Objetivos

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

• Compilar, ejecutar y depurar contenedores de Docker
• Extraer imágenes de Docker desde Docker Hub y Google Artifact Registry
• Enviar imágenes de Docker a Google Artifact Registry

Requisitos previos

Este es un lab de nivel introductorio. Parte de la suposición de que la experiencia en Docker y contenedores que tiene el alumno es escasa o nula. Contar con conocimientos de Cloud Shell y la línea de comandos es recomendable, pero no es obligatorio.

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

1. En Cloud Shell, escribe el comando siguiente para ejecutar un contenedor de Hello World y empezar.

docker run hello-world

(Resultado del comando)

Unable to find image 'hello-world:latest' locally latest: Pulling from library/hello-world 9db2ca6ccae0: Pull complete Digest: sha256:4b8ff392a12ed9ea17784bd3c9a8b1fa3299cac44aca35a85c90c5e3c7afacdc Status: Downloaded newer image for hello-world:latest Hello from Docker! This message shows that your installation appears to be working correctly. ...

Este contenedor simple muestra Hello from Docker! en la pantalla. Si bien el comando es simple, observa en el resultado la cantidad de pasos que ejecutó. El daemon de Docker buscó la imagen hello-world a nivel local, pero no la encontró. Luego, extrajo la imagen desde un registro público llamado Docker Hub, creó un contenedor a partir de esa imagen y ejecutó el contenedor por ti.

2. Ejecuta el comando siguiente para consultar la imagen del contenedor que se extrajo de Docker Hub:

docker images

(Resultado del comando)

REPOSITORY TAG IMAGE ID CREATED SIZE hello-world latest feb5d9fea6a5 14 months ago 13.3kB

Esta es la imagen extraída del registro público Docker Hub. El ID de imagen está en formato hash SHA256. Este campo especifica la imagen de Docker que se aprovisionó. Cuando el daemon de Docker no puede encontrar una imagen a nivel local, la busca en el registro público de forma predeterminada.

3. Vuelve a ejecutar el contenedor:

docker run hello-world

(Resultado del comando)

Hello from Docker! This message shows that your installation appears to be working correctly. To generate this message, Docker took the following steps: ...

Ten en cuenta que, la segunda vez que ejecutas esto, el daemon de Docker encontrará la imagen en tu registro local y ejecutará el contenedor a partir de ella. No es necesario extraer la imagen de Docker Hub.

4. Por último, ejecuta el comando siguiente para observar los contenedores que están en ejecución:

docker ps

(Resultado del comando)

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

No hay contenedores en ejecución. Ya saliste de los contenedores de hello-world que ejecutaste con anterioridad.

5. Para ver todos los contenedores, incluso los que terminaron de ejecutarse, ejecuta docker ps -a:

docker ps -a

(Resultado del comando)

CONTAINER ID IMAGE COMMAND ... NAMES 6027ecba1c39 hello-world "/hello" ... elated_knuth 358d709b8341 hello-world "/hello" ... epic_lewin

Aquí se muestra el Container ID, un UUID que genera Docker para identificar el contenedor, junto con otros metadatos de la ejecución. En Names, se muestran los nombres de los contenedores que también se generan de forma aleatoria, pero se pueden especificar con el comando docker run --name [container-name] hello-world.

Tarea 2: Compilación

En esta sección, compilarás una imagen de Docker basada en una aplicación de nodo sencilla.

1. Ejecuta el comando siguiente para crear una carpeta llamada test y cambiar a ella.

mkdir test && cd test

2. Crea un Dockerfile:

cat > Dockerfile <<EOF # Use an official Node runtime as the parent image FROM node:lts # Set the working directory in the container to /app WORKDIR /app # Copy the current directory contents into the container at /app ADD . /app # Make the container's port 80 available to the outside world EXPOSE 80 # Run app.js using node when the container launches CMD ["node", "app.js"] EOF

Este archivo le indica al daemon de Docker cómo compilar la imagen.

• La línea inicial especifica la imagen superior base que, en este caso, es la imagen de Docker oficial de la versión con asistencia a largo plazo (LTS) del nodo.
• En la segunda, configuras el directorio de trabajo (actual) del contenedor.
• En la tercera, agregas el contenido del directorio actual (indicado por ".") al contenedor.
• Luego, expones el puerto del contenedor, de manera que acepte conexiones en ese puerto. Por último, ejecutas el comando del nodo para iniciar la aplicación.

Nota: Revisa las referencias de los comandos de Dockerfile para comprender cada línea del Dockerfile.

Ahora, escribirás la aplicación del nodo y, después, compilarás la imagen.

3. Ejecuta los comandos siguientes para crear la aplicación del nodo:

cat > app.js << EOF; const http = require("http"); const hostname = "0.0.0.0"; const port = 80; const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader("Content-Type", "text/plain"); res.end("Hello World\n"); }); server.listen(port, hostname, () => { console.log("Server running at http://%s:%s/", hostname, port); }); process.on("SIGINT", function () { console.log("Caught interrupt signal and will exit"); process.exit(); }); EOF

Este es un servidor HTTP simple que escucha en el puerto 80 y muestra “Hello World”.

Ahora, compila la imagen.

4. Observa otra vez que está el “.”, que hace referencia al directorio actual. Por ello, debes ejecutar este comando desde el directorio en el que se encuentra el Dockerfile:

docker build -t node-app:0.1 .

Es posible que este comando tarde un par de minutos en terminar de ejecutarse. Cuando termine, el resultado debería ser similar al siguiente:

+] Building 0.7s (8/8) FINISHED docker:default => [internal] load .dockerignore 0.0s => => transferring context: 2B 0.0s => [internal] load build definition from Dockerfile 0.0s => => transferring dockerfile: 397B 0.0s => [internal] load metadata for docker.io/library/node:lts

La marca -t es para otorgar un nombre y una etiqueta a una imagen con la sintaxis name:tag. El nombre de la imagen es node-app y la etiqueta es 0.1. Se recomienda usar etiquetas cuando se compilan imágenes de Docker. Si no especificas una etiqueta, por configuración predeterminada será latest y será más difícil distinguir las imágenes más recientes de las anteriores. Además, observa que cada línea del Dockerfile anterior genera capas intermedias del contenedor a medida que se compila la imagen.

5. Ahora, ejecuta el comando siguiente para observar las imágenes que compilaste:

docker images

El resultado debería ser similar al siguiente:

REPOSITORY TAG IMAGE ID CREATED SIZE node-app 0.1 f166cd2a9f10 25 seconds ago 656.2 MB node lts 5a767079e3df 15 hours ago 656.2 MB hello-world latest 1815c82652c0 6 days ago 1.84 kB

Ten en cuenta que node es la imagen base, y node-app es la imagen que compilaste. No se puede quitar node si no quitas primero node-app. El tamaño de la imagen es relativamente pequeño en comparación con las VMs. Otras versiones de la imagen del nodo, como node:slim y node:alpine pueden proporcionar imágenes aún más pequeñas para facilitar la portabilidad. El tema de reducir los tamaños de los contenedores se explora más a fondo en los temas avanzados. Puedes ver todas las versiones en el repositorio oficial del nodo.

Tarea 3: Realiza la ejecución

1. Usa este código para ejecutar contenedores basados en la imagen que compilaste:

docker run -p 4000:80 --name my-app node-app:0.1

(Resultado del comando)

Server running at http://0.0.0.0:80/

La marca --name permite asignar un nombre al contenedor, si así lo deseas. La marca -p indica a Docker que asigne el puerto 4000 del host al puerto 80 del contenedor. Ahora puedes alcanzar el servidor en http://localhost:4000. Sin la asignación de puertos, no podrás alcanzar el contenedor en localhost.

2. Abre otra terminal (en Cloud Shell, haz clic en el ícono +) y prueba el servidor:

curl http://localhost:4000

(Resultado del comando)

Hello World

El contenedor se ejecutará mientras se esté ejecutando la terminal inicial. Si quieres que el contenedor se ejecute en segundo plano (no vinculado a la sesión de la terminal), debes especificar la marca -d.

3. Cierra la terminal inicial y, luego, ejecuta el comando siguiente para detener y quitar el contenedor:

docker stop my-app && docker rm my-app

4. Ahora, ejecuta el comando siguiente para iniciar el contenedor en segundo plano:

docker run -p 4000:80 --name my-app -d node-app:0.1 docker ps

(Resultado del comando)

CONTAINER ID IMAGE COMMAND CREATED ... NAMES xxxxxxxxxxxx node-app:0.1 "node app.js" 16 seconds ago ... my-app

5. Observa que el contenedor se ejecuta en el resultado de docker ps. Para ver los registros, ejecuta docker logs [container_id].

Nota: No es necesario que escribas el ID completo del contenedor, siempre y cuando los caracteres iniciales identifiquen el contenedor de manera inequívoca. Por ejemplo, puedes ejecutar docker logs 17b si el ID del contenedor es 17bcaca6f… docker logs [container_id]

(Resultado del comando)

Server running at http://0.0.0.0:80/

Ahora, modifica la aplicación.

1. En Cloud Shell, abre el directorio de prueba que creaste con anterioridad en el lab:

cd test

2. Edita app.js con el editor de texto que prefieras (por ejemplo, nano o vim) y reemplaza “Hello World” por otra cadena:

.... const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); res.end('Welcome to Cloud\n'); }); ....

3. Compila esta imagen nueva y agrégale la etiqueta 0.2:

docker build -t node-app:0.2 .

(Resultado del comando)

[+] Building 0.7s (8/8) FINISHED docker:default => [internal] load .dockerignore 0.0s => => transferring context: 2B 0.0s => [internal] load build definition from Dockerfile 0.0s => => transferring dockerfile: 397B 0.0s => [internal] load metadata for docker.io/library/node:lts 0.5s

Ten en cuenta que, en el paso 2, se usa una capa de caché existente. A partir del paso 3, las capas se modifican debido a que hiciste un cambio en app.js.

4. Ejecuta otro contenedor con la nueva versión de la imagen. Observa cómo asignamos el puerto 8080 del host, en vez del 80. No se puede usar el puerto 4000 del host porque ya está en uso.

docker run -p 8080:80 --name my-app-2 -d node-app:0.2 docker ps

(Resultado del comando)

CONTAINER ID IMAGE COMMAND CREATED xxxxxxxxxxxx node-app:0.2 "node app.js" 53 seconds ago ... xxxxxxxxxxxx node-app:0.1 "node app.js" About an hour ago ...

5. Prueba los contenedores con el comando siguiente:

curl http://localhost:8080

(Resultado del comando)

Welcome to Cloud

6. Ahora, prueba el primer contenedor que creaste con el siguiente comando:

curl http://localhost:4000

(Resultado del comando)

Hello World

Tarea 4: Depuración

Ahora que te familiarizaste con la creación y ejecución de contenedores, revisa las prácticas de depuración.

1. Para ver los registros de un contenedor, usa docker logs [container_id]. Si quieres seguir los resultados del registro mientras se ejecuta el contenedor, usa la opción -f.

docker logs -f [container_id]

(Resultado del comando)

Server running at http://0.0.0.0:80/

En algunos casos, necesitarás iniciar una sesión de Bash interactiva dentro del contenedor en ejecución.

2. Puedes usar docker exec para hacerlo. Abre otra terminal (en Cloud Shell, haz clic en el ícono +) y, luego, ingresa el comando siguiente:

docker exec -it [container_id] bash

Las marcas -it permiten interactuar con un contenedor, ya que asignan un seudo-TTY y mantienen stdin abierto. Observa que Bash se ejecutó en el directorio WORKDIR (/app) especificado en el Dockerfile. A partir de aquí, tienes una sesión de shell interactiva dentro del contenedor que depurarás.

(Resultado del comando)

root@xxxxxxxxxxxx:/app#

3. Observa el directorio con el comando siguiente:

ls

(Resultado del comando)

Dockerfile app.js

4. Sal de la sesión de Bash:

exit

5. Para examinar los metadatos de un contenedor en Docker, usa Docker inspect:

docker inspect [container_id]

(Resultado del comando)

[ { "Id": "xxxxxxxxxxxx....", "Created": "2017-08-07T22:57:49.261726726Z", "Path": "node", "Args": [ "app.js" ], ...

6. Usa --format para inspeccionar campos específicos del JSON que se devuelve. Por ejemplo:

docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' [container_id]

(Resultado de ejemplo)

192.168.9.3

Asegúrate de consultar los recursos siguientes de la documentación de Docker para conocer más sobre la depuración:

• Referencia de Docker inspect
• Referencia de Docker exec

Tarea 5: Publicación

Ahora enviarás la imagen a Google Artifact Registry. Después, quitarás todos los contenedores y las imágenes para simular un entorno nuevo, y extraerás los contenedores y los ejecutarás. Esto demostrará la portabilidad de los contenedores de Docker.

Para enviar imágenes a tu registro privado alojado en Artifact Registry, debes etiquetar las imágenes con el nombre de un registro. El formato debe ser <repositorio-regional>-docker.pkg.dev/mi-proyecto/mi-repositorio/mi-imagen.

Crea el repositorio de Docker de destino (con la consola de Cloud)

Debes crear un repositorio para poder enviarle imágenes. El envío de una imagen no activa la creación de un repositorio y la cuenta de servicio de Cloud Build no tiene permisos para crear repositorios.

1. En el Menú de navegación, en CI/CD navega a Artifact Registry > Repositorios.

2. Haz clic en el ícono + CREAR REPOSITORIO junto a los repositorios.

3. Asigna el nombre my-repository al repositorio.

4. Elige Docker como formato.

5. En Tipo de ubicación, elige Región y, luego, la ubicación: .

6. Haz clic en Crear.

Configura la autenticación

Antes de poder enviar o extraer imágenes, debes configurar Docker para que use Google Cloud CLI con el objetivo de autenticar las solicitudes enviadas a Artifact Registry.

1. Para configurar la autenticación en los repositorios de Docker de la región , ejecuta el comando siguiente en Cloud Shell:

gcloud auth configure-docker {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev

2. Escribe Y cuando se te solicite.

El comando actualiza tu configuración de Docker. Ahora puedes conectarte con Artifact Registry en tu proyecto de Google Cloud para enviar y extraer imágenes.

Nota: También puedes usar gcloud CLI para obtener un enfoque de línea de comandos optimizado.

Crea un repositorio de Artifact Registry (con la CLI)

1. Ejecuta los siguientes comandos para crear un repositorio de artefactos.

gcloud artifacts repositories create my-repository --repository-format=docker --location={{{ project_0.default_region | "REGION" }}} --description="Docker repository" Nota: Cuando realizas llamadas a la API de Google Cloud o usas una herramienta de línea de comandos que requiere credenciales (como gcloud CLI, BigQuery o gsutil) con Cloud Shell por primera vez, este servicio te muestra un mensaje con el diálogo Autorizar Cloud Shell. Para permitir que la herramienta use tus credenciales para realizar llamadas, haz clic en Autorizar.

Envía el contenedor a Artifact Registry

1. Cambia al directorio con tu Dockerfile.

cd ~/test

2. Ejecuta el comando para etiquetar node-app:0.2.

docker build -t {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id | "PROJECT_ID" }}}/my-repository/node-app:0.2 .

3. Ejecuta el comando siguiente para revisar tus imágenes de Docker compiladas.

docker images

(Resultado del comando)

REPOSITORY TAG IMAGE ID CREATED node-app 0.2 76b3beef845e 22 hours {{{project_0.default_region | "REGION"}}}-....node-app:0.2 0.2 76b3beef845e 22 hours node-app 0.1 f166cd2a9f10 26 hours node lts 5a767079e3df 7 days hello-world latest 1815c82652c0 7 weeks

4. Envía esta imagen a Artifact Registry.

docker push {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id | "PROJECT_ID" }}}/my-repository/node-app:0.2

Resultado del comando (el tuyo puede variar):

The push refers to a repository [{{{project_0.default_region | "REGION"}}}-docker.pkg.dev/{{{project_0.project_id | "PROJECT_ID"}}}/my-repository/node-app:0.2] 057029400a4a: Pushed 342f14cb7e2b: Pushed 903087566d45: Pushed 99dac0782a63: Pushed e6695624484e: Pushed da59b99bbd3b: Pushed 5616a6292c16: Pushed f3ed6cb59ab0: Pushed 654f45ecb7e3: Pushed 2c40c66f7667: Pushed 0.2: digest: sha256:25b8ebd7820515609517ec38dbca9086e1abef3750c0d2aff7f341407c743c46 size: 2419

5. Cuando el envío finalice, en el menú de navegación de CI/CD, navega a Artifact Registry > Repositorios.

6. Haz clic en my-repository. Deberías ver que se creó el contenedor de Docker node-app:

Prueba la imagen

Podrías iniciar una nueva VM, conectarte a ella a través de SSH y, luego, instalar gcloud. Para hacerlo más simple, solo quita todos los contenedores y las imágenes para simular un entorno nuevo.

1. Detén y quita todos los contenedores:

docker stop $(docker ps -q) docker rm $(docker ps -aq)

Debes quitar las imágenes secundarias (de node:lts) antes de quitar la imagen del nodo.

2. Ejecuta el comando siguiente para quitar todas las imágenes de Docker.

docker rmi {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id| "PROJECT_ID" }}}/my-repository/node-app:0.2 docker rmi node:lts docker rmi -f $(docker images -aq) # remove remaining images docker images

(Resultado del comando)

REPOSITORY TAG IMAGE ID CREATED SIZE

En este punto, deberías tener un entorno que es casi nuevo.

3. Extrae la imagen y ejecútala.

docker run -p 4000:80 -d {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id| "PROJECT_ID" }}}/my-repository/node-app:0.2

4. Ejecuta un comando curl en relación con el contenedor en ejecución.

curl http://localhost:4000

(Resultado del comando)

Welcome to Cloud

Prueba la tarea completada

Haz clic en Revisar mi progreso para verificar la tarea realizada. Si publicaste con éxito una imagen de contenedor en Artifact Registry, verás una puntuación de evaluación.

Publica tu imagen de contenedor en Artifact Registry

Aquí se demuestra la portabilidad de los contenedores. Siempre que Docker esté instalado en el host (ya sea una instalación local o en una VM), puedes extraer imágenes de registros privados o públicos y ejecutar contenedores según esa imagen. No hay dependencias de aplicación que se deban instalar en el host, excepto Docker.

¡Felicitaciones!

¡Felicitaciones! En este lab, realizaste varias actividades prácticas, como ejecutar contenedores basados en imágenes públicas de Docker Hub. También compilaste tus propias imágenes de contenedor y las enviaste correctamente a Google Artifact Registry. Además, el lab te permitió desarrollar habilidades para depurar contenedores en ejecución de manera eficaz y obtuviste experiencia en la ejecución de contenedores basados en imágenes que se extrajeron de Google Artifact Registry, lo que mejoró tu comprensión y dominio en Docker.

Próximos pasos y más información

• Referencia de Dockerfile
• Docker Hub
• Más información acerca de Docker en la documentación oficial
• Documentación de Artifact Registry

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: 29 de febrero de 2024

Prueba más reciente del lab: 29 de febrero de 2024

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.