Service type
Apache Airflow service
Apache Airflow workflow orchestration service built from your Git repository, with your DAGs, plugins, and Python packages in every Airflow component and linked PostgreSQL metadata storage.
Use it as a versioned stack building block that can build from source, plug into CI/CD, and connect to external providers without hardcoding secrets into the codebase.
Why teams use this service
Technical profile
Review versions, ports, source, and packaging.
Stacks that use it
See where this service fits in ready-made stacks.
Source builds and CI/CD
Start from a compatible boilerplate, use Wodby CI, and publish images cleanly.
Runtime wiring and defaults
See ports, links, storage, configs, and runtime behavior.
On Wodby
How Apache Airflow runs on Wodby
apache/airflow image built with the app's repository. Configuration is passed as AIRFLOW__<SECTION>__<KEY> environment variables, which take precedence over airflow.cfg.Processes
One pod runs four containers on the same volume: the API server (main container, port 8080, also the web interface), scheduler, dag-processor and triggerer. Before they start, an init container migrates the metadata database (_AIRFLOW_DB_MIGRATE) and creates the administrator (_AIRFLOW_WWW_USER_CREATE). The executor is LocalExecutor: tasks run inside the scheduler container, so their memory comes from that container's limit, which is set with the other containers' resources on the app service. Airflow itself doesn't cap a task's memory; AIRFLOW__CORE__PARALLELISM and DAG-level max_active_tasks limit how many tasks run at once. The service is not scalable.
Linked services
| Link | Variables |
|---|---|
| PostgreSQL (required) | AIRFLOW__DATABASE__SQL_ALCHEMY_CONN |
It is the metadata database of Airflow. Do not set the connection elsewhere.
Generated credentials
| Token | Variable | Use |
|---|---|---|
admin_username, admin_password | _AIRFLOW_WWW_USER_USERNAME, _AIRFLOW_WWW_USER_PASSWORD | administrator created by the init container; an existing user is left as it is |
fernet_key | AIRFLOW__CORE__FERNET_KEY | encrypts connection passwords stored in the database |
api_secret_key | AIRFLOW__API__SECRET_KEY | API server sessions |
api_auth_jwt_secret | AIRFLOW__API_AUTH__JWT_SECRET | tokens between Airflow components and for the API |
Users are managed by the FAB auth manager (AIRFLOW__CORE__AUTH_MANAGER). Example DAGs are off (AIRFLOW__CORE__LOAD_EXAMPLES).
Image and DAGs
The image is built from the app's Git repository on top of the apache/airflow image of the service's version, so the service's versions are Airflow versions. Start the repository from the Airflow boilerplate. The build:
- copies the repository to
/opt/airflow-app, outside the/opt/airflowdata volume, which would hide files baked into the image; - installs the packages in
requirements.txt, when the repository has one, with Airflow pinned to the image's version, so packages that need another Airflow fail the build; - sets
AIRFLOW__CORE__DAGS_FOLDERto/opt/airflow-app/dagsandAIRFLOW__CORE__PLUGINS_FOLDERto/opt/airflow-app/plugins.
Every Airflow component runs the built image: the API server, scheduler, DAG processor and triggerer are build containers of the workload, and the setup step gets the image through helm.image.references. DAG and package changes reach Airflow with the next deployment. Airflow's version comes from the service version and the image, not from the repository.
Put DAG files in dags/ and plugins in plugins/ of the repository; the dags and plugins directories on the data volume are not read. The data volume is mounted at /opt/airflow, the Airflow home, in every container and keeps Airflow's logs.
Changing configuration
Add or change AIRFLOW__* environment variables on the service and deploy it. The scheduler, DAG processor and triggerer get only the service's secret variables, from the environment Secret, plus the executor, examples and auth manager settings declared in the manifest; after a change, check that it reached the container that uses it.
Check the result
/api/v2/monitor/health on port 8080 reports the state of the metadata database, scheduler, DAG processor and triggerer.
Overview
Technical profile and packaging
Versions
Source repository
Public Helm chart
Ports and protocols
Labels
Persistent volumes
Stacks
Use it inside ready-made stacks or your own
CI/CD
Build from source and ship changes without extra glue work
Vanilla Airflow project
Start from a working boilerplate instead of wiring the build process from scratch.
wodby/airflow-boilerplateGit providers
Connect repositories from supported Git providers when this service should build from your own codebase.
CI providers
Wodby CI is the default path, but external CI providers can fit the same build and release workflow when that suits your team better.
Container registries
Keep built images in Wodby Registry by default or store them in another registry without changing how the service is built.
Keep secrets and variables outside the codebase
Attach provider credentials and environment variables at the platform level so the build and runtime do not depend on hardcoded secrets.
Runtime wiring
Reuse connectivity, storage, and runtime defaults
Endpoints
Technical domains
Volumes
Service links
These links define which other services can connect to Apache Airflow when it is used inside a stack.
postgres
Eligible linked services