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
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
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
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
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
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,configyscripts. - El archivo
.envcon Fernet key, API secret y contraseñas. docker-compose.yml,Dockerfileyrequirements.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
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.
- Traslade los DAG a un repositorio Git y configure comprobaciones CI de importación, linters y pruebas antes de entregar los archivos al servidor.
- Conecte un backend externo de secretos si en Airflow aparecen claves API, tokens y accesos a bases de datos de producción.
- 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.