Implementa PostgreSQL en GKE con Zalando

Autopilot Estándar

En la guía, se muestra cómo usar el operador Zalando Postgres para implementar clústeres de Postgres en Google Kubernetes Engine (GKE).

PostgreSQL es un sistema de base de datos relacional de objetos de código abierto con varias décadas de desarrollo activo que le permitió obtener una reputación sólida en cuanto a la confiabilidad, la solidez de las características y el rendimiento.

Esta guía está dirigida a administradores de plataformas, arquitectos de nube y profesionales de operaciones interesados en ejecutar PostgreSQL como una aplicación de base de datos en GKE en lugar de usar Cloud SQL para PostgreSQL.

Objetivos

Planificar y, además, implementar la infraestructura de GKE para Postgres
Implementar y configurar el operador de Zalando Postgres
Configurar Postgres con el operador para garantizar la disponibilidad, la seguridad, la observabilidad y el rendimiento

Ventajas

Zalando ofrece las siguientes ventajas:

Una forma declarativa y nativa de Kubernetes de administrar y configurar los clústeres de PostgreSQL
Alta disponibilidad proporcionada por Patroni
Compatibilidad con la administración de copias de seguridad mediante buckets de Cloud Storage
Actualizaciones progresivas sobre los cambios del clúster de Postgres, incluidas las actualizaciones rápidas de versiones secundarias
Administración de usuarios declarativa con generación y rotación de contraseñas mediante recursos personalizados
Compatibilidad con TLS, rotación de certificados y grupos de conexiones
Clonación de clústeres y replicación de datos

Arquitectura de implementación

En este instructivo, usarás el operador de Zalando Postgres para implementar y configurar un clúster de Postgres con alta disponibilidad en GKE. El clúster tiene una réplica líder y dos réplicas en espera (de solo lectura) administradas por Patroni. Patroni es una solución de código abierto que mantiene Zalando para proporcionar funciones de alta disponibilidad y conmutación por error automática a Postgres. En caso de una falla líder, una réplica en espera se asciende de forma automática a un rol líder.

También implementas un clúster de GKE regional con alta disponibilidad para Postgres, con varios nodos > Kubernetes distribuidos en varias zonas de disponibilidad. Esta configuración ayuda a garantizar la tolerancia a errores, la escalabilidad y la redundancia geográfica. Permite realizar actualizaciones y mantenimiento progresivos, a la vez que proporciona ANS para el tiempo de actividad y la disponibilidad. Para obtener más información, consulta Clústeres regionales.

En el siguiente diagrama, se muestra un clúster de Postgres que se ejecuta en varios nodos y zonas en un clúster de GKE:

En el diagrama, el StatefulSet de Postgres se implementa en tres nodos en tres zonas diferentes. Puedes controlar cómo GKE se implementa en los nodos si configuras el pod requerido.afinidad y antiafinidad las reglas delpostgresql Especificación de recursos personalizados. Si una zona falla, con la configuración recomendada, GKE reprograma los Pods en otros nodos disponibles en tu clúster. Para los datos persistentes, usa discos SSD (premium-rwoStorageClass), que sonrecomendados en la mayoría de los casos, en bases de datos altamente cargadas debido a su latencia baja e IOPS altas.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

Cloud Shell tiene preinstalado el software que necesitas para este instructivo, incluido kubectl, gcloud CLI, Helm y Terraform. Si no usas Cloud Shell, debes instalar gcloud CLI.

Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Instala Google Cloud CLI.

Para inicializar la CLI de gcloud, ejecuta el siguiente comando:

gcloud init

Nota: Si ya instalaste la CLI de gcloud, asegúrate de que tienes la versión más reciente mediante la ejecución de

gcloud components
      update

Crea o selecciona un proyecto de Google Cloud.

Crea un proyecto de Google Cloud:
```
gcloud projects create PROJECT_ID
```
Reemplaza PROJECT_ID por un nombre para el proyecto de Google Cloud que estás creando.
Selecciona el proyecto de Google Cloud que creaste:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el nombre del proyecto de Google Cloud.

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

Habilita las APIs de Compute Engine, IAM, GKE, Backup for GKE:

gcloud services enable compute.googleapis.com iam.googleapis.com container.googleapis.com gkebackup.googleapis.com

Instala Google Cloud CLI.

Para inicializar la CLI de gcloud, ejecuta el siguiente comando:

gcloud init

Nota: Si ya instalaste la CLI de gcloud, asegúrate de que tienes la versión más reciente mediante la ejecución de

gcloud components
      update

Crea o selecciona un proyecto de Google Cloud.

Crea un proyecto de Google Cloud:
```
gcloud projects create PROJECT_ID
```
Reemplaza PROJECT_ID por un nombre para el proyecto de Google Cloud que estás creando.
Selecciona el proyecto de Google Cloud que creaste:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el nombre del proyecto de Google Cloud.

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

Habilita las APIs de Compute Engine, IAM, GKE, Backup for GKE:

gcloud services enable compute.googleapis.com iam.googleapis.com container.googleapis.com gkebackup.googleapis.com

Otorga roles a tu Cuenta de Google. Ejecuta el siguiente comando una vez para cada uno de los siguientes roles de IAM: roles/storage.objectViewer, roles/container.admin, roles/iam.serviceAccountAdmin, roles/compute.admin, roles/gkebackup.admin, roles/monitoring.viewer
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:EMAIL_ADDRESS" --role=ROLE
```
- Reemplaza PROJECT_ID con el ID del proyecto.
- Reemplaza EMAIL_ADDRESS por tu dirección de correo electrónico.
- Reemplaza ROLE por cada rol individual.

Configura tu entorno

Para configurar tu entorno, sigue estos pasos

Establece las variables de entorno:

export PROJECT_ID=PROJECT_ID
export KUBERNETES_CLUSTER_PREFIX=postgres
export REGION=us-central1

Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

Clona el repositorio de GitHub:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples

Cambia al directorio de trabajo:

cd kubernetes-engine-samples/databases/postgres-zalando

Crea la infraestructura del clúster

En esta sección, debes ejecutar una secuencia de comandos de Terraform para crear un clúster de GKE privado, regional y con alta disponibilidad.

Puedes instalar el operador mediante un clúster de Standard o Autopilot.

Standard

En el siguiente diagrama, se muestra un clúster de GKE estándar regional privado implementado en tres zonas diferentes:

Implementa esta infraestructura:

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=terraform/gke-standard init
terraform -chdir=terraform/gke-standard apply \
  -var project_id=${PROJECT_ID} \
  -var region=${REGION} \
  -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Cuando se te solicite, escribe yes. Es posible que este comando tarde varios minutos en completarse y que el clúster muestre un estado de preparación.

Terraform crea los siguientes recursos:

Una red de VPC y una subred privada para los nodos de Kubernetes
Un router para acceder a Internet a través de NAT
Un clúster de GKE privado en la región us-central1
Un grupo de nodos con ajuste de escala automático habilitado (de uno a dos nodos por zona y un nodo por zona como mínimo)
Un ServiceAccount con permisos de registro y supervisión
Copia de seguridad para GKE para la recuperación ante desastres
Google Cloud Managed Service para Prometheus para la supervisión de clústeres

El resultado es similar al siguiente:

...
Apply complete! Resources: 14 added, 0 changed, 0 destroyed.
...

Autopilot

En el siguiente diagrama, se muestra un clúster de GKE de Autopilot regional privado:

Implementa la infraestructura:

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=terraform/gke-autopilot init
terraform -chdir=terraform/gke-autopilot apply \
  -var project_id=${PROJECT_ID} \
  -var region=${REGION} \
  -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Cuando se te solicite, escribe yes. Es posible que este comando tarde varios minutos en completarse y que el clúster muestre un estado de preparación.

Terraform crea los siguientes recursos:

Una red de VPC y una subred privada para los nodos de Kubernetes
Un router para acceder a Internet a través de NAT
Un clúster de GKE privado en la región us-central1
Un ServiceAccount con permiso de registro y supervisión
Google Cloud Managed Service para Prometheus para la supervisión de clústeres

El resultado es similar al siguiente:

...
Apply complete! Resources: 12 added, 0 changed, 0 destroyed.
...

Conéctate al clúster

Configura kubectl para comunicarse con el clúster:

gcloud container clusters get-credentials ${KUBERNETES_CLUSTER_PREFIX}-cluster --region ${REGION}

Implementa el operador de Zalando en tu clúster

Implementa el operador de Zalando en tu clúster de Kubernetes con un gráfico de Helm.

Agrega el repositorio de gráfico de Helm para operadores de Zalando:

helm repo add postgres-operator-charts https://opensource.zalando.com/postgres-operator/charts/postgres-operator

Crea un espacio de nombres para el operador Zalando y el clúster de Postgres:
```
kubectl create ns postgres
kubectl create ns zalando
```
Implementa el operador de Zalando mediante la herramienta de línea de comandos de Helm:
```
helm install postgres-operator postgres-operator-charts/postgres-operator -n zalando \
    --set configKubernetes.enable_pod_antiaffinity=true \
    --set configKubernetes.pod_antiaffinity_preferred_during_scheduling=true \
    --set configKubernetes.pod_antiaffinity_topology_key="topology.kubernetes.io/zone" \
    --set configKubernetes.spilo_fsgroup="103"
```
No puedes establecer la configuración de podAntiAffinity directamente en el recurso personalizado que representa el clúster de Postgres. En su lugar, establece la configuración podAntiAffinity de forma global para todos los clústeres de Postgres en la configuración del operador.

Verifica el estado de implementación del operador de Zalando mediante Helm:

helm ls -n zalando

El resultado es similar al siguiente:

NAME                 NAMESPACE    REVISION    UPDATED                                STATUS      CHART                       APP VERSION
postgres-operator    zalando     1           2023-10-13 16:04:13.945614 +0200 CEST    deployed    postgres-operator-1.10.1    1.10.1

Implementa Postgres

La configuración básica de la instancia de clústeres de Postgres incluye los siguientes componentes:

Tres réplicas de Postgres: una líder y dos réplicas en espera.
Asignación de recursos de CPU de una solicitud de CPU y dos límites de CPU, con requisitos de memoria y límites de 4 GB.
Tolerancias, nodeAffinities y topologySpreadConstraints configuradas para cada carga de trabajo, lo que garantiza una distribución adecuada en los nodos de Kubernetes mediante sus respectivos grupos de nodos y zonas de disponibilidad diferentes.

Esta configuración representa la configuración mínima necesaria para crear un clúster de Postgres listo para la producción.

En el siguiente manifiesto, se describe un clúster de Postgres:

apiVersion: "acid.zalan.do/v1"
kind: postgresql
metadata:
  name: my-cluster
spec:
  dockerImage: ghcr.io/zalando/spilo-15:3.0-p1
  teamId: "my-team"
  numberOfInstances: 3
  users:
    mydatabaseowner:
    - superuser
    - createdb
    myuser: []
  databases:
    mydatabase: mydatabaseowner
  postgresql:
    version: "15"
    parameters:
      shared_buffers: "32MB"
      max_connections: "10"
      log_statement: "all"
      password_encryption: scram-sha-256
  volume:
    size: 5Gi
    storageClass: premium-rwo
  enableShmVolume: true
  podAnnotations:
    cluster-autoscaler.kubernetes.io/safe-to-evict: "true"
  tolerations:
  - key: "app.stateful/component"
    operator: "Equal"
    value: "postgres-operator"
    effect: NoSchedule
  nodeAffinity:
    preferredDuringSchedulingIgnoredDuringExecution:
    - weight: 1
      preference:
        matchExpressions:
        - key: "app.stateful/component"
          operator: In
          values:
          - "postgres-operator"
  resources:
    requests:
      cpu: "1"
      memory: 4Gi
    limits:
      cpu: "2"
      memory: 4Gi
  sidecars:
    - name: exporter
      image: quay.io/prometheuscommunity/postgres-exporter:v0.14.0
      args:
      - --collector.stat_statements
      ports:
      - name: exporter
        containerPort: 9187
        protocol: TCP
      resources:
        limits:
          cpu: 500m
          memory: 256M
        requests:
          cpu: 100m
          memory: 256M
      env:
      - name: "DATA_SOURCE_URI"
        value: "localhost/postgres?sslmode=require"
      - name: "DATA_SOURCE_USER"
        value: "$(POSTGRES_USER)"
      - name: "DATA_SOURCE_PASS"
        value: "$(POSTGRES_PASSWORD)"

Este manifiesto tiene los siguientes campos:

spec.teamId: Un prefijo para los objetos de clúster que elijas.
spec.numberOfInstances: La cantidad total de instancias para un clúster.
spec.users: La lista de usuarios con privilegios
spec.databases: La lista de bases de datos en el formato dbname: ownername
spec.postgresql: Parámetros de postgres
spec.volume: Parámetros de Persistent Disk
spec.tolerations: La plantilla de Pod de tolerancias que permite que los Pods del clúster se programen en nodos pool-postgres
spec.nodeAffinity: La plantilla de Pod nodeAffinity que le indica a GKE que los Pods del clúster prefieren programarse en nodos pool-postgres.
spec.resources: Solicitudes y límites para Pods del clúster
spec.sidecars: Una lista de contenedores de sidecar, que contiene postgres-exporter

Para obtener más información, consulta la referencia del manifiesto del clúster en la documentación de Postgres.

Crea un clúster básico de Postgres

Crea un clúster de Postgres nuevo mediante la configuración básica:
```
kubectl apply -n postgres -f manifests/01-basic-cluster/my-cluster.yaml
```
Con este comando, se crea un recurso personalizado de PostgreSQL del operador Zalando con lo siguiente:
- Solicitudes y límites de CPU y memoria
- Aplica taints y afinidades para distribuir las réplicas de Pods aprovisionadas en los nodos de GKE.
- Una base de datos
- Dos usuarios con permisos de propietario de la base de datos
- Un usuario sin permisos
Espera a que GKE inicie las cargas de trabajo requeridas:
```
kubectl wait pods -l cluster-name=my-cluster  --for condition=Ready --timeout=300s -n postgres
```
Este comando puede tardar unos minutos en completarse.

Verifica que GKE haya creado las cargas de trabajo de Postgres:

kubectl get pod,svc,statefulset,deploy,pdb,secret -n postgres

El resultado es similar al siguiente:

NAME                                    READY   STATUS  RESTARTS   AGE
pod/my-cluster-0                        1/1     Running   0         6m41s
pod/my-cluster-1                        1/1     Running   0         5m56s
pod/my-cluster-2                        1/1     Running   0         5m16s
pod/postgres-operator-db9667d4d-rgcs8   1/1     Running   0         12m

NAME                        TYPE        CLUSTER-IP  EXTERNAL-IP   PORT(S)   AGE
service/my-cluster          ClusterIP   10.52.12.109   <none>       5432/TCP   6m43s
service/my-cluster-config   ClusterIP   None        <none>      <none>  5m55s
service/my-cluster-repl     ClusterIP   10.52.6.152 <none>      5432/TCP   6m43s
service/postgres-operator   ClusterIP   10.52.8.176 <none>      8080/TCP   12m

NAME                        READY   AGE
statefulset.apps/my-cluster   3/3   6m43s

NAME                                READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/postgres-operator   1/1     1           1           12m

NAME                                                MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
poddisruptionbudget.policy/postgres-my-cluster-pdb   1              N/A             0                   6m44s

NAME                                                            TYPE                DATA   AGE
secret/my-user.my-cluster.credentials.postgresql.acid.zalan.do  Opaque              2   6m45s
secret/postgres.my-cluster.credentials.postgresql.acid.zalan.do   Opaque            2   6m44s
secret/sh.helm.release.v1.postgres-operator.v1                  helm.sh/release.v1   1      12m
secret/standby.my-cluster.credentials.postgresql.acid.zalan.do  Opaque              2   6m44s
secret/zalando.my-cluster.credentials.postgresql.acid.zalan.do  Opaque              2   6m44s

El operador crea los siguientes recursos:

Un StatefulSet de Postgres, que controla tres réplicas de pod para Postgres
Un PodDisruptionBudgets, que garantiza un mínimo de una réplica disponible
El Service my-cluster, que se orienta solo a la réplica líder
El Service my-cluster-repl, que expone el puerto de Postgres para las conexiones entrantes y la replicación entre réplicas de Postgres
El Service sin interfaz gráfica my-cluster-config, para obtener la lista de réplicas de Pods de Postgres en ejecución
Secretos con credenciales de usuario para acceder a la base de datos y la replicación entre los nodos de Postgres

Autentica en Postgres

Puedes crear usuarios de Postgres y asignarles permisos de base de datos. Por ejemplo, en el siguiente manifiesto, se describe un recurso personalizado que asigna usuarios y roles:

apiVersion: "acid.zalan.do/v1"
kind: postgresql
metadata:
  name: my-cluster
spec:
  ...
  users:
    mydatabaseowner:
    - superuser
    - createdb
    myuser: []
  databases:
    mydatabase: mydatabaseowner

En el manifiesto se muestra lo siguiente:

El usuario mydatabaseowner tiene los roles SUPERUSER y CREATEDB, que permiten derechos de administrador completos (es decir, administrar la configuración de Postgres, crear bases de datos, tablas y usuarios nuevos). No debes compartir este usuario con los clientes. Por ejemplo, Cloud SQL no permite que los clientes tengan acceso a los usuarios con el rol SUPERUSER.
El usuario myuser no tiene roles asignados. Esto sigue la práctica recomendada de usar SUPERUSER para crear usuarios con privilegios mínimos. mydatabaseowner otorga los derechos detallados a myuser. Para mantener la seguridad, solo debes compartir las credenciales de myuser con las aplicaciones cliente.

Almacena contraseñas

Debes usar el método recomendado para almacenar contraseñas scram-sha-256. Por ejemplo, en el siguiente manifiesto, se describe un recurso personalizado que especifica la encriptación scram-sha-256 mediante el campo postgresql.parameters.password_encryption:

apiVersion: "acid.zalan.do/v1"
kind: postgresql
metadata:
  name: my-cluster
spec:
  ...
  postgresql:
    parameters:
      password_encryption: scram-sha-256

Rota las credenciales de usuario

Con Zalando, puedes rotar las credenciales de usuario que se almacenan en secretos de Kubernetes. Por ejemplo, en el siguiente manifiesto, se describe un recurso personalizado que define la rotación de credenciales de usuario mediante el campo usersWithSecretRotation:

apiVersion: "acid.zalan.do/v1"
kind: postgresql
metadata:
  name: my-cluster
spec:
  ...
  usersWithSecretRotation:
  - myuser
  - myanotheruser
  - ...

Ejemplo de autenticación: Conectarse a Postgres

En esta sección, se muestra cómo implementar un cliente de Postgres de ejemplo y conectarse a la base de datos con la contraseña de un secreto de Kubernetes.

Ejecuta el Pod del cliente para interactuar con tu clúster de Postgres:
```
kubectl apply -n postgres -f manifests/02-auth/client-pod.yaml
```
Las credenciales de los usuarios de myuser y mydatabaseowner se toman de los Secrets relacionados y se activan como variables de entorno en el Pod.

Conéctate al Pod cuando esté listo:

kubectl wait pod postgres-client --for=condition=Ready --timeout=300s -n postgres
kubectl exec -it postgres-client -n postgres -- /bin/bash

Conéctate a Postgres y, luego, intenta crear una tabla nueva con las credenciales de myuser:

PGPASSWORD=$CLIENTPASSWORD psql \
  -h my-cluster \
  -U $CLIENTUSERNAME \
  -d mydatabase \
  -c "CREATE TABLE test (id serial PRIMARY KEY, randomdata VARCHAR ( 50 ) NOT NULL);"

El comando debería fallar con un error similar al siguiente:

ERROR:  permission denied for schema public
LINE 1: CREATE TABLE test (id serial PRIMARY KEY, randomdata VARCHAR...

El comando falla porque los usuarios sin privilegios asignados de forma predeterminada solo pueden acceder a Postgres y enumerar bases de datos.

Crea una tabla con credenciales mydatabaseowner y otorga todos los privilegios de la tabla a myuser:

PGPASSWORD=$OWNERPASSWORD psql \
  -h my-cluster \
  -U $OWNERUSERNAME \
  -d mydatabase \
  -c "CREATE TABLE test (id serial PRIMARY KEY, randomdata VARCHAR ( 50 ) NOT NULL);GRANT ALL ON test TO myuser;GRANT ALL ON SEQUENCE test_id_seq TO myuser;"

El resultado es similar al siguiente:

CREATE TABLE
GRANT
GRANT

Inserta datos aleatorios en la tabla con las credenciales myuser:

for i in {1..10}; do
  DATA=$(tr -dc A-Za-z0-9 </dev/urandom | head -c 13)
  PGPASSWORD=$CLIENTPASSWORD psql \
  -h my-cluster \
  -U $CLIENTUSERNAME \
  -d mydatabase \
  -c "INSERT INTO test(randomdata) VALUES ('$DATA');"
done

El resultado es similar al siguiente:

INSERT 0 1
INSERT 0 1
INSERT 0 1
INSERT 0 1
INSERT 0 1
INSERT 0 1
INSERT 0 1
INSERT 0 1
INSERT 0 1
INSERT 0 1

Obtén los valores que insertaste:

PGPASSWORD=$CLIENTPASSWORD psql \
  -h my-cluster \
  -U $CLIENTUSERNAME \
  -d mydatabase \
  -c "SELECT * FROM test;"

El resultado es similar al siguiente:

id |  randomdata
----+---------------
  1 | jup9HYsAjwtW4
  2 | 9rLAyBlcpLgNT
  3 | wcXSqxb5Yz75g
  4 | KoDRSrx3muD6T
  5 | b9atC7RPai7En
  6 | 20d7kC8E6Vt1V
  7 | GmgNxaWbkevGq
  8 | BkTwFWH6hWC7r
  9 | nkLXHclkaqkqy
 10 | HEebZ9Lp71Nm3
(10 rows)

Sal de la shell del Pod:
```
exit
```

Comprende cómo Prometheus recopila métricas para tu clúster de Postgres

En el siguiente diagrama, se muestra cómo funciona la recopilación de métricas de Prometheus:

En el diagrama, un clúster privado de GKE contiene lo siguiente:

Un Pod de Postgres que recopila métricas en la ruta de acceso / y el puerto 9187
Recopiladores basados en Prometheus que procesan las métricas del Pod de Postgres
Un recurso PodMonitoring que envía métricas a Cloud Monitoring

Google Cloud Managed Service para Prometheus admite la recopilación de métricas en el formato de Prometheus. Cloud Monitoring usa un panel integrado para las métricas de Postgres.

Zalando expone métricas del clúster en el formato de Prometheus mediante el componente postgres_exporter como un contenedor de sidecar.

Crea el recurso PodMonitoring para extraer métricas por labelSelector:

kubectl apply -n postgres -f manifests/03-prometheus-metrics/pod-monitoring.yaml

En la consola de Google Cloud, ve a la página Panel de clústeres de GKE.

Ir al Panel de clústeres de GKE

En el panel, se muestra una tasa de transferencia de métricas distinta de cero.
En la consola de Google Cloud, ve a la página Paneles.

Ir a Paneles
Abre el panel de descripción general de PostgreSQL Prometheus. El panel muestra la cantidad de filas recuperadas. El panel puede tardar varios minutos en aprovisionarse de forma automática.

Conéctate al Pod cliente:

kubectl exec -it postgres-client -n postgres -- /bin/bash

Inserte datos aleatorios:

for i in {1..100}; do
  DATA=$(tr -dc A-Za-z0-9 </dev/urandom | head -c 13)
  PGPASSWORD=$CLIENTPASSWORD psql \
  -h my-cluster \
  -U $CLIENTUSERNAME \
  -d mydatabase \
  -c "INSERT INTO test(randomdata) VALUES ('$DATA');"
done

Actualiza la página. Los gráficos de Filas y Bloques se actualizan para mostrar el estado real de la base de datos.
Sal de la shell del Pod:
```
exit
```

Limpia

Borra el proyecto

Precaución: Borrar un proyecto tiene estas consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

Borra un proyecto de Google Cloud:

gcloud projects delete PROJECT_ID

Borra los recursos individuales

Configurar variables de entorno

export PROJECT_ID=${PROJECT_ID}
export KUBERNETES_CLUSTER_PREFIX=postgres
export REGION=us-central1

Ejecuta el comando terraform destroy:

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform  -chdir=terraform/FOLDER destroy \
  -var project_id=${PROJECT_ID} \
  -var region=${REGION} \
  -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Reemplaza FOLDER por gke-autopilot o gke-standard.

Cuando se te solicite, escribe yes.

Busca todos los discos no conectados:

export disk_list=$(gcloud compute disks list --filter="-users:* AND labels.name=${KUBERNETES_CLUSTER_PREFIX}-cluster" --format "value[separator=|](name,zone)")

Borra los discos:

for i in $disk_list; do
  disk_name=$(echo $i| cut -d'|' -f1)
  disk_zone=$(echo $i| cut -d'|' -f2|sed 's|.*/||')
  echo "Deleting $disk_name"
  gcloud compute disks delete $disk_name --zone $disk_zone --quiet
done

Borra el repositorio de GitHub
```
rm -r ~/kubernetes-engine-samples/
```

¿Qué sigue?

Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.