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à. # Risoluzione dei problemi di sviluppo Questa sezione contiene informazioni sulla diagnosi e la risoluzione dei problemi di sviluppo con l'applicazione Managed Service for Apache Flink. **Topics** + [Le migliori pratiche per il rollback del sistema](troubleshooting-system-rollback.md) + [Le migliori pratiche di configurazione di Hudi](troubleshooting-hudi.md) + [Grafici a candela di Apache Flink](troubleshooting-update-flamegraphs.md) + [Problema con il provider di credenziali con il connettore EFO 1.15.2](troubleshooting-credential-provider.md) + [Applicazioni con connettori Kinesis non supportati](troubleshooting-unsupported-kinesis-connectors.md) + [Errore di compilazione: «Impossibile risolvere le dipendenze per il progetto»](troubleshooting-compile.md) + [Scelta non valida: «kinesisanalyticsv2"](troubleshooting-cli-update.md) + [UpdateApplication l'azione non consiste nel ricaricare il codice dell'applicazione](troubleshooting-update.md) + [S3 StreamingFileSink FileNotFoundExceptions](troubleshooting-s3sink.md) + [FlinkKafkaConsumer problema con stop with savepoint](troubleshooting-FlinkKafkaConsumer.md) + [Blocco di Async sink per Flink 1.15](troubleshooting-async-deadlock.md) + [L'elaborazione del codice sorgente dei flussi di dati di Amazon Kinesis non funziona correttamente durante il re-sharding](troubleshooting-kinesis-data-streams-processing-out-of-order.md) + [Domande frequenti e risoluzione dei problemi relativi ai progetti di incorporamento vettoriale in tempo reale](troubleshooting-blueprints.md) # Le migliori pratiche per il rollback del sistema Con il rollback automatico del sistema e le funzionalità di visibilità delle operazioni in Amazon Managed Service for Apache Flink, puoi identificare e risolvere i problemi con le tue applicazioni. ## Rollback del sistema Se l'operazione di aggiornamento o ridimensionamento dell'applicazione non riesce a causa di un errore del cliente, ad esempio un bug nel codice o un problema di autorizzazione, Amazon Managed Service for Apache Flink tenta automaticamente di ripristinare la versione precedente in esecuzione se hai attivato questa funzionalità. Per ulteriori informazioni, consulta [Abilita i rollback di sistema per la tua applicazione Managed Service for Apache Flink](how-system-rollbacks.md). Se l'autorollback fallisce o se non hai effettuato l'attivazione o l'annullamento del consenso, l'applicazione verrà inserita nello stato. `READY` Per aggiornare la tua applicazione, completa i seguenti passaggi: Controlla la console Amazon Managed Service for Apache Flink o utilizza l'`DescribeApplicationOperation`API per visualizzare la descrizione dell'errore e spiegare il motivo per cui l'operazione non è riuscita. [Per lo stack completo degli errori, usa i log di Cloudwatch.](https://docs.aws.amazon.com/managed-flink/latest/java/logging.html) I problemi più comuni sono le autorizzazioni insufficienti, le modifiche al codice incompatibili o le configurazioni errate dell'infrastruttura. Risolvi il problema di fondo. Utilizza l'`UpdateApplicaton`API per ridistribuire la nuova versione dell'applicazione. ## Rollback manuale Se l'applicazione non procede ed è in uno stato transitorio da molto tempo, o se l'applicazione è passata correttamente`Running`, ma si riscontrano problemi a valle come errori di elaborazione in un'applicazione Flink aggiornata correttamente, è possibile ripristinarla manualmente utilizzando l'API. `RollbackApplication` 1. Chiama`RollbackApplication`: questa operazione ripristinerà la versione precedente in esecuzione e ripristinerà lo stato precedente. 1. Monitora l'operazione di rollback utilizzando l'`DescribeApplicationOperation`API. 1. Se il rollback fallisce, utilizza i passaggi precedenti di rollback del sistema. ## Visibilità delle operazioni L'`ListApplicationOperations`API mostra la cronologia di tutte le operazioni dei clienti e del sistema sull'applicazione. 1. Ottieni l'*OperationID* dell'operazione non riuscita dall'elenco. 1. Chiama `DescribeApplicationOperation` e controlla lo stato e lo *StatusDescription*. 1. Se un'operazione non è riuscita, la descrizione indica un potenziale errore da esaminare. **Bug comuni relativi ai codici di errore:** utilizzate le funzionalità di rollback per ripristinare l'ultima versione funzionante. Risolvi i bug e riprova l'aggiornamento. **Problemi di autorizzazione:** utilizza il `DescribeApplicationOperation` per visualizzare le autorizzazioni richieste. Aggiorna le autorizzazioni dell'applicazione e riprova. **Problemi relativi al servizio Amazon Managed Service for Apache Flink:** verifica Dashboard AWS Health o apri una richiesta di supporto. # Le migliori pratiche di configurazione di Hudi Per eseguire i connettori Hudi su Managed Service for Apache Flink, consigliamo le seguenti modifiche alla configurazione. Disabilitazione di `hoodie.embed.timeline.server` Il connettore Hudi su Flink configura un server timeline (TM) incorporato sul Flink jobmanager (JM) per memorizzare nella cache i metadati per migliorare le prestazioni quando il parallelismo dei lavori è elevato. Ti consigliamo di disabilitare questo server incorporato su Managed Service for Apache Flink perché disabilitiamo la comunicazione non Flink tra JM e TM. Se questo server è abilitato, Hudi write tenterà prima di connettersi al server integrato su JM, quindi tornerà alla lettura dei metadati da Amazon S3. Ciò significa che Hudi subisce un timeout di connessione che ritarda le scritture di Hudi e causa un impatto sulle prestazioni del servizio gestito per Apache Flink. # Grafici a candela di Apache Flink I grafici a candela sono abilitati per impostazione predefinita nelle applicazioni nelle versioni di servizio gestito per Apache Flink che li supportano. I grafici a candela possono influire sulle prestazioni dell'applicazione se rimangono aperti, come indicato nella [documentazione di Flink](https://nightlies.apache.org/flink/flink-docs-release-1.15//docs/ops/debugging/flame_graphs/). Per disabilitare i grafici a candela per l’applicazione è sufficiente creare un caso e richiederne la disabilitazione per l'ARN dell’applicazione. Per ulteriori informazioni, consulta il [Centro di supporto AWS](https://console.aws.amazon.com/support/home#/). # Problema con il provider di credenziali con il connettore EFO 1.15.2 Esiste un [problema noto](https://issues.apache.org/jira/browse/FLINK-29205) con le versioni del connettore EFO del flusso di dati Kinesis fino alla 1.15.2, in cui `FlinkKinesisConsumer` non rispetta la configurazione `Credential Provider`. Le configurazioni valide vengono ignorate a causa del problema, che comporta l'utilizzo del provider di credenziali `AUTO`. Ciò può causare problemi nell'utilizzo dell'accesso multi-account a Kinesis tramite il connettore EFO. Per risolvere questo errore, è sufficiente utilizzare la versione 1.15.3 o successiva del connettore EFO. # Applicazioni con connettori Kinesis non supportati Managed Service for Apache Flink per Apache Flink versione 1.15 o successiva [rifiuterà automaticamente l'avvio o l'aggiornamento delle applicazioni se utilizzano versioni di Kinesis Connector](https://docs.aws.amazon.com/managed-flink/latest/java/flink-1-15-2.html) non supportate (precedenti alla versione 1.15.2) incluse in applicazioni o archivi (ZIP). JARs ## Errore di rifiuto Verrà visualizzato il seguente errore quando si inviano chiamate di creazione/aggiornamento all'applicazione tramite: ``` An error occurred (InvalidArgumentException) when calling the CreateApplication operation: An unsupported Kinesis connector version has been detected in the application. Please update flink-connector-kinesis to any version equal to or newer than 1.15.2. For more information refer to connector fix: https://issues.apache.org/jira/browse/FLINK-23528 ``` ## Come risolvere il problema + Aggiorna la dipendenza dell'applicazione da `flink-connector-kinesis`. Se utilizzi Maven come strumento di compilazione del progetto, segui [Aggiorna una dipendenza da Maven](#troubleshooting-unsupported-kinesis-connectors-update-maven-dependency). Se utilizzi Gradle, segui [Aggiorna una dipendenza da Gradle](#troubleshooting-unsupported-kinesis-connectors-update-gradle-dependency). + Crea di nuovo un pacchetto con l'applicazione. + Carica oggetti in un bucket Amazon S3. + Invia nuovamente la richiesta di creazione/aggiornamento con l'applicazione modificata appena caricata nel bucket Amazon S3. + Se il messaggio di errore continua a ripresentarsi, controlla nuovamente le dipendenze dell'applicazione. Crea un ticket per richiedere assistenza nel caso in cui il problema persista. ### Aggiorna una dipendenza da Maven 1. Apri il file `pom.xml` del progetto. 1. Individua le dipendenze del progetto. Hanno questo aspetto: ``` ... ... org.apache.flink flink-connector-kinesis ... ... ``` 1. Aggiorna `flink-connector-kinesis` a una versione uguale o successiva alla 1.15.2. Per esempio: ``` ... ... org.apache.flink flink-connector-kinesis 1.15.2 ... ... ``` ### Aggiorna una dipendenza da Gradle 1. Apri il `build.gradle` del progetto (o `build.gradle.kts` per le applicazioni Kotlin). 1. Individua le dipendenze del progetto. Hanno questo aspetto: ``` ... dependencies { ... implementation("org.apache.flink:flink-connector-kinesis") ... } ... ``` 1. Aggiorna `flink-connector-kinesis` a una versione uguale o successiva alla 1.15.2. Per esempio: ``` ... dependencies { ... implementation("org.apache.flink:flink-connector-kinesis:1.15.2") ... } ... ``` # Errore di compilazione: «Impossibile risolvere le dipendenze per il progetto» Per compilare il servizio gestito per le applicazioni di esempio di Apache Flink, è necessario scaricare e compilare il connettore Kinesis di Apache Flink e aggiungerlo al repository locale di Maven. Se il connettore non è stato aggiunto al repository verrà visualizzato un errore di compilazione simile al seguente: ``` Could not resolve dependencies for project your project name: Failure to find org.apache.flink:flink-connector-kinesis_2.11:jar:1.8.2 in https://repo.maven.apache.org/maven2 was cached in the local repository, resolution will not be reattempted until the update interval of central has elapsed or updates are forced ``` Per risolvere questo errore, è necessario scaricare il codice sorgente di Apache Flink (dalla versione 1.8.2) per il connettore. [https://flink.apache.org/downloads.html](https://flink.apache.org/downloads.html) Per istruzioni su come scaricare, compilare e installare il codice sorgente di Apache Flink, consulta [Utilizzo del connettore Apache Flink Kinesis Streams con versioni precedenti di Apache Flink](earlier.md#how-creating-apps-building-kinesis). # Scelta non valida: «kinesisanalyticsv2" Per utilizzare l'API v2 del servizio gestito per Apache Flink è necessaria la versione più recente di AWS Command Line Interface (AWS CLI). [https://docs.aws.amazon.com/cli/latest/userguide/installing.html](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) # UpdateApplication l'azione non consiste nel ricaricare il codice dell'applicazione L'[UpdateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html)azione non ricaricherà il codice dell'applicazione con lo stesso nome di file se non viene specificata la versione dell'oggetto S3. Per ricaricare il codice dell'applicazione con lo stesso nome di file, è necessario abilitare il controllo delle versioni sul bucket S3 e specificare la nuova versione dell'oggetto utilizzando il parametro `ObjectVersionUpdate`. Per ulteriori informazioni sul controllo delle versioni degli oggetti in un bucket S3, consulta [Abilitazione e sospensione del controllo delle versioni](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/enable-versioning.html). # S3 StreamingFileSink FileNotFoundExceptions Le applicazioni del servizio gestito per Apache Flink possono essere eseguite in un file delle parti in corso `FileNotFoundException` quando si parte da snapshot se manca un file delle parti in corso a cui fa riferimento il relativo savepoint. Quando si verifica questa modalità di errore, lo stato dell'operatore dell'applicazione di servizio gestito per Apache Flink non è in genere ripristinabile e deve essere riavviato senza utilizzare uno snapshot `SKIP_RESTORE_FROM_SNAPSHOT`. Vedi il seguente esempio di stack trace: ``` java.io.FileNotFoundException: No such file or directory: s3://amzn-s3-demo-bucket/pathj/INSERT/2023/4/19/7/_part-2-1234_tmp_12345678-1234-1234-1234-123456789012 at org.apache.hadoop.fs.s3a.S3AFileSystem.s3GetFileStatus(S3AFileSystem.java:2231) at org.apache.hadoop.fs.s3a.S3AFileSystem.innerGetFileStatus(S3AFileSystem.java:2149) at org.apache.hadoop.fs.s3a.S3AFileSystem.getFileStatus(S3AFileSystem.java:2088) at org.apache.hadoop.fs.s3a.S3AFileSystem.open(S3AFileSystem.java:699) at org.apache.hadoop.fs.FileSystem.open(FileSystem.java:950) at org.apache.flink.fs.s3hadoop.HadoopS3AccessHelper.getObject(HadoopS3AccessHelper.java:98) at org.apache.flink.fs.s3.common.writer.S3RecoverableMultipartUploadFactory.recoverInProgressPart(S3RecoverableMultipartUploadFactory.java:97) ... ``` [Flink `StreamingFileSink` scrive i record su file system supportati dai File System.](https://nightlies.apache.org/flink/flink-docs-release-1.15/docs/deployment/filesystems/overview/) Dato che i flussi in entrata possono essere illimitati, i dati vengono organizzati in file delle parti di dimensioni limitate; man mano che i dati vengono scritti, i nuovi file sono aggiunti. Il ciclo di vita delle parti e la politica di rollover determinano le tempistiche, la dimensione e la denominazione dei file delle parti. Durante il checkpoint e il savepoint (cattura degli snapshot), tutti i file in sospeso vengono rinominati e salvati. Tuttavia, i file delle parti in corso non sono salvati, ma rinominati; il riferimento viene mantenuto nei metadati del checkpoint o del savepoint, in modo da poter essere utilizzato durante il ripristino dei processi. I file delle parti in corso verranno infine contrassegnati come in sospeso, rinominati e salvati da un checkpoint o savepoint successivi. Di seguito sono riportate le cause principali e le misure di mitigazione nel caso in cui manchino i file delle parti in corso: + Istantanea obsoleta utilizzata per avviare l'applicazione Managed Service for Apache Flink: solo l'ultima istantanea del sistema scattata quando un'applicazione viene arrestata o aggiornata può essere utilizzata per avviare un'applicazione Managed Service for Apache Flink con Amazon S3. StreamingFileSink Per evitare questa classe di errori è consigliabile utilizzare lo snapshot di sistema più recente. + Ciò accade ad esempio quando si sceglie uno snapshot creato utilizzando `CreateSnapshot` invece di uno innescato dal sistema durante l'arresto o l'aggiornamento. Il punto di salvataggio della vecchia istantanea conserva un out-of-date riferimento al file di parte in corso che è stato rinominato e salvato dal checkpoint o dal punto di salvataggio successivo. + Ciò può verificarsi anche quando viene selezionata un'istantanea attivata dal sistema relativa a un evento non più recente. Stop/Update Un esempio è un'applicazione con lo snapshot del sistema disabilitato ma `RESTORE_FROM_LATEST_SNAPSHOT` configurato. In genere, le applicazioni Managed Service for Apache Flink con Amazon StreamingFileSink S3 devono sempre avere lo snapshot di sistema abilitato e configurato. `RESTORE_FROM_LATEST_SNAPSHOT` + File delle parti In corso rimosso: poiché il file delle parti In corso si trova in un bucket S3, può essere rimosso da altri componenti o attori che hanno accesso al bucket. + [Ciò può accadere quando l'app è stata interrotta per troppo tempo e il file di parte in corso a cui fa riferimento il punto di salvataggio dell'app è stato rimosso dalla politica del ciclo di vita del bucket S3. MultiPartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html) Per evitare questa classe di errori, assicurarsi che la politica sul ciclo di vita del bucket MPU S3 si estenda su un periodo sufficientemente ampio per il caso d'utilizzo. + Ciò può accadere anche quando il file delle parti In corso è stato rimosso manualmente o da un altro componente del sistema. Per evitare questa classe di errori, assicurarsi che i file delle parti In corso non vengano rimossi da altri attori o componenti. + Condizione di competizione in cui viene innescato un checkpoint automatico dopo il checkpoint: ciò influisce sulle versioni di servizio gestito per Apache Flink fino alla 1.13 inclusa. Questo problema è stato risolto nella versione 1.15 di Managed Service for Apache Flink. Esegui la migrazione dell'applicazione alla versione più recente di Managed Service for Apache Flink per evitare che si verifichino recidive. Ti suggeriamo anche di migrare da a. StreamingFileSink [FileSink](https://nightlies.apache.org/flink/flink-docs-release-1.19/docs/connectors/datastream/filesystem/#file-sink) + Quando le applicazioni vengono arrestate o aggiornate, il servizio gestito per Apache Flink innesca un savepoint e arresta l'applicazione in due passaggi. Se tra i due passaggi si innesca un checkpoint automatico il savepoint sarà inutilizzabile, in quanto il relativo file delle parti in corso verrebbe rinominato e potenzialmente salvato. # FlinkKafkaConsumer problema con stop with savepoint Quando si utilizza la versione precedente FlinkKafkaConsumer , è possibile che l'applicazione rimanga bloccata in UPDATING, STOP o SCALING, se sono abilitate le istantanee di sistema. Non è disponibile alcuna correzione pubblicata per questo [problema](https://issues.apache.org/jira/browse/FLINK-28758), pertanto si consiglia di eseguire l'aggiornamento alla nuova versione per [KafkaSource](https://nightlies.apache.org/flink/flink-docs-master/docs/connectors/datastream/kafka/#kafka-source)mitigare il problema. Se si utilizza `FlinkKafkaConsumer` con gli snapshot abilitati, esiste la possibilità che, quando il processo Flink elabora un arresto con una richiesta di savepoint API, `FlinkKafkaConsumer` possa non riuscire e mostrare un errore di runtime che segnala un `ClosedException`. In queste condizioni l'applicazione Flink si blocca e dà luogo a checkpoint non riusciti. # Blocco di Async sink per Flink 1.15 Esiste un [problema noto](https://issues.apache.org/jira/browse/FLINK-32230) con i AWS connettori per l'interfaccia di implementazione di Apache Flink. AsyncSink Ciò riguarda le applicazioni che utilizzano Flink 1.15 con i seguenti connettori: + Per applicazioni Java: + KinesisStreamsSink – `org.apache.flink:flink-connector-kinesis` + KinesisStreamsSink – `org.apache.flink:flink-connector-aws-kinesis-streams` + KinesisFirehoseSink – `org.apache.flink:flink-connector-aws-kinesis-firehose` + DynamoDbSink – `org.apache.flink:flink-connector-dynamodb` + Applicazioni Flink: SQL/TableAPI/Python + kinesis – `org.apache.flink:flink-sql-connector-kinesis` + kinesis – `org.apache.flink:flink-sql-connector-aws-kinesis-streams` + firehose – `org.apache.flink:flink-sql-connector-aws-kinesis-firehose` + dynamodb – `org.apache.flink:flink-sql-connector-dynamodb` Le applicazioni interessate presenteranno le seguenti caratteristiche: + il processo di Flink è nello stato`RUNNING`, ma non elabora i dati; + non si verificano riavvii del processo; + I checkpoint sono in fase di interruzione. Il problema è causato da un [bug](https://github.com/aws/aws-sdk-java-v2/issues/4354) nell' AWS SDK che impedisce la visualizzazione di alcuni errori al chiamante quando utilizza il client HTTP asincrono. Il risultato è che il sink continuerà ad attendere il completamento di una "richiesta in corso" durante un'operazione di pulizia del checkpoint. **Questo problema è stato risolto in AWS SDK a partire dalla versione 2.20.144.** Di seguito sono riportate le istruzioni su come aggiornare i connettori interessati per utilizzare la nuova versione di AWS SDK nelle applicazioni: **Topics** + [Aggiornamento dell'applicazione Java.](troubleshooting-async-deadlock-update-java-apps.md) + [Aggiornamento di applicazioni Python](troubleshooting-async-deadlock-update-python-apps.md) # Aggiornamento dell'applicazione Java. Per aggiornare le applicazioni Java è sufficiente seguire il seguente procedimento: ## flink-connector-kinesis Se l'applicazione utilizza `flink-connector-kinesis`: Il connettore Kinesis utilizza lo shading per impacchettare alcune dipendenze, incluso l' AWS SDK, nella barra dei connettori. Per aggiornare la versione AWS SDK, utilizza la seguente procedura per sostituire queste classi ombreggiate: ------ #### [ Maven ] 1. Aggiungi il connettore Kinesis e i moduli AWS SDK richiesti come dipendenze del progetto. 1. Configurare `maven-shade-plugin`: 1. Aggiungi un filtro per escludere le classi AWS SDK ombreggiate durante la copia del contenuto del jar del connettore Kinesis. 1. Aggiungi la regola di riposizionamento per spostare le classi AWS SDK aggiornate nel pacchetto, prevista dal connettore Kinesis. **pom.xml** ``` ... ... org.apache.flink flink-connector-kinesis 1.15.4 software.amazon.awssdk kinesis 2.20.144 software.amazon.awssdk netty-nio-client 2.20.144 software.amazon.awssdk sts 2.20.144 ... ... ... ... org.apache.maven.plugins maven-shade-plugin 3.1.1 package shade ... ... org.apache.flink:flink-connector-kinesis org/apache/flink/kinesis/shaded/software/amazon/awssdk/** org/apache/flink/kinesis/shaded/org/reactivestreams/** org/apache/flink/kinesis/shaded/io/netty/** org/apache/flink/kinesis/shaded/com/typesafe/netty/** ... ... software.amazon.awssdk org.apache.flink.kinesis.shaded.software.amazon.awssdk org.reactivestreams org.apache.flink.kinesis.shaded.org.reactivestreams io.netty org.apache.flink.kinesis.shaded.io.netty com.typesafe.netty org.apache.flink.kinesis.shaded.com.typesafe.netty ... ... ... ... ``` ------ #### [ Gradle ] 1. Aggiungi il connettore Kinesis e i moduli AWS SDK richiesti come dipendenze del progetto. 1. Modificare la configurazione di shadowJar: 1. Escludi le classi AWS SDK ombreggiate quando copi il contenuto del jar del connettore Kinesis. 1. Trasferisci le classi AWS SDK aggiornate in un pacchetto previsto dal connettore Kinesis. **build.gradle** ``` ... dependencies { ... flinkShadowJar("org.apache.flink:flink-connector-kinesis:1.15.4") flinkShadowJar("software.amazon.awssdk:kinesis:2.20.144") flinkShadowJar("software.amazon.awssdk:sts:2.20.144") flinkShadowJar("software.amazon.awssdk:netty-nio-client:2.20.144") ... } ... shadowJar { configurations = [project.configurations.flinkShadowJar] exclude("software/amazon/kinesis/shaded/software/amazon/awssdk/**/*") exclude("org/apache/flink/kinesis/shaded/org/reactivestreams/**/*.class") exclude("org/apache/flink/kinesis/shaded/io/netty/**/*.class") exclude("org/apache/flink/kinesis/shaded/com/typesafe/netty/**/*.class") relocate("software.amazon.awssdk", "org.apache.flink.kinesis.shaded.software.amazon.awssdk") relocate("org.reactivestreams", "org.apache.flink.kinesis.shaded.org.reactivestreams") relocate("io.netty", "org.apache.flink.kinesis.shaded.io.netty") relocate("com.typesafe.netty", "org.apache.flink.kinesis.shaded.com.typesafe.netty") } ... ``` ------ ## Altri connettori interessati Se l'applicazione utilizza un altro connettore interessato: Per aggiornare la versione SDK, la versione AWS SDK deve essere applicata nella configurazione di build del progetto. ------ #### [ Maven ] Aggiungi la distinta base AWS SDK (BOM) alla sezione di gestione delle dipendenze del `pom.xml` file per applicare la versione SDK per il progetto. **pom.xml** ``` ... ... software.amazon.awssdk bom 2.20.144 import pom ... ... ``` ------ #### [ Gradle ] Aggiungi la dipendenza della piattaforma dalla distinta base (BOM) dell' AWS SDK per applicare la versione SDK per il progetto. Sarà necessaria la versione Gradle 5.0 o versioni successive: **build.gradle** ``` ... dependencies { ... flinkShadowJar(platform("software.amazon.awssdk:bom:2.20.144")) ... } ... ``` ------ # Aggiornamento di applicazioni Python Le applicazioni Python possono utilizzare i connettori in due maniere diverse: per impacchettare connettori e altre dipendenze Java come parte di un singolo uber jar o utilizzare direttamente il connettore jar. Per correggere le applicazioni interessate dal blocco di Async sink: + Se l'applicazione utilizza un uber jar, seguire le istruzioni per [Aggiornamento dell'applicazione Java.](troubleshooting-async-deadlock-update-java-apps.md). + Per ricostruire i connettori jar dalla sorgente, seguire i passaggi seguenti: **Creazione di connettori dalla fonte:** Prerequisiti, simili ai [requisiti per la costruzione](https://nightlies.apache.org/flink/flink-docs-release-1.15/docs/flinkdev/building/#build-flink) di Flink: + Java 11 + Maven 3.2.5 ## flink-sql-connector-kinesis 1. Scarica il codice sorgente per Flink 1.15.4: ``` wget https://archive.apache.org/dist/flink/flink-1.15.4/flink-1.15.4-src.tgz ``` 1. Decomprimi il codice sorgente: ``` tar -xvf flink-1.15.4-src.tgz ``` 1. Vai alla directory del connettore Kinesis ``` cd flink-1.15.4/flink-connectors/flink-connector-kinesis/ ``` 1. Compila e installa il connettore jar, specificando la versione SDK richiesta. AWS Per velocizzare la compilazione, usa `-DskipTests` per saltare l'esecuzione dei test e `-Dfast` per saltare i controlli aggiuntivi del codice sorgente: ``` mvn clean install -DskipTests -Dfast -Daws.sdkv2.version=2.20.144 ``` 1. Vai alla directory del connettore Kinesis ``` cd ../flink-sql-connector-kinesis ``` 1. Compilare e installare il connettore jar sql: ``` mvn clean install -DskipTests -Dfast ``` 1. Il jar risultante sarà disponibile all'indirizzo: ``` target/flink-sql-connector-kinesis-1.15.4.jar ``` ## flink-sql-connector-aws-kinesis-stream 1. Scarica il codice sorgente per Flink 1.15.4: ``` wget https://archive.apache.org/dist/flink/flink-1.15.4/flink-1.15.4-src.tgz ``` 1. Decomprimi il codice sorgente: ``` tar -xvf flink-1.15.4-src.tgz ``` 1. Vai alla directory del connettore Kinesis ``` cd flink-1.15.4/flink-connectors/flink-connector-aws-kinesis-streams/ ``` 1. Compila e installa il connector jar, specificando la versione SDK richiesta. AWS Per velocizzare la compilazione, usa `-DskipTests` per saltare l'esecuzione dei test e `-Dfast` per saltare i controlli aggiuntivi del codice sorgente: ``` mvn clean install -DskipTests -Dfast -Daws.sdk.version=2.20.144 ``` 1. Vai alla directory del connettore Kinesis ``` cd ../flink-sql-connector-aws-kinesis-streams ``` 1. Compilare e installare il connettore jar sql: ``` mvn clean install -DskipTests -Dfast ``` 1. Il jar risultante sarà disponibile all'indirizzo: ``` target/flink-sql-connector-aws-kinesis-streams-1.15.4.jar ``` ## flink-sql-connector-aws-kinesis-firehose 1. Scarica il codice sorgente per Flink 1.15.4: ``` wget https://archive.apache.org/dist/flink/flink-1.15.4/flink-1.15.4-src.tgz ``` 1. Decomprimi il codice sorgente: ``` tar -xvf flink-1.15.4-src.tgz ``` 1. Accedi alla directory del connettore ``` cd flink-1.15.4/flink-connectors/flink-connector-aws-kinesis-firehose/ ``` 1. Compila e installa il connettore jar, specificando la versione SDK richiesta. AWS Per velocizzare la compilazione, usa `-DskipTests` per saltare l'esecuzione dei test e `-Dfast` per saltare i controlli aggiuntivi del codice sorgente: ``` mvn clean install -DskipTests -Dfast -Daws.sdk.version=2.20.144 ``` 1. Accedi alla directory del connettore sql ``` cd ../flink-sql-connector-aws-kinesis-firehose ``` 1. Compilare e installare il connettore jar sql: ``` mvn clean install -DskipTests -Dfast ``` 1. Il jar risultante sarà disponibile all'indirizzo: ``` target/flink-sql-connector-aws-kinesis-firehose-1.15.4.jar ``` ## flink-sql-connector-dynamodb 1. Scarica il codice sorgente per Flink 1.15.4: ``` wget https://archive.apache.org/dist/flink/flink-connector-aws-3.0.0/flink-connector-aws-3.0.0-src.tgz ``` 1. Decomprimi il codice sorgente: ``` tar -xvf flink-connector-aws-3.0.0-src.tgz ``` 1. Accedi alla directory del connettore ``` cd flink-connector-aws-3.0.0 ``` 1. Compila e installa il connettore jar, specificando la versione SDK richiesta. AWS Per velocizzare la compilazione, usa `-DskipTests` per saltare l'esecuzione dei test e `-Dfast` per saltare i controlli aggiuntivi del codice sorgente: ``` mvn clean install -DskipTests -Dfast -Dflink.version=1.15.4 -Daws.sdk.version=2.20.144 ``` 1. Il jar risultante sarà disponibile all'indirizzo: ``` flink-sql-connector-dynamodb/target/flink-sql-connector-dynamodb-3.0.0.jar ``` # L'elaborazione del codice sorgente dei flussi di dati di Amazon Kinesis non funziona correttamente durante il re-sharding L' FlinkKinesisConsumer implementazione attuale non fornisce forti garanzie di ordinamento tra gli shard Kinesis. Ciò può comportare l' out-of-orderelaborazione durante la ripartizione di Kinesis Stream, in particolare per le applicazioni Flink che presentano ritardi di elaborazione. In alcune circostanze, ad esempio gli operatori delle finestre basati sugli orari degli eventi, gli eventi potrebbero essere eliminati a causa del ritardo che ne deriva. ![\[Diagram showing shards and shard consumers with time progression and trim horizon.\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/images/flink-ts.png) Si tratta di un [problema noto](https://issues.apache.org/jira/browse/FLINK-6349) in Open source di Flink. Fino a quando non sarà disponibile la correzione del connettore, è fondamentale assicurarsi che le applicazioni Flink non accumulino ritardi rispetto al flusso di dati Kinesis nel corso del partizionamento. Assicurandoti che il ritardo di elaborazione sia tollerato dalle tue app Flink, puoi ridurre al minimo l'impatto dell'elaborazione e il rischio di perdita dei out-of-order dati. # Domande frequenti e risoluzione dei problemi relativi ai progetti di incorporamento vettoriale in tempo reale Consulta le seguenti domande frequenti e le sezioni sulla risoluzione dei problemi relativi ai blueprint di incorporamento vettoriale in tempo reale. [Per ulteriori informazioni sui blueprint di incorporamento vettoriale in tempo reale, consulta Blueprint di incorporamento vettoriale in tempo reale.](https://docs.aws.amazon.com/msk/latest/developerguide/ai-vector-embedding-integration-learn-more.html) [Per la risoluzione generale dei problemi relativi all'applicazione Managed Service for Apache Flink, consulta -runtime.html. https://docs.aws.amazon.com/managed-flink/ latest/java/troubleshooting](https://docs.aws.amazon.com/managed-flink/latest/java/troubleshooting-runtime.html) **Topics** + [Progetti di incorporamento vettoriale in tempo reale - Domande frequenti](troubleshooting-blueprints-FAQ.md) + [Blueprint di incorporamento vettoriale in tempo reale: risoluzione dei problemi](troubleshooting-blueprints-TS.md) # Progetti di incorporamento vettoriale in tempo reale - Domande frequenti Consulta le seguenti domande frequenti sui progetti di incorporamento vettoriale in tempo reale. [Per ulteriori informazioni sui blueprint di incorporamento vettoriale in tempo reale, consulta Blueprint di incorporamento vettoriale in tempo reale.](https://docs.aws.amazon.com/msk/latest/developerguide/ai-vector-embedding-integration-learn-more.html) **Topics** + [Quali risorse crea AWS questo modello?](#troubleshooting-blueprints-1) + [Quali sono le mie azioni una volta completata l'implementazione dello AWS CloudFormation stack?](#troubleshooting-blueprints-2) + [Quale dovrebbe essere la struttura dei dati negli argomenti di origine di Amazon MSK?](#troubleshooting-blueprints-3) + [Posso specificare parti di un messaggio da incorporare?](#troubleshooting-blueprints-4) + [Posso leggere dati da più argomenti di Amazon MSK?](#troubleshooting-blueprints-5) + [Posso usare regex per configurare i nomi degli argomenti di Amazon MSK?](#troubleshooting-blueprints-6) + [Qual è la dimensione massima di un messaggio che può essere letto da un argomento di Amazon MSK?](#troubleshooting-blueprints-7) + [Che tipo di è supportato? OpenSearch](#troubleshooting-blueprints-8) + [Perché devo utilizzare una raccolta di ricerca vettoriale, un indice vettoriale e aggiungere un campo vettoriale nella mia raccolta Serverless? OpenSearch](#troubleshooting-blueprints-9) + [Cosa devo impostare come dimensione per il mio campo vettoriale?](#troubleshooting-blueprints-10) + [Che aspetto ha l'output nell'indice OpenSearch configurato?](#troubleshooting-blueprints-11) + [Posso specificare campi di metadati da aggiungere al documento memorizzato nell'indice? OpenSearch](#troubleshooting-blueprints-12) + [Devo aspettarmi voci duplicate nell' OpenSearch indice?](#troubleshooting-blueprints-13) + [Posso inviare dati a più indici? OpenSearch](#troubleshooting-blueprints-14) + [Posso implementare più applicazioni di incorporamento vettoriale in tempo reale in un'unica applicazione? Account AWS](#troubleshooting-blueprints-15) + [Più applicazioni di incorporamento vettoriale in tempo reale possono utilizzare la stessa fonte di dati o lo stesso sink?](#troubleshooting-blueprints-16) + [L'applicazione supporta la connettività tra account?](#troubleshooting-blueprints-17) + [L'applicazione supporta la connettività tra regioni?](#troubleshooting-blueprints-18) + [Il mio cluster e la mia OpenSearch raccolta Amazon MSK possono trovarsi in VPCs sottoreti diverse?](#troubleshooting-blueprints-19) + [Quali modelli di incorporamento sono supportati dall'applicazione?](#troubleshooting-blueprints-20) + [Posso ottimizzare le prestazioni della mia applicazione in base al mio carico di lavoro?](#troubleshooting-blueprints-21) + [Quali tipi di autenticazione Amazon MSK sono supportati?](#troubleshooting-blueprints-22) + [Cos'è `sink.os.bulkFlushIntervalMillis` e come posso impostarlo?](#troubleshooting-blueprints-23) + [Quando distribuisco la mia applicazione Managed Service for Apache Flink, da quale punto dell'argomento Amazon MSK inizierà a leggere i messaggi?](#troubleshooting-blueprints-24) + [Come posso usare`source.msk.starting.offset`?](#troubleshooting-blueprints-25) + [Quali strategie di suddivisione in blocchi sono supportate?](#troubleshooting-blueprints-26) + [Come faccio a leggere i record nel mio datastore vettoriale?](#troubleshooting-blueprints-27) + [Dove posso trovare nuovi aggiornamenti al codice sorgente?](#troubleshooting-blueprints-28) + [Posso apportare una modifica al AWS CloudFormation modello e aggiornare l'applicazione Managed Service for Apache Flink?](#troubleshooting-blueprints-29) + [AWS Monitorerà e gestirà l'applicazione per mio conto?](#troubleshooting-blueprints-30) + [Questa applicazione sposta i miei dati al di fuori del mio Account AWS?](#troubleshooting-blueprints-31) ## Quali risorse crea AWS questo modello? Per trovare le risorse distribuite nel tuo account, accedi alla AWS CloudFormation console e identifica il nome dello stack che inizia con il nome che hai fornito per l'applicazione Managed Service for Apache Flink. Scegli la scheda **Risorse** per controllare le risorse che sono state create come parte dello stack. Le seguenti sono le risorse chiave create dallo stack: + Servizio gestito di incorporamento vettoriale in tempo reale per l'applicazione Apache Flink + Bucket Amazon S3 per contenere il codice sorgente per l'applicazione di incorporamento vettoriale in tempo reale + CloudWatch gruppo di log e flusso di log per l'archiviazione dei log + Funzioni Lambda per il recupero e la creazione di risorse + Ruoli e policy IAM per Lambdas, Managed Service for Apache Flink e accesso ad Amazon Bedrock e Amazon Service OpenSearch + Politica di accesso ai dati per Amazon OpenSearch Service + Endpoint VPC per accedere ad Amazon Bedrock e Amazon Service OpenSearch ## Quali sono le mie azioni una volta completata l'implementazione dello AWS CloudFormation stack? Una volta completata la distribuzione AWS CloudFormation dello stack, accedi alla console Managed Service for Apache Flink e trova l'applicazione blueprint Managed Service for Apache Flink. Scegli la scheda **Configura** e conferma che tutte le proprietà di runtime siano configurate correttamente. Potrebbero passare alla pagina successiva. Quando sei sicuro delle impostazioni, scegli **Esegui**. L'applicazione inizierà a importare i messaggi dal tuo argomento. [Per verificare la presenza di nuove versioni, https://github.com/awslabs/ real-time-vectorization-of consulta -streaming-data/releases.](https://github.com/awslabs/real-time-vectorization-of-streaming-data/releases) ## Quale dovrebbe essere la struttura dei dati negli argomenti di origine di Amazon MSK? Al momento supportiamo dati di origine strutturati e non strutturati. + I dati non strutturati sono indicati con in. `STRING` `source.msk.data.type` I dati vengono letti così come sono dal messaggio in arrivo. + Attualmente supportiamo i dati JSON strutturati, indicati con in. `JSON` `source.msk.data.type` I dati devono essere sempre in formato JSON. Se l'applicazione riceve un codice JSON non valido, l'applicazione fallirà. + Quando utilizzi JSON come tipo di dati di origine, assicurati che ogni messaggio in tutti gli argomenti di origine sia un JSON valido. Se sottoscrivi uno o più argomenti che non contengono oggetti JSON con questa impostazione, l'applicazione avrà esito negativo. Se uno o più argomenti contengono una combinazione di dati strutturati e non strutturati, si consiglia di configurare i dati di origine come non strutturati nell'applicazione Managed Service for Apache Flink. ## Posso specificare parti di un messaggio da incorporare? + Per i `source.msk.data.type` dati di input non strutturati`STRING`, l'applicazione incorporerà sempre l'intero messaggio e memorizzerà l'intero messaggio nell'indice configurato. OpenSearch + Per i dati di input strutturati where `source.msk.data.type` is`JSON`, è possibile configurare in modo `embed.input.config.json.fieldsToEmbed` da specificare quale campo dell'oggetto JSON deve essere selezionato per l'incorporamento. Funziona solo per i campi JSON di primo livello e non funziona con i messaggi annidati JSONs e contenenti un array JSON. Usa .\$1 per incorporare l'intero JSON. ## Posso leggere dati da più argomenti di Amazon MSK? Sì, con questa applicazione puoi leggere dati da più argomenti di Amazon MSK. I dati di tutti gli argomenti devono essere dello stesso tipo (STRING o JSON), altrimenti l'applicazione potrebbe fallire. I dati di tutti gli argomenti vengono sempre archiviati in un unico OpenSearch indice. ## Posso usare regex per configurare i nomi degli argomenti di Amazon MSK? `source.msk.topic.names`non supporta un elenco di espressioni regolari. Supportiamo un elenco separato da virgole di nomi di argomenti o `.*` espressioni regolari per includere tutti gli argomenti. ## Qual è la dimensione massima di un messaggio che può essere letto da un argomento di Amazon MSK? La dimensione massima di un messaggio che può essere elaborato è limitata dal limite di InvokeModel corpi di Amazon Bedrock, attualmente impostato su 25.000.000. Per ulteriori informazioni, consulta [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html#API_runtime_InvokeModel_RequestBody). ## Che tipo di è supportato? OpenSearch Supportiamo sia i OpenSearch domini che le raccolte. Se utilizzi una OpenSearch raccolta, assicurati di utilizzare una raccolta vettoriale e di creare un indice vettoriale da utilizzare per questa applicazione. Questo vi permetterà di utilizzare le funzionalità del database OpenSearch vettoriale per interrogare i vostri dati. Per ulteriori informazioni, consulta la [spiegazione delle funzionalità dei database vettoriali di Amazon OpenSearch Service](https://aws.amazon.com/blogs/big-data/amazon-opensearch-services-vector-database-capabilities-explained/). ## Perché devo utilizzare una raccolta di ricerca vettoriale, un indice vettoriale e aggiungere un campo vettoriale nella mia raccolta Serverless? OpenSearch Il tipo di raccolta di *ricerca vettoriale* in OpenSearch Serverless offre una funzionalità di ricerca per similarità scalabile e ad alte prestazioni. Semplifica la creazione di moderne esperienze di ricerca aumentata di machine learning (ML) e applicazioni generative di intelligenza artificiale (AI). Per ulteriori informazioni, consulta [Lavorare con le raccolte di ricerca vettoriale](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-vector-search.html?icmpid=docs_console_unmapped). ## Cosa devo impostare come dimensione per il mio campo vettoriale? Imposta la dimensione del campo vettoriale in base al modello di incorporamento che desideri utilizzare. Fate riferimento alla tabella seguente e confermate questi valori dalla rispettiva documentazione. **Dimensioni dei campi vettoriali** | Nome del modello di incorporamento vettoriale Amazon Bedrock | Supporto per le dimensioni di output offerto dal modello | | --- | --- | | Incorporamenti di testo Amazon Titan V1 | 1.536 | | Embedding di testo Amazon Titan V2 | 1.024 (impostazione predefinita), 384, 256 | | Amazon Titan Multimodal Embeddings G1 | 1.024 (impostazione predefinita), 384, 256 | | Cohere Embed English | 1,024 | | Cohere Embed Multilingual | 1,024 | ## Che aspetto ha l'output nell'indice OpenSearch configurato? Ogni documento dell' OpenSearch indice contiene i seguenti campi: + **original\$1data: i dati** utilizzati per generare gli incorporamenti. Per il tipo STRING, è l'intero messaggio. Per l'oggetto JSON, è l'oggetto JSON utilizzato per gli incorporamenti. Potrebbe essere l'intero JSON nel messaggio o i campi specificati nel JSON. Ad esempio, se il nome fosse selezionato per essere incorporato nei messaggi in arrivo, l'output sarebbe il seguente: ``` "original_data": "{\"name\":\"John Doe\"}" ``` + **embedded\$1data**: una matrice vettoriale float di incorporamenti generata da Amazon Bedrock + **data: timestamp** UTC in cui il documento è stato archiviato OpenSearch ## Posso specificare campi di metadati da aggiungere al documento memorizzato nell'indice? OpenSearch No, al momento non supportiamo l'aggiunta di campi aggiuntivi al documento finale memorizzato nell' OpenSearch indice. ## Devo aspettarmi voci duplicate nell' OpenSearch indice? A seconda di come è stata configurata l'applicazione, è possibile che nell'indice vengano visualizzati messaggi duplicati. Uno dei motivi più comuni è il riavvio dell'applicazione. L'applicazione è configurata per impostazione predefinita per iniziare a leggere dal primo messaggio nell'argomento di origine. Quando si modifica la configurazione, l'applicazione si riavvia ed elabora nuovamente tutti i messaggi dell'argomento. Per evitare la rielaborazione, consultate la documentazione su come utilizzare source.msk.starting.offset e impostate correttamente l'offset iniziale per l'applicazione. ## Posso inviare dati a più indici? OpenSearch No, l'applicazione supporta l'archiviazione dei dati in un unico OpenSearch indice. Per configurare l'output di vettorizzazione su più indici, è necessario distribuire un servizio gestito separato per le applicazioni Apache Flink. ## Posso implementare più applicazioni di incorporamento vettoriale in tempo reale in un'unica applicazione? Account AWS Sì, puoi distribuire più servizi gestiti di incorporamento vettoriale in tempo reale per applicazioni Apache Flink in un'unica Account AWS applicazione se ogni applicazione ha un nome univoco. ## Più applicazioni di incorporamento vettoriale in tempo reale possono utilizzare la stessa fonte di dati o lo stesso sink? Sì, puoi creare più servizi gestiti di incorporamento vettoriale in tempo reale per applicazioni Apache Flink che leggono i dati dallo stesso argomento o archiviano i dati nello stesso indice. ## L'applicazione supporta la connettività tra account? No, affinché l'applicazione funzioni correttamente, il cluster Amazon MSK e la OpenSearch raccolta devono trovarsi nello stesso Account AWS punto in cui stai tentando di configurare l'applicazione Managed Service for Apache Flink. ## L'applicazione supporta la connettività tra regioni? No, l'applicazione consente solo di distribuire un'applicazione Managed Service for Apache Flink con un cluster Amazon MSK e una OpenSearch raccolta nella stessa regione dell'applicazione Managed Service for Apache Flink. ## Il mio cluster e la mia OpenSearch raccolta Amazon MSK possono trovarsi in VPCs sottoreti diverse? Sì, supportiamo il cluster e la OpenSearch raccolta Amazon MSK in diverse VPCs sottoreti, purché si trovino nella stessa. Account AWS Vedi (Risoluzione dei problemi generali di MSF) per verificare che la configurazione sia corretta. ## Quali modelli di incorporamento sono supportati dall'applicazione? Attualmente, l'applicazione supporta tutti i modelli supportati da Bedrock. Ciò include: + Titan Embeddings G1 - Text + Embedding di testo Amazon Titan V2 + Amazon Titan Multimodal Embeddings G1 + Cohere Embed English + Cohere Embed Multilingual ## Posso ottimizzare le prestazioni della mia applicazione in base al mio carico di lavoro? Sì. La velocità effettiva dell'applicazione dipende da una serie di fattori, tutti controllabili dai clienti: 1. **AWS MSF KPUs**: L'applicazione viene distribuita con fattore di parallelismo predefinito 2 e parallelismo per KPU 1, con ridimensionamento automatico attivato. Tuttavia, ti consigliamo di configurare la scalabilità per l'applicazione Managed Service for Apache Flink in base ai tuoi carichi di lavoro. Per ulteriori informazioni, consulta [Review Managed Service for Apache](https://docs.aws.amazon.com/managed-flink/latest/java/how-resources.html) Flink application Resources. 1. **Amazon Bedrock**: in base al modello on-demand di Amazon Bedrock selezionato, potrebbero essere applicate quote diverse. Controlla le quote di servizio in Bedrock per vedere il carico di lavoro che il servizio sarà in grado di gestire. Per ulteriori informazioni, consulta [Quotas for Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/quotas.html). 1. **Amazon OpenSearch Service**: inoltre, in alcune situazioni, potresti notare che questo OpenSearch è il collo di bottiglia nella tua pipeline. Per informazioni sulla scalabilità, consulta OpenSearch [Ridimensionamento dei domini OpenSearch Amazon Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/sizing-domains.html). ## Quali tipi di autenticazione Amazon MSK sono supportati? Supportiamo solo il tipo di autenticazione IAM MSK. ## Cos'è `sink.os.bulkFlushIntervalMillis` e come posso impostarlo? Quando si inviano dati ad Amazon OpenSearch Service, l'intervallo di trasferimento in blocco è l'intervallo in cui viene eseguita la richiesta in blocco, indipendentemente dal numero di azioni o dalla dimensione della richiesta. Il valore predefinito è impostato su 1 millisecondo. L'impostazione di un intervallo di lavaggio può aiutare a garantire che i dati vengano indicizzati tempestivamente, ma può anche comportare un aumento del sovraccarico se impostato su un valore troppo basso. Considerate il vostro caso d'uso e l'importanza di un'indicizzazione tempestiva quando scegliete un intervallo di flush. ## Quando distribuisco la mia applicazione Managed Service for Apache Flink, da quale punto dell'argomento Amazon MSK inizierà a leggere i messaggi? L'applicazione inizierà a leggere i messaggi dall'argomento Amazon MSK all'offset specificato dalla `source.msk.starting.offset` configurazione impostata nella configurazione di runtime dell'applicazione. Se non `source.msk.starting.offset` è impostato in modo esplicito, il comportamento predefinito dell'applicazione consiste nell'iniziare a leggere dal primo messaggio disponibile nell'argomento. ## Come posso usare`source.msk.starting.offset`? Imposta esplicitamente s `ource.msk.starting.offset` su uno dei seguenti valori, in base al comportamento desiderato: + EARLEST: L'impostazione predefinita, che legge dall'offset più vecchio nella partizione. Questa è una buona scelta soprattutto se: + Hai appena creato argomenti e applicazioni consumer di Amazon MSK. + È necessario riprodurre i dati, in modo da poter creare o ricostruire lo stato. Ciò è importante quando si implementa il pattern di approvvigionamento degli eventi o quando si inizializza un nuovo servizio che richiede una visualizzazione completa della cronologia dei dati. + ULTIMO: L'applicazione Managed Service for Apache Flink leggerà i messaggi dalla fine della partizione. Ti consigliamo questa opzione se ti interessa solo la produzione di nuovi messaggi e non hai bisogno di elaborare dati storici. In questa impostazione, il consumatore ignorerà i messaggi esistenti e leggerà solo i nuovi messaggi pubblicati dal produttore originale. + COMMITTED: L'applicazione Managed Service for Apache Flink inizierà a consumare i messaggi provenienti dall'offset impegnato del gruppo di consumatori. Se l'offset confermato non esiste, verrà utilizzata la strategia di ripristino EARLIEST. ## Quali strategie di suddivisione in blocchi sono supportate? Stiamo usando la libreria [langchain](https://js.langchain.com/v0.1/docs/get_started/introduction/) per suddividere gli input. Il chunking viene applicato solo se la lunghezza dell'input è maggiore di quella scelta. `maxSegmentSizeInChars` Supportiamo i seguenti cinque tipi di chunking: + `SPLIT_BY_CHARACTER`: Inserirà il maggior numero di caratteri possibile in ogni blocco in cui la lunghezza di ogni blocco non è maggiore di. maxSegmentSize InChars Non gli interessa lo spazio bianco, quindi può tagliare le parole. + `SPLIT_BY_WORD`: troverà i caratteri di spaziatura in base ai quali suddividere. Nessuna parola viene interrotta. + `SPLIT_BY_SENTENCE`: I limiti delle frasi vengono rilevati utilizzando la libreria Apache OpenNLP con il modello di frase in inglese. + `SPLIT_BY_LINE`: troverà nuovi caratteri di riga in base ai quali suddividere. + `SPLIT_BY_PARAGRAPH`: troverà nuovi caratteri di riga consecutivi in base ai quali suddividere in blocchi. Le strategie di suddivisione rientrano nell'ordine precedente, a cui ricorrono le strategie di suddivisione in blocchi più grandi. `SPLIT_BY_PARAGRAPH` `SPLIT_BY_CHARACTER` Ad esempio, quando si utilizza`SPLIT_BY_LINE`, se una riga è troppo lunga, la riga verrà suddivisa in blocchi per frase, dove ogni blocco può contenere quante più frasi possibile. Se ci sono frasi troppo lunghe, verranno suddivise in blocchi a livello di parola. Se una parola è troppo lunga, verrà divisa per carattere. ## Come faccio a leggere i record nel mio datastore vettoriale? 1. Quando è `source.msk.data.type` `STRING` + **original\$1data**: l'intera stringa originale del messaggio Amazon MSK. + **embedded\$1data**: vettore di incorporamento creato se non è vuoto (suddivisione in blocchi applicata) o creato da `chunk_data` se non è stato applicato alcun chunking. `original_data` + **chunk\$1data: presente solo quando i dati originali sono stati suddivisi in blocchi**. Contiene la parte del messaggio originale che è stata utilizzata per creare l'incorporamento. `embedded_data` 1. Quando è `source.msk.data.type` `JSON` + **original\$1data**: l'intero codice JSON originale del messaggio Amazon MSK *dopo l'applicazione del filtro delle chiavi JSON*. + **embedded\$1data**: vettore di incorporamento creato se non è vuoto (suddivisione in blocchi applicata) o creato da `chunk_data` se non è stata applicata alcuna suddivisione in blocchi. `original_data` + **chunk\$1key: presente solo quando i dati originali erano suddivisi in blocchi**. Contiene la chiave JSON da cui proviene il blocco. `original_data` Ad esempio, può assomigliare alle chiavi o `jsonKey1.nestedJsonKeyA` ai *metadati* annidati nell'esempio di. `original_data` + **chunk\$1data: presente solo quando i dati** originali erano suddivisi in blocchi. Contiene la parte del messaggio originale che è stata utilizzata per creare l'incorporamento. `embedded_data` Sì, con questa applicazione puoi leggere dati da più argomenti di Amazon MSK. I dati di tutti gli argomenti devono essere dello stesso tipo (STRING o JSON), altrimenti l'applicazione potrebbe fallire. I dati di tutti gli argomenti vengono sempre archiviati in un unico OpenSearch indice. ## Dove posso trovare nuovi aggiornamenti al codice sorgente? Vai a [https://github.com/awslabs/real-time-vectorization-of-streaming-data/releases](https://github.com/awslabs/real-time-vectorization-of-streaming-data/releases) per verificare la presenza di nuove versioni. ## Posso apportare una modifica al AWS CloudFormation modello e aggiornare l'applicazione Managed Service for Apache Flink? No, apportare una modifica al AWS CloudFormation modello non aggiorna l'applicazione Managed Service for Apache Flink. Qualsiasi nuova modifica AWS CloudFormation implica la necessità di implementare un nuovo stack. ## AWS Monitorerà e gestirà l'applicazione per mio conto? No, non AWS monitorerà, ridimensionerà, aggiornerà o applicherà patch a questa applicazione per tuo conto. ## Questa applicazione sposta i miei dati al di fuori del mio Account AWS? Tutti i dati letti e archiviati dall'applicazione Managed Service for Apache Flink rimangono all'interno dell'utente Account AWS e non escono mai dal suo account. # Blueprint di incorporamento vettoriale in tempo reale: risoluzione dei problemi Consulta i seguenti argomenti di risoluzione dei problemi relativi ai blueprint di incorporamento vettoriale in tempo reale. [Per ulteriori informazioni sui blueprint di incorporamento vettoriale in tempo reale, consulta Blueprint di incorporamento vettoriale in tempo reale.](https://docs.aws.amazon.com/msk/latest/developerguide/ai-vector-embedding-integration-learn-more.html) **Topics** + [La mia distribuzione CloudFormation dello stack non è riuscita o è stata ripristinata. Cosa posso fare per risolvere il problema?](#troubleshooting-blueprints-deployment) + [Non voglio che la mia applicazione inizi a leggere i messaggi dall'inizio degli argomenti di Amazon MSK. Cosa devo fare?](#troubleshooting-blueprints-beginning) + [Come faccio a sapere se c'è un problema con la mia applicazione Managed Service for Apache Flink e come posso eseguirne il debug?](#troubleshooting-blueprints-debug) + [Quali sono le metriche chiave che devo monitorare per la mia applicazione Managed Service for Apache Flink?](#troubleshooting-blueprints-metrics) ## La mia distribuzione CloudFormation dello stack non è riuscita o è stata ripristinata. Cosa posso fare per risolvere il problema? + Vai al tuo stack CFN e trova il motivo dell'errore dello stack. Potrebbe essere correlato alla mancanza di autorizzazioni, alle collisioni tra i nomi AWS delle risorse, tra le altre cause. Risolvi la causa principale dell'errore di distribuzione. Per ulteriori informazioni, consulta la [guida alla CloudWatch risoluzione dei problemi](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/troubleshooting.html#basic-ts-guide). + [Facoltativo] Può esserci un solo endpoint VPC per servizio per VPC. Se hai distribuito più blueprint di incorporamento vettoriale in tempo reale per scrivere nelle raccolte di Amazon OpenSearch Service nello stesso VPC, è possibile che condividano gli endpoint VPC. Questi potrebbero essere già presenti nel tuo account per il VPC oppure il primo stack di blueprint di incorporamento vettoriale in tempo reale creerà endpoint VPC per Amazon Bedrock e Amazon OpenSearch Service che verranno utilizzati da tutti gli altri stack distribuiti nel tuo account. Se uno stack fallisce, controlla se quello stack ha creato endpoint VPC per Amazon Bedrock e Amazon OpenSearch Service ed eliminali se non vengono utilizzati in nessun'altra parte del tuo account. Per i passaggi per eliminare gli endpoint VPC, consulta la documentazione su come eliminare l'applicazione in modo sicuro. + Potrebbero esserci altri servizi o applicazioni nel tuo account che utilizzano l'endpoint VPC. La sua eliminazione potrebbe causare interruzioni della rete per altri servizi. Fai attenzione nell'eliminare questi endpoint. ## Non voglio che la mia applicazione inizi a leggere i messaggi dall'inizio degli argomenti di Amazon MSK. Cosa devo fare? È necessario impostare `source.msk.starting.offset` esplicitamente uno dei seguenti valori, a seconda del comportamento desiderato: + **Offset più** antico: l'offset più vecchio nella partizione. + **Ultimo offset**: i consumatori leggeranno i messaggi dalla fine della partizione. + **Offset confermato**: legge l'ultimo messaggio che il consumatore ha elaborato all'interno di una partizione. ## Come faccio a sapere se c'è un problema con la mia applicazione Managed Service for Apache Flink e come posso eseguirne il debug? Utilizza la [guida alla risoluzione dei problemi relativi a Managed Service for Apache Flink per eseguire il debug dei problemi relativi](https://docs.aws.amazon.com/managed-flink/latest/java/troubleshooting-runtime.html) a Managed Service for Apache Flink con la tua applicazione. ## Quali sono le metriche chiave che devo monitorare per la mia applicazione Managed Service for Apache Flink? + Tutte le metriche disponibili per una normale applicazione Managed Service for Apache Flink possono aiutarti a monitorare la tua applicazione. Per ulteriori informazioni, consulta [Metriche e dimensioni in Managed Service](https://docs.aws.amazon.com/managed-flink/latest/java/metrics-dimensions.html) for Apache Flink. + Per monitorare i parametri di Amazon Bedrock, consulta i parametri Amazon [ CloudWatch per Amazon](https://docs.aws.amazon.com/bedrock/latest/userguide/monitoring.html#runtime-cloudwatch-metrics) Bedrock. + Abbiamo aggiunto due nuove metriche per il monitoraggio delle prestazioni di generazione di incorporamenti. Li trovi sotto il nome dell'`EmbeddingGeneration`operazione in. CloudWatch Le due metriche sono: + **BedrockTitanEmbeddingTokenCount**: numero di token presenti in una singola richiesta ad Amazon Bedrock. + **BedrockEmbeddingGenerationLatencyMs**: riporta il tempo impiegato per inviare e ricevere una risposta da Amazon Bedrock per la generazione di incorporamenti, in millisecondi. + Per le raccolte serverless di Amazon OpenSearch Service, puoi utilizzare metriche come `IngestionDocumentErrors` e `IngestionDataRate` altre. Per ulteriori informazioni, consulta [Monitoring OpenSearch Serverless with Amazon CloudWatch](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/monitoring-cloudwatch.html). + Per i OpenSearch parametri assegnati, consulta [Monitoraggio dei parametri OpenSearch del cluster con Amazon](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/managedomains-cloudwatchmetrics.html). CloudWatch