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

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

Sebelum memulai

Sebelum mengikuti panduan ini, biasakan diri Anda dengan 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 berikut ini:

• Deploy sertifikat global yang dikelola sendiri.
• Buat sertifikat yang dikelola Google yang diterbitkan oleh instance Certificate Authority Service 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 sebuah project. Anda harus menjadi pemilik atau editor project, atau Anda harus memiliki semua peran IAM Compute Engine berikut.

Tugas	Peran yang diperlukan
Membuat jaringan, subnet, dan komponen 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 dalam diagram berikut:

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

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

Diagram menampilkan 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 region digunakan bersama oleh semua Load Balancer Aplikasi internal lintas region di region tersebut. Alamat sumber paket yang dikirim dari load balancer ke backend layanan 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 mengalami gangguan, traffic akan gagal 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 menggunakan HTTP atau HTTPS.

6. Aturan penerusan global, memiliki alamat IP internal regional dari 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 dan menetapkan flag --purpose-nya ke GLOBAL_MANAGED_PROXY.
   • Jika Anda ingin menggunakan alamat IP internal yang sama dengan beberapa aturan penerusan, tetapkan flag --purpose alamat IP ke SHARED_LOADBALANCER_VIP.

7. Opsional: Konfigurasi 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 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 region 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 selanjutnya dalam panduan ini akan 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 Subnets, tetapkan Subnet creation mode ke Custom.

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

   • Berikan Name untuk subnet.
   • Pilih Wilayah: 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 New subnet, masukkan informasi berikut:

   • Berikan Name untuk subnet.
   • Pilih Wilayah: 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 memberikan sekumpulan alamat IP yang digunakan Google Cloud untuk menjalankan proxy Envoy atas nama Anda. Proxy tersebut menghentikan koneksi dari klien dan membuat koneksi baru ke backend.

Subnet khusus proxy ini digunakan oleh semua load balancing regional berbasis Envoy di region yang sama dengan jaringan VPC. Hanya boleh ada satu subnet khusus proxy yang aktif untuk tujuan tertentu, per region, 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 (atau rentang subnet) yang berbeda, bukan yang ini. Google Cloud mencadangkan 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 VPC networks

2. Klik nama jaringan VPC.
3. Pada tab Subnet, klik Add subnet.
4. Berikan Nama untuk subnet khusus proxy.
5. Pilih Wilayah: REGION_A
6. Dalam daftar Destination, pilih Cross-region Managed Proxy.
7. Di kolom Rentang alamat IP, masukkan 10.129.0.0/23.
8. Klik Tambahkan.

Buat subnet khusus proxy di REGION_B

1. Pada tab Subnet, klik Add subnet.
2. Berikan Nama untuk subnet khusus proxy.
3. Pilih Wilayah: REGION_B
4. Dalam daftar Destination, pilih Cross-region Managed Proxy.
5. Di kolom Rentang alamat IP, 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, yang menggantikan 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 masuk, yang berlaku untuk instance yang mengalami load balancing, yang memungkinkan konektivitas SSH yang masuk pada port TCP 22 dari alamat apa pun. Anda dapat memilih rentang alamat IP sumber yang lebih ketat untuk aturan ini. Misalnya, Anda dapat menentukan hanya rentang alamat IP di sistem tempat Anda memulai sesi SSH. Contoh ini menggunakan tag target allow-ssh untuk mengidentifikasi VM yang menerapkan aturan firewall.

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

• fw-backends. Aturan masuk, yang berlaku untuk instance yang mengalami load balancing, yang memungkinkan traffic TCP pada port 80, 443, dan 8080 dari proxy yang dikelola 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 backend instance 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 akan mengizinkan koneksi SSH yang masuk:

   • Name: fw-ilb-to-backends
   • Jaringan: NETWORK
   • Arah traffic: Ingress
   • Tindakan jika kecocokan: Izinkan
   • 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 Specified protocols and ports.
     • Pilih kotak centang TCP, lalu masukkan 22 untuk nomor port.

3. Klik Create.

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

   • Name: fw-healthcheck
   • Jaringan: NETWORK
   • Arah traffic: Ingress
   • Tindakan jika kecocokan: Izinkan
   • 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 Specified protocols and ports.
     • 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 pada port 80 untuk menghubungi VM Anda, tetapi tidak dapat menggunakan HTTPS pada port 443 untuk menghubungi VM.

5. Klik Create.

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

   • Name: fw-backends
   • Jaringan: NETWORK
   • Arah traffic: Ingress
   • Tindakan jika kecocokan: Izinkan
   • 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 Specified protocols and ports.
     • Centang kotak 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 Load Balancer Aplikasi 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, yang mengganti 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, yang mengganti 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, yang mengganti 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 balanced ke server backend. Untuk tujuan demonstrasi, backend menyediakan nama host-nya sendiri.

Konsol

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

   Buka Instance templates

   1. Klik Create instance template.
   2. Untuk Name, masukkan gil7-backendeast1-template.
   3. Pastikan Boot disk disetel ke image Debian, seperti Debian GNU/Linux 10 (buster). 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 Tag jaringan, masukkan allow-ssh dan load-balanced-backend.
      2. Untuk Network interfaces, pilih opsi berikut:
         • Jaringan: NETWORK
         • Subnet: SUBNET_B

   6. Klik Management. Masukkan skrip berikut ke 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 10 (buster). 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 Tag jaringan, masukkan allow-ssh dan load-balanced-backend.
       2. Untuk Network interfaces, pilih opsi berikut:
          • Jaringan: NETWORK
          • Subnet: SUBNET_A

   13. Klik Management. Masukkan skrip berikut ke 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 grup instance.
   2. Pilih New managed instance group (stateless). Untuk mengetahui 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 Autoscaling:

      • 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 secara otomatis menambahkan atau menghapus instance berdasarkan penggunaan CPU instance.

   9. Klik Create.

   10. Klik Create grup instance.

   11. Pilih New managed instance group (stateless). Untuk mengetahui 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 Autoscaling:

       • 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 secara 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 yang telah menginstal bash.

1. Buat template instance VM dengan server HTTP menggunakan 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-10 \
     --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-10 \
       --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 dalam 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, dengan mengganti 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-10"
         },
         "autoDelete":true
       }
     ]
  }
}

Buat grup instance terkelola di setiap zona dengan metode instanceGroupManagers.insert, yang mengganti 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-10"
         },
         "autoDelete":true
       }
     ]
  }
}

Buat grup instance terkelola di setiap zona dengan metode instanceGroupManagers.insert, yang mengganti 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 masuk. Peta URL global dapat direferensikan 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 Anda

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 Terhadap publik atau internal, pilih Internal, lalu klik Berikutnya.
5. Untuk Cross-region or single region deployment, pilih Best for cross-region working, 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 Nama aturan penerusan.
2. Dalam daftar Subnetwork region, pilih REGION_A.
   

   Mencadangkan 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 Alamat IP, klik Buat alamat IP. Halaman Reserve a static internal IP address akan terbuka.
• Berikan Nama untuk alamat IP statis.
• Dalam daftar Alamat IP statis, pilih Biarkan saya pilih.
• Di kolom Alamat IP khusus, masukkan 10.1.2.99.
• Pilih Reserve.
2. Klik Done.
3. Untuk menambahkan aturan penerusan kedua, klik Tambahkan IP dan port frontend.
1. Berikan Nama aturan penerusan.
2. Dalam daftar Subnetwork region, pilih REGION_B.
   

   Mencadangkan 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 Alamat IP, klik Buat alamat IP. Halaman Reserve a static internal IP address akan terbuka.
• Berikan Nama untuk alamat IP statis.
• Dalam daftar Alamat IP statis, pilih Biarkan saya pilih.
• Di kolom Alamat IP khusus, masukkan 10.1.3.99.
• Pilih Reserve.
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 all-regions yang dikelola Google, lihat dokumentasi berikut:

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

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

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

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

   Mencadangkan 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 Alamat IP, klik Buat alamat IP. Halaman Reserve a static internal IP address akan terbuka.
• Berikan Nama untuk alamat IP statis.
• Dalam daftar Alamat IP statis, pilih Biarkan saya pilih.
• Di kolom Alamat IP khusus, masukkan 10.1.3.99.
• Pilih Reserve.
7. Di bagian Add certificate, 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. Dalam daftar Subnetwork region, pilih REGION_B.
   

   Mencadangkan 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 Alamat IP, klik Buat alamat IP. Halaman Reserve a static internal IP address akan terbuka.
• Berikan Nama untuk alamat IP statis.
• Dalam daftar Alamat IP statis, pilih Biarkan saya pilih.
• Di kolom Alamat IP khusus, masukkan 10.1.3.99.
• Pilih Reserve.
7. Di bagian Add certificate, 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 Port Bernama, masukkan http.
6. Dalam daftar Backend type, pilih Instance group.
7. Di bagian New backend:
• Dalam daftar Instance group, pilih gl7-ilb-mig-a di REGION_A.
• Setel Transfer nomor ke 80.
• Klik Done.
• Untuk menambahkan backend lain, klik Add backend.
• Dalam daftar Instance group, pilih gl7-ilb-mig-b 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.
• Setel Protocol ke HTTP.
• Tetapkan Port ke 80.
• Klik Save.

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 host yang tidak cocok 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 Certificate Authority Service Anda.
   • Buat sertifikat yang dikelola Google dengan otorisasi DNS.

   Setelah Anda membuat sertifikat yang dikelola Google, lampirkan sertifikat secara 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.

   Tetapkan jalur file Anda ke nama variabel.

   export LB_CERT=PATH_TO_PEM_FORMATTED_FILE
   

   export LB_PRIVATE_KEY=PATH_TO_LB_PRIVATE_KEY_FILE
   

   Buat sertifikat SSL 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 tanda 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 tanda 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, yang 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, yang 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, yang 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, yang mengganti 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, yang 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, yang mengganti PROJECT_ID dengan project ID 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, yang 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

Buat instance VM untuk menguji konektivitas

1. Buat VM klien:

   gcloud compute instances create l7-ilb-client-a \
       --image-family=debian-10 \
       --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-10 \
       --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 menampilkan nama host

   • Pastikan bahwa VM klien dapat menjangkau kedua alamat IP. Perintah ini menampilkan nama VM backend yang menayangkan 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 telah dikonfigurasi untuk me-resolve alamat IP yang terdekat dengan VM klien. Misalnya, DNS_NAME dapat berupa service.example.com.

     curl DNS_NAME
     

Jalankan 100 permintaan dan konfirmasi bahwa permintaan tersebut mengalami load balancing

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 tidak responsif 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 yang di-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.

Saat 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 endpoint atau instance 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 backend atau endpoint di grup endpoint jaringan (NEG) berdasarkan nilai header HTTP yang disebutkan 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.

Saat afinitas cookie HTTP diaktifkan, load balancer akan merutekan permintaan ke VM backend atau endpoint di NEG, berdasarkan cookie HTTP yang dinamai dalam flag HTTP_COOKIE dengan flag --affinity-cookie-ttl opsional. Jika klien tidak menyediakan cookie dalam permintaan HTTP-nya, proxy akan menghasilkan cookie dan menampilkannya ke klien dalam header Set-Cookie. Afinitas cookie HTTP hanya valid jika kebijakan lokalitas load balancing adalah RING_HASH atau MAGLEV dan hash konsisten dari layanan backend menentukan cookie HTTP tersebut.

Konsol

Untuk mengaktifkan atau mengubah afinitas sesi untuk layanan backend:

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

   Buka Load balancing

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

gcloud

Gunakan perintah Google Cloud CLI berikut untuk memperbarui 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 mana 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 pada 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 aturan penerusan VIP 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. Aturan firewall yang mengizinkan atau menolak traffic masuk pada backend ini tidak dapat dibuat berdasarkan VIP aturan penerusan yang digunakan oleh klien.

Berikut ini 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 pada langkah-langkah berikut.

Gunakan satu aturan firewall atau beberapa aturan untuk menyiapkannya.

Aturan firewall keluar tunggal

Anda dapat mengonfigurasi satu aturan traffic 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.

   • Name: fr-deny-access
   • Jaringan: lb-network
   • Prioritas: 100
   • Arah traffic: Traffic keluar
   • Tindakan pada kecocokan: Tolak
   • Targets: Tag target yang ditentukan
   • Tag target: TARGET_TAG
   • Filter tujuan: Rentang IP
   • Rentang IP tujuan: 10.1.2.99
   • Protokol dan port:
     • Pilih Specified protocols and ports.
     • Centang kotak tcp, lalu masukkan 80 untuk nomor port.

3. Klik Create.

Beberapa aturan firewall keluar

Pendekatan yang lebih skalabel mencakup penetapan dua aturan. Aturan default berprioritas rendah yang membatasi semua klien agar tidak mengakses VIP load balancer. Aturan kedua dengan prioritas lebih tinggi yang memungkinkan subset klien yang diberi tag 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:

   • Name: fr-deny-all-access-low-priority
   • Jaringan: lb-network
   • Prioritas: 200
   • Arah traffic: Traffic keluar
   • Tindakan pada kecocokan: Tolak
   • Targets: Tag target yang ditentukan
   • Tag target: TARGET_TAG
   • Filter tujuan: Rentang IP
   • Rentang IP tujuan: 10.1.2.99
   • Protokol dan port:
     • Pilih Specified protocols and ports.
     • 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.

   • Name: fr-allow-some-access-high-priority
   • Jaringan: lb-network
   • Prioritas: 100
   • Arah traffic: Traffic keluar
   • Tindakan jika kecocokan: Izinkan
   • Targets: Tag target yang ditentukan
   • Tag target: TARGET_TAG
   • Filter tujuan: Rentang IP
   • Rentang IP tujuan: 10.1.2.99
   • Protokol dan port:
     • Pilih Specified protocols and ports.
     • 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 pada langkah-langkah ini.

Gunakan satu aturan firewall atau beberapa aturan untuk menyiapkannya.

Aturan firewall keluar tunggal

Anda dapat mengonfigurasi satu aturan traffic 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 berprioritas rendah yang membatasi semua klien agar tidak mengakses VIP load balancer, dan aturan kedua dengan prioritas lebih tinggi yang memungkinkan subset klien yang diberi tag mengakses VIP load balancer. Hanya VM yang diberi tag yang dapat mengakses VIP.

1. Buat aturan dengan prioritas 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 dengan 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, untuk 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

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

Berikut 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 yang di-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 {i>subnet<i}. 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 untuk rentang alamat IP 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
   

Gunakan 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 flag --purpose 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 yang sama. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan pengalihan HTTP-ke-HTTPS untuk Load Balancer Aplikasi internal.

Mengonfigurasi kebijakan perutean DNS

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

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 kumpulan 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": "gil7-forwarding-rule-a",
                "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": "gil7-forwarding-rule-b",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        }
      ]
    }
  }
}

Aktifkan deteksi pencilan

Anda dapat mengaktifkan deteksi pencilan pada layanan backend global untuk mengidentifikasi NEG serverless yang tidak responsif dan mengurangi jumlah permintaan yang dikirim ke NEG serverless yang tidak responsif.

Deteksi pencilan diaktifkan di layanan backend dengan menggunakan salah satu metode berikut:

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

Gunakan langkah-langkah berikut untuk mengaktifkan deteksi pencilan untuk layanan backend yang sudah ada. Perlu diperhatikan bahwa meskipun setelah mengaktifkan deteksi pencilan, beberapa permintaan dapat dikirim ke layanan yang tidak responsif dan menampilkan kode status 5xx ke klien. Untuk mengurangi tingkat error lebih lanjut, Anda dapat mengonfigurasi nilai yang lebih agresif untuk parameter deteksi pencilan. 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 Load balancer details, 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 diubah.

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

7. Di bagian Deteksi luar, centang kotak Aktifkan.

8. Klik Edit untuk mengonfigurasi deteksi pencilan.

   Pastikan opsi berikut dikonfigurasi dengan nilai ini:

   Properti	Nilai
   Error berkelanjutan	5
   Interval	1.000
   Waktu ejeksi dasar	30000
   Persentase ejeksi maks.	50
   Menimbulkan error berturut-turut	100

   Dalam contoh ini, analisis deteksi pencilan 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 yang berlaku ditetapkan ke 100%, layanan backend akan menerapkan penghapusan endpoint yang tidak responsif dari kumpulan load balancing proxy Envoy spesifik tersebut setiap kali analisis deteksi pencilan berjalan. Jika kondisi pengecualian terpenuhi, hingga 50% endpoint backend dari kumpulan load balancing dapat dikeluarkan.

9. Klik Save.

10. Untuk mengupdate layanan backend, klik Update.

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

gcloud

1. Mengekspor 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 dari layanan backend guna menambahkan kolom untuk deteksi pencilan seperti yang ditandai dalam konfigurasi YAML berikut.

   Dalam contoh ini, analisis deteksi pencilan 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 yang berlaku ditetapkan ke 100%, layanan backend akan menerapkan penghapusan endpoint yang tidak responsif dari kumpulan load balancing proxy Envoy spesifik tersebut setiap kali analisis deteksi pencilan berjalan. Jika kondisi pengecualian 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 dikonfigurasi.
   • SERVERLESS_NEG_NAME: nama NEG serverless pertama
   • SERVERLESS_NEG_NAME_2: nama NEG serverless kedua

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

• Ringkasan Load Balancer Aplikasi Internal.
• Subnet khusus proxy untuk load balancer berbasis Envoy.
• Kelola sertifikat.
• Bersihkan penyiapan load balancing.