Kubernetes

Kubernetes Executor

The kubernetes executor is introduced in Apache Airflow 1.10.0. The Kubernetes executor will create a new pod for every task instance.

Example helm charts are available at scripts/ci/kubernetes/kube/{airflow,volumes,postgres}.yaml in the source distribution. The volumes are optional and depend on your configuration. There are two volumes available:

• Dags: by storing all the dags onto the persistent disks, all the workers can read the dags from there. Another option is using git-sync, before starting the container, a git pull of the dags repository will be performed and used throughout the lifecycle of the pod.
• Logs: by storing the logs onto a persistent disk, all the logs will be available for all the workers and the webserver itself. If you don’t configure this, the logs will be lost after the worker pods shuts down. Another option is to use S3/GCS/etc to store the logs.

Kubernetes Operator

from airflow.contrib.operators import KubernetesOperator
from airflow.contrib.operators.kubernetes_pod_operator import KubernetesPodOperator
from airflow.contrib.kubernetes.secret import Secret

secret_file = Secret('volume', '/etc/sql_conn', 'airflow-secrets', 'sql_alchemy_conn')
secret_env  = Secret('env', 'SQL_CONN', 'airflow-secrets', 'sql_alchemy_conn')
volume_mount = VolumeMount('test-volume',
                            mount_path='/root/mount_file',
                            sub_path=None,
                            read_only=True)

volume_config= {
    'persistentVolumeClaim':
      {
        'claimName': 'test-volume'
      }
    }
volume = Volume(name='test-volume', configs=volume_config)

affinity = {
    'nodeAffinity': {
      'preferredDuringSchedulingIgnoredDuringExecution': [
        {
          "weight": 1,
          "preference": {
            "matchExpressions": {
              "key": "disktype",
              "operator": "In",
              "values": ["ssd"]
            }
          }
        }
      ]
    },
    "podAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchExpressions": [
              {
                "key": "security",
                "operator": "In",
                "values": ["S1"]
              }
            ]
          },
          "topologyKey": "failure-domain.beta.kubernetes.io/zone"
        }
      ]
    },
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchExpressions": [
              {
                "key": "security",
                "operator": "In",
                "values": ["S2"]
              }
            ]
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
}

tolerations = [
    {
        'key': "key",
        'operator': 'Equal',
        'value': 'value'
     }
]

k = KubernetesPodOperator(namespace='default',
                          image="ubuntu:16.04",
                          cmds=["bash", "-cx"],
                          arguments=["echo", "10"],
                          labels={"foo": "bar"},
                          secrets=[secret_file,secret_env]
                          volume=[volume],
                          volume_mounts=[volume_mount]
                          name="test",
                          task_id="task",
                          affinity=affinity,
                          is_delete_operator_pod=True,
                          hostnetwork=False,
                          tolerations=tolerations
                          )

class airflow.contrib.operators.kubernetes_pod_operator.KubernetesPodOperator(**kwargs)

Bases: airflow.models.BaseOperator

Execute a task in a Kubernetes Pod

Parameters:

• image (str) – Docker image you wish to launch. Defaults to dockerhub.io, but fully qualified URLS will point to custom repositories
• cmds (list of str) – entrypoint of the container. (templated) The docker images’s entrypoint is used if this is not provide.
• arguments (list of str) – arguments of to the entrypoint. (templated) The docker image’s CMD is used if this is not provided.
• image_pull_policy (str) – Specify a policy to cache or always pull an image
• image_pull_secrets (str) – Any image pull secrets to be given to the pod. If more than one secret is required, provide a comma separated list: secret_a,secret_b
• volume_mounts (list of VolumeMount) – volumeMounts for launched pod
• volumes (list of Volume) – volumes for launched pod. Includes ConfigMaps and PersistentVolumes
• labels (dict) – labels to apply to the Pod
• startup_timeout_seconds (int) – timeout in seconds to startup the pod
• name (str) – name of the task you want to run, will be used to generate a pod id
• env_vars (dict) – Environment variables initialized in the container. (templated)
• secrets (list of Secret) – Kubernetes secrets to inject in the container, They can be exposed as environment vars or files in a volume.
• in_cluster (bool) – run kubernetes client with in_cluster configuration
• cluster_context (string) – context that points to kubernetes cluster. Ignored when in_cluster is True. If None, current-context is used.
• get_logs (bool) – get the stdout of the container as logs of the tasks
• affinity (dict) – A dict containing a group of affinity scheduling rules
• node_selectors (dict) – A dict containing a group of scheduling rules
• config_file (str) – The path to the Kubernetes config file
• xcom_push (bool) – If xcom_push is True, the content of the file /airflow/xcom/return.json in the container will also be pushed to an XCom when the container completes.
• hostnetwork (bool) – If True enable host networking on the pod
• tolerations (list tolerations) – A list of kubernetes tolerations

Param:

namespace: the namespace to run within kubernetes

Type:

namespace: str

class airflow.contrib.kubernetes.secret.Secret(deploy_type, deploy_target, secret, key)

Defines Kubernetes Secret Volume