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

Konsol

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

   Buka jaringan VPC

2. Klik Create VPC network.

3. Berikan Name untuk jaringan.

4. Di bagian Subnets, setel 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 Selesai.

7. Klik Tambahkan subnet.

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

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

9. Klik Selesai.

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",
}

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
   • Tindakan terhadap 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 Buat.

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

   • Nama: fw-healthcheck
   • Jaringan: NETWORK
   • Direction of traffic: Ingress
   • Tindakan terhadap 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

   • Protocols and ports:

     • 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 di port 80 untuk menghubungi VM Anda, tetapi tidak dapat menggunakan HTTPS di port 443 untuk menghubungi VM.

5. Klik Buat.

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

   • Nama: fw-backends
   • Jaringan: NETWORK
   • Direction of traffic: Ingress
   • Tindakan terhadap 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 Buat.

gcloud

1. Buat aturan firewall fw-ilb-to-backends untuk mengizinkan konektivitas SSH ke VM dengan tag jaringan allow-ssh. Jika 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, 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, dengan 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"
}

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, lalu konfigurasi 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 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 Buat.

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

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

   9. Klik Buat.

   10. Klik Create instance group.

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

   18. Klik Buat.

gcloud

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

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

Konsol

Pilih jenis load balancer

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

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

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 Pesan.
2. Klik Selesai.
3. Untuk menambahkan aturan penerusan kedua, klik Tambahkan IP dan port frontend.
1. Berikan Name untuk aturan penerusan.
2. Di daftar Subnetwork region, pilih REGION_B.
   

   Mereservasi subnet khusus proxy

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 Pesan.
4. Klik Selesai.

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

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 Pesan.
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 default Google Cloud akan diterapkan.
10. Klik Selesai.

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

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 Pesan.
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 default Google Cloud akan diterapkan.
10. Klik Selesai.
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. Di daftar Backend type, pilih Instance group.
7. Di bagian New backend:
• Dalam daftar Grup instance, pilih gl4-ilb-miga di REGION_A.
• Setel Transfer nomor ke 80.
• Klik Selesai.
• Untuk menambahkan backend lain, klik Tambahkan backend.
• Dalam daftar Grup instance, pilih gl4-ilb-migb di REGION_B.
• Setel Transfer nomor ke 80.
• Klik Selesai.
8. Di daftar Health check, klik Create a health check.
• Di kolom Name, masukkan global-http-health-check.
• Tetapkan Protocol 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 Buat.

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.

   Tetapkan 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 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, dengan 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, ganti 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, ganti 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, ganti 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 targetHttpsProxies.insert method, ganti 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, ganti 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"
}

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 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 yang 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
   • Tindakan terhadap 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 Buat.

Beberapa aturan firewall keluar

Pendekatan yang lebih skalabel melibatkan penetapan dua aturan. Aturan default berprioritas rendah yang membatasi semua klien mengakses VIP load balancer. Aturan kedua dengan prioritas lebih tinggi yang mengizinkan subset 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
   • Tindakan terhadap 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 Buat.

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
   • Tindakan terhadap 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 Buat.

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.

Aturan firewall keluar tunggal

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 berprioritas rendah yang membatasi semua klien agar tidak mengakses VIP load balancer, dan aturan kedua berprioritas lebih tinggi yang mengizinkan subset klien yang diberi tag untuk mengakses VIP load balancer. Hanya VM yang diberi tag yang dapat mengakses VIP.

1. Buat aturan berprioritas 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.

gcloud

1. Buat subnet regional yang akan digunakan untuk mengalokasikan alamat IP yang di-load balance 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 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
   

gcloud

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

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 telah 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"
              }
            ]
          }
        }
      ]
    }
  }
}

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

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

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

6. Scroll ke bawah dan luaskan bagian Konfigurasi lanjutan.

7. Di bagian Deteksi pencilan, centang kotak Aktifkan.

8. Klik editEdit untuk mengonfigurasi deteksi anomali.

   Verifikasi bahwa opsi berikut dikonfigurasi dengan nilai ini:

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

   Dalam contoh ini, analisis deteksi pencilan berjalan setiap satu detik. Jika jumlah kode status HTTP 5xx berturut-turut yang diterima oleh proxy Envoy adalah lima atau lebih, endpoint backend akan dikeluarkan dari kumpulan penyeimbangan beban proxy Envoy tersebut selama 30 detik. Jika persentase penerapan ditetapkan ke 100%, layanan backend akan menerapkan penghapusan 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 deteksi anomali seperti yang ditandai dalam konfigurasi YAML berikut, di bagian outlierDetection:

   Dalam contoh ini, analisis deteksi pencilan berjalan setiap satu detik. Jika jumlah kode status HTTP 5xx berturut-turut yang diterima oleh proxy Envoy adalah lima atau lebih, endpoint backend akan dikeluarkan dari kumpulan penyeimbangan beban proxy Envoy tersebut selama 30 detik. Jika persentase penerapan ditetapkan ke 100%, layanan backend akan menerapkan penghapusan 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 serverless 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.