Docker: Comandos de Producción

Muestra la versión del cliente Docker instalada en su sistema, útil para verificar la compatibilidad y el entorno.

docker --version

Proporciona un resumen detallado de la información del sistema Docker, incluyendo el número de contenedores (en ejecución, pausados, detenidos), imágenes, volúmenes, redes y configuraciones del daemon.

docker info

Similar a `docker info`, este comando puede ofrecer una vista más específica o formateada de la información del sistema Docker, dependiendo de la versión y configuración.

docker system info

Muestra el uso de espacio en disco por Docker, detallando el consumo por imágenes, contenedores, volúmenes y caché de build, ayudando a identificar dónde se está utilizando el espacio.

docker system df

Muestra las versiones del cliente (CLI) y del servidor (daemon) Docker, permitiendo verificar la comunicación y la compatibilidad entre ellos.

docker version

Transmite eventos en tiempo real del daemon Docker, como creación, inicio, parada y destrucción de contenedores, imágenes y volúmenes, útil para monitoreo continuo.

docker system events

Muestra eventos del daemon Docker ocurridos en la última hora, útil para revisar actividades recientes del sistema y depurar problemas que surgieron recientemente.

docker system events --since 1h

Elimina datos no utilizados por Docker que fueron creados hace más de 24 horas, como containers detenidos, imágenes sin etiqueta y caché de build, ayudando a liberar espacio de forma selectiva.

docker system prune --filter until=24h

Lista todos os containers Docker que estão atualmente em execução, mostrando seus IDs, nomes, imagens, comandos, portas mapeadas e status.

docker ps

Lista todos los contenedores Docker, incluyendo aquellos que están detenidos o han sido terminados (`-a` para "all").

docker ps -a

Lista solo los IDs de los contenedores Docker que están en ejecución, útil para encadenar comandos o scripts automatizados.

docker ps -q

Lista contenedores en ejecución con un formato de tabla personalizado, mostrando solo los nombres, estado y puertos mapeados, permitiendo una visualización más limpia y enfocada.

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

Ejecuta un nuevo contenedor a partir de la imagen `blueprint-backend` y mapea el puerto `3001` del host al puerto `3001` dentro del contenedor (`-p` para "publish"), permitiendo acceso externo al servicio.

docker run -p 3001:3001 blueprint-backend

Ejecuta un nuevo contenedor en modo `detached` (segundo plano, `-d`), asigna el nombre `backend` (`--name`) y mapea el puerto `3001` del host al puerto `3001` del contenedor.

docker run -d --name backend -p 3001:3001 blueprint-backend

Ejecuta un container de la imagen `alpine` en modo interactivo (`-i`) con un pseudo-TTY (`-t`), ejecutando el comando `sh`. El container será automáticamente eliminado (`--rm`) al ser terminado.

docker run -it --rm alpine sh

Ejecuta un container de la imagen `app` y define la variable de entorno `NODE_ENV` como `production` (`-e` para "env"), útil para configurar el comportamiento de la aplicación dentro del container.

docker run -e NODE_ENV=production app

Ejecuta un container de la imagen `node`, montando el directorio de trabajo actual del host (`$(pwd)`) como `/app` dentro del container (`-v` para "volumen") y definiendo `/app` como el directorio de trabajo (`-w`). Luego, ejecuta `npm install`.

docker run -v $(pwd):/app -w /app node npm install

Ejecuta un container de la imagen `app` y configura una política de reinicio automático (`--restart unless-stopped`), garantizando que el container será reiniciado automáticamente a menos que sea explícitamente detenido.

docker run --restart unless-stopped app

Ejecuta un container de la imagen `app` y limita la cantidad de memoria RAM que puede usar a 256 megabytes (`--memory`), útil para el control de recursos.

docker run --memory="256m" app

Ejecuta un container de la imagen `app` y limita el uso de la CPU a 0.5 (equivalente al 50% de un núcleo de CPU) (`--cpus`), útil para el control de recursos.

docker run --cpus="0.5" app

Envía una señal SIGTERM al contenedor especificado, solicitando su terminación gracefully. Después de un tiempo límite, si el contenedor no se detiene, se envía un SIGKILL.

docker stop container_name

Detiene todos los contenedores Docker en ejecución, utilizando la salida de `docker ps -q` (que lista solo los IDs de los contenedores en ejecución) como argumento para `docker stop`.

docker stop $(docker ps -q)

Elimina un contenedor Docker específico. El contenedor debe estar detenido antes de ser eliminado, a menos que se use la bandera `-f` (force).

docker rm container_name

Elimina todos los contenedores Docker, tanto los en ejecución como los detenidos, utilizando la salida de `docker ps -aq` (que lista todos los IDs) como argumento para `docker rm`.

docker rm $(docker ps -aq)

Reinicia un contenedor Docker en ejecución, deteniéndolo e iniciándolo de nuevo.

docker restart container_name

Pausa todos los procesos dentro de un contenedor en ejecución, suspendiéndolo temporalmente sin terminarlo, liberando recursos de la CPU pero manteniendo la memoria.

docker pause container_name

Despausa un contenedor que fue previamente pausado, permitiendo que sus procesos continúen la ejecución.

docker unpause container_name

Fuerza la parada inmediata de un contenedor Docker enviando una señal SIGKILL, sin esperar que se cierre gracefuly. Use con cautela, ya que puede resultar en pérdida de datos.

docker kill container_name

Lista todas las imágenes Docker almacenadas localmente, mostrando sus repositorios, tags, IDs y tamaños.

docker images

Lista todas las imágenes Docker, incluyendo las capas intermedias (`-a` para "all"), que normalmente están ocultas y pueden consumir espacio.

docker images -a

Lista imagens Docker com um formato de tabela personalizado, exibindo repositório, tag e tamanho, para uma visualização mais organizada e focada.

docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}"

Construye una imagen Docker a partir del `Dockerfile` ubicado en el directorio `./backend` y la etiqueta con el nombre `blueprint-backend` (`-t` para "tag").

docker build -t blueprint-backend ./backend

Construye una imagen Docker a partir del `Dockerfile` ubicado en el directorio `./frontend` y la etiqueta con el nombre `blueprint-frontend`.

docker build -t blueprint-frontend ./frontend

Construye una imagen Docker a partir del `Dockerfile` en el directorio actual, sin utilizar la caché de capas (`--no-cache`), garantizando que todas las etapas se ejecuten desde cero, y la etiqueta como `app:latest`.

docker build --no-cache -t app:latest .

Construye una imagen Docker a partir del `Dockerfile` en el directorio actual, utilizando una etapa específica de build (`--target production`) definida en el Dockerfile multi-stage, y la etiqueta como `app:prod`.

docker build --target production -t app:prod .

Construye una imagen Docker a partir del `Dockerfile` en el directorio actual, pasando un argumento de build (`--build-arg NODE_ENV=production`) que puede ser usado dentro del Dockerfile durante el proceso de build, y la etiqueta como `app`.

docker build --build-arg NODE_ENV=production -t app .

Construye una imagen Docker con una salida de progreso detallada y sin formato especial (`--progress=plain`), útil para depuración en entornos CI/CD o cuando la salida estándar no es un TTY.

docker build --progress=plain -t app .

Construye una imagen Docker y "aplana" las capas resultantes en una única capa después de la imagen base, reduciendo el número de capas y, potencialmente, el tamaño final de la imagen (`--squash`).

docker build --squash -t app .

Construye una imagen Docker y añade una etiqueta (label) `version=1.0` (`--label`) a la imagen, útil para metadatos, organización y filtrado.

docker build --label version=1.0 -t app .

Elimina una imagen Docker específica del almacenamiento local. La imagen no puede estar en uso por ningún container para ser eliminada.

docker rmi image_name

Elimina todas las imágenes Docker no utilizadas, utilizando la salida de `docker images -q` (que lista solo los IDs de las imágenes) como argumento para `docker rmi`.

docker rmi $(docker images -q)

Elimina imágenes Docker que no están asociadas a ningún contenedor y no tienen tags (imágenes "colgantes" o "huérfanas"), liberando espacio en disco.

docker image prune

Elimina todas las imágenes Docker no utilizadas, incluyendo las capas intermedias (`-a` para "all"), que no son referenciadas por ninguna imagen nombrada.

docker image prune -a

Crea una nueva etiqueta (`target:1.0`) para una imagen existente (`source:latest`), permitiendo referenciar la misma imagen con nombres diferentes o versiones específicas.

docker tag source:latest target:1.0

Envía una imagen Docker a un registro remoto (`registry.com/app:latest`), haciéndola disponible para otros usuarios o sistemas.

docker push registry.com/app:latest

Descarga una imagen Docker de un registro remoto (`registry.com/app:latest`) al almacenamiento local de su sistema.

docker pull registry.com/app:latest

Muestra la salida de log estándar (stdout/stderr) de un contenedor Docker específico, útil para depuración y monitoreo.

docker logs container_name

Muestra los logs de un contenedor en tiempo real, siguiendo nuevas entradas (`-f` para "follow"), manteniendo la conexión abierta y mostrando los logs a medida que se generan.

docker logs -f container_name

Muestra las últimas 50 líneas de log de un contenedor específico (`--tail`), útil para una rápida verificación de eventos recientes sin cargar todo el historial.

docker logs --tail 50 container_name

Muestra los logs de un contenedor generados en las últimas 2 horas (`--since`), permitiendo filtrar logs por período de tiempo para enfocarse en eventos recientes.

docker logs --since="2h" container_name

Muestra los logs de un contenedor, añadiendo un timestamp a cada línea de log (`--timestamps`), lo que es útil para análisis cronológico y correlación de eventos.

docker logs --timestamps container_name

Muestra un flujo en tiempo real de estadísticas de uso de recursos (CPU, memoria, red, I/O de disco) para todos los containers en ejecución, útil para el monitoreo de rendimiento e identificación de cuellos de botella.

docker stats

Muestra estadísticas de uso de recursos en tiempo real para un container Docker específico, permitiendo enfocarse en el rendimiento de un único servicio.

docker stats container_name

Muestra los procesos en ejecución dentro de un container Docker específico, similar al comando `top` de Linux, útil para depuración y verificación de qué procesos están activos.

docker top container_name

Muestra una instantánea estática de las estadísticas de uso de recursos para los containers en ejecución, sin el flujo continuo en tiempo real (`--no-stream`), útil para capturas puntuales.

docker stats --no-stream

Muestra estadísticas de uso de recursos de los containers con un formato de tabla personalizado, mostrando el nombre del container y el porcentaje de uso de la CPU, para una visualización concisa.

docker stats --format "table {{.Container}}\t{{.CPUPerc}}"

Transmite eventos en tiempo real del daemon Docker, como creación, inicio, detención y destrucción de containers, imágenes y volúmenes, útil para auditoría y automatización.

docker events

Muestra información detallada de bajo nivel sobre un contenedor Docker específico en formato JSON, incluyendo configuraciones de red, volúmenes, estado, metadatos e historial de eventos.

docker inspect container_name

Muestra información detallada de bajo nivel sobre una imagen Docker específica en formato JSON, incluyendo capas, metadatos, configuraciones de puertos y variables de entorno.

docker inspect image_name

Ejecuta el comando `bash` dentro de un contenedor Docker en ejecución, asignando un pseudo-TTY (`-t`) y manteniendo la entrada estándar abierta (`-i`) para interacción, permitiendo acceso al shell del contenedor.

docker exec -it container_name bash

Ejecuta el comando `sh` (shell básico) dentro de un contenedor Docker en ejecución en modo interactivo con pseudo-TTY, útil cuando `bash` no está disponible en el contenedor.

docker exec -it container_name sh

Ejecuta un comando específico (`ls -la /app`) dentro de un contenedor Docker en ejecución, sin necesidad de interacción con un shell.

docker exec container_name ls -la /app

Copia el archivo `file.txt` del host al directorio `/app/` dentro del contenedor especificado (`container_name`).

docker cp file.txt container_name:/app/

Copia el directorio `logs` de dentro del contenedor especificado (`container_name:/app/logs`) al directorio local `./logs` en el host.

docker cp container_name:/app/logs ./logs

Muestra los mapeos de puertos para un contenedor Docker específico, mostrando qué puertos del host están conectados a qué puertos del contenedor.

docker port container_name

Ejecuta un container de la imagen `nginx` y mapea el puerto `8080` del host al puerto `80` del container (`-p` para "publish"), permitiendo el acceso al servidor web.

docker run -p 8080:80 nginx

Ejecuta un container de la imagen `nginx` y mapea automáticamente todos los puertos expuestos en el `Dockerfile` del container a puertos aleatorios y no utilizados en el host (`-P` para "publish all").

docker run -P nginx

Ejecuta el comando `bash` dentro de un container en ejecución como el usuario `root` (`-u`), útil para tareas administrativas que requieren privilegios elevados.

docker exec -u root container bash

Ejecuta el comando `sleep 60` dentro de un container en ejecución en modo `detached` (segundo plano, `-d`), sin bloquear el terminal actual.

docker exec -d container sleep 60

Ejecuta un comando (`cmd`) dentro de un container en ejecución, pasando una variable de entorno (`--env VAR=value`) que estará disponible solo para la ejecución de ese comando.

docker exec -it container --env VAR=value cmd

Elimina todos los datos no utilizados por Docker, incluyendo contenedores detenidos, redes no utilizadas e imágenes colgantes, pero no volúmenes por defecto.

docker system prune

Elimina todos los datos no utilizados por Docker, incluyendo contenedores detenidos, redes no utilizadas, imágenes colgantes y todas las imágenes sin etiqueta (`-a` para "all").

docker system prune -a

Elimina todos los datos no utilizados por Docker, incluyendo volúmenes no referenciados por ningún contenedor (`--volumes`), además de contenedores detenidos, redes e imágenes colgantes.

docker system prune --volumes

Elimina todos los contenedores Docker que están detenidos, liberando recursos y espacio en disco.

docker container prune

Elimina imágenes Docker que no están asociadas a ningún contenedor y no tienen tags (imágenes "colgadas" o "huérfanas").

docker image prune

Elimina todos los volúmenes Docker que no están siendo utilizados por ningún container, liberando espacio en disco. Use con cautela para evitar la pérdida de datos.

docker volume prune

Elimina todas las redes Docker que no están siendo utilizadas por ningún container, liberando recursos de red.

docker network prune

Muestra el uso de espacio en disco por Docker de forma detallada (`-v` para "verbose"), mostrando información más granular sobre el consumo de cada tipo de recurso.

docker system df -v

Muestra eventos del daemon Docker, filtrando solo los eventos relacionados con containers (`--filter type=container`), útil para monitorear actividades específicas.

docker system events --filter type=container

Limpia el caché de build de Docker, eliminando capas intermedias no utilizadas, lo que puede liberar espacio en disco y resolver problemas de build.

docker builder prune

Muestra un resumen del uso de espacio en disco por Docker, detallando el consumo por imágenes, containers, volúmenes y caché de build.

docker system df

Lista imágenes Docker con un formato de tabla personalizado, mostrando repositorio, tag y tamaño, para un análisis rápido del espacio ocupado por imágenes.

docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}"

Exibe a versão do Docker Compose instalada, útil para verificar a compatibilidade e os recursos disponíveis.

docker-compose --version

Construye, (re)crea, inicia y se adjunta a los contenedores para todos los servicios definidos en el archivo `docker-compose.yml`, ejecutando en primer plano y mostrando los logs.

docker-compose up

Construye, (re)crea, inicia y se adjunta a los contenedores para todos los servicios definidos en el archivo `docker-compose.yml`, ejecutándose en modo `detached` (segundo plano).

docker-compose up -d

Inicia solo el servicio `backend` y sus dependencias definidas en el archivo `docker-compose.yml`.

docker-compose up backend

Construye las imágenes de los servicios antes de iniciar los contenedores, garantizando que las imágenes estén actualizadas con los últimos cambios en el `Dockerfile`.

docker-compose up --build

Recrea todos los contenedores, incluso si no hay cambios en la configuración o imagen, útil para resolver problemas o aplicar nuevas configuraciones.

docker-compose up --force-recreate

Elimina containers de servicios que ya no están definidos en el archivo `docker-compose.yml` (huérfanos) al iniciar, limpiando el entorno.

docker-compose up --remove-orphans

Inicia un servicio específico sin iniciar sus dependencias, útil para probar un componente de forma aislada.

docker-compose up --no-deps

Define un tiempo límite de 30 segundos para el apagado graceful de los containers al detener o reiniciar los servicios durante el `up`.

docker-compose up --timeout 30

Detiene y elimina los containers, redes y volúmenes estándar creados por `docker-compose up`.

docker-compose down

Detiene y elimina los containers, redes y también los volúmenes nombrados definidos en el archivo `docker-compose.yml` (`-v` para "volúmenes").

docker-compose down -v

Detiene los containers de los servicios definidos en el `docker-compose.yml`, pero no los elimina, permitiendo que sean reiniciados posteriormente con `docker-compose start`.

docker-compose stop

Detiene solo el contenedor del servicio `backend` definido en el `docker-compose.yml`.

docker-compose stop backend

Detiene y elimina los contenedores, redes y también las imágenes creadas por los servicios (`--rmi all`), liberando más espacio en disco.

docker-compose down --rmi all

Define un tiempo límite de 10 segundos para el apagado graceful de los contenedores al detener los servicios con `down`.

docker-compose down --timeout 10

Elimina los contenedores detenidos sin pedir confirmación (`-f` para "force").

docker-compose rm -f

Detiene y elimina los contenedores, redes y también cualquier contenedor que ya no esté referenciado en el archivo `docker-compose.yml`.

docker-compose down --remove-orphans

Muestra la salida de log consolidada de todos los servicios definidos en el `docker-compose.yml`.

docker-compose logs

Muestra la salida de log de todos los servicios en tiempo real, siguiendo nuevas entradas (`-f` para "follow"), manteniendo la conexión abierta.

docker-compose logs -f

Muestra la salida de log solo del servicio `backend`.

docker-compose logs backend

Ejecuta el comando `bash` dentro del contenedor del servicio `backend`, permitiendo acceso interactivo al shell del contenedor.

docker-compose exec backend bash

Ejecuta un comando específico (`cargo build`) dentro del contenedor del servicio `backend`.

docker-compose exec backend cargo build

Muestra las últimas 50 líneas de log del servicio `backend`.

docker-compose logs --tail 50 backend

Muestra los logs del servicio `backend` generados en la última hora.

docker-compose logs --since="1h" backend

Ejecuta el comando `ls -la` dentro del contenedor del servicio `backend` sin asignar un pseudo-TTY (`-T`), útil para scripts automatizados o cuando la salida no necesita formato interactivo.

docker-compose exec -T backend ls -la

Ejecuta el comando `bash` dentro del contenedor del servicio `backend` como el usuario `root` (`-u`), útil para tareas administrativas que requieren privilegios elevados.

docker-compose exec -u root backend bash

Construye las imágenes para todos los servicios que tienen un `build` definido en el `docker-compose.yml`.

docker-compose build

Construye la imagen solo para el servicio `backend`.

docker-compose build backend

Construye las imágenes de los servicios sin utilizar la caché de capas, garantizando un build limpio y desde cero, útil para resolver problemas de caché.

docker-compose build --no-cache

Inicia los servicios en modo `detached` y escala el servicio `backend` a 3 instancias, útil para balanceo de carga o pruebas de rendimiento.

docker-compose up -d --scale backend=3

Descarga las imágenes más recientes para todos los servicios definidos en el `docker-compose.yml` de sus respectivos repositorios.

docker-compose pull

Valida y muestra la configuración efectiva del `docker-compose.yml` (y archivos de override), útil para depuración de la configuración antes de iniciar los servicios.

docker-compose config

Lista todos los contenedores creados por Docker Compose, mostrando su estado, puertos y nombres, similar a `docker ps` pero enfocado en los servicios de Compose.

docker-compose ps

Construye las imágenes para múltiples servicios en paralelo, acelerando el proceso de build para proyectos con muchos servicios.

docker-compose build --parallel

Construye las imágenes con una salida de progreso detallada y sin formato especial, útil para entornos CI/CD o logs.

docker-compose build --progress=plain

Inicia los servicios y escala múltiples servicios simultáneamente, por ejemplo, `web` a 2 instancias y `db` a 1 instancia, en una única operación.

docker-compose up --scale web=2 --scale db=1

Ejecuta un comando one-off en un nuevo contenedor del servicio `backend`, pasando una variable de entorno `VAR` con el valor `value` inline.

docker-compose run --env VAR=value backend

Ejecuta un comando one-off en un nuevo contenedor del servicio `backend`, cargando variables de entorno de un archivo `.env` específico.

docker-compose run --env-file .env backend

Muestra solo los nombres de los servicios definidos en la configuración del `docker-compose.yml`, útil para scripts o automatización.

docker-compose config --services

Inicia los servicios utilizando variables de entorno definidas en un archivo `prod.env` específico, sobrescribiendo o complementando las del `.env` estándar, para diferentes entornos.

docker-compose --env-file prod.env up

Ejecuta el comando `env` dentro de un nuevo contenedor del servicio `backend` y lo elimina (`--rm`) después de la ejecución, para listar las variables de entorno disponibles para el servicio.

docker-compose run --rm backend env

Ejecuta el comando `printenv` dentro del contenedor *en ejecución* del servicio `backend` para listar sus variables de entorno.

docker-compose exec backend printenv

Inicia los servicios bajo un nombre de proyecto específico (`--project-name proyecto`), lo que afecta los nombres de los contenedores, redes y volúmenes creados, útil para aislar entornos.

docker-compose --project-name projeto up

Inicia los servicios en modo `detached`, especificando el driver de volumen `local` para volúmenes definidos en los servicios. Generalmente, el driver se configura directamente en el `docker-compose.yml`.

docker-compose up -d --volume-driver local

Ejecuta el comando `ls /data` dentro del contenedor del servicio `backend` para listar el contenido de un volumen montado en `/data`.

docker-compose exec backend ls /data

Ejecuta el comando `ls /shared` en un nuevo contenedor del servicio `backend` (que se elimina después de la ejecución) para listar el contenido de un volumen compartido montado en `/shared`.

docker-compose run --rm backend ls /shared

Este comando no añade un alias de red directamente vía `up`. Los alias de red para servicios se definen dentro de la configuración de red del servicio en el archivo `docker-compose.yml` para permitir que otros servicios lo encuentren por ese nombre.

docker-compose up --network-alias web

Ejecuta el comando `ping database` dentro del contenedor del servicio `backend` para probar la conectividad de red con el servicio `database`.

docker-compose exec backend ping database

Detiene y elimina los contenedores, redes y todos los volúmenes nombrados definidos en el archivo `docker-compose.yml`.

docker-compose down --volumes

Lista todos los volúmenes Docker y filtra aquellos que contienen el nombre del proyecto (`projeto`), útil para identificar volúmenes creados por Docker Compose.

docker volume ls | grep projeto

Lista todas las redes Docker y filtra aquellas que contienen el nombre del proyecto (`projeto`), útil para identificar redes creadas por Docker Compose.

docker network ls | grep projeto

Inicia el servicio `backend` sin iniciar sus dependencias, útil para aislar y probar un único servicio.

docker-compose up --no-deps backend

Recrea los contenedores de un servicio específico sin iniciar sus dependencias, útil para forzar una recreación sin afectar a otros servicios.

docker-compose up --force-recreate --no-deps

Reinicia el contenedor del servicio `backend`.

docker-compose restart backend

Reinicia todos los contenedores de los servicios definidos en el `docker-compose.yml`.

docker-compose restart

Pausa el contenedor del servicio `backend`, suspendiendo sus procesos sin terminarlo.

docker-compose pause backend

Despausa el contenedor del servicio `backend` que fue previamente pausado.

docker-compose unpause backend

Fuerza la detención inmediata del contenedor del servicio `backend` enviando una señal SIGKILL, sin esperar un apagado elegante.

docker-compose kill backend

Reduce el número de instancias del servicio `backend` a cero, deteniendo y eliminando efectivamente todos los contenedores asociados a él.

docker-compose up --scale backend=0

Inicia los servicios utilizando un archivo `docker-compose` alternativo (`docker-compose.prod.yml`) en lugar del predeterminado, útil para diferentes entornos (producción, desarrollo).

docker-compose -f docker-compose.prod.yml up

Inicia los servicios combinando las configuraciones de múltiples archivos `docker-compose`, donde el segundo archivo (`override.yml`) puede sobrescribir o extender el primero.

docker-compose -f docker-compose.yml -f docker-compose.override.yml up

Activa el modo de compatibilidad, que intenta convertir opciones de `deploy` de Compose a opciones de `run` de Docker, útil para compatibilidad con Docker Swarm.

docker-compose --compatibility up

Inicia los servicios y muestra una salida detallada (`--verbose`) de lo que Docker Compose está haciendo, útil para depuración de problemas de inicialización.

docker-compose --verbose up

Inicia los servicios, deshabilitando la salida ANSI (colores) en el terminal (`--no-ansi`), útil para logs en sistemas que no interpretan códigos de color o para logs en archivos.

docker-compose --no-ansi up

Inicia los servicios que pertenecen al perfil `dev` (`--profile`), permitiendo activar/desactivar grupos de servicios con base en el entorno o propósito.

docker-compose --profile dev up

Inicia los servicios que pertenecen a los perfiles `dev` Y `test`, activando múltiples grupos de servicios simultáneamente.

docker-compose --profile dev --profile test up

Valida y muestra la configuración de `docker-compose.yml`, resolviendo y reemplazando todas las variables de entorno por sus valores actuales, útil para verificar la configuración final.

docker-compose config --resolve-env-vars

Inicia los servicios definidos en `docker-compose.test.yml` y cierra todos los demás contenedores si uno de ellos sale (`--abort-on-container-exit`), ideal para entornos de prueba automatizados donde el fallo de una prueba debe detener todo.

docker-compose -f docker-compose.test.yml up --abort-on-container-exit

Inicia los servicios definidos en `docker-compose.ci.yml`, reconstruyendo las imágenes, para un entorno de Integración Continua (CI) garantizando que el entorno esté siempre actualizado.

docker-compose -f docker-compose.ci.yml up --build

Executa o comando `npm test` em um novo container do serviço `backend` e o remove (`--rm`) após a execução, ideal para rodar testes unitários ou de integração de forma isolada.

docker-compose run --rm backend npm test

Ejecuta la herramienta de lint `flake8` en un nuevo contenedor del servicio `backend` y lo elimina (`--rm`) después de la ejecución, para análisis estático de código Python.

docker-compose run --rm backend flake8 .

Ejecuta el comando `python manage.py migrate` en un nuevo contenedor del servicio `backend` y lo elimina (`--rm`) después de la ejecución, para aplicar migraciones de base de datos en aplicaciones Django.

docker-compose run --rm backend python manage.py migrate

Ejecuta el comando `python manage.py collectstatic` dentro del contenedor en ejecución del servicio `backend` para recolectar archivos estáticos en aplicaciones Django.

docker-compose exec backend python manage.py collectstatic

Primero, detiene y elimina todos los servicios y sus redes (`down`), y luego los inicia nuevamente, reconstruyendo las imágenes (`up --build`), útil para un "reset" completo del entorno de desarrollo.

docker-compose down && docker-compose up --build

Muestra la versión de Docker Compose V2, que está integrada al cliente Docker (el comando `compose` es un subcomando de `docker`).

docker compose version

Inicia los servicios definidos en el archivo `docker-compose.yml` usando la sintaxis de la versión V2 de Docker Compose.

docker compose up

Monitorea el sistema de archivos y reinicia o reconstruye servicios automáticamente cuando se detectan cambios, útil para desarrollo local con retroalimentación instantánea.

docker compose watch

Intenta convertir un archivo `docker-compose.yml` de la versión V1 a la sintaxis de la versión V2, útil para migración. (Comando alpha, puede cambiar).

docker compose alpha convert

Valida y muestra la configuración efectiva de `docker-compose.yml` en formato JSON, útil para procesamiento programático o integración con otras herramientas.

docker compose config --format json

Ejecuta el comando `bash` en un nuevo contenedor del servicio `backend` (V2) y lo elimina (`--rm`) después de la ejecución.

docker compose run --rm backend bash

Inicia los servicios y espera hasta que todos los contenedores estén saludables (healthcheck) antes de considerar el comando completo, útil en scripts de CI/CD para garantizar que la aplicación esté lista.

docker compose up --wait

Inicia los servicios y se adjunta a los logs de todos los servicios, incluyendo sus dependencias, útil para observar el inicio completo de la aplicación y depurar problemas de inicialización entre servicios.

docker compose up --attach dependencies

Copia archivos o directorios desde dentro del contenedor del servicio `backend` a un directorio local en el host, usando la sintaxis V2 de Docker Compose.

docker compose cp backend:/app ./local

Detiene y elimina los servicios con un tiempo límite de 30 segundos para el apagado graceful, usando la sintaxis V2 de Docker Compose.

docker compose down --timeout 30

Lista todas las redes Docker en el sistema, mostrando sus IDs, nombres, drivers y alcances, útil para entender la topología de red.

docker network ls

Muestra información detallada de bajo nivel sobre la red Docker `bridge` en formato JSON, incluyendo contenedores conectados, configuraciones de IP y opciones.

docker network inspect bridge

Crea una nueva red Docker llamada `blueprint-net` usando el driver `bridge`, permitiendo que los contenedores conectados a ella se comuniquen fácilmente por nombre.

docker network create --driver bridge blueprint-net

Elimina una red Docker específica. La red debe estar vacía (sin contenedores conectados) para ser eliminada.

docker network rm network_name

Lista todos los volúmenes Docker almacenados localmente, mostrando sus nombres y drivers, útil para gestionar la persistencia de datos.

docker volume ls

Muestra información detallada de bajo nivel sobre un volumen Docker específico en formato JSON, incluyendo su driver, punto de montaje y opciones.

docker volume inspect volume_name

Elimina un volumen Docker específico. El volumen no puede estar en uso por ningún container. Use con cautela para evitar la pérdida de datos.

docker volume rm volume_name

Ejecuta un container de la imagen `alpine` y monta un volumen nombrado (`nombre_volume`) en el directorio `/data` dentro del container, garantizando la persistencia de datos.

docker run -v nome_volume:/data alpine

Ejecuta el comando `ping container2` dentro del `container1` para probar la conectividad de red entre dos containers en la misma red Docker.

docker exec -it container1 ping container2

Ejecuta el comando `curl` dentro del container `frontend` para probar la accesibilidad y el estado de salud de una API en el container `backend` en el puerto `3001`.

docker exec frontend curl http://backend:3001/health

Conecta un container Docker existente a una red Docker específica (en este caso, la red `bridge`), permitiendo que se comunique con otros containers en esa red.

docker network connect bridge container

Desconecta un contenedor Docker de una red específica (en este caso, la red `bridge`), aislándolo de esa red.

docker network disconnect bridge container

Crea un nuevo volumen Docker nombrado `data`, que puede ser usado para persistir datos entre contenedores o entre el host y contenedores, independientemente del ciclo de vida del contenedor.

docker volume create --name data

Verifica las versiones del cliente y del servidor (daemon) Docker, útil para confirmar si Docker está instalado y si el daemon está respondiendo.

docker version

Verifica el estado del servicio Docker en Linux usando `systemctl`, mostrando si el daemon está activo, en ejecución y cualquier mensaje de log reciente del sistema.

systemctl status docker

Verifica el estado del servicio Docker en Windows usando `Get-Service` (PowerShell), mostrando si el servicio está en ejecución.

Get-Service docker

Añade el usuario actual (`$USER`) al grupo `docker` en Linux, concediendo permisos para ejecutar comandos Docker sin `sudo`. Requiere cerrar/iniciar sesión o `newgrp docker` para aplicar.

sudo usermod -aG docker $USER

Cambia el grupo primario del shell actual a `docker`, aplicando los permisos del grupo sin la necesidad de cerrar y volver a iniciar sesión. Útil después de añadir el usuario al grupo docker.

newgrp docker

Muestra un resumen del uso de espacio en disco por Docker, detallando el consumo por imágenes, containers, volúmenes y caché de build, útil para diagnosticar problemas de espacio.

docker system df

Elimina todos los datos no utilizados por Docker, incluyendo containers detenidos, redes no utilizadas, imágenes colgantes y todas las imágenes sin etiqueta (`-a` para "all"), liberando el máximo espacio posible.

docker system prune -a

Lista todas las redes Docker en el sistema, mostrando sus IDs, nombres, drivers y alcances, útil para diagnosticar problemas de conectividad entre containers.

docker network ls

Muestra información detallada de bajo nivel sobre la red Docker `bridge` en formato JSON, incluyendo containers conectados y configuraciones de IP, crucial para la depuración de red.

docker network inspect bridge

Muestra los logs del servicio Docker en Linux usando `journalctl`, útil para depurar problemas con el daemon Docker en sí, como fallas de inicialización o errores internos.

journalctl -u docker.service

Muestra los logs de eventos relacionados con Docker en Windows usando `Get-EventLog` (PowerShell), útil para depurar problemas en el sistema operativo o en el servicio Docker.

Get-EventLog -LogName Application -Source Docker

Lista todos los contextos Docker disponibles, que permiten alternar fácilmente entre diferentes hosts Docker (local, remoto, cloud), útil para verificar qué entorno está siendo el objetivo de los comandos.

docker context ls

Cambia el contexto Docker activo a `my-context`, dirigiendo los comandos Docker subsiguientes al host o entorno definido en ese contexto. Esencial al trabajar con múltiples entornos Docker.

docker context use my-context

Verifica la firma de confianza de una imagen Docker específica, garantizando que la imagen no ha sido adulterada y proviene de una fuente confiable, importante para la seguridad.

docker trust inspect image:tag