Men-deploy PostgreSQL ke GKE menggunakan Zalando

Menyiapkan lingkungan Anda

Untuk menyiapkan lingkungan, ikuti langkah-langkah berikut

1. Menetapkan variabel lingkungan:

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

   Ganti PROJECT_ID dengan project ID Google Cloud Anda.

2. Buat clone repositori GitHub:

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

3. Ubah ke direktori kerja:

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

Membuat infrastruktur cluster

Di bagian ini, Anda akan menjalankan skrip Terraform untuk membuat cluster GKE regional pribadi yang sangat tersedia.

Anda dapat menginstal operator menggunakan cluster Standard atau Autopilot.

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.
...

Hubungkan ke cluster

Konfigurasi kubectl untuk berkomunikasi dengan cluster:

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

Men-deploy operator Zalando ke cluster Anda

Men-deploy operator Zalando ke cluster Kubernetes Anda menggunakan chart Helm.

1. Tambahkan repositori Helm Chart operator Zalando:

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

2. Buat namespace untuk operator Zalando dan cluster Postgres:

   kubectl create ns postgres
   kubectl create ns zalando
   

3. Deploy operator Zalando menggunakan alat command line 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"
   

   Anda tidak dapat mengonfigurasi setelan podAntiAffinity secara langsung pada resource kustom yang mewakili cluster Postgres. Sebagai gantinya, tetapkan setelan podAntiAffinity secara global untuk semua cluster Postgres di setelan operator.

4. Periksa status deployment operator Zalando menggunakan Helm:

   helm ls -n zalando
   

   Outputnya mirip dengan hal berikut ini:

   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
   

Men-deploy Postgre

Konfigurasi dasar untuk instance cluster Postgres mencakup komponen berikut:

• Tiga replika Postgres: satu replika pemimpin dan dua replika standby.
• Alokasi resource CPU sebesar satu permintaan CPU dan dua batas CPU, dengan permintaan dan batas memori 4 GB.
• Toleransi, nodeAffinities, dan topologySpreadConstraints yang dikonfigurasi untuk setiap beban kerja, memastikan distribusi yang tepat di seluruh node Kubernetes, dengan memanfaatkan kumpulan node masing-masing dan zona ketersediaan yang berbeda.

Konfigurasi ini mewakili penyiapan minimal yang diperlukan untuk membuat cluster Postgres siap produksi.

Manifes berikut menjelaskan 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)"

Manifes ini memiliki kolom berikut:

• spec.teamId: awalan untuk objek cluster yang Anda pilih
• spec.numberOfInstances: jumlah total instance untuk sebuah cluster
• spec.users: daftar pengguna dengan hak istimewa
• spec.databases: daftar database dalam format dbname: ownername
• spec.postgresql: parameter postgres
• spec.volume: Parameter Persistent Disk
• spec.tolerations: template Pod toleransi yang memungkinkan Pod cluster dijadwalkan pada pool-postgres node
• spec.nodeAffinity: template Pod nodeAffinity yang memberi tahu GKE bahwa Pod cluster lebih suka dijadwalkan untuk dijadwalkan pada node pool-postgres.
• spec.resources: permintaan dan batas untuk Pod cluster
• spec.sidecars: daftar container file bantuan, yang berisi postgres-exporter

Untuk mengetahui informasi selengkapnya, baca Referensi manifes cluster dalam dokumentasi Postgres.

Membuat cluster Postgres dasar

1. Buat cluster Postgres baru menggunakan konfigurasi dasar:

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

   Perintah ini membuat Resource Kustom PostgreSQL dari operator Zalando dengan:

   • Permintaan dan batas CPU dan memori
   • Taint dan afinitas untuk mendistribusikan replika Pod yang disediakan di seluruh node GKE.
   • Suatu{i> database<i}
   • Dua pengguna dengan izin pemilik database
   • Pengguna tanpa izin

2. Tunggu GKE memulai workload yang diperlukan:

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

   Pemrosesan perintah ini mungkin membutuhkan waktu beberapa menit.

3. Pastikan GKE membuat workload Postgres:

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

   Outputnya mirip dengan hal berikut ini:

   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
   

Operator membuat resource berikut:

• Postgres StatefulSet, yang mengontrol tiga replika Pod untuk Postgres
• PodDisruptionBudgets, yang memastikan minimal satu replika yang tersedia
• Layanan my-cluster, yang hanya menargetkan replika pemimpin
• Layanan my-cluster-repl, yang mengekspos port Postgres untuk koneksi masuk dan untuk replikasi di antara replika Postgres
• Layanan headless my-cluster-config, untuk mendapatkan daftar replika Postgres Pod yang berjalan
• Secret dengan kredensial pengguna untuk mengakses database dan replikasi di antara node Postgres

Melakukan autentikasi ke Postgres

Anda dapat membuat pengguna Postgres dan menetapkan izin database kepada mereka. Misalnya, manifes berikut menjelaskan resource kustom yang menetapkan pengguna dan peran:

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

Dalam manifes ini:

• Pengguna mydatabaseowner memiliki peran SUPERUSER dan CREATEDB, yang mengizinkan hak administrator penuh (yaitu mengelola konfigurasi Postgres, membuat database, tabel, dan pengguna baru). Anda tidak boleh membagikan pengguna ini dengan klien. Misalnya, Cloud SQL tidak mengizinkan pelanggan untuk mengakses pengguna dengan peran SUPERUSER.
• Pengguna myuser tidak memiliki peran yang ditetapkan. Langkah ini mengikuti praktik terbaik penggunaan SUPERUSER untuk membuat pengguna dengan hak istimewa terendah. Hak terperinci diberikan kepada myuser oleh mydatabaseowner. Untuk menjaga keamanan, Anda hanya boleh membagikan kredensial myuser ke aplikasi klien.

Simpan sandi

Anda harus menggunakan scram-sha-256 metode yang direkomendasikan untuk menyimpan sandi. Misalnya, manifes berikut menjelaskan resource kustom yang menentukan enkripsi scram-sha-256 menggunakan kolom postgresql.parameters.password_encryption:

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

Merotasi kredensial pengguna

Anda dapat merotasi kredensial pengguna yang disimpan di Kubernetes Secrets dengan Zalando. Misalnya, manifes berikut menjelaskan resource kustom yang menentukan rotasi kredensial pengguna menggunakan kolom usersWithSecretRotation:

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

Contoh autentikasi: terhubung ke Postgres

Bagian ini menunjukkan cara men-deploy contoh klien Postgres dan terhubung ke database menggunakan sandi dari Secret Kubernetes.

1. Jalankan Pod klien untuk berinteraksi dengan cluster Postgres Anda:

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

   Kredensial pengguna myuser dan mydatabaseowner diambil dari Secret terkait dan dipasang sebagai variabel lingkungan ke Pod.

2. Hubungkan ke Pod setelah siap:

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

3. Hubungkan ke Postgres dan coba buat tabel baru menggunakan kredensial myuser:

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

   Perintah akan gagal dengan error seperti berikut:

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

   Perintah gagal karena pengguna tanpa hak istimewa yang ditetapkan secara default hanya dapat login ke Postgres dan daftar database.

4. Buat tabel dengan kredensial mydatabaseowner dan berikan semua hak istimewa pada tabel kepada 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;"
   

   Outputnya mirip dengan hal berikut ini:

   CREATE TABLE
   GRANT
   GRANT
   

5. Masukkan data acak ke dalam tabel menggunakan kredensial 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
   

   Outputnya mirip dengan hal berikut ini:

   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. Dapatkan nilai yang Anda sisipkan:

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

   Outputnya mirip dengan hal berikut ini:

   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. Keluar dari shell Pod:

   exit
   

Memahami cara Prometheus mengumpulkan metrik untuk gugus Postgres

Diagram berikut menunjukkan cara kerja pengumpulan metrik Prometheus:

Dalam diagram, cluster pribadi GKE berisi:

• Pod Postgres yang mengumpulkan metrik di jalur / dan port 9187
• Kolektor berbasis Prometheus yang memproses metrik dari Pod Postgres
• Resource PodMonitoring yang mengirimkan metrik ke Cloud Monitoring

Google Cloud Managed Service for Prometheus mendukung pengumpulan metrik dalam format Prometheus. Cloud Monitoring menggunakan dasbor terintegrasi untuk metrik Postgres.

Zalando mengekspos metrik cluster dalam format Prometheus menggunakan komponen postgres_exporter sebagai container bantuan.

1. Buat resource PodMonitoring untuk menyalin metrik menurut labelSelector:

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

2. Di konsol Google Cloud, buka halaman Dasbor Cluster GKE.

   Buka Dasbor Cluster GKE

   Dasbor menampilkan rasio penyerapan metrik yang bukan nol.

3. Di Konsol Google Cloud, buka halaman Dashboards.

   Buka Dashboards

4. Buka dasbor PostgreSQL Prometheus Overview. Dasbor menunjukkan jumlah baris yang diambil. Mungkin perlu waktu beberapa menit hingga dasbor menyediakannya secara otomatis.

5. Menghubungkan ke Pod klien:

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

6. Menyisipkan data acak:

   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. Muat ulang halaman. Grafik Rows dan Blocks diperbarui untuk menampilkan status database yang sebenarnya.

8. Keluar dari shell Pod:

   exit