Pianificazione delle esportazioni dei database Memorystore for Redis utilizzando Cloud Scheduler

Last reviewed 2023-03-18 UTC

---

Questo tutorial mostra come utilizzare Cloud Scheduler e Cloud Functions per esportare automaticamente un database di Memorystore per Redis in Cloud Storage. L'esportazione dei database su Cloud Storage ti consente di creare un piano di ripristino di emergenza solido e diversificato. Ad esempio, puoi esportare in un'altra regione e importare in altre istanze Memorystore for Redis.

Architettura

Questo tutorial include i seguenti componenti di Google Cloud:

• Job Cloud Scheduler: job che consentono di effettuare chiamate in base a una pianificazione impostata per avviare l'esportazione del database.
• Cloud Functions: funzioni per esportare i dati da Memorystore a Cloud Storage.
• Messaggi Pub/Sub: messaggi inviati e ricevuti per ogni evento di esportazione di dati.
• Bucket Cloud Storage: bucket in cui archiviare i dati esportati.
• Memorystore for Redis: database di origine da cui esportare i dati.

Un job Cloud Scheduler pubblica un messaggio su un argomento Pub/Sub con informazioni relative all'ID istanza Memorystore, all'ID progetto, alla regione in cui si trova e alla località di Cloud Storage in cui archiviare il backup. Questo evento attiva una Cloud Function che riceve questo payload e avvia un'esportazione del database in Memorystore for Redis tramite la relativa API. Il database genera l'esportazione e la salva in Cloud Storage. Il seguente diagramma mostra questo flusso di lavoro.

Obiettivi

• Crea un bucket Cloud Storage e un'istanza Memorystore
• Crea un argomento Pub/Sub, una Cloud Function e un job Cloud Scheduler.
• Attiva l'esportazione dei dati del database eseguendo il job Cloud Scheduler manualmente.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

• Cloud Scheduler
• Cloud Functions
• Pub/Sub
• Cloud Storage
• Memorystore for Redis

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

1. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

2. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

3. Nella console Google Cloud, attiva Cloud Shell.

   Attiva Cloud Shell

4. Abilita le API Memorystore for Redis, Cloud Functions, Cloud Scheduler, and Cloud Build.

   Abilita le API

Nel corso di questo tutorial, eseguirai tutti i comandi da Cloud Shell.

configura l'ambiente

Per iniziare, devi prima configurare il tuo ambiente, quindi creare ruoli personalizzati con le autorizzazioni necessarie per questo tutorial.

1. In Cloud Shell, configura le seguenti variabili di ambiente:

   export PROJECT_ID=`gcloud config get-value project`
   export DEMO="mem-exporter"
   export BUCKET_NAME=${USER}-mem-$(date +%s)
   export MEM_INSTANCE="${DEMO}-instance"
   export FUNCTION_NAME="${DEMO}-gcf"
   export PUBSUB_TOPIC="${DEMO}-topic"
   export SCHEDULER_JOB="${DEMO}-job"
   export MEM_EXPORT_ROLE="memExporter"
   export STORAGE_ROLE="simpleStorageRole"
   export REGION="us-central1"
   

2. Crea due ruoli personalizzati che dispongono solo delle autorizzazioni necessarie per questo tutorial:

   gcloud iam roles create ${STORAGE_ROLE} --project=${PROJECT_ID} \
       --title="Simple Storage Role" \
       --description="Grant permissions to view and create objects in Cloud Storage" \
       --permissions="storage.objects.create,storage.buckets.get"
   
   gcloud iam roles create ${MEM_EXPORT_ROLE} --project=${PROJECT_ID} \
       --title="Memorystore Exporter Role" \
       --description="Grant permissions to export data from a Memorystore instance to a Cloud Storage bucket" \
       --permissions="redis.instances.export"
   

   Questi ruoli riducono l'ambito di accesso degli account di servizio Cloud Functions e Memorystore, secondo il principio del privilegio minimo.

crea un bucket Cloud Storage e un'istanza Memorystore

In questa sezione, creerai prima un bucket Cloud Storage e un'istanza di Memorystore for Redis. Quindi, inserisci i dati di esempio in Memorystore.

Crea un bucket Cloud Storage

Puoi utilizzare lo strumento a riga di comando gsutil per creare un bucket Cloud Storage.

• Crea un bucket Cloud Storage in cui salvare le esportazioni dei dati:

  gsutil mb -l ${REGION} gs://${BUCKET_NAME}
  

Creare un'istanza Memorystore e concedere le autorizzazioni al rispettivo account di servizio

Successivamente, dovrai creare un'istanza Memorystore e concedere al relativo account di servizio le autorizzazioni per esportare i dati in Cloud Storage.

1. Crea un'istanza di Memorystore for Redis 4:

   gcloud redis instances create ${MEM_INSTANCE} --size=1 --region=${REGION}
   

   Il completamento dell'operazione richiede alcuni minuti.

2. Verifica che l'istanza Memorystore sia READY:

   gcloud redis instances list --region=${REGION}
   

   L'output è simile al seguente:

   INSTANCE_NAME   VERSION    REGION       TIER   SIZE_GB  HOST          PORT  NETWORK  RESERVED_IP      STATUS  CREATE_TIME
   redis-instance  REDIS_4_0  us-central1  BASIC  1        10.61.20.131  6379  default  10.61.20.128/29  READY   2020-04-23T18:38:54
   

3. Concedi al tuo account di servizio Memorystore le autorizzazioni per esportare dati in Cloud Storage con il ruolo Simple Storage personalizzato che hai creato in precedenza:

   export MEM_SA=$(gcloud redis instances describe ${MEM_INSTANCE} --region ${REGION} \
       --project ${PROJECT_ID} \
       --format "value(persistenceIamIdentity)")
   
   gsutil iam ch ${MEM_SA}:projects/${PROJECT_ID}/roles/${STORAGE_ROLE} gs://${BUCKET_NAME}
   

Crea l'attività di esportazione dei dati pianificata

In questa sezione creerai un account di servizio personalizzato e lo associ al ruolo Redis personalizzato che crei. Quindi creerai un argomento Pub/Sub da utilizzare per attivare l'esecuzione di una Cloud Function. Puoi anche creare un job Cloud Scheduler per eseguire periodicamente la funzione di esportazione dei dati.

Crea un account di servizio per la Cloud Function

Il primo passaggio consiste nel creare un account di servizio e associarlo ai ruoli.

1. Crea un account di servizio IAM da utilizzare per la Cloud Function e salvalo nella variabile:

   gcloud iam service-accounts create ${FUNCTION_NAME} \
       --display-name="Service Account for GCF and Memorystore"
   
   export GCF_SA=$(gcloud iam service-accounts list --filter="${FUNCTION_NAME}" --format="value(email)")
   

2. Concedi all'account di servizio l'accesso al ruolo Memorystore Exporter personalizzato per richiedere le esportazioni di Memorystore:

   gcloud projects add-iam-policy-binding ${PROJECT_ID} \
       --member="serviceAccount:${GCF_SA}" \
       --role="projects/${PROJECT_ID}/roles/${MEM_EXPORT_ROLE}"
   

3. Concedi all'account di servizio l'accesso al ruolo Simple Storage personalizzato

   gsutil iam ch \
       serviceAccount:${GCF_SA}:projects/${PROJECT_ID}/roles/${STORAGE_ROLE} \
       gs://${BUCKET_NAME}
   

crea un argomento Pub/Sub

Il passaggio successivo prevede la creazione di un argomento Pub/Sub da utilizzare per attivare la Cloud Function che interagisce con il database Memorystore.

• Crea l'argomento Pub/Sub:

  gcloud pubsub topics create ${PUBSUB_TOPIC}
  

Crea una funzione Cloud

Il passaggio successivo consiste nel creare la Cloud Function.

1. Crea una cartella per il codice della funzione Cloud Function:

   mkdir scheduler_gcf_code && cd scheduler_gcf_code
   

2. Crea un file main.py incollando quanto segue in Cloud Shell:

   cat <<EOF  > main.py
   
   import base64
   import logging
   import json
   
   from datetime import datetime
   from httplib2 import Http
   
   from googleapiclient import discovery
   from googleapiclient.errors import HttpError
   from oauth2client.client import GoogleCredentials
   
   def main(event, context):
       pubsub_message = json.loads(base64.b64decode(event['data']).decode('utf-8'))
       credentials = GoogleCredentials.get_application_default()
   
       service = discovery.build('redis', 'v1beta1', http=credentials.authorize(Http()), cache_discovery=False)
   
       datestamp = datetime.now().strftime("%Y%m%d%H%M") # format timestamp: YearMonthDayHourMinute
       instance_name=pubsub_message['name'].split("/")[-1]
       uri = f"{pubsub_message['gs']}/backup-{instance_name}-{datestamp}.rdb"
   
       request_body = {
           "outputConfig": {
               "gcsDestination" : {
                   "uri": uri
               }
           }
       }
   
       try:
           request = service.projects().locations().instances().export(
               name=pubsub_message['name'],
               body=request_body
           )
   
           response = request.execute()
       except HttpError as err:
           logging.error(f"Could NOT run backup. Reason: {err}")
       else:
           logging.info(f"Backup task status: {response}")
   EOF
   

3. Crea un file requirements.txt incollando quanto segue in Cloud Shell:

   cat <<EOF > requirements.txt
   
   google-api-python-client
   Oauth2client
   EOF
   

4. Esegui il deployment del codice.

   gcloud functions deploy ${FUNCTION_NAME} \
       --trigger-topic=${PUBSUB_TOPIC} \
       --runtime=python37 \
       --entry-point=main \
       --service-account=${FUNCTION_NAME}@${PROJECT_ID}.iam.gserviceaccount.com \
       --ingress-settings=internal-and-gclb
   

Crea un job Cloud Scheduler

Infine, crei un job Cloud Scheduler per eseguire periodicamente la funzione di esportazione dei dati.

1. Salva il nome completo di Memorystore in una variabile:

   export MEM_NAME=$(gcloud redis instances describe ${MEM_INSTANCE} --region ${REGION} --format "value(name)")
   

2. Crea un job Cloud Scheduler per eseguire periodicamente la funzione di esportazione dei dati:

   gcloud scheduler jobs create pubsub ${SCHEDULER_JOB} \
       --schedule='0 23 * * *' --topic=${PUBSUB_TOPIC} \
       --message-body='{"name":'\"${MEM_NAME}\"',"gs":'\"gs://${BUCKET_NAME}\"'}' \
       --time-zone='America/Los_Angeles' --location=${REGION}
   

   Questo job è pianificato per essere eseguito ogni giorno alle 23:00 del fuso orario del Pacifico.

   Il corpo del messaggio contiene il nome dell'istanza Memorystore da esportare e il bucket Cloud Storage di destinazione.

Testa la tua soluzione

Il passaggio finale consiste nel testare la soluzione. Per iniziare, esegui il job Cloud Scheduler.

1. Esegui il job Cloud Scheduler manualmente per attivare un'esportazione dell'archivio memoria del tuo database.

   gcloud scheduler jobs run ${SCHEDULER_JOB} --location=${REGION}
   

2. Elenca le operazioni eseguite sull'istanza Memorystore e verifica che esista un'operazione di tipo EXPORT:

   gcloud redis operations list --region=${REGION} --filter="${MEM_INSTANCE}"
   

   Il seguente esempio di output mostra un job di esportazione con uno stato DONE pari a True per indicare che è stato completato. Se lo stato DONE mostra False, significa che il job è ancora in fase di elaborazione. Attendi un minuto ed esegui nuovamente il comando precedente.

   OPERATION_NAME                                           REGION       TYPE    TARGET                 DONE  CREATE_TIME          DURATION
   operation-1592329364987-5a837122a600c-b22c2703-5077c6b7  us-central1  export  mem-exporter-instance  True  2020-06-16T17:42:45  16S
   

3. Controlla il bucket Cloud Storage per vedere se il file del file di esportazione è stato creato:

   gsutil ls -l gs://${BUCKET_NAME}/*.rdb
   

   Viene visualizzato un file denominato backup-INSTANCE_NAME-TIMESTAMP.rdb.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, segui questi passaggi. Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato per il tutorial.

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.
1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

• Scopri come pianificare le istanze di calcolo con Cloud Scheduler.
• Scopri di più su come pianificare le esportazioni dei database Cloud SQL utilizzando Cloud Scheduler.
• Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Dai un'occhiata al nostro Cloud Architecture Center.