API 參考 · Airflow 中文文檔

# API 參考 ## 運營商運算符允許生成某些類型的任務，這些任務在實例化時成為 DAG 中的節點。所有運算符都派生自`BaseOperator` ，并以這種方式繼承許多屬性和方法。有關更多詳細信息，請參閱[BaseOperator](31)文檔。有三種主要類型的運營商： * 執行操作的操作員，或告訴其他系統執行操作的操作員 * **傳輸**操作員將數據從一個系統移動到另一個系 * **傳感器**是某種類型的運算符，它將一直運行直到滿足某個標準。示例包括在 HDFS 或 S3 中登陸的特定文件，在 Hive 中顯示的分區或當天的特定時間。傳感器派生自`BaseSensorOperator`并在指定的`poke_interval`運行 poke 方法，直到它返回`True` 。 ### BaseOperator 所有運算符都派生自`BaseOperator`并通過繼承獲得許多功能。由于這是引擎的核心，因此值得花時間了解`BaseOperator`的參數，以了解可在 DAG 中使用的原始功能。 ```py class airflow.models.BaseOperator(task_id, owner='Airflow', email=None, email_on_retry=True, email_on_failure=True, retries=0, retry_delay=datetime.timedelta(0, 300), retry_exponential_backoff=False, max_retry_delay=None, start_date=None, end_date=None, schedule_interval=None, depends_on_past=False, wait_for_downstream=False, dag=None, params=None, default_args=None, adhoc=False, priority_weight=1, weight_rule=u'downstream', queue='default', pool=None, sla=None, execution_timeout=None, on_failure_callback=None, on_success_callback=None, on_retry_callback=None, trigger_rule=u'all_success', resources=None, run_as_user=None, task_concurrency=None, executor_config=None, inlets=None, outlets=None, *args, **kwargs) ``` 基類： `airflow.utils.log.logging_mixin.LoggingMixin` 所有運營商的抽象基類。由于運算符創建的對象成為 dag 中的節點，因此 BaseOperator 包含許多用于 dag 爬行行為的遞歸方法。要派生此類，您需要覆蓋構造函數以及“execute”方法。從此類派生的運算符應同步執行或觸發某些任務（等待完成）。運算符的示例可以是運行 Pig 作業（PigOperator）的運算符，等待分區在 Hive（HiveSensorOperator）中著陸的傳感器運算符，或者是將數據從 Hive 移動到 MySQL（Hive2MySqlOperator）的運算符。這些運算符（任務）的實例針對特定操作，運行特定腳本，函數或數據傳輸。此類是抽象的，不應實例化。實例化從這個派生的類導致創建任務對象，該對象最終成為 DAG 對象中的節點。應使用 set_upstream 和/或 set_downstream 方法設置任務依賴性。參數： * `task_id( string )` - 任務的唯一，有意義的 id * `owner( string )` - 使用 unix 用戶名的任務的所有者 * `retries( int )` - 在失敗任務之前應執行的重試次數 * `retry_delay( timedelta )` - 重試之間的延遲 * `retry_exponential_backoff( bool )` - 允許在重試之間使用指數退避算法在重試之間進行更長時間的等待（延遲將轉換為秒） * `max_retry_delay( timedelta )` - 重試之間的最大延遲間隔 * `start_date( datetime )` - 任務的`start_date` ，確定第一個任務實例的`execution_date` 。最佳做法是將 start_date 四舍五入到 DAG 的`schedule_interval` 。每天的工作在 00:00:00 有一天的 start_date，每小時的工作在特定時間的 00:00 有 start_date。請注意，Airflow 只查看最新的`execution_date`并添加`schedule_interval`以確定下一個`execution_date` 。同樣非常重要的是要注意不同任務的依賴關系需要及時排列。如果任務 A 依賴于任務 B 并且它們的 start_date 以其 execution_date 不排列的方式偏移，則永遠不會滿足 A 的依賴性。如果您希望延遲任務，例如在凌晨 2 點運行每日任務，請查看`TimeSensor`和`TimeDeltaSensor` 。我們建議不要使用動態`start_date`并建議使用固定的。有關更多信息，請閱讀有關 start_date 的 FAQ 條目。 * `end_date( datetime )` - 如果指定，則調度程序不會超出此日期 * `depends_on_past( bool )` - 當設置為 true 時，任務實例將依次運行，同時依賴上一個任務的計劃成功。允許 start_date 的任務實例運行。 * `wait_for_downstream( bool )` - 當設置為 true 時，任務 X 的實例將等待緊接上一個任務 X 實例下游的任務在運行之前成功完成。如果任務 X 的不同實例更改同一資產，并且任務 X 的下游任務使用此資產，則此操作非常有用。請注意，在使用 wait_for_downstream 的任何地方，depends_on_past 都將強制為 True。 * `queue( str )` - 運行此作業時要定位到哪個隊列。并非所有執行程序都實現隊列管理，CeleryExecutor 確實支持定位特定隊列。 * `dag( DAG )` - 對任務所附的 dag 的引用（如果有的話） * `priority_weight( int )` - 此任務相對于其他任務的優先級權重。這允許執行程序在事情得到備份時在其他任務之前觸發更高優先級的任務。 * `weight_rule( str )` - 用于任務的有效總優先級權重的加權方法。選項包括： `{ downstream | upstream | absolute }` `{ downstream | upstream | absolute }` `{ downstream | upstream | absolute }`默認為`downstream`當設置為`downstream`時，任務的有效權重是所有下游后代的總和。因此，上游任務將具有更高的權重，并且在使用正權重值時將更積極地安排。當您有多個 dag 運行實例并希望在每個 dag 可以繼續處理下游任務之前完成所有運行的所有上游任務時，這非常有用。設置為`upstream` ，有效權重是所有上游祖先的總和。這與 downtream 任務具有更高權重并且在使用正權重值時將更積極地安排相反。當你有多個 dag 運行實例并希望在啟動其他 dag 的上游任務之前完成每個 dag 時，這非常有用。設置為`absolute` ，有效權重是指定的確切`priority_weight`無需額外加權。當您確切知道每個任務應具有的優先級權重時，您可能希望這樣做。此外，當設置為`absolute` ，對于非常大的 DAGS，存在顯著加速任務創建過程的額外效果。可以將選項設置為字符串或使用靜態類`airflow.utils.WeightRule`定義的常量 * `pool( str )` - 此任務應運行的插槽池，插槽池是限制某些任務的并發性的一種方法 * `sla( datetime.timedelta )` - 作業預期成功的時間。請注意，這表示期間結束后的`timedelta` 。例如，如果您將 SLA 設置為 1 小時，則如果`2016-01-01`實例尚未成功，則調度程序將在`2016-01-02`凌晨 1:00 之后發送電子郵件。調度程序特別關注具有 SLA 的作業，并發送警報電子郵件以防止未命中。 SLA 未命中也記錄在數據庫中以供將來參考。共享相同 SLA 時間的所有任務都捆綁在一封電子郵件中，在此之后很快就會發送。 SLA 通知僅為每個任務實例發送一次且僅一次。 * `execution_timeout( datetime.timedelta )` - 執行此任務實例所允許的最長時間，如果超出它將引發并失敗。 * `on_failure_callback( callable )` - 當此任務的任務實例失敗時要調用的函數。上下文字典作為單個參數傳遞給此函數。 Context 包含對任務實例的相關對象的引用，并記錄在 API 的宏部分下。 * `on_retry_callback` - 與`on_failure_callback`非常相似，只是在重試發生時執行。 * `on_success_callback( callable )` - 與`on_failure_callback`非常相似，只是在任務成功時執行。 * `trigger_rule( str )` - 定義應用依賴項以觸發任務的規則。選項包括： `{ all_success | all_failed | all_done | one_success | one_failed | dummy}` `{ all_success | all_failed | all_done | one_success | one_failed | dummy}` `{ all_success | all_failed | all_done | one_success | one_failed | dummy}`默認為`all_success` 。可以將選項設置為字符串，也可以使用靜態類`airflow.utils.TriggerRule`定義的常量 * `resources( dict )` - 資源參數名稱（Resources 構造函數的參數名稱）與其值的映射。 * `run_as_user( str )` - 在運行任務時使用 unix 用戶名進行模擬 * `task_concurrency( int )` - 設置后，任務將能夠限制 execution_dates 之間的并發運行 * `executor_config( dict )` - 由特定執行程序解釋的其他任務級配置參數。參數由 executor 的名稱命名。 [``](31)示例：通過 KubernetesExecutor MyOperator（...，在特定的 docker 容器中運行此任務） > executor_config = {“KubernetesExecutor”： > > > {“image”：“myCustomDockerImage”}} ）`` ```py clear(**kwargs) ``` 根據指定的參數清除與任務關聯的任務實例的狀態。 ```py dag ``` 如果設置則返回運算符的 DAG，否則引發錯誤 ```py deps ``` 返回運算符的依賴項列表。這些與執行上下文依賴性的不同之處在于它們特定于任務，并且可以由子類擴展/覆蓋。 ```py downstream_list ``` @property：直接下游的任務列表 ```py execute(context) ``` 這是在創建運算符時派生的主要方法。 Context 與渲染 jinja 模板時使用的字典相同。有關更多上下文，請參閱 get_template_context。 ```py get_direct_relative_ids(upstream=False) ``` 獲取當前任務（上游或下游）的直接相對 ID。 ```py get_direct_relatives(upstream=False) ``` 獲取當前任務的直接親屬，上游或下游。 ```py get_flat_relative_ids(upstream=False, found_descendants=None) ``` 獲取上游或下游的親屬 ID 列表。 ```py get_flat_relatives(upstream=False) ``` 獲取上游或下游親屬的詳細列表。 ```py get_task_instances(session, start_date=None, end_date=None) ``` 獲取與特定日期范圍的此任務相關的一組任務實例。 ```py has_dag() ``` 如果已將運算符分配給 DAG，則返回 True。 ```py on_kill() ``` 當任務實例被殺死時，重寫此方法以清除子進程。在操作員中使用線程，子過程或多處理模塊的任何使用都需要清理，否則會留下重影過程。 ```py post_execute(context, *args, **kwargs) ``` 調用 self.execute（）后立即觸發此掛接。它傳遞執行上下文和運算符返回的任何結果。 ```py pre_execute(context, *args, **kwargs) ``` 在調用 self.execute（）之前觸發此掛鉤。 ```py prepare_template() ``` 模板化字段被其內容替換后觸發的掛鉤。如果您需要操作員在呈現模板之前更改文件的內容，則應覆蓋此方法以執行此操作。 ```py render_template(attr, content, context) ``` 從文件或直接在字段中呈現模板，并返回呈現的結果。 ```py render_template_from_field(attr, content, context, jinja_env) ``` 從字段中呈現模板。如果字段是字符串，它將只是呈現字符串并返回結果。如果它是集合或嵌套的集合集，它將遍歷結構并呈現其中的所有字符串。 ```py run(start_date=None, end_date=None, ignore_first_depends_on_past=False, ignore_ti_state=False, mark_success=False) ``` 為日期范圍運行一組任務實例。 ```py schedule_interval ``` DAG 的計劃間隔始終勝過單個任務，因此 DAG 中的任務始終排列。該任務仍然需要 schedule_interval，因為它可能未附加到 DAG。 ```py set_downstream(task_or_task_list) ``` 將任務或任務列表設置為直接位于當前任務的下游。 ```py set_upstream(task_or_task_list) ``` 將任務或任務列表設置為直接位于當前任務的上游。 ```py upstream_list ``` @property：直接上游的任務列表 ```py xcom_pull(context, task_ids=None, dag_id=None, key=u'return_value', include_prior_dates=None) ``` 請參見 TaskInstance.xcom_pull（） ```py xcom_push(context, key, value, execution_date=None) ``` 請參見 TaskInstance.xcom_push（） ### BaseSensorOperator 所有傳感器均來自`BaseSensorOperator` 。所有傳感器都在`BaseOperator`屬性之上繼承`timeout`和`poke_interval` 。 ```py class airflow.sensors.base_sensor_operator.BaseSensorOperator(poke_interval=60, timeout=604800, soft_fail=False, *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") ， `airflow.models.SkipMixin` 傳感器操作符派生自此類繼承這些屬性。 ```py Sensor operators keep executing at a time interval and succeed when ``` 如果標準超時，則會達到并且失敗。參數： * `soft_fail( bool )` - 設置為 true 以在失敗時將任務標記為 SKIPPED * `poke_interval( int )` - 作業在每次嘗試之間應等待的時間（以秒為單位） * `timeout( int )` - 任務超時和失敗前的時間（以秒為單位）。 ```py poke(context) ``` 傳感器在派生此類時定義的功能應該覆蓋。 ### 核心運營商 #### 運營商 ```py class airflow.operators.bash_operator.BashOperator(bash_command, xcom_push=False, env=None, output_encoding='utf-8', *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 執行 Bash 腳本，命令或命令集。參數： * `bash_command( string )` - 要執行的命令，命令集或對 bash 腳本（必須為'.sh'）的引用。（模板） * `xcom_push( bool )` - 如果 xcom_push 為 True，寫入 stdout 的最后一行也將在 bash 命令完成時被推送到 XCom。 * `env( dict )` - 如果 env 不是 None，它必須是一個定義新進程的環境變量的映射; 這些用于代替繼承當前進程環境，這是默認行為。（模板） ```py execute(context) ``` 在臨時目錄中執行 bash 命令，之后將對其進行清理 ```py class airflow.operators.python_operator.BranchPythonOperator(python_callable, op_args=None, op_kwargs=None, provide_context=False, templates_dict=None, templates_exts=None, *args, **kwargs) ``` 基類： [`airflow.operators.python_operator.PythonOperator`](31 "airflow.operators.python_operator.PythonOperator") ， `airflow.models.SkipMixin` 允許工作流在執行此任務后“分支”或遵循單個路徑。它派生 PythonOperator 并期望一個返回 task_id 的 Python 函數。返回的 task_id 應指向{self}下游的任務。所有其他“分支”或直接下游任務都標記為`skipped`狀態，以便這些路徑不能向前移動。 `skipped`狀態在下游被提出以允許 DAG 狀態填滿并且推斷 DAG 運行的狀態。請注意，在`depends_on_past=True`中使用`depends_on_past=True`下游的任務在邏輯上是不合理的，因為`skipped`狀態將總是導致依賴于過去成功的塊任務。 `skipped`狀態在所有直接上游任務被`skipped`地方傳播。 ```py class airflow.operators.check_operator.CheckOperator(sql, conn_id=None, *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 對 db 執行檢查。 `CheckOperator`需要一個返回單行的 SQL 查詢。第一行的每個值都使用 python `bool` cast 進行計算。如果任何值返回`False`則檢查失敗并輸出錯誤。請注意，Python bool cast 會將以下內容視為`False` ： * `False` * `0` * 空字符串（ `""` ） * 空列表（ `[]` ） * 空字典或集（ `{}` ）給定`SELECT COUNT(*) FROM foo`類的查詢，只有當 count `== 0`它才會失敗。您可以制作更復雜的查詢，例如，可以檢查表與上游源表的行數相同，或者今天的分區計數大于昨天的分區，或者一組指標是否更少 7 天平均值超過 3 個標準差。此運算符可用作管道中的數據質量檢查，并且根據您在 DAG 中的位置，您可以選擇停止關鍵路徑，防止發布可疑數據，或者側面接收電子郵件警報阻止 DAG 的進展。請注意，這是一個抽象類，需要定義 get_db_hook。而 get_db_hook 是鉤子，它從外部源獲取單個記錄。參數：`sql( string )` - 要執行的 sql。（模板） ```py class airflow.operators.docker_operator.DockerOperator(image, api_version=None, command=None, cpus=1.0, docker_url='unix://var/run/docker.sock', environment=None, force_pull=False, mem_limit=None, network_mode=None, tls_ca_cert=None, tls_client_cert=None, tls_client_key=None, tls_hostname=None, tls_ssl_version=None, tmp_dir='/tmp/airflow', user=None, volumes=None, working_dir=None, xcom_push=False, xcom_all=False, docker_conn_id=None, *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 docker 容器中執行命令。在主機上創建臨時目錄并將其裝入容器，以允許在容器中存儲超過默認磁盤大小 10GB 的文件。可以通過環境變量`AIRFLOW_TMP_DIR`訪問已安裝目錄的路徑。如果在提取映像之前需要登錄私有注冊表，則需要在 Airflow 中配置 Docker 連接，并使用參數`docker_conn_id`提供連接 ID。參數： * `image( str )` - 用于創建容器的 Docker 鏡像。 * `api_version( str )` - 遠程 API 版本。設置為`auto`以自動檢測服務器的版本。 * `command( str 或 list )` - 要在容器中運行的命令。（模板） * `cpus( float )` - 分配給容器的 CPU 數。此值乘以 1024.請參閱[https://docs.docker.com/engine/reference/run/#cpu-share-constraint](https://docs.docker.com/engine/reference/run/) * `docker_url( str )` - 運行**docker**守護程序的主機的 URL。默認為 unix：//var/run/docker.sock * `environment( dict )` - 要在容器中設置的環境變量。（模板） * `force_pull( bool )` - 每次運行時拉動泊塢窗圖像。默認值為 false。 * `mem_limit( float 或 str )` - 容器可以使用的最大內存量。浮點值（表示以字節為單位的限制）或字符串（如`128m`或`1g` 。 * `network_mode( str )` - 容器的網絡模式。 * `tls_ca_cert( str )` - 用于保護 docker 連接的 PEM 編碼證書頒發機構的路徑。 * `tls_client_cert( str )` - 用于驗證 docker 客戶端的 PEM 編碼證書的路徑。 * `tls_client_key( str )` - 用于驗證 docker 客戶端的 PEM 編碼密鑰的路徑。 * `tls_hostname( str 或 bool )` - 與**docker**服務器證書匹配的主機名或 False 以禁用檢查。 * `tls_ssl_version( str )` - 與 docker 守護程序通信時使用的 SSL 版本。 * `tmp_dir( str )` - 將容器內的掛載點掛載到操作員在主機上創建的臨時目錄。該路徑也可通過容器內的環境變量`AIRFLOW_TMP_DIR`獲得。 * `user( int 或 str )` - docker 容器內的默認用戶。 * `卷` - 要裝入容器的卷列表，例如`['/host/path:/container/path', '/host/path2:/container/path2:ro']` 。 * `working_dir( str )` - 在容器上設置的工作目錄（相當于-w 切換 docker 客戶端） * `xcom_push( bool )` - 是否會使用 XCom 將 stdout 推送到下一步。默認值為 False。 * `xcom_all( bool )` - 推送所有標準輸出或最后一行。默認值為 False（最后一行）。 * `docker_conn_id( str )` - 要使用的 Airflow 連接的 ID ```py class airflow.operators.dummy_operator.DummyOperator(*args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 操作員確實沒什么。它可用于對 DAG 中的任務進行分組。 ```py class airflow.operators.druid_check_operator.DruidCheckOperator(sql, druid_broker_conn_id='druid_broker_default', *args, **kwargs) ``` 基類： [`airflow.operators.check_operator.CheckOperator`](31 "airflow.operators.check_operator.CheckOperator") 對德魯伊進行檢查。 `DruidCheckOperator`需要一個返回單行的 SQL 查詢。第一行的每個值都使用 python `bool` cast 進行計算。如果任何值返回`False`則檢查失敗并輸出錯誤。請注意，Python bool cast 會將以下內容視為`False` ： * `False` * `0` * 空字符串（ `""` ） * 空列表（ `[]` ） * 空字典或集（ `{}` ）給定`SELECT COUNT(*) FROM foo`類的查詢，只有當 count `== 0`它才會失敗。您可以制作更復雜的查詢，例如，可以檢查表與上游源表的行數相同，或者今天的分區計數大于昨天的分區，或者一組指標是否更少 7 天平均值超過 3 個標準差。此運算符可用作管道中的數據質量檢查，并且根據您在 DAG 中的位置，您可以選擇停止關鍵路徑，防止發布可疑數據，或者在旁邊接收電子郵件替代品阻止 DAG 的進展。參數： * `sql( string )` - 要執行的 sql * `druid_broker_conn_id( string )` - 對德魯伊經紀人的提及 ```py get_db_hook() ``` 返回德魯伊 db api 鉤子。 ```py get_first(sql) ``` 執行德魯伊 sql 到德魯伊經紀人并返回第一個結果行。參數：`sql( str )` - 要執行的 sql 語句（str） ```py class airflow.operators.email_operator.EmailOperator(to, subject, html_content, files=None, cc=None, bcc=None, mime_subtype='mixed', mime_charset='us_ascii', *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 發送電子郵件。參數： * `to( list 或 string （逗號或分號分隔） )` - 要發送電子郵件的電子郵件列表。（模板） * `subject( string )` - 電子郵件的主題行。（模板） * `html_content( string )` - 電子郵件的內容，允許使用 html 標記。（模板） * `files( list )` - 要在電子郵件中附加的文件名 * `cc( list 或 string _（逗號或分號分隔） )` - 要在 CC 字段中添加的收件人列表 * `密件抄送( list 或 string （逗號或分號分隔） )` - 要在 BCC 字段中添加的收件人列表 * `mime_subtype( string )` - MIME 子內容類型 * `mime_charset( string )` - 添加到 Content-Type 標頭的字符集參數。 ```py class airflow.operators.generic_transfer.GenericTransfer(sql, destination_table, source_conn_id, destination_conn_id, preoperator=None, *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從連接移動到另一個連接，假設它們都在各自的鉤子中提供所需的方法。源鉤子需要公開`get_records`方法，目標是`insert_rows`方法。這適用于適合內存的小型數據集。參數： * `sql( str )` - 針對源數據庫執行的 SQL 查詢。（模板） * `destination_table( str )` - 目標表。（模板） * `source_conn_id( str )` - 源連接 * `destination_conn_id( str )` - 源連接 * `preoperator( str 或 list[str] )` - sql 語句或在加載數據之前要執行的語句列表。（模板） ```py class airflow.operators.hive_to_druid.HiveToDruidTransfer(sql, druid_datasource, ts_dim, metric_spec=None, hive_cli_conn_id='hive_cli_default', druid_ingest_conn_id='druid_ingest_default', metastore_conn_id='metastore_default', hadoop_dependency_coordinates=None, intervals=None, num_shards=-1, target_partition_size=-1, query_granularity='NONE', segment_granularity='DAY', hive_tblproperties=None, *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從 Hive 移動到 Druid，[del]注意到現在數據在被推送到 Druid 之前被加載到內存中，因此該運算符應該用于少量數據。[/ del] 參數： * `sql( str )` - 針對 Druid 數據庫執行的 SQL 查詢。（模板） * `druid_datasource( str )` - 您想要在德魯伊中攝取的數據源 * `ts_dim( str )` - 時間戳維度 * `metric_spec( list )` - 您要為數據定義的指標 * `hive_cli_conn_id( str )` - 配置單元連接 ID * `druid_ingest_conn_id( str )` - 德魯伊攝取連接 ID * `metastore_conn_id( str )` - Metastore 連接 ID * `hadoop_dependency_coordinates( list[str] )` - 用于擠壓攝取 json 的坐標列表 * `interval( list )` - 定義段的時間間隔列表，按原樣傳遞給 json 對象。（模板） * `hive_tblproperties( dict )` - 用于登臺表的 hive 中 tblproperties 的其他屬性 ```py construct_ingest_query(static_path, columns) ``` 構建 HDFS TSV 負載的接收查詢。參數： * `static_path( str )` - 數據所在的 hdfs 上的路徑 * `columns( list )` - 所有可用列的列表 ```py class airflow.operators.hive_to_mysql.HiveToMySqlTransfer(sql, mysql_table, hiveserver2_conn_id='hiveserver2_default', mysql_conn_id='mysql_default', mysql_preoperator=None, mysql_postoperator=None, bulk_load=False, *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從 Hive 移動到 MySQL，請注意，目前數據在被推送到 MySQL 之前已加載到內存中，因此該運算符應該用于少量數據。參數： * `sql( str )` - 對 Hive 服務器執行的 SQL 查詢。（模板） * `mysql_table( str )` - 目標 MySQL 表，使用點表示法來定位特定數據庫。（模板） * `mysql_conn_id( str )` - 源碼 mysql 連接 * `hiveserver2_conn_id( str )` - 目標配置單元連接 * `mysql_preoperator( str )` - 在導入之前對 mysql 運行的 sql 語句，通常用于截斷刪除代替進入的數據，允許任務是冪等的（運行任務兩次不會加倍數據）。（模板） * `mysql_postoperator( str )` - 導入后針對 mysql 運行的 sql 語句，通常用于將數據從登臺移動到生產并發出清理命令。（模板） * `bulk_load( bool )` - 使用 bulk_load 選項的標志。這使用 LOAD DATA LOCAL INFILE 命令直接從制表符分隔的文本文件加載 mysql。此選項需要為目標 MySQL 連接提供額外的連接參數：{'local_infile'：true}。 ```py class airflow.operators.hive_to_samba_operator.Hive2SambaOperator(hql, destination_filepath, samba_conn_id='samba_default', hiveserver2_conn_id='hiveserver2_default', *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在特定的 Hive 數據庫中執行 hql 代碼，并將查詢結果作為 csv 加載到 Samba 位置。參數： * `hql( string )` - 要導出的 hql。（模板） * `hiveserver2_conn_id( string )` - 對 hiveserver2 服務的引用 * `samba_conn_id( string )` - 對 samba 目標的引用 ```py class airflow.operators.hive_operator.HiveOperator(hql, hive_cli_conn_id=u'hive_cli_default', schema=u'default', hiveconfs=None, hiveconf_jinja_translate=False, script_begin_tag=None, run_as_owner=False, mapred_queue=None, mapred_queue_priority=None, mapred_job_name=None, *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在特定的 Hive 數據庫中執行 hql 代碼或 hive 腳本。參數： * `hql( string )` - 要執行的 hql。請注意，您還可以使用（模板）配置單元腳本的 dag 文件中的相對路徑。（模板） * `hive_cli_conn_id( string )` - 對 Hive 數據庫的引用。（模板） * `hiveconfs( dict )` - 如果已定義，這些鍵值對將作為`-hiveconf "key"="value"`傳遞給 hive * `hiveconf_jinja_translate( _boolean_ )` - 當為 True 時，hiveconf-type 模板$ {var}被翻譯成 jinja-type templating {{var}}，$ {hiveconf：var}被翻譯成 jinja-type templating {{var}}。請注意，您可能希望將此選項與`DAG(user_defined_macros=myargs)`參數一起使用。查看 DAG 對象文檔以獲取更多詳細信息。 * `script_begin_tag( str )` - 如果已定義，運算符將在第一次出現`script_begin_tag`之前刪除腳本的一部分 * `mapred_queue( string )` - Hadoop CapacityScheduler 使用的隊列。（模板） * `mapred_queue_priority( string )` - CapacityScheduler 隊列中的優先級。可能的設置包括：VERY_HIGH，HIGH，NORMAL，LOW，VERY_LOW * `mapred_job_name( string )` - 此名稱將出現在 jobtracker 中。這可以使監控更容易。 ```py class airflow.operators.hive_stats_operator.HiveStatsCollectionOperator(table, partition, extra_exprs=None, col_blacklist=None, assignment_func=None, metastore_conn_id='metastore_default', presto_conn_id='presto_default', mysql_conn_id='airflow_db', *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 使用動態生成的 Presto 查詢收集分區統計信息，將統計信息插入到具有此格式的 MySql 表中。如果重新運行相同的日期/分區，統計信息將覆蓋自己。 ```py CREATE TABLE hive_stats ( ds VARCHAR ( 16 ), table_name VARCHAR ( 500 ), metric VARCHAR ( 200 ), value BIGINT ); ``` 參數： * `table( str )` - 源表，格式為`database.table_name` 。（模板） * `partition( dict{col:value} )` - 源分區。（模板） * `extra_exprs( dict )` - 針對表運行的表達式，其中鍵是度量標準名稱，值是 Presto 兼容表達式 * `col_blacklist( list )` - 列入黑名單的列表，考慮列入黑名單，大型 json 列，...... * `assignment_func( function )` - 接收列名和類型的函數，返回度量標準名稱和 Presto 表達式的 dict。如果返回 None，則應用全局默認值。如果返回空字典，則不會為該列計算統計信息。 ```py class airflow.operators.check_operator.IntervalCheckOperator(table, metrics_thresholds, date_filter_column='ds', days_back=-7, conn_id=None, *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 檢查作為 SQL 表達式給出的度量值是否在 days_back 之前的某個容差范圍內。請注意，這是一個抽象類，需要定義 get_db_hook。而 get_db_hook 是鉤子，它從外部源獲取單個記錄。參數： * `table( str )` - 表名 * `days_back( int )` - ds 與我們要檢查的 ds 之間的天數。默認為 7 天 * `metrics_threshold( dict )` - 由指標索引的比率字典 ```py class airflow.operators.jdbc_operator.JdbcOperator(sql, jdbc_conn_id='jdbc_default', autocommit=False, parameters=None, *args, **kwargs) ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 使用 jdbc 驅動程序在數據庫中執行 sql 代碼。需要 jaydebeapi。參數： * `jdbc_conn_id( string )` - 對預定義數據庫的引用 * `sql(可以接收表示 sql 語句的 str，list[str]（sql 語句）或模板文件的引用。模板引用由以 '.sql' 結尾的 str 識別)` - 要執行的 sql 代碼。（模板） ```py class airflow.operators.latest_only_operator.LatestOnlyOperator(task_id, owner='Airflow', email=None, email_on_retry=True, email_on_failure=True, retries=0, retry_delay=datetime.timedelta(0, 300), retry_exponential_backoff=False, max_retry_delay=None, start_date=None, end_date=None, schedule_interval=None, depends_on_past=False, wait_for_downstream=False, dag=None, params=None, default_args=None, adhoc=False, priority_weight=1, weight_rule=u'downstream', queue='default', pool=None, sla=None, execution_timeout=None, on_failure_callback=None, on_success_callback=None, on_retry_callback=None, trigger_rule=u'all_success', resources=None, run_as_user=None, task_concurrency=None, executor_config=None, inlets=None, outlets=None, *args, **kwargs) ``` 基類：[`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator")，`airflow.models.SkipMixin` 允許工作流跳過在最近的計劃間隔期間未運行的任務。如果任務在最近的計劃間隔之外運行，則將跳過所有直接下游任務。 ```py class airflow.operators.mssql_operator.MsSqlOperator（sql，mssql_conn_id ='mssql_default'，parameters = None，autocommit = False，database = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在特定的 Microsoft SQL 數據庫中執行 sql 代碼參數： * `mssql_conn_id(string)` - 對特定 mssql 數據庫的引用 * `sql(_ 指向擴展名為.sql 的模板文件的 _string 或 _ 字符串。_ _（_ _ 模板化 _ _）_)` - 要執行的 sql 代碼 * `database(string)` - 覆蓋連接中定義的數據庫的數據庫名稱 ```py class airflow.operators.mssql_to_hive.MsSqlToHiveTransfer（sql，hive_table，create = True，recreate = False，partition = None，delimiter = u'x01'，mssql_conn_id ='mssql_default'，hive_cli_conn_id ='hive_cli_default'，tblproperties = None，* args ，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從 Microsoft SQL Server 移動到 Hive。操作員針對 Microsoft SQL Server 運行查詢，在將文件加載到 Hive 表之前將其存儲在本地。如果將`create`或`recreate`參數設置為`True`，則生成 a 和語句。從游標的元數據推斷出 Hive 數據類型。請注意，在 Hive 中生成的表使用的不是最有效的序列化格式。如果加載了大量數據和/或表格被大量查詢，您可能只想使用此運算符將數據暫存到臨時表中，然后使用 a 將其加載到最終目標中。`CREATE TABLE``DROP TABLE``STORED AS textfile``HiveOperator` 參數： * `sql(str)` - 針對 Microsoft SQL Server 數據庫執行的 SQL 查詢。（模板） * `hive_table(str)` - 目標 Hive 表，使用點表示法來定位特定數據庫。（模板） * `create(bool)` - 是否創建表，如果它不存在 * `recreate(bool)` - 是否在每次執行時刪除并重新創建表 * `partition(dict)` - 將目標分區作為分區列和值的字典。（模板） * `delimiter(str)` - 文件中的字段分隔符 * `mssql_conn_id(str)` - 源 Microsoft SQL Server 連接 * `hive_conn_id(str)` - 目標配置單元連接 * `tblproperties(dict)` - 正在創建的 hive 表的 TBLPROPERTIES ```py class airflow.operators.mysql_operator.MySqlOperator（sql，mysql_conn_id ='mysql_default'，parameters = None，autocommit = False，database = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在特定的 MySQL 數據庫中執行 sql 代碼參數： * `mysql_conn_id(string)` - 對特定 mysql 數據庫的引用 * `SQL(_ 可接收表示 SQL 語句中的海峽 _ _，_ _ 海峽列表 _ _（_ _SQL 語句 _ _）_ _，或 _ _ 參照模板文件模板引用在“.SQL”結束海峽認可。_)` -要執行的 SQL 代碼。（模板） * `database(string)` - 覆蓋連接中定義的數據庫的數據庫名稱 ```py class airflow.operators.mysql_to_hive.MySqlToHiveTransfer（sql，hive_table，create = True，recreate = False，partition = None，delimiter = u'x01'，mysql_conn_id ='mysql_default'，hive_cli_conn_id ='hive_cli_default'，tblproperties = None，* args ，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從 MySql 移動到 Hive。操作員針對 MySQL 運行查詢，在將文件加載到 Hive 表之前將文件存儲在本地。如果將`create`或`recreate`參數設置為`True`，則生成 a 和語句。從游標的元數據推斷出 Hive 數據類型。請注意，在 Hive 中生成的表使用的不是最有效的序列化格式。如果加載了大量數據和/或表格被大量查詢，您可能只想使用此運算符將數據暫存到臨時表中，然后使用 a 將其加載到最終目標中。`CREATE TABLE``DROP TABLE``STORED AS textfile``HiveOperator` 參數： * `sql(str)` - 針對 MySQL 數據庫執行的 SQL 查詢。（模板） * `hive_table(str)` - 目標 Hive 表，使用點表示法來定位特定數據庫。（模板） * `create(bool)` - 是否創建表，如果它不存在 * `recreate(bool)` - 是否在每次執行時刪除并重新創建表 * `partition(dict)` - 將目標分區作為分區列和值的字典。（模板） * `delimiter(str)` - 文件中的字段分隔符 * `mysql_conn_id(str)` - 源碼 mysql 連接 * `hive_conn_id(str)` - 目標配置單元連接 * `tblproperties(dict)` - 正在創建的 hive 表的 TBLPROPERTIES ```py class airflow.operators.oracle_operator.OracleOperator（sql，oracle_conn_id ='oracle_default'，parameters = None，autocommit = False，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在特定的 Oracle 數據庫中執行 sql 代碼：param oracle_conn_id：對特定 Oracle 數據庫的引用：type oracle_conn_id：string：param sql：要執行的 sql 代碼。（模板化）：type sql：可以接收表示 sql 語句的 str， > str（sql 語句）列表或對模板文件的引用。模板引用由以'.sql'結尾的 str 識別 ```py class airflow.operators.pig_operator.PigOperator（pig，pig_cli_conn_id ='pig_cli_default'，pigparams_jinja_translate = False，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 執行豬腳本。參數： * `pig(string)` - 要執行的豬拉丁文字。（模板） * `pig_cli_conn_id(string)` - 對 Hive 數據庫的引用 * `pigparams_jinja_translate(_boolean_)` - 當為 True 時，豬 params 類型的模板$ {var}被轉換為 jinja-type templating {{var}}。請注意，您可能希望將此`DAG(user_defined_macros=myargs)`參數與參數一起使用。查看 DAG 對象文檔以獲取更多詳細信息。 ```py class airflow.operators.postgres_operator.PostgresOperator（sql，postgres_conn_id ='postgres_default'，autocommit = False，parameters = None，database = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在特定的 Postgres 數據庫中執行 sql 代碼參數： * `postgres_conn_id(string)` - 對特定 postgres 數據庫的引用 * `SQL(_ 可接收表示 SQL 語句中的海峽 _ _，_ _ 海峽列表 _ _（_ _SQL 語句 _ _）_ _，或 _ _ 參照模板文件模板引用在“.SQL”結束海峽認可。_)` -要執行的 SQL 代碼。（模板） * `database(string)` - 覆蓋連接中定義的數據庫的數據庫名稱 ```py class airflow.operators.presto_check_operator.PrestoCheckOperator（sql，presto_conn_id ='presto_default'，* args，** kwargs） ``` 基類： [`airflow.operators.check_operator.CheckOperator`](31 "airflow.operators.check_operator.CheckOperator") 對 Presto 執行檢查。該`PrestoCheckOperator`預期的 SQL 查詢將返回一行。使用 python `bool`強制轉換評估第一行的每個值。如果任何值返回，`False`則檢查失敗并輸出錯誤。請注意，Python bool 強制轉換如下`False`： * `False` * `0` * 空字符串（`""`） * 空列表（`[]`） * 空字典或集（`{}`）給定一個查詢，它只會在計數時失敗。您可以制作更復雜的查詢，例如，可以檢查表與上游源表的行數相同，或者今天的分區計數大于昨天的分區，或者一組指標是否更少 7 天平均值超過 3 個標準差。`SELECT COUNT(*) FROM foo``== 0` 此運算符可用作管道中的數據質量檢查，并且根據您在 DAG 中的位置，您可以選擇停止關鍵路徑，防止發布可疑數據，或者在旁邊接收電子郵件替代品阻止 DAG 的進展。參數： * `sql(string)` - 要執行的 sql * `presto_conn_id(string)` - 對 Presto 數據庫的引用 ```py class airflow.operators.presto_check_operator.PrestoIntervalCheckOperator（table，metrics_thresholds，date_filter_column ='ds'，days_back = -7，presto_conn_id ='presto_default'，* args，** kwargs） ``` 基類： [`airflow.operators.check_operator.IntervalCheckOperator`](31 "airflow.operators.check_operator.IntervalCheckOperator") 檢查作為 SQL 表達式給出的度量值是否在 days_back 之前的某個容差范圍內。參數： * `table(str)` - 表名 * `days_back(int)` - ds 與我們要檢查的 ds 之間的天數。默認為 7 天 * `metrics_threshold(dict)` - 由指標索引的比率字典 * `presto_conn_id(string)` - 對 Presto 數據庫的引用 ```py class airflow.operators.presto_to_mysql.PrestoToMySqlTransfer（sql，mysql_table，presto_conn_id ='presto_default'，mysql_conn_id ='mysql_default'，mysql_preoperator = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從 Presto 移動到 MySQL，注意到現在數據在被推送到 MySQL 之前被加載到內存中，因此該運算符應該用于少量數據。參數： * `sql(str)` - 對 Presto 執行的 SQL 查詢。（模板） * `mysql_table(str)` - 目標 MySQL 表，使用點表示法來定位特定數據庫。（模板） * `mysql_conn_id(str)` - 源碼 mysql 連接 * `presto_conn_id(str)` - 源 presto 連接 * `mysql_preoperator(str)` - 在導入之前對 mysql 運行的 sql 語句，通常用于截斷刪除代替進入的數據，允許任務是冪等的（運行任務兩次不會加倍數據）。（模板） ```py class airflow.operators.presto_check_operator.PrestoValueCheckOperator（sql，pass_value，tolerance = None，presto_conn_id ='presto_default'，* args，** kwargs） ``` 基類： [`airflow.operators.check_operator.ValueCheckOperator`](31 "airflow.operators.check_operator.ValueCheckOperator") 使用 sql 代碼執行簡單的值檢查。參數： * `sql(string)` - 要執行的 sql * `presto_conn_id(string)` - 對 Presto 數據庫的引用 ```py class airflow.operators.python_operator.PythonOperator（python_callable，op_args = None，op_kwargs = None，provide_context = False，templates_dict = None，templates_exts = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 執行 Python 可調用參數： * `python_callable(_python callable_)` - 對可調用對象的引用 * `op_kwargs(dict)` - 一個關鍵字參數的字典，將在你的函數中解壓縮 * `op_args(list)` - 調用 callable 時將解壓縮的位置參數列表 * `provide_context(bool)` - 如果設置為 true，Airflow 將傳遞一組可在函數中使用的關鍵字參數。這組 kwargs 完全對應于你在 jinja 模板中可以使用的內容。為此，您需要在函數頭中定義`** kwargs`。 * `templates_dict(_STR 的字典 _)` -一本字典其中的值將由發動機氣流之間的某個時候得到模板模板`__init__`和`execute`發生和已應用模板后，您可調用的上下文中提供。（模板） * `templates_exts(_list __（_ _str __）_)` - 例如，在處理模板化字段時要解析的文件擴展名列表`['.sql', '.hql']` ```py class airflow.operators.python_operator.PythonVirtualenvOperator（python_callable，requirements = None，python_version = None，use_dill = False，system_site_packages = True，op_args = None，op_kwargs = None，string_args = None，templates_dict = None，templates_exts = None，* args， ** kwargs） ``` 基類： [`airflow.operators.python_operator.PythonOperator`](31 "airflow.operators.python_operator.PythonOperator") 允許一個人在自動創建和銷毀的 virtualenv 中運行一個函數（有一些警告）。該函數必須使用 def 定義，而不是類的一部分。所有導入必須在函數內部進行，并且不能引用范圍之外的變量。名為 virtualenvstringargs 的全局范圍變量將可用（由 string_args 填充）。另外，可以通過 op_args 和 op_kwargs 傳遞內容，并且可以使用返回值。請注意，如果您的 virtualenv 運行在與 Airflow 不同的 Python 主要版本中，則不能使用返回值，op_args 或 op_kwargs。你可以使用 string_args。參數： * `python_callable(function)` - 一個沒有引用外部變量的 python 函數，用 def 定義，將在 virtualenv 中運行 * `requirements(_list __（_ _str __）_)` - pip install 命令中指定的要求列表 * `python_version(str)` - 用于運行 virtualenv 的 Python 版本。請注意，2 和 2.7 都是可接受的形式。 * `use_dill(bool)` - 是否使用 dill 序列化 args 和結果（pickle 是默認值）。這允許更復雜的類型，但要求您在您的要求中包含蒔蘿。 * `system_site_packages(bool)` - 是否在 virtualenv 中包含 system_site_packages。有關更多信息，請參閱 virtualenv 文檔。 * `op_args` - 要傳遞給 python_callable 的位置參數列表。 * `op_kwargs(dict)` - 傳遞給 python_callable 的關鍵字參數的字典。 * `string_args(_list __（_ _str __）_)` - 全局 var virtualenvstringargs 中存在的字符串，在運行時可用作列表（str）的 python_callable。請注意，args 按換行符分割。 * `templates_dict(_STR 的字典 _)` -一本字典，其中值是將某個之間的氣流引擎獲得模板模板`__init__`和`execute`發生，并取得了您的可調用的上下文提供的模板已被應用后， * `templates_exts(_list __（_ _str __）_)` - 例如，在處理模板化字段時要解析的文件擴展名列表`['.sql', '.hql']` ```py class airflow.operators.s3_file_transform_operator.S3FileTransformOperator（source_s3_key，dest_s3_key，transform_script = None，select_expression = None，source_aws_conn_id ='aws_default'，dest_aws_conn_id ='aws_default'，replace = False，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從源 S3 位置復制到本地文件系統上的臨時位置。根據轉換腳本的指定對此文件運行轉換，并將輸出上載到目標 S3 位置。本地文件系統中的源文件和目標文件的位置作為轉換腳本的第一個和第二個參數提供。轉換腳本應該從源讀取數據，轉換它并將輸出寫入本地目標文件。然后，操作員接管控制并將本地目標文件上載到 S3。 S3 Select 也可用于過濾源內容。如果指定了 S3 Select 表達式，則用戶可以省略轉換腳本。參數： * `source_s3_key(str)` - 從 S3 檢索的密鑰。（模板） * `source_aws_conn_id(str)` - 源 s3 連接 * `dest_s3_key(str)` - 從 S3 寫入的密鑰。（模板） * `dest_aws_conn_id(str)` - 目標 s3 連接 * `replace(bool)` - 替換 dest S3 密鑰（如果已存在） * `transform_script(str)` - 可執行轉換腳本的位置 * `select_expression(str)` - S3 選擇表達式 ```py class airflow.operators.s3_to_hive_operator.S3ToHiveTransfer（s3_key，field_dict，hive_table，delimiter ='，'，create = True，recreate = False，partition = None，headers = False，check_headers = False，wildcard_match = False，aws_conn_id ='aws_default' ，hive_cli_conn_id ='hive_cli_default'，input_compressed = False，tblproperties = None，select_expression = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從 S3 移動到 Hive。操作員從 S3 下載文件，在將文件加載到 Hive 表之前將其存儲在本地。如果將`create`或`recreate`參數設置為`True`，則生成 a 和語句。Hive 數據類型是從游標的元數據中推斷出來的。`CREATE TABLE``DROP TABLE` 請注意，在 Hive 中生成的表使用的不是最有效的序列化格式。如果加載了大量數據和/或表格被大量查詢，您可能只想使用此運算符將數據暫存到臨時表中，然后使用 a 將其加載到最終目標中。`STORED AS textfile``HiveOperator` 參數： * `s3_key(str)` - 從 S3 檢索的密鑰。（模板） * `field_dict(dict)` - 字段的字典在文件中命名為鍵，其 Hive 類型為值 * `hive_table(str)` - 目標 Hive 表，使用點表示法來定位特定數據庫。（模板） * `create(bool)` - 是否創建表，如果它不存在 * `recreate(bool)` - 是否在每次執行時刪除并重新創建表 * `partition(dict)` - 將目標分區作為分區列和值的字典。（模板） * `headers(bool)` - 文件是否包含第一行的列名 * `check_headers(bool)` - 是否應該根據 field_dict 的鍵檢查第一行的列名 * `wildcard_match(bool)` - 是否應將 s3_key 解釋為 Unix 通配符模式 * `delimiter(str)` - 文件中的字段分隔符 * `aws_conn_id(str)` - 源 s3 連接 * `hive_cli_conn_id(str)` - 目標配置單元連接 * `input_compressed(bool)` - 布爾值，用于確定是否需要文件解壓縮來處理標頭 * `tblproperties(dict)` - 正在創建的 hive 表的 TBLPROPERTIES * `select_expression(str)` - S3 選擇表達式 ```py class airflow.operators.s3_to_redshift_operator.S3ToRedshiftTransfer（schema，table，s3_bucket，s3_key，redshift_conn_id ='redshift_default'，aws_conn_id ='aws_default'，copy_options =（），autocommit = False，parameters = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 執行 COPY 命令將文件從 s3 加載到 Redshift 參數： * `schema(string)` - 對 redshift 數據庫中特定模式的引用 * `table(string)` - 對 redshift 數據庫中特定表的引用 * `s3_bucket(string)` - 對特定 S3 存儲桶的引用 * `s3_key(string)` - 對特定 S3 密鑰的引用 * `redshift_conn_id(string)` - 對特定 redshift 數據庫的引用 * `aws_conn_id(string)` - 對特定 S3 連接的引用 * `copy_options(list)` - 對 COPY 選項列表的引用 ```py class airflow.operators.python_operator.ShortCircuitOperator（python_callable，op_args = None，op_kwargs = None，provide_context = False，templates_dict = None，templates_exts = None，* args，** kwargs） ``` 基類：[`airflow.operators.python_operator.PythonOperator`](31 "airflow.operators.python_operator.PythonOperator")，`airflow.models.SkipMixin` 僅在滿足條件時才允許工作流繼續。否則，將跳過工作流程“短路”和下游任務。 ShortCircuitOperator 派生自 PythonOperator。如果條件為 False，它會評估條件并使工作流程短路。任何下游任務都標記為“已跳過”狀態。如果條件為 True，則下游任務正常進行。條件由`python_callable`的結果`決定`。 ```py class airflow.operators.http_operator.SimpleHttpOperator（endpoint，method ='POST'，data = None，headers = None，response_check = None，extra_options = None，xcom_push = False，http_conn_id ='http_default'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 HTTP 系統上調用端點以執行操作參數： * `http_conn_id(string)` - 運行傳感器的連接 * `endpoint(string)` - 完整 URL 的相對部分。（模板） * `method(string)` - 要使用的 HTTP 方法，default =“POST” * `data(_ 對于 POST / PUT __，_ _ 取決于 content-type 參數 _ _，_ _ 用于 GET 鍵/值字符串對的字典 _)` - 要傳遞的數據。POST / PUT 中的 POST 數據和 GET 請求的 URL 中的 params。（模板） * `headers(_ 字符串鍵/值對的字典 _)` - 要添加到 GET 請求的 HTTP 頭 * `response_check(_lambda _ 或 _ 定義的函數。_)` - 檢查'requests'響應對象。對于'pass'返回 True，否則返回 False。 * `extra_options(_ 選項字典 _ _，_ _ 其中鍵是字符串，值取決于正在修改的選項。_)` - 'requests'庫的額外選項，請參閱'requests'文檔（修改超時，ssl 等選項） ```py class airflow.operators.slack_operator.SlackAPIOperator（slack_conn_id = None，token = None，method = None，api_params = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") Base Slack 運算符 SlackAPIPostOperator 派生自此運算符。在未來，還將從此類派生其他 Slack API 操作符參數： * `slack_conn_id(string)` - Slack 連接 ID，其密碼為 Slack API 令牌 * `token(string)` - Slack API 令牌（[https://api.slack.com/web](https://api.slack.com/web)） * `method(string)` - 要調用的 Slack API 方法（[https://api.slack.com/methods](https://api.slack.com/methods)） * `api_params(dict)` - API 方法調用參數（[https://api.slack.com/methods](https://api.slack.com/methods)） ```py construct_api_call_params（） ``` 由 execute 函數使用。允許在構造之前對 api_call_params dict 的源字段進行模板化覆蓋子類。每個 SlackAPIOperator 子類都負責使用 construct_api_call_params 函數，該函數使用 API??調用參數的字典設置 self.api_call_params（[https://api.slack.com/methods](https://api.slack.com/methods)） ```py 執行（** kwargs） ``` 即使調用不成功，SlackAPIOperator 調用也不會失敗。它不應該阻止 DAG 成功完成 ```py class airflow.operators.slack_operator.SlackAPIPostOperator（channel ='＃general'，username ='Airflow'，text ='沒有設置任何消息。這是一個貓視頻而不是 http://www.youtube.com/watch？v = J --- aiyznGQ'，icon_url ='https：//raw.githubusercontent.com/airbnb/airflow/master/airflow/www/static/pin_100.png'，附件=無，* args，** kwargs） ``` 基類： [`airflow.operators.slack_operator.SlackAPIOperator`](31 "airflow.operators.slack_operator.SlackAPIOperator") 將消息發布到松弛通道參數： * `channel(string)` - 在松弛名稱（#general）或 ID（C12318391）上發布消息的通道。（模板） * `username(string)` - 氣流將發布到 Slack 的用戶**名**。（模板） * `text(string)` - 要發送到 slack 的消息。（模板） * `icon_url(string)` - 用于此消息的圖標的 url * `附件(哈希數組)` - 額外的格式詳細信息。（模板化） - 請參閱[https://api.slack.com/docs/attachments](https://api.slack.com/docs/attachments)。 ```py construct_api_call_params（） ``` 由 execute 函數使用。允許在構造之前對 api_call_params dict 的源字段進行模板化覆蓋子類。每個 SlackAPIOperator 子類都負責使用 construct_api_call_params 函數，該函數使用 API??調用參數的字典設置 self.api_call_params（[https://api.slack.com/methods](https://api.slack.com/methods)） ```py class airflow.operators.sqlite_operator.SqliteOperator（sql，sqlite_conn_id ='sqlite_default'，parameters = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在特定的 Sqlite 數據庫中執行 sql 代碼參數： * `sqlite_conn_id(string)` - 對特定 sqlite 數據庫的引用 * `sql(_ 指向模板文件的 _string 或 _ 字符串。文件必須具有'.sql'擴展名。_)` - 要執行的 sql 代碼。（模板） ```py class airflow.operators.subdag_operator.SubDagOperator（** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") ```py class airflow.operators.dagrun_operator.TriggerDagRunOperator（trigger_dag_id，python_callable = None，execution_date = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 觸發指定的 DAG 運行 `dag_id` 參數： * `trigger_dag_id(str)` - 要觸發的 dag_id * `python_callable(_python callable_)` - 對 python 函數的引用，在傳遞`context`對象時將調用該對象，`obj`并且如果要創建 DagRun，則可調用的占位符對象可以填充并返回。這個`obj`對象包含`run_id`和`payload`屬性，你可以在你的函數修改。本`run_id`應為 DAG 運行的唯一標識符，有效載荷必須是在執行該 DAG 運行，這將提供給你的任務 picklable 對象。你的函數頭應該是這樣的`def foo(context, dag_run_obj):` * `execution_date(_datetime.datetime_)` - dag 的執行日期 ```py class airflow.operators.check_operator.ValueCheckOperator（sql，pass_value，tolerance = None，conn_id = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 使用 sql 代碼執行簡單的值檢查。請注意，這是一個抽象類，需要定義 get_db_hook。而 get_db_hook 是鉤子，它從外部源獲取單個記錄。參數：`sql(string)` - 要執行的 sql。（模板） ```py class airflow.operators.redshift_to_s3_operator.RedshiftToS3Transfer（schema，table，s3_bucket，s3_key，redshift_conn_id ='redshift_default'，aws_conn_id ='aws_default'，unload_options =（），autocommit = False，parameters = None，include_header = False，* args，* * kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 執行 UNLOAD 命令，將 s3 作為帶標題的 CSV 參數： * `schema(string)` - 對 redshift 數據庫中特定模式的引用 * `table(string)` - 對 redshift 數據庫中特定表的引用 * `s3_bucket(string)` - 對特定 S3 存儲桶的引用 * `s3_key(string)` - 對特定 S3 密鑰的引用 * `redshift_conn_id(string)` - 對特定 redshift 數據庫的引用 * `aws_conn_id(string)` - 對特定 S3 連接的引用 * `unload_options(list)` - 對 UNLOAD 選項列表的引用 #### 傳感器 ```py class airflow.sensors.external_task_sensor.ExternalTask??Sensor（external_dag_id，external_task_id，allowed_states = None，execution_delta = None，execution_date_fn = None，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 等待任務在不同的 DAG 中完成參數： * `external_dag_id(string)` - 包含您要等待的任務的 dag_id * `external_task_id(string)` - 包含您要等待的任務的 task_id * `allowed_states(list)` - 允許的狀態列表，默認為`['success']` * `execution_delta(datetime.timedelta)` - 與上一次執行的時間差異來看，默認是與當前任務相同的 execution_date。對于昨天，使用[positive！] datetime.timedelta（days = 1）。execution_delta 或 execution_date_fn 可以傳遞給 ExternalTask??Sensor，但不能同時傳遞給兩者。 * `execution_date_fn(callable)` - 接收當前執行日期并返回所需執行日期以進行查詢的函數。execution_delta 或 execution_date_fn 可以傳遞給 ExternalTask??Sensor，但不能同時傳遞給兩者。 ```py 戳（** kwargs） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.sensors.hdfs_sensor.HdfsSensor（filepath，hdfs_conn_id ='hdfs_default'，ignored_ext = ['_ COPYING_']，ignore_copying = True，file_size = None，hook = <class'airflow.hooks.hdfs_hook.HDFSHook'>，* args ，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 等待文件或文件夾降落到 HDFS 中 ```py static filter_for_filesize（result，size = None） ``` 將測試文件路徑結果并測試其大小是否至少為 self.filesize 參數： * `結果` - Snakebite ls 返回的 dicts 列表 * `size` - 文件大小（MB）文件應該至少觸發 True 返回值：（bool）取決于匹配標準 ```py static filter_for_ignored_ext（result，ignored_ext，ignore_copying） ``` 如果指示過濾將刪除匹配條件的結果參數： * `結果` - Snakebite ls 返回的 dicts（列表） * `ignored_ext` - 忽略擴展名的（列表） * `ignore_copying` - （bool）我們會忽略嗎？返回值：（清單）未刪除的詞典 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.sensors.hive_partition_sensor.HivePartitionSensor（table，partition =“ds ='{{ds}}'”，metastore_conn_id ='metastore_default'，schema ='default'，poke_interval = 180，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 等待分區顯示在 Hive 中。注意：因為`partition`支持通用邏輯運算符，所以效率低下。如果您不需要 HivePartitionSensor 的完全靈活性，請考慮使用 NamedHivePartitionSensor。參數： * `table(string)` - 要等待的表的名稱，支持點表示法（my_database.my_table） * `partition(string)` - 要等待的分區子句。這是原樣傳遞給 Metastore Thrift 客戶端`get_partitions_by_filter`方法，顯然支持 SQL 作為符號和比較運算符，如`ds='2015-01-01' AND type='value'``"ds>=2015-01-01"` * `metastore_conn_id(str)` - 對 Metastore thrift 服務連接 id 的引用 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.sensors.http_sensor.HttpSensor（endpoint，http_conn_id ='http_default'，method ='GET'，request_params = None，headers = None，response_check = None，extra_options = None，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") ```py 執行 HTTP get 語句并在失敗時返回 False： ``` 找不到 404 或者 response_check 函數返回 False 參數： * `http_conn_id(string)` - 運行傳感器的連接 * `method(string)` - 要使用的 HTTP 請求方法 * `endpoint(string)` - 完整 URL 的相對部分 * `request_params(_ 字符串鍵/值對的字典 _)` - 要添加到 GET URL 的參數 * `headers(_ 字符串鍵/值對的字典 _)` - 要添加到 GET 請求的 HTTP 頭 * `response_check(_lambda _ 或 _ 定義的函數。_)` - 檢查'requests'響應對象。對于'pass'返回 True，否則返回 False。 * `extra_options(_ 選項字典 _ _，_ _ 其中鍵是字符串，值取決于正在修改的選項。_)` - 'requests'庫的額外選項，請參閱'requests'文檔（修改超時，ssl 等選項） ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.sensors.metastore_partition_sensor.MetastorePartitionSensor（table，partition_name，schema ='default'，mysql_conn_id ='metastore_mysql'，* args，** kwargs） ``` 基類： [`airflow.sensors.sql_sensor.SqlSensor`](31 "airflow.sensors.sql_sensor.SqlSensor") HivePartitionSensor 的替代方案，直接與 MySQL 數據庫對話。這是在觀察子分區表時 Metastore thrift 服務生成的子最優查詢的結果。Thrift 服務的查詢是以不利用索引的方式編寫的。參數： * `schema(str)` - 架構 * `table(str)` - 表格 * `partition_name(str)` - 分區名稱，在 Metastore 的 PARTITIONS 表中定義。字段順序很重要。示例：`ds=2016-01-01`或`ds=2016-01-01/sub=foo`用于子分區表 * `mysql_conn_id(str)` - 對 Metastore 的 MySQL conn_id 的引用 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.sensors.named_hive_partition_sensor.NamedHivePartitionSensor（partition_names，metastore_conn_id ='metastore_default'，poke_interval = 180，hook = None，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 等待一組分區顯示在 Hive 中。參數： * `partition_names(_ 字符串列表 _)` - 要等待的分區的完全限定名稱列表。完全限定名稱的格式`schema.table/pk1=pv1/pk2=pv2`為，例如，default.users / ds = 2016-01-01。這將原樣傳遞給 Metastore Thrift 客戶端`get_partitions_by_name`方法。請注意，您不能像在 HivePartitionSensor 中那樣使用邏輯或比較運算符。 * `metastore_conn_id(str)` - 對 Metastore thrift 服務連接 id 的引用 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.sensors.s3_key_sensor.S3KeySensor（bucket_key，bucket_name = None，wildcard_match = False，aws_conn_id ='aws_default'，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 等待 S3 存儲桶中存在密鑰（S3 上的文件類實例）。S3 是鍵/值，它不支持文件夾。路徑只是資源的關鍵。參數： * `bucket_key(str)` - 正在等待的密鑰。支持完整的 s3：//樣式 URL 或從根級別的相對路徑。 * `bucket_name(str)` - S3 存儲桶的名稱 * `wildcard_match(bool)` - 是否應將 bucket_key 解釋為 Unix 通配符模式 * `aws_conn_id(str)` - 對 s3 連接的引用 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.sensors.s3_prefix_sensor.S3PrefixSensor（bucket_name，prefix，delimiter ='/'，aws_conn_id ='aws_default'，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 等待前綴存在。前綴是鍵的第一部分，因此可以檢查類似于 glob airfl *或 SQL LIKE'airfl％'的構造。有可能精確定界符來指示層次結構或鍵，這意味著匹配將停止在該定界符處。當前代碼接受合理的分隔符，即 Python 正則表達式引擎中不是特殊字符的字符。參數： * `bucket_name(str)` - S3 存儲桶的名稱 * `prefix(str)` - 等待的前綴。桶根級別的相對路徑。 * `delimiter(str)` - 用于顯示層次結構的分隔符。默認為'/'。 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.sensors.sql_sensor.SqlSensor（conn_id，sql，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 運行 sql 語句，直到滿足條件。它將繼續嘗試，而 sql 不返回任何行，或者如果第一個單元格返回（0，'0'，''）。參數： * `conn_id(string)` - 運行傳感器的連接 * `sql` - 要運行的 sql。要傳遞，它需要返回至少一個包含非零/空字符串值的單元格。 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.sensors.time_sensor.TimeSensor（target_time，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 等到當天的指定時間。參數：`target_time(_datetime.time_)` - 作業成功的時間 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.sensors.time_delta_sensor.TimeDeltaSensor（delta，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 在任務的 execution_date + schedule_interval 之后等待 timedelta。在 Airflow 中，標有`execution_date`2016-01-01 的每日任務只能在 2016-01-02 開始運行。timedelta 在此表示執行期間結束后的時間。參數：`delta(datetime.timedelta)` - 成功之前在 execution_date 之后等待的時間長度 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.sensors.web_hdfs_sensor.WebHdfsSensor（filepath，webhdfs_conn_id ='webhdfs_default'，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 等待文件或文件夾降落到 HDFS 中 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ### 社區貢獻的運營商 #### 運營商 ```py class airflow.contrib.operators.awsbatch_operator.AWSBatchOperator（job_name，job_definition，job_queue，overrides，max_retries = 4200，aws_conn_id = None，region_name = None，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 AWS Batch Service 上執行作業參數： * `job_name(str)` - 將在 AWS Batch 上運行的作業的名稱 * `job_definition(str)` - AWS Batch 上的作業定義名稱 * `job_queue(str)` - AWS Batch 上的隊列名稱 * `max_retries(int)` - 服務器未合并時的指數退避重試，4200 = 48 小時 * `aws_conn_id(str)` - AWS 憑證/區域名稱的連接 ID。如果為 None，將使用憑證 boto3 策略（[http://boto3.readthedocs.io/en/latest/guide/configuration.html](http://boto3.readthedocs.io/en/latest/guide/configuration.html)）。 * `region_name` - 要在 AWS Hook 中使用的區域名稱。覆蓋連接中的 region_name（如果提供） | 帕拉姆： | 覆蓋：boto3 將在 containerOverrides 上接收的相同參數（模板化）：[http](http://boto3.readthedocs.io/en/latest/reference/services/batch.html)：//boto3.readthedocs.io/en/latest/reference/services/batch.html#submit_job[](http://boto3.readthedocs.io/en/latest/reference/services/batch.html)類型：覆蓋：dict ```py class airflow.contrib.operators.bigquery_check_operator.BigQueryCheckOperator（sql，bigquery_conn_id ='bigquery_default'，* args，** kwargs） ``` 基類： [`airflow.operators.check_operator.CheckOperator`](31 "airflow.operators.check_operator.CheckOperator") 對 BigQuery 執行檢查。該`BigQueryCheckOperator`預期的 SQL 查詢將返回一行。使用 python `bool`強制轉換評估第一行的每個值。如果任何值返回，`False`則檢查失敗并輸出錯誤。請注意，Python bool 強制轉換如下`False`： * `False` * `0` * 空字符串（`""`） * 空列表（`[]`） * 空字典或集（`{}`）給定一個查詢，它只會在計數時失敗。您可以制作更復雜的查詢，例如，可以檢查表與上游源表的行數相同，或者今天的分區計數大于昨天的分區，或者一組指標是否更少 7 天平均值超過 3 個標準差。`SELECT COUNT(*) FROM foo``== 0` 此運算符可用作管道中的數據質量檢查，并且根據您在 DAG 中的位置，您可以選擇停止關鍵路徑，防止發布可疑數據，或者在旁邊接收電子郵件替代品阻止 DAG 的進展。參數： * `sql(string)` - 要執行的 sql * `bigquery_conn_id(string)` - 對 BigQuery 數據庫的引用 ```py class airflow.contrib.operators.bigquery_check_operator.BigQueryValueCheckOperator（sql，pass_value，tolerance = None，bigquery_conn_id ='bigquery_default'，* args，** kwargs） ``` 基類： [`airflow.operators.check_operator.ValueCheckOperator`](31 "airflow.operators.check_operator.ValueCheckOperator") 使用 sql 代碼執行簡單的值檢查。參數：`sql(string)` - 要執行的 sql ```py class airflow.contrib.operators.bigquery_check_operator.BigQueryIntervalCheckOperator（table，metrics_thresholds，date_filter_column ='ds'，days_back = -7，bigquery_conn_id ='bigquery_default'，* args，** kwargs） ``` 基類： [`airflow.operators.check_operator.IntervalCheckOperator`](31 "airflow.operators.check_operator.IntervalCheckOperator") 檢查作為 SQL 表達式給出的度量值是否在 days_back 之前的某個容差范圍內。此方法構造一個類似的查詢 ```py SELECT { metrics_thresholddictkey } FROM { table } WHERE { date_filter_column } =< date > ``` 參數： * `table(str)` - 表名 * `days_back(int)` - ds 與我們要檢查的 ds 之間的天數。默認為 7 天 * `metrics_threshold(dict)` - 由指標索引的比率字典，例如'COUNT（*）'：1.5 將需要當前日和之前的 days_back 之間 50％或更小的差異。 ```py class airflow.contrib.operators.bigquery_get_data.BigQueryGetDataOperator（dataset_id，table_id，max_results ='100'，selected_fields = None，bigquery_conn_id ='bigquery_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 從 BigQuery 表中獲取數據（或者為所選列獲取數據）并在 python 列表中返回數據。返回列表中的元素數將等于獲取的行數。列表中的每個元素將再次是一個列表，其中元素將表示該行的列值。 **結果示例**：`[['Tony', '10'], ['Mike', '20'], ['Steve', '15']]` 注意如果傳遞的字段`selected_fields`的順序與 BQ 表中已有的列的順序不同，則數據仍將按 BQ 表的順序排列。例如，如果 BQ 表有 3 列，`[A,B,C]`并且您傳遞'B，`selected_fields`那么數據中的 A' 仍然是表格`'A,B'`。 **示例** ： ```py get_data = BigQueryGetDataOperator ( task_id = 'get_data_from_bq' , dataset_id = 'test_dataset' , table_id = 'Transaction_partitions' , max_results = '100' , selected_fields = 'DATE' , bigquery_conn_id = 'airflow-service-account' ) ``` 參數： * `dataset_id` - 請求的表的數據集 ID。（模板） * `table_id(string)` - 請求表的表 ID。（模板） * `max_results(string)` - 從表中獲取的最大記錄數（行數）。（模板） * `selected_fields(string)` - 要返回的字段列表（逗號分隔）。如果未指定，則返回所有字段。 * `bigquery_conn_id(string)` - 對特定 BigQuery 鉤子的引用。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py class airflow.contrib.operators.bigquery_operator.BigQueryCreateEmptyTableOperator（dataset_id，table_id，project_id = None，schema_fields = None，gcs_schema_object = None，time_partitioning = {}，bigquery_conn_id ='bigquery_default'，google_cloud_storage_conn_id ='google_cloud_default'，delegate_to = None，* args ，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在指定的 BigQuery 數據集中創建一個新的空表，可選擇使用模式。可以用兩種方法之一指定用于 BigQuery 表的模式。您可以直接傳遞架構字段，也可以將運營商指向 Google 云存儲對象名稱。Google 云存儲中的對象必須是包含架構字段的 JSON 文件。您還可以創建沒有架構的表。參數： * `project_id(string)` - 將表創建的項目。（模板） * `dataset_id(string)` - 用于創建表的數據集。（模板） * `table_id(string)` - 要創建的表的名稱。（模板） * `schema_fields(list)` - 如果設置，則此處定義的架構字段列表：[https](https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs)：[//cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.load.schema](https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs) **示例** ： ```py schema_fields = [{ "name" : "emp_name" , "type" : "STRING" , "mode" : "REQUIRED" }, { "name" : "salary" , "type" : "INTEGER" , "mode" : "NULLABLE" }] ``` * `gcs_schema_object(string)` - 包含模式（模板化）的 JSON 文件的完整路徑。例如：`gs://test-bucket/dir1/dir2/employee_schema.json` * `time_partitioning(dict)` - 配置可選的時間分區字段，即按 API 規范按字段，類型和到期分區。也可以看看 [https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#timePartitioning](https://cloud.google.com/bigquery/docs/reference/rest/v2/tables) * `bigquery_conn_id(string)` - 對特定 BigQuery 掛鉤的引用。 * `google_cloud_storage_conn_id(string)` - 對特定 Google 云存儲掛鉤的引用。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 **示例（在 GCS 中使用模式 JSON）**： ```py CreateTable = BigQueryCreateEmptyTableOperator ( task_id = 'BigQueryCreateEmptyTableOperator_task' , dataset_id = 'ODS' , table_id = 'Employees' , project_id = 'internal-gcp-project' , gcs_schema_object = 'gs://schema-bucket/employee_schema.json' , bigquery_conn_id = 'airflow-service-account' , google_cloud_storage_conn_id = 'airflow-service-account' ) ``` **對應的 Schema 文件**（`employee_schema.json`）： ```py [ { "mode" : "NULLABLE" , "name" : "emp_name" , "type" : "STRING" }, { "mode" : "REQUIRED" , "name" : "salary" , "type" : "INTEGER" } ] ``` **示例（在 DAG 中使用模式）**： ```py CreateTable = BigQueryCreateEmptyTableOperator ( task_id = 'BigQueryCreateEmptyTableOperator_task' , dataset_id = 'ODS' , table_id = 'Employees' , project_id = 'internal-gcp-project' , schema_fields = [{ "name" : "emp_name" , "type" : "STRING" , "mode" : "REQUIRED" }, { "name" : "salary" , "type" : "INTEGER" , "mode" : "NULLABLE" }], bigquery_conn_id = 'airflow-service-account' , google_cloud_storage_conn_id = 'airflow-service-account' ) ``` ```py class airflow.contrib.operators.bigquery_operator.BigQueryCreateExternalTableOperator（bucket，source_objects，destination_project_dataset_table，schema_fields = None，schema_object = None，source_format ='CSV'，compression ='NONE'，skip_leading_rows = 0，field_delimiter ='，'，max_bad_records = 0 ，quote_character = None，allow_quoted_newlines = False，allow_jagged_rows = False，bigquery_conn_id ='bigquery_default'，google_cloud_storage_conn_id ='google_cloud_default'，delegate_to = None，src_fmt_configs = {}，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 使用 Google 云端存儲中的數據在數據集中創建新的外部表。可以用兩種方法之一指定用于 BigQuery 表的模式。您可以直接傳遞架構字段，也可以將運營商指向 Google 云存儲對象名稱。Google 云存儲中的對象必須是包含架構字段的 JSON 文件。參數： * `bucket(string)` - 指向外部表的存儲桶。（模板） * `source_objects` - 指向表格的 Google 云存儲 URI 列表。（模板化）如果 source_format 是'DATASTORE_BACKUP'，則列表必須只包含一個 URI。 * `destination_project_dataset_table(string)` - 用于將數據加載到（模板化）的虛線（<project>。）<dataset>。<table> BigQuery 表。如果未包含<project>，則項目將是連接 json 中定義的項目。 * `schema_fields(list)` - 如果設置，則此處定義的架構字段列表：[https](https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs)：[//cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.load.schema](https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs) **示例** ： ```py schema_fields = [{ "name" : "emp_name" , "type" : "STRING" , "mode" : "REQUIRED" }, { "name" : "salary" , "type" : "INTEGER" , "mode" : "NULLABLE" }] ``` 當 source_format 為'DATASTORE_BACKUP'時，不應設置。 * `schema_object` - 如果設置，則指向包含表的架構的.json 文件的 GCS 對象路徑。（模板） * `schema_object` - 字符串 * `source_format(string)` - 數據的文件格式。 * `compression(string)` - [可選]數據源的壓縮類型。可能的值包括 GZIP 和 NONE。默認值為 NONE。Google Cloud Bigtable，Google Cloud Datastore 備份和 Avro 格式會忽略此設置。 * `skip_leading_rows(int)` - 從 CSV 加載時要跳過的行數。 * `field_delimiter(string)` - 用于 CSV 的分隔符。 * `max_bad_records(int)` - BigQuery 在運行作業時可以忽略的最大錯誤記錄數。 * `quote_character(string)` - 用于引用 CSV 文件中數據部分的值。 * `allow_quoted_newlines(_boolean_)` - 是否允許引用的換行符（true）或不允許（false）。 * `allow_jagged_rows(bool)` - 接受缺少尾隨可選列的行。缺失值被視為空值。如果為 false，則缺少尾隨列的記錄將被視為錯誤記錄，如果錯誤記錄太多，則會在作業結果中返回無效錯誤。僅適用于 CSV，忽略其他格式。 * `bigquery_conn_id(string)` - 對特定 BigQuery 掛鉤的引用。 * `google_cloud_storage_conn_id(string)` - 對特定 Google 云存儲掛鉤的引用。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `src_fmt_configs(dict)` - 配置特定于源格式的可選字段 ```py class airflow.contrib.operators.bigquery_operator.BigQueryOperator（bql = None，sql = None，destination_dataset_table = False，write_disposition ='WRITE_EMPTY'，allow_large_results = False，flatten_results = False，bigquery_conn_id ='bigquery_default'，delegate_to = None，udf_config = False ，use_legacy_sql = True，maximum_billing_tier = None，maximum_bytes_billed = None，create_disposition ='CREATE_IF_NEEDED'，schema_update_options =（），query_params = None，priority ='INTERACTIVE'，time_partitioning = {}，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在特定的 BigQuery 數據庫中執行 BigQuery SQL 查詢參數： * `BQL(_ 可接收表示 SQL 語句中的海峽 _ _，_ _ 海峽列表 _ _（_ _SQL 語句 _ _）_ _，或 _ _ 參照模板文件模板引用在“.SQL”結束海峽認可。_)` - （不推薦使用。`SQL`參數代替）要執行的 sql 代碼（模板化） * `SQL(_ 可接收表示 SQL 語句中的海峽 _ _，_ _ 海峽列表 _ _（_ _SQL 語句 _ _）_ _，或 _ _ 參照模板文件模板引用在“.SQL”結束海峽認可。_)` - SQL 代碼被執行（模板） * `destination_dataset_table(string)` - 一個虛線（<project>。| <project>：）<dataset>。<table>，如果設置，將存儲查詢結果。（模板） * `write_disposition(string)` - 指定目標表已存在時發生的操作。（默認：'WRITE_EMPTY'） * `create_disposition(string)` - 指定是否允許作業創建新表。（默認值：'CREATE_IF_NEEDED'） * `allow_large_results(_boolean_)` - 是否允許大結果。 * `flatten_results(_boolean_)` - 如果為 true 且查詢使用舊版 SQL 方言，則展平查詢結果中的所有嵌套和重復字段。`allow_large_results`必須是`true`如果設置為`false`。對于標準 SQL 查詢，將忽略此標志，并且結果永遠不會展平。 * `bigquery_conn_id(string)` - 對特定 BigQuery 鉤子的引用。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `udf_config(list)` - 查詢的用戶定義函數配置。有關詳細信息，請參閱[https://cloud.google.com/bigquery/user-defined-functions](https://cloud.google.com/bigquery/user-defined-functions)。 * `use_legacy_sql(_boolean_)` - 是使用舊 SQL（true）還是標準 SQL（false）。 * `maximum_billing_tier(_ 整數 _)` - 用作基本價格乘數的正整數。默認為 None，在這種情況下，它使用項目中設置的值。 * `maximum_bytes_billed(float)` - 限制為此作業計費的字節數。超出此限制的字節數的查詢將失敗（不會產生費用）。如果未指定，則將其設置為項目默認值。 * `schema_update_options(_tuple_)` - 允許更新目標表的模式作為加載作業的副作用。 * `query_params(dict)` - 包含查詢參數類型和值的字典，傳遞給 BigQuery。 * `priority(string)` - 指定查詢的優先級。可能的值包括 INTERACTIVE 和 BATCH。默認值為 INTERACTIVE。 * `time_partitioning(dict)` - 配置可選的時間分區字段，即按 API 規范按字段，類型和到期分區。請注意，'field'不能與 dataset.table $ partition 一起使用。 ```py class airflow.contrib.operators.bigquery_table_delete_operator.BigQueryTableDeleteOperator（deletion_dataset_table，bigquery_conn_id ='bigquery_default'，delegate_to = None，ignore_if_missing = False，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 刪除 BigQuery 表參數： * `deletion_dataset_table(string)` - 一個虛線（<project>。| <project>：）<dataset>。<table>，指示將刪除哪個表。（模板） * `bigquery_conn_id(string)` - 對特定 BigQuery 鉤子的引用。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `ignore_if_missing(_boolean_)` - 如果為 True，則即使請求的表不存在也返回成功。 ```py class airflow.contrib.operators.bigquery_to_bigquery.BigQueryToBigQueryOperator（source_project_dataset_tables，destination_project_dataset_table，write_disposition ='WRITE_EMPTY'，create_disposition ='CREATE_IF_NEEDED'，bigquery_conn_id ='bigquery_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從一個 BigQuery 表復制到另一個。也可以看看有關這些參數的詳細信息，請訪問：[https](https://cloud.google.com/bigquery/docs/reference/v2/jobs)：[//cloud.google.com/bigquery/docs/reference/v2/jobs#configuration.copy](https://cloud.google.com/bigquery/docs/reference/v2/jobs) 參數： * `source_project_dataset_tables(_list | string_)` - 一個或多個點（項目：[|](31)項目。）<dataset>。<table>用作源數據的 BigQuery 表。如果未包含<project>，則項目將是連接 json 中定義的項目。如果有多個源表，請使用列表。（模板） * `destination_project_dataset_table(string)` - 目標 BigQuery 表。格式為：（project：[|](31) project。）<dataset>。<table>（模板化） * `write_disposition(string)` - 表已存在時的寫處置。 * `create_disposition(string)` - 如果表不存在，則創建處置。 * `bigquery_conn_id(string)` - 對特定 BigQuery 鉤子的引用。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py class airflow.contrib.operators.bigquery_to_gcs.BigQueryToCloudStorageOperator（source_project_dataset_table，destination_cloud_storage_uris，compression ='NONE'，export_format ='CSV'，field_delimiter ='，'，print_header = True，bigquery_conn_id ='bigquery_default'，delegate_to = None，* args， ** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將 BigQuery 表傳輸到 Google Cloud Storage 存儲桶。也可以看看有關這些參數的詳細信息，請訪問：[https](https://cloud.google.com/bigquery/docs/reference/v2/jobs)：[//cloud.google.com/bigquery/docs/reference/v2/jobs](https://cloud.google.com/bigquery/docs/reference/v2/jobs) 參數： * `source_project_dataset_table(string)` - 用作源數據的虛線（<project>。| <project>：）<dataset>。<table> BigQuery 表。如果未包含<project>，則項目將是連接 json 中定義的項目。（模板） * `destination_cloud_storage_uris(list)` - 目標 Google 云端存儲 URI（例如 gs：//some-bucket/some-file.txt）。（模板化）遵循此處定義的慣例：https：//cloud.google.com/bigquery/exporting-data-from-bigquery#exportingmultiple * `compression(string)` - 要使用的壓縮類型。 * `export_format` - 要導出的文件格式。 * `field_delimiter(string)` - 提取到 CSV 時使用的分隔符。 * `print_header(_boolean_)` - 是否打印 CSV 文件提取的標頭。 * `bigquery_conn_id(string)` - 對特定 BigQuery 鉤子的引用。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py class airflow.contrib.operators.cassandra_to_gcs.CassandraToGoogleCloudStorageOperator（cql，bucket，filename，schema_filename = None，approx_max_file_size_bytes = 1900000000，cassandra_conn_id = u'cassandra_default'，google_cloud_storage_conn_id = u'google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從 Cassandra 復制到 JSON 格式的 Google 云端存儲注意：不支持數組數組。 ```py classmethod convert_map_type（name，value） ``` 將映射轉換為包含兩個字段的重復 RECORD：'key'和'value'，每個字段將轉換為 BQ 中的相應數據類型。 ```py classmethod convert_tuple_type（name，value） ``` 將元組轉換為包含 n 個字段的 RECORD，每個字段將轉換為 bq 中相應的數據類型，并將命名為“field_ <index>”，其中 index 由 cassandra 中定義的元組元素的順序確定。 ```py classmethod convert_user_type（name，value） ``` 將用戶類型轉換為包含 n 個字段的 RECORD，其中 n 是屬性的數量。用戶類型類中的每個元素將在 BQ 中轉換為其對應的數據類型。 ```py class airflow.contrib.operators.databricks_operator.DatabricksSubmitRunOperator（json = None，spark_jar_task = None，notebook_task = None，new_cluster = None，existing_cluster_id = None，libraries = None，run_name = None，timeout_seconds = None，databricks_conn_id ='databricks_default'，polling_period_seconds = 30，databricks_retry_limit = 3，do_xcom_push = False，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 使用[api / 2.0 / jobs / runs / submit](https://docs.databricks.com/api/latest/jobs.html) API 端點向 Databricks 提交 Spark 作業運行。有兩種方法可以實例化此運算符。在第一種方式，你可以把你通常用它來調用的 JSON 有效載荷`api/2.0/jobs/runs/submit`端點并將其直接傳遞到我們`DatabricksSubmitRunOperator`通過`json`參數。例如 ```py json = { 'new_cluster' : { 'spark_version' : '2.1.0-db3-scala2.11' , 'num_workers' : 2 }, 'notebook_task' : { 'notebook_path' : '/Users/airflow@example.com/PrepareData' , }, } notebook_run = DatabricksSubmitRunOperator ( task_id = 'notebook_run' , json = json ) ``` 另一種完成同樣事情的方法是直接使用命名參數`DatabricksSubmitRunOperator`。請注意，`runs/submit`端點中的每個頂級參數都只有一個命名參數。在此方法中，您的代碼如下所示： ```py new_cluster = { 'spark_version' : '2.1.0-db3-scala2.11' , 'num_workers' : 2 } notebook_task = { 'notebook_path' : '/Users/airflow@example.com/PrepareData' , } notebook_run = DatabricksSubmitRunOperator ( task_id = 'notebook_run' , new_cluster = new_cluster , notebook_task = notebook_task ) ``` 在提供 json 參數**和**命名參數的情況下，它們將合并在一起。如果在合并期間存在沖突，則命名參數將優先并覆蓋頂級`json`鍵。 ```py 目前 DatabricksSubmitRunOperator 支持的命名參數是 ``` * `spark_jar_task` * `notebook_task` * `new_cluster` * `existing_cluster_id` * `libraries` * `run_name` * `timeout_seconds` 參數： * `json(dict)` - 包含 API 參數的 JSON 對象，將直接傳遞給`api/2.0/jobs/runs/submit`端點。其他命名參數（即`spark_jar_task`，`notebook_task`..）到該運營商將與此 JSON 字典合并如果提供他們。如果在合并期間存在沖突，則命名參數將優先并覆蓋頂級 json 鍵。（模板）也可以看看有關模板的更多信息，請參閱[Jinja 模板](concepts.html)。[https://docs.databricks.com/api/latest/jobs.html#runs-submit](https://docs.databricks.com/api/latest/jobs.html) * `spark_jar_task(dict)` - JAR 任務的主要類和參數。請注意，實際的 JAR 在`libraries`。中指定。_ 無論是 _ `spark_jar_task` 或 `notebook_task`應符合規定。該字段將被模板化。也可以看看 [https://docs.databricks.com/api/latest/jobs.html#jobssparkjartask](https://docs.databricks.com/api/latest/jobs.html) * `notebook_task(dict)` - 筆記本任務的筆記本路徑和參數。_ 無論是 _ `spark_jar_task` 或 `notebook_task`應符合規定。該字段將被模板化。也可以看看 [https://docs.databricks.com/api/latest/jobs.html#jobsnotebooktask](https://docs.databricks.com/api/latest/jobs.html) * `new_cluster(dict)` - 將在其上運行此任務的新群集的規范。_ 無論是 _ `new_cluster` 或 `existing_cluster_id`應符合規定。該字段將被模板化。也可以看看 [https://docs.databricks.com/api/latest/jobs.html#jobsclusterspecnewcluster](https://docs.databricks.com/api/latest/jobs.html) * `existing_cluster_id(string)` - 要運行此任務的現有集群的 ID。_ 無論是 _ `new_cluster` 或 `existing_cluster_id`應符合規定。該字段將被模板化。 * `圖書館(_dicts 列表 _)` - 這個運行的庫將使用。該字段將被模板化。也可以看看 [https://docs.databricks.com/api/latest/libraries.html#managedlibrarieslibrary](https://docs.databricks.com/api/latest/libraries.html) * `run_name(string)` - 用于此任務的運行名稱。默認情況下，這將設置為 Airflow `task_id`。這`task_id`是超類的必需參數`BaseOperator`。該字段將被模板化。 * `timeout_seconds(_int32_)` - 此次運行的超時。默認情況下，使用值 0 表示沒有超時。該字段將被模板化。 * `databricks_conn_id(string)` - 要使用的 Airflow 連接的名稱。默認情況下，在常見情況下，這將是`databricks_default`。要使用基于令牌的身份驗證，請`token`在連接的額外字段中提供密鑰。 * `polling_period_seconds(int)` - 控制我們輪詢此運行結果的速率。默認情況下，操作員每 30 秒輪詢一次。 * `databricks_retry_limit(int)` - 如果 Databricks 后端無法訪問，則重試的次數。其值必須大于或等于 1。 * `do_xcom_push(_boolean_)` - 我們是否應該將 run_id 和 run_page_url 推送到 xcom。 ```py class airflow.contrib.operators.dataflow_operator.DataFlowJavaOperator（jar，dataflow_default_options = None，options = None，gcp_conn_id ='google_cloud_default'，delegate_to = None，poll_sleep = 10，job_class = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 啟動 Java Cloud DataFlow 批處理作業。操作的參數將傳遞給作業。在 dag 的 default_args 中定義 dataflow_ *參數是一個很好的做法，例如項目，區域和分段位置。 ```py default_args = { 'dataflow_default_options' : { 'project' : 'my-gcp-project' , 'zone' : 'europe-west1-d' , 'stagingLocation' : 'gs://my-staging-bucket/staging/' } } ``` 您需要使用`jar`參數將路徑作為文件引用傳遞給數據流，jar 需要是一個自動執行的 jar（請參閱以下文檔：[https](https://beam.apache.org/documentation/runners/dataflow/)：[//beam.apache.org/documentation/runners/dataflow/#self-執行 jar](https://beam.apache.org/documentation/runners/dataflow/)。使用`options`轉嫁選項你的工作。 ```py t1 = DataFlowOperation ( task_id = 'datapflow_example' , jar = '{{var.value.gcp_dataflow_base}}pipeline/build/libs/pipeline-example-1.0.jar' , options = { 'autoscalingAlgorithm' : 'BASIC' , 'maxNumWorkers' : '50' , 'start' : '{{ds}}' , 'partitionType' : 'DAY' , 'labels' : { 'foo' : 'bar' } }, gcp_conn_id = 'gcp-airflow-service-account' , dag = my - dag ) ``` 這兩個`jar`和`options`模板化，所以你可以在其中使用變量。 ```py class airflow.contrib.operators.dataflow_operator.DataflowTemplateOperator（template，dataflow_default_options = None，parameters = None，gcp_conn_id ='google_cloud_default'，delegate_to = None，poll_sleep = 10，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 啟動模板化云 DataFlow 批處理作業。操作的參數將傳遞給作業。在 dag 的 default_args 中定義 dataflow_ *參數是一個很好的做法，例如項目，區域和分段位置。也可以看看 [https://cloud.google.com/dataflow/docs/reference/rest/v1b3/LaunchTemplateParameters ](https://cloud.google.com/dataflow/docs/reference/rest/v1b3/LaunchTemplateParameters)[https://cloud.google.com/dataflow/docs/reference/rest/v1b3/RuntimeEnvironment](https://cloud.google.com/dataflow/docs/reference/rest/v1b3/RuntimeEnvironment) ```py default_args = { 'dataflow_default_options' : { 'project' : 'my-gcp-project' 'zone' : 'europe-west1-d' , 'tempLocation' : 'gs://my-staging-bucket/staging/' } } } ``` 您需要將路徑作為帶`template`參數的文件引用傳遞給數據流模板。使用`parameters`來傳遞參數給你的工作。使用`environment`對運行環境變量傳遞給你的工作。 ```py t1 = DataflowTemplateOperator ( task_id = 'datapflow_example' , template = '{{var.value.gcp_dataflow_base}}' , parameters = { 'inputFile' : "gs://bucket/input/my_input.txt" , 'outputFile' : "gs://bucket/output/my_output.txt" }, gcp_conn_id = 'gcp-airflow-service-account' , dag = my - dag ) ``` `template`，`dataflow_default_options`并且`parameters`是模板化的，因此您可以在其中使用變量。 ```py class airflow.contrib.operators.dataflow_operator.DataFlowPythonOperator（py_file，py_options = None，dataflow_default_options = None，options = None，gcp_conn_id ='google_cloud_default'，delegate_to = None，poll_sleep = 10，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") ```py 執行（上下文） ``` 執行 python 數據流作業。 ```py class airflow.contrib.operators.dataproc_operator.DataprocClusterCreateOperator（cluster_name，project_id，num_workers，zone，network_uri = None，subnetwork_uri = None，internal_ip_only = None，tags = None，storage_bucket = None，init_actions_uris = None，init_action_timeout ='10m'，metadata =無，image_version =無，屬性=無，master_machine_type ='n1-standard-4'，master_disk_size = 500，worker_machine_type ='n1-standard-4'，worker_disk_size = 500，num_preemptible_workers = 0，labels = None，region =' global'，gcp_conn_id ='google_cloud_default'，delegate_to = None，service_account = None，service_account_scopes = None，idle_delete_ttl = None，auto_delete_time = None，auto_delete_ttl = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 Google Cloud Dataproc 上創建新群集。操作員將等待創建成功或創建過程中發生錯誤。參數允許配置群集。請參閱 [https://cloud.google.com/dataproc/docs/reference/rest/v1/projects.regions.clusters](https://cloud.google.com/dataproc/docs/reference/rest/v1/projects.regions.clusters) 有關不同參數的詳細說明。鏈接中詳述的大多數配置參數都可作為此運算符的參數。參數： * `cluster_name(string)` - 要創建的 DataProc 集群的名稱。（模板） * `project_id(string)` - 用于創建集群的 Google 云項目的 ID。（模板） * `num_workers(int)` - 旋轉的工人數量 * `storage_bucket(string)` - 要使用的存儲桶，設置為 None 允許 dataproc 為您生成自定義存儲桶 * `init_actions_uris(_list __[ __string __]_)` - 包含數據空間初始化腳本的 GCS uri 列表 * `init_action_timeout(string)` - init_actions_uris 中可執行腳本必須完成的時間 * `元數據(_ 字典 _)` - 要添加到所有實例的鍵值 google 計算引擎元數據條目的字典 * `image_version(string)` - Dataproc 集群內的軟件版本 * `屬性(_ 字典 _)` -性能上的配置文件設置的字典（如火花 defaults.conf），見[https://cloud.google.com/dataproc/docs/reference/rest/v1/](https://cloud.google.com/dataproc/docs/reference/rest/v1/) projects.regions.clusters＃SoftwareConfig * `master_machine_type(string)` - 計算要用于主節點的引擎機器類型 * `master_disk_size(int)` - 主節點的磁盤大小 * `worker_machine_type(string)` - 計算要用于工作節點的引擎計算機類型 * `worker_disk_size(int)` - 工作節點的磁盤大小 * `num_preemptible_workers(int)` - 要旋轉的可搶占工作節點數 * `labels(dict)` - 要添加到集群的標簽的字典 * `zone(string)` - 群集所在的區域。（模板） * `network_uri(string)` - 用于機器通信的網絡 uri，不能用 subnetwork_uri 指定 * `subnetwork_uri(string)` - 無法使用 network_uri 指定要用于機器通信的子網 uri * `internal_ip_only(bool)` - 如果為 true，則群集中的所有實例將只具有內部 IP 地址。這只能為啟用子網的網絡啟用 * `tags(_list __[ __string __]_)` - 要添加到所有實例的 GCE 標記 * `地區` - 作為'全球'留下，可能在未來變得相關。（模板） * `gcp_conn_id(string)` - 用于連接到 Google Cloud Platform 的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `service_account(string)` - dataproc 實例的服務帳戶。 * `service_account_scopes(_list __[ __string __]_)` - 要包含的服務帳戶范圍的 URI。 * `idle_delete_ttl(int)` - 群集在保持空閑狀態時保持活動狀態的最長持續時間。通過此閾值將導致群集被自動刪除。持續時間（秒）。 * `auto_delete_time(_datetime.datetime_)` - 自動刪除群集的時間。 * `auto_delete_ttl(int)` - 群集的生命周期，群集將在此持續時間結束時自動刪除。持續時間（秒）。（如果設置了 auto_delete_time，則將忽略此參數） ```py class airflow.contrib.operators.dataproc_operator.DataprocClusterScaleOperator（cluster_name，project_id，region ='global'，gcp_conn_id ='google_cloud_default'，delegate_to = None，num_workers = 2，num_preemptible_workers = 0，graceful_decommission_timeout = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 Google Cloud Dataproc 上進行擴展，向上或向下擴展。操作員將等待，直到重新調整群集。 **示例** ： ```py t1 = DataprocClusterScaleOperator（ ``` task_id ='dataproc_scale'，project_id ='my-project'，cluster_name ='cluster-1'，num_workers = 10，num_preemptible_workers = 10，graceful_decommission_timeout ='1h'dag = dag）也可以看看有關擴展群集的更多詳細信息，請參閱以下參考：[https](https://cloud.google.com/dataproc/docs/concepts/configuring-clusters/scaling-clusters)：[//cloud.google.com/dataproc/docs/concepts/configuring-clusters/scaling-clusters](https://cloud.google.com/dataproc/docs/concepts/configuring-clusters/scaling-clusters) 參數： * `cluster_name(string)` - 要擴展的集群的名稱。（模板） * `project_id(string)` - 群集運行的 Google 云項目的 ID。（模板） * `region(string)` - 數據通路簇的區域。（模板） * `gcp_conn_id(string)` - 用于連接到 Google Cloud Platform 的連接 ID。 * `num_workers(int)` - 新的工人數量 * `num_preemptible_workers(int)` - 新的可搶占工人數量 * `graceful_decommission_timeout(string)` - 優雅的 YARN decomissioning 超時。最大值為 1d * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py class airflow.contrib.operators.dataproc_operator.DataprocClusterDeleteOperator（cluster_name，project_id，region ='global'，gcp_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 刪除 Google Cloud Dataproc 上的群集。操作員將等待，直到群集被銷毀。參數： * `cluster_name(string)` - 要創建的集群的名稱。（模板） * `project_id(string)` - 群集運行的 Google 云項目的 ID。（模板） * `region(string)` - 保留為“全局”，將來可能會變得相關。（模板） * `gcp_conn_id(string)` - 用于連接到 Google Cloud Platform 的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py class airflow.contrib.operators.dataproc_operator.DataProcPigOperator（query = None，query_uri = None，variables = None，job_name ='{{task.task_id}} _ {{ds_nodash}}'，cluster_name ='cluster-1'，dataproc_pig_properties =無，dataproc_pig_jars =無，gcp_conn_id ='google_cloud_default'，delegate_to =無，region ='全局'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 Cloud DataProc 群集上啟動 Pig 查詢作業。操作的參數將傳遞給集群。在 dag 的 default_args 中定義 dataproc_ *參數是一種很好的做法，比如集群名稱和 UDF。 ```py default_args = { 'cluster_name' : 'cluster-1' , 'dataproc_pig_jars' : [ 'gs://example/udf/jar/datafu/1.2.0/datafu.jar' , 'gs://example/udf/jar/gpig/1.2/gpig.jar' ] } ``` 您可以將 pig 腳本作為字符串或文件引用傳遞。使用變量傳遞要在群集上解析的 pig 腳本的變量，或者使用要在腳本中解析的參數作為模板參數。 **示例** ： ```py t1 = DataProcPigOperator ( task_id = 'dataproc_pig' , query = 'a_pig_script.pig' , variables = { 'out' : 'gs://example/output/{{ds}}' }, dag = dag ) ``` 也可以看看有關工作提交的更多詳細信息，請參閱以下參考：[https](https://cloud.google.com/dataproc/reference/rest/v1/projects.regions.jobs)：[//cloud.google.com/dataproc/reference/rest/v1/projects.regions.jobs](https://cloud.google.com/dataproc/reference/rest/v1/projects.regions.jobs) 參數： * `query(string)` - 對查詢文件的查詢或引用（pg 或 pig 擴展）。（模板） * `query_uri(string)` - 云存儲上的豬腳本的 uri。 * `variables(dict)` - 查詢的命名參數的映射。（模板） * `job_name(string)` - DataProc 集群中使用的作業名稱。默認情況下，此名稱是附加執行數據的 task_id，但可以進行模板化。該名稱將始終附加一個隨機數，以避免名稱沖突。（模板） * `cluster_name(string)` - DataProc 集群的名稱。（模板） * `dataproc_pig_properties(dict)` - Pig 屬性的映射。非常適合放入默認參數 * `dataproc_pig_jars(list)` - 在云存儲中配置的 jars 的 URI（例如：用于 UDF 和 lib），非常適合放入默認參數。 * `gcp_conn_id(string)` - 用于連接到 Google Cloud Platform 的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `region(string)` - 創建數據加載集群的指定區域。 ```py class airflow.contrib.operators.dataproc_operator.DataProcHiveOperator（query = None，query_uri = None，variables = None，job_name ='{{task.task_id}} _ {{ds_nodash}}'，cluster_name ='cluster-1'，dataproc_hive_properties =無，dataproc_hive_jars =無，gcp_conn_id ='google_cloud_default'，delegate_to =無，region ='全局'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 Cloud DataProc 群集上啟動 Hive 查詢作業。參數： * `query(string)` - 查詢或對查詢文件的引用（q 擴展名）。 * `query_uri(string)` - 云存儲上的 hive 腳本的 uri。 * `variables(dict)` - 查詢的命名參數的映射。 * `job_name(string)` - DataProc 集群中使用的作業名稱。默認情況下，此名稱是附加執行數據的 task_id，但可以進行模板化。該名稱將始終附加一個隨機數，以避免名稱沖突。 * `cluster_name(string)` - DataProc 集群的名稱。 * `dataproc_hive_properties(dict)` - Pig 屬性的映射。非常適合放入默認參數 * `dataproc_hive_jars(list)` - 在云存儲中配置的 jars 的 URI（例如：用于 UDF 和 lib），非常適合放入默認參數。 * `gcp_conn_id(string)` - 用于連接到 Google Cloud Platform 的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `region(string)` - 創建數據加載集群的指定區域。 ```py class airflow.contrib.operators.dataproc_operator.DataProcSparkSqlOperator（query = None，query_uri = None，variables = None，job_name ='{{task.task_id}} _ {{ds_nodash}}'，cluster_name ='cluster-1'，dataproc_spark_properties =無，dataproc_spark_jars =無，gcp_conn_id ='google_cloud_default'，delegate_to =無，region ='全局'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 Cloud DataProc 集群上啟動 Spark SQL 查詢作業。參數： * `query(string)` - 查詢或對查詢文件的引用（q 擴展名）。（模板） * `query_uri(string)` - 云存儲上的一個 spark sql 腳本的 uri。 * `variables(dict)` - 查詢的命名參數的映射。（模板） * `job_name(string)` - DataProc 集群中使用的作業名稱。默認情況下，此名稱是附加執行數據的 task_id，但可以進行模板化。該名稱將始終附加一個隨機數，以避免名稱沖突。（模板） * `cluster_name(string)` - DataProc 集群的名稱。（模板） * `dataproc_spark_properties(dict)` - Pig 屬性的映射。非常適合放入默認參數 * `dataproc_spark_jars(list)` - 在云存儲中配置的 jars 的 URI（例如：用于 UDF 和 lib），非常適合放入默認參數。 * `gcp_conn_id(string)` - 用于連接到 Google Cloud Platform 的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `region(string)` - 創建數據加載集群的指定區域。 ```py class airflow.contrib.operators.dataproc_operator.DataProcSparkOperator（main_jar = None，main_class = None，arguments = None，archives = None，files = None，job_name ='{{task.task_id}} _ {{ds_nodash}}'，cluster_name ='cluster-1'，dataproc_spark_properties =無，dataproc_spark_jars =無，gcp_conn_id ='google_cloud_default'，delegate_to =無，region ='全局'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 Cloud DataProc 群集上啟動 Spark 作業。參數： * `main_jar(string)` - 在云存儲上配置的作業 jar 的 URI。（使用 this 或 main_class，而不是兩者一起）。 * `main_class(string)` - 作業類的名稱。（使用 this 或 main_jar，而不是兩者一起）。 * `arguments(list)` - 作業的參數。（模板） * `archives(list)` - 將在工作目錄中解壓縮的已歸檔文件列表。應存儲在云存儲中。 * `files(list)` - 要復制到工作目錄的文件列表 * `job_name(string)` - DataProc 集群中使用的作業名稱。默認情況下，此名稱是附加執行數據的 task_id，但可以進行模板化。該名稱將始終附加一個隨機數，以避免名稱沖突。（模板） * `cluster_name(string)` - DataProc 集群的名稱。（模板） * `dataproc_spark_properties(dict)` - Pig 屬性的映射。非常適合放入默認參數 * `dataproc_spark_jars(list)` - 在云存儲中配置的 jars 的 URI（例如：用于 UDF 和 lib），非常適合放入默認參數。 * `gcp_conn_id(string)` - 用于連接到 Google Cloud Platform 的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `region(string)` - 創建數據加載集群的指定區域。 ```py class airflow.contrib.operators.dataproc_operator.DataProcHadoopOperator（main_jar = None，main_class = None，arguments = None，archives = None，files = None，job_name ='{{task.task_id}} _ {{ds_nodash}}'，cluster_name ='cluster-1'，dataproc_hadoop_properties =無，dataproc_hadoop_jars =無，gcp_conn_id ='google_cloud_default'，delegate_to =無，region ='全局'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 Cloud DataProc 群集上啟動 Hadoop 作業。參數： * `main_jar(string)` - 在云存儲上配置的作業 jar 的 URI。（使用 this 或 main_class，而不是兩者一起）。 * `main_class(string)` - 作業類的名稱。（使用 this 或 main_jar，而不是兩者一起）。 * `arguments(list)` - 作業的參數。（模板） * `archives(list)` - 將在工作目錄中解壓縮的已歸檔文件列表。應存儲在云存儲中。 * `files(list)` - 要復制到工作目錄的文件列表 * `job_name(string)` - DataProc 集群中使用的作業名稱。默認情況下，此名稱是附加執行數據的 task_id，但可以進行模板化。該名稱將始終附加一個隨機數，以避免名稱沖突。（模板） * `cluster_name(string)` - DataProc 集群的名稱。（模板） * `dataproc_hadoop_properties(dict)` - Pig 屬性的映射。非常適合放入默認參數 * `dataproc_hadoop_jars(list)` - 在云存儲中配置的 jars 的 URI（例如：用于 UDF 和 lib），非常適合放入默認參數。 * `gcp_conn_id(string)` - 用于連接到 Google Cloud Platform 的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `region(string)` - 創建數據加載集群的指定區域。 ```py class airflow.contrib.operators.dataproc_operator.DataProcPySparkOperator（main，arguments = None，archives = None，pyfiles = None，files = None，job_name ='{{task.task_id}} _ {{ds_nodash}}'，cluster_name =' cluster-1'，dataproc_pyspark_properties = None，dataproc_pyspark_jars = None，gcp_conn_id ='google_cloud_default'，delegate_to = None，region ='global'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 Cloud DataProc 群集上啟動 PySpark 作業。參數： * `main(string)` - [必需]用作驅動程序的主 Python 文件的 Hadoop 兼容文件系統（HCFS）URI。必須是.py 文件。 * `arguments(list)` - 作業的參數。（模板） * `archives(list)` - 將在工作目錄中解壓縮的已歸檔文件列表。應存儲在云存儲中。 * `files(list)` - 要復制到工作目錄的文件列表 * `pyfiles(list)` - 要傳遞給 PySpark 框架的 Python 文件列表。支持的文件類型：.py，.egg 和.zip * `job_name(string)` - DataProc 集群中使用的作業名稱。默認情況下，此名稱是附加執行數據的 task_id，但可以進行模板化。該名稱將始終附加一個隨機數，以避免名稱沖突。（模板） * `cluster_name(string)` - DataProc 集群的名稱。 * `dataproc_pyspark_properties(dict)` - Pig 屬性的映射。非常適合放入默認參數 * `dataproc_pyspark_jars(list)` - 在云存儲中配置的 jars 的 URI（例如：用于 UDF 和 lib），非常適合放入默認參數。 * `gcp_conn_id(string)` - 用于連接到 Google Cloud Platform 的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `region(string)` - 創建數據加載集群的指定區域。 ```py class airflow.contrib.operators.dataproc_operator.DataprocWorkflowTemplateBaseOperator（project_id，region ='global'，gcp_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") ```py class airflow.contrib.operators.dataproc_operator.DataprocWorkflowTemplateInstantiateOperator（template_id，* args，** kwargs） ``` 基類： [`airflow.contrib.operators.dataproc_operator.DataprocWorkflowTemplateBaseOperator`](31 "airflow.contrib.operators.dataproc_operator.DataprocWorkflowTemplateBaseOperator") 在 Google Cloud Dataproc 上實例化 WorkflowTemplate。操作員將等待 WorkflowTemplate 完成執行。也可以看看請參閱：[https](https://cloud.google.com/dataproc/docs/reference/rest/v1beta2/projects.regions.workflowTemplates/instantiate)：[//cloud.google.com/dataproc/docs/reference/rest/v1beta2/projects.regions.workflowTemplates/instantiate](https://cloud.google.com/dataproc/docs/reference/rest/v1beta2/projects.regions.workflowTemplates/instantiate) 參數： * `template_id(string)` - 模板的 id。（模板） * `project_id(string)` - 模板運行所在的 Google 云項目的 ID * `region(string)` - 保留為“全局”，將來可能會變得相關 * `gcp_conn_id(string)` - 用于連接到 Google Cloud Platform 的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py class airflow.contrib.operators.dataproc_operator.DataprocWorkflowTemplateInstantiateInlineOperator（template，* args，** kwargs） ``` 基類： [`airflow.contrib.operators.dataproc_operator.DataprocWorkflowTemplateBaseOperator`](31 "airflow.contrib.operators.dataproc_operator.DataprocWorkflowTemplateBaseOperator") 在 Google Cloud Dataproc 上實例化 WorkflowTemplate 內聯。操作員將等待 WorkflowTemplate 完成執行。也可以看看請參閱：[https](https://cloud.google.com/dataproc/docs/reference/rest/v1beta2/projects.regions.workflowTemplates/instantiateInline)：[//cloud.google.com/dataproc/docs/reference/rest/v1beta2/projects.regions.workflowTemplates/instantiateInline](https://cloud.google.com/dataproc/docs/reference/rest/v1beta2/projects.regions.workflowTemplates/instantiateInline) 參數： * `template(_map_)` - 模板內容。（模板） * `project_id(string)` - 模板運行所在的 Google 云項目的 ID * `region(string)` - 保留為“全局”，將來可能會變得相關 * `gcp_conn_id(string)` - 用于連接到 Google Cloud Platform 的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py class airflow.contrib.operators.datastore_export_operator.DatastoreExportOperator（bucket，namespace = None，datastore_conn_id ='google_cloud_default'，cloud_storage_conn_id ='google_cloud_default'，delegate_to = None，entity_filter = None，labels = None，polling_interval_in_seconds = 10，overwrite_existing = False，xcom_push =假，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將實體從 Google Cloud Datastore 導出到云存儲參數： * `bucket(string)` - 要備份數據的云存儲桶的名稱 * `namespace(str)` - 指定云存儲桶中用于備份數據的可選命名空間路徑。如果 GCS 中不存在此命名空間，則將創建該命名空間。 * `datastore_conn_id(string)` - 要使用的數據存儲區連接 ID 的名稱 * `cloud_storage_conn_id(string)` - 強制寫入備份的云存儲連接 ID 的名稱 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `entity_filter(dict)` - 導出中包含項目中哪些數據的說明，請參閱[https://cloud.google.com/datastore/docs/reference/rest/Shared.Types/EntityFilter](https://cloud.google.com/datastore/docs/reference/rest/Shared.Types/EntityFilter) * `labels(dict)` - 客戶端分配的云存儲標簽 * `polling_interval_in_seconds(int)` - 再次輪詢執行狀態之前等待的秒數 * `overwrite_existing(bool)` - 如果存儲桶+命名空間不為空，則在導出之前將清空它。這樣可以覆蓋現有備份。 * `xcom_push(bool)` - 將操作名稱推送到 xcom 以供參考 ```py class airflow.contrib.operators.datastore_import_operator.DatastoreImportOperator（bucket，file，namespace = None，entity_filter = None，labels = None，datastore_conn_id ='google_cloud_default'，delegate_to = None，polling_interval_in_seconds = 10，xcom_push = False，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將實體從云存儲導入 Google Cloud Datastore 參數： * `bucket(string)` - 云存儲中用于存儲數據的容器 * `file(string)` - 指定云存儲桶中備份元數據文件的路徑。它應該具有擴展名.overall_export_metadata * `namespace(str)` - 指定云存儲桶中備份元數據文件的可選命名空間。 * `entity_filter(dict)` - 導出中包含項目中哪些數據的說明，請參閱[https://cloud.google.com/datastore/docs/reference/rest/Shared.Types/EntityFilter](https://cloud.google.com/datastore/docs/reference/rest/Shared.Types/EntityFilter) * `labels(dict)` - 客戶端分配的云存儲標簽 * `datastore_conn_id(string)` - 要使用的連接 ID 的名稱 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `polling_interval_in_seconds(int)` - 再次輪詢執行狀態之前等待的秒數 * `xcom_push(bool)` - 將操作名稱推送到 xcom 以供參考 ```py class airflow.contrib.operators.discord_webhook_operator.DiscordWebhookOperator（http_conn_id = None，webhook_endpoint = None，message =''，username = None，avatar_url = None，tts = False，proxy = None，* args，** kwargs） ``` 基類： [`airflow.operators.http_operator.SimpleHttpOperator`](31 "airflow.operators.http_operator.SimpleHttpOperator") 此運算符允許您使用傳入的 webhook 將消息發布到 Discord。使用默認相對 webhook 端點獲取 Discord 連接 ID。可以使用 webhook_endpoint 參數（[https://discordapp.com/developers/docs/resources/webhook](https://discordapp.com/developers/docs/resources/webhook)）覆蓋默認端點。每個 Discord webhook 都可以預先配置為使用特定的用戶名和 avatar_url。您可以在此運算符中覆蓋這些默認值。參數： * `http_conn_id(str)` - Http 連接 ID，主機為“ [https://discord.com/api/](https://discord.com/api/) ”，默認 webhook 端點在額外字段中，格式為{“webhook_endpoint”：“webhooks / {webhook.id} / { webhook.token}” * `webhook_endpoint(str)` - 以“webhooks / {webhook.id} / {webhook.token}”的形式 Discord webhook 端點 * `message(str)` - 要發送到 Discord 頻道的消息（最多 2000 個字符）。（模板） * `username(str)` - 覆蓋 webhook 的默認用戶名。（模板） * `avatar_url(str)` - 覆蓋 webhook 的默認頭像 * `tts(bool)` - 是一個文本到語音的消息 * `proxy(str)` - 用于進行 Discord webhook 調用的代理 ```py 執行（上下文） ``` 調用 DiscordWebhookHook 發布消息 ```py class airflow.contrib.operators.druid_operator.DruidOperator（json_index_file，druid_ingest_conn_id ='druid_ingest_default'，max_ingestion_time = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 允許直接向德魯伊提交任務參數： * `json_index_file(str)` - 德魯伊索引規范的文件路徑 * `druid_ingest_conn_id(str)` - 接受索引作業的德魯伊霸主的連接 ID ```py class airflow.contrib.operators.ecs_operator.ECSOperator（task_definition，cluster，overrides，aws_conn_id = None，region_name = None，launch_type ='EC2'，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 AWS EC2 Container Service 上執行任務參數： * `task_definition(str)` - EC2 容器服務上的任務定義名稱 * `cluster(str)` - EC2 Container Service 上的群集名稱 * `aws_conn_id(str)` - AWS 憑證/區域名稱的連接 ID。如果為 None，將使用憑證 boto3 策略（[http://boto3.readthedocs.io/en/latest/guide/configuration.html](http://boto3.readthedocs.io/en/latest/guide/configuration.html)）。 * `region_name` - 要在 AWS Hook 中使用的區域名稱。覆蓋連接中的 region_name（如果提供） * `launch_type` - 運行任務的啟動類型（'EC2'或'FARGATE'） | 帕拉姆： | 覆蓋：boto3 將接收的相同參數（模板化）：[http](http://boto3.readthedocs.org/en/latest/reference/services/ecs.html)：//boto3.readthedocs.org/en/latest/reference/services/ecs.html#ECS.Client.run_task[](http://boto3.readthedocs.org/en/latest/reference/services/ecs.html)類型：覆蓋：dict 類型： launch_type：str ```py class airflow.contrib.operators.emr_add_steps_operator.EmrAddStepsOperator（job_flow_id，aws_conn_id ='s3_default'，steps = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 向現有 EMR job_flow 添加步驟的運算符。參數： * `job_flow_id` - 要添加步驟的 JobFlow 的 ID。（模板） * `aws_conn_id(str)` - 與使用的 aws 連接 * `步驟(list)` - 要添加到作業流的 boto3 樣式步驟。（模板） ```py class airflow.contrib.operators.emr_create_job_flow_operator.EmrCreateJobFlowOperator（aws_conn_id ='s3_default'，emr_conn_id ='emr_default'，job_flow_overrides = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 創建 EMR JobFlow，從 EMR 連接讀取配置。可以傳遞 JobFlow 覆蓋的字典，覆蓋連接中的配置。參數： * `aws_conn_id(str)` - 與使用的 aws 連接 * `emr_conn_id(str)` - 要使用的 emr 連接 * `job_flow_overrides` - 用于覆蓋 emr_connection extra 的 boto3 樣式參數。（模板） ```py class airflow.contrib.operators.emr_terminate_job_flow_operator.EmrTerminateJobFlowOperator（job_flow_id，aws_conn_id ='s3_default'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 運營商終止 EMR JobFlows。參數： * `job_flow_id` - 要終止的 JobFlow 的 id。（模板） * `aws_conn_id(str)` - 與使用的 aws 連接 ```py class airflow.contrib.operators.file_to_gcs.FileToGoogleCloudStorageOperator（src，dst，bucket，google_cloud_storage_conn_id ='google_cloud_default'，mime_type ='application / octet-stream'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將文件上傳到 Google 云端存儲參數： * `src(string)` - 本地文件的路徑。（模板） * `dst(string)` - 指定存儲桶中的目標路徑。（模板） * `bucket(string)` - 要上傳的存儲桶。（模板） * `google_cloud_storage_conn_id(string)` - 要上傳的 Airflow 連接 ID * `mime_type(string)` - mime 類型字符串 * `delegate_to(string)` - 模擬的帳戶（如果有） ```py 執行（上下文） ``` 將文件上傳到 Google 云端存儲 ```py class airflow.contrib.operators.file_to_wasb.FileToWasbOperator（file_path，container_name，blob_name，wasb_conn_id ='wasb_default'，load_options = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將文件上載到 Azure Blob 存儲。參數： * `file_path(str)` - 要加載的文件的路徑。（模板） * `container_name(str)` - 容器的名稱。（模板） * `blob_name(str)` - blob 的名稱。（模板） * `wasb_conn_id(str)` - 對 wasb 連接的引用。 * `load_options(dict)` - `WasbHook.load_file（）`采用的可選關鍵字參數。 ```py 執行（上下文） ``` 將文件上載到 Azure Blob 存儲。 ```py class airflow.contrib.operators.gcp_container_operator.GKEClusterCreateOperator（project_id，location，body = {}，gcp_conn_id ='google_cloud_default'，api_version ='v2'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") ```py class airflow.contrib.operators.gcp_container_operator.GKEClusterDeleteOperator（project_id，name，location，gcp_conn_id ='google_cloud_default'，api_version ='v2'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") ```py class airflow.contrib.operators.gcs_download_operator.GoogleCloudStorageDownloadOperator（bucket，object，filename = None，store_to_xcom_key = None，google_cloud_storage_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 從 Google 云端存儲下載文件。參數： * `bucket(string)` - 對象所在的 Google 云存儲桶。（模板） * `object(string)` - 要在 Google 云存儲桶中下載的對象的名稱。（模板） * `filename(string)` - 應將文件下載到的本地文件系統（正在執行操作符的位置）上的文件路徑。（模板化）如果未傳遞文件名，則下載的數據將不會存儲在本地文件系統中。 * `store_to_xcom_key(string)` - 如果設置了此參數，操作員將使用此參數中設置的鍵將下載文件的內容推送到 XCom。如果未設置，則下載的數據不會被推送到 XCom。（模板） * `google_cloud_storage_conn_id(string)` - 連接到 Google 云端存儲時使用的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py class airflow.contrib.operators.gcslistoperator.GoogleCloudStorageListOperator（bucket，prefix = None，delimiter = None，google_cloud_storage_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 使用名稱中的給定字符串前綴和分隔符列出存儲桶中的所有對象。 ```py 此運算符返回一個 python 列表，其中包含可供其使用的對象的名稱 ``` <cite>xcom</cite>在下游任務中。參數： * `bucket(string)` - 用于查找對象的 Google 云存儲桶。（模板） * `prefix(string)` - 前綴字符串，用于過濾名稱以此前綴開頭的對象。（模板） * `delimiter(string)` - 要過濾對象的分隔符。（模板化）例如，要列出 GCS 目錄中的 CSV 文件，您可以使用 delimiter ='。csv'。 * `google_cloud_storage_conn_id(string)` - 連接到 Google 云端存儲時使用的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py Example: ``` 以下運算符將列出存儲桶中文件`sales/sales-2017`夾中的所有 Avro 文件`data`。 ```py GCS_Files = GoogleCloudStorageListOperator ( task_id = 'GCS_Files' , bucket = 'data' , prefix = 'sales/sales-2017/' , delimiter = '.avro' , google_cloud_storage_conn_id = google_cloud_conn_id ) ``` ```py class airflow.contrib.operators.gcs_operator.GoogleCloudStorageCreateBucketOperator（bucket_name，storage_class ='MULTI_REGIONAL'，location ='US'，project_id = None，labels = None，google_cloud_storage_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 創建一個新存儲桶。Google 云端存儲使用平面命名空間，因此您無法創建名稱已在使用中的存儲桶。 > 也可以看看 > > 有關詳細信息，請參閱存儲桶命名指南：[https](https://cloud.google.com/storage/docs/bucketnaming.html)：[//cloud.google.com/storage/docs/bucketnaming.html#requirements](https://cloud.google.com/storage/docs/bucketnaming.html) 參數： * `bucket_name(string)` - 存儲桶的名稱。（模板） * `storage_class(string)` - 這定義了存儲桶中對象的存儲方式，并確定了 SLA 和存儲成本（模板化）。價值包括 * `MULTI_REGIONAL` * `REGIONAL` * `STANDARD` * `NEARLINE` * `COLDLINE` 。如果在創建存儲桶時未指定此值，則默認為 STANDARD。 * `位置(string)` - 水桶的位置。（模板化）存儲桶中對象的對象數據駐留在此區域內的物理存儲中。默認為美國。也可以看看 [https://developers.google.com/storage/docs/bucket-locations](https://developers.google.com/storage/docs/bucket-locations) * `project_id(string)` - GCP 項目的 ID。（模板） * `labels(dict)` - 用戶提供的鍵/值對標簽。 * `google_cloud_storage_conn_id(string)` - 連接到 Google 云端存儲時使用的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py Example: ``` 以下運算符將在區域中創建`test-bucket`具有`MULTI_REGIONAL`存儲類的新存儲桶`EU` ```py CreateBucket = GoogleCloudStorageCreateBucketOperator ( task_id = 'CreateNewBucket' , bucket_name = 'test-bucket' , storage_class = 'MULTI_REGIONAL' , location = 'EU' , labels = { 'env' : 'dev' , 'team' : 'airflow' }, google_cloud_storage_conn_id = 'airflow-service-account' ) ``` ```py class airflow.contrib.operators.gcs_to_bq.GoogleCloudStorageToBigQueryOperator（bucket，source_objects，destination_project_dataset_table，schema_fields = None，schema_object = None，source_format ='CSV'，compression ='NONE'，create_disposition ='CREATE_IF_NEEDED'，skip_leading_rows = 0，write_disposition =' WRITE_EMPTY'，field_delimiter ='，'，max_bad_records = 0，quote_character = None，ignore_unknown_values = False，allow_quoted_newlines = False，allow_jagged_rows = False，max_id_key = None，bigquery_conn_id ='bigquery_default'，google_cloud_storage_conn_id ='google_cloud_default'，delegate_to = None，schema_update_options =（），src_fmt_configs = {}，external_table = False，time_partitioning = {}，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將文件從 Google 云存儲加載到 BigQuery 中。可以用兩種方法之一指定用于 BigQuery 表的模式。您可以直接傳遞架構字段，也可以將運營商指向 Google 云存儲對象名稱。Google 云存儲中的對象必須是包含架構字段的 JSON 文件。參數： * `bucket(string)` - 要加載的桶。（模板） * `source_objects` - 要加載的 Google 云存儲 URI 列表。（模板化）如果 source_format 是'DATASTORE_BACKUP'，則列表必須只包含一個 URI。 * `destination_project_dataset_table(string)` - 用于加載數據的虛線（<project>。）<dataset>。<table> BigQuery 表。如果未包含<project>，則項目將是連接 json 中定義的項目。（模板） * `schema_fields(list)` - 如果設置，則此處定義的架構字段列表：[https](https://cloud.google.com/bigquery/docs/reference/v2/jobs)：**//cloud.google.com/bigquery/docs/reference/v2/jobs#configuration.load**當 source_format 為'DATASTORE_BACKUP'時，不應設置。 * `schema_object` - 如果設置，則指向包含表的架構的.json 文件的 GCS 對象路徑。（模板） * `schema_object` - 字符串 * `source_format(string)` - 要導出的文件格式。 * `compression(string)` - [可選]數據源的壓縮類型。可能的值包括 GZIP 和 NONE。默認值為 NONE。Google Cloud Bigtable，Google Cloud Datastore 備份和 Avro 格式會忽略此設置。 * `create_disposition(string)` - 如果表不存在，則創建處置。 * `skip_leading_rows(int)` - 從 CSV 加載時要跳過的行數。 * `write_disposition(string)` - 表已存在時的寫處置。 * `field_delimiter(string)` - 從 CSV 加載時使用的分隔符。 * `max_bad_records(int)` - BigQuery 在運行作業時可以忽略的最大錯誤記錄數。 * `quote_character(string)` - 用于引用 CSV 文件中數據部分的值。 * `ignore_unknown_values(bool)` - [可選]指示 BigQuery 是否應允許表模式中未表示的額外值。如果為 true，則忽略額外值。如果為 false，則將具有額外列的記錄視為錯誤記錄，如果錯誤記錄太多，則在作業結果中返回無效錯誤。 * `allow_quoted_newlines(_boolean_)` - 是否允許引用的換行符（true）或不允許（false）。 * `allow_jagged_rows(bool)` - 接受缺少尾隨可選列的行。缺失值被視為空值。如果為 false，則缺少尾隨列的記錄將被視為錯誤記錄，如果錯誤記錄太多，則會在作業結果中返回無效錯誤。僅適用于 CSV，忽略其他格式。 * `max_id_key(string)` - 如果設置，則是 BigQuery 表中要加載的列的名稱。在加載發生后，Thsi 將用于從 BigQuery 中選擇 MAX 值。結果將由 execute（）命令返回，該命令又存儲在 XCom 中供將來的操作員使用。這對增量加載很有幫助 - 在將來的執行過程中，您可以從最大 ID 中獲取。 * `bigquery_conn_id(string)` - 對特定 BigQuery 掛鉤的引用。 * `google_cloud_storage_conn_id(string)` - 對特定 Google 云存儲掛鉤的引用。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `schema_update_options(list)` - 允許更新目標表的模式作為加載作業的副作用。 * `src_fmt_configs(dict)` - 配置特定于源格式的可選字段 * `external_table(bool)` - 用于指定目標表是否應為 BigQuery 外部表的標志。默認值為 False。 * `time_partitioning(dict)` - 配置可選的時間分區字段，即按 API 規范按字段，類型和到期分區。請注意，“field”在 dataset.table $ partition 的并發中不可用。 ```py class airflow.contrib.operators.gcs_to_gcs.GoogleCloudStorageToGoogleCloudStorageOperator（source_bucket，source_object，destination_bucket = None，destination_object = None，move_object = False，google_cloud_storage_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將對象從存儲桶復制到另一個存儲桶，并在需要時重命名。參數： * `source_bucket(string)` - 對象所在的源 Google 云存儲桶。（模板） * `source_object(string)` - 要在 Google 云存儲分區中復制的對象的源名稱。（模板化）如果在此參數中使用通配符： > 您只能在存儲桶中使用一個通配符作為對象（文件名）。通配符可以出現在對象名稱內或對象名稱的末尾。不支持在存儲桶名稱中附加通配符。 * `destination_bucket` - 目標 Google 云端存儲分區對象應該在哪里。（模板化）：type destination_bucket：string：param destination_object：對象的目標名稱 > 目標 Google 云存儲桶。（模板化）如果在 source_object 參數中提供了通配符，則這是將添加到最終目標對象路徑的前綴。請注意，將刪除通配符之前的源路徑部分; 如果需要保留，則應將其附加到 destination_object。例如，使用 prefix `foo/*`和 destination_object'blah `/``，文件`foo/baz`將被復制到`blah/baz`; 保留前綴寫入 destination_object，例如`blah/foo`，在這種情況下，復制的文件將被命名`blah/foo/baz`。參數：`move_object` - 當移動對象為 True 時，移動對象 ```py 復制到新位置。 ``` 這相當于 mv 命令而不是 cp 命令。參數： * `google_cloud_storage_conn_id(string)` - 連接到 Google 云端存儲時使用的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py Examples: ``` 下面的操作將命名一個文件復制`sales/sales-2017/january.avro`在`data`桶的文件和名為斗`copied_sales/2017/january-backup.avro` in the ``data_backup` ```py copy_single_file = GoogleCloudStorageToGoogleCloudStorageOperator ( task_id = 'copy_single_file' , source_bucket = 'data' , source_object = 'sales/sales-2017/january.avro' , destination_bucket = 'data_backup' , destination_object = 'copied_sales/2017/january-backup.avro' , google_cloud_storage_conn_id = google_cloud_conn_id ) ``` 以下運算符會將文件`sales/sales-2017`夾中的所有 Avro 文件（即名稱以該前綴開頭）復制到存儲`data`桶中的`copied_sales/2017`文件夾中`data_backup`。 ```py copy_files = GoogleCloudStorageToGoogleCloudStorageOperator ( task_id = 'copy_files' , source_bucket = 'data' , source_object = 'sales/sales-2017/*.avro' , destination_bucket = 'data_backup' , destination_object = 'copied_sales/2017/' , google_cloud_storage_conn_id = google_cloud_conn_id ) ``` 以下運算符會將文件`sales/sales-2017`夾中的所有 Avro 文件（即名稱以該前綴開頭）移動到`data`存儲桶中的同一文件夾`data_backup`，刪除過程中的原始文件。 ```py move_files = GoogleCloudStorageToGoogleCloudStorageOperator ( task_id = 'move_files' , source_bucket = 'data' , source_object = 'sales/sales-2017/*.avro' , destination_bucket = 'data_backup' , move_object = True , google_cloud_storage_conn_id = google_cloud_conn_id ) ``` ```py class airflow.contrib.operators.gcs_to_s3.GoogleCloudStorageToS3Operator（bucket，prefix = None，delimiter = None，google_cloud_storage_conn_id ='google_cloud_storage_default'，delegate_to = None，dest_aws_conn_id = None，dest_s3_key = None，replace = False，* args，** kwargs） ``` 基類： [`airflow.contrib.operators.gcslistoperator.GoogleCloudStorageListOperator`](integration.html "airflow.contrib.operators.gcslistoperator.GoogleCloudStorageListOperator") 將 Google 云端存儲分區與 S3 分區同步。參數： * `bucket(string)` - 用于查找對象的 Google Cloud Storage 存儲桶。（模板） * `prefix(string)` - 前綴字符串，用于過濾名稱以此前綴開頭的對象。（模板） * `delimiter(string)` - 要過濾對象的分隔符。（模板化）例如，要列出 GCS 目錄中的 CSV 文件，您可以使用 delimiter ='。csv'。 * `google_cloud_storage_conn_id(string)` - 連接到 Google 云端存儲時使用的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `dest_aws_conn_id(str)` - 目標 S3 連接 * `dest_s3_key(str)` - 用于存儲文件的基本 S3 密鑰。（模板） ```py class airflow.contrib.operators.hipchat_operator.HipChatAPIOperator（token，base_url ='https：//api.hipchat.com/v2'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 基礎 HipChat 運算符。所有派生的 HipChat 運營商都參考了 HipChat 的官方 REST API 文檔，[網址](https://www.hipchat.com/docs/apiv2)為[https://www.hipchat.com/docs/apiv2](https://www.hipchat.com/docs/apiv2)。在使用任何 HipChat API 運算符之前，您需要在[https://www.hipchat.com/docs/apiv2/auth](https://www.hipchat.com/docs/apiv2/auth)獲取身份驗證令牌。在未來，其他 HipChat 運算符也將從此類派生。參數： * `token(str)` - HipChat REST API 身份驗證令牌 * `base_url(str)` - HipChat REST API 基本 URL。 ```py prepare_request（） ``` 由 execute 函數使用。設置 HipChat 的 REST API 調用的請求方法，URL 和正文。在子類中重寫。每個 HipChatAPI 子運算符負責具有設置 self.method，self.url 和 self.body 的 prepare_request 方法調用。 ```py class airflow.contrib.operators.hipchat_operator.HipChatAPISendRoomNotificationOperator（room_id，message，* args，** kwargs） ``` 基類： [`airflow.contrib.operators.hipchat_operator.HipChatAPIOperator`](31 "airflow.contrib.operators.hipchat_operator.HipChatAPIOperator") 將通知發送到特定的 HipChat 會議室。更多信息：[https](https://www.hipchat.com/docs/apiv2/method/send_room_notification)：[//www.hipchat.com/docs/apiv2/method/send_room_notification](https://www.hipchat.com/docs/apiv2/method/send_room_notification) 參數： * `room_id(str)` - 在 HipChat 上發送通知的房間。（模板） * `message(str)` - 郵件正文。（模板） * `frm(str)` - 除發件人姓名外還要顯示的標簽 * `message_format(str)` - 如何呈現通知：html 或文本 * `color(str)` - msg 的背景顏色：黃色，綠色，紅色，紫色，灰色或隨機 * `attach_to(str)` - 將此通知附加到的消息 ID * `notify(bool)` - 此消息是否應觸發用戶通知 * `card(dict)` - HipChat 定義的卡片對象 ```py prepare_request（） ``` 由 execute 函數使用。設置 HipChat 的 REST API 調用的請求方法，URL 和正文。在子類中重寫。每個 HipChatAPI 子運算符負責具有設置 self.method，self.url 和 self.body 的 prepare_request 方法調用。 ```py class airflow.contrib.operators.hive_to_dynamodb.HiveToDynamoDBTransferOperator（sql，table_name，table_keys，pre_process = None，pre_process_args = None，pre_process_kwargs = None，region_name = None，schema ='default'，hiveserver2_conn_id ='hiveserver2_default'，aws_conn_id ='aws_default' ，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從 Hive 移動到 DynamoDB，請注意，現在數據在被推送到 DynamoDB 之前已加載到內存中，因此該運算符應該用于少量數據。參數： * `sql(str)` - 針對 hive 數據庫執行的 SQL 查詢。（模板） * `table_name(str)` - 目標 DynamoDB 表 * `table_keys(list)` - 分區鍵和排序鍵 * `pre_process(function)` - 實現源數據的預處理 * `pre_process_args(list)` - pre_process 函數參數列表 * `pre_process_kwargs(dict)` - pre_process 函數參數的字典 * `region_name(str)` - aws 區域名稱（例如：us-east-1） * `schema(str)` - hive 數據庫模式 * `hiveserver2_conn_id(str)` - 源配置單元連接 * `aws_conn_id(str)` - aws 連接 ```py class airflow.contrib.operators.jenkins_job_trigger_operator.JenkinsJobTriggerOperator（jenkins_connection_id，job_name，parameters =''，sleep_time = 10，max_try_before_job_appears = 10，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 觸發 Jenkins 作業并監視它的執行情況。此運算符依賴于 python-jenkins 庫，版本> = 0.4.15 與 jenkins 服務器通信。您還需要在連接屏幕中配置 Jenkins 連接。：param jenkins_connection_id：用于此作業的 jenkins 連接：type jenkins_connection_id：string：param job_name：要觸發的作業的名稱：type job_name：string：param parameters：要提供給 jenkins 的參數塊。（模板化）：類型參數：string：param sleep_time：操作員在作業的每個狀態請求之間休眠多長時間（min 1，默認值為 10）：type sleep_time：int：param max_try_before_job_appears：要發出的最大請求數 > 等待作業出現在 jenkins 服務器上（默認為 10） ```py build_job（jenkins_server） ``` 此函數對 Jenkins 進行 API 調用以觸發'job_name'的構建。它返回了一個帶有 2 個鍵的字典：body 和 headers。headers 還包含一個類似 dict 的對象，可以查詢該對象以獲取隊列中輪詢的位置。：param jenkins_server：應該觸發作業的 jenkins 服務器：return：包含響應正文（密鑰正文）和標題出現的標題（標題） ```py poll_job_in_queue（location，jenkins_server） ``` 此方法輪詢 jenkins 隊列，直到執行作業。當我們通過 API 調用觸發作業時，首先將作業放入隊列而不分配內部版本號。因此，我們必須等待作業退出隊列才能知道其內部版本號。為此，我們必須將/ api / json（或/ api / xml）添加到 build_job 調用返回的位置并輪詢該文件。當 json 中出現'可執行'塊時，表示作業執行已開始，字段'number'則包含內部版本號。：param location：輪詢的位置，在 build_job 調用的標頭中返回：param jenkins_server：要輪詢的 jenkins 服務器：return：與觸發的作業對應的 build_number ```py class airflow.contrib.operators.jira_operator.JiraOperator（jira_conn_id ='jira_default'，jira_method = None，jira_method_args = None，result_processor = None，get_jira_resource_method = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") JiraOperator 在 Jira 問題跟蹤系統上進行交互并執行操作。此運算符旨在使用 Jira Python SDK：[http](http://jira.readthedocs.io/)：[//jira.readthedocs.io](http://jira.readthedocs.io/) 參數： * `jira_conn_id(str)` - 對預定義的 Jira 連接的引用 * `jira_method(str)` - 要調用的 Jira Python SDK 中的方法名稱 * `jira_method_args(dict)` - **jira_method**所需的方法參數。（模板） * `result_processor(function)` - 用于進一步處理 Jira 響應的函數 * `get_jira_resource_method(function)` - 用于獲取將在其上執行提供的 jira_method 的 jira 資源的函數或運算符 ```py class airflow.contrib.operators.kubernetes_pod_operator.KubernetesPodOperator（namespace，image，name，cmds = None，arguments = None，volume_mounts = None，volumes = None，env_vars = None，secrets = None，in_cluster = False，cluster_context = None，labels = None，startup_timeout_seconds = 120，get_logs = True，image_pull_policy ='IfNotPresent'，annotations = None，resources = None，affinity = None，config_file = None，xcom_push = False，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 Kubernetes Pod 中執行任務參數： * `image(str)` - 您希望啟動的 Docker 鏡像。默認為 dockerhub.io，但完全限定的 URLS 將指向自定義存儲庫 * `cmds(list[str])` - 容器的入口點。（模板化）如果未提供，則使用泊塢窗圖像的入口點。 * `arguments(list[str])` - 入口點的參數。（模板化）如果未提供，則使用泊塢窗圖像的 CMD。 * `volume_mounts(_VolumeMount 列表 _)` - 已啟動 pod 的 volumeMounts * `卷(**卷**list)` - 已啟動 pod 的卷。包括 ConfigMaps 和 PersistentVolumes * `labels(dict)` - 要應用于 Pod 的標簽 * `startup_timeout_seconds(int)` - 啟動 pod 的超時時間（秒） * `name(str)` - 要運行的任務的名稱，將用于生成 pod id * `env_vars(dict)` - 在容器中初始化的環境變量。（模板） * `秘密(**秘密**list)` - Kubernetes 秘密注入容器中，它們可以作為環境變量或卷中的文件公開。 * `in_cluster(bool)` - 使用 in_cluster 配置運行 kubernetes 客戶端 * `cluster_context(string)` - 指向 kubernetes 集群的上下文。當 in_cluster 為 True 時忽略。如果為 None，則使用 current-context。 * `get_logs(bool)` - 獲取容器的標準輸出作為任務的日志 * `affinity(dict)` - 包含一組關聯性調度規則的 dict * `config_file(str)` - Kubernetes 配置文件的路徑 * `xcom_push(bool)` - 如果 xcom_push 為 True，容器中的文件/airflow/xcom/return.json 的內容也將在容器完成時被推送到 XCom。 | 帕拉姆： | namespace：在 kubernetes 中運行的命名空間類型： namespace：str ```py class airflow.contrib.operators.mlengine_operator.MLEngineBatchPredictionOperator（project_id，job_id，region，data_format，input_paths，output_path，model_name = None，version_name = None，uri = None，max_worker_count = None，runtime_version = None，gcp_conn_id ='google_cloud_default'，delegate_to =無，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 啟動 Google Cloud ML Engine 預測作業。注意：對于模型原點，用戶應該考慮以下三個選項中的一個：1。僅填充“uri”字段，該字段應該是指向 tensorflow savedModel 目錄的 GCS 位置。2.僅填充'model_name'字段，該字段引用現有模型，并將使用模型的默認版本。3.填充“model_name”和“version_name”字段，這些字段指特定模型的特定版本。在選項 2 和 3 中，模型和版本名稱都應包含最小標識符。例如，打電話 ```py MLEngineBatchPredictionOperator ( ... , model_name = 'my_model' , version_name = 'my_version' , ... ) ``` 如果所需的型號版本是“projects / my_project / models / my_model / versions / my_version”。有關參數的更多文檔，請參閱[https://cloud.google.com/ml-engine/reference/rest/v1/projects.jobs](https://cloud.google.com/ml-engine/reference/rest/v1/projects.jobs)。參數： * `project_id(string)` - 提交預測作業的 Google Cloud 項目名稱。（模板） * `job_id(string)` - Google Cloud ML Engine 上預測作業的唯一 ID。（模板） * `data_format(string)` - 輸入數據的格式。如果未提供或者不是[“TEXT”，“TF_RECORD”，“TF_RECORD_GZIP”]之一，它將默認為“DATA_FORMAT_UNSPECIFIED”。 * `input_paths(_ 字符串列表 _)` - 批量預測的輸入數據的 GCS 路徑列表。接受通配符運算符[*](31)，但僅限于結尾處。（模板） * `output_path(string)` - 寫入預測結果的 GCS 路徑。（模板） * `region(string)` - 用于運行預測作業的 Google Compute Engine 區域。（模板化） * `model_name(string)` - 用于預測的 Google Cloud ML Engine 模型。如果未提供 version_name，則將使用此模型的默認版本。如果提供了 version_name，則不應為 None。如果提供 uri，則應為 None。（模板） * `version_name(string)` - 用于預測的 Google Cloud ML Engine 模型版本。如果提供 uri，則應為 None。（模板） * `uri(string)` - 用于預測的已保存模型的 GCS 路徑。如果提供了 model_name，則應為 None。它應該是指向張量流 SavedModel 的 GCS 路徑。（模板） * `max_worker_count(int)` - 用于并行處理的最大 worker 數。如果未指定，則默認為 10。 * `runtime_version(string)` - 用于批量預測的 Google Cloud ML Engine 運行時版本。 * `gcp_conn_id(string)` - 用于連接到 Google Cloud Platform 的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用 doamin 范圍的委派。 ```py Raises: ``` `ValueError` ：如果無法確定唯一的模型/版本來源。 ```py class airflow.contrib.operators.mlengine_operator.MLEngineModelOperator（project_id，model，operation ='create'，gcp_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 管理 Google Cloud ML Engine 模型的運營商。參數： * `project_id(string)` - MLEngine 模型所屬的 Google Cloud 項目名稱。（模板） * `型號(_ 字典 _)` - 包含有關模型信息的字典。如果`操作`是`create`，則`model`參數應包含有關此模型的所有信息，例如`name`。如果`操作`是`get`，則`model`參數應包含`模型`的`名稱`。 * `操作` - 執行的操作。可用的操作是： * `create`：創建`model`參數提供的新模型。 * `get`：獲取在模型中指定名稱的特定`模型`。 * `gcp_conn_id(string)` - 獲取連接信息時使用的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py class airflow.contrib.operators.mlengine_operator.MLEngineVersionOperator（project_id，model_name，version_name = None，version = None，operation ='create'，gcp_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 管理 Google Cloud ML Engine 版本的運營商。參數： * `project_id(string)` - MLEngine 模型所屬的 Google Cloud 項目名稱。 * `model_name(string)` - 版本所屬的 Google Cloud ML Engine 模型的名稱。（模板） * `version_name(string)` - 用于正在操作的版本的名稱。如果沒有人及`版本`的說法是沒有或不具備的值`名稱`鍵，那么這將是有效載荷中用于填充`名稱`鍵。（模板） * `version(dict)` - 包含版本信息的字典。如果`操作`是`create`，則`version`應包含有關此版本的所有信息，例如 name 和 deploymentUrl。如果`操作`是`get`或`delete`，則`version`參數應包含`版本`的`名稱`。如果是 None，則唯一可能的`操作`是`list`。（模板） * `操作(string)` - 執行的操作。可用的操作是： * `create`：在`model_name`指定的`模型中`創建新版本，在這種情況下，`version`參數應包含創建該版本的所有信息（例如`name`，`deploymentUrl`）。 * `get`：獲取`model_name`指定的`模型中`特定版本的完整信息。應在`version`參數中指定版本的名稱。 * `list`：列出`model_name`指定的`模型的`所有可用版本。 * `delete`：從`model_name`指定的`模型中`刪除`version`參數中指定的`版本`。應在`version`參數中指定版本的名稱。 * `gcp_conn_id(string)` - 獲取連接信息時使用的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 ```py class airflow.contrib.operators.mlengine_operator.MLEngineTrainingOperator（project_id，job_id，package_uris，training_python_module，training_args，region，scale_tier = None，runtime_version = None，python_version = None，job_dir = None，gcp_conn_id ='google_cloud_default'，delegate_to = None，mode ='生產'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 啟動 MLEngine 培訓工作的操作員。參數： * `project_id(string)` - 應在其中運行 MLEngine 培訓作業的 Google Cloud 項目名稱（模板化）。 * `job_id(string)` - 提交的 Google MLEngine 培訓作業的唯一模板化 ID。（模板） * `package_uris(string)` - MLEngine 培訓作業的包位置列表，其中應包括主要培訓計劃+任何其他依賴項。（模板） * `training_python_module(string)` - 安裝'package_uris'軟件包后，在 MLEngine 培訓作業中運行的 Python 模塊名稱。（模板） * `training_args(string)` - 傳遞給 MLEngine 訓練程序的模板化命令行參數列表。（模板） * `region(string)` - 用于運行 MLEngine 培訓作業的 Google Compute Engine 區域（模板化）。 * `scale_tier(string)` - MLEngine 培訓作業的資源層。（模板） * `runtime_version(string)` - 用于培訓的 Google Cloud ML 運行時版本。（模板） * `python_version(string)` - 訓練中使用的 Python 版本。（模板） * `job_dir(string)` - 用于存儲培訓輸出和培訓所需的其他數據的 Google 云端存儲路徑。（模板） * `gcp_conn_id(string)` - 獲取連接信息時使用的連接 ID。 * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `mode(string)` - 可以是'DRY_RUN'/'CLOUD'之一。在“DRY_RUN”模式下，不會啟動真正的培訓作業，但會打印出 MLEngine 培訓作業請求。在“CLOUD”模式下，將發出真正的 MLEngine 培訓作業創建請求。 ```py class airflow.contrib.operators.mongo_to_s3.MongoToS3Operator（mongo_conn_id，s3_conn_id，mongo_collection，mongo_query，s3_bucket，s3_key，mongo_db = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") ```py Mongo - > S3 ``` 更具體的 baseOperator 意味著將數據從 mongo 通過 pymongo 移動到 s3 通過 boto ```py 需要注意的事項 ``` .execute（）編寫依賴于.transform（）。transnsform（）旨在由子類擴展，以執行特定于運算符需求的轉換 ```py 執行（上下文） ``` 由 task_instance 在運行時執行 ```py 變換（文檔） ``` ```py 處理 pyMongo 游標并返回每個元素都在的 iterable ``` 一個 JSON 可序列化的字典 Base transform（）假設不需要處理，即。docs 是文檔的 pyMongo 游標，只需要傳遞游標重寫此方法以進行自定義轉換 ```py class airflow.contrib.operators.mysql_to_gcs.MySqlToGoogleCloudStorageOperator（sql，bucket，filename，schema_filename = None，approx_max_file_size_bytes = 1900000000，mysql_conn_id ='mysql_default'，google_cloud_storage_conn_id ='google_cloud_default'，schema = None，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從 MySQL 復制到 JSON 格式的 Google 云存儲。 ```py classmethod type_map（mysql_type） ``` 從 MySQL 字段映射到 BigQuery 字段的輔助函數。在設置 schema_filename 時使用。 ```py class airflow.contrib.operators.postgres_to_gcs_operator.PostgresToGoogleCloudStorageOperator（sql，bucket，filename，schema_filename = None，approx_max_file_size_bytes = 1900000000，po??stgres_conn_id ='postgres_default'，google_cloud_storage_conn_id ='google_cloud_default'，delegate_to = None，parameters = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從 Postgres 復制到 JSON 格式的 Google 云端存儲。 ```py classmethod convert_types（value） ``` 從 Postgres 獲取值，并將其轉換為對 JSON / Google Cloud Storage / BigQuery 安全的值。日期轉換為 UTC 秒。小數轉換為浮點數。時間轉換為秒。 ```py classmethod type_map（postgres_type） ``` 從 Postgres 字段映射到 BigQuery 字段的 Helper 函數。在設置 schema_filename 時使用。 ```py class airflow.contrib.operators.pubsub_operator.PubSubTopicCreateOperator（project，topic，fail_if_exists = False，gcp_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 創建 PubSub 主題。默認情況下，如果主題已存在，則此運算符不會導致 DAG 失敗。 ```py with DAG ( 'successful DAG' ) as dag : ( dag >> PubSubTopicCreateOperator ( project = 'my-project' , topic = 'my_new_topic' ) >> PubSubTopicCreateOperator ( project = 'my-project' , topic = 'my_new_topic' ) ) ``` 如果主題已存在，則可以將操作員配置為失敗。 ```py with DAG ( 'failing DAG' ) as dag : ( dag >> PubSubTopicCreateOperator ( project = 'my-project' , topic = 'my_new_topic' ) >> PubSubTopicCreateOperator ( project = 'my-project' , topic = 'my_new_topic' , fail_if_exists = True ) ) ``` 這兩個`project`和`topic`模板化，所以你可以在其中使用變量。 ```py class airflow.contrib.operators.pubsub_operator.PubSubTopicDeleteOperator（project，topic，fail_if_not_exists = False，gcp_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 刪除 PubSub 主題。默認情況下，如果主題不存在，則此運算符不會導致 DAG 失敗。 ```py with DAG ( 'successful DAG' ) as dag : ( dag >> PubSubTopicDeleteOperator ( project = 'my-project' , topic = 'non_existing_topic' ) ) ``` 如果主題不存在，則可以將運算符配置為失敗。 ```py with DAG ( 'failing DAG' ) as dag : ( dag >> PubSubTopicCreateOperator ( project = 'my-project' , topic = 'non_existing_topic' , fail_if_not_exists = True ) ) ``` 這兩個`project`和`topic`模板化，所以你可以在其中使用變量。 ```py class airflow.contrib.operators.pubsub_operator.PubSubSubscriptionCreateOperator（topic_project，topic，subscription = None，subscription_project = None，ack_deadline_secs = 10，fail_if_exists = False，gcp_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 創建 PubSub 訂閱。默認情況下，將在中創建訂閱`topic_project`。如果`subscription_project`已指定且 GCP 憑據允許，則可以在與其主題不同的項目中創建訂閱。默認情況下，如果訂閱已存在，則此運算符不會導致 DAG 失敗。但是，該主題必須存在于項目中。 ```py with DAG ( 'successful DAG' ) as dag : ( dag >> PubSubSubscriptionCreateOperator ( topic_project = 'my-project' , topic = 'my-topic' , subscription = 'my-subscription' ) >> PubSubSubscriptionCreateOperator ( topic_project = 'my-project' , topic = 'my-topic' , subscription = 'my-subscription' ) ) ``` 如果訂閱已存在，則可以將運算符配置為失敗。 ```py with DAG ( 'failing DAG' ) as dag : ( dag >> PubSubSubscriptionCreateOperator ( topic_project = 'my-project' , topic = 'my-topic' , subscription = 'my-subscription' ) >> PubSubSubscriptionCreateOperator ( topic_project = 'my-project' , topic = 'my-topic' , subscription = 'my-subscription' , fail_if_exists = True ) ) ``` 最后，不需要訂閱。如果未通過，則運營商將為訂閱的名稱生成通用唯一標識符。 ```py with DAG ( 'DAG' ) as dag : ( dag >> PubSubSubscriptionCreateOperator ( topic_project = 'my-project' , topic = 'my-topic' ) ) ``` `topic_project`,, `topic`和`subscription`，并且`subscription`是模板化的，因此您可以在其中使用變量。 ```py class airflow.contrib.operators.pubsub_operator.PubSubSubscriptionDeleteOperator（project，subscription，fail_if_not_exists = False，gcp_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 刪除 PubSub 訂閱。默認情況下，如果訂閱不存在，則此運算符不會導致 DAG 失敗。 ```py with DAG ( 'successful DAG' ) as dag : ( dag >> PubSubSubscriptionDeleteOperator ( project = 'my-project' , subscription = 'non-existing' ) ) ``` 如果訂閱已存在，則可以將運算符配置為失敗。 ```py with DAG ( 'failing DAG' ) as dag : ( dag >> PubSubSubscriptionDeleteOperator ( project = 'my-project' , subscription = 'non-existing' , fail_if_not_exists = True ) ) ``` `project`，并且`subscription`是模板化的，因此您可以在其中使用變量。 ```py class airflow.contrib.operators.pubsub_operator.PubSubPublishOperator（project，topic，messages，gcp_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將消息發布到 PubSub 主題。每個任務都將所有提供的消息發布到單個 GCP 項目中的同一主題。如果主題不存在，則此任務將失敗。 ```py from base64 import b64encode as b64e m1 = {'data': b64e('Hello, World!'), 'attributes': {'type': 'greeting'} } m2 = {'data': b64e('Knock, knock')} m3 = {'attributes': {'foo': ''}} t1 = PubSubPublishOperator( project='my-project',topic='my_topic', messages=[m1, m2, m3], create_topic=True, dag=dag) ``project`` , ``topic``, and ``messages`` are templated so you can use ``` 其中的變量。 ```py class airflow.contrib.operators.qubole_check_operator.QuboleCheckOperator（qubole_conn_id ='qubole_default'，* args，** kwargs） ``` 基類：[`airflow.operators.check_operator.CheckOperator`](31 "airflow.operators.check_operator.CheckOperator")，[`airflow.contrib.operators.qubole_operator.QuboleOperator`](31 "airflow.contrib.operators.qubole_operator.QuboleOperator") 對 Qubole 命令執行檢查。`QuboleCheckOperator`期望一個將在 QDS 上執行的命令。默認情況下，使用 python `bool`強制計算此 Qubole Commmand 結果第一行的每個值。如果返回任何值`False`，則檢查失敗并輸出錯誤。請注意，Python bool 強制轉換如下`False`： * `False` * `0` * 空字符串（`""`） * 空列表（`[]`） * 空字典或集（`{}`）給定一個查詢，它只會在計數時失敗。您可以制作更復雜的查詢，例如，可以檢查表與上游源表的行數相同，或者今天的分區計數大于昨天的分區，或者一組指標是否更少 7 天平均值超過 3 個標準差。`SELECT COUNT(*) FROM foo``== 0` 此運算符可用作管道中的數據質量檢查，并且根據您在 DAG 中的位置，您可以選擇停止關鍵路徑，防止發布可疑數據，或者側面接收電子郵件警報阻止 DAG 的進展。參數：`qubole_conn_id(str)` - 由 qds auth_token 組成的連接 ID kwargs： > 可以從 QuboleOperator 文檔中引用特定于 Qubole 命令的參數。 > > <colgroup><col class="field-name"><col class="field-body"></colgroup> > | results_parser_callable： | > | --- | > | | 這是一個可選參數，用于擴展將 Qubole 命令的結果解析給用戶的靈活性。這是一個 python 可調用的，它可以保存邏輯來解析 Qubole 命令返回的行列表。默認情況下，僅第一行的值用于執行檢查。此可調用對象應返回必須在其上執行檢查的記錄列表。 | 注意與 QuboleOperator 和 CheckOperator 的模板字段相同的所有字段都是模板支持的。 ```py class airflow.contrib.operators.qubole_check_operator.QuboleValueCheckOperator（pass_value，tolerance = None，qubole_conn_id ='qubole_default'，* args，** kwargs） ``` 基類：[`airflow.operators.check_operator.ValueCheckOperator`](31 "airflow.operators.check_operator.ValueCheckOperator")，[`airflow.contrib.operators.qubole_operator.QuboleOperator`](31 "airflow.contrib.operators.qubole_operator.QuboleOperator") 使用 Qubole 命令執行簡單的值檢查。默認情況下，此 Qubole 命令的第一行上的每個值都與預定義的值進行比較。如果命令的輸出不在預期值的允許限度內，則檢查失敗并輸出錯誤。參數： * `qubole_conn_id(str)` - 由 qds auth_token 組成的連接 ID * `pass_value(_str / int / float_)` - 查詢結果的預期值。 * `tolerance(_int / float_)` - 定義允許的 pass_value 范圍，例如，如果 tolerance 為 2，則 Qubole 命令輸出可以是-2 * pass_value 和 2 * pass_value 之間的任何值，而不會導致操作員錯誤輸出。 kwargs： > 可以從 QuboleOperator 文檔中引用特定于 Qubole 命令的參數。 > > <colgroup><col class="field-name"><col class="field-body"></colgroup> > | results_parser_callable： | > | --- | > | | 這是一個可選參數，用于擴展將 Qubole 命令的結果解析給用戶的靈活性。這是一個 python 可調用的，它可以保存邏輯來解析 Qubole 命令返回的行列表。默認情況下，僅第一行的值用于執行檢查。此可調用對象應返回必須在其上執行檢查的記錄列表。 | 注意與 QuboleOperator 和 ValueCheckOperator 的模板字段相同的所有字段都是模板支持的。 ```py class airflow.contrib.operators.qubole_operator.QuboleOperator（qubole_conn_id ='qubole_default'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 QDS 上執行任務（命令）（[https://qubole.com](https://qubole.com/)）。參數：`qubole_conn_id(str)` - 由 qds auth_token 組成的連接 ID ```py kwargs： ``` | COMMAND_TYPE： | 要執行的命令類型，例如 hivecmd，shellcmd，hadoopcmd| 標簽： | 要使用該命令分配的標記數組| cluster_label： | 將在其上執行命令的集群標簽| 名稱： | 要命令的名稱| 通知： | 是否在命令完成時發送電子郵件（默認為 False） **特定于命令類型的參數** ```py hivecmd： ``` | 查詢： | 內聯查詢語句| script_location： | | --- | | | 包含查詢語句的 s3 位置 | | SAMPLE_SIZE： | 要運行查詢的樣本大小（以字節為單位）| 宏： | 在查詢中使用的宏值 ```py prestocmd： ``` | 查詢： | 內聯查詢語句| script_location： | | --- | | | 包含查詢語句的 s3 位置 | | 宏： | 在查詢中使用的宏值 ```py hadoopcmd： ``` | sub_commnad： | 必須是這些[“jar”，“s3distcp”，“流媒體”]后跟一個或多個 args ```py shellcmd： ``` | 腳本： | 帶有 args 的內聯命令| script_location： | | --- | | | 包含查詢語句的 s3 位置 | | 文件： | s3 存儲桶中的文件列表為 file1，file2 格式。這些文件將被復制到正在執行 qubole 命令的工作目錄中。| 檔案： | s3 存儲桶中的存檔列表為 archive1，archive2 格式。這些將被解壓縮到正在執行 qubole 命令的工作目錄中參數：需要傳遞給腳本的任何額外的 args（僅當提供了 script_location 時） ```py pigcmd： ``` | 腳本： | 內聯查詢語句（latin_statements）| script_location： | | --- | | | 包含 pig 查詢的 s3 位置 | 參數：需要傳遞給腳本的任何額外的 args（僅當提供了 script_location 時） ```py sparkcmd： ``` | 程序： | Scala，SQL，Command，R 或 Python 中的完整 Spark 程序| CMDLINE： | spark-submit 命令行，必須在 cmdline 本身中指定所有必需的信息。| SQL： | 內聯 sql 查詢| script_location： | | --- | | | 包含查詢語句的 s3 位置 | | 語言： | 程序的語言，Scala，SQL，Command，R 或 Python| APP_ID： | Spark 作業服務器應用程序的 ID 參數：spark-submit 命令行參數| user_program_arguments： | | --- | | | 用戶程序所接受的參數 | | 宏： | 在查詢中使用的宏值 ```py dbtapquerycmd： ``` | db_tap_id： | Qubole 中目標數據庫的數據存儲 ID。| 查詢： | 內聯查詢語句| 宏： | 在查詢中使用的宏值 ```py dbexportcmd： ``` | 模式： | 1（簡單），2（提前）| hive_table： | 配置單元表的名稱| partition_spec： | Hive 表的分區規范。| dbtap_id： | Qubole 中目標數據庫的數據存儲 ID。| db_table： | db 表的名稱| db_update_mode： | allowinsert 或 updateonly| db_update_keys： | 用于確定行唯一性的列| export_dir： | HDFS / S3 將從中導出數據的位置。| fields_terminated_by： | | --- | | | 用作數據集中列分隔符的 char 的十六進制 | ```py dbimportcmd： ``` | 模式： | 1（簡單），2（提前）| hive_table： | 配置單元表的名稱| dbtap_id： | Qubole 中目標數據庫的數據存儲 ID。| db_table： | db 表的名稱| where_clause： | where 子句，如果有的話| 并行： | 用于提取數據的并行數據庫連接數| extract_query： | SQL 查詢從 db 中提取數據。$ CONDITIONS 必須是 where 子句的一部分。| boundary_query： | 要使用的查詢獲取要提取的行 ID 范圍| split_column： | 用作行 ID 的列將數據拆分為范圍（模式 2）注意以下字段模板支持：`query`，`script_location`，`sub_command`，`script`，`files`，`archives`，`program`，`cmdline`，`sql`，`where_clause`，`extract_query`，`boundary_query`，`macros`，`tags`，`name`，`parameters`，`dbtap_id`，`hive_table`，`db_table`，`split_column`，`note_id`，`db_update_keys`，`export_dir`，`partition_spec`，`qubole_conn_id`，`arguments`，`user_program_arguments`。 > 您還可以將`.txt`文件用于模板驅動的用例。注意在 QuboleOperator 中，有一個用于任務失敗和重試的默認處理程序，它通常會殺死在 QDS 上運行的相應任務實例的命令。您可以通過在任務定義中提供自己的失敗和重試處理程序來覆蓋此行為。 ```py class airflow.contrib.operators.s3listoperator.S3ListOperator（bucket，prefix =''，delimiter =''，aws_conn_id ='aws_default'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 列出桶中具有名稱中給定字符串前綴的所有對象。此運算符返回一個 python 列表，其中包含可由`xcom`在下游任務中使用的對象名稱。參數： * `bucket(string)` - S3 存儲桶在哪里找到對象。（模板） * `prefix(string)` - 用于過濾名稱以此前綴開頭的對象的前綴字符串。（模板） * `delimiter(string)` - 分隔符標記鍵層次結構。（模板） * `aws_conn_id(string)` - 連接到 S3 存儲時使用的連接 ID。 ```py Example: ``` 以下運算符將列出存儲桶中 S3 `customers/2018/04/`鍵的所有文件（不包括子文件夾）`data`。 ```py s3_file = S3ListOperator ( task_id = 'list_3s_files' , bucket = 'data' , prefix = 'customers/2018/04/' , delimiter = '/' , aws_conn_id = 'aws_customers_conn' ) ``` ```py class airflow.contrib.operators.s3_to_gcs_operator.S3ToGoogleCloudStorageOperator（bucket，prefix =''，delimiter =''，aws_conn_id ='aws_default'，dest_gcs_conn_id = None，dest_gcs = None，delegate_to = None，replace = False，* args，** kwargs） ``` 基類： [`airflow.contrib.operators.s3listoperator.S3ListOperator`](integration.html "airflow.contrib.operators.s3listoperator.S3ListOperator") 將 S3 密鑰（可能是前綴）與 Google 云端存儲目標路徑同步。參數： * `bucket(string)` - S3 存儲桶在哪里找到對象。（模板） * `prefix(string)` - 前綴字符串，用于過濾名稱以此前綴開頭的對象。（模板） * `delimiter(string)` - 分隔符標記鍵層次結構。（模板） * `aws_conn_id(string)` - 源 S3 連接 * `dest_gcs_conn_id(string)` - 連接到 Google 云端存儲時要使用的目標連接 ID。 * `dest_gcs(string)` - 要存儲文件的目標 Google 云端存儲**分區**和前綴。（模板） * `delegate_to(string)` - 模擬的帳戶（如果有）。為此，發出請求的服務帳戶必須啟用域范圍委派。 * `replace(bool)` - 是否要替換現有目標文件。 **示例**：.. code-block :: python > ```py > s3_to_gcs_op = S3ToGoogleCloudStorageOperator（ > ``` > > task_id ='s3_to_gcs_example'，bucket ='my-s3-bucket'，prefix ='data / customers-201804'，dest_gcs_conn_id ='google_cloud_default'，dest_gcs ='gs：//my.gcs.bucket/some/customers/' ，replace = False，dag = my-dag）需要注意的是`bucket`，`prefix`，`delimiter`和`dest_gcs`模板化，所以你可以，如果你想使用變量在其中。 ```py class airflow.contrib.operators.segment_track_event_operator.SegmentTrackEventOperator（user_id，event，properties = None，segment_conn_id ='segment_default'，segment_debug_mode = False，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將跟蹤事件發送到 Segment 以獲取指定的 user_id 和事件參數： * `user_id(string)` - 數據庫中此用戶的 ID。（模板） * `event(string)` - 您要跟蹤的事件的名稱。（模板） * `properties(dict)` - 事件屬性的字典。（模板） * `segment_conn_id(string)` - 連接到 Segment 時使用的連接 ID。 * `segment_debug_mode(_boolean_)` - 確定 Segment 是否應在調試模式下運行。默認為 False ```py class airflow.contrib.operators.sftp_operator.SFTPOperator（ssh_hook = None，ssh_conn_id = None，remote_host = None，local_filepath = None，remote_filepath = None，operation ='put'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") SFTPOperator 用于將文件從遠程主機傳輸到本地或反之亦然。此運算符使用 ssh_hook 打開 sftp trasport 通道，該通道用作文件傳輸的基礎。參數： * `ssh_hook(`SSHHook`)` - 用于遠程執行的預定義 ssh_hook * `ssh_conn_id(str)` - 來自**airflow** Connections 的連接 ID * `remote_host(str)` - 要連接的遠程主機 * `local_filepath(str)` - 要獲取或放置的本地文件路徑。（模板） * `remote_filepath(str)` - 要獲取或放置的遠程文件路徑。（模板） * `操作` - 指定操作'get'或'put'，默認為 get ```py class airflow.contrib.operators.slack_webhook_operator.SlackWebhookOperator（http_conn_id = None，webhook_token = None，message =''，channel = None，username = None，icon_emoji = None，link_names = False，proxy = None，* args，** kwargs ） ``` 基類： [`airflow.operators.http_operator.SimpleHttpOperator`](31 "airflow.operators.http_operator.SimpleHttpOperator") 此運算符允許您使用傳入的 webhook 將消息發布到 Slack。直接使用 Slack webhook 令牌和具有 Slack webhook 令牌的連接。如果兩者都提供，將使用 Slack webhook 令牌。每個 Slack webhook 令牌都可以預先配置為使用特定頻道，用戶名和圖標。您可以在此掛鉤中覆蓋這些默認值。參數： * `conn_id(str)` - 在額外字段中具有 Slack webhook 標記的連接 * `webhook_token(str)` - Slack webhook 令牌 * `message(str)` - 要在 Slack 上發送的消息 * `channel(str)` - 郵件應發布到的頻道 * `username(str)` - 要發布的用戶名 * `icon_emoji(str)` - 用作發布給 Slack 的用戶圖標的表情符號 * `link_names(bool)` - 是否在郵件中查找和鏈接頻道和用戶名 * `proxy(str)` - 用于進行 Slack webhook 調用的代理 ```py 執行（上下文） ``` 調用 SparkSqlHook 來運行提供的 sql 查詢 ```py class airflow.contrib.operators.snowflake_operator.SnowflakeOperator（sql，snowflake_conn_id ='snowflake_default'，parameters = None，autocommit = True，warehouse = None，database = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在 Snowflake 數據庫中執行 sql 代碼參數： * `snowflake_conn_id(string)` - 對特定雪花連接 ID 的引用 * `SQL(_ 可接收表示 SQL 語句中的海峽 _ _，_ _ 海峽列表 _ _（_ _SQL 語句 _ _）_ _，或 _ _ 參照模板文件模板引用在“.SQL”結束海峽認可。_)` -要執行的 SQL 代碼。（模板） * `warehouse(string)` - 覆蓋連接中已定義的倉庫的倉庫名稱 * `database(string)` - 覆蓋連接中定義的數據庫的數據庫名稱 ```py class airflow.contrib.operators.spark_jdbc_operator.SparkJDBCOperator（spark_app_name ='airflow-spark-jdbc'，spark_conn_id ='spark-default'，spark_conf = None，spark_py_files = None，spark_files = None，spark_jars = None，num_executors = None，executor_cores = None，executor_memory = None，driver_memory = None，verbose = False，keytab = None，principal = None，cmd_type ='spark_to_jdbc'，jdbc_table = None，jdbc_conn_id ='jdbc-default'，jdbc_driver = None，metastore_table = None，jdbc_truncate = False，save_mode = None，save_format = None，batch_size = None，fetch_size = None，num_partitions = None，partition_column = None，lower_bound = None，upper_bound = None，create_table_column_types = None，* args，** kwargs） ``` 基類： [`airflow.contrib.operators.spark_submit_operator.SparkSubmitOperator`](31 "airflow.contrib.operators.spark_submit_operator.SparkSubmitOperator") 此運算符專門用于擴展 SparkSubmitOperator，以便使用 Apache Spark 執行與基于 JDBC 的數據庫之間的數據傳輸。與 SparkSubmitOperator 一樣，它假定 PATH 上有“spark-submit”二進制文件。參數： * `spark_app_name**（str） - 作業名稱（默認為**airflow` -spark-jdbc） * `spark_conn_id(str)` - 在 Airflow 管理中配置的連接 ID * `spark_conf(dict)` - 任何其他 Spark 配置屬性 * `spark_py_files(str)` - 使用的其他 python 文件（.zip，.egg 或.py） * `spark_files(str)` - 要上載到運行作業的容器的其他文件 * `spark_jars(str)` - 要上傳并添加到驅動程序和執行程序類路徑的其他 jar * `num_executors(int)` - 要運行的執行程序的數量。應設置此項以便管理使用 JDBC 數據庫建立的連接數 * `executor_cores(int)` - 每個執行程序的核心數 * `executor_memory(str)` - 每個執行者的內存（例如 1000M，2G） * `driver_memory(str)` - 分配給驅動程序的內存（例如 1000M，2G） * `verbose(bool)` - 是否將詳細標志傳遞給 spark-submit 進行調試 * `keytab(str)` - 包含 keytab 的文件的完整路徑 * `principal(str)` - 用于 keytab 的 kerberos 主體的名稱 * `cmd_type(str)` - 數據應該以哪種方式流動。2 個可能的值：spark_to_jdbc：從 Metastore 到 jdbc jdbc_to_spark 的 spark 寫入的數據：來自 jdbc 到 Metastore 的 spark 寫入的數據 * `jdbc_table(str)` - JDBC 表的名稱 * `jdbc_conn_id` - 用于連接 JDBC 數據庫的連接 ID * `jdbc_driver(str)` - 用于 JDBC 連接的 JDBC 驅動程序的名稱。這個驅動程序（通常是一個 jar）應該在'jars'參數中傳遞 * `metastore_table(str)` - Metastore 表的名稱， * `jdbc_truncate(bool)` - （僅限 spark_to_jdbc）Spark 是否應截斷或刪除并重新創建 JDBC 表。這僅在'save_mode'設置為 Overwrite 時生效。此外，如果架構不同，Spark 無法截斷，并將丟棄并重新創建 * `save_mode(str)` - 要使用的 Spark 保存模式（例如覆蓋，追加等） * `save_format(str)` - （jdbc_to_spark-only）要使用的 Spark 保存格式（例如鑲木地板） * `batch_size(int)` - （僅限 spark_to_jdbc）每次往返 JDBC 數據庫時要插入的批處理的大小。默認為 1000 * `fetch_size(int)` - （僅限 jdbc_to_spark）從 JDBC 數據庫中每次往返獲取的批處理的大小。默認值取決于 JDBC 驅動程序 * `num_partitions(int)` - Spark 同時可以使用的最大分區數，包括 spark_to_jdbc 和 jdbc_to_spark 操作。這也將限制可以打開的 JDBC 連接數 * `partition_column(str)` - （jdbc_to_spark-only）用于對 Metastore 表進行分區的數字列。如果已指定，則還必須指定：num_partitions，lower_bound，upper_bound * `lower_bound(int)` - （jdbc_to_spark-only）要獲取的數字分區列范圍的下限。如果已指定，則還必須指定：num_partitions，partition_column，upper_bound * `upper_bound(int)` - （jdbc_to_spark-only）要獲取的數字分區列范圍的上限。如果已指定，則還必須指定：num_partitions，partition_column，lower_bound * `create_table_column_types` - （spark_to_jdbc-only）創建表時要使用的數據庫列數據類型而不是默認值。應以與 CREATE TABLE 列語法相同的格式指定數據類型信息（例如：“name CHAR（64），comments VARCHAR（1024）”）。指定的類型應該是有效的 spark sql 數據類型。類型： jdbc_conn_id：str ```py 執行（上下文） ``` 調用 SparkSubmitHook 來運行提供的 spark 作業 ```py class airflow.contrib.operators.spark_sql_operator.SparkSqlOperator（sql，conf = None，conn_id ='spark_sql_default'，total_executor_cores = None，executor_cores = None，executor_memory = None，keytab = None，principal = None，master ='yarn'，name ='default-name'，num_executors = None，yarn_queue ='default'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 執行 Spark SQL 查詢參數： * `sql(str)` - 要執行的 SQL 查詢。（模板） * `conf(_str __（_ _ 格式：PROP = VALUE __）_)` - 任意 Spark 配置屬性 * `conn_id(str)` - connection_id 字符串 * `total_executor_cores(int)` - （僅限 Standalone 和 Mesos）所有執行程序的總核心數（默認值：工作程序上的所有可用核心） * `executor_cores(int)` - （僅限 Standalone 和 YARN）每個執行程序的核心數（默認值：2） * `executor_memory(str)` - 每個執行程序的內存（例如 1000M，2G）（默認值：1G） * `keytab(str)` - 包含 keytab 的文件的完整路徑 * `master(str)` - spark：// host：port，mesos：// host：port，yarn 或 local * `name(str)` - 作業名稱 * `num_executors(int)` - 要啟動的執行程序數 * `verbose(bool)` - 是否將詳細標志傳遞給 spark-sql * `yarn_queue(str)` - 要提交的 YARN 隊列（默認值：“default”） ```py 執行（上下文） ``` 調用 SparkSqlHook 來運行提供的 sql 查詢 ```py class airflow.contrib.operators.spark_submit_operator.SparkSubmitOperator（application =''，conf = None，conn_id ='spark_default'，files = None，py_files = None，driver_classpath = None，jars = None，java_class = None，packages = None， exclude_packages = None，repositories = None，total_executor_cores = None，executor_cores = None，executor_memory = None，driver_memory = None，keytab = None，principal = None，name ='airflow-spark'，num_executors = None，application_args = None，env_vars =無，詳細=假，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 這個鉤子是一個圍繞 spark-submit 二進制文件的包裝器來啟動一個 spark-submit 作業。它要求“spark-submit”二進制文件在 PATH 中，或者 spark-home 在連接中的額外設置。參數： * `application(str)` - 作為作業提交的應用程序，jar 或 py 文件。（模板） * `conf(dict)` - 任意 Spark 配置屬性 * `conn_id(str)` - Airflow 管理中配置的連接 ID。當提供無效的 connection_id 時，它將默認為 yarn。 * `files(str)` - 將其他文件上載到運行作業的執行程序，以逗號分隔。文件將放在每個執行程序的工作目錄中。例如，序列化對象。 * `py_files(str)` - 作業使用的其他 python 文件可以是.zip，.egg 或.py。 * `jars(str)` - 提交其他 jar 以上傳并將它們放在執行程序類路徑中。 * `driver_classpath(str)` - 其他特定于驅動程序的類路徑設置。 * `java_class(str)` - Java 應用程序的主要類 * `packages(str)` - 包含在驅動程序和執行程序類路徑上的 jar 的 maven 坐標的逗號分隔列表。（模板） * `exclude_packages(str)` - 解析“包”中提供的依賴項時要排除的 jar 的 maven 坐標的逗號分隔列表 * `repositories(str)` - 以逗號分隔的其他遠程存儲庫列表，用于搜索“packages”給出的 maven 坐標 * `total_executor_cores(int)` - （僅限 Standalone 和 Mesos）所有執行程序的總核心數（默認值：工作程序上的所有可用核心） * `executor_cores(int)` - （僅限 Standalone 和 YARN）每個執行程序的核心數（默認值：2） * `executor_memory(str)` - 每個執行程序的內存（例如 1000M，2G）（默認值：1G） * `driver_memory(str)` - 分配給驅動程序的內存（例如 1000M，2G）（默認值：1G） * `keytab(str)` - 包含 keytab 的文件的完整路徑 * `principal(str)` - 用于 keytab 的 kerberos 主體的名稱 * `name(str)` - 作業名稱（默認氣流 - 火花）。（模板） * `num_executors(int)` - 要啟動的執行程序數 * `application_args(list)` - 正在提交的應用程序的參數 * `env_vars(dict)` - spark-submit 的環境變量。它也支持紗線和 k8s 模式。 * `verbose(bool)` - 是否將詳細標志傳遞給 spark-submit 進程進行調試 ```py 執行（上下文） ``` 調用 SparkSubmitHook 來運行提供的 spark 作業 ```py class airflow.contrib.operators.sqoop_operator.SqoopOperator（conn_id ='sqoop_default'，cmd_type ='import'，table = None，query = None，target_dir = None，append = None，file_type ='text'，columns = None，num_mappers = None，split_by = None，其中= None，export_dir = None，input_null_string = None，input_null_non_string = None，staging_table = None，clear_staging_table = False，enclosed_by = None，escaped_by = None，input_fields_terminated_by = None，input_lines_terminated_by = None，input_optionally_enclosed_by = None ，batch = False，direct = False，driver = None，verbose = False，relaxed_isolation = False，properties = None，hcatalog_database = None，hcatalog_table = None，create_hcatalog_table = False，extra_import_options = None，extra_export_options = None，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 執行 Sqoop 作業。Apache Sqoop 的文檔可以在這里找到： > [https://sqoop.apache.org/docs/1.4.2/SqoopUserGuide.html](https://sqoop.apache.org/docs/1.4.2/SqoopUserGuide.html)。 ```py 執行（上下文） ``` 執行 sqoop 作業 ```py class airflow.contrib.operators.ssh_operator.SSHOperator（ssh_hook = None，ssh_conn_id = None，remote_host = None，command = None，timeout = 10，do_xcom_push = False，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") SSHOperator 使用 ssh_hook 在給定的遠程主機上執行命令。參數： * `ssh_hook(`SSHHook`)` - 用于遠程執行的預定義 ssh_hook * `ssh_conn_id(str)` - 來自**airflow** Connections 的連接 ID * `remote_host(str)` - 要連接的遠程主機 * `command(str)` - 在遠程主機上執行的命令。（模板） * `timeout(int)` - 執行命令的超時（以秒為單位）。 * `do_xcom_push(bool)` - 返回由氣流平臺在 xcom 中設置的標準輸出 ```py class airflow.contrib.operators.vertica_operator.VerticaOperator（sql，vertica_conn_id ='vertica_default'，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 在特定的 Vertica 數據庫中執行 sql 代碼參數： * `vertica_conn_id(string)` - 對特定 Vertica 數據庫的引用 * `SQL(_ 可接收表示 SQL 語句中的海峽 _ _，_ _ 海峽列表 _ _（_ _SQL 語句 _ _）_ _，或 _ _ 參照模板文件模板引用在“.SQL”結束海峽認可。_)` -要執行的 SQL 代碼。（模板） ```py class airflow.contrib.operators.vertica_to_hive.VerticaToHiveTransfer（sql，hive_table，create = True，recreate = False，partition = None，delimiter = u'x01'，vertica_conn_id ='vertica_default'，hive_cli_conn_id ='hive_cli_default'，* args，* * kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") 將數據從 Vertia 移動到 Hive。操作員針對 Vertia 運行查詢，在將文件加載到 Hive 表之前將文件存儲在本地。如果將`create`或`recreate`參數設置為`True`，則生成 a 和語句。從游標的元數據推斷出 Hive 數據類型。請注意，在 Hive 中生成的表使用的不是最有效的序列化格式。如果加載了大量數據和/或表格被大量查詢，您可能只想使用此運算符將數據暫存到臨時表中，然后使用 a 將其加載到最終目標中。`CREATE TABLE``DROP TABLE``STORED AS textfile``HiveOperator` 參數： * `sql(str)` - 針對 Vertia 數據庫執行的 SQL 查詢。（模板） * `hive_table(str)` - 目標 Hive 表，使用點表示法來定位特定數據庫。（模板） * `create(bool)` - 是否創建表，如果它不存在 * `recreate(bool)` - 是否在每次執行時刪除并重新創建表 * `partition(dict)` - 將目標分區作為分區列和值的字典。（模板） * `delimiter(str)` - 文件中的字段分隔符 * `vertica_conn_id(str)` - 源 Vertica 連接 * `hive_conn_id(str)` - 目標配置單元連接 ```py class airflow.contrib.operators.winrm_operator.WinRMOperator（winrm_hook = None，ssh_conn_id = None，remote_host = None，command = None，timeout = 10，do_xcom_push = False，* args，** kwargs） ``` 基類： [`airflow.models.BaseOperator`](31 "airflow.models.BaseOperator") WinRMOperator 使用 winrm_hook 在給定的遠程主機上執行命令。參數： * `winrm_hook(`WinRMHook`)` - 用于遠程執行的預定義 ssh_hook * `ssh_conn_id(str)` - 來自**airflow** Connections 的連接 ID * `remote_host(str)` - 要連接的遠程主機 * `command(str)` - 在遠程主機上執行的命令。（模板） * `timeout(int)` - 執行命令的超時。 * `do_xcom_push(bool)` - 返回由氣流平臺在 xcom 中設置的標準輸出 #### 傳感器 ```py class airflow.contrib.sensors.aws_redshift_cluster_sensor.AwsRedshiftClusterSensor（cluster_identifier，target_status ='available'，aws_conn_id ='aws_default'，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 等待 Redshift 群集達到特定狀態。參數： * `cluster_identifier(str)` - 要 ping 的集群的標識符。 * `target_status(str)` - 所需的集群狀態。 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.bash_sensor.BashSensor（bash_command，env = None，output_encoding ='utf-8'，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 當且僅當返回碼為 0 時，執行 bash 命令/腳本并返回 True。參數： * `bash_command(string)` - 要執行的命令，命令集或對 bash 腳本（必須為'.sh'）的引用。 * `env(dict)` - 如果 env 不是 None，它必須是一個定義新進程的環境變量的映射; 這些用于代替繼承當前進程環境，這是默認行為。（模板） * `output_encoding(string)` - bash 命令的輸出編碼。 ```py 戳（上下文） ``` 在臨時目錄中執行 bash 命令，之后將對其進行清理 ```py class airflow.contrib.sensors.bigquery_sensor.BigQueryTableSensor（project_id，dataset_id，table_id，bigquery_conn_id ='bigquery_default_conn'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 檢查 Google Bigquery 中是否存在表格。 > <colgroup><col class="field-name"><col class="field-body"></colgroup> > | param project_id： | > | --- | > | | 要在其中查找表的 Google 云項目。提供給鉤子的連接必須提供對指定項目的訪問。 | > | 類型 project_id： | > | --- | > | | 串 | > | param dataset_id： | > | --- | > | | 要在其中查找表的數據集的名稱。存儲桶。 | > | 類型 dataset_id： | > | --- | > | | 串 | > | param table_id： | 要檢查表的名稱是否存在。 | > | --- | --- | > | type table_id： | 串 | > | --- | --- | > | param bigquery_conn_id： | > | --- | > | | 連接到 Google BigQuery 時使用的連接 ID。 | > | 輸入 bigquery_conn_id： | > | --- | > | | 串 | > | param delegate_to： | > | --- | > | | 假冒的帳戶，如果有的話。為此，發出請求的服務帳戶必須啟用域范圍委派。 | > | type delegate_to： | > | --- | > | | 串 | ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.datadog_sensor.DatadogSensor（datadog_conn_id ='datadog_default'，from_seconds_ago = 3600，up_to_seconds_from_now = 0，priority = None，sources = None，tags = None，response_check = None，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 一個傳感器，通過過濾器監聽數據對象事件流并確定是否發出了某些事件。取決于 datadog API，該 API 必須部署在 Airflow 運行的同一服務器上。參數： * `datadog_conn_id` - 與 datadog 的連接，包含 api 密鑰的元數據。 * `datadog_conn_id` - 字符串 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.emr_base_sensor.EmrBaseSensor（aws_conn_id ='aws_default'，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 包含 EMR 的一般傳感器行為。子類應該實現 get_emr_response（）和 state_from_response（）方法。子類還應實現 NON_TERMINAL_STATES 和 FAILED_STATE 常量。 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.emr_job_flow_sensor.EmrJobFlowSensor（job_flow_id，* args，** kwargs） ``` 基類： [`airflow.contrib.sensors.emr_base_sensor.EmrBaseSensor`](31 "airflow.contrib.sensors.emr_base_sensor.EmrBaseSensor") 詢問 JobFlow 的狀態，直到它達到終端狀態。如果傳感器錯誤失敗，則任務失敗。參數：`job_flow_id(string)` - job_flow_id 來檢查狀態 ```py class airflow.contrib.sensors.emr_step_sensor.EmrStepSensor（job_flow_id，step_id，* args，** kwargs） ``` 基類： [`airflow.contrib.sensors.emr_base_sensor.EmrBaseSensor`](31 "airflow.contrib.sensors.emr_base_sensor.EmrBaseSensor") 詢問步驟的狀態，直到達到終端狀態。如果傳感器錯誤失敗，則任務失敗。參數： * `job_flow_id(string)` - job_flow_id，其中包含檢查狀態的步驟 * `step_id(string)` - 檢查狀態的步驟 ```py class airflow.contrib.sensors.file_sensor.FileSensor（filepath，fs_conn_id ='fs_default2'，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 等待文件或文件夾降落到文件系統中。如果給定的路徑是目錄，則該傳感器僅在其中存在任何文件時才返回 true（直接或在子目錄中）參數： * `fs_conn_id(string)` - 對文件（路徑）連接 ID 的引用 * `filepath` - 文件或文件夾名稱（相對于連接中設置的基本路徑） ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.ftp_sensor.FTPSensor（path，ftp_conn_id ='ftp_default'，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 等待 FTP 上存在文件或目錄。參數： * `path(str)` - 遠程文件或目錄路徑 * `ftp_conn_id(str)` - 運行傳感器的連接 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.ftp_sensor.FTPSSensor（path，ftp_conn_id ='ftp_default'，* args，** kwargs） ``` 基類： [`airflow.contrib.sensors.ftp_sensor.FTPSensor`](31 "airflow.contrib.sensors.ftp_sensor.FTPSensor") 等待通過 SSL 在 FTP 上存在文件或目錄。 ```py class airflow.contrib.sensors.gcs_sensor.GoogleCloudStorageObjectSensor（bucket，object，google_cloud_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 檢查 Google 云端存儲中是否存在文件。創建一個新的 GoogleCloudStorageObjectSensor。 > <colgroup><col class="field-name"><col class="field-body"></colgroup> > | param bucket： | 對象所在的 Google 云存儲桶。 | > | --- | --- | > | 型桶： | 串 | > | --- | --- | > | 參數對象： | 要在 Google 云存儲分區中檢查的對象的名稱。 | > | --- | --- | > | 類型對象： | 串 | > | --- | --- | > | param google_cloud_storage_conn_id： | > | --- | > | | 連接到 Google 云端存儲時使用的連接 ID。 | > | 輸入 google_cloud_storage_conn_id： | > | --- | > | | 串 | > | param delegate_to： | > | --- | > | | 假冒的帳戶，如果有的話。為此，發出請求的服務帳戶必須啟用域范圍委派。 | > | type delegate_to： | > | --- | > | | 串 | ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.gcs_sensor.GoogleCloudStorageObjectUpdatedSensor（bucket，object，ts_func = <function ts_function>，google_cloud_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 檢查 Google Cloud Storage 中是否更新了對象。創建一個新的 GoogleCloudStorageObjectUpdatedSensor。 > <colgroup><col class="field-name"><col class="field-body"></colgroup> > | param bucket： | 對象所在的 Google 云存儲桶。 | > | --- | --- | > | 型桶： | 串 | > | --- | --- | > | 參數對象： | 要在 Google 云存儲分區中下載的對象的名稱。 | > | --- | --- | > | 類型對象： | 串 | > | --- | --- | > | param ts_func： | 用于定義更新條件的回調。默認回調返回 execution_date + schedule_interval。回調將上下文作為參數。 | > | --- | --- | > | 輸入 ts_func： | 功能 | > | --- | --- | > | param google_cloud_storage_conn_id： | > | --- | > | | 連接到 Google 云端存儲時使用的連接 ID。 | > | 輸入 google_cloud_storage_conn_id： | > | --- | > | | 串 | > | param delegate_to： | > | --- | > | | 假冒的帳戶，如果有的話。為此，發出請求的服務帳戶必須啟用域范圍委派。 | > | type delegate_to： | > | --- | > | | 串 | ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.gcs_sensor.GoogleCloudStoragePrefixSensor（bucket，prefix，google_cloud_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 檢查 Google 云端存儲分區中是否存在前綴文件。創建一個新的 GoogleCloudStorageObjectSensor。 > <colgroup><col class="field-name"><col class="field-body"></colgroup> > | param bucket： | 對象所在的 Google 云存儲桶。 | > | --- | --- | > | 型桶： | 串 | > | --- | --- | > | 參數前綴： | 要在 Google 云存儲分區中檢查的前綴的名稱。 | > | --- | --- | > | 類型前綴： | 串 | > | --- | --- | > | param google_cloud_storage_conn_id： | > | --- | > | | 連接到 Google 云端存儲時使用的連接 ID。 | > | 輸入 google_cloud_storage_conn_id： | > | --- | > | | 串 | > | param delegate_to： | > | --- | > | | 假冒的帳戶，如果有的話。為此，發出請求的服務帳戶必須啟用域范圍委派。 | > | type delegate_to： | > | --- | > | | 串 | ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.hdfs_sensor.HdfsSensorFolder（be_empty = False，* args，** kwargs） ``` 基類： [`airflow.sensors.hdfs_sensor.HdfsSensor`](31 "airflow.sensors.hdfs_sensor.HdfsSensor") ```py 戳（上下文） ``` 戳一個非空的目錄返回值： Bool 取決于搜索條件 ```py class airflow.contrib.sensors.hdfs_sensor.HdfsSensorRegex（regex，* args，** kwargs） ``` 基類： [`airflow.sensors.hdfs_sensor.HdfsSensor`](31 "airflow.sensors.hdfs_sensor.HdfsSensor") ```py 戳（上下文） ``` 用 self.regex 戳一個目錄中的文件返回值： Bool 取決于搜索條件 ```py class airflow.contrib.sensors.jira_sensor.JiraSensor（jira_conn_id ='jira_default'，method_name = None，method_params = None，result_processor = None，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 如有任何變更，請監控 jira 票。參數： * `jira_conn_id(str)` - 對預定義的 Jira 連接的引用 * `method_name(str)` - 要執行的 jira-python-sdk 的方法名稱 * `method_params(dict)` - 方法 method_name 的參數 * `result_processor(function)` - 返回布爾值并充當傳感器響應的函數 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.pubsub_sensor.PubSubPullSensor（project，subscription，max_messages = 5，return_immediately = False，ack_messages = False，gcp_conn_id ='google_cloud_default'，delegate_to = None，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 從 PubSub 訂閱中提取消息并通過 XCom 傳遞它們。此傳感器操作員將從`max_messages`指定的 PubSub 訂閱中提取消息。當訂閱返回消息時，將完成 poke 方法的標準，并且將從操作員返回消息并通過 XCom 傳遞下游任務。如果`ack_messages`設置為 True，則在返回之前將立即確認消息，否則，下游任務將負責確認消息。 `project`并且`subscription`是模板化的，因此您可以在其中使用變量。 ```py 執行（上下文） ``` 重寫以允許傳遞消息 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.qubole_sensor.QuboleSensor（data，qubole_conn_id ='qubole_default'，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 所有 Qubole 傳感器的基類參數： * `qubole_conn_id(string)` - 用于運行傳感器的 qubole 連接 * `data(_JSON 對象 _)` - 包含有效負載的 JSON 對象，需要檢查其存在注意兩個`data`和`qubole_conn_id`字段都是模板支持的。您可以還使用`.txt`文件進行模板驅動的用例。 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.redis_key_sensor.RedisKeySensor（key，redis_conn_id，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 檢查 Redis 數據庫中是否存在密鑰 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.sftp_sensor.SFTPSensor（path，sftp_conn_id ='sftp_default'，* args，** kwargs） ``` 基類： `airflow.operators.sensors.BaseSensorOperator` 等待 SFTP 上存在文件或目錄。：param path：遠程文件或目錄路徑：type path：str：param sftp_conn_id：運行傳感器的連接：鍵入 sftp_conn_id：str ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ```py class airflow.contrib.sensors.wasb_sensor.WasbBlobSensor（container_name，blob_name，wasb_conn_id ='wasb_default'，check_options = None，* args，** kwargs） ``` 基類： [`airflow.sensors.base_sensor_operator.BaseSensorOperator`](31 "airflow.sensors.base_sensor_operator.BaseSensorOperator") 等待 blob 到達 Azure Blob 存儲。參數： * `container_name(str)` - 容器的名稱。 * `blob_name(str)` - blob 的名稱。 * `wasb_conn_id(str)` - 對 wasb 連接的引用。 * `check_options(dict)` - `WasbHook.check_for_blob（）`采用的可選關鍵字參數。 ```py 戳（上下文） ``` 傳感器在派生此類時定義的功能應該覆蓋。 ## 宏這是可以在模板中使用的變量和宏的列表 ### 默認變量默認情況下，Airflow 引擎會傳遞一些可在所有模板中訪問的變量 <colgroup><col width="30%"><col width="70%"></colgroup> | 變量 | 描述| `{{ ds }}` | 執行日期為 `YYYY-MM-DD` | | `{{ ds_nodash }}` | 執行日期為 `YYYYMMDD` | | `{{ prev_ds }}` | 上一個執行日期為`YYYY-MM-DD`。如果是和是，將是。`{{ ds }}``2016-01-08``schedule_interval``@weekly``{{ prev_ds }}``2016-01-01` | | `{{ next_ds }}` | 下一個執行日期為`YYYY-MM-DD`。如果是和是，將是。`{{ ds }}``2016-01-01``schedule_interval``@weekly``{{ prev_ds }}``2016-01-08` | | `{{ yesterday_ds }}` | 昨天的日期是 `YYYY-MM-DD` | | `{{ yesterday_ds_nodash }}` | 昨天的日期是 `YYYYMMDD` | | `{{ tomorrow_ds }}` | 明天的日期是 `YYYY-MM-DD` | | `{{ tomorrow_ds_nodash }}` | 明天的日期是 `YYYYMMDD` | | `{{ ts }}` | 與...一樣 `execution_date.isoformat()` | | `{{ ts_nodash }}` | 和`ts`沒有`-`和`:` | | `{{ execution_date }}` | execution_date，（datetime.datetime） | | `{{ prev_execution_date }}` | 上一個執行日期（如果可用）（datetime.datetime） | | `{{ next_execution_date }}` | 下一個執行日期（datetime.datetime） | | `{{ dag }}` | DAG 對象 | | `{{ task }}` | Task 對象 | | `{{ macros }}` | 對宏包的引用，如下所述 | | `{{ task_instance }}` | task_instance 對象 | | `{{ end_date }}` | 與...一樣 `{{ ds }}` | | `{{ latest_date }}` | 與...一樣 `{{ ds }}` | | `{{ ti }}` | 與...一樣 `{{ task_instance }}` | | `{{ params }}` | 對用戶定義的 params 字典的引用，如果啟用，則可以通過字典覆蓋該字典`trigger_dag -c``dag_run_conf_overrides_params` in ``airflow.cfg` | | `{{ var.value.my_var }}` | 全局定義的變量表示為字典 | | `{{ var.json.my_var.path }}` | 全局定義的變量表示為具有反序列化 JSON 對象的字典，將路徑追加到 JSON 對象中的鍵 | | `{{ task_instance_key_str }}` | 格式化任務實例的唯一，人類可讀的鍵 `{dag_id}_{task_id}_{ds}` | | `{{ conf }}` | 完整的配置對象位于`airflow.configuration.conf`其中，代表您的內容`airflow.cfg` | | `{{ run_id }}` | 在`run_id`當前 DAG 運行 | | `{{ dag_run }}` | 對 DagRun 對象的引用 | | `{{ test_mode }}` | 是否使用 CLI 的 test 子命令調用任務實例 | 請注意，您可以使用簡單的點表示法訪問對象的屬性和方法。這里有什么是可能的一些例子：，，，...參考模型文檔上對象的屬性和方法的詳細信息。`{{ task.owner }}``{{ task.task_id }}``{{ ti.hostname }}` 該`var`模板變量允許您訪問氣流的 UI 定義的變量。您可以以純文本或 JSON 格式訪問它們。如果使用 JSON，您還可以遍歷嵌套結構，例如：`{{ var.json.mydictvar.key1 }}` ### 宏宏是一種向模板公開對象并在模板中位于`macros`命名空間下的方法。提供了一些常用的庫和方法。 <colgroup><col width="44%"><col width="56%"></colgroup> | 變量 | 描述| `macros.datetime` | 標準的 lib `datetime.datetime` | | `macros.timedelta` | 標準的 lib `datetime.timedelta` | | `macros.dateutil` | 對`dateutil`包的引用 | | `macros.time` | 標準的 lib `time` | | `macros.uuid` | 標準的 lib `uuid` | | `macros.random` | 標準的 lib `random` | 還定義了一些特定于氣流的宏： ```py airflow.macros.ds_add（ds，days） ``` 從 YYYY-MM-DD 添加或減去天數參數： * `ds(str)` - `YYYY-MM-DD`要添加的格式的錨定日期 * `days(int)` - 要添加到 ds 的天數，可以使用負值 ```py >>> ds_add ( '2015-01-01' , 5 ) '2015-01-06' >>> ds_add ( '2015-01-06' , - 5 ) '2015-01-01' ``` ```py airflow.macros.ds_format（ds，input_format，output_format） ``` 獲取輸入字符串并輸出輸出格式中指定的另一個字符串參數： * `ds(str)` - 包含日期的輸入字符串 * `input_format(str)` - 輸入字符串格式。例如％Y-％m-％d * `output_format(str)` - 輸出字符串格式例如％Y-％m-％d ```py >>> ds_format ( '2015-01-01' , "%Y-%m- %d " , "%m- %d -%y" ) '01-01-15' >>> ds_format ( '1/5/2015' , "%m/ %d /%Y" , "%Y-%m- %d " ) '2015-01-05' ``` ```py airflow.macros.random（）→x 在區間[0,1）中。 ``` ```py airflow.macros.hive.closest_ds_partition（table，ds，before = True，schema ='default'，metastore_conn_id ='metastore_default'） ``` 此函數在最接近目標日期的列表中查找日期。可以給出可選參數以獲得最接近的之前或之后。參數： * `table(str)` - 配置單元表名稱 * `ds(_datetime.date list_)` - _ 日期 _ 戳，`%Y-%m-%d`例如`yyyy-mm-dd` * `之前(_bool _ 或 _None_)` - 最接近之前（True），之后（False）或 ds 的任一側返回值：最近的日期| 返回類型： | str 或 None ```py >>> tbl = 'airflow.static_babynames_partitioned' >>> closest_ds_partition ( tbl , '2015-01-02' ) '2015-01-01' ``` ```py airflow.macros.hive.max_partition（table，schema ='default'，field = None，filter_map = None，metastore_conn_id ='metastore_default'） ``` 獲取表的最大分區。參數： * `schema(string)` - 表所在的 hive 模式 * `table(string)` - 您感興趣的 hive 表，支持點符號，如“my_database.my_table”，如果找到一個點，則模式參數被忽略 * `metastore_conn_id(string)` - 您感興趣的配置單元連接。如果設置了默認值，則不需要使用此參數。 * `filter_map(_map_)` - partition_key：用于分區過濾的 partition_value 映射，例如{'key1'：'value1'，'key2'：'value2'}。只有匹配所有 partition_key：partition_value 對的分區才會被視為最大分區的候選者。 * `field(str)` - 從中??獲取最大值的字段。如果只有一個分區字段，則會推斷出這一點 ```py >>> max_partition ( 'airflow.static_babynames_partitioned' ) '2015-01-01' ``` ## 楷模模型構建在 SQLAlchemy ORM Base 類之上，實例保留在數據庫中。 ```py class airflow.models.BaseOperator（task_id，owner ='Airflow'，email = None，email_on_retry = True，email_on_failure = True，retries = 0，retry_delay = datetime.timedelta（0,300），retry_exponential_backoff = False，max_retry_delay = None， start_date = None，end_date = None，schedule_interval = None，depends_on_past = False，wait_for_downstream = False，dag = None，params = None，default_args = None，adhoc = False，priority_weight = 1，weight_rule = u'downstream'，queue =' default'，pool = None，sla = None，execution_timeout = None，on_failure_callback = None，on_success_callback = None，on_retry_callback = None，trigger_rule = u'all_success'，resources = None，run_as_user = None，task_concurrency = None，executor_config = None， inlets = None，outlets = None，* args，** kwargs） ``` 基類： `airflow.utils.log.logging_mixin.LoggingMixin` 所有運營商的抽象基類。由于運算符創建的對象成為 dag 中的節點，因此 BaseOperator 包含許多用于 dag 爬行行為的遞歸方法。要派生此類，您需要覆蓋構造函數以及“execute”方法。從此類派生的運算符應同步執行或觸發某些任務（等待完成）。運算符的示例可以是運行 Pig 作業（PigOperator）的運算符，等待分區在 Hive（HiveSensorOperator）中著陸的傳感器運算符，或者是將數據從 Hive 移動到 MySQL（Hive2MySqlOperator）的運算符。這些運算符（任務）的實例針對特定操作，運行特定腳本，函數或數據傳輸。此類是抽象的，不應實例化。實例化從這個派生的類導致創建任務對象，該對象最終成為 DAG 對象中的節點。應使用 set_upstream 和/或 set_downstream 方法設置任務依賴性。參數： * `task_id(string)` - 任務的唯一，有意義的 id * `owner(string)` - 使用 unix 用戶名的任務的所有者 * `retries(int)` - 在失敗任務之前應執行的重試次數 * `retry_delay(timedelta)` - 重試之間的延遲 * `retry_exponential_backoff(bool)` - 允許在重試之間使用指數退避算法在重試之間進行更長時間的等待（延遲將轉換為秒） * `max_retry_delay(timedelta)` - 重試之間的最大延遲間隔 * `start_date(datetime)` - `start_date`用于任務，確定`execution_date`第一個任務實例。最佳做法是將 start_date 四舍五入到 DAG 中`schedule_interval`。每天的工作在 00:00:00 有一天的 start_date，每小時的工作在特定時間的 00:00 有 start_date。請注意，Airflow 只是查看最新的`execution_date`并添加`schedule_interval`以確定下一個`execution_date`。同樣非常重要的是要注意不同任務的依賴關系需要及時排列。如果任務 A 依賴于任務 B 并且它們的 start_date 以其 execution_date 不排列的方式偏移，則永遠不會滿足 A 的依賴性。如果您希望延遲任務，例如在凌晨 2 點運行每日任務，請查看`TimeSensor`和`TimeDeltaSensor`。我們建議不要使用動態`start_date`，建議使用固定的。有關更多信息，請閱讀有關 start_date 的 FAQ 條目。 * `end_date(datetime)` - 如果指定，則調度程序不會超出此日期 * `depends_on_past(bool)` - 當設置為 true 時，任務實例將依次運行，同時依賴上一個任務的計劃成功。允許 start_date 的任務實例運行。 * `wait_for_downstream(bool)` - 當設置為 true 時，任務 X 的實例將等待緊接上一個任務 X 實例下游的任務在運行之前成功完成。如果任務 X 的不同實例更改同一資產，并且任務 X 的下游任務使用此資產，則此操作非常有用。請注意，在使用 wait_for_downstream 的任何地方，depends_on_past 都將強制為 True。 * `queue(str)` - 運行此作業時要定位到哪個隊列。并非所有執行程序都實現隊列管理，CeleryExecutor 確實支持定位特定隊列。 * `dag([_DAG_](31 "airflow.models.DAG"))` - 對任務所附的 dag 的引用（如果有的話） * `priority_weight(int)` - 此任務相對于其他任務的優先級權重。這允許執行程序在事情得到備份時在其他任務之前觸發更高優先級的任務。 * `weight_rule(str)` - 用于任務的有效總優先級權重的加權方法。選項包括：default 是設置為任務的有效權重時是所有下游后代的總和。因此，上游任務將具有更高的權重，并且在使用正權重值時將更積極地安排。當您有多個 dag 運行實例并希望在每個 dag 可以繼續處理下游任務之前完成所有運行的所有上游任務時，這非常有用。設置為時`{ downstream | upstream | absolute }``downstream``downstream``upstream`有效權重是所有上游祖先的總和。這與 downtream 任務具有更高權重并且在使用正權重值時將更積極地安排相反。當你有多個 dag 運行實例并希望在啟動其他 dag 的上游任務之前完成每個 dag 時，這非常有用。設置為時`absolute`，有效重量是精確`priority_weight`指定的，無需額外加權。當您確切知道每個任務應具有的優先級權重時，您可能希望這樣做。另外，當設置`absolute`為時，對于非常大的 DAGS，存在顯著加速任務創建過程的額外效果。可以將選項設置為字符串或使用靜態類中定義的常量`airflow.utils.WeightRule` * `pool(str)` - 此任務應運行的插槽池，插槽池是限制某些任務的并發性的一種方法 * `sla(datetime.timedelta)` - 作業預期成功的時間。請注意，這表示`timedelta`期間結束后。例如，如果您將 SLA 設置為 1 小時，則調度程序將在凌晨 1:00 之后發送電子郵件，`2016-01-02`如果`2016-01-01`實例尚未成功的話。調度程序特別關注具有 SLA 的作業，并發送警報電子郵件以防止未命中。SLA 未命中也記錄在數據庫中以供將來參考。共享相同 SLA 時間的所有任務都捆綁在一封電子郵件中，在此之后很快就會發送。SLA 通知僅為每個任務實例發送一次且僅一次。 * `execution_timeout(datetime.timedelta)` - 執行此任務實例所允許的最長時間，如果超出它將引發并失敗。 * `on_failure_callback(callable)` - 當此任務的任務實例失敗時要調用的函數。上下文字典作為單個參數傳遞給此函數。Context 包含對任務實例的相關對象的引用，并記錄在 API 的宏部分下。 * `on_retry_callback` - 非常類似于`on_failure_callback`重試發生時執行的。 * `on_success_callback(callable)` - 很像`on_failure_callback`是在任務成功時執行它。 * `trigger_rule(str)` - 定義應用依賴項以觸發任務的規則。選項包括：默認為。可以將選項設置為字符串或使用靜態類中定義的常量`{ all_success | all_failed | all_done | one_success | one_failed | dummy}``all_success``airflow.utils.TriggerRule` * `resources(dict)` - 資源參數名稱（Resources 構造函數的參數名稱）與其值的映射。 * `run_as_user(str)` - 在運行任務時使用 unix 用戶名進行模擬 * `task_concurrency(int)` - 設置后，任務將能夠限制 execution_dates 之間的并發運行 * `executor_config(dict)` - 由特定執行程序解釋的其他任務級配置參數。參數由 executor 的名稱命名。[``](31)示例：通過 KubernetesExecutor MyOperator（...，在特定的 docker 容器中運行此任務） > executor_config = {“KubernetesExecutor”： > > > {“image”：“myCustomDockerImage”}} ）`` ```py 清晰（** kwargs） ``` 根據指定的參數清除與任務關聯的任務實例的狀態。 ```py DAG ``` 如果設置則返回運算符的 DAG，否則引發錯誤 ```py deps ``` 返回運算符的依賴項列表。這些與執行上下文依賴性的不同之處在于它們特定于任務，并且可以由子類擴展/覆蓋。 ```py downstream_list ``` @property：直接下游的任務列表 ```py 執行（上下文） ``` 這是在創建運算符時派生的主要方法。Context 與渲染 jinja 模板時使用的字典相同。有關更多上下文，請參閱 get_template_context。 ```py get_direct_relative_ids（上游=假） ``` 獲取當前任務（上游或下游）的直接相對 ID。 ```py get_direct_relatives（上游=假） ``` 獲取當前任務的直接親屬，上游或下游。 ```py get_flat_relative_ids（upstream = False，found_descendants = None） ``` 獲取上游或下游的親屬 ID 列表。 ```py get_flat_relatives（上游=假） ``` 獲取上游或下游親屬的詳細列表。 ```py get_task_instances（session，start_date = None，end_date = None） ``` 獲取與特定日期范圍的此任務相關的一組任務實例。 ```py has_dag（） ``` 如果已將運算符分配給 DAG，則返回 True。 ```py on_kill（） ``` 當任務實例被殺死時，重寫此方法以清除子進程。在操作員中使用線程，子過程或多處理模塊的任何使用都需要清理，否則會留下重影過程。 ```py post_execute（context，* args，** kwargs） ``` 調用 self.execute（）后立即觸發此掛接。它傳遞執行上下文和運算符返回的任何結果。 ```py pre_execute（context，* args，** kwargs） ``` 在調用 self.execute（）之前觸發此掛鉤。 ```py prepare_template（） ``` 模板化字段被其內容替換后觸發的掛鉤。如果您需要操作員在呈現模板之前更改文件的內容，則應覆蓋此方法以執行此操作。 ```py render_template（attr，content，context） ``` 從文件或直接在字段中呈現模板，并返回呈現的結果。 ```py render_template_from_field（attr，content，context，jinja_env） ``` 從字段中呈現模板。如果字段是字符串，它將只是呈現字符串并返回結果。如果它是集合或嵌套的集合集，它將遍歷結構并呈現其中的所有字符串。 ```py run（start_date = None，end_date = None，ignore_first_depends_on_past = False，ignore_ti_state = False，mark_success = False） ``` 為日期范圍運行一組任務實例。 ```py schedule_interval ``` DAG 的計劃間隔始終勝過單個任務，因此 DAG 中的任務始終排列。該任務仍然需要 schedule_interval，因為它可能未附加到 DAG。 ```py set_downstream（task_or_task_list） ``` 將任務或任務列表設置為直接位于當前任務的下游。 ```py set_upstream（task_or_task_list） ``` 將任務或任務列表設置為直接位于當前任務的上游。 ```py upstream_list ``` @property：直接上游的任務列表 ```py xcom_pull（context，task_ids = None，dag_id = None，key = u'return_value'，include_prior_dates = None） ``` 請參見 TaskInstance.xcom_pull（） ```py xcom_push（context，key，value，execution_date = None） ``` 請參見 TaskInstance.xcom_push（） ```py class airflow.models.Chart（** kwargs） ``` 基類： `sqlalchemy.ext.declarative.api.Base` ```py class airflow.models.Connection（conn_id = None，conn_type = None，host = None，login = None，password = None，schema = None，port = None，extra = None，uri = None） ``` 基類：`sqlalchemy.ext.declarative.api.Base`，`airflow.utils.log.logging_mixin.LoggingMixin` 占位符用于存儲有關不同數據庫實例連接信息的信息。這里的想法是腳本使用對數據庫實例（conn_id）的引用，而不是在使用運算符或鉤子時硬編碼主機名，登錄名和密碼。 ```py extra_dejson ``` 通過反序列化 json 返回額外的屬性。 ```py class airflow.models.DAG（dag_id，description = u''，schedule_interval = datetime.timedelta（1），start_date = None，end_date = None，full_filepath = None，template_searchpath = None，user_defined_macros = None，user_defined_filters = None，default_args = None，concurrency = 16，max_active_runs = 16，dagrun_timeout = None，sla_miss_callback = None，default_view = u'tree'，orientation ='LR'，catchup = True，on_success_callback = None，on_failure_callback = None，params = None） ``` 基類：`airflow.dag.base_dag.BaseDag`，`airflow.utils.log.logging_mixin.LoggingMixin` dag（有向無環圖）是具有方向依賴性的任務集合。dag 也有一個時間表，一個開始結束日期（可選）。對于每個計劃（例如每天或每小時），DAG 需要在滿足其依賴性時運行每個單獨的任務。某些任務具有依賴于其自身過去的屬性，這意味著它們在完成之前的計劃（和上游任務）之前無法運行。 DAG 本質上充當任務的命名空間。task_id 只能添加一次到 DAG。參數： * `dag_id(string)` - DAG 的 ID * `description(string)` - 例如，在 Web 服務器上顯示 DAG 的描述 * `schedule_interval(_datetime.timedelta _ 或 _dateutil.relativedelta.relativedelta _ 或 _ 作為 cron 表達式的 str_)` - 定義 DAG 運行的頻率，此 timedelta 對象被添加到最新任務實例的 execution_date 以確定下一個計劃 * `start_date(_datetime.datetime_)` - 調度程序將嘗試回填的時間戳 * `end_date(_datetime.datetime_)` - DAG 無法運行的日期，對于開放式調度保留為 None * `template_searchpath(string 或 _stings 列表 _)` - 此文件夾列表（非相對）定義 jinja 將在哪里查找模板。訂單很重要。請注意，jinja / airflow 默認包含 DAG 文件的路徑 * `user_defined_macros(dict)` - 將在您的 jinja 模板中公開的宏字典。例如，傳遞`dict(foo='bar')`給此參數允許您在與此 DAG 相關的所有 jinja 模板中。請注意，您可以在此處傳遞任何類型的對象。`{{ foo }}` * `user_defined_filters(dict)` - 將在 jinja 模板中公開的過濾器字典。例如，傳遞給此參數允許您在與此 DAG 相關的所有 jinja 模板中。`dict(hello=lambda name: 'Hello %s' % name)``{{ 'world' | hello }}` * `default_args(dict)` - 初始化運算符時用作構造函數關鍵字參數的默認參數的字典。請注意，運算符具有相同的鉤子，并且在此處定義的鉤子之前，這意味著如果您的 dict 包含`'depends_on_past'：`這里為`True`并且`'depends_on_past'：`在運算符的調用`default_args 中`為`False`，實際值將為`False`。 * `params(dict)` - DAG 級別參數的字典，可在模板中訪問，在`params`下命名。這些參數可以在任務級別覆蓋。 * `concurrency(int)` - 允許并發運行的任務實例數 * `max_active_runs(int)` - 活動 DAG 運行的最大數量，超過運行狀態下運行的 DAG 數量，調度程序將不會創建新的活動 DAG 運行 * `dagrun_timeout(datetime.timedelta)` - 指定在超時/失敗之前 DagRun 應該運行多長時間，以便可以創建新的 DagRuns * `sla_miss_callback(_types.FunctionType_)` - 指定報告 SLA 超時時要調用的函數。 * `default_view(string)` - 指定 DAG 默認視圖（樹，圖，持續時間，甘特圖，landing_times） * `orientation(string)` - 在圖表視圖中指定 DAG 方向（LR，TB，RL，BT） * `catchup(bool)` - 執行調度程序追趕（或只運行最新）？默認為 True * `on_failure_callback(callable)` - 當這個 dag 的 DagRun 失敗時要調用的函數。上下文字典作為單個參數傳遞給此函數。 * `on_success_callback(callable)` - 很像`on_failure_callback`是在 dag 成功時執行的。 ```py add_task（任務） ``` 將任務添加到 DAG 參數：`任務(_task_)` - 要添加的任務 ```py add_tasks（任務） ``` 將任務列表添加到 DAG 參數：`任務(**任務**list)` - 您要添加的任務 ```py 清晰（** kwargs） ``` 清除與指定日期范圍的當前 dag 關聯的一組任務實例。 ```py CLI（） ``` 公開特定于此 DAG 的 CLI ```py concurrency_reached ``` 返回一個布爾值，指示是否已達到此 DAG 的并發限制 ```py create_dagrun（** kwargs） ``` 從這個 dag 創建一個 dag run，包括與這個 dag 相關的任務。返回 dag run。參數： * `run_id(string)` - 定義此 dag 運行的運行 ID * `execution_date(datetime)` - 此 dag 運行的執行日期 * `州(_ 州 _)` - dag run 的狀態 * `start_date(datetime)` - 應評估此 dag 運行的日期 * `external_trigger(bool)` - 這個 dag run 是否是外部觸發的 * `session(_Session_)` - 數據庫會話 ```py static deactivate_stale_dags（* args，** kwargs） ``` 在到期日期之前，停用調度程序最后觸及的所有 DAG。這些 DAG 可能已被刪除。參數：`expiration_date(datetime)` - 設置在此時間之前觸摸的非活動 DAG 返回值：沒有 ```py static deactivate_unknown_dags（* args，** kwargs） ``` 給定已知 DAG 列表，停用在 ORM 中標記為活動的任何其他 DAG 參數：`active_dag_ids(_list __[ __unicode __]_)` - 活動的 DAG ID 列表返回值：沒有 ```py 文件路徑 ``` dag 對象實例化的文件位置 ```py 夾 ``` dag 對象實例化的文件夾位置 ```py following_schedule（DTTM） ``` 在當地時間計算此 dag 的以下計劃參數：`dttm` - utc datetime 返回值： utc datetime ```py get_active_runs（** kwargs） ``` 返回當前運行的 dag 運行執行日期列表參數：`會議` -返回值：執行日期清單 ```py get_dagrun（** kwargs） ``` 返回給定執行日期的 dag 運行（如果存在），否則為 none。參數： * `execution_date` - 要查找的 DagRun 的執行日期。 * `會議` - 返回值：如果找到 DagRun，否則為 None。 ```py get_last_dagrun（** kwargs） ``` 返回此 dag 的最后一個 dag 運行，如果沒有則返回 None。最后的 dag run 可以是任何類型的運行，例如。預定或回填。重寫的 DagRuns 被忽略 ```py get_num_active_runs（** kwargs） ``` 返回活動“正在運行”的 dag 運行的數量參數： * `external_trigger(bool)` - 對于外部觸發的活動 dag 運行為 True * `會議` - 返回值：活動 dag 運行的數字大于 0 ```py static get_num_task_instances（* args，** kwargs） ``` 返回給定 DAG 中的任務實例數。參數： * `會話` - ORM 會話 * `dag_id(_unicode_)` - 獲取任務并發性的 DAG 的 ID * `task_ids(_list __[ __unicode __]_)` - 給定 DAG 的有效任務 ID 列表 * `states(_list __[ __state __]_)` - 要提供的過濾狀態列表返回值：正在運行的任務數量| 返回類型： | INT ```py get_run_dates（start_date，end_date = None） ``` 使用此 dag 的計劃間隔返回作為參數接收的間隔之間的日期列表。返回日期可用于執行日期。參數： * `start_date(datetime)` - 間隔的開始日期 * `end_date(datetime)` - 間隔的結束日期，默認為 timezone.utcnow（）返回值： dag 計劃之后的時間間隔內的日期列表| 返回類型： | 名單 ```py get_template_env（） ``` 返回 jinja2 環境，同時考慮 DAGs template_searchpath，user_defined_macros 和 user_defined_filters ```py handle_callback（** kwargs） ``` 根據成功的值觸發相應的回調，即 on_failure_callback 或 on_success_callback。此方法獲取此 DagRun 的單個 TaskInstance 部分的上下文，并將其與“原因”一起傳遞給 callable，主要用于區分 DagRun 失敗。.. 注意： ```py The logs end up in $AIRFLOW_HOME/logs/scheduler/latest/PROJECT/DAG_FILE.py.log ``` 參數： * `dagrun` - DagRun 對象 * `success` - 指定是否應調用失敗或成功回調的標志 * `理由` - 完成原因 * `session` - 數據庫會話 ```py is_paused ``` 返回一個布爾值，指示此 DAG 是否已暫停 ```py latest_execution_date ``` 返回至少存在一個 dag 運行的最新日期 ```py normalize_schedule（DTTM） ``` 返回 dttm + interval，除非 dttm 是第一個區間，然后它返回 dttm ```py previous_schedule（DTTM） ``` 在當地時間計算此 dag 的先前計劃參數：`dttm` - utc datetime 返回值： utc datetime ```py run（start_date = None，end_date = None，mark_success = False，local = False，executor = None，donot_pickle = False，ignore_task_deps = False，ignore_first_depends_on_past = False，pool = None，delay_on_limit_secs = 1.0，verbose = False，conf = None， rerun_failed_tasks = FALSE） ``` 運行 DAG。參數： * `start_date(datetime)` - 要運行的范圍的開始日期 * `end_date(datetime)` - 要運行的范圍的結束日期 * `mark_success(bool)` - 如果成功，則將作業標記為成功而不運行它們 * `local(bool)` - 如果使用 LocalExecutor 運行任務，則為 True * `executor(_BaseExecutor_)` - 運行任務的執行程序實例 * `donot_pickle(bool)` - 正確以避免腌制 DAG 對象并發送給工人 * `ignore_task_deps(bool)` - 如果為 True 則跳過上游任務 * `ignore_first_depends_on_past(bool)` - 如果為 True，則忽略第一組任務的 depends_on_past 依賴項 * `pool(string)` - 要使用的資源池 * `delay_on_limit_secs(float)` - 達到 max_active_runs 限制時，下次嘗試運行 dag run 之前等待的時間（以秒為單位） * `verbose(_boolean_)` - 使日志輸出更詳細 * `conf(dict)` - 從 CLI 傳遞的用戶定義字典 ```py set_dependency（upstream_task_id，downstream_task_id） ``` 使用 add_task（）在已添加到 DAG 的兩個任務之間設置依賴關系的簡單實用工具方法 ```py sub_dag（task_regex，include_downstream = False，include_upstream = True） ``` 基于應該與一個或多個任務匹配的正則表達式返回當前 dag 的子集作為當前 dag 的深層副本，并且包括基于傳遞的標志的上游和下游鄰居。 ```py subdags ``` 返回與此 DAG 關聯的子標記對象的列表 ```py sync_to_db（** kwargs） ``` 將有關此 DAG 的屬性保存到數據庫。請注意，可以為 DAG 和 SubDAG 調用此方法。SubDag 實際上是 SubDagOperator。參數： * `dag([_DAG_](31 "airflow.models.DAG"))` - 要保存到 DB 的 DAG 對象 * `sync_time(datetime)` - 應將 DAG 標記為 sync'ed 的時間返回值：沒有 ```py test_cycle（） ``` 檢查 DAG 中是否有任何循環。如果沒有找到循環，則返回 False，否則引發異常。 ```py topological_sort（） ``` 按地形順序對任務進行排序，以便任務在其任何上游依賴項之后。深受啟發：[http](http://blog.jupo.org/2012/04/06/topological-sorting-acyclic-directed-graphs/)：[//blog.jupo.org/2012/04/06/topological-sorting-acyclic-directed-graphs/](http://blog.jupo.org/2012/04/06/topological-sorting-acyclic-directed-graphs/) 返回值：拓撲順序中的任務列表 ```py 樹視圖（） ``` 顯示 DAG 的 ascii 樹表示 ```py class airflow.models.DagBag（dag_folder = None，executor = None，include_examples = False） ``` 基類：`airflow.dag.base_dag.BaseDagBag`，`airflow.utils.log.logging_mixin.LoggingMixin` dagbag 是 dags 的集合，從文件夾樹中解析出來并具有高級配置設置，例如用作后端的數據庫以及用于觸發任務的執行器。這樣可以更輕松地為生產和開發，測試或不同的團隊或安全配置文件運行不同的環境。系統級別設置現在是 dagbag 級別，以便一個系統可以運行多個獨立的設置集。參數： * `dag_folder(_unicode_)` - 要掃描以查找 DAG 的文件夾 * `executor` - 在此 DagBag 中執行任務實例時使用的執行程序 * `include_examples(bool)` - 是否包含帶有氣流的示例 * `has_logged` - 在跳過文件后從 False 翻轉為 True 的實例布爾值。這是為了防止用戶記錄有關跳過文件的消息而使用戶過載。因此，每個 DagBag 只有一次被記錄的文件被跳過。 ```py bag_dag（dag，parent_dag，root_dag） ``` 將 DAG 添加到包中，遞歸到子 d .. 如果在此 dag 或其子標記中檢測到循環，則拋出 AirflowDagCycleException ```py collect_dags（dag_folder = None，only_if_updated = True） ``` 給定文件路徑或文件夾，此方法查找 python 模塊，導入它們并將它們添加到 dagbag 集合中。請注意，如果在處理目錄時發現.airflowignore 文件，它的行為與.gitignore 非常相似，忽略了與文件中指定的任何正則表達式模式匹配的文件。**注意**：.airflowignore 中的模式被視為未錨定的正則表達式，而不是類似 shell 的 glob 模式。 ```py dagbag_report（） ``` 打印有關 DagBag loading stats 的報告 ```py get_dag（dag_id） ``` 從字典中獲取 DAG，并在過期時刷新它 ```py kill_zombies（** kwargs） ``` 失敗的任務太長時間沒有心跳 ```py process_file（filepath，only_if_updated = True，safe_mode = True） ``` 給定 python 模塊或 zip 文件的路徑，此方法導入模塊并在其中查找 dag 對象。 ```py 尺寸（） ``` 返回值：這個 dagbag 中包含的 dags 數量 ```py class airflow.models.DagModel（** kwargs） ``` 基類： `sqlalchemy.ext.declarative.api.Base` ```py class airflow.models.DagPickle（dag） ``` 基類： `sqlalchemy.ext.declarative.api.Base` Dags 可以來自不同的地方（用戶回購，主回購，......），也可以在不同的地方（不同的執行者）執行。此對象表示 DAG 的一個版本，并成為 BackfillJob 執行的真實來源。pickle 是本機 python 序列化對象，在這種情況下，在作業持續時間內存儲在數據庫中。執行程序獲取 DagPickle id 并從數據庫中讀取 dag 定義。 ```py class airflow.models.DagRun（** kwargs） ``` 基類：`sqlalchemy.ext.declarative.api.Base`，`airflow.utils.log.logging_mixin.LoggingMixin` DagRun 描述了 Dag 的一個實例。它可以由調度程序（用于常規運行）或外部觸發器創建 ```py 靜態查找（* args，** kwargs） ``` 返回給定搜索條件的一組 dag 運行。參數： * `dag_id(_integer __，_ list)` - 用于查找 dag 的 dag_id * `run_id(string)` - 定義此 dag 運行的運行 ID * `execution_date(datetime)` - 執行日期 * `州(_ 州 _)` - dag run 的狀態 * `external_trigger(bool)` - 這個 dag run 是否是外部觸發的 * `no_backfills` - 返回無回填（True），全部返回（False）。默認為 False：鍵入 no_backfills：bool：param session：數據庫會話：類型會話：會話 ```py get_dag（） ``` 返回與此 DagRun 關聯的 Dag。返回值： DAG ```py classmethod get_latest_runs（** kwargs） ``` 返回每個 DAG 的最新 DagRun。 ```py get_previous_dagrun（** kwargs） ``` 以前的 DagRun，如果有的話 ```py get_previous_scheduled_dagrun（** kwargs） ``` 如果有的話，以前的 SCHEDULED DagRun ```py static get_run（session，dag_id，execution_date） ``` 參數： * `dag_id(_unicode_)` - DAG ID * `execution_date(datetime)` - 執行日期返回值： DagRun 對應于給定的 dag_id 和執行日期如果存在的話。否則沒有。：rtype：DagRun ```py get_task_instance（** kwargs） ``` 返回此 dag 運行的 task_id 指定的任務實例參數：`task_id` - 任務 ID ```py get_task_instances（** kwargs） ``` 返回此 dag 運行的任務實例 ```py refresh_from_db（** kwargs） ``` 從數據庫重新加載當前 dagrun：param session：數據庫會話 ```py update_state（** kwargs） ``` 根據 TaskInstances 的狀態確定 DagRun 的整體狀態。返回值：州 ```py verify_integrity（** kwargs） ``` 通過檢查已刪除的任務或尚未在數據庫中的任務來驗證 DagRun。如果需要，它會將狀態設置為已刪除或添加任務。 ```py class airflow.models.DagStat（dag_id，state，count = 0，dirty = False） ``` 基類： `sqlalchemy.ext.declarative.api.Base` ```py 靜態創建（* args，** kwargs） ``` 為指定的 dag 創建缺少狀態 stats 表參數： * `dag_id` - 用于創建統計數據的 dag 的 dag id * `會話` - 數據庫會話返回值： ```py static set_dirty（* args，** kwargs） ``` 參數： * `dag_id` - 用于標記臟的 dag_id * `會話` - 數據庫會話返回值： ```py 靜態更新（* args，** kwargs） ``` 更新臟/不同步 dag 的統計信息參數： * `dag_ids(list)` - 要更新的 dag_ids * `dirty_only(bool)` - 僅針對標記的臟更新，默認為 True * `session(_Session_)` - 要使用的 db 會話 ```py class airflow.models.ImportError（** kwargs） ``` 基類： `sqlalchemy.ext.declarative.api.Base` ```py exception airflow.models.InvalidFernetToken ``` 基類： `exceptions.Exception` ```py class airflow.models.KnownEvent（** kwargs） ``` 基類： `sqlalchemy.ext.declarative.api.Base` ```py class airflow.models.KnownEventType（** kwargs） ``` 基類： `sqlalchemy.ext.declarative.api.Base` ```py class airflow.models.KubeResourceVersion（** kwargs） ``` 基類： `sqlalchemy.ext.declarative.api.Base` ```py class airflow.models.KubeWorkerIdentifier（** kwargs） ``` 基類： `sqlalchemy.ext.declarative.api.Base` ```py class airflow.models.Log（event，task_instance，owner = None，extra = None，** kwargs） ``` 基類： `sqlalchemy.ext.declarative.api.Base` 用于主動將事件記錄到數據庫 ```py class airflow.models.NullFernet ``` 基類： `future.types.newobject.newobject` “Null”加密器類，不加密或解密，但提供與 Fernet 類似的接口。這樣做的目的是使其余代碼不必知道差異，并且只顯示消息一次，而不是在運行`氣流 initdb`時顯示 20 次。 ```py class airflow.models.Pool（** kwargs） ``` 基類： `sqlalchemy.ext.declarative.api.Base` ```py open_slots（** kwargs） ``` 返回此刻打開的插槽數 ```py queued_slots（** kwargs） ``` 返回此刻使用的插槽數 ```py used_slots（** kwargs） ``` 返回此刻使用的插槽數 ```py class airflow.models.SlaMiss（** kwargs） ``` 基類： `sqlalchemy.ext.declarative.api.Base` 存儲已錯過的 SLA 歷史的模型。它用于跟蹤 SLA 故障，并避免雙重觸發警報電子郵件。 ```py class airflow.models.TaskFail（task，execution_date，start_date，end_date） ``` 基類： `sqlalchemy.ext.declarative.api.Base` TaskFail 跟蹤每個任務實例的失敗運行持續時間。 ```py class airflow.models.TaskInstance（task，execution_date，state = None） ``` 基類：`sqlalchemy.ext.declarative.api.Base`，`airflow.utils.log.logging_mixin.LoggingMixin` 任務實例存儲任務實例的狀態。該表是圍繞已運行任務及其所處狀態的權威和單一事實來源。 SqlAlchemy 模型沒有任務或 dag 模型的 SqlAlchemy 外鍵故意對事務進行更多控制。此表上的數據庫事務應該確保雙觸發器以及圍繞哪些任務實例準備好運行的任何混淆，即使多個調度程序可能正在觸發任務實例。 ```py are_dependencies_met（** kwargs） ``` 返回在給定依賴關系的上下文的情況下是否滿足所有條件以運行此任務實例（例如，從 UI 強制運行的任務實例將忽略某些依賴關系）。參數： * `dep_context(_DepContext_)` - 確定應評估的依賴項的執行上下文。 * `session(_Session_)` - 數據庫會話 * `verbose(_boolean_)` - 是否在信息或調試日志級別上的失敗依賴項的日志詳細信息 ```py are_dependents_done（** kwargs） ``` 檢查此任務實例的依賴項是否都已成功。這應該由 wait_for_downstream 使用。當您不希望在完成依賴項之前開始處理任務的下一個計劃時，這非常有用。例如，如果任務 DROPs 并重新創建表。 ```py clear_xcom_data（** kwargs） ``` 從數據庫中清除任務實例的所有 XCom 數據 ```py command（mark_success = False，ignore_all_deps = False，ignore_depends_on_past = False，ignore_task_deps = False，ignore_ti_state = False，local = False，pickle_id = None，raw = False，job_id = None，pool = None，cfg_path = None） ``` 返回可在安裝氣流的任何位置執行的命令。此命令是 orchestrator 發送給執行程序的消息的一部分。 ```py command_as_list（mark_success = False，ignore_all_deps = False，ignore_task_deps = False，ignore_depends_on_past = False，ignore_ti_state = False，local = False，pickle_id = None，raw = False，job_id = None，pool = None，cfg_path = None） ``` 返回可在安裝氣流的任何位置執行的命令。此命令是 orchestrator 發送給執行程序的消息的一部分。 ```py current_state（** kwargs） ``` 從數據庫中獲取最新狀態，如果會話通過，我們使用并查找狀態將成為會話的一部分，否則將使用新會話。 ```py 誤差（** kwargs） ``` 在數據庫中強制將任務實例的狀態設置為 FAILED。 ```py static generate_command（dag_id，task_id，execution_date，mark_success = False，ignore_all_deps = False，ignore_depends_on_past = False，ignore_task_deps = False，ignore_ti_state = False，local = False，pickle_id = None，file_path = None，raw = False，job_id = None，pool =無，cfg_path =無） ``` 生成執行此任務實例所需的 shell 命令。參數： * `dag_id(_unicode_)` - DAG ID * `task_id(_unicode_)` - 任務 ID * `execution_date(datetime)` - 任務的執行日期 * `mark_success(bool)` - 是否將任務標記為成功 * `ignore_all_deps(_boolean_)` - 忽略所有可忽略的依賴項。覆蓋其他 ignore_ *參數。 * `ignore_depends_on_past(_boolean_)` - 忽略 DAG 的 depends_on_past 參數（例如，對于回填） * `ignore_task_deps(_boolean_)` - 忽略任務特定的依賴項，例如 depends_on_past 和觸發器規則 * `ignore_ti_state(_boolean_)` - 忽略任務實例之前的失敗/成功 * `local(bool)` - 是否在本地運行任務 * `pickle_id(_unicode_)` - 如果 DAG 序列化到 DB，則與酸洗 DAG 關聯的 ID * `file_path` - 包含 DAG 定義的文件的路徑 * `原始` - 原始模式（需要更多細節） * `job_id` - 工作 ID（需要更多細節） * `pool(_unicode_)` - 任務應在其中運行的 Airflow 池 * `cfg_path(_basestring_)` - 配置文件的路徑返回值： shell 命令，可用于運行任務實例 ```py get_dagrun（** kwargs） ``` 返回此 TaskInstance 的 DagRun 參數：`會議` -返回值： DagRun ```py init_on_load（） ``` 初始化未存儲在 DB 中的屬性。 ```py init_run_context（原始=假） ``` 設置日志上下文。 ```py is_eligible_to_retry（） ``` 任務實例是否有資格重試 ```py is_premature ``` 返回任務是否處于 UP_FOR_RETRY 狀態且其重試間隔是否已過去。 ```py key ``` 返回唯一標識任務實例的元組 ```py next_retry_datetime（） ``` 如果任務實例失敗，則獲取下次重試的日期時間。對于指數退避，retry_delay 用作基數并將轉換為秒。 ```py pool_full（** kwargs） ``` 返回一個布爾值，指示槽池是否有空間運行此任務 ```py previous_ti ``` 在此任務實例之前運行的任務的任務實例 ```py ready_for_retry（） ``` 檢查任務實例是否處于正確狀態和重試時間范圍。 ```py refresh_from_db（** kwargs） ``` 根據主鍵刷新數據庫中的任務實例參數：`lock_for_update` - 如果為 True，則表示數據庫應鎖定 TaskInstance（發出 FOR UPDATE 子句），直到提交會話為止。 ```py try_number ``` 返回該任務編號在實際運行時的嘗試編號。如果 TI 當前正在運行，這將匹配數據庫中的列，在所有其他情況下，這將是增量的 ```py xcom_pull（task_ids = None，dag_id = None，key = u'return_value'，include_prior_dates = False） ``` 拉 XComs 可選擇滿足特定條件。 `key`的默認值將搜索限制為由其他任務返回的 XComs（而不是手動推送的那些）。要刪除此過濾器，請傳遞 key = None（或任何所需的值）。如果提供了單個 task_id 字符串，則結果是該 task_id 中最新匹配的 XCom 的值。如果提供了多個 task_id，則返回匹配值的元組。無法找到匹配項時返回 None。參數： * `key(string)` - XCom 的密鑰。如果提供，將僅返回具有匹配鍵的 XCom。默認鍵是'return_value'，也可以作為常量 XCOM_RETURN_KEY 使用。此鍵自動提供給任務返回的 XComs（而不是手動推送）。要刪除過濾器，請傳遞 key = None。 * `task_ids(string 或 _ 可迭代的字符串 _ _（_ _ 表示 task_ids __）_)` - 僅提取具有匹配 ID 的任務的 XCom。可以通過 None 刪除過濾器。 * `dag_id(string)` - 如果提供，則僅從此 DAG 中提取 XComs。如果為 None（默認值），則使用調用任務的 DAG。 * `include_prior_dates(bool)` - 如果為 False，則僅返回當前 execution_date 中的 XComs。如果為 True，則返回之前日期的 XComs。 ```py xcom_push（key，value，execution_date = None） ``` 使 XCom 可用于執行任務。參數： * `key(string)` - XCom 的密鑰 * `value(_ 任何 pickleable 對象 _)` - _XCom_ 的值。該值被 pickle 并存儲在數據庫中。 * `execution_date(datetime)` - 如果提供，XCom 將在此日期之前不可見。例如，這可以用于在將來的日期將消息發送到任務，而不會立即顯示。 ```py class airflow.models.User（** kwargs） ``` 基類： `sqlalchemy.ext.declarative.api.Base` ```py class airflow.models.Variable（** kwargs） ``` 基類：`sqlalchemy.ext.declarative.api.Base`，`airflow.utils.log.logging_mixin.LoggingMixin` ```py classmethod setdefault（key，default，deserialize_json = False） ``` 與 Python 內置的 dict 對象一樣，setdefault 返回鍵的當前值，如果不存在，則存儲默認值并返回它。參數： * `key(string)` - 此變量的 Dict 鍵 * `default` - 要設置的默認值，如果變量則返回不在 DB 中：type default：Mixed：param deserialize_json：將其存儲為 DB 中的 JSON 編碼值 > 并在檢索值時取消編碼返回值：雜 ```py class airflow.models.XCom（** kwargs） ``` 基類：`sqlalchemy.ext.declarative.api.Base`，`airflow.utils.log.logging_mixin.LoggingMixin` XCom 對象的基類。 ```py classmethod get_many（** kwargs） ``` 檢索 XCom 值，可選地滿足某些條件 TODO：“pickling”已被棄用，JSON 是首選。 > Airflow 2.0 中將刪除“酸洗”。 ```py classmethod get_one（** kwargs） ``` 檢索 XCom 值，可選擇滿足特定條件。TODO：“pickling”已被棄用，JSON 是首選。 > Airflow 2.0 中將刪除“酸洗”。返回值： XCom 值 ```py classmethod set（** kwargs） ``` 存儲 XCom 值。TODO：“pickling”已被棄用，JSON 是首選。 > Airflow 2.0 中將刪除“酸洗”。返回值：沒有 ```py airflow.models.clear_task_instances（tis，session，activate_dag_runs = True，dag = None） ``` 清除一組任務實例，但確保正在運行的任務實例被殺死。參數： * `tis` - 任務實例列表 * `會話` - 當前會話 * `activate_dag_runs` - 用于檢查活動 dag 運行的標志 * `dag` - DAG 對象 ```py airflow.models.get_fernet（） ``` Fernet 密鑰的延期負載。此功能可能因為未安裝加密或因為 Fernet 密鑰無效而失敗。返回值： Fernet 對象| 舉： | 如果嘗試加載 Fernet 時出現問題，則會出現 AirflowException ## 鉤鉤子是外部平臺和數據庫的接口，在可能的情況下實現通用接口，并充當操作員的構建塊。 ```py class airflow.hooks.dbapi_hook.DbApiHook（* args，** kwargs） ``` 基類： `airflow.hooks.base_hook.BaseHook` sql hooks 的抽象基類。 ```py bulk_dump（table，tmp_file） ``` 將數據庫表轉儲到制表符分隔的文件中參數： * `table(str)` - 源表的名稱 * `tmp_file(str)` - 目標文件的路徑 ```py bulk_load（table，tmp_file） ``` 將制表符分隔的文件加載到數據庫表中參數： * `table(str)` - 目標表的名稱 * `tmp_file(str)` - 要加載到表中的文件的路徑 ```py get_autocommit（康涅狄格州） ``` 獲取提供的連接的自動提交設置。如果 conn.autocommit 設置為 True，則返回 True。如果未設置 conn.autocommit 或將其設置為 False 或 conn 不支持自動提交，則返回 False。：param conn：從中獲取自動提交設置的連接。：type conn：連接對象。：return：連接自動提交設置。：rtype 布爾。 ```py get_conn（） ``` 返回一個連接對象 ```py get_cursor（） ``` 返回一個游標 ```py get_first（sql，parameters = None） ``` 執行 sql 并返回第一個結果行。參數： * `sql(_str _ 或 list)` - 要執行的 sql 語句（str）或要執行的 sql 語句列表 * `參數(_mapping _ 或 _iterable_)` - 用于呈現 SQL 查詢的參數。 ```py get_pandas_df（sql，parameters = None） ``` 執行 sql 并返回一個 pandas 數據幀參數： * `sql(_str _ 或 list)` - 要執行的 sql 語句（str）或要執行的 sql 語句列表 * `參數(_mapping _ 或 _iterable_)` - 用于呈現 SQL 查詢的參數。 ```py get_records（sql，parameters = None） ``` 執行 sql 并返回一組記錄。參數： * `sql(_str _ 或 list)` - 要執行的 sql 語句（str）或要執行的 sql 語句列表 * `參數(_mapping _ 或 _iterable_)` - 用于呈現 SQL 查詢的參數。 ```py insert_rows（table，rows，target_fields = None，commit_every = 1000，replace = False） ``` 將一組元組插入表中的通用方法是，每個 commit_every 行都會創建一個新事務參數： * `table(str)` - 目標表的名稱 * `rows(_ 可迭代的元組 _)` - 要插入表中的行 * `target_fields(_ 可迭代的字符串 _)` - 要填充表的列的名稱 * `commit_every(int)` - 要在一個事務中插入的最大行數。設置為 0 以在一個事務中插入所有行。 * `replace(bool)` - 是否替換而不是插入 ```py run（sql，autocommit = False，parameters = None） ``` 運行命令或命令列表。將 sql 語句列表傳遞給 sql 參數，以使它們按順序執行參數： * `sql(_str _ 或 list)` - 要執行的 sql 語句（str）或要執行的 sql 語句列表 * `autocommit(bool)` - 在執行查詢之前將連接的自動提交設置設置為什么。 * `參數(_mapping _ 或 _iterable_)` - 用于呈現 SQL 查詢的參數。 ```py set_autocommit（conn，autocommit） ``` 設置連接上的自動提交標志 ```py class airflow.hooks.docker_hook.DockerHook（docker_conn_id ='docker_default'，base_url = None，version = None，tls = None） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` 與私有 Docker 注冊表交互。參數：`docker_conn_id(str)` - 存儲憑證和額外配置的 Airflow 連接的 ID ```py class airflow.hooks.hive_hooks.HiveCliHook（hive_cli_conn_id = u'hive_cli_default'，run_as = None，mapred_queue = None，mapred_queue_priority = None，mapred_job_name = None） ``` 基類： `airflow.hooks.base_hook.BaseHook` 圍繞 hive CLI 的簡單包裝。它還支持`beeline`運行 JDBC 的輕量級 CLI，并取代較重的傳統 CLI。要啟用`beeline`，請在連接的額外字段中設置 use_beeline 參數，如下所示`{ "use_beeline": true }` 請注意，您還`hive_cli_params`可以使用要在連接中使用的默認配置單元 CLI 參數，因為在此處傳遞的參數可以被 run_cli 的 hive_conf 參數覆蓋。`{"hive_cli_params": "-hiveconf mapred.job.tracker=some.jobtracker:444"}` 額外的連接參數`auth`將按原樣在`jdbc`連接字符串中傳遞。參數： * `mapred_queue(string)` - Hadoop 調度程序使用的隊列（容量或公平） * `mapred_queue_priority(string)` - 作業隊列中的優先級。可能的設置包括：VERY_HIGH，HIGH，NORMAL，LOW，VERY_LOW * `mapred_job_name(string)` - 此名稱將出現在 jobtracker 中。這可以使監控更容易。 ```py load_df（df，table，field_dict = None，delimiter = u'，'，encoding = u'utf8'，pandas_kwargs = None，** kwargs） ``` 將 pandas DataFrame 加載到配置單元中。如果未傳遞 Hive 數據類型，則會推斷 Hive 數據類型，但不會清理列名稱。參數： * `df(_DataFrame_)` - 要加載到 Hive 表中的 DataFrame * `table(str)` - 目標 Hive 表，使用點表示法來定位特定數據庫 * `field_dict(_OrderedDict_)` - 從列名映射到 hive 數據類型。請注意，它必須是 OrderedDict 才能保持列的順序。 * `delimiter(str)` - 文件中的字段分隔符 * `encoding(str)` - 將 DataFrame 寫入文件時使用的字符串編碼 * `pandas_kwargs(dict)` - 傳遞給 DataFrame.to_csv * `kwargs` - 傳遞給 self.load_file ```py load_file（filepath，table，delimiter = u'，'，field_dict = None，create = True，overwrite = True，partition = None，recreate = False，tblproperties = None） ``` 將本地文件加載到 Hive 中請注意，在 Hive 中生成的表使用的不是最有效的序列化格式。如果加載了大量數據和/或表格被大量查詢，您可能只想使用此運算符將數據暫存到臨時表中，然后使用 a 將其加載到最終目標中。`STORED AS textfile``HiveOperator` 參數： * `filepath(str)` - 要加載的文件的本地文件路徑 * `table(str)` - 目標 Hive 表，使用點表示法來定位特定數據庫 * `delimiter(str)` - 文件中的字段分隔符 * `field_dict(_OrderedDict_)` - 文件中字段的字典名稱作為鍵，其 Hive 類型作為值。請注意，它必須是 OrderedDict 才能保持列的順序。 * `create(bool)` - 是否創建表，如果它不存在 * `overwrite(bool)` - 是否覆蓋表或分區中的數據 * `partition(dict)` - 將目標分區作為分區列和值的字典 * `recreate(bool)` - 是否在每次執行時刪除并重新創建表 * `tblproperties(dict)` - 正在創建的 hive 表的 TBLPROPERTIES ```py run_cli（hql，schema = None，verbose = True，hive_conf = None） ``` 使用 hive cli 運行 hql 語句。如果指定了 hive_conf，它應該是一個 dict，并且條目將在 HiveConf 中設置為鍵/值對參數：`hive_conf(dict)` - 如果指定，這些鍵值對將作為傳遞給 hive 。請注意，它們將在之后傳遞，因此將覆蓋數據庫中指定的任何值。`-hiveconf "key"="value"``hive_cli_params` ```py >>> hh = HiveCliHook () >>> result = hh . run_cli ( "USE airflow;" ) >>> ( "OK" in result ) True ``` ```py test_hql（HQL） ``` 使用 hive cli 和 EXPLAIN 測試 hql 語句 ```py class airflow.hooks.hive_hooks.HiveMetastoreHook（metastore_conn_id = u'metastore_default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` 包裝器與 Hive Metastore 交互 ```py check_for_named_pa??rtition（schema，table，partition_name） ``` 檢查是否存在具有給定名稱的分區參數： * `schema(string)` - @table 所屬的 hive 模式（數據庫）的名稱 * `table` - @partition 所屬的配置單元表的名稱 | 劃分： | 要檢查的分區的名稱（例如`a = b / c = d`）| 返回類型： | 布爾 ```py >>> hh = HiveMetastoreHook () >>> t = 'static_babynames_partitioned' >>> hh . check_for_named_partition ( 'airflow' , t , "ds=2015-01-01" ) True >>> hh . check_for_named_partition ( 'airflow' , t , "ds=xxx" ) False ``` ```py check_for_partition（架構，表，分區） ``` 檢查分區是否存在參數： * `schema(string)` - @table 所屬的 hive 模式（數據庫）的名稱 * `table` - @partition 所屬的配置單元表的名稱 | 劃分： | 與要檢查的分區匹配的表達式（例如`a ='b'和 c ='d'`）| 返回類型： | 布爾 ```py >>> hh = HiveMetastoreHook () >>> t = 'static_babynames_partitioned' >>> hh . check_for_partition ( 'airflow' , t , "ds='2015-01-01'" ) True ``` ```py get_databases（圖案= U '*'） ``` 獲取 Metastore 表對象 ```py get_metastore_client（） ``` 返回一個 Hive thrift 客戶端。 ```py get_partitions（schema，table_name，filter = None） ``` 返回表中所有分區的列表。僅適用于小于 32767（java short max val）的表。對于子分區表，該數字可能很容易超過此值。 ```py >>> hh = HiveMetastoreHook () >>> t = 'static_babynames_partitioned' >>> parts = hh . get_partitions ( schema = 'airflow' , table_name = t ) >>> len ( parts ) 1 >>> parts [{'ds': '2015-01-01'}] ``` ```py get_table（table_name，db = u'default'） ``` 獲取 Metastore 表對象 ```py >>> hh = HiveMetastoreHook () >>> t = hh . get_table ( db = 'airflow' , table_name = 'static_babynames' ) >>> t . tableName 'static_babynames' >>> [ col . name for col in t . sd . cols ] ['state', 'year', 'name', 'gender', 'num'] ``` ```py get_tables（db，pattern = u'*'） ``` 獲取 Metastore 表對象 ```py max_partition（schema，table_name，field = None，filter_map = None） ``` 返回表中給定字段的所有分區的最大值。如果表中只存在一個分區鍵，則該鍵將用作字段。filter_map 應該是 partition_key：partition_value map，將用于過濾掉分區。參數： * `schema(string)` - 模式名稱。 * `table_name(string)` - 表名。 * `field(string)` - 從中??獲取最大分區的分區鍵。 * `filter_map(_map_)` - partition_key：用于分區過濾的 partition_value 映射。 ```py >>> hh = HiveMetastoreHook () >>> filter_map = { 'ds' : '2015-01-01' , 'ds' : '2014-01-01' } >>> t = 'static_babynames_partitioned' >>> hh . max_partition ( schema = 'airflow' , ... table_name = t , field = 'ds' , filter_map = filter_map ) '2015-01-01' ``` ```py table_exists（table_name，db = u'default'） ``` 檢查表是否存在 ```py >>> hh = HiveMetastoreHook () >>> hh . table_exists ( db = 'airflow' , table_name = 'static_babynames' ) True >>> hh . table_exists ( db = 'airflow' , table_name = 'does_not_exist' ) False ``` ```py class airflow.hooks.hive_hooks.HiveServer2Hook（hiveserver2_conn_id = u'hiveserver2_default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` pyhive 庫周圍的包裝請注意，默認的 authMechanism 是 PLAIN，要覆蓋它，您可以`extra`在 UI 中的連接中指定它，如在 ```py get_pandas_df（hql，schema = u'default'） ``` 從 Hive 查詢中獲取 pandas 數據幀 ```py >>> hh = HiveServer2Hook () >>> sql = "SELECT * FROM airflow.static_babynames LIMIT 100" >>> df = hh . get_pandas_df ( sql ) >>> len ( df . index ) 100 ``` ```py get_records（hql，schema = u'default'） ``` 從 Hive 查詢中獲取一組記錄。 ```py >>> hh = HiveServer2Hook () >>> sql = "SELECT * FROM airflow.static_babynames LIMIT 100" >>> len ( hh . get_records ( sql )) 100 ``` ```py class airflow.hooks.http_hook.HttpHook（method ='POST'，http_conn_id ='http_default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` 與 HTTP 服務器交互。：param http_conn_id：具有基本 API 網址的連接，即[https://www.google.com/](https://www.google.com/) > 和可選的身份驗證憑據也可以在 Json 格式的 Extra 字段中指定默認標頭。參數：`method(str)` - 要調用的 API 方法 ```py check_response（響應） ``` 檢查狀態代碼并在非 2XX 或 3XX 狀態代碼上引發 AirflowException 異常：param response：請求響應對象：type response：requests.response ```py get_conn（頭=無） ``` 返回用于請求的 http 會話：param headers：要作為字典傳遞的其他標頭：type headers：dict ```py run（endpoint，data = None，headers = None，extra_options = None） ``` 執行請求：param endpoint：要調用的端點，即 resource / v1 / query？：type endpoint：str：param data：要上載的有效負載或請求參數：type data：dict：param headers：要作為字典傳遞的其他頭：type headers：dict：param extra_options：執行時要使用的其他選項請求 > ie {'check_response'：False}以避免在非 2XX 或 3XX 狀態代碼上檢查引發異常 ```py run_and_check（session，prepped_request，extra_options） ``` 獲取超時等額外選項并實際運行請求，檢查結果：param session：用于執行請求的會話：type session：requests.Session：param prepped_request：在 run（）中生成的準備好的請求：type prepped_request ：session.prepare_request：param extra_options：執行請求時要使用的其他選項 > ie {'check_response'：False}以避免在非 2XX 或 3XX 狀態代碼上檢查引發異常 ```py run_with_advanced_retry（_retry_args，* args，** kwargs） ``` 運行 Hook.run（）并附加一個 Tenacity 裝飾器。這對于可能受間歇性問題干擾并且不應立即失效的連接器非常有用。：param _retry_args：定義重試行為的參數。 > 請參閱[https://github.com/jd/tenacity 上的](https://github.com/jd/tenacity) Tenacity 文檔[](https://github.com/jd/tenacity) ```py 示例：:: ``` hook = HttpHook（http_conn_id ='my_conn'，method ='GET'）retry_args = dict（ > > wait = tenacity.wait_exponential（），stop = tenacity.stop_after_attempt（10），retry = requests.exceptions.ConnectionError > > ）hook.run_with_advanced_retry（ > > > > endpoint ='v1 / test'，_ retry_args = retry_args > > > > ） ```py class airflow.hooks.druid_hook.DruidDbApiHook（* args，** kwargs） ``` 基類： [`airflow.hooks.dbapi_hook.DbApiHook`](31 "airflow.hooks.dbapi_hook.DbApiHook") 與德魯伊經紀人互動這個鉤子純粹是供用戶查詢德魯伊經紀人。攝取，請使用 druidHook。 ```py get_conn（） ``` 建立與德魯伊經紀人的聯系。 ```py get_pandas_df（sql，parameters = None） ``` 執行 sql 并返回一個 pandas 數據幀參數： * `sql(_str _ 或 list)` - 要執行的 sql 語句（str）或要執行的 sql 語句列表 * `參數(_mapping _ 或 _iterable_)` - 用于呈現 SQL 查詢的參數。 ```py get_uri（） ``` 獲取德魯伊經紀人的連接 uri。例如：druid：// localhost：8082 / druid / v2 / sql / ```py insert_rows（table，rows，target_fields = None，commit_every = 1000） ``` 將一組元組插入表中的通用方法是，每個 commit_every 行都會創建一個新事務參數： * `table(str)` - 目標表的名稱 * `rows(_ 可迭代的元組 _)` - 要插入表中的行 * `target_fields(_ 可迭代的字符串 _)` - 要填充表的列的名稱 * `commit_every(int)` - 要在一個事務中插入的最大行數。設置為 0 以在一個事務中插入所有行。 * `replace(bool)` - 是否替換而不是插入 ```py set_autocommit（conn，autocommit） ``` 設置連接上的自動提交標志 ```py class airflow.hooks.druid_hook.DruidHook（druid_ingest_conn_id ='druid_ingest_default'，timeout = 1，max_ingestion_time = None） ``` 基類： `airflow.hooks.base_hook.BaseHook` 與德魯伊霸主的聯系以供攝取參數： * `druid_ingest_conn_id(string)` - 接受索引作業的德魯伊霸王機器的連接 ID * `timeout(int)` - 輪詢 Druid 作業以獲取攝取作業狀態之間的間隔 * `max_ingestion_time(int)` - 假定作業失敗前的最長攝取時間 ```py class airflow.hooks.hdfs_hook.HDFSHook（hdfs_conn_id ='hdfs_default'，proxy_user = None，autoconfig = False） ``` 基類： `airflow.hooks.base_hook.BaseHook` 與 HDFS 互動。這個類是 snakebite 庫的包裝器。參數： * `hdfs_conn_id` - 用于獲取連接信息的連接 ID * `proxy_user(string)` - HDFS 操作的有效用戶 * `autoconfig(bool)` - 使用 snakebite 自動配置的客戶端 ```py get_conn（） ``` 返回一個 snakebite HDFSClient 對象。 ```py class airflow.hooks.jdbc_hook.JdbcHook（* args，** kwargs） ``` 基類： [`airflow.hooks.dbapi_hook.DbApiHook`](31 "airflow.hooks.dbapi_hook.DbApiHook") jdbc db 訪問的常規掛鉤。 JDBC URL，用戶名和密碼將取自預定義的連接。請注意，必須在 DB 中的“host”字段中指定整個 JDBC URL。如果給定的連接 ID 不存在，則引發氣流錯誤。 ```py get_conn（） ``` 返回一個連接對象 ```py set_autocommit（conn，autocommit） ``` 啟用或禁用給定連接的自動提交。參數：`conn` - 連接返回值： ```py class airflow.hooks.mssql_hook.MsSqlHook（* args，** kwargs） ``` 基類： [`airflow.hooks.dbapi_hook.DbApiHook`](31 "airflow.hooks.dbapi_hook.DbApiHook") 與 Microsoft SQL Server 交互。 ```py get_conn（） ``` 返回一個 mssql 連接對象 ```py set_autocommit（conn，autocommit） ``` 設置連接上的自動提交標志 ```py class airflow.hooks.mysql_hook.MySqlHook（* args，** kwargs） ``` 基類： [`airflow.hooks.dbapi_hook.DbApiHook`](31 "airflow.hooks.dbapi_hook.DbApiHook") 與 MySQL 交互。您可以在連接的額外字段中指定 charset 。您也可以選擇光標。有關更多詳細信息，請參閱 MySQLdb.cursors。`{"charset": "utf8"}``{"cursor": "SSCursor"}` ```py bulk_dump（table，tmp_file） ``` 將數據庫表轉儲到制表符分隔的文件中 ```py bulk_load（table，tmp_file） ``` 將制表符分隔的文件加載到數據庫表中 ```py get_autocommit（康涅狄格州） ``` MySql 連接以不同的方式進行自動提交。：param conn：連接以獲取自動提交設置。：type conn：連接對象。：return：connection autocommit setting：rtype bool ```py get_conn（） ``` 返回一個 mysql 連接對象 ```py set_autocommit（conn，autocommit） ``` MySql 連接以不同的方式設置自動提交。 ```py class airflow.hooks.oracle_hook.OracleHook（* args，** kwargs） ``` 基類： [`airflow.hooks.dbapi_hook.DbApiHook`](31 "airflow.hooks.dbapi_hook.DbApiHook") 與 Oracle SQL 交互。 ```py bulk_insert_rows（table，rows，target_fields = None，commit_every = 5000） ``` cx_Oracle 的高性能批量插入，它通過`executemany（）`使用預處理語句。為獲得最佳性能，請將`行`作為迭代器傳入。 ```py get_conn（） ``` 返回 oracle 連接對象使用自定義 DSN 連接的可選參數（而不是使用來自 tnsnames.ora 的服務器別名）dsn（數據源名稱）是 TNS 條目（來自 Oracle 名稱服務器或 tnsnames.ora 文件）或者是一個像 makedsn（）返回的字符串。參數： * `dsn` - Oracle 服務器的主機地址 * `service_name` - 要連接的數據庫的 db_unique_name（TNS 的 CONNECT_DATA 部分）您可以在連接的額外字段中設置這些參數，如 `{ "dsn":"some.host.address" , "service_name":"some.service.name" }` ```py insert_rows（table，rows，target_fields = None，commit_every = 1000） ``` 將一組元組插入表中的通用方法，整個插入集被視為一個事務從標準 DbApiHook 實現更改： - cx_Oracle 中的 Oracle SQL 查詢不能以分號（';'）終止 - 替換 NaN 使用 numpy.nan_to_num 的 NULL 值（不使用 is_nan（） > 因為字符串的輸入類型錯誤） * 在插入期間將日期時間單元格強制轉換為 Oracle DATETIME 格式 ```py class airflow.hooks.pig_hook.PigCliHook（pig_cli_conn_id ='pig_cli_default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` 豬 CLI 的簡單包裝。請注意，您還`pig_properties`可以使用要在連接中使用的默認 pig CLI 屬性來設置`{"pig_properties": "-Dpig.tmpfilecompression=true"}` ```py run_cli（pig，verbose = True） ``` 使用豬 cli 運行豬腳本 ```py >>> ph = PigCliHook () >>> result = ph . run_cli ( "ls /;" ) >>> ( "hdfs://" in result ) True ``` ```py class airflow.hooks.postgres_hook.PostgresHook（* args，** kwargs） ``` 基類： [`airflow.hooks.dbapi_hook.DbApiHook`](31 "airflow.hooks.dbapi_hook.DbApiHook") 與 Postgres 互動。您可以在連接的額外字段中指定 ssl 參數。`{"sslmode": "require", "sslcert": "/path/to/cert.pem", etc}` 注意：對于 Redshift，請在額外的連接參數中使用 keepalives_idle 并將其設置為小于 300 秒。 ```py bulk_dump（table，tmp_file） ``` 將數據庫表轉儲到制表符分隔的文件中 ```py bulk_load（table，tmp_file） ``` 將制表符分隔的文件加載到數據庫表中 ```py copy_expert（sql，filename，open = <內置函數打開>） ``` 使用 psycopg2 copy_expert 方法執行 SQL。必須在不訪問超級用戶的情況下執行 COPY 命令。注意：如果使用“COPY FROM”語句調用此方法并且指定的輸入文件不存在，則會創建一個空文件并且不會加載任何數據，但操作會成功。因此，如果用戶想要知道輸入文件何時不存在，他們必須自己檢查它的存在。 ```py get_conn（） ``` 返回一個連接對象 ```py class airflow.hooks.presto_hook.PrestoHook（* args，** kwargs） ``` 基類： [`airflow.hooks.dbapi_hook.DbApiHook`](31 "airflow.hooks.dbapi_hook.DbApiHook") 通過 PyHive 與 Presto 互動！ ```py >>> ph = PrestoHook () >>> sql = "SELECT count(1) AS num FROM airflow.static_babynames" >>> ph . get_records ( sql ) [[340698]] ``` ```py get_conn（） ``` 返回一個連接對象 ```py get_first（hql，parameters = None） ``` 無論查詢返回多少行，都只返回第一行。 ```py get_pandas_df（hql，parameters = None） ``` 從 sql 查詢中獲取 pandas 數據幀。 ```py get_records（hql，parameters = None） ``` 從 Presto 獲取一組記錄 ```py insert_rows（table，rows，target_fields = None） ``` 將一組元組插入表中的通用方法。參數： * `table(str)` - 目標表的名稱 * `rows(_ 可迭代的元組 _)` - 要插入表中的行 * `target_fields(_ 可迭代的字符串 _)` - 要填充表的列的名稱 ```py run（hql，parameters = None） ``` 執行針對 Presto 的聲明。可用于創建視圖。 ```py class airflow.hooks.S3_hook.S3Hook（aws_conn_id ='aws_default'） ``` 基類： [`airflow.contrib.hooks.aws_hook.AwsHook`](31 "airflow.contrib.hooks.aws_hook.AwsHook") 使用 boto3 庫與 AWS S3 交互。 ```py check_for_bucket（BUCKET_NAME） ``` 檢查 bucket_name 是否存在。參數：`bucket_name(str)` - 存儲桶的名稱 ```py check_for_key（key，bucket_name = None） ``` 檢查存儲桶中是否存在密鑰參數： * `key(str)` - 指向文件的 S3 鍵 * `bucket_name(str)` - 存儲文件的存儲桶的名稱 ```py check_for_prefix（bucket_name，prefix，delimiter） ``` 檢查存儲桶中是否存在前綴 ```py check_for_wildcard_key（wildcard_key，bucket_name = None，delimiter =''） ``` 檢查桶中是否存在與通配符表達式匹配的密鑰 ```py get_bucket（BUCKET_NAME） ``` 返回 boto3.S3.Bucket 對象參數：`bucket_name(str)` - 存儲桶的名稱 ```py get_key（key，bucket_name = None） ``` 返回 boto3.s3.Object 參數： * `key(str)` - 密鑰的路徑 * `bucket_name(str)` - 存儲桶的名稱 ```py get_wildcard_key（wildcard_key，bucket_name = None，delimiter =''） ``` 返回與通配符表達式匹配的 boto3.s3.Object 對象參數： * `wildcard_key(str)` - 密鑰的路徑 * `bucket_name(str)` - 存儲桶的名稱 ```py list_keys（bucket_name，prefix =''，delimiter =''，page_size = None，max_items = None） ``` 列出前綴下的存儲桶中的密鑰，但不包含分隔符參數： * `bucket_name(str)` - 存儲桶的名稱 * `prefix(str)` - 一個密鑰前綴 * `delimiter(str)` - 分隔符標記鍵層次結構。 * `page_size(int)` - 分頁大小 * `max_items(int)` - 要返回的最大項目數 ```py list_prefixes（bucket_name，prefix =''，delimiter =''，page_size = None，max_items = None） ``` 列出前綴下的存儲桶中的前綴參數： * `bucket_name(str)` - 存儲桶的名稱 * `prefix(str)` - 一個密鑰前綴 * `delimiter(str)` - 分隔符標記鍵層次結構。 * `page_size(int)` - 分頁大小 * `max_items(int)` - 要返回的最大項目數 ```py load_bytes（bytes_data，key，bucket_name = None，replace = False，encrypt = False） ``` 將字節加載到 S3 這是為了方便在 S3 中刪除字符串。它使用 boto 基礎結構將文件發送到 s3。參數： * `bytes_data(_bytes_)` - 設置為密鑰內容的字節。 * `key(str)` - 指向文件的 S3 鍵 * `bucket_name(str)` - 存儲文件的存儲桶的名稱 * `replace(bool)` - 一個標志，用于決定是否覆蓋密鑰（如果已存在） * `encrypt(bool)` - 如果為 True，則文件將在服務器端由 S3 加密，并在 S3 中靜止時以加密形式存儲。 ```py load_file（filename，key，bucket_name = None，replace = False，encrypt = False） ``` 將本地文件加載到 S3 參數： * `filename(str)` - 要加載的文件的名稱。 * `key(str)` - 指向文件的 S3 鍵 * `bucket_name(str)` - 存儲文件的存儲桶的名稱 * `replace(bool)` - 一個標志，用于決定是否覆蓋密鑰（如果已存在）。如果 replace 為 False 且密鑰存在，則會引發錯誤。 * `encrypt(bool)` - 如果為 True，則文件將在服務器端由 S3 加密，并在 S3 中靜止時以加密形式存儲。 ```py load_string（string_data，key，bucket_name = None，replace = False，encrypt = False，encoding ='utf-8'） ``` 將字符串加載到 S3 這是為了方便在 S3 中刪除字符串。它使用 boto 基礎結構將文件發送到 s3。參數： * `string_data(str)` - 要設置為鍵的內容的字符串。 * `key(str)` - 指向文件的 S3 鍵 * `bucket_name(str)` - 存儲文件的存儲桶的名稱 * `replace(bool)` - 一個標志，用于決定是否覆蓋密鑰（如果已存在） * `encrypt(bool)` - 如果為 True，則文件將在服務器端由 S3 加密，并在 S3 中靜止時以加密形式存儲。 ```py read_key（key，bucket_name = None） ``` 從 S3 讀取密鑰參數： * `key(str)` - 指向文件的 S3 鍵 * `bucket_name(str)` - 存儲文件的存儲桶的名稱 ```py select_key（key，bucket_name = None，expression ='SELECT * FROM S3Object'，expression_type ='SQL'，input_serialization = {'CSV'：{}}，output_serialization = {'CSV'：{}}） ``` 使用 S3 Select 讀取密鑰。參數： * `key(str)` - 指向文件的 S3 鍵 * `bucket_name(str)` - 存儲文件的存儲桶的名稱 * `expression(str)` - S3 選擇表達式 * `expression_type(str)` - S3 選擇表達式類型 * `input_serialization(dict)` - S3 選擇輸入數據序列化格式 * `output_serialization(dict)` - S3 選擇輸出數據序列化格式返回值：通過 S3 Select 檢索原始數據的子集| 返回類型： | 海峽也可以看看有關 S3 Select 參數的更多詳細信息：[http](http://boto3.readthedocs.io/en/latest/reference/services/s3.html)：[//boto3.readthedocs.io/en/latest/reference/services/s3.html#S3.Client.selectobjectcontent](http://boto3.readthedocs.io/en/latest/reference/services/s3.html) ```py class airflow.hooks.samba_hook.SambaHook（samba_conn_id） ``` 基類： `airflow.hooks.base_hook.BaseHook` 允許與 samba 服務器交互。 ```py class airflow.hooks.slack_hook.SlackHook（token = None，slack_conn_id = None） ``` 基類： `airflow.hooks.base_hook.BaseHook` 使用 slackclient 庫與 Slack 交互。 ```py class airflow.hooks.sqlite_hook.SqliteHook（* args，** kwargs） ``` 基類： [`airflow.hooks.dbapi_hook.DbApiHook`](31 "airflow.hooks.dbapi_hook.DbApiHook") 與 SQLite 交互。 ```py get_conn（） ``` 返回一個 sqlite 連接對象 ```py class airflow.hooks.webhdfs_hook.WebHDFSHook（webhdfs_conn_id ='webhdfs_default'，proxy_user = None） ``` 基類： `airflow.hooks.base_hook.BaseHook` 與 HDFS 互動。這個類是 hdfscli 庫的包裝器。 ```py check_for_path（hdfs_path） ``` 通過查詢 FileStatus 檢查 HDFS 中是否存在路徑。 ```py get_conn（） ``` 返回 hdfscli InsecureClient 對象。 ```py load_file（source，destination，overwrite = True，parallelism = 1，** kwargs） ``` 將文件上傳到 HDFS 參數： * `source(str)` - 文件或文件夾的本地路徑。如果是文件夾，則會上傳其中的所有文件（請注意，這意味著不會遠程創建文件夾空文件夾）。 * `destination(str)` - PTarget HDFS 路徑。如果它已經存在并且是目錄，則文件將被上傳到內部。 * `overwrite(bool)` - 覆蓋任何現有文件或目錄。 * `parallelism(int)` - 用于并行化的線程數。值`0`（或負數）使用與文件一樣多的線程。 * `** kwargs` - 轉發給的關鍵字參數`upload()`。 ```py class airflow.hooks.zendesk_hook.ZendeskHook（zendesk_conn_id） ``` 基類： `airflow.hooks.base_hook.BaseHook` 與 Zendesk 交談的鉤子 ```py call（path，query = None，get_all_pages = True，side_loading = False） ``` 調用 Zendesk API 并返回結果參數： * `path` - 要調用的 Zendesk API * `query` - 查詢參數 * `get_all_pages` - 在返回之前累積所有頁面的結果。由于嚴格的速率限制，這通常會超時。等待超時后嘗試之間的建議時間段。 * `side_loading` - 作為單個請求的一部分檢索相關記錄。為了啟用側載，請添加一個'include'查詢參數，其中包含要加載的以逗號分隔的資源列表。有關側載的更多信息，請參閱[https://developer.zendesk.com/rest_api/docs/core/side_loading](https://developer.zendesk.com/rest_api/docs/core/side_loading) ### 社區貢獻了鉤子 ```py class airflow.contrib.hooks.aws_dynamodb_hook.AwsDynamoDBHook（table_keys = None，table_name = None，region_name = None，* args，** kwargs） ``` 基類： [`airflow.contrib.hooks.aws_hook.AwsHook`](31 "airflow.contrib.hooks.aws_hook.AwsHook") 與 AWS DynamoDB 交互。參數： * `table_keys(list)` - 分區鍵和排序鍵 * `table_name(str)` - 目標 DynamoDB 表 * `region_name(str)` - aws 區域名稱（例如：us-east-1） ```py write_batch_data（項目） ``` 將批處理項目寫入 dynamodb 表，并提供整個容量。 ```py class airflow.contrib.hooks.aws_hook.AwsHook（aws_conn_id ='aws_default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` 與 AWS 互動。這個類是 boto3 python 庫的一個瘦包裝器。 ```py get_credentials（REGION_NAME =無） ``` 獲取底層的`botocore.Credentials`對象。它包含以下屬性：access_key，secret_key 和 token。 ```py get_session（REGION_NAME =無） ``` 獲取底層的 boto3.session。 ```py class airflow.contrib.hooks.aws_lambda_hook.AwsLambdaHook（function_name，region_name = None，log_type ='None'，qualifier ='$ LATEST'，invocation_type ='RequestResponse'，* args，** kwargs） ``` 基類： [`airflow.contrib.hooks.aws_hook.AwsHook`](31 "airflow.contrib.hooks.aws_hook.AwsHook") 與 AWS Lambda 互動參數： * `function_name(str)` - AWS Lambda 函數名稱 * `region_name(str)` - AWS 區域名稱（例如：us-west-2） * `log_type(str)` - 尾調用請求 * `qualifier(str)` - AWS Lambda 函數版本或別名 * `invocation_type(str)` - AWS Lambda 調用類型（RequestResponse，Event 等） ```py invoke_lambda（有效載荷） ``` 調用 Lambda 函數 ```py class airflow.contrib.hooks.azure_data_lake_hook.AzureDataLakeHook（azure_data_lake_conn_id ='azure_data_lake_default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` 與 Azure Data Lake 進行交互。客戶端 ID 和客戶端密鑰應該在用戶和密碼參數中。租戶和帳戶名稱應為{“租戶”：“<TENANT>”，“account_name”：“ACCOUNT_NAME”}的額外字段。參數：`azure_data_lake_conn_id(str)` - 對 Azure Data Lake 連接的引用。 ```py check_for_file（FILE_PATH） ``` 檢查 Azure Data Lake 上是否存在文件。參數：`file_path(str)` - 文件的路徑和名稱。返回值：如果文件存在則為 True，否則為 False。：rtype 布爾 ```py download_file（local_path，remote_path，nthreads = 64，overwrite = True，buffersize = 4194304，blocksize = 4194304） ``` 從 Azure Blob 存儲下載文件。參數： * `local_path(str)` - 本地路徑。如果下載單個文件，將寫入此特定文件，除非它是現有目錄，在這種情況下，將在其中創建文件。如果下載多個文件，這是要寫入的根目錄。將根據需要創建目錄。 * `remote_path(str)` - 用于查找遠程文件的遠程路徑/ globstring。不支持使用`**的`遞歸 glob 模式。 * `nthreads(int)` - 要使用的線程數。如果為 None，則使用核心數。 * `overwrite(bool)` - 是否強制覆蓋現有文件/目錄。如果 False 和遠程路徑是目錄，則無論是否覆蓋任何文件都將退出。如果為 True，則實際僅覆蓋匹配的文件名。 * `buffersize(int)` - int [2 ** 22]內部緩沖區的字節數。此塊不能大于塊，并且不能小于塊。 * `blocksize(int)` - int [2 ** 22]塊的字節數。在每個塊中，我們為每個 API 調用編寫一個較小的塊。這個塊不能大于塊。 ```py get_conn（） ``` 返回 AzureDLFileSystem 對象。 ```py upload_file（local_path，remote_path，nthreads = 64，overwrite = True，buffersize = 4194304，blocksize = 4194304） ``` 將文件上載到 Azure Data Lake。參數： * `local_path(str)` - 本地路徑。可以是單個文件，目錄（在這種情況下，遞歸上傳）或 glob 模式。不支持使用`**的`遞歸 glob 模式。 * `remote_path(str)` - 要上傳的遠程路徑; 如果有多個文件，這就是要寫入的 dircetory 根目錄。 * `nthreads(int)` - 要使用的線程數。如果為 None，則使用核心數。 * `overwrite(bool)` - 是否強制覆蓋現有文件/目錄。如果 False 和遠程路徑是目錄，則無論是否覆蓋任何文件都將退出。如果為 True，則實際僅覆蓋匹配的文件名。 * `buffersize(int)` - int [2 ** 22]內部緩沖區的字節數。此塊不能大于塊，并且不能小于塊。 * `blocksize(int)` - int [2 ** 22]塊的字節數。在每個塊中，我們為每個 API 調用編寫一個較小的塊。這個塊不能大于塊。 ```py class airflow.contrib.hooks.azure_fileshare_hook.AzureFileShareHook（wasb_conn_id ='wasb_default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` 與 Azure FileShare 存儲交互。在連接的“額外”字段中傳遞的其他選項將傳遞給`FileService（）`構造函數。參數：`wasb_conn_id(str)` - 對 wasb 連接的引用。 ```py check_for_directory（share_name，directory_name，** kwargs） ``` 檢查 Azure 文件共享上是否存在目錄。參數： * `share_name(str)` - 共享的名稱。 * `directory_name(str)` - 目錄的名稱。 * `kwargs(object)` - `FileService.exists（）`采用的可選關鍵字參數。返回值：如果文件存在則為 True，否則為 False。：rtype 布爾 ```py check_for_file（share_name，directory_name，file_name，** kwargs） ``` 檢查 Azure 文件共享上是否存在文件。參數： * `share_name(str)` - 共享的名稱。 * `directory_name(str)` - 目錄的名稱。 * `file_name(str)` - 文件名。 * `kwargs(object)` - `FileService.exists（）`采用的可選關鍵字參數。返回值：如果文件存在則為 True，否則為 False。：rtype 布爾 ```py create_directory（share_name，directory_name，** kwargs） ``` 在 Azure 文件共享上創建新的目標。參數： * `share_name(str)` - 共享的名稱。 * `directory_name(str)` - 目錄的名稱。 * `kwargs(object)` - `FileService.create_directory（）`采用的可選關鍵字參數。返回值：文件和目錄列表：rtype 列表 ```py get_conn（） ``` 返回 FileService 對象。 ```py get_file（file_path，share_name，directory_name，file_name，** kwargs） ``` 從 Azure 文件共享下載文件。參數： * `file_path(str)` - 存儲文件的位置。 * `share_name(str)` - 共享的名稱。 * `directory_name(str)` - 目錄的名稱。 * `file_name(str)` - 文件名。 * `kwargs(object)` - `FileService.get_file_to_path（）`采用的可選關鍵字參數。 ```py get_file_to_stream（stream，share_name，directory_name，file_name，** kwargs） ``` 從 Azure 文件共享下載文件。參數： * `stream(類 _ 文件對象 _)` - 用于存儲文件的文件句柄。 * `share_name(str)` - 共享的名稱。 * `directory_name(str)` - 目錄的名稱。 * `file_name(str)` - 文件名。 * `kwargs(object)` - `FileService.get_file_to_stream（）`采用的可選關鍵字參數。 ```py list_directories_and_files（share_name，directory_name = None，** kwargs） ``` 返回存儲在 Azure 文件共享中的目錄和文件列表。參數： * `share_name(str)` - 共享的名稱。 * `directory_name(str)` - 目錄的名稱。 * `kwargs(object)` - `FileService.list_directories_and_files（）`采用的可選關鍵字參數。返回值：文件和目錄列表：rtype 列表 ```py load_file（file_path，share_name，directory_name，file_name，** kwargs） ``` 將文件上載到 Azure 文件共享。參數： * `file_path(str)` - 要加載的文件的路徑。 * `share_name(str)` - 共享的名稱。 * `directory_name(str)` - 目錄的名稱。 * `file_name(str)` - 文件名。 * `kwargs(object)` - `FileService.create_file_from_path（）`采用的可選關鍵字參數。 ```py load_stream（stream，share_name，directory_name，file_name，count，** kwargs） ``` 將流上載到 Azure 文件共享。參數： * `stream(類 _ 文件 _)` - 打開的文件/流作為文件內容上傳。 * `share_name(str)` - 共享的名稱。 * `directory_name(str)` - 目錄的名稱。 * `file_name(str)` - 文件名。 * `count(int)` - 流的大小（以字節為單位） * `kwargs(object)` - `FileService.create_file_from_stream（）`采用的可選關鍵字參數。 ```py load_string（string_data，share_name，directory_name，file_name，** kwargs） ``` 將字符串上載到 Azure 文件共享。參數： * `string_data(str)` - 要加載的字符串。 * `share_name(str)` - 共享的名稱。 * `directory_name(str)` - 目錄的名稱。 * `file_name(str)` - 文件名。 * `kwargs(object)` - `FileService.create_file_from_text（）`采用的可選關鍵字參數。 ```py class airflow.contrib.hooks.bigquery_hook.BigQueryHook（bigquery_conn_id ='bigquery_default'，delegate_to = None，use_legacy_sql = True） ``` 基類：[`airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook`](31 "airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook")，[`airflow.hooks.dbapi_hook.DbApiHook`](31 "airflow.hooks.dbapi_hook.DbApiHook")，`airflow.utils.log.logging_mixin.LoggingMixin` 與 BigQuery 交互。此掛鉤使用 Google Cloud Platform 連接。 ```py get_conn（） ``` 返回 BigQuery PEP 249 連接對象。 ```py get_pandas_df（sql，parameters = None，dialect = None） ``` 返回 BigQuery 查詢生成的結果的 Pandas DataFrame。必須重寫 DbApiHook 方法，因為 Pandas 不支持 PEP 249 連接，但 SQLite 除外。看到： [https://github.com/pydata/pandas/blob/master/pandas/io/sql.py#L447 ](https://github.com/pydata/pandas/blob/master/pandas/io/sql.py)[https://github.com/pydata/pandas/issues/6900](https://github.com/pydata/pandas/issues/6900) 參數： * `sql(string)` - 要執行的 BigQuery SQL。 * `參數(_ 映射 _ 或 _ 可迭代 _)` - 用于呈現 SQL 查詢的參數（未使用，請保留覆蓋超類方法） * `dialect(_{'legacy' __，_ _'standard'}中的 _string)` - BigQuery SQL 的方言 - 遺留 SQL 或標準 SQL 默認使用`self.use_legacy_sql（`如果未指定） ```py get_service（） ``` 返回一個 BigQuery 服務對象。 ```py insert_rows（table，rows，target_fields = None，commit_every = 1000） ``` 目前不支持插入。從理論上講，您可以使用 BigQuery 的流 API 將行插入表中，但這尚未實現。 ```py table_exists（project_id，dataset_id，table_id） ``` 檢查 Google BigQuery 中是否存在表格。參數： * `project_id(string)` - 要在其中查找表的 Google 云項目。提供給鉤子的連接必須提供對指定項目的訪問。 * `dataset_id(string)` - 要在其中查找表的數據集的名稱。 * `table_id(string)` - 要檢查的表的名稱。 ```py class airflow.contrib.hooks.cassandra_hook.CassandraHook（cassandra_conn_id ='cassandra_default'） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` 胡克曾經與卡桑德拉互動可以在連接的“hosts”字段中將聯系點指定為逗號分隔的字符串。可以在連接的端口字段中指定端口。如果在 Cassandra 中啟用了 SSL，則將額外字段中的 dict 作為 kwargs 傳入`ssl.wrap_socket()`。例如： > ```py > { > ``` > > ```py > 'ssl_options'：{ > ``` > > 'ca_certs'：PATH_TO_CA_CERTS > > } > > } ```py 默認負載平衡策略是 RoundRobinPolicy。要指定不同的 LB 策略： ``` * ```py DCAwareRoundRobinPolicy ``` ```py { ``` > 'load_balancing_policy'：'DCAwareRoundRobinPolicy'，'load_balancing_policy_args'：{ > > > 'local_dc'：LOCAL_DC_NAME，//可選'used_hosts_per_remote_dc'：SOMEintVALUE，//可選 > > } } * ```py WhiteListRoundRobinPolicy ``` ```py { ``` 'load_balancing_policy'：'WhiteListRoundRobinPolicy'，'load_balancing_policy_args'：{ > '主持人'：['HOST1'，'HOST2'，'HOST3'] } } * ```py TokenAwarePolicy ``` ```py { ``` 'load_balancing_policy'：'TokenAwarePolicy'，'load_balancing_policy_args'：{ > 'child_load_balancing_policy'：CHILD_POLICY_NAME，//可選'child_load_balancing_policy_args'：{...} //可選 } } 有關群集配置的詳細信息，請參閱 cassandra.cluster。 ```py get_conn（） ``` 返回一個 cassandra Session 對象 ```py record_exists（表，鍵） ``` 檢查 Cassandra 中是否存在記錄參數： * `table(string)` - 目標 Cassandra 表。使用點表示法來定位特定鍵空間。 * `keys(dict)` - 用于檢查存在的鍵及其值。 ```py shutdown_cluster（） ``` 關閉與此群集關聯的所有會話和連接。 ```py class airflow.contrib.hooks.cloudant_hook.CloudantHook（cloudant_conn_id ='cloudant_default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` 與 Cloudant 互動。這個類是 cloudant python 庫的一個薄包裝器。請參閱[此處](https://github.com/cloudant-labs/cloudant-python)的文檔。 ```py D b（） ``` 返回此掛接的 Database 對象。請參閱 cloudant-python 的文檔[https://github.com/cloudant-labs/cloudant-python](https://github.com/cloudant-labs/cloudant-python)。 ```py class airflow.contrib.hooks.databricks_hook.DatabricksHook（databricks_conn_id ='databricks_default'，timeout_seconds = 180，retry_limit = 3） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` 與 Databricks 互動。 ```py submit_run（JSON） ``` 用于調用`api/2.0/jobs/runs/submit`端點的實用程序功能。參數：`json(dict)` - 在`submit`端點請求體中使用的數據。返回值： run_id 為字符串| 返回類型： | 串 ```py class airflow.contrib.hooks.datadog_hook.DatadogHook（datadog_conn_id ='datadog_default'） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` 使用 datadog API 發送幾乎任何可測量的度量標準，因此可以跟蹤插入/刪除的 db 記錄數，從文件讀取的記錄以及許多其他有用的度量標準。取決于 datadog API，該 API 必須部署在 Airflow 運行的同一服務器上。參數： * `datadog_conn_id` - 與 datadog 的連接，包含 api 密鑰的元數據。 * `datadog_conn_id` - 字符串 ```py post_event（title，text，tags = None，alert_type = None，aggregation_key = None） ``` 將事件發布到 datadog（處理完成，潛在警報，其他問題）將此視為維持警報持久性的一種方法，而不是提醒自己。參數： * `title(string)` - 事件的標題 * `text(string)` - 事件正文（更多信息） * `tags(list)` - 要應用于事件的字符串標記列表 * `alert_type(string)` - 事件的警報類型，[“錯誤”，“警告”，“信息”，“成功”之一] * `aggregation_key(string)` - 可用于在流中聚合此事件的鍵 ```py query_metric（query，from_seconds_ago，to_seconds_ago） ``` 查詢特定度量標準的數據路徑，可能會應用某些功能并返回結果。參數： * `query(string)` - 要執行的 datadog 查詢（請參閱 datadog docs） * `from_seconds_ago(int)` - 開始查詢的秒數。 * `to_seconds_ago(int)` - 最多查詢前幾秒。 ```py send_metric（metric_name，datapoint，tags = None） ``` 將單個數據點度量標準發送到 DataDog 參數： * `metric_name(string)` - 度量標準的名稱 * `datapoint(_ 整數 _ 或 _ 浮點數 _)` - 與度量標準相關的單個整數或浮點數 * `tags(list)` - 與度量標準關聯的標記列表 ```py class airflow.contrib.hooks.datastore_hook.DatastoreHook（datastore_conn_id ='google_cloud_datastore_default'，delegate_to = None） ``` 基類： [`airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook`](31 "airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook") 與 Google Cloud Datastore 互動。此掛鉤使用 Google Cloud Platform 連接。此對象不是線程安全的。如果要同時發出多個請求，則需要為每個線程創建一個鉤子。 ```py allocate_ids（partialKeys） ``` 為不完整的密鑰分配 ID。請參閱[https://cloud.google.com/datastore/docs/reference/rest/v1/projects/allocateIds](https://cloud.google.com/datastore/docs/reference/rest/v1/projects/allocateIds) 參數：`partialKeys` - 部分鍵列表返回值：完整密鑰列表。 ```py begin_transaction（） ``` 獲取新的事務處理 > 也可以看看 > > [https://cloud.google.com/datastore/docs/reference/rest/v1/projects/beginTransaction](https://cloud.google.com/datastore/docs/reference/rest/v1/projects/beginTransaction) 返回值：交易句柄 ```py 提交（體） ``` 提交事務，可選地創建，刪除或修改某些實體。也可以看看 [https://cloud.google.com/datastore/docs/reference/rest/v1/projects/commit](https://cloud.google.com/datastore/docs/reference/rest/v1/projects/commit) 參數：`body` - 提交請求的主體返回值：提交請求的響應主體 ```py delete_operation（名稱） ``` 刪除長時間運行的操作參數：`name` - 操作資源的名稱 ```py export_to_storage_bucket（bucket，namespace = None，entity_filter = None，labels = None） ``` 將實體從 Cloud Datastore 導出到 Cloud Storage 進行備份 ```py get_conn（版本= 'V1'） ``` 返回 Google 云端存儲服務對象。 ```py GET_OPERATION（名稱） ``` 獲取長時間運行的最新狀態參數：`name` - 操作資源的名稱 ```py import_from_storage_bucket（bucket，file，namespace = None，entity_filter = None，labels = None） ``` 將備份從云存儲導入云數據存儲 ```py lookup（keys，read_consistency = None，transaction = None） ``` 按鍵查找一些實體也可以看看 [https://cloud.google.com/datastore/docs/reference/rest/v1/projects/lookup](https://cloud.google.com/datastore/docs/reference/rest/v1/projects/lookup) 參數： * `keys` - 要查找的鍵 * `read_consistency` - 要使用的讀取一致性。默認，強或最終。不能與事務一起使用。 * `transaction` - 要使用的事務，如果有的話。返回值：查找請求的響應主體。 ```py poll_operation_until_done（name，polling_interval_in_seconds） ``` 輪詢備份操作狀態直到完成 ```py 回滾（事務） ``` 回滾交易也可以看看 [https://cloud.google.com/datastore/docs/reference/rest/v1/projects/rollback](https://cloud.google.com/datastore/docs/reference/rest/v1/projects/rollback) 參數：`transaction` - 要回滾的事務 ```py run_query（體） ``` 運行實體查詢。也可以看看 [https://cloud.google.com/datastore/docs/reference/rest/v1/projects/runQuery](https://cloud.google.com/datastore/docs/reference/rest/v1/projects/runQuery) 參數：`body` - 查詢請求的主體返回值：批量查詢結果。 ```py class airflow.contrib.hooks.discord_webhook_hook.DiscordWebhookHook（http_conn_id = None，webhook_endpoint = None，message =''，username = None，avatar_url = None，tts = False，proxy = None，* args，** kwargs） ``` 基類： [`airflow.hooks.http_hook.HttpHook`](31 "airflow.hooks.http_hook.HttpHook") 此掛鉤允許您使用傳入的 webhooks 將消息發布到 Discord。使用默認相對 webhook 端點獲取 Discord 連接 ID。可以使用 webhook_endpoint 參數（[https://discordapp.com/developers/docs/resources/webhook](https://discordapp.com/developers/docs/resources/webhook)）覆蓋默認端點。每個 Discord webhook 都可以預先配置為使用特定的用戶名和 avatar_url。您可以在此掛鉤中覆蓋這些默認值。參數： * `http_conn_id(str)` - Http 連接 ID，主機為“ [https://discord.com/api/](https://discord.com/api/) ”，默認 webhook 端點在額外字段中，格式為{“webhook_endpoint”：“webhooks / {webhook.id} / { webhook.token}” * `webhook_endpoint(str)` - 以“webhooks / {webhook.id} / {webhook.token}”的形式 Discord webhook 端點 * `message(str)` - 要發送到 Discord 頻道的消息（最多 2000 個字符） * `username(str)` - 覆蓋 webhook 的默認用戶名 * `avatar_url(str)` - 覆蓋 webhook 的默認頭像 * `tts(bool)` - 是一個文本到語音的消息 * `proxy(str)` - 用于進行 Discord webhook 調用的代理 ```py 執行（） ``` 執行 Discord webhook 調用 ```py class airflow.contrib.hooks.emr_hook.EmrHook（emr_conn_id = None，* args，** kwargs） ``` 基類： [`airflow.contrib.hooks.aws_hook.AwsHook`](31 "airflow.contrib.hooks.aws_hook.AwsHook") 與 AWS EMR 交互。emr_conn_id 只是使用 create_job_flow 方法所必需的。 ```py create_job_flow（job_flow_overrides） ``` 使用 EMR 連接中的配置創建作業流。json 額外哈希的鍵可以具有 boto3 run_job_flow 方法的參數。此配置的覆蓋可以作為 job_flow_overrides 傳遞。 ```py class airflow.contrib.hooks.fs_hook.FSHook（conn_id ='fs_default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` 允許與文件服務器交互。連接應具有名稱和額外指定的路徑：示例：Conn Id：fs_test Conn 類型：文件（路徑）主機，Shchema，登錄，密碼，端口：空額外：{“path”：“/ tmp”} ```py class airflow.contrib.hooks.ftp_hook.FTPHook（ftp_conn_id ='ftp_default'） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` 與 FTP 交互。可能在整個過程中發生的錯誤應該在下游處理。 ```py close_conn（） ``` 關閉連接。如果未打開連接，則會發生錯誤。 ```py create_directory（路徑） ``` 在遠程系統上創建目錄。參數：`path(str)` - 要創建的遠程目錄的完整路徑 ```py delete_directory（路徑） ``` 刪除遠程系統上的目錄。參數：`path(str)` - 要刪除的遠程目錄的完整路徑 ```py DELETE_FILE（路徑） ``` 刪除 FTP 服務器上的文件。參數：`path(str)` - 遠程文件的完整路徑 ```py describe_directory（路徑） ``` 返回遠程系統上所有文件的{filename：{attributes}}字典（支持 MLSD 命令）。參數：`path(str)` - 遠程目錄的完整路徑 ```py get_conn（） ``` 返回 FTP 連接對象 ```py list_directory（path，nlst = False） ``` 返回遠程系統上的文件列表。參數：`path(str)` - 要列出的遠程目錄的完整路徑 ```py 重命名（from_name，to_name） ``` 重命名文件。參數： * `from_name` - 從名稱重命名文件 * `to_name` - 將文件重命名為 name ```py retrieve_file（remote_full_path，local_full_path_or_buffer） ``` 將遠程文件傳輸到本地位置。如果 local_full_path_or_buffer 是字符串路徑，則該文件將放在該位置; 如果它是類似文件的緩沖區，則該文件將被寫入緩沖區但不會被關閉。參數： * `remote_full_path(str)` - 遠程文件的完整路徑 * `local_full_path_or_buffer(_str __ 或類 _ _ 文件緩沖區 _)` - 本地文件的完整路徑或類文件緩沖區 ```py store_file（remote_full_path，local_full_path_or_buffer） ``` 將本地文件傳輸到遠程位置。如果 local_full_path_or_buffer 是字符串路徑，則將從該位置讀取該文件; 如果它是類似文件的緩沖區，則從緩沖區讀取文件但不關閉。參數： * `remote_full_path(str)` - 遠程文件的完整路徑 * `local_full_path_or_buffer(_str __ 或類 _ _ 文件緩沖區 _)` - 本地文件的完整路徑或類文件緩沖區 ```py class airflow.contrib.hooks.ftp_hook.FTPSHook（ftp_conn_id ='ftp_default'） ``` 基類： [`airflow.contrib.hooks.ftp_hook.FTPHook`](31 "airflow.contrib.hooks.ftp_hook.FTPHook") ```py get_conn（） ``` 返回 FTPS 連接對象。 ```py class airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook（gcp_conn_id ='google_cloud_default'，delegate_to = None） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` 谷歌云相關鉤子的基礎鉤子。Google 云有一個共享的 REST API 客戶端，無論您使用哪種服務，都以相同的方式構建。此類有助于構建和授權所需的憑據，然后調用 apiclient.discovery.build（）來實際發現和構建 Google 云服務的客戶端。該類還包含一些其他輔助函數。從此基本掛鉤派生的所有掛鉤都使用“Google Cloud Platform”連接類型。支持兩種身份驗證方式：默認憑據：只需要“項目 ID”。您需要設置默認憑據，例如`GOOGLE_APPLICATION_DEFAULT`環境變量或 Google Compute Engine 上的元數據服務器。 JSON 密鑰文件：指定“項目 ID”，“密鑰路徑”和“范圍”。不支持舊版 P12 密鑰文件。 ```py class airflow.contrib.hooks.gcp_container_hook.GKEClusterHook（project_id，location） ``` 基類： `airflow.hooks.base_hook.BaseHook` ```py create_cluster（cluster，retry = <object object>，timeout = <object object>） ``` 創建一個群集，由指定數量和類型的 Google Compute Engine 實例組成。參數： * `cluster(_dict _ 或 _google.cloud.container_v1.types.Cluster_)` - 群集 protobuf 或 dict。如果提供了 dict，它必須與 protobuf 消息的格式相同 google.cloud.container_v1.types.Cluster * `重試(_google.api_core.retry.Retry_)` - 用于重試請求的重試對象（google.api_core.retry.Retry）。如果指定 None，則不會重試請求。 * `timeout(float)` - 等待請求完成的時間（以秒為單位）。請注意，如果指定了重試，則超時適用于每次單獨嘗試。返回值：新集群或現有集群的完整 URL ```py ：加薪 ``` ParseError：在嘗試轉換 dict 時出現 JSON 解析問題 AirflowException：cluster 不是 dict 類型也不是 Cluster proto 類型 ```py delete_cluster（name，retry = <object object>，timeout = <object object>） ``` 刪除集群，包括 Kubernetes 端點和所有工作節點。在群集創建期間配置的防火墻和路由也將被刪除。群集可能正在使用的其他 Google Compute Engine 資源（例如，負載均衡器資源）如果在初始創建時不存在，則不會被刪除。參數： * `name(str)` - 要刪除的集群的名稱 * `重試(_google.api_core.retry.Retry_)` - 重 _ 試用 _ 于確定何時/是否重試請求的對象。如果指定 None，則不會重試請求。 * `timeout(float)` - 等待請求完成的時間（以秒為單位）。請注意，如果指定了重試，則超時適用于每次單獨嘗試。返回值：如果成功則刪除操作的完整 URL，否則為 None ```py get_cluster（name，retry = <object object>，timeout = <object object>） ``` 獲取指定集群的詳細信息：param name：要檢索的集群的名稱：type name：str：param retry：用于重試請求的重試對象。如果指定了 None， > 請求不會被重試。參數：`timeout(float)` - 等待請求完成的時間（以秒為單位）。請注意，如果指定了重試，則超時適用于每次單獨嘗試。返回值：一個 google.cloud.container_v1.types.Cluster 實例 ```py GET_OPERATION（OPERATION_NAME） ``` 從 Google Cloud 獲取操作：param operation_name：要獲取的操作的名稱：type operation_name：str：return：來自 Google Cloud 的新的更新操作 ```py wait_for_operation（操作） ``` 給定操作，持續從 Google Cloud 獲取狀態，直到完成或發生錯誤：param 操作：等待的操作：鍵入操作：google.cloud.container_V1.gapic.enums.Operator：return：a new，updated 從 Google Cloud 獲取的操作 ```py class airflow.contrib.hooks.gcp_dataflow_hook.DataFlowHook（gcp_conn_id ='google_cloud_default'，delegate_to = None，poll_sleep = 10） ``` 基類： [`airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook`](31 "airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook") ```py get_conn（） ``` 返回 Google 云端存儲服務對象。 ```py class airflow.contrib.hooks.gcp_dataproc_hook.DataProcHook（gcp_conn_id ='google_cloud_default'，delegate_to = None，api_version ='v1beta2'） ``` 基類： [`airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook`](31 "airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook") Hook for Google Cloud Dataproc API。 ```py 等待（操作） ``` 等待 Google Cloud Dataproc Operation 完成。 ```py get_conn（） ``` 返回 Google Cloud Dataproc 服務對象。 ```py 等待（操作） ``` 等待 Google Cloud Dataproc Operation 完成。 ```py class airflow.contrib.hooks.gcp_mlengine_hook.MLEngineHook（gcp_conn_id ='google_cloud_default'，delegate_to = None） ``` 基類： [`airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook`](31 "airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook") ```py create_job（project_id，job，use_existing_job_fn = None） ``` 啟動 MLEngine 作業并等待它達到終端狀態。參數： * `project_id(string)` - 將在其中啟動 MLEngine 作業的 Google Cloud 項目 ID。 * `工作(_ 字典 _)` - 應該提供給 MLEngine API 的 MLEngine Job 對象，例如： ```py { 'jobId' : 'my_job_id' , 'trainingInput' : { 'scaleTier' : 'STANDARD_1' , ... } } ``` * `use_existing_job_fn(function)` - 如果已存在具有相同 job_id 的 MLEngine 作業，則此方法（如果提供）將決定是否應使用此現有作業，繼續等待它完成并返回作業對象。它應該接受 MLEngine 作業對象，并返回一個布爾值，指示是否可以重用現有作業。如果未提供“use_existing_job_fn”，我們默認重用現有的 MLEngine 作業。返回值：如果作業成功到達終端狀態（可能是 FAILED 或 CANCELED 狀態），則為 MLEngine 作業對象。| 返回類型： | 字典 ```py create_model（project_id，model） ``` 創建一個模型。阻止直到完成。 ```py create_version（project_id，model_name，version_spec） ``` 在 Google Cloud ML Engine 上創建版本。如果版本創建成功則返回操作，否則引發錯誤。 ```py delete_version（project_id，model_name，version_name） ``` 刪除給定版本的模型。阻止直到完成。 ```py get_conn（） ``` 返回 Google MLEngine 服務對象。 ```py get_model（project_id，model_name） ``` 獲取一個模型。阻止直到完成。 ```py list_versions（project_id，model_name） ``` 列出模型的所有可用版本。阻止直到完成。 ```py set_default_version（project_id，model_name，version_name） ``` 將版本設置為默認值。阻止直到完成。 ```py class airflow.contrib.hooks.gcp_pubsub_hook.PubSubHook（gcp_conn_id ='google_cloud_default'，delegate_to = None） ``` 基類： [`airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook`](31 "airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook") 用于訪問 Google Pub / Sub 的 Hook。應用操作的 GCP 項目由嵌入在 gcp_conn_id 引用的 Connection 中的項目確定。 ```py 確認（項目，訂閱，ack_ids） ``` `max_messages`從 Pub / Sub 訂閱中提取消息。參數： * `project(string)` - 用于創建主題的 GCP 項目名稱或 ID * `subscription(string)` - 要刪除的 Pub / Sub 訂閱名稱; 不包括'projects / {project} / topics /'前綴。 * `ack_ids(list)` - 來自先前拉取響應的 ReceivedMessage 確認列表 ```py create_subscription（topic_project，topic，subscription = None，subscription_project = None，ack_deadline_secs = 10，fail_if_exists = False） ``` 如果 Pub / Sub 訂閱尚不存在，則創建它。參數： * `topic_project(string)` - 訂閱將綁定到的主題的 GCP 項目 ID。 * `topic(string)` - 訂閱將綁定創建的發布/訂閱主題名稱; 不包括`projects/{project}/subscriptions/`前綴。 * `subscription(string)` - 發布/訂閱訂閱名稱。如果為空，將使用 uuid 模塊生成隨機名稱 * `subscription_project(string)` - 將在其中創建訂閱的 GCP 項目 ID。如果未指定，`topic_project`將使用。 * `ack_deadline_secs(int)` - 訂戶必須確認從訂閱中提取的每條消息的秒數 * `fail_if_exists(bool)` - 如果設置，則在主題已存在時引發異常返回值：訂閱名稱，如果`subscription`未提供參數，它將是系統生成的值| 返回類型： | 串 ```py create_topic（project，topic，fail_if_exists = False） ``` 如果 Pub / Sub 主題尚不存在，則創建它。參數： * `project(string)` - 用于創建主題的 GCP 項目 ID * `topic(string)` - 要創建的發布/訂閱主題名稱; 不包括`projects/{project}/topics/`前綴。 * `fail_if_exists(bool)` - 如果設置，則在主題已存在時引發異常 ```py delete_subscription（project，subscription，fail_if_not_exists = False） ``` 刪除發布/訂閱訂閱（如果存在）。參數： * `project(string)` - 訂閱所在的 GCP 項目 ID * `subscription(string)` - 要刪除的 Pub / Sub 訂閱名稱; 不包括`projects/{project}/subscriptions/`前綴。 * `fail_if_not_exists(bool)` - 如果設置，則在主題不存在時引發異常 ```py delete_topic（項目，主題，fail_if_not_exists = False） ``` 刪除 Pub / Sub 主題（如果存在）。參數： * `project(string)` - 要刪除主題的 GCP 項目 ID * `topic(string)` - 要刪除的發布/訂閱主題名稱; 不包括`projects/{project}/topics/`前綴。 * `fail_if_not_exists(bool)` - 如果設置，則在主題不存在時引發異常 ```py get_conn（） ``` 返回 Pub / Sub 服務對象。 | 返回類型： | apiclient.discovery.Resource ```py 發布（項目，主題，消息） ``` 將消息發布到 Pub / Sub 主題。參數： * `project(string)` - 要發布的 GCP 項目 ID * `topic(string)` - 要發布的發布/訂閱主題; 不包括`projects/{project}/topics/`前綴。 * `消息(PubSub 消息列表;請參閱[http://cloud.google.com/pubsub/docs/reference/rest/v1/PubsubMessage](http://cloud.google.com/pubsub/docs/reference/rest/v1/PubsubMessage))` - 要發布的消息; 如果設置了消息中的數據字段，則它應該已經是 base64 編碼的。 ```py pull（項目，訂閱，max_messages，return_immediately = False） ``` `max_messages`從 Pub / Sub 訂閱中提取消息。參數： * `project(string)` - 訂閱所在的 GCP 項目 ID * `subscription(string)` - 要從中提取的 Pub / Sub 訂閱名稱; 不包括'projects / {project} / topics /'前綴。 * `max_messages(int)` - 從 Pub / Sub API 返回的最大消息數。 * `return_immediately(bool)` - 如果設置，如果沒有可用的消息，Pub / Sub API 將立即返回。否則，請求將阻止未公開但有限的時間段 ```py ：return 每個包含的 Pub / Sub ReceivedMessage 對象列表 ``` 的`ackId`屬性和`message`屬性，其中包括 base64 編碼消息內容。請參閱[https://cloud.google.com/pubsub/docs/reference/rest/v1/](https://cloud.google.com/pubsub/docs/reference/rest/v1/) projects.subscriptions / pull＃ReceivedMessage ```py class airflow.contrib.hooks.gcs_hook.GoogleCloudStorageHook（google_cloud_storage_conn_id ='google_cloud_default'，delegate_to = None） ``` 基類： [`airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook`](31 "airflow.contrib.hooks.gcp_api_base_hook.GoogleCloudBaseHook") 與 Google 云端存儲互動。此掛鉤使用 Google Cloud Platform 連接。 ```py copy（source_bucket，source_object，destination_bucket = None，destination_object = None） ``` 將對象從存儲桶復制到另一個存儲桶，并在需要時重命名。 destination_bucket 或 destination_object 可以省略，在這種情況下使用源桶/對象，但不能同時使用兩者。參數： * `source_bucket(string)` - 要從中復制的對象的存儲桶。 * `source_object(string)` - 要復制的對象。 * `destination_bucket(string)` - 要復制到的對象的目標。可以省略; 然后使用相同的桶。 * `destination_object` - 給定對象的（重命名）路徑。可以省略; 然后使用相同的名稱。 ```py create_bucket（bucket_name，storage_class ='MULTI_REGIONAL'，location ='US'，project_id = None，labels = None） ``` 創建一個新存儲桶。Google 云端存儲使用平面命名空間，因此您無法創建名稱已在使用中的存儲桶。也可以看看有關詳細信息，請參閱存儲桶命名指南：[https](https://cloud.google.com/storage/docs/bucketnaming.html)：[//cloud.google.com/storage/docs/bucketnaming.html#requirements](https://cloud.google.com/storage/docs/bucketnaming.html) 參數： * `bucket_name(string)` - 存儲桶的名稱。 * `storage_class(string)` - 這定義了存儲桶中對象的存儲方式，并確定了 SLA 和存儲成本。價值包括 * `MULTI_REGIONAL` * `REGIONAL` * `STANDARD` * `NEARLINE` * `COLDLINE` 。如果在創建存儲桶時未指定此值，則默認為 STANDARD。 * `位置(string)` - 水桶的位置。存儲桶中對象的對象數據駐留在此區域內的物理存儲中。默認為美國。也可以看看 [https://developers.google.com/storage/docs/bucket-locations](https://developers.google.com/storage/docs/bucket-locations) * `project_id(string)` - GCP 項目的 ID。 * `labels(dict)` - 用戶提供的鍵/值對標簽。返回值：如果成功，則返回`id`桶的內容。 ```py 刪除（桶，對象，生成=無） ``` 如果未對存儲桶啟用版本控制，或者使用了生成參數，則刪除對象。參數： * `bucket(string)` - 對象所在的存儲桶的名稱 * `object(string)` - 要刪除的對象的名稱 * `generation(string)` - 如果存在，則永久刪除該代的對象返回值：如果成功則為真 ```py 下載（bucket，object，filename = None） ``` 從 Google 云端存儲中獲取文件。參數： * `bucket(string)` - 要獲取的存儲桶。 * `object(string)` - 要獲取的對象。 * `filename(string)` - 如果設置，則應寫入文件的本地文件路徑。 ```py 存在（桶，對象） ``` 檢查 Google 云端存儲中是否存在文件。參數： * `bucket(string)` - 對象所在的 Google 云存儲桶。 * `object(string)` - 要在 Google 云存儲分區中檢查的對象的名稱。 ```py get_conn（） ``` 返回 Google 云端存儲服務對象。 ```py get_crc32c（bucket，object） ``` 獲取 Google Cloud Storage 中對象的 CRC32c 校驗和。參數： * `bucket(string)` - 對象所在的 Google 云存儲桶。 * `object(string)` - 要在 Google 云存儲分區中檢查的對象的名稱。 ```py get_md5hash（bucket，object） ``` 獲取 Google 云端存儲中對象的 MD5 哈希值。參數： * `bucket(string)` - 對象所在的 Google 云存儲桶。 * `object(string)` - 要在 Google 云存儲分區中檢查的對象的名稱。 ```py get_size（bucket，object） ``` 獲取 Google 云端存儲中文件的大小。參數： * `bucket(string)` - 對象所在的 Google 云存儲桶。 * `object(string)` - 要在 Google 云存儲分區中檢查的對象的名稱。 ```py is_updated_after（bucket，object，ts） ``` 檢查 Google Cloud Storage 中是否更新了對象。參數： * `bucket(string)` - 對象所在的 Google 云存儲桶。 * `object(string)` - 要在 Google 云存儲分區中檢查的對象的名稱。 * `ts(datetime)` - 要檢查的時間戳。 ```py list（bucket，versions = None，maxResults = None，prefix = None，delimiter = None） ``` 使用名稱中的給定字符串前綴列出存儲桶中的所有對象參數： * `bucket(string)` - 存儲桶名稱 * `versions(_boolean_)` - 如果為 true，則列出對象的所有版本 * `maxResults(_ 整數 _)` - 在單個響應頁面中返回的最大項目數 * `prefix(string)` - 前綴字符串，用于過濾名稱以此前綴開頭的對象 * `delimiter(string)` - 根據分隔符過濾對象（例如'.csv'）返回值：與過濾條件匹配的對象名稱流 ```py 重寫（source_bucket，source_object，destination_bucket，destination_object = None） ``` 具有與復制相同的功能，除了可以處理超過 5 TB 的文件，以及在位置和/或存儲類之間復制時。 destination_object 可以省略，在這種情況下使用 source_object。參數： * `source_bucket(string)` - 要從中復制的對象的存儲桶。 * `source_object(string)` - 要復制的對象。 * `destination_bucket(string)` - 要復制到的對象的目標。 * `destination_object` - 給定對象的（重命名）路徑。可以省略; 然后使用相同的名稱。 ```py upload（bucket，object，filename，mime_type ='application / octet-stream'） ``` 將本地文件上傳到 Google 云端存儲。參數： * `bucket(string)` - 要上傳的存儲桶。 * `object(string)` - 上載本地文件時要設置的對象名稱。 * `filename(string)` - 要上載的文件的本地文件路徑。 * `mime_type(string)` - 上載文件時要設置的 MIME 類型。 ```py class airflow.contrib.hooks.jenkins_hook.JenkinsHook（conn_id ='jenkins_default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` 掛鉤管理與 jenkins 服務器的連接 ```py class airflow.contrib.hooks.jira_hook.JiraHook（jira_conn_id ='jira_default'，proxies = None） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` Jira 交互鉤，JIRA Python SDK 的 Wrapper。參數：`jira_conn_id(string)` - 對預定義的 Jira 連接的引用 ```py class airflow.contrib.hooks.mongo_hook.MongoHook（conn_id ='mongo_default'，* args，** kwargs） ``` 基類： `airflow.hooks.base_hook.BaseHook` PyMongo Wrapper 與 Mongo 數據庫進行交互 Mongo 連接文檔[https://docs.mongodb.com/manual/reference/connection-string/index.html](https://docs.mongodb.com/manual/reference/connection-string/index.html)您可以在連接的額外字段中指定連接字符串選項[https：//docs.mongodb .com / manual / reference / connection-string / index.html＃connection-string-options](https://docs.mongodb.com/manual/reference/connection-string/index.html) ex。 > {replicaSet：test，ssl：True，connectTimeoutMS：30000} ```py aggregate（mongo_collection，aggregate_query，mongo_db = None，** kwargs） ``` 運行聚合管道并返回結果[https://api.mongodb.com/python/current/api/pymongo/collection.html#pymongo.collection.Collection.aggregate ](https://api.mongodb.com/python/current/api/pymongo/collection.html)[https://api.mongodb.com/python/current /examples/aggregation.html](https://api.mongodb.com/python/current/examples/aggregation.html) ```py find（mongo_collection，query，find_one = False，mongo_db = None，** kwargs） ``` 運行 mongo 查找查詢并返回結果[https://api.mongodb.com/python/current/api/pymongo/collection.html#pymongo.collection.Collection.find](https://api.mongodb.com/python/current/api/pymongo/collection.html) ```py get_collection（mongo_collection，mongo_db = None） ``` 獲取用于查詢的 mongo 集合對象。除非指定，否則將連接模式用作 DB。 ```py get_conn（） ``` 獲取 PyMongo 客戶端 ```py insert_many（mongo_collection，docs，mongo_db = None，** kwargs） ``` 將許多文檔插入到 mongo 集合中。[https://api.mongodb.com/python/current/api/pymongo/collection.html#pymongo.collection.Collection.insert_many](https://api.mongodb.com/python/current/api/pymongo/collection.html) ```py insert_one（mongo_collection，doc，mongo_db = None，** kwargs） ``` 將單個文檔插入到 mongo 集合中[https://api.mongodb.com/python/current/api/pymongo/collection.html#pymongo.collection.Collection.insert_one](https://api.mongodb.com/python/current/api/pymongo/collection.html) ```py class airflow.contrib.hooks.pinot_hook.PinotDbApiHook（* args，** kwargs） ``` 基類： [`airflow.hooks.dbapi_hook.DbApiHook`](31 "airflow.hooks.dbapi_hook.DbApiHook") 連接到 pinot db（[https://github.com/linkedin/pinot](https://github.com/linkedin/pinot)）以發出 pql ```py get_conn（） ``` 通過 pinot dbqpi 建立與 pinot 代理的連接。 ```py get_first（SQL） ``` 執行 sql 并返回第一個結果行。參數：`sql(_str _ 或 list)` - 要執行的 sql 語句（str）或要執行的 sql 語句列表 ```py get_pandas_df（sql，parameters = None） ``` 執行 sql 并返回一個 pandas 數據幀參數： * `sql(_str _ 或 list)` - 要執行的 sql 語句（str）或要執行的 sql 語句列表 * `參數(_mapping _ 或 _iterable_)` - 用于呈現 SQL 查詢的參數。 ```py get_records（SQL） ``` 執行 sql 并返回一組記錄。參數：`sql(str)` - 要執行的 sql 語句（str）或要執行的 sql 語句列表 ```py get_uri（） ``` 獲取 pinot 經紀人的連接 uri。例如：[http：// localhost：9000 / pql](http://localhost:9000/pql) ```py insert_rows（table，rows，target_fields = None，commit_every = 1000） ``` 將一組元組插入表中的通用方法是，每個 commit_every 行都會創建一個新事務參數： * `table(str)` - 目標表的名稱 * `rows(_ 可迭代的元組 _)` - 要插入表中的行 * `target_fields(_ 可迭代的字符串 _)` - 要填充表的列的名稱 * `commit_every(int)` - 要在一個事務中插入的最大行數。設置為 0 以在一個事務中插入所有行。 * `replace(bool)` - 是否替換而不是插入 ```py set_autocommit（conn，autocommit） ``` 設置連接上的自動提交標志 ```py class airflow.contrib.hooks.qubole_hook.QuboleHook（* args，** kwargs） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` ```py get_jobs_id（TI） ``` 獲取與 Qubole 命令相關的作業：param ti：任務 dag 的實例，用于確定 Quboles 命令 id：return：與命令關聯的作業信息 ```py get_log（TI） ``` 從 Qubole 獲取命令的日志：param ti：dag 的任務實例，用于確定 Quboles 命令 id：return：命令日志作為文本 ```py get_results（ti = None，fp = None，inline = True，delim = None，fetch = True） ``` 從 Qubole 獲取命令的結果（或僅 s3 位置）并保存到文件中：param ti：任務 dag 的實例，用于確定 Quboles 命令 id：param fp：可選文件指針，將創建一個并返回如果 None 傳遞：param inline：True 表示只下載實際結果，False 表示僅獲取 s3 位置：param delim：用給定的 delim 替換 CTL-A 字符，默認為'，'：param fetch：當 inline 為 True 時，直接從中獲取結果 s3（如果大）：return：包含實際結果的文件位置或結果的 s3 位置 ```py 殺（TI） ``` 殺死（取消）一個 Qubole 委托：param ti：任務 dag 的實例，用于確定 Quboles 命令 id：return：來自 Qubole 的響應 ```py class airflow.contrib.hooks.redis_hook.RedisHook（redis_conn_id ='redis_default'） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` 掛鉤與 Redis 數據庫交互 ```py get_conn（） ``` 返回 Redis 連接。 ```py key_exists（鑰匙??） ``` 檢查 Redis 數據庫中是否存在密鑰參數：`key(string)` - 檢查存在的關鍵。 ```py class airflow.contrib.hooks.redshift_hook.RedshiftHook（aws_conn_id ='aws_default'） ``` 基類： [`airflow.contrib.hooks.aws_hook.AwsHook`](31 "airflow.contrib.hooks.aws_hook.AwsHook") 使用 boto3 庫與 AWS Redshift 交互 ```py cluster_status（cluster_identifier） ``` 返回群集的狀態參數：`cluster_identifier(str)` - 集群的唯一標識符 ```py create_cluster_snapshot（snapshot_identifier，cluster_identifier） ``` 創建群集的快照參數： * `snapshot_identifier(str)` - 群集快照的唯一標識符 * `cluster_identifier(str)` - 集群的唯一標識符 ```py delete_cluster（cluster_identifier，skip_final_cluster_snapshot = True，final_cluster_snapshot_identifier =''） ``` 刪除群集并可選擇創建快照參數： * `cluster_identifier(str)` - 集群的唯一標識符 * `skip_final_cluster_snapshot(bool)` - 確定群集快照創建 * `final_cluster_snapshot_identifier(str)` - 最終集群快照的名稱 ```py describe_cluster_snapshots（cluster_identifier） ``` 獲取群集的快照列表參數：`cluster_identifier(str)` - 集群的唯一標識符 ```py restore_from_cluster_snapshot（cluster_identifier，snapshot_identifier） ``` 從其快照還原群集參數： * `cluster_identifier(str)` - 集群的唯一標識符 * `snapshot_identifier(str)` - 群集快照的唯一標識符 ```py class airflow.contrib.hooks.segment_hook.SegmentHook（segment_conn_id ='segment_default'，segment_debug_mode = False，* args，** kwargs） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` ```py on_error（錯誤，項目） ``` 在將 segment_debug_mode 設置為 True 的情況下使用 Segment 時處理錯誤回調 ```py class airflow.contrib.hooks.sftp_hook.SFTPHook（ftp_conn_id ='sftp_default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` 與 SFTP 互動。旨在與 FTPHook 互換。 ```py 陷阱： - 與 FTPHook 相比，describe_directory 只返回大小，類型和 ``` > 修改。它不返回 unix.owner，unix.mode，perm，unix.group 和 unique。 * retrieve_file 和 store_file 只接受本地完整路徑而不是緩沖區。 * 如果沒有模式傳遞給 create_directory，它將以 777 權限創建。可能在整個過程中發生的錯誤應該在下游處理。 ```py close_conn（） ``` 關閉連接。如果連接未被打開，則會發生錯誤。 ```py create_directory（path，mode = 777） ``` 在遠程系統上創建目錄。：param path：要創建的遠程目錄的完整路徑：type path：str：param mode：int 表示目錄的八進制模式 ```py delete_directory（路徑） ``` 刪除遠程系統上的目錄。：param path：要刪除的遠程目錄的完整路徑：type path：str ```py DELETE_FILE（路徑） ``` 刪除 FTP 服務器上的文件：param path：遠程文件的完整路徑：type path：str ```py describe_directory（路徑） ``` 返回遠程系統上所有文件的{filename：{attributes}}字典（支持 MLSD 命令）。：param path：遠程目錄的完整路徑：type path：str ```py get_conn（） ``` 返回 SFTP 連接對象 ```py list_directory（路徑） ``` 返回遠程系統上的文件列表。：param path：要列出的遠程目錄的完整路徑：type path：str ```py retrieve_file（remote_full_path，local_full_path） ``` 將遠程文件傳輸到本地位置。如果 local_full_path 是字符串路徑，則文件將放在該位置：param remote_full_path：遠程文件的完整路徑：type remote_full_path：str：param local_full_path：本地文件的完整路徑：type local_full_path：str ```py store_file（remote_full_path，local_full_path） ``` 將本地文件傳輸到遠程位置。如果 local_full_path_or_buffer 是字符串路徑，則將從該位置讀取文件：param remote_full_path：遠程文件的完整路徑：type remote_full_path：str：param local_full_path：本地文件的完整路徑：type local_full_path：str ```py class airflow.contrib.hooks.slack_webhook_hook.SlackWebhookHook（http_conn_id = None，webhook_token = None，message =''，channel = None，username = None，icon_emoji = None，link_names = False，proxy = None，* args，** kwargs ） ``` 基類： [`airflow.hooks.http_hook.HttpHook`](31 "airflow.hooks.http_hook.HttpHook") 此掛鉤允許您使用傳入的 webhook 將消息發布到 Slack。直接使用 Slack webhook 令牌和具有 Slack webhook 令牌的連接。如果兩者都提供，將使用 Slack webhook 令牌。每個 Slack webhook 令牌都可以預先配置為使用特定頻道，用戶名和圖標。您可以在此掛鉤中覆蓋這些默認值。參數： * `http_conn_id(str)` - 在額外字段中具有 Slack webhook 標記的連接 * `webhook_token(str)` - Slack webhook 令牌 * `message(str)` - 要在 Slack 上發送的消息 * `channel(str)` - 郵件應發布到的頻道 * `username(str)` - 要發布的用戶名 * `icon_emoji(str)` - 用作發布給 Slack 的用戶圖標的表情符號 * `link_names(bool)` - 是否在郵件中查找和鏈接頻道和用戶名 * `proxy(str)` - 用于進行 Slack webhook 調用的代理 ```py 執行（） ``` 遠程 Popen（實際上執行松弛的 webhook 調用）參數： * `cmd` - 遠程執行的命令 * `kwargs` - **Popen 的**額外參數（參見 subprocess.Popen） ```py class airflow.contrib.hooks.snowflake_hook.SnowflakeHook（* args，** kwargs） ``` 基類： [`airflow.hooks.dbapi_hook.DbApiHook`](31 "airflow.hooks.dbapi_hook.DbApiHook") 與 Snowflake 互動。 get_sqlalchemy_engine（）依賴于 snowflake-sqlalchemy ```py get_conn（） ``` 返回一個 snowflake.connection 對象 ```py get_uri（） ``` 覆蓋 get_sqlalchemy_engine（）的 DbApiHook get_uri 方法 ```py set_autocommit（conn，autocommit） ``` 設置連接上的自動提交標志 ```py class airflow.contrib.hooks.spark_jdbc_hook.SparkJDBCHook（spark_app_name ='airflow-spark-jdbc'，spark_conn_id ='spark-default'，spark_conf = None，spark_py_files = None，spark_files = None，spark_jars = None，num_executors = None，executor_cores = None，executor_memory = None，driver_memory = None，verbose = False，principal = None，keytab = None，cmd_type ='spark_to_jdbc'，jdbc_table = None，jdbc_conn_id ='jdbc-default'，jdbc_driver = None，metastore_table = None，jdbc_truncate = False，save_mode = None，save_format = None，batch_size = None，fetch_size = None，num_partitions = None，partition_column = None，lower_bound = None，upper_bound = None，create_table_column_types = None，* args，** kwargs） ``` 基類： [`airflow.contrib.hooks.spark_submit_hook.SparkSubmitHook`](31 "airflow.contrib.hooks.spark_submit_hook.SparkSubmitHook") 此鉤子擴展了 SparkSubmitHook，專門用于使用 Apache Spark 執行與基于 JDBC 的數據庫之間的數據傳輸。參數： * `spark_app_name**（str） - 作業名稱（默認為**airflow` -spark-jdbc） * `spark_conn_id(str)` - 在 Airflow 管理中配置的連接 ID * `spark_conf(dict)` - 任何其他 Spark 配置屬性 * `spark_py_files(str)` - 使用的其他 python 文件（.zip，.egg 或.py） * `spark_files(str)` - 要上載到運行作業的容器的其他文件 * `spark_jars(str)` - 要上傳并添加到驅動程序和執行程序類路徑的其他 jar * `num_executors(int)` - 要運行的執行程序的數量。應設置此項以便管理使用 JDBC 數據庫建立的連接數 * `executor_cores(int)` - 每個執行程序的核心數 * `executor_memory(str)` - 每個執行者的內存（例如 1000M，2G） * `driver_memory(str)` - 分配給驅動程序的內存（例如 1000M，2G） * `verbose(bool)` - 是否將詳細標志傳遞給 spark-submit 進行調試 * `keytab(str)` - 包含 keytab 的文件的完整路徑 * `principal(str)` - 用于 keytab 的 kerberos 主體的名稱 * `cmd_type(str)` - 數據應該以哪種方式流動。2 個可能的值：spark_to_jdbc：從 Metastore 到 jdbc jdbc_to_spark 的 spark 寫入的數據：來自 jdbc 到 Metastore 的 spark 寫入的數據 * `jdbc_table(str)` - JDBC 表的名稱 * `jdbc_conn_id` - 用于連接 JDBC 數據庫的連接 ID * `jdbc_driver(str)` - 用于 JDBC 連接的 JDBC 驅動程序的名稱。這個驅動程序（通常是一個 jar）應該在'jars'參數中傳遞 * `metastore_table(str)` - Metastore 表的名稱， * `jdbc_truncate(bool)` - （僅限 spark_to_jdbc）Spark 是否應截斷或刪除并重新創建 JDBC 表。這僅在'save_mode'設置為 Overwrite 時生效。此外，如果架構不同，Spark 無法截斷，并將丟棄并重新創建 * `save_mode(str)` - 要使用的 Spark 保存模式（例如覆蓋，追加等） * `save_format(str)` - （jdbc_to_spark-only）要使用的 Spark 保存格式（例如鑲木地板） * `batch_size(int)` - （僅限 spark_to_jdbc）每次往返 JDBC 數據庫時要插入的批處理的大小。默認為 1000 * `fetch_size(int)` - （僅限 jdbc_to_spark）從 JDBC 數據庫中每次往返獲取的批處理的大小。默認值取決于 JDBC 驅動程序 * `num_partitions(int)` - Spark 同時可以使用的最大分區數，包括 spark_to_jdbc 和 jdbc_to_spark 操作。這也將限制可以打開的 JDBC 連接數 * `partition_column(str)` - （jdbc_to_spark-only）用于對 Metastore 表進行分區的數字列。如果已指定，則還必須指定：num_partitions，lower_bound，upper_bound * `lower_bound(int)` - （jdbc_to_spark-only）要獲取的數字分區列范圍的下限。如果已指定，則還必須指定：num_partitions，partition_column，upper_bound * `upper_bound(int)` - （jdbc_to_spark-only）要獲取的數字分區列范圍的上限。如果已指定，則還必須指定：num_partitions，partition_column，lower_bound * `create_table_column_types` - （spark_to_jdbc-only）創建表時要使用的數據庫列數據類型而不是默認值。應以與 CREATE TABLE 列語法相同的格式指定數據類型信息（例如：“name CHAR（64），comments VARCHAR（1024）”）。指定的類型應該是有效的 spark sql 數據類型。類型： jdbc_conn_id：str ```py class airflow.contrib.hooks.spark_sql_hook.SparkSqlHook（sql，conf = None，conn_id ='spark_sql_default'，total_executor_cores = None，executor_cores = None，executor_memory = None，keytab = None，principal = None，master ='yarn'，name ='default-name'，num_executors =無，verbose = True，yarn_queue ='default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` 這個鉤子是 spark-sql 二進制文件的包裝器。它要求“spark-sql”二進制文件在 PATH 中。：param sql：要執行的 SQL 查詢：type sql：str：param conf：arbitrary Spark 配置屬性：type conf：str（format：PROP = VALUE）：param conn_id：connection_id string：type conn_id：str：param total_executor_cores :(僅限 Standalone 和 Mesos）所有執行程序的總核心數 > （默認值：工作者的所有可用核心）參數： * `executor_cores(int)` - （僅限 Standalone 和 YARN）每個執行程序的核心數（默認值：2） * `executor_memory(str)` - 每個執行程序的內存（例如 1000M，2G）（默認值：1G） * `keytab(str)` - 包含 keytab 的文件的完整路徑 * `master(str)` - spark：// host：port，mesos：// host：port，yarn 或 local * `name(str)` - 作業名稱。 * `num_executors(int)` - 要啟動的執行程序數 * `verbose(bool)` - 是否將詳細標志傳遞給 spark-sql * `yarn_queue(str)` - 要提交的 YARN 隊列（默認值：“default”） ```py run_query（cmd =''，** kwargs） ``` Remote Popen（實際執行 Spark-sql 查詢）參數： * `cmd` - 遠程執行的命令 * `kwargs` - **Popen 的**額外參數（參見 subprocess.Popen） ```py class airflow.contrib.hooks.spark_submit_hook.SparkSubmitHook（conf = None，conn_id ='spark_default'，files = None，py_files = None，driver_classpath = None，jars = None，java_class = None，packages = None，exclude_packages = None，repositories = None，total_executor_cores = None，executor_cores = None，executor_memory = None，driver_memory = None，keytab = None，principal = None，name ='default-name'，num_executors = None，application_args = None，env_vars = None，verbose = False ） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` 這個鉤子是一個圍繞 spark-submit 二進制文件的包裝器來啟動一個 spark-submit 作業。它要求“spark-submit”二進制文件在 PATH 或 spark_home 中提供。：param conf：任意 Spark 配置屬性：類型 conf：dict：param conn_id：Airflow 管理中配置的連接 ID。當一個 > 提供的 connection_id 無效，默認為 yarn。參數： * `files(str)` - 將其他文件上載到運行作業的執行程序，以逗號分隔。文件將放在每個執行程序的工作目錄中。例如，序列化對象。 * `py_files(str)` - 作業使用的其他 python 文件可以是.zip，.egg 或.py。 * `driver_classpath(str)` - 其他特定于驅動程序的類路徑設置。 * `jars(str)` - 提交其他 jar 以上傳并將它們放在執行程序類路徑中。 * `java_class(str)` - Java 應用程序的主要類 * `packages` - 包含在的**包的**逗號分隔的 maven 坐標列表驅動程序和執行程序類路徑：類型包：str：param exclude_packages：解析“packages”中提供的依賴項時要排除的 jar 的 maven 坐標的逗號分隔列表：type exclude_packages：str：param repositories：以逗號分隔的其他遠程存儲庫列表搜索“packages”給出的 maven 坐標：type repositories：str：param total_executor_cores :(僅限 Standalone 和 Mesos）所有執行程序的總核心數（默認值：worker 上的所有可用核心）：type total_executor_cores：int：param executor_cores :(僅限 Standalone，YARN 和 Kubernetes）每個執行程序的核心數（默認值：2）：類型 executor_cores：int：param executor_memory：每個執行程序的內存（例如 1000M，2G）（默認值：1G）：類型 executor_memory：str：param driver_memory ：分配給驅動程序的內存（例如 1000M，2G）（默認值：1G）：類型 driver_memory：str：param keytab：包含 keytab 的文件的完整路徑：type keytab：str：param principal：用于 keytab 的 curb eros principal 的名稱：type principal：str： param name：作業名稱（默認為 airflow-spark）：類型名稱：str：param num_executors：要啟動的執行程序數：類型 num_executors：int：param application_args：正在提交的應用程序的參數：type application_args：list：param env_vars ：spark-submit 的環境變量。type num_executors：int：param application_args：正在提交的應用程序的參數：type application_args：list：param env_vars：spark-submit 的環境變量。type num_executors：int：param application_args：正在提交的應用程序的參數：type application_args：list：param env_vars：spark-submit 的環境變量。它 > 也支持紗線和 k8s 模式。參數：`verbose(bool)` - 是否將詳細標志傳遞給 spark-submit 進程進行調試 ```py 提交（application =''，** kwargs） ``` Remote Popen 執行 spark-submit 作業參數： * `application(str)` - 提交的應用程序，jar 或 py 文件 * `kwargs` - **Popen 的**額外參數（參見 subprocess.Popen） ```py class airflow.contrib.hooks.sqoop_hook.SqoopHook（conn_id ='sqoop_default'，verbose = False，num_mappers = None，hcatalog_database = None，hcatalog_table = None，properties = None） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` 這個鉤子是 sqoop 1 二進制文件的包裝器。為了能夠使用鉤子，需要“sqoop”在 PATH 中。可以通過 sqoop 連接的“額外”JSON 字段傳遞的其他參數： * job_tracker：Job tracker local | jobtracker：port。 * namenode：Namenode。 * lib_jars：逗號分隔的 jar 文件，包含在類路徑中。 * files：要復制到地圖縮減群集的逗號分隔文件。 * archives：要在計算機上取消歸檔的逗號分隔的歸檔 > 機器。 * password_file：包含密碼的文件路徑。參數： * `conn_id(str)` - 對 sqoop 連接的引用。 * `verbose(bool)` - 將 sqoop 設置為 verbose。 * `num_mappers(int)` - 要并行導入的地圖任務數。 * `properties(dict)` - 通過-D 參數設置的屬性 ```py Popen（cmd，** kwargs） ``` 遠程 Popen 參數： * `cmd` - 遠程執行的命令 * `kwargs` - **Popen 的**額外參數（參見 subprocess.Popen）返回值：處理子進程 ```py export_table（table，export_dir，input_null_string，input_null_non_string，staging_table，clear_staging_table，enclosed_by，escaped_by，input_fields_terminated_by，input_lines_terminated_by，input_optionally_enclosed_by，batch，relaxed_isolation，extra_export_options = None） ``` 將 Hive 表導出到遠程位置。參數是直接 sqoop 命令行的副本參數：param table：表遠程目標：param export_dir：要導出的 Hive 表：param input_null_string：要解釋為 null 的字符串 > 字符串列參數： * `input_null_non_string` - 非字符串列的解釋為 null 的字符串 * `staging_table` - 在插入目標表之前將暫存數據的表 * `clear_staging_table` - 指示可以刪除登臺表中存在的任何數據 * `enclosed_by` - 設置包含字符的必填字段 * `escaped_by` - 設置轉義字符 * `input_fields_terminated_by` - 設置字段分隔符 * `input_lines_terminated_by` - 設置行尾字符 * `input_optionally_enclosed_by` - 設置包含字符的字段 * `batch` - 使用批處理模式執行基礎語句 * `relaxed_isolation` - 為映射器讀取未提交的事務隔離 * `extra_export_options` - 作為 dict 傳遞的額外導出選項。如果某個鍵沒有值，只需將空字符串傳遞給它即可。對于 sqoop 選項，不要包含 - 的前綴。 ```py import_query（query，target_dir，append = False，file_type ='text'，split_by = None，direct = None，driver = None，extra_import_options = None） ``` 從 rdbms 導入特定查詢到 hdfs：param 查詢：要運行的自由格式查詢：param target_dir：HDFS 目標 dir：param append：將數據附加到 HDFS 中的現有數據集：param file_type：“avro”，“sequence”，“文字“或”鑲木地板“ > 將數據導入 hdfs 為指定格式。默認為文字。參數： * `split_by` - 用于拆分工作單元的表的列 * `直接` - 使用直接導入快速路徑 * `driver` - 手動指定要使用的 JDBC 驅動程序類 * `extra_import_options` - 作為 dict 傳遞的額外導入選項。如果某個鍵沒有值，只需將空字符串傳遞給它即可。對于 sqoop 選項，不要包含 - 的前綴。 ```py import_table（table，target_dir = None，append = False，file_type ='text'，columns = None，split_by = None，where = None，direct = False，driver = None，extra_import_options = None） ``` 將表從遠程位置導入到目標目錄。參數是直接 sqoop 命令行參數的副本：param table：要讀取的表：param target_dir：HDFS 目標 dir：param append：將數據附加到 HDFS 中的現有數據集：param file_type：“avro”，“sequence”，“text”或“鑲木地板”。 > 將數據導入指定的格式。默認為文字。參數： * `columns` - <col，col，col ...>要從表導入的列 * `split_by` - 用于拆分工作單元的表的列 * `where` - 導入期間要使用的 WHERE 子句 * `direct` - 如果存在數據庫，則使用直接連接器 * `driver` - 手動指定要使用的 JDBC 驅動程序類 * `extra_import_options` - 作為 dict 傳遞的額外導入選項。如果某個鍵沒有值，只需將空字符串傳遞給它即可。對于 sqoop 選項，不要包含 - 的前綴。 ```py class airflow.contrib.hooks.ssh_hook.SSHHook（ssh_conn_id = None，remote_host = None，username = None，password = None，key_file = None，port = 22，timeout = 10，keepalive_interval = 30） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` 使用 Paramiko 進行 ssh 遠程執行的鉤子。ref：[https](https://github.com/paramiko/paramiko)：[//github.com/paramiko/paramiko](https://github.com/paramiko/paramiko)這個鉤子還允許你創建 ssh 隧道并作為 SFTP 文件傳輸的基礎參數： * `ssh_conn_id(str)` - 來自氣流的連接 ID 從中可以獲取所有必需參數的連接，如用戶名，密碼或 key_file。認為優先權是在 init 期間傳遞的參數 * `remote_host(str)` - 要連接的遠程主機 * `username(str)` - 用于連接 remote_host 的用戶名 * `password(str)` - 連接到 remote_host 的用戶名的密碼 * `key_file(str)` - 用于連接 remote_host 的密鑰文件。 * `port(int)` - 要連接的遠程主機的端口（默認為 paramiko SSH_PORT） * `timeout(int)` - 嘗試連接到 remote_host 的超時。 * `keepalive_interval(int)` - 每隔 keepalive_interval 秒向遠程主機發送一個 keepalive 數據包 ```py create_tunnel（** kwds） ``` 在兩臺主機之間創建隧道。與 ssh -L <LOCAL_PORT>類似：host：<REMOTE_PORT>。記得關閉（）返回的“隧道”對象，以便在完成隧道后自行清理。參數： * `local_port(int)` - * `remote_port(int)` - * `remote_host(str)` - 返回值： ```py class airflow.contrib.hooks.vertica_hook.VerticaHook（* args，** kwargs） ``` 基類： [`airflow.hooks.dbapi_hook.DbApiHook`](31 "airflow.hooks.dbapi_hook.DbApiHook") 與 Vertica 互動。 ```py get_conn（） ``` 返回 verticaql 連接對象 ```py class airflow.contrib.hooks.wasb_hook.WasbHook（wasb_conn_id ='wasb_default'） ``` 基類： `airflow.hooks.base_hook.BaseHook` 通過 wasb：//協議與 Azure Blob 存儲進行交互。在連接的“額外”字段中傳遞的其他選項將傳遞給`BlockBlockService（）`構造函數。例如，通過添加{“sas_token”：“YOUR_TOKEN”}使用 SAS 令牌進行身份驗證。參數：`wasb_conn_id(str)` - 對 wasb 連接的引用。 ```py check_for_blob（container_name，blob_name，** kwargs） ``` 檢查 Azure Blob 存儲上是否存在 Blob。參數： * `container_name(str)` - 容器的名稱。 * `blob_name(str)` - blob 的名稱。 * `kwargs(object)` - `BlockBlobService.exists（）`采用的可選關鍵字參數。返回值：如果 blob 存在則為 True，否則為 False。：rtype 布爾 ```py check_for_prefix（container_name，prefix，** kwargs） ``` 檢查 Azure Blob 存儲上是否存在前綴。參數： * `container_name(str)` - 容器的名稱。 * `prefix(str)` - blob 的前綴。 * `kwargs(object)` - `BlockBlobService.list_blobs（）`采用的可選關鍵字參數。返回值：如果存在與前綴匹配的 blob，則為 True，否則為 False。：rtype 布爾 ```py get_conn（） ``` 返回 BlockBlobService 對象。 ```py get_file（file_path，container_name，blob_name，** kwargs） ``` 從 Azure Blob 存儲下載文件。參數： * `file_path(str)` - 要下載的文件的路徑。 * `container_name(str)` - 容器的名稱。 * `blob_name(str)` - blob 的名稱。 * `kwargs(object)` - `BlockBlobService.create_blob_from_path（）`采用的可選關鍵字參數。 ```py load_file（file_path，container_name，blob_name，** kwargs） ``` 將文件上載到 Azure Blob 存儲。參數： * `file_path(str)` - 要加載的文件的路徑。 * `container_name(str)` - 容器的名稱。 * `blob_name(str)` - blob 的名稱。 * `kwargs(object)` - `BlockBlobService.create_blob_from_path（）`采用的可選關鍵字參數。 ```py load_string（string_data，container_name，blob_name，** kwargs） ``` 將字符串上載到 Azure Blob 存儲。參數： * `string_data(str)` - 要加載的字符串。 * `container_name(str)` - 容器的名稱。 * `blob_name(str)` - blob 的名稱。 * `kwargs(object)` - `BlockBlobService.create_blob_from_text（）`采用的可選關鍵字參數。 ```py read_file（container_name，blob_name，** kwargs） ``` 從 Azure Blob Storage 讀取文件并以字符串形式返回。參數： * `container_name(str)` - 容器的名稱。 * `blob_name(str)` - blob 的名稱。 * `kwargs(object)` - `BlockBlobService.create_blob_from_path（）`采用的可選關鍵字參數。 ```py class airflow.contrib.hooks.winrm_hook.WinRMHook（ssh_conn_id = None，remote_host = None，username = None，password = None，key_file = None，timeout = 10，keepalive_interval = 30） ``` 基類：`airflow.hooks.base_hook.BaseHook`，`airflow.utils.log.logging_mixin.LoggingMixin` 使用 pywinrm 進行 winrm 遠程執行的鉤子。參數： * `ssh_conn_id(str)` - 來自氣流的連接 ID 從中可以獲取所有必需參數的連接，如用戶名，密碼或 key_file。認為優先權是在 init 期間傳遞的參數 * `remote_host(str)` - 要連接的遠程主機 * `username(str)` - 用于連接 remote_host 的用戶名 * `password(str)` - 連接到 remote_host 的用戶名的密碼 * `key_file(str)` - 用于連接 remote_host 的密鑰文件。 * `timeout(int)` - 嘗試連接到 remote_host 的超時。 * `keepalive_interval(int)` - 每隔 keepalive_interval 秒向遠程主機發送一個 keepalive 數據包 ## 執行人執行程序是運行任務實例的機制。 ```py class airflow.executors.local_executor.LocalExecutor（parallelism = 32） ``` 基類： `airflow.executors.base_executor.BaseExecutor` LocalExecutor 并行本地執行任務。它使用多處理 Python 庫和隊列來并行執行任務。 ```py 結束（） ``` 當調用者完成提交作業并且想要同步等待先前提交的作業全部完成時，調用此方法。 ```py execute_async（key，command，queue = None，executor_config = None） ``` 此方法將異步執行該命令。 ```py 開始（） ``` 執行人員可能需要開始工作。例如，LocalExecutor 啟動 N 個工作者。 ```py 同步（） ``` 將通過心跳方法定期調用同步。執行者應該重寫此操作以執行收集狀態。 ```py class airflow.executors.celery_executor.CeleryExecutor（parallelism = 32） ``` 基類： `airflow.executors.base_executor.BaseExecutor` CeleryExecutor 推薦用于 Airflow 的生產使用。它允許將任務實例的執行分配給多個工作節點。 Celery 是一個簡單，靈活和可靠的分布式系統，用于處理大量消息，同時為操作提供維護此類系統所需的工具。 ```py 端（同步=假） ``` 當調用者完成提交作業并且想要同步等待先前提交的作業全部完成時，調用此方法。 ```py execute_async（key，command，queue ='default'，executor_config = None） ``` 此方法將異步執行該命令。 ```py 開始（） ``` 執行人員可能需要開始工作。例如，LocalExecutor 啟動 N 個工作者。 ```py 同步（） ``` 將通過心跳方法定期調用同步。執行者應該重寫此操作以執行收集狀態。 ```py class airflow.executors.sequential_executor.SequentialExecutor ``` 基類： `airflow.executors.base_executor.BaseExecutor` 此執行程序一次只運行一個任務實例，可用于調試。它也是唯一可以與 sqlite 一起使用的執行器，因為 sqlite 不支持多個連接。由于我們希望氣流能夠開箱即用，因此在您首次安裝時，它會默認使用此 SequentialExecutor 和 sqlite。 ```py 結束（） ``` 當調用者完成提交作業并且想要同步等待先前提交的作業全部完成時，調用此方法。 ```py execute_async（key，command，queue = None，executor_config = None） ``` 此方法將異步執行該命令。 ```py 同步（） ``` 將通過心跳方法定期調用同步。執行者應該重寫此操作以執行收集狀態。 ### 社區貢獻的遺囑執行人 ```py class airflow.contrib.executors.mesos_executor.MesosExecutor（parallelism = 32） ``` 基類：`airflow.executors.base_executor.BaseExecutor`，`airflow.www.utils.LoginMixin` MesosExecutor 允許將任務實例的執行分配給多個 mesos worker。 Apache Mesos 是一個分布式系統內核，可以將 CPU，內存，存儲和其他計算資源從機器（物理或虛擬）中抽象出來，從而可以輕松構建和運行容錯和彈性分布式系統。見[http://mesos.apache.org/](http://mesos.apache.org/) ```py 結束（） ``` 當調用者完成提交作業并且想要同步等待先前提交的作業全部完成時，調用此方法。 ```py execute_async（key，command，queue = None，executor_config = None） ``` 此方法將異步執行該命令。 ```py 開始（） ``` 執行人員可能需要開始工作。例如，LocalExecutor 啟動 N 個工作者。 ```py 同步（） ``` 將通過心跳方法定期調用同步。執行者應該重寫此操作以執行收集狀態。