Collecter des informations de débogage
Ces sections expliquent comment collecter les journaux et les configurations pour le débogage.
Récupérer les journaux des pods d'opérateur
Pour récupérer les journaux des pods de l'opérateur, exécutez les commandes suivantes :
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
Récupérer les journaux des pods de base de données
Pour récupérer les journaux du pod de base de données, exécutez les commandes suivantes :
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
Les journaux suivants sont des exemples de vérifications de l'état de la base de données réussies :
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"
Récupérer le fichier postgresql.log
Pour récupérer le postgresql.log, exécutez la commande suivante :
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
Récupérer le fichier YAML DBInstance
Pour récupérer le fichier YAML DBInstance, exécutez la commande suivante :
kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o yaml > dbcluster_DB_CLUSTER_NAME.yaml
Récupérer les configurations et les journaux pour les scénarios de haute disponibilité
Pour récupérer les configurations et les journaux spécifiques aux scénarios de haute disponibilité, exécutez les commandes suivantes :
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
Récupérer l'état des pods et des STS
Pour récupérer les états des pods et des StatefulSets (STS), exécutez les commandes suivantes :
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
Identifier les erreurs
Ces sections expliquent comment identifier les erreurs.
Rechercher les états et les codes d'erreur
Pour identifier le code d'erreur, vérifiez le fichier YAML du DBCluster sous l'état. Pour en savoir plus, consultez la documentation sur les codes d'erreur.
Pour récupérer le fichier YAML DBCluster, exécutez la commande suivante :
kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o yaml > dbcluster_DB_CLUSTER_NAME.yaml
Recherchez criticalIncidents. Cette section contient le code d'erreur et une trace de la pile.
Voici des exemples de 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'
Vous pouvez également récupérer l'état en extrayant des champs spécifiques au format JSON :
kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o jsonpath='{.status.criticalIncidents}' | jq
Le résultat ressemble à ce qui suit :
[
{
"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"
}
]
}
]
Si le message d'erreur fait référence au pod de base de données, vérifiez les instances et les ressources de pod dans le même espace de noms :
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
Problèmes connus
Cette section décrit les problèmes connus et les solutions de contournement pour l'opérateur AlloyDB Omni. Pour obtenir la liste complète des annonces de versions, des corrections de bugs et des mises à jour de sécurité, consultez les notes de version.
Échec de l'émission du certificat dans cert-manager
L'opérateur AlloyDB Omni utilise cert-manager pour provisionner des certificats TLS (Transport Layer Security) pour l'opérateur et les clusters de bases de données. Dans la version 1.21.2 et les versions antérieures de cert-manager, une condition de concurrence connue (problème cert-manager n° 6331) peut entraîner l'échec de l'émission du certificat et l'activation d'un intervalle de nouvelle tentative d'une heure.
Versions affectées
Opérateur AlloyDB Omni 1.0.0 et versions ultérieures avec cert-manager 1.21.2 et versions antérieures.
Symptômes
Lorsque ce problème se produit, vous pouvez observer les symptômes suivants :
- Une ressource
DBClusterreste dans la phaseDBClusterWaitingForCertificate, et la création ou la mise à niveau du cluster de base de données expire. - Une installation Helm de l'opérateur AlloyDB Omni échoue, car une ressource
Certificate, telle quelocal-serving-certdans l'espace de nomsalloydb-omni-system, n'est pas prête. - Les conditions d'état d'une ressource
Certificateincluent le messageCSR not signed by referenced private keyavec le motifFailedouErrorKeyMatch.
Pour trouver les ressources Certificate concernées par ce problème, exécutez la commande suivante :
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"
Le résultat liste l'espace de noms, le nom et les messages de condition d'état de chaque ressource Certificate concernée. Si vous affichez une ressource Certificate concernée au format YAML, son champ status est semblable à ce qui suit :
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
Solution
Pour éviter les conflits de mise à jour du contrôleur et réduire le délai avant nouvelle tentative pour les demandes de certificat ayant échoué de une heure à 15 secondes, mettez à niveau cert-manager avec la feature gate ServerSideApply et des durées d'intervalle entre les tentatives réduites :
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}"
Remplacez les éléments suivants :
CERT_MANAGER_VERSION: version decert-managerinstallée dans votre cluster Kubernetes, par exemplev1.21.2. Pour trouver la version installée, exécutez la commandehelm list --namespace cert-manager.
Une fois le contrôleur cert-manager redémarré, vérifiez que tous les certificats affichent True dans la colonne READY :
kubectl get certificates.cert-manager.io --all-namespaces
Si l'installation de l'opérateur AlloyDB Omni a échoué en raison de ce problème, relancez l'installation.
La mise à niveau de la version mineure avec maintenance à temps d'arrêt réduit s'arrête sur un cluster de bases de données secondaire
Versions affectées
Opérateur AlloyDB Omni 1.8.0 et versions ultérieures.
Symptômes
Lors d'une mise à niveau ou d'un passage à une version mineure antérieure d'un cluster de base de données secondaire de réplication entre centres de données doté d'instances de secours à haute disponibilité (HA), l'opération s'arrête après la mise à niveau de la première instance de secours. La ressource DBCluster reste à l'état DBCUpgradeInProgress=True avec le motif DBCUpgradeFlowBegins.
Solution
Désactivez la maintenance à faible temps d'arrêt (LDTM) sur le cluster de bases de données secondaire afin que l'opérateur AlloyDB Omni effectue la mise à niveau à l'aide du workflow de mise à niveau progressive standard :
kubectl annotate dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME \ dbcluster.dbadmin.goog/enableLDTM=false \ --namespace DB_CLUSTER_NAMESPACE \ --overwriteRemplacez les éléments suivants :
DB_CLUSTER_NAME: nom de votre ressourceDBClustersecondaire.DB_CLUSTER_NAMESPACE: espace de noms de votre ressourceDBClustersecondaire.
Vérifiez que la mise à niveau est terminée et que la ressource
DBClusteratteint la phaseDBClusterReady:kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME \ --namespace DB_CLUSTER_NAMESPACERéactivez la maintenance avec des temps d'arrêt réduits sur le cluster de bases de données secondaire afin que la ressource
DBClusterconserve la capacité de maintenance avec des temps d'arrêt réduits si elle est promue en cluster de bases de données principal :kubectl annotate dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME \ dbcluster.dbadmin.goog/enableLDTM=true \ --namespace DB_CLUSTER_NAMESPACE \ --overwrite
L'agent Monitoring rencontre des erreurs d'autorisation cgroups après l'activation de la réplication entre centres de données
Versions affectées
Opérateur AlloyDB Omni 1.9.0.
Symptômes
Après avoir activé la réplication entre centres de données, l'agent de surveillance rencontre des erreurs d'autorisation dans les journaux du conteneur lorsqu'il tente de collecter des informations cgroups.
Solution
Répertoriez les pods de base de données de votre cluster de base de données secondaire pour trouver le nom du pod de base de données en aval :
kubectl get pods \ --selector alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME,alloydbomni.internal.dbadmin.goog/task-type=database \ --namespace DB_CLUSTER_NAMESPACERemplacez les éléments suivants :
DB_CLUSTER_NAME: nom de votre ressourceDBClustersecondaire.DB_CLUSTER_NAMESPACE: espace de noms de votre ressourceDBClustersecondaire.
Supprimez le pod de la base de données en aval pour que l'opérateur AlloyDB Omni recrée et redémarre le pod :
kubectl delete pod DB_POD_NAME \ --namespace DB_CLUSTER_NAMESPACERemplacez
DB_POD_NAMEpar le nom du pod de base de données en aval obtenu à l'étape précédente.
Le cluster de bases de données déclenche continuellement des basculements automatiques
Si votre ressource DBCluster crée plusieurs basculements automatiques l'un après l'autre, effectuez les vérifications suivantes :
Répertoriez les ressources
Failoverde votreDBClusteret comparez leurs codes temporels de création :kubectl get failover.alloydbomni.dbadmin.goog \ --selector failover.dbadmin.goog/dbcluster=DB_CLUSTER_NAME \ --namespace DB_CLUSTER_NAMESPACERemplacez les éléments suivants :
DB_CLUSTER_NAME: nom de votre ressourceDBClusterDB_CLUSTER_NAMESPACE: espace de noms de votre ressourceDBCluster.
Connectez-vous au pod de la base de données principale sur la base de données
alloydbadminet vérifiez l'état de la base de données :SELECT * FROM healthcheck;Vérifiez que l'horodatage de la dernière vérification de l'état d'état est récent et que les vérifications d'état sont exécutées aux intervalles prévus. Si l'instance principale n'est pas opérationnelle, inspectez le fichier
postgresql.logpour déterminer la cause de la défaillance de l'instance. Pour en savoir plus sur la récupération des journaux, consultez Résoudre les problèmes liés à l'opérateur Kubernetes AlloyDB Omni.
Si vous utilisez un grand nombre de clusters de bases de données dans un seul cluster Kubernetes, ou si vous avez des clusters de bases de données sous-provisionnés, les vérifications d'état du basculement automatique peuvent expirer ou échouer. Si vous recevez une erreur commençant par HealthCheckProber: health check for instance failed, consultez les corrections recommandées dans Résoudre les problèmes de réparation d'instance.
Pour réduire ou empêcher les basculements automatiques, vous pouvez également effectuer les actions suivantes :
Augmentez la valeur
autoFailoverTriggerThresholdpour que le basculement automatique se produise moins fréquemment. Pour en savoir plus, consultez Ajuster les paramètres de déclenchement du basculement automatique.Désactivez le basculement automatique sur les clusters de bases de données. Pour en savoir plus, consultez Désactiver le basculement automatique.
Le cluster de bases de données reste bloqué dans un état de basculement ou de commutation
Lors d'un basculement ou d'une commutation de haute disponibilité, l'opérateur AlloyDB Omni isole l'ancienne instance principale pendant la phase StopPrimary en renommant les fichiers PG_VERSION en PG_VERSION.disabled à la fois dans le répertoire de données racine (/pgdata/db/PG_VERSION.disabled) et dans chaque sous-répertoire de base de données (/pgdata/db/base/OID/PG_VERSION.disabled). Si le basculement ou la commutation échoue avant que l'instance de secours ne soit promue et que le rollback automatique n'a pas lieu ou échoue, l'ancienne instance principale reste isolée et la ressource DBCluster reste bloquée dans une phase de rollback en cours ou ayant échoué.
Versions affectées
Opérateur AlloyDB Omni 1.0.0 et versions ultérieures.
Symptômes
Lorsque ce problème se produit, vous pouvez observer les symptômes suivants :
- Le champ
status.phasede la ressourceDBClusterreste dans l'étatDBClusterFailoverInProgress,DBClusterSwitchoverInProgress,DBClusterFailoverRollbackFailedouDBClusterSwitchoverRollbackFailed. - La condition
HAReadysur la ressourceDBClustera la valeurstatus: "False"avec le motifFailoverInProgressouSwitchoverInProgress. - La ressource
Failover(failovers.alloydbomni.dbadmin.goog) ouSwitchover(switchovers.alloydbomni.dbadmin.goog) est à l'étatFailedouFailed_RollbackFailed. - Le champ
status.internal.phasede la ressourceFailoverouSwitchoverreste dans une phase antérieure àPromoteStandby, telle queStopPrimary, ou reste dans la phasePromoteStandbypendant une heure ou plus sans promouvoir l'instance de secours. - Le pod de la base de données principale ne parvient pas à démarrer PostgreSQL et consigne une erreur indiquant que le fichier
PG_VERSIONest manquant, carPG_VERSIONa été renomméPG_VERSION.disableddans/pgdata/db/PG_VERSION.disabledet/pgdata/db/base/OID/PG_VERSION.disabled. Si une récupération manuelle précédente n'a restauré que le fichier
/pgdata/db/PG_VERSIONde niveau supérieur tout en laissant les fichiersPG_VERSION.disableddans les sous-répertoires/pgdata/db/base/OID/, les opérationspg_basebackupultérieures sur les instances de secours échouent avec l'erreur suivante dans les journaux PostgreSQL de l'instance principale :XX000:ERROR: [basebackup.c:1549] invalid segment number 0 in file "PG_VERSION.disabled"
Solution
Pour annuler manuellement le cloisonnement de l'ancienne instance principale et récupérer la ressource DBCluster, procédez comme suit :
Inspectez les ressources
FailoverouSwitchoverexternes et internes dans l'espace de noms de votre cluster de bases de données pour vérifier leur phase et identifier l'ancienne instance principale (oldPrimary) et l'instance de secours cible (newPrimary) :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 yamlRemplacez
DB_CLUSTER_NAMESPACEpar l'espace de noms de votre ressourceDBCluster.Vérifiez que
status.internal.phasen'a pas dépasséPromoteStandby. Si le pod de la base de données de secours est en cours d'exécution, vérifiez que PostgreSQL sur l'instance de secours est toujours en mode de récupération en lecture seule :kubectl exec -c database STANDBY_POD_NAME \ --namespace DB_CLUSTER_NAMESPACE -- \ psql -U alloydbadmin -d alloydbadmin -c "SELECT pg_is_in_recovery();"Remplacez
STANDBY_POD_NAMEpar le nom du pod de base de données de secours, au formatal-STANDBY_INSTANCE_NAME-0, oùSTANDBY_INSTANCE_NAMEest la valeur destatus.internal.newPrimary.Vérifiez que la requête renvoie
t(true) ou que le pod de la base de données de secours est arrêté. Après avoir vérifié que l'instance de secours n'a pas été promue, supprimez la ressourceInstancede secours pour l'empêcher d'être promue pendant la récupération :kubectl delete instances.alloydbomni.internal.dbadmin.goog STANDBY_INSTANCE_NAME \ --namespace DB_CLUSTER_NAMESPACERemplacez
STANDBY_INSTANCE_NAMEpar le nom de la ressourceInstancede secours du champstatus.internal.newPrimary.Vérifiez le répertoire de données
/pgdata/dbsur le pod de la base de données principale pour les fichiersPG_VERSIONetPG_VERSION.disabled:kubectl exec -c database PRIMARY_POD_NAME \ --namespace DB_CLUSTER_NAMESPACE -- \ find /pgdata/db -type f -name "PG_VERSION*"Remplacez
PRIMARY_POD_NAMEpar le nom du pod de base de données principal, au formatal-PRIMARY_INSTANCE_NAME-0, oùPRIMARY_INSTANCE_NAMEest la valeur destatus.internal.oldPrimary.Si ni
PG_VERSIONniPG_VERSION.disabledn'existent dans/pgdata/db, le répertoire de données de la base de données n'est pas récupérable et doit être restauré à partir d'une sauvegarde.Si des fichiers
PG_VERSION.disabledexistent, restaurezPG_VERSIONdans le répertoire de données racine à l'emplacement/pgdata/db/PG_VERSION.disabledet dans chaque sous-répertoire de base de données à l'emplacement/pgdata/db/base/OID/PG_VERSION.disabled. La commande suivante renomme chaque fichierPG_VERSION.disabledenPG_VERSIONou supprime le fichierPG_VERSION.disabledsi le fichierPG_VERSIONcorrespondant a déjà été restauré :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'Redémarrez le service PostgreSQL dans le pod de la base de données principale :
kubectl exec -c database PRIMARY_POD_NAME \ --namespace DB_CLUSTER_NAMESPACE -- \ /scripts/supervisor/bin/supervisorctl.par \ -c /scripts/supervisor/etc/supervisord.conf restart postgresEffacez l'état d'échec du basculement ou de la commutation à l'aide de l'une des options suivantes :
Option 1 : Supprimez les ressources
FailoverouSwitchover, puis redémarrez les contrôleurs de l'opérateur. Supprimez les ressourcesFailoverexternes et internes, puis redémarrez les déploiementsfleet-controller-manageretlocal-controller-managerdans l'espace de nomsalloydb-omni-systempour libérer les verrous en mémoire :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-systemRemplacez les éléments suivants :
FAILOVER_NAME: nom de la ressourcefailovers.alloydbomni.dbadmin.goog.INTERNAL_FAILOVER_NAME: nom de la ressourcefailovers.alloydbomni.internal.dbadmin.goog.
Si une commutation est bloquée au lieu d'un basculement, supprimez plutôt les ressources
switchovers.alloydbomni.dbadmin.googetinstanceswitchovers.alloydbomni.internal.dbadmin.goog.Option 2 : Marquer les ressources
Failovercomme ayant fait l'objet d'un rollback. Cette option ne s'applique qu'aux ressourcesFailoverbloquées. Si une ressourceSwitchoverest bloquée, utilisez plutôt l'option 1. Modifiez la sous-ressourcestatussur les ressourcesfailovers.alloydbomni.dbadmin.googetfailovers.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=statusDans la section
statusde chaque ressourceFailover, définissezendTimesur un code temporel postérieur àcreateTime, définissezinternal.phasesurRollbackSucceededet définissezstatesurFailed, comme illustré dans l'exemple suivant :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
Mettez à jour la sous-ressource
statusde la ressourceDBClusterpour effacerlatestFailoverStatuset définissezphasesurDBClusterReconciling:kubectl patch dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME \ --namespace DB_CLUSTER_NAMESPACE \ --subresource=status \ --type=merge \ --patch '{"status":{"latestFailoverStatus":null,"phase":"DBClusterReconciling"}}'Remplacez
DB_CLUSTER_NAMEpar le nom de votre ressourceDBCluster.Si la condition
HAReadydansstatus.conditionsempêche toujours le rapprochement, car son champreasonest défini surFailoverInProgressouSwitchoverInProgress, modifiez la sous-ressourcestatusde la ressourceDBClusteret supprimez l'entrée de conditionHAReadydestatus.conditionsafin que l'opérateur AlloyDB Omni la recrée lors du rapprochement, ou définissez son champreasonsur une valeurCamelCasenon vide valide, telle queClusterReady:kubectl edit dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME \ --namespace DB_CLUSTER_NAMESPACE \ --subresource=statusVérifiez que l'opérateur AlloyDB Omni rapproche l'instance de secours et renvoie la ressource
DBClusterà la phaseDBClusterReady:kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME \ --namespace DB_CLUSTER_NAMESPACE
Déboguer les problèmes de mémoire
Ces sections expliquent comment déboguer les problèmes de mémoire.
Exécuter et effectuer un heapdump
N'activez cette fonctionnalité que pour résoudre des problèmes. N'oubliez pas de le désactiver par la suite.
Pour effectuer un vidage de tas de mémoire, procédez comme suit :
- Modifiez le déploiement de l'opérateur sous l'espace de noms
alloydb-omni-systemavec les nomsfleet-controller-manageretlocal-controller-manager. - Ajoutez l'argument suivant au pod
--pprof-address=:8642ou à tout autre port disponible. - Attendez que le pod du contrôleur redémarre.
Transférez le port précédent. Exemple :
kubectl port-forward FLEET_CONTROLLER_MANAGER_POD_NAME -n alloydb-omni-system 8642:8642Dans un autre terminal, exécutez
go tool pprof http://localhost:8642/debug/pprof/heap. Si vous n'utilisez pas8642, modifiez le port pour qu'il corresponde au port précédent.Connectez-vous à l'adresse et exécutez les commandes de dépannage. Exemple :
top.Une fois le dépannage terminé, annulez l'étape 1 en supprimant l'argument et en attendant que le pod redémarre.
Déterminer le nombre de ressources surveillées par l'opérateur
Pour comprendre les ressources utilisées, exécutez les commandes suivantes :
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
Par exemple, si le nombre de secrets est élevé, cela peut entraîner une erreur de mémoire insuffisante (OOM).
kubectl get secrets -A | wc -l
Débogage HA avancé
Cette section fait référence à des ressources qui sont des implémentations internes. Elles sont susceptibles d'être modifiées à tout moment et ne sont pas soumises à des engagements de rétrocompatibilité. N'appliquez des corrections manuelles qu'aux problèmes survenant sur des bases de données hors production. Ces étapes peuvent rendre la base de données irrécupérable.
La configuration de la haute disponibilité AlloyDB Omni comporte trois phases :
- Configurez l'instance principale pour qu'elle reçoive une connexion de l'instance de secours.
- Initialisez l'instance de secours et connectez-la à l'instance principale.
- Définissez les paramètres principaux pour rendre la connexion synchrone.
L'étape 2 est généralement la plus lente. Selon la taille de la base de données, cela peut prendre plusieurs heures.
Chaque instance répliquée doit être associée à un replicationconfig. Exemple :
kubectl get replicationconfigs.alloydbomni.internal.dbadmin.goog -n DB_CLUSTER_NAMESPACE
Exemple de résultat :
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 spécification de ReplicationConfig indique les paramètres prévus, tandis que l'état reflète l'état réel tel qu'il est lu à partir de la base de données. En cas de non-concordance entre la spécification et l'état, le contrôleur tente toujours d'appliquer la modification, ou une erreur empêche l'application de la modification. Cela se refléterait dans les champs d'état.
Jobs en attente
Deux ensembles de jobs internes doivent suivre le workflow d'un serveur de secours :
createstandbyjobs.alloydbomni.internal.dbadmin.googdeletestandbyjobs.alloydbomni.internal.dbadmin.goog
Si la configuration semble bloquée, affichez les jobs liés au cluster de base de données (DBC). Le job peut comporter des messages d'erreur qui expliquent l'état de la configuration. Les jobs sont automatiquement nettoyés un certain temps après leur exécution. Par conséquent, il est possible que vous ne voyiez aucun job si aucun n'est en cours.
kubectl get createstandbyjobs.alloydbomni.internal.dbadmin.goog -n DB_CLUSTER_NAMESPACE
Le résultat ressemble à ce qui suit :
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"
Validation principale
La première chose à vérifier est que l'instance principale est correctement configurée. Il doit y avoir un profil de réplication pour chaque instance de secours. Si isSynchronous est défini sur "true" dans la spécification et l'état, la configuration doit être terminée. Si isSynchronous est défini sur "false" dans la spécification et l'état, l'étape 3 n'a pas encore été atteinte. Affichez les jobs de secours pour voir s'il y a des jobs en cours d'exécution et s'ils comportent des messages d'erreur.
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
Vérifiez que l'annotation disableHealthcheck est définie sur "false". Il n'est censé être désactivé que lors d'un basculement ou d'une commutation.
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"
Requêtes
Pour vérifier que les ressources du pod de base de données sont correctement configurées, connectez-vous à la base de données en tant qu'administrateur alloydbadmin. Exécutez ensuite les requêtes suivantes :
Emplacement de réplication
\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
Un bon état est la présence d'un emplacement de réplication portant le même nom que l'instance de secours. L'absence d'un emplacement de réplication indique que la première étape de configuration n'a pas abouti.
Si active n'est pas t (vrai), cela signifie que l'instance de secours ne se connecte pas pour une raison quelconque (mise en réseau, instance de secours ne terminant pas la configuration, etc.) et que le débogage devra probablement se poursuivre du côté de l'instance de secours.
Statistiques de réplication
\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
Si ce n'est pas le cas, cela signifie qu'il n'y a pas de connexion active. sync_state doit être défini sur sync. Si ce n'est pas sync, cela signifie que la dernière étape de la configuration n'a pas été effectuée. Consultez les journaux/jobs pour en savoir plus.
Validation de secours
L'instance de secours doit avoir un profil de réplication qui correspond au même profil que l'instance 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
Si l'instance de secours n'est pas connectée à l'instance principale, deux possibilités sont courantes :
- La configuration de l'instance de secours est toujours en cours.
- L'appareil de secours rencontre une erreur lors de la configuration ou de la tentative de connexion.
Pour vérifier si l'option 1 se produit, récupérez les journaux du pod de base de données et recherchez les instructions de journalisation nommées dbdaemon/setupPhysicalReplicationDownstream. Voici des exemples de journaux de configuration réussie :
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"
En cas d'erreur de connexion, vérifiez les journaux du pod de base de données ainsi que le fichier journal de la base de données à l'emplacement /obs/diagnostic/postgresql.log, puis identifiez l'erreur qui se produit lors de la tentative de connexion. Une erreur courante est l'absence de connectivité réseau entre l'instance de secours et l'instance principale.
Corrections manuelles
Le moyen le plus simple de résoudre les problèmes de haute disponibilité consiste à désactiver, puis à réactiver la haute disponibilité en définissant numberOfStandbys sur 0, puis en le réinitialisant sur le nombre souhaité. Si les instances de secours sont bloquées et désactivées, procédez comme suit pour réinitialiser manuellement la configuration de haute disponibilité afin qu'elle soit vide :
- Supprimez manuellement les instances de secours.
Connectez-vous à la base de données principale. Interrogez les emplacements de réplication actuels et supprimez les emplacements de réplication des instances de secours que vous souhaitez supprimer :
select pg_drop_replication_slot('REPLICATION_SLOT_NAME');Supprimez tous les profils de réplication de l'instance principale que vous souhaitez supprimer.
Si une instance n'a pas été rapprochée récemment, vous pouvez modifier la valeur de l'annotation forceReconcile. Définissez-le sur n'importe quelle valeur numérique, qui correspond au code temporel de la dernière mise à jour de cette annotation. Le seul but de cette annotation est de fournir un champ que nous pouvons mettre à jour pour forcer un nouveau rapprochement.
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"
Si une ressource DBCluster reste bloquée dans l'état DBClusterFailoverInProgress, DBClusterSwitchoverInProgress, DBClusterFailoverRollbackFailed ou DBClusterSwitchoverRollbackFailed parce que l'instance principale est isolée avec des fichiers PG_VERSION.disabled, consultez Le cluster de bases de données reste bloqué dans un état de basculement ou de commutation.
Collecter les journaux d'audit et du moteur de base de données
Les journaux du moteur de base de données et les journaux d'audit sont disponibles sous forme de fichiers dans le pod de base de données (nécessitant un accès racine) :
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
Une fois connecté au conteneur de base de données :
ls -l /obs/diagnostic/
Exemple de résultat :
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
Collecter les métriques de la base de données et des pods de base de données
L'opérateur AlloyDB Omni fournit un ensemble de métriques de base pour le moteur AlloyDB Omni et le pod qui l'héberge. Les métriques sont disponibles en tant que points de terminaison Prometheus sur le port 9187. Pour accéder aux points de terminaison, vous devez identifier le nom du pod de base de données à l'aide de l'étiquette DBCluster et démarrer le transfert de port comme suit :
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
Accéder aux métriques des pods de base de données
Dans un autre terminal :
curl http://localhost:9187/metrics | grep HELP
Pour en savoir plus sur la surveillance, consultez Surveiller AlloyDB Omni.
Vous pouvez également configurer Prometheus pour extraire les métriques de votre cluster Kubernetes. Pour en savoir plus, consultez la configuration de la détection de services Kubernetes pour Prometheus.