Implantar a migração em tempo real RIOT para migrar para o Redis Enterprise Cloud

Last reviewed 2024-01-29 UTC

Neste documento, descrevemos como implantar a Migração em tempo real RIOT para migrar para o Redis Enterprise Cloud. Arquitetos de bancos de dados, equipes de DevOps e SRE ou administradores de rede podem usar essa arquitetura para oferecer migrações com inatividade quase zero para as equipes. Para seguir este documento, você precisa estar familiarizado com a CLI do Google Cloud e o Compute Engine.

Arquitetura

O diagrama a seguir mostra a arquitetura de referência que usa o serviço de migração em tempo real RIOT para migrar origens compatíveis com o Redis para o Redis Enterprise Cloud.

As origens compatíveis com o Redis são migradas por meio do RIOT para o Redis Enterprise Cloud.

Para detalhes sobre a arquitetura, consulte Migração em tempo real RIOT para migrar para o Redis Enterprise Cloud.

A implantação de amostra neste documento usa a seguinte arquitetura, na qual a origem é um Redis OSS em uma VM do Compute Engine:

O Redis OSS é migrado por RIOT e peering de VPC para o Redis Enterprise Cloud.

No diagrama, uma instância do Redis OSS e RIOT são consolidados em uma única VM do Compute Engine para simplificar. Em um ambiente de produção, recomendamos que a RIOT sempre seja executada na própria VM para ajudar a garantir um melhor desempenho.

A arquitetura de implantação de exemplo contém os seguintes componentes:

Fonte: instância Redis OSS em execução na VM do Compute Engine.
Destino: Redis Enterprise Cloud em execução na VPC gerenciada do Redis.
Serviço de migração: RIOT em execução na mesma VM do Compute Engine que o Redis OSS.
Configuração de rede: peering de VPC entre uma VPC gerenciada e a outra gerenciada pelo Redis.

A ferramenta de migração RIOT tem inatividade quase zero. Durante a migração do Redis OSS (origem) para o Redis Enterprise Cloud (destino), seus aplicativos ainda podem acessar o Redis OSS sem impacto ou interrupção do serviço. Durante o processo de migração, após o carregamento inicial de dados do Redis OSS, a migração em tempo real do RIOT continua a migrar alterações desse sistema à medida que elas ocorrem.

Objetivos

Crie e carregue dados para configurar a origem do Redis OSS.
Configurar um cluster de destino de migração no Redis Enterprise Cloud.
Use a migração em tempo real RIOT para migrar dados do Redis OSS para o Redis Enterprise Cloud.
Entenda as estratégias de teste, transição e substituição.

Custos

A implantação dessa arquitetura usa os seguintes componentes faturáveis do Google Cloud:

Custos do Compute Engine para executar instâncias do Redis OSS e RIOT.
O custo do Redis Enterprise Cloud é adquirido por meio do Google Cloud Marketplace.
Taxas de rede são geradas pelo tráfego de migração de dados entre zonas e regiões.

Antes de começar

Conclua as etapas a seguir para configurar um ambiente para a migração.

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

Acessar o seletor de projetos
Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
Ative as APIs BigQuery, Pub/Sub, Dataflow, and Compute Engine.
Ative as APIs
Para receber as permissões necessárias para concluir a implantação, peça ao administrador para conceder a você o papel do IAM de Administrador de faturamento (roles/billing.admin) na organização. Para mais informações sobre como conceder papéis, consulte Gerenciar acesso.

Também é possível conseguir as permissões necessárias via papéis personalizados ou outros papéis predefinidos.

Configurar uma instância do Redis OSS

Para iniciar a implantação, instale a instância do Redis OSS em uma VM do Compute Engine. A instância atua como sua instância de origem.

Instalar a instância do Redis OSS

No Console do Google Cloud, ative o Cloud Shell.

Ativar o Cloud Shell

Na parte inferior do Console do Google Cloud, uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

No Cloud Shell, crie uma VM do Ubuntu:

gcloud compute instances create redis-oss-riot-vm \
  --image-family=ubuntu-2004-lts \
    --image-project=ubuntu-os-cloud \
    --zone=us-central1-a \
    --machine-type=e2-medium \
    --network=VPC_NETWORK_NAME \
    --subnet=VPC_SUBNETWORK_NAME \
  --metadata=startup-script='#! /bin/bash
    apt-get update -y
    apt-get install redis-tools -y
    snap install redis'

Substitua:

VPC_NETWORK_NAME: o nome da rede VPC.
VPC_SUBNETWORK_NAME: o nome da sub-rede VPC.

Use uma conexão SSH para fazer login na instância do Compute Engine que executa a instância do OSS do Redis:

PROJECT_ID=$(gcloud info --format='value(config.project)')

gcloud compute ssh redis-oss-riot-vm --project $PROJECT_ID --zone us-central1-a

Ative a notificação do keyspace para a migração em tempo real, que é exigida pelo RIOT:
```
redis-cli config set notify-keyspace-events KEA
```

Verificar se a instância do Redis OSS está operacional

No Cloud Shell, inicie a CLI do Redis:
```
redis-cli
```
Defina e receba um par de chave-valor simples:
```
set my_key my_value
get my_key
unlink my_key
```
A saída é esta:
```
OK
"my_value"
(integer) 1
```
Você criou e acessou sua instância Redis OSS e confirmou que ela está operacional.

Inserir dados de amostra

Nesta seção, você insere dados de amostra na instância do Redis OSS e verifica se eles foram inseridos com êxito.

No Cloud Shell, inicie a CLI do Redis:
```
redis-cli
```
Adicione os seis pares de chave-valor a seguir como o conjunto de dados inicial. Insira cada comando individualmente e aguarde a saída OK antes de inserir o próximo par de chave-valor.
```
set tennis federer
```
```
set soccer ronaldo
```
```
set basketball curry
```
```
set football montana
```
```
set golf woods
```
```
set swimmer phelps
```
Verifique se você adicionou seis pares de chave-valor:
```
SCAN 0
```
A saída é esta:
```
"swimmer"
"soccer"
"football"
"golf"
"tennis"
"basketball"
```

Depois de configurar e iniciar a migração RIOT, os dados são migrados para a instância de destino do Redis Enterprise Cloud.

Instalar o RIOT na VM da instância do Redis OSS

Para executar o RIOT, verifique se a VM do Compute Engine tem o tamanho adequado. Em geral, recomendamos dimensionar sua VM para 8 VCPUs ou mais, dependendo da quantidade de dados a serem transportados e da frequência de atualização. Para mais informações, consulte o Guia de comparação e recursos para famílias de máquinas.

No Cloud Shell, use uma conexão SSH para fazer login na instância do Compute Engine que executa a instância do OSS do Redis:

PROJECT_ID=$(gcloud info --format='value(config.project)')

gcloud compute ssh redis-oss-riot-vm --project $PROJECT_ID --zone us-central1-a

Instale o JDK para RIOT:
```
sudo apt install default-jre -y
```

Faça o download e instale o RIOT:

sudo apt-get install unzip

wget https://github.com/redis-developer/riot/releases/download/v2.19.0/riot-redis-2.19.0.zip

unzip riot-redis-2.19.0.zip

Verifique se o RIOT está instalado corretamente:
```
./riot-redis-2.19.0/bin/riot-redis -V
```
A saída é semelhante à seguinte, que mostra um logotipo RIOT e um número de versão:

Você instalou a ferramenta de migração RIOT na instância do Redis OSS e confirmou que ela está operacional.

Criar uma instância do Redis Enterprise Cloud

O Redis Enterprise Cloud está disponível no Cloud Marketplace. Se você não tiver um cluster do Redis Enterprise configurado como sua instância de destino do Redis Enterprise, siga as etapas nesta seção. Se você já tiver um cluster do Redis Enterprise configurado como banco de dados de destino, pule esta seção e prossiga para Iniciar a migração em tempo real RIOT.

No Cloud Marketplace, acesse Redis Enterprise Cloud flexível - Pagamento por uso.

Acesse o Redis Enterprise no Marketplace

Para mais informações, consulte as instruções no documento Redis Assinaturas flexíveis com o Cloud Marketplace.
Faça login no console do Redis usando as informações da conta do Redis que você forneceu quando se inscreveu no Redis Enterprise Cloud flexível.
Crie uma assinatura flexível seguindo as instruções no documento do Redis, Criar uma assinatura flexível. Escolha o Google Cloud como seu fornecedor de nuvem e crie um banco de dados com todas as configurações padrão.
Crie um peering de VPC entre sua nuvem privada virtual do Google e a VPC gerenciada pelo Redis, seguindo as instruções no documento do Redis Ativar peering de VPC.
No console do Redis, acesse Assinatura e localize a string de conexão do banco de dados do Redis Enterprise:
1. Anote a Porta e o IP do endpoint particular no formato:
```
ENDPOINT_IP:ENDPOINT_PORT
```
  Os valores representam o seguinte:
  - ENDPOINT_IP: o endereço IP do endpoint particular para o banco de dados do Redis Enterprise.
  - ENDPOINT_PORT: o número da porta do endpoint particular para o banco de dados do Redis Enterprise.
2. Anote a senha do banco de dados.

Iniciar a migração em tempo real RIOT

Para migrar os dados do Redis OSS (origem) para a instância do Redis Enterprise Cloud (destino), faça o seguinte:

No Cloud Shell, use uma conexão SSH para fazer login na instância do Compute Engine que executa a instância do OSS do Redis:

PROJECT_ID=$(gcloud info --format='value(config.project)')

gcloud compute ssh redis-oss-riot-vm --project $PROJECT_ID --zone us-central1-a

Inicie uma migração em tempo real entre a origem e o destino. Se a instância Redis OSS estiver no Redis 7.2, você precisará usar a replicação baseada em tipos. Para informações sobre como usar a opção --type, consulte a documentação do Redis Replicação baseada em tipos.
```
./riot-redis-2.19.0/bin/riot-redis -u redis://localhost:6379 replicate  \
-u redis://ENDPOINT_IP:ENDPOINT_PORT \
  -a REDIS_ENTERPRISE_DB_PASSWORD \
  --mode live
```
Substitua o seguinte pelos valores que você anotou na seção anterior:
- ENDPOINT_IP: o endereço IP do endpoint particular para o banco de dados do cluster do Redis Enterprise.
- ENDPOINT_PORT: o número da porta do endpoint particular para o banco de dados do cluster do Redis Enterprise.
- REDIS_ENTERPRISE_DB_PASSWORD: a senha do banco de dados do cluster do Redis Enterprise.
O resultado será assim:
```
Listening  ? % ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━0/? (0:00:00 / ?) ?/s\
Scanning 100% ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 6/6 (0:00:00 / 0:00:00) ?/s
```

Verificar a migração do banco de dados

É importante projetar e implementar uma estratégia de verificação de migração de banco de dados para confirmar se a migração foi bem-sucedida. Embora a estratégia de verificação usada dependa do seu caso de uso específico, recomendamos que você faça estas verificações para todas as migrações:

Verificação de integridade: verifique se os pares de chave-valor iniciais foram migrados do Redis OSS para o Redis Enterprise (carregamento inicial).
Verificação dinâmica: verifica se as alterações na origem estão sendo transferidas para a instância de destino (migração em andamento).

Carregamento inicial

No Cloud Shell, use uma conexão SSH para fazer login na instância do Compute Engine que executa a instância do OSS do Redis:

PROJECT_ID=$(gcloud info --format='value(config.project)')
$ gcloud compute ssh redis-oss-riot-vm --project $PROJECT_ID --zone us-central1-a

Inicie a CLI do Redis:

redis-cli -u redis://ENDPOINT_IP:ENDPOINT_PORT \
-a REDIS_ENTERPRISE_DB_PASSWORD

Verifique se os seis pares de chave-valor foram migrados do Redis OSS para a instância do Redis Enterprise:
```
SCAN 0
```
A saída é esta:
```
"swimmer"
"soccer"
"football"
"golf"
"tennis"
"basketball"
```
Encontre o valor da chave de tênis:
```
get tennis
```
A saída é esta:
```
[return federer]
```
Saia da CLI do Redis:
```
exit
```

Migração em andamento

Verifique se as alterações contínuas no Redis OSS de origem são refletidas na instância de destino do Redis Enterprise:

No Cloud Shell, use uma conexão SSH para fazer login na VM do Redis OSS.
Inicie a CLI do Redis:
```
redis-cli
```
Adicione novos pares de chave-valor:
1. Adicione um novo par de runner bolt:
```
set runner bolt
```
2. Faça a inserção de um novo par de tennis alcaraz:
```
set tennis alcaraz
```
A saída para cada um desses comandos é a seguinte:
```
OK
```
Na instância do Redis Enterprise, observe que novos pares de chave-valor são adicionados:
```
get runner
```
A saída é esta:
```
[return bolt]
```
Para confirmar que todos os pares de chave-valor estão presentes, confira as contagens de chaves:
```
redis-cli info keyspace and redis-cli -u <REMOTE> info keyspace
```
A saída é esta:
```
# Keyspace
db0:keys=7,expires=0,avg_ttl=0
```

Você verificou que a migração em tempo real RIOT migrou automaticamente todos os pares de chave-valor da instância de origem do Redis OSS e todas as alterações em andamento para a origem.

Substituir da origem para o destino

Depois de verificar a migração do banco de dados, é possível executar uma transição da instância do Redis OSS de origem para a instância de destino do Redis Enterprise:

Suspenda o acesso de gravação do cliente à instância do Redis OSS de origem usando a Lista de controle de acesso do Redis.
A menos que você precise preservar o banco de dados de origem para sua estratégia de substituto, desative o Redis OSS de origem removendo a instância de VM.
Migre o cliente para a mesma região da instância de banco de dados do Redis Enterprise. Para mais informações, consulte a documentação do host do cliente.
No console do Redis, localize o endpoint particular da instância de banco de dados do Redis Enterprise e atualize a conexão Redis do seu cliente para o endpoint particular. Para mais informações, consulte Visualizar e editar bancos de dados na documentação do Redis.
No Cloud Shell, pressione Ctrl+C para interromper o processo RIOT.

Preparar uma estratégia substituta

Após a conclusão da transição, a instância de destino do Redis Enterprise será o sistema de registro. A instância de origem do Redis OSS está desatualizada e foi removida. No entanto, talvez você queira voltar à instância de origem do Redis OSS em caso de falhas graves na nova instância de destino do Redis Enterprise.

Para evitar essas falhas, mantenha a instância original do Redis OSS atualizada com as alterações do banco de dados de destino. Quando você tiver certeza de que a nova instância de destino é confiável, encerre a instância de origem.

Limpar

As seções a seguir explicam como evitar cobranças futuras pelo projeto do Google Cloud e pelos recursos do Redis usados nessa implantação.

Excluir o projeto

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

No Console do Google Cloud, acesse a página Gerenciar recursos.
Acessar "Gerenciar recursos"
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir o banco de dados do Redis Enterprise

Para excluir o banco de dados do Redis Enterprise, consulte Excluir banco de dados na documentação do Redis.

A seguir

Saiba como Definir o escopo da sua migração para o Redis Enterprise Cloud.
Leia Conteúdo sobre a migração de dados do Google Cloud.
Para ver documentações mais detalhadas e práticas recomendadas, consulte a documentação RIOT.
Para mais arquiteturas de referência, diagramas e práticas recomendadas, confira a Central de arquitetura do Cloud.

Colaboradores

Autores:

Saurabh Kumar | Engenheiro de parceiros de ISV
Gilbert Lau | Cloud Architect principal, Redis

Outros colaboradores:

Chris Mague | Engenheiro de clientes, gerenciamento de dados
Gabe Weiss | Gerente de suporte ao desenvolvedor
Marco Ferrari | Arquiteto de soluções do Cloud