Cheatsheet 02

Comandos de la CLI

Todo lo que se escribe en la terminal, agrupado por tema y explicado. Los comandos se ejecutan en PowerShell (o la terminal de VS Code) con Docker Desktop abierto. Lo que está entre < > se reemplaza por tu valor; el botón a la derecha de cada bloque lo copia.

Términos de esta página

Las ideas de fondo (imagen, contenedor, red, volumen) están explicadas en Conceptos.

CLI: Command Line Interface: usar un programa escribiendo comandos en la terminal. La CLI de Docker es el comando docker.
Subcomando: La palabra que sigue a docker y dice qué hacer: run, ps, logs… Algunos se agrupan por tema: docker image ls, docker network create.
Flag (opción): Lo que empieza con - o -- y modifica el comando: -d, --name. Van antes del nombre de la imagen.
Argumento: El dato sobre el que actúa el comando: el nombre de una imagen, de un contenedor, una ruta.
Detached (-d): Correr el contenedor “de fondo”: la terminal queda libre y el contenedor sigue corriendo.
Interactivo (-it): Conectar tu teclado y pantalla al contenedor, para usar una terminal adentro.
Variable de entorno (-e): Un par NOMBRE=valor que el programa del contenedor puede leer, típicamente para configuración (usuarios, contraseñas, URLs).
Prune: “Podar”: borrar en lote lo que no se usa (contenedores detenidos, imágenes huérfanas…).
Imagen colgada: Una imagen vieja que quedó sin nombre (<none>) después de reconstruir otra con el mismo tag.
\ al final de línea: Partir un comando largo en varias líneas (en Bash). En PowerShell el equivalente es la comilla invertida `, o escribirlo todo en una línea.

Cómo se lee un comando de Docker

docker run -d --name web -p 8080:80 nginx:1.27

Parte	Qué es
`docker`	El programa
`run`	El subcomando: qué hacer (crear y arrancar un contenedor)
`-d`	Flag sin valor: en segundo plano
`--name web`	Flag con valor: el nombre del contenedor
`-p 8080:80`	Flag con valor: mapeo de puertos (PC:contenedor)
`nginx:1.27`	El argumento: la imagen y su versión

Reglas que conviene saber

Las flags van entre el subcomando y la imagen. Lo que escribas después de la imagen se le pasa al programa del contenedor, no a Docker.
Muchas flags tienen forma corta y larga: -d = --detach, -e = --env.
Para referirte a un contenedor podés usar su nombre o los primeros caracteres de su ID (docker stop 3f9c).
Cualquier comando acepta --help: docker run --help lista todas sus opciones.

Imágenes

Descargar, listar, construir y borrar.

Descargar (pull)

docker pull <imagen>:<version>

Descarga una imagen desde Docker Hub (el catálogo público de imágenes) y la guarda en tu PC, sin crear ningún contenedor. Si no ponés versión, Docker usa :latest, que es “la más nueva”: cambia con el tiempo, así que en proyectos conviene fijar una versión concreta.

docker pull node:18
docker pull node:latest
docker pull mysql:latest
docker pull mongo

Ejemplos: Node 18 fijo, la última de Node, MySQL y MongoDB. Si la imagen ya está descargada y no cambió, Docker lo avisa (Image is up to date) y no baja nada.

Listar imágenes

docker images

Lista las imágenes que tenés en tu PC, descargadas o construidas por vos. Muestra REPOSITORY (nombre), TAG (versión), IMAGE ID y SIZE. Es lo mismo que docker image ls. Las que aparecen como <none> son versiones viejas que quedaron sin nombre al reconstruir.

docker image inspect <imagen>

Muestra en formato JSON toda la información de una imagen: sus capas, variables de entorno, el comando que ejecuta al arrancar (Cmd) y los puertos que declara (ExposedPorts). Sirve para saber cómo se usa una imagen que no hiciste vos.

docker history <imagen>

Lista las capas de la imagen, de la más nueva a la más vieja, con el tamaño de cada una y la instrucción del Dockerfile que la generó. Útil para encontrar qué paso hace pesada a una imagen.

Borrar imágenes

docker image rm <imagen>:<version>

Borra una imagen de tu PC (no afecta a Docker Hub). El atajo docker rmi hace lo mismo. Podés indicar la imagen por nombre y versión o por su IMAGE ID.

docker image rm node:16
docker image rm mysql:latest

Ejemplos. Falla con “image is being used by stopped container” si algún contenedor, aunque esté detenido, se creó con esa imagen: primero borrá el contenedor (docker rm) o forzalo con -f.

docker image prune

Borra imágenes “colgadas” (<none>) que quedan tras rebuilds. Con -a borra todas las que no usa ningún contenedor.

Construir una imagen (build)

docker build -t <nombre>:<tag> <ruta-contexto>

Construye una imagen siguiendo el Dockerfile que hay en la ruta indicada. -t (tag) le pone nombre y versión. El último argumento es el contexto: la carpeta cuyos archivos puede copiar el Dockerfile. Ojo: hay un espacio entre el tag y la ruta.

docker build -t miapp:1 .

El . significa “la carpeta actual”: Docker usa el Dockerfile de ahí y puede copiar cualquier archivo de esa carpeta. Al terminar, miapp:1 aparece en docker images.

docker build -t miapp:dev -f Dockerfile.dev .

-f (file) indica qué Dockerfile usar cuando no se llama exactamente Dockerfile, por ejemplo uno separado para desarrollo. El contexto sigue siendo el . del final.

docker build --no-cache -t miapp:1 .

Reconstruye todos los pasos desde cero, sin reutilizar capas guardadas. Usalo cuando sospechás que la caché quedó vieja, por ejemplo si un RUN apt-get update no trae paquetes nuevos. Tarda más.

Etiquetar y subir

docker tag miapp:1 <usuario>/miapp:1

Le agrega otro nombre a una imagen que ya existe, sin copiarla (las dos etiquetas apuntan a la misma imagen). Para subir a Docker Hub el nombre tiene que empezar con tu usuario: <usuario>/miapp.

docker login
docker push <usuario>/miapp:1

docker login te pide usuario y contraseña (o un access token) de Docker Hub y los recuerda. docker push sube la imagen a tu cuenta; después cualquiera con acceso puede bajarla con docker pull <usuario>/miapp:1.

Contenedores

Crear, arrancar, detener, listar, borrar. Se referencian por ID (alcanzan los primeros caracteres) o nombre.

Crear (sin arrancar)

docker create <imagen>

Crea el contenedor y devuelve su ID. Queda en estado created. Igual a docker container create.

docker create --name <nombre> <imagen>

Crea un contenedor a partir de una imagen, pero no lo arranca (queda en estado Created; se inicia con docker start). --name le da un nombre para usarlo en los demás comandos; si no lo ponés, Docker inventa uno como jolly_turing.

docker create --name monguito \
  -p 27017:27017 \
  -e MONGO_INITDB_ROOT_USERNAME=mati \
  -e MONGO_INITDB_ROOT_PASSWORD=<password> \
  mongo

Un Mongo con puerto y usuario. -p 27017:27017 publica el puerto: PC:contenedor, así tu app local puede conectarse a localhost:27017. Cada -e define una variable de entorno que la imagen de Mongo lee al iniciar para crear el usuario administrador. Todas las opciones van antes del nombre de la imagen. La \ al final de línea solo sirve para partir el comando en varias líneas (en PowerShell se usa `).

Arrancar / detener

docker start <id|nombre>

Arranca un contenedor que ya existe (creado o detenido). Conserva todo lo que tenía: archivos, configuración y puertos. Devuelve la terminal enseguida.

docker stop <id|nombre>

Detiene el contenedor de forma ordenada: le avisa al programa que termine y, si no lo hace en 10 segundos, lo corta. El contenedor sigue existiendo (estado Exited) y se puede volver a arrancar.

docker restart <id|nombre>

Equivale a stop + start. Útil cuando cambiaste algo que el programa solo lee al iniciar, o para destrabar una app que dejó de responder.

docker pause <id|nombre>
docker unpause <id|nombre>

Congela los procesos del contenedor sin detenerlo: dejan de usar CPU pero conservan todo en memoria. docker unpause los reanuda en el mismo punto. Se usa poco; para apagar, usá stop.

Listar contenedores

docker ps

Lista los contenedores que están corriendo: ID, imagen, comando, hace cuánto se creó, estado y puertos publicados (por ejemplo 0.0.0.0:3000->3000/tcp). Si un contenedor no aparece, puede haberse detenido: probá con -a.

docker ps -a

Lista todos los contenedores, también los detenidos. En STATUS: Up = corriendo, Exited (0) = terminó bien, Exited (1) u otro número = terminó con error (mirá docker logs), Created = nunca se arrancó.

docker ps -q

Muestra solo los IDs, uno por línea, sin tabla. No sirve para leer, sino para pasarle esa lista a otro comando (ver “Atajos” al final de esta página).

Borrar contenedores

docker rm <id|nombre>

Borra un contenedor detenido, junto con los archivos que se hayan creado dentro de él (no borra la imagen ni los volúmenes). Ejemplo: docker rm 2d77ac5398a8; alcanza con los primeros caracteres del ID. Si está corriendo, primero docker stop.

docker rm -f <id|nombre>

-f (force) lo detiene de golpe y lo borra en un solo paso. Práctico en desarrollo; no le da tiempo al programa a cerrar ordenadamente.

docker container prune

Borra todos los contenedores detenidos de una vez. Pide confirmación (y). No toca los que están corriendo.

docker run — todo en uno

1) si no está la imagen, la descarga · 2) crea el contenedor · 3) lo inicia.

Formas de usar run

docker run <imagen>

Crea y arranca un contenedor en un solo paso (es create + start). Si la imagen no está en tu PC, la descarga antes. Sin -d, la terminal queda mostrando la salida del programa; Ctrl+C lo detiene.

docker run -d <imagen>

-d (detached, desconectado) lo deja corriendo en segundo plano y te devuelve la terminal. Docker imprime el ID del contenedor nuevo; para ver su salida usá docker logs.

docker run --name <nombre> -p <host>:<cont> -d <imagen>

La forma más habitual: con nombre propio, un puerto publicado y en segundo plano. -p 8080:80 hace que lo que entra por el puerto 8080 de tu PC llegue al puerto 80 del contenedor. Se abre en el navegador como http://localhost:8080.

docker run mongo -d no funciona como esperás: todo lo que va después de la imagen se pasa como argumento al proceso del contenedor. Escribí docker run -d mongo.

Recetas con run

docker run -d --name monguito -p 27017:27017 \
  -e MONGO_INITDB_ROOT_USERNAME=mati \
  -e MONGO_INITDB_ROOT_PASSWORD=<password> \
  -v mongo-data:/data/db \
  mongo

Un Mongo listo para usar. Además del puerto y el usuario (-e), -v mongo-data:/data/db guarda los datos en un volumen: si borrás el contenedor y creás otro con el mismo -v, los datos siguen ahí.

docker run --rm -it node:18 bash

Abre una terminal dentro de un contenedor nuevo de Node, para probar cosas. -it conecta tu teclado (interactive + tty); --rm borra el contenedor al salir con exit. Lo que va después de la imagen (bash) es el programa a ejecutar adentro.

docker run -d --name chanchito -p 3000:3000 --network mired miapp:1

Arranca tu app dentro de la red mired (creada antes con docker network create). Así puede conectarse a otros contenedores de esa red usando su nombre como dirección, por ejemplo mongodb://monguito:27017.

docker run -d --env-file .env -p 3000:3000 miapp:1

Carga las variables de entorno desde un archivo .env (una por línea, CLAVE=valor) en vez de escribir muchos -e. Evita dejar contraseñas en el historial de la terminal.

Flags más usadas

Sirven para create y run. Siempre van antes del nombre de la imagen.

Tabla de flags

Flag	Para qué	Ejemplo
`--name`	Nombre del contenedor (también su hostname en la red)	`--name monguito`
`-p`	Publica puerto HOST:CONTENEDOR	`-p 3000:3000` · `-p 8080:3000`
`-e`	Variable de entorno (repetible)	`-e NODE_ENV=production`
`--env-file`	Variables desde archivo	`--env-file .env`
`-d`	Segundo plano (detached)	`docker run -d mongo`
`-it`	Interactivo + terminal (para shells)	`docker run -it node:18 bash`
`--rm`	Borra el contenedor al terminar	`docker run --rm alpine ls`
`--network`	Conecta a una red	`--network mired`
`-v`	Volumen nombrado o bind mount	`-v mongo-data:/data/db` · `-v ${PWD}:/home/app`
`-w`	Directorio de trabajo dentro del contenedor	`-w /home/app`
`--restart`	Política de reinicio	`--restart unless-stopped`

Logs e inspección

Ver qué está pasando adentro.

Logs

docker logs <id|nombre>

Muestra todo lo que el programa del contenedor escribió en la consola: tus console.log, errores y mensajes de arranque. Es lo primero que hay que mirar cuando un contenedor no anda o se detiene solo. Funciona también con contenedores detenidos.

docker logs -f <id|nombre>

-f (follow) se queda mostrando los logs nuevos a medida que aparecen, como un monitor en vivo. Ctrl+C deja de mirar; el contenedor sigue corriendo.

docker logs --tail 100 -f <nombre>

Muestra solo las últimas 100 líneas y sigue en vivo. Útil cuando el contenedor lleva mucho tiempo andando y tiene miles de líneas de log.

Inspeccionar

docker inspect <id|nombre>

Toda la información del contenedor en JSON: su IP en cada red, volúmenes montados, variables de entorno, puertos y estado (incluido el código de salida si se detuvo). Para un solo dato: docker inspect -f "{{.State.Status}}" <nombre>.

docker port <nombre>

Muestra qué puertos del contenedor están publicados y en qué puerto de tu PC, por ejemplo 3000/tcp -> 0.0.0.0:3000. Si no muestra nada, el contenedor se creó sin -p.

docker stats

Una tabla en vivo con el uso de CPU, memoria, red y disco de cada contenedor corriendo. Ctrl+C para salir. Sirve para encontrar qué contenedor está consumiendo de más.

docker top <nombre>

Lista los procesos que corren dentro del contenedor, con su PID y comando. Permite confirmar que tu app sigue viva adentro.

Entrar al contenedor y copiar archivos

Para curiosear, depurar o ejecutar algo puntual.

Abrir una terminal adentro

docker exec -it <nombre> sh

Abre una terminal dentro de un contenedor que está corriendo, para mirar archivos o probar comandos desde adentro. -it conecta tu teclado. Salís con exit y el contenedor sigue funcionando.

docker exec -it <nombre> bash

Lo mismo, con bash, que tiene historial y autocompletado. Las imágenes alpine (versiones mínimas) no traen bash: si aparece “executable file not found”, usá sh.

docker exec -it monguito mongosh -u mati -p <password>

Abre la consola de MongoDB (mongosh) dentro del contenedor, con el usuario creado al arrancarlo. Ahí podés escribir show dbs o db.coleccion.find(). Salís con exit.

Ejecutar un comando suelto

docker exec <nombre> ls /home/app

Sin -it, ejecuta un solo comando dentro del contenedor, muestra el resultado y vuelve a tu terminal. Ejemplo: listar los archivos de la app para confirmar que se copiaron.

docker cp <nombre>:/ruta/archivo.txt ./archivo.txt
docker cp ./config.json <nombre>:/home/app/config.json

Copia archivos entre el contenedor y tu PC, en cualquier dirección: primero el origen y después el destino. La parte del contenedor se escribe nombre:/ruta. Funciona aunque el contenedor esté detenido.

Redes

Para que dos contenedores se comuniquen deben estar en la misma red.

Gestionar redes

docker network ls

Lista las redes de Docker. Siempre existen bridge (la red por defecto), host y none; las demás las creaste vos o Compose (con nombres como carpeta_default).

docker network create <nombre>

Crea una red propia. Los contenedores conectados a la misma red propia se encuentran usando su nombre como dirección (monguito en vez de una IP). En la red por defecto bridge eso no funciona. Ejemplo: docker network create mired.

docker network rm <nombre>

Borra una red. Falla si todavía hay contenedores conectados: detenelos o desconectalos primero.

docker network inspect <nombre>

Muestra la configuración de la red y, en Containers, qué contenedores están conectados y la IP de cada uno. Útil cuando dos contenedores no se ven entre sí.

Conectar contenedores

docker create --name monguito \
  -p 27017:27017 --network mired \
  -e MONGO_INITDB_ROOT_USERNAME=mati \
  -e MONGO_INITDB_ROOT_PASSWORD=<password> \
  mongo

El mismo Mongo de antes, pero con --network mired: ya nace conectado a esa red, así tu app (en la misma red) lo encuentra como monguito:27017.

docker network connect mired <nombre>
docker network disconnect mired <nombre>

Conecta a una red un contenedor que ya existe (o lo desconecta con disconnect), sin recrearlo. Un contenedor puede estar en varias redes a la vez.

Dentro de la red, la app se conecta usando el nombre del contenedor como host: mongodb://mati:<pass>@monguito:27017/miapp?authSource=admin

Volúmenes

Datos que sobreviven aunque borres el contenedor.

Gestionar volúmenes

docker volume ls

Listar volúmenes. Los de compose se llaman <carpeta>_<volumen> (ej: mi-proyecto_mongo-data).

docker volume create <nombre>

Crea un volumen: un espacio de almacenamiento que administra Docker y que sobrevive aunque borres el contenedor. Casi nunca hace falta crearlo a mano: -v nombre:/ruta o Compose lo crean solos si no existe.

docker volume inspect <nombre>

Muestra dónde guarda Docker los datos (Mountpoint, una ruta dentro de la máquina virtual de Docker Desktop, no una carpeta de Windows) y cuándo se creó.

docker volume rm <nombre>

Borra el volumen y sus datos para siempre. Falla si algún contenedor, aunque esté detenido, lo usa: borrá primero el contenedor. docker volume ls lista los existentes.

Montar volúmenes

docker run -d -v mongo-data:/data/db mongo

Volumen nombrado: -v nombre:ruta-dentro-del-contenedor. Todo lo que Mongo escribe en /data/db queda en el volumen mongo-data. Es la forma recomendada para datos de bases de datos.

# PowerShell
docker run -d -v ${PWD}:/home/app -p 3000:3000 miapp:dev
# Git Bash / Linux / macOS
docker run -d -v "$(pwd)":/home/app -p 3000:3000 miapp:dev

Bind mount: en vez de un volumen, monta una carpeta de tu PC dentro del contenedor (${PWD} o $(pwd) = la carpeta actual). Si editás un archivo en tu PC, el contenedor lo ve al instante: se usa en desarrollo junto con nodemon. La sintaxis de la carpeta actual cambia según la terminal.

Limpieza y espacio en disco

Docker acumula basura rápido. Leé qué borra cada uno antes de ejecutarlo.

Liberar espacio

docker system df

Muestra cuánto disco ocupa Docker, separado en imágenes, contenedores, volúmenes y caché de builds, y cuánto se podría liberar (RECLAIMABLE).

docker system prune

Borra contenedores detenidos, redes sin uso, imágenes colgadas y caché de build. No toca volúmenes.

docker system prune -a --volumes

Limpieza total: además de lo anterior, borra todas las imágenes que no use ningún contenedor (habrá que volver a descargarlas) y los volúmenes sin uso, incluidos datos de bases de datos de contenedores borrados. Leé bien la confirmación antes de aceptar.

docker builder prune

Borra solo la caché de construcción de imágenes. Libera bastante espacio si construís seguido; el próximo docker build tarda más porque no reutiliza pasos.

Borrado en lote

# PowerShell / Bash
docker stop $(docker ps -q)

$(docker ps -q) ejecuta primero docker ps -q (los IDs de los que corren) y pone el resultado como argumentos de docker stop. Resultado: detiene todos los contenedores en marcha.

docker rm $(docker ps -aq)

Mismo truco con -aq (todos los IDs, también los detenidos): borra todos los contenedores. Los que estén corriendo dan error y quedan; detenelos antes con el comando anterior.

docker volume prune

Borra los volúmenes que no usa ningún contenedor. Pide confirmación. Ojo: un volumen de base de datos cuyo contenedor borraste cuenta como “sin uso”.

Ejemplo completo a mano (sin compose)

Lo mismo que hace tu docker-compose.yml, paso a paso.

App Node (chanchito) + MongoDB (monguito)

# 1. Red compartida
docker network create mired

# 2. Base de datos dentro de la red
docker create --name monguito -p 27017:27017 --network mired \
  -e MONGO_INITDB_ROOT_USERNAME=mati \
  -e MONGO_INITDB_ROOT_PASSWORD=<password> \
  -v mongo-data:/data/db \
  mongo

# 3. Imagen de la app (desde la carpeta del proyecto)
docker build -t miapp:1 .

# 4. Contenedor de la app en la misma red
docker create --name chanchito -p 3000:3000 --network mired miapp:1

# 5. Arrancar ambos
docker start monguito
docker start chanchito

# 6. Probar
#    http://localhost:3000/crear   -> crea un documento
#    http://localhost:3000         -> lista los documentos
docker logs -f chanchito

Los mismos pasos que hace Compose, a mano: red, base de datos dentro de la red, imagen de la app y app dentro de la red apuntando a monguito. Con un docker-compose.yml todo esto se reduce a docker compose up (ver la hoja de Compose).

No hay comandos que coincidan con la búsqueda.