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à. # Create ed eseguite un servizio gestito per l'applicazione Apache Flink In questo passaggio, si crea un'applicazione Managed Service for Apache Flink con i flussi di dati Kinesis come origine e sink. **Topics** + [Create 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 la tua applicazione localmente](#get-started-exercise-5-run) + [Osserva i dati di input e output negli stream Kinesis](#get-started-exercise-input-output) + [Interrompi l'esecuzione dell'applicazione localmente](#get-started-exercise-stop) + [Compilate e impacchettate 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) ## Create 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 l'input e l'output + Un bucket Amazon S3 per archiviare il codice dell'applicazione **Nota** Questo tutorial presuppone che tu stia distribuendo la tua applicazione nella regione us-east-1 US East (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 flussi utilizzando la console Amazon Kinesis o il seguente comando. AWS CLI 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 il AWS CLI, utilizza 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`), utilizza 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, cambiando 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/](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 utilizzata per questo tutorial (us-east-1). ### Altre risorse Quando crei la tua applicazione, Managed Service for Apache Flink crea automaticamente le seguenti CloudWatch 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 sul tuo computer direttamente dal tuo IDE preferito. Tutte le dipendenze di Apache Flink vengono gestite come normali dipendenze Java utilizzando Apache Maven. **Nota** Sul computer di sviluppo, è necessario che Java JDK 11, Maven e Git siano installati. Ti consigliamo di utilizzare un ambiente di sviluppo come [ Eclipse Java Neon o IntelliJ IDEA. ](https://www.eclipse.org/downloads/packages/release/neon/3) [https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/) Per verificare di soddisfare tutti i prerequisiti, consulta. [Soddisfa i prerequisiti per completare gli esercizi](getting-started.md#setting-up-prerequisites) **Non ** è necessario installare un cluster Apache Flink sul computer. ### Autentica il tuo AWS sessione L'applicazione utilizza i flussi di dati Kinesis per pubblicare i dati. Quando viene eseguita localmente, è necessario disporre di una sessione AWS autenticata valida con le autorizzazioni per scrivere nel flusso di dati Kinesis. Utilizzate i seguenti passaggi per autenticare la sessione: 1. Se non hai configurato un profilo denominato con credenziali valide, consulta. AWS CLI [Configura il AWS Command Line Interface (AWS CLI)](setup-awscli.md) 1. Verifica che il tuo 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 plug-in con cui integrarti AWS, puoi usarlo per passare le credenziali all'applicazione in esecuzione nell'IDE. Per ulteriori informazioni, consulta [AWS Toolkit for IntelliJ IDEA ](https://aws.amazon.com/intellij/) e [AWS 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 presso. 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`. ### Rivedi 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 in streaming e per eseguirli. **Nota** Per un'esperienza di sviluppo ottimizzata, l'applicazione è progettata per funzionare senza modifiche al codice sia su Amazon Managed Service for Apache Flink che localmente, per lo sviluppo nel tuo IDE. + Per leggere la configurazione di runtime in modo che funzioni quando viene eseguita 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 nel tuo IDE, crea 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 quelli `StreamExecutionEnvironment` da utilizzare con l' DataSteam API sia quelli `StreamTableEnvironment` da utilizzare con SQL e l'API Table. I due oggetti di ambiente sono due riferimenti separati allo stesso ambiente di runtime, per utilizzare API diverse. ``` StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); ``` + Carica 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 ](https://nightlies.apache.org/flink/flink-docs-release-1.18/docs/connectors/datastream/kinesis/#kinesis-consumer) 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 dello stream si trovano `aws.region` rispettivamente nelle proprietà denominate `stream.name` e. 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 ](https://nightlies.apache.org/flink/flink-docs-release-1.18/docs/connectors/datastream/kinesis/#kinesis-streams-sink) Kinesis Streams Sink per inviare dati al flusso di uscita. 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 il flusso di dati richiede: ``` env.execute("Flink streaming Java API skeleton"); ``` ### Usa 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 automaticamente disponibili 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 la tua 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 di Apache Flink al pom con l'ambito predefinito, come il connettore Kinesis utilizzato da questa applicazione. [https://nightlies.apache.org/flink/flink-docs-master/docs/connectors/datastream/kinesis/](https://nightlies.apache.org/flink/flink-docs-master/docs/connectors/datastream/kinesis/) 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 in base a Java 11, la versione JDK attualmente supportata da Apache Flink. + Il plugin Maven Shade impacchetta il fat-jar, escludendo alcune librerie fornite dal runtime. Specifica inoltre due trasformatori: e. `ServicesResourceTransformer` `ManifestResourceTransformer` Quest'ultimo configura la classe contenente il `main` metodo per avviare l'applicazione. Se rinominate la classe principale, non dimenticate 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 affinché l'applicazione li elabori. Sono disponibili due opzioni per generare dati di esempio, utilizzando uno script Python o il [ Kinesis Data Generator. ](https://github.com/awslabs/amazon-kinesis-data-generator) ### Generate dati di esempio utilizzando 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 la libreria [AWS SDK for Python (Boto) installata. ](https://aws.amazon.com/developer/language/python/) **Per iniziare a inviare i dati di test al flusso di input di Kinesis: ** 1. Scaricate 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 possibile eseguire l'applicazione Apache Flink. ### Genera dati di esempio utilizzando Kinesis Data Generator In alternativa allo script Python, puoi utilizzare [ 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. Verrà eseguito un CloudFormation modello che imposta un utente e una password. 1. Accedi a Kinesis Data Generator tramite l'URL generato dal CloudFormation modello. L'URL è disponibile nella ** scheda ** Output dopo che il CloudFormation modello è stato completato. 1. Configura il generatore di dati: + **Regione: ** seleziona la regione che stai usando per questo tutorial: us-east-1 + **Stream/delivery stream: ** 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 la tua applicazione localmente È possibile eseguire ed eseguire il debug dell'applicazione Flink localmente nel proprio 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 il tuo AWS sessione](#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 hai 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 in`./src/main/resources`. È possibile modificare questo file per utilizzare nomi o regioni di stream Kinesis diversi. ``` [ { "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, vedi [ Run/debug le configurazioni ](https://www.jetbrains.com/help/idea/run-debug-configuration.html) nella documentazione di IntelliJ IDEA. In particolare, è necessario configurare quanto segue: 1. **Aggiungete le `provided` dipendenze al ** classpath. Ciò è necessario per assicurarsi che le dipendenze con `provided` ambito vengano passate all'applicazione durante l'esecuzione locale. Senza questa configurazione, l'applicazione visualizza immediatamente un `class not found` errore. 1. **Passate 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, puoi 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`, è possibile eseguirla o eseguirne il debug come una normale applicazione Java. **Nota** Non puoi 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. Questo è seguito da una serie di log INFO e da alcuni log 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. **Mentre i dati fluiscono, 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** Non emettere registri sui flussi di dati è il comportamento normale di un'applicazione Flink. L'emissione di log 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 negli stream Kinesis Puoi osservare i record inviati al flusso di input da Python (esempio di generazione) o da Kinesis Data Generator (link) utilizzando il ** Data Viewer ** nella console Amazon Kinesis. **Per osservare i record** 1. Apri la console Kinesis all'indirizzo. [ https://console.aws.amazon.com/kinesis ](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 ** ** Latest 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 controllare il contenuto del record in formato JSON. ## Interrompi l'esecuzione dell'applicazione localmente Interrompi l'esecuzione dell'applicazione nel tuo IDE. L'IDE di solito fornisce un'opzione «stop». La posizione e il metodo esatti dipendono dall'IDE che stai utilizzando. ## Compilate e impacchettate 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 a 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 con 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 il 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 negli stream Kinesis](#get-started-exercise-7-console-output) + [Interrompi l'applicazione](#get-started-exercise-stop) ### Creazione dell’applicazione **Per creare l'applicazione** 1. Accedi 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 US East (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 Guida introduttiva della pagina iniziale. 1. Nella ** pagina ** Crea applicazione di streaming: + **Scegli un metodo per configurare l'applicazione di elaborazione dello streaming: ** scegli ** Crea da zero**. + **Configurazione Apache Flink, versione Application Flink: ** scegliete ** Apache Flink 1.20. ** 1. Configura la tua applicazione + **Nome dell'applicazione: ** immettere**MyApplication**. + **Descrizione: ** inserisci**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 per Apache Flink era precedentemente noto come Kinesis Data Analytics. Il nome delle risorse che vengono create automaticamente è preceduto dal prefisso per 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 policy** 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 gli ID account di esempio ({{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'artefatto 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 che hai creato in precedenza per il codice dell'applicazione. Scegli ** Browse ** 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 delle 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. Nella console di Amazon Managed Service for Apache Flink, scegli ** La mia applicazione ** e scegli ** Esegui. ** 1. Nella pagina successiva, la pagina di configurazione del ripristino dell'applicazione, scegli ** Esegui con l'istantanea ** più recente, quindi scegli Esegui. ** ** Lo ** stato ** nei dettagli ** dell'applicazione ** passa da `Ready` a `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 visualizzare. **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 processo 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 delle CloudWatch metriche di ** Amazon, 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 e integra, puoi vedere la ** metrica di ** uptime aumentare continuamente. 1. La ** metrica di ** riavvio completo deve essere zero. Se aumenta, la configurazione potrebbe presentare problemi. Per esaminare il problema, consulta la ** scheda ** Eccezioni nella dashboard di Flink. 1. La ** metrica ** Numero di checkpoint non riusciti deve essere zero in un'applicazione integra. **Nota** Questa dashboard mostra un set fisso di metriche con una granularità di 5 minuti. Puoi creare una dashboard dell'applicazione personalizzata con qualsiasi metrica nella dashboard. CloudWatch ### Osserva i dati di output negli stream Kinesis Assicurati di continuare a pubblicare i dati sull'input, utilizzando 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 nel formato [ https://console.aws.amazon.com/kinesis/](https://console.aws.amazon.com/kinesis/), analogamente a quanto già fatto in precedenza. **Per visualizzare l'output** 1. Aprire la console Kinesis all'indirizzo. [ https://console.aws.amazon.com/kinesis ](https://console.aws.amazon.com/kinesis) 1. Verifica che la regione sia la stessa che stai utilizzando 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 Visualizzatore ** dati. 1. Seleziona uno ** Shard**, mantieni ** ** Latest 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 controllare il contenuto del record in formato JSON. ### Interrompi 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 ** nei dettagli ** dell'applicazione ** passa da `Running` a e `Stopping` quindi a `Ready` quando l'applicazione viene completamente interrotta. **Nota** Non dimenticate inoltre di interrompere l'invio di dati al flusso di input dallo script Python o dal Kinesis Data Generator. ## Approfondimenti [Eliminazione AWS risorse](getting-started-cleanup.md)