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à. # Inizia a usare Amazon Managed Service per Apache Flink (DataStream API) Questa sezione presenta i concetti fondamentali di Managed Service for Apache Flink e l'implementazione di un'applicazione in Java utilizzando l'API. DataStream Descrive le opzioni disponibili per la creazione e il test delle applicazioni. Fornisce inoltre istruzioni per l'installazione degli strumenti necessari per completare i tutorial di questa guida e creare la tua prima applicazione. **Topics** + [ ## Esamina i componenti dell'applicazione Managed Service for Apache Flink ](#getting-started-components) + [ ## Soddisfa i prerequisiti per completare gli esercizi ](#setting-up-prerequisites) + [ # Configura un AWS account e crea un utente amministratore ](setting-up.md) + [ # Configura il () AWS Command Line Interface AWS CLI ](setup-awscli.md) + [ # Crea ed esegui un servizio gestito per l'applicazione Apache Flink ](get-started-exercise.md) + [ # Pulisci le risorse AWS ](getting-started-cleanup.md) + [ # Esplora risorse aggiuntive ](getting-started-next-steps.md) ## Esamina i componenti dell'applicazione Managed Service for Apache Flink **Nota** Amazon Managed Service per Apache Flink supporta tutti i linguaggi Apache Flink APIs e potenzialmente tutti i linguaggi JVM. [Per ulteriori informazioni, consulta Flink's. APIs](https://nightlies.apache.org/flink/flink-docs-release-1.20/docs/concepts/overview/#flinks-apis) A seconda dell'API scelta, la struttura dell'applicazione e l'implementazione sono leggermente diverse. Questo tutorial introduttivo illustra l'implementazione delle applicazioni che utilizzano l' DataStream API in Java. Per elaborare i dati, l'applicazione Managed Service for Apache Flink utilizza un'applicazione Java che elabora l'input e produce l'output utilizzando il runtime Apache Flink. Una tipica applicazione Managed Service for Apache Flink ha i seguenti componenti: + **Proprietà di runtime:** è possibile utilizzare *le proprietà di runtime* per passare i parametri di configurazione all'applicazione e modificarli senza modificare e ripubblicare il codice. + **Fonti:** *l'applicazione utilizza dati da una o più fonti.* Una fonte utilizza un [connettore](https://nightlies.apache.org/flink/flink-docs-release-1.20/docs/connectors/table/overview/) per leggere i dati da un sistema esterno, come un flusso di dati Kinesis o un bucket Kafka. Per ulteriori informazioni, consulta [Aggiungi sorgenti di dati in streaming](how-sources.md). + **Operatori:** l'applicazione elabora i dati utilizzando uno o più *operatori*. Un operatore può trasformare, arricchire o aggregare i dati. Per ulteriori informazioni, consulta [Operatori](how-operators.md). + **Sinks:** *l'applicazione invia i dati a fonti esterne tramite i sink.* Un sink utilizza un [connettore](https://nightlies.apache.org/flink/flink-docs-release-1.20/docs/connectors/table/overview/) v per inviare dati a un flusso di dati Kinesis, un argomento di Kafka, Amazon S3 o un database relazionale. Puoi anche usare un connettore speciale per stampare l'output solo a scopo di sviluppo. Per ulteriori informazioni, consulta [Scrivi dati usando i sink](how-sinks.md). L'applicazione richiede alcune *dipendenze esterne*, come i connettori Flink utilizzati dall'applicazione o potenzialmente una libreria Java. Per essere eseguita in Amazon Managed Service for Apache Flink, l'applicazione deve essere impacchettata insieme alle dipendenze in un *fat-jar* e caricata in un bucket Amazon S3. Potrai quindi creare un'applicazione del servizio gestito per Apache Flink. Devi passare la posizione del pacchetto di codice, insieme a qualsiasi altro parametro di configurazione di runtime. Questo tutorial dimostra come usare Apache Maven per creare pacchetti dell'applicazione e come eseguire l'applicazione localmente nell'IDE di tua scelta. ## Soddisfa i prerequisiti per completare gli esercizi Per completare le fasi in questa guida, è richiesto quanto segue: + [Client Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git). Installa il client Git, se non l'hai già fatto. + [Java Development Kit (JDK) versione 11](https://www.oracle.com/java/technologies/downloads/#java11). Installa un Java JDK 11 e imposta la variabile di `JAVA_HOME` ambiente in modo che punti alla posizione di installazione di JDK. Se non disponi di un JDK 11, puoi utilizzare [Amazon Coretto 11](https://docs.aws.amazon.com/corretto/latest/corretto-11-ug/what-is-corretto-11.html) o qualsiasi altro JDK standard a tua scelta. + Per verificare che il JDK sia installato correttamente, esegui il comando seguente. L'output sarà diverso se utilizzi un JDK diverso da Amazon Corretto. Assicurati che la versione sia 11.x. ``` $ java --version openjdk 11.0.23 2024-04-16 LTS OpenJDK Runtime Environment Corretto-11.0.23.9.1 (build 11.0.23+9-LTS) OpenJDK 64-Bit Server VM Corretto-11.0.23.9.1 (build 11.0.23+9-LTS, mixed mode) ``` + [Apache Maven](https://maven.apache.org/). Installa Apache Maven se non l'hai già fatto. Per informazioni su come installarlo, consulta [Installazione](https://maven.apache.org/install.html) di Apache Maven. + Per testare l'installazione Apache Maven, immetti quanto segue: ``` $ mvn -version ``` + IDE per lo sviluppo locale. Ti consigliamo di utilizzare un ambiente di sviluppo come [Eclipse Java Neon](https://www.eclipse.org/downloads/packages/release/neon/3) o [IntelliJ IDEA](https://www.jetbrains.com/idea/) per sviluppare e compilare l'applicazione. + Per testare l'installazione Apache Maven, immetti quanto segue: ``` $ mvn -version ``` Per iniziare, vai alla pagina [Configura un AWS account e crea un utente amministratore](setting-up.md). # Configura un AWS account e crea un utente amministratore Prima di utilizzare il servizio gestito per Apache Flink per la prima volta, completa le seguenti attività: ## Registrati per un Account AWS Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno. **Per iscriverti a un Account AWS** 1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup) 1. Segui le istruzioni online. Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono. Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks). AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**. ## Crea un utente con accesso amministrativo Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane. **Proteggi i tuoi Utente root dell'account AWS** 1. Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password. Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *. 1. Abilita l’autenticazione a più fattori (MFA) per l’utente root. Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*. **Crea un utente con accesso amministrativo** 1. Abilita il Centro identità IAM. Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *. 1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente. Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*. **Accesso come utente amministratore** + Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM. Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*. **Assegnazione dell’accesso ad altri utenti** 1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo. Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *. 1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On). Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *. ## Concessione dell'accesso programmatico Gli utenti hanno bisogno di un accesso programmatico se vogliono interagire con l' AWS Console di gestione AWS esterno di. Il modo per concedere l'accesso programmatico dipende dal tipo di utente che accede. AWS Per fornire agli utenti l’accesso programmatico, scegli una delle seguenti opzioni. **** | Quale utente necessita dell’accesso programmatico? | Per | Come | | --- | --- | --- | | IAM | (Consigliato) Utilizza le credenziali della console come credenziali temporanee per firmare le richieste programmatiche a,, o. AWS CLI AWS SDKs AWS APIs | Segui le istruzioni per l’interfaccia che desideri utilizzare. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/setting-up.html) | | Identità della forza lavoro (Utenti gestiti nel centro identità IAM) | Utilizza credenziali temporanee per firmare richieste programmatiche a AWS CLI, AWS SDKs, o. AWS APIs | Segui le istruzioni per l’interfaccia che desideri utilizzare. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/setting-up.html) | | IAM | Utilizza credenziali temporanee per firmare le richieste programmatiche a AWS CLI, AWS SDKs, o. AWS APIs | Seguendo le istruzioni riportate in [Utilizzo delle credenziali temporanee con le AWS risorse nella Guida per](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) l'utente IAM. | | IAM | (Non consigliato)Utilizza credenziali a lungo termine per firmare richieste programmatiche a AWS CLI,, AWS SDKs o. AWS APIs | Segui le istruzioni per l’interfaccia che desideri utilizzare. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/setting-up.html) | ## Fase succcessiva [Configura il () AWS Command Line Interface AWS CLI](setup-awscli.md) # Configura il () AWS Command Line Interface AWS CLI In questo passaggio, si scarica e si configura AWS CLI per l'utilizzo con Managed Service for Apache Flink. **Nota** Gli esercizi sulle Nozioni di base di questa guida presuppongono che tu disponga di credenziali di amministratore (`adminuser`) nell'account per eseguire le operazioni. **Nota** Se è già AWS CLI installato, potrebbe essere necessario eseguire l'aggiornamento per ottenere le funzionalità più recenti. Per ulteriori informazioni, consulta [Installazione dell' AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) nella *Guida per l'utente dell'AWS Command Line Interface *. Per verificare la versione di AWS CLI, esegui il seguente comando: ``` aws --version ``` Gli esercizi di questo tutorial richiedono la seguente AWS CLI versione o successiva: ``` aws-cli/1.16.63 ``` **Per configurare il AWS CLI** 1. Scarica e configura la AWS CLI. Per le istruzioni, consulta i seguenti argomenti nella *Guida per l'utente dell'AWS Command Line Interface *: + [Installazione dell' AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) + [Configurazione della AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) 1. Aggiungere un profilo denominato per l'utente amministratore nel AWS CLI `config` file. Puoi usare questo profilo quando esegui i comandi della AWS CLI . Per ulteriori informazioni sui profili denominati, consulta [Profili denominati](https://docs.aws.amazon.com/cli/latest/userguide/cli-multiple-profiles.html) in *Guida per l'utente dell'AWS Command Line Interface *. ``` [profile adminuser] aws_access_key_id = adminuser access key ID aws_secret_access_key = adminuser secret access key region = aws-region ``` Per un elenco delle AWS regioni disponibili, consulta [Regioni ed endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html) in. *Riferimenti generali di Amazon Web Services* **Nota** Il codice e i comandi di esempio in questo tutorial utilizzano la regione us-east-1 Stati Uniti orientali (Virginia settentrionale). Per utilizzare una regione diversa, sostituisci la regione nel codice e nei comandi di questo tutorial con quella che desideri utilizzare. 1. Verifica la configurazione digitando il comando help riportato di seguito al prompt dei comandi: ``` aws help ``` Dopo aver impostato un AWS account AWS CLI, potete provare l'esercizio successivo, in cui configurate un'applicazione di esempio e verificate la configurazione. end-to-end ## Approfondimenti [Crea ed esegui un servizio gestito per l'applicazione Apache Flink](get-started-exercise.md) # Crea ed esegui un servizio gestito per l'applicazione Apache Flink In questo passaggio, crei un servizio gestito per l'applicazione Apache Flink con flussi di dati Kinesis come origine e sink. **Topics** + [ ## Crea risorse dipendenti ](#get-started-exercise-0) + [ ## Configurazione dell'ambiente di sviluppo locale ](#get-started-exercise-2) + [ ## Scarica ed esamina il codice Java per lo streaming di Apache Flink ](#get-started-exercise-5) + [ ## Scrivi record di esempio nel flusso di input ](#get-started-exercise-5-4) + [ ## Esegui l'applicazione localmente ](#get-started-exercise-5-run) + [ ## Osserva i dati di input e output nei flussi Kinesis ](#get-started-exercise-input-output) + [ ## Interrompi l'esecuzione locale dell'applicazione ](#get-started-exercise-stop) + [ ## Compila e impacchetta il codice dell'applicazione ](#get-started-exercise-5-5) + [ ## Carica il file JAR del codice dell'applicazione ](#get-started-exercise-6) + [ ## Crea e configura l'applicazione Managed Service for Apache Flink ](#get-started-exercise-7) + [ ## Approfondimenti ](#get-started-exercise-next-step-4) ## Crea risorse dipendenti Prima di creare un'applicazione del servizio gestito per Apache Flink per questo esercizio, è necessario creare le seguenti risorse dipendenti: + Due flussi di dati Kinesis per input e output + Un bucket Amazon S3 per archiviare il codice dell'applicazione **Nota** Questo tutorial presuppone che l'applicazione venga distribuita nella regione us-east-1 Stati Uniti orientali (Virginia settentrionale). Se utilizzi un'altra regione, adatta tutti i passaggi di conseguenza. ### Crea due flussi di dati Amazon Kinesis Prima di creare un'applicazione del servizio gestito per Apache Flink per questo esercizio, crea due flussi di dati Kinesis (`ExampleInputStream` e `ExampleOutputStream`). L'applicazione utilizza questi flussi per i flussi di origine e di destinazione dell'applicazione. Puoi creare questi stream utilizzando la console Amazon Kinesis o il AWS CLI seguente comando. 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*. Per creare gli stream utilizzando AWS CLI, usa i seguenti comandi, adattandoli alla regione utilizzata per la tua applicazione. **Per creare i flussi di dati (AWS CLI)** 1. Per creare il primo stream (`ExampleInputStream`), usa il seguente comando Amazon Kinesis `create-stream` AWS CLI : ``` $ aws kinesis create-stream \ --stream-name ExampleInputStream \ --shard-count 1 \ --region us-east-1 \ ``` 1. Per creare il secondo stream utilizzato dall'applicazione per scrivere l'output, esegui lo stesso comando, modificando il nome dello stream in`ExampleOutputStream`: ``` $ aws kinesis create-stream \ --stream-name ExampleOutputStream \ --shard-count 1 \ --region us-east-1 \ ``` ### Crea un bucket Amazon S3 per il codice dell'applicazione Puoi creare un bucket Amazon S3 utilizzando la relativa console. [Per informazioni su come creare un bucket Amazon S3 utilizzando la console, consulta [Creating a bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) nella Amazon S3 User Guide.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/) Assegna un nome al bucket Amazon S3 utilizzando un nome univoco globale, ad esempio aggiungendo il tuo nome di accesso. **Nota** Assicurati di creare il bucket nella regione che usi per questo tutorial (us-east-1). ### Altre risorse Quando crei la tua applicazione, Managed Service for Apache Flink crea automaticamente CloudWatch le seguenti risorse Amazon se non esistono già: + Un gruppo di log denominato `/AWS/KinesisAnalytics-java/` + Un flusso di log denominato `kinesis-analytics-log-stream` ## Configurazione dell'ambiente di sviluppo locale Per lo sviluppo e il debug, puoi eseguire l'applicazione Apache Flink sulla tua macchina direttamente dal tuo IDE preferito. Tutte le dipendenze di Apache Flink vengono gestite come normali dipendenze Java utilizzando Apache Maven. **Nota** Sulla tua macchina di sviluppo, devi avere Java JDK 11, Maven e Git installati. [Ti consigliamo di utilizzare un ambiente di sviluppo come [Eclipse Java Neon](https://www.eclipse.org/downloads/packages/release/neon/3) o IntelliJ IDEA.](https://www.jetbrains.com/idea/) Per verificare di soddisfare tutti i prerequisiti, vedere. [Soddisfa i prerequisiti per completare gli esercizi](getting-started.md#setting-up-prerequisites) **Non** è necessario installare un cluster Apache Flink sul computer. ### Autentica la tua sessione AWS L'applicazione utilizza i flussi di dati Kinesis per pubblicare i dati. Quando si esegue localmente, è necessario disporre di una sessione AWS autenticata valida con autorizzazioni di scrittura nel flusso di dati Kinesis. Usa i seguenti passaggi per autenticare la tua sessione: 1. Se non hai configurato il profilo AWS CLI e un profilo denominato con credenziali valide, consulta. [Configura il () AWS Command Line Interface AWS CLI](setup-awscli.md) 1. Verifica che AWS CLI sia configurato correttamente e che gli utenti dispongano delle autorizzazioni per scrivere nel flusso di dati Kinesis pubblicando il seguente record di test: ``` $ aws kinesis put-record --stream-name ExampleOutputStream --data TEST --partition-key TEST ``` 1. Se il tuo IDE ha un plugin con cui integrarti AWS, puoi utilizzarlo per passare le credenziali all'applicazione in esecuzione nell'IDE. Per ulteriori informazioni, vedere [AWS Toolkit for IntelliJ](https://aws.amazon.com/intellij/) IDEA [AWS e Toolkit for Eclipse](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/welcome.html). ## Scarica ed esamina il codice Java per lo streaming di Apache Flink Il codice dell'applicazione Java per questo esempio è disponibile da. GitHub Per scaricare il codice dell'applicazione, esegui le operazioni descritte di seguito: 1. Clona il repository remoto con il comando seguente: ``` git clone https://github.com/aws-samples/amazon-managed-service-for-apache-flink-examples.git ``` 1. Passa alla directory `amazon-managed-service-for-apache-flink-examples/tree/main/java/GettingStarted`. ### Esamina i componenti dell'applicazione L'applicazione è interamente implementata nella `com.amazonaws.services.msf.BasicStreamingJob` classe. Il `main()` metodo definisce il flusso di dati per elaborare i dati di streaming ed eseguirli. **Nota** Per un'esperienza di sviluppo ottimizzata, l'applicazione è progettata per funzionare senza modifiche al codice sia su Amazon Managed Service per Apache Flink che localmente, per lo sviluppo nel tuo IDE. + Per leggere la configurazione di runtime in modo che funzioni durante l'esecuzione in Amazon Managed Service for Apache Flink e nel tuo IDE, l'applicazione rileva automaticamente se è in esecuzione autonoma localmente nell'IDE. In tal caso, l'applicazione carica la configurazione di runtime in modo diverso: 1. Quando l'applicazione rileva che è in esecuzione in modalità autonoma nell'IDE, forma il `application_properties.json` file incluso nella cartella delle **risorse** del progetto. Segue il contenuto del file. 1. Quando l'applicazione viene eseguita in Amazon Managed Service for Apache Flink, il comportamento predefinito carica la configurazione dell'applicazione dalle proprietà di runtime che definirai nell'applicazione Amazon Managed Service for Apache Flink. Per informazioni, consulta [Crea e configura l'applicazione Managed Service for Apache Flink](#get-started-exercise-7). ``` private static Map loadApplicationProperties(StreamExecutionEnvironment env) throws IOException { if (env instanceof LocalStreamEnvironment) { LOGGER.info("Loading application properties from '{}'", LOCAL_APPLICATION_PROPERTIES_RESOURCE); return KinesisAnalyticsRuntime.getApplicationProperties( BasicStreamingJob.class.getClassLoader() .getResource(LOCAL_APPLICATION_PROPERTIES_RESOURCE).getPath()); } else { LOGGER.info("Loading application properties from Amazon Managed Service for Apache Flink"); return KinesisAnalyticsRuntime.getApplicationProperties(); } } ``` + Il `main()` metodo definisce il flusso di dati dell'applicazione e lo esegue. + Inizializza gli ambienti di streaming predefiniti. In questo esempio, mostriamo come creare sia l'API `StreamExecutionEnvironment` da utilizzare con l' DataSteam API sia `StreamTableEnvironment` quello da utilizzare con SQL e l'API Table. I due oggetti di ambiente sono due riferimenti separati allo stesso ambiente di runtime, da utilizzare in modo diverso APIs. ``` StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); ``` + Caricate i parametri di configurazione dell'applicazione. Questo li caricherà automaticamente dalla posizione corretta, a seconda di dove è in esecuzione l'applicazione: ``` Map applicationParameters = loadApplicationProperties(env); ``` + L'applicazione definisce una fonte utilizzando il connettore [Kinesis Consumer](https://nightlies.apache.org/flink/flink-docs-release-1.18/docs/connectors/datastream/kinesis/#kinesis-consumer) per leggere i dati dal flusso di input. La configurazione del flusso di input è definita in `PropertyGroupId` =`InputStream0`. Il nome e la regione del flusso si trovano nelle proprietà denominate `stream.name` `aws.region` rispettivamente. Per semplicità, questa fonte legge i record come una stringa. ``` private static FlinkKinesisConsumer createSource(Properties inputProperties) { String inputStreamName = inputProperties.getProperty("stream.name"); return new FlinkKinesisConsumer<>(inputStreamName, new SimpleStringSchema(), inputProperties); } ... public static void main(String[] args) throws Exception { ... SourceFunction source = createSource(applicationParameters.get("InputStream0")); DataStream input = env.addSource(source, "Kinesis Source"); ... } ``` + L'applicazione definisce quindi un sink utilizzando il connettore [Kinesis Streams Sink](https://nightlies.apache.org/flink/flink-docs-release-1.18/docs/connectors/datastream/kinesis/#kinesis-streams-sink) per inviare i dati al flusso di output. Il nome e la regione del flusso di output sono definiti in `PropertyGroupId` =`OutputStream0`, in modo simile al flusso di input. Il sink è collegato direttamente all'unità interna `DataStream` che riceve i dati dalla fonte. In un'applicazione reale, si verifica una trasformazione tra sorgente e sink. ``` private static KinesisStreamsSink createSink(Properties outputProperties) { String outputStreamName = outputProperties.getProperty("stream.name"); return KinesisStreamsSink.builder() .setKinesisClientProperties(outputProperties) .setSerializationSchema(new SimpleStringSchema()) .setStreamName(outputStreamName) .setPartitionKeyGenerator(element -> String.valueOf(element.hashCode())) .build(); } ... public static void main(String[] args) throws Exception { ... Sink sink = createSink(applicationParameters.get("OutputStream0")); input.sinkTo(sink); ... } ``` + Infine, esegui il flusso di dati che hai appena definito. Questa deve essere l'ultima istruzione del `main()` metodo, dopo aver definito tutti gli operatori richiesti dal flusso di dati: ``` env.execute("Flink streaming Java API skeleton"); ``` ### Utilizzate il file pom.xml Il file pom.xml definisce tutte le dipendenze richieste dall'applicazione e configura il plugin Maven Shade per creare il fat-jar che contiene tutte le dipendenze richieste da Flink. + `provided`Alcune dipendenze hanno un ambito. Queste dipendenze sono disponibili automaticamente quando l'applicazione viene eseguita in Amazon Managed Service for Apache Flink. Sono necessarie per compilare l'applicazione o per eseguirla localmente nel tuo IDE. Per ulteriori informazioni, consulta [Esegui l'applicazione localmente](#get-started-exercise-5-run). Assicurati di utilizzare la stessa versione di Flink del runtime che utilizzerai in Amazon Managed Service for Apache Flink. ``` org.apache.flink flink-clients ${flink.version} provided org.apache.flink flink-streaming-java ${flink.version} provided ``` + È necessario aggiungere ulteriori dipendenze Apache Flink al pom con l'ambito predefinito, come il connettore [Kinesis](https://nightlies.apache.org/flink/flink-docs-master/docs/connectors/datastream/kinesis/) utilizzato da questa applicazione. Per ulteriori informazioni, consulta [Usa i connettori Apache Flink](how-flink-connectors.md). È inoltre possibile aggiungere eventuali dipendenze Java aggiuntive richieste dall'applicazione. ``` org.apache.flink flink-connector-kinesis ${aws.connector.version} ``` + Il plugin Maven Java Compiler assicura che il codice sia compilato con Java 11, la versione JDK attualmente supportata da Apache Flink. + Il plugin Maven Shade racchiude il fat-jar, escludendo alcune librerie fornite dal runtime. Inoltre specifica due trasformatori: e. `ServicesResourceTransformer` `ManifestResourceTransformer` Quest'ultimo configura la classe contenente il `main` metodo per avviare l'applicazione. Se rinomini la classe principale, non dimenticare di aggiornare questo trasformatore. + ``` org.apache.maven.plugins maven-shade-plugin ... com.amazonaws.services.msf.BasicStreamingJob ... ``` ## Scrivi record di esempio nel flusso di input In questa sezione, invierai record di esempio allo stream per l'elaborazione dell'applicazione. Sono disponibili due opzioni per generare dati di esempio, utilizzando uno script Python o il [Kinesis](https://github.com/awslabs/amazon-kinesis-data-generator) Data Generator. ### Genera dati di esempio usando uno script Python Puoi usare uno script Python per inviare record di esempio allo stream. **Nota** Per eseguire questo script Python, devi usare Python 3.x e avere installata la libreria SDK [AWS for Python](https://aws.amazon.com/developer/language/python/) (Boto). **Per iniziare a inviare i dati di test al flusso di input Kinesis:** 1. Scarica lo script `stock.py` Python del generatore di [dati dal repository Data generator GitHub ](https://github.com/aws-samples/amazon-managed-service-for-apache-flink-examples/tree/main/python/data-generator). 1. Esegui lo script `stock.py`: ``` $ python stock.py ``` Mantieni lo script in esecuzione mentre completi il resto del tutorial. Ora puoi eseguire la tua applicazione Apache Flink. ### Generazione di dati di esempio utilizzando Kinesis Data Generator In alternativa all'utilizzo dello script Python, puoi usare [Kinesis Data Generator](https://github.com/awslabs/amazon-kinesis-data-generator), disponibile anche in una [versione ospitata](https://awslabs.github.io/amazon-kinesis-data-generator/web/producer.html), per inviare dati di esempio casuali allo stream. Kinesis Data Generator viene eseguito nel browser e non è necessario installare nulla sul computer. **Per configurare ed eseguire Kinesis Data Generator:** 1. Segui le istruzioni nella [documentazione di Kinesis Data Generator](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html) per configurare l'accesso allo strumento. Eseguirai un CloudFormation modello che imposta un utente e una password. 1. Accedi a Kinesis Data Generator tramite l'URL generato dal CloudFormation modello. Puoi trovare l'URL nella scheda **Output** dopo aver completato il CloudFormation modello. 1. Configura il generatore di dati: + **Regione:** Seleziona la regione che stai utilizzando per questo tutorial: us-east-1 + **Stream/flusso di consegna:** seleziona il flusso di input che l'applicazione utilizzerà: `ExampleInputStream` + **Record al secondo**: 100 + **Modello di registrazione:** copia e incolla il seguente modello: ``` { "event_time" : "{{date.now("YYYY-MM-DDTkk:mm:ss.SSSSS")}}, "ticker" : "{{random.arrayElement( ["AAPL", "AMZN", "MSFT", "INTC", "TBV"] )}}", "price" : {{random.number(100)}} } ``` 1. Prova il modello: scegli **Modello di test** e verifica che il record generato sia simile al seguente: ``` { "event_time" : "2024-06-12T15:08:32.04800, "ticker" : "INTC", "price" : 7 } ``` 1. Avvia il generatore di dati: scegli **Seleziona Invia dati**. Kinesis Data Generator sta ora inviando dati a. `ExampleInputStream` ## Esegui l'applicazione localmente Puoi eseguire ed eseguire il debug dell'applicazione Flink localmente nel tuo IDE. **Nota** Prima di continuare, verificate che i flussi di input e output siano disponibili. Per informazioni, consulta [Crea due flussi di dati Amazon Kinesis](#get-started-exercise-1). Inoltre, verifica di disporre dell'autorizzazione per leggere e scrivere da entrambi gli stream. Per informazioni, consulta [Autentica la tua sessione AWS](#get-started-exercise-2-5). La configurazione dell'ambiente di sviluppo locale richiede Java 11 JDK, Apache Maven e un IDE per lo sviluppo in Java. Verifica di soddisfare i prerequisiti richiesti. Per informazioni, consulta [Soddisfa i prerequisiti per completare gli esercizi](getting-started.md#setting-up-prerequisites). ### Importa il progetto Java nel tuo IDE Per iniziare a lavorare sull'applicazione nel tuo IDE, devi importarla come progetto Java. Il repository che avete clonato contiene diversi esempi. Ogni esempio è un progetto separato. Per questo tutorial, importa il contenuto della `./java/GettingStarted` sottodirectory nel tuo IDE. Inserisci il codice come progetto Java esistente usando Maven. **Nota** Il processo esatto per importare un nuovo progetto Java varia a seconda dell'IDE in uso. ### Controllate la configurazione locale dell'applicazione Quando viene eseguita localmente, l'applicazione utilizza la configurazione contenuta nel `application_properties.json` file nella cartella delle risorse del progetto sotto`./src/main/resources`. È possibile modificare questo file per utilizzare diversi nomi o regioni di stream Kinesis. ``` [ { "PropertyGroupId": "InputStream0", "PropertyMap": { "stream.name": "ExampleInputStream", "flink.stream.initpos": "LATEST", "aws.region": "us-east-1" } }, { "PropertyGroupId": "OutputStream0", "PropertyMap": { "stream.name": "ExampleOutputStream", "aws.region": "us-east-1" } } ] ``` ### Configura la configurazione di esecuzione dell'IDE Puoi eseguire ed eseguire il debug dell'applicazione Flink dal tuo IDE direttamente eseguendo la classe principale`com.amazonaws.services.msf.BasicStreamingJob`, come faresti con qualsiasi applicazione Java. Prima di eseguire l'applicazione, è necessario configurare la configurazione Run. La configurazione dipende dall'IDE in uso. Ad esempio, vedete le [configurazioni di esecuzione/debug nella](https://www.jetbrains.com/help/idea/run-debug-configuration.html) documentazione di IntelliJ IDEA. In particolare, è necessario configurare quanto segue: 1. **Aggiungi le `provided` dipendenze al classpath**. Ciò è necessario per assicurarsi che le dipendenze con `provided` scope vengano passate all'applicazione durante l'esecuzione locale. Senza questa configurazione, l'applicazione visualizza immediatamente un `class not found` errore. 1. **Passa AWS le credenziali per accedere agli stream Kinesis all'**applicazione. Il modo più veloce è usare [AWS Toolkit for IntelliJ IDEA](https://aws.amazon.com/intellij/). Utilizzando questo plugin IDE nella configurazione Run, è possibile selezionare un profilo specifico AWS . AWS l'autenticazione avviene utilizzando questo profilo. Non è necessario passare direttamente AWS le credenziali. 1. Verifica che l'IDE esegua l'applicazione utilizzando **JDK 11**. ### Esegui l'applicazione nel tuo IDE Dopo aver impostato la configurazione Run per`BasicStreamingJob`, potete eseguirla o eseguire il debug come una normale applicazione Java. **Nota** Non è possibile eseguire il fat-jar generato da Maven direttamente dalla riga di `java -jar ...` comando. Questo jar non contiene le dipendenze principali di Flink necessarie per eseguire l'applicazione in modo autonomo. Quando l'applicazione viene avviata correttamente, registra alcune informazioni sul minicluster autonomo e sull'inizializzazione dei connettori. Seguono una serie di registri INFO e alcuni registri WARN che Flink normalmente emette all'avvio dell'applicazione. ``` 13:43:31,405 INFO com.amazonaws.services.msf.BasicStreamingJob [] - Loading application properties from 'flink-application-properties-dev.json' 13:43:31,549 INFO org.apache.flink.streaming.connectors.kinesis.FlinkKinesisConsumer [] - Flink Kinesis Consumer is going to read the following streams: ExampleInputStream, 13:43:31,676 INFO org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.cpu.cores required for local execution is not set, setting it to the maximal possible value. 13:43:31,676 INFO org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.task.heap.size required for local execution is not set, setting it to the maximal possible value. 13:43:31,676 INFO org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.task.off-heap.size required for local execution is not set, setting it to the maximal possible value. 13:43:31,676 INFO org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.network.min required for local execution is not set, setting it to its default value 64 mb. 13:43:31,676 INFO org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.network.max required for local execution is not set, setting it to its default value 64 mb. 13:43:31,676 INFO org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.managed.size required for local execution is not set, setting it to its default value 128 mb. 13:43:31,677 INFO org.apache.flink.runtime.minicluster.MiniCluster [] - Starting Flink Mini Cluster .... ``` Una volta completata l'inizializzazione, l'applicazione non emette ulteriori voci di registro. **Durante il flusso di dati, non viene emesso alcun registro.** Per verificare se l'applicazione sta elaborando correttamente i dati, puoi controllare i flussi Kinesis di input e output, come descritto nella sezione seguente. **Nota** Il comportamento normale di un'applicazione Flink è quello di non emettere registri relativi al flusso di dati. L'emissione di registri su ogni record può essere utile per il debug, ma può comportare un notevole sovraccarico durante l'esecuzione in produzione. ## Osserva i dati di input e output nei flussi Kinesis Puoi osservare i record inviati al flusso di input da (Python di esempio che genera) o Kinesis Data Generator (link) utilizzando **Data Viewer** nella console Amazon Kinesis. **Per osservare i record** 1. [Apri la console Kinesis in /kinesis. https://console.aws.amazon.com](https://console.aws.amazon.com/kinesis) 1. Verifica che la regione sia la stessa in cui stai eseguendo questo tutorial, che per impostazione predefinita è us-east-1 US East (Virginia settentrionale). Cambia la regione se non corrisponde. 1. Scegli **Data Streams.** 1. Seleziona lo stream che desideri osservare, oppure `ExampleInputStream` `ExampleOutputStream.` 1. Scegli la scheda **Visualizzatore dati**. 1. Scegli uno **Shard**, mantieni **Ultimo** come **posizione iniziale**, quindi scegli **Ottieni record**. Potresti visualizzare l'errore «Nessun record trovato per questa richiesta». In tal caso, scegli **Riprova a recuperare i record**. Vengono visualizzati i record più recenti pubblicati nello stream. 1. Scegli il valore nella colonna Dati per esaminare il contenuto del record in formato JSON. ## Interrompi l'esecuzione locale dell'applicazione Arresta l'esecuzione dell'applicazione nel tuo IDE. L'IDE di solito fornisce un'opzione di «stop». La posizione e il metodo esatti dipendono dall'IDE che stai utilizzando. ## Compila e impacchetta il codice dell'applicazione In questa sezione, si utilizza Apache Maven per compilare il codice Java e impacchettarlo in un file JAR. Puoi compilare e impacchettare il codice usando lo strumento da riga di comando Maven o il tuo IDE. **Per compilare e impacchettare usando la riga di comando Maven:** Passa alla directory contenente il GettingStarted progetto Java ed esegui il seguente comando: ``` $ mvn package ``` **Per compilare e impacchettare usando il tuo IDE:** Esegui `mvn package` dalla tua integrazione IDE Maven. In entrambi i casi, viene creato il seguente file JAR:. `target/amazon-msf-java-stream-app-1.0.jar` **Nota** L'esecuzione di un «progetto di compilazione» dal tuo IDE potrebbe non creare il file JAR. ## Carica il file JAR del codice dell'applicazione In questa sezione, carichi il file JAR creato nella sezione precedente nel bucket Amazon Simple Storage Service (Amazon S3) creato all'inizio di questo tutorial. Se non hai completato questo passaggio, consulta (link). **Per caricare il file JAR del codice dell'applicazione** 1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 1. Scegli il bucket che hai creato in precedenza per il codice dell'applicazione. 1. Scegli **Carica**. 1. Scegliere **Add files (Aggiungi file)**. 1. Passa al file JAR generato nel passaggio precedente:`target/amazon-msf-java-stream-app-1.0.jar`. 1. Scegli **Carica** senza modificare altre impostazioni. **avvertimento** Assicurati di selezionare il file JAR corretto in`/java/GettingStarted/target/amazon-msf-java-stream-app-1.0.jar`. La `target` directory contiene anche altri file JAR che non è necessario caricare. ## Crea e configura l'applicazione Managed Service for Apache Flink È possibile creare ed eseguire un'applicazione del servizio gestito per Apache Flink utilizzando la console o la AWS CLI. Per questo tutorial, utilizzerai la console. **Nota** Quando crei l'applicazione utilizzando la console, le tue risorse AWS Identity and Access Management (IAM) e Amazon CloudWatch Logs vengono create automaticamente. Quando crei l'applicazione utilizzando AWS CLI, crei queste risorse separatamente. **Topics** + [ ### Creazione dell’applicazione ](#get-started-exercise-7-console-create) + [ ### Modifica la policy IAM ](#get-started-exercise-7-console-iam) + [ ### Configura l'applicazione ](#get-started-exercise-7-console-configure) + [ ### Esecuzione dell'applicazione. ](#get-started-exercise-7-console-run) + [ ### Osserva le metriche dell'applicazione in esecuzione ](#get-started-exercise-7-console-stop) + [ ### Osserva i dati di output nei flussi Kinesis ](#get-started-exercise-7-console-output) + [ ### Arresta l'applicazione ](#get-started-exercise-stop) ### Creazione dell’applicazione **Per creare l'applicazione** 1. Accedi a e apri Console di gestione AWS la console Amazon MSF all'indirizzo https://console.aws.amazon.com /flink. 1. Verifica che sia selezionata la regione corretta: us-east-1 Stati Uniti orientali (Virginia settentrionale) 1. **Apri il menu a destra e scegli Applicazioni **Apache Flink, quindi Crea applicazione** di streaming.** In alternativa, scegli **Crea applicazione di streaming** nel contenitore Get started della pagina iniziale. 1. Nella pagina **Crea applicazione di streaming**: + **Scegliete un metodo per configurare l'applicazione di elaborazione dello stream:** scegliete **Crea da zero**. + **Configurazione Apache Flink, versione Application Flink:** scegli **Apache** Flink 1.20. 1. Configura la tua applicazione + **Nome dell'applicazione:** invio**MyApplication**. + **Descrizione:** immettere**My java test app**. + **Accesso alle risorse dell'applicazione:** scegli **Crea/aggiorna il ruolo IAM `kinesis-analytics-MyApplication-us-east-1` con le policy richieste**. 1. Configura il tuo **modello per le impostazioni dell'applicazione** + **Modelli:** scegli **Sviluppo**. 1. Scegli **Crea applicazione di streaming** nella parte inferiore della pagina. **Nota** Quando crei un'applicazione del servizio gestito per Apache Flink tramite la console, hai la possibilità di avere un ruolo e una policy IAM creati per l'applicazione. L'applicazione utilizza questo ruolo e questa policy per accedere alle sue risorse dipendenti. Queste risorse IAM sono denominate utilizzando il nome dell'applicazione e la Regione come segue: Policy: `kinesis-analytics-service-MyApplication-us-east-1` Ruolo: `kinesisanalytics-MyApplication-us-east-1` Amazon Managed Service for Apache Flink era precedentemente noto come Kinesis Data Analytics. Il nome delle risorse che vengono create automaticamente ha il prefisso per garantire la compatibilità con le versioni precedenti. `kinesis-analytics-` ### Modifica la policy IAM Modifica la policy IAM per aggiungere le autorizzazioni per accedere ai flussi di dati Kinesis. **Per modificare la politica** 1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Seleziona **Policy**. Scegli la policy **`kinesis-analytics-service-MyApplication-us-east-1`** creata dalla console nella sezione precedente. 1. Scegli **Modifica**, quindi scegli la scheda **JSON**. 1. Aggiungi alla policy la sezione evidenziata del seguente esempio di policy. Sostituisci l'account di esempio IDs (*012345678901*) con l'ID del tuo account. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "ReadCode", "Effect": "Allow", "Action": [ "s3:GetObject", "s3:GetObjectVersion" ], "Resource": [ "arn:aws:s3:::my-bucket/kinesis-analytics-placeholder-s3-object" ] }, { "Sid": "ListCloudwatchLogGroups", "Effect": "Allow", "Action": [ "logs:DescribeLogGroups" ], "Resource": [ "arn:aws:logs:us-east-1:012345678901:log-group:*" ] }, { "Sid": "ListCloudwatchLogStreams", "Effect": "Allow", "Action": [ "logs:DescribeLogStreams" ], "Resource": [ "arn:aws:logs:us-east-1:012345678901:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*" ] }, { "Sid": "PutCloudwatchLogs", "Effect": "Allow", "Action": [ "logs:PutLogEvents" ], "Resource": [ "arn:aws:logs:us-east-1:012345678901:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream" ] }, { "Sid": "ReadInputStream", "Effect": "Allow", "Action": "kinesis:*", "Resource": "arn:aws:kinesis:us-east-1:012345678901:stream/ExampleInputStream" }, { "Sid": "WriteOutputStream", "Effect": "Allow", "Action": "kinesis:*", "Resource": "arn:aws:kinesis:us-east-1:012345678901:stream/ExampleOutputStream" } ] } ``` ------ 1. Scegli **Avanti** nella parte inferiore della pagina, quindi scegli **Salva modifiche**. ### Configura l'applicazione Modifica la configurazione dell'applicazione per impostare l'elemento del codice dell'applicazione. **Per modificare la configurazione** 1. Nella **MyApplication**pagina, scegli **Configura**. 1. Nella sezione **Posizione del codice dell'applicazione**: + Per il bucket **Amazon S3, seleziona il bucket** creato in precedenza per il codice dell'applicazione. **Scegli **Sfoglia** e seleziona il bucket corretto, quindi seleziona Scegli.** Non fare clic sul nome del bucket. + Per **Percorso dell'oggetto Amazon S3**, inserisci **amazon-msf-java-stream-app-1.0.jar** 1. Per le **autorizzazioni di accesso**, scegli **Crea/aggiorna il ruolo IAM `kinesis-analytics-MyApplication-us-east-1` con le politiche richieste.** 1. Nella sezione **Proprietà di runtime**, aggiungi le seguenti proprietà. 1. **Scegliete Aggiungi nuovo elemento** e aggiungete ciascuno dei seguenti parametri: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/get-started-exercise.html) 1. Non modificate nessuna delle altre sezioni. 1. Scegli **Save changes** (Salva modifiche). **Nota** Quando scegli di abilitare la CloudWatch registrazione di Amazon, Managed Service for Apache Flink crea un gruppo di log e un flusso di log per te. I nomi di tali risorse sono i seguenti: Gruppo di log: `/aws/kinesis-analytics/MyApplication` Flusso di log: `kinesis-analytics-log-stream` ### Esecuzione dell'applicazione. L'applicazione è ora configurata e pronta per l'esecuzione. **Per eseguire l'applicazione** 1. **Sulla console per Amazon Managed Service for Apache Flink, scegli **La mia applicazione** e scegli Esegui.** 1. **Nella pagina successiva, nella pagina di configurazione del ripristino dell'applicazione, scegli **Esegui con l'ultima istantanea**, quindi scegli Esegui.** Lo **stato** nell'**applicazione descrive in dettaglio** le transizioni da `Ready` `Starting` e poi a `Running` quando l'applicazione è stata avviata. Quando l'applicazione è nello `Running` stato, ora puoi aprire la dashboard di Flink. **Per aprire il pannello di controllo** 1. Scegli **Apri la dashboard di Apache Flink**. La dashboard si apre in una nuova pagina. 1. Nell'elenco **dei lavori in esecuzione**, scegli il singolo lavoro che puoi vedere. **Nota** Se imposti le proprietà di Runtime o modifichi le policy IAM in modo errato, lo stato dell'applicazione potrebbe trasformarsi in`Running`, ma la dashboard di Flink mostra che il job viene riavviato continuamente. Si tratta di uno scenario di errore comune se l'applicazione non è configurata correttamente o non dispone delle autorizzazioni per accedere alle risorse esterne. Quando ciò accade, controlla la scheda **Eccezioni** nella dashboard di Flink per vedere la causa del problema. ### Osserva le metriche dell'applicazione in esecuzione Nella **MyApplication**pagina, nella sezione **Amazon CloudWatch metrics**, puoi vedere alcune delle metriche fondamentali dell'applicazione in esecuzione. **Per visualizzare le metriche** 1. Accanto al pulsante **Aggiorna**, seleziona **10 secondi** dall'elenco a discesa. 1. Quando l'applicazione è in esecuzione ed è integra, puoi vedere la metrica di **uptime aumentare continuamente**. 1. La metrica **fullrestarts deve** essere zero. Se è in aumento, la configurazione potrebbe presentare problemi. Per esaminare il problema, consulta la scheda **Eccezioni** nella dashboard di Flink. 1. La metrica **del numero di checkpoint non riusciti** deve essere pari a zero in un'applicazione integra. **Nota** Questa dashboard mostra un set fisso di metriche con una granularità di 5 minuti. Puoi creare un pannello di controllo dell'applicazione personalizzato con qualsiasi metrica presente nella dashboard. CloudWatch ### Osserva i dati di output nei flussi Kinesis Assicurati di continuare a pubblicare i dati sull'input, usando lo script Python o il Kinesis Data Generator. È ora possibile osservare l'output dell'applicazione in esecuzione su Managed Service for Apache Flink utilizzando il Data Viewer in [https://console.aws.amazon.com/kinesis/](https://console.aws.amazon.com/kinesis/), analogamente a quanto già fatto in precedenza. **Per visualizzare l'output** 1. [Apri la console Kinesis in /kinesis. https://console.aws.amazon.com](https://console.aws.amazon.com/kinesis) 1. Verifica che la regione sia la stessa che stai usando per eseguire questo tutorial. Per impostazione predefinita, è US-East-1US East (Virginia settentrionale). Se necessario, modificare la regione. 1. Scegli **Data Streams.** 1. Seleziona lo stream che desideri osservare. Ai fini di questo tutorial, utilizza `ExampleOutputStream`. 1. Scegli la scheda **Data viewer**. 1. Seleziona uno **Shard**, mantieni **Ultimo** come **posizione iniziale**, quindi scegli **Ottieni record**. Potresti visualizzare l'errore «nessun record trovato per questa richiesta». In tal caso, scegli **Riprova a recuperare i record**. Vengono visualizzati i record più recenti pubblicati nello stream. 1. Seleziona il valore nella colonna Dati per esaminare il contenuto del record in formato JSON. ### Arresta l'applicazione Per interrompere l'applicazione, vai alla pagina della console dell'applicazione Managed Service for Apache Flink denominata. `MyApplication` **Per interrompere l'applicazione** 1. **Dall'elenco a discesa **Azione**, scegli Stop.** 1. Lo **stato** nell'**applicazione descrive in dettaglio** le transizioni da `Running` e quindi a `Ready` quando l'applicazione viene completamente interrotta. `Stopping` **Nota** Non dimenticare di interrompere anche l'invio di dati al flusso di input dallo script Python o dal Kinesis Data Generator. ## Approfondimenti [Pulisci le risorse AWS](getting-started-cleanup.md) # Pulisci le risorse AWS Questa sezione include le procedure per la pulizia AWS delle risorse create in questo tutorial Getting Started (DataStream API). **Topics** + [ ## Eliminare l'applicazione Managed Service for Apache Flink ](#getting-started-cleanup-app) + [ ## Eliminare i flussi di dati Kinesis ](#getting-started-cleanup-stream) + [ ## Elimina oggetti e bucket Amazon S3 ](#getting-started-cleanup-s3) + [ ## Elimina le tue risorse IAM ](#getting-started-cleanup-iam) + [ ## CloudWatch Elimina le tue risorse ](#getting-started-cleanup-cw) + [ ## Esplora risorse aggiuntive per Apache Flink ](#getting-started-cleanup-next-step-5) ## Eliminare l'applicazione Managed Service for Apache Flink Per eliminare l'applicazione, utilizza la procedura seguente. 1. [Apri la console Kinesis in /kinesis. https://console.aws.amazon.com](https://console.aws.amazon.com/kinesis) 1. Nel pannello Managed Service for Apache Flink, scegli. **MyApplication** 1. Dall'elenco a discesa **Azioni**, scegliete **Elimina** e quindi confermate l'eliminazione. ## Eliminare i flussi di dati Kinesis 1. Accedi a e apri Console di gestione AWS la console Amazon MSF all'indirizzo https://console.aws.amazon.com /flink.. 1. **Scegli Flussi di dati.** 1. Seleziona i due stream che hai creato e. `ExampleInputStream` `ExampleOutputStream` 1. Dall'elenco a discesa **Azioni**, scegli **Elimina**, quindi conferma l'eliminazione. ## Elimina oggetti e bucket Amazon S3 Utilizza le seguenti procedure per eliminare oggetti e bucket Amazon S3. **Per eliminare l'oggetto dal bucket S3** 1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 1. Seleziona il bucket S3 che hai creato per l'elemento dell'applicazione. 1. Seleziona l'elemento dell'applicazione che hai caricato, denominato. `amazon-msf-java-stream-app-1.0.jar` 1. Scegliete **Elimina** e confermate l'eliminazione. **Per eliminare il bucket S3** 1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 1. Seleziona il bucket che hai creato per gli artefatti. 1. Scegliete **Elimina e confermate l'eliminazione**. **Nota** Il bucket S3 deve essere vuoto per eliminarlo. ## Elimina le tue risorse IAM **Per eliminare le risorse IAM** 1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Nella barra di navigazione, scegli **Policy**. 1. Nel controllo filtro, inserisci **kinesis**. 1. Scegli la politica **kinesis-analytics-service- MyApplication -us-east-1**. 1. Seleziona **Operazioni di policy** e quindi **Elimina**. 1. Nella barra di navigazione, scegli **Ruoli**. 1. Scegli il ruolo **kinesis-analytics- MyApplication** -us-east-1. 1. Quindi scegli **Elimina ruolo** e conferma l'eliminazione. ## CloudWatch Elimina le tue risorse 1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Nella barra di navigazione, scegli **Log**. 1. Scegli il gruppo**/aws/kinesis-analytics/MyApplication**log. 1. Quindi scegli **Elimina gruppo di log** e conferma l'eliminazione. ## Esplora risorse aggiuntive per Apache Flink [Esplora risorse aggiuntive](getting-started-next-steps.md) # Esplora risorse aggiuntive Ora che hai creato ed eseguito un'applicazione di base del servizio gestito per Apache Flink, consulta le seguenti risorse per esplorare soluzioni del servizio gestito per Apache Flink più avanzate. + **[Workshop Amazon Managed Service per Apache Flink](https://catalog.workshops.aws/managed-flink):** in questo workshop, crei un'architettura di end-to-end streaming per importare, analizzare e visualizzare i dati di streaming quasi in tempo reale. Hai deciso di migliorare le attività di una compagnia di taxi a New York City. Analizza i dati di telemetria di una flotta di taxi a New York City quasi in tempo reale per ottimizzare le operazioni della flotta. + **[Esempi di creazione e utilizzo di Managed Service per applicazioni Apache Flink](examples-collapsibles.md):** questa sezione della Guida per gli sviluppatori fornisce esempi di creazione e utilizzo di applicazioni nel servizio gestito per Apache Flink. Includono codice di esempio e step-by-step istruzioni per aiutarti a creare un servizio gestito per le applicazioni Apache Flink e testare i risultati. + **[Scopri Flink: esercitazioni pratiche](https://nightlies.apache.org/flink/flink-docs-release-1.19/docs/learn-flink/overview/):** formazione introduttiva ufficiale su Apache Flink che ti consente di iniziare a scrivere applicazioni di streaming scalabili ETL, di analisi e basate su eventi.