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 no ElastiCache
Um *cluster* é uma coleção de um ou mais nós de cache, todos os quais executam uma instância do software de mecanismo Valkey, Memcached e Redis OSS. Ao criar um cluster, especifique o mecanismo e a versão para que todos os nós usem.
**Clusters Valkey e Redis OSS**
O diagrama a seguir ilustra um cluster típico do Valkey ou do Redis OSS. Esses clusters podem conter um nó único ou até seis nós dentro de um fragmento (API/CLI: grupo de nós). Um cluster do Valkey ou Redis OSS (modo cluster desabilitado) de nó único não possui fragmentos e um cluster do Valkey ou Redis OSS (modo cluster desabilitado) com vários nós tem um único fragmento. Clusters do Valkey ou Redis OSS (modo cluster habilitado) podem ter até 500 fragmentos, com seus dados particionados nos fragmentos. O limite de nós ou fragmentos pode ser aumentado para um máximo de 500 por cluster se a versão do mecanismo for Valkey 7.2 e posteriores ou Redis OSS 5.0.6 e posteriores. Por exemplo, você pode optar por configurar um cluster de 500 nós que varia entre 83 fragmentos (uma primária e 5 réplicas por fragmento) e 500 fragmentos (primário único e sem réplicas). Verifique se existem endereços IP disponíveis suficientes para acomodar o aumento. As armadilhas comuns incluem as sub-redes no grupo de sub-redes têm um intervalo CIDR muito pequeno ou as sub-redes são compartilhadas e fortemente usadas por outros clusters. Para obter mais informações, consulte [Criação de um grupo de sub-redes](SubnetGroups.Creating.md). Para versões abaixo de 5.0.6, o limite é 250 por cluster.
Para solicitar um aumento de limite, consulte [Limites de serviço da AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) e selecione o tipo de limite **Nodes per cluster per instance type** (Nós por cluster por tipo de instância).
Quando você possui múltiplos nós em um fragmento do Valkey ou Redis OSS, um dos nós é um nó primário de leitura/gravação. Todos os outros nós no estilhaço são réplicas somente leitura.
Os clusters típicos do Valkey ou Redis OSS são semelhantes ao seguinte.
![\[Imagem: clusters típicos do Valkey e Redis OSS\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Redis.png)
**Clusters do Memcached**
Clusters típicos do Memcached têm a seguinte aparência. Os clusters do Memcached contêm de 1 a 60 nós em que você particiona horizontalmente seus dados.
![\[Imagem: cluster Memcached típico\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Memcached.png)
**Operações do Elasticache para Valkey, Memcached e Redis OSS**
A maioria das operações do ElastiCache é 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 ElastiCache e da AWS CLI. O identificador de cluster deve ser exclusivo para esse cliente em uma região da AWS.
O ElastiCache oferece suporte para várias versões do mecanismo. A menos que você tenha motivos específicos, recomendamos usar a versão mais recente.
Os clusters do ElastiCache foram criados para serem acessados ao usar uma instância do Amazon EC2. Ao executar seu cluster em uma nuvem privada virtual (VPC) com base no serviço da Amazon VPC, é possível acessá-lo externamente à AWS. Para obter mais informações, consulte [Acessando ElastiCache recursos de fora AWS](accessing-elasticache.md#access-from-outside-aws).
Para obter uma lista das versões compatíveis, consulte [Mecanismos e versões compatíveis](VersionManagement.md#supported-engine-versions), [Versões compatíveis do mecanismo do Redis OSS](engine-versions.md#supported-engine-versions.redis) e [Compatível com ElastiCache versões do Memcached](engine-versions.md#supported-engine-versions-mc).
# Escolhendo um tipo de rede em ElastiCache
ElastiCache suporta as versões 4 e 6 do Protocolo de Internet (IPv4 e IPv6), permitindo que você configure seu cluster para aceitar:
+ somente IPv4 conexões,
+ somente IPv6 conexões,
+ ambos IPv4 e IPv6 conexões (pilha dupla)
IPv6 [é compatível com cargas de trabalho usando Valkey 7.2 e versões posteriores, ou Redis OSS 6.2 e versões posteriores, em todas as instâncias criadas no sistema Nitro.](https://aws.amazon.com/ec2/nitro/) Não há custos adicionais para acessar ElastiCache IPv6.
**nota**
A migração de clusters criados antes da disponibilidade de IPV6 /dual-stack não é suportada. A alternância entre tipos de rede em clusters recém-criados também não tem suporte.
IPv6 [é compatível com cargas de trabalho usando o Memcached 1.6.6 em diante em todas as instâncias criadas no sistema Nitro.](https://aws.amazon.com/ec2/nitro/) Não há custos adicionais para acessar ElastiCache IPv6.
## Configurar sub-redes para o tipo de rede
Se você criar um cluster em uma Amazon VPC, deverá especificar um grupo de sub-redes. ElastiCache usa esse grupo de sub-redes para escolher uma sub-rede e endereços IP dentro dessa sub-rede para associar aos seus nós. ElastiCache os clusters exigem uma sub-rede de pilha dupla com IPv6 endereços atribuídos a eles para operar no modo de pilha dupla e uma IPv6 sub-rede somente para operar como somente. IPv4 IPv6
## Usar pilha dupla
Ao usar o ElastiCache Redis OSS no modo de cluster ativado, do ponto de vista de um aplicativo, conectar-se a todos os nós do cluster por meio do endpoint de configuração não é diferente de conectar-se diretamente a um nó de cache individual. Para conseguir isso, um cliente com reconhecimento de cluster deve participar de um processo de descoberta de clusters e solicitar as informações de configuração de todos os nós. O protocolo de descoberta do Redis oferece suporte a apenas um IP por nó.
Ao criar um cluster com ElastiCache for Memcached e escolher dual-stack como o tipo de rede, você precisa designar um tipo de descoberta de IP — ou. IPv4 IPv6 ElastiCache usará como padrão o tipo de rede e a descoberta de IP IPv6, mas isso pode ser alterado. Se você usar a Descoberta automática, somente os endereços IP do tipo de IP escolhido serão retornados ao cliente Memcached. Para obter mais informações, consulte [Identificar automaticamente nós no seu cluster (Memcached)](AutoDiscovery.md).
Para manter a compatibilidade retroativa com todos os clientes existentes, é introduzida a descoberta de IP, que permite selecionar o tipo de IP (ou seja, IPv4 ou IPv6) a ser anunciado no protocolo de descoberta. Embora isso limite a descoberta automática a apenas um tipo de IP, a pilha dupla ainda é benéfica para cargas de trabalho habilitadas para o modo de cluster, pois permite migrações (ou reversões) de um IPv4 para um IPv6 tipo de IP de descoberta sem tempo de inatividade.
## Clusters de ElastiCache pilha dupla habilitados para TLS
Quando o TLS está habilitado para ElastiCache clusters, as funções de descoberta de clusters`cluster slots`, como,`cluster shards`, e `cluster nodes` com Valkey ou Redis OSS e `config get cluster` com Memcached retornam nomes de host em vez de. IPs Os nomes de host são então usados em vez de se conectar IPs ao ElastiCache cluster e realizar um handshake TLS. Isso significa que os clientes não serão afetados pelo parâmetro de descoberta de IP. *Para clusters habilitados para TLS, o parâmetro de descoberta de IP não tem efeito no protocolo IP preferencial. * Em vez disso, o protocolo IP usado será determinado pelo protocolo IP que o cliente prefere ao resolver nomes de host DNS.
Para obter exemplos sobre como configurar uma preferência de protocolo IP ao resolver nomes de host DNS, consulte [Clusters do ElastiCache de pilha dupla habilitados para TLS](BestPractices.md#network-type-configuring-tls-enabled-dual-stack).
## Usando o Console de gerenciamento da AWS(Valkey e Redis OSS)
Ao criar um cluster usando o Console de gerenciamento da AWS, em **Conectividade**, escolha um tipo de rede **IPv6**ou **pilha dupla**. **IPv4** Se você estiver criando um cluster Valkey ou Redis OSS (modo de cluster ativado) e escolher pilha dupla, deverá selecionar um **tipo de IP de descoberta**, ou. IPv6 IPv4
Para acessar mais informações, consulte [Criação de um cluster do Valkey ou Redis OSS (modo cluster habilitado) (console)](Clusters.Create.md#Clusters.Create.CON.RedisCluster) ou [Criação de um cluster do Valkey ou Redis OSS (modo cluster desabilitado) (console)](Clusters.Create.md#Clusters.Create.CON.Redis).
Ao criar um grupo de replicação usando o Console de gerenciamento da AWS, escolha um tipo de rede **IPv6**ou **pilha dupla**. **IPv4** Se você escolher pilha dupla, deverá selecionar um **tipo de IP de descoberta**, IPv6 ou IPv4.
Para acessar mais informações, consulte [Criação de um grupo de replicação do Valkey ou Redis OSS (modo cluster desabilitado) do início](Replication.CreatingReplGroup.NoExistingCluster.Classic.md) ou [Criação de um grupo de replicação no Valkey ou Redis OSS (modo cluster habilitado) do início](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md).
## Usando o Console de gerenciamento da AWS(Memcached)
Ao criar um cluster usando o Console de gerenciamento da AWS, em **Conectividade**, escolha um tipo de rede **IPv6**ou **pilha dupla**. **IPv4** Se você escolher pilha dupla, deverá selecionar um **tipo de IP de descoberta**, IPv6 ou IPv4.
Para obter mais informações, consulte [Criação de um cluster do Memcached (console)](Clusters.Create-mc.md#Clusters.Create.CON.Memcached).
## Uso da CLI com Valkey, Memcached ou Redis OSS.
**Redis OSS**
Ao criar um cluster com Valkey ou Redis OSS usando a CLI, você usa o [create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)comando e especifica os parâmetros e: `NetworkType` `IPDiscovery`
Para Linux, macOS ou Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id "cluster-test" \
--engine redis \
--cache-node-type cache.m5.large \
--num-cache-nodes 1 \
--network-type dual_stack \
--ip-discovery ipv4
```
Para Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id "cluster-test" ^
--engine redis ^
--cache-node-type cache.m5.large ^
--num-cache-nodes 1 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
Ao criar um grupo de replicação com o modo de cluster desativado usando a CLI, você usa [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)o comando e especifica `NetworkType` os `IPDiscovery` parâmetros e:
Para Linux, macOS ou Unix:
```
aws elasticache create-replication-group \
--replication-group-id sample-repl-group \
--replication-group-description "demo cluster with replicas" \
--num-cache-clusters 3 \
--primary-cluster-id redis01 \
--network-type dual_stack \
--ip-discovery ipv4
```
Para Windows:
```
aws elasticache create-replication-group ^
--replication-group-id sample-repl-group ^
--replication-group-description "demo cluster with replicas" ^
--num-cache-clusters 3 ^
--primary-cluster-id redis01 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
Ao criar um grupo de replicação com o modo de cluster ativado e usado IPv4 para descoberta de IP usando a CLI, você usa [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)o comando e especifica `NetworkType` os `IPDiscovery` parâmetros e:
Para Linux, macOS ou Unix:
```
aws elasticache create-replication-group \
--replication-group-id demo-cluster \
--replication-group-description "demo cluster" \
--cache-node-type cache.m5.large \
--num-node-groups 2 \
--engine redis \
--cache-subnet-group-name xyz \
--network-type dual_stack \
--ip-discovery ipv4 \
--region us-east-1
```
Para Windows:
```
aws elasticache create-replication-group ^
--replication-group-id demo-cluster ^
--replication-group-description "demo cluster" ^
--cache-node-type cache.m5.large ^
--num-node-groups 2 ^
--engine redis ^
--cache-subnet-group-name xyz ^
--network-type dual_stack ^
--ip-discovery ipv4 ^
--region us-east-1
```
Ao criar um grupo de replicação com o modo de cluster ativado e usado IPv6 para descoberta de IP usando a CLI, você usa [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)o comando e especifica `NetworkType` os `IPDiscovery` parâmetros e:
Para Linux, macOS ou Unix:
```
aws elasticache create-replication-group \
--replication-group-id demo-cluster \
--replication-group-description "demo cluster" \
--cache-node-type cache.m5.large \
--num-node-groups 2 \
--engine redis \
--cache-subnet-group-name xyz \
--network-type dual_stack \
--ip-discovery ipv6 \
--region us-east-1
```
Para Windows:
```
aws elasticache create-replication-group ^
--replication-group-id demo-cluster ^
--replication-group-description "demo cluster" ^
--cache-node-type cache.m5.large ^
--num-node-groups 2 ^
--engine redis ^
--cache-subnet-group-name xyz ^
--network-type dual_stack ^
--ip-discovery ipv6 ^
--region us-east-1
```
**Memcached**
Ao criar um cluster com o Memcached usando a CLI, você usa o [create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)comando e especifica os parâmetros e: `NetworkType` `IPDiscovery`
Para Linux, macOS ou Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id "cluster-test" \
--engine memcached \
--cache-node-type cache.m5.large \
--num-cache-nodes 1 \
--network-type dual_stack \
--ip-discovery ipv4
```
Para Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id "cluster-test" ^
--engine memcached ^
--cache-node-type cache.m5.large ^
--num-cache-nodes 1 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
# Identificar automaticamente nós no seu cluster (Memcached)
Para clusters que executam o mecanismo Memcached, ElastiCache oferece suporte à *descoberta automática* — a capacidade dos programas cliente identificarem automaticamente todos os nós em um cluster e iniciarem e manterem conexões com todos esses nós.
**nota**
A descoberta automática é adicionada para clusters executados no Amazon ElastiCache Memcached. A Descoberta automática não está disponível para mecanismos Valkey ou Redis OSS.
Com a Descoberta automática, seu aplicativo não precisa se conectar manualmente a nós de cache individuais. Em vez disso, seu aplicativo se conecta a um nó Memcached e recupera a lista de nós. Nessa lista, seu aplicativo está ciente do restante dos nós no cluster e pode se conectar a qualquer um deles. Você não precisa embutir em código os endpoints de nó de cache individuais no seu aplicativo.
Se você estiver usando o tipo de rede dual stack em seu cluster, o Auto Discovery retornará somente IPv6 endereços IPv4 ou, dependendo de qual deles você selecionar. Para obter mais informações, consulte [Escolhendo um tipo de rede em ElastiCache](network-type.md).
Todos os nós de cache no cluster mantêm uma lista de metadados sobre todos os outros nós. Esses metadados são atualizados sempre que os nós são adicionados ou removidos do cluster.
**Topics**
+ [Benefícios da descoberta automática com o Memcached](AutoDiscovery.Benefits.md)
+ [Como a Descoberta automática funciona](AutoDiscovery.HowAutoDiscoveryWorks.md)
+ [Como usar a Descoberta automática](AutoDiscovery.Using.md)
+ [Conexão manual aos nós de cache do Memcached](AutoDiscovery.Manual.md)
+ [Adicionar a Descoberta automática à sua biblioteca de clientes do Memcached](AutoDiscovery.AddingToYourClientLibrary.md)
+ [ElastiCache clientes com descoberta automática](Clients.md)
# Benefícios da descoberta automática com o Memcached
Ao usar o Memcached, a descoberta automática oferece os seguintes benefícios:
+ Quando você aumenta o número de nós em um cluster, os novos nós se registram no endpoint da configuração e em todos os outros nós. Quando você remove os nós do cluster de cache, os nós de partida cancelam o registro. Em ambos os casos, todos os outros nós no cluster são atualizados com os metadados do nó de cache mais recentes.
+ As falhas de nós de cache são detectadas automaticamente. Os nós com falha são automaticamente substituídos.
**nota**
Até que a substituição dos nós seja concluída, o nó continuará a falhar.
+ Um programa cliente só precisa se conectar ao endpoint da configuração. Depois disso, a biblioteca da Descoberta automática se conecta a todos os outros nós do cluster.
+ Os programas cliente sondam o cluster uma vez por minuto (esse intervalo pode ser ajustado, se necessário). Se houver alguma alteração na configuração do cluster, como nós novos ou excluídos, o cliente receberá uma lista atualizada de metadados. Em seguida, o cliente se conecta ou desconecta desses nós conforme necessário.
A descoberta automática está ativada em todos os clusters do ElastiCache Memcached. Você não precisa reinicializar nenhum dos seus nós de cache para usar esse recurso.
# Como a Descoberta automática funciona
**Topics**
+ [Conexão com nós de cache](#AutoDiscovery.HowAutoDiscoveryWorks.Connecting)
+ [Operações normais de cluster](#AutoDiscovery.HowAutoDiscoveryWorks.NormalOps)
+ [Outras operações](#AutoDiscovery.HowAutoDiscoveryWorks.OtherOps)
Esta seção descreve como os aplicativos cliente usam o cliente de cluster do ElastiCache para gerenciar conexões de nós de cache e interagir com itens de dados no cache.
## Conexão com nós de cache
Do ponto de vista do aplicativo, conectar-se ao endpoint de configuração de cluster não é diferente de conectar-se diretamente a um nó de cache individual. O diagrama de sequência a seguir mostra o processo de conexão com nós de cache.
![\[Conexão com nós de cache\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/autodiscovery_cluster_membership_refresh-diagram.png)
**Processo de conexão com nós de cache**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/1.png) | O aplicativo resolve o nome DNS do endpoint de configuração. Como o endpoint de configuração mantém entradas CNAME para todos os nós de cache, o nome DNS é resolvido para um dos nós. O cliente pode então se conectar a esse nó. |
| ![\[2\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/2.png) | O cliente solicita as informações de configuração para todos os outros nós. Como cada nó mantém informações de configuração para todos os nós do cluster, qualquer nó pode transmitir informações de configuração ao cliente mediante solicitação. |
| ![\[3\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/3.png) | O cliente recebe a lista atual de nomes de host e endereços IP de nós de cache. Em seguida, ele pode se conectar a todos os outros nós do cluster. |
**nota**
O programa cliente atualiza sua lista de nomes de host e endereços IP de nós de cache uma vez por minuto. Esse intervalo de sondagem pode ser ajustado se necessário.
## Operações normais de cluster
Quando a aplicação estiver conectada a todos os nós de cache, o cliente de cluster do ElastiCache determinará quais nós deverão armazenar os itens de dados individuais e quais nós deverão ser consultados para esses itens de dados mais tarde. O diagrama de sequência a seguir mostra o processo das operações normais de cluster.
![\[Operações normais de cluster\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/autodiscovery_normal_cache_usage-diagram.png)
**Processo das operações normais de cluster**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/1.png) | O aplicativo emite uma solicitação get para um item de dados específico, identificado por sua chave. |
| ![\[2\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/2.png) | O cliente usa um algoritmo de hash contra a chave para determinar qual nó de cache contém o item de dados. |
| ![\[3\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/3.png) | O item de dados é solicitado do nó apropriado. |
| ![\[4\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/4.png) | O item de dados é retornado ao aplicativo. |
## Outras operações
Em algumas situações, você pode alterar os nós de um cluster. Por exemplo, você pode acrescentar um nó adicional para acomodar demanda adicional ou excluir um nó para economizar dinheiro durante períodos de demanda reduzida. Ou você pode substituir um nó devido a uma falha de nó de uma ou outra classificação.
Quando há uma alteração no cluster que requer uma atualização de metadados para os endpoints do cluster, essa alteração é feita em todos os nós ao mesmo tempo. Portanto, os metadados em qualquer nó especificado são consistentes com os metadados em todos os outros nós do cluster.
Em cada um desses casos, os metadados são consistentes entre todos os nós em todos os momentos, já que os metadados são atualizados ao mesmo tempo para todos os nós do cluster. Você sempre deve usar o endpoint de configuração para obter os endpoints dos vários nós no cluster. Ao usar o endpoint de configuração, você garante que não obterá dados de endpoint de um nó que "desaparecerá".
### Adicionar um nó
Durante o tempo em que o nó está sendo configurado, seu endpoint não é incluído nos metadados. Assim que o nó estiver disponível, ele será adicionado aos metadados de cada um dos nós do cluster. Nesse cenário, os metadados são consistentes entre todos os nós, e você poderá interagir com o novo nó somente depois que ele estiver disponível. Antes de o nó estar disponível, você não saberá sobre ele e interagirá com os nós no seu cluster como se o novo nó não existisse.
### Excluir um nó
Quando um nó é removido, seu endpoint é primeiramente removido dos metadados e, em seguida, o nó é removido do cluster. Nesse cenário, os metadados em todos os nós são consistentes e em nenhuma ocasião ele conterá o endpoint para o nó a ser removido se esse nó não estiver disponível. Durante o tempo de remoção do nó, ele não é relatado nos metadados e, portanto, seu aplicativo só interagirá com os n-1 nós restantes, como se o nó não existisse.
### Substituir um nó
Se um nó falhar, o ElastiCache o retirará e configurará uma substituição. O processo de substituição demora alguns minutos. Durante esse tempo, os metadados em todos os nós ainda mostram o endpoint do nó com falha, mas qualquer tentativa de interação com esse nó falhará. Portanto, sua lógica sempre deve incluir uma lógica de nova tentativa.
# Como usar a Descoberta automática
Para começar a usar a Descoberta automática com o ElastiCache para Memcached, siga estas etapas:
+ [Obter o endpoint de configuração](#AutoDiscovery.Using.ConfigEndpoint)
+ [Baixe o cliente de cluster do ElastiCache](#AutoDiscovery.Using.ClusterClient)
+ [Modificar seu programa aplicativo](#AutoDiscovery.Using.ModifyApp)
## Obter o endpoint de configuração
Para se conectar a um cluster, os programas cliente devem conhecer o endpoint de configuração de cluster. Consulte o tópico [Localização de endpoints de um cluster (console) (Memcached)](Endpoints.md#Endpoints.Find.Memcached)
Você também pode usar o comando `aws elasticache describe-cache-clusters` com o parâmetro `--show-cache-node-info`:
Seja qual for o método usado para encontrar os endpoints do cluster, o endpoint de configuração sempre terá **.cfg** em seu endereço.
**Example Localização de endpoints usando a AWS CLI para o ElastiCache**
Para Linux, macOS ou Unix:
```
aws elasticache describe-cache-clusters \
--cache-cluster-id mycluster \
--show-cache-node-info
```
Para Windows:
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id mycluster ^
--show-cache-node-info
```
Esta operação produz uma saída semelhante à seguinte (formato JSON):
```
{
"CacheClusters": [
{
"Engine": "memcached",
"CacheNodes": [
{
"CacheNodeId": "0001",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.0001.use1.cache.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-10-12T21:39:28.001Z",
"CustomerAvailabilityZone": "us-east-1e"
},
{
"CacheNodeId": "0002",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.0002.use1.cache.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-10-12T21:39:28.001Z",
"CustomerAvailabilityZone": "us-east-1a"
}
],
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "mycluster",
"PreferredAvailabilityZone": "Multiple",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-10-12T21:39:28.001Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "available",
"NumCacheNodes": 2,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "sat:06:00-sat:07:00",
"CacheNodeType": "cache.r3.large"
}
]
}
```
## Baixe o cliente de cluster do ElastiCache
Para tirar proveito da Descoberta automática, os programas cliente devem usar o *cliente de cluster do ElastiCache*. O cliente de cluster do ElastiCache está disponível para Java, PHP e .NET e contém toda a lógica necessária para descobrir e conectar-se a todos os seus nós de cache.
**Para baixar o cliente de cluster do ElastiCache**
1. Faça login no Console de Gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No console do ElastiCache, escolha **Cliente de cluster do ElastiCache**, e depois escolha **Baixar**.
O código-fonte do cliente de cluster do ElastiCache para Java está disponível em [https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java). Essa biblioteca se baseia no popular cliente Spymemcached. O cliente de cluster do ElastiCache é lançado sob a Licença de software da Amazon [https://aws.amazon.com/asl](https://aws.amazon.com/asl). Você tem a liberdade de modificar o código-fonte como você bem entender. Você pode até mesmo incorporar o código em outras bibliotecas Memcached de código aberto ou no seu próprio código de cliente.
**nota**
Para usar o cliente de cluster do ElastiCache para PHP, você precisa primeiro instalá-lo na sua instância do Amazon EC2. Para obter mais informações, consulte [Instalação do cliente de cluster do ElastiCache para PHP](Appendix.PHPAutoDiscoverySetup.md).
Para clientes compatíveis com TLS, baixe o binário com PHP versão 7.4 ou superior.
Para usar o cliente de cluster do ElastiCache para .NET, você precisa primeiro instalá-lo na sua instância do Amazon EC2. Para obter mais informações, consulte [Instalação do cliente de cluster do ElastiCache para .NET](Appendix.DotNETAutoDiscoverySetup.md).
## Modificar seu programa aplicativo
Modifique seu programa aplicativo para que ele use a Descoberta automática. As seções a seguir mostram como usar o cliente de cluster do ElastiCache para Java, PHP e .NET.
**Importante**
Ao especificar o endpoint de configuração do cluster, certifique-se de que o endpoint tenha ".cfg" em seu endereço, conforme mostrado aqui. Não use um CNAME ou um endpoint sem ".cfg".
```
"mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
```
Se o endpoint de configuração de cluster não for especificado explicitamente, a configuração ocorrerá para um nó específico.
# Uso do cliente de cluster do ElastiCache para Java
O programa abaixo demonstra como usar o cliente de cluster do ElastiCache para se conectar a um endpoint de configuração de cluster e adicionar um item de dados ao cache. Usando a Descoberta automática, o programa se conecta a todos os nós do cluster sem qualquer intervenção adicional.
```
package com.amazon.elasticache;
import java.io.IOException;
import java.net.InetSocketAddress;
// Import the &AWS;-provided library with Auto Discovery support
import net.spy.memcached.MemcachedClient;
public class AutoDiscoveryDemo {
public static void main(String[] args) throws IOException {
String configEndpoint = "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
Integer clusterPort = 11211;
MemcachedClient client = new MemcachedClient(
new InetSocketAddress(configEndpoint,
clusterPort));
// The client will connect to the other cache nodes automatically.
// Store a data item for an hour.
// The client will decide which cache host will store this item.
client.set("theKey", 3600, "This is the data value");
}
}
```
# Usando o ElastiCache Cluster Client para PHP
O programa abaixo demonstra como usar o ElastiCache Cluster Client para se conectar a um endpoint de configuração de cluster e adicionar um item de dados ao cache. Usando a Descoberta automática, o programa se conectará a todos os nós do cluster sem qualquer intervenção adicional.
Para usar o ElastiCache Cluster Client para PHP, primeiro você precisará instalá-lo na sua EC2 instância da Amazon. Para obter mais informações, consulte [Instalação do cliente de cluster do ElastiCache para PHP](Appendix.PHPAutoDiscoverySetup.md).
```
setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE);
$dynamic_client->addServer($server_endpoint, $server_port);
/**
* Store the data for 60 seconds in the cluster.
* The client will decide which cache host will store this item.
*/
$dynamic_client->set('key', 'value', 60);
/**
* Configuring the client with Static client mode disables the usage of Auto Discovery
* and the client operates as it did before the introduction of Auto Discovery.
* The user can then add a list of server endpoints.
*/
$static_client = new Memcached('persistent-id');
$static_client->setOption(Memcached::OPT_CLIENT_MODE, Memcached::STATIC_CLIENT_MODE);
$static_client->addServer($server_endpoint, $server_port);
/**
* Store the data without expiration.
* The client will decide which cache host will store this item.
*/
$static_client->set('key', 'value');
?>
```
Para ver um exemplo de como usar o ElastiCache Cluster Client com o TLS ativado, consulte [Usando criptografia em trânsito com PHP e Memcached](in-transit-encryption.md#in-transit-encryption-connect-php-mc).
# Uso do cliente de cluster do ElastiCache para .NET
**nota**
O cliente de cluster ElastiCache .NET foi suspenso em maio de 2022.
Ocliente .NET para o ElastiCache é um código aberto que pode se encontrado em [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net).
Em geral, os aplicativos .NET obtém suas configurações de seu arquivo de configuração. O seguinte é um exemplo de arquivo de configuração de aplicativo.
```
```
O programa em C\$1 abaixo demonstra como usar o cliente de cluster do ElastiCache para se conectar a um endpoint de configuração de cluster e adicionar um item de dados ao cache. Usando a Descoberta automática, o programa se conectará a todos os nós do cluster sem qualquer intervenção adicional.
```
// *****************
// Sample C# code to show how to integrate with the Amazon ElastiCcache Auto Discovery feature.
using System;
using Amazon.ElastiCacheCluster;
using Enyim.Caching;
using Enyim.Caching.Memcached;
public class DotNetAutoDiscoveryDemo {
public static void Main(String[] args) {
// instantiate a new client.
ElastiCacheClusterConfig config = new ElastiCacheClusterConfig();
MemcachedClient memClient = new MemcachedClient(config);
// Store the data for 3600 seconds (1hour) in the cluster.
// The client will decide which cache host will store this item.
memClient.Store(StoreMode.Set, 3600, "This is the data value.");
} // end Main
} // end class DotNetAutoDiscoverDemo
```
# Conexão manual aos nós de cache do Memcached
Se o seu programa cliente não usar a descoberta automática, ele poderá se conectar manualmente a cada um dos nós de cache do Memcached. Este é o comportamento padrão para clientes Memcached.
Você pode obter uma lista de nomes de host de nós de cache e números de portas no [Console de Gerenciamento da AWS](https://aws.amazon.com/console/). Você também pode usar o AWS CLI`aws elasticache describe-cache-clusters` comando com o `--show-cache-node-info` parâmetro.
**Example**
O seguinte trecho de código Java mostra como se conectar a todos os nós em um cluster de quatro nós:
```
...
ArrayList cacheNodes = new ArrayList(
Arrays.asList(
"mycachecluster.fnjyzo.0001.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0002.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0003.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0004.use1.cache.amazonaws.com:11211"));
MemcachedClient cache = new MemcachedClient(AddrUtil.getAddresses(cacheNodes));
...
```
**Importante**
Se você expandir ou reduzir seu cluster adicionando ou removendo nós, precisará atualizar a lista de nós no código do cliente.
# Adicionar a Descoberta automática à sua biblioteca de clientes do Memcached
As informações de configuração para Descoberta automática são armazenadas de forma redundante em cada nó de cluster Memcached. Os aplicativos cliente podem consultar qualquer nó de cache e obter as informações de configuração para todos os nós no cluster.
A maneira como um aplicativo faz isso depende da versão do mecanismo de cache:
+ Se a versão do mecanismo de cache for **1.4.14 ou superior**, use o comando `config`.
+ Se a versão do mecanismo de cache for **inferior a 1.4.14**, use o comando `get AmazonElastiCache:cluster`.
As saídas desses dois comandos são idênticas e estão descritas na seção [Output Format](#AutoDiscovery.AddingToYourClientLibrary.OutputFormat) abaixo.
## Versão do mecanismo de cache 1.4.14 ou superior
Para o mecanismo de cache versão 1.4.14 ou superior, use o comando `config`. Esse comando foi adicionado ao Memcached ASCII e aos protocolos binários por ElastiCache, e é implementado no Cluster Client. ElastiCache Se você quiser usar a Descoberta automática com outra biblioteca de cliente, essa biblioteca precisará ser estendida para oferecer suporte ao comando `config`.
**nota**
A seguinte documentação pertence ao protocolo ASCII. No entanto, o comando `config` oferece suporte para ASCII e binário. Se você quiser adicionar suporte à descoberta automática usando o protocolo binário, consulte o [código-fonte do ElastiCache Cluster Client](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java/tree/master/src/main/java/net/spy/memcached/protocol/binary).
**Sintaxe**
`config [sub-command] [key]`
### Opções
| Name (Nome) | Description | Obrigatório |
| --- | --- | --- |
| sub-command | O subcomando usado para interagir com um nó de cache. Para a Descoberta automática, esse subcomando é `get`. | Sim |
| key | A chave na qual a configuração de cluster está armazenada. Para a Descoberta automática, essa chave se chama `cluster`. | Sim |
Para obter as informações de configuração do cluster, use o seguinte comando:
```
config get cluster
```
## Versão do mecanismo de cache 1.4.14 ou inferior
Para obter as informações de configuração do cluster, use o seguinte comando:
```
get AmazonElastiCache:cluster
```
**nota**
Não altere a chave “:clusterAmazonElastiCache”, pois é aqui que residem as informações de configuração do cluster. Se você sobrescrever essa chave, o cliente poderá ser configurado incorretamente por um breve período de tempo (não mais que 15 segundos) antes de atualizar ElastiCache automaticamente e corretamente as informações de configuração.
## Output Format
Se você usar `config get cluster` ou `get AmazonElastiCache:cluster`, a resposta consistirá em duas linhas:
+ O número de versão das informações de configuração. Cada vez que um nó é adicionado ou removido do cluster, o número da versão aumenta em um.
+ Uma lista de nós de cache. Cada nó na lista é representado por um grupo de *nome do host\$1endereço IP\$1porta*, e cada nó é delimitado por um espaço.
Um retorno de carro e um caractere de avanço de linha (CR \$1 LF) aparecem no final de cada linha. A linha de dados contém um caractere de avanço de linha (LF) no final, ao qual o CR\$1LF é adicionado. A linha de versão de configuração é encerrada por LF sem o CR.
Um cluster contendo três nós seria representado da seguinte maneira:
```
configversion\n
hostname|ip-address|port hostname|ip-address|port hostname|ip-address|port\n\r\n
```
Cada nó é mostrado com o CNAME e o endereço IP privado. O CNAME sempre estará presente. Se o endereço IP privado não estiver disponível, ele não será mostrado. Entretanto, os caracteres de barra vertical "`|`" continuarão a ser impressos.
**Example**
Veja a seguir um exemplo da carga útil retornada quando você consulta as informações de configuração:
```
CONFIG cluster 0 136\r\n
12\n
myCluster.pc4ldq.0001.use1.cache.amazonaws.com|10.82.235.120|11211 myCluster.pc4ldq.0002.use1.cache.amazonaws.com|10.80.249.27|11211\n\r\n
END\r\n
```
**nota**
A segunda linha indica que as informações de configuração foram modificadas doze vezes até agora.
Na terceira linha, a lista de nós está em ordem alfabética por nome de host. Essa ordem pode estar em uma sequência diferente da que você está usando no seu aplicativo cliente.
# ElastiCache clientes com descoberta automática
Os programas cliente de cluster podem identificar e se conectar automaticamente a todos os nós de cluster que executem o mecanismo Memcached.
Esta seção discute a instalação e a configuração dos clientes ElastiCache PHP e .NET para uso com descoberta automática.
**Topics**
+ [Instalação e compilação de clientes de cluster](Appendix.InstallingClients.md)
+ [Configuração do ElastiCache](ClientConfig.md)
# Instalação e compilação de clientes de cluster
Esta seção discute a instalação, a configuração e a compilação dos clientes de cluster de descoberta automática PHP e .NET do Amazon ElastiCache.
**Topics**
+ [Instalação do cliente de cluster do ElastiCache para .NET](Appendix.DotNETAutoDiscoverySetup.md)
+ [Instalação do cliente de cluster do ElastiCache para PHP](Appendix.PHPAutoDiscoverySetup.md)
+ [Compilação do código-fonte para o cliente de cluster do ElastiCache para PHP](Appendix.PHPAutoDiscoveryCompile.md)
# Instalação do cliente de cluster do ElastiCache para .NET
Você pode encontrar o código do cliente de cluster .NET do ElastiCache como código aberto em [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net).
Esta seção descreve como instalar, atualizar e remover os componentes .NET do cliente de cluster do ElastiCache em instâncias do Amazon EC2. Para obter mais informações sobre a descoberta automática, consulte [Identificar automaticamente nós no seu cluster (Memcached)](AutoDiscovery.md). Para obter o código de exemplo do .NET para usar o cliente, consulte [Uso do cliente de cluster do ElastiCache para .NET](AutoDiscovery.Using.ModifyApp.DotNET.md).
**Topics**
+ [Instalar o .NET](#Appendix.DotNETAutoDiscoverySetup.DotNET)
+ [Baixar o cliente de cluster .NET do ElastiCache para ElastiCache](#Appendix.DotNETAutoDiscoverySetup.Downloading)
+ [Instalar conjuntos da AWS com o NuGet](#Appendix.DotNETAutoDiscoverySetup.Installing)
## Instalar o .NET
Você deve ter o .NET 3.5 ou posterior instalado para usar o SDK .NET da AWS para ElastiCache. Caso não tenha o .NET 3.5 ou posterior, pode fazer download e instalar a versão mais recente em [http://www.microsoft.com/net](http://www.microsoft.com/net).
## Baixar o cliente de cluster .NET do ElastiCache para ElastiCache
**Para baixar o cliente de cluster .NET do ElastiCache**
1. Faça login no Console de gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel de navegação, clique em **ElastiCache Cluster Client**.
1. Na lista **Download ElastiCache Memcached Cluster Client**, selecione **.NET** e clique em **Download.**
## Instalar conjuntos da AWS com o NuGet
O NuGet é um sistema de gerenciamento de pacotes para a plataforma .NET. O NuGet está ciente das dependências de assembly e instala todos os arquivos necessários automaticamente. Os assemblies instalados pelo NuGet são armazenados com a sua solução, em vez de em uma localização central, como em `Program Files`, e, por isso, você pode instalar versões específicas para um aplicativo sem criar problemas de compatibilidade.
### Instalar o NuGet
O NuGet pode ser instalado da galeria de instalação no MSDN; consulte [https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c](https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c). Se você estiver usando o Visual Studio 2010 ou posterior, o NuGet será instalado automaticamente.
Você pode usar o NuGet no **Gerenciador de Soluções** ou no **Console do Gerenciador de Pacotes**.
### Usar o NuGet no Gerenciador de Soluções
**Para usar o NuGet no Gerenciador de Soluções do Visual Studio 2010**
1. No menu **Ferramentas**, selecione **Gerenciador de Pacotes de Biblioteca**.
1. Clique em **Console do Gerenciador de Pacotes**.
**Para usar o NuGet no Solution Explorer do Visual Studio 2012 ou Visual Studio 2013**
1. No menu **Ferramentas**, selecione **Gerenciador de Pacotes NuGet**.
1. Clique em **Console do Gerenciador de Pacotes**.
Na linha de comando, você pode instalar os assemblies usando `Install-Package`, conforme mostrado a seguir.
```
Install-Package Amazon.ElastiCacheCluster
```
Para ver uma página de cada pacote disponível via NuGet, como os conjuntos SDK da AWS e extensões da AWS, consulte o site do NuGet em [http://www.nuget.org](http://www.nuget.org). A página de cada pacote inclui uma linha de comando de amostra para instalar o pacote usando o console e uma lista das versões anteriores desse pacote que estão disponíveis no NuGet.
Para obter mais informações sobre os comandos do **Console do Gerenciador de Pacotes**, consulte [http://nuget.codeplex.com/wikipage?title=Package%20Manager%20Console%20Command%20Reference%20%28v1.3%29](http://nuget.codeplex.com/wikipage?title=Package%20Manager%20Console%20Command%20Reference%20%28v1.3%29).
# Instalação do cliente de cluster do ElastiCache para PHP
Esta seção descreve como instalar, atualizar e remover os componentes de PHP do cliente de cluster do ElastiCache em instâncias do Amazon EC2. Para obter mais informações sobre a descoberta automática, consulte [Identificar automaticamente nós no seu cluster (Memcached)](AutoDiscovery.md). Para obter o código de exemplo do PHP para usar o cliente, consulte [Usando o ElastiCache Cluster Client para PHP](AutoDiscovery.Using.ModifyApp.PHP.md).
**Topics**
+ [Para baixar o pacote de instalação](Appendix.PHPAutoDiscoverySetup.Downloading.md)
+ [Para usuários que já possuam a extensão *php-memcached* instalada](#Appendix.PHPAutoDiscoverySetup.InstallingExisting)
+ [Etapas de instalação para novos usuários](Appendix.PHPAutoDiscoverySetup.Installing.md)
+ [Remoção do cliente de cluster PHP](Appendix.PHPAutoDiscoverySetup.Removing.md)
# Para baixar o pacote de instalação
Para garantir que está usando a versão correta do cliente de cluster do ElastiCache para PHP, você precisa saber qual versão do PHP está instalada na sua instância do Amazon EC2. Você também precisará saber se a sua instância do Amazon EC2 está executando uma versão de 64 bits ou 32 bits do Linux.
**Para determinar a versão do PHP instalada na sua instância do Amazon EC2**
+ No prompt de comando, execute o seguinte comando:
```
php -v
```
A versão do PHP será mostrada na saída, como neste exemplo:
```
PHP 5.4.10 (cli) (built: Jan 11 2013 14:48:57)
Copyright (c) 1997-2012 The PHP Group
Zend Engine v2.4.0, Copyright (c) 1998-2012 Zend Technologies
```
**nota**
Se suas versões do PHP e do Memcached forem incompatíveis, você receberá uma mensagem de erro como a seguinte:
```
PHP Warning: PHP Startup: memcached: Unable to initialize module
Module compiled with module API=20100525
PHP compiled with module API=20131226
These options need to match
in Unknown on line 0
```
Se isso acontecer, será necessário compilar o módulo do código-fonte. Para obter mais informações, consulte [Compilação do código-fonte para o cliente de cluster do ElastiCache para PHP](Appendix.PHPAutoDiscoveryCompile.md).
**Para determinar a sua arquitetura de AMI do Amazon EC2 (64 bits ou 32 bits)**
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. Na lista **Instances** (Instâncias), clique na sua instância do Amazon EC2.
1. Na guia **Description**, procure o campo **AMI:**. Uma instância de 64 bits deve ter `x86_64` como parte da descrição. Para uma instância de 32 bits, procure `i386` ou `i686` neste campo.
Agora, você está pronto para baixar o cliente de cluster do ElastiCache.
**Para baixar o cliente de cluster do ElastiCache para PHP**
1. Faça login no Console de gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No console do ElastiCache, escolha **ElastiCache Cluster Client** (Cliente de cluster do ElastiCache.
1. Na lista **Download ElastiCache Memcached Cluster Client** (Baixar cliente de cluster Memcached do ElastiCache), escolha o cliente de cluster do ElastiCache que corresponda à sua versão do PHP e arquitetura da AMI e depois escolha o botão **Download** (Baixar).
## Para usuários que já possuam a extensão *php-memcached* instalada
**Para atualizar a instalação do `php-memcached`**
1. Remova a instalação anterior da extensão Memcached para PHP, conforme descrito pelo tópico [Remoção do cliente de cluster PHP](Appendix.PHPAutoDiscoverySetup.Removing.md).
1. Instale a nova extensão `php-memcached` do ElastiCache conforme descrito anteriormente em [Etapas de instalação para novos usuários](Appendix.PHPAutoDiscoverySetup.Installing.md).
# Etapas de instalação para novos usuários
**Topics**
+ [Instalação do PHP 7.x para novos usuários](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x)
+ [Instalação do PHP 5.x para novos usuários](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x)
## Instalação do PHP 7.x para novos usuários
**Topics**
+ [Para instalar o PHP 7 em uma AMI Ubuntu Server 14.04 LTS (64 bits e 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.Ubuntu)
+ [Para instalar o PHP 7 em uma AMI Amazon Linux 201609](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.AmznLinux)
+ [Para instalar o PHP 7 em uma AMI SUSE Linux](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.SuseLinux)
### Para instalar o PHP 7 em uma AMI Ubuntu Server 14.04 LTS (64 bits e 32 bits)
1. Execute uma nova instância a partir da AMI.
1. Execute os seguintes comandos:
```
sudo apt-get update
sudo apt-get install gcc g++
```
1. Instale o PHP 7.
```
sudo yum install php70
```
1. Baixe o cliente de cluster do Amazon ElastiCache.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Extraia `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Com permissões de root, copie o arquivo de artefato extraído `amazon-elasticache-cluster-client.so` para `/usr/lib/php/20151012`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib/php/20151012
```
1. Insira a linha `extension=amazon-elasticache-cluster-client.so` no arquivo `/etc/php/7.0/cli/php.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php/7.0/cli/php.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar o PHP 7 em uma AMI Amazon Linux 201609
1. Execute uma nova instância a partir da AMI.
1. Execute o seguinte comando:
```
sudo yum install gcc-c++
```
1. Instale o PHP 7.
```
sudo yum install php70
```
1. Baixe o cliente de cluster do Amazon ElastiCache.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Extraia `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Com permissão de root, copie o arquivo de artefato extraído `amazon-elasticache-cluster-client.so` para `/usr/lib64/php/7.0/modules/`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php/7.0/modules/
```
1. Crie o arquivo `50-memcached.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php-7.0.d/50-memcached.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar o PHP 7 em uma AMI SUSE Linux
1. Execute uma nova instância a partir da AMI.
1. Execute o seguinte comando:
```
sudo zypper install gcc
```
1. Instale o PHP 7.
```
sudo yum install php70
```
1. Baixe o cliente de cluster do Amazon ElastiCache.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Extraia `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Com permissão de root, copie o arquivo de artefato extraído `amazon-elasticache-cluster-client.so` para `/usr/lib64/php7/extensions/`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php7/extensions/
```
1. Insira a linha `extension=amazon-elasticache-cluster-client.so` no arquivo `/etc/php7/cli/php.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php7/cli/php.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
## Instalação do PHP 5.x para novos usuários
**Topics**
+ [Para instalar o PHP 5 em uma AMI Amazon Linux 2014.03 (64 bits e 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.AmznLinux)
+ [Para instalar o PHP 5 em uma AMI Red Hat Enterprise Linux 7.0 (64 bits e 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.RHEL)
+ [Para instalar o PHP 5 em uma AMI Ubuntu Server 14.04 LTS (64 bits e 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Ubuntu)
+ [Para instalar o PHP 5 para a AMI SUSE Linux Enterprise Server 11 (64 bits ou 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.SuseLinux)
+ [Outras distribuições do Linux](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Other)
### Para instalar o PHP 5 em uma AMI Amazon Linux 2014.03 (64 bits e 32 bits)
1. Inicie uma instância do Amazon Linux (64 bits ou 32 bits) e faça login nela.
1. Instalar dependências PHP:
```
sudo yum install gcc-c++ php php-pear
```
1. Baixe o pacote `php-memcached` correto para sua instância do Amazon EC2 e versão do PHP. Para obter mais informações, consulte [Para baixar o pacote de instalação](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Instalar o `php-memcached`. O URI deve ser o caminho de download para o pacote de instalação:
```
sudo pecl install
```
Veja a seguir um exemplo de comando de instalação para o PHP 5.4, Linux de 64 bits. Nessa amostra, substitua *X.Y.Z* pelo número de versão atual:
```
sudo pecl install /home/AmazonElastiCacheClusterClient-X.Y.Z-PHP54-64bit.tgz
```
**nota**
Use a versão recente do artefato de instalação.
1. Com a permissão root/sudo, adicione um novo arquivo denominado `memcached.ini` no diretório `/etc/php.d` e insira "extension=amazon-elasticache-cluster-client.so" no arquivo:
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar o PHP 5 em uma AMI Red Hat Enterprise Linux 7.0 (64 bits e 32 bits)
1. Execute uma instância do Red Hat Enterprise Linux (64 bits ou 32 bits) e faça login nela.
1. Instalar dependências PHP:
```
sudo yum install gcc-c++ php php-pear
```
1. Baixe o pacote `php-memcached` correto para sua instância do Amazon EC2 e versão do PHP. Para obter mais informações, consulte [Para baixar o pacote de instalação](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Instalar o `php-memcached`. O URI deve ser o caminho de download para o pacote de instalação:
```
sudo pecl install
```
1. Com a permissão root/sudo, adicione um novo arquivo denominado `memcached.ini` no diretório `/etc/php.d` e insira `extension=amazon-elasticache-cluster-client.so` no arquivo.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar o PHP 5 em uma AMI Ubuntu Server 14.04 LTS (64 bits e 32 bits)
1. Inicie uma instância do Ubuntu Linux (64 bits ou 32 bits) e faça login nela.
1. Instalar dependências PHP:
```
sudo apt-get update
sudo apt-get install gcc g++ php5 php-pear
```
1. Baixe o pacote `php-memcached` correto para sua instância do Amazon EC2 e versão do PHP. Para obter mais informações, consulte [Para baixar o pacote de instalação](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Instalar o `php-memcached`. O URI deve ser o caminho de download para o pacote de instalação.
```
sudo pecl install
```
**nota**
Essa etapa de instalação instala o artefato de build `amazon-elasticache-cluster-client.so` no diretório `/usr/lib/php5/20121212*`. Verifique o caminho absoluto do artefato de build, porque você precisa dele na próxima etapa.
Se o comando anterior não funcionar, você precisará extrair manualmente o artefato de cliente PHP `amazon-elasticache-cluster-client.so` do arquivo `*.tgz` obtido por download e copiá-lo para o diretório `/usr/lib/php5/20121212*`.
```
tar -xvf
cp amazon-elasticache-cluster-client.so /usr/lib/php5/20121212/
```
1. Com a permissão root/sudo, adicione um novo arquivo denominado `memcached.ini` no diretório `/etc/php5/cli/conf.d` e insira "extension=" no arquivo.
```
echo "extension=" | sudo tee --append /etc/php5/cli/conf.d/memcached.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar o PHP 5 para a AMI SUSE Linux Enterprise Server 11 (64 bits ou 32 bits)
1. Inicie uma instância do SUSE Linux (64 bits ou 32 bits) e faça login nela.
1. Instalar dependências PHP:
```
sudo zypper install gcc php53-devel
```
1. Baixe o pacote `php-memcached` correto para sua instância do Amazon EC2 e versão do PHP. Para obter mais informações, consulte [Para baixar o pacote de instalação](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Instalar o `php-memcached`. O URI deve ser o caminho de download para o pacote de instalação.
```
sudo pecl install
```
1. Com a permissão root/sudo, adicione um novo arquivo denominado `memcached.ini` no diretório `/etc/php5/conf.d` e insira **extension=`amazon-elasticache-cluster-client.so`** no arquivo.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php5/conf.d/memcached.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
**nota**
Se a Etapa 5 não funcionar para nenhuma das plataformas anteriores, verifique o caminho de instalação para `amazon-elasticache-cluster-client.so`. Além disso, especifique o caminho completo do binário da extensão. Além disso, verifique se o PHP em uso é uma versão com suporte. Oferecemos suporte às versões 5.3 a 5.5.
### Outras distribuições do Linux
Em alguns sistemas, especialmente o CentOS7 e o Red Hat Enterprise Linux (RHEL) 7.1, `libsasl2.so.3` substituiu `libsasl2.so.2`. Nesses sistemas, quando você carrega o cliente de cluster ElastiCache, ele tenta e não consegue localizar e carregar `libsasl2.so.2`. Para resolver esse problema, crie um link simbólico para `libsasl2.so.3`, de forma que, quando o cliente tentar carregar libsasl2.so.2, ele seja redirecionado para `libsasl2.so.3`. O código a seguir cria esse link simbólico.
```
cd /usr/lib64
sudo ln libsasl2.so.3 libsasl2.so.2
```
# Remoção do cliente de cluster PHP
**Topics**
+ [Remover uma versão anterior do PHP 7](#Appendix.PHPAutoDiscoverySetup.Removing.PHP7x)
+ [Remover uma versão anterior do PHP 5](#Appendix.PHPAutoDiscoverySetup.Removing.PHP5x)
## Remover uma versão anterior do PHP 7
**Para remover uma versão anterior do PHP 7**
1. Remova o arquivo `amazon-elasticache-cluster-client.so` do diretório lib PHP apropriado, conforme indicado anteriormente nas instruções de instalação. Consulte a seção para a sua instalação em [Para usuários que já possuam a extensão *php-memcached* instalada](Appendix.PHPAutoDiscoverySetup.md#Appendix.PHPAutoDiscoverySetup.InstallingExisting).
1. Remova a linha `extension=amazon-elasticache-cluster-client.so` do arquivo `php.ini`.
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
## Remover uma versão anterior do PHP 5
**Para remover uma versão anterior do PHP 5**
1. Remova a extensão `php-memcached`:
```
sudo pecl uninstall __uri/AmazonElastiCacheClusterClient
```
1. Remova o arquivo `memcached.ini` adicionado no diretório apropriado, conforme indicado nas etapas de instalação anteriores.
# Compilação do código-fonte para o cliente de cluster do ElastiCache para PHP
Esta seção discute como obter e compilar o código-fonte do cliente de cluster do ElastiCache para PHP.
Existem dois pacotes que você precisa extrair do GitHub e compilar; [aws-elasticache-cluster-client-libmemcached](https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached) e [aws-elasticache-cluster-client-memcached-for-php](https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php).
**Topics**
+ [Compilação da biblioteca libmemcached](#Appendix.PHPAutoDiscoveryCompile.Libmemcached)
+ [Compilação do cliente de descoberta automática do Memcached do ElastiCache para PHP](#Appendix.PHPAutoDiscoveryCompile.Client)
## Compilação da biblioteca libmemcached
**Para compilar a biblioteca aws-elasticache-cluster-client-libmemcached**
1. Iniciar uma instância do Amazon EC2.
1. Instale as dependências da biblioteca.
+ Na AMI Amazon Linux 201509
```
sudo yum install gcc gcc-c++ autoconf libevent-devel
```
+ Na AMI Ubuntu 14.04
```
sudo apt-get update
sudo apt-get install libevent-dev gcc g++ make autoconf libsasl2-dev
```
1. Extraia o repositório e compile o código.
```
Download and install [ https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached/archive/v1.0.18.tar.gz]( https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached/archive/v1.0.18.tar.gz)
```
## Compilação do cliente de descoberta automática do Memcached do ElastiCache para PHP
As seções a seguir descrevem como compilar o cliente de descoberta automática do Memcached do ElastiCache
**Topics**
+ [Compilação do cliente do Memcached do ElastiCache para PHP 7](#Appendix.PHPAudiscoveryCompile.Client.PHP7)
+ [Compilação do cliente do Memcached do ElastiCache para PHP 5](#Appendix.PHPAudiscoveryCompile.PHP5)
### Compilação do cliente do Memcached do ElastiCache para PHP 7
Execute o seguinte conjunto de comandos no diretório de código.
```
git clone https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php.git
cd aws-elasticache-cluster-client-memcached-for-php
git checkout php7
sudo yum install php70-devel
phpize
./configure --with-libmemcached-dir= --disable-memcached-sasl
make
make install
```
**nota**
Você pode vincular estaticamente a biblioteca libmemcached ao binário PHP para que ele possa ser compatibilizado em várias plataformas Linux. Para fazer isso, execute o seguinte comando antes de `make`:
```
sed -i "s#-lmemcached#/lib/libmemcached.a -lcrypt -lpthread -lm -lstdc++ -lsasl2#" Makefile
```
### Compilação do cliente do Memcached do ElastiCache para PHP 5
Compile o `aws-elasticache-cluster-client-memcached-for-php` executando os seguintes comandos na pasta `aws-elasticache-cluster-client-memcached-for-php/`.
```
git clone https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php.git
cd aws-elasticache-cluster-client-memcached-for-php
sudo yum install zlib-devel
phpize
./configure --with-libmemcached-dir=
make
make install
```
# Configuração do ElastiCache
Um cluster do ElastiCache tem conformidade de protocolo com o Valkey, Memcached e Redis OSS. O código, aplicações e as ferramentas mais populares que você usa hoje com seu ambiente existente funcionarão perfeitamente com o serviço.
Esta seção discute considerações específicas para se conectar a nós de cache no ElastiCache.
**Topics**
+ [Comandos restritos](ClientConfig.RestrictedCommands.md)
+ [Localização de endpoints de nó e números de porta](ClientConfig.FindingEndpointsAndPorts.md)
+ [Conexão para uso da descoberta automática](ClientConfig.AutoDiscovery.md)
+ [Conexão a nós em um cluster Valkey ou Redis OSS](ClientConfig.ReplicationGroup.md)
+ [Nomes de DNS e IP subjacente](ClientConfig.DNS.md)
# Comandos restritos
Para oferecer uma experiência de serviço gerenciado, ElastiCache restringe o acesso a determinados comandos específicos do mecanismo de cache que exigem privilégios avançados. Para clusters executando o Redis OSS, os seguintes comandos não estão disponíveis:
+ `bgrewriteaof`
+ `bgsave`
+ `config`
+ `debug`
+ `migrate`
+ `replicaof`
+ `save`
+ `slaveof`
+ `shutdown`
+ `sync`
# Localização de endpoints de nó e números de porta
Para se conectar a um nó de cache, seu aplicativo precisa conhecer o endpoint e o número da porta desse nó.
## Localização de endpoints de nó e números de porta (console)
**Para determinar os endpoints do nó e os números de porta**
1. Faça login no [ Console de Gerenciamento do Amazon ElastiCache](https://aws.amazon.com/elasticache) e escolha o mecanismo em execução no seu cluster.
É exibida uma lista de todos os clusters que executam o mecanismo escolhido.
1. Continue abaixo para o mecanismo e a configuração que você está executando.
1. Escolha o nome do cluster de interesse.
1. Localize as colunas **Port** e **Endpoint** para o nó em que você está interessado.
## Localização de endpoints de nó de cache e números de porta (AWS CLI)
Para determinar endpoints de nó de cache e números de porta, use o comando `describe-cache-clusters` com o parâmetro `--show-cache-node-info`.
```
aws elasticache describe-cache-clusters --show-cache-node-info
```
Os nomes DNS e números de porta totalmente qualificados estão na seção Endpoint da saída.
## Localização de endpoints de nó de cache e números de porta (API do ElastiCache)
Para determinar endpoints de nó de cache e números de porta, use a ação `DescribeCacheClusters` com o parâmetro `ShowCacheNodeInfo=true`.
**Example**
```
1. https://elasticache.us-west-2.amazonaws.com /
2. ?Action=DescribeCacheClusters
3. &ShowCacheNodeInfo=true
4. &SignatureVersion=4
5. &SignatureMethod=HmacSHA256
6. &Timestamp=20140421T220302Z
7. &Version=2014-09-30
8. &X-Amz-Algorithm=&AWS;4-HMAC-SHA256
9. &X-Amz-Credential=
10. &X-Amz-Date=20140421T220302Z
11. &X-Amz-Expires=20140421T220302Z
12. &X-Amz-Signature=
13. &X-Amz-SignedHeaders=Host
```
# Conexão para uso da descoberta automática
Se os seus aplicativos usam a Descoberta automática, você só precisa conhecer o endpoint de configuração do cluster, e não os endpoints individuais de cada nó de cache. Para obter mais informações, consulte [Identificar automaticamente nós no seu cluster (Memcached)](AutoDiscovery.md).
**nota**
Neste momento, a Descoberta automática só está disponível para clusters executando o Memcached.
# Conexão a nós em um cluster Valkey ou Redis OSS
**nota**
Neste momento, os clusters (API/CLI: grupos de replicação) que oferecem suporte para replicação e réplicas de leitura têm suporte apenas para clusters que executam o Valkey ou o Redis OSS.
Para clusters, o ElastiCache fornece interfaces de console, CLI e API para informações de conexão de nós individuais.
Para atividades somente leitura, os aplicativos podem se conectar a qualquer nó no cluster. No entanto, para a atividade de gravação, recomendamos que suas aplicações se conectem ao endpoint primário (Valkey ou Redis OSS (modo cluster desabilitado)) ou ao endpoint de configuração (Valkey ou Redis OSS (modo cluster habilitado)) do cluster em vez de se conectarem diretamente a um nó. Isso garantirá que seus aplicativos sempre possam localizar o nó correto, mesmo que você decida reconfigurar seu cluster promovendo uma réplica de leitura para a função primária.
## Conexão a clusters em um grupo de replicação (console)
**Para determinar endpoints e números de porta**
+ Consulte o tópico, [Localização de endpoints de um cluster do Valkey ou do Redis OSS (modo cluster desabilitado) (console)](Endpoints.md#Endpoints.Find.Redis).
## Conexão a clusters em um grupo de replicação (AWS CLI)
**Para determinar endpoints de nó de cache e números de porta**
Use o comando `describe-replication-groups` com o nome do seu grupo de replicação:
```
aws elasticache describe-replication-groups redis2x2
```
Esse comando deve produzir um resultado semelhante ao seguinte:
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "2 shards, 2 nodes (1 + 1 replica)",
"NodeGroups": [
{
"Status": "available",
"Slots": "0-8191",
"NodeGroupId": "0001",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0001-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0001-002"
}
]
},
{
"Status": "available",
"Slots": "8192-16383",
"NodeGroupId": "0002",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0002-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0002-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "redis2x2.9dcv5r.clustercfg.usw2.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "redis2x2",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "13:00-14:00",
"MemberClusters": [
"redis2x2-0001-001",
"redis2x2-0001-002",
"redis2x2-0002-001",
"redis2x2-0002-002"
],
"CacheNodeType": "cache.m3.medium",
"PendingModifiedValues": {}
}
]
}
```
## Conexão a clusters em um grupo de replicação (API do ElastiCache)
**Para determinar endpoints de nó de cache e números de porta**
Chame `DescribeReplicationGroups` com o seguinte parâmetro:
`ReplicationGroupId` = o nome do seu grupo de replicação.
**Example**
```
1. https://elasticache.us-west-2.amazonaws.com /
2. ?Action=DescribeCacheClusters
3. &ReplicationGroupId=repgroup01
4. &Version=2014-09-30
5. &SignatureVersion=4
6. &SignatureMethod=HmacSHA256
7. &Timestamp=20140421T220302Z
8. &X-Amz-Algorithm=&AWS;4-HMAC-SHA256
9. &X-Amz-Date=20140421T220302Z
10. &X-Amz-SignedHeaders=Host
11. &X-Amz-Expires=20140421T220302Z
12. &X-Amz-Credential=
13. &X-Amz-Signature=
```
# Nomes de DNS e IP subjacente
Os clientes mantêm uma lista de servidores contendo os endereços e as portas dos servidores que possuem os dados do cache. Ao usar o ElastiCache, a API DescribeCacheClusters (ou o utilitário de linha de comando describe-cache-clusters) retorna uma entrada DNS totalmente qualificada e um número de porta que podem ser usados para a lista de servidores.
**Importante**
É importante que os aplicativos do cliente estejam configurados para resolver frequentemente os nomes DNS dos nós de cache quando eles tentam se conectar a um endpoint do nó de cache.
O ElastiCache garante que o nome DNS dos nós de cache permaneçam os mesmos quando os nós de cache forem recuperados em caso de falha.
A maioria das bibliotecas de cliente oferece suporte para conexões persistentes de nó de cache por padrão. Recomendamos o uso de conexões de nó de cache persistentes ao usar o ElastiCache. O armazenamento em cache de DNS no lado do cliente pode ocorrer em vários locais, incluindo bibliotecas de clientes, runtime da linguagem ou sistema operacional do cliente. Você deve revisar a configuração do seu aplicativo em cada camada para garantir que esteja resolvendo os endereços IP frequentemente para seus nós de cache.
# Classificação de dados em níveis no ElastiCache
Os clusters do ElastiCache para Valkey ou Redis OSS que compõem um grupo de replicação e usam um tipo de nó da família r6gd têm seus dados classificados em níveis entre a memória e o armazenamento SSD (unidades de estado sólido) local. A classificação de dados em níveis fornece uma nova opção de performance de preço para workloads do Valkey ou Redis OSS ao utilizar unidades de estado sólido (SSDs) de menor custo em cada nó de cluster, além de armazenar dados na memória. Essa modalidade é 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 do ElastiCache com classificação de dados em níveis, o ElastiCache monitora o último horário de acesso de cada item armazenado. Quando a memória disponível (DRAM) é totalmente consumida, o ElastiCache usa um algoritmo Least-Recently Used (LRU – Usado menos recentemente) 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 ElastiCache 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, presumindo valores de string de 500 bytes, você pode esperar uma média de mais 300 microssegundos de latência para solicitações de dados armazenados em SSD em comparação com solicitações de dados em memória.
Com o maior tamanho de nó de classificação de dados em níveis (cache.r6gd.16xlarge), você pode armazenar até 1 petabyte em um só cluster de 500 nós (500 TB ao usar 1 réplica de leitura). A classificação de dados em níveis é compatível com todos os comandos e estruturas de dados do Valkey ou Redis OSS compatíveis com o ElastiCache. Para usar esse recurso, não é necessário promover alterações no lado do cliente.
**Topics**
+ [Práticas recomendadas](#data-tiering-best-practices)
+ [Limitações](#data-tiering-prerequisites)
+ [Preços](#data-tiering-pricing)
+ [Monitoramento](#data-tiering-monitoring)
+ [Como usar a classificação de dados em níveis](#data-tiering-enabling)
+ [Como restaurar dados do backup para clusters com a classificação de dados em níveis ativada](#data-tiering-enabling-snapshots)
## 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. 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.
## Limitações
A classificação de dados em níveis tem as seguintes limitações:
+ Você só pode usar a classificação de dados em níveis em clusters que fazem parte de um grupo de replicação.
+ 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-central-1`, `eu-north-1`, `eu-west-3`, `ap-northeast-1`, `ap-southeast-1`, `ap-southeast-2`, `ap-south-1`, `ca-central-1` e `sa-east-1`.
+ Você deve usar um mecanismo que seja Valkey 7.2 ou posterior, ou um Redis OSS 6.2 ou posterior.
+ Você não pode restaurar um backup de um cluster r6gd para outro cluster, a menos que ele também use r6gd.
+ Você não pode exportar um backup para o Amazon S3 para clusters de classificação de dados em níveis.
+ Não há compatibilidade para migração online com clusters em execução no tipo de nó r6gd.
+ 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). Para obter mais informações, consulte [Dimensionamento ElastiCache](Scaling.md).
+ O ajuste de escala automático é aceito em clusters que usam classificação de dados em níveis para Valkey versão 7.2 e posteriores e Redis OSS versão 7.0.7 e posteriores. Para obter mais informações, consulte . [Auto Scaling de clusters Valkey e Redis OSS](AutoScaling.md)
+ A divisão de dados em camadas só são compatíveis com as políticas `volatile-lru`, `allkeys-lru`, `volatile-lfu`, `allkeys-lfu` e `noeviction`.
+ A gravação sem bifurcação é compatível com o Valkey versão 7.2 e posteriores, e com o Redis OSS versão 7.0.7 e posteriores. Para obter mais informações, consulte [Como a sincronização e o backup são implementados](Replication.Redis.Versions.md).
+ Itens maiores que 128 MiB não são movidos para o SSD.
+ A partir do Valkey 8.1 e versões posteriores, um item cujo tamanho de chave\$1valor seja menor que 40 bytes não será movido para o SSD.
## Preços
Os nós R6gd têm 4,8x mais capacidade total (memória \$1 SSD) e podem ajudar você a obter mais de 60% de economia para execução com utilização máxima em comparação aos nós R6g (somente memória). Para mais informações, consulte [Preços do Amazon ElastiCache](https://aws.amazon.com/elasticache/pricing/).
## Monitoramento
O ElastiCache oferece métricas especificamente projetadas para monitorar os clusters de performance 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 `CurrItems` em [Métricas para Valkey e Redis OSS](CacheMetrics.Redis.md). É possível calcular a porcentagem como: *(CurrItems com dimensão: Nível = Memória \$1 100) / (CurrItems sem filtro de dimensão)*.
Se a política de remoção configurada permitir, o ElastiCache 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 é recomendável que você considere aumentar a escala horizontalmente para clusters de modo cluster habilitado ou aumentar a escala verticalmente para clusters de modo cluster desabilitado quando a porcentagem de itens na memória cair abaixo de 5%. Para obter mais informações sobre a escalabilidade, consulte [Escalabilidade de clusters no Valkey ou Redis OSS (modo cluster habilitado)](scaling-redis-cluster-mode-enabled.md). Para obter mais informações sobre métricas para clusters do Valkey ou Redis OSS que usam a classificação de dados em níveis, consulte [Métricas para o Valkey e Redis OSS](CacheMetrics.Redis.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 como parte de um grupo de replicação, você usa a classificação de dados em níveis selecionando um tipo de nó da família r6gd, p. ex., *cache.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 [Criação de um cluster do Valkey ou Redis OSS](Clusters.Create.md).
### Como habilitar a classificação de dados em níveis usando a AWS CLI
Ao criar um grupo de replicação usando a AWS CLI, você usa a classificação de dados em níveis selecionando um tipo de nó da família r6gd, p. ex., *cache.r6gd.xlarge* e configurando o parâmetro `--data-tiering-enabled`.
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-enabled`, a operação falhará.
Para Linux, macOS ou Unix:
```
aws elasticache create-replication-group \
--replication-group-id redis-dt-cluster \
--replication-group-description "Redis OSS cluster with data tiering" \
--num-node-groups 1 \
--replicas-per-node-group 1 \
--cache-node-type cache.r6gd.xlarge \
--engine redis \
--cache-subnet-group-name default \
--automatic-failover-enabled \
--data-tiering-enabled
```
Para Windows:
```
aws elasticache create-replication-group ^
--replication-group-id redis-dt-cluster ^
--replication-group-description "Redis OSS cluster with data tiering" ^
--num-node-groups 1 ^
--replicas-per-node-group 1 ^
--cache-node-type cache.r6gd.xlarge ^
--engine redis ^
--cache-subnet-group-name default ^
--automatic-failover-enabled ^
--data-tiering-enabled
```
Após executar essa operação, você verá uma resposta semelhante ao seguinte:
```
{
"ReplicationGroup": {
"ReplicationGroupId": "redis-dt-cluster",
"Description": "Redis OSS cluster with data tiering",
"Status": "creating",
"PendingModifiedValues": {},
"MemberClusters": [
"redis-dt-cluster"
],
"AutomaticFailover": "enabled",
"DataTiering": "enabled",
"SnapshotRetentionLimit": 0,
"SnapshotWindow": "06:00-07:00",
"ClusterEnabled": false,
"CacheNodeType": "cache.r6gd.xlarge",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false
}
}
```
## Como restaurar dados do backup para clusters com a classificação de dados em níveis ativada
Você pode usar o (Console), a (AWS CLI) ou a (API do ElastiCache) para restaurar um backup para um novo cluster com a classificação de dados em níveis ativada. Ao criar um cluster usando tipos de nós na família r6gd, a classificação de dados em níveis é ativada.
### Como restaurar dados do backup para clusters com a classificação de dados em níveis ativada (console)
**Para restaurar um backup para um novo cluster com a classificação de dados em níveis ativada (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel de navegação, escolha **Backups**.
1. Na lista de backups, escolha a caixa à esquerda do nome do backup do qual você deseja restaurar.
1. Escolha **Restore**.
1. Preencha a caixa de diálogo **Restore Cluster**. Certifique-se de preencher todos os campos **Obrigatórios** e qualquer outro que você deseja alterar em relação aos padrões.
1. **Cluster ID** (ID do cluster): obrigatório. O nome do novo cluster.
1. **Modo cluster habilitado (aumento de escala horizontalmente)**: escolha esta opção para um cluster do Valkey ou Redis OSS (modo cluster habilitado).
1. **Node Type** (Tipo de nó) – Especifique **cache.r6gd.xlarge** ou qualquer outro tipo de nó da família r6gd.
1. **Number of Shards** – Escolha o número de estilhaços desejados no novo cluster (API/CLI: grupos de nós).
1. **Replicas per Shard** – Escolha o número de nós de réplica de leitura desejados em cada estilhaço.
1. **Slots and keyspaces** (Slots e espaços de chaves): escolha como deseja que as chaves sejam distribuídas entre os fragmentos. Se você optar por especificar as distribuições de chaves, complete a tabela especificando os intervalos de chaves para cada estilhaço.
1. **Availability zone(s)** – especifique como você deseja que as zonas de disponibilidade do cluster sejam selecionadas.
1. **Port** – Somente altere esse valor se quiser que o novo cluster use uma porta diferente.
1. **Choose a VPC** – Escolha a VPC na qual criar esse cluster.
1. **Parameter Group**: escolha um grupo de parâmetros que reserve memória suficiente para a sobrecarga do Valkey ou Redis OSS para o tipo de nó selecionado.
1. Quando estiver satisfeito com as configurações, escolha **Create** (Criar).
Para mais informações sobre como criar um cluster, consulte [Criação de um cluster do Valkey ou Redis OSS](Clusters.Create.md).
### Como restaurar dados do backup para clusters com a classificação de dados em níveis ativada (AWS CLI)
Ao criar um grupo de replicação usando a AWS CLI, a classificação de dados em níveis é utilizada por padrão mediante a seleção de um tipo de nó da família r6gd, p. ex., *cache.r6gd.xlarge* e a configuração do parâmetro `--data-tiering-enabled`.
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-enabled`, a operação falhará.
Para Linux, macOS ou Unix:
```
aws elasticache create-replication-group \
--replication-group-id redis-dt-cluster \
--replication-group-description "Redis OSS cluster with data tiering" \
--num-node-groups 1 \
--replicas-per-node-group 1 \
--cache-node-type cache.r6gd.xlarge \
--engine redis \
--cache-subnet-group-name default \
--automatic-failover-enabled \
--data-tiering-enabled \
--snapshot-name my-snapshot
```
Para Linux, macOS ou Unix:
```
aws elasticache create-replication-group ^
--replication-group-id redis-dt-cluster ^
--replication-group-description "Redis OSS cluster with data tiering" ^
--num-node-groups 1 ^
--replicas-per-node-group 1 ^
--cache-node-type cache.r6gd.xlarge ^
--engine redis ^
--cache-subnet-group-name default ^
--automatic-failover-enabled ^
--data-tiering-enabled ^
--snapshot-name my-snapshot
```
Após executar essa operação, você verá uma resposta semelhante ao seguinte:
```
{
"ReplicationGroup": {
"ReplicationGroupId": "redis-dt-cluster",
"Description": "Redis OSS cluster with data tiering",
"Status": "creating",
"PendingModifiedValues": {},
"MemberClusters": [
"redis-dt-cluster"
],
"AutomaticFailover": "enabled",
"DataTiering": "enabled",
"SnapshotRetentionLimit": 0,
"SnapshotWindow": "06:00-07:00",
"ClusterEnabled": false,
"CacheNodeType": "cache.r6gd.xlarge",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false
}
}
```
# Preparação de um cluster no ElastiCache
Veja a seguir instruções sobre como criar um cluster usando o console do ElastiCache, a AWS CLI ou a API do ElastiCache.
Você também pode criar um cluster do ElastiCache usando [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html). Para obter mais informações, consulte [ ::AWS::ElastiCache::CacheCluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-cache-cluster.html) no *AWSGuia do usuário do Cloud Formation*, que inclui orientações sobre como implementar essa abordagem.
Sempre que você criar um cluster ou grupo de replicação, é uma boa ideia fazer algum trabalho preparatório para que você não precise atualizar nem fazer alterações imediatamente.
**Topics**
+ [Determinar os requisitos do seu cluster do ElastiCache](cluster-create-determine-requirements.md)
+ [Escolha do tamanho do nó](CacheNodes.SelectSize.md)
# Determinar os requisitos do seu cluster do ElastiCache
**Preparação**
Conhecer as respostas às seguintes perguntas ajuda a simplificar a criação de um cluster do ElastiCache:
+ De qual tipo de instância de nó você precisa?
Para obter orientação sobre como escolher um tipo de nó de instância, consulte [Escolha do tamanho do nó](CacheNodes.SelectSize.md).
+ Você executará seu cluster em uma nuvem privada virtual (VPC) baseada na Amazon VPC?
**Importante**
Se você estiver executando seu cluster em uma VPC, crie um grupo de sub-redes na mesma VPC antes de começar a criar um cluster. Para obter mais informações, consulte [Sub-redes e grupos de sub-redes](SubnetGroups.md).
O ElastiCache foi projetado para ser acessado de dentro da AWS usando o Amazon EC2. No entanto, ao iniciá-lo em uma VPC com base na Amazon VPC e o seu cluster em uma VPC, você pode fornecer acesso de fora da AWS. Para obter mais informações, consulte [Acessando ElastiCache recursos de fora AWS](accessing-elasticache.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 [Criação de um grupo de parâmetros do ElastiCache](ParameterGroups.Creating.md).
Se você estiver executando o Valkey ou o Redis OSS, considere definir `reserved-memory` ou `reserved-memory-percent`. Para obter mais informações, consulte [Gerenciamento de memória reservada para Valkey e Redis OSS](redis-memory-management.md).
+ Você precisa criar o próprio *grupo de segurança da 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](disaster-recovery-resiliency.md#FaultTolerance).
**Topics**
+ [Requisitos de memória e processador do ElastiCache](#cluster-create-determine-requirements-memory)
+ [Configuração do cluster do Memcached](#memcached-cluster-configuration)
+ [Configuração do cluster do Valkey e Redis OSS](#redis-cluster-configuration)
+ [Requisitos de escalabilidade do ElastiCache](#cluster-create-determine-requirements-scaling)
+ [Requisitos de acesso do ElastiCache](#cluster-create-determine-requirements-access)
+ [Requisitos de região, zona de disponibilidade e zona local do ElastiCache](#cluster-create-determine-requirements-region)
## Requisitos de memória e processador do ElastiCache
O bloco de construção básico do Amazon ElastiCache é o nó. Nós são configurados de forma singular ou em agrupamentos 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.
O mecanismo Memcached é multi-threaded e, portanto, o número de núcleos de um nó afeta o poder computacional disponível para o cluster.
## Configuração do cluster do Memcached
Os clusters do ElastiCache for Memcached são compostos de 1 a 60 nós. Os dados em um cluster Memcached são particionados nos nós do cluster. Seu aplicativo conecta-se a um cluster Memcached usando um endereço de rede chamado de Endpoint. Cada nó em um cluster Memcached tem seu próprio endpoint, que seu aplicativo usa para ler ou gravar de/em um nó específico. Além dos pontos de extremidade do nó, o cluster do Memcached em si tem um endpoint chamado *endpoint de configuração*. Sua aplicação pode usar esse endpoint para ler ou gravar no cluster, deixando a determinação de qual nó deve ser lido ou gravado para até .
![\[Imagem mostrando como um cluster do Memcached é particionado entre os nós do cluster.\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Memcached.png)
Para obter mais informações, consulte [Gerenciamento de clusters no ElastiCache](Clusters.md).
## Configuração do cluster do Valkey e Redis OSS
Os clusters do ElastiCache para Valkey e Redis OSS são compostos de 0 a 500 fragmentos (também chamados de grupos de nós). Os dados em um cluster do Valkey ou Redis OSS são particionados nos fragmentos do cluster. Sua aplicação se conecta a um cluster do Valkey ou Redis OSS usando um endereço de rede chamado de Endpoint. Os nós em um fragmento do Valkey ou Redis OSS cumprem uma das duas funções: uma primária de leitura/gravação e todos os outros nós secundários somente leitura (também chamados de réplicas de leitura). Além dos endpoints do nó, o cluster do Valkey ou Redis OSS em si tem um endpoint chamado *endpoint de configuração*. Sua aplicação pode usar esse endpoint para ler ou gravar no cluster, deixando a determinação de qual nó deve ser lido ou gravado para até ElastiCache para Redis OSS.
![\[Imagem comparando um cluster do Valkey ou Redis OSS no modo desabilitado versus no modo habilitado.\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-Redis-ClustersRGs.png)
Para obter mais informações, consulte [Gerenciamento de clusters no ElastiCache](Clusters.md).
## Requisitos de escalabilidade do ElastiCache
Todos os clusters podem ser expandidos criando um novo cluster com o novo tipo de nó maior. Quando você aumenta a escala na vertical de um cluster do Memcached, o novo cluster começa vazio. Ao aumentar a escala na vertical de um cluster do Valkey ou Redis OSS, você pode propagá-lo de um backup e evitar que o novo cluster seja iniciado vazio.
Os clusters do Amazon ElastiCache for Memcached podem ter aumento ou redução de escala na horizontal. Para expandir ou reduzir um cluster Memcached, basta adicionar ou remover nós do cluster. Se você tiver habilitado a Descoberta automática e seu aplicativo estiver se conectando ao endpoint de configuração do cluster, não será necessário fazer alterações no aplicativo quando você adicionar ou remover nós.
Para obter mais informações, consulte [Dimensionamento ElastiCache](Scaling.md) neste guia.
## Requisitos de acesso do ElastiCache
Por design, os clusters do Amazon ElastiCache são acessados a partir de instâncias do Amazon EC2. O acesso via rede a um cluster do ElastiCache é limitado à conta que criou esse cluster. Portanto, antes de poder acessar um cluster de uma instância do Amazon EC2, você deve autorizar a instância do Amazon EC2 a acessar o cluster. As etapas para essa autorização variam, dependendo de você ter executado na EC2-VPC ou no EC2-Classic.
Se você tiver executado seu cluster na EC2-VPC, deverá conceder entrada de rede ao cluster. Se você executou seu cluster no EC2-Classic, será necessário conceder acesso ao grupo de segurança do Amazon Elastic Compute Cloud para o grupo de segurança do ElastiCache associado à instância. Para obter instruções detalhadas, consulte [Etapa 3. Autorizar o acesso ao cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) neste guia.
## Requisitos de região, zona de disponibilidade e zona local do ElastiCache
O Amazon ElastiCache oferece suporte a todas as regiões da AWS. Ao colocar seus clusters do ElastiCache em uma região da AWS próxima à sua aplicação, é possível reduzir a latência. Se o seu cluster tiver vários nós, a localização deles em diferentes zonas de disponibilidade ou em zonas locais poderá reduzir o impacto das falhas no cluster.
Para obter mais informações, consulte:
+ [Seleção de regiões e zonas de disponibilidade para o ElastiCache](RegionsAndAZs.md)
+ [Uso de zonas locais com o ElastiCache](Local_zones.md)
+ [Atenuar falhas](disaster-recovery-resiliency.md#FaultTolerance)
# Escolha do tamanho do nó
O tamanho do nó selecionado para seu cluster do ElastiCache afeta os custos, o desempenho e a tolerância a falhas.
## Tamanho do nó (Valkey e Redis OSS)
Para receber informações sobre os benefícios dos processadores Graviton, consulte [Processador Graviton da AWS](https://aws.amazon.com/pm/ec2-graviton/).
Responder às seguintes perguntas poderá ajudá-lo a determinar o tipo mínimo de nó de que você precisa para sua implementação do Valkey ou Redis OSS:
+ Você espera workloads limitadas ao throughput com várias conexões de clientes?
Se for esse o caso e você estiver executando o Redis OSS versão 5.0.6 ou posterior, você poderá obter melhor throughput e latência usando nosso atributo de E/S aprimorada, em que as CPUs disponíveis são usadas para descarregar as conexões do cliente, em nome do mecanismo Redis OSS. Se você estiver executando o Redis OSS versão 7.0.4 ou posterior, além da E/S aprimorada, você obterá aceleração adicional com multiplexação de E/S aprimorada, em que cada thread de E/S de rede dedicado canaliza comandos de vários clientes para o mecanismo Redis OSS, aproveitando a capacidade do Redis OSS de processar comandos em lotes com eficiência. No ElastiCache para Redis OSS v7.1 e versões posteriores, estendemos a funcionalidade de threads de E/S melhorada para também lidar com a lógica da camada de apresentação. Por camada de apresentação, o que queremos dizer é que os threads de E/S aprimorada agora não estão apenas lendo a entrada do cliente, mas também analisando a entrada no formato de comando binário do Redis OSS, que acaba sendo encaminhado para o thread principal para execução, proporcionando ganho de desempenho. Consulte a [publicação do blog](https://aws.amazon.com/blogs/database/achieve-over-500-million-requests-per-second-per-cluster-with-amazon-elasticache-for-redis-7-1/) e a página de [versões compatíveis](VersionManagement.md#supported-engine-versions) para obter detalhes adicionais.
+ Você tem workloads que acessam regularmente um pequeno percentual de seus dados?
Caso a resposta seja afirmativa e seu sistema esteja em execução no mecanismo Redis OSS versão 6.2 ou posterior, você pode aproveitar a classificação de dados em níveis escolhendo o tipo de nó r6gd. Com a classificação de dados em níveis, os dados usados menos recentemente são armazenados em SSD. Quando eles são recuperados, há um pequeno custo de latência, que é equilibrado pela economia de custos. Para obter mais informações, consulte [Classificação de dados em níveis no ElastiCache](data-tiering.md).
Para obter mais informações, consulte [Tipos de nó compatíveis](CacheNodes.SupportedTypes.md).
+ Quanto de memória total você precisa para seus dados?
Para obter uma estimativa geral, tome o tamanho dos itens que você deseja armazenar em cache. Multiplique esse tamanho pelo número de itens que deseja manter no cache ao mesmo tempo. Para obter uma estimativa razoável do tamanho dos itens, primeiro serialize seus itens de cache, e depois conte os caracteres. Em seguida, divida isso pelo número de fragmentos no cluster.
Para obter mais informações, consulte [Tipos de nó compatíveis](CacheNodes.SupportedTypes.md).
+ Qual versão do Redis OSS você está executando?
Versões do Redis OSS anteriores à 2.8.22 exigem que você reserve mais memória para failover, snapshot, sincronização e promoção de uma réplica para operações primárias. Esse requisito é importante porque você deve ter memória suficiente disponível para todas as gravações que ocorrem durante o processo.
O Redis OSS versão 2.8.22 e posteriores usam um processo de salvamento sem bifurcação que requer menos memória disponível que o processo anterior.
Para obter mais informações, consulte:
+ [Como a sincronização e o backup são implementados](Replication.Redis.Versions.md)
+ [Garantir que você tem memória suficiente para criar um snapshot do Valkey ou Redis OSS](BestPractices.BGSAVE.md)
+ Qual é a intensidade de gravação do seu aplicativo?
Gravar aplicativos pesados pode exigir significativamente mais memória disponível, memória não utilizada por dados, ao tirar snapshots ou fazer failover. Sempre que o processo `BGSAVE` for executado, você deve ter memória suficiente que não é usada pelos dados para acomodar todas as gravações que transpirem durante o processo `BGSAVE`. Exemplos são ao tirar um snapshot, ao sincronizar um cluster primário com uma réplica em um cluster e ao ativar o recurso de arquivo somente anexado (AOF). Outro exemplo acontece ao promover uma réplica para primária (se você tiver o Multi-AZ habilitado). O pior caso é quando todos os seus dados são reescritos durante o processo. Nesse caso, você precisa de um tamanho de instância de nó com o dobro da memória que é necessária para os dados isoladamente.
Para obter mais informações detalhadas, consulte [Garantir que você tem memória suficiente para criar um snapshot do Valkey ou Redis OSS](BestPractices.BGSAVE.md).
+ Sua implementação será um cluster autônomo do Valkey ou Redis OSS (modo cluster desabilitado) ou um cluster do Valkey ou Redis OSS (modo cluster habilitado) com vários fragmentos?
**Cluster do Valkey ou Redis OSS (modo cluster desabilitado)**
Se você estiver implementando um cluster do Valkey ou Redis OSS (modo cluster desabilitado), seu tipo de nó deve ser capaz de acomodar todos os seus dados mais a sobrecarga necessária, conforme descrito anteriormente.
Por exemplo, suponha que você estime que o tamanho total de todos os seus itens é de 12 GB. Nesse caso, você pode usar um nó `cache.m3.xlarge` com 13,3 GB de memória ou um nó `cache.r3.large` com 13,5 GB de memória. No entanto, talvez você precise de mais memória para operações `BGSAVE`. Se a sua aplicação for de escrita pesada, duplique os requisitos de memória para pelo menos 24 GB. Assim, use ou `cache.m3.2xlarge` com 27,9 GB de memória ou um `cache.r3.xlarge` com 30,5 GB de memória.
**Valkey ou Redis OSS (modo cluster habilitado) com vários fragmentos**
Se você estiver implementando um cluster do Valkey ou Redis OSS (modo cluster habilitado) com vários fragmentos, o tipo de nó deve ser capaz de acomodar `bytes-for-data-and-overhead / number-of-shards` bytes de dados.
Por exemplo, suponha que você estime que o tamanho total de todos os seus itens é de 12 GB e você tem dois fragmentos. Nesse caso, você pode usar um nó `cache.m3.large` com 6,05 GB de memória (12 GB/2). No entanto, talvez você precise de mais memória para operações `BGSAVE`. Se a sua aplicação for de escrita pesada, duplique os requisitos de memória para pelo menos 12 GB por fragmento. Assim, use ou `cache.m3.xlarge` com 13,3 GB de memória ou um `cache.r3.large` com 13,5 GB de memória.
+ Você está usando Local Zones?
[Local Zones](Local_zones.md) (Zonas locais) permitem que você coloque recursos como um cluster do ElastiCache em vários locais próximos aos usuários. Mas, ao escolher o tamanho do nó, esteja ciente de que os tamanhos de nó disponíveis estão limitados ao seguinte no momento, independentemente dos requisitos de capacidade:
+ Geração atual:
**Tipos de nó M:** `cache.m5.large`, `cache.m5.xlarge`, `cache.m5.2xlarge`, `cache.m5.4xlarge`, `cache.m5.12xlarge`, `cache.m5.24xlarge`
**Tipos de nó R:** `cache.r5.large`, `cache.r5.xlarge`, `cache.r5.2xlarge`, `cache.r5.4xlarge`, `cache.r5.12xlarge`, `cache.r5.24xlarge`
**Tipos de nó T:** `cache.t3.micro`, `cache.t3.small`, `cache.t3.medium`
Enquanto seu cluster está em execução, você pode monitorar o uso da memória, a utilização do processador, o cache e as métricas de perdas no cache que são publicadas no CloudWatch. Você pode notar que seu cluster não tem a taxa de acertos desejada ou que as chaves estão sendo removidas com muita frequência. Nesses casos, você pode escolher um tamanho de nó diferente com especificações de CPU e memória maiores.
Ao monitorar o uso da CPU, lembre-se que o Valkey e o Redis OSS são de thread único. Assim, multiplique o uso da CPU relatado pelo número de núcleos da CPU para obter esse uso real. Por exemplo, uma CPU de quatro núcleos que informa uma taxa de uso de 20% é, na verdade, o único núcleo que o Redis OSS está executando com 80% de utilização.
## Tamanho do nó (Memcached)
Os clusters Memcached contêm um ou mais nós com os dados do cluster particionados entre os nós. Por isso, as necessidades de memória do cluster e de memória de um nó estão relacionadas, mas não são idênticas. Você pode obter a capacidade de memória de cluster necessária tendo alguns nós grandes ou vários nós menores. Além disso, conforme suas necessidades mudarem, você poderá adicionar ou remover nós do cluster e, assim, pagar apenas pelo que precisa.
A capacidade de memória total do cluster é calculada multiplicando o número de nós no cluster pela capacidade de RAM de cada nó, depois de deduzir as despesas gerais do sistema. A capacidade de cada nó é baseada no tipo de nó.
```
cluster_capacity = number_of_nodes * (node_capacity - system_overhead)
```
O número de nós no cluster é um fator chave na disponibilidade do seu cluster executando o Memcached. A falha de um único nó pode ter um impacto na disponibilidade da sua aplicação e na carga do seu banco de dados de backend. Nesse caso, o ElastiCache provisiona uma substituição para um nó com falha e ele é preenchido novamente. Para reduzir esse impacto na disponibilidade, espalhe sua memória e capacidade de computação ao redor de um número maior de nós com menor capacidade, em vez de usar um número menor de nós de alta capacidade.
Em um cenário em que você deseja ter 35 GB de memória cache, você pode definir qualquer uma das seguintes configurações:
+ 11`cache.t2.medium` nós com 3,22 GB de memória e 2 threads cada = 35,42 GB e 22 threads.
+ 6`cache.m4.large` nós com 6,42 GB de memória e 2 threads cada = 38,52 GB e 12 threads.
+ 3`cache.r4.large` nós com 12,3 GB de memória e 2 threads cada = 36,90 GB e 6 threads.
+ 3`cache.m4.xlarge` nós com 14,28 GB de memória e 4 threads cada = 42,84 GB e 12 threads.
**Comparar opções de nós**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/CacheNodes.SelectSize.html)
Essas opções oferecem uma capacidade de memória semelhante, mas uma capacidade e custo computacional diferentes. Para comparar os custos das suas opções específicas, consulte [Definição de preço do Amazon ElastiCache](https://aws.amazon.com/elasticache/pricing/).
Para clusters executados no Memcached, algumas das memórias disponíveis em cada nó são usadas para sobrecarga de conexão. Para obter mais informações, consulte [Sobrecarga de conexões do Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached.Overhead)
O uso de vários nós exigirá a distribuição das chaves entre eles. Cada nó possui seu próprio endpoint. Para o fácil gerenciamento de endpoints, você pode usar o recurso de descoberta automática do ElastiCache, que permite que os programas clientes identifiquem automaticamente todos os nós em um cluster. Para obter mais informações, consulte [Identificar automaticamente nós no seu cluster (Memcached)](AutoDiscovery.md).
Em alguns casos, você pode não ter certeza de quanta capacidade precisa. Em caso afirmativo, para testes recomendamos começar com um nó `cache.m5.large`. Em seguida, monitore o uso da memória, a utilização da CPU e a taxa de acerto do cache com as métricas do ElastiCache publicadas no Amazon CloudWatch. Para obter mais informações sobre métricas do CloudWatch para o ElastiCache, consulte [Monitorando o uso com CloudWatch métricas](CacheMetrics.md). Para produção e maiores workloads, os nós R5 fornecem o melhor desempenho e valor de custo de RAM.
Se o seu cluster não tiver a taxa de acerto desejada, você poderá adicionar facilmente mais nós, aumentando assim a memória total disponível no seu cluster.
Se o seu cluster for limitado por CPU, mas tiver taxa de acerto suficiente, tente configurar um novo cluster com um tipo de nó que forneça mais poder computacional.
# Criação de um cluster do Valkey ou Redis OSS
Os exemplos a seguir mostram como criar um cluster OSS Valkey ou Redis usando a Console de gerenciamento da AWS API e.AWS CLI ElastiCache
## Criação de um cluster do Valkey ou Redis OSS (modo cluster desabilitado) (console)
ElastiCache oferece suporte à replicação quando você usa o mecanismo Valkey ou Redis OSS. Para monitorar a latência entre o momento em que os dados são gravados em um cluster read/write primário Valkey ou Redis OSS e o momento em que são propagados para um cluster secundário somente para leitura, ElastiCache adiciona ao cluster uma chave especial,. `ElastiCacheMasterReplicationTimestamp` Essa chave é a hora em Tempo Universal Coordenado (UTC) atual. Como um cluster do Valkey ou Redis OSS pode ser adicionado a um grupo de replicação mais tarde, essa chave está incluída em todos os clusters do Valkey ou Redis OSS, mesmo que inicialmente eles não sejam membros de um grupo de replicação. Para obter mais informações sobre grupos de replicação, consulte [Alta disponibilidade com o uso de grupos de replicação](Replication.md).
Para criar um cluster do Valkey ou Redis OSS (modo de cluster desabilitado), siga as etapas em [Criação de um cluster do Valkey (modo cluster desabilitado) (console)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs).
Assim que o status do seu cluster estiver *disponível*, você poderá conceder EC2 à Amazon acesso a ele, conectar-se a ele e começar a usá-lo. Para obter mais informações, consulte [Etapa 3. Autorizar o acesso ao cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) e [Etapa 4: Conectar-se ao nó de um cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**Importante**
Assim que seu cluster se tornar disponível, você será cobrado por cada hora ou hora parcial em que ele estiver ativo, mesmo que você não o esteja usando ativamente. Para interromper as cobranças aplicáveis para esse cluster, você deve excluí-lo. Consulte [Excluindo um cluster no ElastiCache](Clusters.Delete.md).
## Criação de um cluster do Valkey ou Redis OSS (modo cluster habilitado) (console)
Se você estiver executando o Redis OSS 3.2.4 ou posterior, será possível criar um cluster do Valkey ou Redis OSS (modo cluster habilitado). Clusters do Valkey ou Redis OSS (modo cluster habilitado) oferecem suporte para o particionamento dos seus dados entre 1 e 500 fragmentos (API/CLI: grupos de nós), mas com algumas limitações. Para obter uma comparação entre o Valkey ou Redis OSS (modo cluster desabilitado) e o Valkey ou Redis OSS (modo cluster habilitado), consulte [Mecanismos e versões compatíveis](VersionManagement.md#supported-engine-versions).
**Para criar um cluster Valkey ou Redis OSS (modo de cluster ativado) usando o console ElastiCache**
1. Faça login no Console de gerenciamento da AWS e abra o ElastiCache console da Amazon em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Na lista no canto superior direito, escolha a AWS região na qual você deseja iniciar esse cluster.
1. No painel de navegação, escolha **Get started** (Conceitos básicos).
1. Escolha **Create VPC** (Criar VPC) e siga as etapas em [Creating a Virtual Private Cloud (VPC)](VPCs.CreatingVPC.md) (Criação de uma nuvem privada virtual (VPC)).
1. Na página do ElastiCache painel, escolha **Criar cluster** e, em seguida, escolha **Criar cluster Valkey ou Criar cluster** **Redis OSS**.
1. Em **Cluster settings** (Configurações do cluster), faça o seguinte:
1. Selecione **Configure and create a new cluster** (Configurar e criar um novo cluster).
1. Para o **Cluster mode** Modo cluster, escolha**Enabled** (Habilitado).
1. Para o **Cluster info** (Informações sobre o cluster), insira um valor para **Name** (Nome).
1. (Opcional) Insira um valor para **Description** (Descrição).
1. Em **Location** (Local):
------
#### [ AWS Cloud ]
1. Para **AWS Cloud** (Nuvem), recomendamos que você aceite as configurações padrão de **Multi-AZ** e **Failover automático**. Para obter mais informações, consulte [Minimizando o tempo de inatividade no ElastiCache Redis OSS](AutoFailover.md) com Multi-AZ.
1. Em **Cluster settings** (Configurações do cluster)
1. Em **Engine version** (Versão do mecanismo), escolha a versão do mecanismo.
1. Em **Port** (Porta), use a porta padrão, 6379. Se você tiver um motivo para usar uma porta diferente, insira o número da porta.
1. Em **Grupo de parâmetro** (Parameter group), escolha um grupo de parâmetro ou crie um novo. Os grupo de parâmetros controlam os parâmetros de tempo de execução do seu cluster. Para obter mais informações sobre grupo de parâmetros, consulte [Parâmetros do Valkey e do Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis) e [Criação de um grupo de parâmetros do ElastiCache](ParameterGroups.Creating.md).
**nota**
Quando você seleciona um grupo de parâmetros para definir os valores de configuração do mecanismo, esse grupo de parâmetros é aplicado a todos os clusters no datastore global. Na página **Parameter Groups** (Grupos de parâmetros), o atributo **Global** indica se um grupo de parâmetros faz parte de um datastore global.
1. Para **Node type** (Tipo de nó), escolha a seta para baixo (![\[Downward-pointing triangle icon, typically used to indicate a dropdown menu.\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/ElastiCache-DnArrow.png)). Na caixa de diálogo **Change node type** (Alterar tipo de nó), escolha um valor para a **Instance family** (Família de instâncias) para o tipo de nó desejado. Depois disso, escolha o tipo de nó que deseja usar para este cluster e escolha **Save** (Salvar).
Para obter mais informações, consulte [Escolha do tamanho do nó](CacheNodes.SelectSize.md).
Se você escolher um tipo de nó 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 no ElastiCache](data-tiering.md).
1. Em **Número de fragmentos**, escolha o número de fragmentos (partições/grupos de nós) desejado para este cluster do Valkey ou Redis OSS (modo cluster habilitado).
Para algumas versões do Valkey ou Redis OSS (modo cluster habilitado), é possível alterar dinamicamente o número de fragmentos no cluster:
+ **Redis OSS 3.2.10 e posteriores**: se o cluster estiver executando o Redis OSS 3.2.10 ou versões posteriores, será possível alterar dinamicamente o número de fragmentos no cluster. Para obter mais informações, consulte [Escalabilidade de clusters no Valkey ou Redis OSS (modo cluster habilitado)](scaling-redis-cluster-mode-enabled.md).
+ **Outras versões do Redis OSS**: se o cluster estiver executando uma versão do Redis OSS anterior à versão 3.2.10, há outra abordagem. Para alterar o número de fragmentos no cluster nesse caso, crie um novo cluster com o novo número de fragmentos. Para obter mais informações, consulte [Restauração de um backup para um novo cache](backups-restoring.md).
1. Em **Réplicas por fragmento**, escolha o número de nós de réplica de leitura desejados em cada fragmento.
As restrições a seguir existem para o Valkey ou Redis OSS (modo cluster habilitado).
+ Se você tiver o Multi-AZ habilitado, verifique se tem pelo menos uma réplica por fragmento.
+ O número de réplicas é o mesmo para cada fragmento ao criar o cluster usando o console.
+ O número de réplicas de leitura por fragmento é fixo e não pode ser alterado. Se você achar que precisa de mais ou menos réplicas por fragmento (API/CLI: grupo de nós), deverá criar um novo cluster com o novo número de réplicas. Para obter mais informações, consulte [Tutorial: propagação de um novo cluster baseado em nós com um backup criado externamente](backups-seeding-redis.md).
1. Em **Connectivity** (Conectividade)
1. Em **Network type** (Tipo de rede), escolha as versões de IP compatíveis com esse cluster.
1. Em **Grupos de sub-redes**, escolha a sub-rede que você deseja aplicar a esse cluster. ElastiCache usa esse grupo de sub-redes para escolher uma sub-rede e endereços IP dentro dessa sub-rede para associar aos seus nós. ElastiCache os clusters exigem uma sub-rede de pilha dupla com ambos IPv4 e IPv6 endereços atribuídos a eles para operar no modo de pilha dupla e uma IPv6 sub-rede somente para operar somente como -only. IPv6
Ao criar um novo grupo de sub-rede, insira o **VPC ID** (ID da VPC) ao qual ele pertence.
Selecione um **Discovery IP type** (Tipo de IP de descoberta). Somente os endereços IP do protocolo escolhido são retornados.
Para obter mais informações, consulte:
+ [Escolhendo um tipo de rede em ElastiCache](network-type.md).
+ [Criar uma sub-rede na VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet).
Se você for [Uso de zonas locais com o ElastiCache](Local_zones.md), deverá criar ou escolher uma sub-rede que esteja na região local.
Para obter mais informações, consulte [Sub-redes e grupos de sub-redes](SubnetGroups.md).
1. Em **Availability zone placements** (Posicionamentos de zona de disponibilidade), você tem duas opções:
+ **Sem preferência** — ElastiCache escolhe a Zona de Disponibilidade.
+ **Specify availability zones** (Especificar zonas de disponibilidade): você especifica a zona de disponibilidade para cada cluster.
Se optar por especificar as zonas de disponibilidade, para cada cluster em cada fragmento, escolha a zona de disponibilidade na lista.
Para obter mais informações, consulte [Seleção de regiões e zonas de disponibilidade para o ElastiCache](RegionsAndAZs.md).
1. Escolha **Next** (Próximo)
1. Em **Configurações avançadas do Valkey** ou **Configurações avançadas do Redis OSS** ou
1. Para **Security** (Segurança):
1. Para criptografar seus dados, você tem as seguintes opções:
+ **Criptografia em repouso**: permite a criptografia de dados armazenados em disco. Para obter mais informações, consulte [Criptografia em repouso](at-rest-encryption.md).
**nota**
Você tem a opção de fornecer uma chave de criptografia diferente escolhendo a chave **AWS KMS gerenciada pelo cliente** e escolhendo a chave. Para obter mais informações, consulte [Usar chaves gerenciadas pelo cliente do AWS KMS](at-rest-encryption.md#using-customer-managed-keys-for-elasticache-security).
+ **Encryption in-transit** (Criptografia em trânsito): permite a criptografia de dados na conexão. Para obter mais informações, consulte [criptografia em trânsito](in-transit-encryption.md). Para o Valkey 7.2 e posteriores ou Redis OSS 6.0 e posteriores, se você habilitar a Criptografia em trânsito, você será solicitado a especificar uma das seguintes opções de **Controle de acesso**:
+ **No Access Control** (Sem controle de acesso): essa é a configuração padrão. Isso indica que não há restrições no acesso do usuário ao cluster.
+ **User Group Access Control List** (Lista de controle de acesso de grupo de usuários): selecione um grupo de usuários com um conjunto definido de usuários que possam acessar o cluster. Para obter mais informações, consulte [Gerenciamento de grupos de usuários com o console e a CLI](Clusters.RBAC.md#User-Groups).
+ **Usuário padrão AUTH**: um mecanismo de autenticação para um servidor Valkey ou Redis OSS. Para obter mais informações, consulte [AUTH](auth.md).
+ **AUTH**: um mecanismo de autenticação para servidores Valkey ou Redis OSS. Para obter mais informações, consulte [AUTH](auth.md).
**nota**
Para versões do Redis OSS 3.2.6 e posteriores, excluindo a versão 3.2.10, o AUTH é a única opção.
1. Em **Grupos de segurança**, escolha os grupos de segurança desejados para esse cluster. Um *grupo de segurança* atua como um firewall para controlar o acesso à rede ao cluster. É possível usar o grupo de segurança padrão para sua VPC ou criar um novo.
Para obter mais informações sobre grupos de segurança, consulte [Grupos de segurança para sua VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) no *Guia do usuário da Amazon VPC*.
1. Para backups automáticos agendados regularmente, selecione **Enable automatic backups** (Habilitar backups automáticos) e insira o número de dias que deseja que cada backup automático seja mantido antes de ser excluído automaticamente. Se não quiser backups automáticos agendados regularmente, desmarque a caixa de seleção **Enable automatic backups** (Habilitar backups automáticos). Em ambos os casos, você sempre tem a opção de criar backups manuais.
Para obter mais informações sobre backup e restauração, consulte [Snapshots e restauração](backups.md).
1. (Opcional) Especifique uma janela de manutenção. A opção *janela de manutenção* é o tempo, geralmente uma hora de duração, a cada semana quando o ElastiCache agenda a manutenção do sistema para seu cluster. Você pode permitir que o ElastiCache escolha o dia e a hora da sua janela de manutenção (*No preference*) ou pode escolher o dia, a hora e a duração por conta própria (*Specify maintenance window*). Se você escolher *Especificar janela de manutenção*, nas listas, escolha *Dia de início*, *Hora de início* e *Duração* (em horas) para sua janela de manutenção. Todos os horários são em UCT.
Para obter mais informações, consulte [Gerenciamento de manutenção de cluster do ElastiCache](maintenance-window.md).
1. (Opcional) Para **Logs**:
+ Em **Log format** (Formato do log), escolha **Text** (Texto) ou **JSON**.
+ Em **Tipo de destino**, escolha **CloudWatch Logs** ou **Kinesis Firehose**.
+ Em **Destino do registro**, escolha **Criar novo** e insira o nome do grupo de CloudWatch registros do Logs ou o nome do stream do Firehose, ou escolha **Selecionar existente** e escolha o nome do grupo de CloudWatch registros do Logs ou o nome do stream do Firehose,
1. Para **Tags**, para ajudá-lo a gerenciar seus clusters e outros ElastiCache recursos, você pode atribuir seus próprios metadados a cada recurso na forma de tags. Para obter mais informações, consulte [Marcando seus recursos ElastiCache](Tagging-Resources.md).
1. Escolha **Next** (Próximo).
1. Revise todas as suas entradas e opções e faça as correções necessárias. Quando estiver pronto, escolha **Create** (Criar).
------
#### [ On premises ]
1. Para **On-premises**, recomendamos que você deixe **Auto-failover** (Failover automático) habilitado. Para obter mais informações, consulte [Minimizando o tempo de inatividade no ElastiCache Redis](AutoFailover.md) OSS com Multi-AZ
1. Siga as etapas em [Uso do Outposts](ElastiCache-Outposts.md).
------
Para criar o equivalente usando a ElastiCache API ou AWS CLI em vez do ElastiCache console, veja o seguinte:
+ API: [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ CLI: [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
Assim que o status do seu cluster estiver *disponível*, você poderá conceder EC2 acesso a ele, conectar-se a ele e começar a usá-lo. Para obter mais informações, consulte [Etapa 3. Autorizar o acesso ao cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) e [Etapa 4: Conectar-se ao nó de um cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**Importante**
Assim que seu cluster se tornar disponível, você será cobrado por cada hora ou hora parcial em que ele estiver ativo, mesmo que você não o esteja usando ativamente. Para interromper as cobranças aplicáveis para esse cluster, você deve excluí-lo. Consulte [Excluindo um cluster no ElastiCache](Clusters.Delete.md).
## Criar um cluster (AWS CLI)
Para criar um cluster usando o AWS CLI, use o `create-cache-cluster` comando.
**Importante**
Assim que seu cluster se tornar disponível, você será cobrado por cada hora ou hora parcial em que ele estiver ativo, mesmo que você não o esteja usando ativamente. Para interromper as cobranças aplicáveis para esse cluster, você deve excluí-lo. Consulte [Excluindo um cluster no ElastiCache](Clusters.Delete.md).
### Criação de um cluster do Valkey ou Redis OSS (modo cluster desabilitado) (CLI)
**Example – Um cluster do Valkey ou Redis OSS (modo cluster desabilitado) sem réplicas de leitura**
O código da CLI a seguir cria um cluster do Valkey ou Redis OSS (modo cluster desabilitado) sem réplicas.
Ao criar cluster usando um tipo de nó da família r6gd, é necessário repassar o parâmetro `data-tiering-enabled`.
Para Linux, macOS ou Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine redis \
--num-cache-nodes 1 \
--cache-parameter-group default.redis6.x \
--snapshot-arns arn:aws:s3:::amzn-s3-demo-bucket/snapshot.rdb
```
Para Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine redis ^
--num-cache-nodes 1 ^
--cache-parameter-group default.redis6.x ^
--snapshot-arns arn:aws:s3:::amzn-s3-demo-bucket/snapshot.rdb
```
### Criação de um cluster do Valkey ou Redis OSS (modo cluster habilitado) (AWS CLI)
Clusters do Valkey ou Redis OSS (modo cluster habilitado) (API/CLI: grupos de replicação) não podem ser criados usando a operação `create-cache-cluster`. Para criar um cluster do Valkey ou Redis OSS (modo cluster habilitado) (API/CLI: grupo de replicação), consulte [Criação de um grupo de replicação do Valkey ou Redis OSS (modo cluster habilitado) do início (AWS CLI)](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI).
Para obter mais informações, consulte o tópico AWS CLI de ElastiCache referência [https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html).
## Criação de um cluster para Valkey ou Redis OSS (API) ElastiCache
Para criar um cluster usando a ElastiCache API, use a `CreateCacheCluster` ação.
**Importante**
Assim que seu cluster se tornar disponível, você será cobrado por cada hora ou hora parcial em que ele estiver, mesmo que você não o esteja usando. Para interromper as cobranças aplicáveis para esse cluster, você deve excluí-lo. Consulte [Excluindo um cluster no ElastiCache](Clusters.Delete.md).
**Topics**
+ [Criação de um cluster (API) Valkey ou Redis OSS (modo de cluster desativado) ElastiCache](#Clusters.Create.API.Redis)
+ [Criação de um cluster no Valkey ou no Redis OSS (modo de cluster ativado) (API) ElastiCache](#Clusters.Create.API.RedisCluster)
### Criação de um cluster (API) Valkey ou Redis OSS (modo de cluster desativado) ElastiCache
O código a seguir cria um cluster (API) Valkey ou Redis OSS (modo de cluster desativado). ElastiCache
As quebras de linha foram adicionadas para legibilidade.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=my-cluster
&CacheNodeType=cache.r4.large
&CacheParameterGroup=default.redis3.2
&Engine=redis
&EngineVersion=3.2.4
&NumCacheNodes=1
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&SnapshotArns.member.1=arn%3Aaws%3As3%3A%3A%3AmyS3Bucket%2Fdump.rdb
&Timestamp=20150508T220302Z
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20150508T220302Z
&X-Amz-Expires=20150508T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Signature=
```
### Criação de um cluster no Valkey ou no Redis OSS (modo de cluster ativado) (API) ElastiCache
Clusters do Valkey ou Redis OSS (modo cluster habilitado) (API/CLI: grupos de replicação) não podem ser criados usando a operação `CreateCacheCluster`. Para criar um cluster do Valkey ou Redis OSS (modo cluster habilitado) (API/CLI: grupo de replicação), consulte [Criação de um grupo de replicação no Valkey ou Redis OSS (modo cluster habilitado) do início (API do ElastiCache)](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.API).
Para obter mais informações, consulte o tópico de referência ElastiCache da API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html).
# Criação de um cluster do Memcached
Os exemplos a seguir mostram como criar um cluster usando Console de gerenciamento da AWS a ElastiCache API AWS CLI e.
## Criação de um cluster do Memcached (console)
Quando você usa o mecanismo Memcached, a Amazon ElastiCache suporta o particionamento horizontal de seus dados em vários nós. O Memcached permite a descoberta automática e, portanto, você não precisa rastrear os endpoints de cada nó. O Memcached rastreia o endpoint de cada nó, atualizando a lista de endpoints à medida que os nós são adicionados e removidos. Seu aplicativo precisa apenas do endpoint de configuração para interagir com o cluster.
Para criar um cluster do Memcached por meio do console, siga as etapas em [Criação de um cluster do Valkey (modo de cluster desabilitado) (console)](Clusters.Create.md#Clusters.Create.CON.RedisCluster). Ao chegar à etapa cinco, selecione **Criar cache do Memcached**.
Assim que o status do seu cluster estiver *disponível*, você poderá conceder EC2 à Amazon acesso a ele, conectar-se a ele e começar a usá-lo. Para obter mais informações, consulte as etapas semelhantes [Etapa 3. Autorizar o acesso ao cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) e [Etapa 4: Conectar-se ao nó de um cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**Importante**
Assim que seu cluster se tornar disponível, você será cobrado por cada hora ou hora parcial em que ele estiver ativo, mesmo que você não o esteja usando ativamente. Para interromper as cobranças aplicáveis para esse cluster, você deve excluí-lo. Consulte [Excluindo um cluster no ElastiCache](Clusters.Delete.md).
## Criar um cluster (AWS CLI)
Para criar um cluster usando o AWS CLI, use o `create-cache-cluster` comando.
**Importante**
Assim que seu cluster se tornar disponível, você será cobrado por cada hora ou hora parcial em que ele estiver ativo, mesmo que você não o esteja usando ativamente. Para interromper as cobranças aplicáveis para esse cluster, você deve excluí-lo. Consulte [Excluindo um cluster no ElastiCache](Clusters.Delete.md).
### Criar um cluster de cache Memcached (AWS CLI)
O código da CLI a seguir cria um cluster de Memcached com 3 nós.
Para Linux, macOS ou Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine memcached \
--engine-version 1.4.24 \
--cache-parameter-group default.memcached1.4 \
--num-cache-nodes 3
```
Para Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine memcached ^
--engine-version 1.4.24 ^
--cache-parameter-group default.memcached1.4 ^
--num-cache-nodes 3
```
## Criação de um cluster para Memcached (API) ElastiCache
Para criar um cluster usando a ElastiCache API, use a `CreateCacheCluster` ação.
**Importante**
Assim que seu cluster se tornar disponível, você será cobrado por cada hora ou hora parcial em que ele estiver, mesmo que você não o esteja usando. Para interromper as cobranças aplicáveis para esse cluster, você deve excluí-lo. Consulte [Excluindo um cluster no ElastiCache](Clusters.Delete.md).
**Topics**
+ [Criação de um cluster Memcached (API) ElastiCache](#Clusters.Create.API.Memcached)
### Criação de um cluster Memcached (API) ElastiCache
O código a seguir cria um cluster Memcached com 3 nós (ElastiCache API).
As quebras de linha foram adicionadas para legibilidade.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=my-cluster
&CacheNodeType=cache.r4.large
&Engine=memcached
&NumCacheNodes=3
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150508T220302Z
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20150508T220302Z
&X-Amz-Expires=20150508T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Signature=
```
# Visualização dos detalhes de um cluster do ElastiCache
Você pode visualizar informações detalhadas sobre um ou mais clusters usando o console do ElastiCache, a AWS CLI ou a API do ElastiCache.
## Visualização dos detalhes de um cluster do Memcached (console)
Você pode visualizar os detalhes de um cluster do Memcached usando o console do ElastiCache, a AWS CLI para o ElastiCache ou a API do ElastiCache.
O procedimento a seguir detalha como visualizar os detalhes de um cluster do Memcached usando o console do ElastiCache.
**Para visualizar os detalhes de um cluster Memcached**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Na lista localizada no canto superior direito, escolha a região da AWS de interesse.
1. No painel do mecanismo ElastiCache, escolha **Memcached**. Isso exibe uma lista de todos os seus clusters que estão em execução no mecanismo Memcached.
1. Para ver os detalhes de um cluster, escolha a caixa de seleção à esquerda do nome do cluster.
1. Para visualizar as informações do nó, escolha a guia **Nodes** (Nós), que exibe informações sobre o status e o endpoint dos nós.
1. Para visualizar as métricas, escolha a guia **Metrics** (Métricas), que exibe as métricas relevantes para todos os nós do cluster. Para obter mais informações, consulte . [Monitorando o uso com CloudWatch métricas](CacheMetrics.md)
1. Escolha a guia **Network and security** (Rede e segurança) para ver detalhes sobre a conectividade de rede e a configuração do grupo de sub-rede do cluster e o grupo de segurança da VPC. Para obter mais informações, consulte [Sub-redes e grupos de sub-redes](SubnetGroups.md).
1. Escolha a guia **Maintenance** (Manutenção) para ver detalhes sobre as configurações de manutenção do cluster. Para obter mais informações, consulte [Gerenciamento de manutenção de cluster do ElastiCache](maintenance-window.md).
1. Escolha a guia **Tags** para ver detalhes sobre as tags aplicadas aos recursos do cluster. Para obter mais informações, consulte [Marcando seus recursos ElastiCache](Tagging-Resources.md).
## Visualização dos detalhes do Valkey ou Redis OSS (modo cluster desabilitado) (console)
Você pode visualizar os detalhes de um cluster do Valkey ou Redis OSS (modo cluster desabilitado) usando o console do ElastiCache, a AWS CLI para o ElastiCache ou a API do ElastiCache.
O procedimento a seguir detalha como visualizar os detalhes de um cluster do Valkey ou Redis OSS (modo cluster desabilitado) usando o console do ElastiCache.
**Para exibir os detalhes de um cluster do Valkey ou Redis OSS (modo cluster desabilitado)**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel do mecanismo ElastiCache, escolha **Valkey** ou **Redis OSS** para exibir uma lista de todos os seus clusters que estão sendo executados no mecanismo.
1. Para ver os detalhes de um cluster, marque a caixa de seleção à esquerda do nome do cluster. Certifique-se de selecionar um cluster que execute o mecanismo Valkey ou Redis OSS, não o Clustered Valkey ou o Clustered Redis OSS. Ao fazer isso, os detalhes sobre o cluster serão exibidos, incluindo o endpoint principal do cluster.
1. Como visualizar informações do nó:
1. Escolha o nome do cluster.
1. Selecione a guia **Shards and nodes** (Fragmentos e nós) Ao fazer isso, os detalhes sobre cada nó serão exibidos, incluindo o endpoint do nó, que você precisa usar para ler do cluster.
1. Para visualizar as métricas, escolha a guia **Metrics** (Métricas), que exibe as métricas relevantes para todos os nós do cluster. Para obter mais informações, consulte . [Monitorando o uso com CloudWatch métricas](CacheMetrics.md)
1. Para visualizar os logs, escolha a guia **Logs**, que indica se o cluster está usando logs lentos ou logs do mecanismo e fornece detalhes relevantes. Para obter mais informações, consulte [Entrega de logs](Log_Delivery.md).
1. Escolha a guia **Network and security** (Rede e segurança) para ver detalhes sobre a conectividade de rede e a configuração do grupo de sub-redes do cluster. Para obter mais informações, consulte [Sub-redes e grupos de sub-redes](SubnetGroups.md).
1. Escolha a guia **Maintenance** (Manutenção) para ver detalhes sobre as configurações de manutenção do cluster. Para obter mais informações, consulte [Gerenciamento de manutenção de cluster do ElastiCache](maintenance-window.md).
1. Escolha a guia **Service updates** (Atualizações do serviço) para ver detalhes sobre todas as atualizações de serviço disponíveis, juntamente com a data de validade recomendada. Para obter mais informações, consulte [Atualizações de serviço em ElastiCache](Self-Service-Updates.md).
1. Escolha a guia **Tags** para ver detalhes sobre as tags aplicadas aos recursos do cluster. Para obter mais informações, consulte [Marcando seus recursos ElastiCache](Tagging-Resources.md).
## Visualização de detalhes de um cluster do Valkey ou Redis OSS (modo cluster habilitado) (console)
Você pode visualizar os detalhes de um cluster do Valkey ou Redis OSS (modo cluster habilitado) usando o console do ElastiCache, a AWS CLI para o ElastiCache ou a API do ElastiCache.
O procedimento a seguir detalha como visualizar os detalhes de um cluster do Valkey ou Redis OSS (modo cluster habilitado) usando o console do ElastiCache.
**Para exibir os detalhes de um cluster do Valkey ou Redis OSS (modo cluster habilitado)**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Na lista localizada no canto superior direito, escolha a região da AWS de interesse.
1. No painel do mecanismo ElastiCache, escolha **Valkey** ou **Redis OSS** para exibir uma lista de todos os seus clusters que estão sendo executados no mecanismo.
1. Para ver os detalhes de um cluster do Valkey ou Redis OSS (modo cluster habilitado), selecione a caixa à esquerda do nome do cluster. Certifique-se de escolher um cluster que esteja executando o mecanismo Valkey ou Clustered Redis OSS.
A tela se expande abaixo do cluster e exibe detalhes sobre o cluster, incluindo o endpoint de configuração de cluster.
1. Para ver uma lista dos fragmentos do cluster e o número de nós em cada fragmento, escolha a guia **Shards and nodes** (Fragmentos e nós).
1. Como visualizar informações específicas sobre um nó:
1. Escolha o ID do fragmento.
Isso exibirá informações sobre cada nó, incluindo o endpoint de cada nó que é necessário usar para ler dados do cluster.
1. Para visualizar as métricas, escolha a guia **Metrics** (Métricas), que exibe as métricas relevantes para todos os nós do cluster. Para obter mais informações, consulte . [Monitorando o uso com CloudWatch métricas](CacheMetrics.md)
1. Para visualizar os logs, escolha a guia **Logs**, que indica se o cluster está usando logs lentos ou logs do mecanismo e fornece detalhes relevantes. Para obter mais informações, consulte [Entrega de logs](Log_Delivery.md).
1. Escolha a guia **Network and security** (Rede e segurança) para ver detalhes sobre a conectividade de rede e a configuração do grupo de sub-rede do cluster, o grupo de segurança da VPC e qual método de criptografia, se houver, está habilitado no cluster. Para obter mais informações, consulte [Sub-redes e grupos de sub-redes](SubnetGroups.md) e [Segurança de dados no Amazon ElastiCache](encryption.md).
1. Escolha a guia **Maintenance** (Manutenção) para ver detalhes sobre as configurações de manutenção do cluster. Para obter mais informações, consulte [Gerenciamento de manutenção de cluster do ElastiCache](maintenance-window.md).
1. Escolha a guia **Service updates** (Atualizações do serviço) para ver detalhes sobre todas as atualizações de serviço disponíveis, juntamente com a data de validade recomendada. Para obter mais informações, consulte [Atualizações de serviço em ElastiCache](Self-Service-Updates.md).
1. Escolha a guia **Tags** para ver detalhes sobre as tags aplicadas aos recursos do cluster. Para obter mais informações, consulte [Marcando seus recursos ElastiCache](Tagging-Resources.md).
## Visualização dos detalhes de um cluster do ElastiCache (AWS CLI)
O seguinte código lista os detalhes de *my-cluster*:
```
aws elasticache describe-cache-clusters --cache-cluster-id my-cluster
```
Substitua *my-cluster* pelo nome de seu cluster em um caso em que o cluster seja criado com um nó de cache e nenhum fragmento usando o comando `create-cache-cluster`.
```
{
"CacheClusters": [
{
"CacheClusterStatus": "available",
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"Engine": "redis",
"PreferredMaintenanceWindow": "wed:12:00-wed:13:00",
"CacheSubnetGroupName": "default",
"SnapshotWindow": "08:30-09:30",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"CacheClusterId": "my-cluster1",
"CacheClusterCreateTime": "2018-02-26T21:06:43.420Z",
"PreferredAvailabilityZone": "us-west-2c",
"AuthTokenEnabled": false,
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2"
},
"SnapshotRetentionLimit": 0,
"AutoMinorVersionUpgrade": true,
"EngineVersion": "3.2.10",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
```
```
{
"CacheClusters": [
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.10",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
```
```
{
"CacheClusters": [
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.6",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.6",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
]
}
```
Em um caso em que o cluster seja criado com o Console de gerenciamento da AWS (nó de cluster habilitado ou desabilitado com um ou mais fragmentos), use o comando a seguir para descrever os detalhes do cluster [substitua *my-cluster* pelo nome do grupo de replicação (nome de seu cluster)]:
```
aws elasticache describe-replication-groups --replication-group-id my-cluster
```
Para obter mais informações, consulte a AWS CLI para o tópico do ElastiCache [https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html).
## Visualização dos detalhes de um cluster do ElastiCache (API do ElastiCache)
Você pode visualizar os detalhes de um cluster usando a ação `DescribeCacheClusters` da API do ElastiCache. Se o parâmetro `CacheClusterId` estiver incluído, os detalhes do cluster especificado serão retornados. Se o parâmetro `CacheClusterId` for omitido, os detalhes para até `MaxRecords` (padrão 100) clusters serão retornados. O valor para `MaxRecords` não pode ser inferior a 20 ou superior a 100.
O código a seguir lista os detalhes para `my-cluster`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=my-cluster
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
O código a seguir lista os detalhes para até 25 clusters.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&MaxRecords=25
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Para obter mais informações, consulte o tópico de referência da API do ElastiCache [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html).
# Modificação de um cluster do ElastiCache
Além de adicionar ou remover nós de um cluster do ElastiCache, pode haver momentos em que você precisará fazer outras alterações, 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 parâmetros de um cluster, a alteração é aplicada no cluster imediatamente ou após ele ser reiniciado. 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. Para determinar quando uma mudança de parâmetro particular é aplicada, consulte a seção **As alterações terão efeito** da coluna **Detalhes** nas tabelas de [Parâmetros específicos do Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached) e [Parâmetros do Valkey e do Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis). Para obter informações sobre como reinicializar um cluster, consulte [Reinicialização de nós](nodes.rebooting.md).
## Uso do Console de gerenciamento da AWS do ElastiCache
**Como modificar um cluster**
1. Faça login no Console de gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Na lista localizada no canto superior direito, escolha a região da AWS em que o cluster que você deseja modificar está localizado.
1. No painel de navegação, escolha o mecanismo em execução no cluster que deseja modificar.
É exibida uma lista dos clusters do mecanismo escolhido.
1. Na lista de clusters, no cluster que você deseja modificar, escolha seu nome.
1. Escolha **Actions** (Ações) e **Modify** (Modificar).
A janela **Modify Cluster** (Modificar cluster) é exibida.
1. Na janela **Modify Cluster** (Modificar cluster), faça as modificações desejadas. Entre as opções estão:
+ Descrição
+ Modo de cluster: para modificar o modo de cluster de **Desativado** para **Ativado**, você deve primeiro definir o modo de cluster como **Compatível**.
O modo compatível permite que seus clientes Valkey ou Redis OSS se conectem usando o modo de cluster habilitado e o modo de cluster desabilitado. Depois de migrar todos os clientes Valkey ou Redis OSS para usar o modo cluster habilitado, você poderá concluir a configuração do modo cluster e definir o modo cluster como **Habilitado**.
+ Compatibilidade de versão de mecanismo
**Importante**
Você pode atualizar para versões mais recentes do mecanismo. Se você atualizar as principais versões do mecanismo, por exemplo, de 5.0.6 para 6.0, será necessário selecionar uma família de grupo de parâmetros que seja compatível com a nova versão do mecanismo. Para obter mais informações para fazer isso, consulte [Gerenciamento de versões para ElastiCache](VersionManagement.md). No entanto, você não pode fazer downgrade para versões anteriores do mecanismo, exceto excluindo o cluster existente e criando-o novamente.
+ Grupos de segurança da VPC
+ Grupo do parâmetro
+ 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 mais informações, consulte [Classificação de dados em níveis](data-tiering.md).
+ Multi-AZ
+ Failover automático (somente no modo cluster desabilitado)
+ Habilitar backups automáticos
+ ID do nó de backup
+ Backup Retention Period
+ Janela de backup
+ Tópico para notificação do SNS
+ Compatibilidade de versão do mecanismo Memcached
+ Tipo de rede
**nota**
Se você estiver mudando de IPv4 para IPv6, deverá selecionar ou criar grupos de sub-rede compatíveis com IPv6. Para obter mais informações, consulte [Escolhendo um tipo de rede em ElastiCache](network-type.md).
+ Grupos de segurança da VPC
+ Grupo do parâmetro
+ Janela de manutenção
+ Tópico para notificação do SNS
A caixa **Apply Immediately (Aplicar imediatamente)** aplica-se apenas a modificações feitas no tipo de nó e na versão do mecanismo. Para aplicar alterações imediatamente, marque a caixa de seleção **Apply Immediately** (Aplicar imediatamente). Se essa caixa não for escolhida, as modificações feitas na versão do mecanismo serão aplicadas durante a próxima janela de manutenção. Outras modificações, como a alteração da janela de manutenção, são aplicadas imediatamente.
**Para habilitar/desabilitar a entrega de logs para o Redis**
1. Na lista de clusters, escolha o cluster que você deseja modificar. Selecione o **Cluster name** (Nome do cluster), e não a caixa de seleção ao lado dele.
1. Na página **Detalhes do cluster**, escolha a guia **Logs**.
1. Para habilitar/desabilitar logs lentos, escolha **Habilitar** ou **Desabilitar**.
Se você escolher habilitar:
1. Em **Log format** (Formato do log), escolha **JSON** ou **Text** (Texto).
1. Em **Log destination type** (Tipo de destino de log), escolha **CloudWatch Logs** (Logs do CloudWatch) ou **Kinesis Firehose**.
1. Em **Destino do log**, escolha **Criar novo** e insira o nome do grupo de logs do CloudWatchLogs ou o nome do stream do Kinesis Data Firehose. Você também pode escolher **Selecionar existente** e escolher o nome do grupo de logs do CloudWatchLogs ou o nome do stream do Kinesis Data Firehose.
1. Escolha **Habilitar**.
**Para alterar sua configuração para o Redis:**
1. Escolha **Modificar**.
1. Em **Log format** (Formato do log), escolha **JSON** ou **Text** (Texto).
1. Em **Destination Type** (Tipo de destino), escolha **CloudWatch Logs** (Logs do CloudWatch) ou **Kinesis Firehose**.
1. Em **Log destination** (Destino do log), escolha **Create new** (Criar) e insira o nome do grupo de logs do CloudWatchLogs ou o nome do stream do Kinesis Data Firehose. Ou escolha **Select existing** (Selecionar existente) e escolha o nome do grupo de logs do CloudWatchLogs ou o nome do stream do Kinesis Data Firehose.
## Uso da AWS CLI com o ElastiCache
Você pode modificar um cluster existente usando a operação AWS CLI `modify-cache-cluster`. 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.
**Importante**
Você pode atualizar para versões mais recentes do mecanismo Memcached. Para obter mais informações para fazer isso, consulte [Gerenciamento de versões para ElastiCache](VersionManagement.md). No entanto, você não pode fazer downgrade para versões anteriores do mecanismo, exceto excluindo o cluster existente e criando-o novamente.
**Importante**
Você pode atualizar para versões mais recentes do mecanismo Valkey ou Redis OSS. Se você atualizar as principais versões do mecanismo, por exemplo, do Redis OSS 5.0.6 para o Redis OSS 6.0, será preciso selecionar uma família de grupos de parâmetros que seja compatível com a nova versão do mecanismo. Para obter mais informações para fazer isso, consulte [Gerenciamento de versões para ElastiCache](VersionManagement.md). No entanto, você não pode fazer downgrade para versões anteriores do mecanismo, exceto excluindo o cluster existente e criando-o novamente.
Para Linux, macOS ou Unix:
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-cluster \
--preferred-maintenance-window sun:23:00-mon:02:00
```
Para Windows:
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-cluster ^
--preferred-maintenance-window sun:23:00-mon:02:00
```
O parâmetro `--apply-immediately` aplica-se apenas a modificações no tipo de nó, na versão do mecanismo e a alteração do número de nós em um cluster. Se quiser aplicar qualquer uma dessas alterações imediatamente, use o parâmetro `--apply-immediately`. Se preferir adiar essas alterações para sua próxima janela de manutenção, use o parâmetro `--no-apply-immediately`. Outras modificações, como a alteração da janela de manutenção, são aplicadas imediatamente.
Para obter mais informações, consulte a AWS CLI para o tópico do ElastiCache [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html).
## Uso da API do ElastiCache
Você pode modificar um cluster existente usando a operação `ModifyCacheCluster` da API do ElastiCache. 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.
**Importante**
Você pode atualizar para versões mais recentes do mecanismo Memcached. Para obter mais informações para fazer isso, consulte [Gerenciamento de versões para ElastiCache](VersionManagement.md). No entanto, você não pode fazer downgrade para versões anteriores do mecanismo, exceto excluindo o cluster existente e criando-o novamente.
**Importante**
Você pode atualizar para versões mais recentes do mecanismo Valkey ou Redis OSS. Se você atualizar as principais versões do mecanismo, por exemplo, do Redis OSS 5.0.6 para o Redis OSS 6.0, será preciso selecionar uma família de grupos de parâmetros que seja compatível com a nova versão do mecanismo. Para obter mais informações para fazer isso, consulte [Gerenciamento de versões para ElastiCache](VersionManagement.md). No entanto, você não pode fazer downgrade para versões anteriores do mecanismo, exceto excluindo o cluster existente e criando-o novamente.
As quebras de linha foram adicionadas para legibilidade.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&CacheClusterId=my-cluster
&PreferredMaintenanceWindow=sun:23:00-mon:02:00
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150901T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20150202T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20150901T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
O parâmetro `ApplyImmediately` aplica-se apenas a modificações no tipo de nó, na versão do mecanismo e a alteração do número de nós em um cluster. Se quiser aplicar qualquer uma dessas alterações imediatamente, defina o parâmetro `ApplyImmediately` como `true`. Se preferir adiar essas alterações para sua próxima janela de manutenção, defina o parâmetro `ApplyImmediately` como `false`. Outras modificações, como a alteração da janela de manutenção, são aplicadas imediatamente.
Para obter mais informações, consulte o tópico de referência da API do ElastiCache [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html).
# Adicionar nós a um ElastiCache cluster
Adicionar nós a um cluster Memcached aumenta o número de partições do seu cluster. Quando você altera o número de partições em um cluster, alguns dos principais espaços precisam ser remapeados para que sejam mapeados para o nó direito. Remapear espaços de chave aumenta temporariamente o número de falhas de cache no cluster. Para obter mais informações, consulte [Configurando seu ElastiCache cliente para balanceamento de carga eficiente (Memcached)](BestPractices.LoadBalancing.md).
Para reconfigurar o cluster do Valkey ou Redis OSS (modo cluster habilitado), consulte [Escalabilidade de clusters no Valkey ou Redis OSS (modo cluster habilitado)](scaling-redis-cluster-mode-enabled.md)
Você pode usar o ElastiCache Management Console AWS CLI ou a ElastiCache API para adicionar nós ao seu cluster.
## Usando o ElastiCache Console de gerenciamento da AWS
Se você quiser adicionar um nó a um cluster do Valkey ou Redis OSS (modo cluster desabilitado) de nó único (sem replicação habilitada), o processo será de duas etapas: primeiro adicione a replicação e, depois, adicione um nó de réplica.
**Tópicos**
+ [Para adicionar replicação a um cluster do Valkey ou Redis OSS sem fragmentos](#AddReplication.CON)
+ [Para adicionar nós a um ElastiCache cluster (console)](#AddNode.CON)
O procedimento a seguir adiciona replicação a um Valkey ou Redis OSS de nó único que não possui replicação habilitada. Quando você adiciona replicação, o nó existente torna-se o nó primário no cluster habilitado para replicação. Depois que a replicação é adicionada, você pode adicionar até 5 nós de réplica ao cluster.
**Para adicionar replicação a um cluster do Valkey ou Redis OSS sem fragmentos**
1. Faça login no Console de gerenciamento da AWS e abra o ElastiCache console em [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel de navegação, escolha **Clusters do Valkey** ou **Clusters do Redis OSS**.
Uma lista de clusters que executam o mecanismo Valkey ou Redis OSS é exibida.
1. Escolha o nome de um cluster (não a caixa à esquerda do nome do cluster) ao qual você quer adicionar nós.
O seguinte é verdade para um cluster do Redis OSS que não possui replicação habilitada:
+ Ele está executando o Redis OSS, e não o Clustered Redis OSS.
+ Tem zero estilhaços.
Se o cluster tiver estilhaços, a replicação já estará ativada e você poderá continuar em [Para adicionar nós a um ElastiCache cluster (console)](#AddNode.CON).
1. Escolha **Add replication**.
1. Em **Adicionar replicação**, insira uma descrição para esse cluster habilitado para replicação.
1. Escolha **Adicionar**.
Assim que o status do cluster retornar *available*, você poderá continuar no próximo procedimento e adicionar réplicas ao cluster.
**Para adicionar nós a um ElastiCache cluster (console)**
O procedimento a seguir pode ser usado para adicionar nós a um cluster.
1. Faça login no Console de gerenciamento da AWS e abra o ElastiCache console em [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel de navegação, escolha o mecanismo em execução no cluster ao qual você deseja adicionar nós.
É exibida uma lista de clusters que executam o mecanismo escolhido.
1. Na lista de clusters, no cluster ao qual você deseja adicionar um nó, escolha seu nome.
Se o cluster for um cluster do Valkey ou Redis OSS (modo cluster habilitado), consulte [Escalabilidade de clusters no Valkey ou Redis OSS (modo cluster habilitado)](scaling-redis-cluster-mode-enabled.md).
Se o cluster é um cluster do Valkey ou Redis OSS (modo cluster desabilitado) com zero fragmentos, primeiro conclua as etapas em [Para adicionar replicação a um cluster do Valkey ou Redis OSS sem fragmentos](#AddReplication.CON).
1. Escolha **Adicionar nó**.
1. Preencha as informações solicitadas na caixa de diálogo **Add Node (Adicionar nó)**.
1. Escolha o botão **Apply Immediately - Yes (Aplicar imediatamente - sim)** para aplicar essa alteração imediatamente ou escolha **No (Não)** para adicionar este nó durante a próxima janela de manutenção do cluster.
**Impacto de novas solicitações de adição e remoção em solicitações pendentes**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/Clusters.AddNode.html)
Para determinar quais operações estão pendentes, escolha a opção **Description** (Descrição) e verifique para ver quantas criações ou exclusões pendentes são mostradas. Você não pode ter criações pendentes e exclusões pendentes.
1. Escolha o botão **Add**.
Depois de alguns momentos, os novos nós deverão aparecer na lista de nós com um status de **creating**. Se não aparecem, atualize a página do navegador. Quando o status mudar para *available do nó* do novo nó pode ser usado.
## Usando o AWS CLI com ElastiCache
Para adicionar nós a um cluster usando o AWS CLI, use a AWS CLI operação `modify-cache-cluster` com os seguintes parâmetros:
+ `--cache-cluster-id`: o ID do cluster ao qual você deseja adicionar os nós.
+ `--num-cache-nodes`: o parâmetro `--num-cache-nodes` especifica o número de nós que você deseja neste cluster após a modificação ser aplicada. Para adicionar nós a esse cluster, `--num-cache-nodes` deve ser maior que o número atual de nós neste cluster. Se esse valor for menor que o número atual de nós, ElastiCache espera que o parâmetro `cache-node-ids-to-remove` e uma lista de nós sejam removidos do cluster. Para obter mais informações, consulte [Usando o AWS CLI com ElastiCache](Clusters.DeleteNode.md#Clusters.DeleteNode.CLI).
+ `--apply-immediately` ou `--no-apply-immediately`, que especifica se você deve adicionar esses nós imediatamente ou na próxima janela de manutenção.
Para Linux, macOS ou Unix:
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-cluster \
--num-cache-nodes 5 \
--apply-immediately
```
Para Windows:
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-cluster ^
--num-cache-nodes 5 ^
--apply-immediately
```
Esta operação produz uma saída semelhante à seguinte (formato JSON):
```
{
"CacheCluster": {
"Engine": "memcached",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "my-cluster",
"PreferredAvailabilityZone": "us-west-2b",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "rlh-mem000.7alc7bf-example.cfg.usw2.cache.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-09-21T16:28:28.973Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "modifying",
"NumCacheNodes": 2,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {
"NumCacheNodes": 5
},
"PreferredMaintenanceWindow": "sat:09:00-sat:10:00",
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
}
}
```
Para obter mais informações, consulte o AWS CLI tópico [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html).
## Usando o AWS CLI com ElastiCache
Se quiser adicionar nós a um cluster existente do Valkey ou Redis OSS (modo cluster desabilitado) que não tenha a replicação habilitada, você deverá primeiro criar o grupo de replicação especificando o cluster existente como primário. Para obter mais informações, consulte [Criação de um grupo de replicação usando um cluster do Valkey ou Redis OSS disponível (AWS CLI)](Replication.CreatingReplGroup.ExistingCluster.md#Replication.CreatingReplGroup.ExistingCluster.CLI). Depois que o grupo de replicação estiver *disponível*, você poderá continuar com o processo a seguir.
Para adicionar nós a um cluster usando o AWS CLI, use a AWS CLI operação `increase-replica-count` com os seguintes parâmetros:
+ `--replication-group-id`: o ID do grupo de replicação ao qual você deseja adicionar nós.
+ `--new-replica-count`: especifica o número de nós que você deseja neste grupo de replicação após a modificação ser aplicada. Para adicionar nós a esse cluster, `--new-replica-count` deve ser maior que o número atual de nós neste cluster.
+ `--apply-immediately` ou `--no-apply-immediately`, que especifica se você deve adicionar esses nós imediatamente ou na próxima janela de manutenção.
Para Linux, macOS ou Unix:
```
aws elasticache increase-replica-count \
--replication-group-id my-replication-group \
--new-replica-count 4 \
--apply-immediately
```
Para Windows:
```
aws elasticache increase-replica-count ^
--replication-group-id my-replication-group ^
--new-replica-count 4 ^
--apply-immediately
```
Esta operação produz uma saída semelhante à seguinte (formato JSON):
```
{
"ReplicationGroup": {
"ReplicationGroupId": "node-test",
"Description": "node-test",
"Status": "modifying",
"PendingModifiedValues": {},
"MemberClusters": [
"node-test-001",
"node-test-002",
"node-test-003",
"node-test-004",
"node-test-005"
],
"NodeGroups": [
{
"NodeGroupId": "0001",
"Status": "modifying",
"PrimaryEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"ReaderEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"NodeGroupMembers": [
{
"CacheClusterId": "node-test-001",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-001.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2a",
"CurrentRole": "primary"
},
{
"CacheClusterId": "node-test-002",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-002.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-003",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-003.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
}
]
}
],
"SnapshottingClusterId": "node-test-002",
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotRetentionLimit": 1,
"SnapshotWindow": "07:30-08:30",
"ClusterEnabled": false,
"CacheNodeType": "cache.r5.large",
"DataTiering": "disabled",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"ARN": "arn:aws:elasticache:us-west-2:123456789012:replicationgroup:node-test"
}
}
```
Para obter mais informações, consulte o AWS CLI tópico [https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html).
## Usando a ElastiCache API
Se quiser adicionar nós a um cluster existente do Valkey ou Redis OSS (modo cluster desabilitado) que não tenha a replicação habilitada, você deverá primeiro criar o grupo de replicação especificando o cluster existente como primário. Para obter mais informações, consulte [Adicionar réplicas a um cluster (API) autônomo Valkey ou Redis OSS (modo de cluster desativado) ElastiCache](Replication.CreatingReplGroup.ExistingCluster.md#Replication.CreatingReplGroup.ExistingCluster.API). Depois que o grupo de replicação estiver *disponível*, você poderá continuar com o processo a seguir.
**Para adicionar nós a um cluster (ElastiCache API)**
+ Chame a operação de API `IncreaseReplicaCount` com os seguintes parâmetros:
+ `ReplicationGroupId`: o ID do cluster ao qual você deseja adicionar os nós.
+ `NewReplicaCount`: o parâmetro `NewReplicaCount` especifica o número de nós que você deseja neste cluster após a modificação ser aplicada. Para adicionar nós a esse cluster, `NewReplicaCount` deve ser maior que o número atual de nós neste cluster. Se esse valor for inferior ao número atual de nós, use a API `DecreaseReplicaCount` com o número de nós a serem removidos do cluster.
+ `ApplyImmediately` Especifica se você deve adicionar esses nós imediatamente ou na próxima janela de manutenção.
+ `Region`Especifica a AWS região do cluster à qual você deseja adicionar nós.
O exemplo a seguir mostra uma chamada para adicionar nós a um cluster.
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=IncreaseReplicaCount
&ApplyImmediately=true
&NumCacheNodes=4
&ReplicationGroupId=my-replication-group
&Region=us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Para obter mais informações, consulte o tópico ElastiCache da API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html).
## Usando a ElastiCache API
**Para adicionar nós a um cluster (ElastiCache API)**
+ Chame a operação de API `ModifyCacheCluster` com os seguintes parâmetros:
+ `CacheClusterId`: o ID do cluster ao qual você deseja adicionar os nós.
+ `NumCacheNodes`: o parâmetro `NumCachNodes` especifica o número de nós que você deseja neste cluster após a modificação ser aplicada. Para adicionar nós a esse cluster, `NumCacheNodes` deve ser maior que o número atual de nós neste cluster. Se esse valor for menor que o número atual de nós, ElastiCache espera que o parâmetro `CacheNodeIdsToRemove` com uma lista de nós seja removido do cluster (consulte[Usando a ElastiCache API com o Memcached](Clusters.DeleteNode.md#Clusters.DeleteNode.API)).
+ `ApplyImmediately` Especifica se você deve adicionar esses nós imediatamente ou na próxima janela de manutenção.
+ `Region`Especifica a AWS região do cluster à qual você deseja adicionar nós.
O exemplo a seguir mostra uma chamada para adicionar nós a um cluster.
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&ApplyImmediately=true
&NumCacheNodes=5
&CacheClusterId=my-cluster
&Region=us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Para obter mais informações, consulte o tópico ElastiCache da API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html).
# Removendo nós de um ElastiCache cluster
Você pode excluir um nó de um cluster OSS Valkey, Memcached ou Redis usando a Console de gerenciamento da AWS, a ou a AWS CLI API. ElastiCache
**nota**
Cada vez que você altera o número de nós em um cluster Memcached, você deve remapear pelo menos alguns dos seus espaços de chaves para que ele seja mapeado para o nó correto. Para obter informações mais detalhadas sobre o balanceamento de carga de um cluster Memcached, consulte [Configurando seu ElastiCache cliente para balanceamento de carga eficiente (Memcached)](BestPractices.LoadBalancing.md).
## Usando o ElastiCache Console de gerenciamento da AWS
**Para remover nós de um cluster (console)**
1. Faça login no Console de gerenciamento da AWS e abra o ElastiCache console em [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Na lista no canto superior direito, escolha a AWS região do cluster da qual você deseja remover os nós.
1. No painel de navegação, escolha o mecanismo em execução no cluster do qual você deseja remover um nó.
É exibida uma lista de clusters que executam o mecanismo escolhido.
1. Na lista de clusters, escolha o nome do cluster do qual você deseja remover um nó.
É exibida uma lista dos nós do cluster.
1. Escolha a caixa à esquerda do ID do nó para o nó que você deseja remover. Usando o console do ElastiCache , é possível excluir somente um nó de cada vez. Portanto, escolher vários nós significa que não é possível usar o botão **Excluir nó**.
A página *Excluir nó* é exibida.
1. Para excluir o nó, preencha a página **Excluir nó** e escolha **Excluir nó**. Para manter o nó, escolha **Cancelar**.
**Importante**
Com o Valkey ou Redis OSS, se você estiver excluindo os resultados do nó no cluster que não são mais compatíveis com Multi-AZ, certifique-se primeiro de desmarcar a caixa de seleção **Multi-AZ** e depois excluir o nó. Se você desmarcar a caixa de seleção **Multi-AZ**, será possível optar por habilitar o **Failover automático**.
**Impacto de novas solicitações de adição e remoção em solicitações pendentes**
| Cenários | Operação pendente | Nova solicitação | Resultados |
| --- | --- | --- | --- |
| Cenário 1 | Delete | Delete | A nova solicitação de exclusão, pendente ou imediata, substitui a solicitação de exclusão pendente. Por exemplo, se os nós 0001, 0003 e 0007 estiverem pendentes de exclusão e uma nova solicitação para excluir os nós 0002 e 0004 for emitida, somente os nós 0002 e 0004 serão excluídos. Os nós 0001, 0003 e 0007 não serão excluídos. |
| Cenário 2 | Delete | Criar | A nova solicitação de criação, pendente ou imediata, substitui a solicitação de exclusão pendente. Por exemplo, se os nós 0001, 0003 e 0007 estiverem pendentes de exclusão e uma nova solicitação para criar um nó for emitida, um novo nó será criado e os nós 0001, 0003 e 0007 não serão excluídos. |
| Cenário 3 | Criar | Delete | A nova solicitação de exclusão, pendente ou imediata, substitui a solicitação de criação pendente. Por exemplo, se houver uma solicitação pendente para criar dois nós e uma nova solicitação for emitida para excluir o nó 0003, nenhum novo nó será criado e o nó 0003 será excluído. |
| Cenário 4 | Criar | Criar | A nova solicitação de criação é adicionada à solicitação de criação pendente. Por exemplo, se houver uma solicitação pendente para criar dois nós e uma nova solicitação for emitida para criar três nós, as novas solicitações serão adicionadas à solicitação pendente e cinco nós serão criados. Se a nova solicitação de criação estiver definida como **Apply immediately - Yes** (Aplicar imediatamente - Sim), todas as solicitações de criação são executadas imediatamente. Se a nova solicitação de criação estiver definida como **Apply immediately - No** (Aplicar imediatamente - No), todas as solicitações de criação ficam pendentes. |
Para determinar quais operações estão pendentes, escolha a opção **Description** (Descrição) e verifique para ver quantas criações ou exclusões pendentes são mostradas. Você não pode ter criações pendentes e exclusões pendentes.
## Usando o AWS CLI com ElastiCache
1. Identifique IDs os nós que você deseja remover. Para obter mais informações, consulte [Visualização dos detalhes de um cluster do ElastiCache](Clusters.ViewDetails.md).
1. Use a operação `decrease-replica-count` 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 `decrease-replica-count` com os seguintes parâmetros:
+ `--replication-group-id`: o ID do grupo de replicação do qual você deseja remover nós.
+ `--new-replica-count`: o parâmetro `--new-replica-count` especifica o número de nós que você deseja neste cluster após a modificação ser aplicada.
+ `--replicas-to-remove`Uma lista de nós IDs que você deseja remover desse cluster.
+ `--apply-immediately` ou `--no-apply-immediately` especifica se você deve remover esses nós imediatamente ou na próxima janela de manutenção.
+ `--region`Especifica a AWS região do cluster da qual você deseja remover os nós.
**nota**
Você pode passar apenas um dos parâmetros `--replicas-to-remove` ou `--new-replica-count` ao chamar esta operação.
Para Linux, macOS ou Unix:
```
aws elasticache decrease-replica-count \
--replication-group-id my-replication-group \
--new-replica-count 2 \
--region us-east-2 \
--apply-immediately
```
Para Windows:
```
aws elasticache decrease-replica-count ^
--replication-group-id my-replication-group ^
--new-replica-count 3 ^
--region us-east-2 ^
--apply-immediately
```
Esta operação produz uma saída semelhante à seguinte (formato JSON):
```
{
"ReplicationGroup": {
"ReplicationGroupId": "node-test",
"Description": "node-test"
},
"Status": "modifying",
"PendingModifiedValues": {},
"MemberClusters": [
"node-test-001",
"node-test-002",
"node-test-003",
"node-test-004",
"node-test-005",
"node-test-006"
],
"NodeGroups": [
{
"NodeGroupId": "0001",
"Status": "modifying",
"PrimaryEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"ReaderEndpoint": {
"Address": "node-test-ro.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"NodeGroupMembers": [
{
"CacheClusterId": "node-test-001",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-001.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2a",
"CurrentRole": "primary"
},
{
"CacheClusterId": "node-test-002",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-002.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-003",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-003.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-004",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-004.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-005",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-005.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-006",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-006.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
}
]
}
],
"SnapshottingClusterId": "node-test-002",
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotRetentionLimit": 1,
"SnapshotWindow": "07:30-08:30",
"ClusterEnabled": false,
"CacheNodeType": "cache.r5.large",
"DataTiering": "disabled",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"ARN": "arn:aws:elasticache:us-west-2:123456789012:replicationgroup:node-test"
}
}
```
Alternativamente, você também poderia chamar o `decrease-replica-count` e, em vez de passar o parâmetro `--new-replica-count`, você pode passar o parâmetro `--replicas-to-remove`, como mostrado a seguir:
Para Linux, macOS ou Unix:
```
aws elasticache decrease-replica-count \
--replication-group-id my-replication-group \
--replicas-to-remove node-test-003 \
--region us-east-2 \
--apply-immediately
```
Para Windows:
```
aws elasticache decrease-replica-count ^
--replication-group-id my-replication-group ^
--replicas-to-remove node-test-003 ^
--region us-east-2 ^
--apply-immediately
```
Para obter mais informações, consulte os AWS CLI tópicos [https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html).
## Usando a ElastiCache API com Valkey ou Redis OSS
Para remover nós usando a ElastiCache API, chame a operação da `DecreaseReplicaCount` API com o ID do grupo de replicação e uma lista de nós a serem removidos, conforme mostrado:
+ `ReplicationGroupId`: o ID do grupo de replicação do qual você deseja remover nós.
+ `ReplicasToRemove`: o parâmetro `ReplicasToRemove` especifica o número de nós que você deseja neste cluster após a modificação ser aplicada.
+ `ApplyImmediately` Especifica se você deve remover esses nós imediatamente ou na próxima janela de manutenção.
+ `Region`Especifica a AWS região do cluster da qual você deseja remover um nó.
O exemplo a seguir remove imediatamente os nós 0004 e 0005 do cluster my-cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DecreaseReplicaCount
&ReplicationGroupId=my-replication-group
&ApplyImmediately=true
&ReplicasToRemove=node-test-003
&Region us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Para obter mais informações, consulte o tópico ElastiCache da API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html).
## Usando a ElastiCache API com o Memcached
Para remover nós usando a ElastiCache API, chame a operação da `ModifyCacheCluster` API com o ID do cluster de cache e uma lista de nós a serem removidos, conforme mostrado:
+ `CacheClusterId` o ID do cluster de cache do qual você deseja remover nós.
+ `NumCacheNodes`: o parâmetro `NumCacheNodes` especifica o número de nós que você deseja neste cluster após a modificação ser aplicada.
+ `CacheNodeIdsToRemove.member.n`A lista de nós IDs a serem removidos do cluster.
+ `CacheNodeIdsToRemove.member.1=0004`
+ `CacheNodeIdsToRemove.member.1=0005`
+ `ApplyImmediately` Especifica se você deve remover esses nós imediatamente ou na próxima janela de manutenção.
+ `Region`Especifica a AWS região do cluster da qual você deseja remover um nó.
O exemplo a seguir remove imediatamente os nós 0004 e 0005 do cluster my-cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&CacheClusterId=my-cluster
&ApplyImmediately=true
&CacheNodeIdsToRemove.member.1=0004
&CacheNodeIdsToRemove.member.2=0005
&NumCacheNodes=3
&Region us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Para obter mais informações, consulte o tópico ElastiCache da API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html).
# Cancelamento de operações de adição ou exclusão de nós pendentes no ElastiCache
Se você tiver optado por não aplicar uma alteração de cluster do ElastiCache imediatamente, a operação terá o status **pendente** até que seja realizada na sua próxima janela de manutenção. Você pode cancelar qualquer operação pendente de adição ou exclusão.
Para cancelar uma operação pendente de adição ou exclusão de nó com o AWS CLI, use o comando `modify-cache-cluster`. Defina `num-cache-nodes` igual ao número atual de nós de cache no cluster e, em seguida, adicione o sinalizador `--apply-immediately`. Isso substituirá a alteração pendente.
Para cancelar a adição ou exclusão de um nó pendente:
```
aws elasticache modify-cache-cluster
--cache-cluster-id
--num-cache-nodes
--apply-immediately
```
Se não estiver claro se alguma adição ou exclusão de nó está pendente, você pode confirmar seu status com o comando `describe-cache-clusters`:
```
aws elasticache describe-cache-clusters
--cache-cluster-id
```
Todos os nós pendentes devem aparecer na saída `PendingModifiedValues`. Por exemplo:
```
"PendingModifiedValues": {
"NumCacheNodes": 3
},
```
# Excluindo um cluster no ElastiCache
Enquanto um ElastiCache cluster estiver no estado *disponível*, você será cobrado por ele, esteja ou não o usando ativamente. Para interromper as cobranças, exclua o cluster.
**Atenção**
Quando você exclui um ElastiCache cluster, seus instantâneos manuais são retidos. Também é possível criar um snapshot final antes que o cluster seja excluído. Os snapshots de cache automáticos não são retidos.
## Usando o Console de gerenciamento da AWS
O procedimento a seguir exclui um único cluster da sua implantação. Para excluir vários clusters, repita o procedimento para cada cluster que deseja excluir. Você não precisa esperar a finalização da exclusão de um cluster antes de iniciar o procedimento para excluir outro.
**Para excluir um cluster**
1. Faça login no Console de gerenciamento da AWS e abra o ElastiCache console da Amazon em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel do ElastiCache mecanismo, escolha o mecanismo que está sendo executado no cluster que você deseja excluir.
É exibida uma lista de todos os clusters que executam esse mecanismo.
1. Para escolher o cluster a ser excluído, escolha o nome na lista de clusters.
**Importante**
Você só pode excluir um cluster por vez do ElastiCache console. Escolher vários clusters desabilita a operação de exclusão.
1. Em **Ações**, escolha **Excluir**.
1. Na tela de confirmação **Excluir cluster**, escolha **Excluir** para excluir o cluster ou **Cancelar** para mantê-lo.
Se você escolheu **Excluir**, o status do cluster muda para *excluindo*.
Assim que o cluster não estiver mais relacionado na lista de clusters, você para de ser cobrado por ele.
## Usando o AWS CLI para excluir um ElastiCache cluster
O código a seguir exclui o ElastiCache cluster`my-cluster`.
```
aws elasticache delete-cache-cluster --cache-cluster-id my-cluster
```
A ação `delete-cache-cluster` da CLI apenas exclui um cluster. Para excluir vários clusters, chame `delete-cache-cluster` para cada cluster de cache que você deseja excluir. Você não precisa esperar a finalização da exclusão de um cluster antes de excluir outro.
Para Linux, macOS ou Unix:
```
aws elasticache delete-cache-cluster \
--cache-cluster-id my-cluster \
--region us-east-2
```
Para Windows:
```
aws elasticache delete-cache-cluster ^
--cache-cluster-id my-cluster ^
--region us-east-2
```
Para obter mais informações, consulte o ElastiCache tópico AWS CLI for [https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html).
## Usando a ElastiCache API
O código a seguir exclui o cluster `my-cluster`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DeleteCacheCluster
&CacheClusterId=my-cluster
&Region us-east-2
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20150202T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20150202T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
A operação `DeleteCacheCluster` da API exclui apenas um cluster. Para excluir vários clusters, chame `DeleteCacheCluster` para cada cluster que você deseja excluir. Você não precisa esperar a finalização da exclusão de um cluster antes de excluir outro.
Para obter mais informações, consulte o tópico de referência ElastiCache da API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheCluster.html).
# Acessando seu ElastiCache cluster ou grupo de replicação
Suas ElastiCache instâncias da Amazon foram projetadas para serem acessadas por meio de uma EC2 instância da Amazon.
Se você lançou sua ElastiCache instância em uma Amazon Virtual Private Cloud (Amazon VPC), você pode acessar sua ElastiCache instância de uma instância da Amazon na EC2 mesma Amazon VPC. Ou, usando o emparelhamento de VPC, você pode acessar sua ElastiCache instância de uma Amazon EC2 em uma Amazon VPC diferente.
Se você lançou sua ElastiCache instância no EC2 Classic, você permite que a EC2 instância acesse seu cluster concedendo ao grupo de EC2 segurança da Amazon associado à instância acesso ao seu grupo de segurança de cache. Por padrão, o acesso a um cluster é restrito à conta que o executou.
**Topics**
+ [Concessão de acesso ao clusterou grupo de replicação](#grant-access)
## Concessão de acesso ao clusterou grupo de replicação
### Você lançou seu cluster em EC2 -VPC
Se você lançou seu cluster em uma Amazon Virtual Private Cloud (Amazon VPC), você pode se conectar ao seu ElastiCache cluster somente a partir de uma EC2 instância da Amazon que esteja sendo executada na mesma Amazon VPC. Nesse caso, você precisará conceder entrada de rede ao cluster.
**nota**
Se você estiver usando *Local Zones* (Zonas locais), verifique se você as habilitou. Para obter mais informações, consulte [Habilitar zonas locais](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/using-regions-availability-zones.html#opt-in-local-zone). Ao fazer isso, sua VPC é estendida para essa zona local e sua VPC tratará a sub-rede como qualquer sub-rede em qualquer outra zona de disponibilidade, e gateways relevantes, tabelas de rota e outras considerações de grupos de segurança serão ajustados automaticamente.
**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 EC2 console da Amazon em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, 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 ElastiCache uso, esse grupo de segurança será denominado *padrão*.
1. Escolha a guia **Inbound** e faça o seguinte:
1. Escolha **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 do Memcached é **11211** A porta padrão do Valkey e Redis OSS é **6379**.
1. Na caixa **Fonte**, escolha **Qualquer lugar** que tenha o intervalo de portas (0.0.0.0/0) para que qualquer EC2 instância da Amazon que você iniciar na sua Amazon VPC possa se conectar aos seus nós. ElastiCache
**Importante**
Abrir o ElastiCache cluster para 0.0.0.0/0 não o expõe à Internet porque ele não tem 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 EC2 instâncias da Amazon 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 ElastiCache. 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ê executa uma EC2 instância da Amazon em sua Amazon VPC, essa instância poderá se conectar ao seu ElastiCache cluster.
### Acessando ElastiCache recursos de fora AWS
A Amazon ElastiCache é um AWS serviço que fornece armazenamento de valores-chave na memória baseado em nuvem. O serviço foi projetado para ser acessado exclusivamente de dentro AWS. No entanto, se o ElastiCache cluster estiver hospedado em uma VPC, você poderá usar uma instância de Network Address Translation (NAT) para fornecer acesso externo.
#### Requisitos
Os seguintes requisitos devem ser atendidos para que você possa acessar seus ElastiCache recursos de fora AWS:
+ O cluster deve residir em uma VPC e ser acessado por meio de uma instância NAT (Conversão de endereços de rede). Não existem exceções para esse requerimento.
+ A instância NAT deve ser executada na mesma VPC que o cluster.
+ A instância NAT deve ser iniciada em uma sub-rede pública separada do cluster.
+ Um endereço IP elástico (EIP) deve ser associado à instância NAT. O recurso de encaminhamento de porta de iptables é usado para encaminhar uma porta na instância NAT à porta do nó de cache na VPC.
#### Considerações
As seguintes considerações devem ser mantidas em mente ao acessar seus recursos do ElastiCache de fora do ElastiCache.
+ Os clientes se conectam ao EIP e à porta de cache da instância NAT. O encaminhamento de porta na instância NAT direciona o tráfego ao nó do cluster apropriado.
+ Se um nó de cluster for adicionado ou substituído, as regras de iptables precisarão ser atualizadas para refletir essa alteração.
#### Limitações
Essa abordagem deve ser usada somente para fins de teste e desenvolvimento. Ela não é recomendada para uso em produção devido às seguintes limitações:
+ A instância NAT está atuando como um proxy entre clientes e vários clusters. A adição de um proxy afeta o desempenho do cluster. O impacto aumenta com o número de clusters que você está acessando por meio da instância NAT.
+ O tráfego dos clientes para a instância NAT não é criptografado. Portanto, você deve evitar o envio de dados confidenciais através da instância NAT.
+ A instância NAT acrescenta a sobrecarga de manter outra instância.
+ A instância NAT serve como um único ponto de falha. Para obter informações sobre como configurar o NAT de alta disponibilidade na VPC, consulte [Alta disponibilidade para instâncias NAT da Amazon VPC: um exemplo](https://aws.amazon.com/articles/2781451301784570).
#### Como acessar ElastiCache recursos de fora AWS
O procedimento a seguir demonstra como se conectar aos seus ElastiCache recursos usando uma instância NAT.
Estas etapas assumem o seguinte:
+ `iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6380 -j DNAT --to 10.0.1.231:6379`
+ `iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6381 -j DNAT --to 10.0.1.232:6379`
Em seguida, você precisa da NAT na direção oposta:
`iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 10.0.0.55`
Você também precisa habilitar o encaminhamento de IP, que permanece desabilitado por padrão:
`sudo sed -i 's/net.ipv4.ip_forward=0/net.ipv4.ip_forward=1/g' /etc/sysctl.conf sudo sysctl --system`
+ Você está acessando um cluster Memcached com:
+ Endereço IP: *10.0.1.230*
+ Porta Memcached padrão: *11211*
+ Grupo de segurança: *\$110\$1.0\$1.0\$1.55\$1*
+ Você está acessando um cluster do Valkey ou Redis OSS com:
+ Endereço IP: *10.0.1.230*
+ Porta padrão: *6379*
+ Grupo de segurança: *sg-bd56b7da*
+ AWS endereço IP da instância — *198.99.100.27*
+ Seu cliente confiável possui o endereço IP *198.51.100.27*.
+ Sua instância NAT possui o endereço IP elástico *203.0.113.73*.
+ Sua instância NAT tem o security group *sg-ce56b7a9*.
**Para se conectar aos seus ElastiCache recursos usando uma instância NAT**
1. Crie uma instância NAT na mesma VPC que o seu cluster, mas em uma sub-rede pública.
Por padrão, o assistente da VPC iniciará um tipo de nó *cache.m1.small*. Você deve selecionar um tamanho de nó conforme as suas necessidades. Você deve usar o EC2 NAT AMI para poder acessar ElastiCache de fora AWS.
Para obter informações sobre como criar uma instância NAT, consulte [Instâncias NAT no Guia](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html) do usuário da AWS VPC.
1. Crie regras de grupo de segurança para o cluster e a instância NAT.
O grupo de segurança da instância NAT e a instância do cluster devem ter as seguintes regras:
+ Duas regras de entrada
+ Com o Memcached, a primeira regra é permitir conexões TCP de clientes confiáveis com cada porta de cache reencaminhada da instância NAT (11211 a 11213).
+ Com Valkey e Redis OSS, a primeira regra é permitir conexões TCP de clientes confiáveis com cada porta de cache reencaminhada da instância NAT (6379 a 6381).
+ Uma segunda regra para permitir acesso SSH a clientes confiáveis.
**Grupo de segurança da instância NAT: regras de entrada com o Memcached**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/accessing-elasticache.html)
**Grupo de segurança da instância NAT: regras de entrada com Valkey ou Redis OSS**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Com o Memcached, uma regra de saída para permitir conexões TCP para a porta de cache (11211).
**Grupo de segurança da instância NAT: regra de saída**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Com o Valkey ou Redis OSS, uma regra de saída para permitir conexões TCP para a porta de cache (6379).
**Grupo de segurança da instância NAT: regra de saída**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Com o Memcached, uma regra de entrada para o grupo de segurança do cluster que permite conexões TCP da instância NAT com a porta de cache (11211).
**Grupo de segurança da instância do cluster: regra de entrada**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Com o Valkey ou Redis OSS, uma regra de entrada para o grupo de segurança do cluster que permite conexões TCP da instância NAT com a porta de cache (6379).
**Grupo de segurança da instância do cluster: regra de entrada**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/accessing-elasticache.html)
1. Valide as regras.
+ Confirme se o cliente confiável é capaz de fazer SSH para a instância NAT.
+ Confirme se o cliente confiável pode se conectar ao cluster a partir da instância NAT.
1. **Memcached**
Adicione uma regra iptables à instância NAT.
Uma regra iptables deve ser adicionada à tabela NAT para cada nó no cluster para encaminhar a porta de cache da instância NAT ao nó do cluster. Um exemplo pode ser o seguinte:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11211 -j DNAT --to 10.0.1.230:11211
```
O número da porta deve ser exclusivo para cada nó no cluster. Por exemplo, se estiver trabalhando com um cluster Memcached de três nós usando as portas 11211 - 11213, as regras seriam as seguintes:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11211 -j DNAT --to 10.0.1.230:11211
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11212 -j DNAT --to 10.0.1.231:11211
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11213 -j DNAT --to 10.0.1.232:11211
```
Confirme se o cliente confiável pode se conectar ao cluster.
O cliente confiável deve se conectar ao EIP associado à instância NAT e à porta de cluster correspondente ao nó de cluster apropriado. Por exemplo, a string de conexão para o PHP pode ser o seguinte:
```
$memcached->connect( '203.0.113.73', 11211 );
$memcached->connect( '203.0.113.73', 11212 );
$memcached->connect( '203.0.113.73', 11213 );
```
Um cliente telnet também pode ser usado para verificar a conexão. Por exemplo:
```
telnet 203.0.113.73 11211
telnet 203.0.113.73 11212
telnet 203.0.113.73 11213
```
**Valkey ou Redis OSS**
Adicione uma regra iptables à instância NAT.
Uma regra iptables deve ser adicionada à tabela NAT para cada nó no cluster para encaminhar a porta de cache da instância NAT ao nó do cluster. Um exemplo pode ser o seguinte:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6379 -j DNAT --to 10.0.1.230:6379
```
O número da porta deve ser exclusivo para cada nó no cluster. Por exemplo, se estiver trabalhando com um cluster do Redis OSS de três nós usando as portas 6379 a 6381, as regras seriam as seguintes:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6379 -j DNAT --to 10.0.1.230:6379
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6380 -j DNAT --to 10.0.1.231:6379
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6381 -j DNAT --to 10.0.1.232:6379
```
Confirme se o cliente confiável pode se conectar ao cluster.
O cliente confiável deve se conectar ao EIP associado à instância NAT e à porta de cluster correspondente ao nó de cluster apropriado. Por exemplo, a string de conexão para o PHP pode ser o seguinte:
```
redis->connect( '203.0.113.73', 6379 );
redis->connect( '203.0.113.73', 6380 );
redis->connect( '203.0.113.73', 6381 );
```
Um cliente telnet também pode ser usado para verificar a conexão. Por exemplo:
```
telnet 203.0.113.73 6379
telnet 203.0.113.73 6380
telnet 203.0.113.73 6381
```
1. Salve a configuração iptables.
Salve as regras depois de testá-las e verificá-las. Se você estiver usando uma distribuição Linux baseada no Redhat (como o Amazon Linux), execute o seguinte comando:
```
service iptables save
```
#### Tópicos relacionados
Os tópicos a seguir podem ser de seu interesse.
+ [Padrões de acesso para acessar um cache do ElastiCache em um Amazon VPC](elasticache-vpc-accessing.md)
+ [Acesso a um cache do ElastiCache a partir de uma aplicação executada no datacenter de um cliente](elasticache-vpc-accessing.md#elasticache-vpc-accessing-data-center)
+ [Instâncias NAT](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html)
+ [Configurando clientes ElastiCache ](ClientConfig.md)
+ [Alta disponibilidade para instâncias NAT da Amazon VPC: um exemplo](https://aws.amazon.com/articles/2781451301784570)
# Encontrar endpoints de conexão no ElastiCache
Sua aplicação conecta-se ao seu cluster do ElastiCache usando endpoints. Um endpoint é o endereço exclusivo de um nó ou cluster.
Também é possível estabelecer uma conexão privada entre a VPC e os endpoints da API do ElastiCache criando um endpoint da VPC da interface por meio do AWS PrivateLink. Para obter mais informações, consulte [ElastiCache API e interface VPC endpoints ()AWS PrivateLink](elasticache-privatelink.md).
**Quais endpoints usar com o Valkey ou Redis OSS.**
+ Para o **nó autônomo**, use o endpoint do nó para operações de leitura e gravação.
+ Para **clusters do Valkey ou Redis OSS (modo cluster desabilitado)**, use o *Endpoint primário* para todas as operações de gravação. Use o *Endpoint de leitor* para dividir uniformemente as conexões de entrada no endpoint entre todas as réplicas de leitura. Use os *Endpoints de nó* individuais para operações de leitura (na API/CLI, eles são chamados de Endpoints de leitura).
+ Para **clusters do Valkey ou do Redis OSS (modo cluster habilitado)**, use o *Endpoint de configuração* do cluster para todas as operações com suporte a comandos do modo cluster habilitado. Você deve usar um cliente que ofereça suporte ao cluster do Valkey ou ao cluster do Redis OSS no Redis OSS 3.2 e superior. Você ainda pode ler de endpoints de nó individuais (na API/CLI, eles se chamam Endpoints de leitura).
As seções a seguir orientam pelo processo de localização dos endpoints necessários para o mecanismo que você está executando.
**Quais endpoints usar com o Memcached.**
Para o **cache com tecnologia sem servidor do ElastiCache para o Memcached**, basta adquirir o DNS do endpoint do cluster e a porta do console.
Na AWS CLI, use o comando `describe-serverless-caches` para adquirir as informações do endpoint.
Linux
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Windows
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
O resultado da operação acima deve ser semelhante a este (formato JSON).
```
{
"ServerlessCaches": [
{
"ServerlessCacheName": "serverless-memcached",
"Description": "test",
"CreateTime": 1697659642.136,
"Status": "available",
"Engine": "memcached",
"MajorEngineVersion": "1.6",
"FullEngineVersion": "21",
"SecurityGroupIds": [
"sg-083eda453e1e51310"
],
"Endpoint": {
"Address": "serverless-memcached-01.amazonaws.com",
"Port":11211
},
"ARN": "",
"SubnetIds": [
"subnet-0cf759df15bd4dc65",
"subnet-09e1307e8f1560d17"
],
"SnapshotRetentionLimit": 0,
"DailySnapshotTime": "03:00"
}
]
}
```
**Para um cluster do Memcached com base na instância**, se usar a descoberta automática, você poderá usar o *endpoint de configuração* do cluster para configurar o cliente do Memcached. Isso significa que você deve usar um cliente que ofereça suporte para Descoberta automática.
Se você não usar a Descoberta automática, deverá configurar seu cliente para usar os endpoints de nó individuais para leituras e gravações. Você também deve acompanhá-los à medida que adiciona e remove nós.
## Localização de endpoints de um cluster do Valkey ou do Redis OSS (modo cluster desabilitado) (console)
Se um cluster do Valkey ou Redis OSS (modo cluster desabilitado) tiver apenas um nó, o endpoint desse nó será usado para tanto para leituras quanto para gravações. Se um cluster do Valkey ou Redis OSS (modo cluster desabilitado) tiver vários nós, há três tipos de endpoints: o *endpoint primário*, o *endpoint leitor* e os *endpoints de nó*.
O endpoint primário é um nome DNS que sempre é resolvido para o nó primário no cluster. O endpoint primário é imune às alterações no seu cluster, como promover uma réplica de leitura para a função primária. Para atividades de gravação, recomendamos que suas aplicações se conectem ao endpoint primário.
Um endpoint de leitor divide uniformemente as conexões de entrada no endpoint entre todas as réplicas de leitura em um cluster do ElastiCache para Redis OSS. Fatores adicionais, como quando o aplicativo cria as conexões ou como o aplicativo (re)usa as conexões determinarão a distribuição do tráfego. Os endpoints de leitor acompanham as alterações do cluster em tempo real à medida que réplicas são adicionadas ou removidas. Você pode colocar várias réplicas de leitura do seu cluster do ElastiCache para Redis OSS em diferentes zonas de disponibilidade da AWS (AZ) para garantir a alta disponibilidade dos endpoints leitores.
**nota**
Um endpoint leitor não é um balanceador de carga. É um registro DNS que vai resolver para um endereço IP de um dos nós de réplica em uma forma round robin.
Para atividades de leitura, os aplicativos também podem se conectar a qualquer nó no cluster. Ao contrário do endpoint primário, endpoints de nó são resolvidos para endpoints específicos. Se você fizer uma alteração no cluster, como adicionar ou excluir uma réplica, deverá atualizar os endpoints de nó no seu aplicativo.
**Para descobrir endpoints de um cluster do Valkey ou Redis OSS (modo cluster desabilitado) (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel de navegação, escolha **Clusters do Valkey** ou **Clusters do Redis OSS**.
A tela de clusters aparecerá com uma lista de clusters do Valkey ou Redis OSS (modo cluster desabilitado) e Valkey ou Redis OSS (modo cluster habilitado).
1. Para encontrar os endpoints Primário e/ou Leitor do cluster, escolha o nome do cluster (e não o botão à esquerda).
![\[Imagem: endpoint primário para um cluster do Valkey ou Redis OSS (modo cluster desabilitado)\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/Reader-Endpoint.png)
*Endpoints primários e leitores para um cluster do Valkey ou Redis OSS (modo cluster desabilitado)*
Se houver apenas um nó no cluster, não haverá um endpoint primário, e você poderá continuar na próxima etapa.
1. Se o cluster do Valkey ou Redis OSS (modo cluster desabilitado) tiver nós de réplica, você poderá encontrar os endpoints dos nós de réplica do cluster escolhendo o nome do cluster e escolhendo a guia **Nós**.
A tela de nós aparece com cada nó do cluster, primário e réplicas, listados com seu respectivo endpoint.
![\[Imagem: endpoints de nó para um cluster do Valkey ou Redis OSS (modo cluster desabilitado)\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/ElastiCache-Endpoints-Redis-Node.png)
*Endpoints de nó para um cluster do Valkey ou Redis OSS (modo cluster desabilitado)*
1. Como copiar um endpoint para a área de transferência:
1. Um endpoint por vez, localize o endpoint que você deseja copiar.
1. Escolha o ícone de cópia diretamente na frente do endpoint.
O endpoint agora é copiado para a área de transferência. Para obter informações sobre como usar o endpoint para se conectar a um nó, consulte [Conexão a nós do Memcached](nodes-connecting.md#nodes-connecting.mem).
Um endpoint primário do Valkey ou Redis OSS (modo cluster desabilitado) se assemelha ao seguinte. Há uma diferença, dependendo de a criptografia em trânsito estar ou não habilitada.
**Criptografia em trânsito não habilitada**
```
clusterName.xxxxxx.nodeId.regionAndAz.cache.amazonaws.com:port
redis-01.7abc2d.0001.usw2.cache.amazonaws.com:6379
```
**Criptografia em trânsito habilitada**
```
master.clusterName.xxxxxx.regionAndAz.cache.amazonaws.com:port
master.ncit.ameaqx.use1.cache.amazonaws.com:6379
```
## Localização de endpoints para um cluster do Valkey ou do Redis OSS (modo cluster habilitado) (console)
O cluster do Valkey ou Redis OSS (modo cluster habilitado) possui um único endpoint de configuração. Ao se conectar ao endpoint de configuração, a aplicação pode descobrir os endpoints primários e os endpoints de leitura para cada fragmento no cluster.
**Para encontrar o endpoint de um cluster do Valkey ou Redis OSS (modo cluster habilitado)**
1. Faça login no Console de gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel de navegação, escolha **Clusters do Valkey** ou **Clusters do Redis OSS**.
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 de configuração do cluster, escolha o nome do cluster (não o botão de opção).
1. O **endpoint de configuração** é exibido em **detalhes do cluster**. Para copiá-lo, selecione o ícone *copiar* à esquerda do endpoint.
## Localização de endpoints de um cluster (console) (Memcached)
Todos os endpoints Memcached são endpoints de leitura/gravação. Para se conectar a nós em um cluster Memcached, seu aplicativo pode usar os endpoints para cada nó ou o endpoint de configuração do cluster, juntamente com a Descoberta automática. Para usar a Descoberta automática, você deve usar um cliente que ofereça suporte para Descoberta automática.
Ao usar a Descoberta automática, seu aplicativo cliente se conecta ao seu cluster Memcached usando o endpoint de configuração. À medida que você escalar seu cluster adicionando ou removendo nós, seu aplicativo "conhecerá" automaticamente todos os nós do cluster e poderá se conectar a qualquer um deles. Sem a Descoberta automática, seu aplicativo teria que fazer isso, ou você precisaria atualizar manualmente os endpoints no seu aplicativo sempre que adicionasse ou removesse um nó.
Para copiar um endpoint, escolha o ícone de cópia diretamente na frente do endereço do endpoint. Para obter informações sobre como usar o endpoint para se conectar a um nó, consulte [Conexão a nós do Memcached](nodes-connecting.md#nodes-connecting.mem).
Endpoints de configuração e de nó são muitos semelhantes. As diferenças estão realçadas com **negrito** a seguir.
```
myclustername.xxxxxx.cfg.usw2.cache.amazonaws.com:port # configuration endpoint contains "cfg"
myclustername.xxxxxx.0001.usw2.cache.amazonaws.com:port # node endpoint for node 0001
```
**Importante**
Se você optar por criar um CNAME para o seu endpoint de configuração Memcached, para que o seu cliente de descoberta automática reconheça o CNAME como um endpoint de configuração, você deverá incluir `.cfg.` nesse CNAME.
## Localizar endpoints (AWS CLI)
Para o Memcached, você pode usar a AWS CLI do Amazon ElastiCache para descobrir os endpoints para nós e clusters.
Para o Redis OSS, você pode usar a AWS CLI do Amazon ElastiCache para descobrir os endpoints para nós, clusters e também grupos de replicação.
**Topics**
+ [Encontrar endpoints para nós e clusters (AWS CLI)](#Endpoints.Find.CLI.Nodes)
+ [Localização de endpoints para grupos de replicação do Valkey ou Redis OSS (AWS CLI)](#Endpoints.Find.CLI.ReplGroups)
### Encontrar endpoints para nós e clusters (AWS CLI)
Você pode usar a AWS CLI para descobrir os endpoints para um cluster e seus nós com o comando `describe-cache-clusters`. Para clusters do Valkey ou Redis OSS, o comando retorna o endpoint do cluster. Para clusters Memcached, o comando retorna o endpoint de configuração. Se você incluir o parâmetro opcional `--show-cache-node-info`, o comando também retornará os endpoints dos nós individuais no cluster.
**Example**
O comando a seguir recupera os endpoints de configuração (`ConfigurationEndpoint`) e os endpoints de nó individuais (`Endpoint`) para o cluster Memcached *mycluster*.
Para Linux, macOS ou Unix:
```
aws elasticache describe-cache-clusters \
--cache-cluster-id mycluster \
--show-cache-node-info
```
Para Windows:
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id mycluster ^
--show-cache-node-info
```
O resultado da operação acima deve ser semelhante a este (formato JSON).
```
{
"CacheClusters": [
{
"Engine": "memcached",
"CacheNodes": [
{
"CacheNodeId": "0001",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
},
{
"CacheNodeId": "0002",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
},
{
"CacheNodeId": "0003",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
}
],
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "mycluster",
"PreferredAvailabilityZone": "us-west-2b",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-09-22T21:30:29.967Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "available",
"NumCacheNodes": 3,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "mon:09:00-mon:10:00",
"CacheNodeType": "cache.m4.large",
"DataTiering": "disabled"
}
]
}
```
Se você optar por criar um CNAME para o seu endpoint de configuração Memcached, para que o seu cliente de descoberta automática reconheça o CNAME como um endpoint de configuração, você deverá incluir `.cfg.` nesse CNAME. Por exemplo, `mycluster.cfg.local` no seu arquivo php.ini para o parâmetro `session.save_path`.
**Example**
Para Valkey e Redis OSS, o comando a seguir recupera as informações do cluster para o cluster de nó único *mycluster*.
O parâmetro `--cache-cluster-id` pode ser usado com um ID de cluster do Valkey ou Redis OSS (modo cluster desabilitado) de nó único ou IDs de nó específicos em grupos de replicação. O `--cache-cluster-id` de um grupo de replicação é um valor de 4 dígitos, como `0001`. Se `--cache-cluster-id` for o ID de um cluster (nó) em um grupo de replicação, o `replication-group-id` será incluído na saída.
Para Linux, macOS ou Unix:
```
aws elasticache describe-cache-clusters \
--cache-cluster-id redis-cluster \
--show-cache-node-info
```
Para Windows:
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id redis-cluster ^
--show-cache-node-info
```
O resultado da operação acima deve ser semelhante a este (formato JSON).
```
{
"CacheClusters": [
{
"CacheClusterStatus": "available",
"SecurityGroups": [
{
"SecurityGroupId": "sg-77186e0d",
"Status": "active"
}
],
"CacheNodes": [
{
"CustomerAvailabilityZone": "us-east-1b",
"CacheNodeCreateTime": "2018-04-25T18:19:28.241Z",
"CacheNodeStatus": "available",
"CacheNodeId": "0001",
"Endpoint": {
"Address": "redis-cluster.amazonaws.com",
"Port": 6379
},
"ParameterGroupStatus": "in-sync"
}
],
"AtRestEncryptionEnabled": false,
"CacheClusterId": "redis-cluster",
"TransitEncryptionEnabled": false,
"CacheParameterGroup": {
"ParameterApplyStatus": "in-sync",
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.redis3.2"
},
"NumCacheNodes": 1,
"PreferredAvailabilityZone": "us-east-1b",
"AutoMinorVersionUpgrade": true,
"Engine": "redis",
"AuthTokenEnabled": false,
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "tue:08:30-tue:09:30",
"CacheSecurityGroups": [],
"CacheSubnetGroupName": "default",
"CacheNodeType": "cache.t2.small",
"DataTiering": "disabled"
"EngineVersion": "3.2.10",
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheClusterCreateTime": "2018-04-25T18:19:28.241Z"
}
]
}
```
Para obter mais informações, consulte o tópico [describe-cache-clusters](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html).
### Localização de endpoints para grupos de replicação do Valkey ou Redis OSS (AWS CLI)
Você pode usar a AWS CLI para descobrir os endpoints para um grupo de replicação e seus clusters com o comando `describe-replication-groups`. O comando retorna o endpoint primário do grupo de replicação e uma lista de todos os clusters (nós) no grupo de replicação com seus endpoints, junto com o endpoint de leitor.
A seguinte operação recupera o endpoint primário e o endpoint de leitor para o grupo de replicação `myreplgroup`. Use o endpoint primário para todas as operações de gravação.
```
aws elasticache describe-replication-groups \
--replication-group-id myreplgroup
```
Para Windows:
```
aws elasticache describe-replication-groups ^
--replication-group-id myreplgroup
```
O resultado dessa operação deve ser semelhante a este (formato JSON).
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "test",
"NodeGroups": [
{
"Status": "available",
"NodeGroupMembers": [
{
"CurrentRole": "primary",
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-001.amazonaws.com"
},
"CacheClusterId": "myreplgroup-001"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-002.amazonaws.com"
},
"CacheClusterId": "myreplgroup-002"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-003.amazonaws.com"
},
"CacheClusterId": "myreplgroup-003"
}
],
"NodeGroupId": "0001",
"PrimaryEndpoint": {
"Port": 6379,
"Address": "myreplgroup.amazonaws.com"
},
"ReaderEndpoint": {
"Port": 6379,
"Address": "myreplgroup-ro.amazonaws.com"
}
}
],
"ReplicationGroupId": "myreplgroup",
"AutomaticFailover": "enabled",
"SnapshottingClusterId": "myreplgroup-002",
"MemberClusters": [
"myreplgroup-001",
"myreplgroup-002",
"myreplgroup-003"
],
"PendingModifiedValues": {}
}
]
}
```
Para obter mais informações, consulte [describe-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-replication-groups.html) na *Referência de comandos da AWS CLI*.
## Localização de endpoints (API do ElastiCache)
Para o Memcached, você pode usar a API do Amazon ElastiCache para descobrir os endpoints para nós e clusters.
Para o Redis OSS, você pode usar a API do Amazon ElastiCache para descobrir os endpoints para nós, clusters e também grupos de replicação.
**Topics**
+ [Localização de endpoints para nós e clusters (API do ElastiCache)](#Endpoints.Find.API.Nodes)
+ [Localização de endpoints para grupos de replicação do Valkey ou Redis OSS (API do ElastiCache)](#Endpoints.Find.API.ReplGroups)
### Localização de endpoints para nós e clusters (API do ElastiCache)
Você pode usar a API do ElastiCache para descobrir os endpoints para um cluster e seus nós com a ação `DescribeCacheClusters`. Para clusters do Valkey ou Redis OSS, o comando retorna o endpoint do cluster. Para clusters Memcached, o comando retorna o endpoint de configuração. Se você incluir o parâmetro opcional `ShowCacheNodeInfo`, a ação também retornará os endpoints dos nós individuais no cluster.
**Example**
Para o Memcached, o comando a seguir recupera os endpoints de configuração (`ConfigurationEndpoint`) e os endpoints de nó individuais (`Endpoint`) para o cluster do Memcached *mycluster*.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=mycluster
&ShowCacheNodeInfo=true
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Se você optar por criar um CNAME para o seu endpoint de configuração Memcached, para que o seu cliente de descoberta automática reconheça o CNAME como um endpoint de configuração, você deverá incluir `.cfg.` nesse CNAME. Por exemplo, `mycluster.cfg.local` no seu arquivo php.ini para o parâmetro `session.save_path`.
### Localização de endpoints para grupos de replicação do Valkey ou Redis OSS (API do ElastiCache)
Você pode usar a API do ElastiCache para descobrir os endpoints para um grupo de replicação e seus cluster com a ação `DescribeReplicationGroups`. A ação retorna o endpoint primário do grupo de replicação e uma lista de todos os clusters no grupo de replicação com seus endpoints, junto com o endpoint de leitor.
A operação a seguir recupera o endpoint primário (PrimaryEndpoint), o endpoints de leitor (ReaderEndpoint) e os endpoints de nós individuais (ReadEndpoint) para o grupo de replicação `myreplgroup`. Use o endpoint primário para todas as operações de gravação.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroups
&ReplicationGroupId=myreplgroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Para obter mais informações, consulte [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html).
# Operação com fragmentos no ElastiCache
Um fragmento (API/CLI: grupo de nós) é uma coleção de um a seis nós do ElastiCache para Valkey ou Redis OSS. Um cluster do Valkey ou Redis OSS (modo cluster desabilitado) nunca terá mais de um fragmento. Com os fragmentos, você pode dividir grandes bancos de dados em partes menores, mais rápidas e mais fáceis de gerenciar, chamadas de fragmentos de dados. Isso pode aumentar a eficiência do banco de dados distribuindo as operações em várias seções separadas. O uso de fragmentos pode oferecer muitos benefícios, incluindo melhor desempenho, escalabilidade e eficiência de custos.
É possível criar um cluster com alto número de fragmentos e baixo número de réplicas totalizando até 90 nós por cluster. Essa configuração do cluster pode variar de 90 fragmentos e 0 réplicas para 15 fragmentos e 5 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.
O limite de nós ou fragmentos pode ser aumentado para um máximo de 500 por cluster se a versão do mecanismo for Valkey 7.2 e posteriores ou Redis OSS 5.0.6 a 7.1. Por exemplo, você pode optar por configurar um cluster de 500 nós que varia entre 83 fragmentos (uma primária e 5 réplicas por fragmento) e 500 fragmentos (primário único e sem réplicas). Verifique se existem endereços IP disponíveis suficientes para acomodar o aumento. As armadilhas comuns incluem as sub-redes no grupo de sub-redes têm um intervalo CIDR muito pequeno ou as sub-redes são compartilhadas e fortemente usadas por outros clusters. Para obter mais informações, consulte [Criação de um grupo de sub-redes](SubnetGroups.Creating.md).
Para versões abaixo de 5.0.6, o limite é 250 por cluster.
Para solicitar um aumento de limite, consulte [Limites do serviço da AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) e escolha o tipo de limite **Nodes per cluster per instance type** (Nós por cluster por tipo de instância).
Ao criar um cluster do Valkey ou Redis OSS (modo cluster habilitado) usando o console do ElastiCache, 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 Valkey ou Redis OSS (modo cluster habilitado) (console)](Clusters.Create.md#Clusters.Create.CON.RedisCluster). Se você usar a API do ElastiCache ou a AWS CLI para criar um cluster (chamado de *grupo de replicação* na API/CLI), poderá configurar o número de nós em um fragmento (API/CLI: grupo de nós) de forma independente. Para obter mais informações, consulte:
+ API: [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ CLI: [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
Cada nó em um fragmento tem as mesmas especificações de computação, armazenamento e memória. A API do ElastiCache permite que você controle atributos no âmbito do fragmento, como o número de nós, as configurações de segurança e as janelas de manutenção do sistema.
![\[Imagem: configurações de fragmento Valkey ou Redis OSS.\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-CSN-RedisShards.png)
*Configurações de fragmento do Valkey ou Redis OSS*
Para obter mais informações, consulte [Refragmentação offline para o Valkey ou o Redis OSS (modo cluster habilitado)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-offline) e [Refragmentação online para o Valkey ou o Redis OSS (modo cluster habilitado)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online).
## Localização de um ID de fragmento
Você pode encontrar o ID de um fragmento usando o Console de gerenciamento da AWS, a AWS CLI ou a API do ElastiCache.
### Utilização do Console de gerenciamento da AWS
**Topics**
+ [Para Valkey ou Redis OSS (modo cluster desabilitado)](#shard-find-id-con-classic)
+ [Para Valkey ou Redis OSS (modo cluster habilitado)](#shard-find-id-con-cluster)
#### Para Valkey ou Redis OSS (modo cluster desabilitado)
Os IDs de fragmento do grupo de replicação do Valkey ou Redis OSS (modo cluster desabilitado) são sempre `0001`.
#### Para Valkey ou Redis OSS (modo cluster habilitado)
O procedimento a seguir usa o Console de gerenciamento da AWS para localizar o ID de um fragmento do Valkey ou Redis OSS (modo cluster habilitado).
**Para localizar o ID do fragmento em um grupo de replicação do Valkey ou Redis OSS (modo cluster habilitado)**
1. Faça login no Console de gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel de navegação, escolha **Valkey** ou **Redis OSS** e o nome do grupo de replicação do Valkey ou Redis OSS (modo cluster habilitado) para o qual deseja encontrar os IDs do fragmento.
1. Na coluna **Shard Name** (Nome do fragmento), o ID do fragmento tem os últimos quatro dígitos do nome do fragmento.
### Como usar o AWS CLI
Para encontrar os IDs de fragmento (grupo de nós) para grupos de replicação do Valkey ou Redis OSS (modo cluster desabilitado) ou do Valkey ou Redis OSS (modo cluster habilitado), use a operação da AWS CLI `describe-replication-groups` com o parâmetro opcional a seguir.
+ **`--replication-group-id`**—um parâmetro opcional que, quando usado, limita a saída aos detalhes do grupo de replicação especificado. Caso esse parâmetro seja omitido, os detalhes de até 100 grupos de replicação são retornados.
**Example**
Esse comando retorna os detalhes do `sample-repl-group`.
Para Linux, macOS ou Unix:
```
aws elasticache describe-replication-groups \
--replication-group-id sample-repl-group
```
Para Windows:
```
aws elasticache describe-replication-groups ^
--replication-group-id sample-repl-group
```
A saída desse comando é semelhante a esta. Os IDs do estilhaço (grupo de nós) estão *realçados* aqui para facilitar a localização deles.
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "2 shards, 2 nodes (1 + 1 replica)",
"NodeGroups": [
{
"Status": "available",
"Slots": "0-8191",
"NodeGroupId": "0001",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0001-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0001-002"
}
]
},
{
"Status": "available",
"Slots": "8192-16383",
"NodeGroupId": "0002",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0002-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0002-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "sample-repl-group.9dcv5r.clustercfg.usw2.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "sample-repl-group",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "13:00-14:00",
"MemberClusters": [
"sample-repl-group-0001-001",
"sample-repl-group-0001-002",
"sample-repl-group-0002-001",
"sample-repl-group-0002-002"
],
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
"PendingModifiedValues": {}
}
]
}
```
### Uso da API do ElastiCache
Para encontrar os IDs de fragmento (grupo de nós) para grupos de replicação do Valkey ou Redis OSS (modo cluster desabilitado) ou do Valkey ou Redis OSS (modo cluster habilitado), use a operação da AWS CLI `describe-replication-groups` com o parâmetro opcional a seguir.
+ **`ReplicationGroupId`**—um parâmetro opcional que, quando usado, limita a saída aos detalhes do grupo de replicação especificado. Caso esse parâmetro seja omitido, os detalhes de até *xxx* grupos de replicação são retornados.
**Example**
Esse comando retorna os detalhes do `sample-repl-group`.
Para Linux, macOS ou Unix:
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroup
&ReplicationGroupId=sample-repl-group
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```