Créer un dépôt de sauvegarde pour le service de base de données

Ce document décrit la procédure à suivre pour configurer les BackupRepository requis pour le service de base de données (DBS) Google Distributed Cloud (GDC) air-gapped. Ce dépôt, obligatoirement nommé dbs-backup-repository, est une ressource personnalisée dans Kubernetes qui dirige le service de sauvegarde GDC vers un bucket de stockage d'objets compatible avec S3 pour stocker les sauvegardes de base de données.

Important : La configuration du dépôt de sauvegarde pour GDC DBS doit être effectuée une seule fois par l'administrateur de la plate-forme pour chaque organisation. Une fois qu'il est créé et prêt, n'essayez pas de le mettre à jour, car cela entraînerait un comportement inattendu de sauvegarde et de restauration de DBS.

Une configuration appropriée est essentielle pour activer les fonctionnalités de sauvegarde et de restauration des instances de SGBD telles que PostgreSQL, Oracle et AlloyDB Omni.

Remarque : Toutes les ressources décrites dans ce document sont créées sur le serveur de l'API Management.

Avant de commencer

Avant de commencer, assurez-vous de remplir les conditions préalables suivantes :

• Projet : projet pour héberger le bucket, généralement nommé database-backups, avec un accès réservé au compte de service.
• Accès : autorisations suffisantes pour interagir avec le serveur de l'API Management.
  • Pour créer le dépôt de sauvegarde, l'utilisateur doit disposer des rôles suivants au niveau de l'organisation :
    • Administrateur de bucket (bucket-admin)
    • Créateur de projet (project-creator)
    • Administrateur des sauvegardes de l'organisation (organization-backup-admin)
  • Dans le projet cible :
    • Administrateur de projet IAM (project-iam-admin)
    • Lecteur des objets du bucket de projet (project-bucket-object-viewer)
    • Administrateur des objets du bucket de projet (project-bucket-object-admin)
    • Administrateur de bucket de projet (project-bucket-admin)
    • Administrateur de l'espace de noms (namespace-admin)
    • Créateur de sauvegarde (backup-creator)
• Outils :
  • La console GDC.
  • La CLI kubectl est configurée pour accéder au serveur d'API de gestion.

Créer un bucket de stockage d'objets

Toutes les étapes suivantes sont effectuées sur le serveur de l'API Management. Définissez et créez une ressource Bucket. Le nom recommandé dbs-backups pour ce bucket de stockage est utilisé dans le reste de ce document, qui se trouve dans l'espace de noms du projet backups. Assurez-vous que le bucket ne dispose pas de règle de conservation.

Console

1. Connectez-vous à la console GDC pour l'organisation.
2. Assurez-vous d'être dans le projet backups.
3. Accédez à Stockage d'objets > Buckets.
4. Cliquez sur Créer un bucket.
5. Nommez le bucket dbs-backups.
6. Définissez la description sur Bucket for DBS backups.
7. Configurez la classe de stockage selon vos besoins. Par exemple, Standard.
8. Pour la sécurité, assurez-vous de ne pas définir de règle de conservation, car cela entraînerait la conservation erronée des bases de données et de leurs sauvegardes.
9. Cliquez sur Créer.

API

• Appliquez le fichier manifeste suivant au serveur de l'API Management :

kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f -
<<EOF
apiVersion: object.gdc.goog/v1
kind: Bucket
metadata:
  name: dbs-backups
  namespace: backups
spec:
  description: "Bucket for DBS backups"
  storageClass: "Standard"
EOF

Créer un compte de service et définir des autorisations

Créez un ProjectServiceAccount et accordez-lui les autorisations d'accès au bucket.

Console

1. Dans le projet backups, accédez à Identité et accès > Comptes de service.
2. Cliquez sur Créer un compte de service, puis nommez-le dbs-backup-sa.
3. Accorder des autorisations :
   1. Accédez à Stockage d'objets > Buckets > dbs-backups > Autorisations.
   2. Cliquez sur Ajouter un compte principal.
   3. Sélectionnez le compte de service : dbs-backup-sa.
   4. Sélectionnez un rôle : un rôle qui accorde un accès en lecture et en écriture aux objets, tel que Administrateur des objets Storage.
   5. Cliquez sur Ajouter.

API

• Appliquez ces fichiers manifeste au serveur de l'API Management :

kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f -
<<EOF
apiVersion: resourcemanager.gdc.goog/v1
kind: ProjectServiceAccount
metadata:
  name: dbs-backup-sa
  namespace: backups
spec: {}
EOF

kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f -
<<EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: dbs-backups-readwrite-role
  namespace: backups
rules:
- apiGroups: ["object.gdc.goog"]
  resources: ["bucket"]
  resourceNames: ["dbs-backups"]
  verbs: ["read-object", "write-object"]
EOF

kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f -
<<EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: dbs-backups-readwrite-rolebinding
  namespace: backups
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: dbs-backups-readwrite-role
subjects:
- kind: ServiceAccount
  name: dbs-backup-sa
  namespace: backups
EOF

Identifier le secret d'identifiant et les détails du bucket du compte de service

Lorsque vous accordez l'accès au bucket à dbs-backup-sa, GDC crée automatiquement un secret dans le même espace de noms, backups, contenant les identifiants d'accès S3. Vous devez trouver le nom de ce secret.

Console

1. Recherchez le nom du secret :
   1. Accédez à Kubernetes Engine > Configuration > Secrets dans le projet backups.
   2. Recherchez un secret commençant par object-storage-key-std-sa- et vérifiez les annotations pour confirmer que object.gdc.goog/subject est dbs-backup-sa.
   3. Notez le nom de ce secret.
2. Recherchez les détails du bucket :
   1. Accédez à la page d'informations Stockage d'objets > Buckets > dbs-backups.
   2. Recherchez et notez les ENDPOINT, REGION et FULL_BUCKET_NAME.

API

1. Définissez les variables d'environnement :

   export SA_NAMESPACE="backups"
   export SA_NAME="dbs-backup-sa"
   export KUBECONFIG=MANAGEMENT_API_SERVER
   

2. Recherchez le nom du secret :

   export BUCKET_CRED_SECRET_NAME=$(kubectl --kubeconfig=${KUBECONFIG} get secret \
       -n "${SA_NAMESPACE}" -l object.gdc.goog/subject-type=ServiceAccount -o json | \
       jq -r --arg SA_NAME "${SA_NAME}" \
       '.items[] | select(.metadata.annotations["object.gdc.goog/subject"] == $SA_NAME and (.metadata.name |startswith("object-storage-key-std-sa-"))) | .metadata.name')
   echo "Bucket Credential Secret Name: ${BUCKET_CRED_SECRET_NAME}"
   

   Cette commande filtre les secrets dans l'espace de noms backups pour trouver celui annoté pour dbs-backup-sa et correspondant à la convention d'attribution de noms standard.

3. Obtenez des informations sur le point de terminaison et la région du bucket :

   export BUCKET_NAME=dbs-backups
   export FULL_BUCKET_NAME=$(kubectl --kubeconfig=${KUBECONFIG} get bucket -n ${SA_NAMESPACE} ${BUCKET_NAME} -o jsonpath='{.status.fullyQualifiedName}')
   export ENDPOINT=$(kubectl --kubeconfig=${KUBECONFIG} get bucket -n ${SA_NAMESPACE} ${BUCKET_NAME} -o jsonpath='{.status.endpoint}')
   export REGION=$(kubectl --kubeconfig=${KUBECONFIG} get bucket -n ${SA_NAMESPACE} ${BUCKET_NAME} -o jsonpath='{.status.region}')
   
   echo "FULL_BUCKET_NAME: ${FULL_BUCKET_NAME}"
   echo "ENDPOINT: ${ENDPOINT}"
   echo "REGION: ${REGION}"'
   

Créer le BackupRepository

Créez la ressource BackupRepository en faisant référence au secret identifié dans la section précédente, Identifier le secret des identifiants et les détails du bucket du compte de service. Cette étape doit être effectuée à l'aide de l'CLI kubectl (API).

• Créez le fichier YAML, par exemple backup-repo.yaml, en remplaçant les variables de la section précédente :

  kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f -
  <<EOF
  apiVersion: backup.gdc.goog/v1
  kind: BackupRepository
  metadata:
    name: dbs-backup-repository # This specific name is required for DBS
  spec:
    secretReference:
      namespace: "backups" # Namespace of the Service Account and the auto-generated secret
      name: BUCKET_CRED_SECRET_NAME
    endpoint: ENDPOINT
    type: "S3"
    s3Options:
      bucket: FULL_BUCKET_NAME"
      region: REGION
      forcePathStyle: true
    importPolicy: "ReadWrite"
    force: true
    EOF
  

  Remplacez les éléments suivants :

  • BUCKET_CRED_SECRET_NAME : nom du secret.
  • ENDPOINT : point de terminaison du bucket.
  • FULL_BUCKET_NAME" : nom complet du bucket.
  • REGION : région du bucket.

Vérifier la sauvegarde

Vérifiez l'état du dépôt pour vous assurer qu'il a été configuré correctement.

1. Imprimez les informations de votre dépôt de sauvegarde :

   kubectl --kubeconfig MANAGEMENT_API_SERVER get backuprepository dbs-backup-repository -ojson | jq .status
   

2. Vérifiez que le résultat ressemble à ce qui suit. Un message NoError indique que le dépôt a été configuré comme prévu :

   NAME                    TYPE   POLICY      ERROR
   dbs-backup-repository   S3     ReadWrite   NoError
   status:
     conditions:
     - lastTransitionTime: "2025-11-13T00:36:09Z"
       message: Backup Repository reconciled successfully
       reason: Ready
       status: "True"
       type: Ready
     initialImportDone: true
     reconciliationError: NoError
     sentinelEtag: 9b82fbb7-6ea2-444d-8878-ab91397ae961