As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Tutorial: Integre com o Apache Spark para importar ou exportar dados O Apache Spark é um mecanismo de código aberto para análise de dados em grande escala. O Apache Spark permite que você realize análises em dados armazenados no Amazon Keyspaces com mais eficiência. Você também pode usar o Amazon Keyspaces para fornecer aos aplicativos acesso consistente e de single-digit-millisecond leitura aos dados analíticos do Spark. O Spark Cassandra Connector de código aberto simplifica a leitura e gravação de dados entre o Amazon Keyspaces e o Spark. O suporte do Amazon Keyspaces para o Spark Cassandra Connector simplifica a execução de workloads do Cassandra em pipelines de análise baseados em Spark usando um serviço de banco de dados totalmente gerenciado e de tecnologia sem servidor. Com o Amazon Keyspaces, você não precisa se preocupar com a concorrência do Spark pelos mesmos recursos de infraestrutura subjacente de suas tabelas. As tabelas do Amazon Keyspaces aumentam e diminuem a escala automaticamente com base no tráfego do seu aplicativo. O tutorial a seguir mostra as etapas e as práticas recomendadas necessárias para ler e gravar dados no Amazon Keyspaces usando o Spark Cassandra Connector. O tutorial demonstra como migrar dados para o Amazon Keyspaces carregando dados de um arquivo com o Spark Cassandra Connector e gravando-os em uma tabela do Amazon Keyspaces. Em seguida, o tutorial mostra como ler os dados do Amazon Keyspaces usando o Spark Cassandra Connector. Você faria isso para executar workloads do Cassandra em pipelines de análise baseados em Spark. **Topics** + [Pré-requisitos para estabelecer conexões com o Amazon Keyspaces usando o Spark Cassandra Connector](spark-tutorial-prerequisites.md) + [Etapa 1: Configurar o Amazon Keyspaces para integração com o Apache Cassandra Spark Connector](spark-tutorial-step1.md) + [Etapa 2: Configurar o Apache Cassandra Spark Connector](spark-tutorial-step2.md) + [Etapa 3: Criar o arquivo de configuração do aplicativo](spark-tutorial-step3.md) + [Etapa 4: Preparar os dados de origem e a tabela de destino no Amazon Keyspaces](spark-tutorial-step4.md) + [Etapa 5: Gravar e ler dados do Amazon Keyspaces usando o Apache Cassandra Spark Connector](spark-tutorial-step5.md) + [Solução de problemas comuns ao usar o Spark Cassandra Connector com o Amazon Keyspaces](spark-tutorial-step6.md) # Pré-requisitos para estabelecer conexões com o Amazon Keyspaces usando o Spark Cassandra Connector Antes de se conectar ao Amazon Keyspaces com o Spark Cassandra Connector, você precisa ter certeza de que instalou o seguinte. A compatibilidade do Amazon Keyspaces com o Spark Cassandra Connector foi testada com as seguintes versões recomendadas: + Java versão 8 + Scala 2.12 + Spark 3.4 + Cassandra Connector 2.5 e superior + Cassandra driver 4.12 1. Para instalar Scala, siga as instruções em [https://www.scala-lang.org/download/scala2.html](https://www.scala-lang.org/download/scala2.html). 1. Para instalar o Spark 3.4.1, siga este exemplo. ``` 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 ``` ``` # Etapa 1: Configurar o Amazon Keyspaces para integração com o Apache Cassandra Spark Connector Nesta etapa, você confirma que o particionador da sua conta é compatível com o Apache Spark Connector e configura as permissões necessárias do IAM. As práticas recomendadas a seguir ajudam você a provisionar read/write capacidade suficiente para a tabela. 1. Confirme se o particionador `Murmur3Partitioner` é o particionador padrão da conta. Esse particionador é compatível com o Spark Cassandra Connector. Para obter mais informações sobre particionadores e como alterá-los, consulte [Como trabalhar com particionadores no Amazon Keyspaces](working-with-partitioners.md). 1. Configure suas permissões do IAM para o Amazon Keyspaces, usando endpoints da VPC de interface, com o Apache Spark. + Atribua read/write acesso à tabela de usuários e leia o acesso às tabelas do sistema, conforme mostrado no exemplo de política do IAM listado abaixo. + É necessário preencher a tabela system.peers com seus endpoints da VPC de interface disponíveis para clientes que acessam o Amazon Keyspaces com o Spark por meio de [endpoints da 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. Considere as seguintes práticas recomendadas para configurar capacidade de throughput de leitura/gravação suficiente para que sua tabela do Amazon Keyspaces ofereça suporte ao tráfego do Spark Cassandra Connector. + Comece a usar a capacidade sob demanda para ajudá-lo a testar o cenário. + Para otimizar o custo do throughput da tabela para ambientes de produção, use um limitador de taxa para o tráfego do conector e configure sua tabela para usar a capacidade provisionada com ajuste de escala automático. Para obter mais informações, consulte [Gerencia automaticamente a capacidade de throughput com o ajuste de escala automático do Amazon Keyspaces](autoscaling.md). + Você pode usar um limitador de taxa fixa que vem com o driver Cassandra. Há alguns [limitadores de taxa personalizados para Amazon Keyspaces](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers) no repositório de [amostras da AWS](https://github.com/aws-samples). + Para obter mais informações sobre gerenciamento de capacidade, consulte [Configurar modos de read/write capacidade no Amazon Keyspaces](ReadWriteCapacityMode.md). # Etapa 2: Configurar o Apache Cassandra Spark Connector O Apache Spark é uma plataforma de computação de uso geral que você pode configurar de diferentes maneiras. Para configurar o Spark e o Spark Cassandra Connector para integração com o Amazon Keyspaces, recomendamos que você comece com as configurações mínimas descritas na seção a seguir e depois aumente-as posteriormente, conforme apropriado para sua workload. + **Crie tamanhos de partição do Spark menores que 8 MBs.** No Spark, as *partições* representam um bloco atômico de dados que pode ser executado paralelamente. Quando você está gravando dados no Amazon Keyspaces com o Spark Cassandra Connector, quanto menor a partição do Spark, menor a quantidade de registros que a tarefa gravará. Se uma tarefa do Spark encontrar vários erros, ela falhará depois que o número designado de novas tentativas for esgotado. Para evitar a repetição de tarefas grandes e o reprocessamento de muitos dados, mantenha o tamanho da partição do Spark pequeno. + **Use um número baixo de gravações simultâneas por executor com um grande número de novas tentativas.** O Amazon Keyspaces retorna erros de capacidade insuficiente aos drivers do Cassandra como tempos limite de operação. Você não pode resolver os tempos limite causados pela capacidade insuficiente alterando a duração do tempo limite configurado porque o Spark Cassandra Connector tenta repetir as solicitações de forma transparente usando a `MultipleRetryPolicy`. Para garantir que as novas tentativas não sobrecarreguem o pool de conexões do driver, use um número baixo de gravações simultâneas por executor com um grande número de novas tentativas. O código snippet a seguir é um exemplo disso. ``` spark.cassandra.query.retry.count = 500 spark.cassandra.output.concurrent.writes = 3 ``` + **Divida o throughput total e distribua-o em várias sessões do Cassandra.** + O Cassandra Spark Connector cria uma sessão para cada executor do Spark. Pense nessa sessão como a unidade de escala para determinar o throughput necessário e o número de conexões necessárias. + Ao definir o número de núcleos por executor e o número de núcleos por tarefa, comece baixo e aumente conforme necessário. + Defina as falhas de tarefas do Spark para permitir o processamento em caso de erros transitórios. Depois de se familiarizar com as características e os requisitos de tráfego do seu aplicativo, recomendamos definir um valor limitado para `spark.task.maxFailures`. + Por exemplo, a configuração a seguir pode lidar com duas tarefas simultâneas por executor, por sessão: ``` 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 ``` + **Desative o processamento em lotes.** + Recomendamos que você desative o processamento em lotes para melhorar os padrões de acesso aleatório. O código snippet a seguir é um exemplo disso. ``` 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) ``` + **Defina `SPARK_LOCAL_DIRS` como um disco local rápido com espaço suficiente.** + Por padrão, o Spark salva os arquivos de saída do mapa e os conjuntos de dados distribuídos resilientes (RDDs) em uma pasta. `/tmp ` Dependendo da configuração do seu host Spark, isso pode resultar em erros do estilo *falta de espaço no dispositivo*. + Para definir a variável de ambiente `SPARK_LOCAL_DIRS` para um diretório chamado `/example/spark-dir`, você pode usar o comando a seguir. ``` export SPARK_LOCAL_DIRS=/example/spark-dir ``` # Etapa 3: Criar o arquivo de configuração do aplicativo Para usar o conector Spark Cassandra de código aberto com o Amazon Keyspaces, você precisa fornecer um arquivo de configuração do aplicativo que contenha as configurações necessárias para se conectar ao driver Java. DataStax Você pode usar as credenciais específicas do serviço ou o plug-in SigV4 para se conectar. Se ainda não tiver feito isso, você precisa converter o certificado digital usado para criar a conexão TLS em um arquivo TrustStore. Você pode seguir as etapas detalhadas no tutorial de conexão do driver Java, [Antes de começar](using_java_driver.md#using_java_driver.BeforeYouBegin). Anote o caminho e a senha do arquivo trustStore porque você precisará dessa informação ao criar o arquivo de configuração do aplicativo. ## Conecte-se com autenticação SigV4 Esta seção mostra um `application.conf` arquivo de exemplo que você pode usar ao se conectar com AWS credenciais e com o plug-in SigV4. Se ainda não tiver feito isso, você precisa gerar suas chaves de acesso do IAM (um ID de chave de acesso e uma chave de acesso secreta) e salvá-las em seu arquivo de AWS configuração ou como variáveis de ambiente. Para obter instruções detalhadas, consulte [Credenciais exigidas pelo AWS CLI AWS SDK ou pelo plug-in SigV4 do Amazon Keyspaces para drivers de clientes do Cassandra](SigV4_credentials.md). No exemplo a seguir, substitua o caminho do arquivo trustStore e substitua a senha. ``` 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 } ``` Atualize e salve esse arquivo de configuração como `/home/user1/application.conf`. Os exemplos a seguir usam este caminho. ## Conecte-se com credenciais específicas do serviço Esta seção mostra um arquivo `application.conf` de exemplo que você pode usar ao se conectar com credenciais específicas do serviço. Se você ainda não tiver feito isso, você precisará gerar credenciais específicas do serviço para Amazon Keyspaces. Para obter instruções detalhadas, consulte [Crie credenciais específicas do serviço para acesso programático ao Amazon Keyspaces](programmatic.credentials.ssc.md). No exemplo a seguir, substitua `username` e `password` pelas suas próprias credenciais. Além disso, substitua o caminho do arquivo trustStore e substitua a senha. ``` 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 } } } } ``` Atualize e salve esse arquivo de configuração `/home/user1/application.conf` para usar com o exemplo de código. ## Conecte-se com uma taxa fixa Para forçar uma taxa fixa por executor do Spark, você pode definir um limitador de solicitações. Esse limitador de solicitações limita a taxa de solicitações por segundo. O Spark Cassandra Connector implanta uma sessão do Cassandra por executor. Usar a fórmula a seguir pode ajudá-lo a obter um throughput consistente em relação a uma tabela. ``` max-request-per-second * numberOfExecutors = total throughput against a table ``` Você pode adicionar esse exemplo ao arquivo de configuração do aplicativo que você criou anteriormente. ``` datastax-java-driver { advanced.throttler { class = RateLimitingRequestThrottler max-requests-per-second = 3000 max-queue-size = 30000 drain-interval = 1 millisecond } } ``` # Etapa 4: Preparar os dados de origem e a tabela de destino no Amazon Keyspaces Nesta etapa, você criará um arquivo de origem com dados demonstrativos e uma tabela do Amazon Keyspaces. 1. Criar o arquivo de origem. Você pode escolher uma das seguintes opções: + Neste tutorial, você usará um arquivo de valores separados por vírgula (CSV) com o nome `keyspaces_sample_table.csv` como arquivo de origem para a migração de dados. O arquivo de amostra fornecido contém algumas linhas de dados de uma tabela com o nome `book_awards`. 1. Faça o download do arquivo CSV de amostra (`keyspaces_sample_table.csv`) que está contido no seguinte arquivo [samplemigration.zip](samples/samplemigration.zip). Descompacte o arquivo e anote o caminho até `keyspaces_sample_table.csv`. + Se você quiser acompanhar seu próprio arquivo CSV para gravar dados no Amazon Keyspaces, certifique-se de que os dados sejam randomizados. Os dados lidos diretamente de um banco de dados ou exportados para arquivos simples geralmente são ordenados pela partição e pela chave primária. A importação de dados ordenados para o Amazon Keyspaces pode fazer com que eles sejam gravados em segmentos menores de partições do Amazon Keyspaces, o que resulta em uma distribuição de tráfego desigual. Isso pode causar um desempenho mais lento e a taxas de erro mais altas. Por outro lado, a randomização de dados ajuda a aproveitar os recursos integrados de balanceamento de carga do Amazon Keyspaces ao distribuir o tráfego entre partições de forma mais uniforme. Há várias ferramentas que você pode usar para randomizar dados. Para ver um exemplo que usa a ferramenta de código aberto [Shuf](https://en.wikipedia.org/wiki/Shuf), consulte o tutorial de migração de dados [Etapa 2: Prepare os dados para upload usando DSBulk](dsbulk-upload-prepare-data.md). Veja a seguir um exemplo que mostra como embaralhar dados como um `DataFrame`. ``` import org.apache.spark.sql.functions.randval shuffledDF = dataframe.orderBy(rand()) ``` 1. Criar o espaço de chaves e a tabela de destino no Amazon Keyspaces. 1. Conecte-se ao Amazon Keyspaces usando o. `cqlsh-expansion` Para obter instruções de instalação de `cqlsh-expansion`, consulte [Usar a `cqlsh-expansion` para se conectar ao Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh). Substitua o endpoint do serviço no exemplo a seguir pelo seu próprio valor. ``` cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl ``` 1. Crie um novo espaço de chave com o nome `catalog` mostrado no exemplo a seguir. ``` CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'}; ``` 1. Depois que o novo keyspace tiver o status de disponível, use o código a seguir para criar a tabela `book_awards` de destino. Para saber mais sobre a criação assíncrona de recursos e como verificar se um recurso está disponível, consulte [Verifique o status de criação do keyspace no 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) ); ``` # Etapa 5: Gravar e ler dados do Amazon Keyspaces usando o Apache Cassandra Spark Connector Nesta etapa, você começa carregando os dados do arquivo de amostra em um `DataFrame` com o Spark Cassandra Connector. Em seguida, você grava os dados do `DataFrame` em sua tabela do Amazon Keyspaces. Você também pode usar essa parte de forma independente, por exemplo, para migrar dados para uma tabela do Amazon Keyspaces. Por fim, você lê os dados da tabela em um `DataFrame` usando o Spark Cassandra Connector. Você também pode usar essa parte de forma independente, por exemplo, para ler dados de uma tabela do Amazon Keyspaces para realizar análises de dados com o Apache Spark. 1. Inicie o Spark Shell conforme mostrado no exemplo a seguir. Observe que este exemplo usa a autenticação 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 o Spark Cassandra Connector com o código a seguir. ``` import org.apache.spark.sql.cassandra._ ``` 1. Para ler dados do arquivo CSV e armazená-los em um `DataFrame`, você pode usar o exemplo de código a seguir. ``` var df = spark.read.option("header","true").option("inferSchema","true").csv("keyspaces_sample_table.csv") ``` É possível exibir o resultado com o seguinte comando. ``` scala> df.show(); ``` A saída deve ser semelhante a esta. ``` +----------------+----+-----------+----+------------------+--------------------+-------------+ | 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| +----------------+----+-----------+----+------------------+--------------------+-------------+ ``` Você pode confirmar o esquema dos dados no `DataFrame`, conforme mostrado no exemplo a seguir. ``` scala> df.printSchema ``` A saída deve ser algo parecido com isso. ``` 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. Use o comando a seguir para gravar os dados no `DataFrame` para a tabela do Amazon Keyspaces. ``` df.write.cassandraFormat("book_awards", "catalog").mode("APPEND").save() ``` 1. Para confirmar que os dados foram salvos, você pode lê-los novamente em um quadro de dados, conforme mostrado no exemplo a seguir. ``` var newDf = spark.read.cassandraFormat("book_awards", "catalog").load() ``` Em seguida, você pode mostrar os dados que agora estão contidos no quadro de dados. ``` scala> newDf.show() ``` A saída do comando deve ser algo parecido com isso. ``` +--------------------+------------------+----------------+-----------+-------------+----+----+ | 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| +--------------------+------------------+----------------+-----------+-------------+----+----+ ``` # Solução de problemas comuns ao usar o Spark Cassandra Connector com o Amazon Keyspaces Se você estiver usando o Amazon Virtual Private Cloud e se conectar ao Amazon Keyspaces, os erros mais comuns encontrados ao usar o conector Spark são causados pelos seguintes problemas de configuração. + O usuário ou o perfil do IAM usado na VPC não tem as permissões necessárias para acessar a tabela `system.peers` no Amazon Keyspaces. Para obter mais informações, consulte [Como preencher entradas da tabela `system.peers` com informações do endpoint da VPC de interface](vpc-endpoints.md#system_peers). + O usuário ou função do IAM não tem as read/write permissões necessárias para a tabela de usuários e acesso de leitura às tabelas do sistema no Amazon Keyspaces. Para obter mais informações, consulte [Etapa 1: Configurar o Amazon Keyspaces para integração com o Apache Cassandra Spark Connector](spark-tutorial-step1.md). + A configuração do driver Java não desativa a verificação do nome do host ao criar a conexão SSL/TLS. Para obter exemplos, consulte [Etapa 2: configurar o driver](using_java_driver.md#java_tutorial.driverconfiguration). Para ver as etapas detalhadas de solução de problemas de conexão, consulte [Minha conexão de endpoint da VPC não funciona corretamente](troubleshooting.connecting.md#troubleshooting.connection.vpce). Além disso, você pode usar CloudWatch as métricas da Amazon para ajudá-lo a solucionar problemas com a configuração do seu conector Spark Cassandra no Amazon Keyspaces. Para saber mais sobre como usar o Amazon Keyspaces com CloudWatch, consulte. [Monitorando o Amazon Keyspaces com a Amazon CloudWatch](monitoring-cloudwatch.md) A seção a seguir descreve as métricas mais úteis a serem observadas ao usar o Spark Cassandra Connector. **PerConnectionRequestRateExceeded** O Amazon Keyspaces tem uma cota de 3.000 solicitações por segundo por conexão. Cada executor do Spark estabelece uma conexão com o Amazon Keyspaces. Executar várias tentativas pode esgotar sua cota de taxa de solicitação por conexão. Se você exceder essa cota, o Amazon Keyspaces emitirá uma `PerConnectionRequestRateExceeded` métrica em. CloudWatch Se você ver PerConnectionRequestRateExceeded eventos presentes junto com outros erros do sistema ou do usuário, é provável que o Spark esteja executando várias tentativas além do número alocado de solicitações por conexão. Se você vir eventos `PerConnectionRequestRateExceeded` sem outros erros, talvez seja necessário aumentar o número de conexões nas configurações do driver para permitir mais throughput, ou talvez seja necessário aumentar o número de executores em seu trabalho do Spark. **StoragePartitionThroughputCapacityExceeded** O Amazon Keyspaces tem uma cota de 1.000 WCUs ou WRUs por segundo/3.000 ou por segundo RCUs , por partição. RRUs Se você estiver vendo `StoragePartitionThroughputCapacityExceeded` CloudWatch eventos, isso pode indicar que os dados não são aleatórios durante o carregamento. Para ver exemplos de como embaralhar dados, consulte [Etapa 4: Preparar os dados de origem e a tabela de destino no Amazon Keyspaces](spark-tutorial-step4.md). ## Erros e avisos comuns Se você estiver usando a Amazon Virtual Private Cloud e se conectar ao Amazon Keyspaces, o driver do Cassandra poderá emitir uma mensagem de aviso sobre o próprio nó de controle na tabela `system.peers`. Para obter mais informações, consulte [Erros e avisos comuns](vpc-endpoints.md#vpc_troubleshooting). Você pode ignorar esse aviso com segurança.