

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Criar um bloco de anotações do Studio com o Kinesis Data Streams
<a name="example-notebook-streams"></a>

Este tutorial descreve como criar um bloco de anotações do Studio que usa um fluxo de dados do Kinesis como uma fonte.

**Topics**
+ [Concluir os pré-requisitos do .](#example-notebook-streams-setup)
+ [Crie uma AWS Glue tabela](#example-notebook-streams-glue)
+ [Criar um bloco de anotações do Studio com o Kinesis Data Streams](#example-notebook-streams-create)
+ [Envie dados para o Kinesis Data Streams](#example-notebook-streams-send)
+ [Teste seu bloco de anotações do Studio](#example-notebook-streams-test)

## Concluir os pré-requisitos do .
<a name="example-notebook-streams-setup"></a>

Antes de criar um bloco de anotações do Studio, crie um fluxo de dados do Kinesis (`ExampleInputStream`). Seu aplicativo usa esse fluxo para a fonte do aplicativo.

Você pode criar esses fluxos usando o console do Amazon Kinesis ou este comando AWS CLI . Para obter instruções sobre o console, consulte [Criar e atualizar fluxos de dados](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html) no *Guia do desenvolvedor do Amazon Kinesis Data Streams*. Nomeie o fluxo **ExampleInputStream** e defina o **Número de fragmentos abertos** como **1**.

Para criar o stream (`ExampleInputStream`) usando o AWS CLI, use o seguinte comando do Amazon Kinesis `create-stream` AWS CLI .

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

## Crie uma AWS Glue tabela
<a name="example-notebook-streams-glue"></a>

Seu bloco de anotações do Studio usa um [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html)banco de dados para metadados sobre sua fonte de dados do Kinesis Data Streams.

**nota**  
Você pode criar o banco de dados manualmente primeiro ou deixar que o Managed Service for Apache Flink o crie para você ao criar o bloco de anotações. Da mesma forma, você pode criar manualmente a tabela conforme descrito nesta seção ou usar o código do conector de criação de tabela para o Managed Service for Apache Flink em seu bloco de anotações no Apache Zeppelin para criar sua tabela por meio de uma instrução DDL. Em seguida, você pode fazer AWS Glue o check-in para verificar se a tabela foi criada corretamente.

**Criar uma tabela**

1. Faça login no Console de gerenciamento da AWS e abra o AWS Glue console em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).

1. Se você ainda não tiver um AWS Glue banco de dados, escolha **Bancos de dados** na barra de navegação à esquerda. Selecione **Adicionar banco de dados**. Na janela **Adicionar banco de dados**, insira **default** para **Nome do banco de dados**. Selecione **Create** (Criar).

1. Na barra de navegação à esquerda, selecione **Tabelas**. Na página **Tabelas**, selecione **Adicionar tabelas**, **Adicionar tabela manualmente**.

1. Na página **Configurar propriedades da tabela**, insira **stock** para o **Nome da tabela**. Certifique-se de selecionar o banco de dados que você criou anteriormente. Selecione **Next** (Próximo).

1. Na página **Adicionar um armazenamento de dados**, selecione **Kinesis**. Para **Nome do fluxo**, insira **ExampleInputStream**. Para **URL de origem do Kinesis**, selecione inserir **https://kinesis.us-east-1.amazonaws.com**. Se você copiar e colar o **URL de origem do Kinesis**, certifique-se de excluir todos os espaços à esquerda ou à direita. Selecione **Next** (Próximo).

1. Na página **Classificação**, selecione **JSON**. Selecione **Next** (Próximo).

1. Na página **Definir um esquema**, selecione Adicionar coluna para adicionar uma coluna. Adicione colunas com as seguintes propriedades:    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/managed-flink/latest/java/example-notebook-streams.html)

   Escolha **Próximo**.

1. Na próxima página, verifique suas configurações e selecione **Concluir**.

1. Selecione a tabela recém-criada na lista de tabelas.

1. Selecione **Editar tabela** e adicione uma propriedade com a chave `managed-flink.proctime` e o valor `proctime`.

1. Selecione **Apply** (Aplicar).

## Criar um bloco de anotações do Studio com o Kinesis Data Streams
<a name="example-notebook-streams-create"></a>

Agora que você criou os recursos que o seu aplicativo usa, crie seu bloco de anotações do Studio. 

**Topics**
+ [Crie um notebook Studio usando o Console de gerenciamento da AWS](#example-notebook-create-streams-console)
+ [Crie um notebook Studio usando o AWS CLI](#example-notebook-msk-create-api)

### Crie um notebook Studio usando o Console de gerenciamento da AWS
<a name="example-notebook-create-streams-console"></a>

1. [Abra o serviço gerenciado para o console Apache Flink em casa https://console.aws.amazon.com/managed-flink/? region=us-east-1\$1/aplicativos/painel](https://console.aws.amazon.com/managed-flink/home?region=us-east-1#/applications/dashboard). 

1. Na página **Aplicativos do Managed Service for Apache Flink**, selecione a guia **Studio**. Selecione **Criar bloco de anotações do Studio**.
**nota**  
Você também pode criar um bloco de anotações do Studio a partir dos consoles Amazon MSK ou Kinesis Data Streams, selecionando seu cluster Amazon MSK de entrada ou Kinesis Data Streams e selecionando **Processar dados em tempo real**.

1. Na página **Criar bloco de anotações do Studio**, forneça as seguintes informações:
   + Digite **MyNotebook** como nome do bloco de anotações.
   + Selecione o **padrão** para o **banco de dados AWS Glue**.

   Selecione **Criar bloco de anotações do Studio**.

1. Na **MyNotebook**página, escolha **Executar**. Aguarde até que o **Status** mostre **Em execução**. As cobranças se aplicam quando o bloco de anotações está em execução.

### Crie um notebook Studio usando o AWS CLI
<a name="example-notebook-msk-create-api"></a>

Para criar seu notebook Studio usando o AWS CLI, faça o seguinte:

1. Verifique o seu ID da conta. Você precisa desse valor para criar seu aplicativo.

1. Crie a função `arn:aws:iam::AccountID:role/ZeppelinRole` e adicione as seguintes permissões à função criada automaticamente pelo console.

   `"kinesis:GetShardIterator",`

   `"kinesis:GetRecords",`

   `"kinesis:ListShards"`

1. Crie um arquivo chamado `create.json` com o conteúdo a seguir. Substitua os valores de espaço reservado por suas próprias informações.

   ```
   {
       "ApplicationName": "MyNotebook",
       "RuntimeEnvironment": "ZEPPELIN-FLINK-3_0",
       "ApplicationMode": "INTERACTIVE",
       "ServiceExecutionRole": "arn:aws:iam::AccountID:role/ZeppelinRole",
       "ApplicationConfiguration": {
           "ApplicationSnapshotConfiguration": {
               "SnapshotsEnabled": false
           },
           "ZeppelinApplicationConfiguration": {
               "CatalogConfiguration": {
                   "GlueDataCatalogConfiguration": {
                       "DatabaseARN": "arn:aws:glue:us-east-1:AccountID:database/default"
                   }
               }
           }
       }
   }
   ```

1. Para criar o seu aplicativo, execute o comando a seguir:

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

1. Quando o comando for concluído, você verá uma saída que mostra os detalhes do seu novo bloco de anotações do Studio. A seguir, veja um exemplo de saída.

   ```
   {
       "ApplicationDetail": {
           "ApplicationARN": "arn:aws:kinesisanalyticsus-east-1:012345678901:application/MyNotebook",
           "ApplicationName": "MyNotebook",
           "RuntimeEnvironment": "ZEPPELIN-FLINK-3_0",
           "ApplicationMode": "INTERACTIVE",
           "ServiceExecutionRole": "arn:aws:iam::012345678901:role/ZeppelinRole",
   ...
   ```

1. Execute o comando a seguir para iniciar o aplicativo. Substitua o valor do exemplo pelo ID de sua conta.

   ```
   aws kinesisanalyticsv2 start-application --application-arn arn:aws:kinesisanalyticsus-east-1:012345678901:application/MyNotebook\
   ```

## Envie dados para o Kinesis Data Streams
<a name="example-notebook-streams-send"></a>

Para enviar dados de teste para seu Kinesis Data Streams, faça o seguinte:

1. Use o [Kinesis Data Generator](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html). 

1. Escolha **Criar um usuário Cognito com**. CloudFormation

1. O CloudFormation console é aberto com o modelo do Kinesis Data Generator. Escolha **Próximo**.

1. Na página **Especificar os detalhes da pilha**, insira o seu nome de usuário e a senha para seu usuário do Cognito. Selecione **Next** (Próximo).

1. Na página **Configurar opções de pilha**, selecione **Próximo**.

1. Na página **Review Kinesis-Data-Generator-Cognito -User**, escolha a opção **Eu reconheço que AWS CloudFormation pode criar recursos do IAM**. caixa de seleção. Selecione **Create Stack** (Criar pilha).

1. Aguarde até que a CloudFormation pilha termine de ser criada. **Depois que a pilha estiver concluída, abra a pilha **Kinesis-Data-Generator-Cognito-User** no console e escolha a guia Saídas. CloudFormation ** Abra o URL listado para o valor **KinesisDataGeneratorUrl**de saída.

1. Na página do **Amazon Kinesis Data Generator**, faça login com as credenciais que você criou na etapa 4.

1. Na página seguinte, forneça os valores a seguir:    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/managed-flink/latest/java/example-notebook-streams.html)

   Para **Modelo de registro**, cole o seguinte código:

   ```
   {
       "ticker": "{{random.arrayElement(
           ["AMZN","MSFT","GOOG"]
       )}}",
       "price": {{random.number(
           {
               "min":10,
               "max":150
           }
       )}}
   }
   ```

1. Selecione **Enviar dados**.

1. O gerador enviará dados para o seu Kinesis Data Streams. 

   Deixe o gerador executando enquanto você conclui a próxima seção.

## Teste seu bloco de anotações do Studio
<a name="example-notebook-streams-test"></a>

Nesta seção, você usa seu bloco de anotações do Studio para consultar dados do seu Kinesis Data Streams.

1. [Abra o serviço gerenciado para o console Apache Flink em casa https://console.aws.amazon.com/managed-flink/? region=us-east-1\$1/aplicativos/painel](https://console.aws.amazon.com/managed-flink/home?region=us-east-1#/applications/dashboard).

1. Na página **Aplicativos do Managed Service for Apache Flink**, selecione a guia **bloco de anotações do Studio**. Selecione **MyNotebook**.

1. Na **MyNotebook**página, escolha **Abrir no Apache Zeppelin**.

   A interface do Apache Zeppelin é aberta em uma nova guia.

1. Na página **Bem-vindo ao Zeppelin\$1**, selecione **Anotação do Zeppelin**.

1. Na página **Anotação do Zeppelin**, insira a seguinte consulta em uma nova anotação:

   ```
   %flink.ssql(type=update)
   select * from stock
   ```

   Selecione o ícone de execução.

   Depois de um curto período de tempo, a anotação exibe dados do Kinesis Data Streams.

Para abrir o painel do Apache Flink para que seu aplicativo visualize aspectos operacionais, selecione **TRABALHO FLINK**. Para obter mais informações sobre o painel do Flink, consulte o [painel do Apache Flink](https://docs.aws.amazon.com/managed-flink/latest/java/how-dashboard.html) no [Guia do desenvolvedor do Managed Service for Apache Flink](https://docs.aws.amazon.com/).

Para obter mais exemplos de consultas SQL do Flink Streaming, veja [Consultas](https://nightlies.apache.org/flink/flink-docs-release-1.15/dev/table/sql/queries.html) na [documentação do Apache Flink](https://nightlies.apache.org/flink/flink-docs-release-1.15/).