Créer un dépôt de sauvegarde pour Database Service

Ce document décrit la procédure à suivre pour configurer le BackupRepository requis pour le service de base de données (DBS) Google Distributed Cloud (GDC) air gap. 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 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, sinon cela entraînera un comportement inattendu de sauvegarde et de restauration DBS.

Une configuration appropriée est essentielle pour activer les fonctionnalités de sauvegarde et de restauration des instances DBS 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 disposer des éléments suivants :

• Projet : un projet pour héberger le bucket, généralement nommé backups, avec un accès réservé au compte de service.
• Accès : autorisations suffisantes pour interagir avec le serveur de l'API de gestion.
  • L'utilisateur doit disposer des rôles suivants au niveau de l'organisation pour créer le dépôt de sauvegarde :
    • Administrateur de buckets (bucket-admin)
    • Créateur de projet (project-creator)
    • Administrateur de sauvegarde de l'organisation (organization-backup-admin)
  • Dans le projet cible :
    • Administrateur de projet IAM (project-iam-admin)
    • Lecteur de projets d'objets de bucket (project-bucket-object-viewer)
    • Administrateur de projet d'objets de bucket (project-bucket-object-admin)
    • Administrateur de projet de bucket (project-bucket-admin)
    • Lecteur de secrets (secret-viewer)
    • Administrateur d'espace de noms (namespace-admin)
    • Créateur de sauvegardes (backup-creator)
• Outils :
  • La console GDC.
  • CLI kubectl 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 d'API de gestion. Définissez et créez une ressource Bucket. Le nom recommandé dbs-backups pour ce bucket de stockage est utilisé pour le reste de ce document, situé dans l'espace de noms du projet backups. Assurez-vous que le bucket ne dispose d'aucune règle de conservation.

Console

1. Connectez-vous à la console GDC de l'organisation.
2. Assurez-vous d'être dans le projet backups.
3. Accédez à Object Storage > Buckets.
4. Cliquez sur Créer un bucket.
5. Nommez-le 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 Sécurité, veillez à 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 d'API de gestion :

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 > Identités de service.
2. Cliquez sur Créer une identité de service. La page Détails de l'identité du service s'ouvre.
3. Dans le champ Nom de l'identité de service, saisissez dbs-backup-sa.
4. Cliquez sur Créer.
5. Accédez à Identité et accès > Accès.
6. Dans la liste Membre, cliquez sur Ajouter un membre. La page Utilisateurs et rôles s'affiche.
7. Sélectionnez Identité du service dans la liste Type de membre.
8. Dans la liste Identité du service, sélectionnez dbs-backup-sa pour attribuer une liaison de rôle.
9. Dans la liste Rôle, sélectionnez Administrateur de projet d'objets de bucket à attribuer à l'identité de service.
10. Cliquez sur Ajouter.

API

• Appliquez ces fichiers manifestes au serveur d'API de gestion :

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: RoleBinding
metadata:
  name: dbs-backups-readwrite-rolebinding
  namespace: backups
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: project-bucket-object-admin
subjects:
- kind: ServiceAccount
  name: dbs-backup-sa
  namespace: backups
EOF

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

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 et les détails du bucket à l'aide de la CLI (API) kubectl.

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 de l'espace de noms backups pour trouver celui annoté pour le compte de service dbs-backup-sa et correspondant à la convention d'attribution de noms standard. Pour exécuter cette commande, vous devez disposer du rôle Lecteur de secrets (secret-viewer) dans le projet backups, ou demander à l'administrateur de la plate-forme qui a créé le compte de service de fournir le nom du secret.

3. Obtenez les détails du point de terminaison et de 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 référençant le secret identifié dans la section précédente, Identifier le secret d'identification du compte de service et les détails du bucket. Cette étape doit être effectuée à l'aide de la 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 le dépôt de sauvegarde

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

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