Menghubungkan dari Google Kubernetes Engine (GKE) ke AlloyDB untuk PostgreSQL

Tutorial ini menjelaskan cara menyiapkan koneksi dari aplikasi yang berjalan di cluster autopilot Google Kubernetes Engine ke instance AlloyDB.

AlloyDB adalah layanan database yang kompatibel dengan PostgreSQL dan terkelola sepenuhnya di Google Cloud.

Google Kubernetes Engine membantu Anda men-deploy, menskalakan, dan mengelola Kubernetes secara otomatis.

Tujuan

• Build image Docker untuk AlloyDB.
• Menjalankan aplikasi di Google Kubernetes Engine.
• Terhubung ke instance AlloyDB menggunakan Proxy Auth AlloyDB dan IP internal.

Biaya

Tutorial ini menggunakan komponen Google Cloud yang dapat ditagih, yaitu , termasuk:

• AlloyDB
• Google Kubernetes Engine
• Artifact Registry

Gunakan kalkulator harga untuk membuat perkiraan biaya berdasarkan penggunaan yang Anda proyeksikan.

Sebelum memulai

Konsol

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Make sure that billing is enabled for your Google Cloud project.

6. Aktifkan Cloud API yang diperlukan untuk membuat dan terhubung ke AlloyDB untuk PostgreSQL.

   Aktifkan API

   1. Pada langkah Konfirmasi project, klik Berikutnya untuk mengonfirmasi nama project yang akan Anda ubah.

   2. Pada langkah Aktifkan API, klik Aktifkan untuk mengaktifkan hal berikut:

      • AlloyDB API
      • Artifact Registry API
      • Compute Engine API
      • Cloud Resource Manager API
      • Cloud Build API
      • Container Registry API
      • Kubernetes Engine API
      • Service Networking API

Catatan: Jika sudah mengaktifkan salah satu atau semua API ini, Anda tidak akan melihatnya tercantum di sini.

Untuk tujuan tutorial ini, gunakan contoh aplikasi web pengumpulan suara bernama gke-alloydb-app.

Meluncurkan Cloud Shell

Cloud Shell adalah lingkungan shell untuk mengelola resource yang dihosting di Google Cloud.

Cloud Shell telah diinstal dengan alat command line Google Cloud CLI dan kubectl. Gcloud CLI menyediakan antarmuka command line utama untuk Google Cloud. kubectl menyediakan antarmuka command line utama untuk menjalankan perintah terhadap cluster Kubernetes.

Konsol

Untuk meluncurkan Cloud Shell, selesaikan langkah-langkah berikut.

1. Buka konsol Google Cloud.

   Konsol Google Cloud

2. Klik Activate Cloud Shell di bagian atas konsol Google Cloud.

3. Di dialog Authorize Cloud Shell, klik Authorize.

   Sesi Cloud Shell akan terbuka di dalam frame yang lebih rendah di konsol. Gunakan shell ini untuk menjalankan perintah gcloud dan kubectl.

   1. Sebelum menjalankan perintah, tetapkan project default Anda di Google Cloud CLI menggunakan perintah berikut:

      gcloud config set project PROJECT_ID

      Ganti PROJECT_ID dengan project ID Anda.

Membuat cluster AlloyDB dan instance utamanya

Cluster AlloyDB Anda terdiri dari sejumlah node dalam Virtual Private Cloud (VPC) Google. Saat membuat cluster, Anda juga mengonfigurasi akses layanan pribadi antara salah satu VPC dan VPC yang dikelola Google yang berisi cluster baru Anda. Sebaiknya gunakan akses IP internal untuk menghindari eksposur database ke internet publik.

Untuk terhubung ke cluster AlloyDB untuk PostgreSQL dari luar VPC yang dikonfigurasi, Anda harus mengonfigurasi konfigurasi Akses Layanan Pribadi di VPC untuk AlloyDB dan menggunakan jaringan VPC default untuk menjalankan kueri dari aplikasi yang di-deploy di cluster GKE.

gcloud

1. Di Cloud Shell, periksa apakah rentang alamat IP (IPv4) yang tidak digunakan sudah ditetapkan ke peering layanan:

   gcloud services vpc-peerings list --network=default

   Lewati langkah berikutnya jika output Anda terlihat seperti berikut:

   network: projects/493573376485/global/networks/default
   peering: servicenetworking-googleapis-com
   reservedPeeringRanges:
   - default-ip-range
   service: services/servicenetworking.googleapis.com
   

   Dalam output ini, nilai reservedPeeringRanges adalah default-ip-range, yang dapat Anda gunakan sebagai IP_RANGE_NAME untuk membuat koneksi pribadi di langkah 3.

2. (Lewati jika menggunakan nilai default reservedPeeringRanges) Untuk mengalokasikan alamat IP yang tidak digunakan di VPC, gunakan perintah berikut:

   gcloud compute addresses create IP_RANGE_NAME \
       --global \
       --purpose=VPC_PEERING \
       --prefix-length=16 \
       --description="VPC private service access" \
       --network=default

   Ganti IP_RANGE_NAME dengan nama Anda untuk alamat IP internal yang tersedia dalam subnet AlloyDB, seperti alloydb-gke-psa-01.

3. Untuk mengonfigurasi akses layanan menggunakan rentang IP yang dialokasikan, jalankan perintah berikut:

   gcloud services vpc-peerings connect \
       --service=servicenetworking.googleapis.com \
       --ranges=IP_RANGE_NAME \
       --network=default

4. Untuk men-deploy cluster AlloyDB, jalankan perintah berikut:

   gcloud alloydb clusters create CLUSTER_ID \
       --database-version=POSTGRES_VERSION \
       --password=CLUSTER_PASSWORD \
       --network=default \
       --region=REGION \
       --project=PROJECT_ID

   Ganti kode berikut:

   • CLUSTER_ID: ID cluster yang Anda buat. Nama harus diawali dengan huruf kecil dan dapat berisi huruf kecil, angka, dan tanda hubung, seperti alloydb-cluster.

   • VERSION: versi utama PostgreSQL yang Anda inginkan agar server database cluster kompatibel. Pilih salah satu opsi berikut:

     • 14: untuk kompatibilitas dengan PostgreSQL 14

     • 15: untuk kompatibilitas dengan PostgreSQL 15, yang merupakan versi PostgreSQL default yang didukung

     • 16: untuk kompatibilitas dengan PostgreSQL 16 (Pratinjau)

       Untuk informasi selengkapnya tentang batasan yang berlaku untuk penggunaan PostgreSQL 16 dalam Pratinjau, lihat Kompatibilitas PostgreSQL 16 Pratinjau.

   • CLUSTER_PASSWORD: sandi yang akan digunakan untuk pengguna postgres default.

   • PROJECT_ID: ID project Google Cloud tempat Anda ingin menempatkan cluster.

   • REGION: nama region tempat cluster AlloyDB dibuat, seperti us-central1.

5. Untuk men-deploy instance utama AlloyDB, jalankan perintah berikut:

   gcloud alloydb instances create INSTANCE_ID \
       --instance-type=PRIMARY \
       --cpu-count=NUM_CPU \
       --region=REGION \
       --cluster=CLUSTER_ID \
       --project=PROJECT_ID

   Ganti kode berikut:

   • INSTANCE_ID dengan nama instance AlloyDB pilihan Anda, seperti alloydb-primary.
   • CLUSTER_ID dengan nama cluster AlloyDB, seperti alloydb-cluster.
   • NUM_CPU dengan jumlah unit pemrosesan virtual, seperti 2.
   • PROJECT_ID dengan ID project Google Cloud .
   • REGION dengan nama region tempat cluster AlloyDB dibuat, seperti us-central1.

   Tunggu hingga instance AlloyDB dibuat. Proses ini dapat memerlukan waktu beberapa menit.

Menghubungkan ke instance utama dan membuat database serta pengguna AlloyDB

Konsol

1. Jika Anda tidak berada di halaman Ringkasan cluster yang baru dibuat, buka halaman Cluster di konsol Google Cloud.

   Buka Cluster

2. Untuk menampilkan halaman Ringkasan cluster, klik nama cluster CLUSTER_ID.

3. Di menu navigasi, klik AlloyDB Studio.

4. Di halaman Login ke AlloyDB Studio, lakukan hal berikut:

   1. Dalam daftar Database, pilih postgres.

   2. Di daftar Pengguna, pilih postgres.

   3. Di kolom Sandi, masukkan CLUSTER_PASSWORD yang Anda buat di Membuat cluster AlloyDB dan instance utamanya.

   4. Klik Autentikasi. Panel Explorer menampilkan daftar objek di database Anda.

5. Di tab Editor 1, selesaikan langkah-langkah berikut:

   1. Buat database AlloyDB:

      CREATE DATABASE DATABASE_NAME;
      

      Ganti DATABASE_NAME dengan nama pilihan Anda, seperti tutorial_db.

   2. Klik Run. Tunggu hingga pesan Statement executed successfully ditampilkan di panel Results.

   3. Klik Hapus.

   4. Buat pengguna dan sandi database AlloyDB:

      CREATE USER USERNAME WITH PASSWORD 'DATABASE_PASSWORD';
      

      Ganti kode berikut:

      • USERNAME: nama pengguna AlloyDB, seperti tutorial_user.

      • DATABASE_PASSWORD: sandi untuk database AlloyDB Anda, seperti tutorial.

   5. Klik Run. Tunggu hingga pesan Statement executed successfully ditampilkan di panel Results.

6. Di panel Penjelajah di AlloyDB Studio, klik Ganti pengguna/database.

7. Di halaman Login ke AlloyDB Studio, lakukan hal berikut:

   1. Di daftar Database, pilih DATABASE_NAME, seperti tutorial_db.

   2. Di daftar Pengguna, pilih postgres.

   3. Di kolom Sandi, masukkan CLUSTER_PASSWORD yang Anda buat di Membuat cluster AlloyDB dan instance utamanya.

   4. Klik Autentikasi. Panel Explorer menampilkan daftar objek di database Anda.

8. Di tab Editor 1, selesaikan langkah-langkah berikut:

   1. Berikan semua izin kepada pengguna database AlloyDB:

      GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";
      

   2. Klik Run. Tunggu hingga pesan Statement executed successfully ditampilkan di panel Results.

   3. Klik Hapus.

   4. Berikan izin kepada pengguna database AlloyDB pada skema publik:

      GRANT CREATE ON SCHEMA public TO "USERNAME";
      

   5. Klik Run. Tunggu hingga pesan Statement executed successfully ditampilkan di panel Results.

9. Catat nama database, nama pengguna, dan sandi. Anda akan menggunakan informasi ini di Membuat secret Kubernetes.

Membuat cluster GKE Autopilot

Cluster berisi setidaknya satu mesin bidang kontrol cluster dan beberapa mesin pekerja yang disebut node. Node adalah instance virtual machine (VM) Compute Engine yang menjalankan proses Kubernetes yang diperlukan untuk menjadikannya bagian dari cluster. Anda men-deploy aplikasi ke cluster, kemudian aplikasi akan berjalan di node.

Konsol

1. Di Konsol Google Cloud, buka halaman Kubernetes Clusters.

   Buka Kubernetes Clusters

2. Klik Create.

3. Tentukan GKE_CLUSTER_ID untuk cluster Autopilot Anda di kolom Nama di halaman Dasar-Dasar Cluster, seperti ap-cluster.

4. Di kolom Region, pilih REGION, seperti us-central1.

5. Klik Create.

   Tunggu hingga cluster GKE dibuat. Proses ini dapat memerlukan waktu beberapa menit.

gcloud

Buat cluster Autopilot:

gcloud container clusters create-auto GKE_CLUSTER_ID \
    --location=REGION

Ganti kode berikut:

• GKE_CLUSTER_ID: nama cluster Autopilot, seperti ap-cluster.
• REGION: nama region tempat cluster GKE di-deploy, seperti us-central1.

Tunggu hingga cluster GKE dibuat. Proses ini dapat memerlukan waktu beberapa menit.

Menghubungkan ke AlloyDB menggunakan Proxy Auth AlloyDB

Sebaiknya gunakan Proxy Auth AlloyDB untuk terhubung ke AlloyDB. Proxy Auth AlloyDB menyediakan enkripsi dan autentikasi yang kuat menggunakan Identity and Access Management (IAM), yang dapat membantu menjaga keamanan database Anda.

Saat Anda terhubung menggunakan Proxy Auth AlloyDB, Proxy Auth AlloyDB ditambahkan ke Pod Anda menggunakan pola penampung sidecar. Penampung Proxy Auth AlloyDB berada di Pod yang sama dengan aplikasi Anda, yang memungkinkan aplikasi terhubung ke Proxy Auth AlloyDB menggunakan localhost, sehingga meningkatkan keamanan dan performa.

Membuat dan memberikan peran ke akun layanan Google

Di Google Cloud, aplikasi menggunakan akun layanan untuk melakukan panggilan API yang diotorisasi dengan mengautentikasi sebagai akun layanan itu sendiri. Saat aplikasi melakukan autentikasi sebagai akun layanan, aplikasi memiliki akses ke semua resource yang boleh diakses oleh akun layanan.

Untuk menjalankan Proxy Auth AlloyDB di Google Kubernetes Engine, Anda membuat akun layanan Google untuk merepresentasikan aplikasi Anda. Sebaiknya buat akun layanan yang unik untuk setiap aplikasi, daripada menggunakan akun layanan yang sama di mana saja. Model ini lebih aman karena memungkinkan Anda membatasi izin per aplikasi.

Konsol

1. Di konsol Google Cloud, buka halaman IAM.

   Buka IAM

2. Di halaman Permissions for project "PROJECT_ID", temukan baris yang berisi akun layanan komputasi default [e-mail], lalu klik Edit principal di baris tersebut.

   Untuk mendapatkan PROJECT_NUMBER yang merupakan ID unik yang dibuat secara otomatis untuk project Anda, lakukan hal berikut:

   1. Buka halaman Dasbor di konsol Google Cloud.

      Buka Dasbor

   2. Klik menu drop-down Select from di bagian atas halaman. Di jendela Select from yang muncul, pilih project Anda.

   PROJECT_NUMBER ditampilkan di kartu Project info pada Dasbor project.

3. Klik Tambahkan peran lain.

4. Untuk memberikan peran roles/artifactregistry.reader, klik Pilih peran dan pilih Artifact Registry dari Menurut produk atau layanan, lalu pilih Artifact Registry Reader dari Peran.

5. Klik Simpan. Akun utama diberi peran.

6. Untuk membuat akun layanan bagi aplikasi contoh GKE, buka halaman Service accounts. Buka halaman Service accounts

7. Pilih project Anda.

8. Di halaman Service accounts for project "PROJECT_ID", klik Create service account.

9. Di bagian Detail akun layanan pada halaman Buat akun layanan, masukkan GSA_NAME di kolom Nama akun layanan, seperti gke-alloydb-gsa.

10. Klik Buat dan lanjutkan.

    Bagian Berikan akses project ke akun layanan ini (opsional) di halaman Buat akun layanan akan muncul.

11. Untuk memberikan peran roles/alloydb.client, lakukan hal berikut:

    1. Klik Pilih peran.
    2. Pilih Cloud AlloyDB dari Menurut produk atau layanan.
    3. Pilih Cloud AlloyDB Client dari Peran.

12. Klik Tambahkan peran lain.

13. Untuk memberikan peran roles/serviceusage.serviceUsageConsumer, klik Pilih peran dan pilih Service Usage dari Menurut produk atau layanan, lalu pilih Service Usage Consumer dari Peran.

14. Klik Done. Akun layanan Google diberi peran.

gcloud

1. Untuk memberikan izin yang diperlukan ke akun layanan Google default agar Compute Engine dapat membaca dari Artifact Registry, jalankan perintah berikut:

   PROGECT_NUM=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
   gcloud projects add-iam-policy-binding PROJECT_ID  --member="serviceAccount:$[e-mail]"  --role="roles/artifactregistry.reader"

2. Untuk membuat akun layanan Google untuk aplikasi Anda, buat akun layanan IAM:

   gcloud iam service-accounts create GSA_NAME \
   --display-name="gke-tutorial-service-account"

   Ganti GSA_NAME dengan nama akun layanan IAM baru Anda, seperti gke-alloydb-gsa.

3. Untuk memberikan peran alloydb.client dan serviceusage.serviceUsageConsumer ke GSA aplikasi Anda, gunakan perintah berikut:

   gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com --role="roles/alloydb.client"
   gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com --role="roles/serviceusage.serviceUsageConsumer"

Mengonfigurasi Workload Identity Federation for GKE untuk aplikasi contoh

Anda perlu mengonfigurasi GKE untuk menyediakan akun layanan ke Proxy Auth AlloyDB menggunakan fitur Workload Identity Federation for GKE. Metode ini memungkinkan Anda mengikat akun layanan Kubernetes ke akun layanan Google. Akun layanan Google kemudian dapat diakses oleh aplikasi yang menggunakan akun layanan Kubernetes yang cocok.

Akun layanan Google adalah identitas IAM yang mewakili aplikasi Anda di Google Cloud. Akun layanan Kubernetes adalah identitas yang mewakili aplikasi Anda di cluster Google Kubernetes Engine.

Workload Identity Federation for GKE mengikat akun layanan Kubernetes ke akun layanan Google. Binding ini menyebabkan deployment dengan akun layanan Kubernetes tersebut diautentikasi sebagai akun layanan Google dalam interaksinya dengan Google Cloud.

gcloud

1. Di konsol Google Cloud, buka Cloud Shell.

   Buka Cloud Shell

2. Di Cloud Shell, dapatkan kredensial untuk cluster Anda:

   gcloud container clusters get-credentials GKE_CLUSTER_ID --region REGION --project PROJECT_ID

   Perintah ini mengonfigurasi kubectl untuk menggunakan cluster GKE yang Anda buat.

3. Di editor pilihan Anda, selesaikan langkah-langkah berikut:

   1. Buka service-account.yaml menggunakan nano, misalnya:

      nano service-account.yaml

   2. Di editor, tempel konten berikut:

        apiVersion: v1
        kind: ServiceAccount
        metadata:
          name: KSA_NAME
      

      Ganti KSA_NAME dengan nama akun layanan, seperti ksa-alloydb.

   3. Tekan Control+O, tekan ENTER untuk menyimpan perubahan, dan tekan Control+X untuk keluar dari editor.

4. Buat akun layanan Kubernetes untuk aplikasi contoh Anda:

   kubectl apply -f service-account.yaml

5. Berikan izin untuk akun layanan Kubernetes Anda agar dapat meniru identitas akun layanan Google dengan membuat binding kebijakan IAM di antara kedua akun layanan tersebut:

   gcloud iam service-accounts add-iam-policy-binding \
      --role="roles/iam.workloadIdentityUser" \
      --member="serviceAccount:PROJECT_ID.svc.id.goog[default/KSA_NAME]" \
      GSA_NAME@PROJECT_ID.iam.gserviceaccount.com

6. Tambahkan anotasi iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID ke akun layanan Kubernetes, menggunakan alamat email akun layanan Google:

   kubectl annotate serviceaccount \
     KSA_NAME \
     iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID.iam.gserviceaccount.com

Mengisi Artifact Registry dengan image aplikasi contoh

gcloud

1. Di Cloud Shell, gunakan perintah berikut untuk meng-clone repositori dengan kode aplikasi gke-alloydb-app contoh dari GitHub:

    git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go

2. Buat repositori di Artifact Registry untuk image Docker:

   gcloud artifacts repositories create REPOSITORY_ID --location REGION --repository-format=docker --project PROJECT_ID

   Ganti kode berikut:

   • PROJECT_ID: ID project Anda.
   • REPOSITORY_ID: nama repositori Anda, seperti gke-alloydb-sample-app.

3. Di dialog Authorize Cloud Shell, klik Authorize. Perintah ini tidak muncul jika Anda telah melakukan langkah ini sebelumnya.

4. Untuk mem-build container Docker dan memublikasikannya ke Artifact Registry, gunakan perintah berikut:

    gcloud builds submit --tag  REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION --project PROJECT_ID

   Ganti kode berikut:

   • PROJECT_ID: ID project Anda.
   • REPOSITORY_ID: nama repositori Anda, seperti gke-alloydb-sample-app.
   • SAMPLE_APPLICATION: nama aplikasi web contoh Anda, seperti gke-alloydb-app.

Membuat secret Kubernetes

Anda membuat secret Kubernetes untuk database, pengguna, dan sandi pengguna yang akan digunakan oleh aplikasi contoh. Nilai setiap secret didasarkan pada nilai yang ditentukan pada langkah Menghubungkan ke instance utama dan membuat database serta pengguna AlloyDB dalam tutorial ini. Untuk mengetahui informasi selengkapnya, lihat Secret.

gcloud

Gunakan SECRET Kubernetes, seperti gke-alloydb-secret untuk menyimpan informasi koneksi:

kubectl create secret generic SECRET \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=USERNAME \
  --from-literal=password=DATABASE_PASSWORD

Men-deploy dan menjalankan Proxy AlloyDB dalam pola file bantuan

Sebaiknya jalankan Proxy AlloyDB dalam pola sidecar sebagai penampung tambahan yang berbagi Pod dengan aplikasi Anda karena alasan berikut:

• Mencegah traffic SQL Anda terekspos secara lokal. Proxy AlloyDB memberikan enkripsi pada koneksi keluar, tetapi Anda perlu membatasi eksposur untuk koneksi masuk.
• Mencegah titik tunggal kegagalan. Akses setiap aplikasi ke database Anda independen dari yang lain, sehingga lebih tangguh.
• Membatasi akses ke Proxy AlloyDB, sehingga Anda dapat menggunakan izin IAM per aplikasi, bukan mengekspos database ke seluruh cluster.
• Memungkinkan Anda menentukan cakupan permintaan resource dengan lebih akurat. Karena Proxy AlloyDB menggunakan resource secara linear untuk digunakan, pola ini memungkinkan Anda menentukan cakupan dan meminta resource secara lebih akurat agar sesuai dengan aplikasi Anda saat diskalakan.
• Memungkinkan Anda mengonfigurasi aplikasi agar terhubung menggunakan 127.0.0.1 pada DB_PORT yang Anda tentukan di bagian perintah.

Setelah membuat cluster GKE dan mem-build image container untuk aplikasi, deploy aplikasi dalam container ke cluster GKE.

gcloud

Dalam tutorial ini, Anda akan men-deploy aplikasi web pengumpulan suara contoh, gke-alloydb-app, yang menggunakan AlloyDB sebagai datastore.

1. Dapatkan koneksi instance INSTANCE_URI untuk instance utama AlloyDB yang ingin dihubungkan dengan proxy AlloyDB:

      gcloud alloydb instances describe INSTANCE_ID \
      --cluster=CLUSTER_ID \
      --region=REGION \
      --format="value(name)"

   Ganti kode berikut:

   • INSTANCE_ID: nama untuk instance, seperti alloydb-primary.
   • CLUSTER_ID: nama untuk cluster, seperti alloydb-cluster.

   Output berisi INSTANCE_URI yang Anda tentukan dalam file definisi proxy_sidecar_deployment.yaml pada langkah 2.b bagian ini.

2. Di editor pilihan Anda, misalnya, nano, selesaikan langkah-langkah berikut:

   1. Buka proxy_sidecar_deployment.yaml menggunakan editor pilihan Anda, misalnya, nano:

      nano proxy_sidecar_deployment.yaml

   2. Di editor, tempel konten berikut:

      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: gke-alloydb
      spec:
        selector:
          matchLabels:
            app: SAMPLE_APPLICATION
        template:
          metadata:
            labels:
              app: SAMPLE_APPLICATION
          spec:
            serviceAccountName: KSA_NAME
            containers:
            - name: SAMPLE_APPLICATION
              # Replace <PROJECT_ID> and <REGION> with your project ID and region.
              image: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION:latest
              imagePullPolicy: Always
              # This app listens on port 8080 for web traffic by default.
              ports:
              - containerPort: 8080
              env:
              - name: PORT
                value: "8080"
              # This project uses environment variables to determine
              # how you would like to run your application
              # To use the Go connector (recommended) - use INSTANCE NAME 
              # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
              - name: INSTANCE_HOST
                value: "127.0.0.1"
              - name: DB_PORT
                value: "5432"
              # To use Automatic IAM Authentication (recommended)
              # use DB_IAM_USER instead of DB_USER
              # you may also remove the DB_PASS environment variable
              - name: DB_USER
                valueFrom:
                  secretKeyRef:
                    name: SECRET
                    key: username
              - name: DB_PASS
                valueFrom:
                 secretKeyRef:
                    name: SECRET
                    key: password
              - name: DB_NAME
                valueFrom:
                  secretKeyRef:
                    name: SECRET
                    key: database
           # If you are using the Go connector (recommended), you can
            # remove alloydb-proxy (everything below this line)
            - name: alloydb-proxy
              # This uses the latest version of the AlloyDB Auth proxy
              # It is recommended to use a specific version for production environments.
              # See: https://github.com/GoogleCloudPlatform/alloydb-auth-proxy
              image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
              command:
                - "/alloydb-auth-proxy"
                #AlloyDB instance name as parameter for the AlloyDB proxy
                # Use <INSTANCE_URI> 
                - "INSTANCE_URI"
              securityContext:
                # The default AlloyDB Auth proxy image runs as the
                # "nonroot" user and group (uid: 65532) by default.
                runAsNonRoot: true
              resources:
                requests:
                  # The proxy's memory use scales linearly with the number of active
                  # connections. Fewer open connections will use less memory. Adjust
                  # this value based on your application's requirements.
                  memory: "2Gi"
                  # The proxy's CPU use scales linearly with the amount of IO between
                  # the database and the application. Adjust this value based on your
                  # application's requirements.
                  cpu:    "1"
      

      Ganti INSTANCE_URI dengan jalur ke instance utama AlloyDB Anda dari langkah 1, seperti projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_ID/instances/INSTANCE_ID.

   3. Tekan Control+O, tekan ENTER untuk menyimpan perubahan, dan tekan Control+X untuk keluar dari editor.

3. Untuk men-deploy aplikasi gke-alloydb-app, terapkan file definisi proxy_sidecar_deployment.yaml yang Anda buat di langkah sebelumnya:

   kubectl apply -f proxy_sidecar_deployment.yaml

4. Verifikasi bahwa status untuk kedua penampung di Pod adalah running:

   kubectl get pods

   Contoh output:

    NAME                          READY   STATUS    RESTARTS   AGE
    gke-alloydb-8d59bb4cc-62xgh   2/2     Running   0          2m53s
   

5. Untuk terhubung ke contoh aplikasi gke-alloydb-app, gunakan layanan — misalnya, load balancer HTTP eksternal. Di editor pilihan Anda, ikuti langkah-langkah berikut:

   1. Buka service.yaml menggunakan nano, misalnya:

      nano service.yaml

   2. Di editor nano, tempel konten berikut:

      apiVersion: v1
      kind: Service
      metadata:
        name: SAMPLE_APPLICATION
      spec:
        type: LoadBalancer
        selector:
          app: SAMPLE_APPLICATION
        ports:
        - port: 80
          targetPort: 8080
      

      Ganti SAMPLE_APPLICATION dengan nama aplikasi web contoh Anda, seperti gke-alloydb-app.

   3. Tekan Control+O, tekan ENTER untuk menyimpan perubahan, dan tekan Control+X untuk keluar dari editor.

6. Untuk men-deploy aplikasi gke-alloydb-app layanan, terapkan file service.yaml:

    kubectl apply -f service.yaml

7. Untuk mendapatkan detail layanan termasuk alamat IP eksternal layanan, gunakan perintah berikut:

   kubectl get service

   Contoh output:

   NAME              TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)        AGE
   gke-alloydb-app   LoadBalancer   34.118.229.246   35.188.16.172   80:32712/TCP   45s
   kubernetes        ClusterIP      34.118.224.1     <none>          443/TCP        85m
   

8. Gunakan nilai IP eksternal dari langkah sebelumnya untuk mengakses aplikasi contoh di URL berikut:

   http://EXTERNAL-IP
   

Contoh file konfigurasi

proxy_sidecar_deployment.yaml

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: <YOUR-DEPLOYMENT-NAME>
spec:
  selector:
    matchLabels:
      app: <YOUR-APPLICATION-NAME>
  template:
    metadata:
      labels:
        app: <YOUR-APPLICATION-NAME>
    spec:
      serviceAccountName: <YOUR-KSA-NAME>
      containers:
      # Your application container goes here.
      - name: <YOUR-APPLICATION-NAME>
        image: <YOUR-APPLICATION-IMAGE-URL>
        env:
        - name: DB_HOST
          # The port value here (5432) should match the --port flag below.
          value: "localhost:5342"
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: username
        - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: database
      # The Auth Proxy sidecar goes here.
      - name: alloydb-auth-proxy
        # Make sure you have automation that upgrades this version regularly.
        # A new version of the Proxy is released monthly with bug fixes,
        # security updates, and new features.
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
        args:
          # If you're connecting over public IP, enable this flag.
          # - "--public-ip"

          # If you're connecting with PSC, enable this flag:
          # - "--psc"

          # If you're using auto IAM authentication, enable this flag:
          # - "--auto-iam-authn"

          # Enable structured logging with Google's LogEntry format:
          - "--structured-logs"

          # Listen on localhost:5432 by default.
          - "--port=5432"
          # Specify your instance URI, e.g.,
          # "projects/myproject/locations/us-central1/clusters/mycluster/instances/myinstance"
          - "<INSTANCE-URI>"

        securityContext:
          # The default AlloyDB Auth Proxy image runs as the "nonroot" user and
          # group (uid: 65532) by default.
          runAsNonRoot: true
        # You should use resource requests/limits as a best practice to prevent
        # pods from consuming too many resources and affecting the execution of
        # other pods. You should adjust the following values based on what your
        # application needs. For details, see
        # https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
        resources:
          requests:
            # The proxy's memory use scales linearly with the number of active
            # connections. Fewer open connections will use less memory. Adjust
            # this value based on your application's requirements.
            memory: "2Gi"
            # The proxy's CPU use scales linearly with the amount of IO between
            # the database and the application. Adjust this value based on your
            # application's requirements.
            cpu:    "1"

service.yaml

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: v1
kind: Service
metadata:
  name: <YOUR-SERVICE-NAME>
spec:
  type: LoadBalancer
  selector:
    app: <YOUR-APPLICATION-NAME>
  ports:
  - port: 80
    targetPort: 8080

service-account.yaml

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: v1
kind: ServiceAccount
metadata:
  name: <YOUR-KSA-NAME> # TODO(developer): replace this value

Pembersihan

Agar tidak dikenai biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Menghapus project

Cara termudah untuk menghilangkan penagihan adalah dengan menghapus project yang Anda buat untuk tutorial.

Untuk menghapus project:

1. Di Konsol Google Cloud, buka halaman Manage resources.

   Mengelola resource

2. Dalam daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.

3. Pada dialog, ketik PROJECT_ID, lalu klik Shut down untuk menghapus project.

Langkah selanjutnya

• Tentang Proxy Auth AlloyDB
• Ringkasan IP internal
• Dokumentasi Google Kubernetes Engine