Configure Kerberos authentication for Airflow databases

Astronomer Software supports Kerberos authentication for Airflow deployment databases, allowing you to connect to Kerberized PostgreSQL databases. This feature is available starting in Astronomer Software 0.37.7.

Overview

Kerberos is an authentication protocol that uses tickets to allow secure authentication in network environments. In enterprise environments with strict security requirements, databases are often configured to use Kerberos authentication instead of traditional username and password authentication.

With Kerberos database support in Astronomer Software, you can:

• Connect Airflow deployments to Kerberized PostgreSQL databases
• Maintain compliance with enterprise security policies that require Kerberos authentication
• Use existing Kerberos infrastructure for database authentication

How it works

Astronomer Software uses PgBouncer as a proxy between Airflow components and the Kerberized database. When you enable Kerberos for a deployment:

1. You provide labels and environment variables for PgBouncer Pods via the Houston API when creating or updating a deployment.
2. Your Kerberos credential injection mechanism (such as a mutation webhook) uses these labels to inject Kerberos credentials (keytabs or credential refresh sidecars) into the PgBouncer Pods.
3. PgBouncer authenticates to the PostgreSQL database using GSSAPI (Kerberos protocol).
4. Airflow components connect to PgBouncer using standard authentication, and PgBouncer proxies the connection to the Kerberized database.

Architecture

The following diagram shows the architecture for Kerberos database authentication in Astronomer Software 0.37.7:

Prerequisites

Before configuring Kerberos authentication, ensure you have:

• Astronomer Software 0.37.7 or later
• A Kerberized PostgreSQL database (PostgreSQL 18 has known issues)
• Kerberos infrastructure:
  • Active Directory or MIT Kerberos KDC (Key Distribution Center)
  • Network connectivity between your Kubernetes cluster and the KDC
• A mechanism to inject Kerberos credentials into PgBouncer Pods (see Kerberos credential injection)
• A Kerberos user principal created in your Active Directory
• Houston API access to create deployments

Responsibility model

Kerberos database authentication in Astronomer Software follows a shared responsibility model:

Astronomer responsibilities

• Providing PgBouncer images with Kerberos (GSSAPI) support
• Supporting labels and environment variables on PgBouncer Pods via the Houston API
• Maintaining deployment stability during updates

Customer responsibilities

• Setting up and managing Kerberos infrastructure (Active Directory, KDC, etc.)
• Creating and managing Kerberos user principals and keytabs
• Implementing a mechanism to inject Kerberos credentials into PgBouncer Pods (such as a mutation webhook)
• Configuring appropriate labels and environment variables via the Houston API to trigger credential injection
• Creating Kerberos users in the PostgreSQL database with appropriate permissions
• Pre-creating Airflow databases for deployments
• Managing Kerberos ticket lifecycle (renewal, rotation)

Scope and limitations

The following are supported in Astronomer Software 0.37.7 with Kerberos Authentication:

• Executor: Kubernetes Executor only
• Deployment Type: Image-based deployments only
• Database: PostgreSQL with Kerberos authentication

Future releases may expand support to other executors, deployment types, and databases.

Kerberos credential injection

You are responsible for implementing a mechanism to inject Kerberos credentials into PgBouncer Pods. One common approach is using a Kubernetes mutation webhook.

Mutation webhook approach (recommended)

A mutation webhook can automatically inject Kerberos credentials when PgBouncer Pods are created. The webhook typically:

1. Watches for Pod creation requests with specific labels that you configure via the Houston API
2. Injects a sidecar container that manages Kerberos ticket renewal
3. Mounts Kerberos configuration files (krb5.conf) and keytabs as volumes
4. Configures environment variables for Kerberos authentication

When creating a deployment, you’ll specify labels in the pgbouncerConfig section that trigger your webhook to inject the necessary credentials.

Alternative approaches

Other methods for credential injection include:

• Init containers that fetch credentials from a secret management system
• Direct volume mounts of Kerberos keytabs from Kubernetes secrets
• Service mesh sidecars

Choose the approach that best fits your organization’s security requirements and infrastructure.

For implementation guidance, contact Astronomer support or your Astronomer representative.

Step 1: Enable manual connection strings

Before creating Kerberos-enabled deployments, you must enable manual connection strings in your Astronomer configuration.

1. Open your values.yaml file.

2. Add the following configuration:

1
deployments:
2
  manualConnectionStrings:
3
    enabled: true
4
global:
5
  airflow:
6
    images:
7
      pgbouncer:
8
        repository: "quay.io/astronomer/ap-pgbouncer-krb"
9
        tag: "1.25.0-2"

3. Push the configuration change. See Apply a platform configuration change.

Step 2: Create the Kerberos database user

You must create a Kerberos user in your PostgreSQL database with the appropriate permissions.

1. Connect to your PostgreSQL database using a superuser account.

2. Create the Kerberos user. The username must be in the format <username>@<REALM>:

1
CREATE USER "astro_user@APC.ASTRONOMER.IO" WITH LOGIN;

3. Grant the necessary permissions:

1
-- For AWS RDS with Kerberos
2
GRANT rds_ad TO "astro_user@APC.ASTRONOMER.IO";
3
4
-- Database and schema permissions
5
GRANT ALL PRIVILEGES ON DATABASE postgres TO "astro_user@APC.ASTRONOMER.IO";
6
GRANT ALL PRIVILEGES ON SCHEMA public TO "astro_user@APC.ASTRONOMER.IO";
7
8
-- Allow database creation
9
ALTER ROLE "astro_user@APC.ASTRONOMER.IO" CREATEDB;

Replace astro_user with your Kerberos username and APC.ASTRONOMER.IO with your Kerberos realm.

Step 3: (Optional) Configure PgBouncer in the control plane

If you need to use a Kerberized database for the control plane (Houston’s database), you must configure PgBouncer in the astronomer namespace.

Create PgBouncer configuration

1. Create a pgbouncer.ini file with the following contents. Replace the placeholders with your actual values:

1
[databases]
2
* = host=<rds-hostname> port=5432 user=<kerberos_user>@<kerberos_realm>
3
4
[pgbouncer]
5
pool_mode = transaction
6
listen_addr = 0.0.0.0
7
listen_port = 6543
8
idle_transaction_timeout = 60
9
transaction_timeout = 60
10
autodb_idle_timeout = 60
11
admin_users = postgres
12
client_idle_timeout = 60
13
server_idle_timeout = 60
14
track_extra_parameters = search_path
15
stats_users = postgres
16
17
# Authentication settings
18
auth_type = md5
19
auth_file = /etc/pgbouncer/users.txt
20
ignore_startup_parameters = extra_float_digits
21
22
# Kerberos settings
23
server_gssauth_negotiate = allow
24
server_krb_spn = postgres/<rds-hostname>@<kerberos_realm>
25
26
max_client_conn = 200
27
verbose = 2
28
log_disconnections = 0
29
log_connections = 0
30
31
# Strongly recommended for RDS
32
server_tls_sslmode = prefer

2. Generate a password hash for the PgBouncer users.txt file:

$
echo -n "md5"; echo -n "<password><user>" | md5sum | awk '{print $1}'

3. Create a users.txt file with the password hashes:

"<kerberos_user>" "<output_from_above_command>"
"postgres" "<output_from_above_command>"

4. Create the Kubernetes secret:

$
kubectl -n astronomer create secret generic astronomer-pgbouncer-config \
>
  --from-file=pgbouncer.ini=./pgbouncer.ini \
>
  --from-file=users.txt=./users.txt \
>
  --dry-run=client -o yaml | kubectl apply -f -

Update Astronomer configuration

1. Open your values.yaml file.

2. Add the following PgBouncer configuration:

1
pgbouncer:
2
  enabled: true
3
  securityContext:
4
    runAsGroup: 65534
5
    runAsNonRoot: true
6
    runAsUser: 65534
7
8
global:
9
  pgbouncer:
10
    enabled: true
11
    extraEnv: []
12
    extraLabels: []
13
    gssSupport: true
14
    secretName: astronomer-pgbouncer-config
15
    securityContext:
16
      runAsGroup: 65534
17
      runAsUser: 65534
18
    servicePort: "6543"
19
    username: postgres

3. Update the Astronomer bootstrap secret to point to the PgBouncer service:

postgres://<username>:<password>@astronomer-pgbouncer.astronomer.svc.cluster.local:6543?pgbouncer=true&connection_limit=100&pool_timeout=60&prisma_connection_limit=100

The username and password are the user and password from the users.txt file above.

4. Upgrade the Astronomer installation. You must perform the upgrade in two steps:

   Step 1: First, upgrade with the --no-hooks flag. This installs PgBouncer in the control plane without running database migration jobs:

$
helm upgrade astronomer astronomer/astronomer \
>
  --namespace astronomer \
>
  -f <values_file>.yaml \
>
  --version <version>  \
>
  --no-hooks

The <version> is the Astronomer Software version you want to upgrade to (e.g., 0.37.7).

Step 2: After the upgrade completes and PgBouncer is running, run the upgrade again without the --no-hooks flag. This runs the Airflow database migration jobs:

$
helm upgrade astronomer astronomer/astronomer \
>
  --namespace astronomer \
>
  -f <values_file>.yaml \
>
  --version <version>

The <version> is the Astronomer Software version you want to upgrade to (e.g., 0.37.7).

Step 4: Create an Airflow deployment database

Before creating a Kerberos-enabled deployment, you must manually create the Airflow database.

Follow these steps to create the database:

1. Create a PostgreSQL client Pod for database operations:

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  labels:
5
    release: astronomer
6
    tier: astronomer
7
  name: postgres-debug-client
8
  namespace: astronomer
9
spec:
10
  containers:
11
  - command:
12
    - /bin/bash
13
    - -c
14
    - sleep infinity
15
    image: postgres:16
16
    imagePullPolicy: Always
17
    name: psql-client

2. Apply the Pod:

$
kubectl apply -f postgres-debug-client.yaml

3. Exec into the Pod and connect to the database:

$
kubectl -n astronomer exec -it postgres-debug-client -- bash
$
psql "postgres://postgres:postgres@astronomer-pgbouncer.astronomer.svc.cluster.local:6543"

4. Create the Airflow database:

1
CREATE DATABASE <deployment_name>_airflow OWNER <kerberos_user>@<kerberos_realm>;

For example:

1
CREATE DATABASE mydeployment_airflow OWNER "astro_user@APC.ASTRONOMER.IO";

Step 5: Create a Kerberos-enabled deployment

Kerberos-enabled deployments must be created using the Houston API. They cannot be created from the Astronomer UI.

Use the upsertDeployment mutation

1. Compose your mutation payload. The following example shows the required fields for a Kerberos-enabled deployment:

1
{
2
  "cloudRole": "",
3
  "dagDeployment": {
4
    "nfsLocation": "",
5
    "type": "image"
6
  },
7
  "dagProcessor": {
8
    "replicas": 1
9
  },
10
  "kerberosEnabled": true,
11
  "deploymentUuid": "",
12
  "deployRevisionDescription": "",
13
  "description": "",
14
  "dockerconfigjson": null,
15
  "environmentVariables": [],
16
  "executor": "KubernetesExecutor",
17
  "image": "",
18
  "label": "my-kerberos-deployment",
19
  "metadataConnection": "",
20
  "metadataConnectionJson": {
21
    "protocol": "postgresql",
22
    "user": "astro_user@APC.ASTRONOMER.IO",
23
    "pass": "no-pass",
24
    "host": "<airflow-db-host>",
25
    "port": 5432,
26
    "db": "mydeployment_airflow"
27
  },
28
  "mode": "helm",
29
  "namespace": "",
30
  "properties": {
31
    "extra_capacity": {
32
      "cpu": 0,
33
      "memory": 0
34
    }
35
  },
36
  "releaseName": "mydeployment",
37
  "resultBackendConnection": "",
38
  "resultBackendConnectionJson": {
39
    "protocol": "postgresql",
40
    "user": "astro_user@APC.ASTRONOMER.IO",
41
    "pass": "no-pass",
42
    "host": "<airflow-db-host>",
43
    "port": 5432,
44
    "db": "mydeployment_airflow"
45
  },
46
  "rollbackEnabled": false,
47
  "runtimeVersion": "11.6.0",
48
  "scheduler": {
49
    "replicas": 1
50
  },
51
  "triggerer": {},
52
  "webserver": {},
53
  "workers": {},
54
  "pgbouncerConfig": {
55
    "labels": {
56
      "key": "value"
57
    },
58
    "env": [
59
      {"name": "KERBEROS_USER", "value": "astro_user@APC.ASTRONOMER.IO"},
60
      {"name": "KERBEROS_PASSWORD", "value": "YourKerberosPassword"}
61
    ],
62
    "extraIniResultBackend": "user=astro_user@APC.ASTRONOMER.IO",
63
    "extraIniMetadata": "user=astro_user@APC.ASTRONOMER.IO",
64
    "extraIni": "server_gssauth_negotiate = allow\\nserver_krb_spn = postgres/<airflow-db-host>@APC.ASTRONOMER.IO",
65
    "sslmode": "prefer"
66
  },
67
  "workspaceLabel": "my-workspace",
68
  "workspaceUuid": "<workspace-uuid>"
69
}

Important configuration fields

• kerberosEnabled: Must be set to true. This enables Houston to perform Kerberos-specific validation.
• metadataConnectionJson and resultBackendConnectionJson:
  • user: Must be in the format <username>@<REALM>
  • pass: Can be any value (e.g., "no-pass") since PgBouncer uses Kerberos for database authentication
  • host: The hostname of your Kerberized PostgreSQL database
  • db: The database name you created (e.g., mydeployment_airflow)
• pgbouncerConfig:
  • labels: Custom labels for the PgBouncer Pod. Use these labels to trigger your Kerberos credential injection mechanism (e.g., "krb-inject": "enabled" or "component": "pgbouncer").
  • env: Environment variables for the PgBouncer Pod. Your credential injection mechanism can use these to configure Kerberos authentication (e.g., KERBEROS_USER, KERBEROS_PASSWORD).
  • extraIniMetadata and extraIniResultBackend: Must specify the Kerberos user.
  • extraIni: Must include Kerberos/GSS settings:
    • server_gssauth_negotiate = allow
    • server_krb_spn = postgres/<airflow-db-host>@<kerberos_realm>
  • sslmode: Set to prefer for RDS or other TLS-enabled databases

2. Execute the mutation using the Houston API.

Step 6: Verify Kerberos authentication

After creating your deployment, verify that Kerberos authentication is working correctly.

Verify deployment creation

1. List the Pods in the deployment namespace:

$
kubectl -n <airflow-namespace> get pods

2. Verify that all Airflow Pods are running:

$
kubectl -n <airflow-namespace> get pods -l component=scheduler
$
kubectl -n <airflow-namespace> get pods -l component=webserver
$
kubectl -n <airflow-namespace> get pods -l component=pgbouncer

Verify database connectivity

1. Check the PgBouncer logs for successful connections:

$
kubectl -n <airflow-namespace> logs <pgbouncer-pod-name>

Look for log entries showing connections using the Kerberos principal.

2. Verify that the Airflow UI loads successfully:

   a. Log in to the Astronomer UI.

   b. Navigate to your deployment.

   c. Click Airflow UI.

If the Airflow UI loads without errors, PgBouncer is successfully connecting to the database using Kerberos authentication.

Troubleshooting

PgBouncer Pod fails to start

If the PgBouncer Pod fails to start, check the following:

• Verify that your Kerberos credential injection mechanism is configured correctly.

• Check the Pod events for error messages:

  $
  kubectl -n <airflow-namespace> describe pod <pgbouncer-pod-name>

• Verify that the labels in pgbouncerConfig match what your credential injection mechanism expects.

Kerberos authentication failures

If authentication fails, verify:

• The Kerberos user exists in your Active Directory and PostgreSQL database.
• The server_krb_spn in the PgBouncer configuration matches your database hostname and realm.
• Network connectivity between the Kubernetes cluster and the KDC.
• Your Kerberos credential injection mechanism is working correctly.

Airflow UI fails to load

If the Airflow UI fails to load:

• Check the webserver and scheduler logs for database connection errors.
• Verify that the database was created with the correct owner.
• Ensure the metadataConnectionJson and resultBackendConnectionJson are correctly configured.

Additional resources

• Apply a platform configuration change
• Houston API
• Houston API examples
• Workspace permissions