Planifier des sauvegardes

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Ce tutoriel explique comment planifier des sauvegardes pour des instances Filestore de niveau HDD de base et SSD de base à l'aide de Cloud Scheduler et de Cloud Functions.

Objectifs

  • Créez un compte de service client pour Cloud Scheduler qui dispose des identifiants nécessaires pour appeler une fonction Cloud Functions.
  • Créez un compte de service client à utiliser par Cloud Functions avec les identifiants nécessaires pour appeler le point de terminaison Filestore.
  • Créer une fonction Cloud Functions qui crée (ou supprime) une sauvegarde d'un partage de fichiers
  • Créer une tâche Cloud Scheduler qui exécute la fonction de création de sauvegardes (ou supprimer des sauvegardes) à intervalles réguliers.

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

  4. Activer les API Cloud Scheduler, Cloud Functions, and Filestore.

    Activer les API

  5. Installez et initialisez Google Cloud CLI.
  6. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  7. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

  8. Activer les API Cloud Scheduler, Cloud Functions, and Filestore.

    Activer les API

  9. Installez et initialisez Google Cloud CLI.
  10. Si vous ne disposez pas d'une instance Filestore dans votre projet, vous devez d'abord en créer une.

Créer des comptes de service client pour Cloud Scheduler et Cloud Functions

  1. Créer un compte de service client que Cloud Scheduler exécute pour appeler une fonction Cloud Functions Pour cet exemple, nous allons nommer le compte schedulerunner et définir le nom à afficher sur "Service Account for FS Backups-Scheduler":

    gcloud iam service-accounts create schedulerunner \
        --display-name="Service Account for FS Backups-Scheduler"
    
  2. créer un compte de service client que Cloud Functions exécute pour appeler le point de terminaison Filestore ; Pour cet exemple, nous appelons le compte backupagent et f définissons le nom à afficher sur "Service Account for FS Backups-GCF":

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

    Vous pouvez vérifier si le compte de service est créé en exécutant la commande suivante:

    gcloud iam service-accounts list
    

    La commande renvoie un résultat semblable à celui-ci:

    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
    

Configurer des variables d'environnement

Configurez les variables d'environnement suivantes dans votre environnement local:

  • ID et projet Google Cloud:

    export PROJECT_ID=`gcloud config get-value core/project`
    export PROJECT_NUMBER=`gcloud projects describe $PROJECT_ID --format='value(projectNumber)'`
    
  • L'agent de service Cloud Scheduler et les comptes de service client pour Cloud Scheduler et 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
    
  • Votre instance Filestore:

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

    Remplacez les éléments suivants :

    • zone est la zone où se trouve l'instance Filestore.
    • instance-id est l'ID de l'instance Filestore ;
    • file-share-name est le nom que vous spécifiez pour le partage de fichiers NFS qui est diffusé à partir de l'instance.
  • Configurez les variables d'environnement pour votre sauvegarde Filestore:

    export FS_BACKUP_LOCATION=region
    

    Remplacez region par la région dans laquelle vous souhaitez stocker la sauvegarde.

Créer une fonction permettant de créer une sauvegarde

  1. Dans Google Cloud Console, accédez à la page Cloud Functions.

    Accéder à la page Cloud Functions

  2. Cliquez sur Créer une fonction, puis configurez la fonction comme suit:

    • Principes de base :
      • Nom de la fonction: pour cet exemple, nous appelons la fonction : fsbackup.
      • Région: pour cet exemple, nous utilisons us-central1.
    • Déclencheur :
      • Type de déclencheur : HTTP.
      • Authentification : Require authentication.
    • Paramètres d'exécution, de compilation et de connexion :
      • Compte de service d'exécution : Service Account for FS Backups-GCF (backupagent@$PROJECT_ID.iam.gserviceaccount.com).
    • Code source : Inline editor.
    • Environnement d'exécution : Python 3.7.
    • Point d'entrée : create_backup.
    • Dans requirements.txt, ajoutez les dépendances suivantes:

      google-auth==1.19.2
      requests==2.24.0
      
    • Copiez l'exemple de code Python suivant dans l'éditeur intégré main.py:

      Créer des sauvegardes

      Cet exemple de code crée une sauvegarde nommée mybackup-, ainsi que l'heure de création.

      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'])
      

      Remplacez les éléments suivants :

      • project-id par l'ID de projet Google Cloud de l'instance Filestore source.
      • filestore-zone par la zone de l'instance Filestore source.
      • filestore-name par le nom de l'instance Filestore source.
      • file-share-name par le nom du partage de fichiers ;
      • backup-region par la région dans laquelle stocker la sauvegarde.

      Supprimer des sauvegardes

      Cet exemple de code supprime les sauvegardes antérieures à une période prédéfinie.

      Configurez cette fonction de la même manière que la fonction "create backup", à l'exception des éléments suivants :

      • Nom de la fonction : deletefsbackups.
      • Point d'entrée : 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'])
      

      Remplacez les éléments suivants :

      • project-id par l'ID de projet Google Cloud de la sauvegarde.
      • region par la région dans laquelle résident les sauvegardes.
      • hours par le nombre d'heures de conservation des sauvegardes. Par exemple, si vous souhaitez conserver les sauvegardes pendant 10 jours, saisissez 240.

Attribuer des rôles IAM aux comptes de service client

  1. Ajoutez l'agent de service Cloud Scheduler à la stratégie IAM du compte de service client Cloud Scheduler avec le rôle roles/cloudscheduler.serviceAgent. Cela permet à l'agent de service d'emprunter l'identité du compte de service client pour appeler la fonction qui crée une sauvegarde.

    gcloud iam service-accounts add-iam-policy-binding $SCHEDULER_CLIENT_SA \
        --member=serviceAccount:$SCHEDULER_SA \
        --role=roles/cloudscheduler.serviceAgent
    
  2. Attribuez le rôle roles/file.editor au compte de service client de Cloud Functions afin qu'il puisse appeler le point de terminaison Filestore.

    gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member=serviceAccount:$GCF_CLIENT_SA \
        --role=roles/file.editor
    
  3. Attribuez au compte de service client Cloud Scheduler le rôle roles/cloudfunctions.invoker pour la fonction fsbackup:

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

    Désormais, seul le compte de service client de Cloud Scheduler peut appeler fsbackup.

Créer une tâche Cloud Scheduler qui déclenche la fonction fsbackup avec une programmation spécifiée

  1. Dans notre exemple pour ce tutoriel, si vous souhaitez planifier une sauvegarde toutes les 15 minutes, la commande devrait ressembler à ceci:

    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
    

    L'option --schedule vous permet de spécifier la fréquence à laquelle la tâche est exécutée au format unix-cron. Pour plus d'informations, consultez la section Configurer la planification de tâches Cron.

  2. Démarrez la tâche Cloud Scheduler créée à l'étape précédente. Dans notre exemple, la commande est la suivante :

    gcloud scheduler jobs run fsbackupschedule
    

    La tâche fsbackupschedule appelle la fonction "fsbackups" immédiatement après l'exécution de la commande, puis l'invoque à nouveau toutes les 15 minutes jusqu'à ce que la tâche soit suspendue.

  3. Vérifiez les journaux de la fonction fsbackups pour voir si elle s'exécute correctement et renvoie un objet status 200.

  4. Vérifiez si la sauvegarde est créée:

    gcloud beta filestore backups list
    

    La commande renvoie un résultat semblable au suivant :

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

Alertes de quota faibles pour les sauvegardes

Si la mise en œuvre de la programmation de sauvegardes vous présente un risque de manquer de quota de sauvegardes, nous vous recommandons de configurer des alertes de faible quota de sauvegardes. Ainsi, vous êtes averti lorsque le quota de sauvegardes est faible.

Effectuer un nettoyage

Une fois le tutoriel terminé, vous pouvez procéder au nettoyage des ressources que vous avez créées afin qu'elles ne soient plus comptabilisées dans votre quota et qu'elles ne vous soient plus facturées. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

  1. Dans la console Google Cloud, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes

  • Découvrez des architectures de référence, des schémas, des tutoriels et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.