Rust y Docker

Configuraciones

.env

• Verificar que el archivo .env esté en .gitignore

.env

# Server configuration
PORT=3001

# Database configuration
# DB_HOST host.docker.internal | <service_name> if using docker-compose
DB_HOST=localhost
DB_PORT=5432
DB_NAME=postgres
DB_USER=postgres
DB_PASSWORD=postgres

# docker-compose only
VOLUME_NAME=my_pg_volume

.gitignore

.gitignore

/target
.env

.dockerignore

.dockerignore

# Build folder for the project
target/

# Git and configuration files
.git/
.gitignore

# Docker files
Dockerfile
.dockerignore

# Environment files
.env
.env.*

# Documentation files
*.md
*.txt
README*
LICENSE*

# IDE and editor files
*.swp
*.swo
*.bak
*.tmp
*.log
*.DS_Store
.vscode/
.idea/

# Other files
*.tar.gz
*.rs.bk

Dockerfile

• Define como se construye la imagen que contendrá la aplicación de Rust
• docker-compose.yml utilizará el Dockerfile para construir el contenedor y/o para conectarlo con otros servicios, como la base de datos

Alpine o Scratch

• Alpine utiliza la biblioteca musl en lugar de glibc (que es más común en otras distribuciones), por lo que algunas aplicaciones pueden requerir ajustes adicionales para funcionar correctamente.

Dockerfile

# BUILD STAGE ###############################################
FROM rust:slim AS builder

# Install musl-tools which includes the required gcc for musl targets
# e.g. SQLx TLS support or to compile mimalloc
RUN apt-get update && apt-get install -y musl-tools && rm -rf /var/lib/apt/lists/*

RUN rustup target add x86_64-unknown-linux-musl

WORKDIR /app

COPY . .

RUN cargo build --target x86_64-unknown-linux-musl --release

# PRODUCTION STAGE ##########################################
# Alpine
#FROM alpine:3.21.3
#WORKDIR /usr/local/bin
#COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/<project-name> .
#CMD ["/<project-name>"]

# Scratch
FROM scratch
COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/<project-name> /
CMD ["/<project-name>"]

slim

Dockerfile

# BUILD STAGE ###############################################
FROM rust:slim AS builder

WORKDIR /app

COPY . .

RUN cargo build --release

# PRODUCTION STAGE ##########################################
FROM rust:slim

WORKDIR /usr/local/bin

COPY --from=builder /app/target/release/<project_name> .

CMD ["./<project_name>"]

Usar Dockerfile

# Construir imagen usando el Dockerfile
docker build -t <image-name> .

# Usar imagen con variables en el archivo .env
docker run -d --name <container-name> -p <host-port>:<.env-port> --env-file .env <image-name>

# Usar imagen con variables directamente
docker run -d --name <container-name> -p <host-port>:<.env-port> -e PORT=3001 -e DB_HOST=host.docker.internal -e DB_PORT=5432 -e DB_NAME=test-db -e DB_USER=postgres -e DB_PASSWORD=123456 <image-name>

docker stop <container-name>    # Detener contenedor
docker start <container-name>   # Iniciar el contenedor
docker logs <container-name>    # Ver logs
docker rm -f <container-name>   # Eliminar contenedor
docker rmi <image-name>         # Eliminar la imagen

docker-compose

• Para construir y gestionar los servicios o contenedores a partir de imágenes oficiales o del Dockerfile (imagen personalizada)
• Cada servicio se convierte en un contenedor utilizando una imagen o el Dockerfile

docker-compose.yml

# Every service is an container using an image or a build context (Dockerfile)
services:
  # Database service
  postgres:
    container_name: postgres
    image: postgres:17.4
    restart: unless-stopped
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      PGDATA: /var/lib/postgresql/data/pgdata
    # Uncomment if need to expose the database outside of Docker
    # ports:
    #   - "${DB_PORT}:5432"
    volumes:
      - pg_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USER} -d ${DB_NAME}"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s
    networks:
      - app-network

  # Backend service
  backend:
    build: .
    container_name: backend
    image: backend:latest
    environment:
      PORT: ${PORT}
      DB_HOST: ${DB_HOST}
      DB_PORT: ${DB_PORT}
      DB_NAME: ${DB_NAME}
      DB_USER: ${DB_USER}
      DB_PASSWORD: ${DB_PASSWORD}
    ports:
      - "${PORT}:${PORT}"
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
    networks:
      - app-network

volumes:
  pg_data:
    name: ${VOLUME_NAME}
    driver: local

networks:
  app-network:
    driver: bridge

Usar docker-compose

# Construir contenedores
docker compose up -d [--build]

# Pausar contenedores
docker compose pause

# Despausar contenedores
docker compose unpause

# Detener contenedores
docker compose stop

# Eliminar contenedores, redes y volumenes
# Remove containers, networks, and volumes
docker compose down --volumes

Ingresar a un servicio

# Ingresar al contenedor de postgres
docker exec -it [container_name] psql -U [username] -d [database_name]

# Ver tablas
\dt

# Crear tabla
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255),
    age INTEGER
);

# Ver detalles de la tabla
\d users