Esegui il deployment della migrazione live RIOT per eseguire la migrazione a Redis Enterprise Cloud

Last reviewed 2024-01-29 UTC

Questo documento descrive come eseguire il deployment di RIOT Live Migration per eseguire la migrazione a Redis Enterprise Cloud. Gli architect di database, i team DevOps e SRE o gli amministratori di rete possono utilizzare questa architettura per offrire ai propri team migrazioni con tempi di inattività quasi azzerati. Questo documento presuppone che tu abbia familiarità con l'utilizzo di Google Cloud CLI e Compute Engine.

Architettura

Il seguente diagramma mostra l'architettura di riferimento che utilizza RIOT Live Migration Service per eseguire la migrazione di origini compatibili con Redis in Redis Enterprise Cloud.

Le origini compatibili con Redis vengono migrate tramite RIOT a Redis Enterprise Cloud.

Per i dettagli sull'architettura, consulta Migrazione live RIOT per la migrazione a Redis Enterprise Cloud.

Il deployment di esempio in questo documento utilizza la seguente architettura in cui l'origine è un sistema operativo Redis su una VM di Compute Engine:

La migrazione di Redis OSS a Redis Enterprise Cloud tramite peering RIOT e VPC viene eseguita.

Nel diagramma, un'istanza OSS Redis e RIOT sono consolidati in una singola VM di Compute Engine per semplicità. In un ambiente di produzione, consigliamo che RIOT venga sempre eseguito sulla propria VM per garantire prestazioni migliori.

L'architettura di deployment di esempio contiene i componenti seguenti:

Origine: istanza Redis OSS in esecuzione sulla VM di Compute Engine.
Destinazione: Redis Enterprise Cloud in esecuzione nel VPC gestito per Redis.
Servizio di migrazione: RIOT in esecuzione sulla stessa VM di Compute Engine del sistema operativo Redis.
Configurazione di rete: peering VPC tra un VPC gestito e il VPC gestito da Redis.

Lo strumento di migrazione RIOT ha tempi di inattività quasi azzerati. Durante la migrazione da Redis OSS (origine) a Redis Enterprise Cloud (destinazione), le tue applicazioni possono comunque accedere a Redis OSS senza conseguenze o interruzioni del servizio. Durante il processo di migrazione, dopo il caricamento iniziale dei dati da Redis OSS, RIOT Live Migration continua a eseguire la migrazione delle modifiche da Redis OSS man mano che si verificano.

Obiettivi

Configura l'origine OSS Redis creando e caricando i dati.
Configura un cluster di destinazione della migrazione in Redis Enterprise Cloud.
Utilizza RIOT Live Migration per eseguire la migrazione dei dati da Redis OSS a Redis Enterprise Cloud.
Informazioni sulle strategie di test, cutover e fallback.

Costi

Il deployment di questa architettura utilizza i seguenti componenti fatturabili di Google Cloud:

Costi di Compute Engine per l'esecuzione di istanze Redis OSS e RIOT.
Costo di Redis Enterprise Cloud acquistato tramite Google Cloud Marketplace.
Costi di rete sostenuti dal traffico di migrazione dei dati tra zone e regioni.

Prima di iniziare

Completa i seguenti passaggi per configurare un ambiente per la migrazione.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
Abilita le API BigQuery, Pub/Sub, Dataflow, and Compute Engine.
Abilita le API
Per ottenere le autorizzazioni necessarie per completare questo deployment, chiedi all'amministratore di concederti il ruolo IAM Amministratore di fatturazione (roles/billing.admin) per la tua organizzazione. Per ulteriori informazioni sulla concessione dei ruoli, consulta Gestione dell'accesso.

Potresti anche essere in grado di ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Configura un'istanza OSS Redis

Per avviare il deployment, installa l'istanza OSS Redis su una VM di Compute Engine. L'istanza funge da istanza di origine.

Installa l'istanza OSS Redis

Nella console Google Cloud, attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.

In Cloud Shell, crea una VM 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'

Sostituisci quanto segue:

VPC_NETWORK_NAME: il nome della tua rete VPC.
VPC_SUBNETWORK_NAME: il nome della tua subnet VPC.

Utilizza una connessione SSH per accedere all'istanza Compute Engine che esegue l'istanza del sistema operativo Redis:

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

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

Abilita la notifica dello spazio dei tasti per la migrazione live, richiesta da RIOT:
```
redis-cli config set notify-keyspace-events KEA
```

Verifica che l'istanza Redis OSS sia operativa

In Cloud Shell, avvia l'interfaccia a riga di comando di Redis:
```
redis-cli
```
Imposta e ottieni una semplice coppia chiave-valore:
```
set my_key my_value
get my_key
unlink my_key
```
L'output è il seguente:
```
OK
"my_value"
(integer) 1
```
Hai creato l'istanza Redis OSS, hai eseguito l'accesso e confermato che è operativa.

Inserisci dati di esempio

In questa sezione inserirai dati di esempio nell'istanza OSS Redis e verificherai che i dati siano stati inseriti correttamente.

In Cloud Shell, avvia l'interfaccia a riga di comando di Redis:
```
redis-cli
```
Aggiungi le seguenti sei coppie chiave-valore come set di dati iniziale. Inserisci ogni comando singolarmente e attendi l'output OK prima di inserire la coppia chiave-valore successiva.
```
set tennis federer
```
```
set soccer ronaldo
```
```
set basketball curry
```
```
set football montana
```
```
set golf woods
```
```
set swimmer phelps
```
Verifica di aver aggiunto correttamente sei coppie chiave-valore:
```
SCAN 0
```
L'output è il seguente:
```
"swimmer"
"soccer"
"football"
"golf"
"tennis"
"basketball"
```

Dopo aver configurato e avviato la migrazione RIOT, i dati vengono migrati nell'istanza Redis Enterprise Cloud di destinazione.

Installa RIOT sulla VM dell'istanza Redis OSS

Per eseguire RIOT, devi assicurarti che la VM di Compute Engine sia dimensionata in modo appropriato. In generale, consigliamo di dimensionare la VM a 8 vCPU o a un valore superiore, a seconda della quantità di dati da trasferire e della frequenza di aggiornamento. Per ulteriori informazioni, consulta la guida alle risorse e al confronto per le famiglie di macchine.

In Cloud Shell, utilizza una connessione SSH per accedere all'istanza di Compute Engine che esegue l'istanza del sistema operativo Redis:

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

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

Installa JDK per RIOT:
```
sudo apt install default-jre -y
```

Scarica e installa 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

Verifica che RIOT sia installato correttamente:
```
./riot-redis-2.19.0/bin/riot-redis -V
```
L'output è simile al seguente, che mostra un logo RIOT e un numero di versione:

A questo punto hai installato lo strumento di migrazione RIOT sull'istanza Redis OSS e hai verificato che è operativo.

Crea un'istanza Redis Enterprise Cloud

Redis Enterprise Cloud è disponibile tramite Cloud Marketplace. Se non hai un cluster Redis Enterprise configurato come istanza Redis Enterprise di destinazione, segui i passaggi in questa sezione. Se hai già configurato un cluster Redis Enterprise come database di destinazione, puoi saltare questa sezione e passare all'avvio della migrazione live RIOT.

In Cloud Marketplace, vai a Redis Enterprise Cloud Flessibile - Pagamento a consumo.

Vai a Redis Enterprise nel Marketplace

Per ulteriori informazioni, consulta le istruzioni nel documento Redis Abbonamenti flessibili con Cloud Marketplace.
Accedi alla console Redis utilizzando le informazioni dell'account Redis che hai fornito quando hai sottoscritto l'abbonamento a Redis Enterprise Cloud flex.
Crea un abbonamento flessibile seguendo le istruzioni nel documento Redis Creare un abbonamento flessibile. Scegli Google Cloud come fornitore di servizi cloud e crea un database con tutte le impostazioni predefinite.
Crea un peering VPC tra il tuo Virtual Private Cloud Google e il VPC gestito da Redis seguendo le istruzioni riportate nel documento Redis Abilitare il peering VPC.
Nella console Redis, vai ad Subscription, quindi individua la stringa di connessione del database Redis Enterprise:
1. Prendi nota di IP e porta dell'endpoint privato nel formato:
```
ENDPOINT_IP:ENDPOINT_PORT
```
  Dove i valori rappresentano quanto segue:
  - ENDPOINT_IP: l'indirizzo IP dell'endpoint privato per il database Redis Enterprise.
  - ENDPOINT_PORT: il numero di porta dell'endpoint privato per il database Redis Enterprise.
2. Annota la password del database.

Avvia la migrazione live RIOT

Per eseguire la migrazione dei dati dall'OSS Redis (origine) all'istanza Redis Enterprise Cloud (destinazione):

In Cloud Shell, utilizza una connessione SSH per accedere all'istanza di Compute Engine che esegue l'istanza del sistema operativo Redis:

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

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

Avvia una migrazione live tra l'origine e la destinazione. Se l'istanza del sistema operativo Redis è in Redis 7.2, devi utilizzare la replica basata sui tipi. Per informazioni sull'utilizzo dell'opzione --type, consulta la documentazione di Redis sulla replica basata sui tipi.
```
./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
```
Sostituisci quanto segue con i valori che hai annotato nella sezione precedente:
- ENDPOINT_IP: l'indirizzo IP dell'endpoint privato per il database del cluster Redis Enterprise.
- ENDPOINT_PORT: il numero di porta dell'endpoint privato per il database del cluster Redis Enterprise.
- REDIS_ENTERPRISE_DB_PASSWORD: la password per il database del cluster Redis Enterprise.
L'output è simile al seguente:
```
Listening  ? % ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━0/? (0:00:00 / ?) ?/s\
Scanning 100% ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 6/6 (0:00:00 / 0:00:00) ?/s
```

Verifica la migrazione del database

È importante progettare e implementare una strategia di verifica della migrazione del database per confermare che la migrazione del database sia riuscita. Anche se la strategia di verifica che utilizzi dipende dal caso d'uso specifico, ti consigliamo di eseguire questi controlli per tutte le migrazioni:

Controllo di completezza: verifica che la migrazione delle coppie chiave-valore iniziali sia stata eseguita correttamente dal sistema operativo Redis a Redis Enterprise (caricamento iniziale).
Controllo dinamico: verifica che le modifiche all'origine vengano trasferite all'istanza di destinazione (migrazione in corso).

Caricamento iniziale

In Cloud Shell, utilizza una connessione SSH per accedere all'istanza di Compute Engine che esegue l'istanza del sistema operativo Redis:

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

Avvia l'interfaccia a riga di comando di Redis:

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

Verifica che la migrazione delle sei coppie chiave-valore da Redis OSS all'istanza Redis Enterprise sia andata a buon fine:
```
SCAN 0
```
L'output è il seguente:
```
"swimmer"
"soccer"
"football"
"golf"
"tennis"
"basketball"
```
Scopri il valore della chiave del tennis:
```
get tennis
```
L'output è il seguente:
```
[return federer]
```
Esci dall'interfaccia a riga di comando di Redis:
```
exit
```

Migrazione in corso

Verifica che le modifiche in corso al sistema operativo Redis di origine vengano riflesse nell'istanza Redis Enterprise di destinazione:

In Cloud Shell, utilizza una connessione SSH per accedere alla VM Redis OSS.
Avvia l'interfaccia a riga di comando di Redis:
```
redis-cli
```
Aggiungi nuove coppie chiave-valore:
1. Aggiungi una nuova coppia runner bolt:
```
set runner bolt
```
2. Esegui l'upsert di una nuova coppia tennis alcaraz:
```
set tennis alcaraz
```
L'output di ciascuno di questi comandi è il seguente:
```
OK
```
Nell'istanza Redis Enterprise, osserva che vengono aggiunte nuove coppie chiave-valore:
```
get runner
```
L'output è il seguente:
```
[return bolt]
```
Per verificare che siano presenti tutte le coppie chiave-valore, controlla i conteggi delle chiavi:
```
redis-cli info keyspace and redis-cli -u <REMOTE> info keyspace
```
L'output è il seguente:
```
# Keyspace
db0:keys=7,expires=0,avg_ttl=0
```

Ora hai verificato che RIOT Live Migration ha eseguito automaticamente la migrazione di tutte le coppie chiave-valore dall'istanza Redis OSS di origine e di tutte le modifiche in corso all'origine.

Esegui la migrazione dall'origine alla destinazione

Dopo aver verificato la migrazione del database, puoi eseguire un cutover dall'istanza Redis OSS di origine all'istanza Redis Enterprise di destinazione:

Sospendi l'accesso in scrittura del client all'istanza OSS Redis di origine utilizzando l'elenco di controllo dell'accesso Redis.
A meno che tu non abbia bisogno di conservare il database di origine per la tua strategia di fallback, dismetti il sistema operativo Redis di origine rimuovendo l'istanza VM.
Esegui la migrazione del client nella stessa regione dell'istanza del database Redis Enterprise. Per informazioni, consulta la documentazione dell'host client.
Nella console Redis, trova l'endpoint privato dell'istanza del database Redis Enterprise e aggiorna la connessione Redis del client all'endpoint privato. Per ulteriori informazioni, consulta Visualizzare e modificare i database nella documentazione di Redis.
In Cloud Shell, interrompi il processo RIOT premendo Ctrl+C.

Preparare una strategia di riserva

Al termine del cutover, l'istanza Redis Enterprise di destinazione è il sistema di registrazione; l'istanza Redis OSS di origine non è aggiornata e alla fine viene rimossa. Tuttavia, ti consigliamo di ricorrere all'istanza Redis OSS di origine in caso di errori gravi nella nuova istanza Redis Enterprise di destinazione.

Per evitare questi errori, ti consigliamo di mantenere l'istanza Redis OSS di origine originale aggiornata con le modifiche al database di destinazione. Quando hai la certezza che la nuova istanza di destinazione sia affidabile, puoi arrestarla.

Esegui la pulizia

Le sezioni seguenti spiegano come evitare addebiti futuri per il tuo progetto Google Cloud e le risorse Redis che hai utilizzato in questo deployment.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina il database Redis Enterprise

Per eliminare il database Redis Enterprise, consulta Elimina database nella documentazione di Redis

Passaggi successivi

Scopri come definire l'ambito della migrazione a Redis Enterprise Cloud.
Leggi Contenuti sulla migrazione dei dati di Google Cloud.
Per una documentazione più approfondita e best practice, consulta la documentazione RIOT.
Per altre architetture di riferimento, diagrammi e best practice, esplora il Cloud Architecture Center.

Collaboratori

Autori:

Saurabh Kumar | Partner Engineer ISV
Gilbert Lau | Principal Cloud Architect, Redis

Altri collaboratori:

Chris Mague | Customer Engineer, gestione dei dati
Gabe Weiss | Responsabile del supporto per gli sviluppatori
Marco Ferrari | Cloud Solutions Architect