Crea un repository di backup per Database Service

Questo documento descrive i passaggi per configurare i BackupRepository richiesti per il servizio di database (DBS) di Google Distributed Cloud (GDC) con air gap. Questo repository, che deve essere denominato dbs-backup-repository, è una risorsa personalizzata all'interno di Kubernetes che indirizza il servizio di supporto GDC a un bucket di archivio di oggetti compatibile con S3 per l'archiviazione dei backup del database.

Importante: la configurazione del repository di backup per GDC DBS deve essere eseguita una sola volta dall'amministratore della piattaforma per ogni organizzazione. Una volta creato e pronto, non tentare di aggiornarlo, altrimenti si verificherà un comportamento imprevisto di backup e ripristino di DBS.

La configurazione corretta è fondamentale per abilitare le funzionalità di backup e ripristino per le istanze DBS come PostgreSQL, Oracle e AlloyDB Omni.

Nota: tutte le risorse descritte in questo documento vengono create nel server API di gestione.

Prima di iniziare

Prima di iniziare, assicurati di soddisfare i seguenti prerequisiti:

• Progetto: un progetto per ospitare il bucket, in genere denominato backups, con accesso solo al account di servizio.
• Accesso: autorizzazioni sufficienti per interagire con il server API di gestione.
  • L'utente deve disporre dei seguenti ruoli a livello di organizzazione per creare il repository di backup:
    • Bucket Admin (bucket-admin)
    • Autore progetto (project-creator)
    • Organization Backup Admin (organization-backup-admin)
  • All'interno del progetto di destinazione:
    • IAM Project Admin (project-iam-admin)
    • Bucket Object Project Viewer (project-bucket-object-viewer)
    • Bucket Object Project Admin (project-bucket-object-admin)
    • Bucket Project Admin (project-bucket-admin)
    • Secret Viewer (secret-viewer)
    • Namespace Admin (namespace-admin)
    • Backup Creator (backup-creator)
• Strumenti:
  • La console GDC.
  • Interfaccia a riga di comando kubectl configurata per accedere al server API di gestione.

Crea un bucket di archiviazione di oggetti

Tutti i passaggi successivi vengono eseguiti nel server API di gestione. Definisci e crea una risorsa Bucket. Nel resto di questo documento, si presuppone che il nome consigliato per questo bucket di archiviazione sia dbs-backups, che si trova nello spazio dei nomi del progetto backups. Assicurati che il bucket non abbia policy di conservazione.

Console

1. Accedi alla console GDC per l'organizzazione.
2. Assicurati di essere nel progetto backups.
3. Vai ad Archiviazione di oggetti > Bucket.
4. Fai clic su Crea bucket.
5. Imposta il nome del bucket su dbs-backups.
6. Imposta la descrizione su Bucket for DBS backups.
7. Configura la classe di archiviazione in base alle esigenze. Ad esempio, Standard.
8. Per Sicurezza, assicurati di non impostare una policy di conservazione, in quanto ciò comporterebbe la conservazione errata dei database e dei relativi backup.
9. Fai clic su Crea.

API

• Applica il seguente manifest al server API di gestione:

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

Crea un account di servizio e imposta le autorizzazioni

Crea un ProjectServiceAccount e concedigli le autorizzazioni per accedere al bucket.

Console

1. Nel progetto backups, vai a Identità e accesso > Identità di servizio.
2. Fai clic su Crea identità di servizio. Viene visualizzata la pagina Dettagli identità di servizio.
3. Nel campo Nome identità di servizio, inserisci dbs-backup-sa.
4. Fai clic su Crea.
5. Vai a Identità e accesso > Accesso.
6. Nell'elenco Membro, fai clic su Aggiungi membro. Viene visualizzata la pagina Utenti e ruoli.
7. Seleziona Identità di servizio nell'elenco Tipo di membro.
8. Nell'elenco Identità del servizio, seleziona dbs-backup-sa per assegnare un'associazione di ruoli.
9. Nell'elenco Ruolo, seleziona Bucket Object Project Admin da assegnare all'identità di servizio.
10. Fai clic su Aggiungi.

API

• Applica questi manifest al server API di gestione:

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

Identifica il secret delle credenziali del account di servizio e i dettagli del bucket

Dopo aver concesso l'accesso al bucket a dbs-backup-sa, GDC crea automaticamente un secret nello stesso spazio dei nomi, backups, contenente le credenziali di accesso S3. Devi trovare il nome di questo secret e i dettagli del bucket utilizzando l'interfaccia a riga di comando (API) kubectl.

1. Imposta le variabili di ambiente:

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

2. Trova il nome del 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}"
   

   Questo comando filtra i secret nello spazio dei nomi backups per trovare quello annotato per il account di servizio dbs-backup-sa e corrispondente alla convenzione di denominazione standard. Per eseguire questo comando, devi disporre del ruolo Secret Viewer (secret-viewer) nel progetto backups o chiedere all'amministratore della piattaforma che ha creato il account di servizio di fornire il nome del secret.

3. Recupera i dettagli dell'endpoint e della regione del 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}"
   

Crea il BackupRepository

Crea la risorsa BackupRepository, facendo riferimento al secret identificato nella sezione precedente, Identifica il secret delle credenziali del account di servizio e i dettagli del bucket. Questo passaggio deve essere completato utilizzando l'interfaccia a riga di comando (API) kubectl.

• Crea il file YAML, ad esempio backup-repo.yaml, sostituendo le variabili trovate nella sezione precedente:

  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
  

  Sostituisci quanto segue:

  • BUCKET_CRED_SECRET_NAME: il nome del secret.
  • ENDPOINT: l'endpoint del bucket.
  • FULL_BUCKET_NAME: il nome completo del bucket.
  • REGION: la regione del bucket.

Verifica il repository di backup

Controlla lo stato del repository per assicurarti che sia stato configurato correttamente.

1. Stampa le informazioni per il repository di backup:

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

2. Verifica che l'output sia simile al seguente. Un messaggio NoError indica che il repository è stato configurato come previsto:

   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