Résoudre les problèmes liés à l'opérateur Kubernetes AlloyDB Omni

Sélectionnez une version de la documentation :

Cette page explique comment résoudre les problèmes liés à l'opérateur Kubernetes AlloyDB Omni.

Collecter des informations de débogage

Ces sections décrivent comment collecter des journaux et des configurations pour le débogage.

Récupérer les journaux des pods d'opérateur

Pour récupérer les journaux des pods d'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 des pods 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 fichier 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 les états des pods et des STS

Pour récupérer les états des pods et des StatefulSet (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 décrivent comment identifier les erreurs.

Rechercher l'état et les codes d'erreur

Pour identifier le code d'erreur, consultez le fichier YAML 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

Déboguer les problèmes de mémoire

Ces sections décrivent comment déboguer les problèmes de mémoire.

Exécuter et effectuer un vidage de tas

N'activez cette fonctionnalité qu'à des fins de dépannage. N'oubliez pas de la désactiver ensuite.

Pour effectuer un vidage de tas, procédez comme suit :

  1. Modifiez le déploiement de l'opérateur sous l'espace de noms alloydb-omni-system avec les noms fleet-controller-manager et local-controller-manager.
  2. Ajoutez l'argument suivant au pod : --pprof-address=:8642 ou tout autre port disponible.
  3. Attendez que le pod de contrôleur redémarre.

  4. Transférez le port précédent. Exemple :

    kubectl port-forward FLEET_CONTROLLER_MANAGER_POD_NAME -n alloydb-omni-system 8642:8642

  5. Dans un autre terminal, exécutez go tool pprof http://localhost:8642/debug/pprof/heap. Modifiez le port pour qu'il corresponde au port précédent si vous n'utilisez pas 8642.

  6. Connectez-vous à l'adresse et exécutez des commandes de dépannage. Exemple : top.

  7. Une fois le dépannage terminé, annulez l'étape 1 en supprimant l'argument et en attendant le redémarrage du pod.

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 saturée (OOM).

kubectl get secrets -A | wc -l

Débogage avancé de la haute disponibilité

Cette section fait référence à des ressources qui sont des implémentations internes. Elles peuvent être modifiées à tout moment et ne sont pas rétrocompatibles. N'appliquez des correctifs manuels qu'aux problèmes liés aux bases de données hors production. Ces étapes peuvent rendre la base de données irrécupérable.

La configuration de la haute disponibilité d'AlloyDB Omni comporte trois phases :

  1. Configurez l'instance principale pour qu'elle reçoive une connexion de l'instance de secours.
  2. Initialisez l'instance de secours et connectez-la à l'instance principale.
  3. 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, elle peut prendre plusieurs heures.

Chaque instance de réplication doit être associée à une 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 la configuration de réplication 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ète dans les champs d'état.

Tâches de secours

Il doit exister deux ensembles de tâches internes qui suivent le workflow d'une instance de secours :

  • createstandbyjobs.alloydbomni.internal.dbadmin.goog
  • deletestandbyjobs.alloydbomni.internal.dbadmin.goog

Si la configuration semble bloquée, consultez les tâches liées au cluster de base de données (DBC). La tâche peut contenir des messages d'erreur expliquant l'état de la configuration. Les tâches sont automatiquement nettoyées quelque temps après leur achèvement. Il est donc possible qu'aucune tâche ne s'affiche si aucune 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 exister 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. Consultez les tâches de secours pour voir s'il existe des tâches en cours d'exécution et si elles contiennent 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". Elle ne doit être désactivée 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'utilisateur 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'emplacement de réplication indique que la première étape de configuration n'a pas abouti.

Si active n'est pas t (true), cela signifie que l'instance de secours ne se connecte pas pour une raison quelconque (mise en réseau, instance de secours qui ne termine pas la configuration, etc.). Le débogage devra probablement se poursuivre côté 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 cela n'existe pas, cela signifie qu'il n'y a pas de connexion active. Le sync_state doit être sync. Si ce n'est pas le cas, cela signifie que la dernière étape de la configuration n'a pas abouti.sync Consulter les journaux / tâches devrait fournir plus de détails.

Validation de l'instance 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

S'il n'y a pas de connexion entre l'instance de secours et l'instance principale, deux possibilités courantes existent :

  1. L'instance de secours est toujours en cours de configuration.
  2. L'instance de secours reçoit 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 des pods de base de données et recherchez les instructions de journal 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, consultez les journaux des pods de base de données, ainsi que le fichier journal de la base de données à l'adresse /obs/diagnostic/postgresql.log, et voyez quelle est l'erreur 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.

Correctifs manuels

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 au 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 la haute disponibilité afin qu'elle soit vide :

  1. Supprimez manuellement les instances de secours.

  2. Connectez-vous à la base de données principale. Interrogez les emplacements de réplication actuels et supprimez tous les emplacements de réplication des instances de secours que vous souhaitez supprimer :

    select pg_drop_replication_slot('REPLICATION_SLOT_NAME');

  3. Supprimez tous les profils de réplication de l'instance principale que vous souhaitez supprimer.

Si une instance n'a pas été réconciliée récemment, vous pouvez modifier la valeur de l'annotation forceReconcile. Définissez-la sur n'importe quelle valeur numérique, qui correspond à l'horodatage de la dernière mise à jour de cette annotation. Le seul objectif de cette annotation est de fournir un champ que nous pouvons mettre à jour pour forcer une nouvelle réconciliation.

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"

Collecter les journaux du moteur de base de données et les journaux d'audit

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écessite un accès racine) :

  • obs/diagnostic/postgresql.log
  • obs/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

Lorsque vous êtes 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 pour le pod de base de données à l'aide du libellé 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 qu'il récupère les métriques de votre cluster Kubernetes. Pour en savoir plus, consultez la configuration de la détection de services Prometheus Kubernetes.