Solucionar problemas del operador de AlloyDB Omni de Kubernetes

Selecciona una versión de la documentación:

En esta página se explica cómo resolver problemas con el operador de Kubernetes de AlloyDB Omni.

Recoger información de depuración

En estas secciones se describe cómo recoger registros y configuraciones para depurar.

Obtener registros de pods de operadores

Para obtener los registros de los pods del operador, ejecuta los siguientes comandos:

kubectl logs deployments/fleet-controller-manager -c manager -n alloydb-omni-system > alloydb-omni-system-fleet-controller-manager.out
kubectl logs deployments/local-controller-manager -c manager -n alloydb-omni-system > alloydb-omni-system-local-controller-manager.out

Obtener los registros de pods de la base de datos

Para obtener los registros del pod de la base de datos, ejecuta los siguientes comandos:

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

Los siguientes registros son ejemplos de comprobaciones de estado de la base de datos correctas:

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"

Obtener el archivo postgresql.log

Para obtener el postgresql.log, ejecuta el siguiente 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

Obtener el archivo YAML de DBInstance

Para obtener el archivo YAML de DBInstance, ejecuta el siguiente comando:

kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o yaml > dbcluster_DB_CLUSTER_NAME.yaml

Obtener configuraciones y registros de escenarios de alta disponibilidad

Para obtener configuraciones y registros específicos de escenarios de alta disponibilidad, ejecuta los siguientes comandos:

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

Obtener los estados de los pods y de STS

Para obtener los estados de los pods y los StatefulSets (STS), ejecuta los siguientes comandos:

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

Identificar errores

En estas secciones se describe cómo identificar errores.

Buscar códigos de error y estados de error

Para identificar el código de error, consulta el archivo YAML de DBCluster en el estado. Consulta la documentación de los códigos de error para obtener más información.

Para obtener el archivo YAML de DBCluster, ejecuta el siguiente comando:

kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o yaml > dbcluster_DB_CLUSTER_NAME.yaml

Busca criticalIncidents. Esta sección contiene el código de error y un rastreo de la pila.

Estos son algunos ejemplos 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'

También puede obtener el estado extrayendo campos específicos en formato JSON:

kubectl get dbclusters.alloydbomni.dbadmin.goog DB_CLUSTER_NAME -n DB_CLUSTER_NAMESPACE -o jsonpath='{.status.criticalIncidents}' | jq

El resultado debería ser similar al siguiente:

[
  {
    "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 el mensaje de error hace referencia al pod de la base de datos, comprueba las instancias y los recursos del pod en el mismo espacio de nombres:

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

Depurar problemas de memoria

En estas secciones se describe cómo depurar problemas de memoria.

Ejecutar y obtener un volcado de montículo

Activa esta función solo para solucionar problemas. No olvides apagarlo después.

Para hacer un volcado de montículo, sigue estos pasos:

  1. Modifica la implementación del operador en el espacio de nombres alloydb-omni-system con los nombres fleet-controller-manager y local-controller-manager.
  2. Añade el siguiente argumento al pod --pprof-address=:8642 o a cualquier otro puerto disponible.
  3. Espera a que se reinicie el pod del controlador.

  4. Redirige el puerto anterior. Por ejemplo:

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

  5. En otro terminal, ejecuta go tool pprof http://localhost:8642/debug/pprof/heap. Cambia el puerto para que coincida con el puerto anterior si no usas 8642.

  6. Conéctate a la dirección y ejecuta comandos para solucionar problemas. Por ejemplo: top.

  7. Cuando hayas terminado de solucionar el problema, deshace el paso 1 quitando el argumento y esperando a que se reinicie el pod.

Determinar el número de recursos que está monitorizando el operador

Para saber qué recursos se están usando, ejecuta los siguientes comandos:

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

Por ejemplo, si el número de secretos es alto, puede provocar un error de falta de memoria (OOM).

kubectl get secrets -A | wc -l

Depuración avanzada de alta disponibilidad

En esta sección se hace referencia a recursos que son implementaciones internas. Están sujetos a cambios en cualquier momento y no tienen compromisos de compatibilidad con versiones anteriores. Aplica las correcciones manuales solo a los problemas de las bases de datos que no sean de producción. Si sigues estos pasos, es posible que la base de datos no se pueda recuperar.

La configuración de alta disponibilidad de AlloyDB Omni tiene tres fases:

  1. Configura la instancia principal para que reciba una conexión de la de reserva.
  2. Inicializa la instancia en espera y conéctala a la principal.
  3. Define los ajustes principales para que la conexión sea síncrona.

El paso 2 suele ser el más lento. En función del tamaño de la base de datos, puede tardar varias horas.

Cada instancia de réplica debe tener un replicationconfig asociado. Por ejemplo:

kubectl get replicationconfigs.alloydbomni.internal.dbadmin.goog -n DB_CLUSTER_NAMESPACE

Ejemplo:

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 especificación de Replication Config indica los ajustes previstos, mientras que el estado refleja el estado real leído de la base de datos. Si hay una discrepancia entre la especificación y el estado, el controlador sigue intentando aplicar el cambio o hay algún error que impide que se aplique el cambio. Esto se reflejaría en los campos de estado.

Tareas en espera

Debería haber dos conjuntos de tareas internas que monitoricen el flujo de trabajo de una instancia en espera:

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

Si parece que la configuración se ha bloqueado, consulta los trabajos relacionados con el clúster de bases de datos (DBC). Es posible que el trabajo tenga mensajes de error que expliquen en qué estado se encuentra la configuración. Las tareas se eliminan automáticamente un tiempo después de completarse, por lo que es posible que no veas ninguna si no hay ninguna en curso.

kubectl get createstandbyjobs.alloydbomni.internal.dbadmin.goog -n DB_CLUSTER_NAMESPACE

El resultado debería ser similar al siguiente:

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"

Verificación principal

Lo primero que debes comprobar es que la primaria esté configurada correctamente. Debe haber un perfil de replicación para cada instancia en espera. Si isSynchronous es true en la especificación y el estado, la configuración debería estar completa. Si isSynchronous es false en la especificación y el estado, significa que aún no se ha llegado al paso 3. Consulta los trabajos en espera para ver si hay alguno en ejecución y si tienen algún mensaje de error.

  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 que la anotación disableHealthcheck sea falsa. Solo se debe inhabilitar durante una conmutación por error o una conmutación.

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"

Consultas

Para verificar que los recursos del pod de la base de datos se han configurado correctamente, inicia sesión en la base de datos como usuario administrador alloydbadmin. A continuación, haz las siguientes consultas:

Slot de replicación

\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 buen estado es la presencia de un espacio de replicación con el mismo nombre que la instancia de espera. La ausencia de un espacio de réplica indica que el primer paso de la configuración no se ha completado correctamente.

Si active no es t (true), significa que el dispositivo en espera no se conecta por algún motivo (problemas de red, no se ha completado la configuración del dispositivo en espera, etc.) y es probable que la depuración deba continuar en el dispositivo en espera.

Estadísticas de replicación

\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 no existe, significa que no hay ninguna conexión activa. El valor de sync_state debe ser sync. Si no es sync, significa que no se ha completado el último paso de la configuración. Si consultas los registros o los trabajos, deberías obtener más información.

Verificación en espera

La réplica debe tener un perfil de replicación que coincida con el de la principal:

  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 no hay conexión entre la instancia de espera y la principal, hay dos posibilidades habituales:

  1. La función de espera aún se está configurando.
  2. Se produce un error en el dispositivo de reserva al configurarlo o intentar conectarse.

Para comprobar si se está produciendo la opción 1, obtén los registros del pod de la base de datos y busca instrucciones de registro llamadas dbdaemon/setupPhysicalReplicationDownstream. A continuación, se muestran ejemplos de registros de configuración correctos:

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"

Si se produce un error de conexión, consulta los registros del pod de la base de datos y el archivo de registro de la base de datos en /obs/diagnostic/postgresql.log para ver cuál es el error al intentar conectarte. Un error habitual es que no haya conectividad de red entre la instancia de espera y la principal.

Correcciones manuales

La forma más sencilla de solucionar los problemas de alta disponibilidad es inhabilitar y volver a habilitar esta función configurando numberOfStandbys en 0 y, a continuación, restableciéndolo al número que quieras. Si los suplentes no se pueden inhabilitar, sigue estos pasos para restablecer manualmente la configuración de alta disponibilidad y dejarla vacía:

  1. Elimina manualmente las instancias de espera.

  2. Conéctate a la base de datos principal. Consulta las ranuras de replicación actuales y elimina las ranuras de replicación de las réplicas que quieras eliminar:

    select pg_drop_replication_slot('REPLICATION_SLOT_NAME');

  3. Elimina los perfiles de replicación de la instancia principal que quieras eliminar.

Si una instancia no se ha conciliado recientemente, puede editar el valor de la anotación forceReconcile. Asigna a este campo cualquier valor numérico, que es la marca de tiempo de la última vez que se actualizó la anotación. El único propósito de esa anotación es proporcionar un campo que podamos actualizar para forzar una nueva conciliación.

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"

Recoger registros de auditoría y del motor de base de datos

Los registros del motor de base de datos y los registros de auditoría están disponibles como archivos en el pod de la base de datos (se requiere acceso de administrador):

  • 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

Cuando se conecte al contenedor de la base de datos:

ls -l /obs/diagnostic/

Ejemplo:

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

Recoger métricas de bases de datos y pods de bases de datos

El operador de AlloyDB Omni proporciona un conjunto de métricas básicas para el motor de AlloyDB Omni y el pod que lo aloja. Las métricas están disponibles como endpoints de Prometheus en el puerto 9187. Para acceder a los endpoints, debes identificar el nombre del pod de la base de datos mediante la etiqueta DBCluster e iniciar el reenvío de puertos de la siguiente manera:

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

Acceder a las métricas de pods de bases de datos

En otra terminal:

curl http://localhost:9187/metrics | grep HELP

Para obtener más información sobre la monitorización, consulta Monitorizar AlloyDB Omni.

También puedes configurar Prometheus para que recoja las métricas de tu clúster de Kubernetes. Para obtener más información, consulta la configuración de descubrimiento de servicios de Kubernetes de Prometheus.