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. # Tutorial: Intégrelo con Apache Spark para importar o exportar datos Apache Spark es un motor de código abierto para el análisis de datos a gran escala. Apache Spark le permite realizar análisis de datos almacenados en Amazon Keyspaces de forma más eficiente. También puedes usar Amazon Keyspaces para proporcionar a las aplicaciones un acceso de single-digit-millisecond lectura coherente a los datos de análisis de Spark. El Spark Cassandra Connector de código abierto simplifica la lectura y escritura de datos entre Amazon Keyspaces y Spark. La compatibilidad de Amazon Keyspaces con Spark Cassandra Connector agiliza la ejecución de cargas de trabajo de Cassandra en canalizaciones de análisis basadas en Spark mediante el uso de un servicio de base de datos totalmente administrado sin servidor. Con Amazon Keyspaces, no tiene que preocuparse de que Spark compita por los mismos recursos de infraestructura subyacentes que sus tablas. Las tablas de Amazon Keyspaces se amplían y reducen automáticamente en función del tráfico de su aplicación. En el siguiente tutorial se describen los pasos y las prácticas recomendadas necesarios para leer y escribir datos en Amazon Keyspaces utilizando Spark Cassandra Connector. En el tutorial se explica cómo migrar datos a Amazon Keyspaces cargando datos desde un archivo con Spark Cassandra Connector y escribiéndolos en una tabla de Amazon Keyspaces. Además, en el tutorial se muestra cómo volver a leer los datos desde Amazon Keyspaces utilizando Spark Cassandra Connector. Esto se haría para ejecutar cargas de trabajo de Cassandra en canalizaciones de análisis basadas en Spark. **Topics** + [Requisitos previos para establecer conexiones a Amazon Keyspaces con Spark Cassandra Connector](spark-tutorial-prerequisites.md) + [Paso 1: Configurar Amazon Keyspaces para la integración con Apache Cassandra Spark Connector](spark-tutorial-step1.md) + [Paso 2: Configurar Apache Cassandra Spark Connector](spark-tutorial-step2.md) + [Paso 3: Crear el archivo de configuración de la aplicación](spark-tutorial-step3.md) + [Paso 4: Preparar los datos de origen y la tabla de destino en Amazon Keyspaces](spark-tutorial-step4.md) + [Paso 5: Escribir y leer datos en Amazon Keyspaces utilizando Apache Cassandra Spark Connector](spark-tutorial-step5.md) + [Solución de problemas comunes al utilizar Spark Cassandra Connector con Amazon Keyspaces](spark-tutorial-step6.md) # Requisitos previos para establecer conexiones a Amazon Keyspaces con Spark Cassandra Connector Antes de conectarse a Amazon Keyspaces con Spark Cassandra Connector, debe asegurarse de haber instalado lo siguiente. La compatibilidad de Amazon Keyspaces con Spark Cassandra Connector se ha probado con las siguientes versiones recomendadas: + Java versión 8 + Scala 2.12 + Spark 3.4 + Cassandra Connector 2.5 y superior + Controlador Cassandra 4.12 1. Para instalar Scala, siga las instrucciones indicadas en [https://www.scala-lang.org/download/scala2.html](https://www.scala-lang.org/download/scala2.html). 1. Para instalar Spark 3.4.1, siga este ejemplo. ``` curl -o spark-3.4.1-bin-hadoop3.tgz -k https://dlcdn.apache.org/spark/spark-3.4.1/spark-3.4.1-bin-hadoop3.tgz # now to untar tar -zxvf spark-3.4.1-bin-hadoop3.tgz # set this variable. export SPARK_HOME=$PWD/spark-3.4.1-bin-hadoop3 ``` ``` # Paso 1: Configurar Amazon Keyspaces para la integración con Apache Cassandra Spark Connector En este paso, usted confirma que el particionador de su cuenta es compatible con Apache Spark Connector y configura los permisos de IAM necesarios. Las siguientes prácticas recomendadas le ayudan a aprovisionar suficiente read/write capacidad para la tabla. 1. Confirme que el particionador `Murmur3Partitioner` es el particionador predeterminado de su cuenta. Este particionador es compatible con Spark Cassandra Connector. Para obtener más información sobre los particionadores y cómo cambiarlos, consulte [Uso de particionadores en Amazon Keyspaces](working-with-partitioners.md). 1. Configure sus permisos de IAM para Amazon Keyspaces, utilizando puntos de conexión de VPC de interfaz, con Apache Spark. + Asigne el read/write acceso a la tabla de usuarios y el acceso de lectura a las tablas del sistema, tal y como se muestra en el ejemplo de política de IAM que se muestra a continuación. + Es necesario rellenar la tabla system.peers con sus puntos de conexión de VPC de interfaz disponibles para los clientes que accedan a Amazon Keyspaces con Spark a través de [puntos de conexión de VPC](https://docs.aws.amazon.com/keyspaces/latest/devguide/vpc-endpoints.html). ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "cassandra:Select", "cassandra:Modify" ], "Resource":[ "arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable", "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*" ] }, { "Sid":"ListVPCEndpoints", "Effect":"Allow", "Action":[ "ec2:DescribeNetworkInterfaces", "ec2:DescribeVpcEndpoints" ], "Resource":"*" } ] } ``` 1. Tenga en cuenta las siguientes prácticas recomendadas a fin de configurar una capacidad de rendimiento de lectura/escritura suficiente para que su tabla de Amazon Keyspaces admita el tráfico de Spark Cassandra Connector. + Para comenzar, utilice capacidad bajo demanda como ayuda para probar el escenario. + Para optimizar el costo de rendimiento de la tabla para entornos de producción, utilice un limitador de velocidad para el tráfico procedente del conector y configure su tabla para utilizar capacidad aprovisionada con escalado automático. Para obtener más información, consulte [Administración automática de la capacidad de rendimiento con el escalado automático de Amazon Keyspaces](autoscaling.md). + Puede utilizar un limitador de tasa fijo que viene con el controlador Cassandra. Existen algunos [limitadores de tasa adaptados para Amazon Keyspaces](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers) en el repositorio [Ejemplos de AWS](https://github.com/aws-samples). + Para obtener más información sobre la administración de capacidad, consulte [Configurar los modos de read/write capacidad en Amazon Keyspaces](ReadWriteCapacityMode.md). # Paso 2: Configurar Apache Cassandra Spark Connector Apache Spark es una plataforma de cómputo de uso general que puede configurar de diferentes maneras. Para configurar Spark y Spark Cassandra Connector para su integración con Amazon Keyspaces, le recomendamos que comience con los ajustes de configuración mínimos que se describen en la siguiente sección y que los aumente posteriormente según resulte apropiado para su carga de trabajo. + **Cree particiones de Spark con tamaños inferiores a 8 MBs.** En Spark, las *particiones* representan un bloque atómico de datos que puede ejecutarse en paralelo. Al escribir datos en Amazon Keyspaces con Spark Cassandra Connector, cuanto menor sea la partición de Spark, menor será la cantidad de registros que la tarea vaya a escribir. Si una tarea de Spark encuentra múltiples errores, falla una vez agotado el número designado de reintentos. Para evitar la repetición de tareas grandes y el reprocesamiento de muchos datos, mantenga pequeño el tamaño de la partición de Spark. + **Utilice un número bajo de escrituras concurrentes por ejecutor con un gran número de reintentos.** Amazon Keyspaces devuelve errores de capacidad insuficiente a los controladores de Cassandra como tiempos de espera de operación. No puede abordar los tiempos de espera debidos a capacidad insuficiente cambiando la duración del tiempo de espera configurado porque Spark Cassandra Connector prueba el reintento de solicitudes de forma transparente utilizando la `MultipleRetryPolicy`. Para asegurarse de que los reintentos no saturan el grupo de conexiones del controlador, utilice un número bajo de escrituras concurrentes por ejecutor con un gran número de reintentos. El siguiente fragmento de código es un ejemplo de ello. ``` spark.cassandra.query.retry.count = 500 spark.cassandra.output.concurrent.writes = 3 ``` + **Divida el rendimiento total y distribúyalo entre múltiples sesiones de Cassandra.** + Spark Cassandra Connector crea una única sesión para cada ejecutor Spark. Piense en esta sesión como la unidad de escala para determinar el rendimiento requerido y el número de conexiones necesarias. + Al definir el número de núcleos por ejecutor y el número de núcleos por tarea, empiece por valores bajos y aumente según sea necesario. + Defina los fallos de las tareas de Spark para permitir el procesamiento en caso de errores transitorios. Una vez que se haya familiarizado con las características y los requisitos de tráfico de su aplicación, le recomendamos establecer `spark.task.maxFailures` en un valor acotado. + Por ejemplo, la siguiente configuración puede gestionar dos tareas concurrentes por ejecutor por sesión: ``` spark.executor.instances = configurable -> number of executors for the session. spark.executor.cores = 2 -> Number of cores per executor. spark.task.cpus = 1 -> Number of cores per task. spark.task.maxFailures = -1 ``` + **Desactive el procesamiento por lotes.** + Le recomendamos que desactive el procesamiento por lotes para mejorar los patrones de acceso aleatorio. El siguiente fragmento de código es un ejemplo de ello. ``` spark.cassandra.output.batch.size.rows = 1 (Default = None) spark.cassandra.output.batch.grouping.key = none (Default = Partition) spark.cassandra.output.batch.grouping.buffer.size = 100 (Default = 1000) ``` + **Establezca `SPARK_LOCAL_DIRS` en un disco local rápido con espacio suficiente.** + De forma predeterminada, Spark guarda los archivos de salida del mapa y los conjuntos de datos distribuidos resilientes (RDDs) en una `/tmp ` carpeta. En función de la configuración de su host Spark, esto puede dar lugar a errores del estilo *no hay espacio disponible en el dispositivo*. + Para establecer la variable de entorno `SPARK_LOCAL_DIRS` en un directorio llamado `/example/spark-dir`, puede utilizar el siguiente comando. ``` export SPARK_LOCAL_DIRS=/example/spark-dir ``` # Paso 3: Crear el archivo de configuración de la aplicación Para usar el conector Spark Cassandra de código abierto con Amazon Keyspaces, debe proporcionar un archivo de configuración de la aplicación que contenga los ajustes necesarios para conectarse con el controlador de Java. DataStax Para conectarse, puede utilizar credenciales específicas del servicio o el complemento SigV4. Si aún no lo ha hecho, debe convertir el certificado digital utilizado para crear la conexión TLS en un archivo TrustStore. Puede seguir los pasos detallados en [Antes de empezar](using_java_driver.md#using_java_driver.BeforeYouBegin) del tutorial de conexión del controlador Java. Tome nota de la ruta y la contraseña del archivo trustStore porque necesitará esta información en el momento de crear el archivo de configuración de la aplicación. ## Conexión con autenticación SigV4 En esta sección, se muestra un `application.conf` archivo de ejemplo que puede usar al conectarse con AWS credenciales y el complemento SigV4. Si aún no lo ha hecho, debe generar sus claves de acceso a IAM (un ID de clave de acceso y una clave de acceso secreta) y guardarlas en su archivo de AWS configuración o como variables de entorno. Para obtener instrucciones detalladas, consulte [Credenciales requeridas por el AWS CLI AWS SDK o el complemento SiGv4 de Amazon Keyspaces para los controladores de cliente de Cassandra](SigV4_credentials.md). En el siguiente ejemplo, sustituya la ruta de acceso a su archivo trustStore y la contraseña. ``` datastax-java-driver { basic.contact-points = ["cassandra.us-east-1.amazonaws.com:9142"] basic.load-balancing-policy { class = DefaultLoadBalancingPolicy local-datacenter = us-east-1 slow-replica-avoidance = false } basic.request { consistency = LOCAL_QUORUM } advanced { auth-provider = { class = software.aws.mcs.auth.SigV4AuthProvider aws-region = us-east-1 } ssl-engine-factory { class = DefaultSslEngineFactory truststore-path = "path_to_file/cassandra_truststore.jks" truststore-password = "password" hostname-validation=false } } advanced.connection.pool.local.size = 3 } ``` Actualice y guarde este archivo de configuración como `/home/user1/application.conf`. Los siguientes ejemplos utilizan esta ruta. ## Conexión con credenciales específicas del servicio En esta sección se muestra un archivo `application.conf` de ejemplo que puede utilizar cuando se conecte con credenciales específicas del servicio. Si aún no lo ha hecho, debe generar credenciales específicas del servicio para Amazon Keyspaces. Para obtener instrucciones detalladas, consulte [Creación de credenciales específicas del servicio para el acceso programático a Amazon Keyspaces](programmatic.credentials.ssc.md). En el siguiente ejemplo, sustituya `username` y `password` por sus propias credenciales. Asimismo, sustituya la ruta de acceso a su archivo trustStore y la contraseña. ``` datastax-java-driver { basic.contact-points = ["cassandra.us-east-1.amazonaws.com:9142"] basic.load-balancing-policy { class = DefaultLoadBalancingPolicy local-datacenter = us-east-1 } basic.request { consistency = LOCAL_QUORUM } advanced { auth-provider = { class = PlainTextAuthProvider username = "username" password = "password" aws-region = "us-east-1" } ssl-engine-factory { class = DefaultSslEngineFactory truststore-path = "path_to_file/cassandra_truststore.jks" truststore-password = "password" hostname-validation=false } metadata = { schema { token-map.enabled = true } } } } ``` Actualice y guarde este archivo de configuración como `/home/user1/application.conf` para utilizarlo con el código de ejemplo. ## Conexión con una tasa fija Para forzar una tasa fija por ejecutor Spark, puede definir un regulador de solicitudes. Este regulador de solicitudes limita la tasa de solicitudes por segundo. Spark Cassandra Connector implementa una sesión de Cassandra por ejecutor. El uso de la siguiente fórmula puede ayudarle a conseguir un rendimiento coherente en una tabla. ``` max-request-per-second * numberOfExecutors = total throughput against a table ``` Puede añadir este ejemplo al archivo de configuración de la aplicación que creó anteriormente. ``` datastax-java-driver { advanced.throttler { class = RateLimitingRequestThrottler max-requests-per-second = 3000 max-queue-size = 30000 drain-interval = 1 millisecond } } ``` # Paso 4: Preparar los datos de origen y la tabla de destino en Amazon Keyspaces En este paso, usted crea un archivo de origen con datos de muestra y una tabla de Amazon Keyspaces. 1. Cree el archivo de origen. Puede elegir una de las siguientes opciones: + En este tutorial, usted utiliza un archivo de valores separados por comas (CSV) llamado `keyspaces_sample_table.csv` como archivo de origen para la migración de datos. El archivo de ejemplo proporcionado contiene algunas filas de datos de una tabla llamada `book_awards`. 1. Descargue el archivo CSV de ejemplo (`keyspaces_sample_table.csv`) que se encuentra en el siguiente archivo comprimido: [samplemigration.zip](samples/samplemigration.zip). Descomprima el archivo y tome nota de la ruta a `keyspaces_sample_table.csv`. + Si desea seguir con su propio archivo CSV para escribir datos en Amazon Keyspaces, asegúrese de que los datos estén asignados al azar. Los datos que se leen directamente de una base de datos o se exportan a archivos planos suelen estar ordenados por la partición y la clave principal. Importar datos ordenados a Amazon Keyspaces puede hacer que se escriban en segmentos más pequeños de las particiones de Amazon Keyspaces, lo que da lugar a una distribución desigual del tráfico. Esto puede dar lugar a un rendimiento más lento y a tasas de error más elevadas. Por el contrario, la asignación al azar de los datos ayuda a aprovechar las capacidades de equilibrio de carga integradas de Amazon Keyspaces al distribuir el tráfico entre las particiones de forma más uniforme. Existen diversas herramientas que puede utilizar para aleatorizar los datos. Para ver un ejemplo que utiliza la herramienta de código abierto [Shuf](https://en.wikipedia.org/wiki/Shuf), consulte [Paso 2: Prepare los datos para cargarlos mediante DSBulk](dsbulk-upload-prepare-data.md) en el tutorial de migración de datos. El siguiente es un ejemplo que muestra cómo aleatorizar datos como un `DataFrame`. ``` import org.apache.spark.sql.functions.randval shuffledDF = dataframe.orderBy(rand()) ``` 1. Cree el espacio de claves y la tabla de destino en Amazon Keyspaces. 1. Conéctese a Amazon Keyspaces mediante. `cqlsh-expansion` Para ver las instrucciones de instalación de `cqlsh-expansion`, consulte [Uso de la `cqlsh-expansion` para conectarse a Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh). Sustituya el punto final del servicio en el siguiente ejemplo por su propio valor. ``` cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl ``` 1. Cree un nuevo espacio de claves con el nombre `catalog` como se muestra en el siguiente ejemplo. ``` CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'}; ``` 1. Una vez que el nuevo espacio de claves tenga el estado de disponible, utilice el siguiente código para crear la tabla de destino `book_awards`. Para obtener más información sobre la creación asíncrona de recursos y cómo comprobar si un recurso está disponible, consulte [Comprobación del estado de creación de los espacios de claves en Amazon Keyspaces](keyspaces-create.md). ``` CREATE TABLE catalog.book_awards ( year int, award text, rank int, category text, book_title text, author text, publisher text, PRIMARY KEY ((year, award), category, rank) ); ``` # Paso 5: Escribir y leer datos en Amazon Keyspaces utilizando Apache Cassandra Spark Connector En este paso, usted comienza cargando los datos del archivo de ejemplo en un `DataFrame` con Spark Cassandra Connector. A continuación, escribe los datos del `DataFrame` en su tabla de Amazon Keyspaces. También puede utilizar esta parte de forma independiente, por ejemplo, para migrar datos a una tabla de Amazon Keyspaces. Por último, lea los datos de su tabla en un `DataFrame` con Spark Cassandra Connector. También puede utilizar esta parte de forma independiente, por ejemplo, para leer datos de una tabla de Amazon Keyspaces para realizar análisis de datos con Apache Spark. 1. Inicie el intérprete de comandos de Spark como se muestra en el siguiente ejemplo. Tenga en cuenta que en este ejemplo se utiliza la autenticación SigV4. ``` ./spark-shell --files application.conf --conf spark.cassandra.connection.config.profile.path=application.conf --packages software.aws.mcs:aws-sigv4-auth-cassandra-java-driver-plugin:4.0.5,com.datastax.spark:spark-cassandra-connector_2.12:3.1.0 --conf spark.sql.extensions=com.datastax.spark.connector.CassandraSparkExtensions ``` 1. Importe Spark Cassandra Connector con el siguiente código. ``` import org.apache.spark.sql.cassandra._ ``` 1. Para leer los datos del archivo CSV y almacenarlos en un `DataFrame`, puede utilizar el siguiente código de ejemplo. ``` var df = spark.read.option("header","true").option("inferSchema","true").csv("keyspaces_sample_table.csv") ``` Puede visualizar el resultado con el siguiente comando. ``` scala> df.show(); ``` La salida debería ser similar a la siguiente. ``` +----------------+----+-----------+----+------------------+--------------------+-------------+ | award|year| category|rank| author| book_title| publisher| +----------------+----+-----------+----+------------------+--------------------+-------------+ |Kwesi Manu Prize|2020| Fiction| 1| Akua Mansa| Where did you go?|SomePublisher| |Kwesi Manu Prize|2020| Fiction| 2| John Stiles| Yesterday|Example Books| |Kwesi Manu Prize|2020| Fiction| 3| Nikki Wolf|Moving to the Cha...| AnyPublisher| | Wolf|2020|Non-Fiction| 1| Wang Xiulan| History of Ideas|Example Books| | Wolf|2020|Non-Fiction| 2|Ana Carolina Silva| Science Today|SomePublisher| | Wolf|2020|Non-Fiction| 3| Shirley Rodriguez|The Future of Sea...| AnyPublisher| | Richard Roe|2020| Fiction| 1| Alejandro Rosalez| Long Summer|SomePublisher| | Richard Roe|2020| Fiction| 2| Arnav Desai| The Key|Example Books| | Richard Roe|2020| Fiction| 3| Mateo Jackson| Inside the Whale| AnyPublisher| +----------------+----+-----------+----+------------------+--------------------+-------------+ ``` Puede confirmar el esquema de los datos en el `DataFrame` como se muestra en el siguiente ejemplo. ``` scala> df.printSchema ``` La salida debería tener este aspecto. ``` root |-- award: string (nullable = true) |-- year: integer (nullable = true) |-- category: string (nullable = true) |-- rank: integer (nullable = true) |-- author: string (nullable = true) |-- book_title: string (nullable = true) |-- publisher: string (nullable = true) ``` 1. Utilice el siguiente comando para escribir los datos del `DataFrame` en la tabla de Amazon Keyspaces. ``` df.write.cassandraFormat("book_awards", "catalog").mode("APPEND").save() ``` 1. Para confirmar que los datos se hayan guardado, puede volver a leerlos en un marco de datos, como se muestra en el siguiente ejemplo. ``` var newDf = spark.read.cassandraFormat("book_awards", "catalog").load() ``` A continuación, puede mostrar los datos que ahora contiene el marco de datos. ``` scala> newDf.show() ``` La salida de ese comando debería tener este aspecto. ``` +--------------------+------------------+----------------+-----------+-------------+----+----+ | book_title| author| award| category| publisher|rank|year| +--------------------+------------------+----------------+-----------+-------------+----+----+ | Long Summer| Alejandro Rosalez| Richard Roe| Fiction|SomePublisher| 1|2020| | History of Ideas| Wang Xiulan| Wolf|Non-Fiction|Example Books| 1|2020| | Where did you go?| Akua Mansa|Kwesi Manu Prize| Fiction|SomePublisher| 1|2020| | Inside the Whale| Mateo Jackson| Richard Roe| Fiction| AnyPublisher| 3|2020| | Yesterday| John Stiles|Kwesi Manu Prize| Fiction|Example Books| 2|2020| |Moving to the Cha...| Nikki Wolf|Kwesi Manu Prize| Fiction| AnyPublisher| 3|2020| |The Future of Sea...| Shirley Rodriguez| Wolf|Non-Fiction| AnyPublisher| 3|2020| | Science Today|Ana Carolina Silva| Wolf|Non-Fiction|SomePublisher| 2|2020| | The Key| Arnav Desai| Richard Roe| Fiction|Example Books| 2|2020| +--------------------+------------------+----------------+-----------+-------------+----+----+ ``` # Solución de problemas comunes al utilizar Spark Cassandra Connector con Amazon Keyspaces Si utiliza Amazon Virtual Private Cloud y se conecta a Amazon Keyspaces, los errores más comunes que se experimentan al utilizar el conector Spark se deben a los siguientes problemas de configuración. + El usuario o rol de IAM utilizado en la VPC carece de los permisos necesarios para acceder a la tabla `system.peers` de Amazon Keyspaces. Para obtener más información, consulte [Relleno de entradas de la tabla `system.peers` con información del punto de conexión de VPC de interfaz](vpc-endpoints.md#system_peers). + El usuario o rol de IAM carece de los read/write permisos necesarios para acceder a la tabla de usuarios y leer las tablas del sistema en Amazon Keyspaces. Para obtener más información, consulte [Paso 1: Configurar Amazon Keyspaces para la integración con Apache Cassandra Spark Connector](spark-tutorial-step1.md). + La configuración del controlador Java no deshabilita la verificación del nombre de host al crear la conexión SSL/TLS. Para ver ejemplos, consulte [Paso 2: configurar el controlador](using_java_driver.md#java_tutorial.driverconfiguration). Para conocer los pasos detallados para la solución de problemas de conexión, consulte [Mi punto de conexión de VPC no funciona correctamente](troubleshooting.connecting.md#troubleshooting.connection.vpce). Además, puedes usar CloudWatch las métricas de Amazon para ayudarte a solucionar problemas relacionados con la configuración del conector Spark Cassandra en Amazon Keyspaces. Para obtener más información sobre el uso de Amazon Keyspaces con CloudWatch, consulte. [Supervisión de Amazon Keyspaces con Amazon CloudWatch](monitoring-cloudwatch.md) En la siguiente sección se describen las métricas de mayor utilidad que debe observar al utilizar Spark Cassandra Connector. **PerConnectionRequestRateExceeded** Amazon Keyspaces tiene una cuota de 3000 solicitudes por segundo por conexión. Cada ejecutor Spark establece una conexión con Amazon Keyspaces. Ejecutar múltiples reintentos podría agotar su cuota de tasa de solicitudes por conexión. Si superas esta cuota, Amazon Keyspaces emitirá una `PerConnectionRequestRateExceeded` métrica in. CloudWatch Si observas la presencia de PerConnectionRequestRateExceeded eventos junto con otros errores del sistema o del usuario, es probable que Spark esté realizando varios reintentos por encima del número de solicitudes asignado por conexión. Si observa eventos `PerConnectionRequestRateExceeded` sin otros errores, es posible que tenga que aumentar el número de conexiones en la configuración de su controlador para permitir un mayor rendimiento, o que tenga que aumentar el número de ejecutores en su trabajo de Spark. **StoragePartitionThroughputCapacityExceeded** Amazon Keyspaces tiene una cuota de 1000 WCUs o WRUs por segundo/3000 RCUs o por segundo, RRUs por partición. Si ve `StoragePartitionThroughputCapacityExceeded` CloudWatch eventos, podría indicar que los datos no se distribuyen aleatoriamente durante la carga. Para ver ejemplos de cómo se aleatorizan los datos, consulte. [Paso 4: Preparar los datos de origen y la tabla de destino en Amazon Keyspaces](spark-tutorial-step4.md) ## Errores y advertencias comunes Si utiliza Amazon Virtual Private Cloud y se conecta a Amazon Keyspaces, el controlador de Cassandra podría emitir un mensaje de advertencia sobre el propio nodo de control en la tabla `system.peers`. Para obtener más información, consulte [Errores y advertencias comunes](vpc-endpoints.md#vpc_troubleshooting). Puede ignorar sin problemas esta advertencia.