Pianificazione dei backup

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Questo tutorial mostra come pianificare i backup per le istanze HDD di base e di livello SSD di base utilizzando Cloud Scheduler e Cloud Functions.

Obiettivi

  • Creare un account di servizio client per Cloud Scheduler con le credenziali necessarie per richiamare una funzione Cloud Functions.
  • Creare un account di servizio client da utilizzare per Cloud Functions con le credenziali per chiamare l'endpoint di Filestore.
  • Creare una funzione Cloud Functions che crei (o elimini) un backup di una condivisione file.
  • Creare un job Cloud Scheduler che esegue la funzione di creazione (o eliminazione) di backup a intervalli regolari.

Costi

Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono beneficiare di una prova gratuita.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Abilita le API Cloud Scheduler, Cloud Functions, and Filestore.

    Abilita le API

  5. Installa e inizializza Google Cloud CLI.
  6. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  7. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  8. Abilita le API Cloud Scheduler, Cloud Functions, and Filestore.

    Abilita le API

  9. Installa e inizializza Google Cloud CLI.
  10. Se nel tuo progetto non è presente un'istanza di Filestore, devi prima crearne una.

Creare account di servizio client per Cloud Scheduler e Cloud Functions

  1. Creare un account di servizio client da eseguire in Cloud Scheduler per richiamare una funzione Cloud Functions. Per questo esempio, utilizza il comando iam service-accounts create per assegnare un nome all'account schedulerunner e impostare il nome visualizzato su "Service Account for FS Backups-Scheduler":

    gcloud iam service-accounts create schedulerunner \
        --display-name="Service Account for FS Backups-Scheduler"
    
  2. Creare un account di servizio client che Cloud Functions esegue per chiamare l'endpoint di Filestore. Per questo esempio, chiamiamo l'account backupagent e impostiamo il nome visualizzato su "Account di servizio per FS Backup-GCF":

    gcloud iam service-accounts create backupagent \
        --display-name="Service Account for FS Backups-GCF"
    

    Puoi controllare se l'account di servizio viene creato eseguendo il comando iam service-accounts list:

    gcloud iam service-accounts list
    

    Il comando restituisce un testo simile al seguente:

    NAME                                         EMAIL                                                   DISABLED
    Service Account for FS Backups-GCF           backupagent@$PROJECT_ID.iam.gserviceaccount.com         False
    Service Account for FS Backups-Scheduler     schedulerunner@$PROJECT_ID.iam.gserviceaccount.com      False
    

Imposta le variabili di ambiente

Configura le seguenti variabili di ambiente nel tuo ambiente locale:

  • ID e progetto del progetto Google Cloud:

    export PROJECT_ID=`gcloud config get-value core/project`
    export PROJECT_NUMBER=`gcloud projects describe $PROJECT_ID --format='value(projectNumber)'`
    
  • L'agente di servizio Cloud Scheduler e gli account di servizio client per Cloud Scheduler e Cloud Functions:

    export SCHEDULER_SA=service-$PROJECT_NUMBER@gcp-sa-cloudscheduler.iam.gserviceaccount.com
    export SCHEDULER_CLIENT_SA=schedulerunner@$PROJECT_ID.iam.gserviceaccount.com
    export GCF_CLIENT_SA=backupagent@$PROJECT_ID.iam.gserviceaccount.com
    
  • La tua istanza Filestore:

    export FS_ZONE=zone
    export INSTANCE_NAME=instance-id
    export SHARE_NAME=datafile-share-name
    

    Sostituisci quanto segue:

    • zone con la zona in cui si trova l'istanza di Filestore.
    • instance-id con l'ID istanza dell'istanza Filestore.
    • file-share-name con il nome specificato per la condivisione file NFS pubblicata dall'istanza.
  • Imposta le variabili di ambiente per il backup di Filestore:

    export FS_BACKUP_LOCATION=region
    

    Sostituisci region con l'area geografica in cui vuoi archiviare il backup.

Creare una funzione che crei un backup

  1. In Google Cloud Console, vai alla pagina Cloud Functions.

    Vai alla pagina Cloud Functions

  2. Fai clic su Crea funzione e configura la funzione come segue:

    • Nozioni di base:
      • Nome funzione: in questo esempio viene denominata la funzione fsbackup.
      • Regione: in questo esempio viene utilizzato us-central1.
    • Attivazione:
      • Tipo di attivatore: HTTP.
      • Autenticazione: Require authentication.
    • Impostazioni di runtime, build e connessione:
      • Account di servizio di runtime: Service Account for FS Backups-GCF (backupagent@$PROJECT_ID.iam.gserviceaccount.com).
    • Codice sorgente: Inline editor.
    • Runtime: Python 3.7.
    • Punto di ingresso: create_backup.
    • In requirements.txt, aggiungi le seguenti dipendenze:

      google-auth==1.19.2
      requests==2.24.0
      
    • Copia il seguente esempio di codice Python nell'editor in linea di main.py:

      Crea backup

      Questo esempio di codice crea un backup denominato mybackup- aggiunto con l'ora di creazione.

      PROJECT_ID = 'project-id'
      SOURCE_INSTANCE_ZONE = 'filestore-zone'
      SOURCE_INSTANCE_NAME = 'filestore-name'
      SOURCE_FILE_SHARE_NAME = 'file-share-name'
      BACKUP_REGION = 'backup-region'
      
      import google.auth
      import google.auth.transport.requests
      from google.auth.transport.requests import AuthorizedSession
      import time
      import requests
      import json
      
      credentials, project = google.auth.default()
      request = google.auth.transport.requests.Request()
      credentials.refresh(request)
      authed_session = AuthorizedSession(credentials)
      
      def get_backup_id():
          return "mybackup-" + time.strftime("%Y%m%d-%H%M%S")
      
      def create_backup(request):
          trigger_run_url = "https://file.googleapis.com/v1beta1/projects/{}/locations/{}/backups?backupId={}".format(PROJECT_ID, BACKUP_REGION, get_backup_id())
          headers = {
            'Content-Type': 'application/json'
          }
          post_data = {
            "description": "my new backup",
            "source_instance": "projects/{}/locations/{}/instances/{}".format(PROJECT_ID, SOURCE_INSTANCE_ZONE, SOURCE_INSTANCE_NAME),
            "source_file_share": "{}".format(SOURCE_FILE_SHARE_NAME)
          }
          print("Making a request to " + trigger_run_url)
          r = authed_session.post(url=trigger_run_url, headers=headers, data=json.dumps(post_data))
          data = r.json()
          print(data)
          if r.status_code == requests.codes.ok:
            print(str(r.status_code) + ": The backup is uploading in the background.")
          else:
            raise RuntimeError(data['error'])
      

      Sostituisci quanto segue:

      • project-id con l'ID progetto Google Cloud dell'istanza Filestore di origine.
      • filestore-zone con la zona dell'istanza Filestore di origine.
      • filestore-name con il nome dell'istanza Filestore di origine.
      • file-share-name con il nome della condivisione file.
      • backup-region con la regione per archiviare il backup.

      Elimina backup

      Questo esempio di codice elimina i backup più vecchi di un periodo predefinito.

      Configura questa funzione nello stesso modo della funzione di creazione di backup, ad eccezione di quanto segue:

      • Nome funzione: deletefsbackups.
      • Punto di ingresso: delete_backup.
      PROJECT_ID = 'project-id'
      BACKUP_REGION = 'region'
      BACKUP_RETENTION_TIME_HRS = hours
      
      import google.auth
      import google.auth.transport.requests
      from google.auth.transport.requests import AuthorizedSession
      import time
      import requests
      import json
      
      credentials, project = google.auth.default()
      request = google.auth.transport.requests.Request()
      credentials.refresh(request)
      authed_session = AuthorizedSession(credentials)
      
      now = time.time()
      retention_seconds = BACKUP_RETENTION_TIME_HRS * 60 * 60
      
      def delete_backup(request):
          list = []
          trigger_run_url = "https://file.googleapis.com/v1beta1/projects/{}/locations/{}/backups".format(PROJECT_ID, BACKUP_REGION)
          r = authed_session.get(trigger_run_url)
          data = r.json()
          if not data:
              print("No backups to delete.")
          else:
              list.extend(data['backups'])
              while 'nextPageToken' in data.keys():
                  nextPageToken = data['nextPageToken']
                  trigger_run_url_next = "https://file.googleapis.com/v1beta1/projects/{}/locations/{}/backups?pageToken={}".format(PROJECT_ID, BACKUP_REGION, nextPageToken)
                  r = authed_session.get(trigger_run_url_next)
                  data = r.json()
                  list.extend(data['backups'])
          for i in list:
              backup_time = i['createTime']
              backup_time = backup_time[:-4]
              backup_time = float(time.mktime(time.strptime(backup_time, "%Y-%m-%dT%H:%M:%S.%f")))
              if now - backup_time > retention_seconds:
                  print("Deleting " + i['name'] + " in the background.")
                  r = authed_session.delete("https://file.googleapis.com/v1beta1/{}".format(i['name']))
                  data = r.json()
                  print(data)
                  if r.status_code == requests.codes.ok:
                    print(str(r.status_code) + ": Deleting " + i['name'] + " in the background.")
                  else:
                    raise RuntimeError(data['error'])
      

      Sostituisci quanto segue:

      • project-id con l'ID progetto Google Cloud del backup.
      • region con l'area geografica in cui si trovano i backup.
      • hours con il numero di ore di conservazione dei backup. Ad esempio, se vuoi conservare i backup per 10 giorni, inserisci 240.

Assegnare ruoli IAM agli account di servizio client

  1. Aggiungi l'agente di servizio Cloud Scheduler al criterio IAM dell'account di servizio client Cloud Scheduler con il ruolo di roles/cloudscheduler.serviceAgent. Questo consente all'agente di servizio di impersonare l'account di servizio client per richiamare la funzione che crea un backup. Esegui il comando iam service-accounts add-iam-policy-binding:

    gcloud iam service-accounts add-iam-policy-binding $SCHEDULER_CLIENT_SA \
        --member=serviceAccount:$SCHEDULER_SA \
        --role=roles/cloudscheduler.serviceAgent
    
  2. Concedi all'account di servizio client di Cloud Functions il ruolo roles/file.editor in modo che possa effettuare chiamate all'endpoint di Filestore. Esegui il comando projects add-iam-policy-binding:

    gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member=serviceAccount:$GCF_CLIENT_SA \
        --role=roles/file.editor
    
  3. Concedi all'account di servizio client di Cloud Scheduler il ruolo di roles/cloudfunctions.invoker per la funzione fsbackup. Esegui questo comando functions add-iam-policy-binding:

    gcloud functions add-iam-policy-binding fsbackup \
        --member serviceAccount:$SCHEDULER_CLIENT_SA \
        --role roles/cloudfunctions.invoker
    

    Ora solo l'account di servizio client di Cloud Scheduler può richiamare fsbackup.

Crea un job Cloud Scheduler che attiva la funzione fsbackup in una pianificazione specificata

  1. Nel nostro esempio per questo tutorial, se vuoi pianificare un backup ogni 15 minuti, utilizza il comando scheduler jobs create http:

    gcloud beta scheduler jobs create http fsbackupschedule \
        --schedule "15 * * * *" \
        --http-method=GET \
        --uri=https://us-central1-$PROJECT_ID.cloudfunctions.net/fsbackup \
        --oidc-service-account-email=$SCHEDULER_CLIENT_SA    \
        --oidc-token-audience=https://us-central1-$PROJECT_ID.cloudfunctions.net/fsbackup
    

    Il flag --schedule consente di specificare la frequenza di esecuzione del job mediante la formattazione unix-cron. Per maggiori dettagli, consulta la pagina sulla configurazione delle pianificazioni dei cron job.

  2. Avvia il job di Cloud Scheduler creato nel passaggio precedente. Nel nostro esempio, utilizza il comando scheduler jobs runs:

    gcloud scheduler jobs run fsbackupschedule
    

    Il job fsbackupschedule richiama la funzione 'fsbackups' immediatamente una volta che esegui il comando e lo richiama ogni 15 minuti finché il job non viene messo in pausa.

  3. Controlla i log per la funzione fsbackups per vedere se la funzione viene eseguita correttamente e restituisce un status 200.

  4. Controlla se il backup viene creato utilizzando il comando backups list:

    gcloud beta filestore backups list
    

    Il comando restituisce un testo simile al seguente:

    NAME                      LOCATION     SRC_INSTANCE                        SRC_FILE_SHARE  STATE
    mybackup-20201123-184500  us-central1  us-central1-c/instances/nfs-server  vol1            READY
    

Avvisi di quota bassa per i backup

Se l'implementazione dei backup di pianificazione comporta il rischio di esaurire la quota di backup, ti consigliamo di configurare avvisi di quota di backup bassa. In questo modo riceverai una notifica quando la quota di backup si esaurisce.

Esegui la pulizia

Una volta completato il tutorial, puoi eseguire la pulizia delle risorse che hai creato in modo che interrompano l'utilizzo della quota e che vengano addebitati dei costi. Le sezioni seguenti descrivono come eliminare o disattivare queste risorse.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato per il tutorial.

Per eliminare il progetto:

  1. In Google Cloud Console, 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

  • Esplora architetture di riferimento, diagrammi, tutorial e best practice su Google Cloud. Consulta il nostro Centro di architettura cloud.