Guía Completa de Comandos y Conceptos de Docker

Este documento explora comandos esenciales de Docker, la configuración de Nginx, el manejo de volúmenes, la creación de imágenes a través de Dockerfiles, la gestión de redes y la orquestación con Docker Compose.

Comandos Fundamentales de Docker

Una tabla resumen de los comandos más utilizados en Docker:

Comando	Descripción
`docker pull`	Descargar imágenes desde un registro.
`docker push`	Subir imágenes a un registro de Docker.
`docker images`	Listar imágenes disponibles localmente.
`docker rmi`	Eliminar imágenes locales.
`docker run`	Crear y ejecutar un nuevo contenedor a partir de una imagen.
`docker stop`	Detener uno o más contenedores en ejecución.
`docker start`	Iniciar uno o más contenedores detenidos.
`docker restart`	Reiniciar uno o más contenedores.
`docker rm`	Eliminar uno o más contenedores.
`docker ps`	Listar contenedores en ejecución.
`docker logs`	Obtener los logs de un contenedor.
`docker exec`	Ejecutar un comando dentro de un contenedor en ejecución.
`docker save`	Guardar una imagen en un archivo comprimido.
`docker load`	Cargar una imagen desde un archivo comprimido.
`docker inspect`	Obtener información detallada sobre contenedores o imágenes.

Despliegue de Nginx con Docker

Ejemplo práctico para desplegar un servidor web Nginx utilizando Docker:

Consultar la imagen de Nginx en Docker Hub.
Descargar la imagen: docker pull nginx.
Verificar la imagen descagrada: docker images.
Crear y ejecutar el contenedor Nginx: docker run -d --name nginx -p 80:80 nginx. El flag -d ejecuta el contenedor en segundo plano, --name le asigna un nombre y -p mapea el puerto 80 del host al puerto 80 del contenedor.
Verificar contenedores en ejecución: docker ps o con formato personalizado: docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}".
Acceder a la interfaz web a través de la IP de la máquina virtual.
Detener el contenedor: docker stop nginx.
Listar todos los contenedores (incluyendo los detenidos): docker ps -a --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}".
Iniciar nuevamente el contenedor: docker start nginx.
Verificar el estado del contenedor iniciado: docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}".
Inspeccionar detalles del contenedor: docker inspect nginx.
Acceder al interior del contenedor: docker exec -it nginx bash. Para otros contenedores, como una base de datos MySQL, el comando podría ser: docker exec -it mysql mysql -uroot -p.
Eliminar el contenedor: Primero, si está en ejecución, se debe detener. Luego, docker rm nginx. Si se desea eliminar forzosamente un contenedor en ejecución: docker rm -f nginx.
Volúmenes de Datos en Docker

3.1 Introducción a los Volúmenes

Un volumen actúa como un puente entre un directorio dentro del contenedor y un directorio en el sistema anfitrión (host). Esto es crucial para persistir datos o para permitir la modificación de configuraciones y recursos estáticos. Por ejemplo, con Nginx, los directorios html (para contenido web) y conf (para la configuración) son de interés. Docker facilita la conexión de estos directorios de contenedor a directorios del host mediante volúmenes.

Al crear volúmenes para Nginx, como conf y html, estos se asocian a directorios específicos dentro del contenedro (/etc/nginx/conf.d y /usr/share/nginx/html respectivamente). Por defecto, Docker gestiona estos volúmenes en /var/lib/docker/volumes/, creando subdirectorios como /var/lib/docker/volumes/<em>nombre_volumen</em>/_data.

La ventaja de usar volúmenes en lugar de mapear directamente directorios del host es la desacoplación. Si la ruta del directorio en el host cambia, solo se necesita ajustar la configuración del volumen, sin afectar la estructura interna del contenedor. Los volúmenes proporcionan un nombre lógico que Docker traduce a la ruta física del host.

3.2 Comandos de Gestión de Volúmenes

Comando	Descripción
`docker volume create`	Crear un nuevo volumen.
`docker volume ls`	Listar todos los volúmenes.
`docker volume rm`	Eliminar uno o más volúmenes.
`docker volume inspect`	Mostrar información detallada de un volumen específico.
`docker volume prune`	Eliminar todos los volúmenes no utilizados por ningún contenedor.

Nota: Los volúmenes se configuran durante la creación del contenedor. Los contenedores existentes no pueden tener volúmenes añadidos posteriormente. Si un volumen no existe al crear el contenedor, Docker lo creará automáticamente.

Sintaxis para montar un volumen al crear un contenedor: -v nombre_volumen:ruta_en_contenedor.

Ejemplo para Nginx: docker run -d --name nginx -p 80:80 -v html:/usr/share/nginx/html nginx.

3.3 Montaje de Directorios Locales

Para una manipulación más directa, es posible montar directorios del sistema anfitrión en contenedores. La sintaxis es similar a la de los volúmenes:

Montar un directorio local: -v /ruta/local/en/host:/ruta/en/contenedor.
Montar un archivo local: -v /ruta/local/archivo.conf:/ruta/archivo.conf.

Importante: Para que Docker interprete la ruta como un directorio o archivo local y no como un nombre de volumen, debe comenzar con / o ./.

Ejemplo de creación de un contenedor MySQL montando directorios locales:


docker run -d \
  --name mysql \
  -p 3306:3306 \
  -e TZ=Asia/Shanghai \
  -e MYSQL_ROOT_PASSWORD=250@wangqiang \
  -v ./mysql/data:/var/lib/mysql \
  -v ./mysql/conf:/etc/mysql/conf.d \
  -v ./mysql/init:/docker-entrypoint-initdb.d \
  mysql

Las rutas exactas de los directorios a montar dentro del contenedor pueden consultarse en la documentación oficial de la imagen de MySQL.

Imágenes y Dockerfiles

4.1 Concepto de Capas (Layers)

Una imagen de Docker es una colección de archivos organizada en capas (Layers). Cada operación en la creación de una imagen genera una nueva capa, identificada por un ID único. Este sistema de capas permite la reutilización: si varias imágenes comparten capas base (como un sistema operativo Linux o un entorno de ejecución Java), solo se necesita descargar y almacenar esas capas una vez.

4.2 Creación de Imágenes con Dockerfile

Un Dockerfile es un archivo de texto que contiene instrucciones para construir una imagen de Docker de forma automatizada. Cada instrucción se traduce en una capa.

Instrucciones comunes en un Dockerfile:

Instrucción	Descripción	Ejemplo
`FROM`	Define la imagen base sobre la cual se construirá la nueva imagen.	`FROM centos:6`
`ENV`	Establece variables de entorno que pueden ser usadas en instrucciones posteriores.	`ENV key value`
`COPY`	Copia archivos o directorios desde el contexto de construcción (host) al sistema de archivos de la imagen.	`COPY ./app.jar /tmp/app.jar`
`RUN`	Ejecuta comandos en el sistema operativo de la imagen durante el proceso de construcción. Útil para instalar paquetes o configurar el entorno.	`RUN yum install gcc`
`EXPOSE`	Documenta qué puertos escucha la aplicación dentro del contenedor. No publica el puerto en el host.	`EXPOSE 8080`
`ENTRYPOINT`	Define el comando principal que se ejecutará cuando se inicie un contenedor a partir de la imagen.	`ENTRYPOINT java -jar app.jar`

Ejemplo de Dockerfile para una aplicación Java:


# Imagen base
FROM ubuntu:16.04
# Configuración de variables de entorno
ENV JAVA_DIR=/usr/local
ENV TZ=Asia/Shanghai
# Copia de archivos necesarios (JDK y aplicación)
COPY ./jdk8.tar.gz $JAVA_DIR/
COPY ./docker-demo.jar /tmp/app.jar
# Configuración de zona horaria
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# Descomprimir e instalar JDK
RUN cd $JAVA_DIR \
 && tar -xf ./jdk8.tar.gz \
 && mv ./jdk1.8.0_144 ./java8
# Configuración de PATH para Java
ENV JAVA_HOME=$JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin
# Puerto expuesto por la aplicación
EXPOSE 8080
# Comando de inicio de la aplicación
ENTRYPOINT ["java", "-jar", "/app.jar"]

Para optimizar la construcción de imágenes Java, se puede utilizar una imagen base que ya incluya el JRE/JDK, reduciendo la cantidad de capas personalizadas:


# Imagen base con JRE preinstalado
FROM openjdk:11.0-jre-buster
# Configuración de zona horaria
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# Copia del archivo JAR de la aplicación
COPY docker-demo.jar /app.jar
# Comando de inicio
ENTRYPOINT ["java", "-jar", "/app.jar"]

4.3 Construcción de Imágenes

Para construir una imagen a partir de un Dockerfile, navegue al directorio que contiene el archivo y ejecute:


# Navegar al directorio del Dockerfile
cd /ruta/al/directorio/del/dockerfile
# Construir la imagen, asignándole un nombre y etiqueta
docker build -t mi-imagen:v1.0 .

docker build: Comando para iniciar el proceso de construcción.
-t mi-imagen:v1.0: Asigna un nombre (mi-imagen) y una etiqueta (v1.0) a la imagen resultante.
.: Indica que el contexto de construcción (incluyendo el Dockerfile) se encuentra en el directorio actual. Alternativamente, se puede especificar la ruta al directorio: docker build -t mi-imagen:v1.0 /ruta/al/directorio/del/dockerfile.

Redes en Docker

Docker permite la comunicación entre contenedores, lo cual es esencial para aplicaciones distribuidas. Los contenedores se conectan a redes virtuales gestionadas por Docker.

Para verificar la conectividad entre contenedores, se puede inspeccionar la configuración de red de un contenedor y luego usar ping desde otro contenedor.


# Inspeccionar el contenedor MySQL para obtener su IP
docker inspect --format='{{range .NetworkSettings.Networks}}{{println .IPAddress}}{{end}}' mysql
# Salida esperada: 172.17.0.2

# Entrar al contenedor 'dd'
docker exec -it dd bash

# Desde el contenedor 'dd', hacer ping a la IP de MySQL
ping 172.17.0.2

Sin embargo, depender de IPs fijas es frágil. Docker proporciona redes personalizadas que permiten a los contenedores comunicarse mediante nombres de servicio o alias, en lugar de IPs.

Comandos de Gestión de Redes

Comando	Descripción
`docker network create`	Crear una nueva red virtual.
`docker network ls`	Listar todas las redes disponibles.
`docker network rm`	Eliminar una o más redes.
`docker network prune`	Eliminar todas las redes no utilizadas.
`docker network connect`	Conectar un contenedor a una red existente.
`docker network disconnect`	Desconectar un contenedor de una red.
`docker network inspect`	Mostrar información detallada de una red.

Demostración con Red Personalizada:

Crear una red: docker network create hmall.
Listar redes: docker network ls.
Conectar contenedores a la red y asignarles alias:
- Conectar MySQL con el alias db: docker network connect hmall mysql --alias db.
- Conectar el contenedor de la aplicación Java: docker network connect hmall dd.
Verificar la conectividad usando alias desde el contenedor dd:
- Entrar al contenedor: docker exec -it dd bash.
- Hacer ping al alias db: ping db. La resolución DNS dentro de la red personalizada permite la comunicación. También se puede hacer ping al nombre del contenedor (mysql).

En resumen, dentro de una red personalizada, los contenedores pueden cmounicarse utilizando sus alias (incluyendo el nombre del contenedor por defecto).

Docker Compose

Docker Compose simplifica la definición y gestión de aplicaciones multi-contenedor. Permite configurar todos los servicios de una aplicación en un único archivo docker-compose.yml (formato YAML).

6.1 Sintaxis del Archivo Compose

Se pueden mapear los parámetros comunes de docker run a las directivas de Docker Compose:

Parámetro `docker run`	Directiva en `docker-compose.yml`	Descripción
`--name`	`container_name`	Nombre explícito para el contenedor.
`-p`	`ports`	Mapeo de puertos (host:contenedor).
`-e`	`environment`	Variables de entorno.
`-v`	`volumes`	Configuración de volúmenes (nombre_volumen:ruta_contenedor o ruta_host:ruta_contenedor).
`--network`	`networks`	Especifica la red a la que se conecta el servicio.

Ejemplo de archivo docker-compose.yml:


version: "3.8"

services:
  mysql:
    image: mysql
    container_name: mysql
    ports:
      - "3306:3306"
    environment:
      TZ: Asia/Shanghai
      MYSQL_ROOT_PASSWORD: 123
    volumes:
      - "./mysql/conf:/etc/mysql/conf.d"
      - "./mysql/data:/var/lib/mysql"
      - "./mysql/init:/docker-entrypoint-initdb.d"
    networks:
      - hm-net

  hmall:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: hmall
    ports:
      - "8080:8080"
    networks:
      - hm-net
    depends_on:
      - mysql

  nginx:
    image: nginx
    container_name: nginx
    ports:
      - "18080:18080"
      - "18081:18081"
    volumes:
      - "./nginx/nginx.conf:/etc/nginx/nginx.conf"
      - "./nginx/html:/usr/share/nginx/html"
    depends_on:
      - hmall
    networks:
      - hm-net

networks:
  hm-net:
    name: hmall

6.2 Gestión de Proyectos con Docker Compose

Los comandos básicos para interactuar con Docker Compose son:

docker compose up: Crea y arranca todos los servicios definidos en el archivo compose. Se puede usar -d para modo "detached".
docker compose down: Detiene y elimina los contenedores, redes y volúmenes creados por el comando up.
docker compose ps: Lista los contenedores de los servicios en ejecución.
docker compose logs: Muestra los logs de los servicios.
docker compose stop: Detiene los contenedores de los servicios.
docker compose start: Inicia los contenedores de los servicios detenidos.
docker compose restart: Reinicia los contenedores de los servicios.
docker compose top: Muestra los procesos en ejecución dentro de los contenedores de los servicios.
docker compose exec <nombre_servicio> <comando>: Ejecuta un comando dentro de un contenedor de servicio específico.

Se puede especificar un archivo compose diferente con la opción -f, por ejemplo: docker compose -f mi-compose.yml up.

Etiquetas: Docker comandos Nginx volumenes dockerfile

Publicado el 6-8 19:46

Friki Work