Menyiapkan Load Balancer Aplikasi internal lintas region dengan backend grup instance VM

Dokumen ini memberikan petunjuk untuk mengonfigurasi Application Load Balancer internal lintas region untuk layanan Anda yang berjalan di instance virtual machine (VM) Compute Engine.

Sebelum memulai

Sebelum mengikuti panduan ini, pahami hal-hal berikut:

• Ringkasan Load Balancer Aplikasi Internal, termasuk bagian Batasan
• Ringkasan aturan firewall VPC

Menyiapkan resource sertifikat SSL

Buat resource sertifikat SSL Pengelola Sertifikat seperti yang dijelaskan dalam hal berikut:

• Men-deploy sertifikat yang dikelola sendiri secara global.
• Buat sertifikat yang dikelola Google yang diterbitkan oleh instance Layanan Certificate Authority Anda.
• Buat sertifikat yang dikelola Google dengan otorisasi DNS.

Sebaiknya gunakan sertifikat yang dikelola Google.

Izin

Untuk mengikuti panduan ini, Anda harus dapat membuat instance dan mengubah jaringan dalam project. Anda harus menjadi pemilik atau editor project, atau Anda harus memiliki semua peran IAM Compute Engine berikut.

Tugas	Peran yang diperlukan
Membuat komponen jaringan, subnet, dan load balancer	Admin Jaringan Compute
Menambahkan dan menghapus aturan firewall	Compute Security Admin
Membuat instance	Compute Instance Admin

Untuk informasi selengkapnya, lihat panduan berikut:

• Peran dan izin
• Kondisi IAM untuk aturan penerusan

Ringkasan penyiapan

Anda dapat mengonfigurasi load balancer seperti yang ditunjukkan pada diagram berikut:

Deployment ketersediaan tinggi Load Balancer Aplikasi internal lintas region (klik untuk memperbesar).

Seperti yang ditunjukkan dalam diagram, contoh ini membuat Load Balancer Aplikasi internal lintas region di jaringan VPC, dengan satu layanan backend dan dua grup instance terkelola backend di region REGION_A dan REGION_B.

Diagram menunjukkan hal berikut:

1. Jaringan VPC dengan subnet berikut:

   • Subnet SUBNET_A dan subnet khusus proxy di REGION_A.
   • Subnet SUBNET_B dan subnet khusus proxy di REGION_B.

   Anda harus membuat subnet khusus proxy di setiap region jaringan VPC tempat Anda menggunakan Load Balancer Aplikasi internal lintas region. Subnet khusus proxy di region dibagikan di antara semua Load Balancer Aplikasi internal lintas region di region tersebut. Alamat sumber paket yang dikirim dari load balancer ke backend layanan Anda dialokasikan dari subnet khusus proxy. Dalam contoh ini, subnet khusus proxy untuk region REGION_A memiliki rentang alamat IP utama 10.129.0.0/23 dan untuk REGION_B memiliki rentang alamat IP utama 10.130.0.0/23 yang merupakan ukuran subnet yang direkomendasikan.

2. Penyiapan ketersediaan tinggi memiliki backend grup instance terkelola untuk deployment VM Compute Engine di region REGION_A dan REGION_B. Jika backend di satu region kebetulan tidak aktif, traffic akan gagal dan beralih ke region lain.

3. Layanan backend global yang memantau penggunaan dan kondisi backend.

4. Peta URL global yang mengurai URL permintaan dan meneruskan permintaan ke layanan backend tertentu berdasarkan host dan jalur URL permintaan.

5. Proxy HTTP atau HTTPS target global, menerima permintaan dari pengguna dan meneruskannya ke peta URL. Untuk HTTPS, konfigurasikan resource sertifikat SSL global. Proxy target menggunakan sertifikat SSL untuk mendekripsi traffic SSL jika Anda mengonfigurasi load balancing HTTPS. Proxy target dapat meneruskan traffic ke instance Anda menggunakan HTTP atau HTTPS.

6. Aturan penerusan global, memiliki alamat IP internal regional load balancer Anda, untuk meneruskan setiap permintaan masuk ke proxy target.

   Alamat IP internal yang terkait dengan aturan penerusan dapat berasal dari subnet di jaringan dan region yang sama dengan backend. Perhatikan kondisi berikut:

   • Alamat IP dapat (tetapi tidak harus) berasal dari subnet yang sama dengan grup instance backend.
   • Alamat IP tidak boleh berasal dari subnet khusus proxy yang dicadangkan yang telah menetapkan tanda --purpose ke GLOBAL_MANAGED_PROXY.
   • Jika Anda ingin menggunakan alamat IP internal yang sama dengan beberapa aturan penerusan, tetapkan tanda --purpose alamat IP ke SHARED_LOADBALANCER_VIP.

7. Opsional: Konfigurasikan kebijakan perutean DNS jenis GEO untuk merutekan traffic klien ke VIP load balancer di region yang paling dekat dengan klien.

Mengonfigurasi jaringan dan subnet

Dalam jaringan VPC, konfigurasikan subnet di setiap region tempat backend Anda dikonfigurasi. Selain itu, konfigurasikan proxy-only-subnet di setiap region tempat Anda ingin mengonfigurasi load balancer.

Contoh ini menggunakan jaringan, region, dan subnet VPC berikut:

• Jaringan. Jaringan ini adalah jaringan VPC mode kustom bernama NETWORK.

• Subnet untuk backend.

  • Subnet bernama SUBNET_A di region REGION_A menggunakan 10.1.2.0/24 untuk rentang IP utamanya.
  • Subnet bernama SUBNET_B di region REGION_B menggunakan 10.1.3.0/24 untuk rentang IP utamanya.

• Subnet untuk proxy.

  • Subnet bernama PROXY_SN_A di wilayah REGION_A menggunakan 10.129.0.0/23 untuk rentang IP utamanya.
  • Subnet bernama PROXY_SN_B di region REGION_B menggunakan 10.130.0.0/23 untuk rentang IP utamanya.

Load Balancer Aplikasi internal lintas region dapat diakses dari region mana pun dalam VPC. Jadi, klien dari region mana pun dapat mengakses backend load balancer Anda secara global.

Catatan: Langkah-langkah berikutnya dalam panduan ini menggunakan parameter jaringan, region, dan subnet seperti yang diuraikan di sini.

Mengonfigurasi subnet backend

Konsol

1. Di Konsol Google Cloud, buka halaman jaringan VPC.

   Buka VPC networks

2. Klik Create VPC network.

3. Berikan Nama untuk jaringan.

4. Di bagian Subnet, tetapkan Subnet creation mode ke Custom.

5. Buat subnet untuk backend load balancer. Di bagian New subnet, masukkan informasi berikut:

   • Berikan Name untuk subnet.
   • Pilih Region: REGION_A
   • Masukkan rentang alamat IP: 10.1.2.0/24

6. Klik Done.

7. Klik Tambahkan subnet.

8. Buat subnet untuk backend load balancer. Di bagian Subnet baru, masukkan informasi berikut:

   • Berikan Name untuk subnet.
   • Pilih Region: REGION_B
   • Masukkan rentang alamat IP: 10.1.3.0/24

9. Klik Done.

10. Klik Create.

gcloud

1. Buat jaringan VPC kustom dengan perintah gcloud compute networks create:

   gcloud compute networks create NETWORK \
       --subnet-mode=custom
   

2. Buat subnet di jaringan NETWORK di region REGION_A dengan perintah gcloud compute networks subnets create:

   gcloud compute networks subnets create SUBNET_A \
       --network=NETWORK \
       --range=10.1.2.0/24 \
       --region=REGION_A
   

3. Buat subnet di jaringan NETWORK di region REGION_B dengan perintah gcloud compute networks subnets create:

   gcloud compute networks subnets create SUBNET_B \
       --network=NETWORK \
       --range=10.1.3.0/24 \
       --region=REGION_B
   

Terraform

Untuk membuat jaringan VPC, gunakan resource google_compute_network.

resource "google_compute_network" "default" {
  auto_create_subnetworks = false
  name                    = "lb-network-crs-reg"
  provider                = google-beta
}

Untuk membuat subnet VPC di jaringan lb-network-crs-reg, gunakan resource google_compute_subnetwork.

resource "google_compute_subnetwork" "subnet_a" {
  provider      = google-beta
  ip_cidr_range = "10.1.2.0/24"
  name          = "lbsubnet-uswest1"
  network       = google_compute_network.default.id
  region        = "us-west1"
}

resource "google_compute_subnetwork" "subnet_b" {
  provider      = google-beta
  ip_cidr_range = "10.1.3.0/24"
  name          = "lbsubnet-useast1"
  network       = google_compute_network.default.id
  region        = "us-east1"
}

API

Buat permintaan POST ke metode networks.insert. Ganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
 "routingConfig": {
   "routingMode": "regional"
 },
 "name": "NETWORK",
 "autoCreateSubnetworks": false
}

Buat permintaan POST ke metode subnetworks.insert. Ganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

{
 "name": "SUBNET_A",
 "network": "projects/PROJECT_ID/global/networks/lb-network-crs-reg",
 "ipCidrRange": "10.1.2.0/24",
 "region": "projects/PROJECT_ID/regions/REGION_A",
}

Buat permintaan POST ke metode subnetworks.insert. Ganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

{
 "name": "SUBNET_B",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "ipCidrRange": "10.1.3.0/24",
 "region": "projects/PROJECT_ID/regions/REGION_B",
}

Mengonfigurasi subnet khusus proxy

Subnet khusus proxy menyediakan kumpulan alamat IP yang digunakan Google Cloud untuk menjalankan proxy Envoy atas nama Anda. Proxy menghentikan koneksi dari klien dan membuat koneksi baru ke backend.

Subnet khusus proxy ini digunakan oleh semua load balancer regional berbasis Envoy di region yang sama dengan jaringan VPC. Hanya boleh ada satu subnet khusus proxy yang aktif untuk tujuan tertentu, per wilayah, per jaringan.

Penting: Jangan mencoba menetapkan alamat dari subnet khusus proxy ke aturan penerusan atau backend load balancer Anda. Anda menetapkan alamat IP aturan penerusan dan alamat IP instance backend dari rentang subnet (atau beberapa rentang) yang berbeda, bukan rentang ini. Google Cloud mereservasi rentang subnet ini untuk proxy yang dikelola Google Cloud.

Konsol

Jika menggunakan konsol Google Cloud, Anda dapat menunggu dan membuat subnet khusus proxy nanti di halaman Load balancing.

Jika Anda ingin membuat subnet khusus proxy sekarang, gunakan langkah-langkah berikut:

1. Di konsol Google Cloud, buka halaman jaringan VPC.

   Buka jaringan VPC

2. Klik nama jaringan VPC.
3. Di tab Subnet, klik Tambahkan subnet.
4. Berikan Nama untuk subnet khusus proxy.
5. Pilih Region: REGION_A
6. Di daftar Tujuan, pilih Proxy Terkelola Lintas Wilayah.
7. Di kolom IP address range, masukkan 10.129.0.0/23.
8. Klik Tambahkan.

Membuat subnet khusus proxy di REGION_B

1. Di tab Subnet, klik Tambahkan subnet.
2. Berikan Nama untuk subnet khusus proxy.
3. Pilih Region: REGION_B
4. Di daftar Tujuan, pilih Proxy Terkelola Lintas Wilayah.
5. Di kolom IP address range, masukkan 10.130.0.0/23.
6. Klik Tambahkan.

gcloud

Buat subnet khusus proxy dengan perintah gcloud compute networks subnets create.

    gcloud compute networks subnets create PROXY_SN_A \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_A \
        --network=NETWORK \
        --range=10.129.0.0/23
    

    gcloud compute networks subnets create PROXY_SN_B \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_B \
        --network=NETWORK \
        --range=10.130.0.0/23
    

Terraform

Untuk membuat subnet khusus proxy VPC di jaringan lb-network-crs-reg, gunakan resource google_compute_subnetwork.

resource "google_compute_subnetwork" "proxy_subnet_a" {
  provider      = google-beta
  ip_cidr_range = "10.129.0.0/23"
  name          = "proxy-only-subnet1"
  network       = google_compute_network.default.id
  purpose       = "GLOBAL_MANAGED_PROXY"
  region        = "us-west1"
  role          = "ACTIVE"
  lifecycle {
    ignore_changes = [ipv6_access_type]
  }
}

resource "google_compute_subnetwork" "proxy_subnet_b" {
  provider      = google-beta
  ip_cidr_range = "10.130.0.0/23"
  name          = "proxy-only-subnet2"
  network       = google_compute_network.default.id
  purpose       = "GLOBAL_MANAGED_PROXY"
  region        = "us-east1"
  role          = "ACTIVE"
  lifecycle {
    ignore_changes = [ipv6_access_type]
  }
}

API

Buat subnet khusus proxy dengan metode subnetworks.insert, dengan mengganti PROJECT_ID dengan project ID Anda.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

    {
      "name": " PROXY_SN_A",
      "ipCidrRange": "10.129.0.0/23",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_A",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }
   

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

    {
      "name": "PROXY_SN_B",
      "ipCidrRange": "10.130.0.0/23",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_B",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }
   

Mengonfigurasi aturan firewall

Contoh ini menggunakan aturan firewall berikut:

• fw-ilb-to-backends. Aturan ingress, yang berlaku untuk instance yang di-load balanced, yang memungkinkan konektivitas SSH yang masuk pada TCP port 22 dari alamat mana pun. Anda dapat memilih rentang alamat IP sumber yang lebih ketat untuk aturan ini; misalnya, Anda dapat menentukan hanya rentang alamat IP sistem tempat Anda memulai sesi SSH. Contoh ini menggunakan tag target allow-ssh untuk mengidentifikasi VM yang menerapkan aturan firewall.

• fw-healthcheck. Aturan ingress, yang berlaku untuk instance yang di-load balance, yang mengizinkan semua traffic TCP dari sistem health check Google Cloud (dalam 130.211.0.0/22 dan 35.191.0.0/16). Contoh ini menggunakan tag target load-balanced-backend untuk mengidentifikasi VM yang menerapkan aturan firewall.

• fw-backends. Aturan ingress, yang berlaku untuk instance yang di-load balance, yang mengizinkan traffic TCP pada port 80, 443, dan 8080 dari proxy terkelola Load Balancer Aplikasi internal. Contoh ini menggunakan tag target load-balanced-backend untuk mengidentifikasi VM yang menerapkan aturan firewall.

Tanpa aturan firewall ini, aturan tolak ingress default akan memblokir traffic masuk ke instance backend.

Tag target menentukan instance backend. Tanpa tag target, aturan firewall akan berlaku untuk semua instance backend Anda di jaringan VPC. Saat membuat VM backend, pastikan untuk menyertakan tag target yang ditentukan, seperti yang ditunjukkan dalam Membuat grup instance terkelola.

Konsol

1. Di Konsol Google Cloud, buka halaman Firewall policies.

   Buka Kebijakan firewall

2. Klik Create firewall rule untuk membuat aturan yang mengizinkan koneksi SSH yang masuk:

   • Nama: fw-ilb-to-backends
   • Jaringan: NETWORK
   • Direction of traffic: Ingress
   • Action on match: Allow
   • Targets: Tag target yang ditentukan
   • Tag target: allow-ssh
   • Filter sumber: Rentang IPv4
   • Rentang IPv4 sumber: 0.0.0.0/0
   • Protokol dan port:
     • Pilih Protokol dan port yang ditentukan.
     • Pilih kotak centang TCP, lalu masukkan 22 untuk nomor port.

3. Klik Create.

4. Klik Create firewall rule untuk kedua kalinya guna membuat aturan yang mengizinkan health check Google Cloud:

   • Nama: fw-healthcheck
   • Jaringan: NETWORK
   • Direction of traffic: Ingress
   • Action on match: Allow
   • Targets: Tag target yang ditentukan
   • Tag target: load-balanced-backend
   • Filter sumber: Rentang IPv4
   • Rentang IPv4 sumber: 130.211.0.0/22 dan 35.191.0.0/16

   • Protokol dan port:

     • Pilih Protokol dan port yang ditentukan.
     • Pilih kotak centang TCP, lalu masukkan 80 untuk nomor port.

     Sebagai praktik terbaik, batasi aturan ini hanya pada protokol dan port yang cocok dengan yang digunakan oleh health check Anda. Jika Anda menggunakan tcp:80 untuk protokol dan port, Google Cloud dapat menggunakan HTTP di port 80 untuk menghubungi VM Anda, tetapi tidak dapat menggunakan HTTPS di port 443 untuk menghubunginya.

5. Klik Create.

6. Klik Create firewall rule untuk ketiga kalinya guna membuat aturan yang mengizinkan server proxy load balancer menghubungkan backend:

   • Nama: fw-backends
   • Jaringan: NETWORK
   • Direction of traffic: Ingress
   • Action on match: Allow
   • Targets: Tag target yang ditentukan
   • Tag target: load-balanced-backend
   • Filter sumber: Rentang IPv4
   • Rentang IPv4 sumber: 10.129.0.0/23 dan 10.130.0.0/23
   • Protokol dan port:
     • Pilih Protokol dan port yang ditentukan.
     • Pilih kotak centang TCP, lalu masukkan 80, 443, 8080 untuk nomor port.

7. Klik Create.

gcloud

1. Buat aturan firewall fw-ilb-to-backends untuk mengizinkan konektivitas SSH ke VM dengan tag jaringan allow-ssh. Saat Anda menghapus source-ranges, Google Cloud akan menafsirkan aturan sebagai sumber apa pun.

   gcloud compute firewall-rules create fw-ilb-to-backends \
       --network=NETWORK \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-ssh \
       --rules=tcp:22
   

2. Buat aturan fw-healthcheck untuk mengizinkan health check Google Cloud. Contoh ini mengizinkan semua traffic TCP dari penguji health check; namun, Anda juga dapat mengonfigurasi kumpulan port yang lebih sempit untuk memenuhi kebutuhan Anda.

   gcloud compute firewall-rules create fw-healthcheck \
       --network=NETWORK \
       --action=allow \
       --direction=ingress \
       --source-ranges=130.211.0.0/22,35.191.0.0/16 \
       --target-tags=load-balanced-backend \
       --rules=tcp
   

3. Buat aturan fw-backends untuk mengizinkan proxy Application Load Balancer internal terhubung ke backend Anda. Tetapkan source-ranges ke rentang yang dialokasikan dari subnet khusus proxy Anda, misalnya, 10.129.0.0/23 dan 10.130.0.0/23.

   gcloud compute firewall-rules create fw-backends \
       --network=NETWORK \
       --action=allow \
       --direction=ingress \
       --source-ranges=source-range \
       --target-tags=load-balanced-backend \
       --rules=tcp:80,tcp:443,tcp:8080
   

Terraform

Untuk membuat aturan firewall, gunakan resource google_compute_firewall.

resource "google_compute_firewall" "fw_healthcheck" {
  name          = "gl7-ilb-fw-allow-hc"
  provider      = google-beta
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16", "35.235.240.0/20"]
  allow {
    protocol = "tcp"
  }
}

resource "google_compute_firewall" "fw_ilb_to_backends" {
  name          = "fw-ilb-to-fw"
  provider      = google-beta
  network       = google_compute_network.default.id
  source_ranges = ["0.0.0.0/0"]
  allow {
    protocol = "tcp"
    ports    = ["22", "80", "443", "8080"]
  }
}

resource "google_compute_firewall" "fw_backends" {
  name          = "gl7-ilb-fw-allow-ilb-to-backends"
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  source_ranges = ["10.129.0.0/23", "10.130.0.0/23"]
  target_tags   = ["http-server"]
  allow {
    protocol = "tcp"
    ports    = ["80", "443", "8080"]
  }
}

API

Buat aturan firewall fw-ilb-to-backends dengan membuat permintaan POST ke metode firewalls.insert, ganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-ilb-to-backends",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "0.0.0.0/0"
 ],
 "targetTags": [
   "allow-ssh"
 ],
 "allowed": [
  {
    "IPProtocol": "tcp",
    "ports": [
      "22"
    ]
  }
 ],
"direction": "INGRESS"
}

Buat aturan firewall fw-healthcheck dengan membuat permintaan POST ke metode firewalls.insert, ganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-healthcheck",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "130.211.0.0/22",
   "35.191.0.0/16"
 ],
 "targetTags": [
   "load-balanced-backend"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   }
 ],
 "direction": "INGRESS"
}

Buat aturan firewall fw-backends untuk mengizinkan traffic TCP dalam subnet proxy untuk metode firewalls.insert, ganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-backends",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "10.129.0.0/23",
   "10.130.0.0/23"
 ],
 "targetTags": [
   "load-balanced-backend"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp",
     "ports": [
       "80"
     ]
   },
 {
     "IPProtocol": "tcp",
     "ports": [
       "443"
     ]
   },
   {
     "IPProtocol": "tcp",
     "ports": [
       "8080"
     ]
   }
 ],
 "direction": "INGRESS"
}

Membuat grup instance terkelola

Bagian ini menunjukkan cara membuat template dan grup instance terkelola. Grup instance terkelola menyediakan instance VM yang menjalankan server backend dari contoh Load Balancer Aplikasi internal lintas-region. Untuk grup instance, Anda dapat menentukan layanan HTTP dan memetakan nama port ke port yang relevan. Layanan backend load balancer meneruskan traffic ke port bernama. Traffic dari klien di-load balance ke server backend. Untuk tujuan demonstrasi, backend menayangkan nama host-nya sendiri.

Konsol

1. Di konsol Google Cloud, buka halaman Instance templates.

   Buka halaman Template instance

   1. Klik Create instance template.
   2. Untuk Name, masukkan gil7-backendeast1-template.
   3. Pastikan Boot disk disetel ke image Debian, seperti Debian GNU/Linux 12 (bookworm). Petunjuk ini menggunakan perintah yang hanya tersedia di Debian, seperti apt-get.
   4. Klik Advanced options.
   5. Klik Networking dan konfigurasikan kolom berikut:
      1. Untuk Network tags, masukkan allow-ssh dan load-balanced-backend.
      2. Untuk Network interfaces, pilih dari daftar berikut:
         • Jaringan: NETWORK
         • Subnet: SUBNET_B

   6. Klik Management. Masukkan skrip berikut ke dalam kolom Skrip startup.

      #! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://169.254.169.254/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      systemctl restart apache2
      

   7. Klik Create.

   8. Klik Create instance template.

   9. Untuk Name, masukkan gil7-backendwest1-template.

   10. Pastikan Boot disk disetel ke image Debian, seperti Debian GNU/Linux 12 (bookworm). Petunjuk ini menggunakan perintah yang hanya tersedia di Debian, seperti apt-get.

   11. Klik Advanced options.

   12. Klik Networking dan konfigurasikan kolom berikut:

       1. Untuk Network tags, masukkan allow-ssh dan load-balanced-backend.
       2. Untuk Network interfaces, pilih dari daftar berikut:
          • Jaringan: NETWORK
          • Subnet: SUBNET_A

   13. Klik Management. Masukkan skrip berikut ke dalam kolom Skrip startup.

       #! /bin/bash
       apt-get update
       apt-get install apache2 -y
       a2ensite default-ssl
       a2enmod ssl
       vm_hostname="$(curl -H "Metadata-Flavor:Google" \
       http://169.254.169.254/computeMetadata/v1/instance/name)"
       echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       systemctl restart apache2
       

   14. Klik Create.

2. Di konsol Google Cloud, buka halaman Instance groups.

   Buka Instance groups

   1. Klik Create instance group.
   2. Pilih New managed instance group (stateless). Untuk informasi selengkapnya, lihat MIG stateless atau stateful.
   3. Untuk Name, masukkan gl7-ilb-mig-a.
   4. Untuk Location, pilih Single zone.
   5. Untuk Region, pilih REGION_A.
   6. Untuk Zone, pilih ZONE_A.
   7. Untuk Instance template, pilih gil7-backendwest1-template.

   8. Tentukan jumlah instance yang ingin Anda buat dalam grup.

      Untuk contoh ini, tentukan opsi berikut di bagian Penskalaan otomatis:

      • Untuk Autoscaling mode, pilih Off:do not autoscale.
      • Untuk Maximum number of instances, masukkan 2.

      Secara opsional, di bagian Autoscaling pada UI, Anda dapat mengonfigurasi grup instance untuk otomatis menambahkan atau menghapus instance berdasarkan penggunaan CPU instance.

   9. Klik Create.

   10. Klik Create instance group.

   11. Pilih New managed instance group (stateless). Untuk informasi selengkapnya, lihat MIG stateless atau stateful.

   12. Untuk Name, masukkan gl7-ilb-mig-b.

   13. Untuk Location, pilih Single zone.

   14. Untuk Region, pilih REGION_B.

   15. Untuk Zone, pilih ZONE_B.

   16. Untuk Instance template, pilih gil7-backendeast1-template.

   17. Tentukan jumlah instance yang ingin Anda buat dalam grup.

       Untuk contoh ini, tentukan opsi berikut di bagian Penskalaan otomatis:

       • Untuk Autoscaling mode, pilih Off:do not autoscale.
       • Untuk Maximum number of instances, masukkan 2.

       Secara opsional, di bagian Autoscaling pada UI, Anda dapat mengonfigurasi grup instance untuk otomatis menambahkan atau menghapus instance berdasarkan penggunaan CPU instance.

   18. Klik Create.

gcloud

Petunjuk gcloud CLI dalam panduan ini mengasumsikan bahwa Anda menggunakan Cloud Shell atau lingkungan lain dengan bash yang diinstal.

1. Buat template instance VM dengan server HTTP dengan perintah gcloud compute instance-templates create.

   gcloud compute instance-templates create gil7-backendwest1-template \
     --region=REGION_A \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --tags=allow-ssh,load-balanced-backend \
     --image-family=debian-12 \
     --image-project=debian-cloud \
     --metadata=startup-script='#! /bin/bash
       apt-get update
       apt-get install apache2 -y
       a2ensite default-ssl
       a2enmod ssl
       vm_hostname="$(curl -H "Metadata-Flavor:Google" \
       http://169.254.169.254/computeMetadata/v1/instance/name)"
       echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       systemctl restart apache2'
   

   gcloud compute instance-templates create gil7-backendeast1-template \
       --region=REGION_B \
       --network=NETWORK \
       --subnet=SUBNET_B \
       --tags=allow-ssh,load-balanced-backend \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --metadata=startup-script='#! /bin/bash
         apt-get update
         apt-get install apache2 -y
         a2ensite default-ssl
         a2enmod ssl
         vm_hostname="$(curl -H "Metadata-Flavor:Google" \
         http://169.254.169.254/computeMetadata/v1/instance/name)"
         echo "Page served from: $vm_hostname" | \
         tee /var/www/html/index.html
         systemctl restart apache2'
   

2. Buat grup instance terkelola di zona dengan perintah gcloud compute instance-groups managed create.

   gcloud compute instance-groups managed create gl7-ilb-mig-a \
       --zone=ZONE_A \
       --size=2 \
       --template=gil7-backendwest1-template
   

   gcloud compute instance-groups managed create gl7-ilb-mig-b \
       --zone=ZONE_B \
       --size=2 \
       --template=gil7-backendeast1-template
   

Terraform

Untuk membuat template instance, gunakan resource google_compute_instance_template.

resource "google_compute_instance_template" "instance_template_a" {
  name         = "gil7-backendwest1-template"
  provider     = google-beta
  machine_type = "e2-small"
  region       = "us-west1"
  tags         = ["http-server"]

  network_interface {
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.subnet_a.id
    access_config {
      # add external ip to fetch packages
    }
  }
  disk {
    source_image = "debian-cloud/debian-11"
    auto_delete  = true
    boot         = true
  }

  # install nginx and serve a simple web page
  metadata = {
    startup-script = <<-EOF1
      #! /bin/bash
      set -euo pipefail

      export DEBIAN_FRONTEND=noninteractive
      apt-get update
      apt-get install -y nginx-light jq

      NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
      IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
      METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')

      cat <<EOF > /var/www/html/index.html
      <pre>
      Name: $NAME
      IP: $IP
      Metadata: $METADATA
      </pre>
      EOF
    EOF1
  }
  lifecycle {
    create_before_destroy = true
  }
}

resource "google_compute_instance_template" "instance_template_b" {
  name         = "gil7-backendeast1-template"
  provider     = google-beta
  machine_type = "e2-small"
  region       = "us-east1"
  tags         = ["http-server"]

  network_interface {
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.subnet_b.id
    access_config {
      # add external ip to fetch packages
    }
  }
  disk {
    source_image = "debian-cloud/debian-11"
    auto_delete  = true
    boot         = true
  }

  # install nginx and serve a simple web page
  metadata = {
    startup-script = <<-EOF1
      #! /bin/bash
      set -euo pipefail

      export DEBIAN_FRONTEND=noninteractive
      apt-get update
      apt-get install -y nginx-light jq

      NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
      IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
      METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')

      cat <<EOF > /var/www/html/index.html
      <pre>
      Name: $NAME
      IP: $IP
      Metadata: $METADATA
      </pre>
      EOF
    EOF1
  }
  lifecycle {
    create_before_destroy = true
  }
}

Untuk membuat grup instance terkelola, gunakan resource google_compute_instance_group_manager.

resource "google_compute_region_instance_group_manager" "mig_a" {
  name     = "gl7-ilb-miga"
  provider = google-beta
  region   = "us-west1"
  version {
    instance_template = google_compute_instance_template.instance_template_a.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

resource "google_compute_region_instance_group_manager" "mig_b" {
  name     = "gl7-ilb-migb"
  provider = google-beta
  region   = "us-east1"
  version {
    instance_template = google_compute_instance_template.instance_template_b.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

API

Buat template instance dengan metode instanceTemplates.insert, ganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates

{
  "name":"gil7-backendwest1-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "load-balanced-backend"
       ]
     },
     "metadata":{
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install
            apache2 -y\na2ensite default-ssl\na2enmod ssl\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/NETWORK",
         "subnetwork":"regions/REGION_A/subnetworks/SUBNET_A",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

Buat grup instance terkelola di setiap zona dengan metode instanceGroupManagers.insert, ganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers

{
  "name": "gl7-ilb-mig-a",
  "zone": "projects/PROJECT_ID/zones/ZONE_A",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil7-backendwest1-template",
  "baseInstanceName": "gl7-ilb-mig-b",
  "targetSize": 2
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates

{
  "name":"gil7-backendeast1-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "load-balanced-backend"
       ]
     },
     "metadata":{
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install
            apache2 -y\na2ensite default-ssl\na2enmod ssl\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/NETWORK",
         "subnetwork":"regions/REGION_B/subnetworks/SUBNET_B",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

Buat grup instance terkelola di setiap zona dengan metode instanceGroupManagers.insert, ganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers

{
  "name": "gl7-ilb-mig-b",
  "zone": "projects/PROJECT_ID/zones/ZONE_B",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil7-backendwest1-template",
  "baseInstanceName": "gl7-ilb-mig-b",
  "targetSize": 2
}

Mengonfigurasi load balancer

Contoh ini menunjukkan cara membuat resource Load Balancer Aplikasi internal lintas region berikut:

• Health check HTTP global.
• Layanan backend global dengan grup instance terkelola sebagai backend.
• Peta URL. Pastikan untuk merujuk ke peta URL global untuk proxy HTTP(S) target. Peta URL global merutekan permintaan ke layanan backend global berdasarkan aturan yang Anda tentukan untuk host dan jalur URL yang masuk. Peta URL global dapat dirujuk oleh aturan proxy target global.
• Sertifikat SSL global (untuk HTTPS).
• Proxy target global.

• Dua aturan penerusan global dengan alamat IP regional. Untuk alamat IP aturan penerusan, gunakan rentang alamat IP SUBNET_A atau SUBNET_B. Jika Anda mencoba menggunakan subnet khusus proxy, pembuatan aturan penerusan akan gagal.

Konsol

Memulai konfigurasi

1. Di konsol Google Cloud, buka halaman Load balancing.

   Buka Load balancing

2. Klik Create load balancer.
3. Untuk Type of load balancer, pilih Application Load Balancer (HTTP/HTTPS), lalu klik Next.
4. Untuk Public facing or internal, pilih Internal, lalu klik Next.
5. Untuk Cross-region or single region deployment, pilih Best for cross-region workloads, lalu klik Next.
6. Klik Konfigurasikan.

Konfigurasi dasar

1. Berikan Nama untuk load balancer.
2. Untuk Network, pilih NETWORK.

Mengonfigurasi frontend dengan dua aturan penerusan

Untuk HTTP:

1. Klik Frontend configuration.
1. Berikan Name untuk aturan penerusan.
2. Di daftar Subnetwork region, pilih REGION_A.
   

   Mereservasi subnet khusus proxy

Jika Anda sudah mengonfigurasi subnet khusus proxy, tombol Reserve subnet tidak akan ditampilkan. Anda dapat melanjutkan ke langkah berikutnya.
3. Dalam daftar Subnetwork, pilih SUBNET_A.
4. Dalam daftar IP address, klik Create IP address. Halaman Reserve a static internal IP address akan terbuka.
• Berikan Name untuk alamat IP statis.
• Dalam daftar Static IP address, pilih Let me choose.
• Di kolom Custom IP address, masukkan 10.1.2.99.
• Pilih Reservasi.
2. Klik Done.
3. Untuk menambahkan aturan penerusan kedua, klik Add frontend IP and port.
1. Berikan Name untuk aturan penerusan.
2. Di daftar Subnetwork region, pilih REGION_B.
   

   Mereservasi subnet khusus proxy

Karena Anda telah mengonfigurasi subnet khusus proxy, tombol Reserve subnet tidak ditampilkan. Anda dapat melanjutkan ke langkah berikutnya.
3. Dalam daftar Subnetwork, pilih SUBNET_B.
4. Dalam daftar IP address, klik Create IP address. Halaman Reserve a static internal IP address akan terbuka.
• Berikan Name untuk alamat IP statis.
• Dalam daftar Static IP address, pilih Let me choose.
• Di kolom Custom IP address, masukkan 10.1.3.99.
• Pilih Reservasi.
4. Klik Done.

Untuk HTTPS:

Jika menggunakan HTTPS antara klien dan load balancer, Anda memerlukan satu atau beberapa resource sertifikat SSL untuk mengonfigurasi proxy. Untuk membuat sertifikat yang dikelola Google all-regions, lihat dokumentasi berikut:

• Buat sertifikat yang dikelola Google yang diterbitkan oleh instance Layanan Certificate Authority Anda.
• Buat sertifikat yang dikelola Google dengan otorisasi DNS.

Setelah Anda membuat sertifikat yang dikelola Google, lampirkan sertifikat langsung ke proxy target. Peta sertifikat tidak didukung oleh Load Balancer Aplikasi internal lintas region.

Untuk membuat sertifikat yang dikelola sendiri all-regions, lihat dokumentasi berikut: Men-deploy sertifikat yang dikelola sendiri secara regional.

1. Klik Frontend configuration.
1. Berikan Name untuk aturan penerusan.
2. Pada kolom Protocol, pilih HTTPS (includes HTTP/2).
3. Pastikan Port disetel ke 443.
4. Di daftar Subnetwork region, pilih REGION_A.
   

   Mereservasi subnet khusus proxy

Karena Anda telah mengonfigurasi subnet khusus proxy, tombol Reserve subnet tidak ditampilkan. Anda dapat melanjutkan ke langkah berikutnya.
5. Dalam daftar Subnetwork, pilih SUBNET_A.
6. Dalam daftar IP address, klik Create IP address. Halaman Reserve a static internal IP address akan terbuka.
• Berikan Name untuk alamat IP statis.
• Dalam daftar Static IP address, pilih Let me choose.
• Di kolom Custom IP address, masukkan 10.1.3.99.
• Pilih Reservasi.
7. Di bagian Tambahkan sertifikat, pilih sertifikat.
8. Opsional: Untuk menambahkan sertifikat selain sertifikat SSL utama:
1. Klik Add certificate.
2. Pilih sertifikat dari daftar.
9. Pilih kebijakan SSL dari daftar Kebijakan SSL. Jika Anda belum membuat kebijakan SSL, kebijakan SSL Google Cloud default akan diterapkan.
10. Klik Done.

Tambahkan konfigurasi frontend kedua:

1. Berikan Name untuk konfigurasi frontend.
2. Pada kolom Protocol, pilih HTTPS (includes HTTP/2).
3. Pastikan Port disetel ke 443.
4. Di daftar Subnetwork region, pilih REGION_B.
   

   Mereservasi subnet khusus proxy

Karena Anda telah mengonfigurasi subnet khusus proxy, tombol Reserve subnet tidak ditampilkan. Anda dapat melanjutkan ke langkah berikutnya.
5. Dalam daftar Subnetwork, pilih SUBNET_B.
6. Dalam daftar IP address, klik Create IP address. Halaman Reserve a static internal IP address akan terbuka.
• Berikan Name untuk alamat IP statis.
• Dalam daftar Static IP address, pilih Let me choose.
• Di kolom Custom IP address, masukkan 10.1.3.99.
• Pilih Reservasi.
7. Di bagian Tambahkan sertifikat, pilih sertifikat.
8. Opsional: Untuk menambahkan sertifikat selain sertifikat SSL utama:
1. Klik Add certificate.
2. Pilih sertifikat dari daftar.
9. Pilih kebijakan SSL dari daftar Kebijakan SSL. Jika Anda belum membuat kebijakan SSL, kebijakan SSL Google Cloud default akan diterapkan.
10. Klik Done.
Mengonfigurasi layanan backend
1. Klik Backend configuration.
2. Dalam daftar Create or select backend services, klik Create a backend service.
3. Berikan Nama untuk layanan backend.
4. Untuk Protocol, pilih HTTP.
5. Untuk Named Port, masukkan http.
6. Dalam daftar Backend type, pilih Instance group.
7. Di bagian New backend:
• Dalam daftar Instance group, pilih gl4-ilb-miga di REGION_A.
• Setel Transfer nomor ke 80.
• Klik Done.
• Untuk menambahkan backend lain, klik Tambahkan backend.
• Dalam daftar Instance group, pilih gl4-ilb-migb di REGION_B.
• Setel Transfer nomor ke 80.
• Klik Done.
8. Di daftar Health check, klik Create a health check.
• Di kolom Name, masukkan global-http-health-check.
• Tetapkan Protokol ke HTTP.
• Tetapkan Port ke 80.
• Klik Simpan.

Mengonfigurasi aturan pemilihan rute

1. Klik Routing rules.
2. Untuk Mode, pilih Simple host and path rule.
3. Pastikan hanya ada satu layanan backend untuk semua host dan jalur yang tidak cocok.

Meninjau konfigurasi

1. Klik Review and finalize.
2. Tinjau setelan konfigurasi load balancer Anda.
3. Klik Create.

gcloud

1. Tentukan health check HTTP dengan perintah gcloud compute health-checks create http.

   gcloud compute health-checks create http global-http-health-check \
      --use-serving-port \
      --global
   

2. Tentukan layanan backend dengan perintah gcloud compute backend-services create.

   gcloud compute backend-services create BACKEND_SERVICE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=HTTP \
     --enable-logging \
     --logging-sample-rate=1.0 \
     --health-checks=global-http-health-check \
     --global-health-checks \
     --global
   

3. Tambahkan backend ke layanan backend dengan perintah gcloud compute backend-services add-backend.

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
     --balancing-mode=UTILIZATION \
     --instance-group=gl7-ilb-mig-a \
     --instance-group-zone=ZONE_A \
     --global
   

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
     --balancing-mode=UTILIZATION \
     --instance-group=gl7-ilb-mig-b \
     --instance-group-zone=ZONE_B \
     --global
   

4. Buat peta URL dengan perintah gcloud compute url-maps create.

   gcloud compute url-maps create gl7-gilb-url-map \
     --default-service=BACKEND_SERVICE_NAME \
     --global
   

5. Buat proxy target.

   Untuk HTTP:

   Buat proxy target dengan perintah gcloud compute target-http-proxies create.

   gcloud compute target-http-proxies create gil7-http-proxy \
     --url-map=gl7-gilb-url-map \
     --global
   

   Untuk HTTPS:

   Untuk membuat sertifikat yang dikelola Google, lihat dokumentasi berikut:

   • Buat sertifikat yang dikelola Google yang diterbitkan oleh instance Layanan Certificate Authority Anda.
   • Buat sertifikat yang dikelola Google dengan otorisasi DNS.

   Setelah membuat sertifikat yang dikelola Google, lampirkan sertifikat langsung ke proxy target. Peta sertifikat tidak didukung oleh Load Balancer Aplikasi internal lintas region.

   Untuk membuat sertifikat yang dikelola sendiri, lihat dokumentasi berikut:

   • Buat kunci pribadi dan sertifikat.

   Menetapkan jalur file ke nama variabel.

   export LB_CERT=PATH_TO_PEM_FORMATTED_FILE
   

   export LB_PRIVATE_KEY=PATH_TO_LB_PRIVATE_KEY_FILE
   

   Buat sertifikat SSL untuk semua region menggunakan perintah gcloud beta certificate-manager certificates create.

   gcloud certificate-manager certificates create gilb-certificate \
     --private-key-file=$LB_PRIVATE_KEY \
     --certificate-file=$LB_CERT \
     --scope=all-regions
   

   Gunakan sertifikat SSL untuk membuat proxy target dengan perintah gcloud compute target-https-proxies create

   gcloud compute target-https-proxies create gil7-https-proxy \
     --url-map=gl7-gilb-url-map \
     --certificate-manager-certificates=gilb-certificate \
     --global
   

6. Buat dua aturan penerusan, satu dengan VIP (10.1.2.99) di region REGION_B dan satu lagi dengan VIP (10.1.3.99) di region REGION_A. Untuk mengetahui informasi selengkapnya, lihat Mencadangkan alamat IPv4 internal statis.

   Untuk jaringan kustom, Anda harus mereferensikan subnet dalam aturan penerusan. Perhatikan bahwa ini adalah subnet VM, bukan subnet proxy.

   Untuk HTTP:

   Gunakan perintah gcloud compute forwarding-rules create dengan flag yang benar.

   gcloud compute forwarding-rules create FWRULE_A \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --subnet-region=REGION_A \
     --address=10.1.2.99 \
     --ports=80 \
     --target-http-proxy=gil7-http-proxy \
     --global
   

   gcloud compute forwarding-rules create FWRULE_B \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_B \
     --subnet-region=REGION_B \
     --address=10.1.3.99 \
     --ports=80 \
     --target-http-proxy=gil7-http-proxy \
     --global
   

   Untuk HTTPS:

   Gunakan perintah gcloud compute forwarding-rules create dengan flag yang benar.

   gcloud compute forwarding-rules create FWRULE_A \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --subnet-region=REGION_A \
     --address=10.1.2.99 \
     --ports=443 \
     --target-https-proxy=gil7-https-proxy \
     --global
   

   gcloud compute forwarding-rules create FWRULE_B \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_B \
     --subnet-region=REGION_B \
     --address=10.1.3.99 \
     --ports=443 \
     --target-https-proxy=gil7-https-proxy \
     --global
   

Terraform

Untuk membuat health check, gunakan resource google_compute_health_check.

resource "google_compute_health_check" "default" {
  provider = google-beta
  name     = "global-http-health-check"
  http_health_check {
    port_specification = "USE_SERVING_PORT"
  }
}

Untuk membuat layanan backend, gunakan resource google_compute_backend_service.

resource "google_compute_backend_service" "default" {
  name                  = "gl7-gilb-backend-service"
  provider              = google-beta
  protocol              = "HTTP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  timeout_sec           = 10
  health_checks         = [google_compute_health_check.default.id]
  backend {
    group           = google_compute_region_instance_group_manager.mig_a.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
  backend {
    group           = google_compute_region_instance_group_manager.mig_b.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

Untuk membuat peta URL, gunakan resource google_compute_url_map.

resource "google_compute_url_map" "default" {
  name            = "gl7-gilb-url-map"
  provider        = google-beta
  default_service = google_compute_backend_service.default.id
}

Untuk membuat proxy HTTP target, gunakan resource google_compute_target_http_proxy.

resource "google_compute_target_http_proxy" "default" {
  name     = "gil7target-http-proxy"
  provider = google-beta
  url_map  = google_compute_url_map.default.id
}

Untuk membuat aturan penerusan, gunakan resource google_compute_forwarding_rule.

resource "google_compute_global_forwarding_rule" "fwd_rule_a" {
  provider              = google-beta
  depends_on            = [google_compute_subnetwork.proxy_subnet_a]
  ip_address            = "10.1.2.99"
  ip_protocol           = "TCP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  name                  = "gil7forwarding-rule-a"
  network               = google_compute_network.default.id
  port_range            = "80"
  target                = google_compute_target_http_proxy.default.id
  subnetwork            = google_compute_subnetwork.subnet_a.id
}

resource "google_compute_global_forwarding_rule" "fwd_rule_b" {
  provider              = google-beta
  depends_on            = [google_compute_subnetwork.proxy_subnet_b]
  ip_address            = "10.1.3.99"
  ip_protocol           = "TCP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  name                  = "gil7forwarding-rule-b"
  network               = google_compute_network.default.id
  port_range            = "80"
  target                = google_compute_target_http_proxy.default.id
  subnetwork            = google_compute_subnetwork.subnet_b.id
}

Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform.

API

Buat health check dengan membuat permintaan POST ke metode healthChecks.insert, mengganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/healthChecks

{
"name": "global-http-health-check",
"type": "HTTP",
"httpHealthCheck": {
  "portSpecification": "USE_SERVING_PORT"
}
}

Buat layanan backend global dengan membuat permintaan POST ke metode backendServices.insert, mengganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices

{
"name": "BACKEND_SERVICE_NAME",
"backends": [
  {
    "group": "projects/PROJECT_ID/zones/ZONE_A/instanceGroups/gl7-ilb-mig-a",
    "balancingMode": "UTILIZATION"
  },
  {
    "group": "projects/PROJECT_ID/zones/ZONE_B/instanceGroups/gl7-ilb-mig-b",
    "balancingMode": "UTILIZATION"
  }
],
"healthChecks": [
  "projects/PROJECT_ID/regions/global/healthChecks/global-http-health-check"
],
"loadBalancingScheme": "INTERNAL_MANAGED"
}

Buat peta URL dengan membuat permintaan POST ke metode urlMaps.insert, dengan mengganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/urlMaps

{
"name": "l7-ilb-map",
"defaultService": "projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME"
}

Untuk HTTP:

Buat proxy HTTP target dengan membuat permintaan POST ke metode targetHttpProxies.insert, ganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/targetHttpProxy

{
"name": "l7-ilb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map"
}

Buat aturan penerusan dengan membuat permintaan POST ke metode forwardingRules.insert, dengan mengganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules

{
"name": "FWRULE_A",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules

{
"name": "gil7forwarding-rule-b",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

Untuk HTTPS:

Baca file sertifikat dan kunci pribadi, lalu buat sertifikat SSL. Contoh berikut menunjukkan cara melakukannya dengan Python.

from pathlib import Path
from pprint import pprint
from typing import Union

from googleapiclient import discovery


def create_regional_certificate(
    project_id: str,
    region: str,
    certificate_file: Union[str, Path],
    private_key_file: Union[str, Path],
    certificate_name: str,
    description: str = "Certificate created from a code sample.",
) -> dict:
    """
    Create a regional SSL self-signed certificate within your Google Cloud project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use.
        certificate_file: path to the file with the certificate you want to create in your project.
        private_key_file: path to the private key you used to sign the certificate with.
        certificate_name: name for the certificate once it's created in your project.
        description: description of the certificate.

        Returns:
        Dictionary with information about the new regional SSL self-signed certificate.
    """
    service = discovery.build("compute", "v1")

    # Read the cert into memory
    with open(certificate_file) as f:
        _temp_cert = f.read()

    # Read the private_key into memory
    with open(private_key_file) as f:
        _temp_key = f.read()

    # Now that the certificate and private key are in memory, you can create the
    # certificate resource
    ssl_certificate_body = {
        "name": certificate_name,
        "description": description,
        "certificate": _temp_cert,
        "privateKey": _temp_key,
    }
    request = service.regionSslCertificates().insert(
        project=project_id, region=region, body=ssl_certificate_body
    )
    response = request.execute()
    pprint(response)

    return response

Buat proxy HTTPS target dengan membuat permintaan POST ke metode targetHttpsProxies.insert, mengganti PROJECT_ID dengan ID project Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/targetHttpsProxy

{
"name": "l7-ilb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map",
"sslCertificates": /projects/PROJECT_ID/global/sslCertificates/SSL_CERT_NAME
}

Buat aturan penerusan dengan membuat permintaan POST ke metode globalForwardingRules.insert, dengan mengganti PROJECT_ID dengan project ID Anda.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules

{
"name": "FWRULE_A",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpsProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules

{
"name": "FWRULE_B",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpsProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

Menguji load balancer

Membuat instance VM untuk menguji konektivitas

1. Buat VM klien:

   gcloud compute instances create l7-ilb-client-a \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --network=NETWORK \
       --subnet=SUBNET_A \
       --zone=ZONE_A \
       --tags=allow-ssh
   

   gcloud compute instances create l7-ilb-client-b \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --network=NETWORK \
       --subnet=SUBNET_B \
       --zone=ZONE_B \
       --tags=allow-ssh
   

2. Gunakan SSH untuk terhubung ke setiap instance klien.

   gcloud compute ssh l7-ilb-client-a --zone=ZONE_A
   

   gcloud compute ssh l7-ilb-client-b --zone=ZONE_B
   

3. Memverifikasi bahwa alamat IP menyalurkan nama host-nya

   • Pastikan VM klien dapat menjangkau kedua alamat IP. Perintah ini menampilkan nama VM backend yang melayani permintaan:

     curl 10.1.2.99
     

     curl 10.1.3.99
     

     Untuk pengujian HTTPS, ganti curl dengan command line berikut:

     curl -k 'https://test.example.com:443' --connect-to test.example.com:443:10.1.2.99:443
     

     curl -k 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443
     

     Flag -k menyebabkan curl melewati validasi sertifikat.

   • Opsional: Gunakan data DNS yang dikonfigurasi untuk me-resolve alamat IP terdekat dengan VM klien. Misalnya, DNS_NAME dapat berupa service.example.com.

     curl DNS_NAME
     

Jalankan 100 permintaan dan pastikan semuanya di-load balance

Untuk HTTP:

  {
    RESULTS=
    for i in {1..100}
    do
        RESULTS="$RESULTS:$(curl --silent 10.1.2.99)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.2.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }
  

  {
    RESULTS=
    for i in {1..100}
    do
      RESULTS="$RESULTS:$(curl --silent 10.1.3.99)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.3.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }
  

Untuk HTTPS:

  {
    RESULTS=
    for i in {1..100}
    do
      RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.2.99:443)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.2.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }
  

  {
    RESULTS=
    for i in {1..100}
    do
       RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.3.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }
  

Menguji failover

1. Verifikasi failover ke backend di region REGION_A saat backend di REGION_B bermasalah atau tidak dapat dijangkau. Untuk menyimulasikan failover, hapus semua backend dari REGION_B:

   gcloud compute backend-services remove-backend BACKEND_SERVICE_NAME \
      --balancing-mode=UTILIZATION \
      --instance-group=gl7-ilb-mig-b \
      --instance-group-zone=ZONE_B
   

2. Hubungkan menggunakan SSH ke VM klien di REGION_B.

   gcloud compute ssh l7-ilb-client-b \
      --zone=ZONE_B
   

3. Kirim permintaan ke alamat IP load balanced di region REGION_B. Output perintah menampilkan respons dari VM backend di REGION_A:

   {
   RESULTS=
   for i in {1..100}
   do
     RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443)"
   done
   echo "***"
   echo "*** Results of load-balancing to 10.1.3.99: "
   echo "***"
   echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
   echo
   }
   

Opsi konfigurasi tambahan

Bagian ini memperluas contoh konfigurasi untuk memberikan opsi konfigurasi alternatif dan tambahan. Semua tugas bersifat opsional. Anda dapat melakukannya dalam urutan apa pun.

Mengaktifkan afinitas sesi

Prosedur ini menunjukkan cara mengupdate layanan backend untuk contoh Load Balancer Aplikasi internal regional atau Load Balancer Aplikasi internal lintas region sehingga layanan backend menggunakan afinitas cookie yang dihasilkan, afinitas kolom header, atau afinitas cookie HTTP.

Jika afinitas cookie yang dihasilkan diaktifkan, load balancer akan mengeluarkan cookie pada permintaan pertama. Untuk setiap permintaan berikutnya dengan cookie yang sama, load balancer akan mengarahkan permintaan ke instance atau endpoint virtual machine (VM) backend yang sama. Dalam contoh ini, cookie diberi nama GCILB.

Jika afinitas kolom header diaktifkan, load balancer akan merutekan permintaan ke VM atau endpoint backend dalam grup endpoint jaringan (NEG) berdasarkan nilai header HTTP yang diberi nama dalam flag --custom-request-header. Afinitas kolom header hanya valid jika kebijakan lokalitas load balancing adalah RING_HASH atau MAGLEV dan hash konsisten layanan backend menentukan nama header HTTP.

Jika afinitas cookie HTTP diaktifkan, load balancer akan merutekan permintaan ke VM atau endpoint backend dalam NEG, berdasarkan cookie HTTP yang diberi nama dalam tanda HTTP_COOKIE dengan tanda --affinity-cookie-ttl opsional. Jika klien tidak memberikan cookie dalam permintaan HTTP-nya, proxy akan membuat cookie dan menampilkannya kepada klien dalam header Set-Cookie. Afinitas cookie HTTP hanya valid jika kebijakan lokalitas load balancing adalah RING_HASH atau MAGLEV dan hash konsisten layanan backend menentukan cookie HTTP.

Konsol

Untuk mengaktifkan atau mengubah afinitas sesi untuk layanan backend:

1. Di konsol Google Cloud, buka halaman Load balancing.

   Buka Load balancing

2. Klik Backend.
3. Klik gil7-backend-service (nama layanan backend yang Anda buat untuk contoh ini), lalu klik Edit.
4. Di halaman Detail layanan backend, klik Konfigurasi lanjutan.
5. Di bagian Afinitas sesi, pilih jenis afinitas sesi yang Anda inginkan.
6. Klik Perbarui.

gcloud

Gunakan perintah Google Cloud CLI berikut untuk mengupdate layanan backend ke berbagai jenis afinitas sesi:

    gcloud compute backend-services update gil7-backend-service \
        --session-affinity=[GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | CLIENT_IP] \
        --global
    

API

Untuk menetapkan afinitas sesi, buat permintaan `PATCH` ke metode backendServices/patch.

    PATCH https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/backendServices/gil7-backend-service
    {
    "sessionAffinity": ["GENERATED_COOKIE" | "HEADER_FIELD" | "HTTP_COOKIE" | "CLIENT_IP" ]
    }
    

Membatasi klien yang dapat mengirim traffic ke load balancer

Anda dapat membatasi klien agar tidak terhubung ke VIP aturan penerusan Load Balancer Aplikasi internal dengan mengonfigurasi aturan firewall keluar di klien ini. Tetapkan aturan firewall ini di VM klien tertentu berdasarkan akun layanan atau tag.

Anda tidak dapat menggunakan aturan firewall untuk membatasi traffic masuk ke VIP aturan penerusan Load Balancer Aplikasi internal tertentu. Setiap klien di jaringan VPC yang sama dan di region yang sama dengan VIP aturan penerusan umumnya dapat mengirim traffic ke VIP aturan penerusan.

Selain itu, semua permintaan ke backend berasal dari proxy yang menggunakan alamat IP dalam rentang subnet khusus proxy. Anda tidak dapat membuat aturan firewall yang mengizinkan atau menolak traffic masuk di backend ini berdasarkan VIP aturan penerusan yang digunakan oleh klien.

Berikut beberapa contoh cara menggunakan aturan firewall keluar untuk membatasi traffic ke VIP aturan penerusan load balancer.

Konsol

Untuk mengidentifikasi VM klien, beri tag pada VM tertentu yang ingin Anda batasi. Tag ini digunakan untuk mengaitkan aturan firewall dengan VM klien yang diberi tag. Kemudian, tambahkan tag ke kolom TARGET_TAG dalam langkah-langkah berikut.

Gunakan satu aturan firewall atau beberapa aturan untuk menyiapkannya.

Satu aturan firewall keluar

Anda dapat mengonfigurasi satu aturan keluar firewall untuk menolak semua traffic keluar yang berasal dari VM klien yang diberi tag ke VIP load balancer.

1. Di konsol Google Cloud, buka halaman Firewall rules.

   Buka Aturan firewall

2. Klik Create firewall rule untuk membuat aturan guna menolak traffic keluar dari VM klien yang diberi tag ke VIP load balancer.

   • Nama: fr-deny-access
   • Jaringan: lb-network
   • Prioritas: 100
   • Direction of traffic: Egress
   • Action on match: Deny
   • Targets: Tag target yang ditentukan
   • Tag target: TARGET_TAG
   • Filter tujuan: Rentang IP
   • Rentang IP tujuan: 10.1.2.99
   • Protokol dan port:
     • Pilih Protokol dan port yang ditentukan.
     • Pilih kotak centang tcp, lalu masukkan 80 untuk nomor port.

3. Klik Create.

Beberapa aturan firewall keluar

Pendekatan yang lebih skalabel melibatkan penetapan dua aturan. Aturan default dengan prioritas rendah yang membatasi semua klien agar tidak mengakses VIP load balancer. Aturan kedua dengan prioritas lebih tinggi yang memungkinkan sebagian klien yang diberi tag untuk mengakses VIP load balancer. Hanya VM yang diberi tag yang dapat mengakses VIP.

1. Di konsol Google Cloud, buka halaman Firewall rules.

   Buka Aturan firewall

2. Klik Create firewall rule untuk membuat aturan prioritas yang lebih rendah guna menolak akses secara default:

   • Nama: fr-deny-all-access-low-priority
   • Jaringan: lb-network
   • Prioritas: 200
   • Direction of traffic: Egress
   • Action on match: Deny
   • Targets: Tag target yang ditentukan
   • Tag target: TARGET_TAG
   • Filter tujuan: Rentang IP
   • Rentang IP tujuan: 10.1.2.99
   • Protokol dan port:
     • Pilih Protokol dan port yang ditentukan.
     • Pilih kotak centang TCP, lalu masukkan 80 untuk nomor port.

3. Klik Create.

4. Klik Create firewall rule untuk membuat aturan prioritas yang lebih tinggi guna mengizinkan traffic dari instance tertentu yang diberi tag.

   • Nama: fr-allow-some-access-high-priority
   • Jaringan: lb-network
   • Prioritas: 100
   • Direction of traffic: Egress
   • Action on match: Allow
   • Targets: Tag target yang ditentukan
   • Tag target: TARGET_TAG
   • Filter tujuan: Rentang IP
   • Rentang IP tujuan: 10.1.2.99
   • Protokol dan port:
     • Pilih Protokol dan port yang ditentukan.
     • Pilih kotak centang TCP, lalu masukkan 80 untuk nomor port.

5. Klik Create.

gcloud

Untuk mengidentifikasi VM klien, beri tag pada VM tertentu yang ingin Anda batasi. Kemudian, tambahkan tag ke kolom TARGET_TAG dalam langkah-langkah ini.

Gunakan satu aturan firewall atau beberapa aturan untuk menyiapkannya.

Satu aturan firewall keluar

Anda dapat mengonfigurasi satu aturan keluar firewall untuk menolak semua traffic keluar yang berasal dari VM klien yang diberi tag ke VIP load balancer.

gcloud compute firewall-rules create fr-deny-access \
  --network=lb-network \
  --action=deny \
  --direction=egress \
  --rules=tcp \
  --priority=100 \
  --destination-ranges=10.1.2.99 \
  --target-tags=TARGET_TAG

Beberapa aturan firewall keluar

Pendekatan yang lebih skalabel melibatkan penetapan dua aturan: aturan default dengan prioritas rendah yang membatasi semua klien agar tidak mengakses VIP load balancer, dan aturan kedua dengan prioritas lebih tinggi yang memungkinkan sebagian klien yang diberi tag untuk mengakses VIP load balancer. Hanya VM yang diberi tag yang dapat mengakses VIP.

1. Buat aturan prioritas yang lebih rendah:

   gcloud compute firewall-rules create fr-deny-all-access-low-priority \
     --network=lb-network \
     --action=deny \
     --direction=egress \
     --rules=tcp \
     --priority=200 \
     --destination-ranges=10.1.2.99
   

2. Buat aturan prioritas yang lebih tinggi:

   gcloud compute firewall-rules create fr-allow-some-access-high-priority \
     --network=lb-network \
     --action=allow \
     --direction=egress \
     --rules=tcp \
     --priority=100 \
     --destination-ranges=10.1.2.99 \
     --target-tags=TARGET_TAG
   

Untuk menggunakan akun layanan, bukan tag, guna mengontrol akses, gunakan opsi --target-service-accounts, bukan flag --target-tags saat membuat aturan firewall.

Menskalakan akses terbatas ke backend Load Balancer Aplikasi internal berdasarkan subnet

Mengelola aturan firewall terpisah atau menambahkan alamat IP load-balanced baru ke aturan yang ada seperti yang dijelaskan di bagian sebelumnya menjadi tidak praktis seiring meningkatnya jumlah aturan penerusan. Salah satu cara untuk mencegahnya adalah dengan mengalokasikan alamat IP aturan penerusan dari subnet yang dicadangkan. Kemudian, traffic dari instance atau akun layanan yang diberi tag dapat diizinkan atau diblokir dengan menggunakan subnet yang dicadangkan sebagai rentang tujuan untuk aturan firewall. Hal ini memungkinkan Anda mengontrol akses ke grup VIP aturan penerusan secara efektif tanpa harus mempertahankan aturan keluar firewall per VIP.

Berikut adalah langkah-langkah tingkat tinggi untuk menyiapkannya, dengan asumsi bahwa Anda akan membuat semua resource load balancer lain yang diperlukan secara terpisah.

gcloud

1. Buat subnet regional yang akan digunakan untuk mengalokasikan alamat IP load-balanced untuk aturan penerusan:

   gcloud compute networks subnets create l7-ilb-restricted-subnet \
     --network=lb-network \
     --region=us-west1 \
     --range=10.127.0.0/24
   

2. Buat aturan penerusan yang mengambil alamat dari subnet. Contoh berikut menggunakan alamat 10.127.0.1 dari subnet yang dibuat pada langkah sebelumnya.

   gcloud compute forwarding-rules create l7-ilb-forwarding-rule-restricted \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=lb-network \
     --subnet=l7-ilb-restricted-subnet \
     --address=10.127.0.1 \
     --ports=80 \
     --global \
     --target-http-proxy=gil7-http-proxy
   

3. Buat aturan firewall untuk membatasi traffic yang ditujukan ke alamat IP rentang di subnet aturan penerusan (l7-ilb-restricted-subnet):

   gcloud compute firewall-rules create restrict-traffic-to-subnet \
     --network=lb-network \
     --action=deny \
     --direction=egress \
     --rules=tcp:80 \
     --priority=100 \
     --destination-ranges=10.127.0.0/24 \
     --target-tags=TARGET_TAG
   

Menggunakan alamat IP yang sama di antara beberapa aturan penerusan internal

Agar beberapa aturan penerusan internal dapat menggunakan alamat IP internal yang sama, Anda harus mencadangkan alamat IP dan menetapkan tanda --purpose-nya ke SHARED_LOADBALANCER_VIP.

gcloud

gcloud compute addresses create SHARED_IP_ADDRESS_NAME \
    --region=REGION \
    --subnet=SUBNET_NAME \
    --purpose=SHARED_LOADBALANCER_VIP

Jika perlu mengalihkan traffic HTTP ke HTTPS, Anda dapat membuat dua aturan penerusan yang menggunakan alamat IP umum. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan pengalihan HTTP ke HTTPS untuk Load Balancer Aplikasi internal.

Mengonfigurasi kebijakan pemilihan rute DNS

Jika klien Anda berada di beberapa region, Anda dapat membuat Load Balancer Aplikasi internal lintas region dapat diakses menggunakan VIP di region tersebut. Penyiapan multi-region ini meminimalkan latensi dan biaya transit jaringan. Selain itu, solusi ini memungkinkan Anda menyiapkan solusi load balancing global berbasis DNS yang memberikan ketahanan terhadap pemadaman layanan regional. Untuk mengetahui informasi selengkapnya, lihat Mengelola kebijakan pemilihan rute DNS dan health check.

gcloud

Untuk membuat entri DNS dengan TTL 30 detik, gunakan perintah gcloud dns record-sets create.

gcloud dns record-sets create DNS_ENTRY --ttl="30" \
  --type="A" --zone="service-zone" \
  --routing-policy-type="GEO" \
  --routing-policy-data="REGION_A=gil7-forwarding-rule-a@global;REGION_B=gil7-forwarding-rule-b@global" \
  --enable-health-checking

Ganti kode berikut:

• DNS_ENTRY: DNS atau nama domain set data

  Contoh, service.example.com

• REGION_A dan REGION_B: region tempat Anda mengonfigurasi load balancer

API

Buat data DNS dengan membuat permintaan POST ke metode ResourceRecordSets.create. Ganti PROJECT_ID dengan project ID Anda.

POST https://www.googleapis.com/dns/v1/projects/PROJECT_ID/managedZones/SERVICE_ZONE/rrsets
{
  "name": "DNS_ENTRY",
  "type": "A",
  "ttl": 30,
  "routingPolicy": {
    "geo": {
      "items": [
        {
          "location": "REGION_A",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        },
        {
          "location": "REGION_B",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS_B",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        }
      ]
    }
  }
}

Memperbarui waktu tunggu keepalive HTTP klien

Load balancer yang dibuat pada langkah sebelumnya telah dikonfigurasi dengan nilai default untuk waktu tunggu keepalive HTTP klien.

Untuk memperbarui waktu tunggu keepalive HTTP klien, gunakan petunjuk berikut.

Konsol

1. Di konsol Google Cloud, buka halaman Load balancing.

   Buka Load balancing.

2. Klik nama load balancer yang ingin diubah.
3. Klik Edit.
4. Klik Frontend configuration.
5. Luaskan Fitur lanjutan. Untuk Timeout keepalive HTTP, masukkan nilai waktu tunggu.
6. Klik Perbarui.
7. Untuk meninjau perubahan, klik Tinjau dan selesaikan, lalu klik Perbarui.

gcloud

Untuk load balancer HTTP, perbarui proxy HTTP target menggunakan perintah gcloud compute target-http-proxies update:

    gcloud compute target-http-proxies update TARGET_HTTP_PROXY_NAME \
        --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
        --global
    

Untuk load balancer HTTPS, perbarui proxy HTTPS target menggunakan perintah gcloud compute target-https-proxies update:

    gcloud compute target-https-proxies update TARGET_HTTPS_PROXY_NAME \
        --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
        --global
    

Ganti kode berikut:

• TARGET_HTTP_PROXY_NAME: nama proxy HTTP target.
• TARGET_HTTPS_PROXY_NAME: nama proxy HTTPS target.
• HTTP_KEEP_ALIVE_TIMEOUT_SEC: nilai waktu tunggu keepalive HTTP dari 5 hingga 600 detik.

Mengaktifkan deteksi pencilan

Anda dapat mengaktifkan deteksi anomali di layanan backend global untuk mengidentifikasi NEG tanpa server yang tidak responsif dan mengurangi jumlah permintaan yang dikirim ke NEG tanpa server yang tidak responsif.

Deteksi outlier diaktifkan di layanan backend menggunakan salah satu metode berikut:

• Metode consecutiveErrors (outlierDetection.consecutiveErrors), yang menjadikan kode status HTTP seri 5xx memenuhi syarat sebagai error.
• Metode consecutiveGatewayFailure (outlierDetection.consecutiveGatewayFailure), yang hanya mengizinkan kode status HTTP 502, 503, dan 504 sebagai error.

Gunakan langkah-langkah berikut untuk mengaktifkan deteksi outlier untuk layanan backend yang ada. Perhatikan bahwa meskipun setelah mengaktifkan deteksi outlier, beberapa permintaan dapat dikirim ke layanan yang tidak responsif dan menampilkan kode status 5xx ke klien. Untuk lebih mengurangi rasio error, Anda dapat mengonfigurasi nilai yang lebih agresif untuk parameter deteksi outlier. Untuk mengetahui informasi selengkapnya, lihat kolom outlierDetection.

Konsol

1. Di konsol Google Cloud, buka halaman Load balancing.

   Buka Load balancing

2. Klik nama load balancer yang layanan backend-nya ingin Anda edit.

3. Di halaman Detail load balancer, klik Edit.

4. Di halaman Edit cross-region internal Application Load Balancer, klik Backend configuration.

5. Di halaman Backend configuration, klik Edit untuk layanan backend yang ingin Anda ubah.

6. Scroll ke bawah, lalu luaskan bagian Advanced configurations.

7. Di bagian Deteksi outlier, centang kotak Enable.

8. Klik Edit untuk mengonfigurasi deteksi pencilan.

   Pastikan opsi berikut dikonfigurasi dengan nilai ini:

   Properti	Nilai
   Error berturut-turut	5
   Interval	1000
   Waktu ejeksi dasar	30000
   Persentase ejeksi maksimum	50
   Error berturut-turut yang berlaku	100

   Dalam contoh ini, analisis deteksi outlier berjalan setiap satu detik. Jika jumlah kode status 5xx HTTP berturut-turut yang diterima oleh proxy Envoy adalah lima atau lebih, endpoint backend akan dikeluarkan dari kumpulan load balancing proxy Envoy tersebut selama 30 detik. Jika persentase penerapan ditetapkan ke 100%, layanan backend akan menerapkan pengusiran endpoint yang tidak responsif dari kumpulan load balancing proxy Envoy tertentu setiap kali analisis deteksi outlier berjalan. Jika kondisi pengeluaran terpenuhi, hingga 50% endpoint backend dari kumpulan load balancing dapat dikeluarkan.

9. Klik Simpan.

10. Untuk memperbarui layanan backend, klik Update.

11. Untuk memperbarui load balancer, di halaman Edit cross-region internal Application Load Balancer, klik Update.

gcloud

1. Ekspor layanan backend ke file YAML.

   gcloud compute backend-services export BACKEND_SERVICE_NAME \
     --destination=BACKEND_SERVICE_NAME.yaml --global
   

   Ganti BACKEND_SERVICE_NAME dengan nama layanan backend.

2. Edit konfigurasi YAML layanan backend untuk menambahkan kolom untuk deteksi outlier seperti yang ditandai dalam konfigurasi YAML berikut, di bagian outlierDetection:

   Dalam contoh ini, analisis deteksi outlier berjalan setiap satu detik. Jika jumlah kode status 5xx HTTP berturut-turut yang diterima oleh proxy Envoy adalah lima atau lebih, endpoint backend akan dikeluarkan dari kumpulan load balancing proxy Envoy tersebut selama 30 detik. Jika persentase penerapan ditetapkan ke 100%, layanan backend akan menerapkan pengusiran endpoint yang tidak responsif dari kumpulan load balancing proxy Envoy tertentu setiap kali analisis deteksi outlier berjalan. Jika kondisi pengeluaran terpenuhi, hingga 50% endpoint backend dari kumpulan load balancing dapat dikeluarkan.

   name: BACKEND_SERVICE_NAME
   backends:
   - balancingMode: UTILIZATION
     capacityScaler: 1.0
     group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/networkEndpointGroups/SERVERLESS_NEG_NAME
   - balancingMode: UTILIZATION
     capacityScaler: 1.0
     group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/networkEndpointGroups/SERVERLESS_NEG_NAME_2
   outlierDetection:
     baseEjectionTime:
       nanos: 0
       seconds: 30
     consecutiveErrors: 5
     enforcingConsecutiveErrors: 100
     interval:
       nanos: 0
       seconds: 1
     maxEjectionPercent: 50
   port: 80
   selfLink: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME
   sessionAffinity: NONE
   timeoutSec: 30
   ...
   

   Ganti kode berikut:

   • BACKEND_SERVICE_NAME: nama layanan backend
   • PROJECT_ID: ID project Anda
   • REGION_A dan REGION_B: region tempat load balancer telah dikonfigurasi.
   • SERVERLESS_NEG_NAME: nama NEG tanpa server pertama
   • SERVERLESS_NEG_NAME_2: nama NEG serverless kedua

3. Perbarui layanan backend dengan mengimpor konfigurasi terbaru.

   gcloud compute backend-services import BACKEND_SERVICE_NAME \
     --source=BACKEND_SERVICE_NAME.yaml --global
   

   Deteksi pencilan kini diaktifkan di layanan backend.

Langkah selanjutnya

• Mengonversi Load Balancer Aplikasi ke IPv6
• Ringkasan Load Balancer Aplikasi Internal
• Subnet khusus proxy untuk load balancer berbasis Envoy
• Mengelola sertifikat
• Membersihkan penyiapan load balancing