Raccogli informazioni di debug
Queste sezioni descrivono come raccogliere log e configurazioni per il debug.
Recupera i log dai pod dell'operatore
Per recuperare i log dai pod dell'operatore, esegui questi comandi:
kubectl logs deployments/fleet-controller-manager -c fleet-manager -n alloydb-omni-system > alloydb-omni-system-fleet-controller-manager.out
kubectl logs deployments/local-controller-manager -c local-manager -n alloydb-omni-system > alloydb-omni-system-local-controller-manager.out
Recupera i log dei pod del database
Per recuperare i log dei pod del database, esegui questi comandi:
DB_POD=$(kubectl get pod -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME,alloydbomni.internal.dbadmin.goog/task-type=database -n DB_CLUSTER_NAMESPACE -o jsonpath='{.items[0].metadata.name}')
kubectl logs -c database ${DB_POD} -n DB_CLUSTER_NAMESPACE > ${DB_POD}.log
kubectl logs -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME -c database -n DB_CLUSTER_NAMESPACE > dbcluster_DB_CLUSTER_NAME.out
I seguenti log sono esempi di controlli di integrità del database riusciti:
I0813 11:01:49.210051 27 gateway.go:184] "DatabaseHealthCheck: request handled successfully" log_name="agent" project_ns="default" dbcluster="adb"
I0813 11:01:59.196796 27 gateway.go:166] "DatabaseHealthCheck: handling request" log_name="agent" project_ns="default" dbcluster="adb"
I0813 11:01:59.196853 27 database.go:702] "dbdaemon/isRestoreInProgress: starting" log_name="agent" project_ns="default" dbcluster="adb"
I0813 11:01:59.209824 27 gateway.go:184] "DatabaseHealthCheck: request handled successfully" log_name="agent" project_ns="default" dbcluster="adb"
I0813 11:02:09.197013 27 gateway.go:166] "DatabaseHealthCheck: handling request" log_name="agent" project_ns="default" dbcluster="adb"
I0813 11:02:09.197093 27 database.go:702] "dbdaemon/isRestoreInProgress: starting" log_name="agent" project_ns="default" dbcluster="adb"
I0813 11:02:09.210010 27 gateway.go:184] "DatabaseHealthCheck: request handled successfully" log_name="agent" project_ns="default" dbcluster="adb"
I0813 11:02:19.197368 27 gateway.go:166] "DatabaseHealthCheck: handling request" log_name="agent" project_ns="default" dbcluster="adb"
I0813 11:02:19.197425 27 database.go:702] "dbdaemon/isRestoreInProgress: starting" log_name="agent" project_ns="default" dbcluster="adb"
I0813 11:02:19.210416 27 gateway.go:184] "DatabaseHealthCheck: request handled successfully" log_name="agent" project_ns="default" dbcluster="adb"
Recupera il file postgresql.log
Per recuperare postgresql.log, esegui questo comando:
DB_POD=$(kubectl get pod -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME,alloydbomni.internal.dbadmin.goog/task-type=database -n DB_CLUSTER_NAMESPACE -o jsonpath='{.items[0].metadata.name}')
kubectl exec -c database -n DB_CLUSTER_NAMESPACE -it ${DB_POD} -- cat /obs/diagnostic/postgresql.log > dbcluster_DB_CLUSTER_NAME_postgresql.log
Recupera il file YAML DBInstance
Per recuperare il file YAML DBInstance, esegui questo comando:
kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o yaml > dbcluster_DB_CLUSTER_NAME.yaml
Recupera configurazioni e log per scenari ad alta disponibilità
Per recuperare configurazioni e log specifici per gli scenari di alta affidabilità (HA), esegui i seguenti comandi:
kubectl get replicationconfig.alloydbomni.internal.dbadmin.goog -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o yaml > replicationconfig_DB_CLUSTER_NAME.yaml
kubectl get deletestandbyjobs.alloydbomni.internal.dbadmin.goog -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o yaml > deletestandbyjobs_DB_CLUSTER_NAME.yaml
kubectl get createstandbyjobs.alloydbomni.internal.dbadmin.goog -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o yaml > createstandbyjobs_DB_CLUSTER_NAME.yaml
kubectl get failovers.alloydbomni.dbadmin.goog -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o yaml > failovers_DB_CLUSTER_NAME.yaml
Recupera gli stati dei pod e di STS
Per recuperare gli stati dei pod e degli StatefulSet (STS), esegui questi comandi:
DB_POD=$(kubectl get pod -n DB_CLUSTER_NAMESPACE -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME,alloydbomni.internal.dbadmin.goog/task-type=database -o jsonpath='{.items[0].metadata.name}')
kubectl describe pod ${DB_POD} -n DB_CLUSTER_NAMESPACE > pod_${DB_POD}.out
kubectl describe statefulset -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE > statefulset_DB_CLUSTER_NAME.out
Identifica gli errori
Queste sezioni descrivono come identificare gli errori.
Cerca lo stato di errore e i codici di errore
Per identificare il codice di errore, controlla il file YAML DBCluster in status. Per ulteriori informazioni, consulta la documentazione sui codici di errore.
Per recuperare il file YAML DBCluster, esegui questo comando:
kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o yaml > dbcluster_DB_CLUSTER_NAME.yaml
Cerca criticalIncidents. Questa sezione contiene il codice di errore e un'analisi dello stack.
Di seguito sono riportati alcuni esempi di criticalIncidents:
status:
certificateReference:
certificateKey: ca.crt
secretRef:
name: dbs-al-cert-dr-mce
namespace: dr
conditions:
- lastTransitionTime: "2024-10-07T22:46:03Z"
...
criticalIncidents:
- code: DBSE0304
createTime: "2024-10-03T11:50:54Z"
message: 'Healthcheck: Health check invalid result.'
resource:
component: healthcheck
location:
group: alloydbomni.internal.dbadmin.goog
kind: Instance
name: bc0f-dr-mce
namespace: dr
version: v1
stackTrace:
- component: healthcheck
message: 'DBSE0304: Healthcheck: Health check invalid result. rpc error: code
= Code(10304) desc = DBSE0304: Healthcheck: Health check invalid result.
dbdaemon/healthCheck: invalid timestamp read back from the healthcheck table.
Lag is 384837.296269 seconds, wanted 35 seconds'
Puoi anche recuperare lo stato estraendo campi specifici in formato JSON:
kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o jsonpath='{.status.criticalIncidents}' | jq
L'output è simile al seguente:
[
{
"code": "DBSE0085",
"createTime": "2024-03-14T05:41:37Z",
"message": "Platform: Pod is unschedulable.",
"resource": {
"component": "provisioning",
"location": {
"group": "alloydb.internal.dbadmin.goog",
"kind": "Instance",
"name": "b55f-testdbcluster",
"namespace": "dbs-system",
"version": "v1"
}
},
"stackTrace": [
{
"component": "provisioning",
"message": "DBSE0085: Platform: Pod is unschedulable. 0/16 nodes are available: pod has unbound immediate PersistentVolumeClaims. preemption: 0/16 nodes are available: 16 No preemption victims found for incoming pod..: Pod is unschedulable"
}
]
}
]
Se il messaggio di errore fa riferimento al pod del database, controlla le istanze e le risorse del pod nello stesso spazio dei nomi:
kubectl get instances.alloydbomni.internal.dbadmin.goog -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o yaml > instance_DB_CLUSTER_NAME.yaml
kubectl get pods -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME,alloydbomni.internal.dbadmin.goog/task-type=database -n DB_CLUSTER_NAMESPACE
Problemi noti
Questa sezione descrive i problemi noti e le soluzioni alternative per l'operatore AlloyDB Omni. Per un elenco completo degli annunci di release, delle correzioni di bug e degli aggiornamenti della sicurezza, consulta le Note di rilascio.
L'emissione del certificato non riesce in cert-manager
L'operatore AlloyDB Omni utilizza cert-manager per eseguire il provisioning dei certificati Transport Layer Security (TLS) per l'operatore e i cluster di database. In
cert-manager versione 1.21.2 e precedenti, una race condition nota
(problema cert-manager n. 6331)
potrebbe causare l'errore dell'emissione del certificato e l'attivazione di un backoff di un'ora per i nuovi tentativi.
Versioni interessate
AlloyDB Omni operator 1.0.0 e versioni successive con cert-manager 1.21.2 e versioni precedenti.
Sintomi
Quando si verifica questo problema, potresti osservare i seguenti sintomi:
- Una risorsa
DBClusterrimane nella faseDBClusterWaitingForCertificatee la creazione o l'upgrade del cluster di database va in timeout. - Un'installazione Helm dell'operatore AlloyDB Omni non va a buon fine perché una risorsa
Certificate, ad esempiolocal-serving-certnello spazio dei nomialloydb-omni-system, non è pronta. - Le condizioni di stato di una risorsa
Certificateincludono il messaggioCSR not signed by referenced private keycon il motivoFailedoErrorKeyMatch.
Per trovare le risorse Certificate interessate da questo problema, esegui questo comando:
kubectl get certificates.cert-manager.io --all-namespaces \
-o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{.status.conditions[*].message}{"\n"}{end}' \
| grep "CSR not signed by referenced private key"
L'output elenca lo spazio dei nomi, il nome e i messaggi di condizione di stato di ogni risorsa Certificate interessata. Se visualizzi una risorsa Certificate interessata in formato YAML, il campo status è simile al seguente:
status:
conditions:
- message: 'The certificate request has failed to complete and will be retried: Error generating certificate template: CSR not signed by referenced private key'
reason: Failed
status: "False"
type: Issuing
failedIssuanceAttempts: 1
Soluzione alternativa
Per evitare conflitti di aggiornamento del controller e ridurre il ritardo dei nuovi tentativi per le richieste di certificato non riuscite da un'ora a 15 secondi, esegui l'upgrade di cert-manager con il feature gate ServerSideApply e durate di backoff ridotte:
helm upgrade cert-manager oci://quay.io/jetstack/charts/cert-manager \
--version CERT_MANAGER_VERSION \
--namespace cert-manager \
--reuse-values \
--set featureGates="ServerSideApply=true" \
--set "extraArgs={--certificate-request-minimum-backoff-duration=15s,--certificate-request-maximum-backoff-duration=5m}"
Sostituisci quanto segue:
CERT_MANAGER_VERSION: la versione dicert-managerinstallata nel tuo cluster Kubernetes, ad esempiov1.21.2. Per trovare la versione installata, esegui il comandohelm list --namespace cert-manager.
Dopo il riavvio del controller cert-manager, verifica che tutti i certificati mostrino
True nella colonna READY:
kubectl get certificates.cert-manager.io --all-namespaces
Se l'installazione dell'operatore AlloyDB Omni non è riuscita a causa di questo problema, eseguila di nuovo.
L'upgrade della versione secondaria di manutenzione con tempi di inattività ridotti interrompe l'avanzamento su un cluster di database secondario
Versioni interessate
AlloyDB Omni operator 1.8.0 e versioni successive.
Sintomi
Durante l'upgrade o il downgrade della versione secondaria di un cluster di database secondario di replica tra data center con standby ad alta affidabilità (HA), l'operazione interrompe l'avanzamento dopo l'upgrade del primo standby. La risorsa DBCluster rimane nello stato DBCUpgradeInProgress=True con il motivo DBCUpgradeFlowBegins.
Soluzione alternativa
Disattiva la manutenzione con tempi di inattività ridotti (LDTM) sul cluster di database secondario in modo che l'operatore AlloyDB Omni completi l'upgrade utilizzando il flusso di lavoro di upgrade in sequenza standard:
kubectl annotate dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME \ dbcluster.dbadmin.goog/enableLDTM=false \ --namespace DB_CLUSTER_NAMESPACE \ --overwriteSostituisci quanto segue:
DB_CLUSTER_NAME: il nome della risorsaDBClustersecondaria.DB_CLUSTER_NAMESPACE: lo spazio dei nomi della risorsaDBClustersecondaria.
Verifica che l'upgrade venga completato e che la risorsa
DBClusterraggiunga la faseDBClusterReady:kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME \ --namespace DB_CLUSTER_NAMESPACERiattiva la manutenzione con tempi di inattività ridotti sul cluster di database secondario in modo che la risorsa
DBClustermantenga la funzionalità di manutenzione con tempi di inattività ridotti se viene promossa a cluster di database primario:kubectl annotate dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME \ dbcluster.dbadmin.goog/enableLDTM=true \ --namespace DB_CLUSTER_NAMESPACE \ --overwrite
L'agente di monitoraggio rileva errori di autorizzazione dei cgroup dopo l'attivazione della replica tra data center
Versioni interessate
AlloyDB Omni operator 1.9.0.
Sintomi
Dopo aver attivato la replica tra data center, l'agente di monitoraggio riscontra errori di autorizzazione nei log del container quando tenta di raccogliere informazioni su cgroups.
Soluzione alternativa
Elenca i pod del database nel cluster del database secondario per trovare il nome del pod del database downstream:
kubectl get pods \ --selector alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME,alloydbomni.internal.dbadmin.goog/task-type=database \ --namespace DB_CLUSTER_NAMESPACESostituisci quanto segue:
DB_CLUSTER_NAME: il nome della risorsaDBClustersecondaria.DB_CLUSTER_NAMESPACE: lo spazio dei nomi della risorsaDBClustersecondaria.
Elimina il pod del database downstream in modo che l'operatore AlloyDB Omni ricrei e riavvii il pod:
kubectl delete pod DB_POD_NAME \ --namespace DB_CLUSTER_NAMESPACESostituisci
DB_POD_NAMEcon il nome del pod del database downstream del passaggio precedente.
Il cluster di database attiva continuamente failover automatici
Se la risorsa DBCluster crea più failover automatici uno dopo l'altro, completa i seguenti controlli:
Elenca le risorse
Failoverper il tuoDBClustere confronta i relativi timestamp di creazione:kubectl get failover.alloydbomni.dbadmin.goog \ --selector failover.dbadmin.goog/dbcluster=DB_CLUSTER_NAME \ --namespace DB_CLUSTER_NAMESPACESostituisci quanto segue:
DB_CLUSTER_NAME: il nome della risorsaDBCluster.DB_CLUSTER_NAMESPACE: lo spazio dei nomi della tua risorsaDBCluster.
Connettiti al pod del database primario sul database
alloydbadmine verifica lo stato del database:SELECT * FROM healthcheck;Verifica che il timestamp dell'ultimo controllo di integrità sia recente e che i controlli di integrità vengano eseguiti a intervalli previsti. Se l'istanza principale non è in stato integro, esamina il file
postgresql.logper determinare il motivo per cui l'istanza non funziona. Per saperne di più sul recupero dei log, consulta Risolvi i problemi dell'operatore AlloyDB Omni Kubernetes.
Se utilizzi un numero elevato di cluster di database in un singolo cluster Kubernetes o se hai cluster di database con provisioning insufficiente, i controlli di integrità del failover automatico potrebbero scadere o non riuscire a connettersi. Se ricevi un errore che inizia con HealthCheckProber: health check for instance failed, consulta le correzioni consigliate in Risolvi i problemi di riparazione delle istanze.
Per ridurre o impedire i failover automatici, puoi anche eseguire le seguenti azioni:
Aumenta il valore di
autoFailoverTriggerThresholdin modo che il failover automatico si verifichi meno di frequente. Per saperne di più, consulta Modifica le impostazioni di attivazione del failover automatico.Disabilita il failover automatico sui cluster di database. Per ulteriori informazioni, consulta Disattiva il failover automatico.
Il cluster di database rimane bloccato in uno stato di failover o di switchover
Durante un failover o uno switchover ad alta affidabilità (HA), l'operatore AlloyDB Omni isola l'istanza principale precedente durante la fase StopPrimary rinominando i file PG_VERSION in PG_VERSION.disabled sia nella directory di dati principale in /pgdata/db/PG_VERSION.disabled sia in ogni sottodirectory del database in /pgdata/db/base/OID/PG_VERSION.disabled. Se il failover o lo switchover non va a buon fine prima della promozione dell'istanza in standby e il rollback automatico non avviene o non va a buon fine, l'istanza principale precedente rimane isolata e la risorsa DBCluster rimane bloccata in una fase di rollback in corso o non riuscita.
Versioni interessate
AlloyDB Omni operator 1.0.0 e versioni successive.
Sintomi
Quando si verifica questo problema, potresti osservare i seguenti sintomi:
- Il campo
status.phasedella risorsaDBClusterrimane inDBClusterFailoverInProgress,DBClusterSwitchoverInProgress,DBClusterFailoverRollbackFailedoDBClusterSwitchoverRollbackFailed. - La condizione
HAReadysulla risorsaDBClusterhastatus: "False"con il motivoFailoverInProgressoSwitchoverInProgress. - La risorsa
Failover(failovers.alloydbomni.dbadmin.goog) oSwitchover(switchovers.alloydbomni.dbadmin.goog) è nello statoFailedoFailed_RollbackFailed. - Il campo
status.internal.phasedella risorsaFailoveroSwitchoverrimane in una fase precedente aPromoteStandby, ad esempioStopPrimary, o rimane nella fasePromoteStandbyper un'ora o più senza promuovere l'istanza in standby. - Il pod del database primario non riesce ad avviare PostgreSQL e registra un errore che indica che il file
PG_VERSIONnon è presente perchéPG_VERSIONè stato rinominato inPG_VERSION.disabledin/pgdata/db/PG_VERSION.disablede/pgdata/db/base/OID/PG_VERSION.disabled. Se un ripristino manuale precedente ha ripristinato solo il file
/pgdata/db/PG_VERSIONdi primo livello lasciando i filePG_VERSION.disablednelle sottodirectory/pgdata/db/base/OID/, le operazionipg_basebackupsuccessive sulle istanze in standby non vanno a buon fine con il seguente errore nei log di PostgreSQL sull'istanza principale:XX000:ERROR: [basebackup.c:1549] invalid segment number 0 in file "PG_VERSION.disabled"
Soluzione alternativa
Per rimuovere manualmente l'isolamento della precedente istanza principale e recuperare la risorsa DBCluster, completa i seguenti passaggi:
Esamina le risorse
FailoveroSwitchoveresterne e interne nello spazio dei nomi del cluster di database per controllare la loro fase e identificare le istanze principali (oldPrimary) e di standby di destinazione (newPrimary) precedenti:kubectl get failovers.alloydbomni.dbadmin.goog,switchovers.alloydbomni.dbadmin.goog,failovers.alloydbomni.internal.dbadmin.goog,instanceswitchovers.alloydbomni.internal.dbadmin.goog \ --namespace DB_CLUSTER_NAMESPACE \ -o yamlSostituisci
DB_CLUSTER_NAMESPACEcon lo spazio dei nomi della tua risorsaDBCluster.Verifica che
status.internal.phasenon abbia superatoPromoteStandby. Se il pod del database in standby è in esecuzione, verifica che PostgreSQL nell'istanza in standby sia ancora in modalità di recupero di sola lettura:kubectl exec -c database STANDBY_POD_NAME \ --namespace DB_CLUSTER_NAMESPACE -- \ psql -U alloydbadmin -d alloydbadmin -c "SELECT pg_is_in_recovery();"Sostituisci
STANDBY_POD_NAMEcon il nome del pod del database di standby, formattato comeal-STANDBY_INSTANCE_NAME-0, doveSTANDBY_INSTANCE_NAMEè il valore distatus.internal.newPrimary.Verifica che la query restituisca
t(true) o che il pod del database in standby sia arrestato. Dopo aver verificato che l'istanza in standby non è stata promossa, elimina la risorsaInstancein standby per evitare che venga promossa durante il recupero:kubectl delete instances.alloydbomni.internal.dbadmin.goog STANDBY_INSTANCE_NAME \ --namespace DB_CLUSTER_NAMESPACESostituisci
STANDBY_INSTANCE_NAMEcon il nome della risorsaInstancedi standby dal campostatus.internal.newPrimary.Controlla la directory di dati
/pgdata/dbnel pod del database primario per verificare la presenza dei filePG_VERSIONePG_VERSION.disabled:kubectl exec -c database PRIMARY_POD_NAME \ --namespace DB_CLUSTER_NAMESPACE -- \ find /pgdata/db -type f -name "PG_VERSION*"Sostituisci
PRIMARY_POD_NAMEcon il nome del pod del database primario, formattato comeal-PRIMARY_INSTANCE_NAME-0, dovePRIMARY_INSTANCE_NAMEè il valore distatus.internal.oldPrimary.Se né
PG_VERSIONnéPG_VERSION.disabledesistono in/pgdata/db, la directory di dati del database non è recuperabile e deve essere ripristinata da un backup.Se esistono file
PG_VERSION.disabled, ripristinaPG_VERSIONsia nella directory dei dati radice in/pgdata/db/PG_VERSION.disabledsia in ogni sottodirectory del database in/pgdata/db/base/OID/PG_VERSION.disabled. Il seguente comando rinomina ogni filePG_VERSION.disabledinPG_VERSIONo rimuove il filePG_VERSION.disabledse il filePG_VERSIONcorrispondente è già stato ripristinato:kubectl exec -c database PRIMARY_POD_NAME \ --namespace DB_CLUSTER_NAMESPACE -- \ sh -c 'find /pgdata/db -type f -name "PG_VERSION.disabled" | while read -r f; do target="${f%.disabled}" if [ -f "$target" ]; then rm -f "$f"; else mv "$f" "$target"; fi done'Riavvia il servizio PostgreSQL all'interno del pod del database primario:
kubectl exec -c database PRIMARY_POD_NAME \ --namespace DB_CLUSTER_NAMESPACE -- \ /scripts/supervisor/bin/supervisorctl.par \ -c /scripts/supervisor/etc/supervisord.conf restart postgresCancella lo stato di failover o di switchover non riuscito utilizzando una delle seguenti opzioni:
Opzione 1: elimina le risorse
FailoveroSwitchovere riavvia i controller dell'operatore. Elimina le risorseFailoveresterne e interne e riavvia i deploymentfleet-controller-managerelocal-controller-managernello spazio dei nomialloydb-omni-systemper rilasciare i blocchi in memoria:kubectl delete failovers.alloydbomni.dbadmin.goog FAILOVER_NAME \ --namespace DB_CLUSTER_NAMESPACE kubectl delete failovers.alloydbomni.internal.dbadmin.goog INTERNAL_FAILOVER_NAME \ --namespace DB_CLUSTER_NAMESPACE kubectl rollout restart deployment/fleet-controller-manager deployment/local-controller-manager \ --namespace alloydb-omni-systemSostituisci quanto segue:
FAILOVER_NAME: il nome della risorsafailovers.alloydbomni.dbadmin.goog.INTERNAL_FAILOVER_NAME: il nome della risorsafailovers.alloydbomni.internal.dbadmin.goog.
Se un'operazione di switchover è bloccata anziché un failover, elimina le risorse
switchovers.alloydbomni.dbadmin.googeinstanceswitchovers.alloydbomni.internal.dbadmin.goog.Opzione 2: contrassegna le risorse
Failovercome sottoposte a rollback. Questa opzione si applica solo alle risorseFailoverbloccate. Se una risorsaSwitchoverè bloccata, utilizza l'opzione 1. Modifica la risorsa secondariastatussia sulla risorsafailovers.alloydbomni.dbadmin.googsia sulla risorsafailovers.alloydbomni.internal.dbadmin.goog:kubectl edit failovers.alloydbomni.dbadmin.goog FAILOVER_NAME \ --namespace DB_CLUSTER_NAMESPACE \ --subresource=status kubectl edit failovers.alloydbomni.internal.dbadmin.goog INTERNAL_FAILOVER_NAME \ --namespace DB_CLUSTER_NAMESPACE \ --subresource=statusNella sezione
statusdi ogni risorsaFailover, impostaendTimesu un timestamp successivo acreateTime, impostainternal.phasesuRollbackSucceedede impostastatesuFailed, come mostrato nell'esempio seguente:apiVersion: alloydbomni.dbadmin.goog/v1 kind: Failover status: createTime: "2026-09-01T22:07:42Z" endTime: "2026-09-01T22:07:50Z" internal: attempt: 0 lastPhaseChangeTime: "2026-09-01T22:07:39Z" newPrimary: 4274-dbcluster-sample newPrimaryZone: "" oldPrimary: dafd-dbcluster-sample phase: RollbackSucceeded observedGeneration: 2 reconciled: true startTime: "2026-09-01T22:07:39Z" state: Failed
Aggiorna la risorsa secondaria
statusdella risorsaDBClusterper cancellarelatestFailoverStatuse impostaphasesuDBClusterReconciling:kubectl patch dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME \ --namespace DB_CLUSTER_NAMESPACE \ --subresource=status \ --type=merge \ --patch '{"status":{"latestFailoverStatus":null,"phase":"DBClusterReconciling"}}'Sostituisci
DB_CLUSTER_NAMEcon il nome della tua risorsaDBCluster.Se la condizione
HAReadyinstatus.conditionsimpedisce ancora la riconciliazione perché il camporeasonè impostato suFailoverInProgressoSwitchoverInProgress, modifica la sottorisorsastatusdella risorsaDBClustere rimuovi la voce della condizioneHAReadydastatus.conditionsin modo che l'operatore AlloyDB Omni la ricrei durante la riconciliazione oppure imposta il camporeasonsu un valoreCamelCasenon vuoto valido, ad esempioClusterReady:kubectl edit dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME \ --namespace DB_CLUSTER_NAMESPACE \ --subresource=statusVerifica che l'operatore AlloyDB Omni riconcili l'istanza in standby e restituisca la risorsa
DBClusteralla faseDBClusterReady:kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME \ --namespace DB_CLUSTER_NAMESPACE
Esegui il debug dei problemi di memoria
Queste sezioni descrivono come eseguire il debug dei problemi di memoria.
Esegui e acquisisci un heapdump
Attiva questa funzionalità solo per la risoluzione dei problemi. Ricorda di disattivarla al termine.
Per acquisire un heapdump, completa i seguenti passaggi:
- Modifica il deployment dell'operatore nello spazio dei nomi
alloydb-omni-systemcon il nomefleet-controller-managerelocal-controller-manager. - Aggiungi il seguente argomento al pod
--pprof-address=:8642o a qualsiasi altra porta disponibile. - Attendi il riavvio del pod del controller.
Esegui il port forwarding della porta precedente. Ad esempio:
kubectl port-forward FLEET_CONTROLLER_MANAGER_POD_NAME -n alloydb-omni-system 8642:8642In un altro terminale, esegui
go tool pprof http://localhost:8642/debug/pprof/heap. Se non utilizzi8642, modifica la porta in modo che corrisponda alla porta precedente.Connettiti all'indirizzo ed esegui i comandi per la risoluzione dei problemi. Ad esempio:
top.Al termine della risoluzione dei problemi, annulla il passaggio 1 rimuovendo l'argomento e attendendo il riavvio del pod.
Determina il numero di risorse controllate dall'operatore
Per comprendere le risorse in uso, esegui i seguenti comandi:
kubectl get backuprepositories -A | wc -l
kubectl get failovers -A | wc -l
kubectl get instancebackupplans -A | wc -l
kubectl get instancebackups -A | wc -l
kubectl get instancerestores -A | wc -l
kubectl get instances -A | wc -l
kubectl get instanceswitchovers -A | wc -l
kubectl get lrojobs -A | wc -l
kubectl get replicationconfigs -A | wc -l
kubectl get sidecars -A | wc -l
kubectl get deployments -A | wc -l
kubectl get statefulsets -A | wc -l
kubectl get certificates.cert-manager.io -A | wc -l
kubectl get issuers.cert-manager.io -A | wc -l
kubectl get configmaps -A | wc -l
kubectl get persistentvolumeclaims -A | wc -l
kubectl get persistentvolumes -A | wc -l
kubectl get pods -A | wc -l
kubectl get secrets -A | wc -l
kubectl get services -A | wc -l
kubectl get storageclasses.storage.k8s.io -A | wc -l
Ad esempio, se il numero di secret è elevato, può verificarsi un errore Out Of Memory (OOM).
kubectl get secrets -A | wc -l
Debug avanzato dell'HA
Questa sezione fa riferimento a risorse che sono implementazioni interne. Questi sono soggetti a modifiche in qualsiasi momento e non hanno impegni di compatibilità con le versioni precedenti. Applica correzioni manuali solo ai problemi relativi ai database non di produzione. Questi passaggi potrebbero rendere il database non recuperabile.
La configurazione dell'alta affidabilità di AlloyDB Omni prevede tre fasi:
- Configura l'istanza principale in modo che riceva una connessione dall'istanza in standby.
- Inizializza l'istanza in standby e connettila a quella principale.
- Configura le impostazioni principali per rendere sincrona la connessione.
Il passaggio 2 è in genere il più lento. A seconda delle dimensioni del database, l'operazione potrebbe richiedere diverse ore.
A ogni istanza di replica deve essere collegato un replicationconfig. Ad esempio:
kubectl get replicationconfigs.alloydbomni.internal.dbadmin.goog -n DB_CLUSTER_NAMESPACE
Output di esempio:
NAME PARENT TYPE ROLE READY HEALTHY SYNC_U SYNC_D SLOT_LOG SLOT_REPLAY
cd58-adb--58ea-adb cd58-adb Physical Upstream True True true
ds-58ea-adb 58ea-adb Physical Downstream True True true
La specifica della configurazione di replica indica le impostazioni previste, mentre lo stato riflette lo stato effettivo letto dal database. Se esiste una mancata corrispondenza tra la specifica e lo stato, il controller sta ancora tentando di applicare la modifica o si è verificato un errore che impedisce l'applicazione della modifica. Questo verrà indicato nei campi di stato.
Job in standby
Dovrebbero essere presenti due set di job interni che monitorano il workflow di un nodo in standby:
createstandbyjobs.alloydbomni.internal.dbadmin.googdeletestandbyjobs.alloydbomni.internal.dbadmin.goog
Se la configurazione sembra bloccata, visualizza i job relativi al cluster di database (DBC). Il job potrebbe contenere messaggi di errore che spiegano lo stato della configurazione. I job vengono eliminati automaticamente un po' di tempo dopo il loro completamento, quindi potresti non visualizzare alcun job se non ce ne sono in corso.
kubectl get createstandbyjobs.alloydbomni.internal.dbadmin.goog -n DB_CLUSTER_NAMESPACE
L'output è simile al seguente:
apiVersion: alloydbomni.dbadmin.gdc.goog/v1
kind: CreateStandbyJob
metadata:
creationTimestamp: "2024-11-05T03:34:26Z"
finalizers:
- createstandbyjob.dbadmin.goog/finalizer
generation: 1804
labels:
dbs.internal.dbadmin.goog/dbc: foo-ha-alloydb1-clone1
name: foo-ha-alloydb1-clone1--ac00-foo-ha-alloydb1-clone1--6036-foo-ha-alloydb1-clone1-1730777666
namespace: db
resourceVersion: "11819071"
uid: 1f24cedf-b326-422f-9405-c96c8720cd90
spec:
attempt: 3
cleanup: false
currentStep: SetupSynchronous
currentStepTime: "2024-11-05T03:45:31Z"
metadata:
dbc: foo-ha-alloydb1-clone1
primaryInstance: ac00-foo-ha-alloydb1-clone1
retryError: 'etcdserver: leader changed'
standbyInstance: 6036-foo-ha-alloydb1-clone1
requeueTime: "2024-11-05T18:33:03Z"
startTime: "2024-11-05T03:36:56Z"
Verifica principale
La prima cosa da verificare è che l'istanza principale sia configurata correttamente. Deve essere presente un profilo di replica per ogni standby. Se isSynchronous è true nella specifica e nello stato, la configurazione dovrebbe essere completata. Se isSynchronous è false nella specifica e nello stato, non ha ancora raggiunto il passaggio 3. Visualizza i job in standby per verificare se sono presenti job in esecuzione e se sono presenti messaggi di errore.
replication:
profiles:
- isActive: true
isSynchronous: true
name: ha:4c82-dbcluster-sample::d85d-dbcluster-sample
password:
name: ha-rep-pw-dbcluster-sample
namespace: default
passwordResourceVersion: "896080"
role: Upstream
type: Physical
username: alloydbreplica
Verifica che l'annotazione disableHealthcheck sia false. Deve essere disattivato solo durante un failover o uno switchover.
apiVersion: alloydbomni.internal.dbadmin.goog/v1
kind: Instance
metadata:
annotations:
dbs.internal.dbadmin.goog/consecutiveHealthcheckFailures: "0"
dbs.internal.dbadmin.goog/disableHealthcheck: "false"
dr-secondary: "false"
forceReconcile: "1730414498"
Query
Per verificare che le risorse sul pod del database siano configurate correttamente, accedi al database come utente amministratore alloydbadmin. Quindi esegui le seguenti query:
Slot di replica
\x on
select * from pg_replication_slots;
-[ RECORD 1 ]-------+---------------------------------------------
slot_name | d85d_dbcluster_sample
plugin |
slot_type | physical
datoid |
database |
temporary | f
active | t
active_pid | 250
xmin | 16318
catalog_xmin |
restart_lsn | 0/CA657F0
confirmed_flush_lsn |
wal_status | reserved
safe_wal_size |
two_phase | f
Uno stato corretto è la presenza di uno slot di replica con lo stesso nome dell'istanza in standby. L'assenza di uno slot di replica indica che il primo passaggio della configurazione non è stato completato correttamente.
Se active non è t (true), significa che lo standby non si connette per qualche motivo (networking, standby che non termina la configurazione e così via) e il debug probabilmente dovrà continuare sul lato standby.
Statistiche di replica
\x on
select * from pg_stat_replication;
-[ RECORD 1 ]----+----------------------------------------------------------------
pid | 250
usesysid | 16385
usename | alloydbreplica
application_name | d85d_dbcluster_sample
client_addr | 10.54.79.196
client_hostname | gke-samwise-default-pool-afaf152d-8197.us-central1-a.c.foo
client_port | 24914
backend_start | 2024-10-30 21:44:26.408261+00
backend_xmin |
state | streaming
sent_lsn | 0/CA64DA8
write_lsn | 0/CA64DA8
flush_lsn | 0/CA64DA8
replay_lsn | 0/CA64DA8
write_lag |
flush_lag |
replay_lag |
sync_priority | 2
sync_state | sync
reply_time | 2024-11-04 22:08:04.370838+00
Se non esiste, significa che non è presente una connessione attiva. sync_state deve essere sync. Se non è sync, significa che il passaggio finale della configurazione non è stato completato. L'esame dei log/job dovrebbe fornire ulteriori dettagli.
Verifica in standby
La replica in standby deve avere un profilo di replica che corrisponda allo stesso profilo della replica principale:
replication:
profiles:
- host: 10.54.79.210
isActive: true
isSynchronous: true
name: ha:4c82-dbcluster-sample::d85d-dbcluster-sample
passwordResourceVersion: "896080"
port: 5432
role: Downstream
type: Physical
username: alloydbreplica
Se non esiste una connessione dall'istanza in standby a quella principale, esistono due possibilità comuni:
- La configurazione dello standby è ancora in corso.
- L'unità in standby riceve un errore durante la configurazione o il tentativo di connessione.
Per verificare se si sta verificando l'opzione 1, recupera i log dei pod del database e cerca le istruzioni di log denominate dbdaemon/setupPhysicalReplicationDownstream. Di seguito
sono riportati esempi di log di configurazione riusciti:
I1104 22:42:42.604871 103 replication.go:107] "dbdaemon/setupPhysicalReplicationDownstream: begin setup" log_name="agent" project_ns="default" dbcluster="dbcluster-sample"
2024-11-04 22:42:42,605 INFO waiting for postgres to stop
2024-11-04 22:42:43,566 INFO stopped: postgres (exit status 0)
I1104 22:42:43.567590 103 replication.go:131] "dbdaemon/setupPhysicalReplicationDownstream: about to call pg_basebackup" log_name="agent" project_ns="default" dbcluster="dbcluster-sample" cmd=["-h","10.54.79.210","-D","/mnt/disks/pgsql/pg_basebackup_data","-U","alloydbreplica","-v","-P","-p","5432","-w","-c","fast"]
I1104 22:42:44.206403 103 replication.go:139] "dbdaemon/setupPhysicalReplicationDownstream: pg_basebackup finished" log_name="agent" project_ns="default" dbcluster="dbcluster-sample"
I1104 22:42:44.206440 103 replication.go:141] "dbdaemon/setupPhysicalReplicationDownstream: replacing data directory with pg_basebackup data directory" log_name="agent" project_ns="default" dbcluster="dbcluster-sample"
I1104 22:42:44.244749 103 replication.go:148] "dbdaemon/setupPhysicalReplicationDownstream: replaced data directory with pg_basebackup data directory" log_name="agent" project_ns="default" dbcluster="dbcluster-sample"
I1104 22:42:44.244783 103 replication.go:150] "dbdaemon/setupPhysicalReplicationDownstream: Creating config files" log_name="agent" project_ns="default" dbcluster="dbcluster-sample"
I1104 22:42:44.251565 103 replication.go:155] "dbdaemon/setupPhysicalReplicationDownstream: removing postgresql config file for log archiving" log_name="agent" project_ns="default" dbcluster="dbcluster-sample"
I1104 22:42:44.251621 103 replication.go:160] "dbdaemon/setupPhysicalReplicationDownstream: removing postgresql auto config file" log_name="agent" project_ns="default" dbcluster="dbcluster-sample"
I1104 22:42:44.251689 103 replication.go:165] "dbdaemon/setupPhysicalReplicationDownstream: Successfully wrote to config file" log_name="agent" project_ns="default" dbcluster="dbcluster-sample"
2024-11-04 22:42:44,256 INFO spawned: 'postgres' with pid 271
2024-11-04 22:42:45,469 INFO success: postgres entered RUNNING state, process has stayed up for > than 1 seconds (startsecs)
I1104 22:42:45.469838 103 replication.go:174] "dbdaemon/setupPhysicalReplicationDownstream: backup replication configuration after changing replication config" log_name="agent" project_ns="default" dbcluster="dbcluster-sample"
I1104 22:42:45.476732 103 replication.go:179] "dbdaemon/setupPhysicalReplicationDownstream: finished standby setup" log_name="agent" project_ns="default" dbcluster="dbcluster-sample"
Se si verifica un errore di connessione, controlla i log del pod del database e il file di log del database in /obs/diagnostic/postgresql.log per vedere qual è l'errore durante il tentativo di connessione. Un errore comune è l'assenza di connettività di rete tra l'istanza di standby e quella principale.
Correzioni manuali
Il modo più semplice per risolvere i problemi di alta affidabilità è disattivare e riattivare l'alta affidabilità impostando
numberOfStandbys su 0 e poi reimpostandolo sul numero che preferisci. Se gli standby sono bloccati e disattivati, segui questi passaggi per reimpostare manualmente la configurazione HA in modo che sia vuota:
- Elimina manualmente le istanze in standby.
Connettiti al database primario. Esegui una query sugli slot di replica attuali ed elimina gli slot di replica degli standby che vuoi eliminare:
select pg_drop_replication_slot('REPLICATION_SLOT_NAME');Elimina tutti i profili di replica dall'istanza principale che vuoi eliminare.
Se un'istanza non è stata riconciliata di recente, puoi modificare il valore dell'annotazione forceReconcile. Impostalo su un valore numerico, che corrisponde al timestamp dell'ultimo aggiornamento dell'annotazione. L'unico scopo di questa annotazione è fornire un campo che possiamo aggiornare per forzare una nuova riconciliazione.
apiVersion: alloydbomni.internal.dbadmin.goog/v1
kind: Instance
metadata:
annotations:
dbs.internal.dbadmin.goog/consecutiveHealthcheckFailures: "0"
dbs.internal.dbadmin.goog/disableHealthcheck: "false"
dr-secondary: "false"
forceReconcile: "1730414498"
Se una risorsa DBCluster rimane bloccata in DBClusterFailoverInProgress, DBClusterSwitchoverInProgress, DBClusterFailoverRollbackFailed o DBClusterSwitchoverRollbackFailed perché l'istanza principale è isolata con file PG_VERSION.disabled, consulta Il cluster di database rimane bloccato in uno stato di failover o switchover.
Raccogli i log del motore del database e di controllo
I log del motore del database e gli audit log sono disponibili come file all'interno del pod del database (richiedono l'accesso root):
obs/diagnostic/postgresql.logobs/diagnostic/postgresql.audit
DB_POD=$(kubectl get pod -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME,alloydbomni.internal.dbadmin.goog/task-type=database -n DB_CLUSTER_NAMESPACE -o jsonpath='{.items[0].metadata.name}')
kubectl exec -c database -n DB_CLUSTER_NAMESPACE ${DB_POD} -it -- /bin/bash
Quando è connesso al container del database:
ls -l /obs/diagnostic/
Output di esempio:
drwx--S--- 2 postgres postgres 4096 Aug 13 10:22 archive
-rw------- 1 postgres postgres 256050 Aug 13 13:25 postgresql.internal
-rw------- 1 postgres postgres 1594799 Aug 13 13:25 postgresql.log
Raccogli le metriche del database e dei pod del database
L'operatore AlloyDB Omni fornisce un insieme di metriche di base per il motore AlloyDB Omni e il pod che lo ospita. Le metriche sono disponibili come endpoint Prometheus sulla porta 9187. Per accedere agli endpoint, devi identificare il nome del pod per il pod del database utilizzando l'etichetta DBCluster e avviare il port forwarding come segue:
DB_POD=$(kubectl get pod -l alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o jsonpath='{.items[0].metadata.name}')
kubectl port-forward -n DB_CLUSTER_NAMESPACE ${DB_POD} 9187:9187
Accedi alle metriche dei pod del database
In un altro terminale:
curl http://localhost:9187/metrics | grep HELP
Per ulteriori informazioni sul monitoraggio, consulta Monitora AlloyDB Omni.
Puoi anche configurare Prometheus per estrarre le metriche nel tuo cluster Kubernetes. Per i dettagli, consulta la configurazione di Service Discovery di Prometheus Kubernetes.