Tutorial Completo de Docker Compose

 


¿Qué es Docker Compose?

Docker Compose es una herramienta que permite definir y ejecutar múltiples contenedores en conjunto mediante un archivo docker-compose.yml. Facilita la administración de entornos complejos, como aplicaciones con bases de datos, servidores web y microservicios.

Comando básico:

bash
docker-compose up -d

Docker Compose vs Dockerfile: ¿Cuál es la diferencia?

CaracterísticaDocker Compose (docker-compose.yml)Dockerfile
¿Qué hace?Orquesta múltiples contenedoresDefine la imagen de un contenedor
Uso principalEjecutar y administrar varios serviciosCrear imágenes personalizadas
Se usa con…Contenedores existentes o imágenes personalizadasDocker para construir imágenes
EjemploLevantar app con Nginx, MySQL y PHPCrear imagen de PHP con dependencias

¿Se pueden usar juntos?

Sí, y es una buena práctica combinarlos. Usas Dockerfile para definir imágenes personalizadas y Docker Compose para orquestar la aplicación con otros servicios.

Ejemplo Práctico: Dockerfile + Docker Compose

1. Crear un Dockerfile para aplicación PHP

dockerfile
# Usar una imagen base de PHP con Apache
FROM php:8.1-apache

# Instalar extensiones necesarias
RUN docker-php-ext-install mysqli pdo pdo_mysql

# Copiar el código fuente de la aplicación al contenedor
COPY ./src /var/www/html

# Exponer el puerto 80
EXPOSE 80

2. Crear un docker-compose.yml

yaml
version: "3.8"

services:
  web:
    build: .
    ports:
      - "8080:80"
    depends_on:
      - db
    volumes:
      - ./src:/var/www/html

  db:
    image: mysql:5.7
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: miapp
      MYSQL_USER: usuario
      MYSQL_PASSWORD: clave
    volumes:
      - db_data:/var/lib/mysql

volumes:
  db_data:

3. Ejecutar la aplicación

bash
docker-compose up --build -d

Ejemplo Completo: Servidor Nginx con Docker Compose

📂 Estructura del proyecto

text
mi-servidor-nginx/
├── docker-compose.yml
├── nginx.conf
└── html/
    └── index.html

Archivo 1: docker-compose.yml

yaml
version: '3.8'
services:
  nginx:
    image: nginx:latest
    container_name: mi-nginx
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
      - ./nginx.conf:/etc/nginx/nginx.conf
    restart: always

📌 Explicación:

  • image: nginx:latest → Usa la imagen oficial de Nginx

  • container_name: mi-nginx → Nombre del contenedor

  • ports: "8080:80" → Mapea puerto 80 del contenedor al 8080 del host

  • volumes → Monta carpetas y configuración personalizada

  • restart: always → Reinicia si el contenedor se detiene

Archivo 2: nginx.conf

nginx
events {}

http {
    server {
        listen 80;
        server_name localhost;

        location / {
            root /usr/share/nginx/html;
            index index.html;
        }
    }
}

Archivo 3: index.html

html
<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Servidor Nginx con Docker</title>
</head>
<body>
    <h1>¡Hola, Docker!</h1>
    <p>Este servidor Nginx está corriendo en un contenedor.</p>
</body>
</html>

🚀 Comandos para ejecutar

1. Crear y ejecutar el proyecto

bash
# Crear carpeta del proyecto
mkdir mi-servidor-nginx && cd mi-servidor-nginx

# Crear estructura de archivos
touch docker-compose.yml nginx.conf
mkdir html

# Mover index.html a la carpeta html
# (crea el archivo index.html con el contenido anterior)

# Ejecutar con Docker Compose
docker-compose up -d

2. Verificar el contenedor

bash
docker ps

3. Probar en el navegador

Visita: http://localhost:8080

4. Comandos útiles de Docker Compose

bash
# Detener contenedores
docker-compose down

# Ver logs
docker-compose logs

# Reconstruir y reiniciar
docker-compose up --build

# Listar contenedores en ejecución
docker-compose ps

# Escalar un servicio
docker-compose up -d --scale nginx=3

# Reiniciar servicio
docker-compose restart

5. Detener y limpiar

bash
# Detener y eliminar contenedores
docker-compose down

# Eliminar contenedores y volúmenes
docker-compose down --volumes

🎯 Conclusión

Docker Compose te permite:

  • ✅ Definir toda la infraestructura en un solo archivo

  • ✅ Gestionar múltiples servicios fácilmente

  • ✅ Configurar redes, volúmenes y dependencias

  • ✅ Escalar servicios según necesidad

Combinación ideal:

  • Usa Dockerfile para imágenes personalizadas

  • Usa Docker Compose para orquestar múltiples servicios

Tutorial de Docker Compose

¿Qué es Docker Compose?

Docker Compose es una herramienta que permite definir y ejecutar aplicaciones Docker multi-contenedor. Usando un archivo YAML, puedes configurar todos los servicios de tu aplicación y luego iniciarlos con un solo comando.

Instalación

Verificar instalación

bash
docker-compose --version

Si no lo tienes instalado, sigue las instrucciones en la documentación oficial de Docker.

Conceptos Básicos

  • docker-compose.yml: Archivo de configuración donde defines los servicios, redes y volúmenes

  • Servicio: Un contenedor en ejecución

  • Proyecto: Conjunto de servicios que trabajan juntos

Estructura Básica de docker-compose.yml

yaml
version: '3.8'

services:
  # Definición de servicios
  web:
    image: nginx:latest
    ports:
      - "80:80"
  
  database:
    image: postgres:13
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password

Ejemplo Práctico: Aplicación Web con Base de Datos

Estructura del proyecto

text
mi-proyecto/
├── docker-compose.yml
├── app/
│   └── index.html
└── nginx/
    └── nginx.conf

docker-compose.yml completo

yaml
version: '3.8'

services:
  # Servicio de base de datos PostgreSQL
  database:
    image: postgres:13
    container_name: myapp_db
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    ports:
      - "5432:5432"
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - app-network

  # Servicio de aplicación web
  web:
    build: ./app
    container_name: myapp_web
    ports:
      - "5000:5000"
    depends_on:
      - database
    environment:
      DATABASE_URL: postgresql://admin:secret@database:5432/myapp
    networks:
      - app-network
    volumes:
      - ./app:/app

  # Servicio de proxy reverso Nginx
  nginx:
    image: nginx:alpine
    container_name: myapp_nginx
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./app:/usr/share/nginx/html
    depends_on:
      - web
    networks:
      - app-network

# Volúmenes para persistencia de datos
volumes:
  db_data:

# Redes para comunicación entre contenedores
networks:
  app-network:
    driver: bridge

Dockerfile para la aplicación web (app/Dockerfile)

dockerfile
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

EXPOSE 5000

CMD ["python", "app.py"]

requirements.txt

text
flask==2.0.1
psycopg2-binary==2.9.1

app.py

python
from flask import Flask
import psycopg2
import os

app = Flask(__name__)

@app.route('/')
def hello():
    try:
        # Conexión a la base de datos usando el nombre del servicio
        conn = psycopg2.connect(
            host="database",
            database="myapp",
            user="admin",
            password="secret"
        )
        return "¡Aplicación funcionando con base de datos PostgreSQL!"
    except Exception as e:
        return f"Error conectando a la base de datos: {str(e)}"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

nginx/nginx.conf

nginx
events {
    worker_connections 1024;
}

http {
    upstream webapp {
        server web:5000;
    }

    server {
        listen 80;
        
        location / {
            proxy_pass http://webapp;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
        
        location /static/ {
            alias /usr/share/nginx/html/;
        }
    }
}

Comandos Esenciales de Docker Compose

Iniciar servicios

bash
# Iniciar en segundo plano
docker-compose up -d

# Iniciar y reconstruir imágenes
docker-compose up --build

# Iniciar solo servicios específicos
docker-compose up web database -d

Ver estado de los servicios

bash
# Listar contenedores del proyecto
docker-compose ps

# Ver logs
docker-compose logs
docker-compose logs web
docker-compose logs -f  # Seguir logs en tiempo real

Detener servicios

bash
# Detener servicios
docker-compose down

# Detener y eliminar volúmenes
docker-compose down -v

# Detener servicios específicos
docker-compose stop web

Gestión de servicios

bash
# Ejecutar comandos en un contenedor
docker-compose exec database psql -U admin -d myapp

# Escalar servicios
docker-compose up --scale web=3 -d

# Ver uso de recursos
docker-compose top

Características Avanzadas

Variables de Entorno

yaml
version: '3.8'

services:
  web:
    build: .
    environment:
      - DATABASE_URL=${DATABASE_URL}
    env_file:
      - .env

Health Checks

yaml
services:
  database:
    image: postgres:13
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U admin -d myapp"]
      interval: 30s
      timeout: 10s
      retries: 3

Dependencias entre servicios

yaml
services:
  web:
    build: .
    depends_on:
      database:
        condition: service_healthy

Configuraciones y Secretos

yaml
services:
  web:
    image: nginx
    configs:
      - source: nginx_config
        target: /etc/nginx/nginx.conf

configs:
  nginx_config:
    file: ./nginx.conf

Ejemplo de Desarrollo con Hot Reload

yaml
version: '3.8'

services:
  web:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
    command: npm run dev

Mejores Prácticas

  1. Usa versiones específicas de imágenes: Evita latest

  2. Utiliza .dockerignore: Excluye archivos innecesarios

  3. Maneja logs apropiadamente: Configura rotación de logs

  4. Usa variables de entorno: Para configuraciones sensibles

  5. Optimiza el orden de las capas: En Dockerfiles

  6. Utiliza redes específicas: Para aislar servicios

Comandos Útiles para Desarrollo

bash
# Reconstruir y reiniciar un servicio específico
docker-compose up -d --build web

# Ver recursos utilizados
docker-compose stats

# Eliminar contenedores detenidos
docker-compose rm

# Listar imágenes del proyecto
docker-compose images

# Pausar/Reanudar servicios
docker-compose pause
docker-compose unpause

Troubleshooting

Problemas comunes y soluciones:

bash
# Si los puertos están en uso
docker-compose down
# o cambia los puertos en docker-compose.yml

# Si hay problemas de permisos con volúmenes
docker-compose down -v
docker-compose up

# Ver información detallada de un servicio
docker-compose logs web --tail=50 -f

Este tutorial te proporciona una base sólida para trabajar con Docker Compose. ¡Practica con estos ejemplos y explora la documentación oficial para profundizar!

Comentarios

Publicar un comentario

Entradas más populares de este blog

ejercicios-Crear Carpeta y Archivo de Texto en Ubuntu

https://copy.sh/v86/?profile=linux26 Ejercicios para Practicar en Terminales Online Ejercicio Básico 1 - Práctica Inicial bash # En la terminal online, escribe estos comandos: whoami pwd ls mkdir practica cd practica touch archivo1.txt ls -l Ejercicio Básico 2 - Crear y Copiar bash # Continuación del ejercicio anterior echo "Hola mundo desde terminal online" > archivo1.txt cat archivo1.txt mkdir copias cp archivo1.txt copias/ ls copias/ cat copias/archivo1.txt Ejercicio Básico 3 - Exploración bash # Explorar el sistema cd / ls cd home ls cd ~ pwd Te voy a guiar paso a paso en un ejercicio muy básico y fácil para principiantes. ¡Vamos a hacerlo juntos! Paso a Paso del Ejercicio Paso 1: Abrir la Terminal Presiona  Ctrl + Alt + T  para abrir la terminal en Ubuntu. Paso 2: Crear una Carpeta Principal bash mkdir mi_primer_ejercicio Paso 3: Entrar a la Carpeta bash cd mi_primer_ejercicio Paso 4: Crear un Archivo de Texto bash touch mi_archivo.txt Paso 5...
Leer más

Instalar Docker en Ubuntu Server usando docker.io

  Tutorial: Instalar Docker en Ubuntu Server usando  docker.io Tutorial completo con  docker.io Paso 1: Actualizar el sistema bash sudo apt update sudo apt upgrade -y Paso 2: Instalar Docker desde los repositorios de Ubuntu bash sudo apt install docker.io Paso 3: Habilitar e iniciar el servicio Docker bash # Habilitar Docker para que inicie automáticamente sudo systemctl enable docker # Iniciar el servicio Docker sudo systemctl start docker # Verificar que el servicio está corriendo sudo systemctl status docker Paso 4: Configurar permisos de usuario Verificar si el grupo docker existe bash sudo grep docker /etc/group Agregar tu usuario al grupo docker bash sudo usermod -aG docker $USER Aplicar los cambios de grupo inmediatamente bash newgrp docker Paso 5: Verificar la instalación bash # Verificar versión de Docker docker --version # Probar Docker con un contenedor de prueba docker run hello-world Comprobación final Verificar que todo funcion...
Leer más

Tutorial de Carpetas y Directorios en Ubuntu Linux

En Linux, todo es un archivo. A medida que te adentres en Linux, lo comprenderás, pero por ahora, tenlo en cuenta. Cada archivo está organizado en un árbol de directorios jerárquico. El primer directorio del sistema de archivos se denomina, acertadamente, directorio raíz. El directorio raíz contiene muchas carpetas y archivos, que pueden almacenar más carpetas y archivos, etc   Introducción a los Directorios en Linux En Linux (incluyendo Ubuntu), los directorios (carpetas) siguen una estructura jerárquica que comienza desde el directorio raíz ( / ). Este sistema organiza todos los archivos y programas del sistema. Estructura Básica del Sistema de Archivos text / ├── bin -> Comandos esenciales del sistema ├── etc -> Archivos de configuración ├── home -> Directorios de usuarios ├── var -> Archivos variables (logs, etc.) ├── tmp -> Archivos temporales ├── usr -> Programas y aplicaciones └── ... Comandos Básicos para Trabajar con Directorios 1. Navegación e...
Leer más