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á.
# Snapshots e restauração
ElastiCache Os caches da Amazon que executam Valkey, Redis OSS ou Serverless Memcached podem fazer backup de seus dados criando um snapshot. É possível usar o backup para restaurar um cache ou propagar dados para um novo cache. O backup consiste nos metadados do cache com todos os dados no cache. Todos os backups são gravados no Amazon Simple Storage Service (Amazon S3), que fornece armazenamento durável. A qualquer momento, você pode restaurar os dados criando um novo cache do Valkey, Redis OSS ou Memcached de tecnologia sem servidor e o preenchendo com dados de um backup. Com ElastiCache, você pode gerenciar backups usando o Console de gerenciamento da AWS, o AWS Command Line Interface(AWS CLI) e a ElastiCache API.
Se quiser excluir um cache e for importante preservar os dados, você poderá tomar uma precaução extra. Para isso, crie um backup manual primeiro, verifique se o status está *disponível* e, em seguida, exclua o cluster. Isso garante que, se o backup falhar, você ainda terá os dados do cache disponíveis. Você pode tentar um backup novamente, seguindo as práticas recomendadas descritas anteriormente.
**Topics**
+ [Restrições do backup](#backups-constraints)
+ [Impacto sobre o desempenho dos backups de clusters baseados em nós](#backups-performance)
+ [Programação de backups automáticos](backups-automatic.md)
+ [Realização de backups manuais](backups-manual.md)
+ [Criação de um backup final](backups-final.md)
+ [Descrição de backups](backups-describing.md)
+ [Copiar backups](backups-copying.md)
+ [Exportação de um backup](backups-exporting.md)
+ [Restauração de um backup para um novo cache](backups-restoring.md)
+ [Exclusão de um backup](backups-deleting.md)
+ [Marcação de backups](backups-tagging.md)
+ [Tutorial: propagação de um novo cluster baseado em nós com um backup criado externamente](backups-seeding-redis.md)
## Restrições do backup
Considere as seguintes restrições ao planejar ou fazer backups:
+ O backup e a restauração são suportados apenas para caches executados no Valkey, Redis OSS ou Memcached de tecnologia sem servidor.
+ Para clusters do Valkey ou Redis OSS (modo cluster desabilitado), não há suporte para backup e restauração em nós `cache.t1.micro`. Todos os outros tipos de nó de cache têm suporte.
+ Para clusters do Valkey ou Redis OSS (modo cluster habilitado), o backup e a restauração têm suporte para todos os tipos de nó.
+ Durante qualquer período contíguo de 24 horas, você não pode criar mais de 24 backups manuais por cache de tecnologia sem servidor. Para clusters baseados em nós do Valkey e Redis OSS, você não pode criar mais de 20 backups manuais por nó do cluster.
+ O Valkey ou Redis OSS (modo cluster habilitado) oferece suporte apenas para backups no nível do cluster (para a API ou CLI, no nível do grupo de replicação). O Valkey ou Redis OSS (modo cluster habilitado) não oferece suporte à execução de backups no nível do fragmento (para a API ou CLI, no nível do grupo de nós).
+ Durante o processo de backup, não é possível executar outra operação de API ou CLI no cache de tecnologia sem servidor. Você pode executar operações de API ou CLI em um cluster baseado em nós durante o backup.
+ Se você estiver usando caches do Valkey ou Redis OSS com classificação de dados em níveis, não será possível exportar um backup para o Amazon S3.
+ Só é possível restaurar um backup de um cluster usando o tipo de nó r6gd para clusters que estejam usando o tipo de nó r6gd.
## Impacto sobre o desempenho dos backups de clusters baseados em nós
Os backups em caches sem servidor são transparentes para a aplicação, sem impacto sobre o desempenho. No entanto, durante a criação de backups para clusters baseados em nós, é possível que haja algum impacto sobre o desempenho, dependendo da memória reservada disponível. Os backups para clusters baseados em nós não estão disponíveis com ElastiCache o Memcached, mas estão disponíveis com ElastiCache o Redis OSS.
Estas são as diretrizes a fim de melhorar o desempenho do backup para clusters baseados em nós.
+ Definir o `reserved-memory-percent` parâmetro — Para reduzir a paginação excessiva, recomendamos que você defina o *reserved-memory-percent*parâmetro. Esse parâmetro impede que o Valkey e Redis OSS consumam toda a memória disponível do nó e pode ajudar a reduzir a quantidade de paginação. Você também pode ver melhorias de desempenho simplesmente usando um nó maior. Para obter mais informações sobre a *memória reservada* e *reserved-memory-percent*os parâmetros, consulte. [Gerenciamento de memória reservada para Valkey e Redis OSS](redis-memory-management.md)
+ Crie backups a partir de uma réplica de leitura: se você estiver executando o Valkey ou Redis OSS em um grupo de nós com mais de um nó, será possível fazer um backup do nó primário ou de uma das réplicas de leitura. Devido aos recursos do sistema necessários durante um BGSAVE, recomendamos que você crie backups de uma das réplicas de leitura. Enquanto o backup está sendo criado da réplica, o nó primário permanece inalterado pelos requisitos de recursos de BGSAVE. O nó primário pode continuar a atender solicitações sem ficar lento.
Para fazer isso, consulte [Criação de um backup manual (console)](backups-manual.md#backups-manual-CON), e no campo **Cluster Name** (Nome do cluster) na janela **Create Backup** (Criar backup), escolha uma réplica em vez do nó primário padrão.
Se você excluir um grupo de replicação e solicitar um backup final, ElastiCache sempre fará o backup do nó primário. Isso garante que você capture os dados mais recentes do Valkey ou Redis OSS antes que o grupo de replicação seja excluído.
# Programação de backups automáticos
É possível habilitar backups automáticos para qualquer cache de tecnologia sem servidor do Valkey ou Redis OSS ou para qualquer cluster baseado em nós. Quando os backups automáticos estão habilitados, ElastiCache cria um backup do cache diariamente. Não há impacto sobre o cache, e a alteração é imediata. Os backups automáticos podem ajudar a proteger contra a perda de dados. Em caso de falha, você pode criar um cache e restaurar os dados usando o backup mais recente. O resultado é um cache inicializado a quente, pré-carregado com os dados e pronto para uso. Para obter mais informações, consulte [Restauração de um backup para um novo cache](backups-restoring.md).
É possível ativar backups automáticos para qualquer cache de tecnologia sem servidor do Memcached. Quando os backups automáticos estão habilitados, ElastiCache cria um backup do cache diariamente. Não há impacto sobre o cache, e a alteração é imediata. Os backups automáticos podem ajudar a proteger contra a perda de dados. Em caso de falha, você pode criar um cache e restaurar os dados usando o backup mais recente. O resultado é um cache inicializado a quente, pré-carregado com os dados e pronto para uso. Para obter mais informações, consulte [Restauração de um backup para um novo cache](backups-restoring.md).
Ao agendar backups automáticos, você deve planejar as seguintes configurações:
+ **Hora de início do backup** — Uma hora do dia em que ElastiCache começa a criar um backup. É possível definir a janela de backup para qualquer momento quando mais prático. Se você não especificar uma janela de backup, ElastiCache atribuirá uma automaticamente.
+ **Backup retention limit** (Limite de retenção de backup): o número de dias em que o backup é mantido no Amazon S3. Por exemplo, se o limite de retenção for definido como 5, um backup feito hoje será mantido por 5 dias. Quando o limite de retenção expirar, o backup será excluído automaticamente.
O limite máximo de retenção de backups é de 35 dias. Se o limite de retenção do backup for definido como 0, os backups automáticos serão desabilitados para o cache.
Quando você agendar backups automáticos, ElastiCache começará a criar o backup. É possível definir a janela de backup para qualquer momento quando mais prático. Se você não especificar uma janela de backup, ElastiCache atribuirá uma automaticamente.
Você pode ativar ou desativar os backups automáticos ao criar um novo cache ou atualizar um cache existente usando o ElastiCache console AWS CLI, o ou a ElastiCache API. Para Valkey e Redis OSS, isso é feito marcando a caixa **Ativar backups automáticos** na seção **Configurações avançadas do Valkey** ou **Configurações avançadas do Redis OSS**. Para Memcached, isso é feito marcando a caixa **Ativar backups automáticos** na seção **Configurações avançadas do Memcached**.
# Realização de backups manuais
Além dos backups automáticos, você pode criar um backup *manual* a qualquer momento. Ao contrário dos backups automáticos, que são excluídos automaticamente após um período de retenção especificado, os backups manuais não têm um período de retenção após o qual são excluídos automaticamente. Mesmo se você excluir o cache, todos os backups manuais desse cache são retidos. Caso não queira mais manter um backup manual, você deverá excluí-lo explicitamente por conta própria.
Além de criar diretamente um backup manual, você pode criar um backup manual de uma das seguintes maneiras:
+ [Copiar backups](backups-copying.md). Não importa se o backup de origem foi criado automática ou manualmente.
+ [Criação de um backup final](backups-final.md). Crie imediatamente um backup antes de excluir um cluster ou nó.
Você pode criar um backup manual de um cache usando a Console de gerenciamento da AWSAWS CLI, a ou a ElastiCache API.
Você pode gerar backups manuais a partir de réplicas com o modo de cluster habilitado e o modo de cluster desabilitado.
## Criação de um backup manual (console)
**Para criar um backup de um cache (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. No painel de navegação, escolha **Caches do Valkey**, **Caches do Redis OSS** ou **Caches do Memcached**, dependendo da sua preferência.
1. Selecione a caixa à esquerda do nome do cache do qual você deseja fazer backup.
1. Escolha **Backup**.
1. No diálogo **Criar backup**, digite um nome para seu backup na caixa **Nome do backup**. Recomendamos que o nome indique o cluster do backup e a data e hora de criação do backup.
As restrições de nomenclatura de cluster são as seguintes:
+ Devem conter 1 a 40 caracteres alfanuméricos ou hifens.
+ Deve começar com uma letra.
+ Não podem conter dois hifens consecutivos.
+ Não podem terminar com um hífen.
1. Escolha **Create Backup**.
O status do cluster muda para *snapshotting*.
## Criação de um backup manual (AWS CLI)
**Backup manual de um cache sem servidor com o AWS CLI**
Para criar um backup manual de um cache usando o AWS CLI, use a `create-serverless-snapshot`AWS CLI operação com os seguintes parâmetros:
+ `--serverless-cache-name`: o nome do cache sem servidor do qual você está fazendo backup.
+ `--serverless-cache-snapshot-name` - Nome do snapshot a ser criado.
Para Linux, macOS ou Unix:
+
```
aws elasticache create-serverless-snapshot \
--serverless-cache-name CacheName \
--serverless-cache-snapshot-name bkup-20231127
```
Para Windows:
+
```
aws elasticache create-serverless-snapshot ^
--serverless-cache-name CacheName ^
--serverless-cache-snapshot-name bkup-20231127
```
**Backup manual de um cluster baseado em nós com o AWS CLI**
Para criar um backup manual de um cluster baseado em nós usando o AWS CLI, use a `create-snapshot`AWS CLI operação com os seguintes parâmetros:
+ `--cache-cluster-id`
+ Se o cluster do qual você está fazendo backup não tiver nós de réplica, `--cache-cluster-id` é o nome do cluster do qual você está fazendo backup, por exemplo. *mycluster*
+ Se o cluster do backup tiver um ou mais nós de réplica, `--cache-cluster-id` será o nome do nó no cluster que você deseja usar para o backup. Por exemplo, o nome pode ser*mycluster-002*.
Use este parâmetro somente ao fazer backup de um cluster do Valkey ou Redis OSS (modo cluster desabilitado).
+ `--replication-group-id`: nome do cluster do Valkey ou Redis OSS (modo cluster habilitado) (CLI/API: um grupo de replicação) para usar como fonte para o backup. Use este parâmetro ao fazer backup de um cluster do Valkey ou Redis OSS (modo cluster habilitado).
+ `--snapshot-name` - Nome do snapshot a ser criado.
As restrições de nomenclatura de cluster são as seguintes:
+ Devem conter 1 a 40 caracteres alfanuméricos ou hifens.
+ Deve começar com uma letra.
+ Não podem conter dois hifens consecutivos.
+ Não podem terminar com um hífen.
### Exemplo 1: backup de um cluster do Valkey ou Redis OSS (modo cluster desabilitado) que não tem nós de réplicas
A AWS CLI operação a seguir cria o backup `bkup-20150515` do cluster Valkey ou Redis OSS (modo de cluster desativado) `myNonClusteredRedis` que não tem réplicas de leitura.
Para Linux, macOS ou Unix:
```
aws elasticache create-snapshot \
--cache-cluster-id myNonClusteredRedis \
--snapshot-name bkup-20150515
```
Para Windows:
```
aws elasticache create-snapshot ^
--cache-cluster-id myNonClusteredRedis ^
--snapshot-name bkup-20150515
```
### Exemplo 2: backup de um cluster do Valkey ou Redis OSS (modo cluster desabilitado) com nós de réplicas
A AWS CLI operação a seguir cria o backup `bkup-20150515` do cluster Valkey ou Redis OSS (modo de cluster desativado). `myNonClusteredRedis` Esse backup tem uma ou mais réplicas de leitura.
Para Linux, macOS ou Unix:
```
aws elasticache create-snapshot \
--cache-cluster-id myNonClusteredRedis-001 \
--snapshot-name bkup-20150515
```
Para Windows:
```
aws elasticache create-snapshot ^
--cache-cluster-id myNonClusteredRedis-001 ^
--snapshot-name bkup-20150515
```
**Saída do exemplo: backup de um cluster do Valkey ou Redis OSS (modo cluster desabilitado) com nós de réplicas**
A saída da operação é semelhante à seguinte.
```
{
"Snapshot": {
"Engine": "redis",
"CacheParameterGroupName": "default.redis6.x",
"VpcId": "vpc-91280df6",
"CacheClusterId": "myNonClusteredRedis-001",
"SnapshotRetentionLimit": 0,
"NumCacheNodes": 1,
"SnapshotName": "bkup-20150515",
"CacheClusterCreateTime": "2017-01-12T18:59:48.048Z",
"AutoMinorVersionUpgrade": true,
"PreferredAvailabilityZone": "us-east-1c",
"SnapshotStatus": "creating",
"SnapshotSource": "manual",
"SnapshotWindow": "08:30-09:30",
"EngineVersion": "6.0",
"NodeSnapshots": [
{
"CacheSize": "",
"CacheNodeId": "0001",
"CacheNodeCreateTime": "2017-01-12T18:59:48.048Z"
}
],
"CacheSubnetGroupName": "default",
"Port": 6379,
"PreferredMaintenanceWindow": "wed:07:30-wed:08:30",
"CacheNodeType": "cache.m3.2xlarge",
"DataTiering": "disabled"
}
}
```
### Exemplo 3: backup de um cluster do Valkey ou Redis OSS (modo cluster habilitado)
A AWS CLI operação a seguir cria o backup `bkup-20150515` do cluster Valkey ou Redis OSS (modo de cluster ativado). `myClusteredRedis` Observe o uso de `--replication-group-id` no lugar de `--cache-cluster-id` para identificar a origem. Observe também que ElastiCache faz o backup usando o nó de réplica quando presente e usará como padrão o nó primário se um nó de réplica não estiver disponível.
Para Linux, macOS ou Unix:
```
aws elasticache create-snapshot \
--replication-group-id myClusteredRedis \
--snapshot-name bkup-20150515
```
Para Windows:
```
aws elasticache create-snapshot ^
--replication-group-id myClusteredRedis ^
--snapshot-name bkup-20150515
```
**Saída do exemplo: backup de um cluster do Valkey ou Redis OSS (modo cluster habilitado)**
A saída dessa operação é semelhante à seguinte.
```
{
"Snapshot": {
"Engine": "redis",
"CacheParameterGroupName": "default.redis6.x.cluster.on",
"VpcId": "vpc-91280df6",
"NodeSnapshots": [
{
"CacheSize": "",
"NodeGroupId": "0001"
},
{
"CacheSize": "",
"NodeGroupId": "0002"
}
],
"NumNodeGroups": 2,
"SnapshotName": "bkup-20150515",
"ReplicationGroupId": "myClusteredRedis",
"AutoMinorVersionUpgrade": true,
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotStatus": "creating",
"SnapshotSource": "manual",
"SnapshotWindow": "10:00-11:00",
"EngineVersion": "6.0",
"CacheSubnetGroupName": "default",
"ReplicationGroupDescription": "2 shards 2 nodes each",
"Port": 6379,
"PreferredMaintenanceWindow": "sat:03:30-sat:04:30",
"CacheNodeType": "cache.r3.large",
"DataTiering": "disabled"
}
}
```
### Tópicos relacionados
Para obter mais informações, consulte [create-snapshot](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-snapshot.html) na *Referência de comandos da AWS CLI*.
## Criando um backup usando CloudFormation
Você pode usar CloudFormation para criar um backup do seu cache ElastiCache Redis OSS ou Valkey, usando as `AWS::ElastiCache::ServerlessCache` propriedades ou. `AWS::ElastiCache::ReplicationGroup`
**Usar o recurso `AWS::ElastiCache::ServerlessCache`**
Use isso para criar um backup usando o AWS::ElastiCache::ServerlessCache recurso:
```
Resources:
iotCatalog:
Type: AWS::ElastiCache::ServerlessCache
Properties:
...
ServerlessCacheName: "your-cache-name"
Engine: "redis"
CacheUsageLimits
```
**Usando o AWS::ElastiCache::ReplicationGroup recurso**
Use o recurso `AWS::ElastiCache::ReplicationGroup`:
```
Resources:
iotCatalog:
Type: AWS::ElastiCache::ReplicationGroup
Properties:
...
ReplicationGroupDescription: "Description of your replication group"
Engine: "redis"
CacheNodeType
NumCacheClusters
AutomaticFailoverEnabled
AtRestEncryptionEnabled
```
# Criação de um backup final
Você pode criar um backup final usando o ElastiCache console AWS CLI, o ou a ElastiCache API.
## Criação de um backup final (console)
Você pode criar um backup final ao excluir um cache sem servidor Valkey, Memcached ou Redis OSS, ou um cluster baseado em nós Valkey ou Redis OSS, usando o console. ElastiCache
Para criar um backup final ao excluir um cache, na caixa de diálogo, escolha **Sim**, em **Criar backup** e dê um nome ao backup.
**Tópicos relacionados**
+ [Usando o Console de gerenciamento da AWS](Clusters.Delete.md#Clusters.Delete.CON)
+ [Exclusão de um grupo de replicação (Console)](Replication.DeletingRepGroup.md#Replication.DeletingRepGroup.CON)
## Criação de um backup final (AWS CLI)
Você pode criar um backup final ao excluir um cache usando a AWS CLI.
**Topics**
+ [Ao excluir um cache do Valkey, cache de tecnologia sem servidor do Memcached ou cache do Redis OSS](#w2aac24b7c29b7b1b7)
+ [Ao excluir um cluster do Valkey ou Redis OSS sem réplicas de leitura](#w2aac24b7c29b7b1b9)
+ [Ao excluir um cluster do Valkey ou Redis OSS com réplicas de leitura](#w2aac24b7c29b7b1c11)
### Ao excluir um cache do Valkey, cache de tecnologia sem servidor do Memcached ou cache do Redis OSS
Para criar um backup final, use a `delete-serverless-cache`AWS CLI operação com os seguintes parâmetros.
+ `--serverless-cache-name`: nome do cache que está sendo excluído.
+ `--final-snapshot-name` – Nome do backup.
O código a seguir cria o backup final `bkup-20231127-final` ao excluir o cache `myserverlesscache`.
Para Linux, macOS ou Unix:
```
aws elasticache delete-serverless-cache \
--serverless-cache-name myserverlesscache \
--final-snapshot-name bkup-20231127-final
```
Para Windows:
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name myserverlesscache ^
--final-snapshot-name bkup-20231127-final
```
Para obter mais informações, consulte [delete-serverless-cache](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-serverless-cache.html) na *Referência de comandos da AWS CLI*.
### Ao excluir um cluster do Valkey ou Redis OSS sem réplicas de leitura
Para criar um backup final para um cluster baseado em nós sem réplicas de leitura, use a `delete-cache-cluster`AWS CLI operação com os parâmetros a seguir.
+ `--cache-cluster-id`: nome do cluster que está sendo excluído.
+ `--final-snapshot-identifier` – Nome do backup.
O código a seguir cria o backup final `bkup-20150515-final` ao excluir o cluster `myRedisCluster`.
Para Linux, macOS ou Unix:
```
aws elasticache delete-cache-cluster \
--cache-cluster-id myRedisCluster \
--final-snapshot-identifier bkup-20150515-final
```
Para Windows:
```
aws elasticache delete-cache-cluster ^
--cache-cluster-id myRedisCluster ^
--final-snapshot-identifier bkup-20150515-final
```
Para obter mais informações, consulte [delete-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html) na *Referência de comandos da AWS CLI*.
### Ao excluir um cluster do Valkey ou Redis OSS com réplicas de leitura
Para criar um backup final ao excluir um grupo de replicação, use a `delete-replication-group`AWS CLI operação, com os seguintes parâmetros:
+ `--replication-group-id` – Nome do grupo de replicação que está sendo excluído.
+ `--final-snapshot-identifier` – Nome do backup final.
O código a seguir usa o backup final `bkup-20150515-final` ao excluir o grupo de replicação `myReplGroup`.
Para Linux, macOS ou Unix:
```
aws elasticache delete-replication-group \
--replication-group-id myReplGroup \
--final-snapshot-identifier bkup-20150515-final
```
Para Windows:
```
aws elasticache delete-replication-group ^
--replication-group-id myReplGroup ^
--final-snapshot-identifier bkup-20150515-final
```
Para obter mais informações, consulte [delete-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-replication-group.html) na *Referência de comandos da AWS CLI*.
# Descrição de backups
Os procedimentos a seguir mostram como exibir uma lista dos seus backups. Se desejar, você também pode visualizar os detalhes de um backup específico.
## Descrição de backups (console)
**Para exibir backups usando o Console de gerenciamento da AWS**
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 **Backups**.
1. Para ver os detalhes de um backup específico, escolha a caixa à esquerda do nome do backup.
## Descrição dos backups sem servidor (AWS CLI)
Para exibir uma lista de backups sem servidor e, como opção, detalhes sobre um backup específico, use a operação `describe-serverless-cache-snapshots` da CLI.
**Exemplos**
A seguinte operação usa o parâmetro `--max-records` para listar até 20 backups associados à sua conta. Omitir o parâmetro `--max-records` lista até 50 backups.
```
aws elasticache describe-serverless-cache-snapshots --max-records 20
```
A operação a seguir usa o parâmetro `--serverless-cache-name` para só listar os backups associados ao cache `my-cache`.
```
aws elasticache describe-serverless-cache-snapshots --serverless-cache-name my-cache
```
A operação a seguir usa o parâmetro `--serverless-cache-snapshot-name` para exibir os detalhes do backup `my-backup`.
```
aws elasticache describe-serverless-cache-snapshots --serverless-cache-snapshot-name my-backup
```
Para obter mais informações, consulte [describe-serverless-cache-snapshots](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-serverless-cache-snapshots.html)na Referência de AWS CLI Comandos.
## Descrever backups de cluster baseados em nós (AWS CLI)
Para exibir uma lista de backups de cluster baseados em nós e, opcionalmente, detalhes sobre um backup específico, use a operação `describe-snapshots` da CLI.
**Exemplos**
A seguinte operação usa o parâmetro `--max-records` para listar até 20 backups associados à sua conta. Omitir o parâmetro `--max-records` lista até 50 backups.
```
aws elasticache describe-snapshots --max-records 20
```
A operação a seguir usa o parâmetro `--cache-cluster-id` para listar apenas os backups associados ao cluster `my-cluster`.
```
aws elasticache describe-snapshots --cache-cluster-id my-cluster
```
A operação a seguir usa o parâmetro `--snapshot-name` para exibir os detalhes do backup `my-backup`.
```
aws elasticache describe-snapshots --snapshot-name my-backup
```
Para obter mais informações, consulte [describe-snapshots](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-snapshots.html) na Referência de Comandos.AWS CLI
# Copiar backups
É possível fazer uma cópia de qualquer backup, seja ele criado automática ou manualmente. Você também pode exportar seu backup para acessá-lo de fora ElastiCache. Para obter orientação sobre como exportar o backup, consulte [Exportação de um backup](backups-exporting.md).
As etapas a seguir mostram como copiar um backup.
## Cópia de backups (console)
**Para copiar um backup (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. Para ver uma lista dos seus backups, no painel de navegação esquerdo, escolha **Backups**.
1. Na lista de backups, escolha a caixa à esquerda do nome do backup que você deseja copiar.
1. Escolha **Ações** e **Copiar**.
1. Na caixa **New backup name**, digite um nome para seu novo backup.
1. Escolha **Copiar**.
## Cópia de um backup sem servidor (AWS CLI)
Para copiar um backup de um cache sem servidor, use a operação `copy-serverless-cache-snapshot`.
**Parâmetros**
+ `--source-serverless-cache-snapshot-name` - Nome do backup a ser copiado.
+ `--target-serverless-cache-snapshot-name` - Nome da cópia do backup.
O exemplo a seguir faz uma cópia de um backup automático.
Para Linux, macOS ou Unix:
```
aws elasticache copy-serverless-cache-snapshot \
--source-serverless-cache-snapshot-name automatic.my-cache-2023-11-27-03-15 \
--target-serverless-cache-snapshot-name my-backup-copy
```
Para Windows:
```
aws elasticache copy-serverless-cache-snapshot ^
--source-serverless-cache-snapshot-name automatic.my-cache-2023-11-27-03-15 ^
--target-serverless-cache-snapshot-name my-backup-copy
```
Para ter mais informações, consulte [https://docs.aws.amazon.com/cli/latest/reference/elasticache/copy-serverless-cache-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/copy-serverless-cache-snapshot.html) no *AWS CLI*.
## Copiar um backup de cluster baseado em nós (AWS CLI)
Para copiar um backup de um cluster baseado em nós, use a operação `copy-snapshot`.
**Parâmetros**
+ `--source-snapshot-name` - Nome do backup a ser copiado.
+ `--target-snapshot-name` - Nome da cópia do backup.
+ `--target-bucket`: reservado para exportação de um backup. Não use esse parâmetro ao fazer uma cópia de um backup. Para obter mais informações, consulte [Exportação de um backup](backups-exporting.md).
O exemplo a seguir faz uma cópia de um backup automático.
Para Linux, macOS ou Unix:
```
aws elasticache copy-snapshot \
--source-snapshot-name automatic.my-redis-primary-2014-03-27-03-15 \
--target-snapshot-name amzn-s3-demo-bucket
```
Para Windows:
```
aws elasticache copy-snapshot ^
--source-snapshot-name automatic.my-redis-primary-2014-03-27-03-15 ^
--target-snapshot-name amzn-s3-demo-bucket
```
Para ter mais informações, consulte [https://docs.aws.amazon.com/cli/latest/reference/elasticache/copy-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/copy-snapshot.html) no *AWS CLI*.
# Exportação de um backup
A Amazon ElastiCache suporta a exportação de seu backup do OSS ElastiCache para Redis para um bucket do Amazon Simple Storage Service (Amazon S3), que dá acesso externo a ele. ElastiCache Você pode exportar um backup usando o ElastiCache console AWS CLI, o ou a ElastiCache API.
Exportar um backup pode ser útil se você precisar iniciar um cluster em outra AWS região. Você pode exportar seus dados em uma AWS região, copiar o arquivo.rdb para a nova AWS região e, em seguida, usar esse arquivo.rdb para alimentar o novo cache em vez de esperar que o novo cluster seja preenchido por meio do uso. Para obter informações sobre como criar um novo cluster, consulte [Tutorial: propagação de um novo cluster baseado em nós com um backup criado externamente](backups-seeding-redis.md). Outra razão pela qual você pode querer exportar os dados do seu cache é para usar o arquivo .rdb para processamento off-line.
**Importante**
O ElastiCache backup e o bucket do Amazon S3 para o qual você deseja copiá-lo devem estar na mesma AWS região.
Embora os backups copiados para um bucket do Amazon S3 sejam criptografados, recomendamos que você não conceda a outras pessoas acesso ao bucket do Amazon S3 no qual deseja armazená-los.
A exportação de um backup para o Amazon S3 não é compatível com clusters que usam classificação de dados em níveis. Para obter mais informações, consulte [Classificação de dados em níveis no ElastiCache](data-tiering.md).
A exportação de um backup está disponível para: clusters Valkey baseados em nós, clusters Redis OSS baseados em nós e caches com tecnologia sem servidor do Valkey, Memcached e Redis OSS. A exportação de um backup não está disponível para clusters baseados em nós do Memcached.
Antes de exportar um backup para um bucket do Amazon S3, você deve ter um bucket do Amazon S3 na AWS mesma região do backup. Conceda ElastiCache acesso ao bucket. As duas primeiras etapas mostram como fazer isso.
## Crie um bucket Amazon S3
As etapas a seguir usam o console do Amazon S3 para criar um bucket do Amazon S3 onde você exporta e armazena seu backup. ElastiCache
**Como criar um bucket do Amazon S3**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Escolha **Criar bucket**.
1. Em **Create a Bucket - Select a Bucket Name and Region**, faça o seguinte:
1. Em **Bucket Name** (Nome do bucket), digite um nome para o bucket do Amazon S3.
O nome do bucket do Amazon S3 deve estar em conformidade com o DNS. Caso contrário, não ElastiCache conseguirá acessar seu arquivo de backup. As regras para a conformidade de DNS são:
+ Os nomes devem ter no mínimo 3 e no máximo 63 caracteres de extensão.
+ Os nomes devem ser uma série de um ou mais rótulos separados por um ponto (.) em que cada rótulo:
+ Começa com uma letra minúscula ou um número.
+ Termina com uma letra minúscula ou um número.
+ Contém somente letras minúsculas, números e traços.
+ Os nomes não podem ser formatado como um endereço IP (por exemplo, 192.0.2.0).
1. Na lista de **regiões**, escolha uma AWS região para seu bucket do Amazon S3. Essa AWS região deve ser a mesma AWS região do ElastiCache backup que você deseja exportar.
1. Escolha **Criar**.
Para obter mais informações sobre como criar um bucket do Amazon S3, consulte [Criação de um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html), no *Guia do usuário do Amazon Simple Storage Service*.
## Conceda ElastiCache acesso ao seu bucket Amazon S3
ElastiCache Para poder copiar um snapshot em um bucket do Amazon S3, você deve atualizar sua política de bucket do IAM para ElastiCache conceder acesso ao bucket.
**Atenção**
Mesmo que os backups copiados em um bucket do Amazon S3 sejam criptografados, seus dados podem ser acessados por qualquer pessoa com acesso ao seu bucket do Amazon S3. Portanto, recomendamos que você configure políticas do IAM para impedir o acesso não autorizado a esse bucket do Amazon S3. Para obter mais informações, consulte [Gerenciamento de acesso](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html) no *Guia do usuário do Amazon S3*.
Para criar as permissões adequadas em um bucket do Amazon S3, siga as etapas descritas abaixo.
**Para conceder ElastiCache acesso a um bucket do S3**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Escolha o nome do bucket do Amazon S3 para o qual você deseja copiar o backup. Esse deve ser o bucket do S3 que você criou em [Crie um bucket Amazon S3](#backups-exporting-create-s3-bucket).
1. Selecione a guia **Permissions** (Permissões) e, em **Permissions** (Permissões), escolha **Access control list (ACL)** (Lista de controle de acesso (ACL)) e, depois, **Edit** (Editar).
1. Adicionar ID canônico do beneficiário `540804c33a284a299d2547575ce1010f2312ef3da9b3a053c8bc45bf233e4353` com as seguintes opções:
+ **Objetos: listar, gravar**
+ **ACL de bucket: ler, gravar**
**nota**
Para a GovCloud região PDT, o ID canônico é. `40fa568277ad703bd160f66ae4f83fc9dfdfd06c2f1b5060ca22442ac3ef8be6`
Para a GovCloud região OSU, o ID canônico é. `c54286759d2a83da9c480405349819c993557275cf37d820d514b42da6893f5c`
1. Escolha **Salvar**.
## Exportar e ElastiCache fazer backup
Agora você criou seu bucket do S3 e concedeu ElastiCache permissões para acessá-lo. Em seguida, você pode usar o ElastiCache console, a AWS CLI ou a ElastiCache API para exportar seu snapshot para ele.
Veja a seguir um exemplo de como a política atualizada pode parecer.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Policy15397346",
"Statement": [
{
"Sid": "Stmt15399484",
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::hkg-elasticache-backup",
"arn:aws:s3:::hkg-elasticache-backup/*"
]
}
]
}
```
------
Para escolher regiões, veja a seguir um exemplo da aparência da política atualizada do IAM para o bucket do S3. O exemplo usa a região Ásia-Pacífico (Hong Kong).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Policy15397346",
"Statement": [
{
"Sid": "Stmt15399483",
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::hkg-elasticache-backup",
"arn:aws:s3:::hkg-elasticache-backup/*"
]
},
{
"Sid": "Stmt15399484",
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::hkg-elasticache-backup",
"arn:aws:s3:::hkg-elasticache-backup/*"
]
}
]
}
```
------
### Exportação de um ElastiCache backup (console)
As etapas a seguir usam o ElastiCache console para exportar um backup para um bucket do Amazon S3 para que você possa acessá-lo de fora. ElastiCache O bucket do Amazon S3 deve estar na mesma AWS região do ElastiCache backup.
**Para exportar um ElastiCache backup para um bucket do Amazon S3**
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. Para ver uma lista dos seus backups, no painel de navegação esquerdo, escolha **Backups**.
1. Na lista de backups, escolha a caixa à esquerda do nome do backup que você deseja exportar.
1. Escolha **Copiar**.
1. Em **Create a Copy of the Backup?** (Criar uma cópia do backup?), faça o seguinte:
1. Na caixa **New backup name** (Novo nome de backup), digite um nome para seu novo backup.
O nome deve ter entre 1 e 1.000 caracteres e pode ser codificado em UTF-8.
ElastiCache adiciona um identificador de instância e `.rdb` ao valor que você insere aqui. Por exemplo, se você inserir `my-exported-backup`, ElastiCache criará `my-exported-backup-0001.rdb`.
1. Na lista **Target S3 Location** (Local do S3 de destino), escolha o nome do bucket do Amazon S3 para o qual você deseja copiar seu backup (o bucket que você criou em [Crie um bucket Amazon S3](#backups-exporting-create-s3-bucket)).
O **local de destino do S3** deve ser um bucket do Amazon S3 na região AWS do backup com as seguintes permissões para que o processo de exportação seja bem-sucedido.
+ Acesso ao objeto: **Ler** e **Escrever**.
+ Permissões de acesso: **Ler**.
Para obter mais informações, consulte [Conceda ElastiCache acesso ao seu bucket Amazon S3](#backups-exporting-grant-access).
1. Escolha **Copiar**.
**nota**
Se seu bucket do S3 não tiver as permissões necessárias ElastiCache para exportar um backup para ele, você receberá uma das seguintes mensagens de erro. Retorne para [Conceda ElastiCache acesso ao seu bucket Amazon S3](#backups-exporting-grant-access) a fim de adicionar as permissões especificadas e tente exportar o backup novamente.
ElastiCache não recebeu permissões READ %s no S3 Bucket.
**Solução:** adicione permissões de Leitura no bucket.
ElastiCache não recebeu permissões de GRAVAÇÃO %s no S3 Bucket.
**Solução:** adicione permissões de Gravação no bucket.
ElastiCache não recebeu as permissões READ\$1ACP %s no S3 Bucket.
**Solução:** adicione permissão de acesso de **Leitura** no bucket.
Se você quiser copiar seu backup para outra AWS região, use o Amazon S3 para copiá-lo. Para obter mais informações, consulte [Cópia de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/MakingaCopyofanObject.html) no *Guia do usuário do Amazon Simple Storage Service*.
### Exportação de um ElastiCache backup sem servidor ()AWS CLI
**Exportação de um backup de um cache sem servidor**
Exporte o backup para um bucket do Amazon S3 usando a operação `export-serverless-cache-snapshot` da CLI com os seguintes parâmetros:
**Parâmetros**
+ `--serverless-cache-snapshot-name` - Nome do backup a ser copiado.
+ `--s3-bucket-name`: nome do bucket do Amazon S3 no qual você deseja exportar o backup. Uma cópia do backup é feita no bucket especificado.
`--s3-bucket-name`Deve ser um bucket do Amazon S3 na AWS região do backup com as seguintes permissões para que o processo de exportação seja bem-sucedido.
+ Acesso ao objeto: **Ler** e **Escrever**.
+ Permissões de acesso: **Ler**.
A operação a seguir copia um backup para my-s3-bucket.
Para Linux, macOS ou Unix:
```
aws elasticache export-serverless-cache-snapshot \
--serverless-cache-snapshot-name automatic.my-redis-2023-11-27 \
--s3-bucket-name my-s3-bucket
```
Para Windows:
```
aws elasticache export-serverless-cache-snapshot ^
--serverless-cache-snapshot-name automatic.my-redis-2023-11-27 ^
--s3-bucket-name my-s3-bucket
```
### Exportando um backup de ElastiCache cluster baseado em nós ()AWS CLI
**Exportar um backup de um cluster baseado em nós**
Exporte o backup para um bucket do Amazon S3 usando a operação `copy-snapshot` da CLI com os seguintes parâmetros:
**Parâmetros**
+ `--source-snapshot-name` - Nome do backup a ser copiado.
+ `--target-snapshot-name` - Nome da cópia do backup.
O nome deve ter entre 1 e 1.000 caracteres e pode ser codificado em UTF-8.
ElastiCache adiciona um identificador de instância e `.rdb` ao valor inserido aqui. Por exemplo, se você inserir `my-exported-backup`, ElastiCache criará `my-exported-backup-0001.rdb`.
+ `--target-bucket`: nome do bucket do Amazon S3 no qual você deseja exportar o backup. Uma cópia do backup é feita no bucket especificado.
`--target-bucket`Deve ser um bucket do Amazon S3 na AWS região do backup com as seguintes permissões para que o processo de exportação seja bem-sucedido.
+ Acesso ao objeto: **Ler** e **Escrever**.
+ Permissões de acesso: **Ler**.
Para obter mais informações, consulte [Conceda ElastiCache acesso ao seu bucket Amazon S3](#backups-exporting-grant-access).
A operação a seguir copia um backup para my-s3-bucket.
Para Linux, macOS ou Unix:
```
aws elasticache copy-snapshot \
--source-snapshot-name automatic.my-redis-primary-2016-06-27-03-15 \
--target-snapshot-name my-exported-backup \
--target-bucket my-s3-bucket
```
Para Windows:
```
aws elasticache copy-snapshot ^
--source-snapshot-name automatic.my-redis-primary-2016-06-27-03-15 ^
--target-snapshot-name my-exported-backup ^
--target-bucket my-s3-bucket
```
# Restauração de um backup para um novo cache
Você pode restaurar um backup existente do Valkey em um novo cache do Valkey ou cluster baseado em nós e restaurar um backup existente do Redis OSS em um novo cache do Redis OSS ou cluster baseado em nós. Você também pode restaurar um backup existente de cache de tecnologia sem servidor do Memcached em um novo cache de tecnologia sem servidor do Memcached.
## Restauração de um backup para um cache sem servidor (console)
**nota**
ElastiCache O Serverless suporta arquivos RDB compatíveis com Valkey 7.2 e superior e versões do Redis OSS entre 5.0 e a versão mais recente disponível.
**Para restaurar um backup para um cache sem servidor (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. No painel de navegação, escolha **Backups**.
1. Na lista de backups, escolha a caixa à esquerda do nome do backup que você deseja restaurar.
1. Escolha **Ações** e **Restaurar**
1. Insira um nome para o novo cache sem servidor e uma descrição opcional.
1. Clique em **Criar** para criar o novo cache e importar dados do backup.
## Restauração de um backup para um cluster baseado em nós (console)
**Para restaurar um backup para um cluster baseado em nós (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. 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 **Ações** e **Restaurar**
1. Escolha **Cache baseado em nós** e personalize as configurações do cluster, como tipo de nó, tamanhos, número de fragmentos, réplicas, posicionamento AZ e configurações de segurança.
1. Escolha **Criar** para criar o novo cluster baseado em nós e importar dados do backup.
## Restauração de um backup para um cache sem servidor (AWS CLI)
**nota**
ElastiCache O Serverless suporta arquivos RDB compatíveis com Valkey 7.2 e superior e versões do Redis OSS entre 5.0 e a versão mais recente disponível.
**Para restaurar um backup para um cache sem servidor novo (AWS CLI)**
O AWS CLI exemplo a seguir cria um novo cache usando `create-serverless-cache` e importa dados de um backup.
Para Linux, macOS ou Unix:
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine redis
--snapshot-arns-to-restore Snapshot-ARN
```
Para Windows:
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine redis ^
--snapshot-arns-to-restore Snapshot-ARN
```
# Exclusão de um backup
Um backup automático é excluído automaticamente quando o limite de retenção expira. Se você excluir um cluster, todos os seus backups automáticos também serão excluídos. Se você excluir um grupo de replicação, todos os backups automáticos dos clusters desse grupo também serão excluídos.
ElastiCache fornece uma operação de API de exclusão que permite excluir um backup a qualquer momento, independentemente de o backup ter sido criado automática ou manualmente. Como os backups manuais não possuem um limite de retenção, a exclusão manual é a única maneira de removê-los.
Você pode excluir um backup usando o ElastiCache console AWS CLI, o ou a ElastiCache API.
## Exclusão de um backup (console)
O procedimento a seguir exclui um backup usando o ElastiCache console.
**Para excluir um backup**
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, selecione **Backups**.
A tela Backups aparece com uma lista dos seus backups.
1. Escolha a caixa à esquerda do nome do backup que você deseja excluir.
1. Escolha **Excluir**.
1. Se você quiser excluir esse backup, escolha **Excluir** na tela de confirmação **Excluir backup**. O status muda para *deleting*.
## Exclusão de um backup sem servidor (AWS CLI)
Use a AWS CLI operação delete-snapshot com o parâmetro a seguir para excluir um backup sem servidor.
+ `--serverless-cache-snapshot-name` - Nome do backup a ser excluído.
O código a seguir exclui o backup `myBackup`.
```
aws elasticache delete-serverless-cache-snapshot --serverless-cache-snapshot-name myBackup
```
Para obter mais informações, consulte [delete-serverless-cache-snapshot](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-serverless-cache-snapshot.html) na *Referência de comandos da AWS CLI*.
## Excluir um backup de cluster baseado em nós (AWS CLI)
Use a AWS CLI operação delete-snapshot com o parâmetro a seguir para excluir um backup de cluster baseado em nós.
+ `--snapshot-name` - Nome do backup a ser excluído.
O código a seguir exclui o backup `myBackup`.
```
aws elasticache delete-snapshot --snapshot-name myBackup
```
Para obter mais informações, consulte [delete-snapshot](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-snapshot.html) na *Referência de comandos da AWS CLI*.
# Marcação de backups
Você pode atribuir os próprios metadados a cada backup na forma de tags. As tags permitem categorizar seus backups de diferentes formas (como por finalidade, por proprietário ou por ambiente). Isso é útil quando você tem muitos recursos do mesmo tipo. É possível identificar rapidamente um recurso específico baseado nas tags que você atribuiu a ele. Para obter mais informações, consulte [Recursos que podem ser marcados](Tagging-Resources.md#Tagging-your-resources).
Tags de alocação de custos são um meio de rastrear seus custos em vários serviços da AWS, agrupando suas despesas em faturas por valores de tag. Para saber mais sobre alocação de custos, consulte [Usar tags de alocação de custos](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html).
Usando o console do ElastiCache, a AWS CLI ou a API do ElastiCache, você pode adicionar, listar, modificar, remover ou copiar tags de alocação de custos em seus backups. Para obter mais informações, consulte [Monitoramento de custos com tags de alocação de custos](Tagging.md).
# Tutorial: propagação de um novo cluster baseado em nós com um backup criado externamente
Ao criar um novo cluster baseado em nós do Valkey ou Redis OSS, você pode propagá-lo com dados de um arquivo de backup .rdb do Valkey ou Redis OSS. A semeadura do cluster é útil se você atualmente gerencia uma instância Valkey ou Redis OSS fora ElastiCache e deseja preencher seu novo ElastiCache cluster baseado em nós do Redis OSS com seus dados existentes do Valkey ou do Redis OSS.
Para implantar um novo cluster baseado em nós Valkey ou Redis OSS a partir de um backup Valkey ou Redis OSS criado na Amazon, consulte. ElastiCache [Restauração de um backup para um novo cache](backups-restoring.md)
Ao usar um arquivo .rdb do Valkey ou Redis OSS para propagar um novo cluster baseado em nós, você pode fazer o seguinte:
+ Atualização de um cluster não particionado para um cluster baseado em nós do Valkey ou Redis OSS (modo cluster habilitado) que execute o Redis OSS versão 3.2.4.
+ Especifique um número de fragmentos (chamados de grupos de nós na API ou na CLI) no novo cluster baseado em nós. Esse número pode ser diferente do número de fragmentos no cluster baseado em nós que foi usado para criar o arquivo de backup.
+ Especificar um tipo de nó diferente para o novo cluster baseado em nós, maior ou menor que o usado no cluster que fez o backup. Se você escalar para um tipo de nó menor, certifique-se de que o novo tipo de nó tenha memória suficiente para seus dados e a sobrecarga do Valkey ou Redis OSS. Para obter mais informações, consulte [Garantir que você tem memória suficiente para criar um snapshot do Valkey ou Redis OSS](BestPractices.BGSAVE.md).
+ Distribua suas chaves nos slots do novo cluster do Valkey ou Redis OSS (modo cluster habilitado) de forma diferente do que no cluster que foi usado para criar o arquivo de backup.
**nota**
Não é possível propagar um cluster do Valkey ou Redis OSS (modo cluster desabilitado) a partir de um arquivo .rdb criado a partir de um cluster do Valkey ou Redis OSS (modo cluster habilitado).
**Importante**
É necessário garantir que seus dados de backup do Valkey ou Redis OSS não excedam os recursos do nó. Por exemplo, você não pode fazer upload de um arquivo .rdb com 5 GB de dados do Valkey ou Redis OSS em um nó cache.m3.medium que tenha 2,9 GB de memória.
Se o backup for muito grande, o cluster resultante terá um status de `restore-failed`. Se isso acontecer, você deverá excluir o cluster e começar de novo.
Para obter uma lista completa dos tipos e especificações de nós, consulte os [recursos [Parâmetros específicos de node-type do Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis.NodeSpecific) e detalhes dos ElastiCache produtos da Amazon](https://aws.amazon.com/elasticache/details/).
Só é possível criptografar um arquivo .rdb do Valkey ou Redis OSS com a criptografia do lado do servidor do Amazon S3 (SSE-S3). Para obter mais informações, consulte [Proteger dados usando a criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html).
A seguir, você encontrará tópicos que orientam você na migração do seu cluster de fora do Valkey ou do Redis OSS ElastiCache para o Redis OSS. ElastiCache
**Topics**
+ [Etapa 1: criar um backup do Valkey ou Redis OSS](#backups-seeding-redis-create-backup)
+ [Etapa 2: criar um bucket e uma pasta no Amazon S3](#backups-seeding-redis-create-s3-bucket)
+ [Etapa 3: carregar seu backup no Amazon S3](#backups-seeding-redis-upload)
+ [Etapa 4: conceder acesso de ElastiCache leitura ao arquivo.rdb](#backups-seeding-redis-grant-access)
**Topics**
+ [Etapa 1: criar um backup do Valkey ou Redis OSS](#backups-seeding-redis-create-backup)
+ [Etapa 2: criar um bucket e uma pasta no Amazon S3](#backups-seeding-redis-create-s3-bucket)
+ [Etapa 3: carregar seu backup no Amazon S3](#backups-seeding-redis-upload)
+ [Etapa 4: conceder acesso de ElastiCache leitura ao arquivo.rdb](#backups-seeding-redis-grant-access)
## Etapa 1: criar um backup do Valkey ou Redis OSS
**Para criar o backup do Valkey ou do Redis OSS para alimentar sua ElastiCache instância do Redis OSS**
1. Conecte-se à sua instância do Valkey ou Redis OSS existente.
1. Execute a operação `BGSAVE` ou `SAVE` para criar um backup. Observe onde seu arquivo .rdb está localizado.
`BGSAVE` é assíncrono e não bloqueia outros clientes durante o processamento. Para obter mais informações, consulte [BGSAVE](https://valkey.io/commands/bgsave) no site do Valkey.
`SAVE` é síncrono e bloqueia outros processos até terminar. Para obter mais informações, consulte [SAVE](https://valkey.io/commands/save) no site do Valkey.
Para obter informações adicionais sobre como criar um backup, consulte [Persistência](https://valkey.io/topics/persistence) no site do Valkey.
## Etapa 2: criar um bucket e uma pasta no Amazon S3
Quando você tiver criado o arquivo de backup, precisará carregá-lo em uma pasta dentro de um bucket do Amazon S3. Para fazer isso, primeiro você deve ter um bucket do Amazon S3 e uma pasta dentro desse bucket. Se você já possui um bucket do Amazon S3 e uma pasta com as permissões apropriadas, poderá pular para [Etapa 3: carregar seu backup no Amazon S3](#backups-seeding-redis-upload).
**Como criar um bucket do Amazon S3**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Para criar um bucket do Amazon S3, siga as instruções em [Criação de um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html) no *Guia do usuário do Amazon Simple Storage Service*.
O nome do bucket do Amazon S3 deve estar em conformidade com o DNS. Caso contrário, não ElastiCache conseguirá acessar seu arquivo de backup. As regras para a conformidade de DNS são:
+ Os nomes devem ter no mínimo 3 e no máximo 63 caracteres de extensão.
+ Os nomes devem ser uma série de um ou mais rótulos separados por um ponto (.) em que cada rótulo:
+ Começa com uma letra minúscula ou um número.
+ Termina com uma letra minúscula ou um número.
+ Contém somente letras minúsculas, números e traços.
+ Os nomes não podem ser formatado como um endereço IP (por exemplo, 192.0.2.0).
Você deve criar seu bucket Amazon S3 na mesma AWS região do seu novo cluster OSS ElastiCache para Redis. Essa abordagem garante a maior velocidade de transferência de dados ao ElastiCache ler seu arquivo.rdb do Amazon S3.
**nota**
Para manter seus dados da forma mais segura possível, restrinja ao máximo as permissões em seu bucket do Amazon S3. Ao mesmo tempo, as permissões ainda precisam permitir que o bucket e seu conteúdo seja usado para propagar o novo cluster do Valkey ou Redis OSS.
**Para adicionar uma pasta a um bucket do Amazon S3**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Escolha o nome do bucket para o qual deseja fazer upload do arquivo .rdb.
1. Selecione **Criar pasta**.
1. Insira um nome para a nova pasta.
1. Escolha **Salvar**.
Anote o nome do bucket e o nome da pasta.
## Etapa 3: carregar seu backup no Amazon S3
Agora, faça upload do arquivo .rdb criado em [Etapa 1: criar um backup do Valkey ou Redis OSS](#backups-seeding-redis-create-backup). Carregue-o no bucket e na pasta do Amazon S3 que você criou em [Etapa 2: criar um bucket e uma pasta no Amazon S3](#backups-seeding-redis-create-s3-bucket). Para obter mais informações sobre essa tarefa, consulte [Adicionar um objeto a um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html). Entre as etapas 2 e 3, escolha o nome da pasta que você criou.
**Para carregar seu arquivo .rdb em uma pasta do Amazon S3**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Escolha o nome do bucket do Amazon S3 criado na Etapa 2.
1. Escolha o nome da pasta que você criou na Etapa 2.
1. Escolha **Carregar**.
1. Escolha **Adicionar arquivos**.
1. Navegue para encontrar um ou mais arquivos que deseja carregar e depois escolha esses arquivos. Para escolher vários arquivos, mantenha pressionada a tecla Ctrl enquanto escolhe o nome de cada arquivo.
1. Escolha **Open (Abrir)**.
1. Confirme se os arquivos corretos estão listados na caixa de diálogo **Upload** e depois escolha **Upload**.
Anote o caminho para o arquivo .rdb. Por exemplo, se o nome do bucket for `myBucket` e o caminho for `myFolder/redis.rdb`, insira `myBucket/myFolder/redis.rdb`. Você precisa desse caminho para propagar o novo cluster com os dados neste backup.
Para obter mais informações, consulte [Restrições e limitações de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) no *Guia do usuário do Amazon Simple Storage Service*.
## Etapa 4: conceder acesso de ElastiCache leitura ao arquivo.rdb
Agora, conceda acesso de ElastiCache leitura ao seu arquivo de backup .rdb. Você concede ElastiCache acesso ao seu arquivo de backup de uma forma diferente, dependendo se seu bucket está em uma AWS região padrão ou em uma AWS região opcional.
AWS As regiões introduzidas antes de 20 de março de 2019 estão habilitadas por padrão. Você pode começar a trabalhar nessas AWS regiões imediatamente. As regiões introduzidas após 20 de março de 2019, como Ásia-Pacífico (Hong Kong) e Oriente Médio (Bahrein), são desabilitadas por padrão. Você deve habilitar ou escolher essas regiões para poder usá-las, conforme descrito em [Gerenciar regiões da AWS](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html) na *Referência geral da AWS*.
Escolha sua abordagem de acordo com sua AWS região:
+ Para uma região padrão, use o procedimento em [Conceder acesso de ElastiCache leitura ao arquivo.rdb em uma região padrão](#backups-seeding-redis-default-region).
+ Para uma região opcional, use o procedimento em [Conceda acesso de ElastiCache leitura ao arquivo.rdb em uma região opcional](#backups-seeding-opt-in-region).
### Conceder acesso de ElastiCache leitura ao arquivo.rdb em uma região padrão
AWS As regiões introduzidas antes de 20 de março de 2019 estão habilitadas por padrão. Você pode começar a trabalhar nessas AWS regiões imediatamente. As regiões introduzidas após 20 de março de 2019, como Ásia-Pacífico (Hong Kong) e Oriente Médio (Bahrein), são desabilitadas por padrão. Você deve habilitar ou escolher essas regiões para poder usá-las, conforme descrito em [Gerenciar regiões da AWS](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html) na *Referência geral da AWS*.
**Para conceder acesso de ElastiCache leitura ao arquivo de backup em uma AWS região ativada por padrão**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Escolha o nome do bucket do S3 que contém seu arquivo .rdb.
1. Escolha o nome da pasta que contém seu arquivo .rdb.
1. Escolha o nome do seu arquivo de backup .rdb. O nome do arquivo selecionado aparece acima das guias na parte superior da página.
1. Escolha **Permissões**.
1. Se **aws-scs-ssomente 3 leituras** ou uma das canônicas IDs na lista a seguir não estiver listada como usuário, faça o seguinte:
1. Em **Acesso para outras AWS contas**, escolha **Adicionar favorecido**.
1. Na caixa, adicione a ID canônica da AWS região conforme mostrado a seguir:
+ AWS GovCloud Região (Oeste dos EUA):
```
40fa568277ad703bd160f66ae4f83fc9dfdfd06c2f1b5060ca22442ac3ef8be6
```
**Importante**
O backup deve estar localizado em um bucket S3 AWS GovCloud (US) para que você possa baixá-lo em um cluster Valkey ou Redis OSS em.AWS GovCloud (US)
+ AWS Regiões ativadas por padrão:
```
540804c33a284a299d2547575ce1010f2312ef3da9b3a053c8bc45bf233e4353
```
1. Defina as permissões no bucket escolhendo **Yes (Sim)** para o seguinte:
+ **Objeto de lista/gravação**
+ **Permissões ACL de objetos de leitura/gravação**
1. Escolha **Salvar**.
1. Escolha **Overview** (Visão geral) e escolha **Download** (Fazer download).
### Conceda acesso de ElastiCache leitura ao arquivo.rdb em uma região opcional
AWS As regiões introduzidas antes de 20 de março de 2019 estão habilitadas por padrão. Você pode começar a trabalhar nessas AWS regiões imediatamente. As regiões introduzidas após 20 de março de 2019, como Ásia-Pacífico (Hong Kong) e Oriente Médio (Bahrein), são desabilitadas por padrão. Você deve habilitar ou escolher essas regiões para poder usá-las, conforme descrito em [Gerenciar regiões da AWS](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html) na *Referência geral da AWS*.
Agora, conceda acesso de ElastiCache leitura ao seu arquivo de backup .rdb.
**Para conceder acesso de ElastiCache leitura ao arquivo de backup**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Escolha o nome do bucket do S3 que contém seu arquivo .rdb.
1. Escolha o nome da pasta que contém seu arquivo .rdb.
1. Escolha o nome do seu arquivo de backup .rdb. O nome do arquivo selecionado aparece acima das guias na parte superior da página.
1. Escolha a guia **Permissões**.
1. Em **Permissões**, escolha **Política de bucket** e, em seguida, **Editar**.
1. Atualize a política para conceder as permissões ElastiCache necessárias para realizar operações:
+ Adicione `[ "Service" : "region-full-name.elasticache-snapshot.amazonaws.com" ]` a `Principal`.
+ Adicione as seguintes permissões necessárias para exportar um snapshot para o bucket do Amazon S3:
+ `"s3:GetObject"`
+ `"s3:ListBucket"`
+ `"s3:GetBucketAcl"`
Veja a seguir um exemplo de como a política atualizada pode parecer.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Policy15397346",
"Statement": [
{
"Sid": "Stmt15399483",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:GetBucketAcl"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/backup1.rdb",
"arn:aws:s3:::amzn-s3-demo-bucket/backup2.rdb"
]
}
]
}
```
------
1. Escolha **Salvar alterações**.
### Semeie o ElastiCache cluster com os dados do arquivo.rdb
Agora você está pronto para criar um ElastiCache cluster e plantá-lo com os dados do arquivo.rdb. Para criar o cluster, siga as instruções em [Criação de um cluster do Valkey ou Redis OSS](Clusters.Create.md) ou [Criação de um grupo de replicação do Valkey ou Redis OSS do início](Replication.CreatingReplGroup.NoExistingCluster.md). Certifique-se de escolher o Valkey ou Redis OSS como seu mecanismo de cluster.
O método usado para saber ElastiCache onde encontrar o backup que você enviou para o Amazon S3 depende do método usado para criar o cluster:
**Prepare o ElastiCache cluster ou grupo de replicação do for Redis OSS com os dados do arquivo.rdb**
+ **Usando o ElastiCache console**
Ao selecionar **Cluster settings** (Configurações de cluster), escolha **Restore from backups** (Restaurar de backups) como seu método de criação de cluster e escolha **Other backups** (Outros backups) como sua **Source** (Origem) na seção **Backup source** (Origem de backup). Na caixa **Propagar local S3 do arquivo RDB**, digite o caminho do Amazon S3 para o(s) arquivo(s). Se você tiver vários arquivos .rdb, digite o caminho para cada um em uma lista separada por vírgulas. O caminho do Amazon S3 parece-se com `myBucket/myFolder/myBackupFilename.rdb`.
+ **Usando o AWS CLI**
Se você usar a operação `create-cache-cluster` ou `create-replication-group`, use o parâmetro `--snapshot-arns` para especificar um ARN totalmente qualificado para cada arquivo .rdb. Por exemplo, .`arn:aws:s3:::myBucket/myFolder/myBackupFilename.rdb` O ARN deve ser resolvido para os arquivos de backup que você armazenou no Amazon S3.
+ **Usando a ElastiCache API**
Se você usar a operação `CreateCacheCluster` ou a `CreateReplicationGroup` ElastiCache API, use o parâmetro `SnapshotArns` para especificar um ARN totalmente qualificado para cada arquivo.rdb. Por exemplo, .`arn:aws:s3:::myBucket/myFolder/myBackupFilename.rdb` O ARN deve ser resolvido para os arquivos de backup que você armazenou no Amazon S3.
**Importante**
Ao propagar um cluster do Valkey ou Redis OSS (modo cluster habilitado), você precisa configurar cada grupo de nós (fragmento) no novo cluster ou grupo de replicação. Use o parâmetro `--node-group-configuration` (API: `NodeGroupConfiguration`) para fazer isso. Para saber mais, consulte:
CLI: [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)na referência AWS CLI
API: [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)na referência da ElastiCache API
Durante o processo de criação do cluster, os dados no backup do Valkey ou Redis OSS são gravados no cluster. Você pode monitorar o progresso visualizando as mensagens do ElastiCache evento. Para fazer isso, consulte o ElastiCache console e escolha **Eventos de cache**. Você também pode usar a interface de linha de AWS ElastiCache comando ou a ElastiCache API para obter mensagens de eventos. Para obter mais informações, consulte [Visualizando ElastiCache eventos](ECEvents.Viewing.md).