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.
# Cómo utilizar las transmisiones de captura de datos de cambios (CDC) en Amazon Keyspaces
**Topics**
+ [Configuración de permisos](configure-cdc-permissions.md)
+ [Acceda a los puntos de enlace de transmisión de los CDC](CDC_access-endpoints.md)
+ [Habilite una transmisión de los CDC para una tabla nueva](keyspaces-enable-cdc-new-table.md)
+ [Habilite una transmisión de CDC para una tabla existente](keyspaces-enable-cdc-alter-table.md)
+ [Desactive una transmisión de los CDC](keyspaces-delete-cdc.md)
+ [Vea las transmisiones de los CDC](keyspaces-view-cdc.md)
+ [Acceda a las transmisiones de los CDC](keyspaces-records-cdc.md)
+ [Utilice KCL para procesar las transmisiones](cdc_how-to-use-kcl.md)
# Configure los permisos para trabajar con las transmisiones de los CDC en Amazon Keyspaces
Para habilitar las transmisiones de los CDC, el director, por ejemplo, un usuario o rol de IAM, necesita los siguientes permisos.
Para obtener más información al respecto AWS Identity and Access Management, consulte[AWS Identity and Access Management para Amazon Keyspaces](security-iam.md).
## Permisos para habilitar una transmisión de los CDC para una tabla
[Para habilitar una transmisión de CDC para una tabla de Amazon Keyspaces, el director primero necesita permisos para crear o modificar una tabla y, en segundo lugar, los permisos para crear el rol AWSService RoleForAmazonKeyspaces CDC vinculado al servicio.](using-service-linked-roles-CDC-streams.md#service-linked-role-permissions-CDC-streams) Amazon Keyspaces utiliza el rol vinculado al servicio para publicar CloudWatch las métricas en su cuenta en su nombre.
La siguiente política de IAM es un ejemplo de ello.
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"cassandra:Create",
"cassandra:CreateMultiRegionResource",
"cassandra:Alter",
"cassandra:AlterMultiRegionResource"
],
"Resource":[
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/*",
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*"
]
},
{
"Sid": "KeyspacesCDCServiceLinkedRole",
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/cassandra-streams.amazonaws.com/AWSServiceRoleForAmazonKeyspacesCDC",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "cassandra-streams.amazonaws.com"
}
}
}
]
}
```
Para deshabilitar una transmisión, solo se requieren `ALTER TABLE` permisos.
## Permisos para ver una transmisión de los CDC
Para ver o enumerar las transmisiones de los CDC, el director necesita permisos de lectura para el espacio de claves del sistema. Para obtener más información, consulte [`system_schema_mcs`](working-with-keyspaces.md#keyspace_system_schema_mcs).
La siguiente política de IAM es un ejemplo de ello.
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":"cassandra:Select",
"Resource":[
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*"
]
}
]
}
```
Para ver o enumerar las transmisiones de los AWS CLI CDC con la API de Amazon Keyspaces, el director necesita permisos adicionales para las acciones `cassandra:ListStreams` y. `cassandra:GetStream`
La siguiente política de IAM es un ejemplo de ello.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cassandra:Select",
"cassandra:ListStreams",
"cassandra:GetStream"
],
"Resource": "*"
}
]
}
```
## Permisos para leer una transmisión de los CDC
Para leer las transmisiones de los CDC, el director necesita los siguientes permisos.
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"cassandra:GetStream",
"cassandra:GetShardIterator",
"cassandra:GetRecords"
],
"Resource":[
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/table/my_table/stream/stream_label"
]
}
]
}
```
## Permisos para procesar las transmisiones de los CDC de Amazon Keyspaces con la biblioteca de clientes de Kinesis (KCL)
Para procesar las transmisiones de CDC de Amazon Keyspaces con KCL, el director de IAM necesita los siguientes permisos.
+ `Amazon Keyspaces`— Acceso de solo lectura a una transmisión CDC específica de Amazon Keyspaces.
+ `DynamoDB`— Permisos para crear `shard lease` tablas, acceso de lectura y escritura a las tablas y acceso de lectura al índice, según sea necesario para el procesamiento de la transmisión de KCL.
+ `CloudWatch`— Permisos para publicar datos de métricas de Amazon Keyspaces Los CDC transmiten el procesamiento con KCL al espacio de nombres de la aplicación cliente de KCL de su cuenta. CloudWatch Para obtener más información sobre la supervisión, consulte [Supervisar la biblioteca de clientes de Kinesis con Amazon](https://docs.aws.amazon.com/streams/latest/dev/monitoring-with-kcl.html). CloudWatch
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"cassandra:GetStream",
"cassandra:GetShardIterator",
"cassandra:GetRecords"
],
"Resource":[
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/table/my_table/stream/stream_label"
]
},
{
"Effect":"Allow",
"Action":[
"dynamodb:CreateTable",
"dynamodb:DescribeTable",
"dynamodb:UpdateTable",
"dynamodb:GetItem",
"dynamodb:UpdateItem",
"dynamodb:PutItem",
"dynamodb:DeleteItem",
"dynamodb:Scan"
],
"Resource":[
"arn:aws:dynamodb:us-east-1:111122223333:table/KCL_APPLICATION_NAME"
]
},
{
"Effect":"Allow",
"Action":[
"dynamodb:CreateTable",
"dynamodb:DescribeTable",
"dynamodb:GetItem",
"dynamodb:UpdateItem",
"dynamodb:PutItem",
"dynamodb:DeleteItem",
"dynamodb:Scan"
],
"Resource":[
"arn:aws:dynamodb:us-east-1:111122223333:table/KCL_APPLICATION_NAME-WorkerMetricStats",
"arn:aws:dynamodb:us-east-1:111122223333:table/KCL_APPLICATION_NAME-CoordinatorState"
]
},
{
"Effect":"Allow",
"Action":[
"dynamodb:Query"
],
"Resource":[
"arn:aws:dynamodb:us-east-1:111122223333:table/KCL_APPLICATION_NAME/index/*"
]
},
{
"Effect":"Allow",
"Action":[
"cloudwatch:PutMetricData"
],
"Resource":"*"
}
]
}
```
# Cómo acceder a los puntos de enlace de transmisión de los CDC en Amazon Keyspaces
Amazon Keyspaces mantiene [puntos de enlace](programmatic.endpoints.md#global_endpoints) separados para keyspaces/tables y para las transmisiones de CDC en cada uno de los lugares en los que Región de AWS Amazon Keyspaces está disponible. Para acceder a una transmisión de los CDC, seleccione la región de la tabla y sustituya el `cassandra` prefijo por el nombre del punto final, como se muestra `cassandra-streams` en el siguiente ejemplo:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/keyspaces/latest/devguide/CDC_access-endpoints.html)
La siguiente tabla contiene una lista completa de los puntos finales públicos disponibles para. Amazon Keyspaces change data capture streams Amazon Keyspaces CDC streams es compatible con IPv4 y. IPv6 Todos los puntos finales públicos, por ejemplo`cassandra-streams.us-east-1.api.aws`, son puntos finales de doble pila que se pueden configurar para IPv4 y. IPv6
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/keyspaces/latest/devguide/CDC_access-endpoints.html)
# Habilita una transmisión de CDC al crear una tabla nueva en Amazon Keyspaces
Para habilitar una transmisión de CDC al crear una tabla, puede usar la `CREATE TABLE` instrucción en CQL o el `create-table` comando con la. AWS CLI
Para cada fila modificada de la tabla, Amazon Keyspaces puede capturar los siguientes cambios en función `view_type` de los `cdc_specification` que seleccione:
+ `NEW_AND_OLD_IMAGES`— ambas versiones de la fila, antes y después del cambio. Este es el valor predeterminado.
+ `NEW_IMAGE`— la versión de la fila tras el cambio.
+ `OLD_IMAGE`— la versión de la fila anterior al cambio.
+ `KEYS_ONLY`— las claves de partición y agrupamiento de la fila que se ha modificado.
Para obtener información sobre cómo etiquetar una transmisión, consulte[Agregue etiquetas a una nueva secuencia al crear una tabla](Tagging.Operations.new.table.stream.md).
**nota**
Amazon Keyspaces CDC requiere la presencia de un rol vinculado a un servicio (`AWSServiceRoleForAmazonKeyspacesCDC`) que publique los datos de métricas de las transmisiones de Amazon Keyspaces CDC en su cuenta `"cloudwatch:namespace": "AWS/Cassandra"` en su nombre. CloudWatch Este rol se crea automáticamente. Para obtener más información, consulte [Uso de roles para las transmisiones de los CDC de Amazon Keyspaces](using-service-linked-roles-CDC-streams.md).
------
#### [ Cassandra Query Language (CQL) ]
**Habilite una transmisión de CDC al crear una tabla con CQL**
1.
```
CREATE TABLE mykeyspace.mytable (a text, b text, PRIMARY KEY(a))
WITH CUSTOM_PROPERTIES={'cdc_specification': {'view_type': 'NEW_IMAGE'}} AND CDC = TRUE;
```
1. Para confirmar la configuración de la transmisión, puede usar la siguiente declaración.
```
SELECT keyspace_name, table_name, cdc, custom_properties FROM system_schema_mcs.tables WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
El resultado de esa declaración debería tener un aspecto similar al siguiente.
```
SELECT keyspace_name, table_name, cdc, custom_properties FROM system_schema_mcs.tables WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';keyspace_name | table_name | cdc | custom_properties
---------------+------------+------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
mykeyspace | mytable | True | {'capacity_mode': {'last_update_to_pay_per_request_timestamp': '1741383893782', 'throughput_mode': 'PAY_PER_REQUEST'}, 'cdc_specification': {'latest_stream_arn': 'arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable/stream/2025-03-07T21:44:53.783', 'status': 'ENABLED', 'view_type': 'NEW_IMAGE'}, 'encryption_specification': {'encryption_type': 'AWS_OWNED_KMS_KEY'}, 'point_in_time_recovery': {'status': 'disabled'}}>
```
------
#### [ CLI ]
**Habilite una transmisión de los CDC al crear una tabla con AWS CLI**
1. Para crear una transmisión, puede usar la siguiente sintaxis.
```
aws keyspaces create-table \
--keyspace-name 'mykeyspace' \
--table-name 'mytable' \
--schema-definition 'allColumns=[{name=a,type=text},{name=b,type=text}],partitionKeys=[{name=a}]' \
--cdc-specification status=ENABLED,viewType=NEW_IMAGE
```
1. El resultado de ese comando muestra la `create-table` respuesta estándar y tiene un aspecto similar al de este ejemplo.
```
{ "resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable" }
```
------
# Habilitar una transmisión de CDC para una tabla existente en Amazon Keyspaces
Para habilitar una transmisión de CDC para una tabla existente, puede usar la `ALTER TABLE` sentencia en CQL, el `update-table` comando junto con la AWS CLI tabla o puede usar la consola.
Para cada fila modificada de la tabla, Amazon Keyspaces puede capturar los siguientes cambios en función `view_type` de los `cdc_specification` que seleccione:
+ `NEW_AND_OLD_IMAGES`— ambas versiones de la fila, antes y después del cambio. Este es el valor predeterminado.
+ `NEW_IMAGE`— la versión de la fila tras el cambio.
+ `OLD_IMAGE`— la versión de la fila anterior al cambio.
+ `KEYS_ONLY`— las claves de partición y agrupamiento de la fila que se ha modificado.
Para obtener información sobre cómo etiquetar una transmisión, consulte[Añadir nuevas etiquetas a una transmisión](Tagging.Operations.existing.stream.md).
**nota**
Amazon Keyspaces CDC requiere la presencia de un rol vinculado a un servicio (`AWSServiceRoleForAmazonKeyspacesCDC`) que publique los datos de métricas de las transmisiones de Amazon Keyspaces CDC en su cuenta `"cloudwatch:namespace": "AWS/Cassandra"` en su nombre. CloudWatch Este rol se crea automáticamente. Para obtener más información, consulte [Uso de roles para las transmisiones de los CDC de Amazon Keyspaces](using-service-linked-roles-CDC-streams.md).
------
#### [ Cassandra Query Language (CQL) ]
**Habilite una transmisión (transmisión de CDC) con CQL**
Se puede utilizar `ALTER TABLE` para habilitar una transmisión en una tabla existente.
1. El siguiente ejemplo crea una secuencia que solo captura los cambios en las claves de partición y agrupamiento de una fila modificada.
```
ALTER TABLE mykeyspace.mytable
WITH cdc = TRUE
AND CUSTOM_PROPERTIES={'cdc_specification': {'view_type': 'KEYS_ONLY'}};
```
1. Para comprobar la configuración de la transmisión, puede utilizar la siguiente declaración.
```
SELECT keyspace_name, table_name, cdc, custom_properties FROM system_schema_mcs.tables WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
El resultado de la declaración tiene un aspecto similar al siguiente.
```
keyspace_name | table_name | cdc | custom_properties
---------------+------------+------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
mykeyspace | mytable | True | {'capacity_mode': {'last_update_to_pay_per_request_timestamp': '1741385897045', 'throughput_mode': 'PAY_PER_REQUEST'}, 'cdc_specification': {'latest_stream_arn': 'arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable/stream/2025-03-07T22:20:10.454', 'status': 'ENABLED', 'view_type': 'KEYS_ONLY'}, 'encryption_specification': {'encryption_type': 'AWS_OWNED_KMS_KEY'}, 'point_in_time_recovery': {'status': 'disabled'}}
```
------
#### [ CLI ]
**Cree una transmisión de los CDC con AWS CLI**
1. Para crear una transmisión para una tabla existente, puede usar la siguiente sintaxis.
```
aws keyspaces update-table \
--keyspace-name 'mykeyspace' \
--table-name 'mytable' \
--cdc-specification status=ENABLED,viewType=NEW_AND_OLD_IMAGES
```
1. El resultado de ese comando muestra la `create-table` respuesta estándar y tiene un aspecto similar al de este ejemplo.
```
{ "resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable" }
```
------
#### [ Console ]
**Habilite una transmisión de CDC con la consola Amazon Keyspaces**
1. [Inicia sesión en la Consola de administración de AWS consola de Amazon Keyspaces y ábrela desde casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. En el panel de navegación, selecciona **Tablas** y, a continuación, selecciona una tabla de la lista.
1. Seleccione la pestaña **Streams**.
1. Seleccione **Editar** para activar una transmisión.
1. Selecciona **Activar transmisiones**.
1. Selecciona **Ver el tipo** de transmisión. Están disponibles las siguientes opciones. Ten en cuenta que no puedes cambiar el tipo de visualización de una transmisión una vez creada.
+ **Imágenes nuevas y antiguas**: Amazon Keyspaces captura ambas versiones de la fila, antes y después del cambio. Esta es la opción predeterminada.
+ **Imagen nueva**: Amazon Keyspaces captura solo la versión de la fila después del cambio.
+ **Imagen antigua**: Amazon Keyspaces captura solo la versión de la fila anterior al cambio.
+ **Solo clave principal**: Amazon Keyspaces captura solo las columnas clave de partición y agrupamiento de la fila que se ha modificado.
1. Para terminar, selecciona **Guardar** cambios.
------
# Inhabilitar una transmisión de los CDC en Amazon Keyspaces
Para deshabilitar una transmisión de CDC en un espacio de claves, puede usar la `ALTER TABLE` instrucción en CQL, el `update-table` comando de o la AWS CLI consola.
------
#### [ Cassandra Query Language (CQL) ]
**Inhabilite una transmisión (transmisión CDC) con CQL**
1. Para deshabilitar una transmisión, puede usar la siguiente declaración.
```
ALTER TABLE mykeyspace.mytable
WITH cdc = FALSE;
```
1. Para confirmar que la transmisión está deshabilitada, puede usar la siguiente declaración.
```
SELECT keyspace_name, table_name, cdc, custom_properties FROM system_schema_mcs.tables WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
El resultado de esa declaración tiene un aspecto similar al siguiente.
```
keyspace_name | table_name | cdc | custom_properties
---------------+------------+-------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
mykeyspace | mytable | False | {'capacity_mode': {'last_update_to_pay_per_request_timestamp': '1741385668642', 'throughput_mode': 'PAY_PER_REQUEST'}, 'encryption_specification': {'encryption_type': 'AWS_OWNED_KMS_KEY'}, 'point_in_time_recovery': {'status': 'disabled'}}
```
------
#### [ CLI ]
**Desactive una transmisión (transmisión de CDC) con el AWS CLI**
1. Para deshabilitar una transmisión, puede usar el siguiente comando.
```
aws keyspaces update-table \
--keyspace-name 'mykeyspace' \
--table-name 'mytable' \
--cdc-specification status=DISABLED
```
1. El resultado del comando es similar al de este ejemplo.
```
{
"keyspaceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/",
"streamName": "my_stream"
}
```
------
#### [ Console ]
**Desactivar una transmisión (transmisión de CDC) con la consola de Amazon Keyspaces**
1. [Inicia sesión en la Consola de administración de AWS consola de Amazon Keyspaces y ábrela desde casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. En el panel de navegación, selecciona **Tablas** y, a continuación, selecciona una tabla de la lista.
1. Seleccione la pestaña **Streams**.
1. Elija **Edit (Edición de)**.
1. Deselecciona **Activar transmisiones**.
1. Selecciona **Guardar cambios** para deshabilitar la transmisión.
------
# Vea las transmisiones de los CDC en Amazon Keyspaces
Para ver o enumerar todas las transmisiones en el espacio de claves, puede consultar la tabla `system_schema_mcs.streams` en el espacio de claves del sistema mediante una sentencia en CQL o utilizar los `list-stream` comandos `get-stream` y con la consola o con la consola AWS CLI.
Para conocer los permisos necesarios, consulte [Configure los permisos para trabajar con las transmisiones de los CDC en Amazon Keyspaces](configure-cdc-permissions.md).
------
#### [ Cassandra Query Language (CQL) ]
**Vea las transmisiones de los CDC con CQL**
+ Para monitorear el estado de su tabla en los CDC, puede usar la siguiente declaración.
```
SELECT custom_properties
FROM system_schema_mcs.tables
WHERE keyspace_name='my_keyspace' and table_name='my_table';
```
El resultado del comando tiene un aspecto similar al siguiente.
```
...
custom_properties
----------------------------------------------------------------------------------
{'cdc_specification':{'status': 'Enabled', 'view_type': 'NEW_IMAGE', 'latest_stream_arn': 'arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/table/my_table/stream/stream_label''}}
...
```
------
#### [ CLI ]
**Vea las transmisiones de los CDC con el AWS CLI**
1. En este ejemplo se muestra cómo ver la información de transmisión de una tabla.
```
aws keyspaces get-table \
--keyspace-name 'my_keyspace' \
--table-name 'my_table'
```
El resultado del comando tiene este aspecto.
```
{
"keyspaceName": "my_keyspace",
"tableName": "my_table",
... Other fields ...,
"latestStreamArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/my_keyspace/table/my_table/stream/stream_label",
"cdcSpecification": {
"status": "ENABLED",
"viewType": "NEW_AND_OLD_IMAGES"
}
}
```
1. Puede enumerar todas las transmisiones de su cuenta de la forma especificada Región de AWS. El siguiente comando es un ejemplo de esto.
```
aws keyspacesstreams list-streams --region us-east-1
```
El resultado del comando podría tener un aspecto similar al siguiente.
```
{
"Streams": [
{
"StreamArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/ks_1/table/t1/stream/2023-05-11T21:21:33.291",
"StreamLabel": "2023-05-11T21:21:33.291",
"KeyspaceName": "ks_1"
"TableName": "t1",
},
{
"StreamArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/ks_1/table/t2/stream/2023-05-11T21:21:33.291",
"StreamLabel": "2023-05-11T21:21:33.291",
"KeyspaceName": "ks_1"Create a keyspace with the name catalog. Note
that streams are not supported in multi-Region keyspaces.
"TableName": "t2",
},
{
"StreamArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/ks_2/table/t1/stream/2023-05-11T21:21:33.291",
"StreamLabel": "2023-05-11T21:21:33.291",
"KeyspaceName": "ks_3"
"TableName": "t1",
}
]
}
```
1. También puede enumerar las secuencias CDC de un espacio de claves determinado mediante los siguientes parámetros.
```
aws keyspacesstreams list-streams --keyspace-name ks_1 --region us-east-1
```
El resultado del comando tiene un aspecto similar al siguiente.
```
{
"Streams": [
{
"StreamArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/ks_1/table/t1/stream/2023-05-11T21:21:33.291",
"StreamLabel": "2023-05-11T21:21:33.291",
"KeyspaceName": "ks_1"
"TableName": "t1",
},
{
"StreamArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/ks_1/table/t2/stream/2023-05-11T21:21:33.291",
"StreamLabel": "2023-05-11T21:21:33.291",
"KeyspaceName": "ks_1"
"TableName": "t2",
}
]
}
```
1. También puede enumerar los flujos CDC de una tabla determinada utilizando los siguientes parámetros.
```
aws keyspacesstreams list-streams --keyspace-name ks_1 --table-name t2 --region us-east-1
```
El resultado del comando tiene un aspecto similar al siguiente.
```
{
"Streams": [
{
"StreamArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/ks_1/table/t2/stream/2023-05-11T21:21:33.291",
"StreamLabel": "2023-05-11T21:21:33.291",
"KeyspaceName": "ks_1"
"TableName": "t2",
}
]
}
```
------
#### [ Console ]
**Vea las transmisiones de los CDC en la consola de Amazon Keyspaces**
1. [Inicia sesión en la Consola de administración de AWS consola de Amazon Keyspaces y ábrela desde casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. En el panel de navegación, selecciona **Tablas** y, a continuación, selecciona una tabla de la lista.
1. Seleccione la pestaña **Transmisiones** para revisar los detalles de la transmisión.
------
# Acceda a los registros de las transmisiones de los CDC en Amazon Keyspaces
Para acceder a los registros de una transmisión, utilice la API [Amazon Keyspaces Streams](https://docs.aws.amazon.com/keyspaces/latest/StreamsAPIReference/Welcome.html). La siguiente sección contiene ejemplos sobre cómo acceder a los registros mediante. AWS CLI
Para conocer los permisos necesarios, consulte [Configure los permisos para trabajar con las transmisiones de los CDC en Amazon Keyspaces](configure-cdc-permissions.md).
**Acceda a los registros de una transmisión mediante el AWS CLI**
1. Puede utilizar la API Amazon Keyspaces Streams para acceder a los registros de cambios de la transmisión. Para obtener más información, consulte la referencia de la [https://docs.aws.amazon.com/keyspaces/latest/StreamsAPIReference/Welcome.html](https://docs.aws.amazon.com/keyspaces/latest/StreamsAPIReference/Welcome.html). Para recuperar los fragmentos de la transmisión, puede utilizar la `get-stream` API, tal y como se muestra en el siguiente ejemplo.
```
aws keyspacesstreams get-stream \
--stream-arn 'arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable/stream/STREAM_LABEL'
```
A continuación se muestra un ejemplo de la salida.
```
{
"StreamArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable/stream/2023-05-11T21:21:33.291",
"StreamStatus": "ENABLED",
"StreamViewType": "NEW_AND_OLD_IMAGES",
"CreationRequestDateTime": "",
"KeyspaceName": "mykeyspace",
"TableName": "mytable",
"StreamLabel": "2023-05-11T21:21:33.291",
"Shards": [
{
"SequenceNumberRange": {
"EndingSequenceNumber": "",
"StartingSequenceNumber": ""
},
"ShardId": ""
},
]
}
```
1. Para recuperar registros de la transmisión, comience por obtener un iterador que le proporcione el punto de partida para acceder a los registros. Para ello, puedes usar los fragmentos de la transmisión de CDC devueltos por la API en el paso anterior. Para recopilar el iterador, puedes usar la `get-shard-iterator` API. Para este ejemplo, se utiliza un iterador del tipo `TRIM_HORIZON` que recupera datos del último punto recortado (o principio) del fragmento.
```
aws keyspacesstreams get-shard-iterator \
--stream-arn 'arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable/stream/STREAM_LABEL' \
--shard-id 'SHARD_ID' \
--shard-iterator-type 'TRIM_HORIZON'
```
El resultado del comando es similar al del siguiente ejemplo.
```
{
"ShardIterator": ""
}
```
1. Para recuperar los registros de los CDC mediante la `get-records` API, puede utilizar el iterador devuelto en el último paso. El siguiente comando es un ejemplo de esto.
```
aws keyspacesstreams get-records \
--shard-iterator 'SHARD_ITERATOR' \
--limit 100
```
# Utilice la biblioteca de clientes de Kinesis (KCL) para procesar las transmisiones de Amazon Keyspaces
En este tema se describe cómo utilizar la biblioteca de clientes de Kinesis (KCL) para consumir y procesar datos de las transmisiones de captura de datos de cambios (CDC) de Amazon Keyspaces.
En lugar de trabajar directamente con la API Streams de Amazon Keyspaces, trabajar con la biblioteca de clientes de Kinesis (KCL) ofrece muchas ventajas, por ejemplo:
+ El seguimiento del linaje de fragmentos y el manejo de iteradores están integrados.
+ Equilibrio de carga automático entre los trabajadores.
+ Tolerancia a las fallas y recuperación de las fallas de los trabajadores.
+ Puntos de control para realizar un seguimiento del progreso del procesamiento.
+ Adaptación a los cambios en la capacidad del flujo.
+ Computación distribuida simplificada para procesar los registros de los CDC.
En la siguiente sección se explica por qué y cómo utilizar la biblioteca de clientes de Kinesis (KCL) para procesar transmisiones y se proporciona un ejemplo de cómo procesar una transmisión CDC de Amazon Keyspaces con la KCL.
Para obtener información sobre precios, consulte [Precios de Amazon Keyspaces (para Apache Cassandra)](https://aws.amazon.com/keyspaces/pricing).
## ¿Qué es Kinesis Client Library?
La biblioteca de clientes de Kinesis (KCL) es una biblioteca de software Java independiente diseñada para simplificar el proceso de consumo y procesamiento de datos de las transmisiones. KCL gestiona muchas de las tareas complejas asociadas a la informática distribuida, lo que le permite centrarse en implementar la lógica empresarial al procesar los datos de las transmisiones. KCL gestiona actividades como equilibrar la carga entre varios trabajadores, responder a las fallas de los trabajadores, controlar los registros procesados y responder a los cambios en la cantidad de fragmentos de la transmisión.
Para procesar las transmisiones CDC de Amazon Keyspaces, puede utilizar los patrones de diseño que se encuentran en la KCL para trabajar con fragmentos y registros de transmisiones. KCL simplifica la codificación porque proporciona abstracciones útiles por encima del API de bajo nivel de Kinesis Data Streams. Para obtener más información sobre la KCL, consulte [Desarrollar consumidores con la KCL](https://docs.aws.amazon.com/kinesis/latest/dev/develop-kcl-consumers.html) en la Guía para desarrolladores de *Amazon Kinesis Data Streams*.
Para escribir aplicaciones con la KCL, utilice el adaptador Amazon Keyspaces Streams Kinesis. El adaptador Kinesis implementa la interfaz Kinesis Data Streams para que pueda utilizar la KCL para consumir y procesar registros de las transmisiones de Amazon Keyspaces. Para obtener instrucciones sobre cómo configurar e instalar el adaptador Amazon Keyspaces Streams Kinesis, visite el repositorio. [GitHub](https://github.com/aws/keyspaces-streams-kinesis-adapter)
El siguiente diagrama muestra cómo interactúan estas bibliotecas entre sí.
![\[Interacción entre las aplicaciones de un cliente y Kinesis Data Streams, KCL, el adaptador Amazon Keyspaces Streams Kinesis Adapter y Amazon Keyspaces APIs al procesar los registros de transmisiones de Amazon Keyspaces CDC.\]](http://docs.aws.amazon.com/es_es/keyspaces/latest/devguide/images/keyspaces-streams-kinesis-adapter.png)
KCL se actualiza con frecuencia para incorporar versiones más recientes de las bibliotecas subyacentes, mejoras de seguridad y correcciones de errores. Recomendamos utilizar la versión más reciente de KCL para evitar los problemas ya conocidos y beneficiarse de las mejoras actuales. [Para encontrar la versión más reciente de KCL, consulte el repositorio de KCL. GitHub ](https://github.com/awslabs/amazon-kinesis-client)
## Conceptos de KCL
Antes de implementar una aplicación de consumo mediante KCL, debe comprender los siguientes conceptos:
**Aplicación KCL para consumidores**
Una aplicación para consumidores de KCL es un programa que procesa datos de una transmisión CDC de Amazon Keyspaces. La KCL actúa como intermediaria entre el código de tu aplicación de consumidor y la transmisión CDC de Amazon Keyspaces.
**Trabajador**
Un trabajador es una unidad de ejecución de su aplicación de consumo de KCL que procesa datos de la transmisión CDC de Amazon Keyspaces. Su aplicación puede ejecutar varios trabajadores distribuidos en varias instancias.
**Procesador de registros**
Un procesador de registros es la lógica de su aplicación que procesa los datos de un fragmento de la transmisión CDC de Amazon Keyspaces. Un trabajador crea una instancia de un procesador de registros para cada fragmento que administra.
**Arrendamiento**
Un arrendamiento representa la responsabilidad de procesar un fragmento. Los trabajadores utilizan los contratos de arrendamiento para coordinar qué trabajador procesa qué fragmento. KCL almacena los datos de arrendamiento en una tabla de Amazon DynamoDB.
**Checkpoint**
Un punto de control es un registro de la posición del fragmento hasta la que el procesador de registros ha procesado correctamente los registros. Los puntos de control permiten que su solicitud reanude el procesamiento desde donde lo dejó en caso de que un trabajador no lo logre.
Con el adaptador Amazon Keyspaces Kinesis instalado, puede empezar a desarrollar en la interfaz KCL, con las llamadas a la API dirigidas sin problemas al punto de conexión de transmisión de Amazon Keyspaces. Para obtener una lista de los puntos de conexión disponibles, consulte [Cómo acceder a los puntos de enlace de transmisión de los CDC en Amazon Keyspaces](CDC_access-endpoints.md).
Cuando se inicia la aplicación, llama a KCL para crear una instancia de un proceso de trabajo. Debe proporcionar al trabajador la información de configuración de la aplicación, como el descriptor de la transmisión y AWS las credenciales, y el nombre de la clase de procesador de registros que proporcione. A medida que el proceso de trabajo ejecuta el código en el procesador de registros, lleva a cabo las siguientes tareas:
+ Se conecta a la secuencia
+ Enumera las particiones del flujo.
+ Coordina la asociación de los fragmentos con otros procesos de trabajo (si procede)
+ Crea instancias de un procesador de registros para cada fragmento que administra
+ Extrae registros del flujo.
+ Inserta los registros en el procesador de registros correspondiente
+ Genera puntos de comprobación para los registros procesados
+ Balancea las asociaciones entre fragmentos y procesos de trabajo cuando cambia el recuento de instancias de procesos de trabajo
+ Equilibra las asociaciones entre particiones y procesos de trabajo cuando las particiones se dividen.
# Implemente una aplicación de consumo de KCL para las transmisiones de Amazon Keyspaces CDC
En este tema se proporciona una step-by-step guía para implementar una aplicación de consumo de KCL para procesar las transmisiones de Amazon Keyspaces CDC.
1. Requisitos previos: antes de empezar, asegúrese de tener:
+ Una tabla de Amazon Keyspaces con una transmisión de CDC
+ Permisos de IAM necesarios para que el director de IAM pueda acceder a la transmisión CDC de Amazon Keyspaces, crear tablas de DynamoDB y acceder a ellas para el procesamiento de transmisiones de KCL y permisos para publicar métricas en ellas. CloudWatch Para obtener más información y un ejemplo de política, consulte. [Permisos para procesar las transmisiones de los CDC de Amazon Keyspaces con la biblioteca de clientes de Kinesis (KCL)](configure-cdc-permissions.md#cdc-permissions-kcl)
+ Asegúrese de que AWS las credenciales válidas estén configuradas en su configuración local. Para obtener más información, consulte [Almacenamiento de claves de acceso para el acceso programático](aws.credentials.manage.md).
+ Java Development Kit (JDK) 8 o posterior,
+ Los requisitos figuran en el [archivo readme](https://github.com/aws/keyspaces-streams-kinesis-adapter) de Github.
1. En este paso, agregas la dependencia de KCL a tu proyecto. Para Maven, agrega lo siguiente a tu archivo pom.xml:
```
software.amazon.kinesis
amazon-kinesis-client
3.1.0
software.amazon.keyspaces
keyspaces-streams-kinesis-adapter
1.0.0
```
**nota**
Compruebe siempre la última versión de KCL en el repositorio de [ GitHub KCL](https://github.com/awslabs/amazon-kinesis-client).
1. Cree una clase de fábrica que produzca instancias de procesadores de registros:
```
import software.amazon.awssdk.services.keyspacesstreams.model.Record;
import software.amazon.keyspaces.streamsadapter.adapter.KeyspacesStreamsClientRecord;
import software.amazon.keyspaces.streamsadapter.model.KeyspacesStreamsProcessRecordsInput;
import software.amazon.keyspaces.streamsadapter.processor.KeyspacesStreamsShardRecordProcessor;
import software.amazon.kinesis.lifecycle.events.InitializationInput;
import software.amazon.kinesis.lifecycle.events.LeaseLostInput;
import software.amazon.kinesis.lifecycle.events.ShardEndedInput;
import software.amazon.kinesis.lifecycle.events.ShutdownRequestedInput;
import software.amazon.kinesis.processor.RecordProcessorCheckpointer;
public class RecordProcessor implements KeyspacesStreamsShardRecordProcessor {
private String shardId;
@Override
public void initialize(InitializationInput initializationInput) {
this.shardId = initializationInput.shardId();
System.out.println("Initializing record processor for shard: " + shardId);
}
@Override
public void processRecords(KeyspacesStreamsProcessRecordsInput processRecordsInput) {
try {
for (KeyspacesStreamsClientRecord record : processRecordsInput.records()) {
Record keyspacesRecord = record.getRecord();
System.out.println("Received record: " + keyspacesRecord);
}
if (!processRecordsInput.records().isEmpty()) {
RecordProcessorCheckpointer checkpointer = processRecordsInput.checkpointer();
try {
checkpointer.checkpoint();
System.out.println("Checkpoint successful for shard: " + shardId);
} catch (Exception e) {
System.out.println("Error while checkpointing for shard: " + shardId + " " + e);
}
}
} catch (Exception e) {
System.out.println("Error processing records for shard: " + shardId + " " + e);
}
}
@Override
public void leaseLost(LeaseLostInput leaseLostInput) {
System.out.println("Lease lost for shard: " + shardId);
}
@Override
public void shardEnded(ShardEndedInput shardEndedInput) {
System.out.println("Shard ended: " + shardId);
try {
// This is required. Checkpoint at the end of the shard
shardEndedInput.checkpointer().checkpoint();
System.out.println("Final checkpoint successful for shard: " + shardId);
} catch (Exception e) {
System.out.println("Error while final checkpointing for shard: " + shardId + " " + e);
throw new RuntimeException("Error while final checkpointing", e);
}
}
@Override
public void shutdownRequested(ShutdownRequestedInput shutdownRequestedInput) {
System.out.println("Shutdown requested for shard " + shardId);
try {
shutdownRequestedInput.checkpointer().checkpoint();
} catch (Exception e) {
System.out.println("Error while checkpointing on shutdown for shard: " + shardId + " " + e);
}
}
}
```
1. Cree una fábrica de discos como se muestra en el siguiente ejemplo.
```
import software.amazon.kinesis.processor.ShardRecordProcessor;
import software.amazon.kinesis.processor.ShardRecordProcessorFactory;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
public class RecordProcessorFactory implements ShardRecordProcessorFactory {
private final Queue processors = new ConcurrentLinkedQueue<>();
@Override
public ShardRecordProcessor shardRecordProcessor() {
System.out.println("Creating new RecordProcessor");
RecordProcessor processor = new RecordProcessor();
processors.add(processor);
return processor;
}
}
```
1. En este paso, se crea la clase base que se va a configurar KCLv3 y el adaptador Amazon Keyspaces.
```
import com.example.KCLExample.utils.RecordProcessorFactory;
import software.amazon.keyspaces.streamsadapter.AmazonKeyspacesStreamsAdapterClient;
import software.amazon.keyspaces.streamsadapter.StreamsSchedulerFactory;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.cloudwatch.CloudWatchAsyncClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
import software.amazon.awssdk.services.dynamodb.model.DeleteTableRequest;
import software.amazon.awssdk.services.dynamodb.model.DeleteTableResponse;
import software.amazon.awssdk.services.keyspacesstreams.KeyspacesStreamsClient;
import software.amazon.awssdk.services.kinesis.KinesisAsyncClient;
import software.amazon.kinesis.common.ConfigsBuilder;
import software.amazon.kinesis.common.InitialPositionInStream;
import software.amazon.kinesis.common.InitialPositionInStreamExtended;
import software.amazon.kinesis.coordinator.CoordinatorConfig;
import software.amazon.kinesis.coordinator.Scheduler;
import software.amazon.kinesis.leases.LeaseManagementConfig;
import software.amazon.kinesis.processor.ProcessorConfig;
import software.amazon.kinesis.processor.StreamTracker;
import software.amazon.kinesis.retrieval.polling.PollingConfig;
public class KCLTestBase {
protected KeyspacesStreamsClient streamsClient;
protected KinesisAsyncClient adapterClient;
protected DynamoDbAsyncClient dynamoDbAsyncClient;
protected CloudWatchAsyncClient cloudWatchClient;
protected Region region;
protected RecordProcessorFactory recordProcessorFactory;
protected Scheduler scheduler;
protected Thread schedulerThread;
public void baseSetUp() {
recordProcessorFactory = new RecordProcessorFactory();
setupKCLBase();
}
protected void setupKCLBase() {
region = Region.US_EAST_1;
streamsClient = KeyspacesStreamsClient.builder()
.region(region)
.build();
adapterClient = new AmazonKeyspacesStreamsAdapterClient(
streamsClient,
region);
dynamoDbAsyncClient = DynamoDbAsyncClient.builder()
.region(region)
.build();
cloudWatchClient = CloudWatchAsyncClient.builder()
.region(region)
.build();
}
protected void startScheduler(Scheduler scheduler) {
this.scheduler = scheduler;
schedulerThread = new Thread(() -> scheduler.run());
schedulerThread.start();
}
protected void shutdownScheduler() {
if (scheduler != null) {
scheduler.shutdown();
try {
schedulerThread.join(30000);
} catch (InterruptedException e) {
System.out.println("Error while shutting down scheduler " + e);
}
}
}
protected Scheduler createScheduler(String streamArn, String leaseTableName) {
String workerId = "worker-" + System.currentTimeMillis();
// Create ConfigsBuilder
ConfigsBuilder configsBuilder = createConfigsBuilder(streamArn, workerId, leaseTableName);
// Configure retrieval config for polling
PollingConfig pollingConfig = new PollingConfig(streamArn, adapterClient);
// Create the Scheduler
return StreamsSchedulerFactory.createScheduler(
configsBuilder.checkpointConfig(),
configsBuilder.coordinatorConfig(),
configsBuilder.leaseManagementConfig(),
configsBuilder.lifecycleConfig(),
configsBuilder.metricsConfig(),
configsBuilder.processorConfig(),
configsBuilder.retrievalConfig().retrievalSpecificConfig(pollingConfig),
streamsClient,
region
);
}
private ConfigsBuilder createConfigsBuilder(String streamArn, String workerId, String leaseTableName) {
ConfigsBuilder configsBuilder = new ConfigsBuilder(
streamArn,
leaseTableName,
adapterClient,
dynamoDbAsyncClient,
cloudWatchClient,
workerId,
recordProcessorFactory);
configureCoordinator(configsBuilder.coordinatorConfig());
configureLeaseManagement(configsBuilder.leaseManagementConfig());
configureProcessor(configsBuilder.processorConfig());
configureStreamTracker(configsBuilder, streamArn);
return configsBuilder;
}
private void configureCoordinator(CoordinatorConfig config) {
config.skipShardSyncAtWorkerInitializationIfLeasesExist(true)
.parentShardPollIntervalMillis(1000)
.shardConsumerDispatchPollIntervalMillis(500);
}
private void configureLeaseManagement(LeaseManagementConfig config) {
config.shardSyncIntervalMillis(0)
.leasesRecoveryAuditorInconsistencyConfidenceThreshold(0)
.leasesRecoveryAuditorExecutionFrequencyMillis(5000)
.leaseAssignmentIntervalMillis(1000L);
}
private void configureProcessor(ProcessorConfig config) {
config.callProcessRecordsEvenForEmptyRecordList(true);
}
private void configureStreamTracker(ConfigsBuilder configsBuilder, String streamArn) {
StreamTracker streamTracker = StreamsSchedulerFactory.createSingleStreamTracker(
streamArn,
InitialPositionInStreamExtended.newInitialPosition(InitialPositionInStream.TRIM_HORIZON)
);
configsBuilder.streamTracker(streamTracker);
}
public void deleteAllDdbTables(String baseTableName) {
List tablesToDelete = Arrays.asList(
baseTableName,
baseTableName + "-CoordinatorState",
baseTableName + "-WorkerMetricStats"
);
for (String tableName : tablesToDelete) {
deleteTable(tableName);
}
}
private void deleteTable(String tableName) {
DeleteTableRequest deleteTableRequest = DeleteTableRequest.builder()
.tableName(tableName)
.build();
try {
DeleteTableResponse response = dynamoDbAsyncClient.deleteTable(deleteTableRequest).get();
System.out.println("Table deletion response " + response);
} catch (InterruptedException | ExecutionException e) {
System.out.println("Error deleting table: " + tableName + " " + e);
}
}
}
```
1. En este paso, implementa la clase de procesador de registros para que su aplicación comience a procesar los eventos de cambio.
```
import software.amazon.kinesis.coordinator.Scheduler;
public class KCLTest {
private static final int APP_RUNTIME_SECONDS = 1800;
private static final int SLEEP_INTERNAL_MS = 60*1000;
public static void main(String[] args) {
KCLTestBase kclTestBase;
kclTestBase = new KCLTestBase();
kclTestBase.baseSetUp();
// Create and start scheduler
String leaseTableName = generateUniqueApplicationName();
// Update below to your Stream ARN
String streamArn = "arn:aws:cassandra:us-east-1:759151643516:/keyspace/cdc_sample_test/table/test_kcl_bool/stream/2025-07-01T15:52:57.529";
Scheduler scheduler = kclTestBase.createScheduler(streamArn, leaseTableName);
kclTestBase.startScheduler(scheduler);
// Wait for specified time before shutting down - KCL applications are designed to run forever, however in this
// example we will shut it down after APP_RUNTIME_SECONDS
long startTime = System.currentTimeMillis();
long endTime = startTime + (APP_RUNTIME_SECONDS * 1000);
while (System.currentTimeMillis() < endTime) {
try {
// Print and sleep every minute
Thread.sleep(SLEEP_INTERNAL_MS);
System.out.println("Application is running");
} catch (InterruptedException e) {
System.out.println("Interrupted while waiting for records");
Thread.currentThread().interrupt();
break;
}
}
// Stop the scheduler
kclTestBase.shutdownScheduler();
kclTestBase.deleteAllDdbTables(leaseTableName);
}
public static String generateUniqueApplicationName() {
String timestamp = String.valueOf(System.currentTimeMillis());
String randomString = java.util.UUID.randomUUID().toString().substring(0, 8);
return String.format("KCL-App-%s-%s", timestamp, randomString);
}
}
```
## Prácticas recomendadas
Siga estas prácticas recomendadas cuando utilice KCL con las transmisiones de los CDC de Amazon Keyspaces:
**Error handling (Control de errores)**
Implemente una sólida gestión de errores en su procesador de registros para gestionar las excepciones sin problemas. Considere la posibilidad de implementar una lógica de reintento para los errores transitorios.
**Frecuencia de los puntos de control**
Equilibre la frecuencia de los puntos de control para minimizar el procesamiento duplicado y, al mismo tiempo, garantizar un seguimiento razonable del progreso. Los puntos de control demasiado frecuentes pueden afectar al rendimiento, mientras que los controles demasiado infrecuentes pueden provocar un mayor reprocesamiento si un trabajador no lo logra.
**Escalamiento de los trabajadores**
Escale la cantidad de trabajadores en función de la cantidad de fragmentos de su transmisión de los CDC. Un buen punto de partida es tener un trabajador por fragmento, pero es posible que tengas que ajustarlo en función de tus requisitos de procesamiento.
**Supervisión**
Utilice CloudWatch las métricas proporcionadas por KCL para supervisar el estado y el rendimiento de su aplicación de consumo. Las métricas clave incluyen la latencia de procesamiento, la antigüedad de los puntos de control y el recuento de arrendamientos.
**Pruebas**
Pruebe minuciosamente su aplicación de consumo, incluidos escenarios como los fallos de los trabajadores, la refragmentación de las transmisiones y las condiciones de carga variables.
## Uso de KCL con lenguajes distintos de Java
Si bien KCL es principalmente una biblioteca de Java, puede usarla con otros lenguajes de programación a través de. MultiLangDaemon MultiLangDaemon Se trata de un daemon basado en Java que gestiona la interacción entre un procesador de registros que no es de Java y el KCL.
KCL es compatible con los siguientes idiomas:
+ Python
+ Ruby
+ Node.js
+ .NET
[Para obtener más información sobre el uso de KCL con lenguajes distintos de Java, consulte la documentación de KCL. MultiLangDaemon ](https://github.com/awslabs/amazon-kinesis-client/tree/master/amazon-kinesis-client-multilang)
## Resolución de problemas
En esta sección se proporcionan soluciones a los problemas habituales que pueden surgir al utilizar KCL con las transmisiones de los CDC de Amazon Keyspaces.
**Procesamiento lento**
Si su solicitud de consumidor procesa los registros lentamente, considere lo siguiente:
+ Aumentar el número de instancias de trabajadores
+ Optimizar la lógica de procesamiento de registros
+ Comprobación de cuellos de botella en los sistemas posteriores
**Procesamiento duplicado**
Si observa un procesamiento duplicado de registros, compruebe la lógica de los puntos de control. Asegúrese de realizar un control después de procesar correctamente los registros.
**Fallos de los trabajadores**
Si los trabajadores fallan con frecuencia, compruebe:
+ Restricciones de recursos (CPU, memoria)
+ Problemas de conectividad de red
+ Problemas con los permisos
**Problemas con la tabla de arrendamiento**
Si tienes problemas con la tabla de arrendamientos de KCL:
+ Comprueba que tu aplicación tiene los permisos adecuados para acceder a la tabla de Amazon Keyspaces.
+ Compruebe que la tabla tiene un rendimiento aprovisionado suficiente