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á.
# Gerenciamento de clusters
A maioria das operações do MemoryDB é realizada no nível do cluster. Você pode configurar um cluster com um número específico de nós e um parameter group que controla as propriedades de cada nó. Todos os nós de um cluster são do mesmo tipo e têm as mesmas configurações de parameter group e security group.
Cada cluster deve ter um identificador de cluster. O identificador de cluster é um nome fornecido pelo cliente para o cluster. Esse identificador especifica um cluster específico ao interagir com os comandos da API do MemoryDB e da AWS CLI . O identificador do cluster deve ser exclusivo para esse cliente em uma AWS região.
Os clusters do MemoryDB foram criados para serem acessados usando uma instância do Amazon EC2. Você só pode iniciar o cluster do MemoryDB em uma nuvem privada virtual (VPC) com base no serviço Amazon VPC, mas pode acessá-lo de fora de AWS. Para obter mais informações, consulte [Acessar recursos do MemoryDB de fora da AWS](accessing-memorydb.md#access-from-outside-aws).
# Classificação de dados em níveis
Os clusters que usam um tipo de nó da família r6gd têm seus dados classificados em níveis entre a memória e o armazenamento local em unidades de estado sólido (Solid state Drives, SSD). A classificação de dados em níveis fornece uma nova opção de relação entre preço e desempenho para workloads do Valkey e Redis OSS, utilizando unidades de estado sólido (SSDs) de menor custo em cada nó de cluster, além do armazenamento de dados na memória. Semelhante a outros tipos de nós, os dados gravados nos nós r6gd são armazenados de forma durável em um log de transações Multi-AZ. A classificação de dados em níveis é ideal para workloads que acessam regularmente até 20% do conjunto de dados geral e para aplicações que podem tolerar latência adicional ao acessar dados em SSD.
Em clusters com classificação de dados em níveis, o MemoryDB monitora o último horário de acesso de cada item armazenado. Quando a memória disponível (DRAM) é totalmente consumida, o MemoryDB usa um algoritmo usado menos recentemente (Least-Recently Used, LRU) para mover automaticamente da memória para o SSD os itens acessados com pouca frequência. Quando os dados em SSD são acessados posteriormente, o MemoryDB os move de modo automático e assíncrono de volta para a memória antes de processar a solicitação. Se você tiver uma workload que acessa regularmente apenas um subconjunto de dados, a classificação de dados em níveis é uma maneira ideal de dimensionar sua capacidade de modo econômico.
Observe que, ao usar a classificação por níveis, as próprias chaves sempre permanecem na memória, enquanto a LRU controla a colocação de valores na memória versus disco. Em geral, recomendamos que seus tamanhos de chave sejam menores do que seus tamanhos de valor ao usar a classificação por níveis de dados.
A classificação de dados em níveis foi projetada para causar impacto mínimo na performance das workload da aplicação. Por exemplo, supondo valores de string de 500 bytes, você pode esperar um adicional de 450 microssegundos de latência para solicitações de leitura de dados armazenados em SSD em comparação com solicitações de leitura de dados na memória.
Com o maior tamanho de nó de classificação de dados (db.r6gd.8xlarge), é possível armazenar até mais ou menos 500 TB em um único cluster de 500 nós (250 TB ao usar 1 réplica de leitura). Para a classificação de dados em níveis, o MemoryDB reserva 19% da memória (DRAM) por nó para uso não relacionado a dados. A classificação de dados em níveis é compatível com todos os comandos e estruturas de dados do Valkey e Redis OSS compatíveis com o MemoryDB. Para usar esse recurso, não é necessário promover alterações no lado do cliente.
**Topics**
+ [Práticas recomendadas](data-tiering-best-practices.md)
+ [Limites para a classificação de dados em níveis](data-tiering-prerequisites.md)
+ [Preços para a classificação de dados em níveis](data-tiering-pricing.md)
+ [Monitoramento de dados em níveis](data-tiering-monitoring.md)
+ [Como usar a classificação de dados em níveis](data-tiering-enabling.md)
+ [Restaurar dados de um snapshot em clusters](data-tiering-enabling-snapshots.md)
# Práticas recomendadas
Recomendamos seguir estas práticas recomendadas:
+ A classificação de dados em níveis é ideal para workloads que acessam regularmente até 20% do conjunto de dados geral e para aplicações que podem tolerar latência adicional ao acessar dados em SSD.
+ Ao usar a capacidade SSD disponível em nós em níveis de dados, recomendamos que o tamanho do valor seja maior do que o tamanho da chave. O tamanho do valor não pode ser maior que 128 MB, caso contrário, não será movido para o disco. Quando os itens são movidos entre DRAM e SSD, as chaves sempre permanecerão na memória e somente os valores serão movidos para a camada SSD.
# Limites para a classificação de dados em níveis
A classificação de dados em níveis tem as seguintes limitações:
+ O tipo de nó usado deve ser da família r6gd, que está disponível nas seguintes regiões: `us-east-2`, `us-east-1`, `us-west-2`, `us-west-1`, `eu-west-1`, `eu-west-3`, `eu-central-1`, `ap-northeast-1`, `ap-southeast-1`, `ap-southeast-2`, `ap-south-1`, `ca-central-1` e `sa-east-1`.
+ Não é possível restaurar um snapshot de um cluster r6gd em outro cluster, a menos que ele também use r6gd.
+ Não é possível exportar um snapshot para o Amazon S3 para clusters de classificação de dados em níveis.
+ Não há compatibilidade com salvamento sem bifurcação.
+ Não há compatibilidade com escalabilidade de um cluster de classificação de dados em níveis (p. ex., um cluster que use um tipo de nó r6gd) para um cluster sem classificação de dados em níveis (p. ex., um cluster que use um tipo de nó r6g).
+ A classificação de dados em níveis só é compatível com as políticas maxmemory `volatile-lru`, `allkeys-lru` e `noeviction`.
+ Itens maiores que 128 MiB não são movidos para o SSD.
# Preços para a classificação de dados em níveis
Os nós R6gd têm 5 vezes mais capacidade total (memória \$1 SSD) e podem ajudá-lo a obter mais de 60% de economia de custos de armazenamento ao serem executados na utilização máxima em comparação com os nós R6g (somente memória). Para obter mais informações, consulte [Preços do MemoryDB](https://aws.amazon.com/memorydb/pricing/).
# Monitoramento de dados em níveis
O MemoryDB oferece métricas especificamente projetadas para monitorar os clusters de desempenho que usam a classificação de dados em níveis. Para monitorar a proporção de itens na DRAM em comparação com o SSD, é possível usar a métrica de `CurrItems` em [Métricas para MemoryDB](metrics.memorydb.md). Você pode calcular a porcentagem como: `(CurrItems with Dimension: Tier = Memory * 100) / (CurrItems with no dimension filter)`.
Se a política de remoção configurada permitir, o MemoryDB começará a remover itens quando a porcentagem de itens na memória cair abaixo de 5%. Nos nós configurados com a política de não remoção, as operações de gravação receberão um erro de falta de memória.
Ainda é recomendado que você considere [Escalabilidade de clusters do MemoryDB](scaling-cluster.md) quando a percentagem de itens na memória cair abaixo de 5%. Para obter mais informações, consulte *Métricas para clusters do MemoryDB que usam classificação de dados em níveis* em [Métricas para MemoryDB](metrics.memorydb.md).
# Como usar a classificação de dados em níveis
## Como usar a classificação de dados em níveis usando o Console de gerenciamento da AWS
Ao criar um cluster, você usa a classificação de dados em níveis selecionando um tipo de nó da família r6gd, como o *db.r6gd.xlarge*. A seleção desse tipo de nó ativa automaticamente a classificação de dados em níveis.
Para mais informações sobre como criar um cluster, consulte [Etapa 2: criar um cluster](getting-started.md#getting-started.createcluster).
## Como habilitar a classificação de dados em níveis usando a AWS CLI
Ao criar um cluster usando o AWS CLI, você usa a classificação de dados em níveis selecionando um tipo de nó da família r6gd, como *db.r6gd.xlarge*, e configurando o parâmetro `--data-tiering`.
Você não pode optar por não usar a classificação de dados em níveis ao selecionar um tipo de nó da família r6gd. Se você configurar o parâmetro `--no-data-tiering`, a operação falhará.
Para Linux, macOS ou Unix:
```
aws memorydb create-cluster \
--cluster-name my-cluster \
--node-type db.r6gd.xlarge \
--engine valkey \
--acl-name my-acl \
--subnet-group my-sg \
--data-tiering
```
Para Windows:
```
aws memorydb create-cluster ^
--cluster-name my-cluster ^
--node-type db.r6gd.xlarge ^
--engine valkey ^
--acl-name my-acl ^
--subnet-group my-sg
--data-tiering
```
Após executar essa operação, você verá uma resposta semelhante ao seguinte:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "creating",
"NumberOfShards": 1,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Port": 6379
},
"NodeType": "db.r6gd.xlarge",
"EngineVersion": "7.2",
"EnginePatchVersion": "7.2.6",
"Engine": "valkey"
"ParameterGroupName": "default.memorydb-valkey7",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxxxxxxxxx:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering":"true",
"AutoMinorVersionUpgrade": true
}
}
```
# Restaurar dados de um snapshot em clusters
Você pode restaurar um snapshot em um novo cluster com a classificação de dados em níveis ativada usando o (Console), a (CLI da AWS) ou a (API do MemoryDB). Ao criar um cluster usando tipos de nós na família r6gd, a classificação de dados em níveis é ativada.
## Restauração de dados do snapshot para clusters com a classificação de dados em níveis ativada (console)
Restaurar um snapshot para um novo cluster com a classificação de dados em níveis ativada (console), siga as etapas em [Restauração a partir de um snapshot (Console)](snapshots-restoring.md#snapshots-restoring-CON)
Observe que, para ativar a classificação de dados em níveis, você precisa selecionar um tipo de nó da família r6gd.
## Restauração de dados do snapshot para clusters com a classificação de dados em níveis ativada (CLI da AWS)
Ao criar um cluster usando a AWS CLI, a classificação de dados em níveis é usada por padrão ao selecionar um tipo de nó da família r6gd, por exemplo, o *db.r6gd.xlarge*, e configurando o parâmetro `--data-tiering`.
Você não pode optar por não usar a classificação de dados em níveis ao selecionar um tipo de nó da família r6gd. Se você configurar o parâmetro `--no-data-tiering`, a operação falhará.
Para Linux, macOS ou Unix:
```
aws memorydb create-cluster \
--cluster-name my-cluster \
--node-type db.r6gd.xlarge \
--engine valkey
--acl-name my-acl \
--subnet-group my-sg \
--data-tiering \
--snapshot-name my-snapshot
```
Para Windows:
```
aws memorydb create-cluster ^
--cluster-name my-cluster ^
--node-type db.r6gd.xlarge ^
--engine valkey ^
--acl-name my-acl ^
--subnet-group my-sg ^
--data-tiering ^
--snapshot-name my-snapshot
```
Após executar essa operação, você verá uma resposta semelhante ao seguinte:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "creating",
"NumberOfShards": 1,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Port": 6379
},
"NodeType": "db.r6gd.xlarge",
"EngineVersion": "7.2",
"EnginePatchVersion": "7.2.6",
"Engine": "valkey"
"ParameterGroupName": "default.memorydb-valkey7",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxxxxxxxxx:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "true"
}
```
# Preparação de um cluster
Veja a seguir instruções sobre como criar um cluster usando o console do MemoryDB, a AWS CLI ou a API do MemoryDB.
Sempre que você criar um cluster, é uma boa ideia fazer algum trabalho preparatório para que você não precise atualizar nem fazer alterações imediatamente.
**Topics**
+ [Determinação dos seus requisitos](cluster-create-determine-requirements.md)
# Determinação dos seus requisitos
**Preparação**
Conhecer as respostas às seguintes perguntas ajuda a tornar a criação do cluster mais simples:
+ Verifique se criou um grupo de sub-redes na mesma VPC antes de começar a criar um cluster. Como alternativa, você pode usar o grupo de sub-redes padrão fornecido. Para obter mais informações, consulte [Sub-redes e grupos de sub-redes](subnetgroups.md).
O MemoryDB foi projetado para ser acessado de dentro AWS usando o Amazon EC2. No entanto, ao iniciá-lo em uma VPC com base na Amazon VPC, você pode fornecer acesso de fora da AWS. Para obter mais informações, consulte [Acessar recursos do MemoryDB de fora da AWS](accessing-memorydb.md#access-from-outside-aws).
+ Você precisa personalizar qualquer valor de parâmetro?
Se você fizer isso, crie um grupo de parâmetro personalizado. Para obter mais informações, consulte [Criar um parameter group](parametergroups.creating.md).
+ Você precisa criar um grupo de segurança de VPC?
Para obter mais informações, consulte [Segurança na sua VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Security.html).
+ Como você pretende implementar a tolerância a falhas?
Para obter mais informações, consulte [Atenuar falhas](faulttolerance.md).
**Topics**
+ [Requisitos de memória e processador](#cluster-create-determine-requirements-memory)
+ [Configuração do cluster do MemoryDB](#cluster-configuration)
+ [I/O Multiplexação aprimorada](#cluster-create-determine-requirements-multiplexing)
+ [Requisitos de escalabilidade](#cluster-create-determine-requirements-scaling)
+ [Requisitos de acesso](#cluster-create-determine-requirements-access)
+ [Regiões e zonas de disponibilidade](#cluster-create-determine-requirements-region)
## Requisitos de memória e processador
O bloco de construção básico do MemoryDB é o nó. Os nós são configurados em fragmentos para formar clusters. Ao determinar o tipo de nó a ser usado para o seu cluster, considere a configuração do nó do cluster e a quantidade de dados que você deve armazenar.
## Configuração do cluster do MemoryDB
Os clusters do MemoryDB são compostos de 1 a 500 fragmentos. Os dados em um cluster do MemoryDB são particionados nos fragmentos no cluster. Seu aplicativo conecta-se a um cluster do MemoryDB usando um endereço de rede chamado de Endpoint. Além dos pontos de extremidade do nó, o cluster do MemoryDB em si tem um endpoint chamado *cluster endpoint*. Seu aplicativo pode usar esse endpoint para ler ou gravar no cluster, deixando a determinação de qual nó deve ser lido ou gravado a cargo do MemoryDB.
## I/O Multiplexação aprimorada
Se você estiver executando o Valkey ou o Redis OSS versão 7.0 ou superior, obterá aceleração adicional com I/O multiplexação aprimorada, em que cada thread de E/S de rede dedicado envia comandos de vários clientes para o mecanismo, aproveitando a capacidade de processar comandos em lotes com eficiência. Para obter mais informações, consulte [Desempenho ultrarrápido](https://aws.amazon.com/memorydb/features/#Ultra-fast_performance) e [Tipos de nó compatíveis](nodes.supportedtypes.md).
## Requisitos de escalabilidade
Todos os clusters podem aumentar a escala verticalmente para um tipo de nó maior. Ao aumentar a escala verticalmente de um cluster do MemoryDB, você pode fazer isso on-line para que o cluster permaneça disponível ou você pode semear um novo cluster a partir de um snapshot e evitar que o novo cluster comece vazio.
Para obter mais informações, consulte [Escalabilidade](scaling.md) neste guia.
## Requisitos de acesso
Por design, os clusters do MemoryDB são acessados a partir de instâncias do Amazon EC2. O acesso via rede a um cluster do MemoryDB é limitado à conta que criou esse cluster. Portanto, antes de poder acessar um cluster de uma instância do Amazon EC2, você deve autorizar a acessar o cluster. Para obter instruções detalhadas, consulte [Etapa 3: autorizar o acesso ao cluster](getting-started.md#getting-started.authorizeaccess) neste guia.
## Regiões e zonas de disponibilidade
Ao localizar seus clusters MemoryDB em uma AWS região próxima ao seu aplicativo, você pode reduzir a latência. Se o seu cluster tiver vários nós, a localização deles em diferentes zonas de disponibilidade poderá reduzir o impacto das falhas no cluster.
Para saber mais, consulte:
+ [Escolher regiões e zonas de disponibilidade](regionsandazs.md)
+ [Atenuar falhas](faulttolerance.md)
# Criação de um cluster
O MemoryDB oferece três maneiras de criar um cluster. Para obter mais informações, consulte [Etapa 2: criar um cluster](getting-started.md#getting-started.createcluster).
# Visualização dos detalhes de um cluster
Você pode visualizar informações detalhadas sobre um ou mais clusters usando o console MemoryDB ou a API MemoryDB. AWS CLI
## Visualização de detalhes de um cluster do MemoryDB (console)
O procedimento a seguir detalha como visualizar os detalhes de um cluster do MemoryDB usando o console do MemoryDB.
****
1. Faça login no Console de gerenciamento da AWS e abra o console do MemoryDB em. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Para ver os detalhes de um cluster, escolha o botão de opção à esquerda do nome do cluster e escolha **Exibir detalhes**. Você também pode clicar diretamente no cluster para ver a página de detalhes do cluster.
A página de **detalhes do cluster** exibe detalhes sobre o cluster, incluindo o endpoint do cluster. Você pode ver mais detalhes usando as várias guias disponíveis na página de **detalhes do cluster**.
1. Selecione a guia **fragmentos e nós** para ver uma lista dos fragmentos do cluster e o número de nós em cada fragmento.
1. Para visualizar informações específicas sobre um nó, expanda o fragmento na tabela abaixo. Como alternativa, você também pode pesquisar o fragmento usando a caixa de pesquisa.
Isso exibe informações sobre cada nó, incluindo sua zona de disponibilidade slots/keyspaces e status.
1. Escolha a guia **Métricas** para monitorar seus respectivos processos, como a **utilização da CPU** e a **utilização da CPU do mecanismo**. Para obter mais informações, consulte [Métricas para MemoryDB](metrics.memorydb.md).
1. Escolha a guia **Rede e segurança** para ver detalhes do grupo de sub-redes e dos grupos de segurança.
1. Em **Grupo de sub-redes**, você pode ver o nome do grupo de sub-redes, um link para a VPC à qual a sub-rede pertence e o nome do recurso da Amazon (ARN) do grupo de sub-redes.
1. Em **Grupos de segurança**, você pode ver o ID, o nome e a descrição do grupo de segurança.
1. Escolha a guia **Manutenção e snapshot** para ver detalhes das configurações do snapshot.
1. Em **Snapshot**, você pode ver se os snapshots automatizados estão ativados, o período de retenção do snapshot e a janela do snapshot.
1. Em **Snapshots**, você verá uma lista de todos os snapshots desse cluster, incluindo o nome, o tamanho, o número de fragmentos e o status do snapshot.
Para obter mais informações, consulte [Snapshots e restauração](snapshots.md).
1. Escolha a guia **Manutenção e snapshot** para ver os detalhes da janela de manutenção, junto com quaisquer atualizações pendentes de ACL, refragmentação ou serviço. Para obter mais informações, consulte [Gerenciamento da manutenção](maintenance-window.md).
1. Escolha a guia **Atualizações de serviços** para ver detalhes de todas as atualizações de serviço aplicáveis a esse cluster. Para obter mais informações, consulte [Atualizações de serviço no MemoryDB](service-updates.md).
1. Escolha a guia **Tags** para ver detalhes de quaisquer tags de alocação de recursos ou custos associados a esse cluster. Para obter mais informações, consulte [Marcação de snapshots](snapshots-tagging.md).
## Visualizando os detalhes de um cluster (AWS CLI)
Você pode ver os detalhes de um cluster usando o AWS CLI `describe-clusters` comando. Se o parâmetro `--cluster-name` for omitido, os detalhes para vários clusters, até `--max-results`, serão retornados. Se o parâmetro `--cluster-name` estiver incluído, os detalhes do cluster especificado serão retornados. Você pode limitar o número de registros retornados com o parâmetro `--max-results`.
O código a seguir lista os detalhes para `my-cluster`.
```
aws memorydb describe-clusters --cluster-name my-cluster
```
O código a seguir lista os detalhes para até 25 clusters.
```
aws memorydb describe-clusters --max-results 25
```
**Example**
Para Linux, macOS ou Unix:
```
aws memorydb describe-clusters \
--cluster-name my-cluster \
--show-shard-details
```
Para Windows:
```
aws memorydb describe-clusters ^
--cluster-name my-cluster ^
--show-shard-details
```
A saída JSON a seguir mostra a resposta:
```
{
"Clusters": [
{
"Name": "my-cluster",
"Description": "my cluster",
"Status": "available",
"NumberOfShards": 1,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-16383",
"Nodes": [
{
"Name": "my-cluster-0001-001",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": 1629230643.961,
"Endpoint": {
"Address": "my-cluster-0001-001.my-cluster.abcdef.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0001-002",
"Status": "available",
"CreateTime": 1629230644.025,
"Endpoint": {
"Address": "my-cluster-0001-002.my-cluster.abcdef.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.abcdef.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "default",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:000000000:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "sat:06:30-sat:07:30",
"SnapshotWindow": "04:00-05:00",
"ACLName": "open-access",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true,
}
```
Para obter mais informações, consulte o tópico AWS CLI for MemoryDB. [https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html)
## Visualizar os detalhes de um cluster: (API do MemoryDB)
Você pode visualizar os detalhes de um cluster usando a ação `DescribeClusters` da API do MemoryDB. Se o parâmetro `ClusterName` estiver incluído, os detalhes do cluster especificado serão retornados. Se o parâmetro `ClusterName` for omitido, os detalhes para até `MaxResults` (padrão 100) clusters serão retornados. O valor para `MaxResults` não pode ser inferior a 20 ou superior a 100.
O código a seguir lista os detalhes para `my-cluster`.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&ClusterName=my-cluster
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
O código a seguir lista os detalhes para até 25 clusters.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&MaxResults=25
&Version=2021-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
Para obter mais informações, consulte o tópico [https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html) de referência da API do MemoryDB.
# Modificar um cluster do MemoryDB
Além de adicionar ou remover nós de um cluster, pode haver momentos em que você precisará fazer outras alterações em um cluster existente, como adicionar um grupo de segurança, alterar a janela de manutenção ou um grupo de parâmetros.
Recomendamos que você tenha sua janela de manutenção cair no momento da menor utilização. Assim, talvez seja necessário modificá-la de tempos em tempos.
Quando você altera os parâmetros de um cluster, a alteração é aplicada ao cluster imediatamente. Isso é verdadeiro se você alterar o próprio grupo de parâmetro do cluster ou um valor do parâmetro dentro do grupo do parâmetro do cluster.
Você também pode atualizar a versão do mecanismo de seus clusters. Por exemplo, você pode selecionar uma nova versão secundária do mecanismo e o MemoryDB começará a atualizar seu cluster imediatamente.
## Usando o Console de gerenciamento da AWS
**Como modificar um cluster**
1. Faça login no Console de gerenciamento da AWS e abra o console do MemoryDB em. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Na lista no canto superior direito, escolha a AWS região em que o cluster que você deseja modificar está localizado.
1. No painel de navegação à esquerda, acesse **Clusters**. Em **Detalhes dos clusters**, selecione o cluster usando o botão de opções e vá até **Ações** e depois **Modificar**.
1. A página **Modificar** é exibida.
1. Na janela **Modificar**, faça as modificações desejadas. As opções incluem:
+ Description
+ Grupos de sub-redes
+ Grupos de segurança da VPC
+ Tipo de nó
**nota**
Se o cluster estiver usando um tipo de nó da família r6gd, você só poderá escolher um tamanho de nó diferente nessa família. Se você escolher um tipo de nó da família r6gd, a classificação de dados em níveis será ativada automaticamente. Para obter mais informações, consulte [Classificação de dados em níveis](data-tiering.md).
+ Compatibilidade com versões do Valkey ou Redis OSS
+ Ativar instantâneos automáticos
+ Período de retenção de snapshot
+ Janela do Snapshot
+ Janela de manutenção
+ Tópico para notificação do SNS
1. Escolha **Salvar alterações**.
Você também pode acessar a página de **detalhes do cluster** e clicar em **modificar** para fazer modificações no cluster. Se você quiser modificar seções específicas do cluster, acesse a respectiva guia na página de **detalhes do cluster** e clique em **Modificar**.
## Usando o AWS CLI
Você pode modificar um cluster existente usando a AWS CLI `update-cluster` operação. Para modificar o valor de configuração de um cluster, especifique o ID do cluster, o parâmetro a ser alterado e o novo valor do parâmetro. O exemplo a seguir altera a janela de manutenção para um cluster chamado `my-cluster` e aplica a alteração imediatamente.
Para Linux, macOS ou Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--preferred-maintenance-window sun:23:00-mon:02:00
```
Para Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--preferred-maintenance-window sun:23:00-mon:02:00
```
Para obter mais informações, consulte [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html) na Referência de AWS CLI comandos.
## Usando a API do MemoryDB
Você pode modificar um cluster existente usando a operação da API [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html)MemoryDB. Para modificar o valor de configuração de um cluster, especifique o ID do cluster, o parâmetro a ser alterado e o novo valor do parâmetro. O exemplo a seguir altera a janela de manutenção para um cluster chamado `my-cluster` e aplica a alteração imediatamente.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=UpdateCluster
&ClusterName=my-cluster
&PreferredMaintenanceWindow=sun:23:00-mon:02:00
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210801T220302Z
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Date=20210802T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20210801T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
## Como acionar uma atualização entre mecanismos do Redis OSS para o Valkey
Você pode atualizar um cluster existente do Redis OSS para o mecanismo Valkey usando o console, a API ou a CLI.
Se você já tem um cluster do Redis OSS que está usando o grupo de parâmetros padrão, pode atualizar para o Valkey especificando o novo mecanismo e a versão do mecanismo com a API update-cluster.
Para Linux, macOS ou Unix:
```
aws memorydb update-cluster \
--cluster-name myCluster \
--engine valkey \
--engine-version 7.2
```
Para Windows:
```
aws memorydb update-cluster ^
--cluster-name myCluster ^
--engine valkey ^
--engine-version 7.2
```
Se você tiver um grupo de parâmetros personalizados aplicado ao cluster existente do Redis OSS que deseja atualizar, também precisará enviar um grupo de parâmetros personalizados do Valkey na solicitação. O grupo de parâmetros personalizados de entrada do Valkey deve ter os mesmos valores de parâmetros estáticos do Redis OSS que o grupo de parâmetros personalizados do Redis OSS existente.
Para Linux, macOS ou Unix:
```
aws memorydb update-cluster \
--cluster-name myCluster \
--engine valkey \
--engine-version 7.2 \
--parameter-group-name myParamGroup
```
Para Windows:
```
aws memorydb update-cluster ^
--cluster-name myCluster ^
--engine valkey ^
--engine-version 7.2 ^
--parameter-group-name myParamGroup
```
# Adição e Remoção de nós de um cluster
Você pode adicionar ou remover nós de um cluster usando a Console de gerenciamento da AWS API MemoryDB ou a AWS CLI API MemoryDB.
## Usando o Console de gerenciamento da AWS
****
1. Faça login no Console de gerenciamento da AWS e abra o console do MemoryDB em. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Na lista de clusters, escolha o nome do cluster do qual você deseja remover um nó.
1. Na guia **fragmentos e nós**, escolha **Adicionar/Excluir nós**
1. em **Número de nós**, insira o número de nós desejado.
1. Selecione a opção **Confirmar**.
**Importante**
Se você definir o número de nós como 1, não estará mais habilitado para Multi-AZ. Você também pode optar por ativar o **failover automático**.
## Usando o AWS CLI
1. Identifique os nomes dos nós que você deseja remover. Para obter mais informações, consulte [Visualização dos detalhes de um cluster](clusters.viewdetails.md).
1. Use a operação `update-cluster` da CLI com uma lista dos nós a serem removidos, como no exemplo a seguir.
Para remover nós de um cluster usando a interface da linha de comando, use o comando `update-cluster` com os seguintes parâmetros:
+ `--cluster-name` o ID do cluster de cache do qual você deseja remover nós.
+ `--replica-configuration`: permite que você defina o número de réplicas:
+ `ReplicaCount`: defina essa propriedade para especificar o número de nós de réplica desejado.
+ `--region`Especifica a AWS região do cluster da qual você deseja remover os nós.
Para Linux, macOS ou Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--replica-configuration \
ReplicaCount=1 \
--region us-east-1
```
Para Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--replica-configuration ^
ReplicaCount=1 ^
--region us-east-1
```
Para obter mais informações, consulte os AWS CLI tópicos [https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html).
## Usando a API do MemoryDB
Para remover nós usando a API do MemoryDB, chame a operação `UpdateCluster` da API com o nome do cluster e uma lista de nós para remoção, conforme mostrado:
+ `ClusterName` o ID do cluster de cache do qual você deseja remover nós.
+ `ReplicaConfiguration`: permite que você defina o número de réplicas:
+ `ReplicaCount`: defina essa propriedade para especificar o número de nós de réplica desejado.
+ `Region`Especifica a AWS região do cluster da qual você deseja remover um nó.
Para obter mais informações, consulte [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
# Acessar o cluster
As instâncias do MemoryDB são projetadas para acesso por meio de uma instância do Amazon EC2.
Você pode acessar seu nó do MemoryDB de uma instância do Amazon EC2 na mesma Amazon VPC. Ou, usando o emparelhamento da VPC, você pode acessar seu nó do MemoryDB de um Amazon EC2 em uma Amazon VPC diferente.
**Topics**
+ [Conceder acesso a seus clusters](#grant-access)
+ [Acessar recursos do MemoryDB de fora da AWS](#access-from-outside-aws)
## Conceder acesso a seus clusters
Você pode se conectar ao seu cluster do MemoryDB somente a partir de uma instância do Amazon EC2 que esteja sendo executada na mesma Amazon VPC. Nesse caso, você precisará conceder entrada de rede ao cluster.
**Para conceder entrada na rede de um grupo de segurança da Amazon VPC para um cluster**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação esquerdo, em **Network & Security**, escolha **Security Groups**.
1. Na lista de grupos de segurança, escolha o de segurança para a sua Amazon VPC. A menos que você tenha criado um grupo de segurança para uso com o MemoryDB, esse grupo de segurança será chamado *default*.
1. Escolha a guia **Inbound** e faça o seguinte:
1. Selecione **Editar**.
1. Escolha **Adicionar regra**.
1. Na coluna **Tipo**, escolha **Regra TCP personalizada**.
1. Na caixa **Port range**, digite o número da porta para o nó do cluster. Esse número deve ser o mesmo que você especificou quando você executou o cluster. A porta padrão para Valkey e Redis OSS é **6379**.
1. Na caixa **Fonte**, escolha **Qualquer lugar**, que tem o intervalo de porta (0.0.0.0/0) para que qualquer instância do Amazon EC2 que você inicie na sua Amazon VPC possa se conectar aos seus nós do MemoryDB.
**Importante**
Abrir o cluster do MemoryDB para 0.0.0.0/0 não expõe o cluster à Internet, pois ele não possui um endereço IP público e, portanto, não pode ser acessado de fora da VPC. No entanto, o grupo de segurança padrão pode ser aplicado a outras instâncias do Amazon EC2 na conta do cliente, e essas instâncias podem ter um endereço IP público. Se eles estiverem executando algo na porta padrão, esse serviço poderá ser exposto involuntariamente. Portanto, recomendamos criar um grupo de segurança de VPC que será usado exclusivamente pelo MemoryDB. Para obter mais informações, consulte [Grupos de segurança personalizados](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#creating-your-own-security-groups).
1. Escolha **Salvar**.
Quando você ativa uma instância do Amazon EC2 na sua Amazon VPC, essa instância poderá se conectar ao seu cluster do MemoryDB.
## Acessar recursos do MemoryDB de fora da AWS
MemoryDB é um serviço projetado para ser usado internamente em sua VPC. O acesso externo não é recomendado devido à latência do tráfego da Internet e preocupações de segurança. No entanto, se o acesso externo ao MemoryDB for necessário para fins de teste ou desenvolvimento, poderá ser feito por meio de uma VPN.
Usando o cliente VPN da AWS, você permite o acesso externo aos seus nós do MemoryDB com os seguintes benefícios:
+ Acesso restrito a usuários aprovados ou chaves de autenticação;
+ Tráfego criptografado entre o cliente de VPN e o endpoint da VPN da AWS;
+ Acesso limitado a sub-redes ou nós específicos;
+ Fácil revogação do acesso de usuários ou chaves de autenticação;
+ Conexões de auditoria;
Os procedimentos a seguir demonstram como:
**Topics**
+ [Criar uma autoridade de certificação](#create-cert)
+ [Configuração de componentes do cliente VPN da AWS](#configure-vpn-components)
+ [Configurar o cliente de VPN](#configure-vpn-client)
### Criar uma autoridade de certificação
É possível criar uma Autoridade de certificação (CA) usando diferentes técnicas ou ferramentas. Sugerimos o utilitário easy-rsa, fornecido pelo projeto [OpenVPN](https://openvpn.net/community-resources/openvpn-project/). Independentemente da opção escolhida, mantenha as chaves seguras. O procedimento a seguir faz download dos scripts easy-rsa, cria a Autoridade de certificação e as chaves para autenticar o primeiro cliente de VPN:
+ Para criar os certificados iniciais, abra um terminal e faça o seguinte:
+ `git clone` [https://github.com/OpenVPN/easy-rsa](https://github.com/OpenVPN/easy-rsa)
+ `cd easy-rsa`
+ `./easyrsa3/easyrsa init-pki`
+ `./easyrsa3/easyrsa build-ca nopass`
+ `./easyrsa3/easyrsa build-server-full server nopass`
+ `./easyrsa3/easyrsa build-client-full client1.domain.tld nopass`
Um subdiretório **pki** com os certificados será criado sob **easy-rsa**.
+ Envie o certificado do servidor para o AWS Certificate Manager (ACM):
+ No console do ACM, selecione **Gerenciador de certificados**.
+ Selecione **Importar certificado**.
+ Informe o certificado de chave pública disponível no arquivo `easy-rsa/pki/issued/server.crt` no campo **Corpo do certificado**.
+ Cole a chave privada disponível no `easy-rsa/pki/private/server.key` no campo **Chave privada do certificado**. Selecione todas as linhas entre `BEGIN AND END PRIVATE KEY` (incluindo as linhas `BEGIN` e `END`).
+ Cole a chave pública da CA disponível no arquivo `easy-rsa/pki/ca.crt` no campo **Cadeia de certificados**.
+ Selecione **Revisar e importar**.
+ Selecione **Importar**.
Para enviar os certificados do servidor ao ACM usando a CLI da AWS, execute o seguinte comando: `aws acm import-certificate --certificate fileb://easy-rsa/pki/issued/server.crt --private-key file://easy-rsa/pki/private/server.key --certificate-chain file://easy-rsa/pki/ca.crt --region region`
Anote o ARN do certificado para uso futuro.
### Configuração de componentes do cliente VPN da AWS
**Usar o AWS Console**
No console da AWS, selecione **Serviços** e, depois, **VPC**.
Em **Rede privada virtual (VPN)**, selecione **Endpoints do Client VPN** e faça o seguinte:
**Configuração de componentes do cliente VPN da AWS**
+ Selecione **Criar endpoint do Client VPN**.
+ Especifique as seguintes opções:
+ **CIDR de IPv4 de cliente**: use uma rede privada com uma máscara de rede de pelo menos intervalo /22. Verifique se a sub-rede selecionada não entra em conflito com os endereços das redes da VPC. Exemplo: 10.0.0.0/22.
+ Em **ARN do certificado de servidor**, selecione o ARN do certificado importado anteriormente.
+ Selecione **Usar autenticação mútua**.
+ Em **ARN do certificado de cliente**, selecione o ARN do certificado importado anteriormente.
+ Selecione **Criar endpoint do Client VPN**.
**Como usar a AWS CLI**
Execute o seguinte comando:
`aws ec2 create-client-vpn-endpoint --client-cidr-block "10.0.0.0/22" --server-certificate-arn arn:aws:acm:us-east-1:012345678912:certificate/0123abcd-ab12-01a0-123a-123456abcdef --authentication-options Type=certificate-authentication,,MutualAuthentication={ClientRootCertificateChainArn=arn:aws:acm:us-east-1:012345678912:certificate/123abcd-ab12-01a0-123a-123456abcdef} --connection-log-options Enabled=false `
Resultado do exemplo:
`"ClientVpnEndpointId": "cvpn-endpoint-0123456789abcdefg", "Status": { "Code": "pending-associate" }, "DnsName": "cvpn-endpoint-0123456789abcdefg.prod.clientvpn.us-east-1.amazonaws.com" } `
**Associar as redes de destino ao endpoint de VPN**
+ Selecione o novo endpoint de VPN e, depois, selecione a guia **Associações**.
+ Selecione **Associar** e especifique as opções a seguir.
+ **VPC**: selecione a VPC do cluster do MemoryDB.
+ Selecione uma das redes do cluster do MemoryDB. Em caso de dúvida, revise as redes nos **Grupos de sub-redes** no painel do MemoryDB.
+ Selecione **Associar**. Se necessário, repita as etapas para as redes restantes.
**Como usar a AWS CLI**
Execute o seguinte comando:
`aws ec2 associate-client-vpn-target-network --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --subnet-id subnet-0123456789abdcdef`
Resultado do exemplo:
`"Status": { "Code": "associating" }, "AssociationId": "cvpn-assoc-0123456789abdcdef" } `
**Analisar o grupo de segurança de VPN**
O endpoint de VPN adotará automaticamente o grupo de segurança padrão da VPC. Verifique as regras de entrada e saída e confirme se o grupo de segurança permite o tráfego da rede VPN (definido nas configurações de endpoint de VPN) para as redes do MemoryDB nas portas de serviço (por padrão, 6379 para Redis).
Se você precisar alterar o grupo de segurança atribuído ao endpoint de VPN, faça o seguinte:
+ Selecione o grupo de segurança atual.
+ Selecione **Apply Security Group (Aplicar grupo de segurança)**.
+ Selecione o novo grupo de segurança.
**Como usar a AWS CLI**
Execute o seguinte comando:
`aws ec2 apply-security-groups-to-client-vpn-target-network --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefga --vpc-id vpc-0123456789abdcdef --security-group-ids sg-0123456789abdcdef`
Resultado do exemplo:
`"SecurityGroupIds": [ "sg-0123456789abdcdef" ] } `
**nota**
O grupo de segurança do MemoryDB também precisa permitir o tráfego proveniente dos clientes de VPN. Os endereços dos clientes serão mascarados com o endereço do endpoint de VPN, de acordo com a rede VPC. Portanto, considere a rede VPC (não a rede dos clientes de VPN) ao criar a regra de entrada no grupo de segurança do MemoryDB.
**Autorizar o acesso de VPN às redes de destino**
Na guia **Autorização**, selecione **Autorizar entrada** e especifique o seguinte:
+ Rede de destino para habilitar o acesso: use 0.0.0.0/0 para permitir o acesso a qualquer rede (incluindo a Internet) ou restringir as redes/hosts do MemoryDB.
+ Em **Conceder acesso a:**, selecione **Permitir acesso a todos os usuários**.
+ Selecione **Adicionar regras de autorização**.
**Como usar a AWS CLI**
Execute o seguinte comando:
`aws ec2 authorize-client-vpn-ingress --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --target-network-cidr 0.0.0.0/0 --authorize-all-groups`
Resultado do exemplo:
`{ "Status": { "Code": "authorizing" } }`
**Permitir o acesso à Internet dos clientes de VPN**
Se você precisar navegar na Internet por meio da VPN, será necessário criar uma rota adicional. Selecione a guia **Tabela de rotas** e, depois, selecione **Criar rota**:
+ Destino da rota: 0.0.0.0/0
+ **ID de sub-rede da VPC de destino**: selecione uma das sub-redes associadas com acesso à Internet.
+ Selecione **Criar rota**.
**Como usar a AWS CLI**
Execute o seguinte comando:
`aws ec2 create-client-vpn-route --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --destination-cidr-block 0.0.0.0/0 --target-vpc-subnet-id subnet-0123456789abdcdef`
Resultado do exemplo:
`{ "Status": { "Code": "creating" } } `
### Configurar o cliente de VPN
No painel do cliente VPN da AWS, selecione o endpoint de VPN criado recentemente e selecione **Baixar configuração do cliente**. Copie o arquivo de configuração e os arquivos `easy-rsa/pki/issued/client1.domain.tld.crt` e `easy-rsa/pki/private/client1.domain.tld.key`. Edite o arquivo de configuração e altere ou adicione os seguintes parâmetros:
+ cert: adicione uma nova linha com o parâmetro cert apontando para o arquivo `client1.domain.tld.crt`. Use o caminho completo para o arquivo. Exemplo: `cert /home/user/.cert/client1.domain.tld.crt`
+ cert: key: adicione uma nova linha com a chave de parâmetro apontando para o arquivo `client1.domain.tld.key`. Use o caminho completo para o arquivo. Exemplo: `key /home/user/.cert/client1.domain.tld.key`
Estabeleça a conexão VPN com o comando: `sudo openvpn --config downloaded-client-config.ovpn`
**Revogar acesso**
Se você precisar invalidar o acesso de uma chave de cliente específica, a chave precisará ser revogada na CA. Depois, envie a lista de revogação para o cliente VPN da AWS.
Revogar a chave com easy-rsa:
+ `cd easy-rsa`
+ `./easyrsa3/easyrsa revoke client1.domain.tld`
+ Digite "sim" para continuar ou qualquer outra entrada para cancelar.
`Continue with revocation: `yes` ... * `./easyrsa3/easyrsa gen-crl`
+ Uma CRL atualizada foi criada. Arquivo de CRL: `/home/user/easy-rsa/pki/crl.pem`
Importação da lista de revogação para o cliente VPN da AWS:
+ No Console de gerenciamento da AWS, selecione **Serviços** e, depois, **VPC**.
+ Selecione **Endpoints do Client VPN**.
+ Selecione o endpoint do Client VPN e, depois, selecione **Ações** -> **Importar CRL de certificado de cliente**.
+ Cole o conteúdo do arquivo `crl.pem`.
**Como usar a AWS CLI**
Execute o seguinte comando:
`aws ec2 import-client-vpn-client-certificate-revocation-list --certificate-revocation-list file://./easy-rsa/pki/crl.pem --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg `
Resultado do exemplo:
`Example output: { "Return": true } `
# Localização de endpoints de conexão
Seu aplicativo conecta-se ao seu cluster usando endpoints. Um endpoint é o endereço exclusivo de um nó ou cluster. Use o *endpoint de cluster* do cluster para todas as operações.
As seções a seguir o guiarão na descoberta do endpoint necessário.
## Localização do endpoint para um cluster do MemoryDB (Console de gerenciamento da AWS)
**Para encontrar os endpoints de um cluster do MemoryDB**
1. Faça login no Console de gerenciamento da AWS e abra o console do MemoryDB em [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/).
1. No painel de navegação, escolha **Clusters**.
A tela de clusters será exibida com uma lista de clusters. Escolha o cluster ao qual você deseja se conectar.
1. Para encontrar o endpoint do cluster, escolha o nome do cluster (não o botão de opção).
1. O **endpoint do cluster** é exibido em **detalhes do cluster**. Para copiá-lo, selecione o ícone *copiar* à esquerda do endpoint.
## Localização do endpoint de um cluster do MemoryDB (CLI da AWS)
Você pode usar o comando `describe-clusters` para descobrir o endpoint de um cluster. O comando retorna o endpoint do cluster.
A operação a seguir recupera o endpoint, que neste exemplo é representado como uma *amostra*, para o cluster `mycluster`.
Retorna a seguinte resposta em JSON:
```
aws memorydb describe-clusters \
--cluster-name mycluster
```
Para Windows:
```
aws memorydb describe-clusters ^
--cluster-name mycluster
```
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 1,
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.4",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:zzzexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"AutoMinorVersionUpgrade": true
}
]
}
```
Para obter mais informações, consulte [describe-clusters](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html).
## Localização do endpoint para um cluster do MemoryDB (API do MemoryDB)
Você pode usar a API do MemoryDB para descobrir o endpoint de um cluster.
### Localização do endpoint para um cluster do MemoryDB (API do MemoryDB)
Você pode usar a API do MemoryDB para descobrir o endpoint de um cluster com a ação `DescribeClusters`. A ação retorna o endpoint do cluster.
A operação a seguir recupera o endpoint do cluster `mycluster`.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&ClusterName=mycluster
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&Version=2021-01-01
&X-Amz-Credential=
```
Para obter mais informações, consulte [DescribeClusters](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html).
# Operação com fragmentos
Um fragmento é uma coleção de um a 6 nós. É possível criar um cluster com alto número de fragmentos e baixo número de réplicas totalizando até 500 nós por cluster. Essa configuração do cluster pode variar de 500 fragmentos e 0 réplicas para 100 fragmentos e 4 réplicas, que é o número máximo de réplicas permitidas. Os dados do cluster são particionados entre todos os fragmentos do cluster. Se houver mais de um nó em um fragmento, este implementará a replicação com um nó sendo o nó primário de leitura/gravação e os outros nós como nós de réplica somente leitura.
Ao criar um cluster do MemoryDB usando o Console de gerenciamento da AWS, você especifica o número de fragmentos no cluster e o número de nós nos fragmentos. Para obter mais informações, consulte [Criação de um cluster do MemoryDB](getting-started.md#clusters.create).
Cada nó em um fragmento tem as mesmas especificações de computação, armazenamento e memória. A API do MemoryDB permite que você controle os atributos de todo o cluster, como o número de nós, as configurações de segurança e as janelas de manutenção do sistema.
Para obter mais informações, consulte [Refragmentação off-line para o MemoryDB](cluster-resharding-offline.md) e [Refragmentação on-line para o MemoryDB](cluster-resharding-online.md).
## Localização do nome de um fragmento
Você pode encontrar o nome de um fragmento usando o Console de gerenciamento da AWS, a AWS CLI ou a API do MemoryDB.
### Utilização do Console de gerenciamento da AWS
O procedimento a seguir usa o Console de gerenciamento da AWS para encontrar os nomes dos fragmentos de um cluster do MemoryDB.
****
1. Faça login no Console de gerenciamento da AWS e abra o console do MemoryDB em [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/).
1. No painel de navegação à esquerda, escolha **Clusters**.
1. Escolha o cluster em **Nome** cujos nomes de fragmentos você deseja encontrar.
1. Na guia **Fragmentos e nós**, visualize a lista de fragmentos em **Nome**. Você também pode expandir cada um para ver detalhes de seus nós.
### Como usar o AWS CLI
Para encontrar nomes de fragmentos (fragmentos) para clusters do MemoryDB, use a operação `describe-clusters` da AWS CLI com o seguinte parâmetro opcional.
+ **`--cluster-name`**: um parâmetro opcional que, quando usado, limita a saída aos detalhes do cluster especificado. Se esse parâmetro for omitido, serão retornados os detalhes de até 100 clusters.
+ **`--show-shard-details`**: retorna detalhes dos fragmentos, incluindo seus nomes.
Esse comando retorna os detalhes do `my-cluster`.
Para Linux, macOS ou Unix:
```
aws memorydb describe-clusters \
--cluster-name my-cluster
--show-shard-details
```
Para Windows:
```
aws memorydb describe-clusters ^
--cluster-name my-cluster
--show-shard-details
```
Retorna a seguinte resposta em JSON:
As quebras de linha foram adicionadas para legibilidade.
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 1,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-16383",
"Nodes": [
{
"Name": "my-cluster-0001-001",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0001-002",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
]
}
```
### Usando a API do MemoryDB
Para localizar IDs de fragmentos para clusters do MemoryDB, use a operação `DescribeClusters` da API com o seguinte parâmetro opcional.
+ **`ClusterName`**: um parâmetro opcional que, quando usado, limita a saída aos detalhes do cluster especificado. Se esse parâmetro for omitido, serão retornados os detalhes de até 100 clusters.
+ **`ShowShardDetails`**: retorna detalhes dos fragmentos, incluindo seus nomes.
**Example**
Esse comando retorna os detalhes do `my-cluster`.
Para Linux, macOS ou Unix:
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&ClusterName=sample-cluster
&ShowShardDetails=true
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```