You are viewing a plain text version of this content. The canonical link for it is here.

Posted to issues@flink.apache.org by GitBox <gi...@apache.org> on 2020/08/16 11:41:24 UTC

[GitHub] [flink-statefun] billyrrr opened a new pull request #131: [FLINK-18968] Translate README.md to Chinese

billyrrr opened a new pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131


   Translate README.md to Chinese. New file is named README.zh.md 
   Methodology: Google Translate on HTML + Manual Correction
   To quickly check diff: click 22ed8a9


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] klion26 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

klion26 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-686536079


   @carp84 got it. It's my pleasure to help to form the glossary for Stateful Functions(I think we can reuse the other parts). I'll first draft a glossary for Stateful Functions according to my understanding.


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] carp84 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

carp84 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-685325397


   @klion26 it would be great if you could also give some suggestions about translation specification here with your experience, thanks!


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] billyrrr commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

billyrrr commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-685099775


   @tzulitai I can update the specifications first 


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] carp84 closed pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

carp84 closed pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131


   


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] carp84 commented on a change in pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

carp84 commented on a change in pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#discussion_r479961465



##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 

Review comment:
       ```suggestion
   * __物理上计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 

Review comment:
       ```suggestion
    _模块_(Module)是将核心构建单元添加到 Stateful Functions 应用程序，即入口、出口、路由器和有状态函数，的入口。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 

Review comment:
       ```suggestion
   一个模块可以提供入口和出口，而其他模块可以通过状态函数来
   独立提供业务逻辑的不同部分。这有助于多个独立团队共同完成较大（复杂）的应用程序。
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  

Review comment:
       ```suggestion
   * __语言无关性：__函数调用使用一个简单的基于HTTP/gRPC的协议，因此可以用各种语言轻松地实现函数。
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 

Review comment:
       ```suggestion
   您可以使用下面的Maven命令快速开始构建 Stateful Functions 应用程序： 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 

Review comment:
       ```suggestion
   本指南将引导您通过设置开始开发和测试自己的 Stateful Functions（Java）应用程序，并运行一个示例。如果您想使用Python快速开始，
   请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 
+
+### <a name="ide-harness"></a>从IDE Harness运行
+
+要测试您的应用程序，可以直接在IDE中运行它，而无需进行任何进一步的打包或部署。 
+
+请参阅[Harness示例](statefun-examples/statefun-flink-harness-example) ，了解如何执行此操作。 
+
+### <a name="greeter"></a>运行一个完整的例子
+
+作为一个简单的演示，我们将逐步完成运行[Greeter示例](statefun-examples/statefun-greeter-example)的步骤。 
+
+在进行其他操作之前，请确保已在本地[构建项目以及基本的Stateful Functions Docker映像](#build) 。
+然后，按照以下步骤运行示例： 
+
+```
+cd statefun-examples/statefun-greeter-example
+docker-compose build
+docker-compose up
+```
+
+该示例包含一个非常基本的有状态函数，具有Kafka入口和Kafka出口。 
+
+要查看实际示例，请向topic `` names ``发送一些消息，并查看topic `` greetings `` ： 

Review comment:
       ```suggestion
   要查看实际的运行情况，请向topic `` names ``发送一些消息，并查看topic `` greetings `` 的输出： 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 
+
+### <a name="ide-harness"></a>从IDE Harness运行
+
+要测试您的应用程序，可以直接在IDE中运行它，而无需进行任何进一步的打包或部署。 
+
+请参阅[Harness示例](statefun-examples/statefun-flink-harness-example) ，了解如何执行此操作。 
+
+### <a name="greeter"></a>运行一个完整的例子
+
+作为一个简单的演示，我们将逐步完成运行[Greeter示例](statefun-examples/statefun-greeter-example)的步骤。 
+
+在进行其他操作之前，请确保已在本地[构建项目以及基本的Stateful Functions Docker映像](#build) 。
+然后，按照以下步骤运行示例： 
+
+```
+cd statefun-examples/statefun-greeter-example
+docker-compose build
+docker-compose up
+```
+
+该示例包含一个非常基本的有状态函数，具有Kafka入口和Kafka出口。 
+
+要查看实际示例，请向topic `` names ``发送一些消息，并查看topic `` greetings `` ： 
+
+```
+docker-compose exec kafka-broker kafka-console-producer.sh \
+     --broker-list localhost:9092 \
+     --topic names
+```
+
+```
+docker-compose exec kafka-broker kafka-console-consumer.sh \
+     --bootstrap-server localhost:9092 \
+     --isolation-level read_committed \
+     --from-beginning \
+     --topic greetings 
+```
+
+## <a name="deploying"></a>部署应用
+
+状态函数应用程序可以打包为[独立应用程序](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#images)或[Flink作业](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#flink-jar) ，可以提交给Flink群集。 

Review comment:
       ```suggestion
   Stateful Functions 应用程序可以打包为[独立应用程序](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#images)或[Flink作业](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#flink-jar) ，并提交给Flink集群运行。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 

Review comment:
       ```suggestion
   Stateful Functions 运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)的属性，但适用于有状态的场景。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：

Review comment:
       ```suggestion
   运行时基于Apache Flink<sup>®</sup>构建，并具有以下设计原则：
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->

Review comment:
       ```suggestion
   *  __逻辑上计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这在抽象层面天然地保证了一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 

Review comment:
       ```suggestion
   按照下面的步骤即可立刻开始使用 Stateful Functions。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 

Review comment:
       ```suggestion
   这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
   `` ArtifactId ``和 package 名称，并将生成一个与您指定的`` ArtifactId ``同名的新目录。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 

Review comment:
       ```suggestion
   如果要构建/打包项目，请进入项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序以及相关依赖的JAR包：`target/<artifact-id>-<version>.jar`。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 

Review comment:
       ```suggestion
   IntelliJ IDEA天然支持Maven项目。如果使用Eclipse，则需要使用`` m2e ``插件导入
   Maven项目。一些 Eclipse发布版本默认包含该插件，而另一些则需要您手动安装。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 

Review comment:
       ```suggestion
   这使得在Kubernetes和FaaS平台上，或（微）服务后台执行函数，同时在函数之间提供一致的状态和轻量级消息传递成为可能。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 
+
+### <a name="ide-harness"></a>从IDE Harness运行
+
+要测试您的应用程序，可以直接在IDE中运行它，而无需进行任何进一步的打包或部署。 
+
+请参阅[Harness示例](statefun-examples/statefun-flink-harness-example) ，了解如何执行此操作。 
+
+### <a name="greeter"></a>运行一个完整的例子
+
+作为一个简单的演示，我们将逐步完成运行[Greeter示例](statefun-examples/statefun-greeter-example)的步骤。 
+
+在进行其他操作之前，请确保已在本地[构建项目以及基本的Stateful Functions Docker映像](#build) 。
+然后，按照以下步骤运行示例： 
+
+```
+cd statefun-examples/statefun-greeter-example
+docker-compose build
+docker-compose up
+```
+
+该示例包含一个非常基本的有状态函数，具有Kafka入口和Kafka出口。 
+
+要查看实际示例，请向topic `` names ``发送一些消息，并查看topic `` greetings `` ： 
+
+```
+docker-compose exec kafka-broker kafka-console-producer.sh \
+     --broker-list localhost:9092 \
+     --topic names
+```
+
+```
+docker-compose exec kafka-broker kafka-console-consumer.sh \
+     --bootstrap-server localhost:9092 \
+     --isolation-level read_committed \
+     --from-beginning \
+     --topic greetings 
+```
+
+## <a name="deploying"></a>部署应用
+
+状态函数应用程序可以打包为[独立应用程序](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#images)或[Flink作业](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#flink-jar) ，可以提交给Flink群集。 
+
+### <a name="docker"></a>使用Docker映像进行部署
+
+以下是一个示例Dockerfile，用于为名为`` statefun-example ``的应用程序构建带有[嵌入式](https://ci.apache.org/projects/flink/flink-statefun-docs-master/sdk/modules.html#embedded-module)模块（Java）的有状态函数映像。 
+
+```
+FROM flink-statefun[:version-tag]
+
+RUN mkdir -p /opt/statefun/modules/statefun-example
+
+COPY target/statefun-example*jar /opt/statefun/modules/statefun-example/
+```
+
+### <a name="flink"></a>部署为Flink作业
+
+如果您希望将Stateful Functions应用程序打包为Flink作业以提交到现有的Flink集群，只需将`` statefun-flink-distribution ``包含为对应用程序的依赖项。 

Review comment:
       ```suggestion
   如果您希望将 Stateful Functions 应用程序打包为 Flink 作业以提交到现有的Flink集群，只需在你的应用程序中将`` statefun-flink-distribution ``添加为依赖项。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目

Review comment:
       I think `构建项目` is better.

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 
+
+### <a name="ide-harness"></a>从IDE Harness运行
+
+要测试您的应用程序，可以直接在IDE中运行它，而无需进行任何进一步的打包或部署。 
+
+请参阅[Harness示例](statefun-examples/statefun-flink-harness-example) ，了解如何执行此操作。 
+
+### <a name="greeter"></a>运行一个完整的例子
+
+作为一个简单的演示，我们将逐步完成运行[Greeter示例](statefun-examples/statefun-greeter-example)的步骤。 
+
+在进行其他操作之前，请确保已在本地[构建项目以及基本的Stateful Functions Docker映像](#build) 。
+然后，按照以下步骤运行示例： 
+
+```
+cd statefun-examples/statefun-greeter-example
+docker-compose build
+docker-compose up
+```
+
+该示例包含一个非常基本的有状态函数，具有Kafka入口和Kafka出口。 
+
+要查看实际示例，请向topic `` names ``发送一些消息，并查看topic `` greetings `` ： 
+
+```
+docker-compose exec kafka-broker kafka-console-producer.sh \
+     --broker-list localhost:9092 \
+     --topic names
+```
+
+```
+docker-compose exec kafka-broker kafka-console-consumer.sh \
+     --bootstrap-server localhost:9092 \
+     --isolation-level read_committed \
+     --from-beginning \
+     --topic greetings 
+```
+
+## <a name="deploying"></a>部署应用
+
+状态函数应用程序可以打包为[独立应用程序](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#images)或[Flink作业](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#flink-jar) ，可以提交给Flink群集。 
+
+### <a name="docker"></a>使用Docker映像进行部署
+
+以下是一个示例Dockerfile，用于为名为`` statefun-example ``的应用程序构建带有[嵌入式](https://ci.apache.org/projects/flink/flink-statefun-docs-master/sdk/modules.html#embedded-module)模块（Java）的有状态函数映像。 

Review comment:
       ```suggestion
   以下是一个Dockerfile示例，用于为名为`` statefun-example ``的应用程序构建带有[嵌入式](https://ci.apache.org/projects/flink/flink-statefun-docs-master/sdk/modules.html#embedded-module)模块（Java）的 Stateful Functions 镜像。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 
+
+### <a name="ide-harness"></a>从IDE Harness运行
+
+要测试您的应用程序，可以直接在IDE中运行它，而无需进行任何进一步的打包或部署。 
+
+请参阅[Harness示例](statefun-examples/statefun-flink-harness-example) ，了解如何执行此操作。 
+
+### <a name="greeter"></a>运行一个完整的例子
+
+作为一个简单的演示，我们将逐步完成运行[Greeter示例](statefun-examples/statefun-greeter-example)的步骤。 
+
+在进行其他操作之前，请确保已在本地[构建项目以及基本的Stateful Functions Docker映像](#build) 。
+然后，按照以下步骤运行示例： 
+
+```
+cd statefun-examples/statefun-greeter-example
+docker-compose build
+docker-compose up
+```
+
+该示例包含一个非常基本的有状态函数，具有Kafka入口和Kafka出口。 
+
+要查看实际示例，请向topic `` names ``发送一些消息，并查看topic `` greetings `` ： 
+
+```
+docker-compose exec kafka-broker kafka-console-producer.sh \
+     --broker-list localhost:9092 \
+     --topic names
+```
+
+```
+docker-compose exec kafka-broker kafka-console-consumer.sh \
+     --bootstrap-server localhost:9092 \
+     --isolation-level read_committed \
+     --from-beginning \
+     --topic greetings 
+```
+
+## <a name="deploying"></a>部署应用
+
+状态函数应用程序可以打包为[独立应用程序](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#images)或[Flink作业](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#flink-jar) ，可以提交给Flink群集。 
+
+### <a name="docker"></a>使用Docker映像进行部署
+
+以下是一个示例Dockerfile，用于为名为`` statefun-example ``的应用程序构建带有[嵌入式](https://ci.apache.org/projects/flink/flink-statefun-docs-master/sdk/modules.html#embedded-module)模块（Java）的有状态函数映像。 
+
+```
+FROM flink-statefun[:version-tag]
+
+RUN mkdir -p /opt/statefun/modules/statefun-example
+
+COPY target/statefun-example*jar /opt/statefun/modules/statefun-example/
+```
+
+### <a name="flink"></a>部署为Flink作业
+
+如果您希望将Stateful Functions应用程序打包为Flink作业以提交到现有的Flink集群，只需将`` statefun-flink-distribution ``包含为对应用程序的依赖项。 
+
+```
+<dependency>
+    <groupId>org.apache.flink</groupId>
+    <artifactId>statefun-flink-distribution</artifactId>
+    <version>2.2-SNAPSHOT</version>
+</dependency>
+```
+
+它包括所有运行时依赖项，并配置应用程序的主入口点。
+除了将依赖项添加到POM文件之外，您无需执行任何其他操作。 
+
+<div class="alert alert-info">
+  <strong>Attention:</strong>该发行版必须捆绑在您的应用程序胖JAR中，以将它放置于Flink的[用户代码类加载器上](https://ci.apache.org/projects/flink/flink-docs-stable/monitoring/debugging_classloading.html#inverted-class-loading-and-classloader-resolution-order) 

Review comment:
       ```suggestion
     <strong>注意:</strong>该发行版必须捆绑在你的应用程序fat JAR中，以将它放置于Flink的[用户代码类加载器上](https://ci.apache.org/projects/flink/flink-docs-stable/monitoring/debugging_classloading.html#inverted-class-loading-and-classloader-resolution-order) 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 
+
+### <a name="ide-harness"></a>从IDE Harness运行
+
+要测试您的应用程序，可以直接在IDE中运行它，而无需进行任何进一步的打包或部署。 

Review comment:
       ```suggestion
   要测试您的应用程序，可以直接在IDE中运行它，而无需进一步的打包或部署。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 
+
+### <a name="ide-harness"></a>从IDE Harness运行
+
+要测试您的应用程序，可以直接在IDE中运行它，而无需进行任何进一步的打包或部署。 
+
+请参阅[Harness示例](statefun-examples/statefun-flink-harness-example) ，了解如何执行此操作。 
+
+### <a name="greeter"></a>运行一个完整的例子
+
+作为一个简单的演示，我们将逐步完成运行[Greeter示例](statefun-examples/statefun-greeter-example)的步骤。 
+
+在进行其他操作之前，请确保已在本地[构建项目以及基本的Stateful Functions Docker映像](#build) 。
+然后，按照以下步骤运行示例： 
+
+```
+cd statefun-examples/statefun-greeter-example
+docker-compose build
+docker-compose up
+```
+
+该示例包含一个非常基本的有状态函数，具有Kafka入口和Kafka出口。 
+
+要查看实际示例，请向topic `` names ``发送一些消息，并查看topic `` greetings `` ： 
+
+```
+docker-compose exec kafka-broker kafka-console-producer.sh \
+     --broker-list localhost:9092 \
+     --topic names
+```
+
+```
+docker-compose exec kafka-broker kafka-console-consumer.sh \
+     --bootstrap-server localhost:9092 \
+     --isolation-level read_committed \
+     --from-beginning \
+     --topic greetings 
+```
+
+## <a name="deploying"></a>部署应用
+
+状态函数应用程序可以打包为[独立应用程序](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#images)或[Flink作业](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#flink-jar) ，可以提交给Flink群集。 
+
+### <a name="docker"></a>使用Docker映像进行部署
+
+以下是一个示例Dockerfile，用于为名为`` statefun-example ``的应用程序构建带有[嵌入式](https://ci.apache.org/projects/flink/flink-statefun-docs-master/sdk/modules.html#embedded-module)模块（Java）的有状态函数映像。 
+
+```
+FROM flink-statefun[:version-tag]
+
+RUN mkdir -p /opt/statefun/modules/statefun-example
+
+COPY target/statefun-example*jar /opt/statefun/modules/statefun-example/
+```
+
+### <a name="flink"></a>部署为Flink作业
+
+如果您希望将Stateful Functions应用程序打包为Flink作业以提交到现有的Flink集群，只需将`` statefun-flink-distribution ``包含为对应用程序的依赖项。 
+
+```
+<dependency>
+    <groupId>org.apache.flink</groupId>
+    <artifactId>statefun-flink-distribution</artifactId>
+    <version>2.2-SNAPSHOT</version>
+</dependency>
+```
+
+它包括所有运行时依赖项，并配置应用程序的主入口点。
+除了将依赖项添加到POM文件之外，您无需执行任何其他操作。 
+
+<div class="alert alert-info">
+  <strong>Attention:</strong>该发行版必须捆绑在您的应用程序胖JAR中，以将它放置于Flink的[用户代码类加载器上](https://ci.apache.org/projects/flink/flink-docs-stable/monitoring/debugging_classloading.html#inverted-class-loading-and-classloader-resolution-order) 
+  </div>
+
+```
+{$FLINK_DIR}/bin/flink run ./statefun-example.jar
+```
+
+## <a name="contributing"></a>贡献

Review comment:
       ```suggestion
   ## <a name="contributing"></a>参与贡献
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 
+
+### <a name="ide-harness"></a>从IDE Harness运行
+
+要测试您的应用程序，可以直接在IDE中运行它，而无需进行任何进一步的打包或部署。 
+
+请参阅[Harness示例](statefun-examples/statefun-flink-harness-example) ，了解如何执行此操作。 
+
+### <a name="greeter"></a>运行一个完整的例子
+
+作为一个简单的演示，我们将逐步完成运行[Greeter示例](statefun-examples/statefun-greeter-example)的步骤。 

Review comment:
       ```suggestion
   作为一个简单的演示，我们将逐步运行[Greeter示例](statefun-examples/statefun-greeter-example)。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 
+
+### <a name="ide-harness"></a>从IDE Harness运行
+
+要测试您的应用程序，可以直接在IDE中运行它，而无需进行任何进一步的打包或部署。 
+
+请参阅[Harness示例](statefun-examples/statefun-flink-harness-example) ，了解如何执行此操作。 
+
+### <a name="greeter"></a>运行一个完整的例子
+
+作为一个简单的演示，我们将逐步完成运行[Greeter示例](statefun-examples/statefun-greeter-example)的步骤。 
+
+在进行其他操作之前，请确保已在本地[构建项目以及基本的Stateful Functions Docker映像](#build) 。
+然后，按照以下步骤运行示例： 
+
+```
+cd statefun-examples/statefun-greeter-example
+docker-compose build
+docker-compose up
+```
+
+该示例包含一个非常基本的有状态函数，具有Kafka入口和Kafka出口。 
+
+要查看实际示例，请向topic `` names ``发送一些消息，并查看topic `` greetings `` ： 
+
+```
+docker-compose exec kafka-broker kafka-console-producer.sh \
+     --broker-list localhost:9092 \
+     --topic names
+```
+
+```
+docker-compose exec kafka-broker kafka-console-consumer.sh \
+     --bootstrap-server localhost:9092 \
+     --isolation-level read_committed \
+     --from-beginning \
+     --topic greetings 
+```
+
+## <a name="deploying"></a>部署应用
+
+状态函数应用程序可以打包为[独立应用程序](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#images)或[Flink作业](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#flink-jar) ，可以提交给Flink群集。 
+
+### <a name="docker"></a>使用Docker映像进行部署
+
+以下是一个示例Dockerfile，用于为名为`` statefun-example ``的应用程序构建带有[嵌入式](https://ci.apache.org/projects/flink/flink-statefun-docs-master/sdk/modules.html#embedded-module)模块（Java）的有状态函数映像。 
+
+```
+FROM flink-statefun[:version-tag]
+
+RUN mkdir -p /opt/statefun/modules/statefun-example
+
+COPY target/statefun-example*jar /opt/statefun/modules/statefun-example/
+```
+
+### <a name="flink"></a>部署为Flink作业
+
+如果您希望将Stateful Functions应用程序打包为Flink作业以提交到现有的Flink集群，只需将`` statefun-flink-distribution ``包含为对应用程序的依赖项。 
+
+```
+<dependency>
+    <groupId>org.apache.flink</groupId>
+    <artifactId>statefun-flink-distribution</artifactId>
+    <version>2.2-SNAPSHOT</version>
+</dependency>
+```
+
+它包括所有运行时依赖项，并配置应用程序的主入口点。
+除了将依赖项添加到POM文件之外，您无需执行任何其他操作。 
+
+<div class="alert alert-info">
+  <strong>Attention:</strong>该发行版必须捆绑在您的应用程序胖JAR中，以将它放置于Flink的[用户代码类加载器上](https://ci.apache.org/projects/flink/flink-docs-stable/monitoring/debugging_classloading.html#inverted-class-loading-and-classloader-resolution-order) 
+  </div>
+
+```
+{$FLINK_DIR}/bin/flink run ./statefun-example.jar
+```
+
+## <a name="contributing"></a>贡献
+
+有多种方法可以为不同类型的应用程序增强Stateful Functions API。运行时和操作也将随着Apache Flink的发展而发展。 
+
+您可以在[Apache Flink网站上](https://flink.apache.org/contributing/how-to-contribute.html)了解有关如何做出贡献的更多信息。对于代码贡献，请仔细阅读“ [贡献代码”](https://flink.apache.org/contributing/contribute-code.html)部分，并检查[Jira](https://issues.apache.org/jira/browse/FLINK-15969?jql=project%20%3D%20FLINK%20AND%20component%20%3D%20%22Stateful%20Functions%22)中的_Stateful Functions_组件以获取正在进行的社区工作的概述。 

Review comment:
       ```suggestion
   您可以在[Apache Flink网站](https://flink.apache.org/contributing/how-to-contribute.html)上了解关于如何做出贡献的更多信息。对于代码贡献，请仔细阅读“ [贡献代码”](https://flink.apache.org/contributing/contribute-code.html)部分，并检查[Jira](https://issues.apache.org/jira/browse/FLINK-15969?jql=project%20%3D%20FLINK%20AND%20component%20%3D%20%22Stateful%20Functions%22)中的_Stateful Functions_组件以概要了解正在进行中的社区工作。 
   ```




----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] billyrrr commented on a change in pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

billyrrr commented on a change in pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#discussion_r481413440



##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），

Review comment:
       ```suggestion
   在于，函数不是在定义数据流动（流的拓扑结构）的有向非循环图（DAG）中组装，
   ```




----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] klion26 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

klion26 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-696654083


   @carp84 thanks for the reply and comments. will check it now.


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] carp84 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

carp84 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-686430531


   > Just to make it a bit more clearer:
   > I think before we merge this, it is best if we can extend the [Flink translation specifications](https://cwiki.apache.org/confluence/display/FLINK/Flink+Translation+Specifications) for Stateful Functions first.
   > That would set a better foundation for future contributions on further translating the documentations.
   
   Thanks for helping review @klion26 , but I meant to ask whether you could help forming the translation specification for Stateful Functions according to your experience in Flink document translation (smile).


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] billyrrr commented on a change in pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

billyrrr commented on a change in pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#discussion_r481411318



##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 

Review comment:
       这里应该是在说 Stateful Functions, ingress, router, egress 是如何将更底层的Flink操作抽象化。 所以翻译成```抽象```可能更好一点 




----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] carp84 commented on a change in pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

carp84 commented on a change in pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#discussion_r476234672



##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>

Review comment:
       I'm not quite sure whether translate the name into Chinese is a good idea. Personally I prefer to keep the English name.
   ```suggestion
   <img alt="Stateful Functions" src="docs/fig/stateful_functions_logo.png" width=350px/>
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 

Review comment:
       ```suggestion
   该文档旨在简要介绍使用 Stateful Functions 需要了解的核心概念和设置方法。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），

Review comment:
       ```suggestion
   在于，函数不是在定义数据流（拓扑）的有向无环图（DAG）中组装，
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 

Review comment:
       ```suggestion
   - [参与贡献](#contributing) 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 

Review comment:
       ```suggestion
   相关代码示例，请查看[这里](statefun-examples/) 。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 

Review comment:
       Ditto
   ```suggestion
   Stateful Functions 是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 

Review comment:
       ```suggestion
      * [摘要](#abstraction) 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 

Review comment:
       ```suggestion
   Stateful Functions 使我们能够将强大的状态管理和组合方法，与 AWS Lambda 等 FaaS 实现和 Kubernetes 等现代资源编排框架的弹性、快速扩缩容和滚动升级功能相结合。通过这些特性，它解决了当今许多 FaaS 解决方案中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：函数间的状态一致性和高效消息传递。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 

Review comment:
       ```suggestion
   更多详细信息，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 

Review comment:
       ```suggestion
   Stateful Functions 应用程序由以下原语组成：有状态函数，入口(ingress)，路由器(router)和出口(egress)。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 

Review comment:
       ```suggestion
   出口是可选的；也有可能没有事件离开应用程序，函数会完成事件的处理或直接调用其他应用程序。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 

Review comment:
       ```suggestion
   * _路由器_(Router)连接到入口(Ingress)并决定最先处理事件的函数实例。 
   ```

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 

Review comment:
       ```suggestion
   入口可以是消息队列，日志或HTTP服务器-它们产生事件并交由应用程序处理。 
   ```




----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] tzulitai commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

tzulitai commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-683638078


   A similar translation specification for StateFun is indeed nice, especially if we want to move along with this, it would be best to have consensus on what not to translate.
   
   IMHO, I agree with @carp84 here, not translating the name of the project makes a lot of sense here.


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] klion26 commented on a change in pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

klion26 commented on a change in pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#discussion_r482033498



##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 

Review comment:
       ```suggestion
   有状态函数是一个 [Apache Flink](https://flink.apache.org/) 库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
   ```
   We need to add a blank between English and Chinese after translation. and everywhere else




----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] klion26 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

klion26 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-696654083


   @carp84 thanks for the reply and comments. will check it now.


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] wangzzu commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

wangzzu commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-731673430


   @tzulitai @klion26 Sorry for the late reply, I will open a new PR soon.


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] billyrrr commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

billyrrr commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-680671983


   Hi, @carp84 Thank you for the review. 
   
   I think that "stateful functions" should be translated to chinese to promote communications within people who primarily speak Chinese. Suppose that someone is proficient at processing stateful streams but not proficient in English, they would not be able to notice the target use case of Flink Stateful Functions. On another note, when someone wants to refer flink stateful functions to another person, it is easier to use the term 'Flink有状态函数' in their native language rather than ' Flink Stateful Functions'. Nevertheless, the English term on its own has its merit of accuracy and ease of finding related documentations. So I do understand your point too. 
   
   I think that there are more benefit from translating 'Flink Stateful Functions' to 'Flink有状态函数'. Can we discuss more about this decision? Thanks! 


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] carp84 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

carp84 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-735532283


   Closing this PR since it's already superseded by #176 


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] billyrrr commented on a change in pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

billyrrr commented on a change in pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#discussion_r471103025



##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目

Review comment:
       TODO: fix 构建项目




----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] billyrrr commented on a change in pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

billyrrr commented on a change in pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#discussion_r481405533



##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 

Review comment:
        I agree with the translations, but I think it is best preserve line breaks; so that when the corresponding English docs changes, the relevant line in Chinese docs can be quickly located. This also assist with machine learning translations, as a training set for translations can be easily extracted.




----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] klion26 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

klion26 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-685414778


   @carp84 thanks for the notice. will review this late today.


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] carp84 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

carp84 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-683607502


   Thanks for sharing the thoughts @billyrrr , and sure let's discuss more about it (and sorry for the late response, busy preparing for this year's Singles' Day recently).
   
   I think translating the name into Chinese will cause confusions in some cases, such as the below one:
   `A Stateful Functions application consists of the following primitives: stateful functions, ingresses, routers and egresses`
   -> `有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，路由器(router)和出口(egress)` 
   Comparing to:
   -> `Stateful Functions 应用程序由以下原语组成：有状态函数，入口(ingress)，路由器(router)和出口(egress)`
   What do you think?
   
   And in Flink we will also keep the original names for some terms such as `State Backend` (referring to [Flink's translation specification](https://cwiki.apache.org/confluence/display/FLINK/Flink+Translation+Specifications))
   
   PS. Maybe we should have a similar translation specification for stateful functions? Wdyt? @igalshilman @tzulitai Thanks.


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] wangzzu commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

wangzzu commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-731966327


   @tzulitai @klion26 I have submitted the new PR: https://github.com/apache/flink-statefun/pull/176
   
   
   
   


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] tzulitai commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

tzulitai commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-684223257


   Just to make it a bit more clearer:
   I think before we merge this, it is best if we can extend the [Flink translation specifications](https://cwiki.apache.org/confluence/display/FLINK/Flink+Translation+Specifications) for Stateful Functions first.
   That would set a better foundation for future contributions on further translating the documentations.
   
   @billyrrr do you think that would be possible? Or do you prefer merging this first, and work on the specifications afterwards?


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] tzulitai commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

tzulitai commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-725270952


   @billyrrr do you plan on updating this PR?
   
   Or alternatively, @klion26 do you have in mind anyone who would be suitable for taking this translation over if @billyrrr remains absent?


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] klion26 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

klion26 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-710106615


   FYI, The Translation Specification for Stateful Functions has been added to the [existing wiki](https://cwiki.apache.org/confluence/display/FLINK/Flink+Translation+Specifications)


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] carp84 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

carp84 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-696077948


   > Sorry for the late reply, dealt with some urgent things on hand.
   > I've drafted a [Flink Stateful Functions Translation Specifications](https://docs.google.com/document/d/1Fv56PG50pHlDxZfF49iRhv-8dY7ZaCSHUCvBM2Vy0ao/edit?usp=sharing), please take a look when you're free, thanks.
   > cc @tzulitai @carp84 @billyrrr
   
   Thanks for driving this and sorry for the late reply @klion26 . The draft LGTM and I've left some minor comments on google doc.
   
   @tzulitai IMHO we're ready to start a discussion in ML, wdyt? Thanks.


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] klion26 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

klion26 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-690003117


   Sorry for the late reply, dealt with some urgent things on hand. 
   I've drafted a [Flink Stateful Functions Translation Specifications](https://docs.google.com/document/d/1Fv56PG50pHlDxZfF49iRhv-8dY7ZaCSHUCvBM2Vy0ao/edit?usp=sharing), please take a look when you're free, thanks.
   cc @tzulitai @carp84 @billyrrr 


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] wangzzu commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

wangzzu commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-726820855


   > @wangzzu Do you want to take over this?
   
   thanks for inviting, I'd be pleased to continue @billyrrr's  previous work, I will modify it according to comments  as soon as possible.


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] carp84 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

carp84 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-696077948


   > Sorry for the late reply, dealt with some urgent things on hand.
   > I've drafted a [Flink Stateful Functions Translation Specifications](https://docs.google.com/document/d/1Fv56PG50pHlDxZfF49iRhv-8dY7ZaCSHUCvBM2Vy0ao/edit?usp=sharing), please take a look when you're free, thanks.
   > cc @tzulitai @carp84 @billyrrr
   
   Thanks for driving this and sorry for the late reply @klion26 . The draft LGTM and I've left some minor comments on google doc.
   
   @tzulitai IMHO we're ready to start a discussion in ML, wdyt? Thanks.


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] klion26 commented on a change in pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

klion26 commented on a change in pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#discussion_r482033498



##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 

Review comment:
       ```suggestion
   有状态函数是一个 [Apache Flink](https://flink.apache.org/) 库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
   ```
   We need to add a blank between English and Chinese after translation.

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 
+
+### <a name="ide-harness"></a>从IDE Harness运行
+
+要测试您的应用程序，可以直接在IDE中运行它，而无需进行任何进一步的打包或部署。 
+
+请参阅[Harness示例](statefun-examples/statefun-flink-harness-example) ，了解如何执行此操作。 

Review comment:
       `详情可以参考 [Harness 示例]`

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数

Review comment:
       maybe we need change to `_有状态函数_ 是` to make the render happy, and everywhere else.

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>

Review comment:
       +1

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 
+
+### <a name="ide-harness"></a>从IDE Harness运行
+
+要测试您的应用程序，可以直接在IDE中运行它，而无需进行任何进一步的打包或部署。 
+
+请参阅[Harness示例](statefun-examples/statefun-flink-harness-example) ，了解如何执行此操作。 
+
+### <a name="greeter"></a>运行一个完整的例子
+
+作为一个简单的演示，我们将逐步完成运行[Greeter示例](statefun-examples/statefun-greeter-example)的步骤。 
+
+在进行其他操作之前，请确保已在本地[构建项目以及基本的Stateful Functions Docker映像](#build) 。
+然后，按照以下步骤运行示例： 
+
+```
+cd statefun-examples/statefun-greeter-example
+docker-compose build
+docker-compose up
+```
+
+该示例包含一个非常基本的有状态函数，具有Kafka入口和Kafka出口。 
+
+要查看实际示例，请向topic `` names ``发送一些消息，并查看topic `` greetings `` ： 
+
+```
+docker-compose exec kafka-broker kafka-console-producer.sh \
+     --broker-list localhost:9092 \
+     --topic names
+```
+
+```
+docker-compose exec kafka-broker kafka-console-consumer.sh \
+     --bootstrap-server localhost:9092 \
+     --isolation-level read_committed \
+     --from-beginning \
+     --topic greetings 
+```
+
+## <a name="deploying"></a>部署应用
+
+状态函数应用程序可以打包为[独立应用程序](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#images)或[Flink作业](https://ci.apache.org/projects/flink/flink-statefun-docs-master/deployment-and-operations/packaging.html#flink-jar) ，可以提交给Flink群集。 
+
+### <a name="docker"></a>使用Docker映像进行部署
+
+以下是一个示例Dockerfile，用于为名为`` statefun-example ``的应用程序构建带有[嵌入式](https://ci.apache.org/projects/flink/flink-statefun-docs-master/sdk/modules.html#embedded-module)模块（Java）的有状态函数映像。 
+
+```
+FROM flink-statefun[:version-tag]
+
+RUN mkdir -p /opt/statefun/modules/statefun-example
+
+COPY target/statefun-example*jar /opt/statefun/modules/statefun-example/
+```
+
+### <a name="flink"></a>部署为Flink作业
+
+如果您希望将Stateful Functions应用程序打包为Flink作业以提交到现有的Flink集群，只需将`` statefun-flink-distribution ``包含为对应用程序的依赖项。 
+
+```
+<dependency>
+    <groupId>org.apache.flink</groupId>
+    <artifactId>statefun-flink-distribution</artifactId>
+    <version>2.2-SNAPSHOT</version>
+</dependency>
+```
+
+它包括所有运行时依赖项，并配置应用程序的主入口点。
+除了将依赖项添加到POM文件之外，您无需执行任何其他操作。 
+
+<div class="alert alert-info">
+  <strong>Attention:</strong>该发行版必须捆绑在您的应用程序胖JAR中，以将它放置于Flink的[用户代码类加载器上](https://ci.apache.org/projects/flink/flink-docs-stable/monitoring/debugging_classloading.html#inverted-class-loading-and-classloader-resolution-order) 
+  </div>
+
+```
+{$FLINK_DIR}/bin/flink run ./statefun-example.jar
+```
+
+## <a name="contributing"></a>贡献
+
+有多种方法可以为不同类型的应用程序增强Stateful Functions API。运行时和操作也将随着Apache Flink的发展而发展。 

Review comment:
       Personally, I don't think `运行时和操作` is a good translation for  `the runtime and operations`, because people can't get the meaning easily.

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 

Review comment:
       +1

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 

Review comment:
       +1

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 

Review comment:
       +1 `该文档旨在简要介绍使用 Stateful Functions 需要了解的核心概念和设置方法。 `
   From my side, I think we should first make the doc more friendly to people, then friendly to machines.

##########
File path: README.zh.md
##########
@@ -0,0 +1,228 @@
+<img alt="有状态函数" src="docs/fig/stateful_functions_logo.png" width=350px/>
+
+有状态函数是一个[Apache Flink](https://flink.apache.org/)库， __可简化构建分布式有状态应用程序的过程__ 。它基于有着可持久化状态的函数，这些函数可以在强大的一致性保证下进行动态交互。 
+
+有状态函数使强大的状态管理和组合，与AWS Lambda之类的FaaS实现和Kubernetes之类的现代资源编排框架的弹性，快速缩放/零缩放和滚动升级功能相结合成为可能。通过这些特性，它解决了当今许多FaaS设置中[最常被引用的两个缺点](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-3.pdf) ：状态一致和函数之间的高效消息传递。 
+
+本自述文件旨在简要介绍核心概念以及如何进行设置
+以使您开始使用有状态函数。 
+
+有关详细文档，请访问[官方文档](https://ci.apache.org/projects/flink/flink-statefun-docs-master) 。 
+
+有关代码示例，请查看[示例](statefun-examples/) 。 
+
+ [![构建状态](https://travis-ci.org/apache/flink-statefun.svg?branch=master)](https://travis-ci.org/apache/flink-statefun) 
+
+## 目录
+
+- [核心概念](#core-concepts) 
+   * [抽象化](#abstraction) 
+   * [函数模块和可扩展性](#modules) 
+   * [运行时](#runtime) 
+- [入门](#getting-started) 
+   * [运行一个完整的例子](#greeter) 
+   * [新建项目](#project-setup) 
+   * [构建项目](#build) 
+   * [在IDE Harness中运行](#ide-harness) 
+- [部署应用](#deploying) 
+   * [使用Docker映像进行部署](#docker) 
+   * [部署为Flink作业](#flink) 
+- [贡献](#contributing) 
+- [开源软件许可](#license) 
+
+## <a name="core-concepts"></a>核心概念
+
+### <a name="abstraction"></a>抽象化
+
+有状态函数应用程序由以下原语组成：有状态函数，入口(ingress)，
+路由器(router)和出口(egress)。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview.png" width="650px"/>
+</p>
+
+#### 有状态函数
+
+* _有状态函数_是通过消息调用的一小段逻辑/代码。每个有状态函数
+都作为_函数类型_的唯一可调用_虚拟实例_存在。每个实例都通过其``type``以及type中的唯一``ID`` （字符串）来寻址。 
+
+* 有状态函数可以从ingress或任何其他有状态函数（包括其自身）中调用。
+调用者只需要知道目标函数的地址即可。 
+
+* 函数实例是_虚拟的_ ，因为它们不总是同时在内存中活跃。
+在任何时间点，只有一小部分函数及其状态作为实际对象存在。当
+虚拟实例接收到消息时，将配置一个对象并带着该虚拟实例的状态
+加载，然后处理该消息。与虚拟内存类似，许多函数的状态可能
+在任何时间点都被“交换出去”(swap out)。 
+
+* 函数的每个虚拟实例都有其自己的状态，可以通过局部变量访问。
+该状态是私有的，对于该实例是本地的(local)。
+
+如果您知道Apache Flink的DataStream API，则可以将有状态函数考虑为轻量级的
+`KeyedProcessFunction` 。函数``type``等同于处理函数转换(process function transformation)，而`` ID ``是键(key)。不同之处
+在于，函数不是在定义数据流的有向非循环图（DAG）中组装（流拓扑），
+而是使用地址将事件任意发送到所有其他函数。 
+
+#### 入口和出口
+
+* _入口_ (Ingress)是事件最初到达有状态函数应用程序的方式。
+入口可以是消息队列，日志或HTTP服务器-产生事件并由
+应用程序处理的任何物件。 
+
+* _路由器_(Router)连接到入口(Ingress)，以确定哪个函数实例应最初处理事件。 
+
+* _出口_(Egress)是一种以标准化方式从应用程序发送事件的方法。
+出口是可选的；也有可能没有事件离开应用程序和函数接收器(functions sink)事件，或
+直接调用其他应用程序。 
+
+### <a name="modules"></a>模块(Module)
+
+ _模块_(Module)将核心构建基元添加到有状态函数
+ 应用程序的入口点，即入口，出口，路由器和有状态函数。 
+
+单个应用程序可以是多个模块的组合，每个模块都构成整个应用程序的一部分。
+这允许应用程序的不同部分由不同的模块来组成。例如，
+一个模块可以提供入口和出口，而其他模块可以分别作为状态函数来
+贡献业务逻辑的特定部分。这有助于在独立团队中工作，但仍可以部署到
+相同的更大应用程序中。 
+
+## <a name="runtime">运行时 
+
+有状态函数运行时旨在提供一组类似于[无服务器函数](https://martinfowler.com/articles/serverless.html)属性的属性，但适用于有状态问题。 
+
+<p align="center">
+  <img src="docs/fig/stateful_functions_overview-ops.png" width="600px"/>
+</p>
+
+运行时建立在Apache Flink<sup>®</sup>，并具有以下设计原则：
+
+*  __逻辑计算/状态共置：__消息传递，状态访问/更新和函数调用在一起紧密管理。这确保了开箱即用地在高层次支持一致性。 <!--TODO: disambiguate high-level 更抽象的(eg. high-level API) vs. 更高度的(eg. a high level of activity) -->
+
+* __物理计算/状态分离：__可以远程执行函数，并将消息和状态访问作为调用请求的一部分提供。这样，可以像无状态进程一样管理函数，并支持快速扩展，滚动升级和其他常见的操作模式。 
+
+* __语言独立性：__函数调用使用简单的HTTP协议/基于gRPC的协议，因此可以轻松地以各种语言实现函数。  
+
+这使得可以在Kubernetes部署，在FaaS平台上或（微）服务后面执行函数，同时在函数之间提供一致的状态和轻量级消息传递。 
+
+## <a name="getting-started"></a>入门
+
+请按照此处的步骤立即开始使用有状态函数。 
+
+本指南将引导您进行设置以开始开发和测试自己的状态函数（Java）应用程序，并运行现有示例。如果您想使用Python快速开始，
+请查看[StateFun Python SDK](https://github.com/apache/flink-statefun/tree/master/statefun-python-sdk)和[Python Greeter示例](https://github.com/apache/flink-statefun/tree/master/statefun-examples/statefun-python-greeter-example) 。 
+
+### <a name="project-setup"></a>项目设置
+
+前提条件： 
+
+* Docker  
+    
+* Maven 3.5.x 及以上
+    
+* Java 8 及以上
+
+您可以使用提供的快速入门Maven原型快速开始构建Stateful Function有状态函数应用程序： 
+
+```
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.flink \
+  -DarchetypeArtifactId=statefun-quickstart \
+  -DarchetypeVersion=2.2-SNAPSHOT
+```
+
+这使您可以命名新创建的项目。它将以交互方式询问您`` GroupId `` ， 
+`` ArtifactId ``和程序包名称。将有一个与您的`` ArtifactId ``同名的新目录。 
+
+我们建议您将此项目导入到IDE中进行开发和测试。 
+IntelliJ IDEA开箱即用地支持Maven项目。如果使用Eclipse，则`` m2e ``插件允许导入
+Maven项目。某些Eclipse捆绑包默认包含该插件，而另一些则需要您手动安装。 
+
+### <a name="build"></a>建设项目
+
+如果要构建/打包项目，请转到项目目录并运行`` mvn clean package ``命令。您将找到一个包含您的应用程序的JAR文件，以及可能已作为依赖关系添加到该应用程序的任何库：`target/<artifact-id>-<version>.jar`。 
+
+### <a name="ide-harness"></a>从IDE Harness运行
+
+要测试您的应用程序，可以直接在IDE中运行它，而无需进行任何进一步的打包或部署。 

Review comment:
       `可以直接在 IDE 中运行测试你的程序，无需进一步打包或部署`




----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] klion26 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

klion26 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-730868665


   @wangzzu is there any update?


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] klion26 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

klion26 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-726460039


   @wangzzu Do you want to take over this?


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] tzulitai commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

tzulitai commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-703998886


   @carp84 @klion26 
   Thanks for drafting up the translation specifications and driving this!
   I took a look, and overall it looks good to me. Yes, I think we are ready to propose a discussion to the ML lists now.


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] tzulitai commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

tzulitai commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-727117942


   Thanks @wangzzu!
   Please remember to retain @billyrrr original commits, and consider opening a separate PR with your commits on top. 


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] carp84 commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

carp84 commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-710845269


   Thanks for the great job @klion26 !
   
   @billyrrr could you update the PR according to the review suggestions and [translation specification](https://cwiki.apache.org/confluence/display/FLINK/Flink+Translation+Specifications)? Thanks.


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [flink-statefun] igalshilman commented on pull request #131: [FLINK-18968] Translate README.md to Chinese

Posted by GitBox <gi...@apache.org>.

igalshilman commented on pull request #131:
URL: https://github.com/apache/flink-statefun/pull/131#issuecomment-676292291


   Thanks for your contribution @billyrrr!
   Unfortunately I don't speak Chinese so it would be a little difficult to review this.
   I would try to find someone from the Flink community that can help with the review.
   
   
    


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org