

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á.

# Crie um bloco de anotações do Studio com o Amazon MSK
<a name="example-notebook-msk"></a>

Este tutorial descreve como criar um bloco de anotações do Studio que usa um cluster do Amazon MSK como fonte.

**Topics**
+ [Configurar um cluster Amazon MSK](#example-notebook-msk-setup)
+ [Adicione um gateway NAT à sua VPC](#example-notebook-msk-nat)
+ [Crie uma AWS Glue conexão e uma tabela](#example-notebook-msk-glue)
+ [Crie um bloco de anotações do Studio com o Amazon MSK](#example-notebook-msk-create)
+ [Envie dados para seu cluster Amazon MSK](#example-notebook-msk-send)
+ [Teste seu bloco de anotações do Studio](#example-notebook-msk-test)

## Configurar um cluster Amazon MSK
<a name="example-notebook-msk-setup"></a>

Para este tutorial, você precisa de um cluster do Amazon MSK que permita o acesso em texto sem formatação. Se você ainda não tiver um cluster Amazon MSK configurado, siga o tutorial [Getting Started Using Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html) para criar uma Amazon VPC, um cluster Amazon MSK, um tópico e uma instância cliente da Amazon. EC2 

Ao seguir o tutorial, faça o seguinte:
+ Na [Etapa 3: Criar um cluster Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/create-cluster.html), na etapa 4, altere o valor `ClientBroker` de `TLS` para **PLAINTEXT**.

## Adicione um gateway NAT à sua VPC
<a name="example-notebook-msk-nat"></a>

Se você criou um cluster Amazon MSK seguindo o tutorial [Conceitos básicos do uso do Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html), ou se sua Amazon VPC existente ainda não tem um gateway NAT para suas sub-redes privadas, você deve adicionar um gateway NAT à sua Amazon VPC. O diagrama a seguir mostra a arquitetura. 

![\[AWS VPC architecture with public and private subnets, NAT gateway, and Glue Data Catalog integration.\]](http://docs.aws.amazon.com/pt_br/managed-flink/latest/java/images/vpc_05.png)


Para criar um gateway NAT para sua Amazon VPC, faça o seguinte:

1. Abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).

1. Selecione **Gateways NAT** na barra de navegação à esquerda.

1. Na página **Gateways NATs**, escolha **Criar gateway NAT**.

1. Na página **Criar gateway NAT**, entre 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-msk.html)

   Escolha **Criar um gateway NAT**.

1. Na barra de navegação à esquerda, escolha **Tabelas de rotas**.

1. Escolha **Criar tabela de rotas**.

1. Na página **Criar tabela de rotas**, forneça as seguintes informações:
   + **Nome da tag**: **ZeppelinRouteTable**
   + **VPC****: escolha sua VPC (por exemplo, VPC).AWS KafkaTutorial**

   Escolha **Criar**.

1. Na lista de tabelas de rotas, escolha **ZeppelinRouteTable**. Escolha a guia **Rotas** e selecione **Editar rotas**.

1. Na página **Editar rotas**, selecione **Adicionar rota**.

1. Em ****Para **Destino**, insira **0.0.0.0/0**. Para **Target**, escolha **NAT Gateway**, **ZeppelinGateway**. Selecione **Salvar rotas**. Escolha **Fechar**.

1. Na página Tabelas de rotas, com a **ZeppelinRouteTable**opção selecionada, escolha a guia **Associações de sub-rede**. Selecione **Editar associações de sub-rede**.

1. Na página **Editar associações de sub-rede**, escolha **AWS KafkaTutorialSubnet2** e **AWS KafkaTutorialSubnet3**. Escolha **Salvar**.

## Crie uma AWS Glue conexão e uma tabela
<a name="example-notebook-msk-glue"></a>

Seu bloco de anotações do Studio usa um banco de dados [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html) para metadados sobre sua fonte de dados Amazon MSK. Nesta seção, você cria uma AWS Glue conexão que descreve como acessar seu cluster Amazon MSK e uma AWS Glue tabela que descreve como apresentar os dados em sua fonte de dados para clientes como seu notebook Studio. 

**Criar uma conexão**

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**. Escolha **Criar**.

1. Selecione **Conexões** na barra de navegação à esquerda. Selecione **Adicionar conexão**.

1. Na janela **Adicionar conexão**, forneça os seguintes valores:
   + Em **Nome da conexão**, insira **ZeppelinConnection**.
   + Em **Tipo de conexão**, escolha **Kafka**.
   + Para o **servidor bootstrap Kafka URLs**, forneça a string do broker bootstrap para seu cluster. Você pode obter os corretores de bootstrap no console do MSK ou digitando o seguinte comando da CLI:

     ```
     aws kafka get-bootstrap-brokers --region us-east-1 --cluster-arn ClusterArn
     ```
   + Desmarque a caixa de seleção **Exigir conexão SSL**.

   Escolha **Próximo**.

1. Na página **VPC**, forneça os valores a seguir:
   + **Para **VPC**, escolha o nome da sua VPC (por exemplo, VPC). AWS KafkaTutorial**
   + Em **Sub-rede**, escolha **AWS KafkaTutorialSubnet2**.
   + Em **Grupos de segurança**, escolha todos os grupos disponíveis.

   Escolha **Próximo**.

1. Na página **Propriedades da conexão** / **Acesso à conexão**, selecione **Concluir**.

**Criar uma tabela**
**nota**  
Você pode criar manualmente a tabela conforme descrito nas etapas a seguir 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.

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. Escolha **Próximo**.

1. Na página **Adicionar um armazenamento de dados**, selecione **Kafka**. Para o **nome do tópico**, insira o nome do tópico (por exemplo **AWS KafkaTutorialTopic**). Para **Conexão**, escolha **ZeppelinConnection**.

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-msk.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. Escolha **Editar tabela** e adicione as seguintes propriedades:
   + chave: `managed-flink.proctime`, valor: `proctime`
   + chave: `flink.properties.group.id`, valor: `test-consumer-group`
   + chave: `flink.properties.auto.offset.reset`, valor: `latest`
   + chave: `classification`, valor: `json`

   Sem esses pares de chave/valor, o notebook Flink apresenta um erro. 

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

## Crie um bloco de anotações do Studio com o Amazon MSK
<a name="example-notebook-msk-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-msk-console)
+ [Crie um notebook Studio usando o AWS CLI](#example-notebook-msk-create-api)

**nota**  
Você também pode criar um bloco de anotações do Studio a partir do console Amazon MSK escolhendo um cluster existente e, em seguida, escolhendo **Processar dados em tempo real**.

### Crie um notebook Studio usando o Console de gerenciamento da AWS
<a name="example-notebook-create-msk-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**  
Para criar um bloco de anotações do Studio a partir dos consoles Amazon MSK ou Kinesis Data Streams, selecione seu cluster Amazon MSK de entrada ou fluxo de dados do Kinesis e escolha **Processar dados em tempo real.**

1. Na página **‬Criar bloco de anotações do Studio**, forneça as seguintes informações:
   + Insira **MyNotebook** para **Nome do bloco de anotações do Studio**.
   + 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 a guia **Configuração**. Na seção **Redes**, selecione **Editar**.

1. Na MyNotebook página **Editar rede para**, escolha a **configuração de VPC com base no cluster Amazon MSK**. Selecione seu cluster Amazon MSK para **Cluster Amazon MSK**. Escolha **Salvar alterações**.

1. Na **MyNotebook**página, escolha **Executar**. Aguarde até que o **Status** mostre **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 se você tem as informações a seguir. Você precisa desses valores para criar seu aplicativo.
   + O ID da sua conta.
   + A sub-rede IDs e o ID do grupo de segurança da Amazon VPC que contém seu cluster Amazon MSK.

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
           },
           "VpcConfigurations": [
               {
                   "SubnetIds": [
                       "SubnetID 1",
                       "SubnetID 2",
                       "SubnetID 3"
                   ],
                   "SecurityGroupIds": [
                       "VPC Security Group ID"
                   ]
               }
           ],
           "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ê deverá ver um resultado semelhante ao apresentado a seguir, mostrando os detalhes do seu novo bloco de anotações do Studio:

   ```
   {
       "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 seu cluster Amazon MSK
<a name="example-notebook-msk-send"></a>

Nesta seção, você executa um script Python em seu EC2 cliente Amazon para enviar dados para sua fonte de dados Amazon MSK.

1. Conecte-se ao seu EC2 cliente Amazon.

1. Execute os comandos a seguir para instalar o Python versão 3, o Pip e o pacote Kafka para Python e confirme as ações:

   ```
   sudo yum install python37
   curl -O https://bootstrap.pypa.io/get-pip.py
   python3 get-pip.py --user
   pip install kafka-python
   ```

1. Configure o AWS CLI em sua máquina cliente digitando o seguinte comando:

   ```
   aws configure
   ```

   Forneça as credenciais da sua conta e **us-east-1** para `region`.

1. Crie um arquivo chamado `stock.py` com o conteúdo a seguir. Substitua o valor da amostra pela string Bootstrap Brokers do seu cluster Amazon MSK e atualize o nome do tópico se o tópico não for: **AWS KafkaTutorialTopic**

   ```
   from kafka import KafkaProducer
   import json
   import random
   from datetime import datetime
   
   BROKERS = "<<Bootstrap Broker List>>"
   producer = KafkaProducer(
       bootstrap_servers=BROKERS,
       value_serializer=lambda v: json.dumps(v).encode('utf-8'),
       retry_backoff_ms=500,
       request_timeout_ms=20000,
       security_protocol='PLAINTEXT')
   
   
   def getStock():
       data = {}
       now = datetime.now()
       str_now = now.strftime("%Y-%m-%d %H:%M:%S")
       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 =getStock()
       # print(data)
       try:
           future = producer.send("AWSKafkaTutorialTopic", value=data)
           producer.flush()
           record_metadata = future.get(timeout=10)
           print("sent event to Kafka! topic {} partition {} offset {}".format(record_metadata.topic, record_metadata.partition, record_metadata.offset))
       except Exception as e:
           print(e.with_traceback())
   ```

1. Execute o script com o comando a seguir:

   ```
   $ python3 stock.py
   ```

1. Deixe o script em execução enquanto você conclui a seção a seguir.

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

Nesta seção, você usa seu bloco de anotações do Studio para consultar dados do seu cluster Amazon MSK.

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 **Nova 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.

   O aplicativo exibe dados do cluster Amazon MSK.

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/).