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á.
# Conceitos básicos do Amazon Keyspaces (para Apache Cassandra)
Se você não possui experiência com Apache Cassandra e Amazon Keyspaces, este tutorial orienta você na instalação dos programas e ferramentas necessários para usar o Amazon Keyspaces com sucesso. Você aprenderá a criar um keyspace e uma tabela usando a Cassandra Query Language (CQL) Console de gerenciamento da AWS, the ou the (). AWS Command Line Interface AWS CLI Em seguida, você usa Cassandra Query Language (CQL) para executar operações de criação, leitura, atualização e exclusão (CRUD) em dados na sua tabela Amazon Keyspaces.
Este tutorial inclui as seguintes etapas.
+ **Pré-requisitos** — Antes de iniciar o tutorial, siga as instruções de AWS configuração para se cadastrar AWS e criar um usuário do IAM com acesso ao Amazon Keyspaces. Então você configura o `cqhsh-expansion` AWS CloudShell e. Como alternativa, você pode usar o AWS CLI para criar recursos no Amazon Keyspaces.
+ **Etapa 1: Crie um espaço de chave e uma tabela**. Nesta seção, você criará um espaço chave chamado “catálogo” e uma tabela chamada “book\$1awards” dentro dele. Você especificará as colunas, os tipos de dados, a chave de partição e a coluna de agrupamento da tabela usando o Console de gerenciamento da AWS, CQL ou o. AWS CLI
+ **Etapa 2: Executar operações CRUD** — Aqui, você usará o `cqlsh-expansion` in CloudShell para inserir, ler, atualizar e excluir dados na tabela “book\$1awards”. Você aprenderá a usar várias instruções CQL, como SELECT, INSERT, UPDATE e DELETE, e praticará a filtragem e a modificação de dados.
+ **Etapa 3: Limpe os recursos**. Para evitar cobranças por recursos não utilizados, esta seção explica como excluir a tabela “book\$1awards” e o keyspace “catalog” usando o console, o CQL ou a AWS CLI.
Para obter tutoriais sobre como se conectar programaticamente ao Amazon Keyspaces usando diferentes drivers de cliente do Apache Cassandra, consulte [Como usar um driver de cliente Cassandra para acessar o Amazon Keyspaces programaticamente](programmatic.drivers.md). Para exemplos de código usando diferentes AWS SDKs, consulte [Exemplos de código para uso do Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/latest/devguide/service_code_examples.html). AWS SDKs
**Topics**
+ [
# Pré-requisitos e considerações do tutorial
](getting-started.before-you-begin.md)
+ [
# Crie um keyspace no Amazon Keyspaces.
](getting-started.keyspaces.md)
+ [
# Verifique o status de criação do keyspace no Amazon Keyspaces
](keyspaces-create.md)
+ [
# Crie uma tabela no Amazon Keyspaces.
](getting-started.tables.md)
+ [
# Verifique o status de criação da tabela no Amazon Keyspaces
](tables-create.md)
+ [
# Crie, leia, atualize e exclua dados (CRUD) usando CQL no Amazon Keyspaces
](getting-started.dml.md)
+ [
# Exclua uma tabela do Amazon Keyspaces
](getting-started.clean-up.table.md)
+ [
# Excluir um keyspace no Amazon Keyspaces
](getting-started.clean-up.keyspace.md)
# Pré-requisitos e considerações do tutorial
Antes de começar a usar o Amazon Keyspaces, siga as instruções de AWS configuração em. [Como acessar o Amazon Keyspaces (para Apache Cassandra)](accessing.md) Essas etapas incluem inscrever-se AWS e criar um usuário AWS Identity and Access Management (IAM) com acesso ao Amazon Keyspaces.
Para concluir todas as etapas do tutorial, é necessário instalar o `cqlsh`. Você pode seguir as instruções de configuração em [Usar `cqlsh` para se conectar ao Amazon Keyspaces](programmatic.cqlsh.md).
Para acessar o Amazon Keyspaces usando `cqlsh` ou o AWS CLI, recomendamos usar. AWS CloudShell CloudShellé um shell pré-autenticado baseado em navegador que você pode iniciar diretamente do. Console de gerenciamento da AWS Você pode executar comandos AWS Command Line Interface (AWS CLI) no Amazon Keyspaces usando seu shell preferido (Bash PowerShell ou Z shell). Para usar `cqlsh`, você deve instalar `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). Para obter mais informações sobre, CloudShell consulte[Usando AWS CloudShell para acessar o Amazon Keyspaces](using-aws-with-cloudshell.md).
Para usar o AWS CLI para criar, visualizar e excluir recursos no Amazon Keyspaces, siga as instruções de configuração em. [Baixando e configurando o AWS CLI](access.cli.md#access.cli.installcli)
Depois de concluir as etapas de pré-requisito, vá para [Crie um keyspace no Amazon Keyspaces.](getting-started.keyspaces.md).
# Crie um keyspace no Amazon Keyspaces.
Nesta seção, você cria um keyspace usando o console, `cqlsh` ou AWS CLI.
**nota**
Antes de começar, certifique-se de que você configurou todos os [pré-requisitos do tutorial](getting-started.before-you-begin.md).
Um *espaço de chave* agrupa tabelas relacionadas que são relevantes para um ou mais aplicativos. Um espaço de chave contém uma ou mais tabelas e define a estratégia de replicação para todas as tabelas que ele contém. Para obter mais informações sobre espaços de chaves, consulte os seguintes tópicos:
+ Instruções de Data Definition Language (DDL) na referência da linguagem CQL: [Keyspaces](cql.ddl.keyspace.md)
+ [Cotas para Amazon Keyspaces (para Apache Cassandra)](quotas.md)
Neste tutorial, criamos um keyspace de região única, e a estratégia de replicação do keyspace é `SingleRegionStrategy`. Usando `SingleRegionStrategy`, o Amazon Keyspaces replica dados em três [zonas de disponibilidade](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/) em uma Região da AWS. Para saber como criar chaves de réplica de várias regiões, consulte [Criar um espaço de chaves multirregional no Amazon Keyspaces](keyspaces-mrr-create.md).
## Utilizar o console
**Para criar um espaço de chave usando o console**
1. [Faça login no Console de gerenciamento da AWS e abra o console do Amazon Keyspaces em casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. No painel de navegação, escolha **Keyspaces**.
1. Selecione **Criar espaço de chaves**.
1. Na caixa **Nome do keyspace**, insira **catalog** como o nome do espaço de chaves.
**Restrições de nome:**
+ Nome não pode estar vazio.
+ Caracteres permitidos: caracteres alfanuméricos e sublinhado ( `_` ).
+ O tamanho máximo é de 48 caracteres.
1. Em **Regiões da AWS**, confirme se a **Replicação em região única** é a estratégia de replicação para o espaço de chave.
1. Para criar o espaço de chaves, escolha **Criar espaço de chaves**.
1. Verifique se o espaço de chave `catalog` foi criado fazendo o seguinte:
1. No painel de navegação, escolha **Keyspaces**.
1. Localize seu espaço de chave `catalog` na lista de espaços de chave.
## Usar SSL
O procedimento a seguir cria um espaço de chave usando CQL.
**Para criar um espaço de chave usando CQL**
1. Abra AWS CloudShell e conecte-se ao Amazon Keyspaces usando o comando a seguir. Certifique-se de atualizar *us-east-1* com sua própria região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
A saída do comando deve ser algo parecido com isso.
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
```
1. Crie seu espaço de chave usando o seguinte comando CQL.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
`SingleRegionStrategy`usa um fator de replicação de três e replica dados em três zonas de AWS disponibilidade em sua região.
**nota**
O Amazon Keyspaces usa como padrão todas as entradas em minúsculas, a menos que você as coloque entre aspas.
1. Verifique se seu espaço de chave foi criado.
```
SELECT * from system_schema.keyspaces;
```
A saída deste comando deve ser semelhante a esta.
```
cqlsh> SELECT * from system_schema.keyspaces;
keyspace_name | durable_writes | replication
-------------------------+----------------+-------------------------------------------------------------------------------------
system_schema | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_schema_mcs | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_multiregion_info | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
catalog | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
(5 rows)
```
## Usando o AWS CLI
O procedimento a seguir cria um espaço de chave usando AWS CLI.
**Para criar um espaço de teclas usando o AWS CLI**
1. Para confirmar se seu ambiente está configurado, você pode executar o seguinte comando em CloudShell.
```
aws keyspaces help
```
1. Crie seu keyspace usando a seguinte AWS CLI declaração.
```
aws keyspaces create-keyspace --keyspace-name 'catalog'
```
1. Verifique se o seu keyspace foi criado com a seguinte declaração AWS CLI
```
aws keyspaces get-keyspace --keyspace-name 'catalog'
```
A saída deste comando deve ser semelhante a este exemplo.
```
{
"keyspaceName": "catalog",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/",
"replicationStrategy": "SINGLE_REGION"
}
```
# Verifique o status de criação do keyspace no Amazon Keyspaces
O Amazon Keyspaces executa operações de linguagem de definição de dados (DDL), como criar e excluir espaços de chaves de forma assíncrona.
Você pode monitorar o status de criação de novos espaços de chave no Console de gerenciamento da AWS, que indica quando um espaço de tecla está pendente ou ativo. Você também pode monitorar o status de criação de um novo espaço de chaves programaticamente usando o espaço de chaves `system_schema_mcs`. Um espaço de chaves fica visível na tabela `system_schema_mcs` `keyspaces` quando está pronto para uso.
O padrão de design recomendado para verificar quando um novo espaço de chaves está pronto para uso é pesquisar as tabelas `system_schema_mcs` `keyspaces` do Amazon Keyspaces (system\$1schema\$1mcs.\$1). Para obter uma lista de instruções DDL para espaços de chaves, consulte a seção [Keyspaces](cql.ddl.keyspace.md) na referência da linguagem CQL.
A consulta a seguir mostra se um espaço de chaves foi criado com sucesso.
```
SELECT * FROM system_schema_mcs.keyspaces WHERE keyspace_name = 'mykeyspace';
```
Para um espaço de chaves que foi criado com sucesso, a saída da consulta é semelhante à seguinte.
```
keyspace_name | durable_writes | replication
--------------+-----------------+--------------
mykeyspace | true |{...} 1 item
```
# Crie uma tabela no Amazon Keyspaces.
Nesta etapa, você cria uma tabela usando o console, `cqlsh` ou AWS CLI.
Uma tabela é onde seus dados são organizados e armazenados. A chave primária da tabela determina como os dados serão particionados na tabela. A chave primária é composta por uma chave de partição necessária e uma ou mais colunas de agrupamento opcionais. Os valores combinados que compõem a chave primária devem ser exclusivos em todos os dados da tabela. Para obter mais informações sobre tabelas, consulte os tópicos a seguir:
+ Design de chave de partição: [Como usar chaves de partição de forma eficaz no Amazon Keyspaces](bp-partition-key-design.md)
+ Trabalhar com tabelas: [Verifique o status de criação da tabela no Amazon Keyspaces](tables-create.md)
+ Instruções DDL na referência da linguagem CQL: [Tabelas](cql.ddl.table.md)
+ Gerenciamento de recursos da tabela: [Como gerenciar os recursos de tecnologia sem servidor no Amazon Keyspaces (para Apache Cassandra)](serverless_resource_management.md)
+ Monitoramento da utilização dos recursos da tabela: [Monitorando o Amazon Keyspaces com a Amazon CloudWatch](monitoring-cloudwatch.md)
+ [Cotas para Amazon Keyspaces (para Apache Cassandra)](quotas.md)
Ao criar uma tabela, especifique o seguinte:
+ O nome da tabela.
+ O nome e o tipo de dados de cada coluna em uma tabela.
+ A chave primária da tabela.
+ **Chave de partição**: obrigatória
+ **Colunas de clustering**: opcional
Use o procedimento a seguir para criar uma tabela com as colunas, os tipos de dados, as chaves de partição e as colunas de clustering especificados.
## Utilizar o console
O procedimento a seguir cria a tabela `book_awards` com essas colunas e tipos de dados.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Para criar uma tabela usando o console**
1. [Faça login no Console de gerenciamento da AWS e abra o console do Amazon Keyspaces em casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. No painel de navegação, escolha **Keyspaces**.
1. Escolha `catalog` como o espaço de chave em que você deseja criar essa tabela.
1. Escolha **Criar tabela**.
1. Na caixa **Nome da tabela**, insira **book\$1awards** como nome da tabela.
**Restrições de nome:**
+ Nome não pode estar vazio.
+ Caracteres permitidos: caracteres alfanuméricos e sublinhado ( `_` ).
+ O tamanho máximo é de 48 caracteres.
1. Na seção **Colunas**, repita as etapas a seguir para cada coluna que você deseja adicionar a essa tabela.
Adicione as colunas e os tipos de dados a seguir.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
1. **Nome**: insira o nome da coluna.
**Restrições de nome:**
+ Nome não pode estar vazio.
+ Caracteres permitidos: caracteres alfanuméricos e sublinhado ( `_` ).
+ O tamanho máximo é de 48 caracteres.
1. **Tipo**: na lista de tipos de dados, escolha o tipo de dados para essa coluna.
1. Para adicionar outra coluna, selecione **Add column**.
1. Escolha `award` e `year` como chaves de partição em **Chave de partição**. É necessária uma chave de partição para cada tabela. A chave de partição pode ser composta por uma ou mais colunas.
1. Adicione `category` e `rank` como **Colunas de clustering**. As colunas de clustering são opcionais e determinam a ordem de classificação em cada partição.
1. Para adicionar uma coluna de clustering, escolha **Adicionar coluna de clustering**.
1. Na lista de **Colunas**, escolha a **categoria**. Na lista **Ordem**, escolha **ASC** para classificar em ordem crescente nos valores dessa coluna. (Escolha **DESC** para ordem decrescente.)
1. Então, selecione **Adicionar coluna de clustering** e escolha **classificação**.
1. Na seção **Configurações da tabela**, escolha **Configurações padrão**.
1. Escolha **Criar tabela**.
1. Verifique se sua tabela foi criada.
1. No painel de navegação, selecione **Tabelas**.
1. Confirme se sua tabela está na lista de tabelas.
1. Escolha o nome da sua tabela.
1. Confirme se todas as suas colunas e tipos de dados estão corretos.
**nota**
As colunas podem não estar listadas na mesma ordem em que você as adicionou à tabela.
## Usar SSL
Este procedimento cria uma tabela com as seguintes colunas e tipos de dados usando CQL. As colunas `year` e `award` são chaves de partição com `category` e `rank` como colunas de clustering. Juntas, elas formam a chave primária da tabela.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Para criar uma tabela usando CQL**
1. Abra AWS CloudShell e conecte-se ao Amazon Keyspaces usando o comando a seguir. Certifique-se de atualizar *us-east-1* com sua própria região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
A saída do comando deve ser algo parecido com isso.
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
```
1. No prompt do espaço de chave (`cqlsh:keyspace_name>`), crie sua tabela inserindo o código a seguir na janela de comando.
```
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)
);
```
**nota**
`ASC` é a ordem de clustering padrão. Você também pode especificar `DESC` para ordem decrescente.
Observe que `year` e `award` são colunas de chave de partição. Em seguida, `category` e `rank` são as colunas de clustering ordenadas em ordem crescente (`ASC`). Juntas, essas colunas formam a chave primária da tabela.
1. Verifique se sua tabela foi criada.
```
SELECT * from system_schema.tables WHERE keyspace_name='catalog.book_awards' ;
```
A saída deve ser semelhante a esta.
```
keyspace_name | table_name | bloom_filter_fp_chance | caching | cdc | comment | compaction | compression | crc_check_chance | dclocal_read_repair_chance | default_time_to_live | extensions | flags | gc_grace_seconds | id | max_index_interval | memtable_flush_period_in_ms | min_index_interval | read_repair_chance | speculative_retry
---------------+------------+------------------------+---------+-----+---------+------------+-------------+------------------+----------------------------+----------------------+------------+-------+------------------+----+--------------------+-----------------------------+--------------------+--------------------+-------------------
(0 rows)
```
1. Verifique a estrutura da sua tabela.
```
SELECT * FROM system_schema.columns WHERE keyspace_name = 'catalog' AND table_name = 'book_awards';
```
A saída desta instrução deve ser semelhante a este exemplo.
```
keyspace_name | table_name | column_name | clustering_order | column_name_bytes | kind | position | type
---------------+-------------+-------------+------------------+------------------------+---------------+----------+------
catalog | book_awards | year | none | 0x79656172 | partition_key | 0 | int
catalog | book_awards | award | none | 0x6177617264 | partition_key | 1 | text
catalog | book_awards | category | asc | 0x63617465676f7279 | clustering | 0 | text
catalog | book_awards | rank | asc | 0x72616e6b | clustering | 1 | int
catalog | book_awards | author | none | 0x617574686f72 | regular | -1 | text
catalog | book_awards | book_title | none | 0x626f6f6b5f7469746c65 | regular | -1 | text
catalog | book_awards | publisher | none | 0x7075626c6973686572 | regular | -1 | text
(7 rows)
```
Confirme se todas as colunas e tipos de dados estão conforme o esperado. A ordem das colunas pode ser diferente da instrução `CREATE`.
## Usando o AWS CLI
Este procedimento cria uma tabela com as seguintes colunas e tipos de dados usando AWS CLI. As colunas `year` e `award` formam a chave de partição com `category` e `rank` como colunas de clustering.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Para criar uma tabela usando o AWS CLI**
O comando a seguir cria uma tabela com o nome *book\$1awards*. A chave de partição da tabela consiste nas colunas `year` e `award` e a chave de agrupamento consiste nas colunas `category` de `rank`. As duas colunas de agrupamento usam a ordem de classificação crescente. (Para facilitar a leitura, o `schema-definition` do comando de criação de tabela nesta seção é dividido em linhas separadas.)
1. Você pode criar uma tabela usando a instrução a seguir.
```
aws keyspaces create-table --keyspace-name 'catalog' \
--table-name 'book_awards' \
--schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},
{name=category,type=text}, {name=author,type=text},{name=book_title,type=text},{name=publisher,type=text}],
partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]'
```
Este comando resulta na seguinte saída.
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards"
}
```
1. Para confirmar os metadados e as propriedades da tabela, você pode usar o seguinte comando:
```
aws keyspaces get-table --keyspace-name 'catalog' --table-name 'book_awards'
```
Este comando retorna a seguinte saída.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards",
"creationTimestamp": "2024-07-11T15:12:55.571000+00:00",
"status": "ACTIVE",
"schemaDefinition": {
"allColumns": [
{
"name": "year",
"type": "int"
},
{
"name": "award",
"type": "text"
},
{
"name": "category",
"type": "text"
},
{
"name": "rank",
"type": "int"
},
{
"name": "author",
"type": "text"
},
{
"name": "book_title",
"type": "text"
},
{
"name": "publisher",
"type": "text"
}
],
"partitionKeys": [
{
"name": "year"
},
{
"name": "award"
}
],
"clusteringKeys": [
{
"name": "category",
"orderBy": "ASC"
},
{
"name": "rank",
"orderBy": "ASC"
}
],
"staticColumns": []
},
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2024-07-11T15:12:55.571000+00:00"
},
"encryptionSpecification": {
"type": "AWS_OWNED_KMS_KEY"
},
"pointInTimeRecovery": {
"status": "DISABLED"
},
"defaultTimeToLive": 0,
"comment": {
"message": ""
},
"replicaSpecifications": []
}
```
Para realizar operações CRUD (criar, ler, atualizar e excluir) nos dados da tabela, vá para [Crie, leia, atualize e exclua dados (CRUD) usando CQL no Amazon Keyspaces](getting-started.dml.md).
# Verifique o status de criação da tabela no Amazon Keyspaces
O Amazon Keyspaces executa operações de linguagem de definição de dados (DDL), como criar e excluir tabelas de forma assíncrona. Você pode monitorar o status de criação de novas tabelas no Console de gerenciamento da AWS, que indica quando uma tabela está pendente ou ativa. Você também pode monitorar programaticamente o status de criação de uma nova tabela usando a tabela de esquema do sistema.
Uma tabela é exibida como ativa no esquema do sistema quando está pronta para uso. O padrão de design recomendado para verificar quando uma nova tabela está pronta para uso é pesquisar as tabelas de esquema do sistema do Amazon Keyspaces (`system_schema_mcs.*`). Para obter uma lista de instruções DDL para tabelas, consulte a seção [Tabelas](cql.ddl.table.md) na referência da linguagem CQL.
A consulta a seguir mostra o status de uma tabela.
```
SELECT keyspace_name, table_name, status FROM system_schema_mcs.tables WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
Para uma tabela que ainda está sendo criada e está pendente, a saída da consulta é semelhante a esta.
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | CREATING
```
Para uma tabela que foi criada com sucesso e está ativa, a saída da consulta é semelhante à seguinte.
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | ACTIVE
```
# Crie, leia, atualize e exclua dados (CRUD) usando CQL no Amazon Keyspaces
Nesta etapa do tutorial, você aprenderá a inserir, ler, atualizar e excluir dados em uma tabela do Amazon Keyspaces usando instruções da linguagem de manipulação de dados (DML) CQL. No Amazon Keyspaces, você só pode criar declarações DML na linguagem CQL. Neste tutorial, você praticará a execução de instruções DML usando `cqlsh-expansion` com [AWS CloudShell](using-aws-with-cloudshell.md) em Console de gerenciamento da AWS.
+ **Inserção de dados**: esta seção aborda a inserção de registros únicos e múltiplos em uma tabela usando a instrução de `INSERT`. Você aprenderá a fazer upload de dados de um arquivo CSV e verificar inserções bem-sucedidas usando consultas de `SELECT`.
+ **Leitura de dados**: aqui, você explorará diferentes variações da instrução de `SELECT` para recuperar dados de uma tabela. Os tópicos incluem selecionar todos os dados, selecionar colunas específicas, filtrar linhas com base nas condições usando a cláusula de `WHERE` e entender condições simples e compostas.
+ **Atualização de dados**: nesta seção, você aprenderá a modificar os dados existentes em uma tabela usando a instrução de `UPDATE`. Você praticará a atualização de uma e várias colunas e, ao mesmo tempo, entenderá as restrições relacionadas à atualização de colunas de chave primária.
+ **Exclusão de dados**: a seção final aborda a exclusão de dados de uma tabela usando a instrução de `DELETE`. Você aprenderá como excluir células específicas, linhas inteiras e as implicações da exclusão de dados versus a exclusão de toda a tabela ou do espaço chave.
Ao longo do tutorial, você encontrará exemplos, dicas e oportunidades para praticar a criação de suas próprias consultas CQL para vários cenários.
**Topics**
+ [
# Inserção e carregamento de dados em uma tabela do Amazon Keyspaces
](getting-started.dml.create.md)
+ [
# Leia dados de uma tabela usando a instrução `SELECT` em CQL no Amazon Keyspaces
](getting-started.dml.read.md)
+ [
# Atualize dados em uma tabela do Amazon Keyspaces usando CQL
](getting-started.dml.update.md)
+ [
# Excluir dados de uma tabela usando a instrução `DELETE` em CQL
](getting-started.dml.delete.md)
# Inserção e carregamento de dados em uma tabela do Amazon Keyspaces
Para criar dados em sua tabela `book_awards`, use a instrução `INSERT` para adicionar uma única linha.
1. Abra AWS CloudShell e conecte-se ao Amazon Keyspaces usando o comando a seguir. Certifique-se de atualizar *us-east-1* com sua própria região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
A saída do comando deve ser algo parecido com isso.
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
```
1. Antes de poder gravar dados em sua tabela do Amazon Keyspaces usando cqlsh, você deve definir a consistência de gravação da sessão atual de cqlsh como `LOCAL_QUORUM`. Para obter mais informações sobre os níveis de consistência compatíveis, consulte [Níveis de consistência de gravação](consistency.md#WriteConsistency). Observe que essa etapa não é necessária se você estiver usando o editor CQL no Console de gerenciamento da AWS.
```
CONSISTENCY LOCAL_QUORUM;
```
1. Para inserir um único registro, execute o comando a seguir no editor CQL.
```
INSERT INTO catalog.book_awards (award, year, category, rank, author, book_title, publisher)
VALUES ('Wolf', 2023, 'Fiction',3,'Shirley Rodriguez','Mountain', 'AnyPublisher') ;
```
1. Verifique se os dados foram adicionados corretamente à tabela executando o comando a seguir.
```
SELECT * FROM catalog.book_awards;
```
A saída da instrução deve ter a aparência a seguir.
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+-------------------+------------+--------------
2023 | Wolf | Fiction | 3 | Shirley Rodriguez | Mountain | AnyPublisher
(1 rows)
```
**Para inserir vários registros de um arquivo usando cqlsh**
1. Baixe o arquivo CSV de amostra (`keyspaces_sample_table.csv`) contido no arquivo [samplemigration.zip](samples/samplemigration.zip). Descompacte o arquivo e anote o caminho até `keyspaces_sample_table.csv`.
![\[Captura de tela de um arquivo CSV mostrando a saída da tabela após a importação do arquivo csv.\]](http://docs.aws.amazon.com/pt_br/keyspaces/latest/devguide/images/keyspaces-awards.png)
1. Abra AWS CloudShell Console de gerenciamento da AWS e conecte-se ao Amazon Keyspaces usando o comando a seguir. Certifique-se de atualizar *us-east-1* com sua própria região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. No prompt de `cqlsh` (`cqlsh>`), especifique um espaço de chave.
```
USE catalog ;
```
1. Defina a consistência de gravação como `LOCAL_QUORUM`. Para obter mais informações sobre os níveis de consistência compatíveis, consulte [Níveis de consistência de gravação](consistency.md#WriteConsistency).
```
CONSISTENCY LOCAL_QUORUM;
```
1. Em **Ações**, no canto superior direito da tela, escolha **Carregar arquivo** para carregar o arquivo csv baixado anteriormente. AWS CloudShell Anote o caminho para o arquivo.
1. No prompt do espaço de chave (`cqlsh:catalog>`), execute a instrução a seguir.
```
COPY book_awards (award, year, category, rank, author, book_title, publisher) FROM '/home/cloudshell-user/keyspaces_sample_table.csv' WITH header=TRUE ;
```
A saída da instrução deve ser semelhante a esta.
```
cqlsh:catalog> COPY book_awards (award, year, category, rank, author, book_title, publisher) FROM '/home/cloudshell-user/keyspaces_sample_table.csv' WITH delimiter=',' AND header=TRUE ;
cqlsh current consistency level is LOCAL_QUORUM.
Reading options from /home/cloudshell-user/.cassandra/cqlshrc:[copy]: {'numprocesses': '16', 'maxattempts': '1000'}
Reading options from /home/cloudshell-user/.cassandra/cqlshrc:[copy-from]: {'ingestrate': '1500', 'maxparseerrors': '1000', 'maxinserterrors': '-1', 'maxbatchsize': '10', 'minbatchsize': '1', 'chunksize': '30'}
Reading options from the command line: {'delimiter': ',', 'header': 'TRUE'}
Using 16 child processes
Starting copy of catalog.book_awards with columns [award, year, category, rank, author, book_title, publisher].
OSError: handle is closed 0 rows/s; Avg. rate: 0 rows/s
Processed: 9 rows; Rate: 0 rows/s; Avg. rate: 0 rows/s
9 rows imported from 1 files in 0 day, 0 hour, 0 minute, and 26.706 seconds (0 skipped).
```
1. Verifique se os dados foram adicionados corretamente à tabela executando a consulta a seguir.
```
SELECT * FROM book_awards ;
```
Você verá a saída a seguir.
```
year | award | category | rank | author | book_title | publisher
------+------------------+-------------+------+--------------------+-----------------------+---------------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | Example Books
2020 | Wolf | Non-Fiction | 2 | Ana Carolina Silva | Science Today | SomePublisher
2020 | Wolf | Non-Fiction | 3 | Shirley Rodriguez | The Future of Sea Ice | AnyPublisher
2020 | Kwesi Manu Prize | Fiction | 1 | Akua Mansa | Where did you go? | SomePublisher
2020 | Kwesi Manu Prize | Fiction | 2 | John Stiles | Yesterday | Example Books
2020 | Kwesi Manu Prize | Fiction | 3 | Nikki Wolf | Moving to the Chateau | AnyPublisher
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | Long Summer | SomePublisher
2020 | Richard Roe | Fiction | 2 | Arnav Desai | The Key | Example Books
2020 | Richard Roe | Fiction | 3 | Mateo Jackson | Inside the Whale | AnyPublisher
(9 rows)
```
Para saber mais sobre como usar `cqlsh COPY` para fazer upload de dados de arquivos csv para uma tabela do Amazon Keyspaces, consulte. [Tutorial: Como carregar dados no Amazon Keyspaces usando cqlsh](bulk-upload.md)
# Leia dados de uma tabela usando a instrução `SELECT` em CQL no Amazon Keyspaces
Na seção [Inserção e carregamento de dados em uma tabela do Amazon Keyspaces](getting-started.dml.create.md), você usou a instrução `SELECT` para verificar se os dados foram adicionados com sucesso à sua tabela. Nesta seção, você refina o uso de `SELECT` para exibir colunas específicas e somente linhas que atendam a critérios específicos.
A forma geral da instrução `SELECT` é a seguinte.
```
SELECT column_list FROM table_name [WHERE condition [ALLOW FILTERING]] ;
```
**Topics**
+ [
## Selecione todos os dados da tabela
](#getting-started.dml.read.all)
+ [
## Selecione um subconjunto de colunas
](#getting-started.dml.read.columns)
+ [
## Selecione um subconjunto de linhas
](#getting-started.dml.read.rows)
## Selecione todos os dados da tabela
A forma mais simples da instrução `SELECT` retorna todos os dados da tabela.
**Importante**
Em um ambiente de produção, normalmente não é uma prática recomendada executar esse comando, que retorna todos os dados da tabela.
**Para selecionar todos os dados da tabela**
1. Abra AWS CloudShell e conecte-se ao Amazon Keyspaces usando o comando a seguir. Certifique-se de atualizar *us-east-1* com sua própria região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Execute a seguinte consulta .
```
SELECT * FROM catalog.book_awards ;
```
Usar o caractere curinga (`*`) para o `column_list` selecionar todas as colunas. A saída da instrução deve ser semelhante ao seguinte exemplo.
```
year | award | category | rank | author | book_title | publisher
------+------------------+-------------+------+--------------------+-----------------------+---------------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | AnyPublisher
2020 | Wolf | Non-Fiction | 2 | Ana Carolina Silva | Science Today | SomePublisher
2020 | Wolf | Non-Fiction | 3 | Shirley Rodriguez | The Future of Sea Ice | AnyPublisher
2020 | Kwesi Manu Prize | Fiction | 1 | Akua Mansa | Where did you go? | SomePublisher
2020 | Kwesi Manu Prize | Fiction | 2 | John Stiles | Yesterday | Example Books
2020 | Kwesi Manu Prize | Fiction | 3 | Nikki Wolf | Moving to the Chateau | AnyPublisher
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | Long Summer | SomePublisher
2020 | Richard Roe | Fiction | 2 | Arnav Desai | The Key | Example Books
2020 | Richard Roe | Fiction | 3 | Mateo Jackson | Inside the Whale | AnyPublisher
```
## Selecione um subconjunto de colunas
**Para consultar um subconjunto de colunas**
1. Abra AWS CloudShell e conecte-se ao Amazon Keyspaces usando o comando a seguir. Certifique-se de atualizar *us-east-1* com sua própria região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Para recuperar apenas as colunas `award`, `category` e `year`, execute a seguinte consulta.
```
SELECT award, category, year FROM catalog.book_awards ;
```
A saída contém somente as colunas especificadas na ordem listada na instrução `SELECT`.
```
award | category | year
------------------+-------------+------
Wolf | Non-Fiction | 2020
Wolf | Non-Fiction | 2020
Wolf | Non-Fiction | 2020
Kwesi Manu Prize | Fiction | 2020
Kwesi Manu Prize | Fiction | 2020
Kwesi Manu Prize | Fiction | 2020
Richard Roe | Fiction | 2020
Richard Roe | Fiction | 2020
Richard Roe | Fiction | 2020
```
## Selecione um subconjunto de linhas
Ao consultar um grande conjunto de dados, escolha apenas registros que atendam a determinados critérios. Para fazer isso, você pode acrescentar uma cláusula `WHERE` ao final da instrução `SELECT`.
**Para consultar um subconjunto de linhas**
1. Abra AWS CloudShell e conecte-se ao Amazon Keyspaces usando o comando a seguir. Certifique-se de atualizar *us-east-1* com sua própria região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Para recuperar somente os registros dos prêmios de um determinado ano, execute a consulta a seguir.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Wolf' ;
```
A instrução `SELECT` anterior retorna o seguinte resultado.
```
year | award | category | rank | author | book_title | publisher
------+-------+-------------+------+--------------------+-----------------------+---------------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | AnyPublisher
2020 | Wolf | Non-Fiction | 2 | Ana Carolina Silva | Science Today | SomePublisher
2020 | Wolf | Non-Fiction | 3 | Shirley Rodriguez | The Future of Sea Ice | AnyPublisher
```
### Entendendo a cláusula `WHERE`
A cláusula `WHERE` é usada para filtrar os dados e retornar somente os dados que atendem aos critérios especificados. Os critérios especificados podem ser uma condição simples ou uma condição composta.
**Como usar as condições em uma cláusula `WHERE`**
+ Uma condição simples, uma única coluna.
```
WHERE column_name=value
```
Você poderá usar uma condição simples em uma cláusula `WHERE` se uma das seguintes condições for atendida:
+ A coluna é a única coluna de chave de partição da tabela.
+ Você adiciona `ALLOW FILTERING` após a condição na cláusula `WHERE`.
Esteja ciente de que usar `ALLOW FILTERING` pode resultar em desempenho inconsistente, especialmente em tabelas grandes e multiparticionadas.
+ Uma condição composta, várias condições simples conectadas por `AND`.
```
WHERE column_name1=value1 AND column_name2=value2 AND column_name3=value3...
```
É possível usar condições compostas em uma cláusula `WHERE` se uma das condições a seguir for atendida:
+ As colunas que você pode usar na cláusula de `WHERE` precisam incluir todas ou um subconjunto das colunas na chave de partição da tabela. Se quiser usar somente um subconjunto das colunas na cláusula de`WHERE`, você deve incluir um conjunto contíguo de colunas de chave de partição da esquerda para a direita, começando com a coluna principal da chave de partição. Por exemplo, se as colunas da chave de partição forem `year`, `month` e `award`, você poderá usar as seguintes colunas na cláusula de`WHERE`:
+ `year`
+ `year` E `month`
+ `year` E `month` E `award`
+ Você adiciona `ALLOW FILTERING` após a condição composta na cláusula `WHERE`, como no exemplo a seguir.
```
SELECT * FROM my_table WHERE col1=5 AND col2='Bob' ALLOW FILTERING ;
```
Esteja ciente de que usar `ALLOW FILTERING` pode resultar em desempenho inconsistente, especialmente em tabelas grandes e multiparticionadas.
### Experimente
Crie suas próprias consultas em CQL para encontrar o seguinte em sua tabela `book_awards`:
+ Encontre os vencedores dos prêmios Wolf 2020 e exiba os títulos e autores dos livros, ordenados por classificação.
+ Mostre os vencedores do primeiro prêmio de todos os prêmios em 2020 e exiba os títulos dos livros e os nomes dos prêmios.
# Atualize dados em uma tabela do Amazon Keyspaces usando CQL
Para atualizar os dados em sua tabela `book_awards`, use a instrução `UPDATE`.
A forma geral da instrução `UPDATE` é a seguinte.
```
UPDATE table_name SET column_name=new_value WHERE primary_key=value ;
```
**dica**
É possível atualizar várias colunas usando uma lista separada por vírgula de `column_names` e valores, como no seguinte exemplo.
```
UPDATE my_table SET col1='new_value_1', col2='new_value2' WHERE col3='1' ;
```
Se a chave primária for composta por várias colunas, todas as colunas da chave primária e seus valores deverão ser incluídos na cláusula `WHERE`.
Você não pode atualizar nenhuma coluna na chave primária porque isso alteraria a chave primária do registro.
**Para atualizar uma única célula**
Usando sua tabela de `book_awards`, altere o nome de uma editora para vencedora do prêmio Wolf de não ficção em 2020.
```
UPDATE book_awards SET publisher='new Books' WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
Verifique se a editora está agora `new Books`.
```
SELECT * FROM book_awards WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
A instrução deve retornar a seguinte saída.
```
year | award | category | rank | author | book_title | publisher
------+-------+-------------+------+-------------+------------------+-----------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | new Books
```
## Experimente
**Avançado:** O vencedor do “Prêmio Kwezi Manu” de ficção de 2020 mudou de nome. Atualize esse registro para alterar o nome para `'Akua Mansa-House'`.
# Excluir dados de uma tabela usando a instrução `DELETE` em CQL
Para excluir dados na tabela `book_awards`, use a instrução `DELETE`.
Você pode excluir dados de uma linha ou de uma partição. Tenha cuidado ao excluir dados, pois as exclusões são irreversíveis.
Excluir uma ou todas as linhas de uma tabela não exclui a tabela. Assim, você pode preenchê-la novamente com dados. A exclusão de uma tabela exclui a tabela e todos os dados nela contidos. Para usar a tabela novamente, você deverá recriá-la e adicionar dados a ela. A exclusão de um espaço de chave exclui o espaço de chave e todas as tabelas dentro dele. Para usar o espaço de chave e as tabelas, você deve recriá-los e, em seguida, preenchê-los com dados. Você pode usar a recuperação do Amazon Keyspaces Point-in-time (PITR) para ajudar a restaurar tabelas excluídas. Para saber mais, consulte. [Faça backup e restaure dados com point-in-time recuperação para Amazon Keyspaces](PointInTimeRecovery.md) Para saber como restaurar uma tabela excluída com o PITR ativado, consulte [Restaurar uma tabela excluída usando a PITR do Amazon Keyspaces](restoredeleted.md).
## Exclua as células
A exclusão de uma coluna de uma linha remove os dados da célula especificada. Quando você exibe essa coluna usando uma `SELECT` instrução, os dados são exibidos como*null*, embora um valor nulo não esteja armazenado nesse local.
A sintaxe geral para excluir uma ou mais colunas específicas é a seguinte.
```
DELETE column_name1[, column_name2...] FROM table_name WHERE condition ;
```
Na sua tabela de `book_awards`, você pode ver que o título do livro que ganhou o primeiro preço do prêmio “Richard Roe” de 2020 é “Long Summer”. Imagine que esse título tenha sido recuperado e você precise excluir os dados dessa célula.
**Como excluir uma célula específica**
1. Abra AWS CloudShell e conecte-se ao Amazon Keyspaces usando o comando a seguir. Certifique-se de atualizar *us-east-1* com sua própria região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Execute a seguinte consulta `DELETE`.
```
DELETE book_title FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. Verifique se a solicitação de exclusão foi feita conforme o esperado.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
A saída desta instrução tem a aparência a seguir.
```
year | award | category | rank | author | book_title | publisher
------+-------------+----------+------+-------------------+------------+---------------
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | null | SomePublisher
```
## Excluir linhas
Pode haver um momento em que você precise excluir uma linha inteira, por exemplo, para atender a uma solicitação de exclusão de dados. A sintaxe geral para excluir uma linha é a seguinte.
```
DELETE FROM table_name WHERE condition ;
```
**Para excluir uma linha**
1. Abra AWS CloudShell e conecte-se ao Amazon Keyspaces usando o comando a seguir. Certifique-se de atualizar *us-east-1* com sua própria região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Execute a seguinte consulta `DELETE`.
```
DELETE FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. Verifique se a exclusão foi feita conforme o esperado.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
A saída dessa instrução fica assim depois que a linha foi excluída.
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+--------+------------+-----------
(0 rows)
```
Você pode excluir dados expirados automaticamente da sua tabela usando o Amazon Keyspaces Time to Live. Para obter mais informações, consulte [Dados expirados com vida útil (TTL) para Amazon Keyspaces (para Apache Cassandra)](TTL.md).
# Exclua uma tabela do Amazon Keyspaces
Para evitar a cobrança por tabelas e dados desnecessários, exclua todas as tabelas que não estiver usando. Quando você exclui uma tabela, a tabela e seus dados são excluídos e você deixa de acumular cobranças por eles. No entanto, o espaço chave permanece. Quando você exclui um espaço de chave, o espaço de chave e todas as suas tabelas são excluídos e você deixa de acumular cobranças por eles.
É possível excluir uma tabela usando o console, o CQL ou AWS CLI. Quando você exclui uma tabela, a tabela e todos os seus dados são excluídos.
## Como usar o console
O procedimento a seguir exclui uma tabela e todos os seus dados que usam o Console de gerenciamento da AWS.
**Para excluir uma tabela usando o console**
1. [Faça login no Console de gerenciamento da AWS e abra o console do Amazon Keyspaces em casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. No painel de navegação, selecione **Tabelas**.
1. Escolha a caixa à esquerda do nome de cada tabela que deseja excluir.
1. Escolha **Excluir**.
1. Na tela **Excluir tabela**, insira **Delete** na caixa. Em seguida, escolha **Excluir tabela**.
1. Para verificar se a tabela foi excluída, escolha **Tabelas** no painel de navegação e confirme se a tabela `book_awards` não está mais listada.
## Usar SSL
O procedimento a seguir exclui uma tabela e todos os seus dados usando CQL.
**Para excluir uma tabela usando CQL**
1. Abra AWS CloudShell e conecte-se ao Amazon Keyspaces usando o comando a seguir. Certifique-se de atualizar *us-east-1* com sua própria região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Exclua sua tabela inserindo a seguinte declaração.
```
DROP TABLE IF EXISTS catalog.book_awards ;
```
1. Verifique se sua tabela foi excluída.
```
SELECT * FROM system_schema.tables WHERE keyspace_name = 'catalog' ;
```
A saída deve ser algo parecido com isso. Observe que isso pode levar algum tempo, portanto, execute novamente a instrução após um minuto, caso não veja esse resultado.
```
keyspace_name | table_name | bloom_filter_fp_chance | caching | cdc | comment | compaction | compression | crc_check_chance | dclocal_read_repair_chance | default_time_to_live | extensions | flags | gc_grace_seconds | id | max_index_interval | memtable_flush_period_in_ms | min_index_interval | read_repair_chance | speculative_retry
---------------+------------+------------------------+---------+-----+---------+------------+-------------+------------------+----------------------------+----------------------+------------+-------+------------------+----+--------------------+-----------------------------+--------------------+--------------------+-------------------
(0 rows)
```
## Usando o AWS CLI
O procedimento a seguir exclui uma tabela e todos os seus dados que usam o AWS CLI.
**Para excluir uma tabela usando o AWS CLI**
1. Abra o CloudShell
1. Exclua sua tabela com a seguinte declaração.
```
aws keyspaces delete-table --keyspace-name 'catalog' --table-name 'book_awards'
```
1. Para verificar se sua tabela foi excluída, você pode listar todas as tabelas em um keyspace.
```
aws keyspaces list-tables --keyspace-name 'catalog'
```
Você verá a saída a seguir. Observe que essa operação assíncrona pode levar algum tempo. Execute novamente o comando depois de um tempo para confirmar que a tabela foi excluída.
```
{
"tables": []
}
```
# Excluir um keyspace no Amazon Keyspaces
Para evitar a cobrança por espaços de chave, exclua todos os espaços de chave que não estiver usando. Quando você exclui um espaço de chave, o espaço de chave e todas as suas tabelas são excluídos e você deixa de acumular cobranças por eles.
Você pode excluir um espaço de chave usando o console, CQL ou AWS CLI.
## Utilizar o console
O procedimento a seguir exclui um espaço de chave e todas as suas tabelas e dados usando o console.
**Para excluir um espaço de chave usando o console**
1. [Faça login no Console de gerenciamento da AWS e abra o console do Amazon Keyspaces em casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. No painel de navegação, escolha **Keyspaces**.
1. Escolha a caixa à esquerda do nome de cada espaço de chave que deseja excluir.
1. Escolha **Excluir**.
1. Na tela **Excluir espaço de chave**, insira **Delete** na caixa. Em seguida, escolha **Excluir espaço de chave.**
1. Para verificar se o espaço de chave `catalog` foi excluído, escolha **Espaços de chave** no painel de navegação e confirme se ele não está mais listado. Como você excluiu seu espaço de chave, a tabela `book_awards` em **Tabelas** também não deve estar listada.
## Usar SSL
O procedimento a seguir exclui um espaço de chave e todas as suas tabelas e dados usando CQL.
**Para excluir um espaço de chave usando CQL**
1. Abra AWS CloudShell e conecte-se ao Amazon Keyspaces usando o comando a seguir. Certifique-se de atualizar *us-east-1* com sua própria região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Exclua seu keyspace digitando a seguinte declaração.
```
DROP KEYSPACE IF EXISTS catalog ;
```
1. Verifique se seu espaço de chave foi excluído.
```
SELECT * from system_schema.keyspaces ;
```
Seu espaço de chave não deve ser listado. Observe que, como essa é uma operação assíncrona, pode haver um atraso até que o espaço de chaves seja excluído. Depois que o keyspace for excluído, a saída da instrução deverá ficar assim.
```
keyspace_name | durable_writes | replication
-------------------------+----------------+-------------------------------------------------------------------------------------
system_schema | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_schema_mcs | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_multiregion_info | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
(4 rows)
```
## Usando o AWS CLI
O procedimento a seguir exclui um espaço de chave e todas as suas tabelas e dados usando o AWS CLI.
**Para excluir um espaço de tecla usando o AWS CLI**
1. Abra o AWS CloudShell
1. Exclua seu keyspace digitando a seguinte declaração.
```
aws keyspaces delete-keyspace --keyspace-name 'catalog'
```
1. Verifique se seu espaço de chave foi excluído.
```
aws keyspaces list-keyspaces
```
A saída dessa declaração deve ser semelhante a essa e listar apenas os espaços de teclas do sistema. Observe que, como essa é uma operação assíncrona, pode haver um atraso até que seu espaço de teclas seja excluído.
```
{
"keyspaces": [
{
"keyspaceName": "system_schema",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system_schema/",
"replicationStrategy": "SINGLE_REGION"
},
{
"keyspaceName": "system_schema_mcs",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system_schema_mcs/",
"replicationStrategy": "SINGLE_REGION"
},
{
"keyspaceName": "system",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system/",
"replicationStrategy": "SINGLE_REGION"
},
{
"keyspaceName": "system_multiregion_info",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system_multiregion_info/",
"replicationStrategy": "SINGLE_REGION"
}
]
}
```