Descripción general

Docker es una plataforma abierta para desarrollar, enviar y ejecutar aplicaciones en contenedores. Ayuda a compilar, probar e implementar código más rápido, y acorta el ciclo entre el desarrollo y la ejecución del código. 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.

Docker te permite expresar el proceso de compilación de la aplicación con una secuencia de comandos, que se denomina Dockerfile. El Dockerfile proporciona un enfoque de bajo nivel que ofrece flexibilidad a costa de la complejidad. Es un manifiesto que detalla cómo convertir tu código fuente en una imagen de contenedor.

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

Objetivos

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

• Compilar, ejecutar y depurar contenedores de Docker
• Enviar imágenes de Docker a Artifact Registry, el repositorio de imágenes de contenedor de Google Cloud
• Extraer imágenes de Docker desde Artifact Registry

Configuración

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

1. Accede a Qwiklabs desde una ventana de incógnito.

2. Ten en cuenta el tiempo de acceso del lab (por ejemplo, 1:15:00) y asegúrate de finalizarlo en el plazo asignado.
   No existe una función de pausa. Si lo necesita, puede reiniciar el lab, pero deberá hacerlo desde el comienzo.

3. Cuando esté listo, haga clic en Comenzar lab.

4. Anote las credenciales del lab (el nombre de usuario y la contraseña). Las usarás para acceder a la consola de Google Cloud.

5. Haga clic en Abrir Google Console.

6. Haga clic en Usar otra cuenta, copie las credenciales para este lab y péguelas en el mensaje emergente que aparece.
   Si usa otras credenciales, se generarán errores o incurrirá en cargos.

7. Acepta las condiciones y omite la página de recursos de recuperación.

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:

Resultado:

Resultado de ejemplo:

• Puedes solicitar el ID del proyecto con este comando:

Resultado:

Resultado de ejemplo:

Tarea 1: Configura tu entorno

Ejecutas los comandos de shell en este lab en otra VM que se aprovisionó previamente para el lab.

1. Para iniciar una sesión SSH en la VM, en Cloud Shell, ejecuta el siguiente comando:

   gcloud compute ssh lab-vm --zone={{{project_0.default_zone| Zone}}}

2. Cuando se te indique, escribe Y para continuar.

3. Para la frase de contraseña, presiona Intro para no usar ninguna.

4. Presiona Intro de nuevo.

5. Otorga permisos al usuario estudiante en el socket que usa Docker:

   sudo chmod 666 /var/run/docker.sock

6. Para configurar el ID de tu proyecto y las variables de entorno de la región, ejecuta los siguientes comandos:

   PROJECT_ID={{{project_0.project_id| Project}}} REGION={{{project_0.default_region| Region}}} Asegúrate de ejecutar todos los comandos del lab en las tareas siguientes, en la sesión SSH en Cloud Shell.

Tarea 2: Crea una imagen de contenedor

En esta tarea, crearás una imagen de contenedor de Docker con un Dockerfile.

Crea un Dockerfile

1. Crea un directorio de prueba y cámbialo como se indica a continuación:

   mkdir test && cd test

2. Crea el Dockerfile:

   cat > Dockerfile <<EOF # Usar un entorno de ejecución oficial Node como la imagen principal FROM node:lts # Establecer el directorio de trabajo en el contenedor en /app WORKDIR /app # Copiar los contenidos del directorio actual en el contenedor en /app COPY . /app # Hacer que el puerto 80 del contenedor esté disponible públicamente EXPOSE 80 # Ejecutar app.js con Node cuando se inicia el contenedor CMD ["node", "app.js"] EOF Nota: En este paso, ensamblas la imagen de contenedor seleccionando primero una imagen superior o de base.

   Esto se especifica con la instrucción FROM y la imagen oficial de Docker para la versión LTS (asistencia a largo plazo) de Node.

   La instrucción WORKDIR establece el directorio de trabajo en el contenedor para cualquier instrucción adicional que siga en el Dockerfile. En este lab, usamos el directorio /app como el directorio de trabajo del contenedor.

   La instrucción COPY copia directorios o archivos desde la ubicación de origen hacia la ruta de destino del sistema de archivos de imagen de contenedor. Aquí copiamos archivos del directorio actual en /app.

   La instrucción EXPOSE expone el puerto del contenedor para que acepte conexiones en ese puerto, que en este lab es el puerto 80.

   Por último, la instrucción CMD proporciona el comando node para ejecutar la aplicación en el contenedor que se está ejecutando.

Desarrolla tu aplicación

Luego, escribirás el código para tu aplicación de Node.js. Esta aplicación es un servidor HTTP simple que escucha solicitudes en el puerto 80 y responde con un mensaje estático.

1. Crea el archivo app.js con el código fuente de tu aplicación:

   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('Welcome to your first Docker container!\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 Nota: La aplicación también implementa la función de controlador SIGINT para registrar un mensaje y salir de forma correcta cuando se detiene el contenedor.

2. Verifica el contenido del archivo de origen de la aplicación:

   cat app.js

Crea la imagen de contenedor

En esta subtarea, crearás la imagen de contenedor a partir del Dockerfile con el comando docker build.

1. Ejecuta el comando docker build:

   docker build -t my-app:0.1 .

   A continuación, se muestra un resultado parcial del comando:

   => [internal] load dockerignore => => transferring context: 2B => [internal] load build definition from Dockerfile => => transferring dockerfile: 394B => [internal] load metadata for docker.io/library/node:lts => [1/3] FROM docker.io/library/node:lts@sha256:586cdef48f920dea2f47a954b8717601933aa1daa0a08264abf9144789abf8ae => => resolve docker.io/library/node:lts@sha256:586cdef48f920dea2f47a954b8717601933aa1daa0a08264abf9144789abf8ae => => sha256:b7483c70b94e9fbb68e91d64456ee147d120488f876d69efeae815ba164e8b54 2.21kB / 2.21kB ... ... => [internal] load build context => => transferring context: 912B => [2/3] WORKDIR /app => [3/3] COPY . /app => exporting to image => => exporting layers => => writing image sha256:8cf51a1aba351cf505cd6d8eefa966b => => naming to docker.io/library/my-app:0.1 Nota: Este comando compila la imagen de contenedor a partir de las instrucciones del Dockerfile en el directorio actual y etiqueta la imagen resultante con el nombre y la versión especificados. Google recomienda especificar una etiqueta para distinguir las versiones de imágenes más recientes de las anteriores.

2. Consulta la lista de imágenes que se compilaron:

   docker images REPOSITORY TAG IMAGE ID CREATED SIZE my-app 0.1 8cf51a1aba35 10 minutes ago 997MB Nota: El comando muestra la imagen base node y la imagen my-app que se compiló. El tamaño de la imagen es relativamente pequeño en comparación con otras imágenes de máquinas virtuales.

   Para verificar este objetivo, haz clic en Revisar mi progreso. Crear una imagen de contenedor

Tarea 3: Ejecuta y prueba la aplicación

Una vez que la imagen de contenedor se creó correctamente, puedes ejecutar tu aplicación y probarla para asegurarte de que se comporte como se espera.

Ejecuta el contenedor

1. Para ejecutar el contenedor, ejecuta el siguiente comando:

   docker run -p 8080:80 --name my-app -d my-app:0.1 Nota: El comando docker run inicia el contenedor con el nombre especificado. El argumento -p asigna el puerto 8080 del host al puerto 80 del contenedor, lo que permite que las solicitudes lleguen al servidor en http://localhost:8080. El argumento -d ejecuta el contenedor en segundo plano.

2. Para ver una lista de contenedores en ejecución, ejecuta el siguiente comando:

   docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 46c209a1fd87 my-app:0.1 "docker-entrypoint.s…" 19 seconds ago Up 17 seconds 0.0.0.0:8080->80/tcp my-app

Prueba la aplicación

1. Para probar la aplicación, envíale una solicitud HTTP con el comando curl:

   curl http://localhost:8080

2. Verifica la respuesta de la aplicación:

   Welcome to your first Docker container!

3. Detén el contenedor con el comando docker stop:

   docker stop [CONTAINER ID]

   Reemplaza [CONTAINER ID] por el valor de CONTAINER ID del resultado del comando que se ejecutó en la subtarea anterior.

Tarea 4: Modifica el contenedor

Puedes tener varias versiones de tus aplicaciones alojadas en contenedores que comparten capas comunes en la imagen. En esta tarea, crearás otra versión de la aplicación alojada en contenedores y probarás ambas versiones.

Modifica el código de la aplicación

1. En el directorio test, actualiza el contenido del archivo app.js:

   cat > app.js <<EOF const http = require('http'); const url = require('url'); const hostname = '0.0.0.0'; const port = 80; const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); console.log('Received request with URL: ?%s', req.url); var q = url.parse(req.url, true).query; res.end(q.user + ', Welcome to your first Docker container!\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 Nota: El código de la aplicación modificada agrega el valor de un parámetro de consulta user que se pasa en la solicitud HTTP en la respuesta de la aplicación.

2. Verifica el contenido modificado del archivo de origen de la aplicación con el comando cat:

   cat app.js

Vuelve a crear la imagen de contenedor

1. Vuelve a crear la imagen con una etiqueta nueva:

   docker build -t my-app:0.2 .

2. Verifica el resultado del comando docker build:

   => [internal] load build definition from Dockerfile => => transferring dockerfile: 394B => [internal] load .dockerignore => => transferring context: 2B => [internal] load metadata for docker.io/library/node:lts => [1/3] FROM docker.io/library/node:lts@sha256:586cdef48f920dea2f47a954b8717601933aa1daa0a08264abf9144789abf8ae => [internal] load build context => => transferring context: 691B => CACHED [2/3] WORKDIR /app => [3/3] COPY . /app => exporting to image => => exporting layers => => writing image sha256:5fc2d7a43c4678da17daf204ef4b071f2da869ead758864622d90d880a40c24b => => naming to docker.io/library/my-app:0.2

   Como se ve en el resultado, en la nueva imagen de contenedor solo se modifican las capas del paso 3 y los anteriores porque se hicieron cambios en el archivo de origen app.js.

Ejecuta el nuevo contenedor

1. Para ejecutar el nuevo contenedor, ejecuta el siguiente comando:

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

2. Para ver una lista de contenedores en ejecución, ejecuta el siguiente comando:

   docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 7071749fe0f6 my-app:0.2 "docker-entrypoint.s…" 10 seconds ago Up 10 seconds 0.0.0.0:8081->80/tcp my-app-2

Prueba la aplicación

1. Para probar la aplicación, envíale una solicitud HTTP con curl:

   curl http://localhost:8080?user=Learner

2. Verifica la respuesta de la aplicación:

   Learner, Welcome to your first Docker container! Nota: La respuesta contiene el valor del argumento user que se pasó en la solicitud al contenedor que ejecuta la versión 0.2 de la imagen de la aplicación.

   Haz clic en Revisar mi progreso para verificar el objetivo. Modificar el contenedor y volver a crear la imagen del contenedor

Tarea 5: Soluciona problemas

Existen algunas técnicas sencillas para solucionar problemas en tus aplicaciones alojadas en contenedores. En esta tarea, revisamos algunos de estos métodos.

Consulta registros del contenedor

1. Primero, recupera el ID del contenedor cuyos registros necesitas ver:

   docker ps

2. Para ver los registros del contenedor, ejecuta el comando docker logs:

   docker logs [CONTAINER ID]

   Reemplaza CONTAINER ID por los caracteres iniciales del ID del contenedor que lo identifica de forma única en el resultado del comando anterior. Para visualizar en tiempo real las últimas entradas del registro mientras se ejecuta el contenedor, usa la opción -f con el comando logs.

   Server running at http://0.0.0.0:80/ Received request with URL: ?/?user=Learner

Inicia una shell dentro del contenedor

Puedes iniciar una shell interactiva dentro de un contenedor en ejecución para solucionar problemas.

1. Para iniciar una sesión interactiva de Bash, ejecuta lo siguiente:

   docker exec -it [CONTAINER ID] bash root@7071749fe0f6:/app#

2. Desde esta shell, para solucionar problemas, puedes inspeccionar el sistema de archivos del contenedor y otros archivos de datos que tu aplicación podría usar.

   ls

3. Sal de la shell de Bash:

   exit

Examina los metadatos del contenedor

1. Para ver los metadatos de un contenedor, ejecuta el siguiente comando:

   docker inspect [CONTAINER ID]

   Este es un resultado parcial del comando:

   [ { "Id": "7071749fe0f66b8b1953bbb6f28f159bd5dbeae079595675e2591d32d87ae5dc", "Created": "2023-02-23T18:08:34.286519913Z", "Path": "docker-entrypoint.sh", "Args": [ "node", "app.js" ], "State": { "Status": "running", "Running": true, "Paused": false, "Restarting": false, "OOMKilled": false, "Dead": false, "Pid": 1099, "ExitCode": 0, "Error": "", "StartedAt": "2023-02-23T18:08:34.785098365Z", "FinishedAt": "0001-01-01T00:00:00Z" }, "Image": "sha256:5fc2d7a43c4678da17daf204ef4b071f2da869ead758864622d90d880a40c24b", "ResolvConfPath": "/var/lib/docker/containers/7071749fe0f66b8b1953bbb6f28f159bd5dbeae079595675e2591d32d87ae5dc/resolv.conf", "HostnamePath": "/var/lib/docker/containers/ ... ... } ] Nota: De forma predeterminada, el comando inspect proporciona información detallada de metadatos en un array JSON. Puedes filtrar los resultados con el argumento --format para inspeccionar campos específicos en el resultado.

Tarea 6: Publica una imagen de contenedor

Artifact Registry es un servicio de Google Cloud que se utiliza para almacenar y administrar artefactos de software en repositorios privados, como imágenes de contenedor y paquetes de software.

En esta tarea, enviarás tus imágenes de contenedor a Artifact Registry, lo que hará que estén disponibles para la implementación en otros entornos, como etapa de pruebas y producción, que conforman tu ciclo de vida de la entrega de software.

Crea un repositorio de imágenes

Antes de enviar imágenes de contenedor a Artifact Registry, debes crear un repositorio.

1. En el menú de navegación () de la consola de Google Cloud, haz clic en Ver todos los productos. Luego, en las categorías de CI/CD, navega a Artifact Registry > Repositorios.

2. En la página Crear repositorio, proporciona la siguiente información y deja el resto de la configuración con los valores predeterminados:

   Propiedad	Valor (escríbelo o selecciónalo)
   Nombre	my-repo
   Formato	Docker
   Tipo de ubicación	Región
   Región

3. Haz clic en Crear.

Autentica Docker para usar el repositorio

Antes de poder enviar imágenes al repositorio o extraerlas desde él, debes configurar Docker para autenticar solicitudes al repositorio en Artifact Registry.

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

   gcloud auth configure-docker ${REGION}-docker.pkg.dev

2. Cuando se te solicite, escribe Y.

   El nombre completo del repositorio que creaste es -docker.pkg.dev//my-repo.

   Los nombres de repositorios de imágenes de Docker usan el formato [ubicación]-docker.pkg.dev en Artifact Registry.

Envía el contenedor a Artifact Registry

1. Para enviar una imagen de contenedor a tu registro privado alojado en Artifact Registry, primero debes etiquetar la imagen con el nombre del repositorio:

   docker build -t ${REGION}-docker.pkg.dev/${PROJECT_ID}/my-repo/my-app:0.2 .

2. Enumera las imágenes de Docker que creaste:

   docker images REPOSITORY TAG IMAGE ID CREATED SIZE my-app 0.2 9b1ef4854d32 4 minutes ago 997MB us-east1-docker.pkg.dev/qwiklabs-gcp-02-7c092125ce3a/my-repo/my-app 0.2 9b1ef4854d32 4 minutes ago 997MB my-app 0.1 8cf51a1aba35 5 minutes ago 997MB

3. Para enviar la imagen a Artifact Registry, ejecuta el siguiente comando:

   docker push ${REGION}-docker.pkg.dev/$PROJECT_ID/my-repo/my-app:0.2

   El resultado de este comando es similar al siguiente:

   The push refers to repository [east1-docker.pkg.dev/qwiklabs-gcp-02-7c092125ce3a/my-repo/my-app] b29bce04ddbb: Pushed 9ba0e19073ee: Pushed 3c397285cb7e: Pushed a8d01c684adc: Pushed 56c4ec92f013: Pushed 4c92897e605e: Pushed 0b6859e9fff1: Pushed 11829b3be9c0: Pushed dc8e1d8b53e9: Pushed 9d49e0bc68a4: Pushed 8e396a1aad50: Pushed 0.2: digest: sha256:383ffb5213f92e33dedb49042c0f070a9f76f263621226de20499dffd863b3df size: 2628

4. Una vez que se complete el comando, en el menú de navegación () de la consola de Google Cloud, haz clic en Ver todos los productos. Luego, en las categorías de CI/CD, navega a Artifact Registry > Repositorios.

5. Haz clic en el repositorio my-repo para mostrar la imagen de contenedor de Docker my-app.

Haz clic en Revisar mi progreso para verificar el objetivo. Publicar una imagen de contenedor

Tarea 7: Extrae y prueba la imagen de contenedor

En esta tarea, comenzarás con un entorno nuevo y, luego, extraerás la imagen de contenedor de Artifact Registry para probarla. Para simular otro entorno, detienes y quitas todos los contenedores y las imágenes de tu entorno de shell que se crearon en las tareas anteriores de este lab.

Detén y quita contenedores

1. Para detener todos los contenedores en ejecución, ejecuta el siguiente comando:

   docker stop $(docker ps -q)

2. Para quitar todos los contenedores, ejecuta el siguiente comando:

   docker rm $(docker ps -aq)

Quita todas las imágenes de contenedor

1. Para quitar la imagen de contenedor etiquetada en el registro, ejecuta el siguiente comando:

   docker rmi ${REGION}-docker.pkg.dev/$PROJECT_ID/my-repo/my-app:0.2 Nota: Este comando no quita la imagen de contenedor del registro.

2. Para quitar todas las demás imágenes, ejecuta el siguiente comando:

   docker rmi -f $(docker images -aq)

3. Verifica que no haya imágenes de contenedores en tu entorno de VM:

   docker images REPOSITORY TAG IMAGE ID CREATED SIZE

   Ahora deberías tener un entorno de host nuevo sin imágenes locales.

Prueba la imagen

Prueba la imagen extrayéndola de Artifact Registry.

1. Para extraer la imagen de Artifact Registry, ejecuta el siguiente comando:

   docker pull ${REGION}-docker.pkg.dev/${PROJECT_ID}/my-repo/my-app:0.2

2. Para implementar la imagen, ejecuta el siguiente comando.

   docker images

3. Para ejecutar el contenedor, ejecuta el siguiente comando:

   docker run -p 8080:80 -d ${REGION}-docker.pkg.dev/${PROJECT_ID}/my-repo/my-app:0.2

4. Para probar la aplicación, ejecuta el siguiente comando:

   curl http://localhost:8080?user=Learner Nota: Esta tarea demuestra la portabilidad de contenedores, en la que puedes ejecutar aplicaciones alojadas en contenedores en otras VMs o entornos con Docker, sin la necesidad de instalar ninguna dependencia de la aplicación en la máquina anfitrión. Las imágenes de contenedor pueden alojarse en registros públicos o privados a los que Docker debería poder acceder.

¡Felicitaciones!

Felicitaciones por completar este lab sobre los aspectos fundamentales de la creación de contenedores con Docker. En este lab, aprendiste a hacer lo siguiente:

• Crear imágenes de contenedor con Docker y ejecutar contenedores de Docker
• Enviar imágenes de Docker a Artifact Registry, el repositorio de imágenes de contenedor de Google Cloud
• Extraer imágenes de Docker de Artifact Registry y ejecutarlas en un entorno nuevo para verificar la portabilidad de contenedores

Próximos pasos / Más información

Para obtener más información sobre Docker y Artifact Registry, consulta la documentación:

• Documentación de Docker
• Referencia de comandos de Docker
• Artifact Registry

Copyright 2026 Google LLC. Todos los derechos reservados. Google y el logotipo de Google son marcas de Google LLC. El resto de los nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que están asociados.