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á.
# Escalabilidade
A quantidade de dados que o seu aplicativo precisa processar é raramente estática. Ela aumenta e diminui à medida que sua empresa cresce ou passa por flutuações normais na demanda. Se autogerenciar seus aplicativos, você precisará provisionar hardware suficiente para seus picos de demanda, o que pode ser caro. Usando o MemoryDB, você pode escalar para atender à demanda atual, pagando apenas pelo que usa.
O conteúdo a seguir ajuda a encontrar o tópico correto para as ações de escalabilidade que você deseja executar.
**Escalabilidade do MemoryDB**
| Ação | MemoryDB |
| --- | --- |
| Aumento de escala | [Refragmentação on-line para o MemoryDB](cluster-resharding-online.md) |
| Alteração nos tipos de nó | [Escalabilidade vertical online com modificação do tipo de nó](cluster-vertical-scaling.md) |
| Alteração no número de fragmentos | [Escalabilidade de clusters do MemoryDB](scaling-cluster.md) |
# Escalabilidade de clusters do MemoryDB
À medida que a demanda dos clusters muda, convém melhorar a performance ou reduzir os custos alterando o número de fragmentos no cluster do MemoryDB. Recomendamos o uso da escalabilidade horizontal online para esse ajuste, pois permite que o seu cluster continue a atender às solicitações durante o processo de escalabilidade.
As condições sob as quais você pode decidir redimensionar seu cluster incluem o seguinte:
+ **Uso intenso de memória:**
Se os nós no cluster estão sob uso intenso da memória, você pode optar por aumentar a escala e ter mais recursos para melhor armazenar dados e atender a solicitações.
Você pode determinar se seus nós estão sob pressão de memória monitorando as seguintes métricas: *FreeableMemory*, *SwapUsage*, e *BytesUsedForMemoryDB*.
+ **CPU ou gargalo de rede:**
Se os latency/throughput problemas estiverem afetando seu cluster, talvez seja necessário escalar para resolvê-los.
Você pode monitorar seus níveis de latência e taxa de transferência monitorando as seguintes métricas: *CPUUtilization*, *NetworkBytesIn*, *NetworkBytesOut*CurrConnections**, e. *NewConnections*
+ **Seu cluster está acima da escala:**
A demanda atual no cluster permite que haja uma redução na escala sem afetar o desempenho e proporcionando corte de custos.
Você pode monitorar o uso do seu cluster para determinar se você pode escalar com segurança usando as seguintes métricas: *FreeableMemory*SwapUsage**,, *BytesUsedForMemoryDB *CPUUtilization*NetworkBytesIn***, *NetworkBytesOut*, *CurrConnections*,, *NewConnections*e.
**Impacto da escalabilidade no desempenho**
Quando você altera a escala usando o processo offline, seu cluster fica offline para uma parte significativa do processo e, por conseguinte, não é capaz de atender a solicitações. Quando você altera a escala usando o método online, como a escalabilidade é uma operação com uso intensivo de computação, há queda no desempenho, mas ainda assim seu cluster continua atendendo a solicitações durante a operação de escalabilidade. O quanto o desempenho é afetado depende do seu uso normal da CPU e dos seus dados.
Existem duas maneiras de escalar o cluster do MemoryDB: escalabilidade horizontal e vertical.
+ A escalabilidade horizontal permite alterar o número de fragmentos no cluster adicionando ou removendo fragmentos. O processo de refragmentação on-line permite a escalabilidade in/out enquanto o cluster continua atendendo às solicitações recebidas.
+ Escalabilidade vertical — altere o tipo de nó para redimensionar o cluster. O escalonamento vertical on-line permite o escalonamento up/down enquanto o cluster continua atendendo às solicitações recebidas.
Se estiver reduzindo o tamanho e a capacidade de memória do cluster, seja reduzindo a escala horizontal ou verticalmente, garanta que a nova configuração tenha memória suficiente para os dados e a sobrecarga do mecanismo.
# Refragmentação off-line para o MemoryDB
A principal vantagem de obter a reconfiguração de fragmentos offline é que você pode fazer mais do que simplesmente adicionar ou remover fragmentos de seu cluster. Quando você faz o reestilhaçamento offline, além de alterar o número de fragmentos no seu cluster, é possível fazer o seguinte:
+ Alterar o tipo de nó do seu cluster.
+ Fazer o upgrade para uma versão mais recente do mecanismo.
**nota**
A refragmentação offline não é compatível com clusters que tenham a classificação de dados em níveis ativada. Para obter mais informações, consulte [Classificação de dados em níveis](data-tiering.md)..
A principal desvantagem da reconfiguração de fragmentos offline é que o cluster fica offline começando com a parte de restauração do processo e continua até você atualizar os endpoints no aplicativo. O tempo em que o cluster fica offline depende da quantidade de dados no seu cluster.
**Para reconfigurar o cluster de fragmentos do MemoryDB offline**
1. Crie um snapshot manual do cluster do MemoryDB existente. Para obter mais informações, consulte [Obtenção manual de snapshots](snapshots-manual.md).
1. Crie um novo cluster fazendo a restauração a partir do snapshot. Para obter mais informações, consulte [Restauração a partir de um snapshot](snapshots-restoring.md).
1. Atualize os endpoints no seu aplicativo para os endpoints do novo cluster. Para obter mais informações, consulte [Localização de endpoints de conexão](endpoints.md).
# Refragmentação on-line para o MemoryDB
Ao optar pela refragmentação on-line com o MemoryDB, você pode escalar o MemoryDB de maneira dinâmica sem tempo de inatividade. Essa abordagem significa que seu cluster pode continuar atendendo a solicitações mesmo durante a escalabilidade ou o rebalanceamento.
Você pode fazer o seguinte:
+ **Aumentar a escala horizontalmente**: aumente a capacidade de leitura e gravação adicionando fragmentos ao seu cluster do MemoryDB.
Se você adicionar um ou mais fragmentos ao cluster, o número de nós em cada novo fragmento será o mesmo que o número de nós no menor dos fragmentos existentes.
+ **Reduzir a escala horizontalmente**: reduza a capacidade de leitura e gravação e, por conseguinte, os custos, removendo fragmentos do cluster do MemoryDB.
Atualmente, as seguintes limitações se aplicam à refragmentação online do MemoryDB:
+ Há limitações em relação a slots ou espaços de chave e itens grandes:
Se qualquer uma das chaves em um fragmento contiver um item grande, essa chave não será migrada para um novo fragmento ao aumentar a escala horizontalmente. Essa funcionalidade pode resultar em fragmentos desbalanceados.
Se qualquer uma das chaves em um fragmento contiver um item grande (itens maiores do que 256 MB após a serialização), o fragmento não será excluído na redução da escala. Essa funcionalidade pode resultar na não exclusão de alguns fragmentos.
+ Ao aumentar a escala horizontalmente, o número de nós em novos fragmentos fica igual ao número de nós nos fragmentos existentes.
Para obter mais informações, consulte [Práticas recomendadas: redimensionamento online de clusters](best-practices-online-resharding.md).
Você pode aumentar a escala de clusters do MemoryDB horizontalmente usando o Console de gerenciamento da AWS, a AWS CLI e a API do MemoryDB.
## Adição de fragmentos com refragmentação online
Você pode adicionar fragmentos ao seu cluster MemoryDB usando a API Console de gerenciamento da AWS AWS CLI, ou MemoryDB.
### Adição de fragmentos (console)
Você pode usar o Console de gerenciamento da AWS para adicionar um ou mais fragmentos ao seu cluster MemoryDB. O procedimento a seguir descreve o processo.
****
1. Faça login no Console de gerenciamento da AWS e abra o console do MemoryDB em. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Na lista de clusters, escolha o nome do cluster a partir do qual você deseja adicionar um fragmento.
1. Na guia **Fragmentos e nós**, escolha **Adicionar/Excluir fragmentos**
1. Em **Novo número de fragmentos**, insira o número de fragmentos que você deseja.
1. Escolha **Confirmar** para manter as alterações ou **Cancelar** para descartá-las.
### Adição de fragmentos (AWS CLI)
O processo a seguir descreve como reconfigurar os fragmentos no seu cluster do MemoryDB adicionando fragmentos com a AWS CLI.
Use os parâmetros a seguir com `update-cluster`.
**Parâmetros**
+ `--cluster-name` – obrigatório. Especifica em qual cluster a operação de reconfiguração de fragmento será executada.
+ `--shard-configuration` – obrigatório. Permite que você defina o número de fragmentos.
+ `ShardCount`: defina essa propriedade para especificar o número de fragmentos que você deseja.
**Example**
O exemplo a seguir modifica o número de fragmentos no cluster `my-cluster` para 2.
Para Linux, macOS ou Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--shard-configuration \
ShardCount=2
```
Para Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--shard-configuration ^
ShardCount=2
```
Retorna a seguinte resposta em JSON:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "updating",
"NumberOfShards": 2,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
}
```
Para visualizar os detalhes do cluster atualizado quando seu status mudar de *Atualizado* para *Disponível*, use o seguinte comando:
Para Linux, macOS ou Unix:
```
aws memorydb describe-clusters \
--cluster-name my-cluster
--show-shard-details
```
Para Windows:
```
aws memorydb describe-clusters ^
--cluster-name my-cluster
--show-shard-details
```
Retorna a seguinte resposta em JSON:
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 2,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-8191",
"Nodes": [
{
"Name": "my-cluster-0001-001",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0001-002",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
},
{
"Name": "0002",
"Status": "available",
"Slots": "8192-16383",
"Nodes": [
{
"Name": "my-cluster-0002-001",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-22T14:26:18.693000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0002-002",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-22T14:26:18.765000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
]
}
```
Para obter mais informações, consulte [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html) na Referência de AWS CLI comandos.
### Adição de fragmentos (API do MemoryDB)
Você pode usar a API do MemoryDB para reconfigurar os fragmentos no cluster do MemoryDB online usando a operação `UpdateCluster`.
Use os parâmetros a seguir com `UpdateCluster`.
**Parâmetros**
+ `ClusterName` – obrigatório. Especifica em qual cluster a operação de reconfiguração de fragmento será executada.
+ `ShardConfiguration` – obrigatório. Permite que você defina o número de fragmentos.
+ `ShardCount`: defina essa propriedade para especificar o número de fragmentos que você deseja.
Para obter mais informações, consulte [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
## Remoção de fragmentos com refragmentação online
Você pode remover fragmentos do seu cluster MemoryDB usando a API Console de gerenciamento da AWS AWS CLI, ou MemoryDB.
### Remoção de fragmentos (console)
O processo a seguir descreve como reconfigurar os fragmentos em seu cluster do MemoryDB removendo os fragmentos usando o Console de gerenciamento da AWS.
**Importante**
Antes de remover os fragmentos do seu cluster, o MemoryDB verifica se todos os seus dados cabem nos demais fragmentos. Se os dados couberem, os fragmentos serão excluídos do cluster como solicitado. Se os dados não couberem nos fragmentos restantes, o processo será encerrado e o cluster será deixado com a mesma configuração do fragmento anterior à solicitação.
Você pode usar o Console de gerenciamento da AWS para remover um ou mais fragmentos do seu cluster MemoryDB. Não é possível remover todos os fragmentos de um cluster. Em vez disso, você deve excluir o cluster. Para obter mais informações, consulte [Etapa 5: excluir um cluster](getting-started.md#clusters.delete). O procedimento a seguir descreve o processo para remover um ou mais fragmentos.
****
1. Faça login no Console de gerenciamento da AWS e abra o console do MemoryDB em. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Na lista de clusters, escolha o nome do cluster do qual você deseja remover um fragmento.
1. Na guia **Fragmentos e nós**, escolha **Adicionar/Excluir fragmentos**
1. Em **Novo número de fragmentos**, insira o número de fragmentos que você deseja (com um mínimo de 1).
1. Escolha **Confirmar** para manter as alterações ou **Cancelar** para descartá-las.
### Remoção de fragmentos (AWS CLI)
O processo a seguir descreve como reconfigurar os fragmentos em seu cluster do MemoryDB removendo os fragmentos usando o AWS CLI.
**Importante**
Antes de remover os fragmentos do seu cluster, o MemoryDB verifica se todos os seus dados cabem nos demais fragmentos. Se os dados couberem, os fragmentos serão excluídos do cluster como solicitado e seus espaços de chave serão mapeados para os fragmentos restantes. Se os dados não couberem nos fragmentos restantes, o processo será encerrado e o cluster permanecerá com a mesma configuração de fragmentos anterior à solicitação.
Você pode usar o AWS CLI para remover um ou mais fragmentos do seu cluster MemoryDB. Não é possível remover todos os fragmentos de um cluster. Em vez disso, você deve excluir o cluster. Para obter mais informações, consulte [Etapa 5: excluir um cluster](getting-started.md#clusters.delete).
Use os parâmetros a seguir com `update-cluster`.
**Parâmetros**
+ `--cluster-name` – obrigatório. Especifica em qual cluster a operação de reconfiguração de fragmento será executada.
+ `--shard-configuration` – obrigatório. Permite que você defina o número de fragmentos usando a propriedade `ShardCount`:
`ShardCount`: defina essa propriedade para especificar o número de fragmentos que você deseja.
**Example**
O exemplo a seguir modifica o número de fragmentos no cluster `my-cluster` para 2.
Para Linux, macOS ou Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--shard-configuration \
ShardCount=2
```
Para Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--shard-configuration ^
ShardCount=2
```
Retorna a seguinte resposta em JSON:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "updating",
"NumberOfShards": 2,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
}
```
Para visualizar os detalhes do cluster atualizado quando seu status mudar de *Atualizado* para *Disponível*, use o seguinte comando:
Para Linux, macOS ou Unix:
```
aws memorydb describe-clusters \
--cluster-name my-cluster
--show-shard-details
```
Para Windows:
```
aws memorydb describe-clusters ^
--cluster-name my-cluster
--show-shard-details
```
Retorna a seguinte resposta em JSON:
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 2,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-8191",
"Nodes": [
{
"Name": "my-cluster-0001-001",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0001-002",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
},
{
"Name": "0002",
"Status": "available",
"Slots": "8192-16383",
"Nodes": [
{
"Name": "my-cluster-0002-001",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-22T14:26:18.693000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0002-002",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-22T14:26:18.765000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
]
}
```
Para obter mais informações, consulte [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html) na Referência de AWS CLI comandos.
### Remoção de fragmentos (API do MemoryDB)
Você pode usar a API do MemoryDB para reconfigurar os fragmentos no cluster do MemoryDB online usando a operação `UpdateCluster`.
O processo a seguir descreve como reconfigurar os fragmentos em seu cluster do MemoryDB removendo fragmentos usando a API do MemoryDB.
**Importante**
Antes de remover fragmentos do seu cluster, o MemoryDB verifica se todos os seus dados cabem nos demais fragmentos. Se os dados couberem, os fragmentos serão excluídos do cluster como solicitado e seus espaços de chave serão mapeados para os fragmentos restantes. Se os dados não couberem nos fragmentos restantes, o processo será encerrado e o cluster permanecerá com a mesma configuração de fragmentos anterior à solicitação.
Você pode usar a API do MemoryDB para remover um ou mais fragmentos de seu cluster do MemoryDB. Não é possível remover todos os fragmentos de um cluster. Em vez disso, você deve excluir o cluster. Para obter mais informações, consulte [Etapa 5: excluir um cluster](getting-started.md#clusters.delete).
Use os parâmetros a seguir com `UpdateCluster`.
**Parâmetros**
+ `ClusterName` – obrigatório. Especifica em qual cluster a operação de reconfiguração de fragmento será executada.
+ `ShardConfiguration` – obrigatório. Permite que você defina o número de fragmentos usando a propriedade `ShardCount`:
`ShardCount`: defina essa propriedade para especificar o número de fragmentos que você deseja.
# Escalabilidade vertical online com modificação do tipo de nó
Usando a escalabilidade vertical online com o MemoryDB, você poderá escalar dinamicamente os clusters com tempo de inatividade mínimo. Isso permite que o cluster veicule solicitações mesmo ao ser escalado.
**nota**
Não há compatibilidade com escalabilidade entre um cluster de classificação de dados em níveis (p. ex., um cluster que use um tipo de nó r6gd) e 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 [Classificação de dados em níveis](data-tiering.md).
Você pode fazer o seguinte:
+ **Aumentar a escala verticalmente**: aumente a capacidade de leitura e gravação ajustando o tipo de nó do cluster do MemoryDB para usar um tipo de nó maior.
O MemoryDB redimensiona dinamicamente o cluster ao permanecer online e veicular solicitações.
+ **Redução de escala vertical**: reduza a capacidade de leitura e gravação ajustando o tipo de nó para usar um nó menor. Novamente, o MemoryDB redimensiona dinamicamente o cluster ao permanecer online e veicular solicitações. Nesse caso, você reduz os custos diminuindo o nó.
**nota**
Os processos de expansão e redução dependem da criação de clusters com tipos de nó recém-selecionados e da sincronização dos novos nós com os anteriores. Para garantir um up/down fluxo de escala suave, faça o seguinte:
Embora o processo de escalabilidade vertical seja desenvolvido para permanecer totalmente online, ele depende da sincronização dos dados entre o nó antigo e o novo nó. Recomendamos iniciar a expansão/redução no horário em que você acredita que o tráfego de dados seja mínimo.
Teste o comportamento de seu aplicativo durante a escalabilidade em um ambiente de preparação, se possível.
# Aumento de escala vertical online
**Topics**
+ [Aumento de escala vertical de clusters do MemoryDB (console)](#cluster-vertical-scaling-console)
+ [Ampliando clusters MemoryDB (CLI)AWS](#scaling.scaleUp.cli)
+ [Aumento de escala vertical de clusters do MemoryDB (API do MemoryDB)](#verticalscaling.scaleup.api)
## Aumento de escala vertical de clusters do MemoryDB (console)
O procedimento a seguir descreve como aumentar a escala verticalmente de um cluster do MemoryDB usando o Console de gerenciamento da AWS. Durante esse processo, o cluster do MemoryDB continuará a atender solicitações com tempo de inatividade mínimo.
**Para aumentar a escala verticalmente de um cluster (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do MemoryDB em. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Na lista de clusters, escolha o cluster.
1. Escolha **Ações** e **Modificar**.
1. Na caixa de diálogo **Modificar cluster**:
1. Na lista **Node type**, escolha o tipo de nó a partir do qual você deseja escalar. Para expandir, selecione um tipo de nó maior do que o nó existente.
1. Escolha **Salvar alterações**.
O status do cluster muda para *Modificação*. Quando o status mudar para *available*, a modificação estará completa, e você poderá começar a usar o novo cluster.
## Ampliando clusters MemoryDB (CLI)AWS
O procedimento a seguir descreve como aumentar a escala verticalmente de um cluster do MemoryDB usando o AWS CLI. Durante esse processo, o cluster do MemoryDB continuará a atender solicitações com tempo de inatividade mínimo.
**Para escalar um cluster MemoryDB (CLI AWS )**
1. Determine os tipos de nós para os quais você pode escalar executando o AWS CLI `list-allowed-node-type-updates` comando com o parâmetro a seguir.
Para Linux, macOS ou Unix:
```
aws memorydb list-allowed-node-type-updates \
--cluster-name my-cluster-name
```
Para Windows:
```
aws memorydb list-allowed-node-type-updates ^
--cluster-name my-cluster-name
```
A saída do comando acima é semelhante a esta (formato JSON).
```
{
"ScaleUpNodeTypes": [
"db.r6g.2xlarge",
"db.r6g.large"
],
"ScaleDownNodeTypes": [
"db.r6g.large"
],
}
```
Para obter mais informações, consulte [list-allowed-node-type-updates](https://docs.aws.amazon.com/cli/latest/reference/memorydb/list-allowed-node-type-updates.html) na *AWS CLI Referência*.
1. Modifique seu cluster para escalar até o novo tipo de nó maior usando o AWS CLI `update-cluster` comando e os parâmetros a seguir.
+ `--cluster-name`: o nome do cluster de cache que você está aumentando.
+ `--node-type`: o novo tipo de nó para o qual você deseja escalar o cluster. Esse valor deve ser um dos tipos de nós retornados pelo comando `list-allowed-node-type-updates` na etapa 1.
Para Linux, macOS ou Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--node-type db.r6g.2xlarge
```
Para Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--node-type db.r6g.2xlarge ^
```
Para obter mais informações, consulte [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html).
## Aumento de escala vertical de clusters do MemoryDB (API do MemoryDB)
O processo a seguir escala seu cluster do tipo de nó atual para um novo tipo de nó maior usando a API do MemoryDB. Durante esse processo, o MemoryDB atualiza as entradas do DNS para que elas apontem para os novos nós. Você pode escalar clusters habilitados para failover automático enquanto o cluster permanece online e atende às solicitações recebidas.
O tempo necessário para aumentar a escala verticalmente até um tipo de nó maior varia, dependendo do tipo de nó e da quantidade de dados no seu cluster atual.
**Como aumentar a escala verticalmente de um cluster do MemoryDB (API do MemoryDB)**
1. Determine quais tipos de nós você pode aumentar a escala verticalmente usando a ação `ListAllowedNodeTypeUpdates` da API do MemoryDB com o seguinte parâmetro.
+ `ClusterName`: o nome do cluster. Use esse parâmetro para descrever um cluster específico em vez de todos os clusters.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=ListAllowedNodeTypeUpdates
&ClusterName=MyCluster
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
Para obter mais informações, consulte a [ListAllowedNodeTypeUpdates](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_ListAllowedNodeTypeUpdates.html)Referência da *API MemoryDB*.
1. Escale seu cluster atual para o novo tipo de nó usando a ação `UpdateCluster` da API do MemoryDB e com os seguintes parâmetros.
+ `ClusterName`: o nome do cluster.
+ `NodeType`: o novo tipo de nó maior dos clusters nesse cluster. Esse valor deve ser um dos tipos de instância retornados pela ação `ListAllowedNodeTypeUpdates` na etapa 1.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=UpdateCluster
&NodeType=db.r6g.2xlarge
&ClusterName=myCluster
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210801T220302Z
&Version=2021-01-01
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Date=20210801T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20210801T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Para obter mais informações, consulte [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
# Redução de escala vertical online
**Topics**
+ [Redução de escala vertical de clusters do MemoryDB (console)](#cluster-vertical-scaling-down-console)
+ [Reduzindo os clusters MemoryDB (CLI)AWS](#scaling.scaledown.cli)
+ [Redução de escala vertical de clusters do MemoryDB (API do MemoryDB)](#scaling.vertical.scaledown.api)
## Redução de escala vertical de clusters do MemoryDB (console)
O procedimento a seguir descreve como reduzir a escala verticalmente de um cluster do MemoryDB usando o Console de gerenciamento da AWS. Durante esse processo, o cluster do MemoryDB continuará a atender solicitações com tempo de inatividade mínimo.
**Para reduzir a escala verticalmente de um cluster do MemoryDB (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do MemoryDB em. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Na lista de clusters, escolha seu cluster preferido.
1. Escolha **Ações** e **Modificar**.
1. Na caixa de diálogo **Modificar cluster**:
1. Na lista **Node type**, escolha o tipo de nó a partir do qual você deseja escalar. Para reduzir, selecione um tipo de nó menor do que o nó existente. Observe que nem todos os tipos de nó estão disponíveis para redução.
1. Escolha **Salvar alterações**.
O status do cluster muda para *Modificação*. Quando o status mudar para *available*, a modificação estará completa, e você poderá começar a usar o novo cluster.
## Reduzindo os clusters MemoryDB (CLI)AWS
O procedimento a seguir descreve como reduzir a escala verticalmente de um cluster do MemoryDB usando o AWS CLI. Durante esse processo, o cluster do MemoryDB continuará a atender solicitações com tempo de inatividade mínimo.
**Para reduzir um cluster MemoryDB (CLI AWS )**
1. Determine os tipos de nós para os quais você pode reduzir executando o AWS CLI `list-allowed-node-type-updates` comando com o parâmetro a seguir.
Para Linux, macOS ou Unix:
```
aws memorydb list-allowed-node-type-updates \
--cluster-name my-cluster-name
```
Para Windows:
```
aws memorydb list-allowed-node-type-updates ^
--cluster-name my-cluster-name
```
A saída do comando acima é semelhante a esta (formato JSON).
```
{
"ScaleUpNodeTypes": [
"db.r6g.2xlarge",
"db.r6g.large"
],
"ScaleDownNodeTypes": [
"db.r6g.large"
],
}
```
Para obter mais informações, consulte [list-allowed-node-type-updates](https://docs.aws.amazon.com/cli/latest/reference/memorydb/list-allowed-node-type-updates.html).
1. Modifique seu cluster para reduzir a escala verticalmente para o novo tipo de nó menor usando o comando `update-cluster` com os seguintes parâmetros.
+ `--cluster-name`: o nome do cluster para o qual você está reduzindo a escala verticalmente.
+ `--node-type`: o novo tipo de nó para o qual você deseja escalar o cluster. Esse valor deve ser um dos tipos de nós retornados pelo comando `list-allowed-node-type-updates` na etapa 1.
Para Linux, macOS ou Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--node-type db.r6g.large
```
Para Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--node-type db.r6g.large
```
Para obter mais informações, consulte [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html).
## Redução de escala vertical de clusters do MemoryDB (API do MemoryDB)
O processo a seguir escala seu cluster do tipo de nó atual para um novo tipo de nó menor usando a API do MemoryDB. Durante esse processo, o cluster do MemoryDB continuará a atender solicitações com tempo de inatividade mínimo.
O tempo necessário para reduzir a escala verticalmente até um tipo de nó menor varia, dependendo do tipo de nó e da quantidade de dados no seu cluster atual.
**Redução de escala vertical (API do MemoryDB)**
1. Determine quais tipos de nós você pode reduzir usando a [ListAllowedNodeTypeUpdates](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_ListAllowedNodeTypeUpdates.html)API com o seguinte parâmetro:
+ `ClusterName`: o nome do cluster. Use esse parâmetro para descrever um cluster específico em vez de todos os clusters.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=ListAllowedNodeTypeUpdates
&ClusterName=MyCluster
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
1. Reduza seu cluster atual para o novo tipo de nó usando a [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html)API com os parâmetros a seguir.
+ `ClusterName`: o nome do cluster.
+ `NodeType`: o novo tipo de nó menor dos clusters nesse cluster. Esse valor deve ser um dos tipos de instância retornados pela ação `ListAllowedNodeTypeUpdates` na etapa 1.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=UpdateCluster
&NodeType=db.r6g.2xlarge
&ClusterName=myReplGroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210801T220302Z
&Version=2021-01-01
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Date=20210801T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20210801T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```