potiuk commented on code in PR #28300: URL: https://github.com/apache/airflow/pull/28300#discussion_r1048325485
########## docs/apache-airflow/public-airflow-interface.rst: ########## @@ -0,0 +1,115 @@ + .. 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. + +Public Interface of Airflow +=========================== + +The Public Interface of Apache Airflow is a set of programmatic interfaces that allow developers to interact +with and access certain features of the Apache Airflow system. This can include operations such as +creating and managing DAGs (directed acyclic graphs), managing tasks and their dependencies, +and extending Airflow capabilities by writing new executors, plugins, operators and providers. The +Public Interface can be useful for building custom tools and integrations with other systems, +as well as for automating certain aspects of the Airflow workflow. + +In general, the Public Interface is an important part of the Airflow ecosystem and can be a powerful +tool for users and developers who want to extend the functionality of the system. + +You can extend Airflow in three ways: + +* By writing new custom Python code (via Operators, Plugins, Provider) +* By using the `Stable REST API <stable-rest-api-ref>`_ (based on the OpenAPI specification) +* By using the `Airflow Command Line Interface (CLI) <cli-and-env-variables-ref.rst>`_ + +How can you extend Apache Airflow with custom Python Code? +========================================================== + +Apache Airflow has a number of different Public Interfaces that allow developers to interact with various +aspects of the system. Some examples of the types of Public Interfaces exposed as Python objects +that are available in Apache Airflow include: + +* `DAG <concepts/dags>`_ (Directed Acyclic Graph) APIs, which allow developers to create, manage, + and access DAGs in Airflow. +* `Task <concepts/tasks>`_ APIs, which provide access to information about individual tasks within + a DAG, such as their dependencies and execution status. +* `Operator <concepts/operators>`_ APIs, which allows the developers to write their custom Operators. +* `Decorators <howto/create-custom-decorator>`_ APIs, which allows the developers to write their + custom decorators to make it easier to write `TaskFlow <tutorial/taskflow>`_ DAGs. +* `Secret Managers <security/secrets>`_ APIs, which allows the developers to write their custom + Secret Managers to safely access credentials and other secret configuration of their workflows. +* `Connection management <concepts/connections>`_ APIs, which allow developers to manage + connections to external systems +* `XCom <concepts/xcoms>`_, which allow developers to manage cross-task communication within Airflow. +* `Variables <concepts/variables>`_, which allow developers to manage variables within Airflow. +* `Executors <executor/index>`_, which allow developers to manage the execution of tasks within Airflow. +* `Listeners <listeners>`_, which allow developers to react to DAG/Task lifecycle events. +* `Plugins <plugins>`_, which allow developers to extend internal Airflow capabilities - add new UI + pages, custom `TimeTables <concepts/timetable>`_, `Extra Links <howto/define_extra_link>`_, + `Triggers <concept/deferring>`_. `Listeners <listeners>`_. + +What is not part of the Public Interface of Apache Airflow? +=========================================================== + +Everything not mentioned in this document should be considered as non-Public Interface. + +The users however, might have some assumptions about different parts of Airflow, thinking that +they can rely on them, so here we try to clarify and want to be explicit that they are not part of the +Public Interface: + +* `Database structure <database-erd-ref>`_ is considered to be an internal implementation + detail and you should not assume the structure is going to be maintained in + backwards-compatible way. + +* `Web UI <ui>`_ is considered to be continuously adapting and evolving for Apache Airflow and + you should not assume that the UI will remain as it is in backwards-compatible way. Views and screens + might be updated and removed in major releases without impacting backwards-compatibility. + +* `Python API <python-api-ref>`_ (except the explicitly mentioned classes below), are considered an + internal implementation details and you should not assume they will be maintained + in backwards-compatible way. + +Which classes and packages are part of the Public Interface of Apache Airflow? +============================================================================== + +The Public Interface of Airflow consists of a number of different classes and packages that provide access +to the core features and functionality of the system. + +The classes and packages that may be considered as the Public Interface include: + +* The :class:`~airflow.DAG`, which provides a way to define and manage DAGs in Airflow. +* The :class:`~airflow.models.baseoperator.BaseOperator`, which provides a way write custom operators. +* The :class:`~airflow.hooks.base.BaseHook`, which provides a way write custom hooks. +* The :class:`~airflow.models.connection.Connection`, which provides access to external service credentials and configuration. +* The :class:`~airflow.models.variable.Variable`, which provides access to Airflow configuration variables. +* The :class:`~airflow.models.xcom.XCom` which are used to access to inter-task communication data. +* The :class:`~airflow.secrets.BaseSecretsBackend` which are used to define custom secret managers. +* The :class:`~airflow.plugins_manager.AirflowPlugin` which are used to define custom plugins. +* The :class:`~airflow.triggers.base.BaseTrigger`, which are used to implement custom Custom Deferrable Operators (based on ``async.io``). +* The :class:`~airflow.decorators.base.TaskDecorator`, which provides a way write custom decorators. +* The :class:`~airflow.listeners.listener.ListenerManager` class which provides hooks that can be implemented to respond to DAG/Task lifecycle events + +.. versionadded:: 2.5 + + Listener public interface has been added in version 2.5. + +* The :class:`~airflow.executors.base_executor.BaseExecutor` - the Executors are the components of Airflow + that are responsible for executing tasks. + +.. versionadded:: 2.6 + + There are a number of different executor implementations built-in Airflow, each with its own unique + characteristics and capabilities. Executor interface was available in earlier version of Airflow but + only as of version 2.6 executors are decoupled and Airflow does not rely on built-in set of executors. Review Comment: The message is that only as 2.6 executors are truly extendable. Because they weren't before. There are certain modifications and changes in the interface (as explained and being implemented in https://cwiki.apache.org/confluence/display/AIRFLOW/AIP-51+Removing+Executor+Coupling+from+Core+Airlfow ) that allow you to implement custom executor without hittting some roadblocks. We just failed in delivering it before even if it was somewhat promised. And this is to warn users they should only target 2.6+. I want to avoid the situation that people mistakenly think they can do it in earlier versions. Of course there is the "version" selector at the top of the documentation, but many people do not realise that the feature they see there in the "stable" version are not available in their version and loose time and effort to try to make them work. And then they come up with bad feelings about Airflow, because we failed to warn them clearly enough. Just one example from last week: User thinking that breadth-first mapping is implemented in 2.3 https://apache-airflow.slack.com/archives/CCQ7EGB1P/p1670968167747709?thread_ts=1670937467.554809&cid=CCQ7EGB1P User is at 2.3.4 in Composer and cannot upgrade to 2.5.0: > User: any possibility to implement an inheritance on TaskGroup and add the "jinja interpretation mechanism" somehow?? even simplistically, just to get a {{ds_nodash}} interpretation (edited) > Jarek: No > User: RIP 10 days of work lmao I want to malke sure our users don't even start working on 2.3, 2.4, 2.5 with custom executors basing on the new documentation that's coming on 2.6 where we explicitly admit Executors are extendable. Before we hinted at it but never admitted to it. Now when we explicitly state it that users "can" do it, we should tell them they should only do it in 2.5 and explain why. Otherwise they will start working on it with earlier versions and when they fail, they will complain. We can prevent it by being explicit about it and if they complain we can link to that doc and tell them "you had a chance to read it, it's your fault". Otherwise they can tell "you have not explained this explicitly that it's only 2.6" and they will be right. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
