Men-deploy PostgreSQL ke GKE menggunakan Zalando

Panduan ini menunjukkan cara menggunakan operator Zalando Postgres untuk men-deploy cluster Postgres ke Google Kubernetes Engine (GKE).

PostgreSQL adalah sistem database relasional objek open source yang andal dengan pengembangan aktif selama beberapa dekade yang telah membuatnya mendapatkan reputasi yang kuat untuk keandalan, ketangguhan fitur, dan performa.

Panduan ini ditujukan bagi administrator platform, arsitek cloud, dan profesional operasi yang tertarik untuk menjalankan PostgreSQL sebagai aplikasi database di GKE, bukan menggunakan Cloud SQL untuk PostgreSQL.

Menyiapkan lingkungan Anda

Untuk menyiapkan lingkungan Anda, 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 Google Cloud project ID 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.

Standar

Diagram berikut menunjukkan cluster GKE Standard regional pribadi yang di-deploy ke tiga zona yang berbeda:

Deploy infrastruktur ini:

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}

Saat diminta, ketik yes. Anda mungkin perlu menunggu beberapa menit agar perintah ini selesai dan cluster akan menampilkan status siap.

Terraform membuat resource berikut:

• Jaringan VPC dan subnet pribadi untuk node Kubernetes
• Router untuk mengakses internet melalui NAT
• Cluster GKE pribadi di region us-central1
• Node pool dengan penskalaan otomatis diaktifkan (satu hingga dua node per zona, minimum satu node per zona)
• ServiceAccount dengan izin logging dan pemantauan
• Pencadangan untuk GKE pada pemulihan dari bencana
• Google Cloud Managed Service for Prometheus untuk pemantauan cluster

Outputnya mirip dengan hal berikut ini:

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

Autopilot

Diagram berikut menunjukkan cluster GKE Autopilot regional pribadi:

Deploy infrastruktur:

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}

Saat diminta, ketik yes. Anda mungkin perlu menunggu beberapa menit agar perintah ini selesai dan cluster akan menampilkan status siap.

Terraform membuat resource berikut:

• Jaringan VPC dan subnet pribadi untuk node Kubernetes
• Router untuk mengakses internet melalui NAT
• Cluster GKE pribadi di region us-central1
• ServiceAccount dengan izin logging dan pemantauan
• Google Cloud Managed Service for Prometheus untuk pemantauan cluster

Outputnya mirip dengan hal berikut ini:

...
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 --location ${REGION}

Men-deploy operator Zalando ke cluster Anda

Deploy operator Zalando ke cluster Kubernetes menggunakan diagram 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 di resource kustom yang merepresentasikan 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 Postgres

Konfigurasi dasar untuk instance cluster Postgres mencakup komponen berikut:

• Tiga replika Postgres: satu replika utama dan dua replika standby.
• Alokasi resource CPU dari satu permintaan CPU dan dua batas CPU, dengan permintaan dan batas memori 4 GB.
• Toleransi, nodeAffinities, dan topologySpreadConstraints dikonfigurasi untuk setiap workload, dan memastikan distribusi yang tepat di seluruh node Kubernetes, dengan memanfaatkan node pool masing-masing dan berbagai zona ketersediaan.

Konfigurasi ini menampilkan 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 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 di node pool-postgres
• spec.nodeAffinity: template Pod nodeAffinity yang memberi tahu GKE bahwa Pod cluster lebih suka dijadwalkan di node pool-postgres.
• spec.resources: permintaan dan batas untuk Pod cluster
• spec.sidecars: daftar container sidecar, yang berisi postgres-exporter

Untuk mengetahui informasi selengkapnya, lihat 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.
   • Database
   • Dua pengguna dengan izin pemilik database
   • Pengguna tanpa izin

2. Tunggu hingga 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:

• StatefulSet Postgres, yang mengontrol tiga replika Pod untuk Postgres
• PodDisruptionBudgets, yang memastikan ketersediaan minimum satu replika
• Layanan my-cluster, yang hanya menargetkan replika pemimpin
• Layanan my-cluster-repl, yang mengekspos port Postgres untuk koneksi masuk dan untuk replikasi antara replika Postgres
• Layanan headless my-cluster-config, untuk mendapatkan daftar replika Pod Postgres yang sedang berjalan
• Secret dengan kredensial pengguna untuk mengakses database dan replikasi antar-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 memberikan hak administrator penuh (yaitu mengelola konfigurasi Postgres, membuat database, tabel, dan pengguna baru). Anda tidak boleh membagikan pengguna ini kepada klien. Misalnya, Cloud SQL tidak mengizinkan pelanggan memiliki akses ke pengguna dengan peran SUPERUSER.
• Pengguna myuser tidak memiliki peran yang ditetapkan. Hal ini mengikuti praktik terbaik dalam menggunakan 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.

Menyimpan 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 Secret Kubernetes 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 saat sudah 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 yang mirip dengan 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 mencantumkan database.

4. Buat tabel dengan kredensial mydatabaseowner dan berikan hak istimewa semua 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. Sisipkan 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. Mendapatkan nilai yang Anda masukkan:

   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 cluster Postgres Anda

Diagram berikut menunjukkan cara kerja pengumpulan metrik Prometheus:

Dalam diagram, cluster pribadi GKE berisi:

• Pod Postgres yang mengumpulkan metrik di jalur / dan port 9187
• Pengumpul berbasis Prometheus yang memproses metrik dari Pod Postgres
• Resource PodMonitoring yang mengirim 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 sidecar.

1. Buat resource PodMonitoring untuk meng-scrape metrik menurut labelSelector:

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

2. Di konsol Google Cloud , buka halaman GKE Clusters Dashboard.

   Buka Dasbor Cluster GKE

   Dasbor menampilkan rasio penyerapan metrik bukan nol.

3. Di konsol Google Cloud , buka halaman Dashboards.

   Buka Dashboards

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

5. Hubungkan 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 Baris dan Blok diperbarui untuk menampilkan status database yang sebenarnya.

8. Keluar dari shell Pod:

   exit