

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Solución de problemas de implementación
<a name="troubleshooting-development"></a>

Esta sección contiene información sobre el diagnóstico y la solución de problemas de implementación con su aplicación Managed Service para Apache Flink.

**Topics**
+ [Prácticas recomendadas de reversión del sistema](troubleshooting-system-rollback.md)
+ [Prácticas recomendadas de configuración de Hudi](troubleshooting-hudi.md)
+ [Gráficos de Apache Flink Flame](troubleshooting-update-flamegraphs.md)
+ [Problema del proveedor de credenciales con el conector EFO 1.15.2](troubleshooting-credential-provider.md)
+ [Aplicaciones con conectores Kinesis no compatibles](troubleshooting-unsupported-kinesis-connectors.md)
+ [Error de compilación: “Could not resolve dependencies for project”](troubleshooting-compile.md)
+ [Opción no válida: “kinesisanalyticsv2”](troubleshooting-cli-update.md)
+ [UpdateApplication la acción no es volver a cargar el código de la aplicación](troubleshooting-update.md)
+ [S3 StreamingFileSink FileNotFoundExceptions](troubleshooting-s3sink.md)
+ [FlinkKafkaConsumer problema con stop with savepoint](troubleshooting-FlinkKafkaConsumer.md)
+ [Bloqueo de Flink 1.15 Async Sink](troubleshooting-async-deadlock.md)
+ [El procesamiento del origen de Amazon Kinesis Data Streams no funciona durante la partición nueva.](troubleshooting-kinesis-data-streams-processing-out-of-order.md)
+ [Preguntas frecuentes y solución de problemas de esquemas de incrustación vectorial en tiempo real](troubleshooting-blueprints.md)

# Prácticas recomendadas de reversión del sistema
<a name="troubleshooting-system-rollback"></a>

Con las funciones de reversión automática del sistema y visibilidad de las operaciones de Amazon Managed Service para Apache Flink, se pueden identificar y resolver problemas con sus aplicaciones.

## Restauraciones del sistema
<a name="troubleshooting-unsupported-kinesis-connectors-error"></a>

Si la operación de actualización o escalado de la aplicación falla debido a un error del cliente, como un error de código o un problema de permisos, Amazon Managed Service para Apache Flink intentará volver de manera automática a la versión anterior en ejecución si ha optado por esta funcionalidad. Para obtener más información, consulte [Habilitación de las restauraciones del sistema para la aplicación Amazon Managed Service para Apache Flink](how-system-rollbacks.md). Si esta reversión automática no se realiza correctamente o si no se ha optado por activarla, su solicitud se colocará en el estado `READY`. Complete los pasos que se indican a continuación para actualizar la aplicación:   Consulte la consola de Amazon Managed Service para Apache Flink o utilice la API de `DescribeApplicationOperation` para ver la descripción del error que explica por qué se ha producido un error en la operación.    Para ver la pila de errores completa, use los [registros de Cloudwatch](https://docs.aws.amazon.com/managed-flink/latest/java/logging.html).   Los problemas más comunes son la falta de permisos, los cambios de código incompatibles o las configuraciones incorrectas de la infraestructura. Resuelva el problema de fondo.    Use la API de `UpdateApplicaton` para volver a implementar la nueva versión de la aplicación.    

## Restauraciones manuales
<a name="troubleshooting-unsupported-kinesis-connectors-error"></a>

Si la aplicación no progresa y permanece en un estado transitorio durante mucho tiempo, o si la aplicación ha realizado la transición a `Running` correctamente, pero observa problemas posteriores, como errores de procesamiento, en una aplicación de Flink que se ha actualizado correctamente, se puede revertir manualmente mediante la API de `RollbackApplication`.

1. Llamada `RollbackApplication`: se revertirá a la versión anterior en ejecución y se restaurará el estado anterior. 

1. Monitoree la operación de reversión mediante la API de `DescribeApplicationOperation`.

1. Si la reversión falla, siga los pasos anteriores de reversión del sistema.

## Visibilidad de las operaciones
<a name="troubleshooting-unsupported-kinesis-connectors-error"></a>

La API de `ListApplicationOperations` muestra el historial de todas las operaciones de los clientes y del sistema en su aplicación.

1. Obtenga el *ID de operación* de la operación fallida de la lista.

1. Llame `DescribeApplicationOperation` y compruebe el estado y *statusDescription*.

1. Si una operación ha fallado, la descripción apunta a un posible error que hay que investigar. 

**Errores comunes en los códigos de error:** utilice las funciones de reversión para volver a la última versión en funcionamiento. Resuelva los errores y vuelva a intentar la actualización. 

**Problemas con los permisos:** utilice la `DescribeApplicationOperation` para ver los permisos necesarios. Actualice los permisos de la aplicación y vuelva a intentarlo. 

**Problemas con el servicio Amazon Managed Service para Apache Flink:** consulta Panel de AWS Health o abre un caso de soporte.

# Prácticas recomendadas de configuración de Hudi
<a name="troubleshooting-hudi"></a>

Para ejecutar los conectores Hudi en Managed Service para Apache Flink, recomendamos los siguientes cambios de configuración.

Deshabilitar `hoodie.embed.timeline.server`

El conector Hudi de Flink configura un servidor de cronograma (TM) integrado en el gestor de tareas (JM) de Flink para almacenar en caché los metadatos y mejorar el rendimiento cuando el paralelismo de las tareas es elevado. Se recomienda que desactive este servidor integrado en Managed Service para Apache Flink, ya que deshabilitamos la comunicación que no es de Flink entre JM y TM.

Si este servidor está activado, las escrituras de Hudi primero intentarán conectarse al servidor integrado en JM y, a continuación, volverán a leer los metadatos de Amazon S3. Esto significa que Hudi tiene un tiempo de espera de conexión, lo que retrasa las escrituras de Hudi y repercute en el rendimiento de Managed Service para Apache Flink.

# Gráficos de Apache Flink Flame
<a name="troubleshooting-update-flamegraphs"></a>

Los gráficos de Flame están habilitados de forma predeterminada en las aplicaciones de las versiones compatibles de Managed Service para Apache Flink. Los gráficos de Flame pueden afectar el rendimiento de la aplicación si se mantiene el gráfico abierto, como se menciona en la [documentación de Flink](https://nightlies.apache.org/flink/flink-docs-release-1.15//docs/ops/debugging/flame_graphs/). 

 Si desea deshabilitar los gráficos de Flame para la aplicación, genere un caso para solicitar que se los deshabilite para el ARN de la aplicación. Para obtener más información, consulte el [Centro de soporte de AWS](https://console.aws.amazon.com/support/home#/).

# Problema del proveedor de credenciales con el conector EFO 1.15.2
<a name="troubleshooting-credential-provider"></a>

Existe un [problema conocido](https://issues.apache.org/jira/browse/FLINK-29205) con las versiones del conector EFO de Kinesis Data Streams anteriores a la 1.15.2, en donde `FlinkKinesisConsumer` no respeta la configuración del `Credential Provider`. Debido a este problema, se descartan configuraciones válidas, lo que provoca que se utilice el proveedor de credenciales `AUTO`. Esto puede provocar un problema al utilizar el acceso entre cuentas a Kinesis mediante el conector EFO.

Para resolver este error, utilice la versión 1.15.3 o superior del conector EFO. 

# Aplicaciones con conectores Kinesis no compatibles
<a name="troubleshooting-unsupported-kinesis-connectors"></a>

Managed Service for Apache Flink for Apache Flink versión 1.15 o posterior [rechazará automáticamente el inicio o la actualización de las aplicaciones si utilizan versiones no compatibles de](https://docs.aws.amazon.com/managed-flink/latest/java/flink-1-15-2.html) Kinesis Connector (anteriores a la versión 1.15.2) incluidas en la aplicación o en los archivos (ZIP). JARs 

## Error de rechazo
<a name="troubleshooting-unsupported-kinesis-connectors-error"></a>

Aparecerá el siguiente error al enviar las llamadas de creación o actualización de la aplicación:

```
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
```

## Pasos para solucionarlo
<a name="troubleshooting-unsupported-kinesis-connectors-steps-to-remediate"></a>
+ Actualice la dependencia de la aplicación en `flink-connector-kinesis`. Si se utiliza Maven como la herramienta de creación de su proyecto, siga [Actualización de una dependencia de Maven](#troubleshooting-unsupported-kinesis-connectors-update-maven-dependency). Si usa Gradle, siga [Actualización de una dependencia de Gradle](#troubleshooting-unsupported-kinesis-connectors-update-gradle-dependency).
+ Vuelva a empaquetar la aplicación.
+ Cargue en un bucket de Amazon S3.
+ Vuelva a enviar la solicitud de creación o actualización de la aplicación con la aplicación modificada que se acaba de cargar en el bucket de Amazon S3.
+ Si sigue apareciendo el mismo mensaje de error, vuelva a comprobar las dependencias de la aplicación. Si el problema persiste, cree una inidencia de soporte técnicio. 

### Actualización de una dependencia de Maven
<a name="troubleshooting-unsupported-kinesis-connectors-update-maven-dependency"></a>

1. Abra el `pom.xml` del proyecto.

1. Encuentre las dependencias del proyecto. Aparecen así:

   ```
   <project>
   
       ...
   
       <dependencies>
   
           ...
   
           <dependency>
               <groupId>org.apache.flink</groupId>
               <artifactId>flink-connector-kinesis</artifactId>
           </dependency>
   
           ...
   
       </dependencies>
   
       ...
   
   </project>
   ```

1. Actualice `flink-connector-kinesis` a una versión igual o posterior a la 1.15.2. Por ejemplo:

   ```
   <project>
   
       ...
   
       <dependencies>
   
           ...
   
           <dependency>
               <groupId>org.apache.flink</groupId>
               <artifactId>flink-connector-kinesis</artifactId>
               <version>1.15.2</version>
           </dependency>
   
           ...
   
       </dependencies>
   
       ...
   
   </project>
   ```

### Actualización de una dependencia de Gradle
<a name="troubleshooting-unsupported-kinesis-connectors-update-gradle-dependency"></a>

1. Abra el `build.gradle` del proyecto (o `build.gradle.kts` para las aplicaciones de Kotlin). 

1. Encuentre las dependencias del proyecto. Aparecen así:

   ```
   ...
   
   dependencies {
   
       ...
   
       implementation("org.apache.flink:flink-connector-kinesis")
   
       ...
   
   }
   
   ...
   ```

1. Actualice `flink-connector-kinesis` a una versión igual o posterior a la 1.15.2. Por ejemplo:

   ```
   ...
   
   dependencies {
   
       ...
   
       implementation("org.apache.flink:flink-connector-kinesis:1.15.2")
   
       ...
   
   }
   
   ...
   ```

# Error de compilación: “Could not resolve dependencies for project”
<a name="troubleshooting-compile"></a>

Para compilar las aplicaciones de ejemplo de Managed Service para Apache Flink, primero debe descargar y compilar el conector Apache Flink Kinesis y añadirlo a su repositorio local de Maven. Si el conector no se ha agregado a su repositorio, aparece un error de compilación similar al siguiente:

```
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
```

Para resolver este error, debe descargar el código fuente de Apache Flink (desde la versión 1.8.2) para el conector. [https://flink.apache.org/downloads.html](https://flink.apache.org/downloads.html) Para obtener instrucciones sobre cómo descargar, compilar e instalar el código fuente de Apache Flink, consulte [Uso del conector Apache Flink Kinesis Streams con versiones anteriores de Apache Flink](earlier.md#how-creating-apps-building-kinesis).

# Opción no válida: “kinesisanalyticsv2”
<a name="troubleshooting-cli-update"></a>

Para usar la versión 2 de la API de Managed Service para Apache Flink, necesita la última versión de AWS Command Line Interface (AWS CLI).

Para obtener información sobre cómo actualizar el AWS CLI, consulte [Instalación del AWS Command Line Interface en la](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) Guía del *AWS Command Line Interface usuario*.

# UpdateApplication la acción no es volver a cargar el código de la aplicación
<a name="troubleshooting-update"></a>

La [UpdateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html)acción no volverá a cargar el código de la aplicación con el mismo nombre de archivo si no se especifica ninguna versión del objeto S3. Para volver a cargar el código de la aplicación con el mismo nombre de archivo, habilite el control de versiones en el bucket de S3 y especifique la versión del nuevo objeto mediante el parámetro `ObjectVersionUpdate`. Para obtener más información sobre la habilitación del control de versiones de objetos en un bucket de S3, consulte [Enabling or Disabling Versioning](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/enable-versioning.html).

# S3 StreamingFileSink FileNotFoundExceptions
<a name="troubleshooting-s3sink"></a>

Las aplicaciones de Managed Service para Apache Flink pueden ejecutarse en un archivo `FileNotFoundException` parcial en curso cuando se parte de instantáneas si falta un archivo parcial en curso al que se hace referencia por su punto de guardado. Cuando se produce este modo de error, el estado de operador de la aplicación Managed Service para Apache Flink no suele ser recuperable y debe reiniciarse sin instantánea mediante `SKIP_RESTORE_FROM_SNAPSHOT`. Consulte el siguiente ejemplo de stacktrace:

```
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)
...
```

`StreamingFileSink` de Flink escribe registros en sistemas de archivos compatibles con [File Systems](https://nightlies.apache.org/flink/flink-docs-release-1.15/docs/deployment/filesystems/overview/). Dado que los flujos entrantes pueden ser ilimitados, los datos se organizan en archivos parciales de tamaño finito y se añaden nuevos archivos a medida que se escriben los datos. El ciclo de vida parcial y la política de renovación determinan el momento, el tamaño y la denominación de los archivos parciales. 

Durante los puntos de control y los puntos de guardado (creación de instantáneas), se cambia el nombre de todos los archivos pendientes y se los confirma. Sin embargo, los archivos parciales en curso no se confirman, sino que se les cambia el nombre, y se guarda su referencia en los metadatos de los puntos de control o de guardado para utilizarlos cuando se restauren los trabajos. Con el tiempo, estos archivos parciales en curso pasarán a estar Pendientes, se les cambiará el nombre y se los confirmará en un punto de control o guardado posterior.

A continuación se indican las causas principales y las medidas correctoras de la falta de un archivo parcial en curso:
+ Instantánea obsoleta utilizada para iniciar la aplicación Managed Service for Apache Flink: solo la última instantánea del sistema tomada cuando se detiene o actualiza una aplicación se puede usar para iniciar una aplicación Managed Service for Apache Flink con Amazon S3. StreamingFileSink Para evitar este tipo de error, utilice la última instantánea del sistema.
  + Esto ocurre, por ejemplo, cuando se selecciona una instantánea creada con `CreateSnapshot` en lugar de una instantánea activada por el sistema durante la detención o la actualización. El punto de guardado de la instantánea anterior guarda una out-of-date referencia a un archivo de pieza en curso al que se le ha cambiado el nombre y al que se ha asignado el siguiente punto de control o punto de guardado.
  + Esto también puede ocurrir cuando se selecciona una instantánea activada por el sistema a partir de un evento que no es el más reciente. Stop/Update Un ejemplo es una aplicación con la instantánea del sistema deshabilitada pero con configuración `RESTORE_FROM_LATEST_SNAPSHOT`. Por lo general, las aplicaciones de Managed Service for Apache Flink con Amazon S3 siempre StreamingFileSink deben tener habilitada y `RESTORE_FROM_LATEST_SNAPSHOT` configurada la instantánea del sistema.
+ Se elimina el archivo parcial en curso: dado que el archivo parcial en curso se encuentra en un bucket de S3, pueden eliminarlo otros componentes o actores que tengan acceso al bucket. 
  + Esto puede suceder si ha detenido la aplicación durante demasiado tiempo y la política de ciclo de vida de los buckets de [S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html) ha eliminado el archivo de parte en curso al que hace referencia el punto de almacenamiento de la aplicación. MultiPartUpload Para evitar este tipo de errores, asegúrese de que la política de ciclo de vida de S3 Bucket MPU abarque un período lo suficientemente amplio para su caso de uso.
  + Esto también puede ocurrir cuando el archivo parcial en curso se elimina manualmente o mediante otro de los componentes del sistema. Para evitar este tipo de errores, asegúrese de que otros actores o componentes no eliminen los archivos parciales en curso.
+ Condición de carrera en la que se activa un punto de control automático después del punto de guardado: esto afecta a las versiones de Managed Service para Apache Flink hasta la 1.13, inclusive. Este problema está solucionado en Managed Service para Apache Flink, versión 1.15. Migre la aplicación a la versión más reciente de Managed Service para Apache Flink para evitar la reaparición. También te sugerimos migrar de a. StreamingFileSink [FileSink](https://nightlies.apache.org/flink/flink-docs-release-1.19/docs/connectors/datastream/filesystem/#file-sink)
  + Cuando las aplicaciones se detienen o actualizan, Managed Service para Apache Flink activa un punto de guardado y detiene la aplicación en dos pasos. Si se activa un punto de control automático entre los dos pasos, el punto de guardado quedará inutilizable, ya que se cambiará el nombre del archivo parcial en curso y, posiblemente, se lo confirmará.

# FlinkKafkaConsumer problema con stop with savepoint
<a name="troubleshooting-FlinkKafkaConsumer"></a>

Al utilizar la versión antigua, FlinkKafkaConsumer existe la posibilidad de que la aplicación se bloquee al actualizar, detener o escalar si tiene habilitadas las instantáneas del sistema. No hay ninguna solución publicada disponible para este [problema](https://issues.apache.org/jira/browse/FLINK-28758), por lo que le recomendamos que actualice a la nueva [KafkaSource](https://nightlies.apache.org/flink/flink-docs-master/docs/connectors/datastream/kafka/#kafka-source)para mitigar este problema. 

Si se utiliza `FlinkKafkaConsumer` con las instantáneas habilitadas, existe la posibilidad de que, cuando el trabajo de Flink procese una detención con una solicitud de API de punto de guardado, `FlinkKafkaConsumer` falle con un error de tiempo de ejecución que indique `ClosedException`. En estas condiciones, la aplicación Flink se bloquea y se manifiesta como puntos de control fallidos. 

# Bloqueo de Flink 1.15 Async Sink
<a name="troubleshooting-async-deadlock"></a>

Existe un [problema conocido](https://issues.apache.org/jira/browse/FLINK-32230) con los AWS conectores de la AsyncSink interfaz de implementación de Apache Flink. Esto afecta a las aplicaciones que utilizan Flink 1.15 con los siguientes conectores: 
+ Para aplicaciones 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`
+ Aplicaciones FlinkSQL/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`

Las aplicaciones afectadas experimentarán los siguientes síntomas:
+ El trabajo de Flink está en estado de `RUNNING`, pero no está procesando datos.
+ No se reinicia ningún trabajo.
+ Se agota el tiempo de espera de los puntos de control.

El problema se debe a un [error](https://github.com/aws/aws-sdk-java-v2/issues/4354) en el AWS SDK que hace que la persona que llama no muestre ciertos errores cuando utiliza el cliente HTTP asíncrono. Esto hace que el receptor espere indefinidamente a que se complete una “solicitud en tránsito” durante una operación de vaciado de puntos de control.

**Este problema se solucionó en el AWS SDK a partir de la versión 2.20.144.** 

A continuación, se incluyen instrucciones sobre cómo actualizar los conectores afectados para usar la nueva versión del AWS SDK en sus aplicaciones:

**Topics**
+ [Actualización de las aplicaciones Java](troubleshooting-async-deadlock-update-java-apps.md)
+ [Actualizar aplicaciones de Python](troubleshooting-async-deadlock-update-python-apps.md)

# Actualización de las aplicaciones Java
<a name="troubleshooting-async-deadlock-update-java-apps"></a>

Siga los procedimientos que se indican a continuación para actualizar las aplicaciones Java:

## flink-connector-kinesis
<a name="troubleshooting-async-deadlock-update-java-apps-flink-connector-kinesis"></a>

Si la aplicación utiliza `flink-connector-kinesis`:

El conector de Kinesis usa el sombreado para empaquetar algunas dependencias, incluido el AWS SDK, en la jarra del conector. Para actualizar la versión del AWS SDK, utilice el siguiente procedimiento para reemplazar estas clases sombreadas:

------
#### [ Maven ]

1. Agregue el conector de Kinesis y los módulos del AWS SDK necesarios como dependencias del proyecto.

1. Configure `maven-shade-plugin`:

   1. Añada un filtro para excluir las clases de AWS SDK sombreadas al copiar el contenido del tarro del conector de Kinesis.

   1. Añada una regla de reubicación para mover las clases de AWS SDK actualizadas al paquete, según lo previsto por el conector de Kinesis.

   **pom.xml** 

   ```
   <project>
       ...    
       <dependencies>
           ...
           <dependency>
               <groupId>org.apache.flink</groupId>
               <artifactId>flink-connector-kinesis</artifactId>
               <version>1.15.4</version>
           </dependency>
           
           <dependency>
               <groupId>software.amazon.awssdk</groupId>
               <artifactId>kinesis</artifactId>
               <version>2.20.144</version>
           </dependency>
           <dependency>
               <groupId>software.amazon.awssdk</groupId>
               <artifactId>netty-nio-client</artifactId>
               <version>2.20.144</version>
           </dependency>
           <dependency>
               <groupId>software.amazon.awssdk</groupId>
               <artifactId>sts</artifactId>
               <version>2.20.144</version>
           </dependency>
           ...
       </dependencies>
       ...
       <build>
           ...
           <plugins>
               ...
               <plugin>
                   <groupId>org.apache.maven.plugins</groupId>
                   <artifactId>maven-shade-plugin</artifactId>
                   <version>3.1.1</version>
                   <executions>
                       <execution>
                           <phase>package</phase>
                           <goals>
                               <goal>shade</goal>
                           </goals>
                           <configuration>
                               ...
                               <filters>
                                   ...
                                   <filter>
                                       <artifact>org.apache.flink:flink-connector-kinesis</artifact>
                                       <excludes>
                                           <exclude>org/apache/flink/kinesis/shaded/software/amazon/awssdk/**</exclude>
                                           <exclude>org/apache/flink/kinesis/shaded/org/reactivestreams/**</exclude>
                                           <exclude>org/apache/flink/kinesis/shaded/io/netty/**</exclude>
                                           <exclude>org/apache/flink/kinesis/shaded/com/typesafe/netty/**</exclude>
                                       </excludes>
                                   </filter>
                                   ...
                               </filters>
                               <relocations>
                                   ...
                                   <relocation>
                                       <pattern>software.amazon.awssdk</pattern>
                                       <shadedPattern>org.apache.flink.kinesis.shaded.software.amazon.awssdk</shadedPattern>
                                   </relocation>
                                   <relocation>
                                       <pattern>org.reactivestreams</pattern>
                                       <shadedPattern>org.apache.flink.kinesis.shaded.org.reactivestreams</shadedPattern>
                                   </relocation>
                                   <relocation>
                                       <pattern>io.netty</pattern>
                                       <shadedPattern>org.apache.flink.kinesis.shaded.io.netty</shadedPattern>
                                   </relocation>
                                   <relocation>
                                       <pattern>com.typesafe.netty</pattern>
                                       <shadedPattern>org.apache.flink.kinesis.shaded.com.typesafe.netty</shadedPattern>
                                   </relocation>
                                   ...
                               </relocations>
                              ...
                           </configuration>
                       </execution>
                   </executions>
               </plugin>
               ...
           </plugins>
           ... 
       </build>
   </project>
   ```

------
#### [ Gradle ]

1. Agregue el conector de Kinesis y los módulos del AWS SDK necesarios como dependencias del proyecto.

1. Ajuste la configuración de ShadowJar:

   1. Excluya las clases de AWS SDK sombreadas al copiar el contenido del tarro del conector de Kinesis.

   1. Reubique las clases de AWS SDK actualizadas en un paquete esperado por el conector de 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")
   }
   ...
   ```

------

## Otros conectores afectados
<a name="troubleshooting-async-deadlock-update-java-apps-flink-another-connector"></a>

Si la aplicación utiliza otro conector afectado:

Para actualizar la versión del AWS SDK, se debe aplicar la versión del SDK en la configuración de compilación del proyecto.

------
#### [ Maven ]

Agrega la lista de materiales (BOM) del AWS SDK a la sección de administración de dependencias del `pom.xml` archivo para aplicar la versión del SDK al proyecto.

**pom.xml**

```
<project>
    ...    
    <dependencyManagement>
        <dependencies>
            ...
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>2.20.144</version>
                <scope>import</scope>
                <type>pom</type>
            </dependency>
            ...
        </dependencies>
    </dependencyManagement>
    ...
</project>
```

------
#### [ Gradle ]

Agregue la dependencia de la plataforma a la lista de materiales (BOM) del AWS SDK para aplicar la versión del SDK al proyecto. Esto requiere Gradle 5.0 o una versión más reciente:

**build.gradle**

```
...
dependencies {
    ...
    flinkShadowJar(platform("software.amazon.awssdk:bom:2.20.144"))
    ...
}
...
```

------

# Actualizar aplicaciones de Python
<a name="troubleshooting-async-deadlock-update-python-apps"></a>

Las aplicaciones de Python pueden usar conectores de dos maneras diferentes: empaquetando conectores y otras dependencias de Java como parte de un único uber-jar, o usar el archivo jar del conector directamente. Cómo corregir las aplicaciones afectadas por el bloqueo de Async Sink:
+ Si la aplicación usa un uber jar, siga las instrucciones de [Actualización de las aplicaciones Java](troubleshooting-async-deadlock-update-java-apps.md).
+ Para reconstruir los archivos jar del conector desde el origen, siga estos pasos:

**Construcción de conectores desde el origen:**

Requisitos previos, similares a los [requisitos de construcción](https://nightlies.apache.org/flink/flink-docs-release-1.15/docs/flinkdev/building/#build-flink) de Flink:
+ Java 11
+ Maven 3.2.5

## flink-sql-connector-kinesis
<a name="troubleshooting-async-deadlock-update-python-apps-flink-sql-connector-kinesis"></a>

1. Descargue el código fuente de Flink 1.15.4:

   ```
   wget https://archive.apache.org/dist/flink/flink-1.15.4/flink-1.15.4-src.tgz
   ```

1. Descomprima el código fuente:

   ```
   tar -xvf flink-1.15.4-src.tgz
   ```

1. Navegación hasta el directorio de conectores de Kinesis

   ```
   cd flink-1.15.4/flink-connectors/flink-connector-kinesis/
   ```

1. Compila e instala el tarro de conectores, especificando la versión AWS del SDK requerida. Para acelerar la construcción, utilice `-DskipTests` para omitir la ejecución de las pruebas y `-Dfast` para omitir las comprobaciones adicionales del código fuente:

   ```
   mvn clean install -DskipTests -Dfast -Daws.sdkv2.version=2.20.144
   ```

1. Navegación hasta el directorio de conectores de Kinesis

   ```
   cd ../flink-sql-connector-kinesis
   ```

1. Compile e instale el archivo jar del conector sql:

   ```
   mvn clean install -DskipTests -Dfast
   ```

1. El jar resultante estará disponible en:

   ```
   target/flink-sql-connector-kinesis-1.15.4.jar
   ```

## flink-sql-connector-aws-kinesis-streams
<a name="troubleshooting-async-deadlock-update-python-apps-flink-sql-connector-aws-kinesis-streams"></a>

1. Descargue el código fuente de Flink 1.15.4:

   ```
   wget https://archive.apache.org/dist/flink/flink-1.15.4/flink-1.15.4-src.tgz
   ```

1. Descomprima el código fuente:

   ```
   tar -xvf flink-1.15.4-src.tgz
   ```

1. Navegación hasta el directorio de conectores de Kinesis

   ```
   cd flink-1.15.4/flink-connectors/flink-connector-aws-kinesis-streams/
   ```

1. Compila e instala el conector jar, especificando la versión del SDK requerida. AWS Para acelerar la construcción, utilice `-DskipTests` para omitir la ejecución de las pruebas y `-Dfast` para omitir las comprobaciones adicionales del código fuente:

   ```
   mvn clean install -DskipTests -Dfast -Daws.sdk.version=2.20.144
   ```

1. Navegación hasta el directorio de conectores de Kinesis

   ```
   cd ../flink-sql-connector-aws-kinesis-streams
   ```

1. Compile e instale el archivo jar del conector sql:

   ```
   mvn clean install -DskipTests -Dfast
   ```

1. El jar resultante estará disponible en:

   ```
   target/flink-sql-connector-aws-kinesis-streams-1.15.4.jar
   ```

## flink-sql-connector-aws-kinesis-firehose
<a name="troubleshooting-async-deadlock-update-python-apps-flink-sql-connector-kinesis-firehose"></a>

1. Descargue el código fuente de Flink 1.15.4:

   ```
   wget https://archive.apache.org/dist/flink/flink-1.15.4/flink-1.15.4-src.tgz
   ```

1. Descomprima el código fuente:

   ```
   tar -xvf flink-1.15.4-src.tgz
   ```

1. Navegación hasta el directorio de conectores

   ```
   cd flink-1.15.4/flink-connectors/flink-connector-aws-kinesis-firehose/
   ```

1. Compila e instala el conector jar, especificando la versión del SDK requerida. AWS Para acelerar la construcción, utilice `-DskipTests` para omitir la ejecución de las pruebas y `-Dfast` para omitir las comprobaciones adicionales del código fuente:

   ```
   mvn clean install -DskipTests -Dfast -Daws.sdk.version=2.20.144
   ```

1. Navegación hasta el directorio de conectores sql

   ```
   cd ../flink-sql-connector-aws-kinesis-firehose
   ```

1. Compile e instale el archivo jar del conector sql:

   ```
   mvn clean install -DskipTests -Dfast
   ```

1. El jar resultante estará disponible en:

   ```
   target/flink-sql-connector-aws-kinesis-firehose-1.15.4.jar
   ```

## flink-sql-connector-dynamodb
<a name="troubleshooting-async-deadlock-update-python-apps-flink-sql-connector-dynamodb"></a>

1. Descargue el código fuente de 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. Descomprima el código fuente:

   ```
   tar -xvf flink-connector-aws-3.0.0-src.tgz
   ```

1. Navegación hasta el directorio de conectores

   ```
   cd flink-connector-aws-3.0.0
   ```

1. Compila e instala el contenedor de conectores, especificando la versión AWS del SDK requerida. Para acelerar la construcción, utilice `-DskipTests` para omitir la ejecución de las pruebas y `-Dfast` para omitir las comprobaciones adicionales del código fuente:

   ```
   mvn clean install -DskipTests -Dfast -Dflink.version=1.15.4 -Daws.sdk.version=2.20.144
   ```

1. El jar resultante estará disponible en:

   ```
   flink-sql-connector-dynamodb/target/flink-sql-connector-dynamodb-3.0.0.jar
   ```

# El procesamiento del origen de Amazon Kinesis Data Streams no funciona durante la partición nueva.
<a name="troubleshooting-kinesis-data-streams-processing-out-of-order"></a>

La FlinkKinesisConsumer implementación actual no ofrece garantías sólidas de ordenamiento entre las particiones de Kinesis. Esto puede provocar que se procese durante la refragmentación de Kinesis Stream, en particular en el caso de las aplicaciones de Flink que sufren retrasos en el out-of-order procesamiento. En algunas circunstancias, por ejemplo, los operadores de Windows basados en la hora de los eventos, es posible que los eventos se desechen debido a la demora resultante. 

![\[Diagram showing shards and shard consumers with time progression and trim horizon.\]](http://docs.aws.amazon.com/es_es/managed-flink/latest/java/images/flink-ts.png)


Este es un [problema conocido](https://issues.apache.org/jira/browse/FLINK-6349) en Open Source Flink. Hasta que se cuente con una corrección de conector, asegúrese de que sus aplicaciones de Flink no se queden atrás de las de Kinesis Data Streams al realizar la partición de nuevo. Al asegurarse de que sus aplicaciones de Flink toleran el retraso en el procesamiento, puede minimizar el impacto del out-of-order procesamiento y el riesgo de pérdida de datos. 

# Preguntas frecuentes y solución de problemas de esquemas de incrustación vectorial en tiempo real
<a name="troubleshooting-blueprints"></a>

Consulte las siguientes secciones de preguntas frecuentes y solución de problemas para resolver problemas con los esquemas de incrustación vectorial en tiempo real. Para obtener más información sobre los esquemas de incrustación vectorial en tiempo real, consulte [Real-time vector embedding blueprints](https://docs.aws.amazon.com/msk/latest/developerguide/ai-vector-embedding-integration-learn-more.html).

Para obtener información general sobre la solución de problemas de la aplicación Managed Service for Apache Flink, consulte [https://docs.aws.amazon.com/managed-flink/latest/java/troubleshooting-runtime.html](https://docs.aws.amazon.com/managed-flink/latest/java/troubleshooting-runtime.html).

**Topics**
+ [Preguntas frecuentes de esquemas de incrustación vectorial en tiempo real](troubleshooting-blueprints-FAQ.md)
+ [Solución de problemas de esquemas de incrustación vectorial en tiempo real](troubleshooting-blueprints-TS.md)

# Preguntas frecuentes de esquemas de incrustación vectorial en tiempo real
<a name="troubleshooting-blueprints-FAQ"></a>

Consulte las siguientes preguntas frecuentes sobre los esquemas de incrustación vectorial en tiempo real. Para obtener más información sobre los esquemas de incrustación vectorial en tiempo real, consulte [Real-time vector embedding blueprints](https://docs.aws.amazon.com/msk/latest/developerguide/ai-vector-embedding-integration-learn-more.html).

**Topics**
+ [¿Qué AWS recursos crea este plan?](#troubleshooting-blueprints-1)
+ [¿Cuáles son mis acciones una vez finalizada la implementación de la AWS CloudFormation pila?](#troubleshooting-blueprints-2)
+ [¿Cuál debe ser la estructura de los datos en los temas de Amazon MSK de origen?](#troubleshooting-blueprints-3)
+ [¿Puedo especificar partes de un mensaje para incrustarlas?](#troubleshooting-blueprints-4)
+ [¿Puedo leer datos de varios temas de Amazon MSK?](#troubleshooting-blueprints-5)
+ [¿Puedo usar expresiones regulares para configurar los nombres de los temas de Amazon MSK?](#troubleshooting-blueprints-6)
+ [¿Cuál es el tamaño máximo de un mensaje que se puede leer de un tema de Amazon MSK?](#troubleshooting-blueprints-7)
+ [¿Qué tipo de es compatible OpenSearch ?](#troubleshooting-blueprints-8)
+ [¿Por qué necesito usar una colección de búsqueda vectorial, un índice vectorial y añadir un campo vectorial a mi colección OpenSearch Serverless?](#troubleshooting-blueprints-9)
+ [¿Qué se debe establecer como dimensión para mi campo vectorial?](#troubleshooting-blueprints-10)
+ [¿Qué aspecto tiene el resultado en el índice configurado? OpenSearch](#troubleshooting-blueprints-11)
+ [¿Puedo especificar campos de metadatos para añadirlos al documento almacenado en el índice? OpenSearch](#troubleshooting-blueprints-12)
+ [¿Debo esperar entradas duplicadas en el OpenSearch índice?](#troubleshooting-blueprints-13)
+ [¿ OpenSearch Puedo enviar datos a varios índices?](#troubleshooting-blueprints-14)
+ [¿Puedo implementar varias aplicaciones de incrustación vectorial en tiempo real en una sola Cuenta de AWS¿](#troubleshooting-blueprints-15)
+ [¿Pueden varias aplicaciones de incrustación vectorial en tiempo real utilizar el mismo origen o receptor de datos?](#troubleshooting-blueprints-16)
+ [¿La aplicación admite la conectividad entre cuentas?](#troubleshooting-blueprints-17)
+ [¿La aplicación admite la conectividad entre regiones?](#troubleshooting-blueprints-18)
+ [¿El clúster y la OpenSearch colección de Amazon MSK pueden estar en redes diferentes VPCs o en subredes?](#troubleshooting-blueprints-19)
+ [¿Qué modelos de incrustación admite la aplicación?](#troubleshooting-blueprints-20)
+ [¿Puedo refinar el rendimiento de mi aplicación en función de mi carga de trabajo?](#troubleshooting-blueprints-21)
+ [¿Qué tipos de autenticación de Amazon MSK son compatibles?](#troubleshooting-blueprints-22)
+ [¿Qué es `sink.os.bulkFlushIntervalMillis` y cómo se configura?](#troubleshooting-blueprints-23)
+ [Cuando despliegue mi aplicación Managed Service para Apache Flink, ¿a partir de qué punto del tema Amazon MSK empezará a leer los mensajes?](#troubleshooting-blueprints-24)
+ [¿Cómo uso `source.msk.starting.offset`?](#troubleshooting-blueprints-25)
+ [¿Qué estrategias de fragmentación se admiten?](#troubleshooting-blueprints-26)
+ [¿Cómo leo los registros de mi almacén de datos de vectores?](#troubleshooting-blueprints-27)
+ [¿Dónde puedo encontrar nuevas actualizaciones del código fuente?](#troubleshooting-blueprints-28)
+ [¿Puedo realizar un cambio en la AWS CloudFormation plantilla y actualizar la aplicación Managed Service for Apache Flink?](#troubleshooting-blueprints-29)
+ [¿ AWS Supervisará y mantendrá la aplicación en mi nombre?](#troubleshooting-blueprints-30)
+ [¿Esta aplicación mueve mis datos fuera de mi Cuenta de AWS?](#troubleshooting-blueprints-31)

## ¿Qué AWS recursos crea este plan?
<a name="troubleshooting-blueprints-1"></a>

Para encontrar los recursos desplegados en su cuenta, vaya a la AWS CloudFormation consola e identifique el nombre de la pila que comienza con el nombre que proporcionó para la aplicación Managed Service for Apache Flink. Elija la pestaña **Recursos** para comprobar los recursos que se crearon como parte de la pila. Los recursos clave que crea la pila son los siguientes:
+ Servicio administrado de incrustación vectorial en tiempo real para la aplicación Apache Flink
+ Bucket Amazon S3 para almacenar el código fuente de la aplicación de incrustación vectorial en tiempo real
+ CloudWatch grupo de registros y flujo de registros para almacenar registros
+ Funciones de Lambda para obtener y crear recursos
+ Funciones y políticas de IAM para Lambdas, servicio gestionado para la aplicación Apache Flink y acceso a Amazon Bedrock y Amazon Service OpenSearch 
+ Política de acceso a datos para Amazon OpenSearch Service
+ Puntos de enlace de VPC para acceder a Amazon Bedrock y Amazon Service OpenSearch 

## ¿Cuáles son mis acciones una vez finalizada la implementación de la AWS CloudFormation pila?
<a name="troubleshooting-blueprints-2"></a>

Una vez completada la implementación de la AWS CloudFormation pila, acceda a la consola de Managed Service for Apache Flink y busque su modelo de aplicación Managed Service for Apache Flink. Seleccione la pestaña **Configurar** y confirme que todas las propiedades del tiempo de ejecución estén configuradas correctamente. Es posible que pasen a la página siguiente. Cuando esté seguro de la configuración, elija **Ejecutar**. La aplicación empezará a ingerir los mensajes de du tema.

[Para comprobar si hay nuevas versiones, consulte -streaming-data/releases. https://github.com/awslabs/ real-time-vectorization-of](https://github.com/awslabs/real-time-vectorization-of-streaming-data/releases)

## ¿Cuál debe ser la estructura de los datos en los temas de Amazon MSK de origen?
<a name="troubleshooting-blueprints-3"></a>

Actualmente, se admiten datos de origen estructurados y no estructurados. 
+ Los datos no estructurados se indican con `STRING` en `source.msk.data.type`. Los datos se leen tal como están en el mensaje entrante.
+ Actualmente, se admiten datos JSON estructurados, indicados con `JSON` en`source.msk.data.type`. Los datos siempre deben estar en formato JSON. Si la aplicación recibe un JSON con formato incorrecto, esta fallará. 
+ Cuando se utilice JSON como tipo de datos de origen, asegúrese de que todos los mensajes de todos los temas de origen sean un JSON válido. Si se suscribe a uno o más temas que no contienen objetos JSON con esta configuración, la aplicación fallará. Si uno o más temas contienen una combinación de datos estructurados y no estructurados, se recomienda configurar los datos de origen como no estructurados en la aplicación Managed Service para Apache Flink. 

## ¿Puedo especificar partes de un mensaje para incrustarlas?
<a name="troubleshooting-blueprints-4"></a>
+ En el caso de los datos de entrada no estructurados, donde `source.msk.data.type` `STRING` estén, la aplicación siempre incrustará el mensaje completo y lo almacenará en el índice configurado. OpenSearch 
+ En el caso de los datos de entrada estructurados donde `source.msk.data.type` es `JSON`, se puede configurar `embed.input.config.json.fieldsToEmbed` para especificar qué campo del objeto JSON debe seleccionarse para su incrustación. Esto solo funciona para los campos JSON de nivel superior y no funciona con mensajes anidados JSONs o que contengan una matriz JSON. Use .\$1 para incrustar la totalidad del JSON.

## ¿Puedo leer datos de varios temas de Amazon MSK?
<a name="troubleshooting-blueprints-5"></a>

Sí, se pueden leer datos de varios temas de Amazon MSK con esta aplicación. Los datos de todos los temas deben ser del mismo tipo (STRING o JSON) o podrían provocar un error en la aplicación. Los datos de todos los temas se almacenan siempre en un único OpenSearch índice.

## ¿Puedo usar expresiones regulares para configurar los nombres de los temas de Amazon MSK?
<a name="troubleshooting-blueprints-6"></a>

`source.msk.topic.names` no admite una lista de expresiones regulares. Se admiten listas de nombres de temas separados por comas o expresiones regulares `.*` para incluir todos los temas.

## ¿Cuál es el tamaño máximo de un mensaje que se puede leer de un tema de Amazon MSK?
<a name="troubleshooting-blueprints-7"></a>

El tamaño máximo de un mensaje que se puede procesar está limitado por el límite de InvokeModel cuerpo de Amazon Bedrock, que actualmente está establecido en 25 000 000 000. Para obtener más información, consulte [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html#API_runtime_InvokeModel_RequestBody).

## ¿Qué tipo de es compatible OpenSearch ?
<a name="troubleshooting-blueprints-8"></a>

Admitimos tanto OpenSearch dominios como colecciones. Si usa una OpenSearch colección, asegúrese de usar una colección vectorial y cree un índice vectorial para usarlo en esta aplicación. Esto le permitirá utilizar las capacidades de la base de datos OpenSearch vectorial para consultar sus datos. Para obtener más información, consulta la [explicación de las capacidades de las bases de datos vectoriales de Amazon OpenSearch Service](https://aws.amazon.com/blogs/big-data/amazon-opensearch-services-vector-database-capabilities-explained/).

## ¿Por qué necesito usar una colección de búsqueda vectorial, un índice vectorial y añadir un campo vectorial a mi colección OpenSearch Serverless?
<a name="troubleshooting-blueprints-9"></a>

El tipo de colección *de búsqueda vectorial* de OpenSearch Serverless proporciona una capacidad de búsqueda por similitud que es escalable y de alto rendimiento. Agiliza la creación de experiencias de búsqueda aumentada de machine learning (ML) modernas y aplicaciones de la inteligencia artificial (IA) generativa. Para obtener más información, consulte [Working with vector search collections](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-vector-search.html?icmpid=docs_console_unmapped).

## ¿Qué se debe establecer como dimensión para mi campo vectorial?
<a name="troubleshooting-blueprints-10"></a>

Establezca la dimensión del campo vectorial en función del modelo de incrustación que se desee utilizar. Consulte la siguiente tabla y confirme estos valores en la documentación correspondiente.


**Dimensiones del campo vectorial**  

| Nombre del modelo de incrustación vectorial de Amazon Bedrock | El modelo ofrece compatibilidad para dimensiones de salida | 
| --- | --- | 
|  Incrustaciones de texto Amazon Titan V1  | 1536 | 
|  Amazon Titan Text Embeddings V2  | 1024 (predeterminado), 384, 256 | 
|  Amazon Titan Multimodal Embeddings G1  | 1024 (predeterminado), 384, 256 | 
|  Cohere Embed inglés  | 1 024 | 
|  Cohere Embed multilingüe  | 1 024 | 

## ¿Qué aspecto tiene el resultado en el índice configurado? OpenSearch
<a name="troubleshooting-blueprints-11"></a>

Todos los documentos del OpenSearch índice contienen los siguientes campos:
+ **original\$1data:** los datos que se utilizaron para generar incrustaciones. En el caso del tipo STRING, es el mensaje completo. En el caso del objeto JSON, es el objeto JSON que se utilizó para las incrustaciones. Puede ser el JSON completo del mensaje o los campos específicos del JSON. Por ejemplo, si se seleccionó un nombre para incrustarlo en los mensajes entrantes, el resultado tendría el siguiente aspecto:

  ```
  "original_data": "{\"name\":\"John Doe\"}"
  ```
+ **embedded\$1data**: matriz flotante vectorial de incrustaciones generada por Amazon Bedrock
+ **fecha**: marca horaria UTC en la que se almacenó el documento OpenSearch

## ¿Puedo especificar campos de metadatos para añadirlos al documento almacenado en el índice? OpenSearch
<a name="troubleshooting-blueprints-12"></a>

No, actualmente no admitimos la adición de campos adicionales al documento final almacenado en el OpenSearch índice.

## ¿Debo esperar entradas duplicadas en el OpenSearch índice?
<a name="troubleshooting-blueprints-13"></a>

Según cómo se haya configurado la aplicación, es posible que vea mensajes duplicados en el índice. Un motivo habitual es el reinicio de la aplicación. La aplicación está configurada de forma predeterminada para empezar a leer desde el primer mensaje del tema de origen. Al cambiar la configuración, la aplicación se reinicia y vuelve a procesar todos los mensajes del tema. Para evitar el reprocesamiento, consulte la documentación sobre cómo usar source.msk.starting.offset y configurar correctamente el desplazamiento inicial de su aplicación.

## ¿ OpenSearch Puedo enviar datos a varios índices?
<a name="troubleshooting-blueprints-14"></a>

No, la aplicación admite el almacenamiento de datos en un único OpenSearch índice. Para configurar el resultado de la vectorización en varios índices, debe implementar un servicio administrado independiente para las aplicaciones de Apache Flink.

## ¿Puedo implementar varias aplicaciones de incrustación vectorial en tiempo real en una sola Cuenta de AWS¿
<a name="troubleshooting-blueprints-15"></a>

Sí, se pueden implementar varias aplicaciones del Servicio gestionado de incrustación vectorial para Apache Flink en tiempo real en una sola Cuenta de AWS si cada aplicación tiene un nombre único.

## ¿Pueden varias aplicaciones de incrustación vectorial en tiempo real utilizar el mismo origen o receptor de datos?
<a name="troubleshooting-blueprints-16"></a>

Sí, se pueden crear varios servicios gestionados de incrustación vectorial en tiempo real para aplicaciones de Apache Flink que lean datos de los mismos temas o almacenen datos en el mismo índice.

## ¿La aplicación admite la conectividad entre cuentas?
<a name="troubleshooting-blueprints-17"></a>

No, para que la aplicación se ejecute correctamente, el clúster de Amazon MSK y la OpenSearch colección deben estar en el mismo Cuenta de AWS lugar en el que intenta configurar la aplicación Managed Service for Apache Flink.

## ¿La aplicación admite la conectividad entre regiones?
<a name="troubleshooting-blueprints-18"></a>

No, la aplicación solo le permite implementar una aplicación de Managed Service for Apache Flink con un clúster de Amazon MSK y una OpenSearch colección en la misma región de la aplicación Managed Service for Apache Flink.

## ¿El clúster y la OpenSearch colección de Amazon MSK pueden estar en redes diferentes VPCs o en subredes?
<a name="troubleshooting-blueprints-19"></a>

Sí, admitimos el clúster y la OpenSearch recopilación de Amazon MSK en diferentes subredes VPCs y subredes siempre que estén en la misma. Cuenta de AWS Consulte (Solución de problemas generales de MSF) para asegurarse de que la configuración es la correcta.

## ¿Qué modelos de incrustación admite la aplicación?
<a name="troubleshooting-blueprints-20"></a>

Actualmente, la aplicación admite todos los modelos compatibles con Bedrock. Entre ellos se incluyen:
+ Amazon Titan Embeddings G1 - Text
+  Amazon Titan Text Embeddings V2
+  Amazon Titan Multimodal Embeddings G1 
+  Cohere Embed inglés 
+  Cohere Embed multilingüe 

## ¿Puedo refinar el rendimiento de mi aplicación en función de mi carga de trabajo?
<a name="troubleshooting-blueprints-21"></a>

Sí. El rendimiento de la aplicación depende de varios factores, todos los cuales pueden ser controlados por los clientes: 

1. **AWS MSF KPUs**: La aplicación se implementa con un factor de paralelismo predeterminado de 2 y un paralelismo por KPU 1, con el escalado automático activado. Sin embargo, se recomienda que configure el escalado de la aplicación de Managed Service para Apache Flink según sus cargas de trabajo. Para obtener más información, consulte [Revise los recursos de aplicaciones de Managed Service for Apache Flink.](https://docs.aws.amazon.com/managed-flink/latest/java/how-resources.html)

1. **Amazon Bedrock**: según el modelo bajo demanda de Amazon Bedrock seleccionado, es posible que se apliquen cuotas diferentes. Revise las cuotas de servicio en Bedrock para ver la carga de trabajo que el servicio podrá gestionar. Para obtener más información, consulte [Quotas for Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/quotas.html).

1. **Amazon OpenSearch Service**: Además, en algunas situaciones, es posible que notes que OpenSearch se trata de un cuello de botella en tu cartera de proyectos. Para obtener información sobre el escalado, consulte OpenSearch Escalar el [tamaño de los dominios OpenSearch de Amazon Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/sizing-domains.html).

## ¿Qué tipos de autenticación de Amazon MSK son compatibles?
<a name="troubleshooting-blueprints-22"></a>

IAM MSK es el único tipo de autenticación admitido.

## ¿Qué es `sink.os.bulkFlushIntervalMillis` y cómo se configura?
<a name="troubleshooting-blueprints-23"></a>

Al enviar datos a Amazon OpenSearch Service, el intervalo de descarga masiva es el intervalo en el que se ejecuta la solicitud masiva, independientemente del número de acciones o del tamaño de la solicitud. El valor predeterminado es de 1 milisegundo.

Si bien establecer un intervalo de vaciado puede ayudar a garantizar que los datos se indexen a tiempo, también puede generar un aumento de la sobrecarga si se establece un intervalo demasiado bajo. Tenga en cuenta su caso de uso y la importancia de una indexación puntual cuando se deba elegir un intervalo de vaciado.

## Cuando despliegue mi aplicación Managed Service para Apache Flink, ¿a partir de qué punto del tema Amazon MSK empezará a leer los mensajes?
<a name="troubleshooting-blueprints-24"></a>

La aplicación empezará a leer los mensajes del tema Amazon MSK con el desfase especificado por la configuración`source.msk.starting.offset` establecida en la configuración de tiempo de ejecución de la aplicación. Si `source.msk.starting.offset` no se establece de forma explícita, el comportamiento predeterminado de la aplicación es empezar a leer desde el primer mensaje disponible del tema.

## ¿Cómo uso `source.msk.starting.offset`?
<a name="troubleshooting-blueprints-25"></a>

Establezca `ource.msk.starting.offset` de forma explícita en uno de los siguientes valores, según el comportamiento deseado: 


+  EARLY: la configuración predeterminada, que se lee desde el desplazamiento más antiguo de la partición. Es una buena opción, especialmente si: 
  +  Acaba de crear temas y aplicaciones para consumidores de Amazon MSK.
  +  Necesita reproducir los datos para poder generar o reconstruir el estado. Esto es pertinente cuando se implementa el patrón de abastecimiento de eventos o cuando se inicializa un nuevo servicio que requiere una vista completa del historial de datos. 
+ LATEST: la aplicación de Managed Service para Apache Flink leerá los mensajes del final de la partición. Se recomienda esta opción si solo importa que se generen nuevos mensajes y no se necesita procesar datos históricos. En esta configuración, el consumidor ignorará los mensajes existentes y solo leerá los nuevos publicados por el productor original.
+ COMMITTED: la aplicación Managed Service para Apache Flink empezará a consumir los mensajes que procedan de la misma cantidad de mensajes confirmados por el grupo consumidor. Si la compensación comprometida no existe, se utilizará la estrategia de restablecimiento EARLIEST. 

## ¿Qué estrategias de fragmentación se admiten?
<a name="troubleshooting-blueprints-26"></a>

Estamos usando la biblioteca [langchain](https://js.langchain.com/v0.1/docs/get_started/introduction/) ara fragmentar las entradas. La fragmentación solo se aplica si la longitud de la entrada es mayor que el `maxSegmentSizeInChars` elegido. Se admiten los siguientes cinco tipos de fragmentación:
+ `SPLIT_BY_CHARACTER`: Cabrá tantos caracteres como sea posible en cada bloque donde la longitud de cada fragmento no sea superior a. maxSegmentSize InChars No importan los espacios en blanco, por lo que puede cortar palabras.
+ `SPLIT_BY_WORD`: encontrará espacios en blanco para fragmentarlos. No se corta ninguna palabra.
+ `SPLIT_BY_SENTENCE`: los límites de las oraciones se detectan con la biblioteca Apache OpenNLP con el modelo de oraciones en inglés.
+ `SPLIT_BY_LINE`: encontrará nuevos caracteres de línea para fragmentarlos.
+ `SPLIT_BY_PARAGRAPH`: encontrará nuevos caracteres de línea consecutivos para fragmentarlos.

Las estrategias de división recurren al orden anterior, donde las estrategias de segmentación más grandes como `SPLIT_BY_PARAGRAPH` recurren al orden anterior `SPLIT_BY_CHARACTER`. Por ejemplo, cuando se usa `SPLIT_BY_LINE`, si una línea es demasiado larga, se la subdivide por oración, y cada fragmento cabe en tantas oraciones como sea posible. Si alguna oración es demasiado larga, se fragmentarán las palabras. Si una palabra es demasiado larga, se dividirá por caracteres.

## ¿Cómo leo los registros de mi almacén de datos de vectores?
<a name="troubleshooting-blueprints-27"></a>

1. Cuando `source.msk.data.type` es `STRING`
   + **original\$1data**: la cadena original completa del mensaje de Amazon MSK.
   + **embedded\$1data**: vector de incrustación creado a partir de `chunk_data` si no está vacío (se aplica la fragmentación) o creado a partir de `original_data` si no se ha aplicado ninguna fragmentación.
   + **chunk\$1data**: solo está presente cuando los datos originales se fragmentaron. Contiene el fragmento del mensaje original que se utilizó para crear la incrustación en `embedded_data`.

1. Cuando `source.msk.data.type` es `JSON`
   + **original\$1data**: todo el JSON original del mensaje de Amazon MSK *después* de aplicar el filtrado de claves JSON. 
   + **embedded\$1data**: vector de incrustación creado a partir de `chunk_data` si no está vacío (se aplica la fragmentación) o creado a partir de `original_data` si no se ha aplicado ninguna fragmentación.
   + **chunk\$1key**: solo está presente cuando los datos originales se fragmentaron. Contiene la clave JSON de la que proviene el fragmento en `original_data`. Por ejemplo, puede tener el mismo aspecto que `jsonKey1.nestedJsonKeyA` en el caso de las claves anidadas o de *metadatos* en el ejemplo de los `original_data`.
   + **chunk\$1data**: solo está presente cuando los datos originales se fragmentaron. Contiene el fragmento del mensaje original que se utilizó para crear la incrustación en `embedded_data`.

Sí, se pueden leer datos de varios temas de Amazon MSK con esta aplicación. Los datos de todos los temas deben ser del mismo tipo (STRING o JSON) o podrían provocar un error en la aplicación. Los datos de todos los temas se almacenan siempre en un único OpenSearch índice.

## ¿Dónde puedo encontrar nuevas actualizaciones del código fuente?
<a name="troubleshooting-blueprints-28"></a>

Ve a [https://github.com/awslabs/real-time-vectorization-of-streaming-data/releases para comprobar si hay nuevos lanzamientos](https://github.com/awslabs/real-time-vectorization-of-streaming-data/releases).

## ¿Puedo realizar un cambio en la AWS CloudFormation plantilla y actualizar la aplicación Managed Service for Apache Flink?
<a name="troubleshooting-blueprints-29"></a>

No, al realizar un cambio en la AWS CloudFormation plantilla no se actualiza la aplicación Managed Service for Apache Flink. Cualquier cambio nuevo AWS CloudFormation implica la necesidad de implementar una nueva pila.

## ¿ AWS Supervisará y mantendrá la aplicación en mi nombre?
<a name="troubleshooting-blueprints-30"></a>

No, no supervisará, AWS escalará, actualizará ni parcheará esta aplicación en su nombre. 

## ¿Esta aplicación mueve mis datos fuera de mi Cuenta de AWS?
<a name="troubleshooting-blueprints-31"></a>

Todos los datos leídos y almacenados por la aplicación Managed Service for Apache Flink permanecen en su cuenta Cuenta de AWS y nunca salen de su cuenta.

# Solución de problemas de esquemas de incrustación vectorial en tiempo real
<a name="troubleshooting-blueprints-TS"></a>

Revise los siguientes temas de solución de problemas relacionados con los esquemas de incrustación vectorial en tiempo real. Para obtener más información sobre los esquemas de incrustación vectorial en tiempo real, consulte [Real-time vector embedding blueprints](https://docs.aws.amazon.com/msk/latest/developerguide/ai-vector-embedding-integration-learn-more.html).

**Topics**
+ [La implementación de mi CloudFormation pila ha fallado o se ha revertido. ¿Qué puedo hacer para solucionarlo?](#troubleshooting-blueprints-deployment)
+ [No deseo que mi aplicación empiece a leer los mensajes desde el principio de los temas de Amazon MSK. ¿Qué tengo que hacer?](#troubleshooting-blueprints-beginning)
+ [¿Cómo sé si hay un problema con mi aplicación Managed Service para Apache Flink y cómo puedo depurarlo?](#troubleshooting-blueprints-debug)
+ [¿Cuáles son las métricas clave que debo monitorear para mi aplicación Managed Service para Apache Flink?](#troubleshooting-blueprints-metrics)

## La implementación de mi CloudFormation pila ha fallado o se ha revertido. ¿Qué puedo hacer para solucionarlo?
<a name="troubleshooting-blueprints-deployment"></a>
+ Vaya a la pila de CFN y encuentre el motivo del fallo de la pila. Podría estar relacionado con la falta de permisos o con colisiones de nombres de recursos de AWS , entre otras causas. Corrija la causa principal del error de implementación. Para obtener más información, consulta la [guía CloudWatch de solución de problemas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/troubleshooting.html#basic-ts-guide).
+  [Opcional] Solo puede haber un punto de conexión de VPC por servicio y por VPC. Si implementaste varios planos de incrustación vectorial en tiempo real para escribirlos en las colecciones de Amazon OpenSearch Service de la misma VPC, es posible que compartan puntos de enlace de la VPC. Es posible que ya estén presentes en su cuenta de la VPC o que la primera pila de planos de incrustación vectorial en tiempo real cree puntos de enlace de VPC para Amazon Bedrock y Amazon OpenSearch Service que se utilizarán en todas las demás pilas implementadas en su cuenta. Si se produce un error en una pila, compruebe si esa pila creó puntos de enlace de VPC para Amazon Bedrock y OpenSearch Amazon Service y elimínelos si no se utilizan en ningún otro lugar de su cuenta. Para conocer los pasos para eliminar los puntos finales de la VPC, consulte la documentación sobre cómo eliminar la aplicación de forma segura.
+ Es posible que haya otros servicios o aplicaciones en su cuenta que utilicen el punto de conexión de VPC. Si se elimina, es posible que se produzcan interrupciones en la red de otros servicios. Tenga cuidado al eliminar estos puntos de conexión.

## No deseo que mi aplicación empiece a leer los mensajes desde el principio de los temas de Amazon MSK. ¿Qué tengo que hacer?
<a name="troubleshooting-blueprints-beginning"></a>

Debe establecer `source.msk.starting.offset` de forma explícita en uno de los siguientes valores, en función del comportamiento deseado:
+ **Desplazamiento más temprano**: el desplazamiento más antiguo de la partición.
+ **Último desplazamiento**: los consumidores leerán los mensajes del final de la partición.
+ **Desplazamiento confirmado**: lee el último mensaje que el consumidor procesó dentro de una partición.

## ¿Cómo sé si hay un problema con mi aplicación Managed Service para Apache Flink y cómo puedo depurarlo?
<a name="troubleshooting-blueprints-debug"></a>

Utilice la [guía de solución de problemas de Managed Service para Apache Flink](https://docs.aws.amazon.com/managed-flink/latest/java/troubleshooting-runtime.html) para depurar los problemas relacionados con Managed Service para Apache Flink en su aplicación.

## ¿Cuáles son las métricas clave que debo monitorear para mi aplicación Managed Service para Apache Flink?
<a name="troubleshooting-blueprints-metrics"></a>
+ Todas las métricas disponibles para una aplicación de Managed Service para Apache Flink normal pueden ayudarlo a monitorear la aplicación. Para más información, consulte [Metrics and dimensions in Managed Service for Apache Flink](https://docs.aws.amazon.com/managed-flink/latest/java/metrics-dimensions.html).
+ Para supervisar las métricas de Amazon Bedrock, consulte [ CloudWatch las métricas de Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/monitoring.html#runtime-cloudwatch-metrics).
+ Se han agregado dos métricas nuevas para monitorear el rendimiento de la generación de incrustaciones. Búscalas bajo el nombre de la `EmbeddingGeneration` operación en. CloudWatch Las dos métricas son:
  + **BedrockTitanEmbeddingTokenCount**: Número de fichas presentes en una sola solicitud a Amazon Bedrock.
  + **BedrockEmbeddingGenerationLatencyMs**: Indica el tiempo que se tarda en enviar y recibir una respuesta de Amazon Bedrock para generar incrustaciones, en milisegundos.
+ Para las colecciones sin servidor de Amazon OpenSearch Service, puedes usar métricas como`IngestionDataRate`, entre `IngestionDocumentErrors` otras. Para obtener más información, consulte [Supervisión de OpenSearch Serverless con Amazon CloudWatch](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/monitoring-cloudwatch.html).
+ Para ver las métricas OpenSearch aprovisionadas, consulta [Supervisar las métricas OpenSearch del clúster con Amazon CloudWatch](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/managedomains-cloudwatchmetrics.html).