Eseguire il deployment di PostgreSQL in GKE utilizzando Zalando

Configura l'ambiente

Per configurare l'ambiente, segui questi passaggi

1. Imposta le variabili di ambiente:

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

   Sostituisci PROJECT_ID con il tuo Google Cloud ID progetto.

2. Clona il repository GitHub:

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

3. Passa alla directory di lavoro:

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

Crea l'infrastruttura del tuo cluster

In questa sezione eseguirai uno script Terraform per creare un'istanza un cluster GKE a livello di regione e alta disponibilità.

Puoi installare l'operatore utilizzando un'istanza Standard o Autopilot in un cluster Kubernetes.

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}

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

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}

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

Connettiti al cluster

Configura kubectl per comunicare con il cluster:

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

Esegui il deployment dell'operatore Zalando nel tuo cluster

Eseguire il deployment dell'operatore Zalando nel cluster Kubernetes utilizzando un grafico Helm.

1. Aggiungi il repository Helm Chart dell'operatore Zalando:

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

2. Crea uno spazio dei nomi per l'operatore Zalando e il cluster Postgres:

   kubectl create ns postgres
   kubectl create ns zalando
   

3. Esegui il deployment dell'operatore Zalando utilizzando lo strumento a riga di comando di 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"
   

   Non puoi configurare le impostazioni di podAntiAffinity direttamente nella risorsa che rappresenta il cluster Postgres. Imposta invece podAntiAffinity a livello globale per tutti i cluster Postgres nelle impostazioni dell'operatore.

4. Controlla lo stato del deployment dell'operatore Zalando utilizzando Helm:

   helm ls -n zalando
   

   L'output è simile al seguente:

   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
   

Esegui il deployment di Postgres

La configurazione di base per l'istanza del cluster Postgres include quanto segue componenti:

• Tre repliche Postgres: una leader e due repliche in standby.
• Allocazione delle risorse di CPU di una richiesta di CPU e di due limiti di CPU, con 4 GB richieste e limiti di memoria.
• Tolleranze, nodeAffinities e topologySpreadConstraints configurati per per ogni carico di lavoro, assicurando una corretta distribuzione tra i nodi Kubernetes, e nelle varie zone di disponibilità.

Questa configurazione rappresenta la configurazione minima richiesta per creare in un cluster Postgres pronto per la produzione.

Il seguente manifest descrive un cluster 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)"

Questo manifest contiene i seguenti campi:

• spec.teamId: un prefisso per gli oggetti del cluster che scegli
• spec.numberOfInstances: il numero totale di istanze per un cluster
• spec.users: l'elenco di utenti con privilegi
• spec.databases: l'elenco dei database nel formato dbname: ownername
• spec.postgresql: parametri postgres
• spec.volume: parametri Persistent Disk
• spec.tolerations: il modello di pod delle tolleranze che consente ai pod del cluster di da pianificare su pool-postgres nodi
• spec.nodeAffinity: il modello di pod nodeAffinity che indica GKE che i pod del cluster preferiscono essere pianificati il giorno pool-postgres nodi.
• spec.resources: richieste e limiti per i pod del cluster
• spec.sidecars: un elenco di container collaterali, che contiene postgres-exporter

Per ulteriori informazioni, vedi Riferimento per il manifest del cluster nella documentazione di Postgres.

Crea un cluster Postgres di base

1. Crea un nuovo cluster Postgres utilizzando la configurazione di base:

   kubectl apply -n postgres -f manifests/01-basic-cluster/my-cluster.yaml
   

   Questo comando crea una risorsa personalizzata PostgreSQL dell'operatore Zalando con:

   • Richieste e limiti di CPU e memoria
   • Incompatibilità e affinità per distribuire le repliche dei pod di cui è stato eseguito il provisioning nodi GKE.
   • Un database
   • Due utenti con autorizzazioni di proprietario del database
   • Un utente senza autorizzazioni

2. Attendi che GKE avvii i carichi di lavoro richiesti:

   kubectl wait pods -l cluster-name=my-cluster  --for condition=Ready --timeout=300s -n postgres
   

   Il completamento di questo comando potrebbe richiedere alcuni minuti.

3. Verifica che GKE abbia creato i carichi di lavoro Postgres:

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

   L'output è simile al seguente:

   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
   

L'operatore crea le seguenti risorse:

• Uno StatefulSet Postgres, che controlla tre repliche di pod per Postgres
• Un PodDisruptionBudgets, che garantisce almeno una replica disponibile
• Il servizio my-cluster, che ha come target solo la replica leader
• Il servizio my-cluster-repl, che espone la porta Postgres per i messaggi in entrata e per la replica tra repliche Postgres
• Il servizio headless my-cluster-config per ottenere l'elenco di Postgres in esecuzione Repliche di pod
• Secret con credenziali utente per l'accesso al database e la replica tra nodi Postgres

Autenticazione in Postgres

Puoi creare utenti Postgres e assegnare loro le autorizzazioni di database. Ad esempio: il seguente manifest descrive una risorsa personalizzata che assegna utenti e ruoli:

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

In questo manifest:

• L'utente mydatabaseowner ha SUPERUSER e CREATEDB ruoli, che consentono diritti di amministratore completi (ovvero gestire Postgres configurazione, creare nuovi database, tabelle e utenti). Non condividere questo utente con i clienti. Ad esempio Cloud SQL non consente ai clienti di avere accesso agli utenti con il ruolo SUPERUSER.
• All'utente myuser non sono stati assegnati ruoli. Questo segue best practice di utilizzando SUPERUSER per creare utenti con privilegi minimi. Diritti granulari sono stati concessi a myuser da mydatabaseowner. Per garantire la sicurezza, devi condividi solo le credenziali di myuser con applicazioni client.

Memorizza password

Dovresti usare scram-sha-256 metodo consigliato per memorizzare le password. Ad esempio, il seguente manifest descrive un modello che specifica la crittografia scram-sha-256 utilizzando Campo postgresql.parameters.password_encryption:

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

Ruota le credenziali utente

Puoi ruota credenziali utente archiviati in Kubernetes Secrets con Zalando. Ad esempio, il file manifest descrive una risorsa personalizzata che definisce la rotazione delle credenziali utente Nel campo usersWithSecretRotation:

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

Esempio di autenticazione: connettiti a Postgres

Questa sezione mostra come eseguire il deployment di un client Postgres di esempio e connetterti a utilizzando la password di un secret Kubernetes.

1. Esegui il pod del client per interagire con il cluster Postgres:

   kubectl apply -n postgres -f manifests/02-auth/client-pod.yaml
   

   Le credenziali degli utenti myuser e mydatabaseowner vengono acquisite da i secret correlati e montati come variabili di ambiente nel pod.

2. Connettiti al pod quando è pronto:

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

3. Connettiti a Postgres e prova a creare una nuova tabella utilizzando myuser credenziali:

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

   Il comando dovrebbe restituire un errore simile al seguente:

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

   Il comando non riesce perché gli utenti senza privilegi assegnati per impostazione predefinita possono accedi solo a Postgres ed elenca i database.

4. Crea una tabella con le credenziali mydatabaseowner e concedi tutte privilegi della tabella per 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;"
   

   L'output è simile al seguente:

   CREATE TABLE
   GRANT
   GRANT
   

5. Inserisci dati casuali nella tabella utilizzando le credenziali di 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
   

   L'output è simile al seguente:

   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
   

6. Ottieni i valori che hai inserito:

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

   L'output è simile al seguente:

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

7. Esci dalla shell del pod:

   exit
   

Scopri come Prometheus raccoglie le metriche per il cluster Postgres

Il seguente diagramma mostra come funziona la raccolta delle metriche di Prometheus:

Nel diagramma, un cluster privato GKE contiene:

• Un pod Postgres che raccoglie le metriche sul percorso / e sulla porta 9187
• Collettori basati su Prometheus che elaborano le metriche dal pod Postgres
• Una risorsa PodMonitoring che invia metriche a Cloud Monitoring

Google Cloud Managed Service per Prometheus supporta la raccolta delle metriche in Prometheus formato. Cloud Monitoring utilizza dashboard integrata per le metriche di Postgres.

Zalando espone le metriche del cluster nel formato Prometheus utilizzando Componente postgres_exporter come container collaterale.

1. Crea il PodMonitoring risorsa per eseguire lo scraping delle metriche in base a labelSelector:

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

2. Nella console Google Cloud, vai alla pagina Dashboard dei cluster GKE.

   Vai alla dashboard dei cluster GKE

   La dashboard mostra una percentuale di importazione di metriche diversa da zero.

3. Nella console Google Cloud, vai alla pagina Dashboard.

   Accedi a Dashboard

4. Apri la dashboard Panoramica di PostgreSQL Prometheus. La dashboard mostra il numero di righe recuperate. Potrebbero essere necessari diversi minuti prima che la dashboard fino al provisioning automatico.

5. Connettiti al pod del client:

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

6. Inserisci dati casuali:

   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
   

7. Aggiorna la pagina. I grafici Righe e Blocchi si aggiornano per mostrare stato effettivo del database.

8. Esci dalla shell del pod:

   exit