Docker: 150 Comandos del Primer Contenedor a Producción

Docker resuelve un problema viejo: "en mi máquina funciona". Empaqueta la aplicación con todo lo que necesita — runtime, bibliotecas, configuración — en una imagen que se ejecuta igual en cualquier sitio.

Estos 150 comandos van desde el primer docker run hasta el diagnóstico de un contenedor que muere en producción. Los ejemplos usan la CLI moderna (docker container ...) y mencionan el atajo clásico cuando es el más usado.

Un contenedor no es una máquina virtual. Comparte el kernel del host y aísla solo lo que necesita (procesos, red, sistema de archivos). Por eso arranca en milisegundos y pesa megabytes en lugar de gigabytes.

Índice

• 1–20 · Primeros pasos
• 21–42 · Imágenes
• 43–64 · Contenedores en el día a día
• 65–86 · Dockerfile
• 87–100 · Volúmenes y datos
• 101–114 · Redes
• 115–132 · Docker Compose
• 133–150 · Producción, seguridad y diagnóstico

Primeros pasos

Verificar la instalación, levantar el primer contenedor y entender qué pasó.

1. Versión e información

Confirma que el cliente habla con el daemon.

docker version
docker info

2. Primer contenedor

Descarga la imagen, crea el contenedor, lo ejecuta y sale. El "hola mundo" de Docker.

docker run hello-world

3. docker run

Crea y arranca un contenedor a partir de una imagen.

docker run nginx

4. Ejecutar en segundo plano

-d (detached) te devuelve el terminal y deja el contenedor funcionando.

docker run -d nginx

5. Publicar un puerto

-p host:contenedor expone el servicio en tu máquina.

docker run -d -p 8080:80 nginx
# entra en http://localhost:8080

6. Dar nombre al contenedor

Sin --name, Docker inventa un nombre aleatorio y pierdes tiempo buscándolo.

docker run -d --name meu-nginx -p 8080:80 nginx

7. Modo interactivo

-it conecta tu terminal al contenedor — imprescindible para una shell.

docker run -it ubuntu bash

8. Eliminar al salir

--rm borra el contenedor en cuanto se para. Ideal para una prueba rápida.

docker run --rm -it alpine sh

9. Variables de entorno

La forma estándar de configurar una aplicación en contenedor.

docker run -d -e POSTGRES_PASSWORD=senha -e POSTGRES_DB=loja postgres:16

10. Variables desde un archivo

Evita exponer el secreto en el historial de la shell.

docker run --env-file .env -d minha-app

11. Listar contenedores activos

El comando que más vas a escribir.

docker ps

12. Listar todos los contenedores

-a incluye los parados — donde suele estar lo que falló.

docker ps -a

13. Formatear la salida de ps

Deja la lista legible en un terminal estrecho.

docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

14. Parar y arrancar

stop envía SIGTERM y espera; start vuelve a encender el mismo contenedor.

docker stop meu-nginx
docker start meu-nginx

15. Reiniciar

Atajo para stop + start.

docker restart meu-nginx

16. Matar un contenedor

SIGKILL inmediato, sin cierre elegante. Último recurso.

docker kill meu-nginx

17. Eliminar un contenedor

Borra el contenedor parado; -f lo fuerza incluso en ejecución.

docker rm meu-nginx
docker rm -f meu-nginx

18. Ver los logs

Lo primero que hay que hacer cuando algo no funciona.

docker logs meu-nginx

19. Seguir los logs en vivo

-f sigue la salida; --tail limita el historial inicial.

docker logs -f --tail 100 meu-nginx

20. Ejecutar un comando en un contenedor en marcha

Abre una shell dentro del contenedor en ejecución.

docker exec -it meu-nginx bash
docker exec -it meu-alpine sh   # las imágenes Alpine no tienen bash

Imágenes

La imagen es el molde; el contenedor es la instancia en ejecución.

21. Listar imágenes

Muestra lo que está descargado y cuánto ocupa.

docker images
docker image ls

22. Descargar una imagen

La trae del registro sin ejecutarla.

docker pull postgres:16

23. Etiquetas de versión

Nunca uses latest en producción: cambia sin avisar y rompe lo que funcionaba.

docker pull node:20-alpine
docker pull node:20.11.1-alpine3.19   # todavía más específico

24. Buscar una imagen

Busca en Docker Hub desde la línea de comandos.

docker search postgres

25. Construir una imagen

Lee el Dockerfile del directorio y genera la imagen con la etiqueta indicada.

docker build -t minha-app:1.0 .

26. Build con un Dockerfile concreto

Cuando hay más de uno (producción, desarrollo, pruebas).

docker build -f Dockerfile.prod -t minha-app:prod .

27. Build sin caché

Fuerza a rehacer todas las capas — útil cuando la caché está tapando un problema.

docker build --no-cache -t minha-app:1.0 .

28. Build con argumentos

ARG parametriza el build (no confundir con ENV, que vale en ejecución).

docker build --build-arg NODE_VERSION=20 -t minha-app .

29. Etiquetar con otro nombre

La misma imagen puede tener varios nombres.

docker tag minha-app:1.0 usuario/minha-app:latest

30. Enviar al registro

Publica en Docker Hub o en un registro privado.

docker login
docker push usuario/minha-app:1.0

31. Registro privado

El nombre de la imagen lleva la dirección del registro.

docker tag minha-app registry.empresa.com/time/minha-app:1.0
docker push registry.empresa.com/time/minha-app:1.0

32. Eliminar una imagen

Solo se va si ningún contenedor depende de ella.

docker rmi minha-app:1.0
docker image rm -f minha-app:1.0

33. Historial de capas

Muestra cada capa y su tamaño — así se descubre qué engordó la imagen.

docker history minha-app:1.0

34. Inspeccionar una imagen

Metadatos completos: variables, entrypoint, puertos, capas.

docker inspect minha-app:1.0

35. Exportar e importar una imagen

Mueve una imagen entre máquinas sin registro, como archivo.

docker save -o minha-app.tar minha-app:1.0
docker load -i minha-app.tar

36. Imágenes colgadas (dangling)

Capas huérfanas de builds antiguos, que solo ocupan disco.

docker images -f "dangling=true"
docker image prune

37. Limpiar imágenes sin uso

-a elimina todas las que no tienen contenedor asociado. Libera mucho espacio.

docker image prune -a

38. Imágenes base ligeras

Alpine pesa unos 5 MB; distroless ni siquiera tiene shell. Menos superficie, menos vulnerabilidades.

# 1.1 GB
FROM node:20
# 130 MB
FROM node:20-alpine
# ~50 MB, sin shell ni gestor de paquetes
FROM gcr.io/distroless/nodejs20-debian12

39. Escanear vulnerabilidades

Comprueba las CVE conocidas en las dependencias de la imagen.

docker scout cves minha-app:1.0
trivy image minha-app:1.0

40. Ver el tamaño real

Compara el tamaño de las imágenes para encontrar la gorda.

docker images --format "{{.Repository}}:{{.Tag}}\t{{.Size}}" | sort -k2 -h

41. Extraer un archivo de una imagen

Crea un contenedor temporal solo para copiar algo de dentro.

id=$(docker create minha-app:1.0)
docker cp $id:/app/dist ./dist
docker rm $id

42. Multiplataforma (buildx)

Genera la misma imagen para amd64 y arm64 — necesario para Apple Silicon y Graviton.

docker buildx build --platform linux/amd64,linux/arm64 -t usuario/app:1.0 --push .

Contenedores en el día a día

Inspeccionar, copiar, limitar y entender qué está pasando ahí dentro.

43. Inspeccionar un contenedor

JSON completo: red, volúmenes, variables, estado, código de salida.

docker inspect meu-nginx

44. Extraer un campo del inspect

Con una plantilla Go, coges solo lo que necesitas.

docker inspect -f '{{.State.Status}}' meu-nginx
docker inspect -f '{{.NetworkSettings.IPAddress}}' meu-nginx

45. Uso de recursos en vivo

CPU, memoria, red y E/S de cada contenedor — el top de Docker.

docker stats
docker stats --no-stream

46. Procesos del contenedor

Lo que está corriendo ahí dentro, visto desde el host.

docker top meu-nginx

47. Copiar archivos

Mueve archivos entre el host y el contenedor en los dos sentidos.

docker cp ./config.json meu-nginx:/etc/app/config.json
docker cp meu-nginx:/var/log/nginx/error.log ./error.log

48. Ver qué cambió en el sistema de archivos

Lista los archivos creados (A), modificados (C) y eliminados (D) desde la imagen.

docker diff meu-nginx

49. Limitar la memoria

Sin límite, un contenedor puede tumbar el host entero.

docker run -d --memory 512m --memory-swap 512m minha-app

50. Limitar la CPU

--cpus define cuántos núcleos puede usar el contenedor.

docker run -d --cpus 1.5 minha-app

51. Política de reinicio

Hace que el contenedor vuelva solo tras un fallo o un reinicio.

docker run -d --restart unless-stopped minha-app
# opciones: no | on-failure | on-failure:3 | always | unless-stopped

52. Healthcheck

Docker pasa a saber si el contenedor está sano, no solo levantado.

docker run -d --health-cmd "curl -f http://localhost/health || exit 1" \
  --health-interval 30s --health-retries 3 minha-app

53. Ver el estado de salud

Muestra el resultado de las últimas comprobaciones.

docker inspect -f '{{.State.Health.Status}}' minha-app

54. Código de salida

Dice por qué murió el contenedor — 137 es OOM/kill, 1 es un error de la aplicación.

docker inspect -f '{{.State.ExitCode}}' minha-app
docker ps -a --filter "exited=137"

55. Ejecutar como otro usuario

Entra en el contenedor con un usuario concreto (útil para depurar permisos).

docker exec -u root -it minha-app sh

56. Ejecutar con un usuario no root

Un contenedor corriendo como root es un riesgo innecesario.

docker run -d --user 1000:1000 minha-app

57. Renombrar un contenedor

Sin recrear nada.

docker rename nome-antigo nome-novo

58. Pausar y reanudar

Congela los procesos sin terminar el contenedor.

docker pause minha-app
docker unpause minha-app

59. Esperar a que el contenedor termine

Bloquea hasta la salida y devuelve el código — útil en un script.

docker wait minha-app

60. Eventos del daemon

Flujo en vivo de todo lo que pasa: creación, muerte, salud, red.

docker events --filter container=minha-app

61. Puertos publicados

Descubre a dónde está mapeado el contenedor.

docker port meu-nginx

62. Eliminar todos los contenedores parados

Limpieza rutinaria.

docker container prune

63. Parar todo de una vez

Emergencia o fin de jornada.

docker stop $(docker ps -q)

64. Convertir un contenedor en imagen

Congela el estado actual como imagen. Sirve para depurar — nunca como forma de construir una imagen.

docker commit minha-app minha-app:debug

Dockerfile

La receta de la imagen. Cada instrucción se convierte en una capa — y el orden importa mucho.

65. FROM

La imagen base. Primera instrucción de todo Dockerfile.

FROM node:20-alpine

66. WORKDIR

Define el directorio de trabajo y lo crea si no existe. Mejor que RUN cd.

WORKDIR /app

67. COPY

Copia del contexto de build al interior de la imagen.

COPY package.json package-lock.json ./
COPY src ./src

68. ADD

Como COPY, pero además descarga una URL y descomprime un tar. Prefiere COPY: menos sorpresas.

ADD https://exemplo.com/arquivo.tar.gz /tmp/

69. RUN

Ejecuta un comando en el build y congela el resultado en una capa.

RUN npm ci --omit=dev

70. Encadenar los RUN

Cada RUN es una capa. Junta los comandos relacionados y limpia en la misma línea.

RUN apt-get update \
 && apt-get install -y --no-install-recommends curl \
 && rm -rf /var/lib/apt/lists/*

71. Orden de las capas (caché)

El truco que más acelera el build: copia el manifiesto e instala antes de copiar el código.

COPY package*.json ./
RUN npm ci            # solo se rehace cuando cambian las dependencias
COPY . .              # cambia en cada commit, pero es la última capa

72. ENV

Variable de entorno disponible en el build y en la ejecución.

ENV NODE_ENV=production PORT=3000

73. ARG

Variable solo del build. No queda en la imagen final — pero sí aparece en el historial, así que nada de secretos.

ARG NODE_VERSION=20
FROM node:${NODE_VERSION}-alpine

74. EXPOSE

Documenta el puerto usado. No publica nada por sí solo — quien publica es el -p.

EXPOSE 3000

75. CMD

Comando por defecto del contenedor, sustituible en la línea de comandos.

CMD ["node", "server.js"]

76. ENTRYPOINT

Comando fijo. Combinado con CMD, se convierte en "programa + argumentos por defecto".

ENTRYPOINT ["node"]
CMD ["server.js"]

77. Forma exec vs shell

Usa siempre la forma exec (JSON): en la forma shell el proceso pasa a ser hijo de /bin/sh y no recibe las señales.

CMD ["node", "server.js"]     # exec — recibe SIGTERM
CMD node server.js            # shell — no la recibe

78. USER

Cambia el usuario. Todo lo que venga después corre sin root.

RUN addgroup -S app && adduser -S app -G app
USER app

79. VOLUME

Marca un directorio como punto de montaje de datos persistentes.

VOLUME ["/var/lib/postgresql/data"]

80. HEALTHCHECK

Enseña a Docker a comprobar si la aplicación está respondiendo de verdad.

HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD wget -qO- http://localhost:3000/health || exit 1

81. LABEL

Metadatos de la imagen: versión, autor, origen del código.

LABEL org.opencontainers.image.source="https://github.com/usuario/projeto"

82. .dockerignore

Reduce el contexto de build. Sin él, mandas node_modules y .git al daemon en cada build.

node_modules
.git
.env
dist
*.log

83. Multi-stage build

Compila en una etapa y copia solo el resultado a la imagen final. Recorta cientos de MB.

FROM node:20-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine
WORKDIR /app
COPY --from=build /app/dist ./dist
COPY --from=build /app/node_modules ./node_modules
USER node
CMD ["node", "dist/server.js"]

84. Copiar de otra imagen

--from acepta cualquier imagen, no solo una etapa anterior.

COPY --from=nginx:alpine /etc/nginx/nginx.conf /etc/nginx/nginx.conf

85. Caché de dependencias (BuildKit)

Mantiene la caché del gestor entre builds, sin hinchar la imagen.

RUN --mount=type=cache,target=/root/.npm npm ci

86. Secreto en el build

Usa la credencial durante el build sin grabarla en ninguna capa.

RUN --mount=type=secret,id=npmrc,target=/root/.npmrc npm ci
# docker build --secret id=npmrc,src=$HOME/.npmrc .

Volúmenes y datos

El contenedor es desechable; los datos no pueden serlo. Para eso existen los volúmenes.

87. Crear un volumen

Volumen con nombre, gestionado por Docker.

docker volume create dados-postgres

88. Listar e inspeccionar

Muestra dónde vive el volumen en el host.

docker volume ls
docker volume inspect dados-postgres

89. Usar un volumen en el contenedor

Los datos sobreviven a la eliminación del contenedor.

docker run -d -v dados-postgres:/var/lib/postgresql/data postgres:16

90. Bind mount

Monta una carpeta del host. Es lo que da hot reload en desarrollo.

docker run -d -v $(pwd)/src:/app/src minha-app

91. La sintaxis --mount

Más explícita que -v y recomendada en los scripts.

docker run -d --mount type=bind,source=$(pwd)/src,target=/app/src minha-app

92. Montaje de solo lectura

Un contenedor que no debería escribir, no escribe.

docker run -d -v $(pwd)/config:/app/config:ro minha-app

93. Volumen vs bind mount

Volumen para datos de producción (lo gestiona Docker); bind mount para el código en desarrollo.

# producción
docker run -v dados:/var/lib/mysql mysql:8
# desarrollo
docker run -v $(pwd):/app node:20 npm run dev

94. tmpfs

Sistema de archivos en memoria: desaparece cuando el contenedor se para. Bueno para datos sensibles.

docker run -d --tmpfs /tmp:rw,size=64m minha-app

95. Backup de un volumen

Un contenedor temporal que empaqueta el contenido del volumen.

docker run --rm -v dados-postgres:/dados -v $(pwd):/backup alpine \
  tar czf /backup/dados-postgres.tar.gz -C /dados .

96. Restaurar un volumen

El camino inverso al del backup.

docker run --rm -v dados-postgres:/dados -v $(pwd):/backup alpine \
  tar xzf /backup/dados-postgres.tar.gz -C /dados

97. Eliminar un volumen

Un volumen no desaparece junto con el contenedor — hay que borrarlo a propósito.

docker volume rm dados-postgres

98. Limpiar volúmenes huérfanos

Cuidado: esto borra datos de verdad. Comprueba la lista antes.

docker volume ls -f dangling=true
docker volume prune

99. Eliminar el contenedor con su volumen

-v borra los volúmenes anónimos de ese contenedor.

docker rm -v minha-app

100. Permisos en un bind mount

El error clásico en Linux: el UID de dentro no es el mismo que el de fuera.

docker run -d --user $(id -u):$(id -g) -v $(pwd):/app minha-app

Redes

Cómo hablan los contenedores entre sí y con el mundo.

101. Listar redes

Toda instalación ya viene con bridge, host y none.

docker network ls

102. Crear una red

Red propia del proyecto: los contenedores se ven por el nombre.

docker network create minha-rede

103. Conectar un contenedor a la red

Al crearlo o después, con el contenedor ya en marcha.

docker run -d --network minha-rede --name api minha-app
docker network connect minha-rede outro-container

104. DNS interno

Dentro de la red, el nombre del contenedor es el host. No uses la IP.

# desde dentro del contenedor "api":
curl http://banco:5432
# en lugar de http://172.18.0.3:5432

105. Inspeccionar una red

Muestra el rango de IP y quién está conectado.

docker network inspect minha-rede

106. Desconectar y eliminar

Una red en uso no se puede eliminar.

docker network disconnect minha-rede api
docker network rm minha-rede

107. Modo host

Sin aislamiento de red: el contenedor usa la pila del host. Rápido, pero sin aislamiento (Linux).

docker run -d --network host nginx

108. Sin red

Aislamiento total. Bueno para procesar datos no confiables.

docker run --rm --network none alpine ip addr

109. Publicar en una interfaz concreta

Lo expone solo en localhost, no en toda la red.

docker run -d -p 127.0.0.1:8080:80 nginx

110. Publicar un rango y UDP

También se pueden exponer intervalos y otro protocolo.

docker run -d -p 8000-8010:8000-8010 minha-app
docker run -d -p 53:53/udp meu-dns

111. Acceder al host desde dentro del contenedor

host.docker.internal resuelve a la máquina anfitriona.

curl http://host.docker.internal:5432

112. Descubrir la IP del contenedor

Para cuando de verdad la necesitas.

docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' api

113. Probar la conectividad

Un contenedor desechable solo para diagnosticar la red.

docker run --rm --network minha-rede alpine ping -c 3 banco
docker run --rm --network minha-rede nicolaka/netshoot nslookup api

114. Limpiar redes sin uso

Limpieza de rutina.

docker network prune

Docker Compose

Varios contenedores descritos en un archivo y levantados con un solo comando.

115. compose.yaml básico

Describe servicios, puertos, variables y dependencias.

services:
  api:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://app:senha@banco:5432/loja
    depends_on:
      banco:
        condition: service_healthy

  banco:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: senha
      POSTGRES_DB: loja
    volumes:
      - dados:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app"]
      interval: 5s
      retries: 5

volumes:
  dados:

116. Levantar todo

-d en segundo plano; sin él, los logs se quedan en el terminal.

docker compose up -d

117. Levantar reconstruyendo

Fuerza el rebuild de las imágenes antes de levantar.

docker compose up -d --build

118. Derribar

down elimina contenedores y redes; con -v, borra también los volúmenes.

docker compose down
docker compose down -v   # ¡borra los datos!

119. Ver los servicios

El estado de cada servicio de la stack.

docker compose ps

120. Logs de la stack

Todos los servicios juntos, o uno concreto.

docker compose logs -f
docker compose logs -f api --tail 100

121. Ejecutar un comando en un servicio

exec en el contenedor en marcha; run crea uno nuevo.

docker compose exec api sh
docker compose run --rm api npm run migrate

122. Reiniciar un servicio

Sin tocar el resto de la stack.

docker compose restart api

123. Escalar réplicas

Levanta varias instancias del mismo servicio.

docker compose up -d --scale worker=3

124. Validar el archivo

Muestra la configuración final, con las variables ya resueltas.

docker compose config

125. Varios archivos

Uno base y uno por entorno — el segundo sobrescribe el primero.

docker compose -f compose.yaml -f compose.prod.yaml up -d

126. El archivo .env

Compose lee el .env del directorio automáticamente.

# .env
POSTGRES_PASSWORD=senha-forte

# compose.yaml
environment:
  POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}

127. Profiles

Servicios que solo se levantan cuando los pides — como las herramientas de desarrollo.

services:
  adminer:
    image: adminer
    profiles: ["dev"]

# docker compose --profile dev up -d

128. depends_on con healthcheck

Sin condition, Compose solo espera a que el contenedor arranque, no a que esté listo.

depends_on:
  banco:
    condition: service_healthy

129. Límites de recursos

Evita que un servicio se coma la máquina entera.

deploy:
  resources:
    limits:
      cpus: "1.5"
      memory: 512M

130. Parar sin eliminar

Mantiene los contenedores para volver a encenderlos después.

docker compose stop
docker compose start

131. Descargar las imágenes de la stack

Actualiza las imágenes antes de levantar.

docker compose pull

132. Ver el consumo de la stack

stats filtrado por los contenedores del proyecto.

docker compose top
docker stats $(docker compose ps -q)

Producción, seguridad y diagnóstico

Lo que separa un contenedor que funciona en tu máquina de uno que aguanta producción.

133. Uso de disco de Docker

Muestra cuánto están ocupando las imágenes, los contenedores, los volúmenes y la caché.

docker system df
docker system df -v

134. Limpieza general

-a elimina también las imágenes sin contenedor. Comprueba antes — --volumes borra datos.

docker system prune
docker system prune -a
docker system prune -a --volumes

135. Limitar el tamaño de los logs

El log de un contenedor crece sin límite y llena el disco del servidor. Este es el error nº 1 en producción.

# /etc/docker/daemon.json
{
  "log-driver": "json-file",
  "log-opts": { "max-size": "10m", "max-file": "3" }
}

136. Ejecutar sin root

Contenedor root + volumen en el host = riesgo real de comprometer la máquina.

USER node               # en el Dockerfile
docker run --user 1000:1000 minha-app

137. Sistema de archivos de solo lectura

Si la aplicación no necesita escribir, no la dejes.

docker run -d --read-only --tmpfs /tmp minha-app

138. Descartar capabilities

Quita privilegios del kernel que la aplicación no usa.

docker run -d --cap-drop ALL --cap-add NET_BIND_SERVICE nginx

139. Impedir la escalada de privilegios

Bloquea que un binario con setuid gane privilegios dentro del contenedor.

docker run -d --security-opt no-new-privileges minha-app

140. Nunca uses --privileged

Equivale a darle al contenedor el root del host. Solo en casos muy concretos y conscientes.

# evítalo
docker run --privileged minha-app

141. No expongas el socket de Docker

Montar /var/run/docker.sock da el control total del host a quien esté en el contenedor.

# peligroso
docker run -v /var/run/docker.sock:/var/run/docker.sock minha-app

142. Cierre elegante

Docker manda SIGTERM y espera 10s antes del SIGKILL. Tu aplicación tiene que tratar la señal.

docker stop -t 30 minha-app

143. Init para los zombis

--init inserta un init mínimo que recoge los procesos huérfanos.

docker run -d --init minha-app

144. Un contenedor que se reinicia sin parar

Mira el log de la ejecución anterior para encontrar la causa.

docker ps -a
docker logs --tail 200 minha-app
docker inspect -f '{{.State.ExitCode}} {{.State.Error}}' minha-app

145. Diagnosticar un OOM

El exit 137 casi siempre es falta de memoria.

docker inspect -f '{{.State.OOMKilled}}' minha-app
docker stats --no-stream minha-app

146. Depurar una imagen sin shell

Distroless no tiene shell: usa un contenedor auxiliar en el mismo namespace.

docker run --rm -it --pid container:minha-app --network container:minha-app \
  nicolaka/netshoot sh

147. Probar la imagen en local

Ejecútala como en producción antes de publicarla: sin bind mount, con las variables reales.

docker run --rm -p 3000:3000 --env-file .env.production minha-app:1.0

148. Registro y versión inmutable

Publica con una etiqueta de versión y despliega por digest — la garantía de que es exactamente esa imagen.

docker push usuario/app:1.4.2
docker inspect --format='{{index .RepoDigests 0}}' usuario/app:1.4.2

149. Docker en CI

Build y push dentro del pipeline, con caché entre ejecuciones.

docker buildx build --push \
  --cache-from type=registry,ref=usuario/app:cache \
  --cache-to type=registry,ref=usuario/app:cache,mode=max \
  -t usuario/app:$GIT_SHA .

150. Cuándo pasar a Kubernetes

Compose resuelve un servidor. Varios nodos, escalado automático y rolling updates piden un orquestador.

# Compose: 1 host, stack sencilla, equipo pequeño
# Kubernetes: múltiples nodos, autoscaling, despliegue sin downtime