

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Creazione di un notebook Studio con il flusso di dati Kinesis
<a name="example-notebook-streams"></a>

Questo tutorial descrive come creare un notebook Studio che utilizza un flusso di dati Kinesis come origine.

**Topics**
+ [

## Completa i prerequisiti
](#example-notebook-streams-setup)
+ [

## Crea una tabella AWS Glue
](#example-notebook-streams-glue)
+ [

## Creazione di un notebook Studio con il flusso di dati Kinesis
](#example-notebook-streams-create)
+ [

## Invio di dati al flusso di dati Kinesis
](#example-notebook-streams-send)
+ [

## Test del notebook Studio
](#example-notebook-streams-test)

## Completa i prerequisiti
<a name="example-notebook-streams-setup"></a>

Prima di creare un notebook Studio, è necessario creare un flusso di dati Kinesis (`ExampleInputStream`). L'applicazione utilizza questo flusso come origine dell'applicazione.

Puoi creare questo flusso utilizzando la console Amazon Kinesis o il comando AWS CLI seguente. Per istruzioni sulla console, consulta [Creazione e aggiornamento dei flussi di dati](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html) nella *Guida per gli sviluppatori del flusso di dati Amazon Kinesis*. Assegna un nome al flusso **ExampleInputStream** e imposta il **Numero di partizioni aperte** su **1**.

Per creare lo stream (`ExampleInputStream`) utilizzando il AWS CLI, usa il seguente comando Amazon Kinesis `create-stream` AWS CLI .

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

## Crea una tabella AWS Glue
<a name="example-notebook-streams-glue"></a>

Il notebook Studio utilizza un database [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html) per i metadati sull'origine dati del flusso di dati Kinesis.

**Nota**  
Puoi creare prima il database manualmente oppure lasciare che il servizio gestito per Apache Flink lo crei automaticamente quando viene creato il notebook. Allo stesso modo, è possibile creare manualmente la tabella come descritto in questa sezione oppure utilizzare il codice del connettore di creazione tabella per il servizio gestito per Apache Flink nel notebook all'interno di Apache Zeppelin per creare la tabella tramite un'istruzione DDL. Puoi quindi effettuare il check-in AWS Glue per assicurarti che la tabella sia stata creata correttamente.

**Creazione di una tabella**

1. Accedi a Console di gestione AWS e apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).

1. Se non disponi già di un AWS Glue database, scegli **Database** dalla barra di navigazione a sinistra. Scegli **Aggiungi database**. Nella finestra **Aggiungi database**, inserisci **default** per **Nome database**. Scegli **Create (Crea) **.

1. Nella barra di navigazione a sinistra, seleziona **Tabelle**. Nella pagina **Tabelle**, scegli **Aggiungi tabelle** > **Aggiungi tabella manualmente**.

1. Nella pagina **Imposta le proprietà della tabella**, inserisci **stock** per **Nome tabella**. Assicurati di selezionare il database creato in precedenza. Scegli **Next (Successivo)**.

1. Nella pagina **Aggiungi un datastore**, scegli **Kinesis**. Per **Nome del flusso**, inserisci **ExampleInputStream**. Per **URL di origine di Kinesis**, inserisci **https://kinesis.us-east-1.amazonaws.com**. Se copi e incolli l'**URL di origine di Kinesis**, assicurati di eliminare gli spazi iniziali o finali. Scegli **Next (Successivo)**.

1. Nella pagina **Classificazione**, scegli **JSON**. Scegli **Next (Successivo)**.

1. Nella pagina **Definisci uno schema**, scegli Aggiungi colonna per aggiungere una colonna. Aggiungi colonne con le seguenti proprietà:    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/example-notebook-streams.html)

   Scegli **Next (Successivo)**.

1. Nella pagina successiva, verifica le impostazioni e scegli **Fine.**

1. Scegli la tabella appena creata dall'elenco delle tabelle.

1. Scegli **Modifica tabella** e aggiungi una proprietà con la chiave `managed-flink.proctime` e il valore `proctime`.

1. Scegli **Applica**.

## Creazione di un notebook Studio con il flusso di dati Kinesis
<a name="example-notebook-streams-create"></a>

Ora che hai creato le risorse utilizzate dall'applicazione, puoi creare il notebook Studio. 

**Topics**
+ [

### Crea un taccuino Studio utilizzando il Console di gestione AWS
](#example-notebook-create-streams-console)
+ [

### Crea un taccuino Studio utilizzando il AWS CLI
](#example-notebook-msk-create-api)

### Crea un taccuino Studio utilizzando il Console di gestione AWS
<a name="example-notebook-create-streams-console"></a>

1. [Aprire la console Managed Service for Apache Flink a casa https://console.aws.amazon.com/managed-flink/? region=us-east-1\$1/applicazioni/dashboard.](https://console.aws.amazon.com/managed-flink/home?region=us-east-1#/applications/dashboard) 

1. Nella pagina **Applicazioni del servizio gestito per Apache Flink**, scegli la scheda **Studio**. Scegli **Crea notebook Studio**.
**Nota**  
Puoi anche creare un notebook Studio dalle console Amazon MSK o del flusso di dati Kinesis selezionando il cluster Amazon MSK o il flusso di dati Kinesis di input e scegliendo **Elabora dati in tempo reale**.

1. Nella pagina **Crea notebook Studio**, immetti le seguenti informazioni:
   + Inserisci **MyNotebook** per il nome del notebook.
   + Scegli l'**impostazione predefinita** per il **database AWS Glue**.

   Scegli **Crea notebook Studio**.

1. **Nella pagina, scegli Esegui. **MyNotebook**** Attendi che lo **stato** mostri **In esecuzione**. Si applicano costi quando il notebook è in funzione.

### Crea un taccuino Studio utilizzando il AWS CLI
<a name="example-notebook-msk-create-api"></a>

Per creare il tuo taccuino Studio utilizzando AWS CLI, procedi come segue:

1. Verifica l'ID del tuo account. Questo valore è necessario per creare l'applicazione.

1. Crea il ruolo `arn:aws:iam::AccountID:role/ZeppelinRole` e aggiungi le seguenti autorizzazioni al ruolo creato automaticamente dalla console.

   `"kinesis:GetShardIterator",`

   `"kinesis:GetRecords",`

   `"kinesis:ListShards"`

1. Crea un file denominato `create.json` con i seguenti contenuti. Sostituisci i valori segnaposto con le tue informazioni.

   ```
   {
       "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. Per creare l'applicazione, esegui il comando riportato di seguito:

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

1. Una volta completata l'esecuzione del comando, visualizzerai un output che mostra i dettagli per il nuovo notebook Studio. Di seguito è riportato un esempio di output.

   ```
   {
       "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. Per avviare l'applicazione, esegui il comando riportato di seguito. Sostituisci il valore di esempio con il tuo ID account.

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

## Invio di dati al flusso di dati Kinesis
<a name="example-notebook-streams-send"></a>

Per inviare i dati di test al flusso di dati Kinesis, procedi come segue:

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

1. Scegli **Crea un utente Cognito** con. CloudFormation

1. La CloudFormation console si apre con il modello Kinesis Data Generator. Scegli **Next (Successivo)**.

1. Nella pagina **Specifica i dettagli dello stack**, inserisci il nome utente e la password per l'utente Cognito. Scegli **Next (Successivo)**.

1. Nella pagina **Configura opzioni dello stack**, scegli **Successivo**.

1. Nella pagina **Review Kinesis-Data-Generator-Cognito -User**, scegli l'opzione **Riconosco che AWS CloudFormation potrebbe creare le risorse IAM**. casella di controllo. Scegli **Crea stack**.

1. Attendi che lo CloudFormation stack finisca di essere creato. **Una volta completato lo stack, apri lo stack **Kinesis-Data-Generator-Cognito-User nella console e scegli la scheda Output**. CloudFormation ** **KinesisDataGeneratorUrl**Apri l'URL elencato per il valore di output.

1. Nella pagina **Amazon Kinesis Data Generator**, accedi con le credenziali create nel passaggio 4.

1. Nella pagina successiva, specifica i seguenti valori:    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/example-notebook-streams.html)

   Per **Modello di record**, incolla il seguente codice:

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

1. Scegli **Invia dati**.

1. Il generatore invierà dati al flusso di dati Kinesis. 

   Lascia il generatore in esecuzione mentre completi la sezione successiva.

## Test del notebook Studio
<a name="example-notebook-streams-test"></a>

In questa sezione, il notebook Studio viene utilizzato per eseguire query sui dati del flusso di dati Kinesis.

1. [Aprire la console Managed Service for Apache Flink a casa https://console.aws.amazon.com/managed-flink/? region=us-east-1\$1/applicazioni/dashboard.](https://console.aws.amazon.com/managed-flink/home?region=us-east-1#/applications/dashboard)

1. Nella pagina **Applicazioni del servizio gestito per Apache Flink**, scegli la scheda **Notebook Studio**. Scegli **MyNotebook**.

1. **Nella pagina, scegli Apri in Apache Zeppelin. **MyNotebook****

   L'interfaccia Apache Zeppelin viene aperta in una nuova scheda.

1. Nella sezione **Ti diamo il benvenuto su Zeppelin\$1**, scegli **Nota Zeppelin**.

1. Nella pagina **Nota Zeppelin**, inserisci la seguente query in una nuova nota:

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

   Seleziona l'icona dell'esecuzione.

   Dopo un breve periodo, la nota visualizza i dati del flusso di dati Kinesis.

Per aprire il pannello di controllo di Apache Flink per la tua applicazione e visualizzare gli aspetti operativi, scegli **PROCESSO FLINK**. Per ulteriori informazioni sul pannello di controllo di Flink, consulta [Pannello di controllo di Apache Flink](https://docs.aws.amazon.com/managed-flink/latest/java/how-dashboard.html) nella [Guida per gli sviluppatori del servizio gestito per Apache Flink](https://docs.aws.amazon.com/).

Per altri esempi di query Streaming SQL in Flink, consulta [Query](https://nightlies.apache.org/flink/flink-docs-release-1.15/dev/table/sql/queries.html) nella [documentazione di Apache Flink](https://nightlies.apache.org/flink/flink-docs-release-1.15/).