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.
Questa sezione contiene le fasi seguenti:
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
NotaQuesto 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 quanto segue AWS CLI comando. Per istruzioni sulla console, consulta Creazione e aggiornamento dei flussi di dati nella Guida per gli sviluppatori del flusso di dati Amazon Kinesis. Per creare gli stream usando il AWS CLI, usa i seguenti comandi, adattandoti alla regione che usi per la tua applicazione.
Per creare i flussi di dati (AWS CLI)
-
Per creare il primo stream (
ExampleInputStream), usa il seguente Amazon Kinesiscreate-streamAWS CLI comando:$ aws kinesis create-stream \ --stream-name ExampleInputStream \ --shard-count 1 \ --region us-east-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 scoprire come creare un bucket Amazon S3 utilizzando la console, consulta Creazione di un bucket nel Guida per l'utente di Amazon S3. Assegna un nome al bucket Amazon S3 utilizzando un nome univoco globale, ad esempio aggiungendo il tuo nome di accesso.
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 quanto segue Amazon CloudWatch risorse se non esistono già:
-
Un gruppo di log denominato
/AWS/KinesisAnalytics-java/<my-application> -
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.
Sul tuo computer di sviluppo, devi avere Java JDK 11, Maven e Git installati. Ti consigliamo di utilizzare un ambiente di sviluppo come Eclipse Java Neon
Autentica il tuo AWS sessione
L'applicazione utilizza i flussi di dati Kinesis per pubblicare i dati. Quando viene eseguita localmente, è necessario disporre di un valore valido AWS sessione autenticata con autorizzazioni di scrittura nel flusso di dati Kinesis. Usa i seguenti passaggi per autenticare la tua sessione:
-
Se non hai il AWS CLI e un profilo denominato con credenziali valide configurate, vedi Configura il AWS Command Line Interface (AWS CLI).
-
Verifica che il tuo AWS CLI è configurato correttamente e gli utenti dispongono 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 -
Se il tuo IDE ha un plugin con cui integrarsi AWS, puoi usarlo per passare le credenziali all'applicazione in esecuzione nell'IDE. Per ulteriori informazioni, vedere AWS Toolkit per IntelliJ IDEA
e AWS Toolkit per Eclipse.
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:
-
Clona il repository remoto con il comando seguente:
git clone https://github.com/aws-samples/amazon-managed-service-for-apache-flink-examples.git -
Passa alla directory
amazon-managed-service-for-apache-flink-examples/tree/main/java/GettingStarted.
Rivedi i componenti dell'applicazione
L'applicazione è interamente implementata in com.amazonaws.services.msf.BasicStreamingJob classe. La main() il metodo definisce il flusso di dati per elaborare i dati in streaming e per eseguirli.
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 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:
-
Quando l'applicazione rileva che è in esecuzione in modalità autonoma nel tuo IDE, crea
application_properties.jsonfile incluso nel risorse cartella del progetto. Segue il contenuto del file. -
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. Consulta Crea e configura l'applicazione Managed Service for Apache Flink.
private static Map<String, Properties> 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()il metodo definisce il flusso di dati dell'applicazione e lo esegue.-
Inizializza gli ambienti di streaming predefiniti. In questo esempio, mostriamo come creare sia
StreamExecutionEnvironmentda utilizzare con DataSteam API eStreamTableEnvironmentda 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<String, Properties> applicationParameters = loadApplicationProperties(env); -
L'applicazione definisce una fonte utilizzando Kinesis Consumer
connettore per leggere i dati dal flusso di input. La configurazione del flusso di input è definita nel PropertyGroupId=InputStream0. Il nome e la regione dello stream si trovano nelle proprietà denominatestream.nameeaws.regionrispettivamente. Per semplicità, questa fonte legge i record come una stringa.private static FlinkKinesisConsumer<String> 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<String> source = createSource(applicationParameters.get("InputStream0")); DataStream<String> input = env.addSource(source, "Kinesis Source"); ... } -
L'applicazione definisce quindi un sink utilizzando Kinesis Streams Sink
connettore per inviare dati al flusso di uscita. Il nome e la regione del flusso di output sono definiti nel PropertyGroupId=OutputStream0, simile al flusso di input. Il lavello è collegato direttamente all'internoDataStreamcioè ottenere dati dalla fonte. In un'applicazione reale, si verifica una trasformazione tra sorgente e sink.private static KinesisStreamsSink<String> createSink(Properties outputProperties) { String outputStreamName = outputProperties.getProperty("stream.name"); return KinesisStreamsSink.<String>builder() .setKinesisClientProperties(outputProperties) .setSerializationSchema(new SimpleStringSchema()) .setStreamName(outputStreamName) .setPartitionKeyGenerator(element -> String.valueOf(element.hashCode())) .build(); } ... public static void main(String[] args) throws Exception { ... Sink<String> sink = createSink(applicationParameters.get("OutputStream0")); input.sinkTo(sink); ... } -
Infine, esegui il flusso di dati che hai appena definito. Questa deve essere l'ultima istruzione di
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.
-
Alcune dipendenze hanno
providedambito. 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 l'applicazione localmente. Assicurati di utilizzare la stessa versione di Flink del runtime che utilizzerai in Amazon Managed Service for Apache Flink.<dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-clients</artifactId> <version>${flink.version}</version> <scope>provided</scope> </dependency> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-streaming-java</artifactId> <version>${flink.version}</version> <scope>provided</scope> </dependency>
-
È necessario aggiungere ulteriori dipendenze di Apache Flink al pom con l'ambito predefinito, ad esempio Connettore Kinesis
utilizzato da questa applicazione. Per ulteriori informazioni, consulta Usa i connettori Apache Flink. È inoltre possibile aggiungere eventuali dipendenze Java aggiuntive richieste dall'applicazione. <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-connector-kinesis</artifactId> <version>${aws.connector.version}</version> </dependency>
-
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:
ServicesResourceTransformereManifestResourceTransformer. Quest'ultimo configura la classe contenentemainmetodo per avviare l'applicazione. Se rinomini la classe principale, non dimenticare di aggiornare questo trasformatore. -
<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> ... <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> <mainClass>com.amazonaws.services.msf.BasicStreamingJob</mainClass> </transformer> ... </plugin>
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 Generatore di dati Kinesis
Genera dati di esempio utilizzando uno script Python
Puoi usare uno script Python per inviare record di esempio allo stream.
Per eseguire questo script Python, devi usare Python 3.x e avere AWS SDK per Python (Boto)
Per iniziare a inviare i dati di test al flusso di input di Kinesis:
-
Scarica il generatore di dati
stock.pyScript Python da Generatore di dati GitHub magazzino. -
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 all'utilizzo dello script Python, puoi usare Generatore di dati Kinesis
Per configurare ed eseguire Kinesis Data Generator:
-
Seguite le istruzioni riportate in Documentazione di Kinesis Data Generator
per configurare l'accesso allo strumento. Eseguirai un CloudFormation modello che imposta un utente e una password. -
Accedi a Kinesis Data Generator tramite l'URL generato da CloudFormation modello. Puoi trovare l'URL nel Uscita scheda dopo CloudFormation il modello è completato.
-
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)}} }
-
-
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 } -
Avvia il generatore di dati: scegli Seleziona Invia dati.
Kinesis Data Generator sta ora inviando dati a ExampleInputStream.
Esegui l'applicazione localmente
È possibile eseguire ed eseguire il debug dell'applicazione Flink localmente nel proprio IDE.
Prima di continuare, verificate che i flussi di input e output siano disponibili. Consulta Crea due flussi di dati Amazon Kinesis. Inoltre, verifica di disporre dell'autorizzazione per leggere e scrivere da entrambi gli stream. Consulta Autentica il tuo AWS sessione.
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. Consulta Soddisfa i prerequisiti per completare gli esercizi.
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 in ./java/GettingStarted sottodirectory nel tuo IDE.
Inserisci il codice come progetto Java esistente usando Maven.
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 in 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
È possibile eseguire ed eseguire il debug dell'applicazione Flink direttamente dal proprio IDE eseguendo la classe principale com.amazonaws.services.msf.BasicStreamingJob, come faresti con qualsiasi applicazione Java. Prima di eseguire l'applicazione, è necessario configurare la configurazione Esegui. La configurazione dipende dall'IDE in uso. Ad esempio, vedi Run/debug configurazioni
-
Aggiungete il
provideddipendenze al classpath. Ciò è necessario per assicurarsi che le dipendenze conprovidedgli scope vengono passati all'applicazione quando vengono eseguiti localmente. Senza questa configurazione, l'applicazione visualizza unclass not founderrore immediato. -
Passa il AWS credenziali per accedere agli stream Kinesis all'applicazione. Il modo più veloce è usare AWS Toolkit per IntelliJ IDEA
. Usando questo plugin IDE nella configurazione Run, puoi selezionare uno specifico AWS profilo. AWS l'autenticazione avviene utilizzando questo profilo. Non è necessario passare AWS credenziali direttamente. -
Verifica che l'IDE esegua l'applicazione utilizzando JDK 11.
Esegui l'applicazione nel tuo IDE
Dopo aver impostato la configurazione Run per BasicStreamingJob, puoi eseguirlo o eseguirne il debug come una normale applicazione Java.
Non puoi eseguire il fat-jar generato da Maven direttamente con java -jar
... dalla riga di 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, potete controllare i flussi Kinesis in ingresso e in uscita, come descritto nella sezione seguente.
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
È possibile osservare i record inviati al flusso di input da Python (che genera un esempio) o da Kinesis Data Generator (link) utilizzando Visualizzatore di dati nella console Amazon Kinesis.
Per osservare i record
Apri la console Kinesis all'indirizzo https://console.aws.amazon.com/kinesis
. -
Verifica che la regione sia la stessa in cui stai eseguendo questo tutorial, che è us-east-1 US East (Virginia settentrionale) per impostazione predefinita. Cambia la regione se non corrisponde.
-
Scegli Flussi di dati.
-
Seleziona lo stream che desideri osservare
ExampleInputStreamoExampleOutputStream. -
Scegli il Visualizzatore di dati scheda.
-
Scegli qualsiasi Coccio, tieni Ultima come Posizione di partenza, 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 sullo stream.
-
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 codice Java GettingStarted proietta 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.
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
Apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/
. -
Scegli il bucket che hai creato in precedenza per il codice dell'applicazione.
-
Scegli Carica.
-
Scegliere Add files (Aggiungi file).
-
Passate al file JAR generato nel passaggio precedente:
target/amazon-msf-java-stream-app-1.0.jar. -
Scegli Carica senza modificare altre impostazioni.
Assicurati di selezionare il file JAR corretto in <repo-dir>/java/GettingStarted/target/amazon-msf-java-stream-app-1.0.jar.
Il target La 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.
Quando crei l'applicazione utilizzando la console, AWS Identity and Access Management (IAM) e Amazon CloudWatch Le risorse di log vengono create per te. Quando si crea l'applicazione utilizzando AWS CLI, si creano queste risorse separatamente.
Argomenti
Creazione dell’applicazione
Per creare l'applicazione
Accedi al Console di gestione AWS e apri la console Amazon MSF all'indirizzo https://console.aws.amazon.com/flink.
-
Verifica che sia selezionata la regione corretta: us-east-1 US East (Virginia settentrionale)
-
Apri il menu a destra e scegli Applicazioni Apache Flink e poi Crea un'applicazione di streaming. In alternativa, scegli Crea un'applicazione di streaming nel contenitore Guida introduttiva della pagina iniziale.
-
Nel Crea un'applicazione di streaming pagina:
-
Scegli un metodo per configurare l'applicazione di elaborazione dello streaming: scegliere Crea da zero.
-
Configurazione di Apache Flink, versione dell'applicazione Flink: scegliere Apache Flink 1.20.
-
-
Configura la tua applicazione
-
Nome dell'applicazione: inserire
MyApplication. -
Descrizione: inserire
My java test app. -
Accesso alle risorse dell'applicazione: scegliere Crea/aggiorna il ruolo IAM
kinesis-analytics-MyApplication-us-east-1con le politiche richieste.
-
-
Configura il tuo Modello per le impostazioni dell'applicazione
-
Modelli: scegliere Sviluppo.
-
-
Scegli Crea un'applicazione di streaming in fondo alla pagina.
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 da kinesis-analytics- per la compatibilità con le versioni precedenti.
Modifica la policy IAM
Modifica la policy IAM per aggiungere le autorizzazioni per accedere ai flussi di dati Kinesis.
Per modificare la policy
Aprire la console IAM all'indirizzo https://console.aws.amazon.com/iam/
. -
Seleziona Policy. Scegli la policy
kinesis-analytics-service-MyApplication-us-east-1creata dalla console nella sezione precedente. -
Scegli Modifica e poi scegli JSON scheda.
-
Aggiungi alla policy la sezione evidenziata del seguente esempio di policy. Sostituisci gli ID account di esempio (
012345678901) con l'ID del tuo account. -
Scegli Prossimo in fondo alla pagina e poi scegli Salva le modifiche.
Questo tutorial crea un'applicazione che utilizza le istantanee dell'applicazione (legacy). La modalità snapshot avanzata non richiede modifiche alla policy modificata in questa procedura. In modalità snapshot avanzata, l'utente o il ruolo IAM che avvia, aggiorna o arresta l'applicazione necessita di più autorizzazioni. Per ulteriori informazioni su queste autorizzazioni, consulta la sezione Autorizzazioni IAM.
Configura l'applicazione
Modifica la configurazione dell'applicazione per impostare l'artefatto del codice dell'applicazione.
Per modificare la configurazione
-
Sul MyApplication pagina, scegli Configura.
-
Nel Posizione del codice dell'applicazione sezione:
-
Per Bucket Amazon S3, seleziona il bucket che hai 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
-
-
Per Autorizzazioni di accesso, scegli Crea/aggiorna il ruolo IAM
kinesis-analytics-MyApplication-us-east-1con le politiche richieste. -
Nel Proprietà di runtime sezione, aggiungi le seguenti proprietà.
-
Scegli Aggiungi nuovo articolo e aggiungi ciascuno dei seguenti parametri:
ID gruppo Chiave Valore InputStream0stream.nameExampleInputStreamInputStream0aws.regionus-east-1OutputStream0stream.nameExampleOutputStreamOutputStream0aws.regionus-east-1 -
Non modificate nessuna delle altre sezioni.
-
Scegli Save changes (Salva modifiche).
Quando scegli di abilitare Amazon CloudWatch logging, 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
-
Nella console di Amazon Managed Service for Apache Flink, scegli La mia applicazione e scegli Esegui.
-
Nella pagina successiva, nella pagina di configurazione del ripristino dell'applicazione, scegli Esegui con l'ultima istantanea e poi scegli Esegui.
Il Stato nel Dettagli della domanda transizioni da
ReadyaStartinge poi aRunningall'avvio dell'applicazione.
Un'applicazione in modalità snapshot avanzata esegue il ripristino da istantanee avanzate, non da istantanee dell'applicazione (legacy). Per ulteriori informazioni, consulta Ripristinare un'applicazione da un'istantanea avanzata.
Quando l'applicazione è in Running status, ora puoi aprire la dashboard di Flink.
Per aprire il pannello di controllo
-
Scegli Apri il pannello di controllo di Apache Flink. La dashboard si apre in una nuova pagina.
-
Nel Lavori in corso elenca, scegli il singolo lavoro che puoi vedere.
NotaSe hai impostato le proprietà di Runtime o modificato 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 Eccezioni scheda nella dashboard di Flink per vedere la causa del problema.
Osserva le metriche dell'applicazione in esecuzione
Sul MyApplication pagina, nella Amazon CloudWatch metriche sezione, puoi vedere alcune delle metriche fondamentali dell'applicazione in esecuzione.
Per visualizzare le metriche
-
Accanto a Aggiorna pulsante, seleziona 10 secondi dall'elenco a discesa.
-
Quando l'applicazione è in esecuzione ed è integra, puoi vedere tempo di attività metrica in continuo aumento.
-
La riavvii completi la metrica deve essere zero. Se è in aumento, la configurazione potrebbe presentare problemi. Per esaminare il problema, consulta il Eccezioni scheda sulla dashboard di Flink.
-
La Numero di checkpoint falliti la metrica deve essere zero in un'applicazione integra.
NotaQuesta dashboard mostra un set fisso di metriche con una granularità di 5 minuti. Puoi creare un pannello di controllo personalizzato dell'applicazione con qualsiasi metrica nel CloudWatch dashboard.
Osserva i dati di output negli stream Kinesis
Assicuratevi 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 in https://console.aws.amazon.com/kinesis/
Per visualizzare l'output
Apri la console Kinesis all'indirizzo https://console.aws.amazon.com/kinesis
. -
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.
-
Scegli Flussi di dati.
-
Seleziona lo stream che desideri osservare. Ai fini di questo tutorial, utilizza
ExampleOutputStream. -
Scegli il Visualizzatore di dati scheda.
-
Seleziona qualsiasi Coccio, tieni Ultima come Posizione di partenza, quindi scegli Ottieni record. Potresti visualizzare un errore «nessun record trovato per questa richiesta». In tal caso, scegli Riprova a recuperare i record. Vengono visualizzati i record più recenti pubblicati sullo stream.
-
Seleziona il valore nella colonna Dati per controllare 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
-
Dal Azione elenco a discesa, scegli Fermare.
-
Il Stato nel Dettagli della domanda transizioni da
RunningaStopping, e poi aReadyquando l'applicazione è completamente interrotta.NotaNon dimenticate inoltre di interrompere l'invio di dati al flusso di input dallo script Python o dal Kinesis Data Generator.
Approfondimenti
Rimuovere le risorse AWS risorse