VTbkTasQ

1sudo -E pip-3.6 install apache-airflow[celery,devel,postgres]
2	
3sudo -E pip-3.6 install apache-airflow[all]
4	
5[ec2-user@ip-1-2-3-4 ~]$ airflow version
6[2018-08-29 16:09:59,088] {{__init__.py:51}} INFO - Using executor SequentialExecutor
7  ____________       _____________
8 ____    |__( )_________  __/__  /________      __
9____  /| |_  /__  ___/_  /_ __  /_  __ _ | /| / /
10___  ___ |  / _  /   _  __/ _  / / /_/ /_ |/ |/ /
11 _/_/  |_/_/  /_/    /_/    /_/  ____/____/|__/
12   v1.10.0
13	
14[2018-08-29 16:14:01,114] {{sequential_executor.py:52}} ERROR - Failed to execute task Command 'airflow run ScheduleTest successful 2018-08-29T19:00:00+00:00 --local -sd /home/ec2-user/{AIRFLOW_HOME}/dags/SchedulerTest.py' returned non-zero exit status 1..
15[2018-08-29 16:14:01,115] {{jobs.py:1443}} INFO - Executor reports ScheduleTest.successful execution_date=2018-08-29 19:00:00+00:00 as failed
16[2018-08-29 16:14:01,119] {{jobs.py:1459}} ERROR - Executor reports task instance <TaskInstance: ScheduleTest.successful 2018-08-29 19:00:00+00:00 [queued]> finished (failed) although the task says its queued. Was the task killed externally?
17[2018-08-29 16:14:01,120] {{models.py:258}} INFO - Filling up the DagBag from /home/ec2-user/{AIRFLOW_HOME}/dags/SchedulerTest.py
18[2018-08-29 16:14:01,540] {{models.py:1736}} ERROR - Executor reports task instance <TaskInstance: ScheduleTest.successful 2018-08-29 19:00:00+00:00 [queued]> finished (failed) although the task says its queued. Was the task killed externally?
19NoneType: None
20[2018-08-29 16:14:01,541] {{models.py:1764}} INFO - Marking task as FAILED.
21[2018-08-29 16:14:01,740] {{models.py:1778}} ERROR - Failed at executing callback
22[2018-08-29 16:14:01,740] {{models.py:1779}} ERROR - Bash command failed
23Traceback (most recent call last):
24  File "/usr/local/lib/python3.6/site-packages/airflow/models.py", line 1776, in handle_failure
25    task.on_failure_callback(context)
26  File "/home/ec2-user/{AIRFLOW_HOME}/dags/SchedulerTest.py", line 35, in on_failure_callback
27    return failure_task_notification.execute(context=context)
28  File "/usr/local/lib/python3.6/site-packages/airflow/operators/bash_operator.py", line 118, in execute
29    raise AirflowException("Bash command failed")
30airflow.exceptions.AirflowException: Bash command failed
31	
32# -*- coding: utf-8 -*-
33#
34# Licensed to the Apache Software Foundation (ASF) under one
35# or more contributor license agreements.  See the NOTICE file
36# distributed with this work for additional information
37# regarding copyright ownership.  The ASF licenses this file
38# to you under the Apache License, Version 2.0 (the
39# "License"); you may not use this file except in compliance
40# with the License.  You may obtain a copy of the License at
41#
42#   http://www.apache.org/licenses/LICENSE-2.0
43#
44# Unless required by applicable law or agreed to in writing,
45# software distributed under the License is distributed on an
46# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
47# KIND, either express or implied.  See the License for the
48# specific language governing permissions and limitations
49# under the License.
50
51
52# This is the template for Airflow's default configuration. When Airflow is
53# imported, it looks for a configuration file at $AIRFLOW_HOME/airflow.cfg. If
54# it doesn't exist, Airflow uses this template to generate it by replacing
55# variables in curly braces with their global values from configuration.py.
56
57# Users should not modify this file; they should customize the generated
58# airflow.cfg instead.
59
60
61# ----------------------- TEMPLATE BEGINS HERE -----------------------
62
63[core]
64# The home folder for airflow, default is ~/airflow
65airflow_home = {AIRFLOW_HOME}
66
67# The folder where your airflow pipelines live, most likely a
68# subfolder in a code repository
69# This path must be absolute
70dags_folder = {AIRFLOW_HOME}/dags
71
72# The folder where airflow should store its log files
73# This path must be absolute
74base_log_folder = {AIRFLOW_HOME}/logs
75
76# Airflow can store logs remotely in AWS S3, Google Cloud Storage or Elastic Search.
77# Users must supply an Airflow connection id that provides access to the storage
78# location. If remote_logging is set to true, see UPDATING.md for additional
79# configuration requirements.
80remote_logging = False
81remote_log_conn_id =
82remote_base_log_folder =
83encrypt_s3_logs = False
84
85# Logging level
86logging_level = INFO
87fab_logging_level = WARN
88
89# Logging class
90# Specify the class that will specify the logging configuration
91# This class has to be on the python classpath
92# logging_config_class = my.path.default_local_settings.LOGGING_CONFIG
93logging_config_class =airflow_local_settings.DEFAULT_LOGGING_CONFIG
94
95# Log format
96# we need to escape the curly braces by adding an additional curly brace
97log_format = [%%(asctime)s] {{%%(filename)s:%%(lineno)d}} %%(levelname)s - %%(message)s
98simple_log_format = %%(asctime)s %%(levelname)s - %%(message)s
99
100# Log filename format
101# we need to escape the curly braces by adding an additional curly brace
102log_filename_template = {{{{ ti.dag_id }}}}/{{{{ ti.task_id }}}}/{{{{ ts }}}}/{{{{ try_number }}}}.log
103log_processor_filename_template = {{{{ filename }}}}.log
104
105# Hostname by providing a path to a callable, which will resolve the hostname
106hostname_callable = socket:getfqdn
107
108# Default timezone in case supplied date times are naive
109# can be utc (default), system, or any IANA timezone string (e.g. Europe/Amsterdam)
110default_timezone = utc
111
112# The executor class that airflow should use. Choices include
113# SequentialExecutor, LocalExecutor, CeleryExecutor, DaskExecutor
114executor = SequentialExecutor
115
116# The SqlAlchemy connection string to the metadata database.
117# SqlAlchemy supports many different database engine, more information
118# their website
119sql_alchemy_conn = sqlite:///{AIRFLOW_HOME}/airflow.db
120
121# If SqlAlchemy should pool database connections.
122sql_alchemy_pool_enabled = True
123
124# The SqlAlchemy pool size is the maximum number of database connections
125# in the pool. 0 indicates no limit.
126sql_alchemy_pool_size = 5
127
128# The SqlAlchemy pool recycle is the number of seconds a connection
129# can be idle in the pool before it is invalidated. This config does
130# not apply to sqlite. If the number of DB connections is ever exceeded,
131# a lower config value will allow the system to recover faster.
132sql_alchemy_pool_recycle = 1800
133
134# How many seconds to retry re-establishing a DB connection after
135# disconnects. Setting this to 0 disables retries.
136sql_alchemy_reconnect_timeout = 300
137
138# The amount of parallelism as a setting to the executor. This defines
139# the max number of task instances that should run simultaneously
140# on this airflow installation
141parallelism = 32
142
143# The number of task instances allowed to run concurrently by the scheduler
144dag_concurrency = 16
145
146# Are DAGs paused by default at creation
147dags_are_paused_at_creation = True
148
149# When not using pools, tasks are run in the "default pool",
150# whose size is guided by this config element
151non_pooled_task_slot_count = 128
152
153# The maximum number of active DAG runs per DAG
154max_active_runs_per_dag = 16
155
156# Whether to load the examples that ship with Airflow. It's good to
157# get started, but you probably want to set this to False in a production
158# environment
159load_examples = True
160
161# Where your Airflow plugins are stored
162plugins_folder = {AIRFLOW_HOME}/plugins
163
164# Secret key to save connection passwords in the db
165fernet_key=ZFz1t3rs5fHD_vdxiBISbr23mhnigDB7YeN_Zek=
166
167# Whether to disable pickling dags
168donot_pickle = False
169
170# How long before timing out a python file import while filling the DagBag
171dagbag_import_timeout = 30
172
173# The class to use for running task instances in a subprocess
174task_runner = StandardTaskRunner
175
176# If set, tasks without a `run_as_user` argument will be run with this user
177# Can be used to de-elevate a sudo user running Airflow when executing tasks
178default_impersonation =
179
180# What security module to use (for example kerberos):
181security =
182
183# If set to False enables some unsecure features like Charts and Ad Hoc Queries.
184# In 2.0 will default to True.
185secure_mode = False
186
187# Turn unit test mode on (overwrites many configuration options with test
188# values at runtime)
189unit_test_mode = False
190
191# Name of handler to read task instance logs.
192# Default to use task handler.
193task_log_reader = task
194
195# Whether to enable pickling for xcom (note that this is insecure and allows for
196# RCE exploits). This will be deprecated in Airflow 2.0 (be forced to False).
197enable_xcom_pickling = True
198
199# When a task is killed forcefully, this is the amount of time in seconds that
200# it has to cleanup after it is sent a SIGTERM, before it is SIGKILLED
201killed_task_cleanup_time = 60
202
203# Whether to override params with dag_run.conf. If you pass some key-value pairs through `airflow backfill -c` or
204# `airflow trigger_dag -c`, the key-value pairs will override the existing ones in params.
205dag_run_conf_overrides_params = False
206
207# Worker initialisation check to validate Metadata Database connection
208worker_precheck = False
209
210[cli]
211# In what way should the cli access the API. The LocalClient will use the
212# database directly, while the json_client will use the api running on the
213# webserver
214api_client = airflow.api.client.local_client
215
216# If you set web_server_url_prefix, do NOT forget to append it here, ex:
217# endpoint_url = http://localhost:8080/myroot
218# So api will look like: http://localhost:8080/myroot/api/experimental/...
219endpoint_url = http://localhost:8080
220
221[api]
222# How to authenticate users of the API
223auth_backend = airflow.api.auth.backend.default
224
225[lineage]
226# what lineage backend to use
227backend =
228
229[atlas]
230sasl_enabled = False
231host =
232port = 21000
233username =
234password =
235
236[operators]
237# The default owner assigned to each new operator, unless
238# provided explicitly or passed via `default_args`
239default_owner = Airflow
240default_cpus = 1
241default_ram = 512
242default_disk = 512
243default_gpus = 0
244
245[hive]
246# Default mapreduce queue for HiveOperator tasks
247default_hive_mapred_queue =
248# Template for mapred_job_name in HiveOperator, supports the following named parameters:
249# hostname, dag_id, task_id, execution_date
250mapred_job_name_template = Airflow HiveOperator task for {{hostname}}.{{dag_id}}.{{task_id}}.{{execution_date}}
251
252[webserver]
253# The base url of your website as airflow cannot guess what domain or
254# cname you are using. This is used in automated emails that
255# airflow sends to point links to the right web server
256base_url = http://localhost:8080
257
258# The ip specified when starting the web server
259web_server_host = 0.0.0.0
260
261# The port on which to run the web server
262web_server_port = 8080
263
264# Paths to the SSL certificate and key for the web server. When both are
265# provided SSL will be enabled. This does not change the web server port.
266web_server_ssl_cert =
267web_server_ssl_key =
268
269# Number of seconds the webserver waits before killing gunicorn master that doesn't respond
270web_server_master_timeout = 120
271
272# Number of seconds the gunicorn webserver waits before timing out on a worker
273web_server_worker_timeout = 120
274
275# Number of workers to refresh at a time. When set to 0, worker refresh is
276# disabled. When nonzero, airflow periodically refreshes webserver workers by
277# bringing up new ones and killing old ones.
278worker_refresh_batch_size = 1
279
280# Number of seconds to wait before refreshing a batch of workers.
281worker_refresh_interval = 30
282
283# Secret key used to run your flask app
284# It should be as random as possible
285secret_key = {SECRET_KEY}
286
287# Number of workers to run the Gunicorn web server
288workers = 4
289
290# The worker class gunicorn should use. Choices include
291# sync (default), eventlet, gevent
292worker_class = sync
293
294# Log files for the gunicorn webserver. '-' means log to stderr.
295access_logfile = -
296error_logfile = -
297
298# Expose the configuration file in the web server
299expose_config = False
300
301# Set to true to turn on authentication:
302# https://airflow.incubator.apache.org/security.html#web-authentication
303authenticate = False
304
305# Filter the list of dags by owner name (requires authentication to be enabled)
306filter_by_owner = False
307
308# Filtering mode. Choices include user (default) and ldapgroup.
309# Ldap group filtering requires using the ldap backend
310#
311# Note that the ldap server needs the "memberOf" overlay to be set up
312# in order to user the ldapgroup mode.
313owner_mode = user
314
315# Default DAG view.  Valid values are:
316# tree, graph, duration, gantt, landing_times
317dag_default_view = tree
318
319# Default DAG orientation. Valid values are:
320# LR (Left->Right), TB (Top->Bottom), RL (Right->Left), BT (Bottom->Top)
321dag_orientation = LR
322
323# Puts the webserver in demonstration mode; blurs the names of Operators for
324# privacy.
325demo_mode = False
326
327# The amount of time (in secs) webserver will wait for initial handshake
328# while fetching logs from other worker machine
329log_fetch_timeout_sec = 5
330
331# By default, the webserver shows paused DAGs. Flip this to hide paused
332# DAGs by default
333hide_paused_dags_by_default = False
334
335# Consistent page size across all listing views in the UI
336page_size = 100
337
338# Use FAB-based webserver with RBAC feature
339rbac = False
340
341# Define the color of navigation bar
342navbar_color = #007A87
343
344# Default dagrun to show in UI
345default_dag_run_display_number = 25
346
347
348[email]
349email_backend = airflow.utils.email.send_email_smtp
350
351
352[smtp]
353# If you want airflow to send emails on retries, failure, and you want to use
354# the airflow.utils.email.send_email_smtp function, you have to configure an
355# smtp server here
356smtp_host = localhost
357smtp_starttls = True
358smtp_ssl = False
359# Uncomment and set the user/pass settings if you want to use SMTP AUTH
360# smtp_user = airflow
361# smtp_password = airflow
362smtp_port = 25
363smtp_mail_from = airflow@example.com
364
365
366[celery]
367# This section only applies if you are using the CeleryExecutor in
368# [core] section above
369
370# The app name that will be used by celery
371celery_app_name = airflow.executors.celery_executor
372
373# The concurrency that will be used when starting workers with the
374# "airflow worker" command. This defines the number of task instances that
375# a worker will take, so size up your workers based on the resources on
376# your worker box and the nature of your tasks
377worker_concurrency = 16
378
379# When you start an airflow worker, airflow starts a tiny web server
380# subprocess to serve the workers local log files to the airflow main
381# web server, who then builds pages and sends them to users. This defines
382# the port on which the logs are served. It needs to be unused, and open
383# visible from the main web server to connect into the workers.
384worker_log_server_port = 8793
385
386# The Celery broker URL. Celery supports RabbitMQ, Redis and experimentally
387# a sqlalchemy database. Refer to the Celery documentation for more
388# information.
389# http://docs.celeryproject.org/en/latest/userguide/configuration.html#broker-settings
390broker_url = sqla+mysql://airflow:airflow@localhost:3306/airflow
391
392# The Celery result_backend. When a job finishes, it needs to update the
393# metadata of the job. Therefore it will post a message on a message bus,
394# or insert it into a database (depending of the backend)
395# This status is used by the scheduler to update the state of the task
396# The use of a database is highly recommended
397# http://docs.celeryproject.org/en/latest/userguide/configuration.html#task-result-backend-settings
398result_backend = db+mysql://airflow:airflow@localhost:3306/airflow
399
400# Celery Flower is a sweet UI for Celery. Airflow has a shortcut to start
401# it `airflow flower`. This defines the IP that Celery Flower runs on
402flower_host = 0.0.0.0
403
404# The root URL for Flower
405# Ex: flower_url_prefix = /flower
406flower_url_prefix =
407
408# This defines the port that Celery Flower runs on
409flower_port = 5555
410
411# Default queue that tasks get assigned to and that worker listen on.
412default_queue = default
413
414# Import path for celery configuration options
415celery_config_options = airflow.config_templates.default_celery.DEFAULT_CELERY_CONFIG
416
417# In case of using SSL
418ssl_active = False
419ssl_key =
420ssl_cert =
421ssl_cacert =
422
423[celery_broker_transport_options]
424# This section is for specifying options which can be passed to the
425# underlying celery broker transport.  See:
426# http://docs.celeryproject.org/en/latest/userguide/configuration.html#std:setting-broker_transport_options
427
428# The visibility timeout defines the number of seconds to wait for the worker
429# to acknowledge the task before the message is redelivered to another worker.
430# Make sure to increase the visibility timeout to match the time of the longest
431# ETA you're planning to use.
432#
433# visibility_timeout is only supported for Redis and SQS celery brokers.
434# See:
435#   http://docs.celeryproject.org/en/master/userguide/configuration.html#std:setting-broker_transport_options
436#
437#visibility_timeout = 21600
438
439[dask]
440# This section only applies if you are using the DaskExecutor in
441# [core] section above
442
443# The IP address and port of the Dask cluster's scheduler.
444cluster_address = 127.0.0.1:8786
445# TLS/ SSL settings to access a secured Dask scheduler.
446tls_ca =
447tls_cert =
448tls_key =
449
450
451[scheduler]
452# Task instances listen for external kill signal (when you clear tasks
453# from the CLI or the UI), this defines the frequency at which they should
454# listen (in seconds).
455job_heartbeat_sec = 5
456
457# The scheduler constantly tries to trigger new tasks (look at the
458# scheduler section in the docs for more information). This defines
459# how often the scheduler should run (in seconds).
460scheduler_heartbeat_sec = 5
461
462# after how much time should the scheduler terminate in seconds
463# -1 indicates to run continuously (see also num_runs)
464run_duration = -1
465
466# after how much time (seconds) a new DAGs should be picked up from the filesystem
467min_file_process_interval = 0
468
469# How often (in seconds) to scan the DAGs directory for new files. Default to 5 minutes.
470dag_dir_list_interval = 300
471
472# How often should stats be printed to the logs
473print_stats_interval = 30
474
475child_process_log_directory = {AIRFLOW_HOME}/logs/scheduler
476
477# Local task jobs periodically heartbeat to the DB. If the job has
478# not heartbeat in this many seconds, the scheduler will mark the
479# associated task instance as failed and will re-schedule the task.
480scheduler_zombie_task_threshold = 300
481
482# Turn off scheduler catchup by setting this to False.
483# Default behavior is unchanged and
484# Command Line Backfills still work, but the scheduler
485# will not do scheduler catchup if this is False,
486# however it can be set on a per DAG basis in the
487# DAG definition (catchup)
488catchup_by_default = True
489
490# This changes the batch size of queries in the scheduling main loop.
491# If this is too high, SQL query performance may be impacted by one
492# or more of the following:
493#  - reversion to full table scan
494#  - complexity of query predicate
495#  - excessive locking
496#
497# Additionally, you may hit the maximum allowable query length for your db.
498#
499# Set this to 0 for no limit (not advised)
500max_tis_per_query = 512
501
502# Statsd (https://github.com/etsy/statsd) integration settings
503statsd_on = False
504statsd_host = localhost
505statsd_port = 8125
506statsd_prefix = airflow
507
508# The scheduler can run multiple threads in parallel to schedule dags.
509# This defines how many threads will run.
510max_threads = 2
511
512authenticate = False
513
514[ldap]
515# set this to ldaps://<your.ldap.server>:<port>
516uri =
517user_filter = objectClass=*
518user_name_attr = uid
519group_member_attr = memberOf
520superuser_filter =
521data_profiler_filter =
522bind_user = cn=Manager,dc=example,dc=com
523bind_password = insecure
524basedn = dc=example,dc=com
525cacert = /etc/ca/ldap_ca.crt
526search_scope = LEVEL
527
528[mesos]
529# Mesos master address which MesosExecutor will connect to.
530master = localhost:5050
531
532# The framework name which Airflow scheduler will register itself as on mesos
533framework_name = Airflow
534
535# Number of cpu cores required for running one task instance using
536# 'airflow run <dag_id> <task_id> <execution_date> --local -p <pickle_id>'
537# command on a mesos slave
538task_cpu = 1
539
540# Memory in MB required for running one task instance using
541# 'airflow run <dag_id> <task_id> <execution_date> --local -p <pickle_id>'
542# command on a mesos slave
543task_memory = 256
544
545# Enable framework checkpointing for mesos
546# See http://mesos.apache.org/documentation/latest/slave-recovery/
547checkpoint = False
548
549# Failover timeout in milliseconds.
550# When checkpointing is enabled and this option is set, Mesos waits
551# until the configured timeout for
552# the MesosExecutor framework to re-register after a failover. Mesos
553# shuts down running tasks if the
554# MesosExecutor framework fails to re-register within this timeframe.
555# failover_timeout = 604800
556
557# Enable framework authentication for mesos
558# See http://mesos.apache.org/documentation/latest/configuration/
559authenticate = False
560
561# Mesos credentials, if authentication is enabled
562# default_principal = admin
563# default_secret = admin
564
565# Optional Docker Image to run on slave before running the command
566# This image should be accessible from mesos slave i.e mesos slave
567# should be able to pull this docker image before executing the command.
568# docker_image_slave = puckel/docker-airflow
569
570[kerberos]
571ccache = /tmp/airflow_krb5_ccache
572# gets augmented with fqdn
573principal = airflow
574reinit_frequency = 3600
575kinit_path = kinit
576keytab = airflow.keytab
577
578
579[github_enterprise]
580api_rev = v3
581
582[admin]
583# UI to hide sensitive variable fields when set to True
584hide_sensitive_variable_fields = True
585
586[elasticsearch]
587elasticsearch_host =
588# we need to escape the curly braces by adding an additional curly brace
589elasticsearch_log_id_template = {{dag_id}}-{{task_id}}-{{execution_date}}-{{try_number}}
590elasticsearch_end_of_log_mark = end_of_log
591
592[kubernetes]
593# The repository, tag and imagePullPolicy of the Kubernetes Image for the Worker to Run
594worker_container_repository =
595worker_container_tag =
596worker_container_image_pull_policy = IfNotPresent
597worker_dags_folder =
598
599# If True (default), worker pods will be deleted upon termination
600delete_worker_pods = True
601
602# The Kubernetes namespace where airflow workers should be created. Defaults to `default`
603namespace = default
604
605# The name of the Kubernetes ConfigMap Containing the Airflow Configuration (this file)
606airflow_configmap =
607
608# For either git sync or volume mounted DAGs, the worker will look in this subpath for DAGs
609dags_volume_subpath =
610
611# For DAGs mounted via a volume claim (mutually exclusive with volume claim)
612dags_volume_claim =
613
614# For volume mounted logs, the worker will look in this subpath for logs
615logs_volume_subpath =
616
617# A shared volume claim for the logs
618logs_volume_claim =
619
620# Git credentials and repository for DAGs mounted via Git (mutually exclusive with volume claim)
621git_repo =
622git_branch =
623git_user =
624git_password =
625git_subpath =
626
627# For cloning DAGs from git repositories into volumes: https://github.com/kubernetes/git-sync
628git_sync_container_repository = gcr.io/google-containers/git-sync-amd64
629git_sync_container_tag = v2.0.5
630git_sync_init_container_name = git-sync-clone
631
632# The name of the Kubernetes service account to be associated with airflow workers, if any.
633# Service accounts are required for workers that require access to secrets or cluster resources.
634# See the Kubernetes RBAC documentation for more:
635#   https://kubernetes.io/docs/admin/authorization/rbac/
636worker_service_account_name =
637
638# Any image pull secrets to be given to worker pods, If more than one secret is
639# required, provide a comma separated list: secret_a,secret_b
640image_pull_secrets =
641
642# GCP Service Account Keys to be provided to tasks run on Kubernetes Executors
643# Should be supplied in the format: key-name-1:key-path-1,key-name-2:key-path-2
644gcp_service_account_keys =
645
646# Use the service account kubernetes gives to pods to connect to kubernetes cluster.
647# It's intended for clients that expect to be running inside a pod running on kubernetes.
648# It will raise an exception if called from a process not running in a kubernetes environment.
649in_cluster = True
650
651[kubernetes_node_selectors]
652# The Key-value pairs to be given to worker pods.
653# The worker pods will be scheduled to the nodes of the specified key-value pairs.
654# Should be supplied in the format: key = value
655
656[kubernetes_secrets]
657# The scheduler mounts the following secrets into your workers as they are launched by the
658# scheduler. You may define as many secrets as needed and the kubernetes launcher will parse the
659# defined secrets and mount them as secret environment variables in the launched workers.
660# Secrets in this section are defined as follows
661#     <environment_variable_mount> = <kubernetes_secret_object>:<kubernetes_secret_key>
662#
663# For example if you wanted to mount a kubernetes secret key named `postgres_password` from the
664# kubernetes secret object `airflow-secret` as the environment variable `POSTGRES_PASSWORD` into
665# your workers you would follow the following format:
666#     POSTGRES_PASSWORD = airflow-secret:postgres_credentials
667#
668# Additionally you may override worker airflow settings with the AIRFLOW__<SECTION>__<KEY>
669# formatting as suppont:d by airflow normally.