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à.
# Aggiornamento a Flink 2.2: guida completa
Questa guida fornisce step-by-step istruzioni per aggiornare l'applicazione Amazon Managed Service for Apache Flink da Flink 1.x a Flink 2.2. Si tratta di un aggiornamento di versione importante con modifiche epocali che richiedono un'attenta pianificazione e test.
**L'aggiornamento della versione principale è unidirezionale**
L'operazione di aggiornamento può spostare l'applicazione da Flink 1.x a 2.2 con conservazione dello stato, ma non è possibile tornare indietro da 2.2 a 1.x con lo stato 2.2. Se l'applicazione non funziona correttamente dopo l'aggiornamento, utilizzate l'API Rollback per tornare alla versione 1.x con lo stato 1.x originale dell'ultima istantanea.
## Prerequisiti
Prima di iniziare l'aggiornamento:
+ Revisione [Interruzione delle modifiche e delle deprecazioni](flink-2-2.md#flink-2-2-breaking-changes)
+ Revisione [Guida alla compatibilità dello stato per gli aggiornamenti di Flink 2.2](state-compatibility.md)
+ Assicurati di disporre di un ambiente non di produzione per i test
+ Documenta la configurazione e le dipendenze correnti dell'applicazione
## Comprendere i percorsi di migrazione
L'esperienza di aggiornamento dipende dalla compatibilità dell'applicazione con Flink 2.2. La comprensione di questi percorsi aiuta a prepararsi in modo appropriato e a stabilire aspettative realistiche.
**Percorso 1: Stato binario e dell'applicazione compatibili**
**Cosa aspettarsi:**
+ Richiama l'operazione di aggiornamento
+ Completa la migrazione alla versione 2.2 con la transizione dello stato dell'applicazione: → → `RUNNING` `UPDATING` `RUNNING`
+ Conserva tutto lo stato dell'applicazione senza perdita o rielaborazione dei dati
+ Stessa esperienza delle migrazioni di versioni minori
Ideale per: applicazioni stateless o applicazioni che utilizzano serializzazione compatibile (Avro, schemi Protobuf compatibili, senza raccolte) POJOs
**Percorso 2: incompatibilità binarie**
**Cosa aspettarsi:**
+ Richiama l'operazione di aggiornamento
+ L'operazione fallisce e viene a galla l'incompatibilità binaria tramite l'API Operations e i log
+ Con il rollback automatico abilitato: le applicazioni vengono ripristinate automaticamente in pochi minuti senza l'intervento dell'utente
+ Con il rollback automatico disabilitato: le applicazioni rimangono in esecuzione senza elaborazione dei dati; si torna manualmente alla versione precedente
+ Una volta corretto il file binario, utilizza l'[UpdateApplication API](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html) per un'esperienza simile a Path 1
Ideale per: applicazioni che utilizzano Remove e APIs che vengono rilevate durante l'avvio del job Flink
**Percorso 3: Stato dell'applicazione incompatibile**
**Cosa aspettarsi:**
+ Richiama l'operazione di aggiornamento
+ Inizialmente la migrazione sembra avere esito positivo
+ Le applicazioni entrano nei cicli di riavvio in pochi secondi quando il ripristino dello stato fallisce
+ Rileva gli errori tramite CloudWatch metriche che mostrano riavvii continui
+ Richiama manualmente l'operazione Rollback
+ Ritorna alla produzione entro pochi minuti dall'avvio del rollback
+ Verifica la tua [Migrazione statale](state-compatibility.md#state-compat-migration) candidatura
Ideale per: applicazioni con incompatibilità di serializzazione dello stato (con raccolte, determinati stati serializzati POJOs con Kryo)
**Nota**
Si consiglia vivamente di creare una replica dell'applicazione di produzione e di testare ciascuna delle seguenti fasi dell'aggiornamento sulla replica prima di seguire gli stessi passaggi per l'applicazione di produzione.
## Fase 1: preparazione
**Aggiorna il codice dell'applicazione**
Aggiorna il codice dell'applicazione per renderlo compatibile con Flink 2.2:
+ **Aggiorna le dipendenze di Flink** alla versione 2.2.0 nel tuo o `pom.xml` `build.gradle`
+ **Aggiorna le dipendenze dei connettori alle versioni compatibili** con Flink 2.2 (vedi) [Disponibilità del connettore](flink-2-2.md#flink-2-2-connectors)
+ **Rimuovi l'utilizzo** di API obsolete:
+ Sostituisci DataSet l'API con DataStream API o Table API/SQL
+ Sostituisci la versione precedente`SourceFunction`/`SinkFunction`con FLIP-27 Source e FLIP-143 Sink APIs
+ Sostituisci l'utilizzo dell'API Scala con l'API Java
+ **Aggiornamento a Java 17**
**Carica il codice dell'applicazione aggiornato**
+ Crea il JAR della tua applicazione con le dipendenze di Flink 2.2
+ Carica su Amazon S3 con un **nome di file diverso** dal tuo JAR corrente (ad esempio,) `my-app-flink-2.2.jar`
+ Prendi nota del bucket e della chiave S3 da utilizzare nella fase di aggiornamento
## Fase 2: abilitare il rollback automatico
Il rollback automatico consente ad Amazon Managed Service for Apache Flink di ripristinare automaticamente la versione precedente se l'aggiornamento non riesce.
**Verifica lo stato del rollback automatico**
*Console di gestione AWS:*
1. Vai alla tua applicazione
1. Scegli **Configuration** (Configurazione)
1. In **Impostazioni dell'applicazione**, verifica che il **rollback del sistema sia abilitato**
*AWS CLI:*
```
aws kinesisanalyticsv2 describe-application \
--application-name MyApplication \
--query 'ApplicationDetail.ApplicationConfigurationDescription.ApplicationSystemRollbackConfigurationDescription.RollbackEnabled'
```
**Abilita il rollback automatico (se non abilitato)**
```
aws kinesisanalyticsv2 update-application \
--application-name MyApplication \
--current-application-version-id \
--application-configuration-update '{
"ApplicationSystemRollbackConfigurationUpdate": {
"RollbackEnabledUpdate": true
}
}'
```
## Fase 3: scattare un'istantanea (opzionale)
Se le istantanee automatiche sono abilitate per l'applicazione, potete saltare questo passaggio, altrimenti scattate un'istantanea dell'applicazione per salvare lo stato dell'applicazione prima dell'aggiornamento.
**Scatta un'istantanea dall'applicazione in esecuzione**
*Console di gestione AWS:*
1. Passa alla tua applicazione
1. Scegli **Istantanee**
1. Scegli **Crea istantanea**
1. Immettete il nome di un'istantanea (ad esempio,) `pre-flink-2.2-upgrade`
1. Scegli **Crea**
*AWS CLI:*
```
aws kinesisanalyticsv2 create-application-snapshot \
--application-name MyApplication \
--snapshot-name pre-flink-2.2-upgrade
```
**Verifica la creazione dell'istantanea**
```
aws kinesisanalyticsv2 describe-application-snapshot \
--application-name MyApplication \
--snapshot-name pre-flink-2.2-upgrade
```
Attendi fino a quando non `SnapshotStatus` è così `READY` prima di procedere.
## Fase 4: aggiornamento dell'applicazione
È possibile aggiornare l'applicazione Flink utilizzando l'[https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html)azione.
Puoi chiamare l'`UpdateApplication`API in diversi modi:
+ **Usa il Console di gestione AWS.**
+ Vai alla pagina della tua app su Console di gestione AWS.
+ Scegli **Configura**.
+ Seleziona il nuovo runtime e l'istantanea da cui vuoi iniziare, nota anche come configurazione di ripristino. Utilizza l'impostazione più recente come configurazione di ripristino per avviare l'app dall'ultima istantanea. Seleziona la nuova applicazione aggiornata JAR/zip su Amazon S3.
+ **Usa l'azione. AWS CLI[https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesisanalyticsv2/update-application.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kinesisanalyticsv2/update-application.html)**
+ **Usa CloudFormation.**
+ Aggiorna il `RuntimeEnvironment` campo. In precedenza, CloudFormation eliminava l'applicazione e ne creava una nuova, causando la perdita delle istantanee e della cronologia dell'altra app. Ora CloudFormation aggiorna la `RuntimeEnvironment` versione in uso e non elimina l'applicazione.
+ **Usa l' AWS SDK.**
+ Consulta la documentazione SDK per il linguaggio di programmazione che preferisci. Per informazioni, consulta [https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html).
È possibile eseguire l'aggiornamento mentre l'applicazione è in `RUNNING` stato o mentre l'applicazione è arrestata in `READY` tale stato. Amazon Managed Service for Apache Flink convalida la compatibilità tra la versione di runtime originale e la versione di runtime di destinazione. Questo controllo di compatibilità viene eseguito quando lo esegui `UpdateApplication` mentre sei in `RUNNING` uno stato o successivamente `StartApplication` se esegui l'upgrade mentre sei in stato. `READY`
**Aggiornamento dallo stato RUNNING**
```
aws kinesisanalyticsv2 update-application \
--application-name MyApplication \
--current-application-version-id \
--runtime-environment-update FLINK-2_2 \
--application-configuration-update '{
"ApplicationCodeConfigurationUpdate": {
"CodeContentUpdate": {
"S3ContentLocationUpdate": {
"FileKeyUpdate": "my-app-flink-2.2.jar"
}
}
}
}'
```
**Aggiornamento dallo stato READY**
```
aws kinesisanalyticsv2 update-application \
--application-name MyApplication \
--current-application-version-id \
--runtime-environment-update FLINK-2_2 \
--application-configuration-update '{
"ApplicationCodeConfigurationUpdate": {
"CodeContentUpdate": {
"S3ContentLocationUpdate": {
"FileKeyUpdate": "my-app-flink-2.2.jar"
}
}
}
}'
```
## Fase 5: aggiornamento del monitor
**Verifica della compatibilità**
+ Utilizza l'API Operations per verificare lo stato dell'aggiornamento. In caso di incompatibilità binarie o problemi con l'avvio del processo, l'operazione di aggiornamento avrà esito negativo e verranno generati i log.
+ Se l'operazione di aggiornamento è riuscita ma l'applicazione è bloccata nei cicli di riavvio, significa che lo stato è incompatibile con la nuova versione di Flink o che c'è un problema con il codice aggiornato. Scopri come identificare [Guida alla compatibilità dello stato per gli aggiornamenti di Flink 2.2](state-compatibility.md) i problemi di incompatibilità tra stati.
**Monitora lo stato delle applicazioni**
*Stato dell'applicazione:*
+ Lo stato della domanda dovrebbe cambiare: `RUNNING` `UPDATING` → `RUNNING`
+ Controlla il runtime dell'applicazione. Se è 2.2, l'operazione di aggiornamento è andata a buon fine.
+ Se l'applicazione è attiva `RUNNING` ma è ancora nel runtime precedente, è stato attivato il rollback automatico. L'API Operations mostrerà il funzionamento come. `FAILED` Controlla i log per trovare l'eccezione in caso di errore.
Inoltre, monitora queste metriche in: CloudWatch
*Metrica di riavvio:*
+ `numRestarts`: Monitora eventuali riavvii imprevisti: l'aggiornamento ha esito positivo se `numRestarts` è pari a zero `uptime` e/o `runningTime` è in aumento.
*Metriche di Checkpoint:*
+ `lastCheckpointDuration`: Dovrebbe essere simile ai valori di pre-aggiornamento
+ `numberOfFailedCheckpoints`: Dovrebbe rimanere su 0
## Fase 6: convalida del comportamento dell'applicazione
Dopo l'esecuzione dell'applicazione su Flink 2.2:
**Validazione funzionale**
+ Verifica che i dati vengano letti dalle fonti
+ Verifica che i dati vengano scritti nei sink
+ Verifica che la logica aziendale produca i risultati attesi
+ Confronta l'output con la linea di base precedente all'aggiornamento
**Convalida delle prestazioni**
+ Monitora le metriche di latenza (end-to-end tempo di elaborazione)
+ Monitora le metriche del throughput (record al secondo)
+ Monitora la durata e le dimensioni del checkpoint
+ Monitora l'utilizzo della memoria e della CPU
**Esegui per più di 24 ore**
Consenti all'applicazione di funzionare per almeno 24 ore in produzione per garantire:
+ Nessuna perdita di memoria
+ Comportamento stabile ai checkpoint
+ Nessun riavvio imprevisto
+ Produttività costante
## Fase 7: procedure di rollback
Se l'aggiornamento non riesce o l'applicazione è in esecuzione ma non integra, tornate alla versione precedente.
**Rollback automatico**
Se il rollback automatico è abilitato e l'aggiornamento non riesce durante l'avvio, Amazon Managed Service for Apache Flink torna automaticamente alla versione precedente.
**Rollback manuale**
Se l'applicazione è in esecuzione ma non integra, utilizza l'`RollbackApplication`API:
*Console di gestione AWS:*
1. Vai alla tua applicazione
1. Scegli **Azioni** → **Ripristina**
1. Conferma il rollback
*AWS CLI:*
```
aws kinesisanalyticsv2 rollback-application \
--application-name MyApplication \
--current-application-version-id
```
**Cosa succede durante il rollback:**
+ L'applicazione si arresta
+ Il runtime ritorna alla versione precedente di Flink
+ Il codice dell'applicazione torna al JAR precedente
+ **L'applicazione viene riavviata dall'ultima istantanea riuscita scattata prima dell'aggiornamento**
**Importante**
Non è possibile ripristinare un'istantanea di Flink 2.2 su Flink 1.x
Rollback utilizza l'istantanea scattata prima dell'aggiornamento
Scatta sempre un'istantanea prima dell'aggiornamento (Fase 3)
## Fasi successive
Per domande o problemi durante l'aggiornamento, consulta [Risoluzione dei problemi relativi al servizio gestito per Apache Flink](troubleshooting.md) o contatta l' AWS assistenza.