apache-airflow-providers-cncf-kubernetes 3.1.0__py3-none-any.whl → 10.10.0rc1__py3-none-any.whl

airflow/providers/cncf/kubernetes/executors/local_kubernetes_executor.py

@@ -0,0 +1,306 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any
+
+from deprecated import deprecated
+
+from airflow.configuration import conf
+from airflow.exceptions import AirflowProviderDeprecationWarning
+from airflow.executors.base_executor import BaseExecutor
+from airflow.providers.cncf.kubernetes.executors.kubernetes_executor import KubernetesExecutor
+from airflow.providers.cncf.kubernetes.version_compat import AIRFLOW_V_3_0_PLUS
+
+if TYPE_CHECKING:
+    from airflow.callbacks.base_callback_sink import BaseCallbackSink
+    from airflow.callbacks.callback_requests import CallbackRequest
+    from airflow.executors.base_executor import EventBufferValueType
+    from airflow.executors.local_executor import LocalExecutor
+    from airflow.models.taskinstance import (  # type: ignore[attr-defined]
+        SimpleTaskInstance,
+        TaskInstance,
+        TaskInstanceKey,
+    )
+
+    CommandType = Sequence[str]
+
+
+class LocalKubernetesExecutor(BaseExecutor):
+    """
+    Chooses between LocalExecutor and KubernetesExecutor based on the queue defined on the task.
+
+    When the task's queue is the value of ``kubernetes_queue`` in section ``[local_kubernetes_executor]``
+    of the configuration (default value: `kubernetes`), KubernetesExecutor is selected to run the task,
+    otherwise, LocalExecutor is used.
+    """
+
+    supports_ad_hoc_ti_run: bool = True
+    # TODO: Remove this attribute once providers rely on Airflow >=3.0.0
+    supports_pickling: bool = False
+    supports_sentry: bool = False
+
+    is_local: bool = False
+    is_single_threaded: bool = False
+    is_production: bool = True
+
+    serve_logs: bool = True
+
+    callback_sink: BaseCallbackSink | None = None
+
+    KUBERNETES_QUEUE = conf.get("local_kubernetes_executor", "kubernetes_queue")
+
+    def __init__(
+        self,
+        local_executor: LocalExecutor | None = None,
+        kubernetes_executor: KubernetesExecutor | None = None,
+    ):
+        if AIRFLOW_V_3_0_PLUS or not local_executor or not kubernetes_executor:
+            raise RuntimeError(
+                f"{self.__class__.__name__} does not support Airflow 3.0+. See "
+                "https://airflow.apache.org/docs/apache-airflow/stable/core-concepts/executor/index.html#using-multiple-executors-concurrently"
+                " how to use multiple executors concurrently."
+            )
+
+        super().__init__()
+        self._job_id: int | str | None = None
+        self.local_executor = local_executor
+        self.kubernetes_executor = kubernetes_executor
+        self.kubernetes_executor.kubernetes_queue = self.KUBERNETES_QUEUE
+
+    @property
+    def _task_event_logs(self):
+        self.local_executor._task_event_logs += self.kubernetes_executor._task_event_logs
+        self.kubernetes_executor._task_event_logs.clear()
+        return self.local_executor._task_event_logs
+
+    @_task_event_logs.setter
+    def _task_event_logs(self, value):
+        """Not implemented for hybrid executors."""
+
+    @property
+    def queued_tasks(self) -> dict[TaskInstanceKey, Any]:
+        """Return queued tasks from local and kubernetes executor."""
+        queued_tasks = self.local_executor.queued_tasks.copy()
+        # TODO: fix this, there is misalignment between the types of queued_tasks so it is likely wrong
+        queued_tasks.update(self.kubernetes_executor.queued_tasks)  # type: ignore[arg-type]
+
+        return queued_tasks
+
+    @queued_tasks.setter
+    def queued_tasks(self, value) -> None:
+        """Not implemented for hybrid executors."""
+
+    @property
+    def running(self) -> set[TaskInstanceKey]:
+        """Return running tasks from local and kubernetes executor."""
+        return self.local_executor.running.union(self.kubernetes_executor.running)
+
+    @running.setter
+    def running(self, value) -> None:
+        """Not implemented for hybrid executors."""
+
+    @property
+    def job_id(self) -> int | str | None:
+        """
+        Inherited attribute from BaseExecutor.
+
+        Since this is not really an executor, but a wrapper of executors
+        we implemented it as property, so we can have custom setter.
+        """
+        return self._job_id
+
+    @job_id.setter
+    def job_id(self, value: int | str | None) -> None:
+        """Expose job ID for SchedulerJob."""
+        self._job_id = value
+        self.kubernetes_executor.job_id = value
+        self.local_executor.job_id = value
+
+    def start(self) -> None:
+        """Start local and kubernetes executor."""
+        self.log.info("Starting local and Kubernetes Executor")
+        self.local_executor.start()
+        self.kubernetes_executor.start()
+
+    @property
+    def slots_available(self) -> int:
+        """Number of new tasks this executor instance can accept."""
+        return self.local_executor.slots_available
+
+    @property
+    def slots_occupied(self):
+        """Number of tasks this executor instance is currently managing."""
+        return len(self.running) + len(self.queued_tasks)
+
+    def queue_command(
+        self,
+        task_instance: TaskInstance,
+        command: CommandType,
+        priority: int = 1,
+        queue: str | None = None,
+    ) -> None:
+        """Queues command via local or kubernetes executor."""
+        executor = self._router(task_instance)
+        self.log.debug("Using executor: %s for %s", executor.__class__.__name__, task_instance.key)
+        executor.queue_command(task_instance, command, priority, queue)  # type: ignore[union-attr]
+
+    def queue_task_instance(
+        self,
+        task_instance: TaskInstance,
+        mark_success: bool = False,
+        ignore_all_deps: bool = False,
+        ignore_depends_on_past: bool = False,
+        wait_for_past_depends_before_skipping: bool = False,
+        ignore_task_deps: bool = False,
+        ignore_ti_state: bool = False,
+        pool: str | None = None,
+        cfg_path: str | None = None,
+        **kwargs,
+    ) -> None:
+        """Queues task instance via local or kubernetes executor."""
+        from airflow.models.taskinstance import SimpleTaskInstance  # type: ignore[attr-defined]
+
+        executor = self._router(SimpleTaskInstance.from_ti(task_instance))
+        self.log.debug(
+            "Using executor: %s to queue_task_instance for %s", executor.__class__.__name__, task_instance.key
+        )
+
+        if not hasattr(task_instance, "pickle_id"):
+            del kwargs["pickle_id"]
+
+        executor.queue_task_instance(  # type: ignore[union-attr]
+            task_instance=task_instance,
+            mark_success=mark_success,
+            ignore_all_deps=ignore_all_deps,
+            ignore_depends_on_past=ignore_depends_on_past,
+            wait_for_past_depends_before_skipping=wait_for_past_depends_before_skipping,
+            ignore_task_deps=ignore_task_deps,
+            ignore_ti_state=ignore_ti_state,
+            pool=pool,
+            cfg_path=cfg_path,
+            **kwargs,
+        )
+
+    def get_task_log(self, ti: TaskInstance, try_number: int) -> tuple[list[str], list[str]]:
+        """Fetch task log from kubernetes executor."""
+        if ti.queue == self.kubernetes_executor.kubernetes_queue:
+            return self.kubernetes_executor.get_task_log(ti=ti, try_number=try_number)
+        return [], []
+
+    def has_task(self, task_instance: TaskInstance) -> bool:
+        """
+        Check if a task is either queued or running in either local or kubernetes executor.
+
+        :param task_instance: TaskInstance
+        :return: True if the task is known to this executor
+        """
+        return self.local_executor.has_task(task_instance) or self.kubernetes_executor.has_task(task_instance)
+
+    def heartbeat(self) -> None:
+        """Heartbeat sent to trigger new jobs in local and kubernetes executor."""
+        self.local_executor.heartbeat()
+        self.kubernetes_executor.heartbeat()
+
+    def get_event_buffer(
+        self, dag_ids: list[str] | None = None
+    ) -> dict[TaskInstanceKey, EventBufferValueType]:
+        """
+        Return and flush the event buffer from local and kubernetes executor.
+
+        :param dag_ids: dag_ids to return events for, if None returns all
+        :return: a dict of events
+        """
+        cleared_events_from_local = self.local_executor.get_event_buffer(dag_ids)
+        cleared_events_from_kubernetes = self.kubernetes_executor.get_event_buffer(dag_ids)
+
+        return {**cleared_events_from_local, **cleared_events_from_kubernetes}
+
+    def try_adopt_task_instances(self, tis: Sequence[TaskInstance]) -> Sequence[TaskInstance]:
+        """
+        Try to adopt running task instances that have been abandoned by a SchedulerJob dying.
+
+        Anything that is not adopted will be cleared by the scheduler (and then become eligible for
+        re-scheduling)
+
+        :return: any TaskInstances that were unable to be adopted
+        """
+        local_tis = [ti for ti in tis if ti.queue != self.KUBERNETES_QUEUE]
+        kubernetes_tis = [ti for ti in tis if ti.queue == self.KUBERNETES_QUEUE]
+        return [
+            *self.local_executor.try_adopt_task_instances(local_tis),
+            *self.kubernetes_executor.try_adopt_task_instances(kubernetes_tis),
+        ]
+
+    @deprecated(
+        reason="Replaced by function `revoke_task`. Upgrade airflow core to make this go away.",
+        category=AirflowProviderDeprecationWarning,
+        action="ignore",  # ignoring since will get warning from the nested executors
+    )
+    def cleanup_stuck_queued_tasks(self, tis: list[TaskInstance]) -> list[str]:
+        # LocalExecutor doesn't have a cleanup_stuck_queued_tasks method, so we
+        # will only run KubernetesExecutor's
+        kubernetes_tis = [ti for ti in tis if ti.queue == self.KUBERNETES_QUEUE]
+        return self.kubernetes_executor.cleanup_stuck_queued_tasks(kubernetes_tis)
+
+    def revoke_task(self, *, ti: TaskInstance):
+        if ti.queue == self.KUBERNETES_QUEUE:
+            self.kubernetes_executor.revoke_task(ti=ti)
+
+    def end(self) -> None:
+        """End local and kubernetes executor."""
+        self.local_executor.end()
+        self.kubernetes_executor.end()
+
+    def terminate(self) -> None:
+        """Terminate local and kubernetes executor."""
+        self.local_executor.terminate()
+        self.kubernetes_executor.terminate()
+
+    def _router(self, simple_task_instance: SimpleTaskInstance) -> LocalExecutor | KubernetesExecutor:
+        """
+        Return either local_executor or kubernetes_executor.
+
+        :param simple_task_instance: SimpleTaskInstance
+        :return: local_executor or kubernetes_executor
+        """
+        if simple_task_instance.queue == self.KUBERNETES_QUEUE:
+            return self.kubernetes_executor
+        return self.local_executor
+
+    def debug_dump(self) -> None:
+        """Debug dump; called in response to SIGUSR2 by the scheduler."""
+        self.log.info("Dumping LocalExecutor state")
+        self.local_executor.debug_dump()
+        self.log.info("Dumping KubernetesExecutor state")
+        self.kubernetes_executor.debug_dump()
+
+    def send_callback(self, request: CallbackRequest) -> None:
+        """
+        Send callback for execution.
+
+        :param request: Callback request to be executed.
+        """
+        if not self.callback_sink:
+            raise ValueError("Callback sink is not ready.")
+        self.callback_sink.send(request)
+
+    @staticmethod
+    def get_cli_commands() -> list:
+        return KubernetesExecutor.get_cli_commands()

airflow/providers/cncf/kubernetes/get_provider_info.py

@@ -15,76 +15,275 @@
 # specific language governing permissions and limitations
 # under the License.
 
-# NOTE! THIS FILE IS AUTOMATICALLY GENERATED AND WILL BE
-# OVERWRITTEN WHEN PREPARING PACKAGES.
+# NOTE! THIS FILE IS AUTOMATICALLY GENERATED AND WILL BE OVERWRITTEN!
 #
-# IF YOU WANT TO MODIFY IT, YOU SHOULD MODIFY THE TEMPLATE
-# `get_provider_info_TEMPLATE.py.jinja2` IN the `provider_packages` DIRECTORY
+# IF YOU WANT TO MODIFY THIS FILE, YOU SHOULD MODIFY THE TEMPLATE
+# `get_provider_info_TEMPLATE.py.jinja2` IN the `dev/breeze/src/airflow_breeze/templates` DIRECTORY
+
 
 def get_provider_info():
     return {
-        'package-name': 'apache-airflow-providers-cncf-kubernetes',
-        'name': 'Kubernetes',
-        'description': '`Kubernetes <https://kubernetes.io/>`__\n',
-        'versions': [
-            '3.1.0',
-            '3.0.2',
-            '3.0.1',
-            '3.0.0',
-            '2.2.0',
-            '2.1.0',
-            '2.0.3',
-            '2.0.2',
-            '2.0.1',
-            '2.0.0',
-            '1.2.0',
-            '1.1.0',
-            '1.0.2',
-            '1.0.1',
-            '1.0.0',
-        ],
-        'additional-dependencies': ['apache-airflow>=2.1.0'],
-        'integrations': [
+        "package-name": "apache-airflow-providers-cncf-kubernetes",
+        "name": "Kubernetes",
+        "description": "`Kubernetes <https://kubernetes.io/>`__\n",
+        "integrations": [
             {
-                'integration-name': 'Kubernetes',
-                'external-doc-url': 'https://kubernetes.io/',
-                'how-to-guide': ['/docs/apache-airflow-providers-cncf-kubernetes/operators.rst'],
-                'logo': '/integration-logos/kubernetes/Kubernetes.png',
-                'tags': ['software'],
+                "integration-name": "Kubernetes",
+                "external-doc-url": "https://kubernetes.io/",
+                "how-to-guide": ["/docs/apache-airflow-providers-cncf-kubernetes/operators.rst"],
+                "logo": "/docs/integration-logos/Kubernetes.png",
+                "tags": ["software"],
             },
             {
-                'integration-name': 'Spark on Kubernetes',
-                'external-doc-url': 'https://github.com/GoogleCloudPlatform/spark-on-k8s-operator',
-                'logo': '/integration-logos/kubernetes/Spark-On-Kubernetes.png',
-                'tags': ['software'],
+                "integration-name": "Spark on Kubernetes",
+                "external-doc-url": "https://github.com/GoogleCloudPlatform/spark-on-k8s-operator",
+                "logo": "/docs/integration-logos/Spark-On-Kubernetes.png",
+                "tags": ["software"],
             },
         ],
-        'operators': [
+        "operators": [
             {
-                'integration-name': 'Kubernetes',
-                'python-modules': [
-                    'airflow.providers.cncf.kubernetes.operators.kubernetes_pod',
-                    'airflow.providers.cncf.kubernetes.operators.spark_kubernetes',
+                "integration-name": "Kubernetes",
+                "python-modules": [
+                    "airflow.providers.cncf.kubernetes.operators.custom_object_launcher",
+                    "airflow.providers.cncf.kubernetes.operators.kueue",
+                    "airflow.providers.cncf.kubernetes.operators.pod",
+                    "airflow.providers.cncf.kubernetes.operators.spark_kubernetes",
+                    "airflow.providers.cncf.kubernetes.operators.resource",
+                    "airflow.providers.cncf.kubernetes.operators.job",
                 ],
             }
         ],
-        'sensors': [
+        "sensors": [
             {
-                'integration-name': 'Kubernetes',
-                'python-modules': ['airflow.providers.cncf.kubernetes.sensors.spark_kubernetes'],
+                "integration-name": "Kubernetes",
+                "python-modules": ["airflow.providers.cncf.kubernetes.sensors.spark_kubernetes"],
             }
         ],
-        'hooks': [
+        "hooks": [
             {
-                'integration-name': 'Kubernetes',
-                'python-modules': ['airflow.providers.cncf.kubernetes.hooks.kubernetes'],
+                "integration-name": "Kubernetes",
+                "python-modules": ["airflow.providers.cncf.kubernetes.hooks.kubernetes"],
             }
         ],
-        'hook-class-names': ['airflow.providers.cncf.kubernetes.hooks.kubernetes.KubernetesHook'],
-        'connection-types': [
+        "triggers": [
             {
-                'hook-class-name': 'airflow.providers.cncf.kubernetes.hooks.kubernetes.KubernetesHook',
-                'connection-type': 'kubernetes',
+                "integration-name": "Kubernetes",
+                "python-modules": [
+                    "airflow.providers.cncf.kubernetes.triggers.pod",
+                    "airflow.providers.cncf.kubernetes.triggers.job",
+                ],
             }
         ],
+        "connection-types": [
+            {
+                "hook-class-name": "airflow.providers.cncf.kubernetes.hooks.kubernetes.KubernetesHook",
+                "connection-type": "kubernetes",
+            }
+        ],
+        "task-decorators": [
+            {
+                "class-name": "airflow.providers.cncf.kubernetes.decorators.kubernetes.kubernetes_task",
+                "name": "kubernetes",
+            },
+            {
+                "class-name": "airflow.providers.cncf.kubernetes.decorators.kubernetes_cmd.kubernetes_cmd_task",
+                "name": "kubernetes_cmd",
+            },
+        ],
+        "config": {
+            "local_kubernetes_executor": {
+                "description": "This section only applies if you are using the ``LocalKubernetesExecutor`` in\n``[core]`` section above\n",
+                "options": {
+                    "kubernetes_queue": {
+                        "description": "Define when to send a task to ``KubernetesExecutor`` when using ``LocalKubernetesExecutor``.\nWhen the queue of a task is the value of ``kubernetes_queue`` (default ``kubernetes``),\nthe task is executed via ``KubernetesExecutor``,\notherwise via ``LocalExecutor``\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": "kubernetes",
+                    }
+                },
+            },
+            "kubernetes_executor": {
+                "description": None,
+                "options": {
+                    "api_client_retry_configuration": {
+                        "description": "Kwargs to override the default urllib3 Retry used in the kubernetes API client\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": '{ "total": 3, "backoff_factor": 0.5 }',
+                        "default": "",
+                    },
+                    "logs_task_metadata": {
+                        "description": "Flag to control the information added to kubernetes executor logs for better traceability\n",
+                        "version_added": None,
+                        "type": "boolean",
+                        "example": None,
+                        "default": "False",
+                    },
+                    "pod_template_file": {
+                        "description": "Path to the YAML pod file that forms the basis for KubernetesExecutor workers.\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": "",
+                        "see_also": ":ref:`concepts:pod_template_file`",
+                    },
+                    "worker_container_repository": {
+                        "description": "The repository of the Kubernetes Image for the Worker to Run\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": "",
+                        "deprecated": True,
+                        "deprecation_reason": "This configuration is deprecated. Use `pod_template_file` to specify container image instead.\n",
+                    },
+                    "worker_container_tag": {
+                        "description": "The tag of the Kubernetes Image for the Worker to Run\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": "",
+                        "deprecated": True,
+                        "deprecation_reason": "This configuration is deprecated. Use `pod_template_file` to specify the image tag instead.\n",
+                    },
+                    "namespace": {
+                        "description": "The Kubernetes namespace where airflow workers should be created. Defaults to ``default``\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": "default",
+                        "deprecated": True,
+                        "deprecation_reason": "This configuration is deprecated. Use `pod_template_file` to specify namespace instead.\n",
+                    },
+                    "delete_worker_pods": {
+                        "description": "If True, all worker pods will be deleted upon termination\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": "True",
+                    },
+                    "delete_worker_pods_on_failure": {
+                        "description": "If False (and delete_worker_pods is True),\nfailed worker pods will not be deleted so users can investigate them.\nThis only prevents removal of worker pods where the worker itself failed,\nnot when the task it ran failed.\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": "False",
+                    },
+                    "worker_pod_pending_fatal_container_state_reasons": {
+                        "description": "If the worker pods are in a pending state due to a fatal container\nstate reasons, then fail the task and delete the worker pod\nif delete_worker_pods is True and delete_worker_pods_on_failure is True.\n",
+                        "version_added": "8.1.0",
+                        "type": "string",
+                        "example": None,
+                        "default": "CreateContainerConfigError,ErrImagePull,CreateContainerError,ImageInspectError,InvalidImageName",
+                    },
+                    "worker_pods_creation_batch_size": {
+                        "description": 'Number of Kubernetes Worker Pod creation calls per scheduler loop.\nNote that the current default of "1" will only launch a single pod\nper-heartbeat. It is HIGHLY recommended that users increase this\nnumber to match the tolerance of their kubernetes cluster for\nbetter performance.\n',
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": "1",
+                    },
+                    "multi_namespace_mode": {
+                        "description": "Allows users to launch pods in multiple namespaces.\nWill require creating a cluster-role for the scheduler,\nor use multi_namespace_mode_namespace_list configuration.\n",
+                        "version_added": None,
+                        "type": "boolean",
+                        "example": None,
+                        "default": "False",
+                    },
+                    "multi_namespace_mode_namespace_list": {
+                        "description": "If multi_namespace_mode is True while scheduler does not have a cluster-role,\ngive the list of namespaces where the scheduler will schedule jobs\nScheduler needs to have the necessary permissions in these namespaces.\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": "",
+                    },
+                    "in_cluster": {
+                        "description": "Use the service account kubernetes gives to pods to connect to kubernetes cluster.\nIt's intended for clients that expect to be running inside a pod running on kubernetes.\nIt will raise an exception if called from a process not running in a kubernetes environment.\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": "True",
+                    },
+                    "cluster_context": {
+                        "description": "When running with in_cluster=False change the default cluster_context or config_file\noptions to Kubernetes client. Leave blank these to use default behaviour like ``kubectl`` has.\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": None,
+                    },
+                    "config_file": {
+                        "description": "Path to the kubernetes configfile to be used when ``in_cluster`` is set to False\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": None,
+                    },
+                    "kube_client_request_args": {
+                        "description": "Keyword parameters to pass while calling a kubernetes client core_v1_api methods\nfrom Kubernetes Executor provided as a single line formatted JSON dictionary string.\nList of supported params are similar for all core_v1_apis, hence a single config\nvariable for all apis. See:\nhttps://raw.githubusercontent.com/kubernetes-client/python/41f11a09995efcd0142e25946adc7591431bfb2f/kubernetes/client/api/core_v1_api.py\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": "",
+                    },
+                    "delete_option_kwargs": {
+                        "description": "Optional keyword arguments to pass to the ``delete_namespaced_pod`` kubernetes client\n``core_v1_api`` method when using the Kubernetes Executor.\nThis should be an object and can contain any of the options listed in the ``v1DeleteOptions``\nclass defined here:\nhttps://github.com/kubernetes-client/python/blob/41f11a09995efcd0142e25946adc7591431bfb2f/kubernetes/client/models/v1_delete_options.py#L19\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": '{"grace_period_seconds": 10}',
+                        "default": "",
+                    },
+                    "enable_tcp_keepalive": {
+                        "description": "Enables TCP keepalive mechanism. This prevents Kubernetes API requests to hang indefinitely\nwhen idle connection is time-outed on services like cloud load balancers or firewalls.\n",
+                        "version_added": None,
+                        "type": "boolean",
+                        "example": None,
+                        "default": "True",
+                    },
+                    "tcp_keep_idle": {
+                        "description": "When the `enable_tcp_keepalive` option is enabled, TCP probes a connection that has\nbeen idle for `tcp_keep_idle` seconds.\n",
+                        "version_added": None,
+                        "type": "integer",
+                        "example": None,
+                        "default": "120",
+                    },
+                    "tcp_keep_intvl": {
+                        "description": "When the `enable_tcp_keepalive` option is enabled, if Kubernetes API does not respond\nto a keepalive probe, TCP retransmits the probe after `tcp_keep_intvl` seconds.\n",
+                        "version_added": None,
+                        "type": "integer",
+                        "example": None,
+                        "default": "30",
+                    },
+                    "tcp_keep_cnt": {
+                        "description": "When the `enable_tcp_keepalive` option is enabled, if Kubernetes API does not respond\nto a keepalive probe, TCP retransmits the probe `tcp_keep_cnt number` of times before\na connection is considered to be broken.\n",
+                        "version_added": None,
+                        "type": "integer",
+                        "example": None,
+                        "default": "6",
+                    },
+                    "verify_ssl": {
+                        "description": "Set this to false to skip verifying SSL certificate of Kubernetes python client.\n",
+                        "version_added": None,
+                        "type": "boolean",
+                        "example": None,
+                        "default": "True",
+                    },
+                    "ssl_ca_cert": {
+                        "description": "Path to a CA certificate to be used by the Kubernetes client to verify the server's SSL certificate.\n",
+                        "version_added": None,
+                        "type": "string",
+                        "example": None,
+                        "default": "",
+                    },
+                    "task_publish_max_retries": {
+                        "description": "The Maximum number of retries for queuing the task to the kubernetes scheduler when\nfailing due to Kube API exceeded quota errors before giving up and marking task as failed.\n-1 for unlimited times.\n",
+                        "version_added": None,
+                        "type": "integer",
+                        "example": None,
+                        "default": "0",
+                    },
+                },
+            },
+        },
+        "executors": ["airflow.providers.cncf.kubernetes.executors.kubernetes_executor.KubernetesExecutor"],
     }