Crea un repository di backup per Database Service

Questo documento descrive i passaggi per configurare il BackupRepository richiesto per Google Distributed Cloud (GDC) air-gapped Database Service (DBS). Questo repository, denominato obbligatoriamente dbs-backup-repository, è una risorsa personalizzata all'interno di 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 DBS.

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 database-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 del backup dell'organizzazione (organization-backup-admin)
  • All'interno del progetto di destinazione:
    • Project IAM Admin (project-iam-admin)
    • Project Bucket Object Viewer (project-bucket-object-viewer)
    • Project Bucket Object Admin (project-bucket-object-admin)
    • Project Bucket Admin (project-bucket-admin)
    • 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. Per il resto di questo documento, si presuppone il nome consigliato dbs-backups per questo bucket di archiviazione, 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 come 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 un criterio 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 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 Identity & Access > Service Accounts.
2. Fai clic su Crea service account e chiamalo dbs-backup-sa.
3. Concedi le autorizzazioni:
   1. Vai a Object Storage > Bucket > dbs-backups > Autorizzazioni.
   2. Fai clic su Aggiungi entità.
   3. Seleziona Service Account: dbs-backup-sa.
   4. Seleziona Ruolo: un ruolo che concede l'accesso in lettura e scrittura agli oggetti, ad esempio Amministratore oggetti di archiviazione.
   5. 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: 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

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.

Console

1. Trova il nome del secret:
   1. Vai a Kubernetes Engine > Configurazione > Secret nel progetto backups.
   2. Cerca un segreto che inizi con object-storage-key-std-sa- e controlla le annotazioni per verificare che object.gdc.goog/subject sia dbs-backup-sa.
   3. Prendi nota di questo nome secret.
2. Trova i dettagli del bucket:
   1. Vai a Object Storage > Bucket > pagina dei dettagli di dbs-backups.
   2. Trova e annota ENDPOINT, REGION e FULL_BUCKET_NAME.

API

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 dbs-backup-sa e corrispondente alla convenzione di denominazione standard.

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 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