eco Principiante Tutorial/Cómo hacer

Instalación de Apache Airflow en un VPS: Docker, PostgreSQL, CeleryExecutor, SSL y copias de seguridad

Ganamos comisiones cuando compras a través de los enlaces de esta página.

calendar_month Nov 01, 2026 schedule 19 min de lectura visibility 704 vistas
Установка Apache Airflow на VPS: Docker, PostgreSQL, CeleryExecutor, SSL и бэкапы
dns ¿No tienes servidor para esta guía? Vultr, DigitalOcean, Contabo

Instalación de Apache Airflow en un VPS: Docker, PostgreSQL, CeleryExecutor, SSL y copias de seguridad

TL;DR

En esta guía desplegaremos Apache Airflow 3 en un VPS mediante Docker Compose: PostgreSQL almacenará los metadatos, Redis será el broker de tareas para CeleryExecutor, Caddy emitirá automáticamente el certificado SSL y las copias de seguridad de PostgreSQL, los archivos DAG y la configuración se enviarán a un almacenamiento S3 externo.

  • Airflow funcionará con una arquitectura tolerante a fallos para equipos pequeños mediante CeleryExecutor.
  • La interfaz web estará disponible mediante HTTPS en un dominio propio.
  • PostgreSQL, Redis, scheduler, worker y el servidor API estarán aislados mediante Docker Compose.
  • Los secretos se almacenarán en el archivo .env, no en Docker Compose ni en el código DAG.
  • Las copias de seguridad de PostgreSQL y de los archivos de Airflow se realizarán automáticamente según un horario.
  • La configuración está pensada para Ubuntu Server 24.04 LTS y Apache Airflow 3.0.x.

Qué configuramos y por qué

Apache Airflow es una plataforma para la orquestación de tareas y pipelines. En Airflow, el desarrollador describe el proceso de procesamiento de datos como un DAG: un grafo acíclico dirigido. Cada tarea tiene dependencias, programación, reintentos, registros y estado. Por ejemplo, Airflow puede extraer datos del CRM cada noche, ejecutar transformaciones de Python, cargar el resultado en PostgreSQL y notificar al equipo en caso de error.

Airflow no solo sirve para el ETL clásico. Se utiliza para ejecutar pipelines de ML, integraciones periódicas con API, generar informes, realizar copias de seguridad, sincronizar servicios SaaS, procesar archivos y ejecutar tareas DevOps. La condición principal es que el proceso conste de pasos repetibles en los que sean importantes la programación, la observabilidad y la posibilidad de volver a ejecutarlos.

En el modo básico, Airflow puede funcionar con LocalExecutor, cuando scheduler ejecuta las tareas en el mismo servidor. Para un entorno de pruebas es suficiente. Sin embargo, para un escenario de production con varios DAG simultáneos, tareas pesadas de Python o varios usuarios, es más razonable utilizar CeleryExecutor. Este separa la planificación de la ejecución: scheduler coloca las tareas en la cola de Redis y los Celery workers independientes las recogen y ejecutan.

Arquitectura final

Componente Propósito Dónde se ejecuta
Airflow API Server Interfaz web, REST API y autenticación Contenedor Docker
Airflow Scheduler Analiza los DAG, crea ejecuciones y coloca las tareas en la cola Contenedor Docker
Airflow DAG Processor Analiza por separado los archivos Python de los DAG Contenedor Docker
Celery Worker Ejecuta las tareas DAG Contenedor Docker
PostgreSQL 16 Almacena usuarios, estado de las tareas, conexiones y metadatos Docker volume
Redis 7 Cola de tareas de Celery y almacenamiento temporal de mensajes Docker volume
Caddy Reverse proxy, HTTPS y renovación automática de certificados TLS Sistema host

Qué obtendrá después de la configuración

  • Acceso a Airflow mediante una dirección como https://airflow.example.com.
  • Una base de datos PostgreSQL independiente en lugar del SQLite integrado.
  • Cola de tareas y ejecución en paralelo mediante CeleryExecutor.
  • Docker volumes persistentes para PostgreSQL, Redis y los registros.
  • Un directorio para DAG, plugins y configuración en el host.
  • HTTPS sin emitir ni renovar certificados manualmente.
  • Copias de seguridad cifradas automáticas en un almacenamiento externo.

Cloud-managed Airflow o self-hosted en un VPS

Las opciones Managed eliminan parte de las tareas operativas: el proveedor actualiza la infraestructura, almacena los metadatos y, en ocasiones, escala los workers. Esto resulta práctico para equipos grandes, pero normalmente limita las versiones, la topología de red, la instalación de bibliotecas del sistema y las dependencias personalizadas de Python. El coste también puede aumentar considerablemente cuando los workers funcionan de forma permanente.

Apache Airflow self-hosted en un VPS ofrece un control total. Puede añadir paquetes del sistema a la imagen, utilizar redes privadas, conectar servicios locales, fijar la versión de los paquetes de Python y almacenar los datos en la jurisdicción elegida. El precio de este control es la necesidad de supervisar por cuenta propia las actualizaciones, las copias de seguridad, los secretos y la disponibilidad del servidor.

No utilice Airflow como un servicio universal de colas en tiempo real. Está diseñado para procesos programados y por lotes. Para procesar miles de eventos cortos por segundo suelen ser más adecuados Kafka, RabbitMQ, NATS o un servicio worker especializado.

Qué configuración de VPS se necesita para esta tarea

Esquema: Qué configuración de VPS se necesita para esta tarea
Esquema: Qué configuración de VPS se necesita para esta tarea

El consumo de recursos de Airflow depende no solo del número de DAG. También son importantes la frecuencia de ejecución, el volumen de registros, el número de tareas simultáneas, las bibliotecas de Python y la carga de PostgreSQL. Incluso con un número reducido de pipelines, varios servicios de Airflow funcionan constantemente en memoria: API server, scheduler, DAG processor, worker, PostgreSQL y Redis.

Escenario vCPU RAM NVMe SSD Modo adecuado
Pruebas, 1–5 DAG ligeros 2 4 GB 40–60 GB LocalExecutor o Celery con un worker
Production pequeño, 5–30 DAG 4 8 GB 80–120 GB CeleryExecutor, 1–2 workers
Equipo y procesos ETL regulares 8 16 GB 160 GB o más CeleryExecutor, varios workers
Tareas pesadas de ML/analítica 8–16+ 32 GB+ 300 GB+ Workers independientes o dedicated

Para comenzar con una carga de production, una configuración razonable es 4 vCPU, 8 GB de RAM, 100 GB NVMe y un puerto de al menos 100 Mbit/s. Esto es suficiente para Airflow, PostgreSQL, Redis y un Celery worker con paralelismo moderado. Puede utilizar un servidor de este tipo como VPS con las características indicadas, si las tareas no requieren una gran cantidad de memoria ni el procesamiento local de decenas de gigabytes de datos.

Por qué no conviene comenzar con 2 GB de RAM

En un servidor con 2 GB de memoria, los contenedores Docker pueden iniciarse formalmente, pero al importar bibliotecas pesadas, realizar migraciones de la base de datos o ejecutar tareas simultáneamente, el sistema comenzará a utilizar swap. Como resultado, scheduler perderá heartbeats, worker recibirá la señal OOM Killer y la interfaz de Airflow se volverá lenta. El mínimo de 4 GB solo es adecuado para un entorno de desarrollo; para DAG de trabajo es mejor planificar 8 GB.

Cuándo se necesita un dedicated en lugar de un VPS

Un servidor dedicated está justificado si las tareas cargan constantemente la CPU, requieren 32–64 GB de RAM, procesan archivos locales grandes, utilizan GPU o son sensibles a un rendimiento predecible del disco. También resulta útil si Airflow ejecuta muchos workers pesados en una sola máquina y no desea competir por recursos con otras máquinas virtuales del host.

Si Airflow solo coordina servicios externos —API, bases de datos en la nube, almacenamientos de objetos y tareas serverless—, normalmente basta con un VPS. En este caso, los principales cálculos se realizan fuera de Airflow, mientras que el servidor almacena los metadatos y gestiona la programación.

Elección de la ubicación

La ubicación del VPS influye en la latencia hasta PostgreSQL, S3, las API corporativas y los empleados que abren la interfaz web. Coloque el servidor cerca de la base de datos principal o de la red privada, no solo cerca de los usuarios de la interfaz. Si el DAG transmite regularmente archivos grandes a un almacenamiento compatible con S3, mida la latencia de red y el coste del tráfico saliente.

Para datos personales y financieros, tenga en cuenta los requisitos jurisdiccionales. En cualquier caso, no exponga PostgreSQL, Redis ni los puertos internos de Airflow a Internet: desde el exterior solo deben estar disponibles SSH, HTTP y HTTPS.

Preparación del servidor

Esquema: Preparación del servidor
Esquema: Preparación del servidor

A continuación se presupone un servidor limpio con Ubuntu Server 24.04 LTS, una dirección IPv4 pública y el dominio airflow.example.com. Antes de configurar Caddy, cree un registro DNS de tipo A que apunte a la dirección IP del VPS. Para IPv6, añada un registro AAAA solo si el servidor realmente acepta tráfico IPv6 entrante.

Conexión y actualización del sistema

Conéctese con el usuario inicial proporcionado por el proveedor y actualice los paquetes. Es necesario reiniciar si se ha actualizado el kernel o bibliotecas críticas del sistema.

ssh root@SERVER_IP

apt update && apt upgrade -y
apt install -y curl wget ca-certificates gnupg lsb-release \
  git vim unzip htop jq ufw fail2ban cron

reboot

Después de reiniciar, vuelva a conectarse y cree un usuario independiente. No realice la administración diaria como root: esto reduce el riesgo de eliminar accidentalmente archivos del sistema o ejecutar un comando malicioso con privilegios máximos.

adduser deploy
usermod -aG sudo deploy

mkdir -p /home/deploy/.ssh
chmod 700 /home/deploy/.ssh
cp /root/.ssh/authorized_keys /home/deploy/.ssh/authorized_keys
chown -R deploy:deploy /home/deploy/.ssh
chmod 600 /home/deploy/.ssh/authorized_keys

Compruebe el acceso con el nuevo usuario en un terminal independiente. No cierre la sesión de root hasta asegurarse de que la clave se acepta.

ssh deploy@SERVER_IP
sudo -v
exit

Protección de SSH

Desactive la autenticación mediante contraseña y el acceso directo de root solo después de comprobar el acceso mediante clave. Cree un archivo drop-in independiente para no editar la configuración principal de OpenSSH.

sudo tee /etc/ssh/sshd_config.d/99-hardening.conf > /dev/null <<'EOF'
PasswordAuthentication no
KbdInteractiveAuthentication no
PermitRootLogin no
PubkeyAuthentication yes
MaxAuthTries 3
X11Forwarding no
EOF

sudo sshd -t && sudo systemctl restart ssh

Configure UFW. Docker publica los puertos mediante sus propias reglas de iptables, por lo que posteriormente la API de Airflow estará vinculada únicamente a 127.0.0.1 y no a la interfaz pública. El acceso externo solo lo tendrá Caddy en los puertos 80 y 443.

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
sudo ufw status verbose

Fail2ban bloqueará las direcciones IP con repetidos intentos fallidos de acceso SSH. Para la autenticación mediante clave, esto constituye una capa de protección adicional, no principal.

sudo systemctl enable --now fail2ban
sudo fail2ban-client status sshd

Límites del sistema y directorio del proyecto

Airflow crea muchos archivos de registro y PostgreSQL utiliza descriptores de archivos. Aumentaremos el límite de archivos abiertos para el usuario con el que funcionará Docker Compose. A continuación, crearemos la estructura de directorios.

sudo tee /etc/security/limits.d/99-airflow.conf > /dev/null <<'EOF'
deploy soft nofile 65535
deploy hard nofile 65535
EOF

sudo mkdir -p /opt/airflow/{dags,logs,plugins,config,backups,scripts}
sudo chown -R deploy:deploy /opt/airflow
sudo chmod 750 /opt/airflow

sudo -iu deploy
cd /opt/airflow

Ejecute todos los comandos posteriores de Docker Compose como el usuario deploy desde el directorio /opt/airflow. No almacene los DAG, las configuraciones ni las copias de seguridad en el directorio personal de root: esto complica los permisos de acceso y la recuperación.

Instalación del software — paso a paso

Esquema: Instalación del software — paso a paso
Esquema: Instalación del software — paso a paso

En esta configuración se utilizan Docker Engine 27+, Docker Compose Plugin 2.30+, PostgreSQL 16, Redis 7.4 y Apache Airflow 3.0.2. La versión de Airflow está fijada intencionadamente: la descarga automática de la etiqueta latest es peligrosa, ya que una actualización importante puede cambiar el esquema de la base de datos y el comportamiento de la API.

Instalación de Docker Engine y Docker Compose

Agregaremos el repositorio oficial de Docker para Ubuntu 24.04. Los comandos instalan el motor de contenedores, la CLI, Buildx y Compose Plugin.

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io \
  docker-buildx-plugin docker-compose-plugin

Agregue el usuario deploy al grupo Docker. Después, es necesario volver a iniciar sesión mediante SSH; de lo contrario, el comando docker requerirá sudo.

sudo usermod -aG docker deploy
exit

ssh deploy@SERVER_IP
docker version
docker compose version

Configuración del daemon de Docker

Limitaremos el crecimiento de los registros JSON de los contenedores. Sin rotación, los registros de Docker pueden llenar el disco incluso ante un error moderado en una tarea de Python.

sudo tee /etc/docker/daemon.json > /dev/null <<'EOF'
{
  "log-driver": "local",
  "log-opts": {
    "max-size": "20m",
    "max-file": "5"
  },
  "live-restore": true
}
EOF

sudo systemctl restart docker
docker info | grep -E "Logging Driver|Live Restore"

Creación de secretos de Airflow

Airflow utiliza una Fernet key para cifrar las Connection passwords y los Variable values en la base de datos. La API secret key se necesita para firmar sesiones y tokens. PostgreSQL y Redis también deben tener contraseñas aleatorias. Los valores no deben confirmarse en Git ni publicarse en tickets.

cd /opt/airflow

FERNET_KEY=$(docker run --rm apache/airflow:3.0.2 \
  python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())")

API_SECRET=$(openssl rand -hex 32)
POSTGRES_PASSWORD=$(openssl rand -base64 32 | tr -d '\n')
REDIS_PASSWORD=$(openssl rand -base64 32 | tr -d '\n')
ADMIN_PASSWORD=$(openssl rand -base64 24 | tr -d '\n')

printf '%s\n' "Generated secrets are ready."

Cree el archivo .env. Sustituya el dominio y el correo electrónico del administrador, e inserte los valores generados. Puede sustituir la contraseña del administrador por una contraseña larga propia, que se almacenará en el gestor de contraseñas.

cat > /opt/airflow/.env <<EOF
AIRFLOW_UID=$(id -u)
AIRFLOW_GID=$(id -g)

POSTGRES_DB=airflow
POSTGRES_USER=airflow
POSTGRES_PASSWORD=${POSTGRES_PASSWORD}

REDIS_PASSWORD=${REDIS_PASSWORD}

AIRFLOW_FERNET_KEY=${FERNET_KEY}
AIRFLOW_API_SECRET_KEY=${API_SECRET}

AIRFLOW_ADMIN_USERNAME=admin
AIRFLOW_ADMIN_FIRSTNAME=Airflow
AIRFLOW_ADMIN_LASTNAME=Admin
[email protected]
AIRFLOW_ADMIN_PASSWORD=${ADMIN_PASSWORD}

AIRFLOW_DOMAIN=airflow.example.com
EOF

chmod 600 /opt/airflow/.env

Preparación de una imagen personalizada

La imagen oficial de Airflow ya contiene el paquete principal, pero los DAG reales casi siempre requieren bibliotecas Python adicionales. No las instale manualmente en un contenedor en ejecución: los cambios desaparecerán al recrearlo. En su lugar, cree una imagen propia.

cat > /opt/airflow/requirements.txt <<'EOF'
requests==2.32.3
pandas==2.2.3
psycopg[binary]==3.2.3
EOF

cat > /opt/airflow/Dockerfile <<'EOF'
FROM apache/airflow:3.0.2

COPY requirements.txt /requirements.txt
RUN pip install --no-cache-dir --constraint \
    "https://raw.githubusercontent.com/apache/airflow/constraints-3.0.2/constraints-3.12.txt" \
    -r /requirements.txt
EOF

Las restricciones de Airflow son fundamentales: fijan versiones compatibles de las bibliotecas. Al añadir proveedores, por ejemplo para AWS, Google Cloud, Slack o Kubernetes, agréguelos a requirements.txt, vuelva a crear la imagen y pruebe los DAG en un entorno separado.

Creación del archivo Docker Compose

El siguiente archivo compose inicia todos los servicios. El puerto de la API de Airflow se publica únicamente en 127.0.0.1:8080, lo que excluye el acceso directo desde Internet. PostgreSQL y Redis no publican puertos en el host.

cat > /opt/airflow/docker-compose.yml <<'EOF'
x-airflow-common: &airflow-common
  build:
    context: .
  env_file:
    - .env
  user: "${AIRFLOW_UID}:0"
  restart: unless-stopped
  depends_on:
    postgres:
      condition: service_healthy
    redis:
      condition: service_healthy
  environment:
    AIRFLOW__CORE__EXECUTOR: CeleryExecutor
    AIRFLOW__DATABASE__SQL_ALCHEMY_CONN: postgresql+psycopg://airflow:${POSTGRES_PASSWORD}@postgres/airflow
    AIRFLOW__CELERY__BROKER_URL: redis://:${REDIS_PASSWORD}@redis:6379/0
    AIRFLOW__CELERY__RESULT_BACKEND: db+postgresql://airflow:${POSTGRES_PASSWORD}@postgres/airflow
    AIRFLOW__CORE__FERNET_KEY: ${AIRFLOW_FERNET_KEY}
    AIRFLOW__API__SECRET_KEY: ${AIRFLOW_API_SECRET_KEY}
    AIRFLOW__CORE__LOAD_EXAMPLES: "false"
    AIRFLOW__CORE__DAGS_ARE_PAUSED_AT_CREATION: "true"
    AIRFLOW__CORE__PARALLELISM: "8"
    AIRFLOW__CORE__MAX_ACTIVE_TASKS_PER_DAG: "4"
    AIRFLOW__CELERY__WORKER_CONCURRENCY: "2"
    AIRFLOW__LOGGING__REMOTE_LOGGING: "false"
  volumes:
    - ./dags:/opt/airflow/dags
    - ./logs:/opt/airflow/logs
    - ./plugins:/opt/airflow/plugins
    - ./config:/opt/airflow/config

services:
  postgres:
    image: postgres:16.6-alpine
    restart: unless-stopped
    env_file:
      - .env
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres-db-volume:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U airflow -d airflow"]
      interval: 10s
      timeout: 5s
      retries: 10

  redis:
    image: redis:7.4-alpine
    restart: unless-stopped
    env_file:
      - .env
    command: ["redis-server", "--appendonly", "yes", "--requirepass", "${REDIS_PASSWORD}"]
    volumes:
      - redis-data:/data
    healthcheck:
      test: ["CMD-SHELL", "redis-cli -a \"$${REDIS_PASSWORD}\" ping | grep PONG"]
      interval: 10s
      timeout: 5s
      retries: 10

  airflow-init:
    <<: airflow-common
    restart: "no"
    command:
      - bash
      - -c
      - |
        airflow db migrate
        airflow users create \
          --username "$${AIRFLOW_ADMIN_USERNAME}" \
          --firstname "$${AIRFLOW_ADMIN_FIRSTNAME}" \
          --lastname "$${AIRFLOW_ADMIN_LASTNAME}" \
          --role Admin \
          --email "$${AIRFLOW_ADMIN_EMAIL}" \
          --password "$${AIRFLOW_ADMIN_PASSWORD}" || true

  airflow-apiserver:
    <<: airflow-common
    command: api-server
    ports:
      - "127.0.0.1:8080:8080"
    healthcheck:
      test: ["CMD-SHELL", "curl --fail http://localhost:8080/api/v2/monitor/health || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 5

  airflow-scheduler:
    <<: airflow-common
    command: scheduler

  airflow-dag-processor:
    <<: airflow-common
    command: dag-processor

  airflow-worker:
    <<: airflow-common
    command: celery worker
    stop_grace_period: 10m

  airflow-triggerer:
    <<: airflow-common
    command: triggerer

volumes:
  postgres-db-volume:
  redis-data:
EOF

Antes de iniciar, compruebe que Compose sustituye correctamente las variables y que el YAML no contiene errores sintácticos.

cd /opt/airflow
docker compose config > /tmp/airflow-rendered.yml
docker compose build
docker compose up airflow-init

docker compose up -d
docker compose ps

En el primer inicio, la inicialización puede tardar varios minutos. Compruebe los registros de scheduler y worker. Todos los servicios deben pasar al estado running, y PostgreSQL y Redis al estado healthy.

docker compose logs --tail=100 airflow-scheduler
docker compose logs --tail=100 airflow-worker
docker compose exec airflow-scheduler airflow version
docker compose exec airflow-scheduler airflow db check

Configuración de Airflow, CeleryExecutor y SSL

Esquema: Configuración de Airflow, CeleryExecutor y SSL
Esquema: Configuración de Airflow, CeleryExecutor y SSL

DAG de prueba

Crearemos un DAG mínimo que confirme el funcionamiento de scheduler, la cola de Celery y worker. Se ejecuta manualmente, por lo que no genera una carga constante en el servidor. En Airflow 3, utilice el SDK actual para los decoradores de DAG y task.

cat > /opt/airflow/dags/healthcheck_dag.py <<'EOF'
from datetime import datetime
from airflow.sdk import dag, task

@dag(
    dag_id="healthcheck_celery",
    start_date=datetime(2025, 1, 1),
    schedule=None,
    catchup=False,
    tags=["system"],
)
def healthcheck_celery():
    @task
    def check_worker():
        return "CeleryExecutor worker completed the task successfully"

    check_worker()

healthcheck_celery()
EOF

cd /opt/airflow
docker compose restart airflow-scheduler airflow-dag-processor

Después de 30–90 segundos, el DAG aparecerá en la interfaz. Antes de configurar SSL, puede comprobar la API localmente desde el servidor. Un código de respuesta 200 o una estructura JSON con componentes de estado indica que el API server responde.

curl -fsS http://127.0.0.1:8080/api/v2/monitor/health | jq
docker compose exec airflow-scheduler airflow dags list | grep healthcheck_celery

Instalación de Caddy para HTTPS

Caddy obtiene y renueva automáticamente los certificados de Let's Encrypt. Para ello, el dominio ya debe apuntar al servidor, y los puertos 80 y 443 deben estar abiertos en UFW y en el panel del proveedor. No ejecute un segundo servidor web en esos mismos puertos.

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https

curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | \
  sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg

curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | \
  sudo tee /etc/apt/sources.list.d/caddy-stable.list

sudo apt update
sudo apt install -y caddy
caddy version

Cree el Caddyfile. Sustituya el dominio y el correo electrónico. Los encabezados siguientes prohíben incrustar la interfaz en un iframe y desactivan la detección del tipo MIME por parte del navegador. Airflow permanece en localhost, por lo que Caddy es el único punto de entrada público.

sudo tee /etc/caddy/Caddyfile > /dev/null <<'EOF'
{
    email [email protected]
}

airflow.example.com {
    encode zstd gzip

    reverse_proxy 127.0.0.1:8080

    header {
        X-Content-Type-Options "nosniff"
        X-Frame-Options "DENY"
        Referrer-Policy "strict-origin-when-cross-origin"
        -Server
    }

    log {
        output file /var/log/caddy/airflow-access.log
        format json
    }
}
EOF

sudo mkdir -p /var/log/caddy
sudo chown caddy:caddy /var/log/caddy
sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy
sudo systemctl enable caddy

Compruebe la emisión del certificado y el proxy inverso. La respuesta debe contener la línea de estado HTTP/2 200 o una redirección a la página de inicio de sesión. Si no se emite el certificado, compruebe primero el DNS y la accesibilidad externa del puerto 80.

curl -I https://airflow.example.com
sudo journalctl -u caddy -n 100 --no-pager
sudo ss -tulpn | grep -E ':80|:443|:8080'

Parámetros de CeleryExecutor

En el archivo compose se han establecido parallelism=8, max_active_tasks_per_dag=4 y worker_concurrency=2. Es un punto de partida seguro para un VPS con 4 vCPU y 8 GB de RAM. El número total de tareas ejecutadas simultáneamente está limitado por el menor de estos valores y por la cantidad disponible de worker slots.

No aumente worker_concurrency solo para obtener una cifra mayor. Si cada tarea utiliza pandas, Selenium, Chrome, dbt o varios cientos de megabytes de memoria, dos procesos simultáneos ya pueden ocupar la mayor parte de la RAM. Primero mida el consumo real mediante docker stats y, después, aumente los valores de uno en uno.

cd /opt/airflow
docker stats --no-stream
docker compose exec airflow-worker celery --app airflow.providers.celery.executors.celery_executor.app inspect ping

Almacenamiento seguro de conexiones

No escriba claves API, DSN de bases de datos ni contraseñas en el código fuente de los DAG. Para una instancia self-hosted pequeña, puede crear Airflow Connections mediante la interfaz web: los valores se cifrarán con la Fernet key en PostgreSQL. Para un entorno de producción, es preferible conectar un backend externo de secretos: HashiCorp Vault, AWS Secrets Manager, Google Secret Manager o un servicio corporativo compatible.

Si se pierde la Fernet key, será imposible descifrar los valores existentes de Connection y Variable. Por eso, incluya el archivo .env en una copia de seguridad cifrada, pero no lo almacene en un repositorio público. Al rotar la Fernet key, utilice el comando estándar de Airflow para la rotación, no sustituya simplemente la variable.

Copias de seguridad y mantenimiento

Esquema: Copias de seguridad y mantenimiento
Esquema: Copias de seguridad y mantenimiento

La copia de seguridad del Docker volume por sí sola no es suficiente. Para restaurar Airflow se necesitan la base de datos PostgreSQL, los archivos DAG, los plugins, la configuración, el archivo .env y la información sobre la versión de la imagen. Redis normalmente no es la fuente de verdad: los mensajes no terminados de la cola pueden perderse, pero el estado de las tareas y los metadatos se almacenan en PostgreSQL.

Qué se debe respaldar

  • Un volcado lógico de PostgreSQL mediante pg_dump.
  • Los directorios dags, plugins, config y scripts.
  • El archivo .env con Fernet key, API secret y contraseñas.
  • docker-compose.yml, Dockerfile y requirements.txt.
  • Si es necesario, el directorio logs, si los registros son necesarios para la auditoría.
  • La configuración de Caddy desde /etc/caddy/Caddyfile.

Para el almacenamiento utilizamos restic, una herramienta de copias de seguridad cifradas y deduplicadas. El repositorio puede encontrarse en un almacenamiento de objetos compatible con S3 o en un servidor independiente mediante SFTP. A continuación se muestra una variante con S3 API; las variables de acceso deben tener permisos únicamente sobre el bucket concreto.

Instalación y configuración de restic

sudo apt install -y restic

sudo mkdir -p /root/.config/restic
sudo chmod 700 /root/.config/restic

sudo tee /root/.config/restic/airflow.env > /dev/null <<'EOF'
export RESTIC_REPOSITORY="s3:https://s3.example.com/airflow-backups"
export RESTIC_PASSWORD="CHANGE_TO_A_LONG_RANDOM_RESTIC_PASSWORD"
export AWS_ACCESS_KEY_ID="CHANGE_ME"
export AWS_SECRET_ACCESS_KEY="CHANGE_ME"
EOF

sudo chmod 600 /root/.config/restic/airflow.env

sudo bash -c 'source /root/.config/restic/airflow.env && restic init'

La primera ejecución de restic init crea el repositorio. Guarde la contraseña del repositorio fuera del servidor: en un gestor de secretos o en un almacenamiento offline. Sin ella no se pueden restaurar las copias de seguridad cifradas.

Script de copia de seguridad

El script primero crea un volcado comprimido de PostgreSQL dentro del contenedor y después transmite los datos a restic. El volcado se crea en /opt/airflow/backups y se elimina automáticamente tras finalizar correctamente, para no acumular copias en el VPS.

sudo tee /opt/airflow/scripts/backup-airflow.sh > /dev/null <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

AIRFLOW_DIR="/opt/airflow"
BACKUP_DIR="${AIRFLOW_DIR}/backups"
DATE="$(date +%F_%H-%M-%S)"
DUMP_FILE="${BACKUP_DIR}/postgres_${DATE}.dump.gz"

source /root/.config/restic/airflow.env

mkdir -p "${BACKUP_DIR}"
cd "${AIRFLOW_DIR}"

docker compose exec -T postgres \
  pg_dump -U airflow -d airflow --format=custom | gzip -9 > "${DUMP_FILE}"

restic backup \
  "${DUMP_FILE}" \
  "${AIRFLOW_DIR}/dags" \
  "${AIRFLOW_DIR}/plugins" \
  "${AIRFLOW_DIR}/config" \
  "${AIRFLOW_DIR}/scripts" \
  "${AIRFLOW_DIR}/docker-compose.yml" \
  "${AIRFLOW_DIR}/Dockerfile" \
  "${AIRFLOW_DIR}/requirements.txt" \
  "${AIRFLOW_DIR}/.env" \
  /etc/caddy/Caddyfile \
  --tag airflow \
  --tag postgres

restic forget --prune \
  --keep-daily 14 \
  --keep-weekly 8 \
  --keep-monthly 12

rm -f "${DUMP_FILE}"
EOF

sudo chmod 700 /opt/airflow/scripts/backup-airflow.sh
sudo /opt/airflow/scripts/backup-airflow.sh

Después de la primera copia de seguridad, compruebe su contenido. El comando debe mostrar los archivos DAG, .env, Caddyfile y el volcado de PostgreSQL. Una vez al mes, realice una restauración de prueba en un servidor independiente o en un directorio separado; una copia de seguridad que no se ha comprobado no se considera fiable.

sudo bash -c 'source /root/.config/restic/airflow.env && restic snapshots'
sudo bash -c 'source /root/.config/restic/airflow.env && restic check'

Programación mediante cron

Ejecute la copia de seguridad por la noche, por ejemplo a las 03:30. Cron redirige stdout y stderr a un registro independiente, útil al investigar un error de acceso a S3 o la falta de espacio.

sudo crontab -e

30 3   * /opt/airflow/scripts/backup-airflow.sh >> /var/log/airflow-backup.log 2>&1

Compruebe que cron está instalado y activo. Si el servidor estaba apagado en el momento de la ejecución, el cron habitual no recuperará la tarea omitida. Para requisitos más estrictos, sustituya cron por un systemd timer con Persistent=true.

sudo systemctl status cron
sudo tail -n 50 /var/log/airflow-backup.log

Actualizaciones de Airflow e imágenes de Docker

Para un VPS individual, es más seguro utilizar una ventana de mantenimiento. Primero lea el changelog de la versión de Airflow de destino, cree una copia de seguridad reciente y pruebe la actualización en un servidor de staging. La actualización de Airflow puede incluir una migración del esquema de PostgreSQL, por lo que revertir el contenedor a una versión anterior después de la migración no siempre es seguro.

cd /opt/airflow

docker compose pull postgres redis
docker compose build --pull

docker compose up -d --no-deps postgres redis
docker compose run --rm airflow-init

docker compose up -d
docker compose ps
docker compose logs --tail=100 airflow-scheduler

Para actualizar Airflow, cambie el tag en Dockerfile y la URL de constraints a una única versión concreta y probada. No actualice las versiones major de PostgreSQL sustituyendo el tag de la imagen: la transición, por ejemplo, de PostgreSQL 16 a 17 requiere un procedimiento independiente de migración de datos.

Solución de problemas y FAQ

¿Por qué el servidor API de Airflow se reinicia constantemente?

Primero ejecute docker compose logs airflow-apiserver y compruebe si la inicialización de la base de datos ha finalizado. Una causa frecuente es que el servidor API se haya iniciado antes de la migración o no pueda conectarse a PostgreSQL debido a una contraseña incorrecta en .env. Compruebe docker compose exec postgres pg_isready -U airflow -d airflow y vuelva a ejecutar docker compose run --rm airflow-init. No elimine el volume de PostgreSQL si contiene datos operativos.

¿Las tareas permanecen en estado queued y no se inicia el worker?

Normalmente esto indica un problema con Celery worker, Redis o una incompatibilidad en la configuración de broker URL. Compruebe el estado del worker mediante docker compose logs airflow-worker y asegúrese de que Redis responde con el comando redis-cli ping dentro del contenedor. Compruebe también que scheduler y worker tengan los mismos valores de AIRFLOW__CELERY__BROKER_URL. Si el worker se detuvo durante una tarea, reinícielo; las tareas con retries configurados correctamente se repetirán mediante el planificador.

¿Por qué el DAG no aparece en la interfaz web?

Compruebe la sintaxis del archivo Python y los registros del servicio airflow-dag-processor. Un error al importar una biblioteca que no está en Dockerfile hace que el DAG sea invisible o se marque como broken. Ejecute docker compose exec airflow-scheduler airflow dags list-import-errors. Asegúrese también de que el archivo se encuentre en /opt/airflow/dags, tenga la extensión .py y sea accesible para el usuario del contenedor.

¿Por qué Caddy no obtiene el certificado SSL?

Compruebe que el registro A del dominio apunte a la IP del VPS y que los puertos 80 y 443 sean accesibles desde Internet. El comando sudo ss -tulpn debe mostrar Caddy en esos puertos. Si anteriormente se instaló Nginx o Apache, deténgalo o vuelva a configurarlo. Consulte los errores mediante sudo journalctl -u caddy -n 100. Cloudflare y otros proxies DNS también pueden afectar a la validación; para el diagnóstico, utilice temporalmente un registro DNS normal.

¿Qué configuración mínima de VPS es adecuada?

Para pruebas y varios DAG ligeros, son suficientes como mínimo 2 vCPU, 4 GB de RAM y 50 GB de SSD. Sin embargo, para un Airflow operativo con PostgreSQL, Redis y CeleryExecutor, es mejor comenzar con 4 vCPU, 8 GB de RAM y 80–100 GB de NVMe. Deje al menos un 20–30 % de espacio libre en disco para registros, imágenes de Docker, archivos temporales y volcados de la base de datos. Si las tareas utilizan pandas o automatización de navegador, es más importante aumentar la RAM.

¿Qué elegir: VPS o dedicated para esta tarea?

El VPS es adecuado para la mayoría de las instalaciones pequeñas y medianas de Airflow: programaciones, integraciones API, ETL de volumen moderado y varios procesos worker. Se necesita un servidor dedicated con carga constante de CPU, grandes volúmenes de datos locales, a partir de 32 GB de memoria, tareas con GPU o requisitos de rendimiento de disco constantemente alto. Otra opción es mantener Airflow en un VPS y enviar los cálculos pesados a Kubernetes jobs externos, Spark, servicios batch en la nube o workers independientes.

¿Qué hacer si el servidor se queda sin memoria y los contenedores reciben OOMKilled?

Ejecute docker stats --no-stream, free -h y dmesg -T | grep -i oom para identificar al responsable. Con frecuencia, la memoria la consume una tarea Python y no el scheduler. Reduzca AIRFLOW__CELERY__WORKER_CONCURRENCY a 1, limite el número de tareas simultáneas y añada RAM. Swap puede proteger temporalmente contra una finalización inesperada, pero no sustituye a la memoria: el uso intensivo de swap vuelve inestable el scheduler.

¿Cómo restaurar Airflow desde una copia de seguridad después de perder el servidor?

En el nuevo servidor instale Docker y restic, restaure los archivos del repositorio en /opt/airflow y, a continuación, inicie únicamente PostgreSQL. Descomprima el volcado de PostgreSQL e impórtelo mediante pg_restore en una base de datos vacía. Después ejecute airflow-init y, posteriormente, el resto de los servicios. Es importante restaurar el .env original con el mismo Fernet key: sin él no se podrán descifrar las conexiones y variables almacenadas.

Conclusiones y próximos pasos

Esquema: Conclusiones y próximos pasos
Esquema: Conclusiones y próximos pasos

Ahora el VPS cuenta con una instalación de Apache Airflow orientada a producción: PostgreSQL almacena los metadatos, Redis gestiona CeleryExecutor, los contenedores worker independientes ejecutan los DAG y Caddy protege la interfaz con un certificado HTTPS. La configuración no expone los servicios internos a Internet e incluye copias de seguridad de los datos críticos.

  1. Traslade los DAG a un repositorio Git y configure comprobaciones CI de importación, linters y pruebas antes de entregar los archivos al servidor.
  2. Conecte un backend externo de secretos si en Airflow aparecen claves API, tokens y accesos a bases de datos de producción.
  3. Al aumentar la carga, traslade los Celery workers a servidores independientes, configure remote logging en un almacenamiento de objetos y añada monitorización mediante Prometheus, Grafana o un servicio externo de alertas.

Enlaces de afiliado: podemos recibir una comisión, el precio para ti no cambia.

¿Te fue útil esta guía?

Tus comentarios nos ayudan a mejorar nuestras guías.

Compartir esta publicación:

Envía esta guía a alguien a quien pueda resultarle útil.

Telegram VKVK WhatsApp Facebook LinkedIn XX

instalación de Apache Airflow en VPS: Docker, PostgreSQL, CeleryExecutor, SSL y copias de seguridad