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 profundiza

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