本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# Managed Service for Apache Flink 的早期版本信息
<a name="earlier"></a>

**注意**  
Apache Flink 社区不支持 Apache Flink 版本 1.6、1.8 和 1.11 已有三年多时间。我们在 2024 年 6 月和 2024 年 10 月发布有关这一更改的通知，而现在将在 Amazon Managed Service for Apache Flink 中终止对这些版本的支持。  
2025 年 7 月 14 日，我们将停止您的应用程序并将其置于就绪状态。届时您将能够重新启动应用程序，并继续照常使用您的应用程序，但会受到服务限制。
从 2025 年 7 月 28 日起，我们将禁用启动应用程序的功能。在此时间后，您将无法启动或操作 Flink 版本 1.6 应用程序。
我们建议您立即将任何使用 Apache Flink 版本 1.6、1.8 或 1.11 的现有应用程序升级到 Apache Flink 版本 1.20。这是最新支持的 Flink 版本。您可以使用 Amazon Managed Service for Apache Flink 中的就地版本升级功能升级应用程序。有关更多信息，请参阅 [使用 Apache Flink 的就地版本升级](how-in-place-version-upgrades.md)。  
如果您有进一步的问题或疑虑，可以联系 [AWS 支持](https://aws.amazon.com/support)。

**注意**  
Apache Flink 社区不支持 Apache Flink 版本 **1.13** 已有三年多时间。我们现在计划于 **2025 年 10 月 16 日**在 Amazon Managed Service for Apache Flink 中终止对该版本的支持。在此日期之后，您将无法再在 Amazon Managed Service for Apache Flink 中使用 Apache Flink 版本 1.13 创建、启动或运行应用程序。  
您可以使用 Managed Service for Apache Flink 中的就地版本升级功能有状态地升级应用程序。有关更多信息，请参阅 [使用 Apache Flink 的就地版本升级](how-in-place-version-upgrades.md)。

Managed Service for Apache Flink 支持 **1.15.2** 版本，但 Apache Flink 社区不再支持此版本。

**Topics**
+ [将 Apache Flink Kinesis Streams 连接器与之前的 Apache Flink 版本一起使用](#how-creating-apps-building-kinesis)
+ [使用 Apache Flink 1.8.2 构建应用程序](#earlier-buildingapps-1_8)
+ [使用 Apache Flink 1.6.2 构建应用程序](#earlier-buildingapps-1_6)
+ [升级应用程序](#earlier-upgrading)
+ [Apache Flink 1.6.2 和 1.8.2 中的可用连接器](#earlier-connectors)
+ [入门：Flink 1.13.2](#getting-started-1-13)
+ [入门：Flink 1.11.1 - 弃用](#earlier-gs-1_11)
+ [入门：Flink 1.8.2 - 弃用](#earlier-gs-1_8)
+ [入门：Flink 1.6.2 - 弃用](#earlier-gs-1_6)
+ [Managed Service for Apache Flink 的早期版本（旧版）](#legacy-examples)

## 将 Apache Flink Kinesis Streams 连接器与之前的 Apache Flink 版本一起使用
<a name="how-creating-apps-building-kinesis"></a>

在 1.11 版本之前，Apache Flink Kinesis Streams 连接器未包含在 Apache Flink 中。为了使您的应用程序能够将 Apache Flink Kinesis 连接器与以前版本的 Apache Flink 结合使用，您必须下载、编译并安装您的应用程序使用的 Apache Flink 版本。该连接器用于使用来自作为应用程序源的 Kinesis 流的数据，或者将数据写入到用于应用程序输出的 Kinesis 流中。

**注意**  
确保使用 [KPL 版本 0.14.0 ](https://mvnrepository.com/artifact/com.amazonaws/amazon-kinesis-producer/0.14.0)或更高版本构建连接器。

要下载并安装 Apache Flink 1.8.2 版源代码，请执行以下操作：

1. 确保已安装 [Apache Maven](https://maven.apache.org/)，并且 `JAVA_HOME` 环境变量指向 JDK 而不是 JRE。您可以使用以下命令测试 Apache Maven 安装：

   ```
   mvn -version
   ```

1. 下载 Apache Flink 版本 1.8.2 源代码：

   ```
   wget https://archive.apache.org/dist/flink/flink-1.8.2/flink-1.8.2-src.tgz
   ```

1. 解压缩 Apache Flink 源代码：

   ```
   tar -xvf flink-1.8.2-src.tgz
   ```

1. 转到 Apache Flink 源代码目录：

   ```
   cd flink-1.8.2
   ```

1. 编译并安装 Apache Flink：

   ```
   mvn clean install -Pinclude-kinesis -DskipTests
   ```
**注意**  
如果您在微软 Windows 上编译 Flink，则需要添加`-Drat.skip=true`参数。

## 使用 Apache Flink 1.8.2 构建应用程序
<a name="earlier-buildingapps-1_8"></a>

本节包含有关用于构建与 Apache Flink 1.8.2 一起使用的 Managed Service for Apache Flink 应用程序的组件的信息。

使用 Managed Service for Apache Flink 应用程序的下列组件版本：


****  

| 组件 | 版本 | 
| --- | --- | 
| Java | 1.8（建议） | 
| Apache Flink | 1.8.2 | 
| Flink 运行时系统的 Managed Service for Apache Flink (aws-kinesisanalytics-runtime) | 1.0.1 | 
| Managed Service for Apache Flink Flink 连接器 (aws-kinesisanalytics-flink) | 1.0.1 | 
| Apache Maven | 3.1 | 

要使用 Apache Flink 1.8.2 编译应用程序，请使用以下参数运行 Maven：

```
mvn package -Dflink.version=1.8.2
```

有关使用 Apache Flink 版本 1.8.2 的 Managed Service for Apache Flink应用程序的`pom.xml`文件示例，请参阅[适用于 Managed Service for Apache Flink 1.8.2 入门应用程序。](https://github.com/aws-samples/amazon-managed-service-for-apache-flink-examples/blob/master/GettingStarted_1_8/pom.xml)

有关如何为 Managed Service for Apache Flink 应用程序构建和使用应用程序代码的信息，请参阅[创建 应用程序](how-creating-apps.md)。

## 使用 Apache Flink 1.6.2 构建应用程序
<a name="earlier-buildingapps-1_6"></a>

本节包含有关用于构建与 Apache Flink 1.6.2 一起使用的 Managed Service for Apache Flink 应用程序组件的信息。

使用 Managed Service for Apache Flink 应用程序的下列组件版本：


****  

| 组件 | 版本 | 
| --- | --- | 
| Java | 1.8（建议） | 
| AWS Java 开发工具 | 1.11.379 | 
| Apache Flink | 1.6.2 | 
| Flink 运行时系统的 Managed Service for Apache Flink (aws-kinesisanalytics-runtime) | 1.0.1 | 
| Managed Service for Apache Flink Flink 连接器 (aws-kinesisanalytics-flink) | 1.0.1 | 
| Apache Maven | 3.1 | 
| Apache Beam | Apache Flink 1.6.2 不支持。 | 

**注意**  
在使用 Managed Service for Apache Flink 运行时系统版本** 1.0.1** 时，您可以在`pom.xml` 文件中指定 Apache Flink 版本，而不是在编译应用程序代码时使用`-Dflink.version`参数。

有关使用 Apache Flink 版本 1.6.2 的 Managed Service for Apache Flink 应用程序的`pom.xml`文件示例，请参阅[Managed Service for Apache Flink 1.6.2 入门应用程序。](https://github.com/aws-samples/amazon-managed-service-for-apache-flink-examples/blob/master/GettingStarted_1_6/pom.xml)

有关如何为 Managed Service for Apache Flink 应用程序构建和使用应用程序代码的信息，请参阅[创建 应用程序](how-creating-apps.md)。

## 升级应用程序
<a name="earlier-upgrading"></a>

要升级适用于 Apache Flink 的亚马逊托管服务 Flink 应用程序的 Apache Flink 版本，请使用、软件开发工具包或的就地 Apache Flink 版本升级功能。 AWS CLI AWS CloudFormation AWS 管理控制台有关更多信息，请参阅 [使用 Apache Flink 的就地版本升级](how-in-place-version-upgrades.md)。

您可以将此功能与在 Amazon Managed Service for Apache Flink 中使用的任何现有应用程序（处于 `READY` 或 `RUNNING` 状态）结合使用。

## Apache Flink 1.6.2 和 1.8.2 中的可用连接器
<a name="earlier-connectors"></a>

Apache Flink 框架包含用于从各种源中访问数据的连接器。
+ [有关 Apache Flink 1.6.2 框架中可用的连接器的信息，请参阅 Apache Flink [文档 (1.6.2) 中的连接器 (1.6.2)](https://ci.apache.org/projects/flink/flink-docs-release-1.6/dev/connectors/)。](https://ci.apache.org/projects/flink/flink-docs-release-1.6/)
+ [有关 Apache Flink 1.8.2 框架中可用的连接器的信息，请参阅 Apache Flink [文档 (1.8.2) 中的连接器 (1.8.2)](https://ci.apache.org/projects/flink/flink-docs-release-1.8/dev/connectors/)。](https://ci.apache.org/projects/flink/flink-docs-release-1.8/)

## 入门：Flink 1.13.2
<a name="getting-started-1-13"></a>

本节向您介绍适用于 Apache Flink 的托管服务和 API 的基本概念。 DataStream 它介绍了可用于创建和测试应用程序的选项。它还提供了相应的说明以安装所需的工具，以完成本指南中的教程和创建第一个应用程序。

**Topics**
+ [Managed Service for Apache Flink 应用程序组件](#getting-started-components-1-13)
+ [完成练习的先决条件](#setting-up-prerequisites-1-13)
+ [步骤 1：设置 AWS 账户并创建管理员用户](#earlier-gs-1_13-setting-up)
+ [后续步骤](#earlier-gs-1_13-setup-awscli)
+ [步骤 2：设置 AWS Command Line Interface (AWS CLI)](#setup-awscli-1-13)
+ [步骤 3：创建并运行 Managed Service for Apache Flink 应用程序](#get-started-exercise-1-13)
+ [步骤 4：清理 AWS 资源](#getting-started-cleanup-1-13)
+ [步骤 5：后续步骤](#getting-started-next-steps-1-13)

### Managed Service for Apache Flink 应用程序组件
<a name="getting-started-components-1-13"></a>

为了处理数据，适用于 Apache 的托管服务 Flink 应用程序使用 Java/Apache Maven 或 Scala 应用程序，该应用程序使用 Apache Flink 运行时处理输入并生成输出。

Managed Service for Apache Flink 应用程序包含以下组件：
+ **运行时系统属性：**您可以使用*运行时属性* 配置应用程序，而无需重新编译应用程序代码。
+ **源：**应用程序通过*源* 使用数据。源连接器从 Kinesis 数据流、Amazon S3 存储桶等读取数据。有关更多信息，请参阅 [添加流数据源](how-sources.md)。
+ **运算符：**应用程序使用一个或多个*运算符* 以处理数据。运算符可以转换、丰富或聚合数据。有关更多信息，请参阅 [运算符](how-operators.md)。
+ **接收器：**应用程序使用*接收器* 将生成的数据发送到外部源。接收器连接器将数据写入到 Kinesis 数据流、Firehose 流、Amazon S3 存储桶等。有关更多信息，请参阅 [使用接收器写入数据](how-sinks.md)。

在创建、编译和打包您的应用程序代码后，您可以将代码包上传到 Amazon Simple Storage Service (Amazon S3) 存储桶中。然后，您创建一个 Managed Service for Apache Flink 应用程序。您在代码包位置中传入一个 Kinesis 数据流以作为流数据源，它通常是接收应用程序处理的数据的流或文件位置。

### 完成练习的先决条件
<a name="setting-up-prerequisites-1-13"></a>

要完成本指南中的步骤，您必须满足以下条件：
+ [Java 开发工具包 (JDK) 版本 11](https://www.oracle.com/java/technologies/javase-jdk11-downloads.html)。设置 `JAVA_HOME` 环境变量，使其指向您的 JDK 安装位置。
+ 我们建议您使用开发环境（如 [Eclipse Java Neon](http://www.eclipse.org/downloads/packages/release/neon/3) 或 [IntelliJ Idea](https://www.jetbrains.com/idea/)）来开发和编译您的应用程序。
+ [Git 客户端](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。如果尚未安装 Git 客户端，请安装它。
+ [Apache Maven 编译器插件](https://maven.apache.org/plugins/maven-compiler-plugin/)。Maven 必须位于您的有效路径中。要测试您的 Apache Maven 安装，请输入以下内容：

  ```
  $ mvn -version
  ```

要开始，请转到[设置 AWS 账户并创建管理员用户](setting-up.md)。

### 步骤 1：设置 AWS 账户并创建管理员用户
<a name="earlier-gs-1_13-setting-up"></a>

#### 注册获取 AWS 账户
<a name="sign-up-for-aws"></a>

如果您没有 AWS 账户，请完成以下步骤来创建一个。

**要注册 AWS 账户**

1. 打开 [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup)。

1. 按照屏幕上的说明操作。

   在注册时，将接到电话或收到短信，要求使用电话键盘输入一个验证码。

   当您注册时 AWS 账户，就会创建*AWS 账户根用户*一个。根用户有权访问该账户中的所有 AWS 服务 和资源。作为最佳安全实践，请为用户分配管理访问权限，并且只使用根用户来执行[需要根用户访问权限的任务](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)。

AWS 注册过程完成后会向您发送一封确认电子邮件。在任何时候，您都可以通过转至 [https://aws.amazon.com/](https://aws.amazon.com/) 并选择 **My Account (我的账户)** 来查看当前的账户活动并管理您的账户。

#### 创建具有管理访问权限的用户
<a name="create-an-admin"></a>

注册后，请保护您的安全 AWS 账户 AWS 账户根用户 AWS IAM Identity Center，启用并创建管理用户，这样您就不会使用 root 用户执行日常任务。

**保护你的 AWS 账户根用户**

1.  选择 **Root 用户**并输入您的 AWS 账户 电子邮件地址，以账户所有者的身份登录。[AWS 管理控制台](https://console.aws.amazon.com/)在下一页上，输入您的密码。

   要获取使用根用户登录方面的帮助，请参阅《AWS 登录 用户指南》**中的 [Signing in as the root user](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)。

1. 为您的根用户启用多重身份验证（MFA）。

   有关说明，请参阅 I [A *M* 用户指南中的为 AWS 账户 根用户启用虚拟 MFA 设备（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)。

**创建具有管理访问权限的用户**

1. 启用 IAM Identity Center。

   有关说明，请参阅**《AWS IAM Identity Center 用户指南》中的[启用 AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)。

1. 在 IAM Identity Center 中，为用户授予管理访问权限。

   有关使用 IAM Identity Center 目录 作为身份源的教程，请参阅《[用户*指南》 IAM Identity Center 目录中的使用默认设置配置AWS IAM Identity Center 用户*访问权限](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)。

**以具有管理访问权限的用户身份登录**
+ 要使用您的 IAM Identity Center 用户身份登录，请使用您在创建 IAM Identity Center 用户时发送到您的电子邮件地址的登录 URL。

  有关使用 IAM Identity Center 用户[登录的帮助，请参阅*AWS 登录 用户指南*中的登录 AWS 访问门户](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)。

**将访问权限分配给其他用户**

1. 在 IAM Identity Center 中，创建一个权限集，该权限集遵循应用最低权限的最佳做法。

   有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)。

1. 将用户分配到一个组，然后为该组分配单点登录访问权限。

   有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)。

#### 授权以编程方式访问
<a name="setting-up-access-gs-13"></a>

如果用户想在 AWS 外部进行交互，则需要编程访问权限 AWS 管理控制台。授予编程访问权限的方式取决于正在访问的用户类型 AWS。

要向用户授予编程式访问权限，请选择以下选项之一。


****  

| 哪个用户需要编程式访问权限？ | 目的 | 方式 | 
| --- | --- | --- | 
| IAM | （推荐）使用控制台凭证作为临时凭证，签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照您希望使用的界面的说明进行操作。[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html) | 
| 人力身份<br />（在 IAM Identity Center 中管理的用户） | 使用临时证书签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照您希望使用的界面的说明进行操作。[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html) | 
| IAM | 使用临时证书签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照 IAM 用户指南中的将[临时证书与 AWS 资源配合使用](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)中的说明进行操作。 | 
| IAM | （不推荐使用）使用长期凭证签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照您希望使用的界面的说明进行操作。[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html) | 

#### 后续步骤
<a name="earlier-gs-1_13-setting-up-next-step-2"></a>

[设置 AWS Command Line Interface (AWS CLI)](#earlier-gs-1_13-setup-awscli)

### 后续步骤
<a name="earlier-gs-1_13-setup-awscli"></a>

[步骤 2：设置 AWS Command Line Interface (AWS CLI)](#setup-awscli-1-13)

### 步骤 2：设置 AWS Command Line Interface (AWS CLI)
<a name="setup-awscli-1-13"></a>

在此步骤中，您将下载并配置为与适用于 Apache Flink 的托管服务一起使用。 AWS CLI 

**注意**  
本指南中的入门练习假定您使用账户中的管理员凭证 (`adminuser`) 来执行这些操作。

**注意**  
如果您已经 AWS CLI 安装了，则可能需要升级才能获得最新功能。有关更多信息，请参阅AWS Command Line Interface 《用户指南》**中的[安装 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)。要检查的版本 AWS CLI，请运行以下命令：  

```
aws --version
```
本教程中的练习需要以下 AWS CLI 版本或更高版本：  

```
aws-cli/1.16.63
```

**要设置 AWS CLI**

1. 下载并配置 AWS CLI。有关说明，请参阅《AWS Command Line Interface 用户指南》**中的以下主题：
   + [安装 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html)
   + [配置 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)

1. 在文件中为管理员用户添加已命名的配置 AWS CLI `config`文件。在执行 AWS CLI 命令时，您将使用此配置文件。有关命名配置文件的更多信息，请参阅 *AWS Command Line Interface 用户指南*中的[命名配置文件](https://docs.aws.amazon.com/cli/latest/userguide/cli-multiple-profiles.html)。

   ```
   [profile adminuser]
   aws_access_key_id = {{adminuser access key ID}}
   aws_secret_access_key = {{adminuser secret access key}}
   region = {{aws-region}}
   ```

   有关可用 AWS 区域的列表，请参阅中的[区域和终端节点*Amazon Web Services 一般参考*](https://docs.aws.amazon.com/general/latest/gr/rande.html)。
**注意**  
本教程中的示例代码和命令使用美国西部（俄勒冈州）区域。要使用不同的区域，请将本教程的代码和命令中的区域更改为要使用的区域。

1. 在命令提示符处输入以下帮助命令来验证设置：

   ```
   aws help
   ```

设置 AWS 帐户和之后 AWS CLI，您可以尝试下一个练习，即配置示例应用程序并测试端到端设置。

#### 后续步骤
<a name="setup-awscli-next-step-3-1-13"></a>

[步骤 3：创建并运行 Managed Service for Apache Flink 应用程序](#get-started-exercise-1-13)

### 步骤 3：创建并运行 Managed Service for Apache Flink 应用程序
<a name="get-started-exercise-1-13"></a>

在本练习中，您将创建面向应用程序的适用于 Apache Flink 的托管服务，并将数据流作为源和接收器。

**Topics**
+ [创建两个 Amazon Kinesis 数据流](#get-started-exercise-1-1-13)
+ [将示例记录写入输入流](#get-started-exercise-2-1-13)
+ [下载并检查 Apache Flink 流式处理 Java 代码](#get-started-exercise-5-1-13)
+ [编译应用程序代码](#get-started-exercise-5.5-1-13)
+ [上传 Apache Flink 流式处理 Java 代码](#get-started-exercise-6-1-13)
+ [创建并运行适用于 Apache Flink 的托管服务](#get-started-exercise-7-1-13)
+ [后续步骤](#get-started-exercise-next-step-4-1-13)

#### 创建两个 Amazon Kinesis 数据流
<a name="get-started-exercise-1-1-13"></a>

在为本练习创建 Managed Service for Apache Flink 应用程序之前，请创建两个 Kinesis 数据流（`ExampleInputStream`和`ExampleOutputStream`）。您的应用程序将这些数据流用于应用程序源和目标流。

可以使用 Amazon Kinesis 控制台或以下 AWS CLI 命令创建这些流。有关控制台说明，请参阅 *Amazon Kinesis Data Streams 开发人员指南*中的[创建和更新数据流](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html)。

**创建数据流 (AWS CLI)**

1. 要创建第一个直播 (`ExampleInputStream`)，请使用以下 Amazon Kinesis 命令`create-stream` AWS CLI 。

   ```
   $ aws kinesis create-stream \
   --stream-name ExampleInputStream \
   --shard-count 1 \
   --region us-west-2 \
   --profile adminuser
   ```

1. 要创建应用程序用来写入输出的第二个流，请运行同一命令（将流名称更改为 `ExampleOutputStream`）。

   ```
   $ aws kinesis create-stream \
   --stream-name ExampleOutputStream \
   --shard-count 1 \
   --region us-west-2 \
   --profile adminuser
   ```

#### 将示例记录写入输入流
<a name="get-started-exercise-2-1-13"></a>

在本节中，您使用 Python 脚本将示例记录写入流，以供应用程序处理。

**注意**  
此部分需要 [AWS SDK for Python (Boto)](https://aws.amazon.com/developers/getting-started/python/)。

1. 使用以下内容创建名为 `stock.py` 的文件：

   ```
       import datetime
       import json
       import random
       import boto3
       STREAM_NAME = "ExampleInputStream"
       def get_data():
           return {
               'event_time': datetime.datetime.now().isoformat(),
               'ticker': random.choice(['AAPL', 'AMZN', 'MSFT', 'INTC', 'TBV']),
               'price': round(random.random() * 100, 2)}
       def generate(stream_name, kinesis_client):
           while True:
               data = get_data()
               print(data)
               kinesis_client.put_record(
                   StreamName=stream_name,
                   Data=json.dumps(data),
                   PartitionKey="partitionkey")
       if __name__ == '__main__':
           generate(STREAM_NAME, boto3.client('kinesis', region_name='us-west-2'))
   ```

1. 在本教程的后面部分，您运行 `stock.py` 脚本，以将数据发送到应用程序。

   ```
   $ python stock.py
   ```

#### 下载并检查 Apache Flink 流式处理 Java 代码
<a name="get-started-exercise-5-1-13"></a>

此示例的 Java 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/GettingStarted` 目录。

请注意有关应用程序代码的以下信息：
+ [项目对象模型 (pom.xml)](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html) 文件包含有关应用程序的配置和依赖项的信息，包括 Managed Service for Apache Flink 库。
+ `BasicStreamingJob.java` 文件包含定义应用程序功能的 `main` 方法。
+ 应用程序使用 Kinesis 源从源流中进行读取。以下代码段创建 Kinesis 源：

  ```
  return env.addSource(new FlinkKinesisConsumer<>(inputStreamName,
                  new SimpleStringSchema(), inputProperties));
  ```
+ 您的应用程序使用 `StreamExecutionEnvironment` 对象创建源和接收连接器以访问外部资源。
+ 该应用程序将使用静态属性创建源和接收连接器。要使用动态应用程序属性，请使用 `createSourceFromApplicationProperties` 和 `createSinkFromApplicationProperties` 方法以创建连接器。这些方法读取应用程序的属性来配置连接器。

  有关运行时系统属性的更多信息，请参阅[使用运行时属性](how-properties.md)。

#### 编译应用程序代码
<a name="get-started-exercise-5.5-1-13"></a>

在本节中，您使用 Apache Maven 编译器创建应用程序的 Java 代码。有关安装 Apache Maven 和 Java 开发工具包 (JDK) 的信息，请参阅[满足完成练习的先决条件](getting-started.md#setting-up-prerequisites)。

**编译应用程序代码**

1. 要使用您的应用程序代码，您将其编译和打包成 JAR 文件。您可以通过两种方式之一编译和打包您的代码：
   + 使用命令行 Maven 工具。在包含 `pom.xml` 文件的目录中通过运行以下命令创建您的 JAR 文件：

     ```
     mvn package -Dflink.version=1.13.2
     ```
   + 设置开发环境。有关详细信息，请参阅您的开发环境文档。
**注意**  
提供的源代码依赖于 Java 11 中的库。

   您可以作为 JAR 文件上传您的包，也可以将包压缩为 ZIP 文件并上传。如果您使用创建应用程序 AWS CLI，则需要指定代码内容类型（JAR 或 ZIP）。

1. 如果编译时出错，请验证 `JAVA_HOME` 环境变量设置正确。

如果应用程序成功编译，则创建以下文件：

`target/aws-kinesis-analytics-java-apps-1.0.jar`

#### 上传 Apache Flink 流式处理 Java 代码
<a name="get-started-exercise-6-1-13"></a>

在本节中，您创建 Amazon Simple Storage Service (Amazon S3) 存储桶并上传应用程序代码。

**上传应用程序代码**

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **创建存储桶 **。

1. 在 **存储桶名称** 字段中输入 **ka-app-code-{{<username>}}**。将后缀（如您的用户名）添加到存储桶名称，以使其具有全局唯一性。选择 **下一步**。

1. 在**配置选项**步骤中，让设置保持原样，然后选择**下一步**。

1. 在**设置权限**步骤中，让设置保持原样，然后选择**下一步**。

1. 选择 **创建存储桶 **。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-bucke-{{<username>}}** bucket，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `aws-kinesis-analytics-java-apps-1.0.jar` 文件。选择 **下一步**。

1. 您无需更改该对象的任何设置，因此，请选择 **上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

#### 创建并运行适用于 Apache Flink 的托管服务
<a name="get-started-exercise-7-1-13"></a>

您可以使用控制台或 AWS CLI创建和运行适用于 Apache Flink 的托管服务的应用程序。

**注意**  
当您使用控制台创建应用程序时，系统会为您创建您的 AWS Identity and Access Management (IAM) 和 A CloudWatch mazon Logs 资源。使用创建应用程序时 AWS CLI，可以单独创建这些资源。

**Topics**
+ [创建并运行应用程序（控制台）](#get-started-exercise-7-console-1-13)
+ [创建并运行应用程序（AWS CLI）](#get-started-exercise-7-cli-1-13)

##### 创建并运行应用程序（控制台）
<a name="get-started-exercise-7-console-1-13"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="get-started-exercise-7-console-create-1-13"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**描述**，输入 **My java test app**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
   + 将版本下拉列表保留为 **Apache Flink 版本 1.13**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 编辑 IAM 策略
<a name="get-started-exercise-7-console-iam-1-13"></a>

编辑 IAM policy 以添加访问 Kinesis 数据流的权限。

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:s3:::ka-app-code-{{username}}/aws-kinesis-analytics-java-apps-1.0.jar"
               ]
           },
           {
               "Sid": "DescribeLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogStreams"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
               ]
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": [
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
               ]
           }{{,
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteOutputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
           }}}
       ]
   }
   ```

------

##### 配置应用程序
<a name="get-started-exercise-7-console-configure-1-13"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**aws-kinesis-analytics-java-apps-1.0.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 输入以下信息：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 Amazon CloudWatch 日志时，适用于 Apache Flink 的托管服务会为您创建一个日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`

##### 运行应用程序
<a name="get-started-exercise-7-console-run-1-13"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

##### 停止应用程序
<a name="get-started-exercise-7-console-stop-1-13"></a>

在**MyApplication**页面上，选择 “**停止**”。确认该操作。

##### 更新应用程序
<a name="get-started-exercise-7-console-update-1-13"></a>

使用控制台，您可以更新应用程序设置，例如应用程序属性、监控设置，或应用程序 JAR 文件的位置和文件名。如果您需要更新应用程序代码，您还可以从 Amazon S3 存储桶重新加载应用程序 JAR。

在**MyApplication**页面上，选择**配置**。更新应用程序设置，然后选择**更新**。

##### 创建并运行应用程序（AWS CLI）
<a name="get-started-exercise-7-cli-1-13"></a>

在本节中，您将使用创建和运行适用 AWS CLI 于 Apache Flink 的托管服务应用程序。适用于 Apache Flink 的托管服务使用该`kinesisanalyticsv2` AWS CLI 命令为 Apache Flink 应用程序创建托管服务并与之交互。

##### 创建权限策略
<a name="get-started-exercise-7-cli-policy-1-13"></a>

**注意**  
您必须为应用程序创建一个权限策略和角色。如果未创建这些 IAM 资源，应用程序将无法访问其数据和日志流。

首先，使用两个语句创建权限策略：一个语句授予对源流执行 `read` 操作的权限，另一个语句授予对接收器流执行 `write` 操作的权限。然后，将策略附加到 IAM 角色（下一部分中将创建此角色）。因此，在适用于 Apache Flink 的托管服务代入该角色时，服务具有必要的权限从源流进行读取和写入接收器流。

使用以下代码创建 `AKReadSourceStreamWriteSinkStream` 权限策略。将 `{{username}}` 替换为您用于创建 Amazon S3 存储桶来存储应用程序代码的用户名。将 Amazon 资源名称 (ARN) 中的账户 ID (`{{012345678901}}`) 替换为您的账户 ID。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "S3",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:GetObjectVersion"
            ],
            "Resource": ["arn:aws:s3:::ka-app-code-{{username}}",
                "arn:aws:s3:::ka-app-code-{{username}}/*"
            ]
        },
        {
            "Sid": "ReadInputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
        },
        {
            "Sid": "WriteOutputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
        }
    ]
}
```

------

有关创建权限策略的分步说明，请参阅*《IAM 用户指南》*中的[教程：创建和附加您的第一个客户管理型策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html#part-two-create-policy)。

**注意**  
要访问其他 Amazon 服务，可以使用 适用于 Java 的 AWS SDK。Managed Service for Apache Flink 会自动将软件开发工具包所需的证书设置为与您的应用程序关联的服务执行 IAM 角色的证书。无需执行其他步骤。

##### 创建一个 IAM 角色
<a name="get-started-exercise-7-cli-role-1-13"></a>

在本节中，您将创建一个 IAM 角色，应用程序的 Managed Service for Apache Flink可以代入此角色来读取源流和写入接收器流。

权限不足时，Managed Service for Apache Flink 无法访问您的串流。您通过 IAM 角色授予这些权限。每个 IAM 角色附加了两种策略。此信任策略授予适用于 Apache Flink 的托管服务代入该角色的权限，权限策略确定适用于 Apache Flink 的托管服务代入这个角色后可以执行的操作。

您将在上一部分中创建的权限策略附加到此角色。

**创建 IAM 角色**

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航窗格中，选择 **角色** 和 **创建角色**。

1. 在 **选择受信任实体的类型** 下，选择 **AWS 服务**。在 **选择将使用此角色的服务** 下，选择 **Kinesis**。在**选择您的使用案例**下，选择 **Kinesis Analytics**。

   选择**下一步: 权限**。

1. 在 **附加权限策略** 页面上，选择 **下一步: 审核**。在创建角色后，您可以附加权限策略。

1. 在 **创建角色** 页面上，输入**MF-stream-rw-role**作为**角色名称**。选择 **创建角色**。

   现在，您已经创建了一个名为 `MF-stream-rw-role` 的新 IAM 角色。接下来，您更新角色的信任和权限策略。

1. 将权限策略附加到角色。
**注意**  
对于本练习，适用于 Apache Flink 的托管服务代入此角色，以便同时从 Kinesis 数据流（源）读取数据和将输出写入另一个 Kinesis 数据流。因此，您附加在上一步（[创建权限策略](#get-started-exercise-7-cli-policy-1-13)）中创建的策略。

   1. 在 **摘要** 页上，选择 **权限** 选项卡。

   1. 选择**附加策略**。

   1. 在搜索框中，输入 **AKReadSourceStreamWriteSinkStream**（您在上一部分中创建的策略）。

   1. 选择**AKReadSourceStreamWriteSinkStream**策略，然后选择**附加策略**。

现在，您已经创建了应用程序用来访问资源的服务执行角色。记下新角色的 ARN。

有关创建角色的分步说明，请参阅*《IAM 用户指南》*中的在您的[中创建 IAM 角色（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html#roles-creatingrole-user-console)。

##### 创建 Managed Service for Apache Flink 应用程序
<a name="get-started-exercise-7-cli-create-1-13"></a>

1. 将以下 JSON 代码保存到名为 `create_request.json` 的文件中。将示例角色 ARN 替换为您之前创建的角色的 ARN。将存储桶 ARN 后缀 (`{{username}}`) 替换为在前一部分中选择的后缀。将服务执行角色中的示例账户 ID (`{{012345678901}}`) 替换为您的账户 ID。

   ```
   {
       "ApplicationName": "test",
       "ApplicationDescription": "my java test app",
       "RuntimeEnvironment": "FLINK-1_15",
       "ServiceExecutionRole": "arn:aws:iam::{{012345678901}}:role/MF-stream-rw-role",
       "ApplicationConfiguration": {
           "ApplicationCodeConfiguration": {
               "CodeContent": {
                   "S3ContentLocation": {
                       "BucketARN": "arn:aws:s3:::ka-app-code-{{username}}",
                       "FileKey": "aws-kinesis-analytics-java-apps-1.0.jar"
                   }
               },
               "CodeContentType": "ZIPFILE"
           },
           "EnvironmentProperties":  { 
            "PropertyGroups": [ 
               { 
                  "PropertyGroupId": "ProducerConfigProperties",
                  "PropertyMap" : {
                       "flink.stream.initpos" : "LATEST",
                       "aws.region" : "us-west-2",
                       "AggregationEnabled" : "false"
                  }
               },
               { 
                  "PropertyGroupId": "ConsumerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2"
                  }
               }
            ]
         }
       }
   }
   ```

1. 使用上述请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html) 操作来创建应用程序：

   ```
   aws kinesisanalyticsv2 create-application --cli-input-json file://create_request.json
   ```

应用程序现已创建。您在下一步中启动应用程序。

##### 启动应用程序
<a name="get-started-exercise-7-cli-start-1-13"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序。

**启动应用程序**

1. 将以下 JSON 代码保存到名为 `start_request.json` 的文件中。

   ```
   {
       "ApplicationName": "test",
       "RunConfiguration": {
           "ApplicationRestoreConfiguration": { 
            "ApplicationRestoreType": "RESTORE_FROM_LATEST_SNAPSHOT"
            }
       }
   }
   ```

1. 使用上述请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序：

   ```
   aws kinesisanalyticsv2 start-application --cli-input-json file://start_request.json
   ```

应用程序正在运行。您可以在亚马逊 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 停止应用程序
<a name="get-started-exercise-7-cli-stop-1-13"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序。

**停止应用程序**

1. 将以下 JSON 代码保存到名为 `stop_request.json` 的文件中。

   ```
   {
      "ApplicationName": "test"
   }
   ```

1. 使用下面的请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序：

   ```
   aws kinesisanalyticsv2 stop-application --cli-input-json file://stop_request.json
   ```

应用程序现已停止。

##### 添加 CloudWatch 日志选项
<a name="get-started-exercise-7-cli-cw-1-13"></a>

您可以使用将 Amazon CloudWatch 日志流 AWS CLI 添加到您的应用程序中。有关在应用程序中使用 CloudWatch Logs 的信息，请参阅[设置 Managed Service for Apache Flink 中的应用程序日志记录](cloudwatch-logs.md)。

##### 更新环境属性
<a name="get-started-exercise-7-cli-update-env-1-13"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) 操作更改应用程序的环境属性，而无需重新编译应用程序代码。在该示例中，您更改源流和目标流的区域。

**更新应用程序的环境属性**

1. 将以下 JSON 代码保存到名为 `update_properties_request.json` 的文件中。

   ```
   {"ApplicationName": "test",
      "CurrentApplicationVersionId": 1,
      "ApplicationConfigurationUpdate": { 
         "EnvironmentPropertyUpdates": { 
            "PropertyGroups": [ 
               { 
                  "PropertyGroupId": "ProducerConfigProperties",
                  "PropertyMap" : {
                       "flink.stream.initpos" : "LATEST",
                       "aws.region" : "us-west-2",
                       "AggregationEnabled" : "false"
                  }
               },
               { 
                  "PropertyGroupId": "ConsumerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2"
                  }
               }
            ]
         }
      }
   }
   ```

1. 使用前面的请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) 操作以更新环境属性：

   ```
   aws kinesisanalyticsv2 update-application --cli-input-json file://update_properties_request.json
   ```

##### 更新应用程序代码
<a name="get-started-exercise-7-cli-update-code-1-13"></a>

当您需要使用新版本的代码包更新应用程序代码时，可以使用[https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) AWS CLI 操作。

**注意**  
要使用相同的文件名加载新版本的应用程序代码，您必须指定新的对象版本。有关使用 Amazon S3 对象版本的更多信息，请参阅[启用或禁用版本控制](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/enable-versioning.html)。

要使用 AWS CLI，请从 Amazon S3 存储桶中删除之前的代码包，上传新版本，然后调用`UpdateApplication`，指定相同的 Amazon S3 存储桶和对象名称以及新的对象版本。应用程序将使用新的代码包重新启动。

以下示例 `UpdateApplication` 操作请求重新加载应用程序代码并重新启动应用程序。将 `CurrentApplicationVersionId` 更新为当前的应用程序版本。您可以使用 `ListApplications` 或 `DescribeApplication` 操作检查当前的应用程序版本。使用您在本节中选择的后缀更新存储桶名称后缀 ({{<username>}})。[创建两个 Amazon Kinesis 数据流](get-started-exercise.md#get-started-exercise-1)

```
{
    "ApplicationName": "test",
    "CurrentApplicationVersionId": {{1}},
    "ApplicationConfigurationUpdate": {
        "ApplicationCodeConfigurationUpdate": {
            "CodeContentUpdate": {
                "S3ContentLocationUpdate": {
                    "BucketARNUpdate": "arn:aws:s3:::ka-app-code-{{username}}",
                    "FileKeyUpdate": "aws-kinesis-analytics-java-apps-1.0.jar",
                    "ObjectVersionUpdate": "{{SAMPLEUehYngP87ex1nzYIGYgfhypvDU}}"
                }
            }
        }
    }
}
```

#### 后续步骤
<a name="get-started-exercise-next-step-4-1-13"></a>

[步骤 4：清理 AWS 资源](#getting-started-cleanup-1-13)

### 步骤 4：清理 AWS 资源
<a name="getting-started-cleanup-1-13"></a>

本节包括清理入门教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#getting-started-cleanup-app-1-13)
+ [删除您的 Kinesis 数据流](#getting-started-cleanup-stream-1-13)
+ [删除您的 Amazon S3 对象和存储桶](#getting-started-cleanup-s3-1-13)
+ [删除您的 IAM 资源](#getting-started-cleanup-iam-1-13)
+ [删除您的 CloudWatch 资源](#getting-started-cleanup-cw-1-13)
+ [后续步骤](#getting-started-cleanup-next-step-5-1-13)

#### 删除 Managed Service for Apache Flink 应用程序
<a name="getting-started-cleanup-app-1-13"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 “适用于 Apache Flink 的托管服务” 面板中，选择。**MyApplication**

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

#### 删除您的 Kinesis 数据流
<a name="getting-started-cleanup-stream-1-13"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

1. 在 **Kinesis 直播**页面中 **ExampleOutputStream**，选择，选择**操作**，选择**删除**，然后确认删除。

#### 删除您的 Amazon S3 对象和存储桶
<a name="getting-started-cleanup-s3-1-13"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

#### 删除您的 IAM 资源
<a name="getting-started-cleanup-iam-1-13"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

#### 删除您的 CloudWatch 资源
<a name="getting-started-cleanup-cw-1-13"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

#### 后续步骤
<a name="getting-started-cleanup-next-step-5-1-13"></a>

[步骤 5：后续步骤](#getting-started-next-steps-1-13)

### 步骤 5：后续步骤
<a name="getting-started-next-steps-1-13"></a>

现在，您已经创建并运行了 Managed Service for Apache Flink 应用程序，请参阅以下资源，了解更多 Managed Service for Apache Flink 解决方案。
+ **[适用于 Amazon Kinesis](https://aws.amazon.com/solutions/implementations/aws-streaming-data-solution-for-amazon-kinesis/) 的 AWS 流数据解决方案：**适用于 Amazon Kinesis 的流数据解决方案可自动配置 AWS 必要的服务，以便轻松捕获、存储、处理和交付流数据。 AWS 该解决方案为解决流数据用例提供了多种选项。Managed Service for Apache Flink 选项提供了一个端到端的流式传输 ETL 示例，演示了一个对模拟的纽约出租车数据运行分析操作的真实应用程序。该解决方案设置了所有必要的 AWS 资源，例如 IAM 角色和策略、 CloudWatch 控制面板和 CloudWatch 警报。
+ **[AWS 适用于 Amazon MSK](https://aws.amazon.com/solutions/implementations/aws-streaming-data-solution-for-amazon-msk/) 的 AWS 流数据解决方案：**适用于 Amazon MSK 的流数据解决方案提供了数据流经生产者、流式存储、消费者和目的地的 AWS CloudFormation 模板。
+ **[带有 Apache Flink 和 Apache Kafka 的 Click](https://amazonmsk-labs.workshop.aws/en/mskkdaflinklab.html)** stream Lab：点击流用例的端到端实验室，使用适用于 Apache Kafka 的Amazon托管流媒体进行流存储，使用 Managed Service for Apache Flink 进行流处理。
+ **[Amazon Managed Service for Apache Flink 讲习会](https://catalog.workshops.aws/managed-flink)：**在此讲习会中，您将构建端到端的流媒体架构，以近乎实时的方式摄取、分析和可视化流媒体数据。您着手改善纽约市一家出租车公司的运营。您可以近乎实时地分析纽约市出租车队的遥测数据，以优化其车队运营。
+ **[学习 Flink：动手训练](https://ci.apache.org/projects/flink/flink-docs-master/learn-flink/)：**Apache Flink 官方入门培训，让您开始编写可扩展的流媒体 ETL、分析和事件驱动的应用程序。
**注意**  
请注意，Managed Service for Apache Flink 不支持本培训中使用的 Apache Flink 版本 (1.12)。你可以在适用于 Apache Flink 的 Flink 托管服务中使用 Flink 1.15.2。

## 入门：Flink 1.11.1 - 弃用
<a name="earlier-gs-1_11"></a>

**注意**  
Apache Flink 社区不支持 Apache Flink 版本 **1.6、1.8 和 1.11** 已有三年多时间。我们计划于 **2024 年 11 月 5 日**在 Amazon Managed Service for Apache Flink 中弃用这些版本。从该日期起，您将无法创建这些 Flink 版本的新应用程序。在此时间，您可以继续运行现有应用程序。您可以使用 Amazon Managed Service for Apache Flink 中的就地版本升级功能有状态地升级应用程序。有关更多信息，请参阅 [使用 Apache Flink 的就地版本升级](how-in-place-version-upgrades.md)。

本主题包含一个使用 Apache Flink 1.11.1 的 [教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md) 教程版本。

本节向您介绍适用于 Apache Flink 的托管服务和 API 的基本概念。 DataStream 它介绍了可用于创建和测试应用程序的选项。它还提供了相应的说明以安装所需的工具，以完成本指南中的教程和创建第一个应用程序。

**Topics**
+ [Managed Service for Apache Flink 应用程序组件](#earlier-gs-1_11-components)
+ [完成练习的先决条件](#earlier-gs-1_11-setting-up-prerequisites)
+ [步骤 1：设置 AWS 账户并创建管理员用户](#earlier-gs-1_11-setting-up)
+ [步骤 2：设置 AWS Command Line Interface (AWS CLI)](#earlier-gs-1_11-setup-awscli)
+ [步骤 3：创建并运行 Managed Service for Apache Flink 应用程序](#earlier-gs-1_11-get-started-exercise)
+ [步骤 4：清理 AWS 资源](#earlier-gs-1_11-cleanup)
+ [步骤 5：后续步骤](#earlier-gs-1_11-next-steps)

### Managed Service for Apache Flink 应用程序组件
<a name="earlier-gs-1_11-components"></a>

为了处理数据，适用于 Apache 的托管服务 Flink 应用程序使用 Java/Apache Maven 或 Scala 应用程序，该应用程序使用 Apache Flink 运行时处理输入并生成输出。

Managed Service for Apache Flink 应用程序包含以下组件：
+ **运行时系统属性：**您可以使用*运行时属性* 配置应用程序，而无需重新编译应用程序代码。
+ **源：**应用程序通过*源* 使用数据。源连接器从 Kinesis 数据流、Amazon S3 存储桶等读取数据。有关更多信息，请参阅 [添加流数据源](how-sources.md)。
+ **运算符：**应用程序使用一个或多个*运算符* 以处理数据。运算符可以转换、丰富或聚合数据。有关更多信息，请参阅 [运算符](how-operators.md)。
+ **接收器：**应用程序使用*接收器* 将生成的数据发送到外部源。接收器连接器将数据写入到 Kinesis 数据流、Firehose 流、Amazon S3 存储桶等。有关更多信息，请参阅 [使用接收器写入数据](how-sinks.md)。

在创建、编译和打包您的应用程序代码后，您可以将代码包上传到 Amazon Simple Storage Service (Amazon S3) 存储桶中。然后，您创建一个 Managed Service for Apache Flink 应用程序。您在代码包位置中传入一个 Kinesis 数据流以作为流数据源，它通常是接收应用程序处理的数据的流或文件位置。

### 完成练习的先决条件
<a name="earlier-gs-1_11-setting-up-prerequisites"></a>

要完成本指南中的步骤，您必须满足以下条件：
+ [Java 开发工具包 (JDK) 版本 11](https://www.oracle.com/java/technologies/javase-jdk11-downloads.html)。设置 `JAVA_HOME` 环境变量，使其指向您的 JDK 安装位置。
+ 我们建议您使用开发环境（如 [Eclipse Java Neon](http://www.eclipse.org/downloads/packages/release/neon/3) 或 [IntelliJ Idea](https://www.jetbrains.com/idea/)）来开发和编译您的应用程序。
+ [Git 客户端](https://git-scm.com/book/en/v2/earlier-gs-1_11-Installing-Git)。如果尚未安装 Git 客户端，请安装它。
+ [Apache Maven 编译器插件](https://maven.apache.org/plugins/maven-compiler-plugin/)。Maven 必须位于您的有效路径中。要测试您的 Apache Maven 安装，请输入以下内容：

  ```
  $ mvn -version
  ```

要开始，请转到[设置 AWS 账户并创建管理员用户](setting-up.md)。

### 步骤 1：设置 AWS 账户并创建管理员用户
<a name="earlier-gs-1_11-setting-up"></a>

#### 注册获取 AWS 账户
<a name="sign-up-for-aws"></a>

如果您没有 AWS 账户，请完成以下步骤来创建一个。

**要注册 AWS 账户**

1. 打开 [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup)。

1. 按照屏幕上的说明操作。

   在注册时，将接到电话或收到短信，要求使用电话键盘输入一个验证码。

   当您注册时 AWS 账户，就会创建*AWS 账户根用户*一个。根用户有权访问该账户中的所有 AWS 服务 和资源。作为最佳安全实践，请为用户分配管理访问权限，并且只使用根用户来执行[需要根用户访问权限的任务](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)。

AWS 注册过程完成后会向您发送一封确认电子邮件。在任何时候，您都可以通过转至 [https://aws.amazon.com/](https://aws.amazon.com/) 并选择 **My Account (我的账户)** 来查看当前的账户活动并管理您的账户。

#### 创建具有管理访问权限的用户
<a name="create-an-admin"></a>

注册后，请保护您的安全 AWS 账户 AWS 账户根用户 AWS IAM Identity Center，启用并创建管理用户，这样您就不会使用 root 用户执行日常任务。

**保护你的 AWS 账户根用户**

1.  选择 **Root 用户**并输入您的 AWS 账户 电子邮件地址，以账户所有者的身份登录。[AWS 管理控制台](https://console.aws.amazon.com/)在下一页上，输入您的密码。

   要获取使用根用户登录方面的帮助，请参阅《AWS 登录 用户指南》**中的 [Signing in as the root user](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)。

1. 为您的根用户启用多重身份验证（MFA）。

   有关说明，请参阅 I [A *M* 用户指南中的为 AWS 账户 根用户启用虚拟 MFA 设备（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)。

**创建具有管理访问权限的用户**

1. 启用 IAM Identity Center。

   有关说明，请参阅**《AWS IAM Identity Center 用户指南》中的[启用 AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)。

1. 在 IAM Identity Center 中，为用户授予管理访问权限。

   有关使用 IAM Identity Center 目录 作为身份源的教程，请参阅《[用户*指南》 IAM Identity Center 目录中的使用默认设置配置AWS IAM Identity Center 用户*访问权限](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)。

**以具有管理访问权限的用户身份登录**
+ 要使用您的 IAM Identity Center 用户身份登录，请使用您在创建 IAM Identity Center 用户时发送到您的电子邮件地址的登录 URL。

  有关使用 IAM Identity Center 用户[登录的帮助，请参阅*AWS 登录 用户指南*中的登录 AWS 访问门户](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)。

**将访问权限分配给其他用户**

1. 在 IAM Identity Center 中，创建一个权限集，该权限集遵循应用最低权限的最佳做法。

   有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)。

1. 将用户分配到一个组，然后为该组分配单点登录访问权限。

   有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)。

#### 授权以编程方式访问
<a name="setting-up-access-gs-11"></a>

如果用户想在 AWS 外部进行交互，则需要编程访问权限 AWS 管理控制台。授予编程访问权限的方式取决于正在访问的用户类型 AWS。

要向用户授予编程式访问权限，请选择以下选项之一。


****  

| 哪个用户需要编程式访问权限？ | 目的 | 方式 | 
| --- | --- | --- | 
| IAM | （推荐）使用控制台凭证作为临时凭证，签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照您希望使用的界面的说明进行操作。[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html) | 
| 人力身份<br />（在 IAM Identity Center 中管理的用户） | 使用临时证书签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照您希望使用的界面的说明进行操作。[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html) | 
| IAM | 使用临时证书签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照 IAM 用户指南中的将[临时证书与 AWS 资源配合使用](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)中的说明进行操作。 | 
| IAM | （不推荐使用）使用长期凭证签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照您希望使用的界面的说明进行操作。[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html) | 

#### 后续步骤
<a name="earlier-gs-1_11-setting-up-next-step-2"></a>

[设置 AWS Command Line Interface (AWS CLI)](#earlier-gs-1_11-setup-awscli)

### 步骤 2：设置 AWS Command Line Interface (AWS CLI)
<a name="earlier-gs-1_11-setup-awscli"></a>

在此步骤中，您将下载并配置为与适用于 Apache Flink 的托管服务一起使用。 AWS CLI 

**注意**  
本指南中的入门练习假定您使用账户中的管理员凭证 (`adminuser`) 来执行这些操作。

**注意**  
如果您已经 AWS CLI 安装了，则可能需要升级才能获得最新功能。有关更多信息，请参阅AWS Command Line Interface 《用户指南》**中的[安装 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)。要检查的版本 AWS CLI，请运行以下命令：  

```
aws --version
```
本教程中的练习需要以下 AWS CLI 版本或更高版本：  

```
aws-cli/1.16.63
```

**要设置 AWS CLI**

1. 下载并配置 AWS CLI。有关说明，请参阅《AWS Command Line Interface 用户指南》**中的以下主题：
   + [安装 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html)
   + [配置 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-earlier-gs-1_11.html)

1. 在文件中为管理员用户添加已命名的配置 AWS CLI `config`文件。在执行 AWS CLI 命令时，您将使用此配置文件。有关命名配置文件的更多信息，请参阅 *AWS Command Line Interface 用户指南*中的[命名配置文件](https://docs.aws.amazon.com/cli/latest/userguide/cli-multiple-profiles.html)。

   ```
   [profile adminuser]
   aws_access_key_id = {{adminuser access key ID}}
   aws_secret_access_key = {{adminuser secret access key}}
   region = {{aws-region}}
   ```

   有关可用 AWS 区域的列表，请参阅中的[区域和终端节点*Amazon Web Services 一般参考*](https://docs.aws.amazon.com/general/latest/gr/rande.html)。
**注意**  
本教程中的示例代码和命令使用美国西部（俄勒冈州）区域。要使用不同的区域，请将本教程的代码和命令中的区域更改为要使用的区域。

1. 在命令提示符处输入以下帮助命令来验证设置：

   ```
   aws help
   ```

设置 AWS 帐户和之后 AWS CLI，您可以尝试下一个练习，即配置示例应用程序并测试端到端设置。

#### 后续步骤
<a name="earlier-gs-1_11-setup-awscli-next-step-3"></a>

[步骤 3：创建并运行 Managed Service for Apache Flink 应用程序](#earlier-gs-1_11-get-started-exercise)

### 步骤 3：创建并运行 Managed Service for Apache Flink 应用程序
<a name="earlier-gs-1_11-get-started-exercise"></a>

在本练习中，您将创建面向应用程序的适用于 Apache Flink 的托管服务，并将数据流作为源和接收器。

**Topics**
+ [创建两个 Amazon Kinesis 数据流](#earlier-gs-1_11-get-started-exercise-1)
+ [将示例记录写入输入流](#earlier-gs-1_11-get-started-exercise-2)
+ [下载并检查 Apache Flink 流式处理 Java 代码](#earlier-gs-1_11-get-started-exercise-5)
+ [编译应用程序代码](#earlier-gs-1_11-get-started-exercise-5.5)
+ [上传 Apache Flink 流式处理 Java 代码](#earlier-gs-1_11-get-started-exercise-6)
+ [创建并运行适用于 Apache Flink 的托管服务](#earlier-gs-1_11-get-started-exercise-7)
+ [后续步骤](#earlier-gs-1_11-get-started-exercise-next-step-4)

#### 创建两个 Amazon Kinesis 数据流
<a name="earlier-gs-1_11-get-started-exercise-1"></a>

在为本练习创建 Managed Service for Apache Flink 应用程序之前，请创建两个 Kinesis 数据流（`ExampleInputStream`和`ExampleOutputStream`）。您的应用程序将这些数据流用于应用程序源和目标流。

可以使用 Amazon Kinesis 控制台或以下 AWS CLI 命令创建这些流。有关控制台说明，请参阅 *Amazon Kinesis Data Streams 开发人员指南*中的[创建和更新数据流](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html)。

**创建数据流 (AWS CLI)**

1. 要创建第一个直播 (`ExampleInputStream`)，请使用以下 Amazon Kinesis 命令`create-stream` AWS CLI 。

   ```
   $ aws kinesis create-stream \
   --stream-name ExampleInputStream \
   --shard-count 1 \
   --region us-west-2 \
   --profile adminuser
   ```

1. 要创建应用程序用来写入输出的第二个流，请运行同一命令（将流名称更改为 `ExampleOutputStream`）。

   ```
   $ aws kinesis create-stream \
   --stream-name ExampleOutputStream \
   --shard-count 1 \
   --region us-west-2 \
   --profile adminuser
   ```

#### 将示例记录写入输入流
<a name="earlier-gs-1_11-get-started-exercise-2"></a>

在本节中，您使用 Python 脚本将示例记录写入流，以供应用程序处理。

**注意**  
此部分需要 [AWS SDK for Python (Boto)](https://aws.amazon.com/sdk-for-python/)。

1. 使用以下内容创建名为 `stock.py` 的文件：

   ```
    
   import datetime
   import json
   import random
   import boto3
   
   STREAM_NAME = "ExampleInputStream"
   
   
   def get_data():
       return {
           "EVENT_TIME": datetime.datetime.now().isoformat(),
           "TICKER": random.choice(["AAPL", "AMZN", "MSFT", "INTC", "TBV"]),
           "PRICE": round(random.random() * 100, 2),
       }
   
   
   def generate(stream_name, kinesis_client):
       while True:
           data = get_data()
           print(data)
           kinesis_client.put_record(
               StreamName=stream_name, Data=json.dumps(data), PartitionKey="partitionkey"
           )
   
   
   if __name__ == "__main__":
       generate(STREAM_NAME, boto3.client("kinesis"))
   ```

1. 在本教程的后面部分，您运行 `stock.py` 脚本，以将数据发送到应用程序。

   ```
   $ python stock.py
   ```

#### 下载并检查 Apache Flink 流式处理 Java 代码
<a name="earlier-gs-1_11-get-started-exercise-5"></a>

此示例的 Java 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/GettingStarted` 目录。

请注意有关应用程序代码的以下信息：
+ [项目对象模型 (pom.xml)](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html) 文件包含有关应用程序的配置和依赖项的信息，包括 Managed Service for Apache Flink 库。
+ `BasicStreamingJob.java` 文件包含定义应用程序功能的 `main` 方法。
+ 应用程序使用 Kinesis 源从源流中进行读取。以下代码段创建 Kinesis 源：

  ```
  return env.addSource(new FlinkKinesisConsumer<>(inputStreamName,
                  new SimpleStringSchema(), inputProperties));
  ```
+ 您的应用程序使用 `StreamExecutionEnvironment` 对象创建源和接收连接器以访问外部资源。
+ 该应用程序将使用静态属性创建源和接收连接器。要使用动态应用程序属性，请使用 `createSourceFromApplicationProperties` 和 `createSinkFromApplicationProperties` 方法以创建连接器。这些方法读取应用程序的属性来配置连接器。

  有关运行时系统属性的更多信息，请参阅[使用运行时属性](how-properties.md)。

#### 编译应用程序代码
<a name="earlier-gs-1_11-get-started-exercise-5.5"></a>

在本节中，您使用 Apache Maven 编译器创建应用程序的 Java 代码。有关安装 Apache Maven 和 Java 开发工具包 (JDK) 的信息，请参阅[满足完成练习的先决条件](getting-started.md#setting-up-prerequisites)。

**编译应用程序代码**

1. 要使用您的应用程序代码，您将其编译和打包成 JAR 文件。您可以通过两种方式之一编译和打包您的代码：
   + 使用命令行 Maven 工具。在包含 `pom.xml` 文件的目录中通过运行以下命令创建您的 JAR 文件：

     ```
     mvn package -Dflink.version=1.11.3
     ```
   + 设置开发环境。有关详细信息，请参阅您的开发环境文档。
**注意**  
提供的源代码依赖于 Java 11 中的库。确保项目的 Java 版本为 11。

   您可以作为 JAR 文件上传您的包，也可以将包压缩为 ZIP 文件并上传。如果您使用创建应用程序 AWS CLI，则需要指定代码内容类型（JAR 或 ZIP）。

1. 如果编译时出错，请验证 `JAVA_HOME` 环境变量设置正确。

如果应用程序成功编译，则创建以下文件：

`target/aws-kinesis-analytics-java-apps-1.0.jar`

#### 上传 Apache Flink 流式处理 Java 代码
<a name="earlier-gs-1_11-get-started-exercise-6"></a>

在本节中，您创建 Amazon Simple Storage Service (Amazon S3) 存储桶并上传应用程序代码。

**上传应用程序代码**

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **创建存储桶 **。

1. 在 **存储桶名称** 字段中输入 **ka-app-code-{{<username>}}**。将后缀（如您的用户名）添加到存储桶名称，以使其具有全局唯一性。选择 **下一步**。

1. 在**配置选项**步骤中，让设置保持原样，然后选择**下一步**。

1. 在**设置权限**步骤中，让设置保持原样，然后选择**下一步**。

1. 选择 **创建存储桶 **。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-bucke-{{<username>}}** bucket，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `aws-kinesis-analytics-java-apps-1.0.jar` 文件。选择 **下一步**。

1. 您无需更改该对象的任何设置，因此，请选择 **上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

#### 创建并运行适用于 Apache Flink 的托管服务
<a name="earlier-gs-1_11-get-started-exercise-7"></a>

您可以使用控制台或 AWS CLI创建和运行适用于 Apache Flink 的托管服务的应用程序。

**注意**  
当您使用控制台创建应用程序时，系统会为您创建您的 AWS Identity and Access Management (IAM) 和 A CloudWatch mazon Logs 资源。使用创建应用程序时 AWS CLI，可以单独创建这些资源。

**Topics**
+ [创建并运行应用程序（控制台）](#earlier-gs-1_11-get-started-exercise-7-console)
+ [创建并运行应用程序（AWS CLI）](#earlier-gs-1_11-get-started-exercise-7-cli)

##### 创建并运行应用程序（控制台）
<a name="earlier-gs-1_11-get-started-exercise-7-console"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="earlier-gs-1_11-get-started-exercise-7-console-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**描述**，输入 **My java test app**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
   + 将版本下拉列表保留为 **Apache Flink 版本 1.11 (建议的版本）**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 编辑 IAM 策略
<a name="earlier-gs-1_11-get-started-exercise-7-console-iam"></a>

编辑 IAM policy 以添加访问 Kinesis 数据流的权限。

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:s3:::ka-app-code-{{username}}/aws-kinesis-analytics-java-apps-1.0.jar"
               ]
           },
           {
               "Sid": "DescribeLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogStreams"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
               ]
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": [
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
               ]
           }{{,
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteOutputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
           }}}
       ]
   }
   ```

------

##### 配置应用程序
<a name="earlier-gs-1_11-get-started-exercise-7-console-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**aws-kinesis-analytics-java-apps-1.0.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 在 **Properties (属性)** 下，对于 **Group ID (组 ID)**，输入 **ProducerConfigProperties**。

1. 输入以下应用程序属性和值：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 Amazon CloudWatch 日志时，适用于 Apache Flink 的托管服务会为您创建一个日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`

##### 运行应用程序
<a name="earlier-gs-1_11-get-started-exercise-7-console-run"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

##### 停止应用程序
<a name="earlier-gs-1_11-get-started-exercise-7-console-stop"></a>

在**MyApplication**页面上，选择 “**停止**”。确认该操作。

##### 更新应用程序
<a name="earlier-gs-1_11-get-started-exercise-7-console-update"></a>

使用控制台，您可以更新应用程序设置，例如应用程序属性、监控设置，或应用程序 JAR 文件的位置和文件名。如果您需要更新应用程序代码，您还可以从 Amazon S3 存储桶重新加载应用程序 JAR。

在**MyApplication**页面上，选择**配置**。更新应用程序设置，然后选择**更新**。

##### 创建并运行应用程序（AWS CLI）
<a name="earlier-gs-1_11-get-started-exercise-7-cli"></a>

在本节中，您将使用创建和运行适用于 Apache Flink 的托管服务应用程序。适用于 Apache Flink 的托管服务使用该`kinesisanalyticsv2` AWS CLI 命令为 Apache Flink 应用程序创建托管服务并与之交互。 AWS CLI 

##### 创建权限策略
<a name="earlier-gs-1_11-get-started-exercise-7-cli-policy"></a>

**注意**  
您必须为应用程序创建一个权限策略和角色。如果未创建这些 IAM 资源，应用程序将无法访问其数据和日志流。

首先，使用两个语句创建权限策略：一个语句授予对源流执行 `read` 操作的权限，另一个语句授予对接收器流执行 `write` 操作的权限。然后，将策略附加到 IAM 角色（下一部分中将创建此角色）。因此，在适用于 Apache Flink 的托管服务代入该角色时，服务具有必要的权限从源流进行读取和写入接收器流。

使用以下代码创建 `AKReadSourceStreamWriteSinkStream` 权限策略。将 `{{username}}` 替换为您用于创建 Amazon S3 存储桶来存储应用程序代码的用户名。将 Amazon 资源名称 (ARN) 中的账户 ID (`{{012345678901}}`) 替换为您的账户 ID。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "S3",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:GetObjectVersion"
            ],
            "Resource": ["arn:aws:s3:::ka-app-code-{{username}}",
                "arn:aws:s3:::ka-app-code-{{username}}/*"
            ]
        },
        {
            "Sid": "ReadInputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
        },
        {
            "Sid": "WriteOutputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
        }
    ]
}
```

------

有关创建权限策略的分步说明，请参阅*《IAM 用户指南》*中的[教程：创建和附加您的第一个客户管理型策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html#part-two-create-policy)。

**注意**  
要访问其他 Amazon 服务，可以使用 适用于 Java 的 AWS SDK。Managed Service for Apache Flink 会自动将软件开发工具包所需的证书设置为与您的应用程序关联的服务执行 IAM 角色的证书。无需执行其他步骤。

##### 创建 IAM 角色
<a name="earlier-gs-1_11-get-started-exercise-7-cli-role"></a>

在本节中，您将创建一个 IAM 角色，应用程序的 Managed Service for Apache Flink可以代入此角色来读取源流和写入接收器流。

权限不足时，Managed Service for Apache Flink 无法访问您的串流。您通过 IAM 角色授予这些权限。每个 IAM 角色附加了两种策略。此信任策略授予适用于 Apache Flink 的托管服务代入该角色的权限，权限策略确定适用于 Apache Flink 的托管服务代入这个角色后可以执行的操作。

您将在上一部分中创建的权限策略附加到此角色。

**创建 IAM 角色**

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航窗格中，选择 **角色** 和 **创建角色**。

1. 在 **选择受信任实体的类型** 下，选择 **AWS 服务**。在 **选择将使用此角色的服务** 下，选择 **Kinesis**。在**选择您的使用案例**下，选择 **Kinesis Analytics**。

   选择**下一步: 权限**。

1. 在 **附加权限策略** 页面上，选择 **下一步: 审核**。在创建角色后，您可以附加权限策略。

1. 在 **创建角色** 页面上，输入**MF-stream-rw-role**作为**角色名称**。选择 **创建角色**。

   现在，您已经创建了一个名为 `MF-stream-rw-role` 的新 IAM 角色。接下来，您更新角色的信任和权限策略。

1. 将权限策略附加到角色。
**注意**  
对于本练习，适用于 Apache Flink 的托管服务代入此角色，以便同时从 Kinesis 数据流（源）读取数据和将输出写入另一个 Kinesis 数据流。因此，您附加在上一步（[创建权限策略](#earlier-gs-1_11-get-started-exercise-7-cli-policy)）中创建的策略。

   1. 在 **摘要** 页上，选择 **权限** 选项卡。

   1. 选择**附加策略**。

   1. 在搜索框中，输入 **AKReadSourceStreamWriteSinkStream**（您在上一部分中创建的策略）。

   1. 选择**AKReadSourceStreamWriteSinkStream**策略，然后选择**附加策略**。

现在，您已经创建了应用程序用来访问资源的服务执行角色。记下新角色的 ARN。

有关创建角色的分步说明，请参阅*《IAM 用户指南》*中的在您的[中创建 IAM 角色（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html#roles-creatingrole-user-console)。

##### 创建 Managed Service for Apache Flink 应用程序
<a name="earlier-gs-1_11-get-started-exercise-7-cli-create"></a>

1. 将以下 JSON 代码保存到名为 `create_request.json` 的文件中。将示例角色 ARN 替换为您之前创建的角色的 ARN。将存储桶 ARN 后缀 (`{{username}}`) 替换为在前一部分中选择的后缀。将服务执行角色中的示例账户 ID (`{{012345678901}}`) 替换为您的账户 ID。

   ```
   {
       "ApplicationName": "test",
       "ApplicationDescription": "my java test app",
       "RuntimeEnvironment": "FLINK-1_11",
       "ServiceExecutionRole": "arn:aws:iam::{{012345678901}}:role/MF-stream-rw-role",
       "ApplicationConfiguration": {
           "ApplicationCodeConfiguration": {
               "CodeContent": {
                   "S3ContentLocation": {
                       "BucketARN": "arn:aws:s3:::ka-app-code-{{username}}",
                       "FileKey": "aws-kinesis-analytics-java-apps-1.0.jar"
                   }
               },
               "CodeContentType": "ZIPFILE"
           },
           "EnvironmentProperties":  { 
            "PropertyGroups": [ 
               { 
                  "PropertyGroupId": "ProducerConfigProperties",
                  "PropertyMap" : {
                       "flink.stream.initpos" : "LATEST",
                       "aws.region" : "us-west-2",
                       "AggregationEnabled" : "false"
                  }
               },
               { 
                  "PropertyGroupId": "ConsumerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2"
                  }
               }
            ]
         }
       }
   }
   ```

1. 使用上述请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html) 操作来创建应用程序：

   ```
   aws kinesisanalyticsv2 create-application --cli-input-json file://create_request.json
   ```

应用程序现已创建。您在下一步中启动应用程序。

##### 启动应用程序
<a name="earlier-gs-1_11-get-started-exercise-7-cli-start"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序。

**启动应用程序**

1. 将以下 JSON 代码保存到名为 `start_request.json` 的文件中。

   ```
   {
       "ApplicationName": "test",
       "RunConfiguration": {
           "ApplicationRestoreConfiguration": { 
            "ApplicationRestoreType": "RESTORE_FROM_LATEST_SNAPSHOT"
            }
       }
   }
   ```

1. 使用上述请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序：

   ```
   aws kinesisanalyticsv2 start-application --cli-input-json file://start_request.json
   ```

应用程序正在运行。您可以在亚马逊 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 停止应用程序
<a name="earlier-gs-1_11-get-started-exercise-7-cli-stop"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序。

**停止应用程序**

1. 将以下 JSON 代码保存到名为 `stop_request.json` 的文件中。

   ```
   {
       "ApplicationName": "test"
   }
   ```

1. 使用下面的请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序：

   ```
   aws kinesisanalyticsv2 stop-application --cli-input-json file://stop_request.json
   ```

应用程序现已停止。

##### 添加 CloudWatch 日志选项
<a name="earlier-gs-1_11-get-started-exercise-7-cli-cw"></a>

您可以使用将 Amazon CloudWatch 日志流 AWS CLI 添加到您的应用程序中。有关在应用程序中使用 CloudWatch Logs 的信息，请参阅[设置 Managed Service for Apache Flink 中的应用程序日志记录](cloudwatch-logs.md)。

##### 更新环境属性
<a name="earlier-gs-1_11-get-started-exercise-7-cli-update-env"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) 操作更改应用程序的环境属性，而无需重新编译应用程序代码。在该示例中，您更改源流和目标流的区域。

**更新应用程序的环境属性**

1. 将以下 JSON 代码保存到名为 `update_properties_request.json` 的文件中。

   ```
   {"ApplicationName": "test",
      "CurrentApplicationVersionId": 1,
      "ApplicationConfigurationUpdate": { 
         "EnvironmentPropertyUpdates": { 
            "PropertyGroups": [ 
               { 
                  "PropertyGroupId": "ProducerConfigProperties",
                  "PropertyMap" : {
                       "flink.stream.initpos" : "LATEST",
                       "aws.region" : "us-west-2",
                       "AggregationEnabled" : "false"
                  }
               },
               { 
                  "PropertyGroupId": "ConsumerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2"
                  }
               }
            ]
         }
      }
   }
   ```

1. 使用前面的请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) 操作以更新环境属性：

   ```
   aws kinesisanalyticsv2 update-application --cli-input-json file://update_properties_request.json
   ```

##### 更新应用程序代码
<a name="earlier-gs-1_11-get-started-exercise-7-cli-update-code"></a>

当您需要使用新版本的代码包更新应用程序代码时，可以使用[https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) AWS CLI 操作。

**注意**  
要使用相同的文件名加载新版本的应用程序代码，您必须指定新的对象版本。有关使用 Amazon S3 对象版本的更多信息，请参阅[启用或禁用版本控制](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/enable-versioning.html)。

要使用 AWS CLI，请从 Amazon S3 存储桶中删除之前的代码包，上传新版本，然后调用`UpdateApplication`，指定相同的 Amazon S3 存储桶和对象名称以及新的对象版本。应用程序将使用新的代码包重新启动。

以下示例 `UpdateApplication` 操作请求重新加载应用程序代码并重新启动应用程序。将 `CurrentApplicationVersionId` 更新为当前的应用程序版本。您可以使用 `ListApplications` 或 `DescribeApplication` 操作检查当前的应用程序版本。使用您在本节中选择的后缀更新存储桶名称后缀 ({{<username>}})。[创建两个 Amazon Kinesis 数据流](#earlier-gs-1_11-get-started-exercise-1)

```
{
    "ApplicationName": "test",
    "CurrentApplicationVersionId": {{1}},
    "ApplicationConfigurationUpdate": {
        "ApplicationCodeConfigurationUpdate": {
            "CodeContentUpdate": {
                "S3ContentLocationUpdate": {
                    "BucketARNUpdate": "arn:aws:s3:::ka-app-code-{{username}}",
                    "FileKeyUpdate": "aws-kinesis-analytics-java-apps-1.0.jar",
                    "ObjectVersionUpdate": "{{SAMPLEUehYngP87ex1nzYIGYgfhypvDU}}"
                }
            }
        }
    }
}
```

#### 后续步骤
<a name="earlier-gs-1_11-get-started-exercise-next-step-4"></a>

[步骤 4：清理 AWS 资源](#earlier-gs-1_11-cleanup)

### 步骤 4：清理 AWS 资源
<a name="earlier-gs-1_11-cleanup"></a>

本节包括清理入门教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#earlier-gs-1_11-cleanup-app)
+ [删除您的 Kinesis 数据流](#earlier-gs-1_11-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#earlier-gs-1_11-cleanup-s3)
+ [删除您的 IAM 资源](#earlier-gs-1_11-cleanup-iam)
+ [删除您的 CloudWatch 资源](#earlier-gs-1_11-cleanup-cw)
+ [后续步骤](#earlier-gs-1_11-cleanup-next-step-5)

#### 删除 Managed Service for Apache Flink 应用程序
<a name="earlier-gs-1_11-cleanup-app"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 “适用于 Apache Flink 的托管服务” 面板中，选择。**MyApplication**

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

#### 删除您的 Kinesis 数据流
<a name="earlier-gs-1_11-cleanup-stream"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

1. 在 **Kinesis 直播**页面中 **ExampleOutputStream**，选择，选择**操作**，选择**删除**，然后确认删除。

#### 删除您的 Amazon S3 对象和存储桶
<a name="earlier-gs-1_11-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

#### 删除您的 IAM 资源
<a name="earlier-gs-1_11-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

#### 删除您的 CloudWatch 资源
<a name="earlier-gs-1_11-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

#### 后续步骤
<a name="earlier-gs-1_11-cleanup-next-step-5"></a>

[步骤 5：后续步骤](#earlier-gs-1_11-next-steps)

### 步骤 5：后续步骤
<a name="earlier-gs-1_11-next-steps"></a>

现在，您已经创建并运行了 Managed Service for Apache Flink 应用程序，请参阅以下资源，了解更多 Managed Service for Apache Flink 解决方案。
+ **[适用于 Amazon Kinesis](https://aws.amazon.com/solutions/implementations/aws-streaming-data-solution-for-amazon-kinesis/) 的 AWS 流数据解决方案：**适用于 Amazon Kinesis 的流数据解决方案可自动配置 AWS 必要的服务，以便轻松捕获、存储、处理和交付流数据。 AWS 该解决方案为解决流数据用例提供了多种选项。Managed Service for Apache Flink 选项提供了一个端到端的流式传输 ETL 示例，演示了一个对模拟的纽约出租车数据运行分析操作的真实应用程序。该解决方案设置了所有必要的 AWS 资源，例如 IAM 角色和策略、 CloudWatch 控制面板和 CloudWatch 警报。
+ **[AWS 适用于 Amazon MSK](https://aws.amazon.com/solutions/implementations/aws-streaming-data-solution-for-amazon-msk/) 的 AWS 流数据解决方案：**适用于 Amazon MSK 的流数据解决方案提供了数据流经生产者、流式存储、消费者和目的地的 AWS CloudFormation 模板。
+ **[带有 Apache Flink 和 Apache Kafka 的 Click](https://amazonmsk-labs.workshop.aws/en/mskkdaflinklab.html)** stream Lab：点击流用例的端到端实验室，使用适用于 Apache Kafka 的Amazon托管流媒体进行流存储，使用 Managed Service for Apache Flink 进行流处理。
+ **[Amazon Managed Service for Apache Flink 讲习会](https://catalog.workshops.aws/managed-flink)：**在此讲习会中，您将构建端到端的流媒体架构，以近乎实时的方式摄取、分析和可视化流媒体数据。您着手改善纽约市一家出租车公司的运营。您可以近乎实时地分析纽约市出租车队的遥测数据，以优化其车队运营。
+ **[学习 Flink：动手训练](https://ci.apache.org/projects/flink/flink-docs-master/learn-flink/)：**Apache Flink 官方入门培训，让您开始编写可扩展的流媒体 ETL、分析和事件驱动的应用程序。
**注意**  
请注意，Managed Service for Apache Flink 不支持本培训中使用的 Apache Flink 版本 (1.12)。你可以在适用于 Apache Flink 的 Flink 托管服务中使用 Flink 1.15.2。
+ **[Apache Flink 代码示例](https://github.com/apache/flink/tree/master/flink-examples/flink-examples-streaming/src/main/java/org/apache/flink/streaming/examples)：**包含各种 Apache Flink 应用程序示例的 GitHub 存储库。

## 入门：Flink 1.8.2 - 弃用
<a name="earlier-gs-1_8"></a>

**注意**  
Apache Flink 社区不支持 Apache Flink 版本 **1.6、1.8 和 1.11** 已有三年多时间。我们计划于 **2024 年 11 月 5 日**在 Amazon Managed Service for Apache Flink 中弃用这些版本。从该日期起，您将无法创建这些 Flink 版本的新应用程序。在此时间，您可以继续运行现有应用程序。您可以使用 Amazon Managed Service for Apache Flink 中的就地版本升级功能有状态地升级应用程序。有关更多信息，请参阅 [使用 Apache Flink 的就地版本升级](how-in-place-version-upgrades.md)。

本主题包含一个使用 Apache Flink 1.8.2 的 [教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md) 教程版本。

**Topics**
+ [Managed Service for Apache Flink 应用程序组件](#getting-started-components)
+ [完成练习的先决条件](#su-1_8-prerequisites)
+ [步骤 1：设置 AWS 账户并创建管理员用户](#earlier-gs-1_8-setting-up)
+ [步骤 2：设置 AWS Command Line Interface (AWS CLI)](#su-1_8-awscli)
+ [步骤 3：创建并运行 Managed Service for Apache Flink 应用程序](#earlier-gs-1_8-exercise)
+ [步骤 4：清理 AWS 资源](#earlier-gs-1_8-cleanup)

### Managed Service for Apache Flink 应用程序组件
<a name="getting-started-components"></a>

为了处理数据，适用于 Apache 的托管服务 Flink 应用程序使用 Java/Apache Maven 或 Scala 应用程序，该应用程序使用 Apache Flink 运行时处理输入并生成输出。

Managed Service for Apache Flink 应用程序包含以下组件：
+ **运行时系统属性：**您可以使用*运行时属性* 配置应用程序，而无需重新编译应用程序代码。
+ **源：**应用程序通过*源* 使用数据。源连接器从 Kinesis 数据流、Amazon S3 存储桶等读取数据。有关更多信息，请参阅 [添加流数据源](how-sources.md)。
+ **运算符：**应用程序使用一个或多个*运算符* 以处理数据。运算符可以转换、丰富或聚合数据。有关更多信息，请参阅 [运算符](how-operators.md)。
+ **接收器：**应用程序使用*接收器* 将生成的数据发送到外部源。接收器连接器将数据写入到 Kinesis 数据流、Firehose 流、Amazon S3 存储桶等。有关更多信息，请参阅 [使用接收器写入数据](how-sinks.md)。

在创建、编译和打包您的应用程序代码后，您可以将代码包上传到 Amazon Simple Storage Service (Amazon S3) 存储桶中。然后，您创建一个 Managed Service for Apache Flink 应用程序。您在代码包位置中传入一个 Kinesis 数据流以作为流数据源，它通常是接收应用程序处理的数据的流或文件位置。

### 完成练习的先决条件
<a name="su-1_8-prerequisites"></a>

要完成本指南中的步骤，您必须满足以下条件：
+ [Java 开发工具包](http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html) (JDK) 版本 8。设置 `JAVA_HOME` 环境变量，使其指向您的 JDK 安装位置。
+ 要在本教程中使用 Apache Flink Kinesis 连接器，必须下载并安装 Apache Flink。有关更多信息，请参阅 [将 Apache Flink Kinesis Streams 连接器与之前的 Apache Flink 版本一起使用](#how-creating-apps-building-kinesis)。
+ 我们建议您使用开发环境（如 [Eclipse Java Neon](http://www.eclipse.org/downloads/packages/release/neon/3) 或 [IntelliJ Idea](https://www.jetbrains.com/idea/)）来开发和编译您的应用程序。
+ [Git 客户端](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。如果尚未安装 Git 客户端，请安装它。
+ [Apache Maven 编译器插件](https://maven.apache.org/plugins/maven-compiler-plugin/)。Maven 必须位于您的有效路径中。要测试您的 Apache Maven 安装，请输入以下内容：

  ```
  $ mvn -version
  ```

要开始，请转到[步骤 1：设置 AWS 账户并创建管理员用户](#earlier-gs-1_8-setting-up)。

### 步骤 1：设置 AWS 账户并创建管理员用户
<a name="earlier-gs-1_8-setting-up"></a>

#### 注册获取 AWS 账户
<a name="sign-up-for-aws"></a>

如果您没有 AWS 账户，请完成以下步骤来创建一个。

**要注册 AWS 账户**

1. 打开 [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup)。

1. 按照屏幕上的说明操作。

   在注册时，将接到电话或收到短信，要求使用电话键盘输入一个验证码。

   当您注册时 AWS 账户，就会创建*AWS 账户根用户*一个。根用户有权访问该账户中的所有 AWS 服务 和资源。作为最佳安全实践，请为用户分配管理访问权限，并且只使用根用户来执行[需要根用户访问权限的任务](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)。

AWS 注册过程完成后会向您发送一封确认电子邮件。在任何时候，您都可以通过转至 [https://aws.amazon.com/](https://aws.amazon.com/) 并选择 **My Account (我的账户)** 来查看当前的账户活动并管理您的账户。

#### 创建具有管理访问权限的用户
<a name="create-an-admin"></a>

注册后，请保护您的安全 AWS 账户 AWS 账户根用户 AWS IAM Identity Center，启用并创建管理用户，这样您就不会使用 root 用户执行日常任务。

**保护你的 AWS 账户根用户**

1.  选择 **Root 用户**并输入您的 AWS 账户 电子邮件地址，以账户所有者的身份登录。[AWS 管理控制台](https://console.aws.amazon.com/)在下一页上，输入您的密码。

   要获取使用根用户登录方面的帮助，请参阅《AWS 登录 用户指南》**中的 [Signing in as the root user](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)。

1. 为您的根用户启用多重身份验证（MFA）。

   有关说明，请参阅 I [A *M* 用户指南中的为 AWS 账户 根用户启用虚拟 MFA 设备（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)。

**创建具有管理访问权限的用户**

1. 启用 IAM Identity Center。

   有关说明，请参阅**《AWS IAM Identity Center 用户指南》中的[启用 AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)。

1. 在 IAM Identity Center 中，为用户授予管理访问权限。

   有关使用 IAM Identity Center 目录 作为身份源的教程，请参阅《[用户*指南》 IAM Identity Center 目录中的使用默认设置配置AWS IAM Identity Center 用户*访问权限](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)。

**以具有管理访问权限的用户身份登录**
+ 要使用您的 IAM Identity Center 用户身份登录，请使用您在创建 IAM Identity Center 用户时发送到您的电子邮件地址的登录 URL。

  有关使用 IAM Identity Center 用户[登录的帮助，请参阅*AWS 登录 用户指南*中的登录 AWS 访问门户](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)。

**将访问权限分配给其他用户**

1. 在 IAM Identity Center 中，创建一个权限集，该权限集遵循应用最低权限的最佳做法。

   有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)。

1. 将用户分配到一个组，然后为该组分配单点登录访问权限。

   有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)。

#### 授权以编程方式访问
<a name="setting-up-access-gs-8"></a>

如果用户想在 AWS 外部进行交互，则需要编程访问权限 AWS 管理控制台。授予编程访问权限的方式取决于正在访问的用户类型 AWS。

要向用户授予编程式访问权限，请选择以下选项之一。


****  

| 哪个用户需要编程式访问权限？ | 目的 | 方式 | 
| --- | --- | --- | 
| IAM | （推荐）使用控制台凭证作为临时凭证，签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照您希望使用的界面的说明进行操作。[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html) | 
| 人力身份<br />（在 IAM Identity Center 中管理的用户） | 使用临时证书签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照您希望使用的界面的说明进行操作。[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html) | 
| IAM | 使用临时证书签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照 IAM 用户指南中的将[临时证书与 AWS 资源配合使用](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)中的说明进行操作。 | 
| IAM | （不推荐使用）使用长期凭证签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照您希望使用的界面的说明进行操作。[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html) | 

### 步骤 2：设置 AWS Command Line Interface (AWS CLI)
<a name="su-1_8-awscli"></a>

在此步骤中，您将下载并配置为与适用于 Apache Flink 的托管服务一起使用。 AWS CLI 

**注意**  
本指南中的入门练习假定您使用账户中的管理员凭证 (`adminuser`) 来执行这些操作。

**注意**  
如果您已经 AWS CLI 安装了，则可能需要升级才能获得最新功能。有关更多信息，请参阅AWS Command Line Interface 《用户指南》**中的[安装 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)。要检查的版本 AWS CLI，请运行以下命令：  

```
aws --version
```
本教程中的练习需要以下 AWS CLI 版本或更高版本：  

```
aws-cli/1.16.63
```

**要设置 AWS CLI**

1. 下载并配置 AWS CLI。有关说明，请参阅《AWS Command Line Interface 用户指南》**中的以下主题：
   + [安装 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html)
   + [配置 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)

1. 在文件中为管理员用户添加已命名的配置 AWS CLI `config`文件。在执行 AWS CLI 命令时，您将使用此配置文件。有关命名配置文件的更多信息，请参阅 *AWS Command Line Interface 用户指南*中的[命名配置文件](https://docs.aws.amazon.com/cli/latest/userguide/cli-multiple-profiles.html)。

   ```
   [profile adminuser]
   aws_access_key_id = {{adminuser access key ID}}
   aws_secret_access_key = {{adminuser secret access key}}
   region = {{aws-region}}
   ```

   有关可用区域的列表，请参阅 *Amazon Web Services 一般参考*中的[区域和终端节点](https://docs.aws.amazon.com/general/latest/gr/rande.html)。
**注意**  
本教程中的示例代码和命令使用美国西部（俄勒冈州）区域。要使用其他 AWS 区域，请将本教程的代码和命令中的区域更改为要使用的区域。

1. 在命令提示符处输入以下帮助命令来验证设置：

   ```
   aws help
   ```

设置 AWS 帐户和之后 AWS CLI，您可以尝试下一个练习，即配置示例应用程序并测试端到端设置。

#### 后续步骤
<a name="su-1_8-awscli-next-step-3"></a>

[步骤 3：创建并运行 Managed Service for Apache Flink 应用程序](#earlier-gs-1_8-exercise)

### 步骤 3：创建并运行 Managed Service for Apache Flink 应用程序
<a name="earlier-gs-1_8-exercise"></a>

在本练习中，您将创建面向应用程序的适用于 Apache Flink 的托管服务，并将数据流作为源和接收器。

**Topics**
+ [创建两个 Amazon Kinesis 数据流](#earlier-gs-1_8-exercise-1)
+ [将示例记录写入输入流](#earlier-gs-1_8-exercise-2)
+ [下载并检查 Apache Flink 流式处理 Java 代码](#earlier-gs-1_8-exercise-5)
+ [编译应用程序代码](#earlier-gs-1_8-exercise-5.5)
+ [上传 Apache Flink 流式处理 Java 代码](#earlier-gs-1_8-exercise-6)
+ [创建并运行适用于 Apache Flink 的托管服务](#earlier-gs-1_8-exercise-7)
+ [后续步骤](#earlier-gs-1_8-exercise-next-step-4)

#### 创建两个 Amazon Kinesis 数据流
<a name="earlier-gs-1_8-exercise-1"></a>

在为本练习创建 Managed Service for Apache Flink 应用程序之前，请创建两个 Kinesis 数据流（`ExampleInputStream`和`ExampleOutputStream`）。您的应用程序将这些数据流用于应用程序源和目标流。

可以使用 Amazon Kinesis 控制台或以下 AWS CLI 命令创建这些流。有关控制台说明，请参阅 *Amazon Kinesis Data Streams 开发人员指南*中的[创建和更新数据流](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html)。

**创建数据流 (AWS CLI)**

1. 要创建第一个直播 (`ExampleInputStream`)，请使用以下 Amazon Kinesis 命令`create-stream` AWS CLI 。

   ```
   $ aws kinesis create-stream \
   --stream-name ExampleInputStream \
   --shard-count 1 \
   --region us-west-2 \
   --profile adminuser
   ```

1. 要创建应用程序用来写入输出的第二个流，请运行同一命令（将流名称更改为 `ExampleOutputStream`）。

   ```
   $ aws kinesis create-stream \
   --stream-name ExampleOutputStream \
   --shard-count 1 \
   --region us-west-2 \
   --profile adminuser
   ```

#### 将示例记录写入输入流
<a name="earlier-gs-1_8-exercise-2"></a>

在本节中，您使用 Python 脚本将示例记录写入流，以供应用程序处理。

**注意**  
此部分需要 [AWS SDK for Python (Boto)](https://aws.amazon.com/developers/getting-started/python/)。

1. 使用以下内容创建名为 `stock.py` 的文件：

   ```
    
   import datetime
   import json
   import random
   import boto3
   
   STREAM_NAME = "ExampleInputStream"
   
   
   def get_data():
       return {
           "EVENT_TIME": datetime.datetime.now().isoformat(),
           "TICKER": random.choice(["AAPL", "AMZN", "MSFT", "INTC", "TBV"]),
           "PRICE": round(random.random() * 100, 2),
       }
   
   
   def generate(stream_name, kinesis_client):
       while True:
           data = get_data()
           print(data)
           kinesis_client.put_record(
               StreamName=stream_name, Data=json.dumps(data), PartitionKey="partitionkey"
           )
   
   
   if __name__ == "__main__":
       generate(STREAM_NAME, boto3.client("kinesis"))
   ```

1. 在本教程的后面部分，您运行 `stock.py` 脚本，以将数据发送到应用程序。

   ```
   $ python stock.py
   ```

#### 下载并检查 Apache Flink 流式处理 Java 代码
<a name="earlier-gs-1_8-exercise-5"></a>

此示例的 Java 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/GettingStarted_1_8` 目录。

请注意有关应用程序代码的以下信息：
+ [项目对象模型 (pom.xml)](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html) 文件包含有关应用程序的配置和依赖项的信息，包括 Managed Service for Apache Flink 库。
+ `BasicStreamingJob.java` 文件包含定义应用程序功能的 `main` 方法。
+ 应用程序使用 Kinesis 源从源流中进行读取。以下代码段创建 Kinesis 源：

  ```
  return env.addSource(new FlinkKinesisConsumer<>(inputStreamName,
                  new SimpleStringSchema(), inputProperties));
  ```
+ 您的应用程序使用 `StreamExecutionEnvironment` 对象创建源和接收连接器以访问外部资源。
+ 该应用程序将使用静态属性创建源和接收连接器。要使用动态应用程序属性，请使用 `createSourceFromApplicationProperties` 和 `createSinkFromApplicationProperties` 方法以创建连接器。这些方法读取应用程序的属性来配置连接器。

  有关运行时系统属性的更多信息，请参阅[使用运行时属性](how-properties.md)。

#### 编译应用程序代码
<a name="earlier-gs-1_8-exercise-5.5"></a>

在本节中，您使用 Apache Maven 编译器创建应用程序的 Java 代码。有关安装 Apache Maven 和 Java 开发工具包 (JDK) 的信息，请参阅[完成练习的先决条件](#su-1_8-prerequisites)。

**注意**  
**要在 1.11 之前的 Apache Flink 版本中使用 Kinesis 连接器，你需要下载、构建和安装 Apache Maven。有关更多信息，请参阅[将 Apache Flink Kinesis Streams 连接器与之前的 Apache Flink 版本一起使用](#how-creating-apps-building-kinesis)。**

**编译应用程序代码**

1. 要使用您的应用程序代码，您将其编译和打包成 JAR 文件。您可以通过两种方式之一编译和打包您的代码：
   + 使用命令行 Maven 工具。在包含 `pom.xml` 文件的目录中通过运行以下命令创建您的 JAR 文件：

     ```
     mvn package -Dflink.version=1.8.2
     ```
   + 设置开发环境。有关详细信息，请参阅您的开发环境文档。
**注意**  
提供的源代码依赖于 Java 1.8 中的库。确保项目的 Java 版本为 1.8。

   您可以作为 JAR 文件上传您的包，也可以将包压缩为 ZIP 文件并上传。如果您使用创建应用程序 AWS CLI，则需要指定代码内容类型（JAR 或 ZIP）。

1. 如果编译时出错，请验证 `JAVA_HOME` 环境变量设置正确。

如果应用程序成功编译，则创建以下文件：

`target/aws-kinesis-analytics-java-apps-1.0.jar`

#### 上传 Apache Flink 流式处理 Java 代码
<a name="earlier-gs-1_8-exercise-6"></a>

在本节中，您创建 Amazon Simple Storage Service (Amazon S3) 存储桶并上传应用程序代码。

**上传应用程序代码**

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **创建存储桶 **。

1. 在 **存储桶名称** 字段中输入 **ka-app-code-{{<username>}}**。将后缀（如您的用户名）添加到存储桶名称，以使其具有全局唯一性。选择 **下一步**。

1. 在**配置选项**步骤中，让设置保持原样，然后选择**下一步**。

1. 在**设置权限**步骤中，让设置保持原样，然后选择**下一步**。

1. 选择 **创建存储桶 **。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-bucke-{{<username>}}** bucket，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `aws-kinesis-analytics-java-apps-1.0.jar` 文件。选择 **下一步**。

1. 您无需更改该对象的任何设置，因此，请选择 **上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

#### 创建并运行适用于 Apache Flink 的托管服务
<a name="earlier-gs-1_8-exercise-7"></a>

您可以使用控制台或 AWS CLI创建和运行适用于 Apache Flink 的托管服务的应用程序。

**注意**  
当您使用控制台创建应用程序时，系统会为您创建您的 AWS Identity and Access Management (IAM) 和 A CloudWatch mazon Logs 资源。使用创建应用程序时 AWS CLI，可以单独创建这些资源。

**Topics**
+ [创建并运行应用程序（控制台）](#earlier-gs-1_8-exercise-7-console)
+ [创建并运行应用程序（AWS CLI）](#earlier-gs-1_8-exercise-7-cli)

##### 创建并运行应用程序（控制台）
<a name="earlier-gs-1_8-exercise-7-console"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="earlier-gs-1_8-exercise-7-console-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**描述**，输入 **My java test app**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
   + 将版本下拉列表保留为 **Apache Flink 1.8 (Recommended Version) (Apache Flink 1.8 (建议的版本))**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 编辑 IAM 策略
<a name="earlier-gs-1_8-exercise-7-console-iam"></a>

编辑 IAM policy 以添加访问 Kinesis 数据流的权限。

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:s3:::ka-app-code-{{username}}/aws-kinesis-analytics-java-apps-1.0.jar"
               ]
           },
           {
               "Sid": "DescribeLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogStreams"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
               ]
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": [
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
               ]
           }{{,
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteOutputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
           }}}
       ]
   }
   ```

------

##### 配置应用程序
<a name="earlier-gs-1_8-exercise-7-console-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**aws-kinesis-analytics-java-apps-1.0.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 输入以下应用程序属性和值：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 Amazon CloudWatch 日志时，适用于 Apache Flink 的托管服务会为您创建一个日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`

##### 运行应用程序
<a name="earlier-gs-1_8-exercise-7-console-run"></a>

1. 在**MyApplication**页面上，选择 “**运行**”。确认该操作。

1. 当应用程序正在运行时，请刷新页面。控制台将显示 **Application graph (应用程序图表)**。

##### 停止应用程序
<a name="earlier-gs-1_8-exercise-7-console-stop"></a>

在**MyApplication**页面上，选择 “**停止**”。确认该操作。

##### 更新应用程序
<a name="earlier-gs-1_8-exercise-7-console-update"></a>

使用控制台，您可以更新应用程序设置，例如应用程序属性、监控设置，或应用程序 JAR 文件的位置和文件名。如果您需要更新应用程序代码，您还可以从 Amazon S3 存储桶重新加载应用程序 JAR。

在**MyApplication**页面上，选择**配置**。更新应用程序设置，然后选择**更新**。

##### 创建并运行应用程序（AWS CLI）
<a name="earlier-gs-1_8-exercise-7-cli"></a>

在本节中，您将使用创建和运行适用 AWS CLI 于 Apache Flink 的托管服务应用程序。适用于 Apache Flink 的托管服务使用该`kinesisanalyticsv2` AWS CLI 命令为 Apache Flink 应用程序创建托管服务并与之交互。

##### 创建权限策略
<a name="earlier-gs-1_8-exercise-7-cli-policy"></a>

**注意**  
您必须为应用程序创建一个权限策略和角色。如果未创建这些 IAM 资源，应用程序将无法访问其数据和日志流。

首先，使用两个语句创建权限策略：一个语句授予对源流执行 `read` 操作的权限，另一个语句授予对接收器流执行 `write` 操作的权限。然后，将策略附加到 IAM 角色（下一部分中将创建此角色）。因此，在适用于 Apache Flink 的托管服务代入该角色时，服务具有必要的权限从源流进行读取和写入接收器流。

使用以下代码创建 `AKReadSourceStreamWriteSinkStream` 权限策略。将 `{{username}}` 替换为您用于创建 Amazon S3 存储桶来存储应用程序代码的用户名。将 Amazon 资源名称 (ARN) 中的账户 ID (`{{012345678901}}`) 替换为您的账户 ID。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "S3",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:GetObjectVersion"
            ],
            "Resource": ["arn:aws:s3:::ka-app-code-{{username}}",
                "arn:aws:s3:::ka-app-code-{{username}}/*"
            ]
        },
        {
            "Sid": "ReadInputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
        },
        {
            "Sid": "WriteOutputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
        }
    ]
}
```

------

有关创建权限策略的分步说明，请参阅*《IAM 用户指南》*中的[教程：创建和附加您的第一个客户管理型策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html#part-two-create-policy)。

**注意**  
要访问其他 Amazon 服务，可以使用 适用于 Java 的 AWS SDK。Managed Service for Apache Flink 会自动将软件开发工具包所需的证书设置为与您的应用程序关联的服务执行 IAM 角色的证书。无需执行其他步骤。

##### 创建一个 IAM 角色
<a name="earlier-gs-1_8-exercise-7-cli-role"></a>

在本节中，您将创建一个 IAM 角色，应用程序的 Managed Service for Apache Flink可以代入此角色来读取源流和写入接收器流。

权限不足时，Managed Service for Apache Flink 无法访问您的串流。您通过 IAM 角色授予这些权限。每个 IAM 角色附加了两种策略。此信任策略授予适用于 Apache Flink 的托管服务代入该角色的权限，权限策略确定适用于 Apache Flink 的托管服务代入这个角色后可以执行的操作。

您将在上一部分中创建的权限策略附加到此角色。

**创建 IAM 角色**

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航窗格中，选择 **角色** 和 **创建角色**。

1. 在 **选择受信任实体的类型** 下，选择 **AWS 服务**。在 **选择将使用此角色的服务** 下，选择 **Kinesis**。在**选择您的使用案例**下，选择 **Kinesis Analytics**。

   选择**下一步: 权限**。

1. 在 **附加权限策略** 页面上，选择 **下一步: 审核**。在创建角色后，您可以附加权限策略。

1. 在 **创建角色** 页面上，输入**MF-stream-rw-role**作为**角色名称**。选择 **创建角色**。

   现在，您已经创建了一个名为 `MF-stream-rw-role` 的新 IAM 角色。接下来，您更新角色的信任和权限策略。

1. 将权限策略附加到角色。
**注意**  
对于本练习，适用于 Apache Flink 的托管服务代入此角色，以便同时从 Kinesis 数据流（源）读取数据和将输出写入另一个 Kinesis 数据流。因此，您附加在上一步（[创建权限策略](#earlier-gs-1_8-exercise-7-cli-policy)）中创建的策略。

   1. 在 **摘要** 页上，选择 **权限** 选项卡。

   1. 选择**附加策略**。

   1. 在搜索框中，输入 **AKReadSourceStreamWriteSinkStream**（您在上一部分中创建的策略）。

   1. 选择**AKReadSourceStreamWriteSinkStream**策略，然后选择**附加策略**。

现在，您已经创建了应用程序用来访问资源的服务执行角色。记下新角色的 ARN。

有关创建角色的分步说明，请参阅*《IAM 用户指南》*中的在您的[中创建 IAM 角色（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html#roles-creatingrole-user-console)。

##### 创建 Managed Service for Apache Flink 应用程序
<a name="earlier-gs-1_8-exercise-7-cli-create"></a>

1. 将以下 JSON 代码保存到名为 `create_request.json` 的文件中。将示例角色 ARN 替换为您之前创建的角色的 ARN。将存储桶 ARN 后缀 (`{{username}}`) 替换为在前一部分中选择的后缀。将服务执行角色中的示例账户 ID (`{{012345678901}}`) 替换为您的账户 ID。

   ```
   {
       "ApplicationName": "test",
       "ApplicationDescription": "my java test app",
       "RuntimeEnvironment": "FLINK-1_8",
       "ServiceExecutionRole": "arn:aws:iam::{{012345678901}}:role/MF-stream-rw-role",
       "ApplicationConfiguration": {
           "ApplicationCodeConfiguration": {
               "CodeContent": {
                   "S3ContentLocation": {
                       "BucketARN": "arn:aws:s3:::ka-app-code-{{username}}",
                       "FileKey": "aws-kinesis-analytics-java-apps-1.0.jar"
                   }
               },
               "CodeContentType": "ZIPFILE"
           },
           "EnvironmentProperties":  { 
            "PropertyGroups": [ 
               { 
                  "PropertyGroupId": "ProducerConfigProperties",
                  "PropertyMap" : {
                       "flink.stream.initpos" : "LATEST",
                       "aws.region" : "us-west-2",
                       "AggregationEnabled" : "false"
                  }
               },
               { 
                  "PropertyGroupId": "ConsumerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2"
                  }
               }
            ]
         }
       }
   }
   ```

1. 使用上述请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html) 操作来创建应用程序：

   ```
   aws kinesisanalyticsv2 create-application --cli-input-json file://create_request.json
   ```

应用程序现已创建。您在下一步中启动应用程序。

##### 启动应用程序
<a name="earlier-gs-1_8-exercise-7-cli-start"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序。

**启动应用程序**

1. 将以下 JSON 代码保存到名为 `start_request.json` 的文件中。

   ```
   {
       "ApplicationName": "test",
       "RunConfiguration": {
           "ApplicationRestoreConfiguration": { 
            "ApplicationRestoreType": "RESTORE_FROM_LATEST_SNAPSHOT"
            }
       }
   }
   ```

1. 使用上述请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序：

   ```
   aws kinesisanalyticsv2 start-application --cli-input-json file://start_request.json
   ```

应用程序正在运行。您可以在亚马逊 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 停止应用程序
<a name="earlier-gs-1_8-exercise-7-cli-stop"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序。

**停止应用程序**

1. 将以下 JSON 代码保存到名为 `stop_request.json` 的文件中。

   ```
   {
      "ApplicationName": "test"
   }
   ```

1. 使用下面的请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序：

   ```
   aws kinesisanalyticsv2 stop-application --cli-input-json file://stop_request.json
   ```

应用程序现已停止。

##### 添加 CloudWatch 日志选项
<a name="earlier-gs-1_8-exercise-7-cli-cw"></a>

您可以使用将 Amazon CloudWatch 日志流 AWS CLI 添加到您的应用程序中。有关在应用程序中使用 CloudWatch Logs 的信息，请参阅[设置 Managed Service for Apache Flink 中的应用程序日志记录](cloudwatch-logs.md)。

##### 更新环境属性
<a name="earlier-gs-1_8-exercise-7-cli-update-env"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) 操作更改应用程序的环境属性，而无需重新编译应用程序代码。在该示例中，您更改源流和目标流的区域。

**更新应用程序的环境属性**

1. 将以下 JSON 代码保存到名为 `update_properties_request.json` 的文件中。

   ```
   {"ApplicationName": "test",
      "CurrentApplicationVersionId": 1,
      "ApplicationConfigurationUpdate": { 
         "EnvironmentPropertyUpdates": { 
            "PropertyGroups": [ 
               { 
                  "PropertyGroupId": "ProducerConfigProperties",
                  "PropertyMap" : {
                       "flink.stream.initpos" : "LATEST",
                       "aws.region" : "us-west-2",
                       "AggregationEnabled" : "false"
                  }
               },
               { 
                  "PropertyGroupId": "ConsumerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2"
                  }
               }
            ]
         }
      }
   }
   ```

1. 使用前面的请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) 操作以更新环境属性：

   ```
   aws kinesisanalyticsv2 update-application --cli-input-json file://update_properties_request.json
   ```

##### 更新应用程序代码
<a name="earlier-gs-1_8-exercise-7-cli-update-code"></a>

当您需要使用新版本的代码包更新应用程序代码时，可以使用[https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) AWS CLI 操作。

**注意**  
要使用相同的文件名加载新版本的应用程序代码，您必须指定新的对象版本。有关使用 Amazon S3 对象版本的更多信息，请参阅[启用或禁用版本控制](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/enable-versioning.html)。

要使用 AWS CLI，请从 Amazon S3 存储桶中删除之前的代码包，上传新版本，然后调用`UpdateApplication`，指定相同的 Amazon S3 存储桶和对象名称以及新的对象版本。应用程序将使用新的代码包重新启动。

以下示例 `UpdateApplication` 操作请求重新加载应用程序代码并重新启动应用程序。将 `CurrentApplicationVersionId` 更新为当前的应用程序版本。您可以使用 `ListApplications` 或 `DescribeApplication` 操作检查当前的应用程序版本。使用您在本节中选择的后缀更新存储桶名称后缀 ({{<username>}})。[创建两个 Amazon Kinesis 数据流](#earlier-gs-1_8-exercise-1)

```
{
    "ApplicationName": "test",
    "CurrentApplicationVersionId": {{1}},
    "ApplicationConfigurationUpdate": {
        "ApplicationCodeConfigurationUpdate": {
            "CodeContentUpdate": {
                "S3ContentLocationUpdate": {
                    "BucketARNUpdate": "arn:aws:s3:::ka-app-code-{{username}}",
                    "FileKeyUpdate": "aws-kinesis-analytics-java-apps-1.0.jar",
                    "ObjectVersionUpdate": "{{SAMPLEUehYngP87ex1nzYIGYgfhypvDU}}"
                }
            }
        }
    }
}
```

#### 后续步骤
<a name="earlier-gs-1_8-exercise-next-step-4"></a>

[步骤 4：清理 AWS 资源](#earlier-gs-1_8-cleanup)

### 步骤 4：清理 AWS 资源
<a name="earlier-gs-1_8-cleanup"></a>

本节包括清理入门教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#earlier-gs-1_8-cleanup-app)
+ [删除您的 Kinesis 数据流](#earlier-gs-1_8-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#earlier-gs-1_8-cleanup-s3)
+ [删除您的 IAM 资源](#earlier-gs-1_8-cleanup-iam)
+ [删除您的 CloudWatch 资源](#earlier-gs-1_8-cleanup-cw)

#### 删除 Managed Service for Apache Flink 应用程序
<a name="earlier-gs-1_8-cleanup-app"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 “适用于 Apache Flink 的托管服务” 面板中，选择。**MyApplication**

1. 选择**配置**。

1. 在 **Snapshots (快照)** 部分中，选择 **Disable (禁用)**，然后选择 **Update (更新)**。

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

#### 删除您的 Kinesis 数据流
<a name="earlier-gs-1_8-cleanup-stream"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

1. 在 **Kinesis 直播**页面中 **ExampleOutputStream**，选择，选择**操作**，选择**删除**，然后确认删除。

#### 删除您的 Amazon S3 对象和存储桶
<a name="earlier-gs-1_8-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

#### 删除您的 IAM 资源
<a name="earlier-gs-1_8-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

#### 删除您的 CloudWatch 资源
<a name="earlier-gs-1_8-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

## 入门：Flink 1.6.2 - 弃用
<a name="earlier-gs-1_6"></a>

**注意**  
Apache Flink 社区不支持 Apache Flink 版本 **1.6、1.8 和 1.11** 已有三年多时间。我们计划于 **2024 年 11 月 5 日**在 Amazon Managed Service for Apache Flink 中弃用这些版本。从该日期起，您将无法创建这些 Flink 版本的新应用程序。在此时间，您可以继续运行现有应用程序。您可以使用 Amazon Managed Service for Apache Flink 中的就地版本升级功能有状态地升级应用程序。有关更多信息，请参阅 [使用 Apache Flink 的就地版本升级](how-in-place-version-upgrades.md)。

本主题包含一个使用 Apache Flink 1.6.2 的 [教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md) 教程版本。

**Topics**
+ [Managed Service for Apache Flink 应用程序组件](#earlier-gs-1_6-components)
+ [完成练习的先决条件](#su-1_6-prerequisites)
+ [步骤 1：设置 AWS 账户并创建管理员用户](#earlier-gs-1_6-setting-up)
+ [步骤 2：设置 AWS Command Line Interface (AWS CLI)](#su-1_6-awscli)
+ [步骤 3：创建并运行 Managed Service for Apache Flink 应用程序](#earlier-gs-1_6-exercise)
+ [步骤 4：清理 AWS 资源](#earlier-gs-1_6-cleanup)

### Managed Service for Apache Flink 应用程序组件
<a name="earlier-gs-1_6-components"></a>

为了处理数据，适用于 Apache 的托管服务 Flink 应用程序使用 Java/Apache Maven 或 Scala 应用程序，该应用程序使用 Apache Flink 运行时处理输入并生成输出。

Managed Service for Apache Flink 应用程序包含以下组件：
+ **运行时系统属性：**您可以使用*运行时属性* 配置应用程序，而无需重新编译应用程序代码。
+ **源：**应用程序通过*源* 使用数据。源连接器从 Kinesis 数据流、Amazon S3 存储桶等读取数据。有关更多信息，请参阅 [添加流数据源](how-sources.md)。
+ **运算符：**应用程序使用一个或多个*运算符* 以处理数据。运算符可以转换、丰富或聚合数据。有关更多信息，请参阅 [运算符](how-operators.md)。
+ **接收器：**应用程序使用*接收器* 将生成的数据发送到外部源。接收器连接器将数据写入到 Kinesis 数据流、Firehose 流、Amazon S3 存储桶等。有关更多信息，请参阅 [使用接收器写入数据](how-sinks.md)。

在创建、编译和打包应用程序后，您可以将代码包上传到 Amazon Simple Storage Service (Amazon S3) 存储桶中。然后，您创建一个 Managed Service for Apache Flink 应用程序。您在代码包位置中传入一个 Kinesis 数据流以作为流数据源，它通常是接收应用程序处理的数据的流或文件位置。

### 完成练习的先决条件
<a name="su-1_6-prerequisites"></a>

要完成本指南中的步骤，您必须满足以下条件：
+ [Java 开发工具包](http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html) (JDK) 版本 8。设置 `JAVA_HOME` 环境变量，使其指向您的 JDK 安装位置。
+ 我们建议您使用开发环境（如 [Eclipse Java Neon](http://www.eclipse.org/downloads/packages/release/neon/3) 或 [IntelliJ Idea](https://www.jetbrains.com/idea/)）来开发和编译您的应用程序。
+ [Git 客户端](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。如果尚未安装 Git 客户端，请安装它。
+ [Apache Maven 编译器插件](https://maven.apache.org/plugins/maven-compiler-plugin/)。Maven 必须位于您的有效路径中。要测试您的 Apache Maven 安装，请输入以下内容：

  ```
  $ mvn -version
  ```

要开始，请转到[步骤 1：设置 AWS 账户并创建管理员用户](#earlier-gs-1_6-setting-up)。

### 步骤 1：设置 AWS 账户并创建管理员用户
<a name="earlier-gs-1_6-setting-up"></a>

#### 注册获取 AWS 账户
<a name="sign-up-for-aws"></a>

如果您没有 AWS 账户，请完成以下步骤来创建一个。

**要注册 AWS 账户**

1. 打开 [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup)。

1. 按照屏幕上的说明操作。

   在注册时，将接到电话或收到短信，要求使用电话键盘输入一个验证码。

   当您注册时 AWS 账户，就会创建*AWS 账户根用户*一个。根用户有权访问该账户中的所有 AWS 服务 和资源。作为最佳安全实践，请为用户分配管理访问权限，并且只使用根用户来执行[需要根用户访问权限的任务](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)。

AWS 注册过程完成后会向您发送一封确认电子邮件。在任何时候，您都可以通过转至 [https://aws.amazon.com/](https://aws.amazon.com/) 并选择 **My Account (我的账户)** 来查看当前的账户活动并管理您的账户。

#### 创建具有管理访问权限的用户
<a name="create-an-admin"></a>

注册后，请保护您的安全 AWS 账户 AWS 账户根用户 AWS IAM Identity Center，启用并创建管理用户，这样您就不会使用 root 用户执行日常任务。

**保护你的 AWS 账户根用户**

1.  选择 **Root 用户**并输入您的 AWS 账户 电子邮件地址，以账户所有者的身份登录。[AWS 管理控制台](https://console.aws.amazon.com/)在下一页上，输入您的密码。

   要获取使用根用户登录方面的帮助，请参阅《AWS 登录 用户指南》**中的 [Signing in as the root user](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)。

1. 为您的根用户启用多重身份验证（MFA）。

   有关说明，请参阅 I [A *M* 用户指南中的为 AWS 账户 根用户启用虚拟 MFA 设备（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)。

**创建具有管理访问权限的用户**

1. 启用 IAM Identity Center。

   有关说明，请参阅**《AWS IAM Identity Center 用户指南》中的[启用 AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)。

1. 在 IAM Identity Center 中，为用户授予管理访问权限。

   有关使用 IAM Identity Center 目录 作为身份源的教程，请参阅《[用户*指南》 IAM Identity Center 目录中的使用默认设置配置AWS IAM Identity Center 用户*访问权限](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)。

**以具有管理访问权限的用户身份登录**
+ 要使用您的 IAM Identity Center 用户身份登录，请使用您在创建 IAM Identity Center 用户时发送到您的电子邮件地址的登录 URL。

  有关使用 IAM Identity Center 用户[登录的帮助，请参阅*AWS 登录 用户指南*中的登录 AWS 访问门户](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)。

**将访问权限分配给其他用户**

1. 在 IAM Identity Center 中，创建一个权限集，该权限集遵循应用最低权限的最佳做法。

   有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)。

1. 将用户分配到一个组，然后为该组分配单点登录访问权限。

   有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)。

#### 授权以编程方式访问
<a name="setting-up-access-gs-6"></a>

如果用户想在 AWS 外部进行交互，则需要编程访问权限 AWS 管理控制台。授予编程访问权限的方式取决于正在访问的用户类型 AWS。

要向用户授予编程式访问权限，请选择以下选项之一。


****  

| 哪个用户需要编程式访问权限？ | 目的 | 方式 | 
| --- | --- | --- | 
| IAM | （推荐）使用控制台凭证作为临时凭证，签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照您希望使用的界面的说明进行操作。[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html) | 
| 人力身份<br />（在 IAM Identity Center 中管理的用户） | 使用临时证书签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照您希望使用的界面的说明进行操作。[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html) | 
| IAM | 使用临时证书签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照 IAM 用户指南中的将[临时证书与 AWS 资源配合使用](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)中的说明进行操作。 | 
| IAM | （不推荐使用）使用长期凭证签署向 AWS CLI、 AWS 软件开发工具包或 AWS API 发出的编程请求。 | 按照您希望使用的界面的说明进行操作。[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html) | 

### 步骤 2：设置 AWS Command Line Interface (AWS CLI)
<a name="su-1_6-awscli"></a>

在此步骤中，您将下载并配置为与适用于 Apache Flink 的托管服务一起使用。 AWS CLI 

**注意**  
本指南中的入门练习假定您使用账户中的管理员凭证 (`adminuser`) 来执行这些操作。

**注意**  
如果您已经 AWS CLI 安装了，则可能需要升级才能获得最新功能。有关更多信息，请参阅AWS Command Line Interface 《用户指南》**中的[安装 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)。要检查的版本 AWS CLI，请运行以下命令：  

```
aws --version
```
本教程中的练习需要以下 AWS CLI 版本或更高版本：  

```
aws-cli/1.16.63
```

**要设置 AWS CLI**

1. 下载并配置 AWS CLI。有关说明，请参阅《AWS Command Line Interface 用户指南》**中的以下主题：
   + [安装 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html)
   + [配置 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)

1. 在文件中为管理员用户添加已命名的配置 AWS CLI `config`文件。在执行 AWS CLI 命令时，您将使用此配置文件。有关命名配置文件的更多信息，请参阅 *AWS Command Line Interface 用户指南*中的[命名配置文件](https://docs.aws.amazon.com/cli/latest/userguide/cli-multiple-profiles.html)。

   ```
   [profile adminuser]
   aws_access_key_id = {{adminuser access key ID}}
   aws_secret_access_key = {{adminuser secret access key}}
   region = {{aws-region}}
   ```

   有关可用 AWS 区域的列表，请参阅中的[区域和终端节点*Amazon Web Services 一般参考*](https://docs.aws.amazon.com/general/latest/gr/rande.html)。
**注意**  
本教程中的示例代码和命令使用美国西部（俄勒冈州）区域。要使用不同的区域，请将本教程的代码和命令中的区域更改为要使用的区域。

1. 在命令提示符处输入以下帮助命令来验证设置：

   ```
   aws help
   ```

设置 AWS 帐户和之后 AWS CLI，您可以尝试下一个练习，即配置示例应用程序并测试端到端设置。

#### 后续步骤
<a name="su-1_6-next-step-3"></a>

[步骤 3：创建并运行 Managed Service for Apache Flink 应用程序](#earlier-gs-1_6-exercise)

### 步骤 3：创建并运行 Managed Service for Apache Flink 应用程序
<a name="earlier-gs-1_6-exercise"></a>

在本练习中，您将创建面向应用程序的适用于 Apache Flink 的托管服务，并将数据流作为源和接收器。

**Topics**
+ [创建两个 Amazon Kinesis 数据流](#earlier-gs-1_6-exercise-1)
+ [将示例记录写入输入流](#earlier-gs-1_6-exercise-2)
+ [下载并检查 Apache Flink 流式处理 Java 代码](#earlier-gs-1_6-exercise-5)
+ [编译应用程序代码](#earlier-gs-1_6-exercise-5.5)
+ [上传 Apache Flink 流式处理 Java 代码](#earlier-gs-1_6-exercise-6)
+ [创建并运行适用于 Apache Flink 的托管服务](#earlier-gs-1_6-exercise-7)

#### 创建两个 Amazon Kinesis 数据流
<a name="earlier-gs-1_6-exercise-1"></a>

在为本练习创建 Managed Service for Apache Flink 应用程序之前，请创建两个 Kinesis 数据流（`ExampleInputStream`和`ExampleOutputStream`）。您的应用程序将这些数据流用于应用程序源和目标流。

可以使用 Amazon Kinesis 控制台或以下 AWS CLI 命令创建这些流。有关控制台说明，请参阅 *Amazon Kinesis Data Streams 开发人员指南*中的[创建和更新数据流](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html)。

**创建数据流 (AWS CLI)**

1. 要创建第一个直播 (`ExampleInputStream`)，请使用以下 Amazon Kinesis 命令`create-stream` AWS CLI 。

   ```
   $ aws kinesis create-stream \
   --stream-name ExampleInputStream \
   --shard-count 1 \
   --region us-west-2 \
   --profile adminuser
   ```

1. 要创建应用程序用来写入输出的第二个流，请运行同一命令（将流名称更改为 `ExampleOutputStream`）。

   ```
   $ aws kinesis create-stream \
   --stream-name ExampleOutputStream \
   --shard-count 1 \
   --region us-west-2 \
   --profile adminuser
   ```

#### 将示例记录写入输入流
<a name="earlier-gs-1_6-exercise-2"></a>

在本节中，您使用 Python 脚本将示例记录写入流，以供应用程序处理。

**注意**  
此部分需要 [AWS SDK for Python (Boto)](https://aws.amazon.com/developers/getting-started/python/)。

1. 使用以下内容创建名为 `stock.py` 的文件：

   ```
    
   import datetime
   import json
   import random
   import boto3
   
   STREAM_NAME = "ExampleInputStream"
   
   
   def get_data():
       return {
           "EVENT_TIME": datetime.datetime.now().isoformat(),
           "TICKER": random.choice(["AAPL", "AMZN", "MSFT", "INTC", "TBV"]),
           "PRICE": round(random.random() * 100, 2),
       }
   
   
   def generate(stream_name, kinesis_client):
       while True:
           data = get_data()
           print(data)
           kinesis_client.put_record(
               StreamName=stream_name, Data=json.dumps(data), PartitionKey="partitionkey"
           )
   
   
   if __name__ == "__main__":
       generate(STREAM_NAME, boto3.client("kinesis"))
   ```

1. 在本教程的后面部分，您运行 `stock.py` 脚本，以将数据发送到应用程序。

   ```
   $ python stock.py
   ```

#### 下载并检查 Apache Flink 流式处理 Java 代码
<a name="earlier-gs-1_6-exercise-5"></a>

此示例的 Java 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/GettingStarted_1_6` 目录。

请注意有关应用程序代码的以下信息：
+ [项目对象模型 (pom.xml)](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html) 文件包含有关应用程序的配置和依赖项的信息，包括Managed Service for Apache Flink库。
+ `BasicStreamingJob.java` 文件包含定义应用程序功能的 `main` 方法。
+ 应用程序使用 Kinesis 源从源流中进行读取。以下代码段创建 Kinesis 源：

  ```
  return env.addSource(new FlinkKinesisConsumer<>(inputStreamName,
                  new SimpleStringSchema(), inputProperties));
  ```
+ 您的应用程序使用 `StreamExecutionEnvironment` 对象创建源和接收连接器以访问外部资源。
+ 该应用程序将使用静态属性创建源和接收连接器。要使用动态应用程序属性，请使用 `createSourceFromApplicationProperties` 和 `createSinkFromApplicationProperties` 方法以创建连接器。这些方法读取应用程序的属性来配置连接器。

  有关运行时系统属性的更多信息，请参阅[使用运行时属性](how-properties.md)。

#### 编译应用程序代码
<a name="earlier-gs-1_6-exercise-5.5"></a>

在本节中，您使用 Apache Maven 编译器创建应用程序的 Java 代码。有关安装 Apache Maven 和 Java 开发工具包 (JDK) 的信息，请参阅[完成练习的先决条件](#su-1_6-prerequisites)。

**注意**  
**要将 Kinesis 连接器与 1.11 之前的 Apache Flink 版本一起使用，您需要下载连接器源代码并构建该连接器，如 [Apache Flink 文档](https://ci.apache.org/projects/flink/flink-docs-release-1.6/dev/connectors/kinesis.html)中所述**。

**编译应用程序代码**

1. 要使用您的应用程序代码，您将其编译和打包成 JAR 文件。您可以通过两种方式之一编译和打包您的代码：
   + 使用命令行 Maven 工具。在包含 `pom.xml` 文件的目录中通过运行以下命令创建您的 JAR 文件：

     ```
     mvn package
     ```
**注意**  
Apache Flink 运行时版本 1.0.1 的托管服务不需要使用-Dflink.version 参数；只有版本 1.1.0 及更高版本才需要使用该参数。有关更多信息，请参阅 [指定应用程序的 Apache Flink 版本](how-creating-apps.md#how-creating-apps-building-flink)。
   + 设置开发环境。有关详细信息，请参阅您的开发环境文档。

   您可以作为 JAR 文件上传您的包，也可以将包压缩为 ZIP 文件并上传。如果您使用创建应用程序 AWS CLI，则需要指定代码内容类型（JAR 或 ZIP）。

1. 如果编译时出错，请验证 `JAVA_HOME` 环境变量设置正确。

如果应用程序成功编译，则创建以下文件：

`target/aws-kinesis-analytics-java-apps-1.0.jar`

#### 上传 Apache Flink 流式处理 Java 代码
<a name="earlier-gs-1_6-exercise-6"></a>

在本节中，您创建 Amazon Simple Storage Service (Amazon S3) 存储桶并上传应用程序代码。

**上传应用程序代码**

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **创建存储桶 **。

1. 在 **存储桶名称** 字段中输入 **ka-app-code-{{<username>}}**。将后缀（如您的用户名）添加到存储桶名称，以使其具有全局唯一性。选择 **下一步**。

1. 在**配置选项**步骤中，让设置保持原样，然后选择**下一步**。

1. 在**设置权限**步骤中，让设置保持原样，然后选择**下一步**。

1. 选择 **创建存储桶 **。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-bucke-{{<username>}}** bucket，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `aws-kinesis-analytics-java-apps-1.0.jar` 文件。选择 **下一步**。

1. 在**设置权限**步骤中，让设置保持原样。选择 **下一步**。

1. 在**设置属性**步骤中，让设置保持原样。选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

#### 创建并运行适用于 Apache Flink 的托管服务
<a name="earlier-gs-1_6-exercise-7"></a>

您可以使用控制台或 AWS CLI创建和运行适用于 Apache Flink 的托管服务的应用程序。

**注意**  
当您使用控制台创建应用程序时，系统会为您创建您的 AWS Identity and Access Management (IAM) 和 A CloudWatch mazon Logs 资源。使用创建应用程序时 AWS CLI，可以单独创建这些资源。

**Topics**
+ [创建并运行应用程序（控制台）](#earlier-gs-1_6-exercise-7-console)
+ [创建并运行应用程序（AWS CLI）](#earlier-gs-1_6-exercise-7-cli)

##### 创建并运行应用程序（控制台）
<a name="earlier-gs-1_6-exercise-7-console"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="earlier-gs-1_6-exercise-7-console-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**描述**，输入 **My java test app**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
**注意**  
Managed Service for Apache Flink使用 Apache Flink 版本 1.8.2 或 1.6.2。
   + 将版本下拉列表更改为 **Apache Flink 1.6**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 编辑 IAM 策略
<a name="earlier-gs-1_6-exercise-7-console-iam"></a>

编辑 IAM policy 以添加访问 Kinesis 数据流的权限。

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:s3:::ka-app-code-{{username}}/java-getting-started-1.0.jar"
               ]
           },
           {
               "Sid": "DescribeLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogStreams"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
               ]
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": [
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
               ]
           }{{,
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteOutputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
           }}}
       ]
   }
   ```

------

##### 配置应用程序
<a name="earlier-gs-1_6-exercise-7-console-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**java-getting-started-1.0.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 输入以下应用程序属性和值：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 Amazon CloudWatch 日志时，适用于 Apache Flink 的托管服务会为您创建一个日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`

##### 运行应用程序
<a name="earlier-gs-1_6-exercise-7-console-run"></a>

1. 在**MyApplication**页面上，选择 “**运行**”。确认该操作。

1. 当应用程序正在运行时，请刷新页面。控制台将显示 **Application graph (应用程序图表)**。

##### 停止应用程序
<a name="earlier-gs-1_6-exercise-7-console-stop"></a>

在**MyApplication**页面上，选择 “**停止**”。确认该操作。

##### 更新应用程序
<a name="earlier-gs-1_6-exercise-7-console-update"></a>

使用控制台，您可以更新应用程序设置，例如应用程序属性、监控设置，或应用程序 JAR 文件的位置和文件名。如果您需要更新应用程序代码，您还可以从 Amazon S3 存储桶重新加载应用程序 JAR。

在**MyApplication**页面上，选择**配置**。更新应用程序设置，然后选择**更新**。

##### 创建并运行应用程序（AWS CLI）
<a name="earlier-gs-1_6-exercise-7-cli"></a>

在本节中，您将使用创建和运行适用 AWS CLI 于 Apache Flink 的托管服务应用程序。适用于 Apache Flink 的托管服务使用该`kinesisanalyticsv2` AWS CLI 命令为 Apache Flink 应用程序创建托管服务并与之交互。

##### 创建权限策略
<a name="earlier-gs-1_6-exercise-7-cli-policy"></a>

首先，使用两个语句创建权限策略：一个语句授予对源流执行 `read` 操作的权限，另一个语句授予对接收器流执行 `write` 操作的权限。然后，将策略附加到 IAM 角色（下一部分中将创建此角色）。因此，在适用于 Apache Flink 的托管服务代入该角色时，服务具有必要的权限从源流进行读取和写入接收器流。

使用以下代码创建 `AKReadSourceStreamWriteSinkStream` 权限策略。将 `{{username}}` 替换为您用于创建 Amazon S3 存储桶来存储应用程序代码的用户名。将 Amazon 资源名称 (ARN) 中的账户 ID (`{{012345678901}}`) 替换为您的账户 ID。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "S3",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:GetObjectVersion"
            ],
            "Resource": ["arn:aws:s3:::ka-app-code-{{username}}",
                "arn:aws:s3:::ka-app-code-{{username}}/*"
            ]
        },
        {
            "Sid": "ReadInputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
        },
        {
            "Sid": "WriteOutputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
        }
    ]
}
```

------

有关创建权限策略的分步说明，请参阅*《IAM 用户指南》*中的[教程：创建和附加您的第一个客户管理型策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html#part-two-create-policy)。

**注意**  
要访问其他 Amazon 服务，可以使用 适用于 Java 的 AWS SDK。Managed Service for Apache Flink 会自动将软件开发工具包所需的证书设置为与您的应用程序关联的服务执行 IAM 角色的证书。无需执行其他步骤。

##### 创建一个 IAM 角色
<a name="earlier-gs-1_6-exercise-7-cli-role"></a>

在本节中，您将创建一个 IAM 角色，应用程序的 Managed Service for Apache Flink可以代入此角色来读取源流和写入接收器流。

权限不足时，Managed Service for Apache Flink 无法访问您的串流。您通过 IAM 角色授予这些权限。每个 IAM 角色附加了两种策略。此信任策略授予适用于 Apache Flink 的托管服务代入该角色的权限，权限策略确定适用于 Apache Flink 的托管服务代入这个角色后可以执行的操作。

您将在上一部分中创建的权限策略附加到此角色。

**创建 IAM 角色**

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航窗格中，选择 **角色** 和 **创建角色**。

1. 在 **选择受信任实体的类型** 下，选择 **AWS 服务**。在 **选择将使用此角色的服务** 下，选择 **Kinesis**。在**选择您的使用案例**下，选择 **Kinesis Analytics**。

   选择**下一步: 权限**。

1. 在 **附加权限策略** 页面上，选择 **下一步: 审核**。在创建角色后，您可以附加权限策略。

1. 在 **创建角色** 页面上，输入**MF-stream-rw-role**作为**角色名称**。选择 **创建角色**。

   现在，您已经创建了一个名为 `MF-stream-rw-role` 的新 IAM 角色。接下来，您更新角色的信任和权限策略。

1. 将权限策略附加到角色。
**注意**  
对于本练习，适用于 Apache Flink 的托管服务代入此角色，以便同时从 Kinesis 数据流（源）读取数据和将输出写入另一个 Kinesis 数据流。因此，您附加在上一步（[创建权限策略](#earlier-gs-1_6-exercise-7-cli-policy)）中创建的策略。

   1. 在 **摘要** 页上，选择 **权限** 选项卡。

   1. 选择**附加策略**。

   1. 在搜索框中，输入 **AKReadSourceStreamWriteSinkStream**（您在上一部分中创建的策略）。

   1. 选择**AKReadSourceStreamWriteSinkStream**策略，然后选择**附加策略**。

现在，您已经创建了应用程序用来访问资源的服务执行角色。记下新角色的 ARN。

有关创建角色的分步说明，请参阅*《IAM 用户指南》*中的在您的[中创建 IAM 角色（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html#roles-creatingrole-user-console)。

##### 创建 Managed Service for Apache Flink 应用程序
<a name="earlier-gs-1_6-exercise-7-cli-create"></a>

1. 将以下 JSON 代码保存到名为 `create_request.json` 的文件中。将示例角色 ARN 替换为您之前创建的角色的 ARN。将存储桶 ARN 后缀 (`{{username}}`) 替换为在前一部分中选择的后缀。将服务执行角色中的示例账户 ID (`{{012345678901}}`) 替换为您的账户 ID。

   ```
   {
       "ApplicationName": "test",
       "ApplicationDescription": "my java test app",
       "RuntimeEnvironment": "FLINK-1_6",
       "ServiceExecutionRole": "arn:aws:iam::{{012345678901}}:role/MF-stream-rw-role",
       "ApplicationConfiguration": {
           "ApplicationCodeConfiguration": {
               "CodeContent": {
                   "S3ContentLocation": {
                       "BucketARN": "arn:aws:s3:::ka-app-code-{{username}}",
                       "FileKey": "java-getting-started-1.0.jar"
                   }
               },
               "CodeContentType": "ZIPFILE"
           },
           "EnvironmentProperties":  { 
            "PropertyGroups": [ 
               { 
                  "PropertyGroupId": "ProducerConfigProperties",
                  "PropertyMap" : {
                       "flink.stream.initpos" : "LATEST",
                       "aws.region" : "us-west-2",
                       "AggregationEnabled" : "false"
                  }
               },
               { 
                  "PropertyGroupId": "ConsumerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2"
                  }
               }
            ]
         }
       }
   }
   ```

1. 使用上述请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html) 操作来创建应用程序：

   ```
   aws kinesisanalyticsv2 create-application --cli-input-json file://create_request.json
   ```

应用程序现已创建。您在下一步中启动应用程序。

##### 启动应用程序
<a name="earlier-gs-1_6-exercise-7-cli-start"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序。

**启动应用程序**

1. 将以下 JSON 代码保存到名为 `start_request.json` 的文件中。

   ```
   {
       "ApplicationName": "test",
       "RunConfiguration": {
           "ApplicationRestoreConfiguration": { 
            "ApplicationRestoreType": "RESTORE_FROM_LATEST_SNAPSHOT"
            }
       }
   }
   ```

1. 使用上述请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序：

   ```
   aws kinesisanalyticsv2 start-application --cli-input-json file://start_request.json
   ```

应用程序正在运行。您可以在亚马逊 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 停止应用程序
<a name="earlier-gs-1_6-exercise-7-cli-stop"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序。

**停止应用程序**

1. 将以下 JSON 代码保存到名为 `stop_request.json` 的文件中。

   ```
   {
      "ApplicationName": "test"
   }
   ```

1. 使用下面的请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序：

   ```
   aws kinesisanalyticsv2 stop-application --cli-input-json file://stop_request.json
   ```

应用程序现已停止。

##### 添加 CloudWatch 日志选项
<a name="earlier-gs-1_6-exercise-7-cli-cw"></a>

您可以使用将 Amazon CloudWatch 日志流 AWS CLI 添加到您的应用程序中。有关在应用程序中使用 CloudWatch Logs 的信息，请参阅[设置 Managed Service for Apache Flink 中的应用程序日志记录](cloudwatch-logs.md)。

##### 更新环境属性
<a name="earlier-gs-1_6-exercise-7-cli-update-env"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) 操作更改应用程序的环境属性，而无需重新编译应用程序代码。在该示例中，您更改源流和目标流的区域。

**更新应用程序的环境属性**

1. 将以下 JSON 代码保存到名为 `update_properties_request.json` 的文件中。

   ```
   {"ApplicationName": "test",
      "CurrentApplicationVersionId": 1,
      "ApplicationConfigurationUpdate": { 
         "EnvironmentPropertyUpdates": { 
            "PropertyGroups": [ 
               { 
                  "PropertyGroupId": "ProducerConfigProperties",
                  "PropertyMap" : {
                       "flink.stream.initpos" : "LATEST",
                       "aws.region" : "us-west-2",
                       "AggregationEnabled" : "false"
                  }
               },
               { 
                  "PropertyGroupId": "ConsumerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2"
                  }
               }
            ]
         }
      }
   }
   ```

1. 使用前面的请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) 操作以更新环境属性：

   ```
   aws kinesisanalyticsv2 update-application --cli-input-json file://update_properties_request.json
   ```

##### 更新应用程序代码
<a name="earlier-gs-1_6-exercise-7-cli-update-code"></a>

当您需要使用新版本的代码包更新应用程序代码时，可以使用[https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) AWS CLI 操作。

要使用 AWS CLI，请从 Amazon S3 存储桶中删除之前的代码包，上传新版本，然后调用`UpdateApplication`，指定相同的 Amazon S3 存储桶和对象名称。应用程序将使用新的代码包重新启动。

以下示例 `UpdateApplication` 操作请求重新加载应用程序代码并重新启动应用程序。将 `CurrentApplicationVersionId` 更新为当前的应用程序版本。您可以使用 `ListApplications` 或 `DescribeApplication` 操作检查当前的应用程序版本。使用您在本节中选择的后缀更新存储桶名称后缀 ({{<username>}})。[创建两个 Amazon Kinesis 数据流](#earlier-gs-1_6-exercise-1)

```
{
    "ApplicationName": "test",
    "CurrentApplicationVersionId": {{1}},
    "ApplicationConfigurationUpdate": {
        "ApplicationCodeConfigurationUpdate": {
            "CodeContentUpdate": {
                "S3ContentLocationUpdate": {
                    "BucketARNUpdate": "arn:aws:s3:::ka-app-code-{{username}}",
                    "FileKeyUpdate": "java-getting-started-1.0.jar"
                }
            }
        }
    }
}
```

### 步骤 4：清理 AWS 资源
<a name="earlier-gs-1_6-cleanup"></a>

本节包括清理入门教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#earlier-gs-1_6-cleanup-app)
+ [删除您的 Kinesis 数据流](#earlier-gs-1_6-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#earlier-gs-1_6-cleanup-s3)
+ [删除您的 IAM 资源](#earlier-gs-1_6-cleanup-iam)
+ [删除您的 CloudWatch 资源](#earlier-gs-1_6-cleanup-cw)

#### 删除 Managed Service for Apache Flink 应用程序
<a name="earlier-gs-1_6-cleanup-app"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 “适用于 Apache Flink 的托管服务” 面板中，选择。**MyApplication**

1. 选择**配置**。

1. 在 **Snapshots (快照)** 部分中，选择 **Disable (禁用)**，然后选择 **Update (更新)**。

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

#### 删除您的 Kinesis 数据流
<a name="earlier-gs-1_6-cleanup-stream"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

1. 在 **Kinesis 直播**页面中 **ExampleOutputStream**，选择，选择**操作**，选择**删除**，然后确认删除。

#### 删除您的 Amazon S3 对象和存储桶
<a name="earlier-gs-1_6-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

#### 删除您的 IAM 资源
<a name="earlier-gs-1_6-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

#### 删除您的 CloudWatch 资源
<a name="earlier-gs-1_6-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

## Managed Service for Apache Flink 的早期版本（旧版）
<a name="legacy-examples"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

本节提供了在Managed Service for Apache Flink 中创建和使用应用程序的示例。它们包括示例代码和分步说明，以帮助您创建 Managed Service for Apache Flink应用程序和测试结果。

在分析这些示例之前，我们建议您先查看以下内容：
+ [工作原理](how-it-works.md)
+ [教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)

**注意**  
这些示例假定您使用美国西部（俄勒冈）区域 (`us-west-2`)。如果您使用不同的区域，请相应地更新应用程序代码、命令和 IAM 角色。

**Topics**
+ [DataStream API 示例](#examples-datastream)
+ [Python 示例](#examples-python)
+ [Scala 示例](#examples-scala)

### DataStream API 示例
<a name="examples-datastream"></a>

以下示例演示了如何使用 Apache Flink DataStream API 创建应用程序。

**Topics**
+ [示例：滚动窗口](#examples-tumbling)
+ [示例：滑动窗口](#examples-sliding)
+ [示例：写入 Amazon S3 存储桶](#examples-s3)
+ [教程：使用 Managed Service for Apache Flink 应用程序将数据从 MSK 集群中的一个主题复制到 VPC 中的另一个主题](#example-msk)
+ [示例：将 EFO 使用者与 Kinesis 数据流配合使用](#examples-efo)
+ [示例：写入 Firehose](#get-started-exercise-fh)
+ [示例：从不同账户的 Kinesis 流中读取](#examples-cross)
+ [教程：在 Amazon MSK 上使用自定义信任库](#example-keystore)

#### 示例：滚动窗口
<a name="examples-tumbling"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

在本练习中，您将创建一个 Managed Service for Apache Flink 应用程序，该应用程序使用滚动窗口聚合数据。在 Flink 中，默认情况下已启用聚合。要禁用，请使用以下命令：

```
sink.producer.aggregation-enabled' = 'false'
```

**注意**  
要为本练习设置所需的先决条件，请先完成[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)练习。

**Topics**
+ [创建相关资源](#examples-tumbling-resources)
+ [将示例记录写入输入流](#examples-tumbling-write)
+ [下载并检查应用程序代码](#examples-tumbling-download)
+ [编译应用程序代码](#examples-tumbling-compile)
+ [上传 Apache Flink 流式处理 Java 代码](#examples-tumbling-upload)
+ [创建并运行适用于 Apache Flink 的托管服务](#examples-tumbling-create-run)
+ [清理 AWS 资源](#examples-tumbling-cleanup)

##### 创建相关资源
<a name="examples-tumbling-resources"></a>

在本练习中，创建Managed Service for Apache Flink的应用程序之前，您需要创建以下从属资源：
+ 两个 Kinesis 数据流（`ExampleInputStream` 和 `ExampleOutputStream`）。
+ 存储应用程序代码 (`ka-app-code-{{<username>}}`) 的 Amazon S3 存储桶 

您可以使用控制台创建 Kinesis 流和 Amazon S3 存储桶。有关创建这些资源的说明，请参阅以下主题：
+ *Amazon Kinesis Data Streams 开发人员指南*中的[创建和更新数据流](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html)。将数据流命名为 **ExampleInputStream** 和 **ExampleOutputStream**。
+ *Amazon Simple Storage Service 用户指南*中的[如何创建 S3 存储桶？](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html)。附加您的登录名，以便为 Amazon S3 存储桶指定全局唯一的名称，例如 **ka-app-code-{{<username>}}**。

##### 将示例记录写入输入流
<a name="examples-tumbling-write"></a>

在本节中，您使用 Python 脚本将示例记录写入流，以供应用程序处理。

**注意**  
此部分需要 [AWS SDK for Python (Boto)](https://aws.amazon.com/developers/getting-started/python/)。

1. 使用以下内容创建名为 `stock.py` 的文件：

   ```
       import datetime
       import json
       import random
       import boto3
   
       STREAM_NAME = "ExampleInputStream"
   
   
       def get_data():
           return {
               'event_time': datetime.datetime.now().isoformat(),
               'ticker': random.choice(['AAPL', 'AMZN', 'MSFT', 'INTC', 'TBV']),
               'price': round(random.random() * 100, 2)}
   
   
       def generate(stream_name, kinesis_client):
           while True:
               data = get_data()
               print(data)
               kinesis_client.put_record(
                   StreamName=stream_name,
                   Data=json.dumps(data),
                   PartitionKey="partitionkey")
   
   
       if __name__ == '__main__':
           generate(STREAM_NAME, boto3.client('kinesis', region_name='us-west-2'))
   ```

1. 运行 `stock.py` 脚本：

   ```
   $ python stock.py
   ```

   在完成本教程的其余部分时，请将脚本保持运行状态。

##### 下载并检查应用程序代码
<a name="examples-tumbling-download"></a>

此示例的 Java 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 如果尚未安装 Git 客户端，请安装它。有关更多信息，请参阅[安装 Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/TumblingWindow` 目录。

应用程序代码位于 `TumblingWindowStreamingJob.java` 文件中。请注意有关应用程序代码的以下信息：
+ 应用程序使用 Kinesis 源从源流中进行读取。以下代码段创建 Kinesis 源：

  ```
  return env.addSource(new FlinkKinesisConsumer<>(inputStreamName,
                  new SimpleStringSchema(), inputProperties));
  ```
+ 添加以下导入语句：

  ```
  import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows; //flink 1.13 onward
  ```
+ 应用程序使用 `timeWindow` 操作符在 5 秒的滚动窗口中查找每个股票代号的值计数。以下代码创建操作符，并将聚合的数据发送到新的 Kinesis Data Streams 接收器：

  ```
  input.flatMap(new Tokenizer()) // Tokenizer for generating words
                      .keyBy(0) // Logically partition the stream for each word
                      
                      .window(TumblingProcessingTimeWindows.of(Time.seconds(5))) //Flink 1.13 onward
                      .sum(1) // Sum the number of words per partition
                      .map(value -> value.f0 + "," + value.f1.toString() + "\n")
                      .addSink(createSinkFromStaticConfig());
  ```

##### 编译应用程序代码
<a name="examples-tumbling-compile"></a>

要编译应用程序，请执行以下操作：

1. 如果还没有 Java 和 Maven，请安装它们。有关更多信息，请参阅[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)教程中的[完成所需的先决条件](getting-started.md#setting-up-prerequisites)。

1. 使用以下命令编译应用程序：

   ```
   mvn package -Dflink.version=1.15.3
   ```
**注意**  
提供的源代码依赖于 Java 11 中的库。

编译应用程序将创建应用程序 JAR 文件 (`target/aws-kinesis-analytics-java-apps-1.0.jar`)。

##### 上传 Apache Flink 流式处理 Java 代码
<a name="examples-tumbling-upload"></a>

在本节中，您将应用程序代码上传到在[创建相关资源](#examples-tumbling-resources)一节中创建的 Amazon S3 存储桶。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-bucke-{{<username>}}** bucket，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `aws-kinesis-analytics-java-apps-1.0.jar` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建并运行适用于 Apache Flink 的托管服务
<a name="examples-tumbling-create-run"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="examples-tumbling-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
**注意**  
Managed Service for Apache Flink 使用 Apache Flink 版本 1.15.2。
   + 将版本下拉列表保留为 **Apache Flink 版本 1.15.2（建议的版本）**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 编辑 IAM 策略
<a name="get-started-exercise-7-console-iam"></a>

编辑 IAM policy 以添加访问 Kinesis 数据流的权限。

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "logs:DescribeLogGroups",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*",
                   "arn:aws:s3:::ka-app-code-{{<username>}}/aws-kinesis-analytics-java-apps-1.0.jar"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": "logs:DescribeLogStreams",
               "Resource": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": "logs:PutLogEvents",
               "Resource": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
           },
           {
               "Sid": "ListCloudwatchLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           }{{,
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteOutputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
           }}}
       ]
   }
   ```

------

##### 配置应用程序
<a name="examples-tumbling-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**aws-kinesis-analytics-java-apps-1.0.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 CloudWatch 日志记录时，适用于 Apache Flink 的托管服务会为您创建日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`
该日志流用于监控应用程序。这与应用程序用于发送结果的日志流不同。

##### 运行应用程序
<a name="examples-tumbling-run"></a>

1. 在**MyApplication**页面上，选择 “**运行**”。保持**不使用快照运行**选项处于选中状态，然后确认操作。

1. 当应用程序正在运行时，请刷新页面。控制台将显示 **Application graph (应用程序图表)**。

您可以在 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 清理 AWS 资源
<a name="examples-tumbling-cleanup"></a>

本节包括清理在 Tumbling Window 教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#examples-tumbling-cleanup-app)
+ [删除您的 Kinesis 数据流](#examples-tumbling-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#examples-tumbling-cleanup-s3)
+ [删除您的 IAM 资源](#examples-tumbling-cleanup-iam)
+ [删除您的 CloudWatch 资源](#examples-tumbling-cleanup-cw)

##### 删除 Managed Service for Apache Flink 应用程序
<a name="examples-tumbling-cleanup-app"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Apache Flink 的托管服务面板中，选择。**MyApplication**

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

##### 删除您的 Kinesis 数据流
<a name="examples-tumbling-cleanup-stream"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

1. 在 **Kinesis 直播**页面中 **ExampleOutputStream**，选择，选择**操作**，选择**删除**，然后确认删除。

##### 删除您的 Amazon S3 对象和存储桶
<a name="examples-tumbling-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

##### 删除您的 IAM 资源
<a name="examples-tumbling-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

##### 删除您的 CloudWatch 资源
<a name="examples-tumbling-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

#### 示例：滑动窗口
<a name="examples-sliding"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

**注意**  
要为本练习设置所需的先决条件，请先完成[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)练习。

**Topics**
+ [创建相关资源](#examples-sliding-resources)
+ [将示例记录写入输入流](#examples-sliding-write)
+ [下载并检查应用程序代码](#examples-sliding-download)
+ [编译应用程序代码](#examples-sliding-compile)
+ [上传 Apache Flink 流式处理 Java 代码](#examples-sliding-upload)
+ [创建并运行适用于 Apache Flink 的托管服务](#examples-sliding-create-run)
+ [清理 AWS 资源](#examples-sliding-cleanup)

##### 创建相关资源
<a name="examples-sliding-resources"></a>

在本练习中，创建Managed Service for Apache Flink的应用程序之前，您需要创建以下从属资源：
+ 两个 Kinesis 数据流（`ExampleInputStream` 和 `ExampleOutputStream`）。
+ 存储应用程序代码 (`ka-app-code-{{<username>}}`) 的 Amazon S3 存储桶 

您可以使用控制台创建 Kinesis 流和 Amazon S3 存储桶。有关创建这些资源的说明，请参阅以下主题：
+ *Amazon Kinesis Data Streams 开发人员指南*中的[创建和更新数据流](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html)。将数据流命名为 **ExampleInputStream** 和 **ExampleOutputStream**。
+ *Amazon Simple Storage Service 用户指南*中的[如何创建 S3 存储桶？](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html)。附加您的登录名，以便为 Amazon S3 存储桶指定全局唯一的名称，例如 **ka-app-code-{{<username>}}**。

##### 将示例记录写入输入流
<a name="examples-sliding-write"></a>

在本节中，您使用 Python 脚本将示例记录写入流，以供应用程序处理。

**注意**  
此部分需要 [AWS SDK for Python (Boto)](https://aws.amazon.com/developers/getting-started/python/)。

1. 使用以下内容创建名为 `stock.py` 的文件：

   ```
    
   import datetime
   import json
   import random
   import boto3
   
   STREAM_NAME = "ExampleInputStream"
   
   
   def get_data():
       return {
           "EVENT_TIME": datetime.datetime.now().isoformat(),
           "TICKER": random.choice(["AAPL", "AMZN", "MSFT", "INTC", "TBV"]),
           "PRICE": round(random.random() * 100, 2),
       }
   
   
   def generate(stream_name, kinesis_client):
       while True:
           data = get_data()
           print(data)
           kinesis_client.put_record(
               StreamName=stream_name, Data=json.dumps(data), PartitionKey="partitionkey"
           )
   
   
   if __name__ == "__main__":
       generate(STREAM_NAME, boto3.client("kinesis"))
   ```

1. 运行 `stock.py` 脚本：

   ```
   $ python stock.py
   ```

   在完成本教程的其余部分时，请将脚本保持运行状态。

##### 下载并检查应用程序代码
<a name="examples-sliding-download"></a>

此示例的 Java 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 如果尚未安装 Git 客户端，请安装它。有关更多信息，请参阅[安装 Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/SlidingWindow` 目录。

应用程序代码位于 `SlidingWindowStreamingJobWithParallelism.java` 文件中。请注意有关应用程序代码的以下信息：
+ 应用程序使用 Kinesis 源从源流中进行读取。以下代码段创建 Kinesis 源：

  ```
  return env.addSource(new FlinkKinesisConsumer<>(inputStreamName,
                  new SimpleStringSchema(), inputProperties));
  ```
+ 应用程序使用 `timeWindow` 操作符在 10 秒的滑动窗口（以 5 秒为增量）中查找每个股票代号的最小值。以下代码创建操作符，并将聚合的数据发送到新的 Kinesis Data Streams 接收器：
+ 添加以下导入语句：

  ```
  import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows; //flink 1.13 onward
  ```
+ 应用程序使用 `timeWindow` 操作符在 5 秒的滚动窗口中查找每个股票代号的值计数。以下代码创建操作符，并将聚合的数据发送到新的 Kinesis Data Streams 接收器：

  ```
  input.flatMap(new Tokenizer()) // Tokenizer for generating words
                  .keyBy(0) // Logically partition the stream for each word
                 
  		.window(TumblingProcessingTimeWindows.of(Time.seconds(5))) //Flink 1.13 onward
                  .sum(1) // Sum the number of words per partition
                  .map(value -> value.f0 + "," + value.f1.toString() + "\n")
                  .addSink(createSinkFromStaticConfig());
  ```

##### 编译应用程序代码
<a name="examples-sliding-compile"></a>

要编译应用程序，请执行以下操作：

1. 如果还没有 Java 和 Maven，请安装它们。有关更多信息，请参阅[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)教程中的[完成所需的先决条件](getting-started.md#setting-up-prerequisites)。

1. 使用以下命令编译应用程序：

   ```
   mvn package -Dflink.version=1.15.3
   ```
**注意**  
提供的源代码依赖于 Java 11 中的库。

编译应用程序将创建应用程序 JAR 文件 (`target/aws-kinesis-analytics-java-apps-1.0.jar`)。

##### 上传 Apache Flink 流式处理 Java 代码
<a name="examples-sliding-upload"></a>

在本节中，您将应用程序代码上传到在[创建相关资源](#examples-sliding-resources)一节中创建的 Amazon S3 存储桶。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-bucke-{{<username>}}** bucket，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `aws-kinesis-analytics-java-apps-1.0.jar` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建并运行适用于 Apache Flink 的托管服务
<a name="examples-sliding-create-run"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="examples-sliding-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
   + 将版本下拉列表保留为 **Apache Flink 1.15.2 (Recommended Version) (Apache Flink 1.15.2 (建议的版本))**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 编辑 IAM 策略
<a name="get-started-exercise-7-console-iam"></a>

编辑 IAM policy 以添加访问 Kinesis 数据流的权限。

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "logs:DescribeLogGroups",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*",
                   "arn:aws:s3:::ka-app-code-{{<username>}}/aws-kinesis-analytics-java-apps-1.0.jar"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": "logs:DescribeLogStreams",
               "Resource": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": "logs:PutLogEvents",
               "Resource": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
           },
           {
               "Sid": "ListCloudwatchLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           }{{,
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteOutputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
           }}}
       ]
   }
   ```

------

##### 配置应用程序
<a name="examples-sliding-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**aws-kinesis-analytics-java-apps-1.0.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 Amazon CloudWatch 日志时，适用于 Apache Flink 的托管服务会为您创建一个日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`
该日志流用于监控应用程序。这与应用程序用于发送结果的日志流不同。

##### 配置应用程序并行度
<a name="examples-sliding-parallelism"></a>

该应用程序示例使用任务的并行执行功能。以下应用程序代码设置 `min` 操作符的并行度：

```
.setParallelism(3) // Set parallelism for the min operator
```

应用程序并行度不能大于预置的并行度（默认为 1）。要提高应用程序的并行度，请使用以下操作： AWS CLI 

```
aws kinesisanalyticsv2 update-application
      --application-name MyApplication
      --current-application-version-id <VersionId>
      --application-configuration-update "{\"FlinkApplicationConfigurationUpdate\": { \"ParallelismConfigurationUpdate\": {\"ParallelismUpdate\": 5, \"ConfigurationTypeUpdate\": \"CUSTOM\" }}}"
```

您可以使用[DescribeApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_DescribeApplication.html)或[ListApplications](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_ListApplications.html)操作检索当前的应用程序版本 ID。

##### 运行应用程序
<a name="examples-sliding-run"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

您可以在 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 清理 AWS 资源
<a name="examples-sliding-cleanup"></a>

本节包括清理滑动窗口教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#examples-sliding-cleanup-app)
+ [删除您的 Kinesis 数据流](#examples-sliding-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#examples-sliding-cleanup-s3)
+ [删除您的 IAM 资源](#examples-sliding-cleanup-iam)
+ [删除您的 CloudWatch 资源](#examples-sliding-cleanup-cw)

##### 删除 Managed Service for Apache Flink 应用程序
<a name="examples-sliding-cleanup-app"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 “适用于 Apache Flink 的托管服务” 面板中，选择。**MyApplication**

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

##### 删除您的 Kinesis 数据流
<a name="examples-sliding-cleanup-stream"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

1. 在 **Kinesis 直播**页面中 **ExampleOutputStream**，选择，选择**操作**，选择**删除**，然后确认删除。

##### 删除您的 Amazon S3 对象和存储桶
<a name="examples-sliding-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

##### 删除您的 IAM 资源
<a name="examples-sliding-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

##### 删除您的 CloudWatch 资源
<a name="examples-sliding-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

#### 示例：写入 Amazon S3 存储桶
<a name="examples-s3"></a>

在本练习中，您创建一个Managed Service for Apache Flink，它将 Kinesis 数据流作为源，并将 Amazon S3 存储桶作为接收器。通过使用接收器，您可以在 Amazon S3 控制台中验证应用程序的输出。

**注意**  
要为本练习设置所需的先决条件，请先完成[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)练习。

**Topics**
+ [创建相关资源](#examples-s3-resources)
+ [将示例记录写入输入流](#examples-s3-write)
+ [下载并检查应用程序代码](#examples-s3-download)
+ [修改应用程序代码](#examples-s3-modify)
+ [编译应用程序代码](#examples-s3-compile)
+ [上传 Apache Flink 流式处理 Java 代码](#examples-s3-upload)
+ [创建并运行适用于 Apache Flink 的托管服务](#examples-s3-create-run)
+ [验证应用程序输出](#examples-s3-verify)
+ [可选：自定义源和接收器](#examples-s3-customize)
+ [清理 AWS 资源](#examples-s3-cleanup)

##### 创建相关资源
<a name="examples-s3-resources"></a>

在本练习中创建 Managed Service for Apache Flink之前，您需要创建以下从属资源：
+ Kinesis 数据流 (`ExampleInputStream`)。
+ 存储应用程序代码和输出的 Amazon S3 存储桶 (`ka-app-code-{{<username>}}`) 

**注意**  
在 Managed Service for Apache Flink 上启用服务器端加密的情况下，Managed Service for Apache Flink 无法将数据写入 Amazon S3。

您可以使用控制台创建 Kinesis 流和 Amazon S3 存储桶。有关创建这些资源的说明，请参阅以下主题：
+ *Amazon Kinesis Data Streams 开发人员指南*中的[创建和更新数据流](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html)。将数据流命名为 **ExampleInputStream**。
+ *Amazon Simple Storage Service 用户指南*中的[如何创建 S3 存储桶？](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html)。附加您的登录名，以便为 Amazon S3 存储桶指定全局唯一的名称，例如 **ka-app-code-{{<username>}}**。在 Amazon S3 存储桶中创建两个文件夹（**code** 和 **data**）。

如果以下 CloudWatch 资源尚不存在，则应用程序会创建这些资源：
+ 名为 `/AWS/KinesisAnalytics-java/MyApplication` 的日志组。
+ 名为 `kinesis-analytics-log-stream` 的日志流。

##### 将示例记录写入输入流
<a name="examples-s3-write"></a>

在本节中，您使用 Python 脚本将示例记录写入流，以供应用程序处理。

**注意**  
此部分需要 [AWS SDK for Python (Boto)](https://aws.amazon.com/developers/getting-started/python/)。

1. 使用以下内容创建名为 `stock.py` 的文件：

   ```
       import datetime
       import json
       import random
       import boto3
   
       STREAM_NAME = "ExampleInputStream"
   
   
       def get_data():
           return {
               'event_time': datetime.datetime.now().isoformat(),
               'ticker': random.choice(['AAPL', 'AMZN', 'MSFT', 'INTC', 'TBV']),
               'price': round(random.random() * 100, 2)}
   
   
       def generate(stream_name, kinesis_client):
           while True:
               data = get_data()
               print(data)
               kinesis_client.put_record(
                   StreamName=stream_name,
                   Data=json.dumps(data),
                   PartitionKey="partitionkey")
   
   
       if __name__ == '__main__':
           generate(STREAM_NAME, boto3.client('kinesis', region_name='us-west-2'))
   ```

1. 运行 `stock.py` 脚本：

   ```
   $ python stock.py
   ```

   在完成本教程的其余部分时，请将脚本保持运行状态。

##### 下载并检查应用程序代码
<a name="examples-s3-download"></a>

此示例的 Java 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 如果尚未安装 Git 客户端，请安装它。有关更多信息，请参阅[安装 Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/S3Sink` 目录。

应用程序代码位于 `S3StreamingSinkJob.java` 文件中。请注意有关应用程序代码的以下信息：
+ 应用程序使用 Kinesis 源从源流中进行读取。以下代码段创建 Kinesis 源：

  ```
  return env.addSource(new FlinkKinesisConsumer<>(inputStreamName,
                  new SimpleStringSchema(), inputProperties));
  ```
+ 您需要添加以下导入语句：

  ```
  import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
  ```
+ 应用程序使用 Apache Flink S3 接收器以写入 Amazon S3。

  接收器在滚动窗口中读取消息，将消息编码为 S3 存储桶对象，然后将编码的对象发送到 S3 接收器。以下代码将对象进行编码以发送到 Amazon S3：

  ```
  input.map(value -> { // Parse the JSON
                  JsonNode jsonNode = jsonParser.readValue(value, JsonNode.class);
                  return new Tuple2<>(jsonNode.get("ticker").toString(), 1);
              }).returns(Types.TUPLE(Types.STRING, Types.INT))
              .keyBy(v -> v.f0) // Logically partition the stream for each word
              .window(TumblingProcessingTimeWindows.of(Time.minutes(1)))
              .sum(1) // Count the appearances by ticker per partition
              .map(value -> value.f0 + " count: " + value.f1.toString() + "\n")
              .addSink(createS3SinkFromStaticConfig());
  ```

**注意**  
应用程序使用 Flink `StreamingFileSink` 对象以写入 Amazon S3。有关的更多信息`StreamingFileSink`，请参阅 [Apache Flink 文档[StreamingFileSink](https://nightlies.apache.org/flink/flink-docs-release-1.13/dev/connectors/streamfile_sink.html)](https://nightlies.apache.org/flink/flink-docs-release-1.13/)中的。

##### 修改应用程序代码
<a name="examples-s3-modify"></a>

在本节中，您修改应用程序代码以将输出写入 Amazon S3 存储桶。

使用您的用户名更新以下行以指定应用程序的输出位置：

```
private static final String s3SinkPath = "s3a://ka-app-code-{{<username>}}/data";
```

##### 编译应用程序代码
<a name="examples-s3-compile"></a>

要编译应用程序，请执行以下操作：

1. 如果还没有 Java 和 Maven，请安装它们。有关更多信息，请参阅[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)教程中的[完成所需的先决条件](getting-started.md#setting-up-prerequisites)。

1. 使用以下命令编译应用程序：

   ```
   mvn package -Dflink.version=1.15.3
   ```

编译应用程序将创建应用程序 JAR 文件 (`target/aws-kinesis-analytics-java-apps-1.0.jar`)。

**注意**  
提供的源代码依赖于 Java 11 中的库。

##### 上传 Apache Flink 流式处理 Java 代码
<a name="examples-s3-upload"></a>

在本节中，您将应用程序代码上传到在[创建相关资源将示例记录写入输入流](#examples-s3-resources)一节中创建的 Amazon S3 存储桶。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-{{<username>}}** bucket，导航到**代码**文件夹，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `aws-kinesis-analytics-java-apps-1.0.jar` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建并运行适用于 Apache Flink 的托管服务
<a name="examples-s3-create-run"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="examples-s3-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
   + 将版本下拉列表保留为 **Apache Flink 1.15.2 (Recommended Version) (Apache Flink 1.15.2 (建议的版本))**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。
**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
对于 **应用程序名称 **，输入 **MyApplication**。
对于**运行时系统**，请选择 **Apache Flink**。
将版本保留为 **Apache Flink 版本 1.15.2（建议的版本）**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
使用控制台创建Managed Service for Apache Flink时，您可以选择为您的应用程序创建一个 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 编辑 IAM 策略
<a name="get-started-exercise-7-console-iam"></a>

编辑 IAM policy 以添加访问 Kinesis 数据流的权限。

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。将 <用户名> 替换为您的用户名。

   ```
   {
               "Sid": "S3",
               "Effect": "Allow",
               "Action": [
                   "s3:Abort*",
                   "s3:DeleteObject*",
                   "s3:GetObject*",
                   "s3:GetBucket*",
                   "s3:List*",
                   "s3:ListBucket",
                   "s3:PutObject"
               ],
               "Resource": [
                   "arn:aws:s3:::ka-app-code-<username>",
                   "arn:aws:s3:::ka-app-code-<username>/*"
               ]
             }, 
           {
               "Sid": "ListCloudwatchLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:region:account-id:log-group:*"
               ]
           },
           {
               "Sid": "ListCloudwatchLogStreams",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogStreams"
               ],
               "Resource": [
                   "arn:aws:logs:region:account-id:log-group:%LOG_GROUP_PLACEHOLDER%:log-stream:*"
               ]
           },
           {
               "Sid": "PutCloudwatchLogs",
               "Effect": "Allow",
               "Action": [
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:region:account-id:log-group:%LOG_GROUP_PLACEHOLDER%:log-stream:%LOG_STREAM_PLACEHOLDER%"
               ]
           }
           {{,
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           }}
       ]
   }
   ```

##### 配置应用程序
<a name="examples-s3-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**code/aws-kinesis-analytics-java-apps-1.0.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 CloudWatch 日志记录时，适用于 Apache Flink 的托管服务会为您创建日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`
该日志流用于监控应用程序。这与应用程序用于发送结果的日志流不同。

##### 运行应用程序
<a name="examples-s3-run"></a>

1. 在**MyApplication**页面上，选择 “**运行**”。保持**不使用快照运行**选项处于选中状态，然后确认操作。

1. 当应用程序正在运行时，请刷新页面。控制台将显示 **Application graph (应用程序图表)**。

##### 验证应用程序输出
<a name="examples-s3-verify"></a>

在 Amazon S3 控制台中，打开 S3 存储桶中的 **data** 文件夹。

几分钟后，将显示包含来自应用程序的聚合数据的对象。

**注意**  
在 Flink 中，默认情况下已启用聚合。要禁用，请使用以下命令：  

```
sink.producer.aggregation-enabled' = 'false'
```

##### 可选：自定义源和接收器
<a name="examples-s3-customize"></a>

在本节中，您将自定义源对象和接收器对象的设置。

**注意**  
更改以下各节所述的代码部分后，请执行以下操作以重新加载应用程序代码：  
重复本[编译应用程序代码](#examples-s3-compile)节中的步骤以编译更新的应用程序代码。
重复本[上传 Apache Flink 流式处理 Java 代码](#examples-s3-upload)节中的步骤以编译更新的应用程序代码。
在控制台的应用程序页面上，选择**配置**，然后选择**更新**，将更新的应用程序代码重新加载到您的应用程序中。

**Topics**
+ [配置数据分区](#examples-s3-configure-partition)
+ [配置读取频率](#examples-s3-configure-read)
+ [配置写入缓冲](#examples-s3-configure-write)

##### 配置数据分区
<a name="examples-s3-configure-partition"></a>

在本节中，您将配置流式文件接收器在 S3 存储桶中创建的文件夹的名称。可以通过向流式文件接收器添加存储桶分配器来完成此操作。

要自定义在 S3 存储桶中创建的文件夹名称，请执行以下操作：

1. 在`S3StreamingSinkJob.java`文件开头添加以下导入语句：

   ```
   import org.apache.flink.streaming.api.functions.sink.filesystem.rollingpolicies.DefaultRollingPolicy;
   import org.apache.flink.streaming.api.functions.sink.filesystem.bucketassigners.DateTimeBucketAssigner;
   ```

1. 更新代码中的`createS3SinkFromStaticConfig()`方法，使其看起来与以下内容类似：

   ```
   private static StreamingFileSink<String> createS3SinkFromStaticConfig() {
   
       final StreamingFileSink<String> sink = StreamingFileSink
           .forRowFormat(new Path(s3SinkPath), new SimpleStringEncoder<String>("UTF-8"))
           {{.withBucketAssigner(new DateTimeBucketAssigner("yyyy-MM-dd--HH"))
           .withRollingPolicy(DefaultRollingPolicy.create().build())}}
           .build();
       return sink;
   }
   ```

前面的代码示例使用带有自定义日期格式的`DateTimeBucketAssigner`，在 S3 存储桶中创建文件夹。`DateTimeBucketAssigner`使用当前系统时间来创建存储桶名称。如果您想创建自定义存储桶分配器以进一步自定义已创建的文件夹名称，则可以创建一个实现[BucketAssigner](https://nightlies.apache.org/flink/flink-docs-release-1.15/api/java/org/apache/flink/streaming/api/functions/sink/filesystem/BucketAssigner.html)的类。您可以使用`getBucketId`方法实现自定义逻辑。

自定义实现`BucketAssigner`可以使用 [Context](https://nightlies.apache.org/flink/flink-docs-release-1.15/api/java/org/apache/flink/streaming/api/functions/sink/filesystem/BucketAssigner.Context.html) 参数获取有关记录的更多信息，从而确定其目标文件夹。

##### 配置读取频率
<a name="examples-s3-configure-read"></a>

在本节中，您将配置对源流的读取频率。

默认情况下，Kinesis Streams 使用者每秒从源流中读取五次。如果有多个客户端从流中读取数据，或者应用程序需要重试读取记录，则此频率将导致出现问题。您可以通过设置使用者的读取频率来避免这些问题。

要设置 Kinesis 使用者的读取频率，您需要设置该`SHARD_GETRECORDS_INTERVAL_MILLIS`设置。

以下代码示例将`SHARD_GETRECORDS_INTERVAL_MILLIS`设置设置为一秒：

```
kinesisConsumerConfig.setProperty(ConsumerConfigConstants.SHARD_GETRECORDS_INTERVAL_MILLIS, "1000");
```

##### 配置写入缓冲
<a name="examples-s3-configure-write"></a>

在本节中，您将配置接收器的写入频率和其他设置。

默认情况下，应用程序每分钟写入一次目标存储桶。您可以通过配置`DefaultRollingPolicy`对象来更改此间隔和其他设置。

**注意**  
每次应用程序创建检查点时，Apache Flink 流式文件接收器都会写入其输出存储桶。默认情况下，应用程序每分钟创建一个检查点。要增加 S3 接收器的写入间隔，还必须增加检查点间隔。

若要配置`DefaultRollingPolicy`对象，请执行以下操作：

1. 增加应用程序的`CheckpointInterval`设置。以下[ UpdateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html)操作输入将检查点间隔设置为 10 分钟：

   ```
   {
      "ApplicationConfigurationUpdate": {  
         "FlinkApplicationConfigurationUpdate": { 
            "CheckpointConfigurationUpdate": {
               "ConfigurationTypeUpdate" : "CUSTOM", 
               "CheckpointIntervalUpdate": 600000
            }
         }
      },
      "ApplicationName": "MyApplication",
      "CurrentApplicationVersionId": {{5}}
   }
   ```

   要使用上述代码，请指定当前应用程序版本。您可以使用[ListApplications](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_ListApplications.html)操作检索应用程序版本。

1. 在`S3StreamingSinkJob.java`文件开头添加以下导入语句：

   ```
   import java.util.concurrent.TimeUnit; 
   ```

1. 更新`S3StreamingSinkJob.java`文件中的`createS3SinkFromStaticConfig`方法，使其看起来与以下内容类似：

   ```
   private static StreamingFileSink<String> createS3SinkFromStaticConfig() {
   
           final StreamingFileSink<String> sink = StreamingFileSink
                   .forRowFormat(new Path(s3SinkPath), new SimpleStringEncoder<String>("UTF-8"))
                   {{.withBucketAssigner(new DateTimeBucketAssigner("yyyy-MM-dd--HH"))
                   .withRollingPolicy(
                           DefaultRollingPolicy.create()
                               .withRolloverInterval(TimeUnit.MINUTES.toMillis(8))
                               .withInactivityInterval(TimeUnit.MINUTES.toMillis(5))
                               .withMaxPartSize(1024 * 1024 * 1024)
                               .build())}}
                   .build();
           return sink;
       }
   ```

   前面的代码示例将写入 Amazon S3 存储桶的频率设置为 8 分钟。

有关配置 Apache Flink 流式文件接收器的更多信息，请参阅 A [pach](https://nightlies.apache.org/flink/flink-docs-release-1.13/) e Flink 文档中的[Row-encoded 格式](https://nightlies.apache.org/flink/flink-docs-release-1.13/dev/connectors/streamfile_sink.html#row-encoded-formats)。

##### 清理 AWS 资源
<a name="examples-s3-cleanup"></a>

本节包括清理您在 Amazon S3 教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#examples-s3-cleanup-app)
+ [删除 Kinesis 数据流](#examples-s3-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#examples-s3-cleanup-s3)
+ [删除您的 IAM 资源](#examples-s3-cleanup-iam)
+ [删除您的 CloudWatch 资源](#examples-s3-cleanup-cw)

##### 删除 Managed Service for Apache Flink 应用程序
<a name="examples-s3-cleanup-app"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 “适用于 Apache Flink 的托管服务” 面板中，选择。**MyApplication**

1. 在应用程序的页面中，选择**删除**，然后确认删除。

##### 删除 Kinesis 数据流
<a name="examples-s3-cleanup-stream"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在**ExampleInputStream**页面上，选择 “**删除 Kinesis Stream**”，然后确认删除。

##### 删除您的 Amazon S3 对象和存储桶
<a name="examples-s3-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

##### 删除您的 IAM 资源
<a name="examples-s3-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择**角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

##### 删除您的 CloudWatch 资源
<a name="examples-s3-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择**日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

#### 教程：使用 Managed Service for Apache Flink 应用程序将数据从 MSK 集群中的一个主题复制到 VPC 中的另一个主题
<a name="example-msk"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

下面的教程演示了如何创建带有 Amazon MSK 集群和两个主题的 Amazon VPC，以及如何创建Managed Service for Apache Flink的应用程序，用于从一个 Amazon MSK 主题读取数据并写入另一个主题。

**注意**  
要为本练习设置所需的先决条件，请先完成[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)练习。

**Topics**
+ [创建带有 Amazon MSK 集群的 Amazon VPC](#example-msk-createcluster)
+ [创建应用程序代码](#example-msk-code)
+ [上传 Apache Flink 流式处理 Java 代码](#example-msk-upload)
+ [创建应用程序](#example-msk-create)
+ [配置应用程序](#example-msk-configure)
+ [运行应用程序](#example-msk-run)
+ [测试应用程序](#example-msk-test)

##### 创建带有 Amazon MSK 集群的 Amazon VPC
<a name="example-msk-createcluster"></a>

要创建示例 VPC 和 Amazon MSK 集群以从Managed Service for Apache Flink的应用程序进行访问，请按照 [Amazon MSK 入门](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html)教程进行操作。

在完成本教程时，请注意以下几点：
+ 在[步骤 3：创建主题](https://docs.aws.amazon.com/msk/latest/developerguide/create-topic.html)中，重复 `kafka-topics.sh --create` 命令以创建名为 `AWSKafkaTutorialTopicDestination` 的目标主题：

  ```
  bin/kafka-topics.sh --create --zookeeper {{ZooKeeperConnectionString}} --replication-factor 3 --partitions 1 --topic AWS KafkaTutorialTopicDestination
  ```
+ 记录集群的引导服务器列表。您可以使用以下命令获取引导服务器列表（{{ClusterArn}}替换为 MSK 集群的 ARN）：

  ```
  aws kafka get-bootstrap-brokers --region us-west-2 --cluster-arn {{ClusterArn}}
  {...
      "BootstrapBrokerStringTls": "b-2.awskafkatutorialcluste.t79r6y.c4.kafka.us-west-2.amazonaws.com:9094,b-1.awskafkatutorialcluste.t79r6y.c4.kafka.us-west-2.amazonaws.com:9094,b-3.awskafkatutorialcluste.t79r6y.c4.kafka.us-west-2.amazonaws.com:9094"
  }
  ```
+ 按照教程中的步骤进行操作时，请务必在代码、命令和控制台条目中使用您选择的 AWS 区域。

##### 创建应用程序代码
<a name="example-msk-code"></a>

在本节中，您下载并编译应用程序 JAR 文件。我们建议使用 Java 11。

此示例的 Java 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 如果尚未安装 Git 客户端，请安装它。有关更多信息，请参阅[安装 Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 应用程序代码位于 `amazon-kinesis-data-analytics-java-examples/KafkaConnectors/KafkaGettingStartedJob.java` 文件中。您可以检查代码以熟悉Managed Service for Apache Flink的应用程序代码的结构。

1. 使用命令行 Maven 工具或首选的开发环境以创建 JAR 文件。要使用命令行 Maven 工具编译 JAR 文件，请输入以下内容：

   ```
   mvn package -Dflink.version=1.15.3
   ```

   如果构建成功，则会创建以下文件：

   ```
   target/KafkaGettingStartedJob-1.0.jar
   ```
**注意**  
提供的源代码依赖于 Java 11 中的库。如果您使用的是开发环境，

##### 上传 Apache Flink 流式处理 Java 代码
<a name="example-msk-upload"></a>

在本节中，您将应用程序代码上传到在[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)教程中创建的 Amazon S3 存储桶。

**注意**  
如果您从入门教程中删除了 Amazon S3 存储桶，请再次执行[上传应用程序代码 JAR 文件](get-started-exercise.md#get-started-exercise-6)步骤。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-bucke-{{<username>}}** bucket，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `KafkaGettingStartedJob-1.0.jar` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建应用程序
<a name="example-msk-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink..

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于**应用程序名称**，输入 **MyApplication**。
   + 对于**运行时系统**，请选择 **Apache Flink 版本 1.15.2**。

1. 对于**访问权限**，请选择**创建/更新 IAM 角色`kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 配置应用程序
<a name="example-msk-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**KafkaGettingStartedJob-1.0.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。
**注意**  
当您使用控制台指定应用程序资源（例如 CloudWatch 日志或 Amazon VPC）时，控制台会修改您的应用程序执行角色以授予访问这些资源的权限。

1. 在 **Properties (属性)** 下面，选择 **Add Group (添加组)**。输入以下属性：  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)
**注意**  
默认证书的 **ssl.truststore.password** 为“changeit”；如果使用默认证书，则不需要更改该值。

   再次选择 **Add Group (添加组)**。输入以下属性：  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

   应用程序代码读取上述应用程序属性，以配置用于与 VPC 和 Amazon MSK 集群交互的源和接收器。有关使用属性的更多信息，请参阅[使用运行时属性](how-properties.md)。

1. 在 **Snapshots (快照)** 下面，选择 **Disable (禁用)**。这样，就可以轻松更新应用程序，而无需加载无效的应用程序状态数据。

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 在 **Virtual Private Cloud (VPC)** 部分中，选择要与应用程序关联的 VPC。选择与您的 VPC 关联的子网和安全组，您希望应用程序使用它们访问 VPC 资源。

1. 选择**更新**。

**注意**  
当您选择启用 CloudWatch 日志记录时，适用于 Apache Flink 的托管服务会为您创建日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`
该日志流用于监控应用程序。

##### 运行应用程序
<a name="example-msk-run"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

##### 测试应用程序
<a name="example-msk-test"></a>

在本节中，您将记录写入到源主题。应用程序从源主题中读取记录，并将其写入到目标主题中。您可以将记录写入到源主题以及从目标主题中读取记录，以验证应用程序是否正常工作。

要写入和读取主题中的记录，请按照 [Amazon MSK 入门](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html)教程中的[步骤 6：生成和使用数据](https://docs.aws.amazon.com/msk/latest/developerguide/produce-consume.html)中的步骤进行操作。

要从目标主题中读取，请在到集群的第二个连接中使用目标主题名称，而不是源主题：

```
bin/kafka-console-consumer.sh --bootstrap-server {{BootstrapBrokerString}} --consumer.config client.properties --topic AWS KafkaTutorialTopicDestination --from-beginning
```

如果在目标主题中没有任何记录，请参阅[Managed Service for Apache Flink 的故障排除](troubleshooting.md)主题中的[无法访问 VPC 中的资源](troubleshooting-symptoms.md#troubleshooting-rt-vpc)一节。

#### 示例：将 EFO 使用者与 Kinesis 数据流配合使用
<a name="examples-efo"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

在本练习中，您将创建一个适用于 Apache Flink 的托管服务，该应用程序使用[增强型 Fan-Out (](https://docs.aws.amazon.com/streams/latest/dev/enhanced-consumers.html)EFO) 使用器从 Kinesis 数据流中读取。如果 Kinesis 使用者使用 EFO，则 Kinesis Data Streams 服务会为其提供自己的专用带宽，而不是让其与从流中读取数据的其他使用者共享流的固定带宽。

有关在 Kinesis 使用者中使用 EFO 的更多信息，[ FLIP-128请参阅：Kinesis 消费者的增强型扇出](https://cwiki.apache.org/confluence/display/FLINK/FLIP-128%3A+Enhanced+Fan+Out+for+AWS+Kinesis+Consumers)。

你在本示例中创建的应用程序使用 AWS Kinesis 连接器（flink-connector-kinesis）1.15.3。

**注意**  
要为本练习设置所需的先决条件，请先完成[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)练习。

**Topics**
+ [创建相关资源](#examples-efo-resources)
+ [将示例记录写入输入流](#examples-efo-write)
+ [下载并检查应用程序代码](#examples-efo-download)
+ [编译应用程序代码](#examples-efo-compile)
+ [上传 Apache Flink 流式处理 Java 代码](#examples-efo-upload)
+ [创建并运行适用于 Apache Flink 的托管服务](#examples-efo-create-run)
+ [清理 AWS 资源](#examples-efo-cleanup)

##### 创建相关资源
<a name="examples-efo-resources"></a>

在本练习中，创建Managed Service for Apache Flink的应用程序之前，您需要创建以下从属资源：
+ 两个 Kinesis 数据流（`ExampleInputStream` 和 `ExampleOutputStream`）。
+ 存储应用程序代码 (`ka-app-code-{{<username>}}`) 的 Amazon S3 存储桶 

您可以使用控制台创建 Kinesis 流和 Amazon S3 存储桶。有关创建这些资源的说明，请参阅以下主题：
+ *Amazon Kinesis Data Streams 开发人员指南*中的[创建和更新数据流](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html)。将数据流命名为 **ExampleInputStream** 和 **ExampleOutputStream**。
+ *Amazon Simple Storage Service 用户指南*中的[如何创建 S3 存储桶？](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html)。附加您的登录名，以便为 Amazon S3 存储桶指定全局唯一的名称，例如 **ka-app-code-{{<username>}}**。

##### 将示例记录写入输入流
<a name="examples-efo-write"></a>

在本节中，您使用 Python 脚本将示例记录写入流，以供应用程序处理。

**注意**  
此部分需要 [AWS SDK for Python (Boto)](https://aws.amazon.com/developers/getting-started/python/)。

1. 使用以下内容创建名为 `stock.py` 的文件：

   ```
    
       import datetime
       import json
       import random
       import boto3
   
       STREAM_NAME = "ExampleInputStream"
   
   
       def get_data():
           return {
               'event_time': datetime.datetime.now().isoformat(),
               'ticker': random.choice(['AAPL', 'AMZN', 'MSFT', 'INTC', 'TBV']),
               'price': round(random.random() * 100, 2)}
   
   
       def generate(stream_name, kinesis_client):
           while True:
               data = get_data()
               print(data)
               kinesis_client.put_record(
                   StreamName=stream_name,
                   Data=json.dumps(data),
                   PartitionKey="partitionkey")
   
   
       if __name__ == '__main__':
           generate(STREAM_NAME, boto3.client('kinesis', region_name='us-west-2'))
   ```

1. 运行 `stock.py` 脚本：

   ```
   $ python stock.py
   ```

   在完成本教程的其余部分时，请将脚本保持运行状态。

##### 下载并检查应用程序代码
<a name="examples-efo-download"></a>

此示例的 Java 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 如果尚未安装 Git 客户端，请安装它。有关更多信息，请参阅[安装 Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/EfoConsumer` 目录。

应用程序代码位于 `EfoApplication.java` 文件中。请注意有关应用程序代码的以下信息：
+ 您可以通过在 Kinesis 使用者上设置以下参数来启用 EFO 使用者：
  + **RECORD\_PUBLISHER\_TYPE：**将此参数设置为 **EFO**，让您的应用程序使用 EFO 使用者访问 Kinesis 数据流数据。
  + **EFO\_CONSUMER\_NAME：**将此参数设置为在该直播的使用者中唯一的字符串值。 Re-using 同一 Kinesis 数据流中的使用者名称将导致之前使用该名称的使用者被终止。
+ 以下代码示例演示如何为使用者配置属性赋值，以便使用 EFO 使用者从源流中读取：

  ```
  consumerConfig.putIfAbsent(RECORD_PUBLISHER_TYPE, "EFO");
  consumerConfig.putIfAbsent(EFO_CONSUMER_NAME, "basic-efo-flink-app");
  ```

##### 编译应用程序代码
<a name="examples-efo-compile"></a>

要编译应用程序，请执行以下操作：

1. 如果还没有 Java 和 Maven，请安装它们。有关更多信息，请参阅[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)教程中的[完成所需的先决条件](getting-started.md#setting-up-prerequisites)。

1. 使用以下命令编译应用程序：

   ```
   mvn package -Dflink.version=1.15.3
   ```
**注意**  
提供的源代码依赖于 Java 11 中的库。

编译应用程序将创建应用程序 JAR 文件 (`target/aws-kinesis-analytics-java-apps-1.0.jar`)。

##### 上传 Apache Flink 流式处理 Java 代码
<a name="examples-efo-upload"></a>

在本节中，您将应用程序代码上传到在[创建相关资源](#examples-efo-resources)一节中创建的 Amazon S3 存储桶。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-bucke-{{<username>}}** bucket，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `aws-kinesis-analytics-java-apps-1.0.jar` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建并运行适用于 Apache Flink 的托管服务
<a name="examples-efo-create-run"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="examples-efo-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
**注意**  
Managed Service for Apache Flink 使用 Apache Flink 版本 1.15.2。
   + 将版本下拉列表保留为 **Apache Flink 版本 1.15.2（建议的版本）**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 编辑 IAM 策略
<a name="get-started-exercise-7-console-iam"></a>

编辑 IAM policy 以添加访问 Kinesis 数据流的权限。

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。
**注意**  
这些权限使应用程序能够访问 EFO 使用者。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "logs:DescribeLogGroups",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*",
                   "arn:aws:s3:::ka-app-code-{{<username>}}/aws-kinesis-analytics-java-apps-1.0.jar"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": "logs:DescribeLogStreams",
               "Resource": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": "logs:PutLogEvents",
               "Resource": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
           },
           {
               "Sid": "ListCloudwatchLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           }{{,
           {
               "Sid": "AllStreams",
               "Effect": "Allow",
               "Action": [
                   "kinesis:ListShards",
                   "kinesis:ListStreamConsumers",
                   "kinesis:DescribeStreamSummary"
               ],
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/*"
           },
           {
               "Sid": "Stream",
               "Effect": "Allow",
               "Action": [
                   "kinesis:DescribeStream",
                   "kinesis:RegisterStreamConsumer",
                   "kinesis:DeregisterStreamConsumer"
               ],
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteOutputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
           },
           {
               "Sid": "Consumer",
               "Effect": "Allow",
               "Action": [
                   "kinesis:DescribeStreamConsumer",
                   "kinesis:SubscribeToShard"
               ],
               "Resource": [
                   "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream/consumer/my-efo-flink-app",
                   "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream/consumer/my-efo-flink-app:*"
               ]
           }}}
       ]
   }
   ```

------

##### 配置应用程序
<a name="examples-efo-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**aws-kinesis-analytics-java-apps-1.0.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 在**属性**下，选择**创建组**。

1. 输入以下应用程序属性和值：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在**属性**下，选择**创建组**。

1. 输入以下应用程序属性和值：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 CloudWatch 日志记录时，适用于 Apache Flink 的托管服务会为您创建日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`
该日志流用于监控应用程序。这与应用程序用于发送结果的日志流不同。

##### 运行应用程序
<a name="examples-efo-run"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

您可以在 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

您还可以在数据流的**增强型扇出功能**选项卡中查看 Kinesis 数据流控制台的使用者名称 (*basic-efo-flink-app*)。

##### 清理 AWS 资源
<a name="examples-efo-cleanup"></a>

本节包括清理在 efo Window 教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#examples-efo-cleanup-app)
+ [删除您的 Kinesis 数据流](#examples-efo-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#examples-efo-cleanup-s3)
+ [删除您的 IAM 资源](#examples-efo-cleanup-iam)
+ [删除您的 CloudWatch 资源](#examples-efo-cleanup-cw)

##### 删除 Managed Service for Apache Flink 应用程序
<a name="examples-efo-cleanup-app"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Apache Flink 的托管服务面板中，选择。**MyApplication**

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

##### 删除您的 Kinesis 数据流
<a name="examples-efo-cleanup-stream"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

1. 在 **Kinesis 直播**页面中 **ExampleOutputStream**，选择，选择**操作**，选择**删除**，然后确认删除。

##### 删除您的 Amazon S3 对象和存储桶
<a name="examples-efo-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

##### 删除您的 IAM 资源
<a name="examples-efo-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

##### 删除您的 CloudWatch 资源
<a name="examples-efo-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

#### 示例：写入 Firehose
<a name="get-started-exercise-fh"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

在本练习中，您将创建一个 Managed Service for Apache Flink 应用程序，该应用程序将 Kinesis 数据流作为源，将 Firehose 流作为接收器。通过使用接收器，您可以在 Amazon S3 存储桶中验证应用程序的输出。

**注意**  
要为本练习设置所需的先决条件，请先完成[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)练习。

**Topics**
+ [创建相关资源](#get-started-exercise-fh-1)
+ [将示例记录写入输入流](#get-started-exercise-fh-2)
+ [下载并检查 Apache Flink 流式处理 Java 代码](#get-started-exercise-fh-5)
+ [编译应用程序代码](#get-started-exercise-fh-5.5)
+ [上传 Apache Flink 流式处理 Java 代码](#get-started-exercise-fh-6)
+ [创建并运行适用于 Apache Flink 的托管服务](#get-started-exercise-fh-7)
+ [清理 AWS 资源](#getting-started-fh-cleanup)

##### 创建相关资源
<a name="get-started-exercise-fh-1"></a>

在本练习中创建 Managed Service for Apache Flink之前，您需要创建以下从属资源：
+ Kinesis 数据流 (`ExampleInputStream`) 
+ 应用程序将输出写入（`ExampleDeliveryStream`）的 Firehose 流。
+ 存储应用程序代码 (`ka-app-code-{{<username>}}`) 的 Amazon S3 存储桶

您可以使用控制台创建 Kinesis 流、Amazon S3 存储桶和 Firehose 流。有关创建这些资源的说明，请参阅以下主题：
+ *Amazon Kinesis Data Streams 开发人员指南*中的[创建和更新数据流](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html)。将数据流命名为 **ExampleInputStream**。
+ *Amazon Data Firehose 开发人员指南*中的[创建 Amazon Kinesis Data Firehose 传输流](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html)。命名您的 Firehose 流 **ExampleDeliveryStream**。在创建 Firehose 流时，还要创建 Firehose 流的 **S3 目标**和 **IAM 角色**。
+ *《Amazon Simple Storage Service 用户指南》*中的[如何创建 S3 存储桶？](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html)。附加您的登录名，以便为 Amazon S3 存储桶指定全局唯一的名称，例如 **ka-app-code-{{<username>}}**。

##### 将示例记录写入输入流
<a name="get-started-exercise-fh-2"></a>

在本节中，您使用 Python 脚本将示例记录写入流，以供应用程序处理。

**注意**  
此部分需要 [AWS SDK for Python (Boto)](https://aws.amazon.com/developers/getting-started/python/)。

1. 使用以下内容创建名为 `stock.py` 的文件：

   ```
    import datetime
       import json
       import random
       import boto3
   
       STREAM_NAME = "ExampleInputStream"
   
   
       def get_data():
           return {
               'event_time': datetime.datetime.now().isoformat(),
               'ticker': random.choice(['AAPL', 'AMZN', 'MSFT', 'INTC', 'TBV']),
               'price': round(random.random() * 100, 2)}
   
   
       def generate(stream_name, kinesis_client):
           while True:
               data = get_data()
               print(data)
               kinesis_client.put_record(
                   StreamName=stream_name,
                   Data=json.dumps(data),
                   PartitionKey="partitionkey")
   
   
       if __name__ == '__main__':
           generate(STREAM_NAME, boto3.client('kinesis', region_name='us-west-2'))
   ```

1. 运行 `stock.py` 脚本：

   ```
   $ python stock.py
   ```

   在完成本教程的其余部分时，请将脚本保持运行状态。

##### 下载并检查 Apache Flink 流式处理 Java 代码
<a name="get-started-exercise-fh-5"></a>

此示例的 Java 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/FirehoseSink` 目录。

应用程序代码位于 `FirehoseSinkStreamingJob.java` 文件中。请注意有关应用程序代码的以下信息：
+ 应用程序使用 Kinesis 源从源流中进行读取。以下代码段创建 Kinesis 源：

  ```
  return env.addSource(new FlinkKinesisConsumer<>(inputStreamName,
                  new SimpleStringSchema(), inputProperties));
  ```
+ 应用程序使用 Firehose 接收器将数据写入到 Firehose 流。以下代码段创建 Firehose 接收器：

  ```
  private static KinesisFirehoseSink<String> createFirehoseSinkFromStaticConfig() {
          Properties sinkProperties = new Properties();
          sinkProperties.setProperty(AWS_REGION, region);
  
          return KinesisFirehoseSink.<String>builder()
                  .setFirehoseClientProperties(sinkProperties)
                  .setSerializationSchema(new SimpleStringSchema())
                  .setDeliveryStreamName(outputDeliveryStreamName)
                  .build();
      }
  ```

##### 编译应用程序代码
<a name="get-started-exercise-fh-5.5"></a>

要编译应用程序，请执行以下操作：

1. 如果还没有 Java 和 Maven，请安装它们。有关更多信息，请参阅[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)教程中的[完成所需的先决条件](getting-started.md#setting-up-prerequisites)。

1. **要将 Kinesis 连接器用于以下应用程序，您需要下载、构建并安装 Apache Maven。有关更多信息，请参阅[将 Apache Flink Kinesis Streams 连接器与之前的 Apache Flink 版本一起使用](#how-creating-apps-building-kinesis)。**

1. 使用以下命令编译应用程序：

   ```
   mvn package -Dflink.version=1.15.3
   ```
**注意**  
提供的源代码依赖于 Java 11 中的库。

编译应用程序将创建应用程序 JAR 文件 (`target/aws-kinesis-analytics-java-apps-1.0.jar`)。

##### 上传 Apache Flink 流式处理 Java 代码
<a name="get-started-exercise-fh-6"></a>

在本节中，您将应用程序代码上传到在[创建相关资源](#get-started-exercise-fh-1)一节中创建的 Amazon S3 存储桶。

**上传应用程序代码**

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. **在控制台中，选择 ka **-app-code-{{<username>}}** bucket，然后选择 Upload。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `java-getting-started-1.0.jar` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建并运行适用于 Apache Flink 的托管服务
<a name="get-started-exercise-fh-7"></a>

您可以使用控制台或 AWS CLI创建和运行适用于 Apache Flink 的托管服务的应用程序。

**注意**  
当您使用控制台创建应用程序时，系统会为您创建您的 AWS Identity and Access Management (IAM) 和 A CloudWatch mazon Logs 资源。使用创建应用程序时 AWS CLI，可以单独创建这些资源。

**Topics**
+ [创建并运行应用程序（控制台）](#get-started-exercise-fh-7-console)
+ [创建并运行应用程序（AWS CLI）](#get-started-exercise-fh-7-cli)

##### 创建并运行应用程序（控制台）
<a name="get-started-exercise-fh-7-console"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="get-started-exercise-fh-7-console-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**描述**，输入 **My java test app**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
**注意**  
Managed Service for Apache Flink 使用 Apache Flink 版本 1.15.2。
   + 将版本下拉列表保留为 **Apache Flink 版本 1.15.2（建议的版本）**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序时，您可以选择为应用程序创建 IAM 角色和策略。应用程序使用该角色和策略访问其相关资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 编辑 IAM 策略
<a name="get-started-exercise-fh-7-console-iam"></a>

编辑 IAM 策略以添加访问 Kinesis 数据流和 Firehose 流的权限。

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 的所有实例替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:s3:::ka-app-code-{{username}}/java-getting-started-1.0.jar"
               ]
           },
           {
               "Sid": "DescribeLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogStreams"
              ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
               ]
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": [
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
               ]
           }{{,
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteDeliveryStream",
               "Effect": "Allow",
               "Action": "firehose:*",
               "Resource": "arn:aws:firehose:us-west-2:{{012345678901}}:deliverystream/ExampleDeliveryStream"
           }}}
       ]
   }
   ```

------

##### 配置应用程序
<a name="get-started-exercise-fh-7-console-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**java-getting-started-1.0.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 CloudWatch 日志记录时，适用于 Apache Flink 的托管服务会为您创建日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`

##### 运行应用程序
<a name="get-started-exercise-fh-7-console-run"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

##### 停止应用程序
<a name="get-started-exercise-fh-7-console-stop"></a>

在**MyApplication**页面上，选择 “**停止**”。确认该操作。

##### 更新应用程序
<a name="get-started-exercise-fh-7-console-update"></a>

使用控制台，您可以更新应用程序设置，例如应用程序属性、监控设置，或应用程序 JAR 文件的位置和文件名。

在**MyApplication**页面上，选择**配置**。更新应用程序设置，然后选择**更新**。

**注意**  
要在控制台上更新应用程序的代码，您必须更改 JAR 的对象名称，使用不同的 S3 存储桶，或使用[更新应用程序代码](#get-started-exercise-fh-7-cli-update-code)一节中所述的 AWS CLI 。如果文件名或存储桶未更改，则当您在**配置**页面上选择**更新**时，不会重新加载应用程序代码。

##### 创建并运行应用程序（AWS CLI）
<a name="get-started-exercise-fh-7-cli"></a>

在本节中，您将使用创建和运行适用 AWS CLI 于 Apache Flink 的托管服务应用程序。

##### 创建权限策略
<a name="get-started-exercise-fh-7-cli-policy"></a>

首先，使用两个语句创建权限策略：一个语句授予对源流执行 `read` 操作的权限，另一个语句授予对接收器流执行 `write` 操作的权限。然后，将策略附加到 IAM 角色（下一部分中将创建此角色）。因此，在适用于 Apache Flink 的托管服务代入该角色时，服务具有必要的权限从源流进行读取和写入接收器流。

使用以下代码创建 `AKReadSourceStreamWriteSinkStream` 权限策略。{{username}}替换为您将用于创建 Amazon S3 存储桶以存储应用程序代码的用户名。将 Amazon 资源名称 (ARN) 中的账户 ID (`{{012345678901}}`) 替换为您的账户 ID。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "S3",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:GetObjectVersion"
            ],
            "Resource": ["arn:aws:s3:::ka-app-code-{{username}}",
                "arn:aws:s3:::ka-app-code-{{username}}/*"
            ]
        },
        {
            "Sid": "ReadInputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
        },
        {
            "Sid": "WriteDeliveryStream",
            "Effect": "Allow",
            "Action": "firehose:*",
            "Resource": "arn:aws:firehose:us-west-2:{{012345678901}}:deliverystream/ExampleDeliveryStream"
        }
    ]
}
```

------

有关创建权限策略的分步说明，请参阅*《IAM 用户指南》*中的[教程：创建和附加您的第一个客户管理型策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html#part-two-create-policy)。

**注意**  
要访问其他 Amazon 服务，可以使用 适用于 Java 的 AWS SDK。Managed Service for Apache Flink 会自动将软件开发工具包所需的证书设置为与您的应用程序关联的服务执行 IAM 角色的证书。无需执行其他步骤。

##### 创建一个 IAM 角色
<a name="get-started-exercise-fh-7-cli-role"></a>

在本节中，您将创建一个 IAM 角色，应用程序的 Managed Service for Apache Flink可以代入此角色来读取源流和写入接收器流。

权限不足时，Managed Service for Apache Flink无法访问您的串流。您通过 IAM 角色授予这些权限。每个 IAM 角色附加了两种策略。信任策略会向Managed Service for Apache Flink授权担任该角色。权限策略确定Managed Service for Apache Flink在担任该角色后可以执行的操作。

您将在上一部分中创建的权限策略附加到此角色。

**创建 IAM 角色**

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航窗格中，选择 **角色** 和 **创建角色**。

1. 在 **选择受信任实体的类型** 下，选择 **AWS 服务**。在 **选择将使用此角色的服务** 下，选择 **Kinesis**。在**选择您的使用案例**下，选择 **Kinesis Analytics**。

   选择**下一步: 权限**。

1. 在 **附加权限策略** 页面上，选择 **下一步: 审核**。在创建角色后，您可以附加权限策略。

1. 在 **创建角色** 页面上，输入**MF-stream-rw-role**作为**角色名称**。选择 **创建角色**。

   现在，您已经创建了一个名为 `MF-stream-rw-role` 的新 IAM 角色。接下来，您更新角色的信任和权限策略。

1. 将权限策略附加到角色。
**注意**  
对于本练习，适用于 Apache Flink 的托管服务代入此角色，以便同时从 Kinesis 数据流（源）读取数据和将输出写入另一个 Kinesis 数据流。因此，您附加在上一步（[创建权限策略](#get-started-exercise-fh-7-cli-policy)）中创建的策略。

   1. 在 **摘要** 页上，选择 **权限** 选项卡。

   1. 选择**附加策略**。

   1. 在搜索框中，输入 **AKReadSourceStreamWriteSinkStream**（您在上一部分中创建的策略）。

   1. 选择**AKReadSourceStreamWriteSinkStream**策略，然后选择**附加策略**。

现在，您已创建应用程序用于访问资源的服务执行角色。记下新角色的 ARN。

有关创建角色的分步说明，请参阅*《IAM 用户指南》*中的在您的[中创建 IAM 角色（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html#roles-creatingrole-user-console)。

##### 创建 Managed Service for Apache Flink 应用程序
<a name="get-started-exercise-fh-7-cli-create"></a>

1. 将以下 JSON 代码保存到名为 `create_request.json` 的文件中。将示例角色 ARN 替换为您之前创建的角色的 ARN。将存储桶 ARN 后缀替换为在[创建相关资源](#get-started-exercise-fh-1)一节中选择的后缀 (`ka-app-code-{{<username>}}`)。将服务执行角色中的示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

   ```
   {
       "ApplicationName": "test",
       "ApplicationDescription": "my java test app",
       "RuntimeEnvironment": "FLINK-1_15",
       "ServiceExecutionRole": "arn:aws:iam::{{012345678901}}:role/MF-stream-rw-role",
       "ApplicationConfiguration": {
           "ApplicationCodeConfiguration": {
               "CodeContent": {
                   "S3ContentLocation": {
                       "BucketARN": "arn:aws:s3:::ka-app-code-{{username}}",
                       "FileKey": "java-getting-started-1.0.jar"
                   }
               },
               "CodeContentType": "ZIPFILE"
           }
         }
       }
   }
   ```

1. 使用上述请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html) 操作来创建应用程序：

   ```
   aws kinesisanalyticsv2 create-application --cli-input-json file://create_request.json
   ```

应用程序现已创建。您在下一步中启动应用程序。

##### 启动应用程序
<a name="get-started-exercise-fh-7-cli-start"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序。

**启动应用程序**

1. 将以下 JSON 代码保存到名为 `start_request.json` 的文件中。

   ```
   {
       "ApplicationName": "test",
       "RunConfiguration": {
           "ApplicationRestoreConfiguration": { 
            "ApplicationRestoreType": "RESTORE_FROM_LATEST_SNAPSHOT"
            }
       }
   }
   ```

1. 使用上述请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序：

   ```
   aws kinesisanalyticsv2 start-application --cli-input-json file://start_request.json
   ```

应用程序正在运行。您可以在亚马逊 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 停止应用程序
<a name="get-started-exercise-fh-7-cli-stop"></a>

在本节中，您使用 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序。

**停止应用程序**

1. 将以下 JSON 代码保存到名为 `stop_request.json` 的文件中。

   ```
   {
       "ApplicationName": "test"
   }
   ```

1. 使用下面的请求执行 [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序：

   ```
   aws kinesisanalyticsv2 stop-application --cli-input-json file://stop_request.json
   ```

应用程序现已停止。

##### 添加 CloudWatch 日志选项
<a name="get-started-exercise-fh-7-cli-cw"></a>

您可以使用将 Amazon CloudWatch 日志流 AWS CLI 添加到您的应用程序中。有关在应用程序中使用 CloudWatch Logs 的信息，请参阅[设置 Managed Service for Apache Flink 中的应用程序日志记录](cloudwatch-logs.md)。

##### 更新应用程序代码
<a name="get-started-exercise-fh-7-cli-update-code"></a>

当您需要使用新版本的代码包更新应用程序代码时，可以使用[https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) AWS CLI 操作。

要使用 AWS CLI，请从 Amazon S3 存储桶中删除之前的代码包，上传新版本，然后调用`UpdateApplication`，指定相同的 Amazon S3 存储桶和对象名称。

以下示例 `UpdateApplication` 操作请求重新加载应用程序代码并重新启动应用程序。将 `CurrentApplicationVersionId` 更新为当前的应用程序版本。您可以使用 `ListApplications` 或 `DescribeApplication` 操作检查当前的应用程序版本。使用您在本节中选择的后缀更新存储桶名称后缀 (< {{username}} >)。[创建相关资源](#get-started-exercise-fh-1)

```
{
    "ApplicationName": "test",
    "CurrentApplicationVersionId": {{1}},
    "ApplicationConfigurationUpdate": {
        "ApplicationCodeConfigurationUpdate": {
            "CodeContentUpdate": {
                "S3ContentLocationUpdate": {
                    "BucketARNUpdate": "arn:aws:s3:::ka-app-code-{{username}}",
                    "FileKeyUpdate": "java-getting-started-1.0.jar"
                }
            }
        }
    }
}
```

##### 清理 AWS 资源
<a name="getting-started-fh-cleanup"></a>

本节包括清理入门教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#getting-started-fh-cleanup-app)
+ [删除 Kinesis 数据流](#getting-started-fh-cleanup-stream)
+ [删除您的 Firehose 流](#getting-started-fh-cleanup-fh)
+ [删除您的 Amazon S3 对象和存储桶](#getting-started-fh-cleanup-s3)
+ [删除您的 IAM 资源](#getting-started-fh-cleanup-iam)
+ [删除您的 CloudWatch 资源](#getting-started-fh-cleanup-cw)

##### 删除 Managed Service for Apache Flink 应用程序
<a name="getting-started-fh-cleanup-app"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 “适用于 Apache Flink 的托管服务” 面板中，选择。**MyApplication**

1. 选择**配置**。

1. 在 **Snapshots (快照)** 部分中，选择 **Disable (禁用)**，然后选择 **Update (更新)**。

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

##### 删除 Kinesis 数据流
<a name="getting-started-fh-cleanup-stream"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

##### 删除您的 Firehose 流
<a name="getting-started-fh-cleanup-fh"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 Firehose 面板中，选择。**ExampleDeliveryStream**

1. 在**ExampleDeliveryStream**页面中，选择 “**删除 Firehose 直播**”，然后确认删除。

##### 删除您的 Amazon S3 对象和存储桶
<a name="getting-started-fh-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

1. 如果您为 Firehose 流目标创建了 Amazon S3 存储桶，则也会删除该存储桶。

##### 删除您的 IAM 资源
<a name="getting-started-fh-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 如果您为 Firehose 流创建了新策略，则也会删除该策略。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

1. 如果您为 Firehose 流创建了新角色，则也会删除该角色。

##### 删除您的 CloudWatch 资源
<a name="getting-started-fh-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

#### 示例：从不同账户的 Kinesis 流中读取
<a name="examples-cross"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

该示例说明了如何创建Managed Service for Apache Flink的应用程序，以从不同账户的 Kinesis 流中读取数据。在该示例中，您将一个账户用于源 Kinesis 流，并将第二个账户用于Managed Service for Apache Flink的应用程序和接收器 Kinesis 流。

**Topics**
+ [先决条件](#examples-cross-prerequisites)
+ [设置](#examples-cross-setup)
+ [创建源 Kinesis 流](#examples-cross-streams)
+ [创建和更新 IAM 角色和策略](#examples-cross-iam)
+ [更新 Python 脚本](#examples-cross-python)
+ [更新 Java 应用程序](#examples-cross-app)
+ [构建、上传和运行应用程序](#examples-cross-run)

##### 先决条件
<a name="examples-cross-prerequisites"></a>
+ 在本教程中，您修改*入门*示例以从不同账户的 Kinesis 流中读取数据。在继续之前，请完成[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)教程。
+ 您需要两个 AWS 帐户才能完成本教程：一个用于源流，一个用于应用程序和接收流。使用您在入门教程中使用的应用程序和接收流的 AWS 帐户。将一个不同的 AWS 账户用于源流。

##### 设置
<a name="examples-cross-setup"></a>

您将使用已命名的个人资料访问您的两个 AWS 帐户。修改您的 AWS 凭证和配置文件，使其包含两个配置文件，其中包含两个账户的区域和连接信息。

以下示例凭证文件包含两个命名的配置文件：`ka-source-stream-account-profile` 和 `ka-sink-stream-account-profile`。将您用于入门教程的账户作为接收器流账户。

```
[ka-source-stream-account-profile]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

[ka-sink-stream-account-profile]
aws_access_key_id=AKIAI44QH8DHBEXAMPLE
aws_secret_access_key=je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY
```

以下示例配置文件包含具有区域和输出格式信息的相同命名配置文件。

```
[profile ka-source-stream-account-profile]
region=us-west-2
output=json

[profile ka-sink-stream-account-profile]
region=us-west-2
output=json
```

**注意**  
本教程不使用 `ka-sink-stream-account-profile`。它作为如何使用配置文件访问两个不同 AWS 帐户的示例包括在内。

有关在中使用命名配置文件的更多信息 AWS CLI，请参阅*AWS Command Line Interface*文档中的[命名配置](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html)文件。

##### 创建源 Kinesis 流
<a name="examples-cross-streams"></a>

在本节中，您在源账户中创建 Kinesis 流。

输入以下命令以创建 Kinesis 流，应用程序将该流用于输入。请注意，`--profile` 参数指定要使用的账户配置文件。

```
$ aws kinesis create-stream \
--stream-name SourceAccountExampleInputStream \
--shard-count 1 \
--profile ka-source-stream-account-profile
```

##### 创建和更新 IAM 角色和策略
<a name="examples-cross-iam"></a>

要允许跨 AWS 账户访问对象，请在源账户中创建 IAM 角色和策略。然后，您在接收器账户中修改 IAM policy。有关创建 IAM 角色和策略的信息，请参阅*AWS Identity and Access Management 用户指南*中的以下主题：
+ [创建 IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html)
+ [创建 IAM 策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html)

##### 接收器账户角色和策略
<a name="examples-cross-iam-sink"></a>

1. 编辑入门教程中的 `kinesis-analytics-service-MyApplication-us-west-2` 策略。该策略允许担任源账户中的角色，以便读取源流。
**注意**  
当您使用控制台创建应用程序时，控制台会创建一个名为 `kinesis-analytics-service-{{<application name>}}-{{<application region>}}` 的策略和一个名为 `kinesisanalytics-{{<application name>}}-{{<application region>}}` 的角色。

   将下面突出显示的部分添加到策略中。将示例账户 ID ({{SOURCE01234567}}) 替换为您要用于源直播的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {{{
               "Sid": "AssumeRoleInSourceAccount",
               "Effect": "Allow",
               "Action": "sts:AssumeRole",
               "Resource": "arn:aws:iam::{{123456789012}}:role/{{KA-Source-Stream-Role}}"
           },}}
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:s3:::ka-app-code-{{username}}/aws-kinesis-analytics-java-apps-1.0.jar"
               ]
           },
           {
               "Sid": "ListCloudwatchLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{123456789012}}:log-group:*"
               ]
           },
           {
               "Sid": "ListCloudwatchLogStreams",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogStreams"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{123456789012}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
               ]
           },
           {
               "Sid": "PutCloudwatchLogs",
               "Effect": "Allow",
               "Action": [
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{123456789012}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
               ]
           }
       ]
   }
   ```

------

1. 打开 `kinesis-analytics-MyApplication-us-west-2` 角色，并记下其 Amazon 资源名称 (ARN)。您需要在下一部分中使用该名称。角色 ARN 如下所示。

   ```
   arn:aws:iam::{{SINK012345678}}:role/service-role/kinesis-analytics-MyApplication-us-west-2
   ```

##### 源账户角色和策略
<a name="examples-cross-iam-source"></a>

1. 在名为 `KA-Source-Stream-Policy` 的源账户中创建一个策略。将以下 JSON 用于该策略。将示例账号替换为源账户的账号。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": [
                   "kinesis:DescribeStream",
                   "kinesis:GetRecords",
                   "kinesis:GetShardIterator",
                   "kinesis:ListShards"
               ],
               "Resource": "arn:aws:kinesis:us-west-2:{{111122223333}}:stream/SourceAccountExampleInputStream"
           }
       ]
   }
   ```

------

1. 在名为 `MF-Source-Stream-Role` 的源账户中创建一个角色。执行以下操作以使用 **Managed Flink** 用例创建角色：

   1. 在 IAM 管理控制台中，选择**创建角色**。

   1. 在**创建角色**页面上，选择**AWS 服务**。在服务列表中，选择 **Kinesis**。

   1. 在**选择您的用例**部分，选择**Managed Service for Apache Flink**。

   1. 选择**下一步: 权限**。

   1. 添加您在上一步中创建的 `KA-Source-Stream-Policy` 权限策略。选择 **Next:Tags**。

   1. 选择**下一步：审核**。

   1. 将角色命名为 `KA-Source-Stream-Role`。应用程序将使用该角色以访问源流。

1. 将接收器账户中的 `kinesis-analytics-MyApplication-us-west-2` ARN 添加到源账户中的 `KA-Source-Stream-Role` 角色的信任关系中：

   1. 打开 IAM 控制台中的 `KA-Source-Stream-Role`。

   1. 选择 **Trust Relationships** 选项卡。

   1. 选择**编辑信任关系**。

   1. 将以下代码用于信任关系。将示例账户 ID ({{{{SINK012345678}}}}) 替换为您的 sink 账户 ID。

------
#### [ JSON ]

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Principal": {
                      "AWS": "arn:aws:iam::{{111122223333}}:role/service-role/kinesis-analytics-MyApplication-us-west-2"
                  },
                  "Action": "sts:AssumeRole"
              }
          ]
      }
      ```

------

##### 更新 Python 脚本
<a name="examples-cross-python"></a>

在本节中，您更新生成示例数据的 Python 脚本以使用源账户配置文件。

使用以下突出显示的更改更新 `stock.py` 脚本。

```
import json
import boto3
import random
import datetime
{{import os

os.environ['AWS_PROFILE'] ='ka-source-stream-account-profile'
os.environ['AWS_DEFAULT_REGION'] = 'us-west-2'
}}

kinesis = boto3.client('kinesis')
def getReferrer():
    data = {}
    now = datetime.datetime.now()
    str_now = now.isoformat()
    data['event_time'] = str_now
    data['ticker'] = random.choice(['AAPL', 'AMZN', 'MSFT', 'INTC', 'TBV'])
    price = random.random() * 100
    data['price'] = round(price, 2)
    return data

while True:
        data = json.dumps(getReferrer())
        print(data)
        kinesis.put_record(
                StreamName="{{SourceAccountExampleInputStream}}",
                Data=data,
                PartitionKey="partitionkey")
```

##### 更新 Java 应用程序
<a name="examples-cross-app"></a>

在本节中，您更新 Java 应用程序代码，以便从源流中读取时担任源账户角色。

对 `BasicStreamingJob.java` 文件进行以下更改。将示例来源账号 ({{SOURCE01234567}}) 替换为来源账号。

```
package com.amazonaws.services.managed-flink;

import com.amazonaws.services.managed-flink.runtime.KinesisAnalyticsRuntime;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kinesis.FlinkKinesisConsumer;
import org.apache.flink.streaming.connectors.kinesis.FlinkKinesisProducer;
import org.apache.flink.streaming.connectors.kinesis.config.ConsumerConfigConstants;
{{import org.apache.flink.streaming.connectors.kinesis.config.AWSConfigConstants;}}

import java.io.IOException;
import java.util.Map;
import java.util.Properties;

 /**
 * A basic Managed Service for Apache Flink for Java application with Kinesis data streams
 * as source and sink.
 */
public class BasicStreamingJob {
    private static final String region = "us-west-2";
    private static final String inputStreamName = {{"SourceAccountExampleInputStream";}}
    private static final String outputStreamName = ExampleOutputStream;
    {{private static final String roleArn = "arn:aws:iam::SOURCE01234567:role/KA-Source-Stream-Role";
    private static final String roleSessionName = "ksassumedrolesession";}}

    private static DataStream<String> createSourceFromStaticConfig(StreamExecutionEnvironment env) {
        Properties inputProperties = new Properties();
        {{inputProperties.setProperty(AWSConfigConstants.AWS_CREDENTIALS_PROVIDER, "ASSUME_ROLE");
        inputProperties.setProperty(AWSConfigConstants.AWS_ROLE_ARN, roleArn);
        inputProperties.setProperty(AWSConfigConstants.AWS_ROLE_SESSION_NAME, roleSessionName);}}
        inputProperties.setProperty(ConsumerConfigConstants.AWS_REGION, region);
        inputProperties.setProperty(ConsumerConfigConstants.STREAM_INITIAL_POSITION, "LATEST");

        return env.addSource(new FlinkKinesisConsumer<>(inputStreamName, new SimpleStringSchema(), inputProperties));
    }

    private static KinesisStreamsSink<String> createSinkFromStaticConfig() {
        Properties outputProperties = new Properties();
        outputProperties.setProperty(AWSConfigConstants.AWS_REGION, region);

        return KinesisStreamsSink.<String>builder()
                .setKinesisClientProperties(outputProperties)
                .setSerializationSchema(new SimpleStringSchema())
                .setStreamName(outputProperties.getProperty("OUTPUT_STREAM", "ExampleOutputStream"))
                .setPartitionKeyGenerator(element -> String.valueOf(element.hashCode()))
                .build();
    }

    public static void main(String[] args) throws Exception {
        // set up the streaming execution environment
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<String> input = createSourceFromStaticConfig(env);

        input.addSink(createSinkFromStaticConfig());

        env.execute("Flink Streaming Java API Skeleton");
    }
}
```

##### 构建、上传和运行应用程序
<a name="examples-cross-run"></a>

执行以下操作以更新和运行应用程序：

1. 在具有 `pom.xml` 文件的目录中运行以下命令，以再次构建应用程序。

   ```
   mvn package -Dflink.version=1.15.3
   ```

1. 从 Amazon Simple Storage Service (Amazon S3) 存储桶中删除以前的 JAR 文件，然后将新的`aws-kinesis-analytics-java-apps-1.0.jar`文件上传到 S3 存储桶中。

1. 在Managed Service for Apache Flink的控制台中，在应用程序页面选择**配置**、**更新**以重新加载应用程序 JAR 文件。

1. 运行 `stock.py` 脚本以将数据发送到源流。

   ```
   python stock.py
   ```

现在，应用程序从另一个账户的 Kinesis 流中读取数据。

您可以检查 `ExampleOutputStream` 流的 `PutRecords.Bytes` 指标，以验证应用程序是否正常工作。如果在输出流中具有活动，则应用程序正常工作。

#### 教程：在 Amazon MSK 上使用自定义信任库
<a name="example-keystore"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

##### 当前数据来源 API
<a name="example-keystore-test-new"></a>

如果您使用的是当前的数据来源 API，则您的应用程序可以利用[此处](https://github.com/aws-samples/msk-config-providers)介绍的 Amazon MSK Config Providers 实用程序。这样，您的 KafkaSource 函数就可以在 Amazon S3 中访问您的密钥库和信任库以实现双向 TLS。

```
...
// define names of config providers:
builder.setProperty("config.providers", "secretsmanager,s3import");

// provide implementation classes for each provider:
builder.setProperty("config.providers.secretsmanager.class", "com.amazonaws.kafka.config.providers.SecretsManagerConfigProvider");
builder.setProperty("config.providers.s3import.class", "com.amazonaws.kafka.config.providers.S3ImportConfigProvider");

String region = appProperties.get(Helpers.S3_BUCKET_REGION_KEY).toString();
String keystoreS3Bucket = appProperties.get(Helpers.KEYSTORE_S3_BUCKET_KEY).toString();
String keystoreS3Path = appProperties.get(Helpers.KEYSTORE_S3_PATH_KEY).toString();
String truststoreS3Bucket = appProperties.get(Helpers.TRUSTSTORE_S3_BUCKET_KEY).toString();
String truststoreS3Path = appProperties.get(Helpers.TRUSTSTORE_S3_PATH_KEY).toString();
String keystorePassSecret = appProperties.get(Helpers.KEYSTORE_PASS_SECRET_KEY).toString();
String keystorePassSecretField = appProperties.get(Helpers.KEYSTORE_PASS_SECRET_FIELD_KEY).toString();

// region, etc..
builder.setProperty("config.providers.s3import.param.region", region);

// properties
builder.setProperty("ssl.truststore.location", "${s3import:" + region + ":" + truststoreS3Bucket + "/" + truststoreS3Path + "}");
builder.setProperty("ssl.keystore.type", "PKCS12");
builder.setProperty("ssl.keystore.location", "${s3import:" + region + ":" + keystoreS3Bucket + "/" + keystoreS3Path + "}");
builder.setProperty("ssl.keystore.password", "${secretsmanager:" + keystorePassSecret + ":" + keystorePassSecretField + "}");
builder.setProperty("ssl.key.password", "${secretsmanager:" + keystorePassSecret + ":" + keystorePassSecretField + "}");
...
```

更多细节和演练可以在[此处](https://github.com/aws-samples/amazon-kinesisanalytics-examples/tree/master/CustomKeystoreWithConfigProviders)找到。

##### 旧版 SourceFunction API
<a name="example-keystore-legacy"></a>

如果您使用的是旧版 SourceFunction API，则您的应用程序将使用自定义序列化和反序列化架构，这些架构将覆盖加载自定义信任库`open`的方法。这样，在应用程序重新启动或替换线程之后，该应用程序便可以使用信任库。

使用以下代码检索和存储自定义信任库：

```
public static void initializeKafkaTruststore() {
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    URL inputUrl = classLoader.getResource("kafka.client.truststore.jks");
    File dest = new File("/tmp/kafka.client.truststore.jks");

    try {
        FileUtils.copyURLToFile(inputUrl, dest);
    } catch (Exception ex) {
        throw new FlinkRuntimeException("Failed to initialize Kakfa truststore", ex);
    }
}
```

**注意**  
Apache Flink 要求信任库采用 [JKS 格式](https://en.wikipedia.org/wiki/Java_KeyStore)。

**注意**  
要为本练习设置所需的先决条件，请先完成[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)练习。

以下教程演示如何安全地连接到 Kafka 集群，该集群使用自定义、私有甚至自托管的证书颁发机构 (CA) 颁发的服务器证书。

为了通过 TLS 将任何 Kafka 客户端安全地连接到 Kafka 集群，Kafka 客户端（如示例 Flink 应用程序）必须信任 Kafka 集群的服务器证书（从颁发证书机构到 CA）提供的完整信任链。 Root-Level 以自定义信任库为例，我们将使用启用双向 TLS（MTLS）身份验证的 Amazon MSK 集群。这意味着 MSK 群集节点使用由证书管理器私有证书颁发机构 (ACM Private CA) 颁发的服务器证书，该证书对您的账户和区域是私有的，因此不受执行 Flink 应用程序的 Java 虚拟机 (JVM) 的默认信任库的信任。 AWS 

**注意**  
**密钥库**用于存储提供给服务器或客户端进行验证的私钥和身份证书。
**信任库**用于存储来自认证机构 (CA) 的证书，这些证书用于验证服务器在 SSL 连接中提供的证书。

 您还可以使用本教程中的方法，在Managed Service for Apache Flink的应用程序与其他 Apache Kafka 源之间进行交互，例如：
+ [托管在 AWS （[亚马逊 EC2 或亚马逊](https://aws.amazon.com/ec2/) EKS）中的自定义 Apache Kafka 集群](https://aws.amazon.com/eks/)
+ 托管于 [Confluent Kafka 集群](https://www.confluent.io) AWS
+ 通过[AWS Direct Connect](https://aws.amazon.com/directconnect/)或 VPN 访问的本地 Kafka 集群

**Topics**
+ [当前数据来源 API](#example-keystore-test-new)
+ [旧版 SourceFunction API](#example-keystore-legacy)
+ [创建带有 Amazon MSK 集群的 Amazon VPC](#example-keystore-createcluster)
+ [创建自定义信任库并将其应用于您的集群](#example-keystore-cert)
+ [创建应用程序代码](#example-keystore-code)
+ [上传 Apache Flink 流式处理 Java 代码](#example-keystore-upload)
+ [创建应用程序](#example-keystore-create)
+ [配置应用程序](#example-keystore-configure)
+ [运行应用程序](#example-keystore-run)
+ [测试应用程序](#example-keystore-test)

##### 创建带有 Amazon MSK 集群的 Amazon VPC
<a name="example-keystore-createcluster"></a>

要创建示例 VPC 和 Amazon MSK 集群以从Managed Service for Apache Flink的应用程序进行访问，请按照 [Amazon MSK 入门](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html)教程进行操作。

在完成本教程时，还请执行以下操作：
+ 在[步骤 3：创建主题](https://docs.aws.amazon.com/msk/latest/developerguide/create-topic.html)中，重复 `kafka-topics.sh --create` 命令以创建名为 `AWS KafkaTutorialTopicDestination` 的目标主题：

  ```
  bin/kafka-topics.sh --create --bootstrap-server {{ZooKeeperConnectionString}} --replication-factor 3 --partitions 1 --topic AWSKafkaTutorialTopicDestination
  ```
**注意**  
如果`kafka-topics.sh`命令返回`ZooKeeperClientTimeoutException`，请验证 Kafka 集群的安全组是否有允许来自客户端实例私有 IP 地址的所有流量的入站规则。
+ 记录集群的引导服务器列表。您可以使用以下命令获取引导服务器列表（{{ClusterArn}}替换为 MSK 集群的 ARN）：

  ```
  aws kafka get-bootstrap-brokers --region us-west-2 --cluster-arn {{ClusterArn}}
  {...
      "BootstrapBrokerStringTls": "b-2.awskafkatutorialcluste.t79r6y.c4.kafka.us-west-2.amazonaws.com:9094,b-1.awskafkatutorialcluste.t79r6y.c4.kafka.us-west-2.amazonaws.com:9094,b-3.awskafkatutorialcluste.t79r6y.c4.kafka.us-west-2.amazonaws.com:9094"
  }
  ```
+ 按照本教程和必备教程中的步骤进行操作时，请务必在代码、命令和控制台条目中使用所选 AWS 区域。

##### 创建自定义信任库并将其应用于您的集群
<a name="example-keystore-cert"></a>

在本节中，您将创建自定义证书颁发机构 (CA)，用其生成自定义信任库，然后将其应用于您的 MSK 集群。

要创建和应用您的自定义信任库，请按照*《Amazon Managed Streaming for Apache Kafka 开发者指南》*中的[客户端身份验证](https://docs.aws.amazon.com/msk/latest/developerguide/msk-authentication.html)教程进行操作。

##### 创建应用程序代码
<a name="example-keystore-code"></a>

在本节中，您下载并编译应用程序 JAR 文件。

此示例的 Java 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 如果尚未安装 Git 客户端，请安装它。有关更多信息，请参阅[安装 Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 应用程序代码位于 `amazon-kinesis-data-analytics-java-examples/CustomKeystore` 中。您可以检查代码以熟悉Managed Service for Apache Flink的代码结构。

1. 使用命令行 Maven 工具或首选的开发环境以创建 JAR 文件。要使用命令行 Maven 工具编译 JAR 文件，请输入以下内容：

   ```
   mvn package -Dflink.version=1.15.3
   ```

   如果构建成功，则会创建以下文件：

   ```
   target/flink-app-1.0-SNAPSHOT.jar
   ```
**注意**  
提供的源代码依赖于 Java 11 中的库。

##### 上传 Apache Flink 流式处理 Java 代码
<a name="example-keystore-upload"></a>

在本节中，您将应用程序代码上传到在[教程：开始使用 Apache Flink 托管服务中的 DataStream API](getting-started.md)教程中创建的 Amazon S3 存储桶。

**注意**  
如果您从入门教程中删除了 Amazon S3 存储桶，请再次执行[上传应用程序代码 JAR 文件](get-started-exercise.md#get-started-exercise-6)步骤。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-bucke-{{<username>}}** bucket，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `flink-app-1.0-SNAPSHOT.jar` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建应用程序
<a name="example-keystore-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于**应用程序名称**，输入 **MyApplication**。
   + 对于**运行时系统**，请选择 **Apache Flink 版本 1.15.2**。

1. 对于**访问权限**，请选择**创建/更新 IAM 角色`kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
使用控制台创建Managed Service for Apache Flink时，您可以选择为您的应用程序创建一个 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 配置应用程序
<a name="example-keystore-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**flink-app-1.0-SNAPSHOT.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。
**注意**  
在使用控制台指定应用程序资源（例如日志或 VPC）时，控制台修改应用程序执行角色以授权访问这些资源。

1. 在 **Properties (属性)** 下面，选择 **Add Group (添加组)**。输入以下属性：  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)
**注意**  
默认证书的 **ssl.truststore.password** 为“changeit”— 如果使用默认证书，则不需要更改该值。

   再次选择 **Add Group (添加组)**。输入以下属性：  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

   应用程序代码读取上述应用程序属性，以配置用于与 VPC 和 Amazon MSK 集群交互的源和接收器。有关使用属性的更多信息，请参阅[使用运行时属性](how-properties.md)。

1. 在 **Snapshots (快照)** 下面，选择 **Disable (禁用)**。这样，就可以轻松更新应用程序，而无需加载无效的应用程序状态数据。

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 在 **Virtual Private Cloud (VPC)** 部分中，选择要与应用程序关联的 VPC。选择与您的 VPC 关联的子网和安全组，您希望应用程序使用它们访问 VPC 资源。

1. 选择**更新**。

**注意**  
当您选择启用 CloudWatch 日志记录时，适用于 Apache Flink 的托管服务会为您创建日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`
该日志流用于监控应用程序。

##### 运行应用程序
<a name="example-keystore-run"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

##### 测试应用程序
<a name="example-keystore-test"></a>

在本节中，您将记录写入到源主题。应用程序从源主题中读取记录，并将其写入到目标主题中。您可以将记录写入到源主题以及从目标主题中读取记录，以验证应用程序是否正常工作。

要写入和读取主题中的记录，请按照 [Amazon MSK 入门](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html)教程中的[步骤 6：生成和使用数据](https://docs.aws.amazon.com/msk/latest/developerguide/produce-consume.html)中的步骤进行操作。

要从目标主题中读取，请在到集群的第二个连接中使用目标主题名称，而不是源主题：

```
bin/kafka-console-consumer.sh --bootstrap-server {{BootstrapBrokerString}} --consumer.config client.properties --topic AWS KafkaTutorialTopicDestination --from-beginning
```

如果在目标主题中没有任何记录，请参阅[Managed Service for Apache Flink 的故障排除](troubleshooting.md)主题中的[无法访问 VPC 中的资源](troubleshooting-symptoms.md#troubleshooting-rt-vpc)一节。

### Python 示例
<a name="examples-python"></a>

以下示例演示如何使用 Python 和 Apache Flink 表 API 创建应用程序。

**Topics**
+ [示例：在 Python 中创建滚动窗口](#examples-python-tumbling)
+ [示例：在 Python 中创建滑动窗口](#examples-python-sliding)
+ [示例：使用 Python 将流数据发送到 Amazon S3](#examples-python-s3)

#### 示例：在 Python 中创建滚动窗口
<a name="examples-python-tumbling"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

在本练习中，您将创建一个 Python Managed Service for Apache Flink 应用程序，该应用程序使用滚动窗口聚合数据。

**注意**  
要为本练习设置所需的先决条件，请先完成[教程：开始在 Managed Service for Apache Flink 中使用 Python](gs-python.md)练习。

**Topics**
+ [创建相关资源](#examples-python-tumbling-resources)
+ [将示例记录写入输入流](#examples-python-tumbling-write)
+ [下载并检查应用程序代码](#examples-python-tumbling-download)
+ [压缩并上传 Apache Flink 流式传输 Python 代码](#examples-python-tumbling-upload)
+ [创建并运行适用于 Apache Flink 的托管服务](#examples-python-tumbling-create-run)
+ [清理 AWS 资源](#examples-python-tumbling-cleanup)

##### 创建相关资源
<a name="examples-python-tumbling-resources"></a>

在本练习中，创建Managed Service for Apache Flink的应用程序之前，您需要创建以下从属资源：
+ 两个 Kinesis 数据流（`ExampleInputStream` 和 `ExampleOutputStream`）。
+ 存储应用程序代码 (`ka-app-code-{{<username>}}`) 的 Amazon S3 存储桶 

您可以使用控制台创建 Kinesis 流和 Amazon S3 存储桶。有关创建这些资源的说明，请参阅以下主题：
+ *Amazon Kinesis Data Streams 开发人员指南*中的[创建和更新数据流](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html)。将数据流命名为 **ExampleInputStream** 和 **ExampleOutputStream**。
+ *Amazon Simple Storage Service 用户指南*中的[如何创建 S3 存储桶？](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html)。附加您的登录名，以便为 Amazon S3 存储桶指定全局唯一的名称，例如 **ka-app-code-{{<username>}}**。

##### 将示例记录写入输入流
<a name="examples-python-tumbling-write"></a>

在本节中，您使用 Python 脚本将示例记录写入流，以供应用程序处理。

**注意**  
此部分需要 [AWS SDK for Python (Boto)](https://aws.amazon.com/developers/getting-started/python/)。

**注意**  
本节中的 Python 脚本使用 AWS CLI。您必须将您的配置 AWS CLI 为使用您的账户凭证和默认区域。要配置您的 AWS CLI，请输入以下内容：  

```
aws configure
```

1. 使用以下内容创建名为 `stock.py` 的文件：

   ```
       import datetime
       import json
       import random
       import boto3
   
       STREAM_NAME = "ExampleInputStream"
   
   
       def get_data():
           return {
               'event_time': datetime.datetime.now().isoformat(),
               'ticker': random.choice(['AAPL', 'AMZN', 'MSFT', 'INTC', 'TBV']),
               'price': round(random.random() * 100, 2)}
   
   
       def generate(stream_name, kinesis_client):
           while True:
               data = get_data()
               print(data)
               kinesis_client.put_record(
                   StreamName=stream_name,
                   Data=json.dumps(data),
                   PartitionKey="partitionkey")
   
   
       if __name__ == '__main__':
           generate(STREAM_NAME, boto3.client('kinesis', region_name='us-west-2'))
   ```

1. 运行 `stock.py` 脚本：

   ```
   $ python stock.py
   ```

   在完成本教程的其余部分时，请将脚本保持运行状态。

##### 下载并检查应用程序代码
<a name="examples-python-tumbling-download"></a>

此示例的 Python 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 如果尚未安装 Git 客户端，请安装它。有关更多信息，请参阅[安装 Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/python/TumblingWindow` 目录。

应用程序代码位于 `tumbling-windows.py` 文件中。请注意有关应用程序代码的以下信息：
+ 应用程序使用 Kinesis 表源从源流中进行读取。以下代码段调用该 `create_table` 函数来创建 Kinesis 表源：

  ```
  table_env.execute_sql(
          create_input_table(input_table_name, input_stream, input_region, stream_initpos)
      )
  ```

  该`create_table`函数使用 SQL 命令创建由流式传输源支持的表：

  ```
  def create_input_table(table_name, stream_name, region, stream_initpos):
      return """ CREATE TABLE {0} (
                  ticker VARCHAR(6),
                  price DOUBLE,
                  event_time TIMESTAMP(3),
                  WATERMARK FOR event_time AS event_time - INTERVAL '5' SECOND
                )
                PARTITIONED BY (ticker)
                WITH (
                  'connector' = 'kinesis',
                  'stream' = '{1}',
                  'aws.region' = '{2}',
                  'scan.stream.initpos' = '{3}',
                  'format' = 'json',
                  'json.timestamp-format.standard' = 'ISO-8601'
                ) """.format(table_name, stream_name, region, stream_initpos)
  ```
+ 应用程序使用 `Tumble` 运算符在指定的滚动窗口内聚合记录，并将聚合的记录作为表对象返回：

  ```
  tumbling_window_table = (
          input_table.window(
              Tumble.over("10.seconds").on("event_time").alias("ten_second_window")
          )
          .group_by("ticker, ten_second_window")
          .select("ticker, price.min as price, to_string(ten_second_window.end) as event_time")
  ```
+ 该应用程序使用来自 [https://mvnrepository.com/artifact/org.apache.flink/flink-sql-connector-kinesis/1.15.2](https://mvnrepository.com/artifact/org.apache.flink/flink-sql-connector-kinesis/1.15.2) 的 Kinesis Flink 连接器。

##### 压缩并上传 Apache Flink 流式传输 Python 代码
<a name="examples-python-tumbling-upload"></a>

在本节中，您将应用程序代码上传到在[创建相关资源](#examples-python-tumbling-resources)一节中创建的 Amazon S3 存储桶。

1. 使用您首选的压缩应用程序来压缩 `tumbling-windows.py` 和 `flink-sql-connector-kinesis-1.15.2.jar` 文件。为存档`myapp.zip`命名。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-bucke-{{<username>}}** bucket，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `myapp.zip` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建并运行适用于 Apache Flink 的托管服务
<a name="examples-python-tumbling-create-run"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="examples-python-tumbling-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
**注意**  
Managed Service for Apache Flink 使用 Apache Flink 版本 1.15.2。
   + 将版本下拉列表保留为 **Apache Flink 版本 1.15.2（建议的版本）**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 配置应用程序
<a name="examples-python-tumbling-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**myapp.zip**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 在**属性**下面，选择**添加组**。

1. 输入以下信息：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

   选择**保存**。

1. 在**属性**下面，再次选择**添加组**。

1. 输入以下信息：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在**属性**下面，再次选择**添加组**。对于 **组 ID**，输入 **kinesis.analytics.flink.run.options**。这个特殊的属性组告诉你的应用程序在哪里可以找到它的代码资源。有关更多信息，请参阅 [指定您的代码文件](how-python-creating.md#how-python-creating-code)。

1. 输入以下信息：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 CloudWatch 日志记录时，适用于 Apache Flink 的托管服务会为您创建日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`
该日志流用于监控应用程序。这与应用程序用于发送结果的日志流不同。

##### 编辑 IAM 策略
<a name="examples-python-tumbling-iam"></a>

编辑 IAM policy 以添加访问 Kinesis 数据流的权限。

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "logs:DescribeLogGroups",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*",
                   "arn:aws:s3:::ka-app-code-{{<username>}}/myapp.zip"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": "logs:DescribeLogStreams",
               "Resource": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": "logs:PutLogEvents",
               "Resource": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
           },
           {
               "Sid": "ListCloudwatchLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           }{{,
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteOutputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
           }}}
       ]
   }
   ```

------

##### 运行应用程序
<a name="examples-python-tumbling-run"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

您可以在 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 清理 AWS 资源
<a name="examples-python-tumbling-cleanup"></a>

本节包括清理在 Tumbling Window 教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#examples-python-tumbling-cleanup-app)
+ [删除您的 Kinesis 数据流](#examples-python-tumbling-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#examples-python-tumbling-cleanup-s3)
+ [删除您的 IAM 资源](#examples-python-tumbling-cleanup-iam)
+ [删除您的 CloudWatch 资源](#examples-python-tumbling-cleanup-cw)

##### 删除 Managed Service for Apache Flink 应用程序
<a name="examples-python-tumbling-cleanup-app"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Apache Flink 的托管服务面板中，选择。**MyApplication**

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

##### 删除您的 Kinesis 数据流
<a name="examples-python-tumbling-cleanup-stream"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

1. 在 **Kinesis 直播**页面中 **ExampleOutputStream**，选择，选择**操作**，选择**删除**，然后确认删除。

##### 删除您的 Amazon S3 对象和存储桶
<a name="examples-python-tumbling-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

##### 删除您的 IAM 资源
<a name="examples-python-tumbling-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

##### 删除您的 CloudWatch 资源
<a name="examples-python-tumbling-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

#### 示例：在 Python 中创建滑动窗口
<a name="examples-python-sliding"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

**注意**  
要为本练习设置所需的先决条件，请先完成[教程：开始在 Managed Service for Apache Flink 中使用 Python](gs-python.md)练习。

**Topics**
+ [创建相关资源](#examples-python-sliding-resources)
+ [将示例记录写入输入流](#examples-python-sliding-write)
+ [下载并检查应用程序代码](#examples-python-sliding-download)
+ [压缩并上传 Apache Flink 流式传输 Python 代码](#examples-python-sliding-upload)
+ [创建并运行适用于 Apache Flink 的托管服务](#examples-python-sliding-create-run)
+ [清理 AWS 资源](#examples-python-sliding-cleanup)

##### 创建相关资源
<a name="examples-python-sliding-resources"></a>

在本练习中，创建Managed Service for Apache Flink的应用程序之前，您需要创建以下从属资源：
+ 两个 Kinesis 数据流（`ExampleInputStream` 和 `ExampleOutputStream`）。
+ 存储应用程序代码 (`ka-app-code-{{<username>}}`) 的 Amazon S3 存储桶 

您可以使用控制台创建 Kinesis 流和 Amazon S3 存储桶。有关创建这些资源的说明，请参阅以下主题：
+ *Amazon Kinesis Data Streams 开发人员指南*中的[创建和更新数据流](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html)。将数据流命名为 **ExampleInputStream** 和 **ExampleOutputStream**。
+ *Amazon Simple Storage Service 用户指南*中的[如何创建 S3 存储桶？](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html)。附加您的登录名，以便为 Amazon S3 存储桶指定全局唯一的名称，例如 **ka-app-code-{{<username>}}**。

##### 将示例记录写入输入流
<a name="examples-python-sliding-write"></a>

在本节中，您使用 Python 脚本将示例记录写入流，以供应用程序处理。

**注意**  
此部分需要 [AWS SDK for Python (Boto)](https://aws.amazon.com/developers/getting-started/python/)。

**注意**  
本节中的 Python 脚本使用 AWS CLI。您必须将您的配置 AWS CLI 为使用您的账户凭证和默认区域。要配置您的 AWS CLI，请输入以下内容：  

```
aws configure
```

1. 使用以下内容创建名为 `stock.py` 的文件：

   ```
       import datetime
       import json
       import random
       import boto3
   
       STREAM_NAME = "ExampleInputStream"
   
   
       def get_data():
           return {
               'event_time': datetime.datetime.now().isoformat(),
               'ticker': random.choice(['AAPL', 'AMZN', 'MSFT', 'INTC', 'TBV']),
               'price': round(random.random() * 100, 2)}
   
   
       def generate(stream_name, kinesis_client):
           while True:
               data = get_data()
               print(data)
               kinesis_client.put_record(
                   StreamName=stream_name,
                   Data=json.dumps(data),
                   PartitionKey="partitionkey")
   
   
       if __name__ == '__main__':
           generate(STREAM_NAME, boto3.client('kinesis', region_name='us-west-2'))
   ```

1. 运行 `stock.py` 脚本：

   ```
   $ python stock.py
   ```

   在完成本教程的其余部分时，请将脚本保持运行状态。

##### 下载并检查应用程序代码
<a name="examples-python-sliding-download"></a>

此示例的 Python 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 如果尚未安装 Git 客户端，请安装它。有关更多信息，请参阅[安装 Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/>amazon-kinesis-data-analytics-java-examples
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/python/SlidingWindow` 目录。

应用程序代码位于 `sliding-windows.py` 文件中。请注意有关应用程序代码的以下信息：
+ 应用程序使用 Kinesis 表源从源流中进行读取。以下代码段调用该 `create_input_table` 函数来创建 Kinesis 表源：

  ```
  table_env.execute_sql(
          create_input_table(input_table_name, input_stream, input_region, stream_initpos)
      )
  ```

  该`create_input_table`函数使用 SQL 命令创建由流式传输源支持的表：

  ```
  def create_input_table(table_name, stream_name, region, stream_initpos):
      return """ CREATE TABLE {0} (
                  ticker VARCHAR(6),
                  price DOUBLE,
                  event_time TIMESTAMP(3),
                  WATERMARK FOR event_time AS event_time - INTERVAL '5' SECOND
                )
                PARTITIONED BY (ticker)
                WITH (
                  'connector' = 'kinesis',
                  'stream' = '{1}',
                  'aws.region' = '{2}',
                  'scan.stream.initpos' = '{3}',
                  'format' = 'json',
                  'json.timestamp-format.standard' = 'ISO-8601'
                ) """.format(table_name, stream_name, region, stream_initpos)
   }
  ```
+ 应用程序使用 `Slide` 运算符在指定的滑动窗口中聚合记录，并将聚合的记录作为表对象返回：

  ```
  sliding_window_table = (
          input_table
              .window(
                  Slide.over("10.seconds")
                  .every("5.seconds")
                  .on("event_time")
                  .alias("ten_second_window")
              )
              .group_by("ticker, ten_second_window")
              .select("ticker, price.min as price, to_string(ten_second_window.end) as event_time")
      )
  ```
+ 应用程序使用来自 [flink-sql-connector-kinesis-1.15.2.jar](https://mvnrepository.com/artifact/org.apache.flink/flink-sql-connector-kinesis/1.15.2) 文件的 Kinesis Flink 连接器。

##### 压缩并上传 Apache Flink 流式传输 Python 代码
<a name="examples-python-sliding-upload"></a>

在本节中，您将应用程序代码上传到在[创建相关资源](#examples-python-sliding-resources)一节中创建的 Amazon S3 存储桶。

本节介绍如何打包 Python 应用程序。

1. 使用您首选的压缩应用程序来压缩 `sliding-windows.py` 和 `flink-sql-connector-kinesis-1.15.2.jar` 文件。为存档`myapp.zip`命名。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-bucke-{{<username>}}** bucket，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `myapp.zip` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建并运行适用于 Apache Flink 的托管服务
<a name="examples-python-sliding-create-run"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="examples-python-sliding-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
**注意**  
Managed Service for Apache Flink 使用 Apache Flink 版本 1.15.2。
   + 将版本下拉列表保留为 **Apache Flink 版本 1.15.2（建议的版本）**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 配置应用程序
<a name="examples-python-sliding-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**myapp.zip**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 在**属性**下面，选择**添加组**。

1. 输入以下应用程序属性和值：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

   选择**保存**。

1. 在**属性**下面，再次选择**添加组**。

1. 输入以下应用程序属性和值：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在**属性**下面，再次选择**添加组**。对于 **组 ID**，输入 **kinesis.analytics.flink.run.options**。这个特殊的属性组告诉你的应用程序在哪里可以找到它的代码资源。有关更多信息，请参阅 [指定您的代码文件](how-python-creating.md#how-python-creating-code)。

1. 输入以下应用程序属性和值：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 CloudWatch 日志记录时，适用于 Apache Flink 的托管服务会为您创建日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`
该日志流用于监控应用程序。这与应用程序用于发送结果的日志流不同。

##### 编辑 IAM 策略
<a name="examples-python-sliding-iam"></a>

编辑 IAM policy 以添加访问 Kinesis 数据流的权限。

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "logs:DescribeLogGroups",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*",
                   "arn:aws:s3:::ka-app-code-{{<username>}}/myapp.zip"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": "logs:DescribeLogStreams",
               "Resource": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": "logs:PutLogEvents",
               "Resource": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
           },
           {
               "Sid": "ListCloudwatchLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           }{{,
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteOutputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
           }}}
       ]
   }
   ```

------

##### 运行应用程序
<a name="examples-python-sliding-run"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

您可以在 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 清理 AWS 资源
<a name="examples-python-sliding-cleanup"></a>

本节包括清理滑动窗口教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#examples-python-sliding-cleanup-app)
+ [删除您的 Kinesis 数据流](#examples-python-sliding-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#examples-python-sliding-cleanup-s3)
+ [删除您的 IAM 资源](#examples-python-sliding-cleanup-iam)
+ [删除您的 CloudWatch 资源](#examples-python-sliding-cleanup-cw)

##### 删除 Managed Service for Apache Flink 应用程序
<a name="examples-python-sliding-cleanup-app"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Apache Flink 的托管服务面板中，选择。**MyApplication**

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

##### 删除您的 Kinesis 数据流
<a name="examples-python-sliding-cleanup-stream"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

1. 在 **Kinesis 直播**页面中 **ExampleOutputStream**，选择，选择**操作**，选择**删除**，然后确认删除。

##### 删除您的 Amazon S3 对象和存储桶
<a name="examples-python-sliding-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

##### 删除您的 IAM 资源
<a name="examples-python-sliding-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

##### 删除您的 CloudWatch 资源
<a name="examples-python-sliding-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

#### 示例：使用 Python 将流数据发送到 Amazon S3
<a name="examples-python-s3"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

在本练习中，您将创建一个 Python Managed Service for Apache Flink 应用程序，该应用程序将数据流式传输到 Amazon Simple Storage Service 接收器。

**注意**  
要为本练习设置所需的先决条件，请先完成[教程：开始在 Managed Service for Apache Flink 中使用 Python](gs-python.md)练习。

**Topics**
+ [创建相关资源](#examples-python-s3-resources)
+ [将示例记录写入输入流](#examples-python-s3-write)
+ [下载并检查应用程序代码](#examples-python-s3-download)
+ [压缩并上传 Apache Flink 流式传输 Python 代码](#examples-python-s3-upload)
+ [创建并运行适用于 Apache Flink 的托管服务](#examples-python-s3-create-run)
+ [清理 AWS 资源](#examples-python-s3-cleanup)

##### 创建相关资源
<a name="examples-python-s3-resources"></a>

在本练习中，创建Managed Service for Apache Flink的应用程序之前，您需要创建以下从属资源：
+ Kinesis 数据流 (`ExampleInputStream`)
+ 存储应用程序代码和输出的 Amazon S3 存储桶 (`ka-app-code-{{<username>}}`) 

**注意**  
在 Managed Service for Apache Flink 上启用服务器端加密的情况下，Managed Service for Apache Flink 无法将数据写入 Amazon S3。

您可以使用控制台创建 Kinesis 流和 Amazon S3 存储桶。有关创建这些资源的说明，请参阅以下主题：
+ *Amazon Kinesis Data Streams 开发人员指南*中的[创建和更新数据流](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html)。将数据流命名为 **ExampleInputStream**。
+ *Amazon Simple Storage Service 用户指南*中的[如何创建 S3 存储桶？](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html)。附加您的登录名，以便为 Amazon S3 存储桶指定全局唯一的名称，例如 **ka-app-code-{{<username>}}**。

##### 将示例记录写入输入流
<a name="examples-python-s3-write"></a>

在本节中，您使用 Python 脚本将示例记录写入流，以供应用程序处理。

**注意**  
此部分需要 [AWS SDK for Python (Boto)](https://aws.amazon.com/developers/getting-started/python/)。

**注意**  
本节中的 Python 脚本使用 AWS CLI。您必须将您的配置 AWS CLI 为使用您的账户凭证和默认区域。要配置您的 AWS CLI，请输入以下内容：  

```
aws configure
```

1. 使用以下内容创建名为 `stock.py` 的文件：

   ```
       import datetime
       import json
       import random
       import boto3
   
       STREAM_NAME = "ExampleInputStream"
   
   
       def get_data():
           return {
               'event_time': datetime.datetime.now().isoformat(),
               'ticker': random.choice(['AAPL', 'AMZN', 'MSFT', 'INTC', 'TBV']),
               'price': round(random.random() * 100, 2)}
   
   
       def generate(stream_name, kinesis_client):
           while True:
               data = get_data()
               print(data)
               kinesis_client.put_record(
                   StreamName=stream_name,
                   Data=json.dumps(data),
                   PartitionKey="partitionkey")
   
   
       if __name__ == '__main__':
           generate(STREAM_NAME, boto3.client('kinesis', region_name='us-west-2'))
   ```

1. 运行 `stock.py` 脚本：

   ```
   $ python stock.py
   ```

   在完成本教程的其余部分时，请将脚本保持运行状态。

##### 下载并检查应用程序代码
<a name="examples-python-s3-download"></a>

此示例的 Python 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 如果尚未安装 Git 客户端，请安装它。有关更多信息，请参阅[安装 Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/python/S3Sink` 目录。

应用程序代码位于 `streaming-file-sink.py` 文件中。请注意有关应用程序代码的以下信息：
+ 应用程序使用 Kinesis 表源从源流中进行读取。以下代码段调用该 `create_source_table` 函数来创建 Kinesis 表源：

  ```
  table_env.execute_sql(
          create_source_table(input_table_name, input_stream, input_region, stream_initpos)
      )
  ```

  该`create_source_table`函数使用 SQL 命令创建由流式传输源支持的表：

  ```
  import datetime
      import json
      import random
      import boto3
  
      STREAM_NAME = "ExampleInputStream"
  
  
      def get_data():
          return {
              'event_time': datetime.datetime.now().isoformat(),
              'ticker': random.choice(['AAPL', 'AMZN', 'MSFT', 'INTC', 'TBV']),
              'price': round(random.random() * 100, 2)}
  
  
      def generate(stream_name, kinesis_client):
          while True:
              data = get_data()
              print(data)
              kinesis_client.put_record(
                  StreamName=stream_name,
                  Data=json.dumps(data),
                  PartitionKey="partitionkey")
  
  
      if __name__ == '__main__':
          generate(STREAM_NAME, boto3.client('kinesis', region_name='us-west-2'))
  ```
+ 应用程序使用 `filesystem` 连接器将记录发送到 Amazon S3 存储桶：

  ```
  def create_sink_table(table_name, bucket_name):
      return """ CREATE TABLE {0} (
                  ticker VARCHAR(6),
                  price DOUBLE,
                  event_time VARCHAR(64)
                )
                PARTITIONED BY (ticker)
                WITH (
                    'connector'='filesystem',
                    'path'='s3a://{1}/',
                    'format'='json',
                    'sink.partition-commit.policy.kind'='success-file',
                    'sink.partition-commit.delay' = '1 min'
                ) """.format(table_name, bucket_name)
  ```
+ 应用程序使用来自 [flink-sql-connector-kinesis-1.15.2.jar](https://mvnrepository.com/artifact/org.apache.flink/flink-sql-connector-kinesis/1.15.2) 文件的 Kinesis Flink 连接器。

##### 压缩并上传 Apache Flink 流式传输 Python 代码
<a name="examples-python-s3-upload"></a>

在本节中，您将应用程序代码上传到在[创建相关资源](#examples-python-s3-resources)一节中创建的 Amazon S3 存储桶。

1. 使用您的首选压缩应用程序压缩 `streaming-file-sink.py` 和 [flink-sql-connector-kinesis-1.15.2.jar](https://mvnrepository.com/artifact/org.apache.flink/flink-sql-connector-kinesis/1.15.2) 文件。为存档`myapp.zip`命名。

1. **在 Amazon S3 控制台中，选择 **ka-app-code-bucke-{{<username>}}** bucket，然后选择上传。**

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `myapp.zip` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建并运行适用于 Apache Flink 的托管服务
<a name="examples-python-s3-create-run"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="examples-python-s3-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
**注意**  
Managed Service for Apache Flink 使用 Apache Flink 版本 1.15.2。
   + 将版本下拉列表保留为 **Apache Flink 版本 1.15.2（建议的版本）**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 配置应用程序
<a name="examples-python-s3-configure"></a>

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**myapp.zip**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 在**属性**下面，选择**添加组**。

1. 输入以下应用程序属性和值：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

   选择**保存**。

1. 在**属性**下面，再次选择**添加组**。对于 **组 ID**，输入 **kinesis.analytics.flink.run.options**。这个特殊的属性组告诉你的应用程序在哪里可以找到它的代码资源。有关更多信息，请参阅 [指定您的代码文件](how-python-creating.md#how-python-creating-code)。

1. 输入以下应用程序属性和值：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在**属性**下面，再次选择**添加组**。对于 **组 ID**，输入 **sink.config.0**。这个特殊的属性组告诉你的应用程序在哪里可以找到它的代码资源。有关更多信息，请参阅 [指定您的代码文件](how-python-creating.md#how-python-creating-code)。

1. 输入以下应用程序属性和值：（{{bucket-name}}替换为您的 Amazon S3 存储桶的实际名称。）    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 CloudWatch 日志记录时，适用于 Apache Flink 的托管服务会为您创建日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`
该日志流用于监控应用程序。这与应用程序用于发送结果的日志流不同。

##### 编辑 IAM 策略
<a name="examples-python-s3-iam"></a>

编辑 IAM policy 以添加访问 Kinesis 数据流的权限。

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "logs:DescribeLogGroups",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*",
                   "arn:aws:s3:::ka-app-code-{{<username>}}/myapp.zip"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": "logs:DescribeLogStreams",
               "Resource": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": "logs:PutLogEvents",
               "Resource": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
           },
           {
               "Sid": "ListCloudwatchLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           }{{,
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteObjects",
               "Effect": "Allow",
               "Action": [
                   "s3:Abort*",
                   "s3:DeleteObject*",
                   "s3:GetObject*",
                   "s3:GetBucket*",
                   "s3:List*",
                   "s3:ListBucket",
                   "s3:PutObject"
               ],
               "Resource": [
                   "arn:aws:s3:::ka-app-code-<username>",
                   "arn:aws:s3:::ka-app-code-<username>/*"
               ]
           }}}
       ]
   }
   ```

------

##### 运行应用程序
<a name="examples-python-s3-run"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

您可以在 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 清理 AWS 资源
<a name="examples-python-s3-cleanup"></a>

本节包括清理滑动窗口教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#examples-python-s3-cleanup-app)
+ [删除 Kinesis 数据流](#examples-python-s3-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#examples-python-s3-cleanup-s3)
+ [删除您的 IAM 资源](#examples-python-s3-cleanup-iam)
+ [删除您的 CloudWatch 资源](#examples-python-s3-cleanup-cw)

##### 删除 Managed Service for Apache Flink 应用程序
<a name="examples-python-s3-cleanup-app"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Apache Flink 的托管服务面板中，选择。**MyApplication**

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

##### 删除 Kinesis 数据流
<a name="examples-python-s3-cleanup-stream"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

##### 删除您的 Amazon S3 对象和存储桶
<a name="examples-python-s3-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

##### 删除您的 IAM 资源
<a name="examples-python-s3-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

##### 删除您的 CloudWatch 资源
<a name="examples-python-s3-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

### Scala 示例
<a name="examples-scala"></a>

以下示例演示如何使用 Scala 和 Apache Flink 创建应用程序。

**Topics**
+ [示例：在 Scala 中创建滚动窗口](#examples-tumbling-scala)
+ [示例：在 Scala 中创建滑动窗口](#examples-sliding-scala)
+ [示例：在 Scala 中将流数据发送到 Amazon S3](#examples-s3sink-scala)

#### 示例：在 Scala 中创建滚动窗口
<a name="examples-tumbling-scala"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

**注意**  
从 Flink 1.15 版本开始，Scala 免费。应用程序现在可以使用任何 Scala 版本的 Java API。Flink 仍然在内部的一些关键组件中使用 Scala，但没有将 Scala 暴露到用户代码类加载器中。因此，用户需要将 Scala 从属项添加到其 jar 存档中。  
有关 Flink 1.15 中 Scala 变更的更多信息，请参阅 [1.15 Scala 免费](https://flink.apache.org/2022/02/22/scala-free.html)。

在本练习中，您将创建一个使用 Scala 3.2.0 和 Flink 的 Java API 的简单流媒体应用程序。 DataStream 该应用程序从 Kinesis 流中读取数据，使用滑动窗口对其进行聚合，并将结果写入输出 Kinesis 流。

**注意**  
要为本练习设置所需的先决条件，请先完成[入门 (Scala)](https://docs.aws.amazon.com/managed-flink/latest/java/examples-gs-scala.html) 练习。

**Topics**
+ [下载并检查应用程序代码](#examples-tumbling-scala-download)
+ [编译并上传应用程序代码](#examples-tumbling-scala-upload)
+ [创建并运行应用程序（控制台）](#scala-7)
+ [创建并运行应用程序 (CLI)](#examples-tumbling-scala-create-run-cli)
+ [更新应用程序代码](#examples-tumbling-scala-update-app-code)
+ [清理 AWS 资源](#examples-tumbling-scala-cleanup)

##### 下载并检查应用程序代码
<a name="examples-tumbling-scala-download"></a>

此示例的 Python 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 如果尚未安装 Git 客户端，请安装它。有关更多信息，请参阅[安装 Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/scala/TumblingWindow` 目录。

请注意有关应用程序代码的以下信息：
+ `build.sbt` 文件包含有关应用程序的配置和从属项的信息，包括Managed Service for Apache Flink的库。
+ `BasicStreamingJob.scala` 文件包含定义应用程序功能的主要方法。
+ 应用程序使用 Kinesis 源从源流中进行读取。以下代码段创建 Kinesis 源：

  ```
  private def createSource: FlinkKinesisConsumer[String] = {
    val applicationProperties = KinesisAnalyticsRuntime.getApplicationProperties
    val inputProperties = applicationProperties.get("ConsumerConfigProperties")
  
    new FlinkKinesisConsumer[String](inputProperties.getProperty(streamNameKey, defaultInputStreamName),
      new SimpleStringSchema, inputProperties)
  }
  ```

  该应用程序还使用 Kinesis 接收器写入结果流。以下代码段创建 Kinesis 接收器：

  ```
  private def createSink: KinesisStreamsSink[String] = {
    val applicationProperties = KinesisAnalyticsRuntime.getApplicationProperties
    val outputProperties = applicationProperties.get("ProducerConfigProperties")
  
    KinesisStreamsSink.builder[String]
      .setKinesisClientProperties(outputProperties)
      .setSerializationSchema(new SimpleStringSchema)
      .setStreamName(outputProperties.getProperty(streamNameKey, defaultOutputStreamName))
      .setPartitionKeyGenerator((element: String) => String.valueOf(element.hashCode))
      .build
  }
  ```
+ 应用程序使用窗口操作符在 5 秒的滚动窗口中查找每个股票代号的值计数。以下代码创建操作符，并将聚合的数据发送到新的 Kinesis Data Streams 接收器：

  ```
  environment.addSource(createSource)
    .map { value =>
      val jsonNode = jsonParser.readValue(value, classOf[JsonNode])
      new Tuple2[String, Int](jsonNode.get("ticker").toString, 1)
    }
    .returns(Types.TUPLE(Types.STRING, Types.INT))
    .keyBy(v => v.f0) // Logically partition the stream for each ticker 
    .window(TumblingProcessingTimeWindows.of(Time.seconds(10)))
    .sum(1) // Sum the number of tickers per partition
    .map { value => value.f0 + "," + value.f1.toString + "\n" }
    .sinkTo(createSink)
  ```
+ 应用程序创建源连接器和接收器连接器，以使用 StreamExecutionEnvironment 对象访问外部资源。
+ 该应用程序将使用动态应用程序属性创建源和接收连接器。读取应用程序的运行时系统属性来配置连接器。有关运行时系统属性的更多信息，请参阅[运行时系统属性](https://docs.aws.amazon.com/managed-flink/latest/java/how-properties.html)。

##### 编译并上传应用程序代码
<a name="examples-tumbling-scala-upload"></a>

在本节中，您将编译应用程序代码并将其上传到 Amazon S3 存储桶。

**编译应用程序代码**

使用 [SBT](https://www.scala-sbt.org/) 构建工具为应用程序构建 Scala 代码。要安装 SBT，请参阅[使用 cs 安装程序安装 sbt](https://www.scala-sbt.org/download.html)。您还需要安装 Java 开发工具包 (JDK)。参阅[完成练习的先决条件](https://docs.aws.amazon.com/managed-flink/latest/java/getting-started.html#setting-up-prerequisites)。

1. 要使用您的应用程序代码，您将其编译和打包成 JAR 文件。您可以用 SBT 编译和打包代码：

   ```
   sbt assembly
   ```

1. 如果应用程序成功编译，则创建以下文件：

   ```
   target/scala-3.2.0/tumbling-window-scala-1.0.jar
   ```

**上传 Apache Flink 流式处理 Scala 代码**

在本节中，创建 Amazon S3 存储桶并上传应用程序代码。

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择**创建存储桶**。

1. 在 **存储桶名称** 字段中输入 `ka-app-code-<username>`。将后缀（如您的用户名）添加到存储桶名称，以使其具有全局唯一性。选择**下一步**。

1. 在**配置选项**中，让设置保持原样，然后选择**下一步**。

1. 在**设置权限**中，让设置保持原样，然后选择**下一步**。

1. 选择 **创建存储桶 **。

1. 选择 `ka-app-code-<username>` 存储桶，然后选择**上传**。

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `tumbling-window-scala-1.0.jar` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建并运行应用程序（控制台）
<a name="scala-7"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="scala-7-console-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**描述**，输入 **My Scala test app**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
   + 将版本保留为 **Apache Flink 版本 1.15.2（建议的版本）**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 配置应用程序
<a name="scala-7-console-configure"></a>

请使用以下过程来配置应用程序。

**配置应用程序**

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**tumbling-window-scala-1.0.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 在**属性**下面，选择**添加组**。

1. 输入以下信息：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

   选择**保存**。

1. 在**属性**下面，再次选择**添加组**。

1. 输入以下信息：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 Amazon CloudWatch 日志时，适用于 Apache Flink 的托管服务会为您创建一个日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`

##### 编辑 IAM 策略
<a name="scala-7-console-iam"></a>

编辑 IAM policy 以添加访问 Amazon S3 数据流的权限。

**编辑 IAM policy 以添加 S3 存储桶权限**

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:s3:::ka-app-code-{{username}}/tumbling-window-scala-1.0.jar"
               ]
           },
           {
               "Sid": "DescribeLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogStreams"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
               ]
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": [
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
               ]
           },
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteOutputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
           }
       ]
   }
   ```

------

##### 运行应用程序
<a name="scala-7-console-run"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

##### 停止应用程序
<a name="scala-7-console-stop"></a>

要停止应用程序，请在**MyApplication**页面上选择**停止**。确认该操作。

##### 创建并运行应用程序 (CLI)
<a name="examples-tumbling-scala-create-run-cli"></a>

在本节中，您将使用创建和运行适用 AWS Command Line Interface 于 Apache Flink 的托管服务应用程序。使用 k *inesisanalyticsv2* AWS CLI 命令为 Apache Flink 应用程序创建托管服务并与之交互。

##### 创建权限策略
<a name="examples-tumbling-scala-permissions"></a>

**注意**  
您必须为应用程序创建一个权限策略和角色。如果未创建这些 IAM 资源，应用程序将无法访问其数据和日志流。

首先，使用两个语句创建权限策略：一个语句授予对源流执行读取操作的权限，另一个语句授予对接收器流执行写入操作的权限。然后，将策略附加到 IAM 角色（下一部分中将创建此角色）。因此，在适用于 Apache Flink 的托管服务代入该角色时，服务具有必要的权限从源流进行读取和写入接收器流。

使用以下代码创建 `AKReadSourceStreamWriteSinkStream` 权限策略。将 **username** 替换为您用于创建 Amazon S3 存储桶来存储应用程序代码的用户名。将 Amazon 资源名称 (ARN) 中的账户 ID **(012345678901)** 替换为您的账户 ID。**MF-stream-rw-role**服务执行角色应根据客户的特定角色量身定制。

```
{
    "ApplicationName": "tumbling_window",
    "ApplicationDescription": "Scala tumbling window application",
    "RuntimeEnvironment": "FLINK-1_15",
    "ServiceExecutionRole": "arn:aws:iam::012345678901:role/MF-stream-rw-role",
    "ApplicationConfiguration": {
        "ApplicationCodeConfiguration": {
            "CodeContent": {
                "S3ContentLocation": {
                    "BucketARN": "arn:aws:s3:::ka-app-code-username",
                    "FileKey": "tumbling-window-scala-1.0.jar"
                }
            },
            "CodeContentType": "ZIPFILE"
        },
        "EnvironmentProperties":  { 
         "PropertyGroups": [ 
            { 
               "PropertyGroupId": "ConsumerConfigProperties",
               "PropertyMap" : {
                    "aws.region" : "us-west-2",
                    "stream.name" : "ExampleInputStream",
                    "flink.stream.initpos" : "LATEST"
               }
            },
            { 
               "PropertyGroupId": "ProducerConfigProperties",
               "PropertyMap" : {
                    "aws.region" : "us-west-2",
                    "stream.name" : "ExampleOutputStream"
               }
            }
         ]
      }
    },
    "CloudWatchLoggingOptions": [ 
      { 
         "LogStreamARN": "arn:aws:logs:us-west-2:012345678901:log-group:MyApplication:log-stream:kinesis-analytics-log-stream"
      }
   ]
}
```

有关创建权限策略的分步说明，请参阅*《IAM 用户指南》*中的[教程：创建和附加您的第一个客户管理型策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html#part-two-create-policy)。

##### 创建一个 IAM 角色
<a name="examples-tumbling-scala-iam-policy"></a>

在本节中，您将创建一个 IAM 角色，应用程序的 Managed Service for Apache Flink可以代入此角色来读取源流和写入接收器流。

权限不足时，Managed Service for Apache Flink 无法访问您的串流。您通过 IAM 角色授予这些权限。每个 IAM 角色附加了两种策略。此信任策略授予适用于 Apache Flink 的托管服务代入该角色的权限，权限策略确定适用于 Apache Flink 的托管服务代入这个角色后可以执行的操作。

您将在上一部分中创建的权限策略附加到此角色。

**创建 IAM 角色**

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航窗格中选择**角色**，然后选择**创建角色**。

1. 在 **选择受信任实体的类型** 下，选择 **AWS 服务**。

1. 在 **选择将使用此角色的服务** 下，选择 **Kinesis**。

1. 在**选择您的用例**部分，选择**Managed Service for Apache Flink**。

1. 选择**下一步: 权限**。

1. 在 **附加权限策略** 页面上，选择 **下一步: 审核**。在创建角色后，您可以附加权限策略。

1. 在 **创建角色** 页面上，输入**MF-stream-rw-role**作为**角色名称**。选择 **创建角色**。

    现在，您已经创建了一个名为 `MF-stream-rw-role` 的新 IAM 角色。接下来，您更新角色的信任和权限策略。

1. 将权限策略附加到角色。
**注意**  
对于本练习，Managed Service for Apache Flink代入此角色，以便同时从 Kinesis 数据流（源）读取数据和将输出写入另一个 Kinesis 数据流。因此，您附加在上一步[创建权限策略](https://docs.aws.amazon.com/managed-flink/latest/java/get-started-exercise.html#get-started-exercise-7-cli-policy)中创建的策略。

   1. 在 **摘要** 页上，选择 **权限** 选项卡。

   1. 选择**附加策略**。

   1. 在搜索框中，输入 **AKReadSourceStreamWriteSinkStream**（您在上一部分中创建的策略）。

   1. 选择`AKReadSourceStreamWriteSinkStream`策略，然后选择**附加策略**。

现在，您已经创建了应用程序用来访问资源的服务执行角色。记下新角色的 ARN。

有关创建角色的分步说明，请参阅*《IAM 用户指南》*中的在您的[中创建 IAM 角色（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html#roles-creatingrole-user-console)。

##### 创建应用程序
<a name="examples-tumbling-scala-create-application-cli"></a>

将以下 JSON 代码保存到名为 `create_request.json` 的文件中。将示例角色 ARN 替换为您之前创建的角色的 ARN。将存储桶 ARN 后缀 (用户名) 替换为在前一部分中选择的后缀。将服务执行角色中的示例账户 ID (012345678901) 替换为您的账户 ID。`ServiceExecutionRole`应包括您在上一节中创建的 IAM 用户角色。

```
"ApplicationName": "tumbling_window",
    "ApplicationDescription": "Scala getting started application",
    "RuntimeEnvironment": "FLINK-1_15",
    "ServiceExecutionRole": "arn:aws:iam::012345678901:role/MF-stream-rw-role",
    "ApplicationConfiguration": {
        "ApplicationCodeConfiguration": {
            "CodeContent": {
                "S3ContentLocation": {
                    "BucketARN": "arn:aws:s3:::ka-app-code-{{username}}",
                    "FileKey": "tumbling-window-scala-1.0.jar"
                }
            },
            "CodeContentType": "ZIPFILE"
        },
        "EnvironmentProperties":  { 
         "PropertyGroups": [ 
            { 
               "PropertyGroupId": "ConsumerConfigProperties",
               "PropertyMap" : {
                    "aws.region" : "us-west-2",
                    "stream.name" : "ExampleInputStream",
                    "flink.stream.initpos" : "LATEST"
               }
            },
            { 
               "PropertyGroupId": "ProducerConfigProperties",
               "PropertyMap" : {
                    "aws.region" : "us-west-2",
                    "stream.name" : "ExampleOutputStream"
               }
            }
         ]
      }
    },
    "CloudWatchLoggingOptions": [ 
      { 
         "LogStreamARN": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:MyApplication:log-stream:kinesis-analytics-log-stream"
      }
   ]
}
```

[CreateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_CreateApplication.html)使用以下请求执行以创建应用程序：

```
aws kinesisanalyticsv2 create-application --cli-input-json file://create_request.json
```

应用程序现已创建。您在下一步中启动应用程序。

##### 启动应用程序
<a name="examples-tumbling-scala-start"></a>

在本节中，您使用 [StartApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序。

**启动应用程序**

1. 将以下 JSON 代码保存到名为 `start_request.json` 的文件中。

   ```
   {
       "ApplicationName": "tumbling_window",
       "RunConfiguration": {
           "ApplicationRestoreConfiguration": { 
            "ApplicationRestoreType": "RESTORE_FROM_LATEST_SNAPSHOT"
            }
       }
   }
   ```

1. 使用上述请求执行 `StartApplication` 操作来启动应用程序：

   ```
   aws kinesisanalyticsv2 start-application --cli-input-json file://start_request.json
   ```

应用程序正在运行。您可以在亚马逊 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 停止应用程序
<a name="examples-tumbling-scala-stop"></a>

在本节中，您使用 [StopApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序。

**停止应用程序**

1. 将以下 JSON 代码保存到名为 `stop_request.json` 的文件中。

   ```
   {
      "ApplicationName": "tumbling_window"
   }
   ```

1. 使用上述请求执行 `StopApplication` 操作来停止应用程序：

   ```
   aws kinesisanalyticsv2 stop-application --cli-input-json file://stop_request.json
   ```

应用程序现已停止。

##### 添加 CloudWatch 日志选项
<a name="examples-tumbling-scala-cw-option"></a>

您可以使用将 Amazon CloudWatch 日志流 AWS CLI 添加到您的应用程序中。有关在应用程序中使用 CloudWatch 日志的信息，请参阅[设置应用程序日志记录](https://docs.aws.amazon.com/managed-flink/latest/java/cloudwatch-logs.html)。

##### 更新环境属性
<a name="examples-tumbling-scala-update-environment-properties"></a>

在本节中，您使用 [UpdateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html) 操作更改应用程序的环境属性，而无需重新编译应用程序代码。在该示例中，您更改源流和目标流的区域。

**更新应用程序的环境属性**

1. 将以下 JSON 代码保存到名为 `update_properties_request.json` 的文件中。

   ```
   {"ApplicationName": "tumbling_window",
      "CurrentApplicationVersionId": 1,
      "ApplicationConfigurationUpdate": { 
         "EnvironmentPropertyUpdates": { 
            "PropertyGroups": [ 
               { 
                  "PropertyGroupId": "ConsumerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2",
                       "stream.name" : "ExampleInputStream",
                       "flink.stream.initpos" : "LATEST"
                  }
               },
               { 
                  "PropertyGroupId": "ProducerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2",
                       "stream.name" : "ExampleOutputStream"
                  }
               }
            ]
         }
      }
   }
   ```

1. 使用前面的请求执行 `UpdateApplication` 操作以更新环境属性：

   ```
   aws kinesisanalyticsv2 update-application --cli-input-json file://update_properties_request.json
   ```

##### 更新应用程序代码
<a name="examples-tumbling-scala-update-app-code"></a>

当您需要使用新版本的代码包更新应用程序代码时，可以使用 [UpdateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html)CLI 操作。

**注意**  
要使用相同的文件名加载新版本的应用程序代码，您必须指定新的对象版本。有关使用 Amazon S3 对象版本的更多信息，请参阅[启用或禁用版本控制](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/enable-versioning.html)。

要使用 AWS CLI，请从 Amazon S3 存储桶中删除之前的代码包，上传新版本，然后调用`UpdateApplication`，指定相同的 Amazon S3 存储桶和对象名称以及新的对象版本。应用程序将使用新的代码包重新启动。

以下示例 `UpdateApplication` 操作请求重新加载应用程序代码并重新启动应用程序。将 `CurrentApplicationVersionId` 更新为当前的应用程序版本。您可以使用 `ListApplications` 或 `DescribeApplication` 操作检查当前的应用程序版本。将存储桶名称后缀 (<用户名>) 更新为在[创建相关资源](examples-gs-scala.md#examples-gs-scala-resources)一节中选择的后缀。

```
{
    "ApplicationName": "tumbling_window",
    "CurrentApplicationVersionId": 1,
    "ApplicationConfigurationUpdate": {
        "ApplicationCodeConfigurationUpdate": {
            "CodeContentUpdate": {
                "S3ContentLocationUpdate": {
                    "BucketARNUpdate": "arn:aws:s3:::ka-app-code-{{username}}",
                    "FileKeyUpdate": "tumbling-window-scala-1.0.jar",
                    "ObjectVersionUpdate": "SAMPLEUehYngP87ex1nzYIGYgfhypvDU"
                }
            }
        }
    }
}
```

##### 清理 AWS 资源
<a name="examples-tumbling-scala-cleanup"></a>

本节包括清理在 tumbling Window 教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#examples-tumbling-scala-cleanup-app)
+ [删除您的 Kinesis 数据流](#examples-tumbling-scala-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#examples-tumbling-scala-cleanup-s3)
+ [删除您的 IAM 资源](#examples-tumbling-scala-cleanup-iam)
+ [删除您的 CloudWatch 资源](#examples-tumbling-scala-cleanup-cw)

##### 删除 Managed Service for Apache Flink 应用程序
<a name="examples-tumbling-scala-cleanup-app"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Apache Flink 的托管服务面板中，选择。**MyApplication**

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

##### 删除您的 Kinesis 数据流
<a name="examples-tumbling-scala-cleanup-stream"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

1. 在 **Kinesis 直播**页面中 **ExampleOutputStream**，选择，选择**操作**，选择**删除**，然后确认删除。

##### 删除您的 Amazon S3 对象和存储桶
<a name="examples-tumbling-scala-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

##### 删除您的 IAM 资源
<a name="examples-tumbling-scala-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

##### 删除您的 CloudWatch 资源
<a name="examples-tumbling-scala-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

#### 示例：在 Scala 中创建滑动窗口
<a name="examples-sliding-scala"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

**注意**  
从 Flink 1.15 版本开始，Scala 免费。应用程序现在可以使用任何 Scala 版本的 Java API。Flink 仍然在内部的一些关键组件中使用 Scala，但没有将 Scala 暴露到用户代码类加载器中。因此，用户需要将 Scala 从属项添加到其 jar 存档中。  
有关 Flink 1.15 中 Scala 变更的更多信息，请参阅 [1.15 Scala 免费](https://flink.apache.org/2022/02/22/scala-free.html)。

在本练习中，您将创建一个使用 Scala 3.2.0 和 Flink 的 Java API 的简单流媒体应用程序。 DataStream 该应用程序从 Kinesis 流中读取数据，使用滑动窗口对其进行聚合，并将结果写入输出 Kinesis 流。

**注意**  
要为本练习设置所需的先决条件，请先完成[入门 (Scala)](https://docs.aws.amazon.com/managed-flink/latest/java/examples-gs-scala.html) 练习。

**Topics**
+ [下载并检查应用程序代码](#examples-sliding-scala-download)
+ [编译并上传应用程序代码](#examples-sliding-scala-upload)
+ [创建并运行应用程序（控制台）](#scala-7)
+ [创建并运行应用程序 (CLI)](#examples-sliding-scala-create-run-cli)
+ [更新应用程序代码](#examples-sliding-scala-update-app-code)
+ [清理 AWS 资源](#examples-sliding-scala-cleanup)

##### 下载并检查应用程序代码
<a name="examples-sliding-scala-download"></a>

此示例的 Python 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 如果尚未安装 Git 客户端，请安装它。有关更多信息，请参阅[安装 Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/scala/SlidingWindow` 目录。

请注意有关应用程序代码的以下信息：
+ `build.sbt` 文件包含有关应用程序的配置和从属项的信息，包括Managed Service for Apache Flink的库。
+ `BasicStreamingJob.scala` 文件包含定义应用程序功能的主要方法。
+ 应用程序使用 Kinesis 源从源流中进行读取。以下代码段创建 Kinesis 源：

  ```
  private def createSource: FlinkKinesisConsumer[String] = {
    val applicationProperties = KinesisAnalyticsRuntime.getApplicationProperties
    val inputProperties = applicationProperties.get("ConsumerConfigProperties")
  
    new FlinkKinesisConsumer[String](inputProperties.getProperty(streamNameKey, defaultInputStreamName),
      new SimpleStringSchema, inputProperties)
  }
  ```

  该应用程序还使用 Kinesis 接收器写入结果流。以下代码段创建 Kinesis 接收器：

  ```
  private def createSink: KinesisStreamsSink[String] = {
    val applicationProperties = KinesisAnalyticsRuntime.getApplicationProperties
    val outputProperties = applicationProperties.get("ProducerConfigProperties")
  
    KinesisStreamsSink.builder[String]
      .setKinesisClientProperties(outputProperties)
      .setSerializationSchema(new SimpleStringSchema)
      .setStreamName(outputProperties.getProperty(streamNameKey, defaultOutputStreamName))
      .setPartitionKeyGenerator((element: String) => String.valueOf(element.hashCode))
      .build
  }
  ```
+ 应用程序使用窗口运算符在 10 秒的滑动窗口（以 5 秒为增量）中查找每个股票代号的计数值。以下代码创建操作符，并将聚合的数据发送到新的 Kinesis Data Streams 接收器：

  ```
  environment.addSource(createSource)
      .map { value =>
        val jsonNode = jsonParser.readValue(value, classOf[JsonNode])
        new Tuple2[String, Double](jsonNode.get("ticker").toString, jsonNode.get("price").asDouble)
      }
      .returns(Types.TUPLE(Types.STRING, Types.DOUBLE))
      .keyBy(v => v.f0) // Logically partition the stream for each word
      .window(SlidingProcessingTimeWindows.of(Time.seconds(10), Time.seconds(5)))
      .min(1) // Calculate minimum price per ticker over the window
      .map { value => value.f0 + String.format(",%.2f", value.f1) + "\n" }
      .sinkTo(createSink)
  ```
+ 应用程序创建源连接器和接收器连接器，以使用 StreamExecutionEnvironment 对象访问外部资源。
+ 该应用程序将使用动态应用程序属性创建源和接收连接器。读取应用程序的运行时系统属性来配置连接器。有关运行时系统属性的更多信息，请参阅[运行时系统属性](https://docs.aws.amazon.com/managed-flink/latest/java/how-properties.html)。

##### 编译并上传应用程序代码
<a name="examples-sliding-scala-upload"></a>

在本节中，您将编译应用程序代码并将其上传到 Amazon S3 存储桶。

**编译应用程序代码**

使用 [SBT](https://www.scala-sbt.org/) 构建工具为应用程序构建 Scala 代码。要安装 SBT，请参阅[使用 cs 安装程序安装 sbt](https://www.scala-sbt.org/download.html)。您还需要安装 Java 开发工具包 (JDK)。参阅[完成练习的先决条件](https://docs.aws.amazon.com/managed-flink/latest/java/getting-started.html#setting-up-prerequisites)。

1. 要使用您的应用程序代码，您将其编译和打包成 JAR 文件。您可以用 SBT 编译和打包代码：

   ```
   sbt assembly
   ```

1. 如果应用程序成功编译，则创建以下文件：

   ```
   target/scala-3.2.0/sliding-window-scala-1.0.jar
   ```

**上传 Apache Flink 流式处理 Scala 代码**

在本节中，创建 Amazon S3 存储桶并上传应用程序代码。

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择**创建存储桶**。

1. 在 **存储桶名称** 字段中输入 `ka-app-code-<username>`。将后缀（如您的用户名）添加到存储桶名称，以使其具有全局唯一性。选择**下一步**。

1. 在**配置选项**中，让设置保持原样，然后选择**下一步**。

1. 在**设置权限**中，让设置保持原样，然后选择**下一步**。

1. 选择 **创建存储桶 **。

1. 选择 `ka-app-code-<username>` 存储桶，然后选择**上传**。

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `sliding-window-scala-1.0.jar` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建并运行应用程序（控制台）
<a name="scala-7"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="scala-7-console-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**描述**，输入 **My Scala test app**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
   + 将版本保留为 **Apache Flink 版本 1.15.2（建议的版本）**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 配置应用程序
<a name="scala-7-console-configure"></a>

请使用以下过程来配置应用程序。

**配置应用程序**

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**sliding-window-scala-1.0.jar.**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 在**属性**下面，选择**添加组**。

1. 输入以下信息：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

   选择**保存**。

1. 在**属性**下面，再次选择**添加组**。

1. 输入以下信息：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 Amazon CloudWatch 日志时，适用于 Apache Flink 的托管服务会为您创建一个日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`

##### 编辑 IAM 策略
<a name="scala-7-console-iam"></a>

编辑 IAM policy 以添加访问 Amazon S3 数据流的权限。

**编辑 IAM policy 以添加 S3 存储桶权限**

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:s3:::ka-app-code-{{username}}/sliding-window-scala-1.0.jar"
               ]
           },
           {
               "Sid": "DescribeLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogStreams"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
               ]
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": [
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
               ]
           },
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteOutputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleOutputStream"
           }
       ]
   }
   ```

------

##### 运行应用程序
<a name="scala-7-console-run"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

##### 停止应用程序
<a name="scala-7-console-stop"></a>

要停止应用程序，请在**MyApplication**页面上选择**停止**。确认该操作。

##### 创建并运行应用程序 (CLI)
<a name="examples-sliding-scala-create-run-cli"></a>

在本节中，您将使用创建和运行适用 AWS Command Line Interface 于 Apache Flink 的托管服务应用程序。使用 k *inesisanalyticsv2* AWS CLI 命令为 Apache Flink 应用程序创建托管服务并与之交互。

##### 创建权限策略
<a name="examples-sliding-scala-permissions"></a>

**注意**  
您必须为应用程序创建一个权限策略和角色。如果未创建这些 IAM 资源，应用程序将无法访问其数据和日志流。

首先，使用两个语句创建权限策略：一个语句授予对源流执行读取操作的权限，另一个语句授予对接收器流执行写入操作的权限。然后，将策略附加到 IAM 角色（下一部分中将创建此角色）。因此，在适用于 Apache Flink 的托管服务代入该角色时，服务具有必要的权限从源流进行读取和写入接收器流。

使用以下代码创建 `AKReadSourceStreamWriteSinkStream` 权限策略。将 **username** 替换为您用于创建 Amazon S3 存储桶来存储应用程序代码的用户名。将 Amazon 资源名称 (ARN) 中的账户 ID **(012345678901)** 替换为您的账户 ID。

```
{
    "ApplicationName": "sliding_window",
    "ApplicationDescription": "Scala sliding window application",
    "RuntimeEnvironment": "FLINK-1_15",
    "ServiceExecutionRole": "arn:aws:iam::012345678901:role/MF-stream-rw-role",
    "ApplicationConfiguration": {
        "ApplicationCodeConfiguration": {
            "CodeContent": {
                "S3ContentLocation": {
                    "BucketARN": "arn:aws:s3:::ka-app-code-{{username}}",
                    "FileKey": "sliding-window-scala-1.0.jar"
                }
            },
            "CodeContentType": "ZIPFILE"
        },
        "EnvironmentProperties":  { 
         "PropertyGroups": [ 
            { 
               "PropertyGroupId": "ConsumerConfigProperties",
               "PropertyMap" : {
                    "aws.region" : "us-west-2",
                    "stream.name" : "ExampleInputStream",
                    "flink.stream.initpos" : "LATEST"
               }
            },
            { 
               "PropertyGroupId": "ProducerConfigProperties",
               "PropertyMap" : {
                    "aws.region" : "us-west-2",
                    "stream.name" : "ExampleOutputStream"
               }
            }
         ]
      }
    },
    "CloudWatchLoggingOptions": [ 
      { 
         "LogStreamARN": "arn:aws:logs:us-west-2:012345678901:log-group:MyApplication:log-stream:kinesis-analytics-log-stream"
      }
   ]
}
```

有关创建权限策略的分步说明，请参阅*《IAM 用户指南》*中的[教程：创建和附加您的第一个客户管理型策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html#part-two-create-policy)。

##### 创建一个 IAM 角色
<a name="examples-sliding-scala-iam-policy"></a>

在本节中，您将创建一个 IAM 角色，应用程序的 Managed Service for Apache Flink可以代入此角色来读取源流和写入接收器流。

权限不足时，Managed Service for Apache Flink 无法访问您的串流。您通过 IAM 角色授予这些权限。每个 IAM 角色附加了两种策略。此信任策略授予适用于 Apache Flink 的托管服务代入该角色的权限，权限策略确定适用于 Apache Flink 的托管服务代入这个角色后可以执行的操作。

您将在上一部分中创建的权限策略附加到此角色。

**创建 IAM 角色**

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航窗格中选择**角色**，然后选择**创建角色**。

1. 在 **选择受信任实体的类型** 下，选择 **AWS 服务**。

1. 在 **选择将使用此角色的服务** 下，选择 **Kinesis**。

1. 在**选择您的用例**部分，选择**Managed Service for Apache Flink**。

1. 选择**下一步: 权限**。

1. 在 **附加权限策略** 页面上，选择 **下一步: 审核**。在创建角色后，您可以附加权限策略。

1. 在 **创建角色** 页面上，输入**MF-stream-rw-role**作为**角色名称**。选择 **创建角色**。

    现在，您已经创建了一个名为 `MF-stream-rw-role` 的新 IAM 角色。接下来，您更新角色的信任和权限策略。

1. 将权限策略附加到角色。
**注意**  
对于本练习，Managed Service for Apache Flink代入此角色，以便同时从 Kinesis 数据流（源）读取数据和将输出写入另一个 Kinesis 数据流。因此，您附加在上一步[创建权限策略](https://docs.aws.amazon.com/managed-flink/latest/java/get-started-exercise.html#get-started-exercise-7-cli-policy)中创建的策略。

   1. 在 **摘要** 页上，选择 **权限** 选项卡。

   1. 选择**附加策略**。

   1. 在搜索框中，输入 **AKReadSourceStreamWriteSinkStream**（您在上一部分中创建的策略）。

   1. 选择`AKReadSourceStreamWriteSinkStream`策略，然后选择**附加策略**。

现在，您已经创建了应用程序用来访问资源的服务执行角色。记下新角色的 ARN。

有关创建角色的分步说明，请参阅*《IAM 用户指南》*中的在您的[中创建 IAM 角色（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html#roles-creatingrole-user-console)。

##### 创建应用程序
<a name="examples-sliding-scala-create-application-cli"></a>

将以下 JSON 代码保存到名为 `create_request.json` 的文件中。将示例角色 ARN 替换为您之前创建的角色的 ARN。将存储桶 ARN 后缀 (用户名) 替换为在前一部分中选择的后缀。将服务执行角色中的示例账户 ID (012345678901) 替换为您的账户 ID。

```
{
    "ApplicationName": "sliding_window",
    "ApplicationDescription": "Scala sliding_window application",
    "RuntimeEnvironment": "FLINK-1_15",
    "ServiceExecutionRole": "arn:aws:iam::012345678901:role/MF-stream-rw-role",
    "ApplicationConfiguration": {
        "ApplicationCodeConfiguration": {
            "CodeContent": {
                "S3ContentLocation": {
                    "BucketARN": "arn:aws:s3:::ka-app-code-{{username}}",
                    "FileKey": "sliding-window-scala-1.0.jar"
                }
            },
            "CodeContentType": "ZIPFILE"
        },
        "EnvironmentProperties":  { 
         "PropertyGroups": [ 
            { 
               "PropertyGroupId": "ConsumerConfigProperties",
               "PropertyMap" : {
                    "aws.region" : "us-west-2",
                    "stream.name" : "ExampleInputStream",
                    "flink.stream.initpos" : "LATEST"
               }
            },
            { 
               "PropertyGroupId": "ProducerConfigProperties",
               "PropertyMap" : {
                    "aws.region" : "us-west-2",
                    "stream.name" : "ExampleOutputStream"
               }
            }
         ]
      }
    },
    "CloudWatchLoggingOptions": [ 
      { 
         "LogStreamARN": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:MyApplication:log-stream:kinesis-analytics-log-stream"
      }
   ]
}
```

[CreateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_CreateApplication.html)使用以下请求执行以创建应用程序：

```
aws kinesisanalyticsv2 create-application --cli-input-json file://create_request.json
```

应用程序现已创建。您在下一步中启动应用程序。

##### 启动应用程序
<a name="examples-sliding-scala-start"></a>

在本节中，您使用 [StartApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序。

**启动应用程序**

1. 将以下 JSON 代码保存到名为 `start_request.json` 的文件中。

   ```
   {
       "ApplicationName": "sliding_window",
       "RunConfiguration": {
           "ApplicationRestoreConfiguration": { 
            "ApplicationRestoreType": "RESTORE_FROM_LATEST_SNAPSHOT"
            }
       }
   }
   ```

1. 使用上述请求执行 `StartApplication` 操作来启动应用程序：

   ```
   aws kinesisanalyticsv2 start-application --cli-input-json file://start_request.json
   ```

应用程序正在运行。您可以在亚马逊 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 停止应用程序
<a name="examples-sliding-scala-stop"></a>

在本节中，您使用 [StopApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序。

**停止应用程序**

1. 将以下 JSON 代码保存到名为 `stop_request.json` 的文件中。

   ```
   {
      "ApplicationName": "sliding_window"
   }
   ```

1. 使用上述请求执行 `StopApplication` 操作来停止应用程序：

   ```
   aws kinesisanalyticsv2 stop-application --cli-input-json file://stop_request.json
   ```

应用程序现已停止。

##### 添加 CloudWatch 日志选项
<a name="examples-sliding-scala-cw-option"></a>

您可以使用将 Amazon CloudWatch 日志流 AWS CLI 添加到您的应用程序中。有关在应用程序中使用 CloudWatch 日志的信息，请参阅[设置应用程序日志记录](https://docs.aws.amazon.com/managed-flink/latest/java/cloudwatch-logs.html)。

##### 更新环境属性
<a name="examples-sliding-scala-update-environment-properties"></a>

在本节中，您使用 [UpdateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html) 操作更改应用程序的环境属性，而无需重新编译应用程序代码。在该示例中，您更改源流和目标流的区域。

**更新应用程序的环境属性**

1. 将以下 JSON 代码保存到名为 `update_properties_request.json` 的文件中。

   ```
   {"ApplicationName": "sliding_window",
      "CurrentApplicationVersionId": 1,
      "ApplicationConfigurationUpdate": { 
         "EnvironmentPropertyUpdates": { 
            "PropertyGroups": [ 
               { 
                  "PropertyGroupId": "ConsumerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2",
                       "stream.name" : "ExampleInputStream",
                       "flink.stream.initpos" : "LATEST"
                  }
               },
               { 
                  "PropertyGroupId": "ProducerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2",
                       "stream.name" : "ExampleOutputStream"
                  }
               }
            ]
         }
      }
   }
   ```

1. 使用前面的请求执行 `UpdateApplication` 操作以更新环境属性：

   ```
   aws kinesisanalyticsv2 update-application --cli-input-json file://update_properties_request.json
   ```

##### 更新应用程序代码
<a name="examples-sliding-scala-update-app-code"></a>

当您需要使用新版本的代码包更新应用程序代码时，可以使用 [UpdateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html)CLI 操作。

**注意**  
要使用相同的文件名加载新版本的应用程序代码，您必须指定新的对象版本。有关使用 Amazon S3 对象版本的更多信息，请参阅[启用或禁用版本控制](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/enable-versioning.html)。

要使用 AWS CLI，请从 Amazon S3 存储桶中删除之前的代码包，上传新版本，然后调用`UpdateApplication`，指定相同的 Amazon S3 存储桶和对象名称以及新的对象版本。应用程序将使用新的代码包重新启动。

以下示例 `UpdateApplication` 操作请求重新加载应用程序代码并重新启动应用程序。将 `CurrentApplicationVersionId` 更新为当前的应用程序版本。您可以使用 `ListApplications` 或 `DescribeApplication` 操作检查当前的应用程序版本。将存储桶名称后缀 (<用户名>) 更新为在[创建相关资源](examples-gs-scala.md#examples-gs-scala-resources)一节中选择的后缀。

```
{
    "ApplicationName": "sliding_window",
    "CurrentApplicationVersionId": 1,
    "ApplicationConfigurationUpdate": {
        "ApplicationCodeConfigurationUpdate": {
            "CodeContentUpdate": {
                "S3ContentLocationUpdate": {
                    "BucketARNUpdate": "arn:aws:s3:::ka-app-code-{{username}}",
                    "FileKeyUpdate": "-1.0.jar",
                    "ObjectVersionUpdate": "SAMPLEUehYngP87ex1nzYIGYgfhypvDU"
                }
            }
        }
    }
}
```

##### 清理 AWS 资源
<a name="examples-sliding-scala-cleanup"></a>

本节包括清理滑动窗口教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#examples-sliding-scala-cleanup-app)
+ [删除您的 Kinesis 数据流](#examples-sliding-scala-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#examples-sliding-scala-cleanup-s3)
+ [删除您的 IAM 资源](#examples-sliding-scala-cleanup-iam)
+ [删除您的 CloudWatch 资源](#examples-sliding-scala-cleanup-cw)

##### 删除 Managed Service for Apache Flink 应用程序
<a name="examples-sliding-scala-cleanup-app"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Apache Flink 的托管服务面板中，选择。**MyApplication**

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

##### 删除您的 Kinesis 数据流
<a name="examples-sliding-scala-cleanup-stream"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

1. 在 **Kinesis 直播**页面中 **ExampleOutputStream**，选择，选择**操作**，选择**删除**，然后确认删除。

##### 删除您的 Amazon S3 对象和存储桶
<a name="examples-sliding-scala-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

##### 删除您的 IAM 资源
<a name="examples-sliding-scala-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

##### 删除您的 CloudWatch 资源
<a name="examples-sliding-scala-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。

#### 示例：在 Scala 中将流数据发送到 Amazon S3
<a name="examples-s3sink-scala"></a>

**注意**  
对于当前示例，请参阅 [创建和使用 Managed Service for Apache Flink 应用程序的示例](examples-collapsibles.md)。

**注意**  
从 Flink 1.15 版本开始，Scala 免费。应用程序现在可以使用任何 Scala 版本的 Java API。Flink 仍然在内部的一些关键组件中使用 Scala，但没有将 Scala 暴露到用户代码类加载器中。因此，用户需要将 Scala 从属项添加到其 jar 存档中。  
有关 Flink 1.15 中 Scala 变更的更多信息，请参阅 [1.15 Scala 免费](https://flink.apache.org/2022/02/22/scala-free.html)。

在本练习中，您将创建一个使用 Scala 3.2.0 和 Flink 的 Java API 的简单流媒体应用程序。 DataStream 该应用程序从 Kinesis 流中读取数据，使用滑动窗口对其进行聚合，然后将结果写入 S3。

**注意**  
要为本练习设置所需的先决条件，请先完成[入门 (Scala)](https://docs.aws.amazon.com/managed-flink/latest/java/examples-gs-scala.html) 练习。您只需要在 Amazon S3 存储桶 *ka-app-code-<username>* 中再创建一个文件夹 **data/**。

**Topics**
+ [下载并检查应用程序代码](#examples-s3sink-scala-download)
+ [编译并上传应用程序代码](#examples-s3sink-scala-upload)
+ [创建并运行应用程序（控制台）](#scala-7)
+ [创建并运行应用程序 (CLI)](#examples-s3sink-scala-create-run-cli)
+ [更新应用程序代码](#examples-s3sink-scala-update-app-code)
+ [清理 AWS 资源](#examples-s3sink-scala-cleanup)

##### 下载并检查应用程序代码
<a name="examples-s3sink-scala-download"></a>

此示例的 Python 应用程序代码可从中获得 GitHub。要下载应用程序代码，请执行以下操作：

1. 如果尚未安装 Git 客户端，请安装它。有关更多信息，请参阅[安装 Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。

1. 使用以下命令克隆远程存储库：

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-examples.git
   ```

1. 导航到 `amazon-kinesis-data-analytics-java-examples/scala/S3Sink` 目录。

请注意有关应用程序代码的以下信息：
+ `build.sbt` 文件包含有关应用程序的配置和从属项的信息，包括Managed Service for Apache Flink的库。
+ `BasicStreamingJob.scala` 文件包含定义应用程序功能的主要方法。
+ 应用程序使用 Kinesis 源从源流中进行读取。以下代码段创建 Kinesis 源：

  ```
  private def createSource: FlinkKinesisConsumer[String] = {
    val applicationProperties = KinesisAnalyticsRuntime.getApplicationProperties
    val inputProperties = applicationProperties.get("ConsumerConfigProperties")
  
    new FlinkKinesisConsumer[String](inputProperties.getProperty(streamNameKey, defaultInputStreamName),
      new SimpleStringSchema, inputProperties)
  }
  ```

  该应用程序还使用写 StreamingFileSink 入 Amazon S3 存储桶：

  ```
  def createSink: StreamingFileSink[String] = {
    val applicationProperties = KinesisAnalyticsRuntime.getApplicationProperties
    val s3SinkPath = applicationProperties.get("ProducerConfigProperties").getProperty("s3.sink.path")
  
    StreamingFileSink
      .forRowFormat(new Path(s3SinkPath), new SimpleStringEncoder[String]("UTF-8"))
      .build()
  }
  ```
+ 应用程序创建源连接器和接收器连接器，以使用 StreamExecutionEnvironment 对象访问外部资源。
+ 该应用程序将使用动态应用程序属性创建源和接收连接器。读取应用程序的运行时系统属性来配置连接器。有关运行时系统属性的更多信息，请参阅[运行时系统属性](https://docs.aws.amazon.com/managed-flink/latest/java/how-properties.html)。

##### 编译并上传应用程序代码
<a name="examples-s3sink-scala-upload"></a>

在本节中，您将编译应用程序代码并将其上传到 Amazon S3 存储桶。

**编译应用程序代码**

使用 [SBT](https://www.scala-sbt.org/) 构建工具为应用程序构建 Scala 代码。要安装 SBT，请参阅[使用 cs 安装程序安装 sbt](https://www.scala-sbt.org/download.html)。您还需要安装 Java 开发工具包 (JDK)。参阅[完成练习的先决条件](https://docs.aws.amazon.com/managed-flink/latest/java/getting-started.html#setting-up-prerequisites)。

1. 要使用您的应用程序代码，您将其编译和打包成 JAR 文件。您可以用 SBT 编译和打包代码：

   ```
   sbt assembly
   ```

1. 如果应用程序成功编译，则创建以下文件：

   ```
   target/scala-3.2.0/s3-sink-scala-1.0.jar
   ```

**上传 Apache Flink 流式处理 Scala 代码**

在本节中，创建 Amazon S3 存储桶并上传应用程序代码。

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择**创建存储桶**。

1. 在 **存储桶名称** 字段中输入 `ka-app-code-<username>`。将后缀（如您的用户名）添加到存储桶名称，以使其具有全局唯一性。选择**下一步**。

1. 在**配置选项**中，让设置保持原样，然后选择**下一步**。

1. 在**设置权限**中，让设置保持原样，然后选择**下一步**。

1. 选择 **创建存储桶 **。

1. 选择 `ka-app-code-<username>` 存储桶，然后选择**上传**。

1. 在**选择文件**步骤中，选择**添加文件**。导航到您在上一步中创建的 `s3-sink-scala-1.0.jar` 文件。

1. 您无需更改该对象的任何设置，因此，请选择**上传**。

您的应用程序代码现在存储在 Amazon S3 存储桶中，应用程序可以在其中访问代码。

##### 创建并运行应用程序（控制台）
<a name="scala-7"></a>

按照以下步骤，使用控制台创建、配置、更新和运行应用程序。

##### 创建应用程序
<a name="scala-7-console-create"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Managed Service for Apache Flink 控制面板上，选择**创建分析应用程序**。

1. 在**Managed Service for Apache Flink - 创建应用程序**页面上，提供应用程序详细信息，如下所示：
   + 对于 **应用程序名称 **，输入 **MyApplication**。
   + 对于**描述**，输入 **My java test app**。
   + 对于**运行时系统**，请选择 **Apache Flink**。
   + 将版本保留为 **Apache Flink 版本 1.15.2（建议的版本）**。

1. 对于**访问权限**，请选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 选择**创建应用程序**。

**注意**  
在使用控制台创建应用程序的 Managed Service for Apache Flink时，您可以选择为应用程序创建 IAM 角色和策略。您的应用程序使用此角色和策略访问其从属资源。这些 IAM 资源是使用您的应用程序名称和区域命名的，如下所示：  
策略：`kinesis-analytics-service-{{MyApplication}}-{{us-west-2}}`
角色：`kinesisanalytics-{{MyApplication}}-{{us-west-2}}`

##### 配置应用程序
<a name="scala-7-console-configure"></a>

请使用以下过程来配置应用程序。

**配置应用程序**

1. 在**MyApplication**页面上，选择**配置**。

1. 在 **配置应用程序** 页面上，提供 **代码位置**：
   + 对于**Amazon S3 存储桶**，请输入**ka-app-code-{{<username>}}**。
   + **在 Amazon S3 对象的路径**中，输入**s3-sink-scala-1.0.jar**。

1. 在 **对应用程序的访问权限** 下，对于 **访问权限**，选择 **创建/更新 IAM 角色 `kinesis-analytics-MyApplication-us-west-2`**。

1. 在**属性**下面，选择**添加组**。

1. 输入以下信息：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

   选择**保存**。

1. 在**属性**下面，选择**添加组**。

1. 输入以下信息：    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_cn/managed-flink/latest/java/earlier.html)

1. 在 **监控** 下，确保 ** 监控指标级别** 设置为 **应用程序**。

1. 要进行**CloudWatch 日志记录**，请选中 “**启用**” 复选框。

1. 选择**更新**。

**注意**  
当您选择启用 Amazon CloudWatch 日志时，适用于 Apache Flink 的托管服务会为您创建一个日志组和日志流。这些资源的名称如下所示：  
日志组：`/aws/kinesis-analytics/MyApplication`
日志流：`kinesis-analytics-log-stream`

##### 编辑 IAM 策略
<a name="scala-7-console-iam"></a>

编辑 IAM policy 以添加访问 Amazon S3 数据流的权限。

**编辑 IAM policy 以添加 S3 存储桶权限**

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 选择**策略**。选择控制台在上一部分中为您创建的 **`kinesis-analytics-service-MyApplication-us-west-2`** 策略。

1. 在 **摘要** 页面上，选择 **编辑策略**。选择 **JSON** 选项卡。

1. 将以下策略示例中突出显示的部分添加到策略中。将示例账户 ID ({{012345678901}}) 替换为您的账户 ID。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:Abort*", 
                   "s3:DeleteObject*", 
                   "s3:GetObject*", 
                   "s3:GetBucket*", 
                   "s3:List*", 
                   "s3:ListBucket", 
                   "s3:PutObject"
               ],
               "Resource": [ 
                   "arn:aws:s3:::ka-app-code-<username>", 
                   "arn:aws:s3:::ka-app-code-<username>/*" 
               ]
           },
           {
               "Sid": "DescribeLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:*"
               ]
           },
           {
               "Sid": "DescribeLogStreams",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogStreams"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
               ]
           },
           {
               "Sid": "PutLogEvents",
               "Effect": "Allow",
               "Action": [
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:us-west-2:{{012345678901}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
               ]
           },
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-west-2:{{012345678901}}:stream/ExampleInputStream"
           }
       ]
   }
   ```

------

##### 运行应用程序
<a name="scala-7-console-run"></a>

可以通过运行应用程序、打开 Apache Flink 控制面板并选择所需的 Flink 任务来查看 Flink 任务图。

##### 停止应用程序
<a name="scala-7-console-stop"></a>

要停止应用程序，请在**MyApplication**页面上选择**停止**。确认该操作。

##### 创建并运行应用程序 (CLI)
<a name="examples-s3sink-scala-create-run-cli"></a>

在本节中，您将使用创建和运行适用 AWS Command Line Interface 于 Apache Flink 的托管服务应用程序。使用 k *inesisanalyticsv2* AWS CLI 命令为 Apache Flink 应用程序创建托管服务并与之交互。

##### 创建权限策略
<a name="examples-s3sink-scala-permissions"></a>

**注意**  
您必须为应用程序创建一个权限策略和角色。如果未创建这些 IAM 资源，应用程序将无法访问其数据和日志流。

首先，使用两个语句创建权限策略：一个语句授予对源流执行读取操作的权限，另一个语句授予对接收器流执行写入操作的权限。然后，将策略附加到 IAM 角色（下一部分中将创建此角色）。因此，在适用于 Apache Flink 的托管服务代入该角色时，服务具有必要的权限从源流进行读取和写入接收器流。

使用以下代码创建 `AKReadSourceStreamWriteSinkStream` 权限策略。将 **username** 替换为您用于创建 Amazon S3 存储桶来存储应用程序代码的用户名。将 Amazon 资源名称 (ARN) 中的账户 ID **(012345678901)** 替换为您的账户 ID。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "ReadCode",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:GetObjectVersion"
            ],
            "Resource": [
                "arn:aws:s3:::ka-app-code-{{username}}/getting-started-scala-1.0.jar"
            ]
        },
        {
            "Sid": "DescribeLogGroups",
            "Effect": "Allow",
            "Action": [
                "logs:DescribeLogGroups"
            ],
            "Resource": [
                "arn:aws:logs:us-west-2:{{123456789012}}:*"
            ]
        },
        {
            "Sid": "DescribeLogStreams",
            "Effect": "Allow",
            "Action": [
                "logs:DescribeLogStreams"
            ],
            "Resource": [
                "arn:aws:logs:us-west-2:{{123456789012}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
            ]
        },
        {
            "Sid": "PutLogEvents",
            "Effect": "Allow",
            "Action": [
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:us-west-2:{{123456789012}}:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
            ]
        },
        {
            "Sid": "ReadInputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:{{123456789012}}:stream/{{ExampleInputStream}}"
        },
        {
            "Sid": "WriteOutputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:{{123456789012}}:stream/{{ExampleOutputStream}}"
        }
    ]
}
```

------

有关创建权限策略的分步说明，请参阅*《IAM 用户指南》*中的[教程：创建和附加您的第一个客户管理型策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html#part-two-create-policy)。

##### 创建一个 IAM 角色
<a name="examples-s3sink-scala-iam-policy"></a>

在本节中，您将创建一个 IAM 角色，应用程序的 Managed Service for Apache Flink可以代入此角色来读取源流和写入接收器流。

权限不足时，Managed Service for Apache Flink 无法访问您的串流。您通过 IAM 角色授予这些权限。每个 IAM 角色附加了两种策略。此信任策略授予适用于 Apache Flink 的托管服务代入该角色的权限，权限策略确定适用于 Apache Flink 的托管服务代入这个角色后可以执行的操作。

您将在上一部分中创建的权限策略附加到此角色。

**创建 IAM 角色**

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航窗格中选择**角色**，然后选择**创建角色**。

1. 在 **选择受信任实体的类型** 下，选择 **AWS 服务**。

1. 在 **选择将使用此角色的服务** 下，选择 **Kinesis**。

1. 在**选择您的用例**部分，选择**Managed Service for Apache Flink**。

1. 选择**下一步: 权限**。

1. 在 **附加权限策略** 页面上，选择 **下一步: 审核**。在创建角色后，您可以附加权限策略。

1. 在 **创建角色** 页面上，输入**MF-stream-rw-role**作为**角色名称**。选择 **创建角色**。

    现在，您已经创建了一个名为 `MF-stream-rw-role` 的新 IAM 角色。接下来，您更新角色的信任和权限策略。

1. 将权限策略附加到角色。
**注意**  
对于本练习，Managed Service for Apache Flink代入此角色，以便同时从 Kinesis 数据流（源）读取数据和将输出写入另一个 Kinesis 数据流。因此，您附加在上一步[创建权限策略](https://docs.aws.amazon.com/managed-flink/latest/java/get-started-exercise.html#get-started-exercise-7-cli-policy)中创建的策略。

   1. 在 **摘要** 页上，选择 **权限** 选项卡。

   1. 选择**附加策略**。

   1. 在搜索框中，输入 **AKReadSourceStreamWriteSinkStream**（您在上一部分中创建的策略）。

   1. 选择`AKReadSourceStreamWriteSinkStream`策略，然后选择**附加策略**。

现在，您已经创建了应用程序用来访问资源的服务执行角色。记下新角色的 ARN。

有关创建角色的分步说明，请参阅*《IAM 用户指南》*中的在您的[中创建 IAM 角色（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html#roles-creatingrole-user-console)。

##### 创建应用程序
<a name="examples-s3sink-scala-create-application-cli"></a>

将以下 JSON 代码保存到名为 `create_request.json` 的文件中。将示例角色 ARN 替换为您之前创建的角色的 ARN。将存储桶 ARN 后缀 (用户名) 替换为在前一部分中选择的后缀。将服务执行角色中的示例账户 ID (012345678901) 替换为您的账户 ID。

```
{
    "ApplicationName": "s3_sink",
    "ApplicationDescription": "Scala tumbling window application",
    "RuntimeEnvironment": "FLINK-1_15",
    "ServiceExecutionRole": "arn:aws:iam::012345678901:role/MF-stream-rw-role",
    "ApplicationConfiguration": {
        "ApplicationCodeConfiguration": {
            "CodeContent": {
                "S3ContentLocation": {
                    "BucketARN": "arn:aws:s3:::ka-app-code-{{username}}",
                    "FileKey": "s3-sink-scala-1.0.jar"
                }
            },
            "CodeContentType": "ZIPFILE"
        },
        "EnvironmentProperties":  { 
         "PropertyGroups": [ 
            { 
               "PropertyGroupId": "ConsumerConfigProperties",
               "PropertyMap" : {
                    "aws.region" : "us-west-2",
                    "stream.name" : "ExampleInputStream",
                    "flink.stream.initpos" : "LATEST"
               }
            },
            { 
               "PropertyGroupId": "ProducerConfigProperties",
               "PropertyMap" : {
                    "s3.sink.path" : "s3a://ka-app-code-<username>/data"
               }
            }
         ]
      }
    },
    "CloudWatchLoggingOptions": [ 
      { 
         "LogStreamARN": "arn:aws:logs:us-west-2:{{012345678901}}:log-group:MyApplication:log-stream:kinesis-analytics-log-stream"
      }
   ]
}
```

[CreateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_CreateApplication.html)使用以下请求执行以创建应用程序：

```
aws kinesisanalyticsv2 create-application --cli-input-json file://create_request.json
```

应用程序现已创建。您在下一步中启动应用程序。

##### 启动应用程序
<a name="examples-s3sink-scala-start"></a>

在本节中，您使用 [StartApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_StartApplication.html) 操作来启动应用程序。

**启动应用程序**

1. 将以下 JSON 代码保存到名为 `start_request.json` 的文件中。

   ```
   {{
       "ApplicationName": "s3_sink",
       "RunConfiguration": {
           "ApplicationRestoreConfiguration": { 
            "ApplicationRestoreType": "RESTORE_FROM_LATEST_SNAPSHOT"
            }
       }
   }
   ```

1. 使用上述请求执行 `StartApplication` 操作来启动应用程序：

   ```
   aws kinesisanalyticsv2 start-application --cli-input-json file://start_request.json
   ```

应用程序正在运行。您可以在亚马逊 CloudWatch 控制台上查看托管服务的 Apache Flink 指标，以验证应用程序是否正常运行。

##### 停止应用程序
<a name="examples-s3sink-scala-stop"></a>

在本节中，您使用 [StopApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_StopApplication.html) 操作来停止应用程序。

**停止应用程序**

1. 将以下 JSON 代码保存到名为 `stop_request.json` 的文件中。

   ```
   {
      "ApplicationName": "s3_sink"
   }
   ```

1. 使用上述请求执行 `StopApplication` 操作来停止应用程序：

   ```
   aws kinesisanalyticsv2 stop-application --cli-input-json file://stop_request.json
   ```

应用程序现已停止。

##### 添加 CloudWatch 日志选项
<a name="examples-s3sink-scala-cw-option"></a>

您可以使用将 Amazon CloudWatch 日志流 AWS CLI 添加到您的应用程序中。有关在应用程序中使用 CloudWatch 日志的信息，请参阅[设置应用程序日志记录](https://docs.aws.amazon.com/managed-flink/latest/java/cloudwatch-logs.html)。

##### 更新环境属性
<a name="examples-s3sink-scala-update-environment-properties"></a>

在本节中，您使用 [UpdateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html) 操作更改应用程序的环境属性，而无需重新编译应用程序代码。在该示例中，您更改源流和目标流的区域。

**更新应用程序的环境属性**

1. 将以下 JSON 代码保存到名为 `update_properties_request.json` 的文件中。

   ```
   {"ApplicationName": "s3_sink",
      "CurrentApplicationVersionId": 1,
      "ApplicationConfigurationUpdate": { 
         "EnvironmentPropertyUpdates": { 
            "PropertyGroups": [ 
               { 
                  "PropertyGroupId": "ConsumerConfigProperties",
                  "PropertyMap" : {
                       "aws.region" : "us-west-2",
                       "stream.name" : "ExampleInputStream",
                       "flink.stream.initpos" : "LATEST"
                  }
               },
               { 
                  "PropertyGroupId": "ProducerConfigProperties",
                  "PropertyMap" : {
                       "s3.sink.path" : "s3a://ka-app-code-<username>/data"
                  }
               }
            ]
         }
      }
   }
   ```

1. 使用前面的请求执行 `UpdateApplication` 操作以更新环境属性：

   ```
   aws kinesisanalyticsv2 update-application --cli-input-json file://update_properties_request.json
   ```

##### 更新应用程序代码
<a name="examples-s3sink-scala-update-app-code"></a>

当您需要使用新版本的代码包更新应用程序代码时，可以使用 [UpdateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html)CLI 操作。

**注意**  
要使用相同的文件名加载新版本的应用程序代码，您必须指定新的对象版本。有关使用 Amazon S3 对象版本的更多信息，请参阅[启用或禁用版本控制](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/enable-versioning.html)。

要使用 AWS CLI，请从 Amazon S3 存储桶中删除之前的代码包，上传新版本，然后调用`UpdateApplication`，指定相同的 Amazon S3 存储桶和对象名称以及新的对象版本。应用程序将使用新的代码包重新启动。

以下示例 `UpdateApplication` 操作请求重新加载应用程序代码并重新启动应用程序。将 `CurrentApplicationVersionId` 更新为当前的应用程序版本。您可以使用 `ListApplications` 或 `DescribeApplication` 操作检查当前的应用程序版本。将存储桶名称后缀 (<用户名>) 更新为在[创建相关资源](examples-gs-scala.md#examples-gs-scala-resources)一节中选择的后缀。

```
{
    "ApplicationName": "s3_sink",
    "CurrentApplicationVersionId": 1,
    "ApplicationConfigurationUpdate": {
        "ApplicationCodeConfigurationUpdate": {
            "CodeContentUpdate": {
                "S3ContentLocationUpdate": {
                    "BucketARNUpdate": "arn:aws:s3:::ka-app-code-{{username}}",
                    "FileKeyUpdate": "s3-sink-scala-1.0.jar",
                    "ObjectVersionUpdate": "SAMPLEUehYngP87ex1nzYIGYgfhypvDU"
                }
            }
        }
    }
}
```

##### 清理 AWS 资源
<a name="examples-s3sink-scala-cleanup"></a>

本节包括清理在 Tumbling Window 教程中创建的 AWS 资源的过程。

**Topics**
+ [删除 Managed Service for Apache Flink 应用程序](#examples-s3sink-scala-cleanup-app)
+ [删除您的 Kinesis 数据流](#examples-s3sink-scala-cleanup-stream)
+ [删除您的 Amazon S3 对象和存储桶](#examples-s3sink-scala-cleanup-s3)
+ [删除您的 IAM 资源](#examples-s3sink-scala-cleanup-iam)
+ [删除您的 CloudWatch 资源](#examples-s3sink-scala-cleanup-cw)

##### 删除 Managed Service for Apache Flink 应用程序
<a name="examples-s3sink-scala-cleanup-app"></a>

1. 登录并打开 Amazon MSF 控制台，网址为 AWS 管理控制台 https://console.aws.amazon.com/flink.

1. 在 Apache Flink 的托管服务面板中，选择。**MyApplication**

1. 在应用程序的页面中，选择 **删除**，然后确认删除。

##### 删除您的 Kinesis 数据流
<a name="examples-s3sink-scala-cleanup-stream"></a>

1. 打开 Kinesis 控制台，网址为。[https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis)

1. 在 Kinesis Data Streams 面板中，**ExampleInputStream**选择。

1. 在该**ExampleInputStream**页面中，选择 “**删除 Kinesis Stream**”，然后确认删除。

1. 在 **Kinesis 直播**页面中 **ExampleOutputStream**，选择，选择**操作**，选择**删除**，然后确认删除。

##### 删除您的 Amazon S3 对象和存储桶
<a name="examples-s3sink-scala-cleanup-s3"></a>

1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 选择 **ka-app-code-buc** ket。{{<username>}}

1. 选择 **删除**，然后输入存储桶名称以确认删除。

##### 删除您的 IAM 资源
<a name="examples-s3sink-scala-cleanup-iam"></a>

1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

1. 在导航栏中，选择**策略**。

1. 在筛选条件控件中，输入 **kinesis**。

1. 选择 k **inesis 分析服务策略**。MyApplication-us-west-2

1. 选择 **策略操作**，然后选择 **删除**。

1. 在导航栏中，选择 **角色**。

1. 选择 k **inesis-Analytics（分析**）角色。MyApplication-us-west-2

1. 选择 **删除角色**，然后确认删除。

##### 删除您的 CloudWatch 资源
<a name="examples-s3sink-scala-cleanup-cw"></a>

1. 打开 CloudWatch 控制台，网址为[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。

1. 在导航栏中，选择 **日志**。

1. 选择**/aws/kinesis-analytics/MyApplication** 日志组。

1. 选择 **删除日志组**，然后确认删除。