添加中英文之间的空格

zh/1.md

@@ -4,9 +4,9 @@
 
 ## 历史
 
-Airflow于2014年10月由Airbnb的Maxime Beauchemin开始。它是第一次提交的开源，并在2015年6月宣布正式加入Airbnb Github。
+Airflow 于 2014 年 10 月由 Airbnb 的 Maxime Beauchemin 开始。它是第一次提交的开源，并在 2015 年 6 月宣布正式加入 Airbnb Github。
 
-该项目于2016年3月加入了Apache Software Foundation的孵化计划。
+该项目于 2016 年 3 月加入了 Apache Software Foundation 的孵化计划。
 
 ## 提交者
 
@@ -28,15 +28,15 @@ Airflow于2014年10月由Airbnb的Maxime Beauchemin开始。它是第一次提
 * @hiteshs (Hitesh Shah)
 * @jghoman (Jakob Homan)
 
-有关贡献者的完整列表，请查看[Airflow的Github贡献者页面：](https://github.com/apache/airflow/graphs/contributors)
+有关贡献者的完整列表，请查看[Airflow 的 Github 贡献者页面：](https://github.com/apache/airflow/graphs/contributors)
 
 ## 资源和链接
 
-* [Airflow的官方文档](http://airflow.apache.org/)
+* [Airflow 的官方文档](http://airflow.apache.org/)
 * 邮件列表（发送电子邮件至`dev-subscribe@airflow.incubator.apache.org`和/或`commits-subscribe@airflow.incubator.apache.org`订阅每个邮件）
-* [关于Apache的Jira的问题](https://issues.apache.org/jira/browse/AIRFLOW)
+* [关于 Apache 的 Jira 的问题](https://issues.apache.org/jira/browse/AIRFLOW)
 * [Slack（聊天）频道](https://apache-airflow-slack.herokuapp.com)
-* [更多资源以及Wiki上与Airflow相关内容的链接](https://cwiki.apache.org/confluence/display/AIRFLOW/Airflow+Links)
+* [更多资源以及 Wiki 上与 Airflow 相关内容的链接](https://cwiki.apache.org/confluence/display/AIRFLOW/Airflow+Links)
 
 ## 路线图
 

zh/10.md

@@ -2,28 +2,28 @@
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)、[@ThinkingChen](https://github.com/cdmikechen)
 
-Airflow需要知道如何连接到您的环境。其他系统和服务的主机名，端口，登录名和密码等信息在UI的`Admin->Connection`部分中处理。您编写的pipeline（管道）代码将引用Connection对象的“conn_id”。
+Airflow 需要知道如何连接到您的环境。其他系统和服务的主机名，端口，登录名和密码等信息在 UI 的`Admin->Connection`部分中处理。您编写的 pipeline（管道）代码将引用 Connection 对象的“conn_id”。
 
 ![https://airflow.apache.org/_images/connections.png](../img/b1caba93dd8fce8b3c81bfb0d58cbf95.jpg)
 
-可以使用UI或环境变量创建和管理连接。
+可以使用 UI 或环境变量创建和管理连接。
 
 有关更多信息，请参阅[Connenctions Concepts](zh/20.md)文档。
 
-## 使用UI创建连接
+## 使用 UI 创建连接
 
-打开UI的`Admin->Connection`部分。 单击`Create`按钮以创建新连接。
+打开 UI 的`Admin->Connection`部分。 单击`Create`按钮以创建新连接。
 
 ![https://airflow.apache.org/_images/connection_create.png](../img/635aacab53c55192ad3e31c28e65eb43.jpg)
 
-1. 使用所需的连接ID填写`Conn Id`字段。建议您使用小写字符和单独的带下划线的单词。
+1. 使用所需的连接 ID 填写`Conn Id`字段。建议您使用小写字符和单独的带下划线的单词。
 2. 使用`Conn Type`字段选择连接类型。
 3. 填写其余字段。有关属于不同连接类型的字段的说明，请参阅连接类型。
 4. 单击`Save`按钮以创建连接。
 
-## 使用UI编辑连接
+## 使用 UI 编辑连接
 
-打开UI的`Admin->Connection`部分。 单击连接列表中要编辑的连接旁边的铅笔图标。
+打开 UI 的`Admin->Connection`部分。 单击连接列表中要编辑的连接旁边的铅笔图标。
 
 ![https://airflow.apache.org/_images/connection_edit.png](../img/08e0f3fedf871b535c850d202dda1422.jpg)
 
@@ -31,26 +31,26 @@ Airflow需要知道如何连接到您的环境。其他系统和服务的主机
 
 ## 使用环境变量创建连接
 
-可以使用环境变量创建Airflow pipeline（管道）中的连接。环境变量需要具有`AIRFLOW_CONN_`的前缀的URI格式才能正确使用连接。
+可以使用环境变量创建 Airflow pipeline（管道）中的连接。环境变量需要具有`AIRFLOW_CONN_`的前缀的 URI 格式才能正确使用连接。
 
-在引用Airflow pipeline（管道）中的连接时，`conn_id`应该是没有前缀的变量的名称。例如，如果`conn_id`名为`postgres_master`，则环境变量应命名为`AIRFLOW_CONN_POSTGRES_MASTER`（请注意，环境变量必须全部为大写）。Airflow假定环境变量返回的值为URI格式（例如`postgres://user:password@localhost:5432/master`或`s3://accesskey:secretkey@S3` ）。
+在引用 Airflow pipeline（管道）中的连接时，`conn_id`应该是没有前缀的变量的名称。例如，如果`conn_id`名为`postgres_master`，则环境变量应命名为`AIRFLOW_CONN_POSTGRES_MASTER`（请注意，环境变量必须全部为大写）。Airflow 假定环境变量返回的值为 URI 格式（例如`postgres://user:password@localhost:5432/master`或`s3://accesskey:secretkey@S3` ）。
 
 ## 连接类型
 
 ### Google Cloud Platform
 
-Google Cloud Platform连接类型支持[GCP集成](zh/28.md) 。
+Google Cloud Platform 连接类型支持[GCP 集成](zh/28.md) 。
 
-#### 对GCP进行身份验证
+#### 对 GCP 进行身份验证
 
-有两种方法可以使用Airflow连接到GCP。
+有两种方法可以使用 Airflow 连接到 GCP。
 
-1. 使用[应用程序默认凭据](https://google-auth.readthedocs.io/en/latest/reference/google.auth.html) ，例如在Google Compute Engine上运行时通过元数据服务器。
-2. 在磁盘上使用[服务帐户](https://cloud.google.com/docs/authentication/)密钥文件（JSON格式）。
+1. 使用[应用程序默认凭据](https://google-auth.readthedocs.io/en/latest/reference/google.auth.html) ，例如在 Google Compute Engine 上运行时通过元数据服务器。
+2. 在磁盘上使用[服务帐户](https://cloud.google.com/docs/authentication/)密钥文件（JSON 格式）。
 
-#### 默认连接ID
+#### 默认连接 ID
 
-默认情况下使用以下连接ID。
+默认情况下使用以下连接 ID。
 
 ```py
 bigquery_default
@@ -74,30 +74,30 @@ google_cloud_default
 
 ##### Project Id (必填)
 
-要连接的Google Cloud项目ID。
+要连接的 Google Cloud 项目 ID。
 
 ##### Keyfile Path
 
-磁盘上[服务帐户](https://cloud.google.com/docs/authentication/)密钥文件（JSON格式）的路径。
+磁盘上[服务帐户](https://cloud.google.com/docs/authentication/)密钥文件（JSON 格式）的路径。
 
 如果使用应用程序默认凭据则不需要
 
 ##### Keyfile JSON
 
-磁盘上的[服务帐户](https://cloud.google.com/docs/authentication/)密钥文件（JSON格式）的内容。 如果使用此方法进行身份验证，建议[保护您的连接](zh/11.md) 。
+磁盘上的[服务帐户](https://cloud.google.com/docs/authentication/)密钥文件（JSON 格式）的内容。 如果使用此方法进行身份验证，建议[保护您的连接](zh/11.md) 。
 
 如果使用应用程序默认凭据则不需要
 
 ##### Scopes (逗号分隔)
 
-要通过身份验证的逗号分隔[Google云端范围](https://developers.google.com/identity/protocols/googlescopes)列表。
+要通过身份验证的逗号分隔[Google 云端范围](https://developers.google.com/identity/protocols/googlescopes)列表。
 
 > 注意
 > 使用应用程序默认凭据时，将忽略范围。 请参阅[AIRFLOW-2522](https://issues.apache.org/jira/browse/AIRFLOW-2522) 。
 
 ### MySQL
 
-MySQL连接类型允许连接MySQL数据库。
+MySQL 连接类型允许连接 MySQL 数据库。
 
 #### 配置连接
 
@@ -119,13 +119,13 @@ MySQL连接类型允许连接MySQL数据库。
 
 ##### 额外参数（选填）
 
-指定可以在mysql连接中使用的额外参数（作为json字典）。支持以下参数：
+指定可以在 mysql 连接中使用的额外参数（作为 json 字典）。支持以下参数：
 
- - charset：指定连接的charset
- - cursor：指定使用的cursor，为“sscursor”、“dictcurssor”、“ssdictcursor”其中之一
- - local_infile：控制MySQL的LOCAL功能（允许客户端加载本地数据）。有关详细信息，请参阅[MySQLdb文档](https://mysqlclient.readthedocs.io/user_guide.html)。
- - unix_socket：使用UNIX套接字而不是默认套接字
- - ssl：控制使用SSL连接的SSL参数字典（这些参数是特定于服务器的，应包含“ca”，“cert”，“key”，“capath”，“cipher”参数。有关详细信息，请参阅[MySQLdb文档](https://mysqlclient.readthedocs.io/user_guide.html)。请注意，以便在URL表示法中很有用，此参数也可以是SSL字典是字符串编码的JSON字典的字符串。
+ - charset：指定连接的 charset
+ - cursor：指定使用的 cursor，为“sscursor”、“dictcurssor”、“ssdictcursor”其中之一
+ - local_infile：控制 MySQL 的 LOCAL 功能（允许客户端加载本地数据）。有关详细信息，请参阅[MySQLdb 文档](https://mysqlclient.readthedocs.io/user_guide.html)。
+ - unix_socket：使用 UNIX 套接字而不是默认套接字
+ - ssl：控制使用 SSL 连接的 SSL 参数字典（这些参数是特定于服务器的，应包含“ca”，“cert”，“key”，“capath”，“cipher”参数。有关详细信息，请参阅[MySQLdb 文档](https://mysqlclient.readthedocs.io/user_guide.html)。请注意，以便在 URL 表示法中很有用，此参数也可以是 SSL 字典是字符串编码的 JSON 字典的字符串。
 
 示例“extras”字段：
 
@@ -155,7 +155,7 @@ MySQL连接类型允许连接MySQL数据库。
 }
 ```
 
-将连接指定为URI（在AIRFLOW_CONN_ *变量中）时，应按照DB连接的标准语法指定它，其中附加项作为URI的参数传递（请注意，URI的所有组件都应进行URL编码）。
+将连接指定为 URI（在 AIRFLOW_CONN_ *变量中）时，应按照 DB 连接的标准语法指定它，其中附加项作为 URI 的参数传递（请注意，URI 的所有组件都应进行 URL 编码）。
 
 举个例子：
 
@@ -164,4 +164,4 @@ mysql://mysql_user:XXXXXXXXXXXX@1.1.1.1:3306/mysqldb?ssl=%7B%22cert%22%3A+%22%2F
 ```
 
 > 注意
-> 如果在使用MySQL连接时遇到UnicodeDecodeError，请检查定义的字符集是否与数据库字符集匹配。
+> 如果在使用 MySQL 连接时遇到 UnicodeDecodeError，请检查定义的字符集是否与数据库字符集匹配。

zh/11.md

@@ -2,25 +2,25 @@
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)、[@ThinkingChen](https://github.com/cdmikechen)
 
-默认情况下，Airflow在元数据数据库中是以纯文本格式保存连接的密码。在安装过程中强烈建议使用`crypto`包。`crypto`包要求您的操作系统安装了libffi-dev。
+默认情况下，Airflow 在元数据数据库中是以纯文本格式保存连接的密码。在安装过程中强烈建议使用`crypto`包。`crypto`包要求您的操作系统安装了 libffi-dev。
 
 如果最初未安装`crypto`软件包，您仍可以通过以下步骤为连接启用加密：
 
-1. 安装crypto包`pip install apache-airflow[crypto]`
-2. 使用下面的代码片段生成fernet_key。 fernet_key必须是base64编码的32字节密钥。
+1. 安装 crypto 包`pip install apache-airflow[crypto]`
+2. 使用下面的代码片段生成 fernet_key。 fernet_key 必须是 base64 编码的 32 字节密钥。
 
 ```py
 from cryptography.fernet import Fernet
 fernet_key= Fernet.generate_key()
-print(fernet_key.decode()) # 你的fernet_key，把它放在安全的地方
+print(fernet_key.decode()) # 你的 fernet_key，把它放在安全的地方
 ```
 
-3.将`airflow.cfg`中的fernet_key值替换为步骤2中的值。或者，可以将fernet_key存储在OS环境变量中。在这种情况下，您不需要更改`airflow.cfg`，因为Airflow将使用环境变量而不是`airflow.cfg`中的值：
+3.将`airflow.cfg`中的 fernet_key 值替换为步骤 2 中的值。或者，可以将 fernet_key 存储在 OS 环境变量中。在这种情况下，您不需要更改`airflow.cfg`，因为 Airflow 将使用环境变量而不是`airflow.cfg`中的值：
 
 ```py
 # 注意双下划线
 export AIRFLOW__CORE__FERNET_KEY=your_fernet_key
 ```
 
-1. 重启Airflow webserver。
-2. 对于现有连接（在安装`airflow[crypto]`和创建Fernet密钥之前已定义的连接），您需要在连接管理UI中打开每个连接，重新键入密码并保存。
+1. 重启 Airflow webserver。
+2. 对于现有连接（在安装`airflow[crypto]`和创建 Fernet 密钥之前已定义的连接），您需要在连接管理 UI 中打开每个连接，重新键入密码并保存。

zh/12.md

@@ -8,13 +8,13 @@
 
 此外，用户也可以提供远程位置，以便在云存储中存储日志和日志备份。
 
-在Airflow Web UI中，本地日志优先于远程日志。 如果找不到或访问本地日志，将显示远程日志。 请注意，只有在任务完成（包括失败）后才会将日志发送到远程存储。 换句话说，运行任务的远程日志不可用。日志以`{dag_id}/{task_id}/{execution_date}/{try_number}.log`的路径格式存储在日志文件夹中。
+在 Airflow Web UI 中，本地日志优先于远程日志。 如果找不到或访问本地日志，将显示远程日志。 请注意，只有在任务完成（包括失败）后才会将日志发送到远程存储。 换句话说，运行任务的远程日志不可用。日志以`{dag_id}/{task_id}/{execution_date}/{try_number}.log`的路径格式存储在日志文件夹中。
 
-## 将日志写入Amazon S3
+## 将日志写入 Amazon S3
 
 ### 在您开始之前
 
-远程日志记录使用现有的Airflow连接来读取/写入日志。如果没有正确设置连接，则会失败。
+远程日志记录使用现有的 Airflow 连接来读取/写入日志。如果没有正确设置连接，则会失败。
 
 ### 启用远程日志记录
 
@@ -22,21 +22,21 @@
 
 ```py
 [core]
-# Airflow可以在AWS S3中远程存储日志。用户必须提供一个远程地址的URL（以's3://...'开始）
-# 和一个提供对存储位置访问的Airflow连接id
+# Airflow 可以在 AWS S3 中远程存储日志。用户必须提供一个远程地址的 URL（以's3://...'开始）
+# 和一个提供对存储位置访问的 Airflow 连接 id
 remote_base_log_folder = s3://my-bucket/path/to/logs
 remote_log_conn_id = MyS3Conn
-# 对存储在S3中的日志使用服务器端加密
+# 对存储在 S3 中的日志使用服务器端加密
 encrypt_s3_logs = False
 ```
 
-在上面的例子中，Airflow将尝试使用`S3Hook('MyS3Conn')` 。
+在上面的例子中，Airflow 将尝试使用`S3Hook('MyS3Conn')` 。
 
-## 将日志写入Azure Blob Storage
+## 将日志写入 Azure Blob Storage
 
-在Azure Blob Storage中Airflow可以为配置读取和写入任务日志。 可以按照以下步骤启用Azure Blob Storage日志记录。
+在 Azure Blob Storage 中 Airflow 可以为配置读取和写入任务日志。 可以按照以下步骤启用 Azure Blob Storage 日志记录。
 
-1. Airflow的日志记录系统需要将一个自定义的 .py文件 放在`PYTHONPATH`，以便可以从Airflow导入。首先创建一个存储配置文件的目录。建议使用`$AIRFLOW_HOME/config`。
+1. Airflow 的日志记录系统需要将一个自定义的 .py 文件 放在`PYTHONPATH`，以便可以从 Airflow 导入。首先创建一个存储配置文件的目录。建议使用`$AIRFLOW_HOME/config`。
 
 2. 创建名为`$AIRFLOW_HOME/config/log_config.py`和`$AIRFLOW_HOME/config/__init__.py`的空文件。
 
@@ -45,14 +45,14 @@ encrypt_s3_logs = False
 4. 自定义模板的以下部分：
 
 ```py
-# wasb buckets应该从“wasb”开始，以帮助Airflow选择正确的处理程序
+# wasb buckets 应该从“wasb”开始，以帮助 Airflow 选择正确的处理程序
 REMOTE_BASE_LOG_FOLDER = 'wasb-<whatever you want here>'
 
-# 重命名DEFAULT_LOGGING_CONFIG为LOGGING CONFIG
+# 重命名 DEFAULT_LOGGING_CONFIG 为 LOGGING CONFIG
 LOGGING_CONFIG = ...
 ```
 
-5. 确保已在Airflow中定义Azure Blob Storage（Wasb）的连接hook。hook应具有在`REMOTE_BASE_LOG_FOLDER`中定义的Azure Blob Storage bucket的读写访问权限。
+5. 确保已在 Airflow 中定义 Azure Blob Storage（Wasb）的连接 hook。hook 应具有在`REMOTE_BASE_LOG_FOLDER`中定义的 Azure Blob Storage bucket 的读写访问权限。
 
 6. 更新`$AIRFLOW_HOME/airflow.cfg`以包含：
 
@@ -64,29 +64,29 @@ remote_log_conn_id = <name of the Azure Blob Storage connection>
 
 7. 重新启动 Airflow webserver 和 scheduler，并触发（或等待）新任务执行。
 
-8. 验证日志是否显示在您定义的bucket中新执行的任务中。
+8. 验证日志是否显示在您定义的 bucket 中新执行的任务中。
 
-## 将日志写入Google Cloud Storage
+## 将日志写入 Google Cloud Storage
 
-请按照以下步骤启用Google Cloud Storage日志记录。
+请按照以下步骤启用 Google Cloud Storage 日志记录。
 
-要启用此功能，必须按照此示例配置airflow.cfg：
+要启用此功能，必须按照此示例配置 airflow.cfg：
 
 ```py
 [core]
-# Airflow可以在 AWS S3, Google Cloud Storage 或者 Elastic Search 中远程存储日志.
-# 用户必须提供可访问存储位置的Airflow连接id。
-# 如果 remote_logging 被设置为true，请参见UPDATING.md以查看其他相关配置的要求。
+# Airflow 可以在 AWS S3, Google Cloud Storage 或者 Elastic Search 中远程存储日志.
+# 用户必须提供可访问存储位置的 Airflow 连接 id。
+# 如果 remote_logging 被设置为 true，请参见 UPDATING.md 以查看其他相关配置的要求。
 remote_logging = True
 remote_base_log_folder = gs://my-bucket/path/to/logs
 remote_log_conn_id = MyGCSConn
 ```
 
 1. 首先安装`gcp_api`安装包，`pip install apache-airflow[gcp_api]`。
-2. 确保已在Airflow中定义了Google Cloud Platform连接hook。该hook应具有对remote_base_log_folder中上面定义的Google Cloud Storage bucket的读写访问权限。
-3. 重新启动Airflow webserver 和 scheduler，并触发（或等待）新任务执行。
+2. 确保已在 Airflow 中定义了 Google Cloud Platform 连接 hook。该 hook 应具有对 remote_base_log_folder 中上面定义的 Google Cloud Storage bucket 的读写访问权限。
+3. 重新启动 Airflow webserver 和 scheduler，并触发（或等待）新任务执行。
 4. 验证日志是否在您定义的 bucket 中显示新执行的任务日志。
-5. 确认Google Cloud Storage查看器在U​​I中正常运行。拉出新执行的任务，并验证您是否看到类似的内容
+5. 确认 Google Cloud Storage 查看器在 U​​I 中正常运行。拉出新执行的任务，并验证您是否看到类似的内容
 
 ```py
 *** Reading remote log from gs://<bucket where logs should be persisted>/example_bash_operator/run_this_last/2017-10-03T00:00:00/16.log.

zh/13.md

-# 使用Celery扩大规模
+# 使用 Celery 扩大规模
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)、[@ThinkingChen](https://github.com/cdmikechen)
 
-`CeleryExecutor`是您扩展worker数量的方法之一。为此，您需要设置Celery后端（**RabbitMQ**，**Redis**，...）并更改`airflow.cfg`以将执行程序参数指向`CeleryExecutor`并提供相关的Celery设置。
+`CeleryExecutor`是您扩展 worker 数量的方法之一。为此，您需要设置 Celery 后端（**RabbitMQ**，**Redis**，...）并更改`airflow.cfg`以将执行程序参数指向`CeleryExecutor`并提供相关的 Celery 设置。
 
-有关设置Celery broker的更多信息，请参阅[有关该主题的详细的Celery文档](http://docs.celeryproject.org/en/latest/getting-started/brokers/index.html)。
+有关设置 Celery broker 的更多信息，请参阅[有关该主题的详细的 Celery 文档](http://docs.celeryproject.org/en/latest/getting-started/brokers/index.html)。
 
-以下是您的workers的一些必要要求：
+以下是您的 workers 的一些必要要求：
 
-* 需要安装`airflow`，CLI需要在路径中
-* 整个集群中的Airflow配置设置应该是同构的
-* 在worker上执行的Operators（执行器）需要在该上下文中满足其依赖项。例如，如果您使用`HiveOperator`，则需要在该框上安装hive CLI，或者如果您使用`MySqlOperator`，则必须以某种方式在`PYTHONPATH`提供所需的Python库
-* workers需要访问其`DAGS_FOLDER`的权限，您需要通过自己的方式同步文件系统。常见的设置是将DAGS_FOLDER存储在Git存储库中，并使用Chef，Puppet，Ansible或用于配置环境中的计算机的任何内容在计算机之间进行同步。如果您的所有盒子都有一个共同的挂载点，那么共享您的管道文件也应该可以正常工作
+* 需要安装`airflow`，CLI 需要在路径中
+* 整个集群中的 Airflow 配置设置应该是同构的
+* 在 worker 上执行的 Operators（执行器）需要在该上下文中满足其依赖项。例如，如果您使用`HiveOperator`，则需要在该框上安装 hive CLI，或者如果您使用`MySqlOperator`，则必须以某种方式在`PYTHONPATH`提供所需的 Python 库
+* workers 需要访问其`DAGS_FOLDER`的权限，您需要通过自己的方式同步文件系统。常见的设置是将 DAGS_FOLDER 存储在 Git 存储库中，并使用 Chef，Puppet，Ansible 或用于配置环境中的计算机的任何内容在计算机之间进行同步。如果您的所有盒子都有一个共同的挂载点，那么共享您的管道文件也应该可以正常工作
 
-要启动worker，您需要设置Airflow并启动worker子命令
+要启动 worker，您需要设置 Airflow 并启动 worker 子命令
 
 ```py
 airflow worker
 ```
 
-您的worker一旦启动就应该开始接收任务。
+您的 worker 一旦启动就应该开始接收任务。
 
-请注意，您还可以运行“Celery Flower”，这是一个建立在Celery之上的Web UI，用于监控您的worker。 您可以使用快捷命令`airflow flower`启动Flower Web服务器。
+请注意，您还可以运行“Celery Flower”，这是一个建立在 Celery 之上的 Web UI，用于监控您的 worker。 您可以使用快捷命令`airflow flower`启动 Flower Web 服务器。
 
 一些警告：
 
-* 确保使用数据库来作为result backend（Celery result_backend，celery的后台存储数据库）的后台存储
-* 确保在[celery_broker_transport_options]中设置超过最长运行任务的ETA的可见性超时
-* 任务会消耗资源，请确保您的worker有足够的资源来运行worker_concurrency任务
+* 确保使用数据库来作为 result backend（Celery result_backend，celery 的后台存储数据库）的后台存储
+* 确保在[celery_broker_transport_options]中设置超过最长运行任务的 ETA 的可见性超时
+* 任务会消耗资源，请确保您的 worker 有足够的资源来运行 worker_concurrency 任务

zh/14.md

-# 使用Dask扩展
+# 使用 Dask 扩展
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)、[@ThinkingChen](https://github.com/cdmikechen)
 
-`DaskExecutor`允许您在Dask分布式集群中运行Airflow任务。
+`DaskExecutor`允许您在 Dask 分布式集群中运行 Airflow 任务。
 
-Dask集群可以在单个机器上运行，也可以在远程网络上运行。有关完整详细信息，请参阅[分布式文档](https://distributed.readthedocs.io/) 。
+Dask 集群可以在单个机器上运行，也可以在远程网络上运行。有关完整详细信息，请参阅[分布式文档](https://distributed.readthedocs.io/) 。
 
-要创建集群，首先启动一个Scheduler：
+要创建集群，首先启动一个 Scheduler：
 
 ```py
 # 一个本地集群的默认设置
@@ -16,15 +16,15 @@ DASK_PORT=8786
 dask-scheduler --host $DASK_HOST --port $DASK_PORT
 ```
 
-接下来，在任何可以连接到主机的计算机上启动至少一个Worker：
+接下来，在任何可以连接到主机的计算机上启动至少一个 Worker：
 
 ```py
 dask-worker $DASK_HOST:$DASK_PORT
 ```
 
-编辑`airflow.cfg`以将执行程序设置为`DaskExecutor`并在`[dask]`部分中提供Dask Scheduler地址。
+编辑`airflow.cfg`以将执行程序设置为`DaskExecutor`并在`[dask]`部分中提供 Dask Scheduler 地址。
 
 请注意：
 
-* 每个Dask worker必须能够导入Airflow和您需要的任何依赖项。
-* Dask不支持队列。如果使用队列创建了Airflow任务，则会引发警告，但该任务会被提交给集群。
+* 每个 Dask worker 必须能够导入 Airflow 和您需要的任何依赖项。
+* Dask 不支持队列。如果使用队列创建了 Airflow 任务，则会引发警告，但该任务会被提交给集群。

zh/15.md

-# 使用Mesos扩展（社区贡献）
+# 使用 Mesos 扩展（社区贡献）
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)、[@ThinkingChen](https://github.com/cdmikechen)
 
-有两种方法可以将Airflow作为mesos框架运行：
+有两种方法可以将 Airflow 作为 mesos 框架运行：
 
-1. 想要直接在mesos slaves上运行Airflow任务，要求每个mesos slave安装和配置Airflow。
-2. 在安装了Airflow的docker容器内运行Airflow任务，该容器在mesos slave上运行。
+1. 想要直接在 mesos slaves 上运行 Airflow 任务，要求每个 mesos slave 安装和配置 Airflow。
+2. 在安装了 Airflow 的 docker 容器内运行 Airflow 任务，该容器在 mesos slave 上运行。
 
-## 任务直接在mesos slave上执行
+## 任务直接在 mesos slave 上执行
 
-`MesosExecutor`允许您在Mesos群集上调度Airflow任务。为此，您需要一个正在运行的mesos集群，并且必须执行以下步骤 -
+`MesosExecutor`允许您在 Mesos 群集上调度 Airflow 任务。为此，您需要一个正在运行的 mesos 集群，并且必须执行以下步骤 -
 
-1. 在可以运行web server和scheduler的mesos slave上安装Airflow，让我们将其称为“Airflow server”。
-2. 在 Airflow server 上，从[mesos下载](http://open.mesosphere.com/downloads/mesos/)安装mesos python eggs。
-3. 在 Airflow server 上，使用可以被所有mesos slave访问的数据库（例如mysql），并在`airflow.cfg`添加配置。
-4. 将您的`airflow.cfg`里 executor 的参数指定为*MesosExecutor*，并提供相关的Mesos设置。
-5. 在所有mesos slave上，安装Airflow。 从Airflow服务器复制`airflow.cfg` （以便它使用相同的sqlalchemy连接）。
-6. 在所有mesos slave上，运行以下服务日志：
+1. 在可以运行 web server 和 scheduler 的 mesos slave 上安装 Airflow，让我们将其称为“Airflow server”。
+2. 在 Airflow server 上，从[mesos 下载](http://open.mesosphere.com/downloads/mesos/)安装 mesos python eggs。
+3. 在 Airflow server 上，使用可以被所有 mesos slave 访问的数据库（例如 mysql），并在`airflow.cfg`添加配置。
+4. 将您的`airflow.cfg`里 executor 的参数指定为*MesosExecutor*，并提供相关的 Mesos 设置。
+5. 在所有 mesos slave 上，安装 Airflow。 从 Airflow 服务器复制`airflow.cfg` （以便它使用相同的 sqlalchemy 连接）。
+6. 在所有 mesos slave 上，运行以下服务日志：
 
 ```py
 airflow serve_logs
 ```
 
-7. 在 Airflow server 上，如果想要开始在mesos上处理/调度DAG，请运行：
+7. 在 Airflow server 上，如果想要开始在 mesos 上处理/调度 DAG，请运行：
 
 ```py
 airflow scheduler -p
 ```
 
-注意：我们需要-p参数来挑选DAG。
+注意：我们需要-p 参数来挑选 DAG。
 
-您现在可以在mesos UI中查看Airflow框架和相应的任务。Airflow任务的日志可以像往常一样在Airflow UI中查看。
+您现在可以在 mesos UI 中查看 Airflow 框架和相应的任务。Airflow 任务的日志可以像往常一样在 Airflow UI 中查看。
 
-有关mesos的更多信息，请参阅[mesos文档](http://mesos.apache.org/documentation/latest/)。 有关MesosExecutor的任何疑问/错误，请联系[@kapil-malik](https://github.com/kapil-malik)。
+有关 mesos 的更多信息，请参阅[mesos 文档](http://mesos.apache.org/documentation/latest/)。 有关 MesosExecutor 的任何疑问/错误，请联系[@kapil-malik](https://github.com/kapil-malik)。
 
-## 在mesos slave上的容器中执行的任务
+## 在 mesos slave 上的容器中执行的任务
 
-[此gist](https://gist.github.com/sebradloff/f158874e615bda0005c6f4577b20036e)包含实现以下所需的所有文件和配置更改：
+[此 gist](https://gist.github.com/sebradloff/f158874e615bda0005c6f4577b20036e)包含实现以下所需的所有文件和配置更改：
 
-1. 使用安装了mesos python eggs的软件环境创建一个dockerized版本的Airflow。
+1. 使用安装了 mesos python eggs 的软件环境创建一个 dockerized 版本的 Airflow。
 
-> 我们建议利用docker的多阶段构建来实现这一目标。我们有一个Dockerfile定义从源（Dockerfile-mesos）构建特定版本的mesos，以便创建python eggs。在Airflow Dockerfile（Dockerfile-airflow）中，我们从mesos镜像中复制python eggs。
+> 我们建议利用 docker 的多阶段构建来实现这一目标。我们有一个 Dockerfile 定义从源（Dockerfile-mesos）构建特定版本的 mesos，以便创建 python eggs。在 Airflow Dockerfile（Dockerfile-airflow）中，我们从 mesos 镜像中复制 python eggs。
 
-2. 在`airflow.cfg`创建一个mesos配置块。
+2. 在`airflow.cfg`创建一个 mesos 配置块。
 
-> 配置块保持与默认Airflow配置（default_airflow.cfg）相同，但添加了一个选项`docker_image_slave`。 这应该设置为您希望mesos在运行Airflow任务时使用的镜像的名称。确保您具有适用于您的mesos主服务器的DNS记录的正确配置以及任何类型的授权（如果存在）。
+> 配置块保持与默认 Airflow 配置（default_airflow.cfg）相同，但添加了一个选项`docker_image_slave`。 这应该设置为您希望 mesos 在运行 Airflow 任务时使用的镜像的名称。确保您具有适用于您的 mesos 主服务器的 DNS 记录的正确配置以及任何类型的授权（如果存在）。
 
-3. 更改`airflow.cfg`以将执行程序参数指向MesosExecutor（executor = SequentialExecutor）。
+3. 更改`airflow.cfg`以将执行程序参数指向 MesosExecutor（executor = SequentialExecutor）。
 
-4. 确保您的mesos slave可以访问您`docker_image_slave`的docker存储库。
+4. 确保您的 mesos slave 可以访问您`docker_image_slave`的 docker 存储库。
 
-> [mesos文档中提供了相关说明。](https://mesos.readthedocs.io/en/latest/docker-containerizer/)
+> [mesos 文档中提供了相关说明。](https://mesos.readthedocs.io/en/latest/docker-containerizer/)
 
-其余部分取决于您以及您希望如何使用dockerized Airflow配置。
+其余部分取决于您以及您希望如何使用 dockerized Airflow 配置。

zh/16.md

-# 使用systemd运行Airflow
+# 使用 systemd 运行 Airflow
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)、[@ThinkingChen](https://github.com/cdmikechen)
 
-Airflow可以与基于systemd的系统集成。这使得观察您的守护进程变得容易，因为systemd可以在失败时重新启动守护进程。在`scripts/systemd`目录中，您可以找到已在基于Redhat的系统上测试过的单元文件。您可以将它们复制到`/usr/lib/systemd/system`。这是基于假设Airflow将在`airflow:airflow`用户/组下运行。如果不是（或者如果您在非基于Redhat的系统上运行），则可能需要调整单元文件。
+Airflow 可以与基于 systemd 的系统集成。这使得观察您的守护进程变得容易，因为 systemd 可以在失败时重新启动守护进程。在`scripts/systemd`目录中，您可以找到已在基于 Redhat 的系统上测试过的单元文件。您可以将它们复制到`/usr/lib/systemd/system`。这是基于假设 Airflow 将在`airflow:airflow`用户/组下运行。如果不是（或者如果您在非基于 Redhat 的系统上运行），则可能需要调整单元文件。
 
 从`/etc/sysconfig/airflow`获取环境配置。提供了一个示例文件。 运行调度程序时，请确保在此文件中指定`SCHEDULER_RUNS`变量。您也可以在此处定义，例如`AIRFLOW_HOME`或`AIRFLOW_CONFIG`。

zh/17.md

-# 使用upstart运行Airflow
+# 使用 upstart 运行 Airflow
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)、[@ThinkingChen](https://github.com/cdmikechen)
 
-Airflow可以与基于upstart的系统集成。Upstart会在系统启动时自动启动在`/etc/init`具有相应`*.conf`文件的所有Airflow服务。失败时，upstart会自动重启进程（直到达到`*.conf`文件中设置的重启限制）。
+Airflow 可以与基于 upstart 的系统集成。Upstart 会在系统启动时自动启动在`/etc/init`具有相应`*.conf`文件的所有 Airflow 服务。失败时，upstart 会自动重启进程（直到达到`*.conf`文件中设置的重启限制）。
 
-您可以在`scripts/upstart`目录中找到示例upstart作业文件。这些文件已在Ubuntu 14.04 LTS上测试过。您可能需要调整`start on`和`stop on`设置，以使其适用于其他upstart系统。`scripts/upstart/README`中列出了一些可能的选项。
+您可以在`scripts/upstart`目录中找到示例 upstart 作业文件。这些文件已在 Ubuntu 14.04 LTS 上测试过。您可能需要调整`start on`和`stop on`设置，以使其适用于其他 upstart 系统。`scripts/upstart/README`中列出了一些可能的选项。
 
-您可以根据需要修改`*.conf`文件并将它们复制到`/etc/init`目录。这是基于假设Airflow将在`airflow:airflow`用户/组下运行的情况。如果您使用其他用户/组，请在`*.conf`文件中更改`setuid`和`setgid`。
+您可以根据需要修改`*.conf`文件并将它们复制到`/etc/init`目录。这是基于假设 Airflow 将在`airflow:airflow`用户/组下运行的情况。如果您使用其他用户/组，请在`*.conf`文件中更改`setuid`和`setgid`。
 
-您可以使用`initctl`手动启动，停止，查看已与upstart集成的Airflow过程的状态
+您可以使用`initctl`手动启动，停止，查看已与 upstart 集成的 Airflow 过程的状态
 
 ```py
 initctl airflow-webserver status

zh/18.md

@@ -2,11 +2,11 @@
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)、[@ThinkingChen](https://github.com/cdmikechen)
 
-Airflow具有一组固定的“test mode”配置选项。您可以随时通过调用`airflow.configuration.load_test_config()`来加载它们（注意此操作不可逆！）。但是，在您有机会调用load_test_config()之前，会加载一些选项（如DAG_FOLDER）。为了更快加载测试配置，请在airflow.cfg中设置test_mode：
+Airflow 具有一组固定的“test mode”配置选项。您可以随时通过调用`airflow.configuration.load_test_config()`来加载它们（注意此操作不可逆！）。但是，在您有机会调用 load_test_config()之前，会加载一些选项（如 DAG_FOLDER）。为了更快加载测试配置，请在 airflow.cfg 中设置 test_mode：
 
 ```py
 [tests]
 unit_test_mode = True
 ```
 
-由于Airflow的自动环境变量扩展（请参阅[设置配置选项](zh/7.md) ），您还可以设置环境变量`AIRFLOW__CORE__UNIT_TEST_MODE`以临时覆盖airflow.cfg。
+由于 Airflow 的自动环境变量扩展（请参阅[设置配置选项](zh/7.md) ），您还可以设置环境变量`AIRFLOW__CORE__UNIT_TEST_MODE`以临时覆盖 airflow.cfg。

zh/19.md

@@ -2,11 +2,11 @@
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)、[@ThinkingChen](https://github.com/cdmikechen)
 
-通过Airflow UI，您可以轻松监控data pipeline（管道）并对其进行故障排除。如下是一些特性的简单预览和一些您可以在Airflow的UI中找到的可视化效果。
+通过 Airflow UI，您可以轻松监控 data pipeline（管道）并对其进行故障排除。如下是一些特性的简单预览和一些您可以在 Airflow 的 UI 中找到的可视化效果。
 
-## DAGs查看
+## DAGs 查看
 
-您环境中的DAG列表，以及一系列进入常用页面的快捷方式。您可以一目了然地查看成功、失败及当前正在运行的任务数量。
+您环境中的 DAG 列表，以及一系列进入常用页面的快捷方式。您可以一目了然地查看成功、失败及当前正在运行的任务数量。
 
 * * *
 
@@ -16,7 +16,7 @@
 
 ## 树视图
 
-跨越时间的DAG的树表示。如果pipeline（管道）延迟了，您可以很快地看到哪里出现了错误的步骤并且辨别出堵塞的进程。
+跨越时间的 DAG 的树表示。如果 pipeline（管道）延迟了，您可以很快地看到哪里出现了错误的步骤并且辨别出堵塞的进程。
 
 * * *
 
@@ -26,7 +26,7 @@
 
 ## 图表视图
 
-图形视图可能是最全面的一种表现形式了。它可以可视化您的DAG依赖以及某个运行实例的当前状态。
+图形视图可能是最全面的一种表现形式了。它可以可视化您的 DAG 依赖以及某个运行实例的当前状态。
 
 * * *
 
@@ -46,7 +46,7 @@
 
 ## 甘特图
 
-甘特图可让您分析任务持续时间和重叠情况。您可以快速识别系统瓶颈和哪些特定DAG在运行中花费了大量的时间。
+甘特图可让您分析任务持续时间和重叠情况。您可以快速识别系统瓶颈和哪些特定 DAG 在运行中花费了大量的时间。
 
 * * *
 
@@ -56,7 +56,7 @@
 
 ## 任务持续时间
 
-过去N次运行的不同任务的持续时间。通过此视图，您可以查找异常值并快速了解DAG在多次运行中花费的时间。
+过去 N 次运行的不同任务的持续时间。通过此视图，您可以查找异常值并快速了解 DAG 在多次运行中花费的时间。
 
 * * *
 
@@ -66,7 +66,7 @@
 
 ## 代码视图
 
-透明就是一切。虽然您的pipeline（管道）代码在源代码管理中，但这是一种快速获取DAG代码并提供更多上下文的方法。
+透明就是一切。虽然您的 pipeline（管道）代码在源代码管理中，但这是一种快速获取 DAG 代码并提供更多上下文的方法。
 
 * * *
 

zh/21.md

@@ -2,19 +2,19 @@
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)
 
-使用数据生产效率的一部分是拥有正确的武器来分析您正在使用的数据。Airflow提供了一个简单的查询界面来编写SQL并快速获得结果，以及一个图表应用程序，可以让您可视化数据。
+使用数据生产效率的一部分是拥有正确的武器来分析您正在使用的数据。Airflow 提供了一个简单的查询界面来编写 SQL 并快速获得结果，以及一个图表应用程序，可以让您可视化数据。
 
 ## 临时查询
 
-adhoc查询UI允许与Airflow中注册的数据库连接进行简单的SQL交互。
+adhoc 查询 UI 允许与 Airflow 中注册的数据库连接进行简单的 SQL 交互。
 
 ![https://airflow.apache.org/_images/adhoc.png](../img/bfbf60f9689630d6aa1f46aeab1e6cf0.jpg)
 
 ## 图表
 
-基于flask-admin和highcharts构建的简单UI允许轻松构建数据可视化和图表。使用标签，SQL，图表类型填写表单，从环境的连接中选择源数据库，选择其他一些选项，然后保存以供以后使用。
+基于 flask-admin 和 highcharts 构建的简单 UI 允许轻松构建数据可视化和图表。使用标签，SQL，图表类型填写表单，从环境的连接中选择源数据库，选择其他一些选项，然后保存以供以后使用。
 
-在编写Airflow管道，参数化查询和直接在URL中修改参数时，您甚至可以使用相同的模板和宏。
+在编写 Airflow 管道，参数化查询和直接在 URL 中修改参数时，您甚至可以使用相同的模板和宏。
 
 这些图表是基本的，但它们很容易创建，修改和共享。
 

zh/23.md

@@ -2,12 +2,12 @@
 
 > 贡献者：[@Ray](https://github.com/echo-ray)
 
-Airflow调度程序监视所有任务和所有DAG，并触发已满足其依赖关系的任务实例。 在幕后，它监视并与其可能包含的所有DAG对象的文件夹保持同步，并定期（每分钟左右）检查活动任务以查看是否可以触发它们。
+Airflow 调度程序监视所有任务和所有 DAG，并触发已满足其依赖关系的任务实例。 在幕后，它监视并与其可能包含的所有 DAG 对象的文件夹保持同步，并定期（每分钟左右）检查活动任务以查看是否可以触发它们。
 
-Airflow调度程序旨在作为Airflow生产环境中的持久服务运行。 要开始，您需要做的就是执行`airflow scheduler` 。 它将使用`airflow.cfg`指定的配置。
+Airflow 调度程序旨在作为 Airflow 生产环境中的持久服务运行。 要开始，您需要做的就是执行`airflow scheduler` 。 它将使用`airflow.cfg`指定的配置。
 
-请注意，如果您在一天的`schedule_interval`上运行DAG，则会在`2016-01-01T23:59`之后不久触发标记为`2016-01-01`的运行。 换句话说，作业实例在其覆盖的时间段结束后启动。
-请注意，如果您运行一个`schedule_interval`为1天的的`DAG`，`run`标记为`2016-01-01`，那么它会在`2016-01-01T23:59`之后马上触发。换句话说，一旦设定的时间周期结束后，工作实例将立马开始。
+请注意，如果您在一天的`schedule_interval`上运行 DAG，则会在`2016-01-01T23:59`之后不久触发标记为`2016-01-01`的运行。 换句话说，作业实例在其覆盖的时间段结束后启动。
+请注意，如果您运行一个`schedule_interval`为 1 天的的`DAG`，`run`标记为`2016-01-01`，那么它会在`2016-01-01T23:59`之后马上触发。换句话说，一旦设定的时间周期结束后，工作实例将立马开始。
 
 **让我们重复一遍**调度`schedule_interval`在开始日期之后，在句点结束时运行您的作业一个`schedule_interval` 。
 
@@ -19,32 +19,32 @@ Airflow调度程序旨在作为Airflow生产环境中的持久服务运行。
 airflow scheduler
 ```
 
-## DAG运行
+## DAG 运行
 
-DAG Run是一个表示DAG实例化的对象。
+DAG Run 是一个表示 DAG 实例化的对象。
 
-每个DAG可能有也可能没有时间表，通知如何创建`DAG Runs` 。 `schedule_interval`被定义为DAG参数，并且优选地接收作为`str`的[cron表达式](https://en.wikipedia.org/wiki/Cron)或`datetime.timedelta`对象。 或者，您也可以使用其中一个cron“预设”：
+每个 DAG 可能有也可能没有时间表，通知如何创建`DAG Runs` 。 `schedule_interval`被定义为 DAG 参数，并且优选地接收作为`str`的[cron 表达式](https://en.wikipedia.org/wiki/Cron)或`datetime.timedelta`对象。 或者，您也可以使用其中一个 cron“预设”：
 
 <colgroup><col width="15%"><col width="69%"><col width="16%"></colgroup>
-| 预置 | 含义 | cron的 |
+| 预置 | 含义 | cron 的 |
 | --- | --- | --- |
-| `None` | 不要安排，专门用于“外部触发”的DAG |  |
+| `None` | 不要安排，专门用于“外部触发”的 DAG |  |
 | `@once` | 安排一次，只安排一次 |  |
 | `@hourly` | 在小时开始时每小时运行一次 | `0 * * * *` |
 | `@daily` | 午夜一天运行一次 | `0 0 * * *` |
 | `@weekly` | 周日早上每周午夜运行一次 | `0 0 * * 0` |
 | `@monthly` | 每个月的第一天午夜运行一次 | `0 0 1 * *` |
-| `@yearly` | 每年1月1日午夜运行一次 | `0 0 1 1 *` |
+| `@yearly` | 每年 1 月 1 日午夜运行一次 | `0 0 1 1 *` |
 
-您的DAG将针对每个计划进行实例化，同时为每个计划创建`DAG Run`条目。
+您的 DAG 将针对每个计划进行实例化，同时为每个计划创建`DAG Run`条目。
 
-DAG运行具有与它们相关联的状态（运行，失败，成功），并通知调度程序应该针对任务提交评估哪组调度。 如果没有DAG运行级别的元数据，Airflow调度程序将需要做更多的工作才能确定应该触发哪些任务并进行爬行。 在更改DAG的形状时，也可能会添加新任务，从而创建不需要的处理。
+DAG 运行具有与它们相关联的状态（运行，失败，成功），并通知调度程序应该针对任务提交评估哪组调度。 如果没有 DAG 运行级别的元数据，Airflow 调度程序将需要做更多的工作才能确定应该触发哪些任务并进行爬行。 在更改 DAG 的形状时，也可能会添加新任务，从而创建不需要的处理。
 
 ## 回填和追赶
 
-具有`start_date` （可能是`end_date` ）和`schedule_interval`的Airflow DAG定义了一系列间隔，调度程序将这些间隔转换为单独的Dag运行并执行。 Airflow的一个关键功能是这些DAG运行是原子的幂等项，默认情况下，调度程序将检查DAG的生命周期（从开始到结束/现在，一次一个间隔）并启动DAG运行对于尚未运行（或已被清除）的任何间隔。 这个概念叫做Catchup。
+具有`start_date` （可能是`end_date` ）和`schedule_interval`的 Airflow DAG 定义了一系列间隔，调度程序将这些间隔转换为单独的 Dag 运行并执行。 Airflow 的一个关键功能是这些 DAG 运行是原子的幂等项，默认情况下，调度程序将检查 DAG 的生命周期（从开始到结束/现在，一次一个间隔）并启动 DAG 运行对于尚未运行（或已被清除）的任何间隔。 这个概念叫做 Catchup。
 
-如果你的DAG被编写来处理它自己的追赶（IE不仅限于间隔，而是改为“现在”。），那么你将需要关闭追赶（在DAG本身上使用`dag.catchup = False` ）或者默认情况下在配置文件级别使用`catchup_by_default = False` 。 这样做，是指示调度程序仅为DAG间隔序列的最新实例创建DAG运行。
+如果你的 DAG 被编写来处理它自己的追赶（IE 不仅限于间隔，而是改为“现在”。），那么你将需要关闭追赶（在 DAG 本身上使用`dag.catchup = False` ）或者默认情况下在配置文件级别使用`catchup_by_default = False` 。 这样做，是指示调度程序仅为 DAG 间隔序列的最新实例创建 DAG 运行。
 
 ```py
 """
@@ -71,27 +71,27 @@ default_args = {
 dag = DAG('tutorial', catchup=False, default_args=default_args)
 ```
 
-在上面的示例中，如果调度程序守护程序在2016-01-02上午6点（或从命令行）拾取DAG，则将创建单个DAG运行，其`execution_date`为2016-01-01 ，下一个将在2016-01-03上午午夜后创建，执行日期为2016-01-02。
+在上面的示例中，如果调度程序守护程序在 2016-01-02 上午 6 点（或从命令行）拾取 DAG，则将创建单个 DAG 运行，其`execution_date`为 2016-01-01 ，下一个将在 2016-01-03 上午午夜后创建，执行日期为 2016-01-02。
 
-如果`dag.catchup`值为True，则调度程序将为2015-12-01和2016-01-02之间的每个完成时间间隔创建一个DAG Run（但不是2016-01-02中的一个，因为该时间间隔）尚未完成）并且调度程序将按顺序执行它们。 对于可以轻松拆分为句点的原子数据集，此行为非常有用。 如果您的DAG运行在内部执行回填，则关闭追赶是很好的。
+如果`dag.catchup`值为 True，则调度程序将为 2015-12-01 和 2016-01-02 之间的每个完成时间间隔创建一个 DAG Run（但不是 2016-01-02 中的一个，因为该时间间隔）尚未完成）并且调度程序将按顺序执行它们。 对于可以轻松拆分为句点的原子数据集，此行为非常有用。 如果您的 DAG 运行在内部执行回填，则关闭追赶是很好的。
 
 ## 外部触发器
 
-请注意，在运行`airflow trigger_dag`命令时，也可以通过CLI手动创建`DAG Runs` ，您可以在其中定义特定的`run_id` 。 在调度程序外部创建的`DAG Runs`与触发器的时间戳相关联，并将与预定的`DAG runs`一起显示在UI中。
+请注意，在运行`airflow trigger_dag`命令时，也可以通过 CLI 手动创建`DAG Runs` ，您可以在其中定义特定的`run_id` 。 在调度程序外部创建的`DAG Runs`与触发器的时间戳相关联，并将与预定的`DAG runs`一起显示在 UI 中。
 
-此外，您还可以使用Web UI手动触发`DAG Run` （选项卡“DAG” - &gt;列“链接” - &gt;按钮“触发器Dag”）。
+此外，您还可以使用 Web UI 手动触发`DAG Run` （选项卡“DAG” - &gt;列“链接” - &gt;按钮“触发器 Dag”）。
 
 ## 要牢记
 
-* 第一个`DAG Run`是基于DAG中任务的最小`start_date`创建的。
-* 后续`DAG Runs`由调度程序进程根据您的DAG的`schedule_interval`顺序创建。
+* 第一个`DAG Run`是基于 DAG 中任务的最小`start_date`创建的。
+* 后续`DAG Runs`由调度程序进程根据您的 DAG 的`schedule_interval`顺序创建。
 * 当清除一组任务的状态以期让它们重新运行时，重要的是要记住`DAG Run`的状态，因为它定义了调度程序是否应该查看该运行的触发任务。
 
 以下是一些可以**取消阻止任务的方法** ：
 
-* 在UI中，您可以从任务实例对话框中**清除** （如删除状态）各个任务实例，同时定义是否要包括过去/未来和上游/下游依赖项。 请注意，接下来会出现一个确认窗口，您可以看到要清除的设置。 您还可以清除与dag关联的所有任务实例。
-* CLI命令`airflow clear -h`在清除任务实例状态时有很多选项，包括指定日期范围，通过指定正则表达式定位task_ids，包含上游和下游亲属的标志，以及特定状态下的目标任务实例（ `failed`或`success` ）
-* 清除任务实例将不再删除任务实例记录。 相反，它更新max_tries并将当前任务实例状态设置为None。
-* 将任务实例标记为失败可以通过UI完成。 这可用于停止运行任务实例。
-* 将任务实例标记为成功可以通过UI完成。 这主要是为了修复漏报，或者例如在Airflow之外应用修复时。
-* `airflow backfill` CLI子命令具有`--mark_success`标志，允许选择DAG的子部分以及指定日期范围。
+* 在 UI 中，您可以从任务实例对话框中**清除** （如删除状态）各个任务实例，同时定义是否要包括过去/未来和上游/下游依赖项。 请注意，接下来会出现一个确认窗口，您可以看到要清除的设置。 您还可以清除与 dag 关联的所有任务实例。
+* CLI 命令`airflow clear -h`在清除任务实例状态时有很多选项，包括指定日期范围，通过指定正则表达式定位 task_ids，包含上游和下游亲属的标志，以及特定状态下的目标任务实例（ `failed`或`success` ）
+* 清除任务实例将不再删除任务实例记录。 相反，它更新 max_tries 并将当前任务实例状态设置为 None。
+* 将任务实例标记为失败可以通过 UI 完成。 这可用于停止运行任务实例。
+* 将任务实例标记为成功可以通过 UI 完成。 这主要是为了修复漏报，或者例如在 Airflow 之外应用修复时。
+* `airflow backfill` CLI 子命令具有`--mark_success`标志，允许选择 DAG 的子部分以及指定日期范围。

zh/24.md

@@ -2,13 +2,13 @@
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)
 
-Airflow内置了一个简单的插件管理器，可以通过简单地删除`$AIRFLOW_HOME/plugins`文件夹中的文件，将外部功能集成到其核心。
+Airflow 内置了一个简单的插件管理器，可以通过简单地删除`$AIRFLOW_HOME/plugins`文件夹中的文件，将外部功能集成到其核心。
 
-`plugins`文件夹中的python模块将被导入，**钩子**，**操作符**，**传感器**，**宏**，**执行器**和Web**视图**将集成到Airflow的主要集合中，并可供使用。
+`plugins`文件夹中的 python 模块将被导入，**钩子**，**操作符**，**传感器**，**宏**，**执行器**和 Web**视图**将集成到 Airflow 的主要集合中，并可供使用。
 
 ## 做什么的？
 
-Airflow提供了一个用于处理数据的通用工具箱。不同的组织有不同的堆栈和不同的需求。 使用Airflow插件可以让公司定制他们的Airflow安装以反映他们的生态系统。
+Airflow 提供了一个用于处理数据的通用工具箱。不同的组织有不同的堆栈和不同的需求。 使用 Airflow 插件可以让公司定制他们的 Airflow 安装以反映他们的生态系统。
 
 插件可以简便地用作编写，共享和激活新功能集。
 
@@ -16,26 +16,26 @@ Airflow提供了一个用于处理数据的通用工具箱。不同的组织有
 
 例子：
 
-* 一组用于解析Hive日志和公开Hive元数据（CPU/IO/阶段/倾斜/...）的工具
+* 一组用于解析 Hive 日志和公开 Hive 元数据（CPU/IO/阶段/倾斜/...）的工具
 * 异常检测框架，允许人们收集指标，设置阈值和警报
 * 审计工具，帮助了解谁访问了什么
-* 配置驱动的SLA监控工具，允许您设置受监控的表以及应该在何时着陆，提醒人员并公开停机的可视化
+* 配置驱动的 SLA 监控工具，允许您设置受监控的表以及应该在何时着陆，提醒人员并公开停机的可视化
 * ...
 
-## 为什么要建立在Airflow之上？
+## 为什么要建立在 Airflow 之上？
 
-Airflow有许多组件可以在构建应用程序时重用：
+Airflow 有许多组件可以在构建应用程序时重用：
 
-* 可用于呈现视图的Web服务器
+* 可用于呈现视图的 Web 服务器
 * 用于存储模型的元数据数据库
 * 访问您的数据库，以及如何连接到它们
-* 应用程序可以将工作负载推送到的一组Workers
-* 部署了Airflow，您可以专注于后面的工作
+* 应用程序可以将工作负载推送到的一组 Workers
+* 部署了 Airflow，您可以专注于后面的工作
 * 基本的图表功能，底层库和抽象
 
 ## 接口
 
-要创建插件，您需要派生`airflow.plugins_manager.AirflowPlugin`类并引用要插入Airflow的对象。以下是类似您需要派生的类：
+要创建插件，您需要派生`airflow.plugins_manager.AirflowPlugin`类并引用要插入 Airflow 的对象。以下是类似您需要派生的类：
 
 ```py
 class AirflowPlugin(object):
@@ -66,7 +66,7 @@ class AirflowPlugin(object):
 
 ## 示例
 
-下面的代码定义了一个插件，它在Airflow中注入一组虚拟对象定义。
+下面的代码定义了一个插件，它在 Airflow 中注入一组虚拟对象定义。
 
 ```py
 # This is the class you derive to create a plugin
@@ -155,4 +155,4 @@ class AirflowTestPlugin(AirflowPlugin):
 
 ## 注意基于角色的视图
 
-Airflow 1.10使用FlaskAppBuilder引入了基于角色的视图。您可以通过设置rbac = True来配置使用的UI。为了支持两个版本的UI的插件视图和链接以保持向后兼容性，请将字段appbuilder_views和appbuilder_menu_items添加到AirflowTestPlugin类中。
+Airflow 1.10 使用 FlaskAppBuilder 引入了基于角色的视图。您可以通过设置 rbac = True 来配置使用的 UI。为了支持两个版本的 UI 的插件视图和链接以保持向后兼容性，请将字段 appbuilder_views 和 appbuilder_menu_items 添加到 AirflowTestPlugin 类中。

zh/25.md

@@ -2,17 +2,17 @@
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)
 
-默认情况下，所有门都是打开的。限制对Web应用程序的访问的一种简单方法是在网络级别执行此操作，比如使用SSH隧道。
+默认情况下，所有门都是打开的。限制对 Web 应用程序的访问的一种简单方法是在网络级别执行此操作，比如使用 SSH 隧道。
 
 但也可以通过使用其中一个已提供的认证后端或创建自己的认证后端来打开身份验证。
 
-请务必查看[Experimental Rest API](zh/27.md)以保护API。
+请务必查看[Experimental Rest API](zh/27.md)以保护 API。
 
-## Web身份验证
+## Web 身份验证
 
 ### 密码
 
-最简单的身份验证机制之一是要求用户在登录前输入密码。密码身份验证需要在requirements文件中使用`password`子扩展包。它在存储密码之前使用了bcrypt扩展包来对密码进行哈希。
+最简单的身份验证机制之一是要求用户在登录前输入密码。密码身份验证需要在 requirements 文件中使用`password`子扩展包。它在存储密码之前使用了 bcrypt 扩展包来对密码进行哈希。
 
 ```
 [webserver]
@@ -20,7 +20,7 @@ authenticate = True
 auth_backend = airflow.contrib.auth.backends.password_auth
 ```
 
-启用密码身份验证后，需要先创建初始用户凭据，然后才能登录其他人。未在此身份验证后端的迁移中创建初始用户，以防止默认Airflow安装受到攻击。必须通过安装Airflow的同一台机器上的Python REPL来创建新用户。
+启用密码身份验证后，需要先创建初始用户凭据，然后才能登录其他人。未在此身份验证后端的迁移中创建初始用户，以防止默认 Airflow 安装受到攻击。必须通过安装 Airflow 的同一台机器上的 Python REPL 来创建新用户。
 
 ```py
 # navigate to the airflow installation directory
@@ -44,11 +44,11 @@ Type "help", "copyright", "credits" or "license" for more information.
 
 ### LDAP
 
-要打开LDAP身份验证，请按如下方式配置`airflow.cfg`。请注意，该示例使用与ldap服务器的加密连接，因为您可能不希望密码在网络级别上可读。 但是，如果您真的想要，可以在不加密的情况下进行配置。
+要打开 LDAP 身份验证，请按如下方式配置`airflow.cfg`。请注意，该示例使用与 ldap 服务器的加密连接，因为您可能不希望密码在网络级别上可读。 但是，如果您真的想要，可以在不加密的情况下进行配置。
 
-此外，如果您使用的是Active Directory，并且没有明确指定用户所在的OU，则需要将`search_scope`更改为“SUBTREE”。
+此外，如果您使用的是 Active Directory，并且没有明确指定用户所在的 OU，则需要将`search_scope`更改为“SUBTREE”。
 
-有效的search_scope选项可以在[ldap3文档中](https://ldap3.readthedocs.org/searches.html%3Fhighlight%3Dsearch_scope)找到
+有效的 search_scope 选项可以在[ldap3 文档中](https://ldap3.readthedocs.org/searches.html%3Fhighlight%3Dsearch_scope)找到
 
 ```
 [webserver]
@@ -77,11 +77,11 @@ cacert = /etc/ca/ldap_ca.crt
 search_scope = LEVEL
 ```
 
-superuser_filter和data_profiler_filter是可选的。如果已定义，则这些配置允许您指定用户必须属于的LDAP组，以便拥有超级用户（admin）和数据分析权限。如果未定义，则所有用户都将成为超级用户和拥有数据分析的权限。
+superuser_filter 和 data_profiler_filter 是可选的。如果已定义，则这些配置允许您指定用户必须属于的 LDAP 组，以便拥有超级用户（admin）和数据分析权限。如果未定义，则所有用户都将成为超级用户和拥有数据分析的权限。
 
 ### 创建自定义
 
-Airflow使用了`flask_login`扩展包并在`airflow.default_login`模块中公开了一组钩子。您可以更改内容并使其成为`PYTHONPATH`一部分，并将其配置为`airflow.cfg`的认证后端。
+Airflow 使用了`flask_login`扩展包并在`airflow.default_login`模块中公开了一组钩子。您可以更改内容并使其成为`PYTHONPATH`一部分，并将其配置为`airflow.cfg`的认证后端。
 
 ```
 [webserver]
@@ -91,7 +91,7 @@ auth_backend = mypackage.auth
 
 ## 多租户
 
-通过在配置中设置`webserver:filter_by_owner`，可以在启用身份验证时按所有者名称筛选`webserver:filter_by_owner`。有了这个，用户将只看到他所有者的dags，除非他是超级用户。
+通过在配置中设置`webserver:filter_by_owner`，可以在启用身份验证时按所有者名称筛选`webserver:filter_by_owner`。有了这个，用户将只看到他所有者的 dags，除非他是超级用户。
 
 ```
 [webserver]
@@ -100,19 +100,19 @@ filter_by_owner = True
 
 ## Kerberos
 
-Airflow天然支持Kerberos。这意味着Airflow可以为自己更新kerberos票证并将其存储在票证缓存中。钩子和dags可以使用票证来验证kerberized服务。
+Airflow 天然支持 Kerberos。这意味着 Airflow 可以为自己更新 kerberos 票证并将其存储在票证缓存中。钩子和 dags 可以使用票证来验证 kerberized 服务。
 
 ### 限制
 
-请注意，此时并未调整所有钩子以使用此功能。此外，它没有将kerberos集成到Web界面中，您现在必须依赖网络级安全性来确保您的服务保持安全。
+请注意，此时并未调整所有钩子以使用此功能。此外，它没有将 kerberos 集成到 Web 界面中，您现在必须依赖网络级安全性来确保您的服务保持安全。
 
-Celery集成尚未经过试用和测试。 但是，如果您为每个主机生成一个key tab，并在每个Worker旁边启动一个ticket renewer，那么它很可能会起作用。
+Celery 集成尚未经过试用和测试。 但是，如果您为每个主机生成一个 key tab，并在每个 Worker 旁边启动一个 ticket renewer，那么它很可能会起作用。
 
-### 启用kerberos
+### 启用 kerberos
 
 #### Airflow
 
-要启用kerberos，您需要生成（服务）key tab。
+要启用 kerberos，您需要生成（服务）key tab。
 
 ```py
 # in the kadmin.local or kadmin shell, create the airflow principal
@@ -122,7 +122,7 @@ kadmin:  addprinc -randkey airflow/fully.qualified.domain.name@YOUR-REALM.COM
 kadmin:  xst -norandkey -k airflow.keytab airflow/fully.qualified.domain.name
 ```
 
-现在将此文件存储在airflow用户可以读取的位置（chmod 600）。然后将以下内容添加到`airflow.cfg`
+现在将此文件存储在 airflow 用户可以读取的位置（chmod 600）。然后将以下内容添加到`airflow.cfg`
 
 ```
 [core]
@@ -135,7 +135,7 @@ principal = airflow
 
 ```
 
-启动ticket renewer
+启动 ticket renewer
 
 ```sh
 # run ticket renewer
@@ -144,7 +144,7 @@ airflow kerberos
 
 #### Hadoop
 
-如果要使用模拟，则需要在hadoop配置的`core-site.xml`中启用。
+如果要使用模拟，则需要在 hadoop 配置的`core-site.xml`中启用。
 
 ```
 <property>
@@ -166,41 +166,41 @@ airflow kerberos
 
 当然，如果您需要加强安全性，请用更合适的东西替换星号。
 
-### 使用kerberos身份验证
+### 使用 kerberos 身份验证
 
-已更新Hive钩子以利用kerberos身份验证。要允许DAG使用它，只需更新连接详细信息，例如：
+已更新 Hive 钩子以利用 kerberos 身份验证。要允许 DAG 使用它，只需更新连接详细信息，例如：
 
 ```
 {"use_beeline": true, "principal": "hive/_HOST@EXAMPLE.COM"}
 ```
 
-请根据您的设置进行调整。_HOST部分将替换为服务器的完全限定域名。
+请根据您的设置进行调整。_HOST 部分将替换为服务器的完全限定域名。
 
-您可以指定是否要将dag所有者用作连接的用户或连接的登录部分中指定的用户。对于登录用户，请将以下内容指定为额外：
+您可以指定是否要将 dag 所有者用作连接的用户或连接的登录部分中指定的用户。对于登录用户，请将以下内容指定为额外：
 ```
 {"use_beeline": true, "principal": "hive/_HOST@EXAMPLE.COM", "proxy_user": "login"}
 ```
 
-对于DAG所有者使用：
+对于 DAG 所有者使用：
 ```
 {"use_beeline": true, "principal": "hive/_HOST@EXAMPLE.COM", "proxy_user": "owner"}
 ```
 
-在DAG中，初始化HiveOperator时，请指定：
+在 DAG 中，初始化 HiveOperator 时，请指定：
 ```
 run_as_owner = True
 ```
 
-为了使用kerberos认证，请务必在安装Airflow时添加kerberos子扩展包：
+为了使用 kerberos 认证，请务必在安装 Airflow 时添加 kerberos 子扩展包：
 ```
 pip install airflow[kerberos]
 ```
 
-## OAuth认证
+## OAuth 认证
 
 ### GitHub Enterprise（GHE）认证
 
-GitHub Enterprise认证后端可用于对使用OAuth2安装GitHub Enterprise的用户进行身份认证。您可以选择指定团队白名单（由slug cased团队名称组成）以限制仅允许这些团队的成员登录。
+GitHub Enterprise 认证后端可用于对使用 OAuth2 安装 GitHub Enterprise 的用户进行身份认证。您可以选择指定团队白名单（由 slug cased 团队名称组成）以限制仅允许这些团队的成员登录。
 
 ```
 [webserver]
@@ -217,31 +217,31 @@ allowed_teams = 1, 345, 23
 
 注意
 
-如果您未指定团队白名单，那么在GHE安装中拥有有效帐户的任何人都可以登录Airflow。
+如果您未指定团队白名单，那么在 GHE 安装中拥有有效帐户的任何人都可以登录 Airflow。
 
-#### 设置GHE身份验证
+#### 设置 GHE 身份验证
 
-必须先在GHE中设置应用程序，然后才能使用GHE身份验证后端。 要设置应用程序：
+必须先在 GHE 中设置应用程序，然后才能使用 GHE 身份验证后端。 要设置应用程序：
 
-1. 导航到您的GHE配置文件
+1. 导航到您的 GHE 配置文件
 2. 从左侧导航栏中选择“应用程序”
 3. 选择“开发者应用程序”选项卡
 4. 点击“注册新申请”
-5. 填写所需信息（“授权回调URL”必须完全合格，例如[http://airflow.example.com/example/ghe_oauth/callback](http://airflow.example.com/example/ghe_oauth/callback) ）
+5. 填写所需信息（“授权回调 URL”必须完全合格，例如[http://airflow.example.com/example/ghe_oauth/callback](http://airflow.example.com/example/ghe_oauth/callback) ）
 6. 点击“注册申请”
-7. 根据上面的示例，将“客户端ID”，“客户端密钥”和回调路由复制到airflow.cfg
+7. 根据上面的示例，将“客户端 ID”，“客户端密钥”和回调路由复制到 airflow.cfg
 
-#### 在github.com上使用GHE身份验证
+#### 在 github.com 上使用 GHE 身份验证
 
-可以在github.com上使用GHE身份验证：
+可以在 github.com 上使用 GHE 身份验证：
 
-1. [创建一个Oauth应用程序](https://developer.github.com/apps/building-oauth-apps/creating-an-oauth-app/)
-2. 根据上面的示例，将“客户端ID”，“客户端密钥”复制到airflow.cfg
-3. 在airflow.cfg设置`host = github.com`和`oauth_callback_route = /oauth/callback`
+1. [创建一个 Oauth 应用程序](https://developer.github.com/apps/building-oauth-apps/creating-an-oauth-app/)
+2. 根据上面的示例，将“客户端 ID”，“客户端密钥”复制到 airflow.cfg
+3. 在 airflow.cfg 设置`host = github.com`和`oauth_callback_route = /oauth/callback`
 
-### Google身份验证
+### Google 身份验证
 
-Google身份验证后端可用于使用OAuth2对Google用户进行身份验证。您必须指定电子邮件域以限制登录（以逗号分隔），仅限于这些域的成员。
+Google 身份验证后端可用于使用 OAuth2 对 Google 用户进行身份验证。您必须指定电子邮件域以限制登录（以逗号分隔），仅限于这些域的成员。
 
 ```
 [webserver]
@@ -255,21 +255,21 @@ oauth_callback_route = /oauth2callback
 domain = "example1.com,example2.com"
 ```
 
-#### 设置Google身份验证
+#### 设置 Google 身份验证
 
-必须先在Google API控制台中设置应用程序，然后才能使用Google身份验证后端。 要设置应用程序：
+必须先在 Google API 控制台中设置应用程序，然后才能使用 Google 身份验证后端。 要设置应用程序：
 
 1. 导航到[https://console.developers.google.com/apis/](https://console.developers.google.com/apis/)
 2. 从左侧导航栏中选择“凭据”
-3. 点击“创建凭据”，然后选择“OAuth客户端ID”
-4. 选择“Web应用程序”
-5. 填写所需信息（'授权重定向URI'必须完全合格，例如[http://airflow.example.com/oauth2callback](http://airflow.example.com/oauth2callback) ）
+3. 点击“创建凭据”，然后选择“OAuth 客户端 ID”
+4. 选择“Web 应用程序”
+5. 填写所需信息（'授权重定向 URI'必须完全合格，例如[http://airflow.example.com/oauth2callback](http://airflow.example.com/oauth2callback) ）
 6. 点击“创建”
-7. 根据上面的示例，将“客户端ID”，“客户端密钥”和重定向URI复制到airflow.cfg
+7. 根据上面的示例，将“客户端 ID”，“客户端密钥”和重定向 URI 复制到 airflow.cfg
 
 ## SSL
 
-可以通过提供证书和密钥来启用SSL。启用后，请务必在浏览器中使用“[https//](https:)”。
+可以通过提供证书和密钥来启用 SSL。启用后，请务必在浏览器中使用“[https//](https:)”。
 
 ```
 [webserver]
@@ -277,7 +277,7 @@ web_server_ssl_cert = <path to cert>
 web_server_ssl_key = <path to key>
 ```
 
-启用S​​SL不会自动更改Web服务器端口。如果要使用标准端口443，则还需要配置它。请注意，侦听端口443需要超级用户权限（或Linux上的cap_net_bind_service）。
+启用 S​​SL 不会自动更改 Web 服务器端口。如果要使用标准端口 443，则还需要配置它。请注意，侦听端口 443 需要超级用户权限（或 Linux 上的 cap_net_bind_service）。
 
 ```py
 # Optionally, set the server to listen on the standard SSL port.
@@ -285,7 +285,7 @@ web_server_port = 443
 base_url = http://<hostname or IP>:443
 ```
 
-使用SSL启用CeleryExecutor。 确保正确生成客户端和服务器证书和密钥。
+使用 SSL 启用 CeleryExecutor。 确保正确生成客户端和服务器证书和密钥。
 
 ```
 [celery]
@@ -297,16 +297,16 @@ CELERY_SSL_CACERT = <path to cacert>
 
 ## 模拟
 
-Airflow能够在运行任务实例时模拟unix用户，该任务实例基于任务的`run_as_user`参数，该参数采用用户的名称。
+Airflow 能够在运行任务实例时模拟 unix 用户，该任务实例基于任务的`run_as_user`参数，该参数采用用户的名称。
 
 **注意：**
-要模拟工作，必须使用`sudo`运行Airflow，因为使用`sudo -u`运行子任务并更改文件的权限。此外，unix用户需要存在于worker中。假设airflow是`airflow`用户运行，一个简单的sudoers文件可能看起来像这样。请注意，这意味着必须以与root用户相同的方式信任和处理airflow用户。
+要模拟工作，必须使用`sudo`运行 Airflow，因为使用`sudo -u`运行子任务并更改文件的权限。此外，unix 用户需要存在于 worker 中。假设 airflow 是`airflow`用户运行，一个简单的 sudoers 文件可能看起来像这样。请注意，这意味着必须以与 root 用户相同的方式信任和处理 airflow 用户。
 
 ```
 airflow ALL=(ALL) NOPASSWD: ALL
 ```
 
-带模拟的子任务仍将记录到同一文件夹，但他们登录的文件将更改权限，只有unix用户才能写入。
+带模拟的子任务仍将记录到同一文件夹，但他们登录的文件将更改权限，只有 unix 用户才能写入。
 
 ### 默认模拟
 
@@ -317,11 +317,11 @@ airflow ALL=(ALL) NOPASSWD: ALL
 default_impersonation = airflow
 ```
 
-## Flower认证
+## Flower 认证
 
-Celery Flower的基础认证是支持的。
+Celery Flower 的基础认证是支持的。
 
-可以在Flower进程启动命令中指定可选参数，或者在`airflow.cfg`指定配置项。对于这两种情况，请提供用逗号分隔的user:password对。
+可以在 Flower 进程启动命令中指定可选参数，或者在`airflow.cfg`指定配置项。对于这两种情况，请提供用逗号分隔的 user:password 对。
 
 ```sh
 airflow flower --basic_auth=user1:password1,user2:password2

zh/26.md

@@ -2,7 +2,7 @@
 
 > 贡献者：[@morefreeze](https://github.com/morefreeze)
 
-默认情况下启用对时区的支持。 Airflow 在内部处理和数据库中以 UTC 格式存储日期时间信息。 这样您就可以在调度中执行带有时区的 DAG。 目前，Airflow 不支持在 Web UI 中显示最终用户时区，它始终以UTC显示。 此外，`Operator`中使用的模板也不会被转换。 时区信息取决于 DAG 作者如何使用它。
+默认情况下启用对时区的支持。 Airflow 在内部处理和数据库中以 UTC 格式存储日期时间信息。 这样您就可以在调度中执行带有时区的 DAG。 目前，Airflow 不支持在 Web UI 中显示最终用户时区，它始终以 UTC 显示。 此外，`Operator`中使用的模板也不会被转换。 时区信息取决于 DAG 作者如何使用它。
 
 如果您的用户居住在多个时区，并且您希望根据每个用户的挂钟(wall clock)显示日期时间信息，这将非常方便。
 
@@ -31,7 +31,7 @@ a_date = timezone.datetime(2017,1,1)
 
 ### 理解原生 datetime 对象
 
-尽管 Airflow 现在是时区敏感的，但为了向后兼容，它仍然允许在 DAG 定义中使用原生 datetime 为`start_dates`和`end_dates`赋值。 如果遇到使用原生 datetime 的`start_date`或`end_date`则使用默认时区。 换句话说，如果您设置了默认时区为`Europe/Amsterdam`，那么对于`start_date = datetime(2017,1,1)`，则认定它是2017年1月1日的 Amesterdam 时间。
+尽管 Airflow 现在是时区敏感的，但为了向后兼容，它仍然允许在 DAG 定义中使用原生 datetime 为`start_dates`和`end_dates`赋值。 如果遇到使用原生 datetime 的`start_date`或`end_date`则使用默认时区。 换句话说，如果您设置了默认时区为`Europe/Amsterdam`，那么对于`start_date = datetime(2017,1,1)`，则认定它是 2017 年 1 月 1 日的 Amesterdam 时间。
 
 ```py
  default_args = dict(
@@ -51,7 +51,7 @@ print(op.owner) # Airflow
 
 ### 默认时区
 
-默认时区是在`airflow.cfg`中的`[core]`下的`default_timezone`定义的。 如果您刚刚安装了Airflow，它推荐您设置为 utc。 您还可以将其设置为系统或 IANA 时区（例如`Europe/Amsterdam`）。 DAG 也会在 worker 上进行计算，因此确保所有 worker 节点上的此设置相同。
+默认时区是在`airflow.cfg`中的`[core]`下的`default_timezone`定义的。 如果您刚刚安装了 Airflow，它推荐您设置为 utc。 您还可以将其设置为系统或 IANA 时区（例如`Europe/Amsterdam`）。 DAG 也会在 worker 上进行计算，因此确保所有 worker 节点上的此设置相同。
 
 ```py
 [core]
@@ -90,7 +90,7 @@ local_tz.convert(execution_date)
 
 ### Cron 安排
 
-如果您设置了 crontab，Airflow 会假定您始终希望在同一时间运行。 然后它将忽略 DST。 比如，您有一个调度要在每天格林威治标准时间 +1 的 08:00运行，它将始终在这个时间运行，**无论 DST 是否发生**。
+如果您设置了 crontab，Airflow 会假定您始终希望在同一时间运行。 然后它将忽略 DST。 比如，您有一个调度要在每天格林威治标准时间 +1 的 08:00 运行，它将始终在这个时间运行，**无论 DST 是否发生**。
 
 ### 时间增量调度
 

zh/27.md

@@ -2,18 +2,18 @@
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)
 
-Airflow公开了一个实验性的Rest API。它可以通过Web服务器获得来请求。 API端点以/api/experimental/开头，同时请注意，我们也希望端点定义发生变化。
+Airflow 公开了一个实验性的 Rest API。它可以通过 Web 服务器获得来请求。 API 端点以/api/experimental/开头，同时请注意，我们也希望端点定义发生变化。
 
 ## 端点
 
-这是占位符，直到swagger定义处于活动状态
+这是占位符，直到 swagger 定义处于活动状态
 
 * /api/experimental/dags/<DAG_ID>/tasks/<TASK_ID> 返回任务信息（GET）。
-* /api/experimental/dags/<DAG_ID>/dag_runs 为给定的dag id创建一个dag_run（POST）。
+* /api/experimental/dags/<DAG_ID>/dag_runs 为给定的 dag id 创建一个 dag_run（POST）。
 
 ## CLI
 
-对于某些功能，cli可以使用API​​。 要配置CLI选项使得在可用时能够使用API​​，请按如下方式配置：
+对于某些功能，cli 可以使用 API​​。 要配置 CLI 选项使得在可用时能够使用 API​​，请按如下方式配置：
 
 ```py
 [cli]
@@ -23,13 +23,13 @@ endpoint_url = http://<WEBSERVER>:<PORT>
 
 ## 认证
 
-API的身份验证与Web身份验证分开处理。 默认情况下，不需要对API进行任何身份验证 - 即默认情况下全开。 如果您的Airflow网络服务器可公开访问，那么不建议这样做，您应该使用拒绝所有后端请求：
+API 的身份验证与 Web 身份验证分开处理。 默认情况下，不需要对 API 进行任何身份验证 - 即默认情况下全开。 如果您的 Airflow 网络服务器可公开访问，那么不建议这样做，您应该使用拒绝所有后端请求：
 ```py
 [api]
 auth_backend = airflow.api.auth.backend.deny_all
 ```
 
-API目前支持两种“真实”的身份验证方法。
+API 目前支持两种“真实”的身份验证方法。
 
 要启用密码身份验证，请在配置中进行以下设置：
 ```py
@@ -37,9 +37,9 @@ API目前支持两种“真实”的身份验证方法。
 auth_backend = airflow.contrib.auth.backends.password_auth
 ```
 
-它的用法类似于用于Web界面的密码验证。
+它的用法类似于用于 Web 界面的密码验证。
 
-要启用Kerberos身份验证，请在配置中设置以下内容：
+要启用 Kerberos 身份验证，请在配置中设置以下内容：
 ```py
 [api]
 auth_backend = airflow.api.auth.backend.kerberos_auth
@@ -48,4 +48,4 @@ auth_backend = airflow.api.auth.backend.kerberos_auth
 keytab = <KEYTAB>
 ```
 
-Kerberos服务配置为`airflow/fully.qualified.domainname@REALM`。确保密钥表文件中存在此配置。
+Kerberos 服务配置为`airflow/fully.qualified.domainname@REALM`。确保密钥表文件中存在此配置。

zh/29.md

@@ -51,7 +51,7 @@ run_this.set_downstream(run_this_last)
 > 注意：
 > 只要 Operator 支持，它会自动地加上 inlets 和 outlets。
 
-在示例DAG任务中， `run_me_first`是一个 BashOperator，它接收`CAT1`, `CAT2`, `CAT3`作为 inlets（译注：根据代码，应为“输出 outlets”）。 其中的`execution_date`会在任务运行时被渲染成执行时间。
+在示例 DAG 任务中， `run_me_first`是一个 BashOperator，它接收`CAT1`, `CAT2`, `CAT3`作为 inlets（译注：根据代码，应为“输出 outlets”）。 其中的`execution_date`会在任务运行时被渲染成执行时间。
 
 > 注意：
 > 在底层，Airflow 会在`pre_execute`方法中准备 lineage 元数据。 当任务运行结束时，会调用`post_execute`将 lineage 元数据推送到 XCOM 中。 因此，如果您要创建自己的 Operator，并且需要覆写这些方法，确保分别用`prepare_lineage`和`apply_lineage`装饰这些方法。

zh/3.md

@@ -5,31 +5,31 @@
 安装是快速而直接的。
 
 ```bash
-# airflow需要home目录，默认是~/airflow，
+# airflow 需要 home 目录，默认是~/airflow，
 # 但是如果你需要，放在其它位置也是可以的
 # (可选)
 export AIRFLOW_HOME = ~/airflow
 
-# 使用pip从pypi安装
+# 使用 pip 从 pypi 安装
 pip install apache-airflow
 
 # 初始化数据库
 airflow initdb
 
-# 启动web服务器，默认端口是8080
+# 启动 web 服务器，默认端口是 8080
 airflow webserver -p 8080
 
 # 启动定时器
 airflow scheduler
 
-# 在浏览器中浏览localhost:8080，并在home页开启example dag
+# 在浏览器中浏览 localhost:8080，并在 home 页开启 example dag
 ```
 
-运行这些命令后，Airflow将创建`$AIRFLOW_HOME`文件夹，并放置一个`airflow.cfg`文件，其默认值可以让您快速上手。您可以通过查看`$AIRFLOW_HOME/airflow.cfg`文件或者在UI的`Admin->Configuration`菜单中检查相关配置。如果由systemd启动，则webserver的PID文件将存储在`$AIRFLOW_HOME/airflow-webserver.pid`或`/run/airflow/webserver.pid`。
+运行这些命令后，Airflow 将创建`$AIRFLOW_HOME`文件夹，并放置一个`airflow.cfg`文件，其默认值可以让您快速上手。您可以通过查看`$AIRFLOW_HOME/airflow.cfg`文件或者在 UI 的`Admin->Configuration`菜单中检查相关配置。如果由 systemd 启动，则 webserver 的 PID 文件将存储在`$AIRFLOW_HOME/airflow-webserver.pid`或`/run/airflow/webserver.pid`。
 
-开箱即用，Airflow使用sqlite数据库，由于使用此数据库后端无法进行并行化，因此您应该迅速替换它。它与`SequentialExecutor`一起使用，但仅能按顺序运行任务实例。虽然这是非常有限的，但它允许您快速启动和运行并浏览UI和命令行实用程序。
+开箱即用，Airflow 使用 sqlite 数据库，由于使用此数据库后端无法进行并行化，因此您应该迅速替换它。它与`SequentialExecutor`一起使用，但仅能按顺序运行任务实例。虽然这是非常有限的，但它允许您快速启动和运行并浏览 UI 和命令行实用程序。
 
-以下是一些将触发一些任务实例的命令。在运行以下命令时，您应该能够在`example_bash_operator`DAG中看到任务的状态发生变化。
+以下是一些将触发一些任务实例的命令。在运行以下命令时，您应该能够在`example_bash_operator`DAG 中看到任务的状态发生变化。
 
 ```py
 # 运行第一个任务实例

zh/30.md

@@ -4,15 +4,15 @@
 
 您的任务可能无法安排的原因有很多。 以下是一些常见原因：
 
-*   您的脚本是否“编译”，Airflow引擎是否可以解析它并找到您的DAG对象。 要对此进行测试，您可以运行`airflow list_dags`并确认您的DAG显示在列表中。 您还可以运行`airflow list_tasks foo_dag_id --tree`并确认您的任务按预期显示在列表中。 如果您使用CeleryExecutor，您可能需要确认这既适用于调度程序运行的位置，也适用于工作程序运行的位置。
-*   包含DAG的文件是否在内容的某处包含字符串“airflow”和“DAG”？ 在搜索DAG目录时，Airflow忽略不包含“airflow”和“DAG”的文件，以防止DagBag解析导入与用户的DAG并置的所有python文件。
-*   你的`start_date`设置正确吗？ 在传递`start_date + scheduler_interval`之后，Airflow调度程序会立即触发任务。
-*   您的`schedule_interval`设置正确吗？ 默认`schedule_interval`是一天（ `datetime.timedelta(1)` ）。 您必须直接为实例化的DAG对象指定不同的`schedule_interval` ，而不是`default_param` ，因为任务实例不会覆盖其父DAG的`schedule_interval` 。
-*   您的`start_date`超出了在UI中可以看到的位置吗？ 如果将`start_date`设置为3个月之前的某个时间，您将无法在UI的主视图中看到它，但您应该能够在`Menu -> Browse ->Task Instances`看到它。
+*   您的脚本是否“编译”，Airflow 引擎是否可以解析它并找到您的 DAG 对象。 要对此进行测试，您可以运行`airflow list_dags`并确认您的 DAG 显示在列表中。 您还可以运行`airflow list_tasks foo_dag_id --tree`并确认您的任务按预期显示在列表中。 如果您使用 CeleryExecutor，您可能需要确认这既适用于调度程序运行的位置，也适用于工作程序运行的位置。
+*   包含 DAG 的文件是否在内容的某处包含字符串“airflow”和“DAG”？ 在搜索 DAG 目录时，Airflow 忽略不包含“airflow”和“DAG”的文件，以防止 DagBag 解析导入与用户的 DAG 并置的所有 python 文件。
+*   你的`start_date`设置正确吗？ 在传递`start_date + scheduler_interval`之后，Airflow 调度程序会立即触发任务。
+*   您的`schedule_interval`设置正确吗？ 默认`schedule_interval`是一天（ `datetime.timedelta(1)` ）。 您必须直接为实例化的 DAG 对象指定不同的`schedule_interval` ，而不是`default_param` ，因为任务实例不会覆盖其父 DAG 的`schedule_interval` 。
+*   您的`start_date`超出了在 UI 中可以看到的位置吗？ 如果将`start_date`设置为 3 个月之前的某个时间，您将无法在 UI 的主视图中看到它，但您应该能够在`Menu -> Browse ->Task Instances`看到它。
 *   是否满足任务的依赖性。 直接位于任务上游的任务实例需要处于`success`状态。 此外，如果已设置`depends_on_past=True` ，则上一个任务实例需要成功（除非它是该任务的第一次运行）。 此外，如果`wait_for_downstream=True` ，请确保您了解其含义。 您可以从`Task Instance Details`页面查看如何设置这些属性。
-*   您需要创建并激活DagRuns吗？ DagRun表示整个DAG的特定执行，并具有状态（运行，成功，失败，......）。 调度程序在向前移动时创建新的DagRun，但永远不会及时创建新的DagRun。 调度程序仅评估`running` DagRuns以查看它可以触发的任务实例。 请注意，清除任务实例（从UI或CLI）确实将DagRun的状态设置为恢复运行。 您可以通过单击DAG的计划标记来批量查看DagRuns列表并更改状态。
-*   是否达到了DAG的`concurrency`参数？ `concurrency`定义了允许DAG `running`任务实例的数量，超过这一点，事物就会排队。
-*   是否达到了DAG的`max_active_runs`参数？ `max_active_runs`定义允许的DAG `running`并发实例的数量。
+*   您需要创建并激活 DagRuns 吗？ DagRun 表示整个 DAG 的特定执行，并具有状态（运行，成功，失败，......）。 调度程序在向前移动时创建新的 DagRun，但永远不会及时创建新的 DagRun。 调度程序仅评估`running` DagRuns 以查看它可以触发的任务实例。 请注意，清除任务实例（从 UI 或 CLI）确实将 DagRun 的状态设置为恢复运行。 您可以通过单击 DAG 的计划标记来批量查看 DagRuns 列表并更改状态。
+*   是否达到了 DAG 的`concurrency`参数？ `concurrency`定义了允许 DAG `running`任务实例的数量，超过这一点，事物就会排队。
+*   是否达到了 DAG 的`max_active_runs`参数？ `max_active_runs`定义允许的 DAG `running`并发实例的数量。
 
 您可能还想阅读文档的“计划程序”部分，并确保完全了解其进度。
 
@@ -20,27 +20,27 @@
 
 查看文档“概念`Trigger Rule`部分中的“ `Trigger Rule`部分
 
-## 安装airflow [crypto]后，为什么连接密码仍未在元数据db中加密？
+## 安装 airflow [crypto]后，为什么连接密码仍未在元数据 db 中加密？
 
 查看文档“配置”部分中的“ `Connections`部分
 
 ## 与`start_date`什么关系？
 
-`start_date`是前DagRun时代的部分遗产，但它在很多方面仍然具有相关性。 创建新DAG时，您可能希望使用`default_args`为任务设置全局`start_date` 。 要创建的第一个DagRun将基于所有任务的`min(start_date)` 。 从那时起，调度程序根据您的schedule_interval创建新的DagRuns，并在满足您的依赖项时运行相应的任务实例。 在向DAG引入新任务时，您需要特别注意`start_date` ，并且可能希望重新激活非活动DagRuns以正确启用新任务。
+`start_date`是前 DagRun 时代的部分遗产，但它在很多方面仍然具有相关性。 创建新 DAG 时，您可能希望使用`default_args`为任务设置全局`start_date` 。 要创建的第一个 DagRun 将基于所有任务的`min(start_date)` 。 从那时起，调度程序根据您的 schedule_interval 创建新的 DagRuns，并在满足您的依赖项时运行相应的任务实例。 在向 DAG 引入新任务时，您需要特别注意`start_date` ，并且可能希望重新激活非活动 DagRuns 以正确启用新任务。
 
-我们建议不要使用动态值作为`start_date` ，尤其是`datetime.now()`因为它可能非常混乱。 一旦周期结束，任务就会被触发，理论上， `@hourly` DAG永远不会达到一小时后，因为`now()`会移动。
+我们建议不要使用动态值作为`start_date` ，尤其是`datetime.now()`因为它可能非常混乱。 一旦周期结束，任务就会被触发，理论上， `@hourly` DAG 永远不会达到一小时后，因为`now()`会移动。
 
-以前我们还建议使用与`schedule_interval`相关的舍入`start_date` 。 这意味着`@hourly`将在`00:00`分钟：秒，午夜的`@monthly`工作，在这个月的第一个月的`@monthly`工作。 这不再是必需的。 现在，Airflow将自动对齐`start_date`和`schedule_interval` ，方法是使用`start_date`作为开始查看的时刻。
+以前我们还建议使用与`schedule_interval`相关的舍入`start_date` 。 这意味着`@hourly`将在`00:00`分钟：秒，午夜的`@monthly`工作，在这个月的第一个月的`@monthly`工作。 这不再是必需的。 现在，Airflow 将自动对齐`start_date`和`schedule_interval` ，方法是使用`start_date`作为开始查看的时刻。
 
-您可以使用任何传感器或`TimeDeltaSensor`来延迟计划间隔内的任务执行。 虽然`schedule_interval`允许指定`datetime.timedelta`对象，但我们建议使用宏或cron表达式，因为它强制执行舍入计划的这种想法。
+您可以使用任何传感器或`TimeDeltaSensor`来延迟计划间隔内的任务执行。 虽然`schedule_interval`允许指定`datetime.timedelta`对象，但我们建议使用宏或 cron 表达式，因为它强制执行舍入计划的这种想法。
 
-使用`depends_on_past=True`时，必须特别注意`start_date`因为过去的依赖关系不会仅针对为任务指定的`start_date`的特定计划强制执行。 除非您计划为新任务运行回填，否则在引入新的`depends_on_past=True`时及时观察DagRun活动状态也很重要。
+使用`depends_on_past=True`时，必须特别注意`start_date`因为过去的依赖关系不会仅针对为任务指定的`start_date`的特定计划强制执行。 除非您计划为新任务运行回填，否则在引入新的`depends_on_past=True`时及时观察 DagRun 活动状态也很重要。
 
-另外需要注意的是，在回填CLI命令的上下文中，任务`start_date`会被回填命令`start_date`覆盖。 这允许对具有`depends_on_past=True`任务实际启动的回填，如果不是这样，则回填就不会启动。
+另外需要注意的是，在回填 CLI 命令的上下文中，任务`start_date`会被回填命令`start_date`覆盖。 这允许对具有`depends_on_past=True`任务实际启动的回填，如果不是这样，则回填就不会启动。
 
-## 如何动态创建DAG？
+## 如何动态创建 DAG？
 
-Airflow在`DAGS_FOLDER`查找其全局命名空间中包含`DAG`对象的模块，并在`DagBag`添加它找到的对象。 知道这一切我们需要的是一种在全局命名空间中动态分配变量的方法，这可以在python中使用`globals()`函数轻松完成，标准库的行为就像一个简单的字典。
+Airflow 在`DAGS_FOLDER`查找其全局命名空间中包含`DAG`对象的模块，并在`DagBag`添加它找到的对象。 知道这一切我们需要的是一种在全局命名空间中动态分配变量的方法，这可以在 python 中使用`globals()`函数轻松完成，标准库的行为就像一个简单的字典。
 
 ```py
  for i in range ( 10 ):
@@ -54,30 +54,30 @@ Airflow在`DAGS_FOLDER`查找其全局命名空间中包含`DAG`对象的模块
 
 `airflow run`命令有很多层，这意味着它可以调用自身。
 
-*   基本`airflow run` ：启动执行程序，并告诉它运行`airflow run --local`命令。 如果使用Celery，这意味着它会在队列中放置一个命令，使其在worker上运行远程。 如果使用LocalExecutor，则转换为在子进程池中运行它。
+*   基本`airflow run` ：启动执行程序，并告诉它运行`airflow run --local`命令。 如果使用 Celery，这意味着它会在队列中放置一个命令，使其在 worker 上运行远程。 如果使用 LocalExecutor，则转换为在子进程池中运行它。
 *   本地`airflow run --local` ：启动`airflow run --raw`命令（如下所述）作为子`airflow run --raw` ，负责发出心跳，监听外部`airflow run --raw`信号，并确保在子进程失败时进行一些清理
 *   原始`airflow run --raw`运行实际操作员的执行方法并执行实际工作
 
-## 我的气流dag如何运行得更快？
+## 我的气流 dag 如何运行得更快？
 
-我们可以控制三个变量来改善气流dag性能：
+我们可以控制三个变量来改善气流 dag 性能：
 
 *   `parallelism` ：此变量控制气流工作者可以同时运行的任务实例的数量。 用户可以增加`airflow.cfg`的并行度变量。
-*   `concurrency` ：Airflow调度程序在任何给定时间都将为您的DAG运行不超过`$concurrency`任务实例。 并发性在Airflow DAG中定义。 如果未在DAG上设置并发性，则调度程序将使用`dag_concurrency`条目的缺省值。
-*   `max_active_runs` ：在给定时间，Airflow调度程序将运行不超过DAG的`max_active_runs` DagRuns。 如果未在DAG中设置`max_active_runs` ，则调度程序将使用`airflow.cfg` `max_active_runs_per_dag`条目的缺省值。
+*   `concurrency` ：Airflow 调度程序在任何给定时间都将为您的 DAG 运行不超过`$concurrency`任务实例。 并发性在 Airflow DAG 中定义。 如果未在 DAG 上设置并发性，则调度程序将使用`dag_concurrency`条目的缺省值。
+*   `max_active_runs` ：在给定时间，Airflow 调度程序将运行不超过 DAG 的`max_active_runs` DagRuns。 如果未在 DAG 中设置`max_active_runs` ，则调度程序将使用`airflow.cfg` `max_active_runs_per_dag`条目的缺省值。
 
-## 我们如何减少气流UI页面加载时间？
+## 我们如何减少气流 UI 页面加载时间？
 
-如果你的dag需要很长时间才能加载，你可以将`airflow.cfg`中`default_dag_run_display_number`配置的值`airflow.cfg`到一个较小的值。 此可配置控制在UI中显示的dag run的数量，默认值为25。
+如果你的 dag 需要很长时间才能加载，你可以将`airflow.cfg`中`default_dag_run_display_number`配置的值`airflow.cfg`到一个较小的值。 此可配置控制在 UI 中显示的 dag run 的数量，默认值为 25。
 
-## 如何修复异常：全局变量explicit_defaults_for_timestamp需要打开（1）？
+## 如何修复异常：全局变量 explicit_defaults_for_timestamp 需要打开（1）？
 
-这意味着在mysql服务器中禁用了`explicit_defaults_for_timestamp` ，您需要通过以下方式启用它：
+这意味着在 mysql 服务器中禁用了`explicit_defaults_for_timestamp` ，您需要通过以下方式启用它：
 
-1.  在my.cnf文件的mysqld部分下设置`explicit_defaults_for_timestamp = 1` 。
-2.  重启Mysql服务器。
+1.  在 my.cnf 文件的 mysqld 部分下设置`explicit_defaults_for_timestamp = 1` 。
+2.  重启 Mysql 服务器。
 
-## 如何减少生产中的气流dag调度延迟？
+## 如何减少生产中的气流 dag 调度延迟？
 
-*   `max_threads` ：Scheduler将并行生成多个线程来安排dags。 这由`max_threads`控制，默认值为2.用户应在生产中将此值增加到更大的值（例如，调度程序运行的cpus的数量 - 1）。
-*   `scheduler_heartbeat_sec` ：用户应考虑将`scheduler_heartbeat_sec`配置增加到更高的值（例如60秒），该值控制气流调度程序获取心跳的频率并更新作业在数据库中的条目。
\ No newline at end of file
+*   `max_threads` ：Scheduler 将并行生成多个线程来安排 dags。 这由`max_threads`控制，默认值为 2.用户应在生产中将此值增加到更大的值（例如，调度程序运行的 cpus 的数量 - 1）。
+*   `scheduler_heartbeat_sec` ：用户应考虑将`scheduler_heartbeat_sec`配置增加到更高的值（例如 60 秒），该值控制气流调度程序获取心跳的频率并更新作业在数据库中的条目。
\ No newline at end of file

zh/4.md

@@ -2,15 +2,15 @@
 
 > 贡献者：[@ThinkingChen](https://github.com/cdmikechen)、[@zhongjiajie](https://github.com/zhongjiajie)
 
-## 获取Airflow
+## 获取 Airflow
 
-安装最新稳定版Airflow的最简单方法是使用`pip` ：
+安装最新稳定版 Airflow 的最简单方法是使用`pip` ：
 
 ```bash
 pip install apache-airflow
 ```
 
-您还可以安装Airflow的一些别的支持功能组件，例如 `gcp_api` 或者 `postgres`：
+您还可以安装 Airflow 的一些别的支持功能组件，例如 `gcp_api` 或者 `postgres`：
 
 ```bash
 pip install apache-airflow[postgres,gcp_api]
@@ -18,48 +18,48 @@ pip install apache-airflow[postgres,gcp_api]
 
 ## 额外的扩展包
 
-通过PyPI的 `apache-airflow` 命令下载的基本包只含有启动的基础部分内容。您可以根据您环境的需要下载您的扩展包。例如，如果您不需要连接Postgres，那么您就不需要使用yum命令安装 `postgres-devel`，或者在您使用的系统上面安装postgre应用，并在安装中的经历一些痛苦过程。
+通过 PyPI 的 `apache-airflow` 命令下载的基本包只含有启动的基础部分内容。您可以根据您环境的需要下载您的扩展包。例如，如果您不需要连接 Postgres，那么您就不需要使用 yum 命令安装 `postgres-devel`，或者在您使用的系统上面安装 postgre 应用，并在安装中的经历一些痛苦过程。
 
-除此之外，Airflow可以按照需求导入这些扩展包来使用。
+除此之外，Airflow 可以按照需求导入这些扩展包来使用。
 
 如下是列举出来的子包列表和他的功能:
 
 | 包名 | 安装命令 | 说明 |
 | :------| :------ | :------ |
-| all | `pip install apache-airflow[all]` | 所有Airflow功能 |
+| all | `pip install apache-airflow[all]` | 所有 Airflow 功能 |
 | all_dbs | `pip install apache-airflow[all_dbs]` | 所有集成的数据库 |
-| async | `pip install apache-airflow[async]` | Gunicorn的异步worker classes |
+| async | `pip install apache-airflow[async]` | Gunicorn 的异步 worker classes |
 | celery | `pip install apache-airflow[celery]` | CeleryExecutor |
 | cloudant | `pip install apache-airflow[cloudant]` | Cloudant hook  |
-| crypto | `pip install apache-airflow[crypto]` | 加密元数据db中的连接密码 |
+| crypto | `pip install apache-airflow[crypto]` | 加密元数据 db 中的连接密码 |
 | devel | `pip install apache-airflow[devel]` | 最小开发工具要求 |
 | devel_hadoop | `pip install apache-airflow[devel_hadoop]` | Airflow + Hadoop stack 的依赖 |
 | druid | `pip install apache-airflow[druid]` | Druid.io 相关的 operators 和 hooks |
-| gcp_api | `pip install apache-airflow[gcp_api]` | Google 云平台 hooks 和operators（使用`google-api-python-client` ） |
-| github_enterprise | `pip install apache-airflow[github_enterprise]` | Github企业版身份认证 |
-| google_auth | `pip install apache-airflow[google_auth]` | Google身份认证 |
+| gcp_api | `pip install apache-airflow[gcp_api]` | Google 云平台 hooks 和 operators（使用`google-api-python-client` ） |
+| github_enterprise | `pip install apache-airflow[github_enterprise]` | Github 企业版身份认证 |
+| google_auth | `pip install apache-airflow[google_auth]` | Google 身份认证 |
 | hdfs | `pip install apache-airflow[hdfs]` | HDFS hooks 和 operators |
-| hive | `pip install apache-airflow[hive]` | 所有Hive相关的 operators |
+| hive | `pip install apache-airflow[hive]` | 所有 Hive 相关的 operators |
 | jdbc | `pip install apache-airflow[jdbc]` | JDBC hooks 和 operators |
-| kerberos | `pip install apache-airflow[kerberos]` | Kerberos集成Kerberized Hadoop |
-| kubernetes | `pip install apache-airflow[kubernetes]` | Kubernetes Executor以及operator |
-| ldap | `pip install apache-airflow[ldap]` | 用户的LDAP身份验证 |
-| mssql | `pip install apache-airflow[mssql]` | Microsoft SQL Server operators 和 hook，作为Airflow后端支持 |
-| mysql | `pip install apache-airflow[mysql]` | MySQL operators 和 hook，支持作为Airflow后端。 MySQL服务器的版本必须是5.6.4+。 确切的版本上限取决于`mysqlclient`包的版本。 例如， `mysqlclient` 1.3.12只能与MySQL服务器5.6.4到5.7一起使用。 |
+| kerberos | `pip install apache-airflow[kerberos]` | Kerberos 集成 Kerberized Hadoop |
+| kubernetes | `pip install apache-airflow[kubernetes]` | Kubernetes Executor 以及 operator |
+| ldap | `pip install apache-airflow[ldap]` | 用户的 LDAP 身份验证 |
+| mssql | `pip install apache-airflow[mssql]` | Microsoft SQL Server operators 和 hook，作为 Airflow 后端支持 |
+| mysql | `pip install apache-airflow[mysql]` | MySQL operators 和 hook，支持作为 Airflow 后端。 MySQL 服务器的版本必须是 5.6.4+。 确切的版本上限取决于`mysqlclient`包的版本。 例如， `mysqlclient` 1.3.12 只能与 MySQL 服务器 5.6.4 到 5.7 一起使用。 |
 | password | `pip install apache-airflow[password]` | 用户密码验证 |
-| postgres | `pip install apache-airflow[postgres]` | Postgres operators 和 hook，作为Airflow后端支持 |
-| qds | `pip install apache-airflow[qds]` | 启用QDS（Qubole数据服务）支持 |
-| rabbitmq | `pip install apache-airflow[rabbitmq]` | rabbitmq作为Celery后端支持 |
+| postgres | `pip install apache-airflow[postgres]` | Postgres operators 和 hook，作为 Airflow 后端支持 |
+| qds | `pip install apache-airflow[qds]` | 启用 QDS（Qubole 数据服务）支持 |
+| rabbitmq | `pip install apache-airflow[rabbitmq]` | rabbitmq 作为 Celery 后端支持 |
 | redis | `pip install apache-airflow[redis]` | Redis hooks 和 sensors |
 | s3 | `pip install apache-airflow[s3]` | `S3KeySensor`，`S3PrefixSensor` |
 | samba | `pip install apache-airflow[samba]` | `Hive2SambaOperator` |
 | slack | `pip install apache-airflow[slack]` | `SlackAPIPostOperator` |
-| ssh | `pip install apache-airflow[ssh]` | SSH hooks及Operator |
-| vertica | `pip install apache-airflow[vertica]` | 做为Airflow后端的 Vertica hook 支持 |
+| ssh | `pip install apache-airflow[ssh]` | SSH hooks 及 Operator |
+| vertica | `pip install apache-airflow[vertica]` | 做为 Airflow 后端的 Vertica hook 支持 |
 
-## 初始化Airflow数据库
+## 初始化 Airflow 数据库
 
-在您运行任务之前，Airflow需要初始化数据库。 如果您只是在试验和学习Airflow，您可以坚持使用默认的SQLite选项。 如果您不想使用SQLite，请查看[初始化数据库后端](zh/8.md)以设置其他数据库。
+在您运行任务之前，Airflow 需要初始化数据库。 如果您只是在试验和学习 Airflow，您可以坚持使用默认的 SQLite 选项。 如果您不想使用 SQLite，请查看[初始化数据库后端](zh/8.md)以设置其他数据库。
 
 配置完成后，若您想要运行任务，需要先初始化数据库：
 

zh/7.md

@@ -2,7 +2,7 @@
 
 > 贡献者：[@ImPerat0R\_](https://github.com/tssujt)
 
-第一次运行Airflow时，它会在`$AIRFLOW_HOME`目录中创建一个名为`airflow.cfg`的文件（默认情况下为`~/airflow`）。此文件包含Airflow的配置，您可以对其进行编辑以更改任何设置。您还可以使用以下格式设置带有环境变量的选项： `$AIRFLOW__{SECTION}__{KEY}` （注意使用双下划线）。
+第一次运行 Airflow 时，它会在`$AIRFLOW_HOME`目录中创建一个名为`airflow.cfg`的文件（默认情况下为`~/airflow`）。此文件包含 Airflow 的配置，您可以对其进行编辑以更改任何设置。您还可以使用以下格式设置带有环境变量的选项： `$AIRFLOW__{SECTION}__{KEY}` （注意使用双下划线）。
 
 例如，元数据库连接字符串可以在`airflow.cfg`设置，如下所示：
 
@@ -39,6 +39,6 @@ sql_alchemy_conn_cmd = bash_command_to_run
 所有配置选项的优先顺序如下 -
 
 1. 环境变量
-2. airflow.cfg中的配置
-3. airflow.cfg中的命令
+2. airflow.cfg 中的配置
+3. airflow.cfg 中的命令
 4. 默认