Crea un repository di backup per Database Service

Questo documento descrive i passaggi per configurare BackupRepository richiesti per Google Distributed Cloud (GDC) air-gapped Database Service (DBS). Questo repository, denominato obbligatoriamente dbs-backup-repository, è una risorsa personalizzata in Kubernetes che indirizza il servizio di backup GDC a un bucket di archiviazione 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 del database.

La configurazione corretta è fondamentale per attivare 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 disporre dei 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.
  • Per creare il repository di backup, l'utente deve disporre dei seguenti ruoli a livello di organizzazione:
    • Amministratore bucket (bucket-admin)
    • Autore progetto (project-creator)
    • Amministratore backup dell'organizzazione (organization-backup-admin)
  • All'interno del progetto di destinazione:
    • Project IAM Admin (project-iam-admin)
    • Visualizzatore di progetti di oggetti bucket (project-bucket-object-viewer)
    • Bucket Object Project Admin (project-bucket-object-admin)
    • Bucket Project Admin (project-bucket-admin)
    • Visualizzatore di secret (secret-viewer)
    • Amministratore spazio dei nomi (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. Il nome consigliato dbs-backups per questo bucket di archiviazione viene utilizzato per il resto di questo documento, che si trova nello spazio dei nomi del progetto backups. Assicurati che il bucket non abbia criteri di conservazione.

Console

1. Accedi alla console GDC per l'organizzazione.
2. Assicurati di essere nel progetto backups.
3. Vai a Object Storage > 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 la sicurezza, assicurati di non impostare una norma di conservazione, in quanto ciò causerà 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 il 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à del servizio nell'elenco Tipo di membro.
8. Nell'elenco Identità del servizio, seleziona dbs-backup-sa per assegnare un binding del ruolo.
9. Nell'elenco Ruolo, seleziona Bucket Object Project Admin da assegnare all'identità del 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 e i dettagli del bucket del account di servizio

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 a 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 Visualizzatore secret (secret-viewer) nel progetto backups oppure 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 e i dettagli del bucket del account di servizio account. Questo passaggio deve essere completato utilizzando l'interfaccia a riga di comando kubectl (API).

• 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 è il segnale che 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