Bienvenido 🐳,este repositorio es un recurso abierto para la comunidad hispanohablante. Nuestro objetivo es proporcionar una guía completa y accesible sobre Docker, facilitando el aprendizaje y la implementación de contenedores en diversos entornos.
- 📘🐳 Holy Docker: Tu Guía Definitiva
- Propósito
- Docker
- Docker Compose
- Imagen y Contenedor
- Imagen
- Contenedor
- Resumen
- Comandos Docker con Ejemplos Detallados
- Comandos Docker Image
- Comandos Contenedores
- Crear un Contenedor
- Ingresar a un Contenedor en Modo Interactivo
- Salir de un Contenedor sin Detener la Ejecución
- Detener un Contenedor
- Detener Todos los Contenedores
- Ver Contenedores en Ejecución
- Ver Contenedores Detenidos
- Ver Último Contenedor Arrancado
- Ver Últimos Contenedores que se Han Ejecutado (Cantidad)
- Ver IDs de Contenedores
- Ver Tamaño del Contenedor
- Filtrar Lista de Contenedores (
--filter
, -f) - Eliminar un Contenedor
- Eliminar un Contenedor en Ejecución
- Eliminar Todos los Contenedores
- Historial Cambios Contenedor
- Puertos Docker
- Redes Docker
- Volúmenes en Docker
- Manipulación de Imagen y Contenedor
- Dockerfile
- Docker Hub
- Docker Compose
- ¿Qué es Docker Compose?
- Instalación de Docker Compose
- Comandos Docker-Compose
- Estructura del fichero Docker-Compose
- Docker Registry: Creación, Uso y Almacenamiento
- Kubernetes
Docker es una plataforma diseñada para crear, implementar y ejecutar aplicaciones en contenedores ligeros y portables. Los contenedores permiten que las aplicaciones y sus dependencias se empaqueten juntas, asegurando que se ejecuten de manera consistente en cualquier entorno que tenga Docker instalado, independientemente del sistema operativo subyacente.
Un contenedor es una "caja" que contiene todo lo necesario para ejecutar una aplicación: el código de la aplicación, las bibliotecas, dependencias y configuraciones necesarias. Esto garantiza que la aplicación se comporte de la misma manera sin importar dónde se ejecute, eliminando problemas de compatibilidad entre diferentes entornos de desarrollo, prueba y producción.
- Portabilidad: Docker permite que las aplicaciones se ejecuten de manera uniforme en diferentes sistemas operativos y plataformas.
- Aislamiento: Cada contenedor funciona de manera aislada, evitando conflictos de dependencias entre aplicaciones.
- Escalabilidad: Docker facilita el escalamiento horizontal, permitiendo ejecutar múltiples instancias de contenedores de una manera eficiente.
- Eficiencia: Los contenedores comparten el mismo kernel del sistema operativo, lo que los hace más ligeros y rápidos que las máquinas virtuales tradicionales.
Docker Compose es una herramienta que permite definir y gestionar aplicaciones multi-contenedor. Con Docker Compose, puedes definir un entorno completo con múltiples servicios (como bases de datos, aplicaciones web y servicios de backend) en un solo archivo docker-compose.yml y luego iniciar todo el entorno con un solo comando.
Un archivo docker-compose.yml
es un archivo de configuración en formato YAML utilizado por Docker Compose para definir y ejecutar aplicaciones multi-contenedor. En este archivo, puedes especificar todos los servicios que componen tu aplicación, así como sus configuraciones, redes y volúmenes necesarios.
-
Version:
- La versión del esquema de Compose que estás utilizando. Diferentes versiones soportan diferentes características.
version: '3.8'
-
Services (Servicios):
- Aquí defines los diferentes servicios que conforman tu aplicación. Cada servicio representa un contenedor de Docker.
services: web: # Configuración del servicio 'web' db: # Configuración del servicio 'db'
-
Build (Construcción):
- Especifica cómo construir la imagen de Docker para el servicio. Puede ser un directorio con un Dockerfile o una imagen existente.
services: web: build: .
-
Image (Imagen):
- Si no deseas construir una imagen, puedes especificar una imagen existente que Docker Compose debe usar para el servicio.
services: db: image: mongo:4.2
-
Ports (Puertos):
- Mapea puertos del contenedor a puertos en el host. Esto es útil para exponer servicios al exterior.
services: web: ports: - "3000:3000"
-
Volumes (Volúmenes):
- Monta volúmenes para persistencia de datos y compartir archivos entre el contenedor y el host.
services: db: volumes: - mongo-data:/data/db
-
Environment (Variables de Entorno):
- Define variables de entorno que se pasarán al contenedor. Útil para configurar el comportamiento del servicio.
services: web: environment: - NODE_ENV=development
-
Networks (Redes):
- Define redes personalizadas para que los servicios puedan comunicarse entre sí de manera aislada.
services: web: networks: - frontend db: networks: - backend
-
Depends_on (Dependencias):
- Especifica dependencias entre servicios, asegurando que ciertos servicios se inicien antes que otros.
services: web: depends_on: - db
A continuación, un ejemplo más completo que incluye varios de los componentes mencionados:
version: '3.8'
services:
web:
build: .
ports:
- "3000:3000"
volumes:
- .:/app
environment:
- NODE_ENV=development
depends_on:
- db
networks:
- frontend
db:
image: mongo:4.2
ports:
- "27017:27017"
volumes:
- mongo-data:/data/db
networks:
- backend
volumes:
mongo-data:
networks:
frontend:
backend:
- version: Usa la versión 3.8 del esquema de Compose.
- services: Define dos servicios:
web
ydb
.- web: Construye la imagen desde el Dockerfile en el directorio actual, mapea el puerto 3000, monta el directorio de la aplicación y establece una variable de entorno. Depende del servicio
db
y está conectado a la redfrontend
. - db: Usa una imagen de MongoDB, mapea el puerto 27017, monta un volumen para persistencia de datos y está conectado a la red
backend
.
- web: Construye la imagen desde el Dockerfile en el directorio actual, mapea el puerto 3000, monta el directorio de la aplicación y establece una variable de entorno. Depende del servicio
- volumes: Define un volumen llamado
mongo-data
para persistir los datos de MongoDB. - networks: Define dos redes:
frontend
ybackend
.
- Consistencia: Define toda la configuración de tu aplicación en un solo archivo, asegurando que cualquier persona que ejecute el archivo obtenga el mismo entorno.
- Facilidad de Uso: Un solo comando (
docker-compose up
) puede iniciar todos los servicios necesarios para tu aplicación. - Aislamiento: Cada servicio se ejecuta en su propio contenedor, evitando conflictos entre dependencias.
- Escalabilidad: Puedes escalar los servicios fácilmente especificando el número de instancias que deseas ejecutar.
Docker es una herramienta que facilita la distribución y ejecución de "Máquinas" virtualizadas.
- Definición: Una imagen es un paquete de software que contiene todo lo necesario para ejecutar una aplicación, incluidos el código, las bibliotecas, las dependencias y las configuraciones.
- Uso: Las imágenes son plantillas estáticas que se distribuyen y se utilizan para crear contenedores.
- Definición: Un contenedor es una instancia en ejecución de una imagen. Contiene todo lo que necesita la aplicación para funcionar y se ejecuta de manera aislada del sistema anfitrión y de otros contenedores.
- Uso: Desde una sola imagen, se pueden crear múltiples contenedores, cada uno ejecutándose de manera independiente.
- Imágenes: Son plantillas reutilizables y distribuidas que contienen todo lo necesario para la aplicación.
- Contenedores: Son instancias ejecutables de las imágenes que proporcionan un entorno aislado y consistente para la aplicación.
Desde una única imagen, puedes crear múltiples contenedores, aprovechando al máximo la eficiencia y la escalabilidad que Docker ofrece.
El comando exec
es una herramienta de administración de contenedores que permite ejecutar comandos dentro de un contenedor que ya está en ejecución. Este comando es particularmente útil cuando necesitas interactuar con un contenedor que no tiene un entorno interactivo preconfigurado.
Puedes ejecutar un comando simple dentro de un contenedor especificando su ID o nombre. Por ejemplo, para imprimir "hola-mundo" dentro de un contenedor llamado ubuntu
:
docker exec ubuntu echo hola-mundo
Resultado:
# Ejemplo 1
[XXXX@XXX ~]# docker exec ubuntu echo hola-mundo
hola-mundo
Este comando imprime "hola-mundo" en la salida estándar del contenedor ubuntu
.
Para acceder a un entorno de shell interactivo dentro de un contenedor en ejecución, puedes usar la opción -it
. Esto es útil para realizar tareas de administración o depuración en tiempo real. Por ejemplo, para iniciar una sesión bash interactiva dentro de un contenedor llamado Nombre_Contenedor
:
docker exec -it Nombre_Contenedor bash
Resultado:
# Ejemplo 2
[XXXX@XXX ~]# docker exec -it Nombre_Contenedor bash
root@Nombre_Contenedor:/#
Este comando te proporciona un terminal interactivo dentro del contenedor, permitiéndote ejecutar comandos directamente.
- Requisitos: El contenedor debe estar en ejecución para usar
docker exec
. - Flexibilidad: Puedes ejecutar cualquier comando que sea válido en el entorno del contenedor, no solo
bash
oecho
.
Utilizar docker exec
es fundamental para la administración diaria de contenedores, permitiéndote interactuar y gestionar contenedores de manera eficiente sin necesidad de reiniciarlos o configurar accesos adicionales.
El comando logs
permite ver la salida de un contenedor en ejecución, lo cual es útil para monitorear y depurar aplicaciones que se ejecutan en segundo plano.
Puedes ver todos los logs de un contenedor especificando su ID o nombre. Por ejemplo, para ver los logs de un contenedor llamado mi_contenedor
:
docker logs mi_contenedor
Resultado:
# Ejemplo 1
[XXXX@XXX ~]# docker logs mi_contenedor
[Fecha y Hora] Mensaje de log 1
[Fecha y Hora] Mensaje de log 2
...
[Fecha y Hora] Mensaje de log n
Este comando muestra toda la salida que el contenedor mi_contenedor
ha generado desde que comenzó a ejecutarse.
Para evitar que se muestren todos los logs y centrarse en las últimas líneas que son más relevantes, puedes usar la opción --tail
seguida del número de líneas que deseas ver. Por ejemplo, para ver las últimas 20 líneas de los logs de un contenedor con el ID 1234asd
:
docker logs 1234asd --tail 20
Resultado:
# Ejemplo 2
[XXXX@XXX ~]# docker logs 1234asd --tail 20
[Fecha y Hora] Mensaje de log 980
[Fecha y Hora] Mensaje de log 981
...
[Fecha y Hora] Mensaje de log 1000
Este comando muestra solo las últimas 20 líneas de los logs del contenedor 1234asd
, ayudando a concentrarse en los eventos más recientes.
- Requisitos: El contenedor debe estar en ejecución o haber estado en ejecución para que los logs estén disponibles.
- Flexibilidad: Puedes usar otras opciones como
--follow
para seguir los logs en tiempo real o--since
para ver los logs generados desde un momento específico.
Utilizar docker logs
es esencial para monitorear el comportamiento y la salida de tus contenedores, permitiéndote detectar y solucionar problemas de manera eficiente.
El comando top
es una herramienta de administración de contenedores que permite identificar cuál es el proceso que más recursos consume dentro de un contenedor. Este comando es útil para monitorear el rendimiento y diagnosticar problemas en contenedores en ejecución.
Puedes usar docker top
para listar todos los procesos activos dentro de un contenedor especificando su ID o nombre. Por ejemplo, para ver los procesos en un contenedor llamado ubuntu
:
docker top ubuntu
Resultado:
# Ejemplo 1
[XXXX@XXX ~]# docker top ubuntu
UID PID PPID C STIME TTY TIME CMD
root 1234 5678 0 01:23 ? 00:00:00 /bin/bash
Este comando muestra una lista de procesos en el contenedor ubuntu
, incluyendo detalles como UID (User ID), PID (Process ID), PPID (Parent Process ID), uso de CPU (C), hora de inicio (STIME), TTY (terminal asociado), tiempo de CPU (TIME) y el comando ejecutado (CMD).
Para obtener información sobre los procesos en un contenedor con un nombre específico, como my_container
, puedes usar el siguiente comando:
docker top my_container
Resultado:
# Ejemplo 2
[XXXX@XXX ~]# docker top my_container
UID PID PPID C STIME TTY TIME CMD
root 2345 6789 1 02:34 ? 00:00:01 /usr/bin/python3
Este comando muestra una lista de procesos en el contenedor my_container
, proporcionando una visión detallada de qué procesos están corriendo y su consumo de recursos.
- Requisitos: El contenedor debe estar en ejecución para usar
docker top
. - Usos:
docker top
es útil para el monitoreo en tiempo real y para detectar procesos que puedan estar consumiendo recursos excesivos, ayudando en la optimización y resolución de problemas en entornos de contenedores.
Utilizar docker top
es esencial para la administración efectiva de contenedores, permitiendo un análisis detallado del rendimiento y el comportamiento de los procesos dentro del contenedor.
El comando stats
es una herramienta de administración de contenedores que permite ver información en tiempo real sobre el uso de recursos de un contenedor, como CPU y memoria, entre otros. Este comando es muy útil para monitorear el rendimiento y la salud de los contenedores en ejecución.
Puedes usar docker stats
para mostrar estadísticas en tiempo real de un contenedor especificando su ID o nombre. Por ejemplo, para ver las estadísticas de un contenedor llamado mi_contenedor
:
docker stats mi_contenedor
Resultado:
# Ejemplo 1
[XXXX@XXX ~]# docker stats mi_contenedor
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS
1234abcd5678 mi_contenedor 0.34% 45.5MiB / 1.95GiB 2.28% 1.2kB / 1.3kB 5.1MB / 0B 19
Este comando muestra estadísticas en tiempo real del contenedor mi_contenedor
, incluyendo el uso de CPU, uso de memoria, tráfico de red, I/O de bloques y el número de procesos activos (PIDS).
Para obtener estadísticas de múltiples contenedores en ejecución, puedes simplemente ejecutar docker stats
sin especificar un contenedor. Esto mostrará las estadísticas de todos los contenedores activos:
docker stats
Resultado:
# Ejemplo 2
[XXXX@XXX ~]# docker stats
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS
1234abcd5678 mi_contenedor 0.34% 45.5MiB / 1.95GiB 2.28% 1.2kB / 1.3kB 5.1MB / 0B 19
abcd1234efgh otro_contenedor 0.01% 22.3MiB / 1.95GiB 1.12% 800B / 900B 2.5MB / 0B 7
Este comando proporciona una vista consolidada del uso de recursos de todos los contenedores en ejecución, lo cual es útil para tener una visión general del rendimiento de todos los contenedores en tu entorno.
- Requisitos: El contenedor debe estar en ejecución para usar
docker stats
. - Flexibilidad: Puedes utilizar filtros y opciones adicionales para personalizar la salida de
docker stats
, como especificar un formato de salida personalizado usando la opción--format
.
Utilizar docker stats
es crucial para el monitoreo continuo y la gestión de recursos de los contenedores, ayudando a asegurar que los contenedores operen dentro de los límites de recursos y a identificar rápidamente cualquier problema de rendimiento.
El comando inspect
permite recuperar información detallada de una imagen o contenedor, incluyendo sus propiedades y características. Este comando es extremadamente útil para obtener un análisis profundo de los contenedores o imágenes en tu entorno.
Puedes usar docker inspect
para obtener información detallada de un contenedor o imagen especificando su ID o nombre. Por ejemplo, para inspeccionar un contenedor llamado mi_contenedor
:
docker inspect mi_contenedor
Resultado:
[
{
"Id": "1234abcd5678",
"Created": "2023-07-19T14:30:00.000Z",
"Path": "/bin/bash",
"Args": [],
"State": {
"Status": "running",
"Running": true,
"Paused": false,
"Restarting": false,
"OOMKilled": false,
"Dead": false,
"Pid": 12345,
"ExitCode": 0,
"Error": "",
"StartedAt": "2023-07-19T14:30:01.000Z",
"FinishedAt": "0001-01-01T00:00:00Z"
},
"Image": "sha256:abcd1234efgh5678ijkl9012mnop3456qrst7890uvwx1234yzab5678cdef9012",
"Name": "/mi_contenedor",
"NetworkSettings": {
"Networks": {
"bridge": {
"IPAddress": "172.17.0.2"
}
}
}
}
]
Este comando proporciona una gran cantidad de información sobre el contenedor mi_contenedor
, incluyendo su ID, fecha de creación, estado, ID de imagen, nombre, configuraciones de red y más.
Debido a la cantidad de información que docker inspect
puede devolver, es recomendable enviar la salida a un archivo para su posterior inspección. Por ejemplo, para inspeccionar un contenedor llamado mi_contenedor
y guardar la información en un archivo info_contenedor.txt
:
docker inspect mi_contenedor > info_contenedor.txt
Resultado:
# Se crea un archivo llamado info_contenedor.txt con la información detallada del contenedor
Este comando guarda toda la información detallada del contenedor mi_contenedor
en el archivo info_contenedor.txt
.
Puedes usar docker inspect
con la opción --format
para recuperar información específica. Por ejemplo, para obtener la dirección IP de un contenedor llamado mi_contenedor
:
docker inspect --format='{{range.NetworkSettings.Networks}}{{.IPAddress}}{{end}}' mi_contenedor
Resultado:
# Ejemplo 3
[XXXX@XXX ~]# docker inspect --format='{{range.NetworkSettings.Networks}}{{.IPAddress}}{{end}}' mi_contenedor
172.17.0.2
Este comando devuelve la dirección IP del contenedor mi_contenedor
.
- Formato JSON: La información proporcionada por
docker inspect
se entrega en formato JSON, lo que facilita su análisis y procesamiento con herramientas automatizadas. - Flexibilidad: Puedes personalizar la salida usando la opción
--format
para recuperar solo la información que necesitas, lo cual es útil para scripts y automatización.
Utilizar docker inspect
es esencial para obtener una visión detallada y comprensiva de las propiedades y configuraciones de tus contenedores e imágenes, permitiéndote gestionar y diagnosticar tu entorno Docker de manera eficiente.
El comando docker image
sirve para administrar imágenes de Docker, agrupando todos los comandos relacionados con las imágenes. A continuación, se presentan las opciones y sus descripciones:
Comando | Descripción |
---|---|
build | Construir una imagen a partir de un Dockerfile |
history | Mostrar el historial de una imagen |
import | Importar el contenido de una tarball para crear una imagen del sistema de archivos |
inspect | Mostrar información detallada sobre una o más imágenes |
load | Cargar una imagen de un archivo tar o STDIN |
ls | Listar imágenes |
prune | Eliminar imágenes no utilizadas |
pull | Extraer una imagen o un repositorio de un registro |
push | Empujar una imagen o un repositorio a un registro |
rm | Eliminar una o más imágenes |
save | Guardar una o más imágenes en un archivo tar (transmitidas a STDOUT por defecto) |
tag | Crear una etiqueta TARGET_IMAGE que haga referencia a SOURCE_IMAGE |
El comando docker image
puede ser considerado una alternativa a ciertos comandos de Docker. A continuación se presentan algunas equivalencias:
Opción 1 | Opción 2 |
---|---|
docker image ls | docker images |
docker image rm | docker rmi |
Estas alternativas pueden simplificar la administración de imágenes al utilizar un conjunto coherente de comandos bajo docker image
.
Al igual que docker image
, el comando docker container
agrupa todos los comandos relacionados con los contenedores. A continuación, se presentan las opciones y sus descripciones:
Comando | Descripción |
---|---|
attach | Conecte flujos de entrada, salida y error estándar locales a un contenedor en funcionamiento. |
commit | Crear una nueva imagen a partir de los cambios de un contenedor. |
cp | Copiar archivos/carpetas entre un contenedor y el sistema de archivos local. |
create | Crear un nuevo contenedor. |
diff | Inspeccionar cambios en archivos o directorios en el sistema de archivos de un contenedor. |
exec | Ejecutar un comando en un contenedor en ejecución. |
export | Exportar el sistema de archivos de un contenedor como un archivo tar. |
inspect | Mostrar información detallada sobre uno o más contenedores. |
kill | Matar uno o más contenedores en marcha. |
logs | Obtener los logs de un contenedor. |
ls | Listar contenedores. |
pause | Pausar todos los procesos dentro de uno o más contenedores. |
port | Listar mapeos de puertos o un mapeo específico para el contenedor. |
prune | Retirar todos los contenedores parados. |
rename | Renombrar un contenedor. |
restart | Reiniciar uno o más contenedores. |
rm | Retirar uno o más contenedores. |
run | Ejecutar un comando en un nuevo contenedor. |
stats | Mostrar una secuencia en vivo de estadísticas de uso de recursos del contenedor(es). |
stop | Parar uno o más contenedores en ejecución. |
top | Mostrar los procesos en ejecución de un contenedor. |
unpause | Despausar todos los procesos dentro de uno o más contenedores. |
update | Actualizar la configuración de uno o más contenedores. |
wait | Bloquear hasta que uno o más contenedores se detengan, luego imprimir sus códigos de salida. |
El comando docker container
puede ser considerado una alternativa a ciertos comandos de Docker. A continuación se presentan algunas equivalencias:
Opción 1 | Opción 2 |
---|---|
docker container ls | docker ps |
docker container ls -a | docker ps -a |
Estas alternativas pueden simplificar la administración de contenedores al utilizar un conjunto coherente de comandos bajo docker container
.
En caso de necesitar ayuda para saber qué hace un comando, se agrega el --help. Esto proporciona una descripción detallada del comando, sus opciones y uso.
[XXXX@XXX ~]# docker container ls --help
Usage: docker container ls [OPTIONS]
List containers
Aliases:
ls, ps, list
Options:
-a, --all Show all containers (default shows just running)
-f, --filter filter Filter output based on conditions provided
--format string Pretty-print containers using a Go template
-n, --last int Show n last created containers (includes all states) (default -1)
-l, --latest Show the latest created container (includes all states)
--no-trunc Don't truncate output
-q, --quiet Only display numeric IDs
-s, --size Display total file sizes
[XXXX@XXX ~]# docker image ls --help
Usage: docker image ls [OPTIONS]
List images
Aliases:
ls, images
Options:
-a, --all Show all images (default hides intermediate images)
--digests Show digests
-f, --filter filter Filter output based on conditions provided
--format string Pretty-print images using a Go template
--no-trunc Don't truncate output
-q, --quiet Only show numeric IDs
[XXXX@XXX ~]# docker run --help
Usage: docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
Run a command in a new container
Options:
-d, --detach Run container in background and print container ID
--name string Assign a name to the container
-e, --env list Set environment variables
-p, --publish list Publish a container's port(s) to the host
-v, --volume list Bind mount a volume
--rm Automatically remove the container when it exits
--network string Connect a container to a network
-h, --help Print usage
El comando --help
es esencial para familiarizarse con las diversas opciones y parámetros disponibles para cualquier comando de Docker, permitiendo así un uso más eficiente y efectivo de las capacidades de Docker.
El comando docker info
entrega múltiples datos sobre el estado y configuración del entorno Docker.
Docker info: Entrega múltiples datos (Espacio, características, etc.), entre los cuales se destacan la cantidad de contenedores e imágenes y el estado de estos.
docker info
El comando docker --version
sirve para conocer la versión de Docker instalada en la máquina.
Docker --version: Sirve para saber qué versión de Docker se tiene instalada actualmente en la máquina.
docker --version
El comando docker run
sirve para crear y ejecutar nuevos contenedores.
Docker run: Cada vez que se ejecuta este comando, crea un nuevo contenedor, no recicla contenedores ejecutados previamente.
docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
Con este comando se buscará y entregará una lista de imágenes que se encuentran en el Docker Hub.
docker search NombreBuscar
Retorna como máximo 25 resultados.
Opción | Descripción |
---|---|
--limit | Limitar el número de resultados (predeterminado: 25) |
--filter | Filtrar resultados en base a criterios específicos (stars, is-official, is-automated) |
Limitar el número de resultados a 10:
docker search --limit 10 NombreBuscar
Filtrar resultados por imágenes oficiales:
docker search --filter "is-official=true" NombreBuscar
Filtrar resultados por número de estrellas (ej. mínimo 3 estrellas):
docker search --filter "stars=3" NombreBuscar
Para descargar una imagen del Docker Hub al entorno local, se utiliza el siguiente comando.
docker pull NombreImagen
Opción | Descripción |
---|---|
--all-tags | Descargar todas las versiones (tags) de la imagen |
--platform | Especificar la plataforma para la que se debe descargar la imagen (ej. linux/amd64, linux/arm64) |
Descargar todas las versiones (tags) de una imagen:
docker pull --all-tags NombreImagen
Especificar la plataforma al descargar una imagen:
docker pull --platform linux/amd64 NombreImagen
Para ver las imágenes descargadas y almacenadas en el entorno local, se utiliza el siguiente comando.
docker images
Opción | Descripción |
---|---|
-a, --all | Mostrar todas las imágenes, incluyendo las intermedias |
--digests | Mostrar los digests de las imágenes |
-f, --filter | Filtrar la salida en función de condiciones proporcionadas |
--format | Formatear la salida usando una plantilla de Go |
--no-trunc | No truncar la salida de la imagen |
-q, --quiet | Mostrar solo los IDs numéricos de las imágenes |
Mostrar todas las imágenes, incluyendo las intermedias:
docker images --all
Filtrar las imágenes por una condición específica (ej. mostrar solo imágenes de un repositorio específico):
docker images --filter "reference=NombreImagen:*"
Formatear la salida para mostrar solo el nombre y la etiqueta de la imagen:
docker images --format "{{.Repository}}:{{.Tag}}"
Mostrar solo los IDs numéricos de las imágenes:
docker images --quiet
Para aplicar filtros a la lista de imágenes en el repositorio local, se utiliza el siguiente comando. Este comando funciona de manera similar a cómo se filtran los contenedores.
docker images -f "filter=valor"
El comando docker images -f
permite aplicar filtros para mostrar solo las imágenes que coinciden con los criterios especificados. Los filtros se pueden basar en atributos como el nombre de la imagen, la etiqueta, la fecha de creación, etc.
Opción | Descripción |
---|---|
-f, --filter | Aplicar un filtro para mostrar solo las imágenes que coinciden con el criterio especificado |
Filtrar imágenes por nombre:
docker images -f "reference=nombre_imagen"
Filtrar imágenes basadas en la etiqueta:
docker images -f "label=etiqueta=valor"
Filtrar imágenes por fecha de creación:
docker images -f "before=fecha"
Filtrar imágenes con una etiqueta específica:
docker images -f "dangling=true"
- Asegúrate de reemplazar
"filter=valor"
con el filtro y valor adecuados según tus necesidades. - Puedes combinar varios filtros para refinar aún más los resultados.
El comando docker images -f
es útil para encontrar imágenes específicas en un repositorio local cuando se manejan muchas imágenes o cuando se requiere una búsqueda más precisa.
Para eliminar una imagen que se encuentra en el repositorio local, se utiliza el siguiente comando:
docker rmi ID/Nombre_Imagen
El comando docker rmi
se usa para eliminar una o más imágenes del repositorio local de Docker. La eliminación se realiza utilizando el ID o el nombre de la imagen.
Opción | Descripción |
---|---|
ID/Nombre_Imagen |
El ID o nombre de la imagen que deseas eliminar. Puedes usar el ID de la imagen, el nombre de la imagen, o una combinación de ambos. |
Eliminar una imagen por ID:
docker rmi abc1234defgh
Eliminar una imagen por nombre:
docker rmi my_image:latest
Eliminar varias imágenes al mismo tiempo:
docker rmi image1 image2 image3
-
Restricción con Contenedores: No es posible eliminar una imagen si existe un contenedor que la está utilizando. Si un contenedor se ha creado a partir de una imagen, Docker no permitirá eliminar esa imagen hasta que el contenedor asociado sea eliminado primero.
Para eliminar una imagen que está en uso, primero debes eliminar el contenedor que está utilizando la imagen. Puedes hacerlo con el siguiente comando para eliminar el contenedor:
docker rm ID/Nombre_Contenedor
-
Eliminar Imagen Forzadamente: Si deseas eliminar una imagen que está en uso, puedes forzar la eliminación utilizando la bandera -f. Esto también eliminará los contenedores que están utilizando la imagen.
Comando para eliminar una imagen forzadamente:
docker rmi -f ID/Nombre_Imagen
-
Comprobación de Imágenes en Uso: Puedes verificar qué contenedores están utilizando una imagen específica utilizando el comando
docker ps -a
para listar todos los contenedores, y luego buscar los que usan la imagen que deseas eliminar. -
Eliminar Contenedores Antes de la Imagen: Es una buena práctica asegurarse de que no hay contenedores en ejecución o detenidos que dependan de la imagen que deseas eliminar. Puedes detener y eliminar todos los contenedores asociados antes de eliminar la imagen.
El comando docker rmi
es útil para limpiar imágenes no utilizadas o para liberar espacio en el disco al eliminar imágenes obsoletas.
Para eliminar todas las imágenes almacenadas en el repositorio local, se utiliza el siguiente comando:
docker rmi $(docker images -q)
El comando docker rmi $(docker images -q)
elimina todas las imágenes locales en el repositorio de Docker. Se compone de dos partes:
docker images -q
: Este comando lista todos los IDs de las imágenes en el repositorio local.docker rmi $(...)
: El comandodocker rmi
elimina las imágenes cuyos IDs son proporcionados como argumento. Al usar$(docker images -q)
, se pasan todos los IDs de imágenes listadas por el comando anterior.
-
docker images -q
: Lista los IDs de todas las imágenes en el repositorio local sin información adicional. La opción-q
(quiet) produce una salida limpia con solo los IDs de las imágenes. -
docker rmi
: Elimina las imágenes especificadas. Cuando se le pasa una lista de IDs de imágenes, elimina todas las imágenes correspondientes.
Eliminar todas las imágenes en el repositorio local:
docker rmi $(docker images -q)
-
Contenedores en Uso: Antes de ejecutar este comando, asegúrate de que no haya contenedores en ejecución que estén utilizando las imágenes que deseas eliminar. Si existen contenedores utilizando estas imágenes, Docker no permitirá su eliminación.
Para detener y eliminar todos los contenedores que pueden estar utilizando las imágenes, usa los siguientes comandos:
Detener todos los contenedores:
docker stop $(docker ps -q)
Eliminar todos los contenedores:
docker rm $(docker ps -a -q)
-
Forzar Eliminación: Si deseas eliminar imágenes que están asociadas a contenedores, puedes forzar la eliminación utilizando la bandera -f con el comando
docker rmi
.Eliminar todas las imágenes forzadamente:
docker rmi -f $(docker images -q)
Nota: Forzar la eliminación eliminará también los contenedores que están en uso y asociados a esas imágenes.
-
Espacio en Disco: Asegúrate de que realmente deseas eliminar todas las imágenes, ya que esto puede afectar los contenedores que dependen de esas imágenes y puede liberar espacio en disco, pero también eliminará imágenes que podrían ser necesarias para otros proyectos.
-
Recreación de Imágenes: Si eliminas todas las imágenes, tendrás que volver a descargar o construir imágenes cuando las necesites nuevamente, lo que podría consumir tiempo y recursos adicionales.
Este comando es útil para limpiar un entorno Docker de todas las imágenes no deseadas, especialmente en entornos de desarrollo o prueba donde se crean y eliminan muchas imágenes regularmente.
Para ver el historial de los cambios que ha sufrido una imagen a lo largo de su proceso de construcción, se utiliza el siguiente comando:
docker image history Nombre_Imagen
El comando docker image history Nombre_Imagen
muestra una lista detallada de las capas y los cambios aplicados a una imagen desde su construcción inicial hasta su estado actual. Esto incluye información sobre cada capa de la imagen, como la fecha de creación, el tamaño y las instrucciones de construcción.
-
docker image history
: Este comando muestra el historial de una imagen específica. Está diseñado para proporcionar una visión detallada de cómo se construyó la imagen, lo que incluye cada instrucción ejecutada durante el proceso de construcción. -
Nombre_Imagen
: Especifica el nombre de la imagen cuyo historial deseas consultar. Puede ser un nombre de imagen completo, incluyendo la etiqueta (por ejemplo,ubuntu:latest
), o solo el nombre de la imagen si hay una única etiqueta asociada.
Ver el historial de cambios para una imagen específica:
docker image history Nombre_Imagen
La salida del comando docker image history
incluye las siguientes columnas:
IMAGE
: ID de la capa de la imagen.CREATED
: Fecha y hora en que se creó la capa de la imagen.CREATED BY
: La instrucción que creó la capa (por ejemplo, un comando de Dockerfile).SIZE
: Tamaño de la capa.COMMENT
: Comentarios opcionales sobre la capa (si se han agregado).
IMAGE CREATED CREATED BY SIZE COMMENT
<sha256:id> 2 weeks ago /bin/sh -c apt-get update && apt-get install... 250MB
<sha256:id> 3 weeks ago /bin/sh -c apt-get install -y python3-pip 50MB
<sha256:id> 4 weeks ago /bin/sh -c apt-get install -y python3 40MB
<sha256:id> 1 month ago /bin/sh -c mkdir /app 10MB
<sha256:id> 1 month ago /bin/sh -c FROM ubuntu:20.04 200MB
- Depuración: Puedes usar el historial de la imagen para depurar problemas en la construcción de la imagen o para entender cómo se configuró una imagen específica.
- Optimización: Analizar el historial puede ayudarte a optimizar el Dockerfile eliminando pasos innecesarios o combinando comandos para reducir el tamaño de la imagen.
- Auditoría: Es útil para auditar las capas y los cambios realizados en la imagen a lo largo del tiempo, asegurando que se cumplan las políticas de seguridad y mantenimiento.
- Imágenes Intermedias: El historial mostrará tanto las imágenes intermedias como las finales. Las imágenes intermedias son capas que se crean durante el proceso de construcción y no se usan directamente en el contenedor en ejecución.
- Cambios Dinámicos: Los cambios mostrados reflejan las instrucciones del Dockerfile y cualquier modificación realizada durante el proceso de construcción, lo que incluye la adición de archivos, instalaciones de paquetes y configuraciones.
Este comando es una herramienta poderosa para obtener información detallada sobre la evolución de una imagen Docker a lo largo del tiempo y puede ser muy útil para desarrolladores y administradores de sistemas que trabajan con Docker.
Para crear un contenedor a partir de una imagen, se utiliza el siguiente comando:
docker run nombre-Contenedor
El comando docker run
se emplea para crear y ejecutar un nuevo contenedor desde una imagen especificada. Cada vez que se ejecuta este comando, se genera un nuevo contenedor, incluso si ya existe un contenedor basado en la misma imagen. El comando también descarga la imagen desde Docker Hub si no está disponible localmente.
Crear un contenedor a partir de una imagen específica:
docker run hello-world
Descripción:
hello-world
: Es una imagen de prueba que confirma que Docker está funcionando correctamente. Si la imagen no está disponible localmente, Docker la descargará desde Docker Hub.
Docker Hub es un registro en línea de imágenes Docker. Si la imagen solicitada no está en el repositorio local, Docker la descargará desde Docker Hub para crear el contenedor.
Para asignar un nombre específico a un contenedor al momento de su creación, se utiliza la opción --name
:
docker run -it --name ubuntu_personal ubuntu bash
Descripción:
-it
: Combina las opciones-i
(interactivo) y -t (terminal), permitiendo la interacción con el contenedor.--name ubuntu_personal
: Asigna el nombreubuntu_personal
al contenedor.ubuntu
: Es la imagen desde la cual se creará el contenedor.bash
: Ejecuta el shellbash
dentro del contenedor.
Uso:
Este comando inicia un contenedor basado en la imagen ubuntu
, lo nombra ubuntu_personal
, y abre una terminal interactiva en el contenedor.
Para crear un contenedor que permita la interacción con el usuario a través de una terminal, se utiliza el comando con las opciones -it:
docker run -it ubuntu
Descripción:
-it
: Combina-i
(interactivo) y -t (terminal) para permitir la interacción con la terminal del contenedor.ubuntu
: Es la imagen base. La imagen de Ubuntu proporciona un entorno de línea de comandos interactivo.
Uso:
Este comando inicia un contenedor interactivo basado en la imagen ubuntu
, permitiendo la entrada de comandos directamente en la terminal del contenedor.
Nota:
La imagen ubuntu
proporciona una versión mínima de Ubuntu para la interacción en la línea de comandos.
Para ejecutar un contenedor en segundo plano, sin mantener la ventana de comandos abierta, se utiliza la opción -d:
docker run -d nginx
Descripción:
- -d: Ejecuta el contenedor en modo "detached" (en segundo plano).
nginx
: Es la imagen desde la cual se creará el contenedor.
Uso:
Este comando inicia un contenedor basado en la imagen nginx
en segundo plano. La opción -d permite que el contenedor se ejecute sin necesidad de mantener una ventana de terminal abierta para interactuar con él.
Nota:
Un contenedor en modo detached no se puede eliminar automáticamente cuando se detiene. La opción --rm
no es compatible con -d.
Para eliminar automáticamente un contenedor una vez que haya terminado su ejecución, se utiliza la opción --rm
:
docker run -it --rm --name Nombre_Contenedor Nombre_imagen
Descripción:
-it
: Permite la interacción con la terminal del contenedor.--rm
: Elimina el contenedor automáticamente después de que se detiene.--name Nombre_Contenedor
: Asigna el nombreNombre_Contenedor
al contenedor.Nombre_imagen
: Es la imagen desde la cual se creará el contenedor.
Uso:
Este comando crea un contenedor interactivo basado en Nombre_imagen
, le asigna el nombre Nombre_Contenedor
, y se elimina automáticamente cuando el contenedor se detiene.
Nota: El contenedor se eliminará tan pronto como se cierre la sesión interactiva.
Estos comandos te permiten crear y gestionar contenedores Docker de manera flexible, ajustando su comportamiento según tus necesidades, ya sea para pruebas, desarrollo o producción.
Para ingresar a un contenedor que ya ha sido creado previamente y que está en estado detenido, utilizando el modo interactivo, puedes usar el siguiente comando:
docker start -i ID_Contenedor
docker start
: Inicia un contenedor que está detenido.-i
: Proporciona una sesión interactiva con el contenedor.ID_Contenedor
: Es el ID del contenedor que deseas iniciar y al que quieres acceder.
Este comando inicia un contenedor previamente creado y detenido y proporciona una terminal interactiva para interactuar con él. Si deseas trabajar con un contenedor que ha sido previamente configurado y está detenido, este comando evita la creación de un nuevo contenedor y te permite retomar la sesión del contenedor existente.
Nota: Cuando un contenedor se detiene, no se elimina automáticamente; debes iniciarlo nuevamente para acceder a él.
Para salir de un contenedor sin detener su ejecución, puedes usar la siguiente combinación de teclas:
Ctrl+P+Q
Ctrl+P
yCtrl+Q
: Esta combinación de teclas permite desvincular la terminal del contenedor, dejando el contenedor en ejecución en segundo plano. Esto es útil si necesitas cerrar tu sesión interactiva sin detener el contenedor.
Uso:
Presiona Ctrl+P
seguido de Ctrl+Q
para regresar a tu terminal local mientras el contenedor sigue ejecutándose en segundo plano.
Para detener un contenedor que se encuentra en ejecución, utiliza el siguiente comando:
docker stop ID_Contenedor
docker stop
: Detiene la ejecución de un contenedor.ID_Contenedor
: Es el ID del contenedor que deseas detener.
Este comando envía una señal de parada al contenedor especificado, permitiéndole cerrar de manera controlada. Es útil cuando necesitas finalizar el contenedor de manera ordenada.
Para detener todos los contenedores que están actualmente en ejecución, usa el siguiente comando:
docker stop $(docker ps -q)
docker stop
: Detiene los contenedores especificados.$(docker ps -q)
: Obtiene los IDs de todos los contenedores en ejecución.
Este comando primero obtiene una lista de todos los contenedores en ejecución (docker ps -q
devuelve solo los IDs de los contenedores) y luego pasa esa lista al comando docker stop
, deteniendo todos los contenedores.
Nota:
Este comando detiene todos los contenedores activos en tu sistema. Si quieres detener todos los contenedores, incluidos los que están detenidos, usa docker ps -a -q
en lugar de docker ps -q
.
Para ver los contenedores que están actualmente en ejecución, puedes usar una de las siguientes opciones:
# Primera Opción
docker container ls
# Segunda Opción
docker ps
docker container ls
: Muestra una lista de todos los contenedores que están en ejecución.docker ps
: Es un alias dedocker container ls
y realiza la misma función.
Estos comandos te proporcionan una lista de contenedores que están activos en tu sistema. La salida incluye detalles como el ID del contenedor, la imagen utilizada, el comando que se está ejecutando, el estado, y más.
Nota: Ambos comandos son equivalentes y puedes usar cualquiera de ellos según tu preferencia.
Para ver los contenedores que están creados pero detenidos, usa el siguiente comando:
docker ps -a
docker ps -a
: Muestra todos los contenedores, incluyendo los que están detenidos y los que están en ejecución.
Este comando proporciona una lista completa de todos los contenedores, independientemente de su estado. Los contenedores detenidos se muestran junto con los que están actualmente en ejecución.
Nota: Los contenedores no se eliminan automáticamente al detenerse; permanecen en estado detenido hasta que se eliminen manualmente.
Para visualizar el último contenedor que ha realizado una operación, usa:
docker ps -l
docker ps -l
: Muestra el último contenedor que ha realizado alguna operación (ya sea que esté en ejecución o detenido).
Este comando es útil para identificar rápidamente el contenedor más reciente que ha sido creado o ejecutado. Proporciona información sobre el último contenedor en tu sistema.
Para ver los últimos contenedores que han realizado alguna operación y especificar la cantidad de contenedores a mostrar, utiliza:
docker ps -n 4
docker ps -n 4
: Muestra los últimos 4 contenedores que han realizado alguna operación. Puedes ajustar el número (4) según la cantidad deseada.
Este comando limita la salida a los contenedores más recientes, lo que facilita la visualización de los contenedores más relevantes que han sido creados o ejecutados recientemente.
Nota: Puedes cambiar el número (4) por cualquier otro valor para mostrar una cantidad diferente de contenedores.
Para visualizar solamente los IDs de los contenedores, puedes usar una de las siguientes opciones:
# Opción 1
docker ps -a -q
# Opción 2
docker ps -aq
docker ps -a -q
: Muestra solamente los IDs de todos los contenedores, independientemente de su estado (en ejecución o detenido).docker ps -aq
: Es un alias dedocker ps -a -q
y realiza la misma función.
Estos comandos proporcionan una lista de IDs de contenedores que puedes usar en scripts o comandos para realizar operaciones automáticas sobre los contenedores.
Para ver el tamaño que ocupa un contenedor en el sistema, usa el siguiente comando. En el ejemplo se muestra cómo ver el tamaño de los últimos 3 contenedores:
docker ps -a -n 3 -s
docker ps -a -n 3 -s
: Muestra todos los contenedores, incluyendo los que están detenidos, los últimos 3 contenedores en ejecución y sus tamaños.
Este comando proporciona información sobre el tamaño de los contenedores, lo que puede ser útil para gestionar el espacio en disco y verificar el impacto de los contenedores en tu sistema.
Nota: El tamaño mostrado es el tamaño de la capa de imagen y los cambios realizados en el contenedor. La opción -s muestra detalles del tamaño de cada contenedor.
El comando para filtrar la lista de contenedores permite agregar una o más opciones de filtrado para personalizar la búsqueda de contenedores. Esto se hace mediante el parámetro --filter
o su forma corta -f. A continuación, se detallan las opciones disponibles para aplicar filtros:
Filtro | Descripción |
---|---|
id |
ID del contenedor. |
name |
Nombre del contenedor. |
label |
Una cadena arbitraria que representa una llave o un par llave-valor. Expresado como <key> o <key>=<value> . |
exited |
Un número entero que representa el código de salida del contenedor. Solo es útil con --all . |
status |
Uno de created , restarting , running , removing , paused , exited , o dead . |
ancestor |
Filtra los contenedores que comparten una determinada imagen como ancestros. Expresado como <image-name>[:<tag>] , <image id> , o <image@digest> . |
before o since |
Filtra los contenedores creados antes o después de una identificación o nombre de contenedor determinado. |
volume |
Filtros que funcionan con contenedores que han montado un volumen determinado o un soporte de fijación. |
network |
Filtros que funcionan con contenedores conectados a una red determinada. |
publish o expose |
Filtra los contenedores que publican o exponen un puerto determinado. Expresado como <port>[/<proto>] o <startport-endport>/[<proto>] . |
health |
Filtra los contenedores en función de su estado de salud. Uno de starting , healthy , unhealthy o none . |
isolation |
Solo daemon de Windows. Uno de default , process o hyperv . |
is-task |
Filtra los contenedores que son una "tarea" para un servicio. Opción booleana (true o false ). |
Para obtener una descripción más detallada de cada filtro, revisa el enlace a filtros de Docker.
Para filtrar la lista de contenedores por nombre, usa el siguiente comando:
docker ps -a -f "name=XX"
Descripción:
docker ps -a -f "name=XX"
: Muestra todos los contenedores (incluidos los detenidos) que tienen un nombre que coincide conXX
.
Nota:
XX
representa el nombre del contenedor que estás buscando. Puedes usar patrones o nombres parciales para realizar búsquedas más flexibles.
Ejemplo:
Si deseas buscar contenedores cuyo nombre contenga "web", podrías usar:
docker ps -a -f "name=web"
Para eliminar un contenedor que se encuentra detenido, se pueden usar los siguientes comandos:
docker rm ID_Contenedor
Descripción:
docker rm ID_Contenedor
: Elimina un contenedor especificado por su ID. ReemplazaID_Contenedor
con el ID real del contenedor que deseas eliminar.
docker rm Nombre_Contenedor
Descripción:
docker rm Nombre_Contenedor
: Elimina un contenedor especificado por su nombre. ReemplazaNombre_Contenedor
con el nombre real del contenedor que deseas eliminar.
Si necesitas eliminar un contenedor que está en ejecución, debes forzar la eliminación utilizando el siguiente comando:
docker rm ID_Contenedor/Nombre_Contenedor -f
Descripción:
docker rm ID_Contenedor/Nombre_Contenedor -f
: Elimina un contenedor que está en ejecución forzando su eliminación. ReemplazaID_Contenedor
oNombre_Contenedor
con el ID o nombre del contenedor que deseas eliminar.
Nota:
- Forzar la eliminación de un contenedor en ejecución detendrá el contenedor de inmediato.
Para eliminar todos los contenedores que has creado, utiliza el siguiente comando en PowerShell (Windows):
docker rm $(docker ps -a -q)
Descripción:
docker rm $(docker ps -a -q)
: Elimina todos los contenedores en el sistema. Primero,docker ps -a -q
lista todos los IDs de los contenedores (independientemente de su estado), y luegodocker rm
los elimina.
Nota:
- Si tienes contenedores en ejecución, debes usar la opción -f para forzar la eliminación de los contenedores o detener la ejecución primero.
Ejemplo de Forzar Eliminación de Todos los Contenedores:
docker rm -f $(docker ps -a -q)
Este comando detendrá y eliminará todos los contenedores en ejecución y detenidos.
Para conocer los cambios, instalaciones o modificaciones que ha sufrido un contenedor, puedes utilizar los siguientes comandos. Estos comandos mostrarán los cambios en los archivos y directorios dentro del contenedor.
docker diff Nombre_Contenedor
Descripción:
docker diff Nombre_Contenedor
: Muestra los cambios realizados en los archivos y directorios dentro del contenedor especificado porNombre_Contenedor
. ReemplazaNombre_Contenedor
con el nombre real del contenedor que deseas inspeccionar.
docker container diff Nombre_Contenedor
Descripción:
docker container diff Nombre_Contenedor
: Similar al comandodocker diff
, pero usa la forma extendida del comando,docker container diff
. ReemplazaNombre_Contenedor
con el nombre real del contenedor que deseas inspeccionar.
Interpretación de los Resultados:
Los cambios se muestran con una letra al principio, que indica el tipo de modificación realizada:
A
(Adición): Indica que un archivo o directorio nuevo ha sido agregado.C
(Modificación): Indica que un archivo o directorio existente ha sido modificado.D
(Eliminado): Indica que un archivo o directorio ha sido eliminado.
Ejemplo:
Si ejecutas el comando:
docker diff my_container
Podrías obtener una salida como esta:
A /newfile.txt
C /existingfile.txt
D /oldfile.txt
Esto significa que:
- Se ha añadido el archivo
/newfile.txt
. - Se ha modificado el archivo
/existingfile.txt
. - Se ha eliminado el archivo
/oldfile.txt
.
Nota:
Estos comandos son útiles para auditar los cambios realizados en un contenedor, especialmente cuando se desean verificar las modificaciones realizadas durante el tiempo de ejecución del contenedor.
Los contenedores Docker deben ser accesibles desde el exterior para poder interactuar con ellos, como en el caso de una API o un servidor web. Por defecto, los puertos de los contenedores son privados y no accesibles desde fuera del contenedor. Es necesario mapear estos puertos con puertos del host que aloja el contenedor para hacerlos accesibles.
Para exponer los puertos de un contenedor y hacerlos accesibles desde el exterior, se utiliza la opción -P
(mayúscula) al iniciar el contenedor. Esto asignará automáticamente puertos del host al contenedor.
docker run -d -P nombre_imagen
Descripción:
- -d: Ejecuta el contenedor en segundo plano (modo detach).
-P
: Expone todos los puertos del contenedor que están definidos en la configuración de la imagen, asignando puertos aleatorios del host.
Nota: La
P
debe ser mayúscula para que Docker asigne puertos aleatorios. Si se usa-p
(minúscula), se necesita especificar el puerto manualmente.
Para verificar los puertos expuestos y sus asignaciones, utiliza el comando:
docker ps
Esto mostrará una columna llamada PORTS, que indica cómo están mapeados los puertos del contenedor al host.
Ejemplo de columna PORTS:
0.0.0.0:24312->80/tcp
Explicación de la columna PORTS:
0.0.0.0
: Indica que el puerto es accesible desde cualquier dirección IP del host. Puede cambiarse a una IP específica si el host tiene múltiples direcciones IP.24312
: Es el puerto en el host que está mapeado con el puerto del contenedor.80/tcp
: Es el puerto del contenedor.
Acceso al Contenedor: Para acceder a un servicio en el contenedor, usa la URL
localhost:24312
en el navegador si el contenedor está ejecutando un servidor web como Apache o Nginx.
En lugar de asignar puertos aleatorios, puedes especificar un puerto concreto en el host para mapearlo al puerto del contenedor utilizando la opción -p
(minúscula).
docker run -d -p 8080:80 Nombre_Imagen
Descripción:
-p 8080:80
: Mapea el puerto80
del contenedor al puerto8080
del host. El formato eshost_port:container_port
.- -d: Ejecuta el contenedor en segundo plano.
Puedes agregar un nombre personalizado al contenedor con la opción --name
:
docker run -d --name Nombre_personalizado -p 8080:80 Nombre_Imagen
Descripción:
--name Nombre_personalizado
: Asigna un nombre específico al contenedor.
Notas Importantes:
- Con la opción
-P
, Docker asignará automáticamente puertos aleatorios del host. - Con la opción
-p
, puedes especificar el puerto del host al que deseas mapear el puerto del contenedor.
Estos comandos te permitirán gestionar la accesibilidad de los contenedores Docker a través de puertos, ya sea exponiéndolos automáticamente o asignando puertos específicos del host.
Docker utiliza redes para permitir la comunicación entre contenedores y entre contenedores y el host. Por defecto, Docker crea y maneja varias redes, pero también puedes crear redes personalizadas para cumplir con requisitos específicos.
Por defecto, Docker proporciona tres redes predefinidas:
- Bridge: Es la red predeterminada para los contenedores si no se especifica otra. Permite la comunicación entre contenedores en la misma red.
- Host: Los contenedores en esta red interactúan directamente con el host y no pueden comunicarse entre ellos. Se utiliza para contenedores aislados.
- None: El contenedor no tiene acceso a la red. Su driver es null.
La columna SCOPE en la lista de redes indica si la red es local o está conectada a otros equipos.
Para listar todas las redes disponibles en Docker:
docker network ls
Para obtener la dirección IP de un contenedor, puedes usar el comando docker inspect
con una plantilla de Golang para formatear la salida:
docker inspect --format='{{range.NetworkSettings.Networks}}{{.IPAddress}}{{end}}' ID/Nombre_Contenedor
Nota: La función de ping para verificar la conexión de red no está disponible en Windows ni en macOS.
Otra opción para obtener la dirección IP es utilizando herramientas de búsqueda en el output de docker inspect
:
# Estructura
docker inspect Nombre/ID_Contenedor | FindStr/grep Objeto_Buscar
# Windows
docker inspect Nombre/ID_Contenedor | FindStr IPAd
# Linux
docker inspect Nombre/ID_Contenedor | grep IPAd
Para guardar la información de una inspección en un archivo:
docker inspect Nombre/ID_Contenedor > Nombre_Archivo.txt
Para obtener información detallada sobre una red específica, incluyendo los contenedores conectados a ella:
docker network inspect Nombre_red
Nota: Puedes obtener el nombre de la red con el comando
docker network ls
.
Para crear una nueva red en Docker:
docker network create Nombre_Red
La red creada por defecto es del tipo bridge. Puedes especificar un tipo diferente con la opción
--driver
.
Para especificar un rango de subnet al crear una red:
docker network create --subnet=192.168.0.0/16 Nombre_Red
Para ejecutar un contenedor y asociarlo a una red existente:
docker run -it --name Nombre_Contenedor --network Nombre_Red Imagen_Contenedor
El parámetro --network especifica la red a la que se asociará el contenedor.
Para conectar un contenedor que ya está en ejecución a una red:
docker network connect Nombre_Red Nombre_Contenedor
Un contenedor puede estar conectado a múltiples redes.
Para desconectar un contenedor de una red:
docker network disconnect Nombre_Red Nombre_Contenedor
Se pueden enlazar contenedores de dos maneras:
Puedes enlazar contenedores utilizando la opción --link
, aunque esta opción está en desuso y no se recomienda para redes personalizadas. Se usa principalmente en la red bridge por defecto.
Ejemplo:
Primero, ejecuta un contenedor con un entorno interactivo:
docker run -it --rm --name Nombre_contenedor Nombre_Imagen
Para saber la IP del contenedor, usa:
[XXXX@XXX ~]# cat /etc/hosts
Luego, enlaza el contenedor con otro:
docker run -it --rm --name Nombre_contenedor --link Nombre_contenedor_destino:alias_contenedor_destino Nombre_Imagen
Notas:
--rm
elimina el contenedor automáticamente al finalizar.--name
debe ser usado para los contenedores que deseas enlazar.- El enlace no es necesario si los contenedores están en la misma red personalizada.
- Los enlaces son unidireccionales en este modo.
Para agregar un contenedor a una red personalizada:
docker run -d --name Nombre_Contenedor --rm --network Nombre_Red Nombre_Imagen
El --rm es opcional, evita la acumulación de contenedores detenidos.
Para acceder al contenedor:
docker exec -it Nombre_Contenedor bash
Para eliminar una red ya creada:
docker network rm Nombre_Red
No es posible borrar una red que tiene contenedores asociados.
Estos comandos y procedimientos te permitirán gestionar redes Docker para facilitar la comunicación entre contenedores y con el host.
Los volúmenes en Docker son fundamentales para gestionar la persistencia de datos y facilitar el intercambio de información entre contenedores y el host. A continuación, se detallan las operaciones y conceptos clave relacionados con los volúmenes en Docker:
- Persistencia de Datos: Los volúmenes permiten que los datos persistan más allá de la vida útil de un contenedor.
- Facilidad de Respaldo y Migración: Facilitan el respaldo y la migración de datos.
- Compatibilidad: Funcionan tanto en sistemas Windows como Linux.
- Compartición entre Contenedores: Un volumen puede estar conectado a varios contenedores simultáneamente.
- Creación Inicial desde un Contenedor: La información puede ser añadida a un volumen mediante un contenedor antes de que un usuario acceda a él.
- Administración con Docker: Los volúmenes se administran directamente con Docker y pueden ser gestionados de forma remota.
Puedes crear un volumen al momento de ejecutar un contenedor:
docker run -it -v Carpeta_Volumen --name Nombre_Contenedor Nombre_Imagen bash
Nota:
Carpeta_Volumen
es la ubicación dentro del contenedor donde se almacenarán los datos. El volumen se crea en la ubicación predeterminada de Docker, pero puede ser personalizado si es necesario.
Para ver todos los volúmenes disponibles:
docker volume ls
El comando muestra el driver y el nombre del volumen. Si no se especifica un nombre, Docker generará un nombre aleatorio.
Para obtener detalles sobre un volumen específico:
docker volume inspect ID/Nombre_Volumen
Se proporciona información como la fecha de creación, el tipo de driver, el punto de montaje (la ubicación en el host donde se almacenan los datos), el nombre, entre otros detalles.
Para compartir archivos o carpetas entre el host y los contenedores, puedes especificar la ruta al crear el contenedor:
docker run -it -v Direccion_Maquina_Host:Direccion_Contenedor --name Nombre_Contenedor Nombre_Imagen
# Ejemplo
docker run -it -v /root/carpeta1:/carpeta1 Nombre_Imagen
Nota: Esto asocia un directorio del host con un directorio en el contenedor. Se muestra como "HostConfig/Binds" en los datos del contenedor y no se considera un volumen en Docker.
Para compartir un volumen entre dos contenedores:
-
Crea el primer contenedor con el volumen que deseas compartir:
docker run -it -v /datos --name Nombre_Contenedor1 Nombre_Imagen bash
-
Crea el segundo contenedor y conéctalo al volumen del primer contenedor:
docker run -it --name Nombre_Contenedor2 --volumes-from Nombre_Contenedor1 Nombre_Imagen bash
Nota: No es posible conectar directamente a un volumen; debe haber un contenedor en ejecución que esté utilizando el volumen para poder compartirlo con otros contenedores.
Para crear un volumen con un nombre personalizado:
docker volume create Nombre_Volume
Para usar el volumen al crear un contenedor:
docker run -it --name Nombre_Contenedor -v Nombre_Volume:Nombre_Directorio Nombre_Imagen bash
Para hacer que un contenedor solo pueda leer datos sin modificar el directorio, agrega :ro
al nombre del directorio:
docker run -it --name Nombre_Contenedor -v Nombre_Volume:Nombre_Directorio:ro Nombre_Imagen bash
Para especificar un volumen en Windows, usa la ruta completa y cambia el separador de directorios:
docker run -it --name Nombre_Contenedor -v C:\\Users\\XXXX\\dir1:volumenDocker Nombre_Imagen bash
Nota: En Windows, se debe utilizar la ruta completa y el separador de directorios
\\
. Asegúrate de tener los permisos necesarios y la contraseña del equipo para que Docker pueda acceder al directorio.
Para eliminar un volumen específico:
docker volume rm ID/Nombre_Volumen
Nota: No se puede eliminar un volumen que esté en uso por un contenedor.
Para eliminar volúmenes que ya no están en uso o que quedaron sin ser eliminados:
docker volume prune
Nota: Se mostrará una advertencia para confirmar la acción antes de eliminar los volúmenes inactivos.
Este resumen cubre las operaciones básicas y avanzadas relacionadas con volúmenes en Docker, proporcionando una visión completa de su uso y administración.
La manipulación de imágenes y contenedores en Docker es fundamental para personalizar y optimizar tus entornos de desarrollo y producción. A continuación, se detallan los pasos y opciones disponibles para modificar y crear imágenes a partir de contenedores.
Para modificar una imagen en Docker, debes seguir estos pasos:
Primero, crea un contenedor a partir de una imagen base. Por ejemplo, para crear un contenedor basado en la imagen de Ubuntu:
docker run -it --name Nombre_Contenedor Nombre_Imagen bash
Nota: Aquí
Nombre_Contenedor
es el nombre que asignarás al contenedor, yNombre_Imagen
es la imagen base (por ejemplo,ubuntu
).
Una vez que el contenedor está en ejecución, puedes instalar software, modificar configuraciones, o realizar cualquier otra tarea necesaria. Por ejemplo, para instalar el servidor web Apache en el contenedor:
apt-get update
apt-get install -y apache2
Realiza todas las modificaciones que necesites dentro del contenedor.
Después de realizar los cambios, debes guardar estos cambios como una nueva imagen. Puedes hacerlo usando el comando docker commit
:
docker commit ID/Nombre_Contenedor Nombre_Nueva_Imagen:tag
Nota:
ID/Nombre_Contenedor
es el identificador o nombre del contenedor modificado.Nombre_Nueva_Imagen
es el nombre que deseas asignar a la nueva imagen.tag
es una etiqueta opcional que puedes utilizar para versionar la imagen. Si no se especifica, Docker asignará automáticamente el taglatest
.
Existen dos maneras principales de crear una imagen en Docker: automática y manual. En este caso, se abordará la creación manual de imágenes.
Para crear una imagen manualmente a partir de un contenedor modificado, sigue estos pasos:
-
Modifica el Contenedor: Realiza las modificaciones necesarias dentro del contenedor como se describió anteriormente.
-
Guardar los Cambios: Usa el comando
docker commit
para crear una nueva imagen que refleje los cambios realizados:docker commit ID/Nombre_Contenedor Nombre_Nueva_Imagen:tag
ID/Nombre_Contenedor
: ID o nombre del contenedor desde el cual quieres crear la imagen.Nombre_Nueva_Imagen
: Nombre que deseas asignar a la nueva imagen.tag
: Etiqueta opcional para la versión de la imagen. Si no se proporciona, Docker usalatest
por defecto.
Si modificaste un contenedor llamado mi_contenedor
y deseas guardar estos cambios en una nueva imagen llamada mi_imagen_personalizada
con una etiqueta v1.0
, el comando sería:
docker commit mi_contenedor mi_imagen_personalizada:v1.0
Nota: La creación manual de imágenes mediante
docker commit
es útil para capturar cambios en un contenedor en ejecución, pero para procesos más repetitivos y automatizados, se recomienda utilizar unDockerfile
para definir la imagen desde cero.
-
Usar Dockerfile: Para una mayor reproducibilidad y control, considera crear un
Dockerfile
en lugar de modificar contenedores manualmente. UnDockerfile
define todos los pasos necesarios para construir una imagen desde el inicio, asegurando consistencia en el proceso de construcción. -
Etiquetas y Versiones: Utiliza etiquetas para versionar tus imágenes. Esto facilita la gestión de versiones y el despliegue en entornos distintos.
-
Limpieza de Contenedores: Después de crear una imagen a partir de un contenedor, considera limpiar el contenedor antiguo si ya no es necesario, usando:
docker rm Nombre_Contenedor
-
Verificación de Imágenes: Para listar las imágenes disponibles y verificar la creación de la nueva imagen, usa:
docker images
Este ítem proporciona una guía detallada sobre cómo modificar y crear imágenes en Docker, cubriendo tanto el proceso manual como algunas mejores prácticas para un manejo eficiente de imágenes y contenedores.
Un Dockerfile
es un archivo de configuración utilizado para construir imágenes de Docker de manera automática y reproducible. Este archivo contiene un conjunto de instrucciones que Docker sigue para crear una imagen. Las imágenes son el blueprint para los contenedores, y un Dockerfile
especifica cómo debe ser construida una imagen a partir de una imagen base, agregando software, configuraciones y archivos necesarios.
Aquí tienes un ejemplo básico de un Dockerfile
que crea una imagen que ejecuta un programa "Hello-World":
FROM scratch
COPY hello /
CMD ["/hello"]
En este ejemplo:
FROM scratch
indica que la imagen base es vacía.COPY hello /
copia el archivohello
desde el contexto de construcción al contenedor.CMD ["/hello"]
especifica que el contenedor debe ejecutar el comando/hello
al iniciar.
Un Dockerfile
típico puede contener las siguientes instrucciones:
- FROM: Define la imagen base a partir de la cual se construye la nueva imagen.
- RUN: Ejecuta comandos dentro del contenedor durante la construcción de la imagen.
- COPY: Copia archivos del contexto de construcción al contenedor.
- ADD: Similar a
COPY
, pero con más funcionalidades, como descomprimir archivos y copiar desde URLs. - WORKDIR: Establece el directorio de trabajo para las siguientes instrucciones.
- ENV: Define variables de entorno.
- ARG: Define variables de construcción que pueden ser pasadas al construir la imagen.
- EXPOSE: Indica los puertos que la aplicación en el contenedor escuchará.
- VOLUME: Define puntos de montaje para volúmenes que se comparten entre el contenedor y el host.
- CMD: Especifica el comando predeterminado a ejecutar cuando el contenedor se inicia.
- ENTRYPOINT: Similar a
CMD
, pero asegura que el comando especificado se ejecute siempre cuando el contenedor se inicie.
# Seleccionar la imagen base
FROM ubuntu:20.04
# Actualizar y instalar software
RUN apt-get update && apt-get install -y python3 python3-pip
# Crear directorios y establecer el directorio de trabajo
WORKDIR /app
RUN mkdir /app/data
# Copiar archivos desde el contexto de construcción al contenedor
COPY requirements.txt /app/
COPY src/ /app/src/
# Instalar dependencias de Python
RUN pip3 install -r requirements.txt
# Exponer el puerto 8080 para la aplicación
EXPOSE 8080
# Definir variables de entorno
ENV APP_ENV=production
# Establecer el punto de entrada
ENTRYPOINT ["python3", "src/app.py"]
# Comando predeterminado
CMD ["--port", "8080"]
El comando RUN
se utiliza para ejecutar comandos en una capa de la imagen. Puedes usar &&
para combinar múltiples comandos en una sola capa:
RUN apt-get update && apt-get install -y python3 && apt-get install -y git
Para una mejor legibilidad, también puedes usar \
para dividir comandos largos en varias líneas:
RUN apt-get update && \
apt-get install -y python3 && \
apt-get install -y git
El comando CMD
especifica el comando predeterminado a ejecutar cuando el contenedor inicia. Puedes utilizar CMD
en dos formatos:
-
Formato de Shell: Ejecuta el comando en un shell:
CMD echo "Hello, World!"
-
Formato Exec: Ejecuta el comando directamente sin un shell, lo que es más eficiente:
CMD ["echo", "Hello, World!"]
Nota: Solo puede haber un
CMD
por Dockerfile. Si se especifican múltiplesCMD
, solo se ejecutará el último.
El comando ENTRYPOINT
define el comando que se ejecuta siempre que el contenedor se inicia, independientemente de los comandos pasados al contenedor:
ENTRYPOINT ["/bin/bash"]
A diferencia de CMD
, ENTRYPOINT
no se puede reemplazar en tiempo de ejecución, lo que lo hace adecuado para casos donde quieres que el contenedor siempre ejecute un comando específico.
Puedes usar ENTRYPOINT
junto con CMD
para proporcionar argumentos predeterminados:
ENTRYPOINT ["python3", "src/app.py"]
CMD ["--port", "8080"]
En este caso, ENTRYPOINT
define el comando principal, mientras que CMD
proporciona argumentos opcionales.
WORKDIR
establece el directorio de trabajo para los comandos RUN
, CMD
, ENTRYPOINT
, COPY
, y ADD
. Puedes usar WORKDIR
varias veces:
WORKDIR /app
RUN mkdir data
WORKDIR /app/data
RUN touch file.txt
El contenedor se iniciará en el último directorio de trabajo especificado.
COPY
copia archivos y directorios desde el contexto de construcción al contenedor:
COPY index.html /app/
ADD
tiene capacidades adicionales, como descomprimir archivos y copiar desde URLs:
ADD archive.tar.gz /app/
ADD https://example.com/file.txt /app/
Nota: Prefiere
COPY
cuando solo necesites copiar archivos locales, ya queADD
tiene más funcionalidades que pueden no ser necesarias y podrían introducir complejidades innecesarias.
ENV
define variables de entorno que estarán disponibles en el contenedor:
ENV APP_ENV=production
Estas variables se pueden usar en el contenedor para configurar el entorno de ejecución.
ARG
permite definir variables que pueden ser pasadas en tiempo de construcción:
ARG APP_VERSION
RUN echo $APP_VERSION
Puedes pasar valores a las variables ARG
usando --build-arg
:
docker build --build-arg APP_VERSION=1.0 -t my_image .
Nota:
ARG
solo está disponible durante la construcción de la imagen, mientras queENV
está disponible en el contenedor en ejecución.
EXPOSE
indica que el contenedor escuchará en el puerto especificado. Esto es informativo y no publica el puerto por sí mismo:
EXPOSE 8080
Para publicar el puerto en el host, usa el flag -p
con docker run
:
docker run -p 8080:8080 my_image
VOLUME
crea un punto de montaje para volúmenes. Esto permite persistir datos generados y compartidos entre contenedores:
VOLUME ["/data"]
Puedes montar volúmenes en el contenedor al ejecutar docker run
:
docker run -v /host/data:/data my_image
Este artículo proporciona una visión completa y detallada de los conceptos básicos y comandos de Dockerfile
, cubriendo desde la creación de una imagen hasta la gestión de volúmenes y variables. Con esta guía, deberías estar bien preparado para crear y personalizar imágenes de Docker de manera efectiva.
Docker Hub es un servicio de repositorio en línea para imágenes de Docker. Proporciona un espacio para almacenar, compartir y gestionar imágenes de Docker. Puedes encontrar imágenes oficiales proporcionadas por empresas y organizaciones, así como imágenes creadas y compartidas por otros usuarios de la comunidad.
Antes de subir una imagen a Docker Hub, necesitas iniciar sesión en tu cuenta. Puedes hacerlo con el siguiente comando:
docker login
Pasos para iniciar sesión:
- Al ejecutar
docker login
, se te pedirá que ingreses tu nombre de usuario y contraseña de Docker Hub. - Una vez ingresados los datos correctamente, verás el mensaje
Login Succeeded
, que indica que el inicio de sesión fue exitoso. - La sesión permanecerá activa mientras el terminal esté abierto o mientras la conexión sea válida.
Docker Hub requiere que las imágenes se etiqueten de manera específica antes de subirlas. Esta etiqueta incluye el nombre del usuario de Docker Hub y el nombre del repositorio. Para etiquetar una imagen existente, usa el comando docker image tag
:
docker image tag Nombre_Imagen:TAG NombreUsuario/NombreImagen:TAG
Ejemplo:
Supongamos que tienes una imagen local llamada mi-imagen
con la etiqueta v1.0
. Si tu nombre de usuario en Docker Hub es miusuario
, deberías etiquetar tu imagen de la siguiente manera:
docker image tag mi-imagen:v1.0 miusuario/mi-imagen:v1.0
En este ejemplo:
mi-imagen:v1.0
es el nombre y la etiqueta de la imagen local.miusuario/mi-imagen:v1.0
es el nombre y la etiqueta que se usará en Docker Hub.
Una vez que la imagen esté etiquetada correctamente, puedes subirla a Docker Hub con el siguiente comando:
docker push NombreUsuario/NombreImagen:TAG
Ejemplo:
Siguiendo el ejemplo anterior, para subir la imagen etiquetada miusuario/mi-imagen:v1.0
, usarías el siguiente comando:
docker push miusuario/mi-imagen:v1.0
Notas:
- Asegúrate de reemplazar
NombreUsuario
,NombreImagen
, yTAG
con los valores correspondientes a tu imagen y cuenta de Docker Hub. - El proceso de subida puede tardar un poco dependiendo del tamaño de la imagen y la velocidad de tu conexión a Internet.
-
Iniciar sesión en Docker Hub:
docker login
-
Etiquetar la imagen:
docker image tag Nombre_Imagen:TAG NombreUsuario/NombreImagen:TAG
-
Subir la imagen:
docker push NombreUsuario/NombreImagen:TAG
Con estos pasos, puedes subir tus imágenes a Docker Hub y compartirlas con otros usuarios o utilizarlas en diferentes entornos. ¡Docker Hub es una herramienta poderosa para gestionar y distribuir imágenes de Docker de manera eficiente!
Docker Compose es una herramienta fundamental para la definición y ejecución de aplicaciones que requieren múltiples contenedores Docker. Utilizando un archivo de configuración llamado docker-compose.yml
, Docker Compose permite orquestar y coordinar los diferentes servicios y contenedores que componen una aplicación, facilitando su gestión y despliegue.
Docker Compose simplifica el manejo de aplicaciones complejas al permitir la definición de múltiples servicios en un solo archivo. Este archivo, docker-compose.yml
, describe cómo deben configurarse y ejecutarse los contenedores, sus redes, volúmenes y otras dependencias.
Por ejemplo, en un stack MEAN (MongoDB, Express, Angular, Node.js), Docker Compose facilita la configuración y coordinación de todos los componentes necesarios. En lugar de iniciar y gestionar cada contenedor de forma independiente, Docker Compose permite hacerlo con un único comando, lo que optimiza y simplifica el flujo de trabajo.
Docker Compose se incluye automáticamente en Docker Desktop para sistemas operativos Windows y macOS. Para Linux, la instalación debe realizarse manualmente. Aquí te dejo una guía rápida para cada plataforma:
Docker Compose ya está integrado en Docker Desktop. Solo necesitas instalar Docker Desktop para tener Docker Compose disponible.
Para instalar Docker Compose en Linux, sigue estos pasos:
-
Descarga la versión más reciente:
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
-
Aplica permisos de ejecución:
sudo chmod +x /usr/local/bin/docker-compose
-
Verifica la instalación:
docker-compose --version
Para obtener más detalles y la documentación completa, visita la documentación oficial de Docker Compose.
Esta versión proporciona una visión más clara de lo que es Docker Compose y cómo se instala en diferentes sistemas operativos, ofreciendo un enfoque más estructurado y fácil de seguir.
El comando docker-compose up
es una de las herramientas más utilizadas en Docker Compose y se encarga de iniciar los servicios definidos en el archivo docker-compose.yml
. Este comando permite construir, crear y arrancar los contenedores según la configuración especificada en el archivo. A continuación se detallan sus principales características y usos:
Cuando ejecutas docker-compose up
, Docker Compose realiza las siguientes acciones:
-
Lee el Archivo
docker-compose.yml
: Docker Compose lee la configuración del archivodocker-compose.yml
ubicado en el directorio actual. Este archivo define los servicios, redes, volúmenes y otras configuraciones necesarias para los contenedores. -
Construye las Imágenes (si es necesario): Si el archivo
docker-compose.yml
especifica que se deben construir imágenes desde un Dockerfile, Docker Compose se encargará de construir estas imágenes antes de iniciar los contenedores. -
Crea y Arranca los Contenedores: Docker Compose crea los contenedores según la configuración proporcionada y luego los arranca. Si los contenedores ya existen, simplemente los inicia.
-
Configura Redes y Volúmenes: Si el archivo
docker-compose.yml
define redes y volúmenes, Docker Compose los configura y los asocia a los contenedores correspondientes. -
Muestra los Logs en Tiempo Real: Mientras los contenedores están en ejecución, Docker Compose muestra la salida de los logs en la terminal, permitiendo observar la actividad de los servicios en tiempo real.
Para iniciar los servicios definidos en el archivo docker-compose.yml
, simplemente ejecuta el siguiente comando:
docker-compose up
Resultado:
# Ejemplo 1
[XXXX@XXX ~]# docker-compose up
Creating network "mi_red" with the default driver
Creating volume "mi_volumen" with default driver
Creating mi_servicio_db_1 ... done
Creating mi_servicio_web_1 ... done
Attaching to mi_servicio_db_1, mi_servicio_web_1
mi_servicio_db_1 | [Fecha y Hora] Mensaje del contenedor de base de datos
mi_servicio_web_1 | [Fecha y Hora] Mensaje del contenedor web
...
En este ejemplo, docker-compose up
inicia dos contenedores (mi_servicio_db_1
y mi_servicio_web_1
) y muestra sus logs en tiempo real.
-
-d (Detached Mode): Para ejecutar los contenedores en segundo plano, agrega el flag -d:
docker-compose up -d
Esto permite que los contenedores se ejecuten en el fondo, liberando la terminal para otros comandos.
-
--build
: Para forzar la reconstrucción de las imágenes antes de iniciar los contenedores, utiliza:docker-compose up --build
-
--force-recreate
: Para forzar la recreación de los contenedores, incluso si no ha habido cambios, usa:docker-compose up --force-recreate
-
--remove-orphans
: Para eliminar contenedores que no están definidos en el archivodocker-compose.yml
actual, puedes usar:docker-compose up --remove-orphans
Este comando es esencial para la gestión de aplicaciones multicontenedor, permitiendo una configuración y ejecución sencilla de servicios interdependientes.
Espero que esta explicación te sea útil para comprender cómo funciona el comando docker-compose up
y cómo puedes utilizarlo eficazmente en tus proyectos.
El comando docker-compose ps
se utiliza para mostrar una lista de los contenedores que forman parte de los servicios definidos en el archivo docker-compose.yml
. Este comando proporciona una visión general del estado actual de los contenedores, similar a lo que ofrece el comando docker ps
, pero específicamente para los servicios gestionados por Docker Compose.
Cuando ejecutas docker-compose ps
, Docker Compose realiza las siguientes acciones:
-
Lee el Archivo
docker-compose.yml
: Docker Compose analiza el archivodocker-compose.yml
ubicado en el directorio actual para identificar los servicios definidos y los contenedores asociados. -
Muestra Información de los Contenedores: El comando lista todos los contenedores que están siendo gestionados por Docker Compose, incluyendo su estado actual y otra información relevante.
-
Proporciona Detalles del Estado del Contenedor: La salida incluye información sobre el estado de cada contenedor, lo que facilita la supervisión y gestión de los servicios.
Para obtener una lista de los contenedores gestionados por Docker Compose y su estado actual, ejecuta el siguiente comando:
docker-compose ps
Resultado:
# Ejemplo 1
[XXXX@XXX ~]# docker-compose ps
Name Command State Ports
----------------------------------------------------------------------------
mi_servicio_db_1 docker-entrypoint.sh mongod Up 27017/tcp
mi_servicio_web_1 /bin/sh -c 'npm start' Up 0.0.0.0:80->80/tcp
En este ejemplo:
- Name: Muestra el nombre del contenedor, que incluye el nombre del servicio y un sufijo numérico.
- Command: Muestra el comando que el contenedor está ejecutando.
- State: Indica el estado actual del contenedor (por ejemplo, "Up" si está en ejecución).
- Ports: Muestra los puertos expuestos y su mapeo desde el contenedor al host.
-
-q
(Quiet Mode): Para mostrar solo los IDs de los contenedores sin información adicional, utiliza:docker-compose ps -q
-
--services
: Para listar solo los nombres de los servicios (sin detalles de los contenedores), usa:docker-compose ps --services
-
--filter
: Para filtrar la lista de contenedores según ciertos criterios, como el estado (por ejemplo,status=running
):docker-compose ps --filter "status=running"
-
Monitoreo del Estado de los Servicios: Puedes usar
docker-compose ps
para verificar rápidamente si todos los servicios están en funcionamiento y si los contenedores están correctamente configurados. -
Diagnóstico de Problemas: Si un contenedor no está funcionando como se espera,
docker-compose ps
te permite verificar su estado actual y detectar posibles problemas. -
Verificación de Puertos: Puedes comprobar qué puertos están expuestos y mapeados, asegurándote de que la configuración de red es la esperada.
Este comando es útil para la administración de aplicaciones multicontenedor, proporcionando una visión clara del estado de cada contenedor dentro de un entorno Docker Compose.
El comando docker-compose images
se utiliza para listar las imágenes Docker que están siendo utilizadas por los contenedores gestionados por Docker Compose. Este comando proporciona una visión general de las imágenes que se han construido o descargado y que están en uso en el contexto de un archivo docker-compose.yml
.
Cuando ejecutas docker-compose images
, Docker Compose realiza las siguientes acciones:
-
Lee el Archivo
docker-compose.yml
: Docker Compose analiza el archivodocker-compose.yml
en el directorio actual para identificar las imágenes asociadas a cada servicio. -
Lista las Imágenes Utilizadas: El comando muestra una lista de las imágenes que se están utilizando en los servicios definidos. Esto incluye tanto imágenes construidas localmente como imágenes descargadas de un registro Docker (por ejemplo, Docker Hub).
-
Proporciona Detalles Relevantes: La salida incluye información como el nombre de la imagen, el nombre del contenedor y la etiqueta asociada, lo que facilita la administración y verificación de las imágenes.
Para ver una lista de las imágenes utilizadas por los servicios definidos en el archivo docker-compose.yml
, ejecuta el siguiente comando:
docker-compose images
Resultado:
# Ejemplo 1
[XXXX@XXX ~]# docker-compose images
Container Repository Tag Image ID Size
-----------------------------------------------------------------------------------
mi_servicio_db_1 mongo latest a1b2c3d4e5f6 487MB
mi_servicio_web_1 myapp/frontend 1.0 7g8h9i0j1k2l 230MB
En este ejemplo:
- Container: Muestra el nombre del contenedor asociado a la imagen.
- Repository: Indica el nombre del repositorio de la imagen.
- Tag: Muestra la etiqueta de la imagen, que puede ser una versión específica (por ejemplo,
latest
,1.0
). - Image ID: Proporciona el ID único de la imagen, útil para identificaciones más precisas.
- Size: Muestra el tamaño de la imagen en disco.
Actualmente, el comando docker-compose images
no tiene opciones adicionales específicas. Sin embargo, puedes combinarlo con otros comandos para obtener información complementaria:
docker images
: Para obtener una lista más detallada de todas las imágenes Docker en el sistema, puedes usar el comandodocker images
. Esto proporcionará información sobre imágenes no solo relacionadas con Docker Compose, sino también imágenes de otros proyectos o servicios.
-
Verificación de Imágenes: Utiliza
docker-compose images
para confirmar qué imágenes se están utilizando en tu entorno Docker Compose, lo cual es útil para asegurar que estás utilizando la versión correcta de cada imagen. -
Gestión de Espacio en Disco: Puedes verificar el tamaño de las imágenes para gestionar el espacio en disco de manera más efectiva, especialmente si tienes imágenes grandes que podrían estar ocupando espacio innecesario.
-
Depuración: Si un servicio no está funcionando como se espera, comprobar las imágenes utilizadas puede ayudar a identificar problemas relacionados con versiones incorrectas o imágenes obsoletas.
Este comando es útil para la administración de imágenes en un entorno Docker Compose, proporcionando una visión clara de qué imágenes están en uso y facilitando la gestión y verificación de los recursos de contenedor.
El comando docker-compose config
es una herramienta útil para validar y verificar la configuración de tu archivo docker-compose.yml
. Te ayuda a asegurar que la sintaxis y la estructura del archivo son correctas, y te proporciona información detallada sobre los servicios y configuraciones definidas.
-
Valida la Sintaxis: Verifica si el archivo
docker-compose.yml
está correctamente formateado y sigue la sintaxis YAML adecuada. Esto ayuda a prevenir errores de configuración que podrían afectar la ejecución de los contenedores. -
Muestra la Configuración Completa: Imprime la configuración completa del archivo
docker-compose.yml
, lo que te permite revisar y confirmar que todas las opciones y servicios están definidos correctamente. -
Detecta Errores: Identifica y muestra errores en la configuración del archivo, como errores de sintaxis o configuraciones incorrectas, proporcionando mensajes de error específicos para facilitar la resolución de problemas.
-
Mostrar Información Completa del Archivo
Para mostrar la información completa y la configuración contenida dentro del archivo
docker-compose.yml
, usa el siguiente comando:docker-compose config
Resultado:
# Ejemplo 1 version: '3.8' services: web: image: nginx:latest ports: - "80:80" db: image: postgres:latest environment: POSTGRES_PASSWORD: example
Este comando muestra toda la configuración que Docker Compose está utilizando para crear y gestionar los servicios. Es útil para revisar y verificar que todos los servicios y configuraciones están correctamente definidos.
-
Mostrar Solo los Errores
Para verificar si hay errores en el archivo
docker-compose.yml
sin mostrar la configuración completa, usa la opción-q
(quiet):docker-compose config -q
Resultado:
# Ejemplo 2 [XXXX@XXX ~]# docker-compose config -q
Si no hay errores, no se muestra ninguna salida. Si hay errores, se mostrarán mensajes de error que te ayudarán a identificar y corregir los problemas en el archivo de configuración.
-
Mostrar Solo los Servicios Definidos
Para listar únicamente los servicios definidos en el archivo
docker-compose.yml
, utiliza la opción--services
:docker-compose config --services
Resultado:
# Ejemplo 3 [XXXX@XXX ~]# docker-compose config --services web db
Esto proporciona una lista de los nombres de los servicios que están definidos en el archivo de configuración. Es útil para una visión rápida de los servicios que Docker Compose va a gestionar.
-
Ubicación del Archivo: Para que el comando funcione correctamente, debes ejecutar
docker-compose config
en el directorio donde se encuentra el archivodocker-compose.yml
, o especificar el archivo con la opción -f si está en una ubicación diferente. -
Uso en Desarrollo: Utiliza este comando durante el desarrollo para validar la configuración antes de iniciar los servicios. Esto puede ayudarte a detectar errores de configuración antes de que causen problemas en la ejecución de los contenedores.
-
Validación en CI/CD: Integra
docker-compose config
en tus procesos de integración continua y despliegue continuo (CI/CD) para asegurarte de que las configuraciones son válidas antes de desplegar aplicaciones en entornos de producción.
El comando docker-compose config
es una herramienta esencial para garantizar la validez y precisión de tu configuración en Docker Compose, ayudando a evitar problemas antes de que afecten la ejecución de tus servicios.
El comando docker-compose start
se utiliza para iniciar los contenedores que componen los servicios definidos en un archivo docker-compose.yml
que ya han sido creados anteriormente. A diferencia de docker-compose up
, que crea y luego inicia los contenedores, docker-compose start
solo inicia contenedores que ya están definidos y creados.
-
Inicia Contenedores Existentes: Este comando inicia contenedores que han sido previamente creados con
docker-compose create
odocker-compose up
, pero que están detenidos. No crea nuevos contenedores ni configura servicios, solo arranca los contenedores existentes. -
Recupera el Estado Anterior: Restaura los contenedores a su estado de ejecución anterior, si estaban en pausa o detenidos. Los contenedores no se recrean, lo que puede ahorrar tiempo en comparación con reiniciar todo el entorno.
-
No Re-Configura ni Re-Crea: A diferencia de
docker-compose up
, que también puede recrear contenedores y aplicar cambios en la configuración,docker-compose start
solo se enfoca en iniciar los contenedores existentes sin modificar su configuración.
-
Iniciar Todos los Contenedores Detenidos
Para iniciar todos los contenedores que están definidos en el archivo
docker-compose.yml
y que están en estado detenido, utiliza:docker-compose start
Resultado:
Starting web ... done Starting db ... done
En este ejemplo,
docker-compose start
arranca los contenedores para los serviciosweb
ydb
que ya han sido creados. El comando muestra un mensaje indicando que cada contenedor ha sido iniciado correctamente. -
Iniciar Contenedores Específicos
Para iniciar solo contenedores específicos dentro de los servicios definidos, puedes proporcionar el nombre de uno o más servicios:
docker-compose start web db
Resultado:
Starting web ... done Starting db ... done
Aquí, solo los contenedores correspondientes a los servicios
web
ydb
se inician, dejando otros servicios en su estado actual.
-
Contenedores Preexistentes: Asegúrate de que los contenedores han sido creados previamente antes de usar
docker-compose start
. Si los contenedores no existen, el comando no los creará ni los iniciará. -
Uso en Desarrollo: Utiliza
docker-compose start
en entornos de desarrollo para reanudar rápidamente el trabajo en contenedores que estaban detenidos sin la necesidad de recrearlos. -
Reinicio de Contenedores: Si necesitas aplicar cambios en la configuración o actualizar las imágenes, es mejor usar
docker-compose up
para asegurar que todos los contenedores se configuren y creen de nuevo según las últimas especificaciones. -
Combinación con Otros Comandos: Puedes combinar
docker-compose start
con otros comandos comodocker-compose stop
para gestionar el ciclo de vida de tus contenedores en diferentes estados.
El comando docker-compose start
es una herramienta útil para gestionar y reiniciar contenedores que ya han sido creados pero están detenidos. Proporciona una manera eficiente de reanudar servicios sin tener que recrear contenedores o aplicar nuevas configuraciones, lo que puede ser especialmente valioso en entornos de desarrollo y pruebas.
El comando docker-compose logs
se utiliza para ver los registros (logs) generados por los contenedores de un servicio específico dentro de una configuración de Docker Compose. Estos logs proporcionan información crucial sobre el funcionamiento del servicio, incluyendo mensajes de información, advertencias y errores que ocurren durante la ejecución.
-
Visualiza Registros de Contenedores: Muestra la salida de los logs de los contenedores asociados a un servicio específico. Estos registros pueden incluir detalles sobre el comportamiento del servicio, errores encontrados, y mensajes de depuración.
-
Filtra por Servicio: Permite especificar un servicio particular dentro del archivo
docker-compose.yml
para ver sus logs, lo cual es útil cuando quieres concentrarte en la salida de un solo componente de la aplicación. -
Facilita la Depuración: Ayuda en la depuración y monitoreo de aplicaciones al proporcionar un flujo continuo de registros de actividad y errores, permitiendo identificar y solucionar problemas de manera más eficiente.
-
Ver Logs de un Servicio Específico
Para ver los logs de un servicio específico, proporciona el nombre del servicio definido en el archivo
docker-compose.yml
. Por ejemplo, para ver los logs del servicioweb
:docker-compose logs web
Resultado:
web_1 | [Fecha y Hora] Información de inicio del servicio web_1 | [Fecha y Hora] Mensaje de log de advertencia web_1 | [Fecha y Hora] Mensaje de error
En este ejemplo, el comando muestra los registros generados por el contenedor asociado al servicio
web
, incluyendo información de inicio, advertencias y errores. -
Ver Logs de Todos los Servicios
Si quieres ver los logs de todos los servicios definidos en el archivo
docker-compose.yml
, simplemente omite el nombre del servicio:docker-compose logs
Resultado:
web_1 | [Fecha y Hora] Información del servicio web db_1 | [Fecha y Hora] Información del servicio de base de datos
Aquí, el comando muestra los registros de todos los contenedores asociados a los servicios
web
ydb
. -
Ver Logs en Tiempo Real
Para seguir los logs en tiempo real (similar a tailing en archivos de log), usa la opción -f o
--follow
:docker-compose logs -f web
Resultado:
web_1 | [Fecha y Hora] Información en tiempo real del servicio web web_1 | [Fecha y Hora] Más mensajes de log en tiempo real
Con esta opción, el comando sigue mostrando nuevos registros a medida que se generan, permitiendo una visualización continua.
-
Ver Logs con Timestamps
Para incluir timestamps en los logs, utiliza la opción
--timestamps
:docker-compose logs --timestamps web
Resultado:
web_1 | [Fecha y Hora] Información con timestamp del servicio web web_1 | [Fecha y Hora] Mensaje adicional con timestamp
Esto ayuda a identificar cuándo ocurrieron eventos específicos en los registros.
-
Acceso a Registros Anteriores:
docker-compose logs
muestra los registros generados desde que el contenedor se inició. No proporciona acceso a registros históricos más allá de lo que está disponible en el sistema de archivos del contenedor. -
Espaciado y Formato: La salida de logs puede variar en formato dependiendo de la configuración del servicio y de la aplicación que se está ejecutando en el contenedor.
-
Utilidad en Desarrollo y Producción: En desarrollo,
docker-compose logs
es útil para depuración en tiempo real. En producción, puede ser necesario redirigir los logs a un sistema de gestión de logs para un análisis más robusto. -
Recursos de Sistema: El comando puede generar una gran cantidad de salida si se utiliza con servicios que producen muchos registros, así que úsalos con cuidado para evitar sobrecargar la terminal.
El comando docker-compose logs
es una herramienta esencial para la monitorización y depuración de aplicaciones que utilizan Docker Compose. Permite acceder a los registros generados por los contenedores, facilitando la identificación de problemas y el seguimiento del comportamiento de los servicios en ejecución.
El comando docker-compose top
permite ver los procesos que se están ejecutando dentro de los contenedores de un servicio gestionado por Docker Compose. Muestra una lista de los procesos activos, similar a la forma en que top
o htop
funciona en sistemas Linux, pero específico para contenedores de Docker.
-
Visualiza Procesos en Contenedores: Muestra los procesos en ejecución dentro de los contenedores asociados a un servicio. Esto incluye información sobre el uso de CPU, memoria y otros detalles del proceso.
-
Identificación de Recursos Intensivos: Ayuda a identificar qué procesos están utilizando más recursos dentro de los contenedores, lo que puede ser útil para la depuración y optimización.
-
Monitoreo de Contenedores: Proporciona una visión rápida del estado de los procesos en los contenedores, permitiendo a los administradores de sistemas y desarrolladores monitorear el comportamiento de los servicios en tiempo real.
-
Ver Procesos de un Servicio Específico
Para ver los procesos que se están ejecutando dentro de los contenedores de un servicio específico, proporciona el nombre del servicio definido en el archivo
docker-compose.yml
. Por ejemplo, para ver los procesos del servicioweb
:docker-compose top web
Resultado:
Name CPU % MEM USAGE / LIMIT MEM % NET I/O PID web_1 0.00% 15.4MiB / 1GiB 1.50% 2.1MB / 1.5MB 1234 web_2 0.01% 16.2MiB / 1GiB 1.62% 2.3MB / 1.8MB 5678
En este ejemplo, el comando muestra una lista de procesos para los contenedores asociados al servicio
web
, incluyendo el uso de CPU, memoria y otras métricas relevantes. -
Ver Todos los Procesos de Todos los Servicios
Si quieres ver los procesos de todos los servicios definidos en el archivo
docker-compose.yml
, omite el nombre del servicio:docker-compose top
Resultado:
Name CPU % MEM USAGE / LIMIT MEM % NET I/O PID web_1 0.00% 15.4MiB / 1GiB 1.50% 2.1MB / 1.5MB 1234 db_1 0.03% 20.1MiB / 1GiB 2.01% 3.0MB / 2.5MB 4321
Aquí, el comando muestra los procesos para todos los contenedores de todos los servicios, proporcionando una visión general del uso de recursos en toda la aplicación.
-
Ver Detalles Específicos de Procesos
La salida de
docker-compose top
incluye columnas que proporcionan información específica sobre cada proceso, tales como:- Name: Nombre del contenedor o del proceso.
- CPU %: Porcentaje de uso de CPU por el proceso.
- MEM USAGE / LIMIT: Uso de memoria del proceso y el límite asignado.
- MEM %: Porcentaje de memoria utilizada en relación con el límite.
- NET I/O: Información sobre la entrada/salida de red.
- PID: Identificador del proceso.
-
Estado de los Contenedores: El comando
docker-compose top
solo muestra información sobre los contenedores que están en ejecución. Si un contenedor está detenido, sus procesos no aparecerán en la salida. -
Uso de Recursos: La visualización de procesos puede ser útil para identificar cuellos de botella en el rendimiento y para optimizar el uso de recursos en los contenedores.
-
Formato de Salida: La salida puede variar dependiendo del sistema y de la versión de Docker Compose utilizada. Los detalles de los procesos pueden ser más extensos en entornos con muchos contenedores y servicios.
-
Interacción con Otros Comandos: Puede ser útil usar
docker-compose top
junto con otros comandos comodocker-compose logs
para obtener una visión completa del estado y rendimiento de los servicios.
El comando docker-compose top
proporciona una visión detallada de los procesos en ejecución dentro de los contenedores gestionados por Docker Compose. Permite a los usuarios identificar procesos que consumen muchos recursos y monitorear el estado de los servicios en tiempo real. Es una herramienta valiosa para la administración y optimización de aplicaciones basadas en contenedores.
El comando docker-compose pause
permite pausar temporalmente todos los contenedores que están ejecutándose en un servicio gestionado por Docker Compose. Esta funcionalidad es útil cuando se desea detener la ejecución de los contenedores sin eliminarlos ni detener completamente los servicios.
-
Pausa Contenedores: Pausa la ejecución de todos los contenedores asociados a los servicios definidos en el archivo
docker-compose.yml
. La pausa detiene la ejecución de procesos dentro de los contenedores, pero mantiene el estado y los datos en su lugar. -
Mantiene Estado: Aunque los contenedores están pausados, los datos y la configuración permanecen intactos. Los contenedores pueden ser reanudados más tarde sin pérdida de información.
-
Útil para Mantenimiento: Pausar contenedores puede ser útil durante el mantenimiento o la actualización de servicios, permitiendo que los servicios sean interrumpidos temporalmente sin necesidad de reiniciar o eliminar los contenedores.
-
Pausar Todos los Contenedores
Para pausar todos los contenedores definidos en el archivo
docker-compose.yml
, simplemente usa el siguiente comando:docker-compose pause
Resultado:
Pausing service1 ... done Pausing service2 ... done
En este ejemplo, todos los contenedores asociados a
service1
yservice2
se pausarán. Los procesos dentro de estos contenedores se detendrán, pero los contenedores seguirán existiendo y ocupando recursos. -
Pausar Contenedores Específicos
Si deseas pausar solo los contenedores de servicios específicos, proporciona el nombre del servicio. Por ejemplo, para pausar solo el servicio
web
:docker-compose pause web
Resultado:
Pausing web ... done
Esto detendrá los procesos del contenedor asociado al servicio
web
, mientras que los demás servicios seguirán funcionando normalmente. -
Reanudar Contenedores
Para reanudar los contenedores que han sido pausados, utiliza el siguiente comando:
docker-compose unpause
Resultado:
Unpausing service1 ... done Unpausing service2 ... done
El comando
docker-compose unpause
reanudará la ejecución de todos los contenedores que fueron pausados anteriormente, restaurando su operación normal. -
Reanudar Contenedores Específicos
Al igual que con la pausa, puedes reanudar solo los contenedores de servicios específicos:
docker-compose unpause web
Resultado:
Unpausing web ... done
Esto reanudará el contenedor del servicio
web
mientras que otros contenedores permanecerán en su estado actual.
-
Impacto en los Contenedores: La pausa detiene los procesos en los contenedores, pero no libera recursos como la memoria y el almacenamiento. Los contenedores continúan ocupando espacio en disco y pueden seguir utilizando recursos de red.
-
Recuperación de Estado: Cuando los contenedores se reanudan, los procesos y aplicaciones dentro de ellos continúan desde el punto en el que fueron pausados, sin pérdida de estado o datos.
-
Compatibilidad: La funcionalidad de pausa y reanudación puede depender de cómo los contenedores y servicios están configurados y gestionados. Asegúrate de que los contenedores soporten esta funcionalidad para evitar problemas.
-
Uso en Entornos de Producción: Usar
pause
yunpause
en entornos de producción debe hacerse con cuidado, ya que puede afectar la disponibilidad de los servicios. Considera los posibles impactos en la experiencia del usuario y en el rendimiento del sistema.
El comando docker-compose pause
proporciona una forma de pausar temporalmente todos o algunos de los contenedores gestionados por Docker Compose, deteniendo la ejecución de procesos sin eliminar los contenedores. Este comando es útil para mantenimiento o actualizaciones que requieren detener servicios sin perder datos. Para reanudar los contenedores, se utiliza docker-compose unpause
, restaurando la operación normal de los servicios.
El comando docker-compose restart
reinicia todos los servicios gestionados por Docker Compose, deteniendo los contenedores en ejecución y luego iniciándolos nuevamente. Esto puede ser útil para aplicar cambios en la configuración o en el entorno que requieren que los servicios se reinicien.
-
Reinicia Contenedores: Detiene todos los contenedores asociados a los servicios definidos en el archivo
docker-compose.yml
y luego los vuelve a iniciar. Esto es útil para aplicar actualizaciones de configuración o resolver problemas que podrían requerir un reinicio. -
Mantiene Datos y Configuración: Aunque los contenedores se detienen y se reinician, los datos y la configuración almacenados en volúmenes persistentes no se pierden. Los contenedores y servicios mantienen su estado y configuración después del reinicio.
-
Reiniciar Todos los Contenedores
Para reiniciar todos los contenedores definidos en el archivo
docker-compose.yml
, utiliza:docker-compose restart
Resultado:
Restarting service1 ... done Restarting service2 ... done
Este comando detiene y reinicia todos los contenedores asociados a
service1
yservice2
. -
Reiniciar Contenedores Específicos
Puedes reiniciar solo los contenedores de servicios específicos. Por ejemplo, para reiniciar el servicio
web
:docker-compose restart web
Resultado:
Restarting web ... done
Solo el contenedor asociado al servicio
web
será reiniciado.
-
Impacto en el Servicio: Reiniciar contenedores puede causar una breve interrupción en el servicio. Asegúrate de considerar el impacto en la disponibilidad de tu aplicación, especialmente en entornos de producción.
-
Uso con Cuidado: El reinicio puede resultar en la pérdida temporal de la conectividad o en la interrupción de procesos. Evalúa si un reinicio es necesario y si hay alternativas para aplicar cambios.
El comando docker-compose stop
detiene todos los contenedores que están ejecutándose en los servicios gestionados por Docker Compose. A diferencia del comando docker-compose down
, stop
no elimina los contenedores ni las redes asociadas; solo los detiene.
-
Detiene Contenedores: Detiene todos los contenedores asociados a los servicios definidos en el archivo
docker-compose.yml
. Los contenedores se mantienen en el sistema y pueden ser reiniciados sin necesidad de recrearlos. -
Mantiene Datos y Configuración: Los datos y configuraciones persistentes se mantienen intactos. Puedes reanudar los servicios y los contenedores desde su estado detenido sin perder información.
-
Detener Todos los Contenedores
Para detener todos los contenedores en ejecución:
docker-compose stop
Resultado:
Stopping service1 ... done Stopping service2 ... done
Todos los contenedores asociados a
service1
yservice2
serán detenidos. -
Detener Contenedores Específicos
Puedes detener contenedores de servicios específicos. Por ejemplo, para detener el servicio
web
:docker-compose stop web
Resultado:
Stopping web ... done
Solo el contenedor del servicio
web
será detenido.
-
Impacto en el Servicio: Detener contenedores puede interrumpir la disponibilidad de los servicios. Asegúrate de tener en cuenta el impacto en la experiencia del usuario y el funcionamiento de la aplicación.
-
Reinicio Necesario: Los contenedores detenidos pueden ser reiniciados con
docker-compose start
sin necesidad de reconstruirlos.
El comando docker-compose rm
se utiliza para eliminar los contenedores que están definidos en el archivo docker-compose.yml
. A diferencia del comando docker-compose stop
, rm
elimina completamente los contenedores detenidos, liberando recursos y espacio en disco.
-
Elimina Contenedores Detenidos: Elimina todos los contenedores que están en estado detenido. Esto es útil para limpiar recursos no utilizados y mantener un entorno ordenado.
-
No Afecta Datos Persistentes: Los volúmenes persistentes asociados a los contenedores no se eliminan. Los datos almacenados en volúmenes persisten a menos que se eliminen explícitamente.
-
Eliminar Todos los Contenedores Detenidos
Para eliminar todos los contenedores detenidos:
docker-compose rm
Resultado:
Going to remove service1, service2 Removing service1 ... done Removing service2 ... done
Los contenedores asociados a
service1
yservice2
serán eliminados. -
Eliminar Contenedores Específicos
Puedes eliminar contenedores específicos usando su nombre. Por ejemplo, para eliminar el servicio
web
:docker-compose rm web
Resultado:
Going to remove web Removing web ... done
Solo el contenedor del servicio
web
será eliminado.
-
Impacto en Datos: Asegúrate de que los datos importantes no se almacenan solo dentro de los contenedores antes de eliminarlos. Los datos persistentes en volúmenes no se eliminan, pero los datos temporales dentro de los contenedores se perderán.
-
Uso con Precaución: Eliminar contenedores es una operación irreversible. Asegúrate de que los contenedores ya no sean necesarios antes de eliminarlos.
El comando docker-compose down
detiene y elimina todos los servicios, contenedores, redes y volúmenes asociados a los servicios definidos en el archivo docker-compose.yml
. Este comando es útil para limpiar completamente el entorno de Docker Compose.
-
Detiene y Elimina Contenedores: Detiene todos los contenedores asociados a los servicios y luego los elimina. Esto incluye eliminar redes y volúmenes asociados, dependiendo de las opciones utilizadas.
-
Elimina Redes y Volúmenes: Por defecto,
docker-compose down
elimina las redes creadas por Docker Compose. Puedes usar opciones adicionales para eliminar volúmenes.
-
Detener y Eliminar Todos los Recursos
Para detener y eliminar todos los servicios, contenedores y redes asociados:
docker-compose down
Resultado:
Stopping service1 ... done Stopping service2 ... done Removing service1 ... done Removing service2 ... done Removing network mynetwork
Todos los contenedores, redes y volúmenes asociados serán eliminados.
-
Eliminar Volúmenes Asociados
Para también eliminar los volúmenes asociados a los servicios:
docker-compose down -v
Resultado:
Stopping service1 ... done Stopping service2 ... done Removing service1 ... done Removing service2 ... done Removing network mynetwork Removing volume myvolume
Además de detener y eliminar contenedores y redes, también se eliminarán los volúmenes asociados.
-
Impacto en Datos: El uso de -v para eliminar volúmenes puede resultar en la pérdida de datos persistentes almacenados en los volúmenes. Asegúrate de que no haya datos importantes que necesiten ser respaldados antes de usar esta opción.
-
Uso para Limpieza Completa: Utiliza
docker-compose down
para una limpieza completa de todos los recursos asociados a los servicios cuando ya no se necesiten. -
Recreación del Entorno: Después de ejecutar
docker-compose down
, el entorno debe ser recreado condocker-compose up
si se desea reiniciar los servicios desde el principio.
El fichero docker-compose.yml
define la configuración de múltiples servicios y cómo deben interactuar entre sí. Su estructura básica se compone de las siguientes secciones:
Define la versión de la sintaxis de Docker Compose que se está utilizando. Esto determina qué características están disponibles en el archivo de configuración.
Contiene todos los servicios que se van a ejecutar, cada uno con su propia configuración.
version: '3.8'
services:
web:
build: .
ports:
- "5000:5000"
volumes:
- .:/code
- logvolume01:/var/log
networks:
- webnet
redis:
image: redis
networks:
- webnet
volumes:
logvolume01:
networks:
webnet:
En este ejemplo:
web
construye una imagen desde el Dockerfile en el directorio actual (.
), expone el puerto 5000, y monta volúmenes locales.redis
usa la imagen oficial de Redis.- Ambos servicios están conectados a la red
webnet
.
Una vez que tienes el archivo docker-compose.yml
, puedes construir y ejecutar tus servicios de la siguiente manera:
# Construye y ejecuta los servicios definidos en el docker-compose.yml
docker-compose up
# Ejecutar en modo background (detached)
docker-compose up -d
La opción -d ejecuta los servicios en segundo plano, liberando la terminal para otras tareas.
# Solo construir los servicios sin iniciarlos
docker-compose build
Usar
docker-compose build
es útil para construir las imágenes antes de ejecutar los servicios.
Para ver el estado de los servicios definidos en tu archivo docker-compose.yml
:
docker-compose ps
Este comando muestra todos los contenedores que Docker Compose está manejando, sus estados, puertos expuestos, y más.
Un ejemplo más detallado de un archivo docker-compose.yml
que enlaza servicios:
version: '3.8'
services:
wordpress:
image: wordpress:latest
environment:
WORDPRESS_DB_HOST: dbserver:3306
WORDPRESS_DB_PASSWORD: secretpassword
ports:
- "8080:80"
depends_on:
- dbserver
dbserver:
image: mariadb:latest
environment:
MYSQL_ROOT_PASSWORD: secretpassword
ports:
- "3306:3306"
networks:
default:
driver: bridge
En este ejemplo:
wordpress
se conecta al serviciodbserver
usando la direccióndbserver:3306
.depends_on
garantiza quedbserver
esté disponible antes de iniciarwordpress
.
Los volúmenes permiten compartir datos entre el host y los contenedores o entre contenedores. Aquí hay un ejemplo detallado:
version: '3.8'
services:
web:
image: nginx:alpine
volumes:
- type: volume
source: mydata
target: /data
volume:
nocopy: true
- type: bind
source: ./static
target: /opt/app/static
ports:
- "80:80"
db:
image: postgres:latest
volumes:
- "dbdata:/var/lib/postgresql/data"
volumes:
mydata:
dbdata:
En este ejemplo:
mydata
es un volumen gestionado por Docker, montado en/data
dentro del contenedorweb
../static
es un directorio en el host montado en/opt/app/static
dentro del contenedorweb
.dbdata
es otro volumen gestionado por Docker, utilizado pordb
para almacenar datos de PostgreSQL.
Configurar redes personalizadas puede ser crucial para entornos más complejos. Ejemplo:
version: '3.8'
services:
app:
image: client
container_name: client
build: .
ports:
- "80:3000"
environment:
- MONGO_URI=mongodb://mongo_db:27017/sample
depends_on:
- db
networks:
- net3
db:
image: mongo:3.0.15
container_name: mongo_db
volumes:
- ./db:/data/db
networks:
net3:
aliases:
- "mongo_db"
- "mongo_server"
ipv4_address: 172.16.238.10
ipv6_address: 2001:3984:3989::10
networks:
net3:
driver: bridge
ipam:
driver: default
config:
- subnet: 172.16.238.0/24
- subnet: 2001:3984:3989::/64
En este ejemplo:
net3
es una red personalizada con configuración IP específica paraapp
ydb
.db
tiene una dirección IP fija y nombres de alias para la resolución dentro de la red.
docker-compose -f custom-compose.yml up
Esto ejecutará el archivo
custom-compose.yml
en lugar del predeterminadodocker-compose.yml
.
docker-compose -p custom_project_name up
Esto cambiará el nombre del proyecto para los servicios y contenedores, útil para evitar conflictos con otros proyectos.
docker-compose -f custom-compose.yml -p custom_project_name up
Combinando -f para especificar el archivo y
-p
para el nombre del proyecto.
docker-compose -p custom_project_name ps
Para listar los servicios con el nombre personalizado del proyecto.
Docker Registry es una herramienta esencial para quienes desean tener su propio repositorio privado de imágenes Docker, en lugar de depender de Docker Hub. Esto es especialmente útil para empresas o equipos que necesitan un registro interno de imágenes para mantener sus datos seguros y gestionados de forma centralizada.
Aquí profundizo en la creación, uso y almacenamiento de imágenes en Docker Registry, proporcionando ejemplos detallados y explicaciones de cómo configurar y manejar un registro privado.
Para comenzar, necesitas descargar la imagen oficial de Docker Registry desde Docker Hub:
docker pull registry:latest
Una vez descargada la imagen, puedes crear y ejecutar un contenedor que actúe como tu registro privado. El puerto 5000
es el puerto predeterminado para Docker Registry, pero puedes elegir otro puerto si lo prefieres.
docker run -d -p 5000:5000 --name mi_registro registry
Nota: Puedes cambiar
5000
por cualquier otro puerto disponible en tu sistema si lo necesitas.
Antes de subir una imagen a tu registro privado, necesitas etiquetarla para que apunte al registro correcto. La estructura del comando es la siguiente:
docker tag <nombre_imagen_local> <direccion_registro>:<puerto>/<nombre_imagen>
docker tag ubuntu localhost:5000/nuevo-ubuntu
Nota: No es recomendable usar
localhost
para un registro de producción; esto solo es útil para pruebas locales.
Para subir una imagen a tu registro privado, usa el comando docker push
especificando la dirección del registro y el nombre de la imagen.
docker push localhost:5000/nuevo-ubuntu:latest
Nota: El tag por defecto es
latest
, pero puedes especificar otros tags si es necesario.
Para descargar una imagen de tu registro privado, usa el comando docker pull
especificando la dirección del registro y el nombre de la imagen.
docker pull localhost:5000/nuevo-ubuntu:latest
Por defecto, Docker Registry almacena las imágenes en el directorio de volúmenes de Docker:
/var/lib/docker/volumes/xxxxxxxxx/_data
Puedes verificar la ubicación de almacenamiento actual con el comando:
docker inspect mi_registro
Si deseas que Docker Registry almacene las imágenes en una ubicación específica en tu sistema, puedes montar un volumen en el contenedor al crearlo.
-
Crear una Carpeta para el Almacenamiento
mkdir /mi_registro
-
Crear y Ejecutar el Contenedor con el Volumen
docker run -d --name mi_registro -p 5000:5000 -v /mi_registro:/var/lib/registry registry
Nota: En este ejemplo,
/mi_registro
es el directorio en tu sistema anfitrión donde se almacenarán las imágenes, y/var/lib/registry
es el directorio dentro del contenedor donde Docker Registry guarda las imágenes por defecto.
- Seguridad: Si tu registro se va a utilizar en un entorno de producción o accesible desde fuera de tu red local, asegúrate de configurarlo con HTTPS para asegurar la transmisión de datos.
- Autenticación: Puedes configurar autenticación básica o usar un servicio de autenticación externo para proteger el acceso a tu registro.
- Backup: Implementa estrategias de respaldo regulares para el directorio de almacenamiento para evitar la pérdida de datos.
Conclusión: Docker Registry te proporciona la flexibilidad de tener un registro privado para tus imágenes Docker, lo que es esencial para entornos corporativos o para gestionar imágenes sensibles. Configurarlo correctamente y mantener una buena práctica de seguridad y gestión es clave para aprovechar al máximo esta herramienta.
Espero que esta información te sea útil para implementar y gestionar un Docker Registry privado en tu entorno. Si tienes alguna pregunta adicional o necesitas más detalles, no dudes en preguntar.
🚧 Work In Progress 🚧
Este ítem está en desarrollo. Próximamente se añadirá información detallada sobre Kubernetes, incluyendo:
- Introducción a Kubernetes
- Configuración y despliegue de clústeres
- Gestión de aplicaciones con Kubernetes
- Ejemplos de configuración y uso
¡Mantente atento para actualizaciones!
Si estás interesado en ayudar a completar esta sección o en mejorar cualquier parte del proyecto, ¡nos encantaría recibir tu colaboración! Puedes contribuir de las siguientes maneras:
-
Enviando Pull Requests: Si tienes experiencia con Kubernetes y quieres aportar contenido, correcciones o mejoras, puedes enviar un Pull Request (PR) a este repositorio. Asegúrate de seguir las directrices de contribución.
-
Abriendo Issues: Si encuentras algo que te gustaría discutir o sugerir, abre un Issue en el repositorio. Puedes reportar problemas, hacer preguntas o proponer nuevas características.
-
Revisando el Código: Revisa el código existente y los cambios propuestos para asegurar que cumplen con los estándares del proyecto.
Consulta la sección Cómo Contribuir para obtener más detalles sobre el proceso de contribución.
Gracias por tu interés en mejorar este proyecto!