Cloud NGFW Essentials untuk Load Balancer

1. Pengantar

Codelab ini membahas Essentials Cloud Next Generation Firewall (NGFW) untuk Load Balancer Aplikasi (ALB) internal dan Load Balancer Jaringan (NLB) proxy menggunakan kebijakan firewall jaringan regional.

Cloud NGFW adalah layanan firewall yang terdistribusi sepenuhnya dengan kemampuan perlindungan ancaman tingkat lanjut dan segmentasi mikro untuk melindungi workload Google Cloud. Mengaktifkan Cloud NGFW di tingkat load balancer menerapkan aturan kebijakan firewall yang konsisten ke traffic TCP yang masuk ke load balancer berbasis proxy internal. Hal ini menyederhanakan penyediaan postur keamanan organisasi dengan menawarkan penegakan kebijakan yang lebih luas untuk semua layanan.

Produk dan fitur Cloud NGFW dan Cloud Load Balancer berikut dibahas dalam Codelab ini:

Cloud NGFW Essentials
Kebijakan firewall jaringan regional
Load Balancer Aplikasi internal regional
Grup instance terkelola (MIG) backend dan grup endpoint jaringan (NEG) Private Service Connect (PSC)

CATATAN: Lihat dokumentasi Cloud NFGW untuk mengetahui fitur dan batasan terbaru yang didukung dari aturan kebijakan firewall untuk target load balancer.

Yang Anda pelajari

Mengaktifkan aturan kebijakan firewall Cloud NGFW dasar yang menargetkan load balancer
Melindungi layanan load balancer konsumen internal dengan backend PSC dan instance VM
Menguji akses klien dan memverifikasi log firewall

Yang Anda perlukan

Project Google Cloud
Memahami konsep jaringan Google Cloud dan menggunakan Google Cloud CLI
Izin IAM: roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, dan roles/storage.admin

2. Konsep

Tingkatan fitur firewall

Cloud NGFW memiliki tiga tingkat fitur: Essentials, Standard, dan Enterprise. Setiap tingkat progresif menawarkan kemampuan tambahan untuk pemfilteran dan pemeriksaan traffic jaringan.

Ringkasan kemampuan pemfilteran Cloud NGFW Essentials:

Tingkat	Kemampuan	Lapisan jaringan	Contoh parameter aturan
Essentials	Pemfilteran alamat & rentang IP	IP	`--src-ip-ranges=1.1.1.0/24,2.2.2.2/32`
Essentials	Grup alamat	IP	`--src-address-groups=special-ranges`
Essentials	Pemfilteran protokol & port	TCP	`--layer4-configs=tcp`
Essentials	Tag aman	Metadata	`--src-secure-tags=tagValues/987654321098`
Essentials	Pemfilteran jenis jaringan	IP / metadata	`--src-network-type=INTRA_VPC`

Aturan penerusan load balancer secara eksplisit menentukan port TCP tujuan. Parameter aturan firewall --layer4-configs= hanya dapat menentukan tcp. Nilai port tersirat oleh aturan penerusan itu sendiri.

Grup alamat dan jenis jaringan dapat berguna untuk membuat aturan kebijakan firewall lebih efisien. Jenis jaringan VPC_NETWORKS dan INTRA_VPC didukung dengan aturan kebijakan firewall untuk load balancer.

CATATAN: Aturan kebijakan firewall untuk load balancer hanya mendukung --direction=INGRESS. Aturan ini dirancang untuk mengontrol akses ke layanan yang diekspos oleh load balancer.

Pemfilteran bidang data

Fitur Essentials Cloud NFGW mencakup aturan firewall stateful dasar Lapisan 3 (alamat IP) dan Lapisan 4 (port TCP). Semua fitur aturan kebijakan firewall ini dilakukan secara efisien di paket data load balancer tanpa perlu pemeriksaan paket penuh.

Aturan kebijakan Essentials Cloud NGFW yang menargetkan instance VM diterapkan dalam fabric jaringan VPC terdistribusi sebagai bagian dari jaringan software-defined (Andromeda) inti Google Cloud. Aturan kebijakan firewall dan pemfilteran paket diterapkan di tingkat hypervisor setiap instance VM, sebelum paket mencapai antarmuka jaringan instance VM.

Aturan kebijakan Essentials Cloud NGFW yang menargetkan load balancer diterapkan menggunakan teknologi dasar load balancer Google Cloud, khususnya infrastruktur proxy layanan Envoy. Dengan menggunakan model resource dan struktur aturan Cloud NFGW yang sama, pemfilteran paket stateful diterapkan langsung di bidang data load balancer berbasis proxy.

Target load balancer

Ada beberapa perbedaan utama antara kebijakan Cloud NGFW yang menargetkan load balancer dan kebijakan yang menargetkan instance VM.

Aturan kebijakan firewall dapat diterapkan ke target satu load balancer dengan menentukan --target-type=INTERNAL_MANAGED_LB bersama dengan referensi spesifik ke aturan penerusan load balancer --target-forwarding-rules=FR_NAME. Untuk menargetkan semua aturan penerusan load balancer di region jaringan VPC (dengan region yang dicakup oleh kebijakan), referensi spesifik harus dihilangkan, dan hanya tanda --target-type=INTERNAL_MANAGED_LB yang diperlukan.

Jika parameter --target-type tidak ditetapkan dalam konfigurasi aturan, aturan akan otomatis diterapkan ke semua instance VM dan tidak load balancer secara default.

Jaringan codelab

Codelab ini menggunakan satu project dengan satu jaringan VPC dan resource berikut:

Dua subnet regional
Satu kebijakan firewall jaringan regional
Tiga Load Balancer Aplikasi internal regional
- www Layanan HTTP dengan backend grup instance VM
- api Layanan HTTP dengan backend grup instance VM
- gcs Layanan HTTPS dengan backend NEG PSC ke Google API
Dua instance VM untuk menguji berbagai kebijakan izin dan tolak

Gambar 1. Jaringan codelab

Aturan kebijakan firewall yang menargetkan load balancer ditautkan ke resource aturan penerusan load balancer. Load balancer itu sendiri terdiri dari resource yang ditentukan secara individual dan dikonfigurasi bersama untuk menyediakan layanan load balancing yang lengkap. Definisi aturan penerusan secara langsung mereferensikan resource proxy target tertentu yang ditentukan untuknya.

Gambar 1. Cloud NFGW untuk resource load balancer

Filter Essentials Cloud NGFW diprogram ke dalam bidang data load balancer dan diterapkan di lapisan layanan proxy target yang ditentukan–mirip dengan antarmuka instance VM–menggunakan mekanisme firewall yang didistribusikan dan konsisten yang sama untuk menerapkan kebijakan.

3. Penyiapan project

Mengakses project Anda

Codelab ini menggunakan satu project Google Cloud. Langkah-langkah konfigurasi menggunakan perintah CLI gcloud cli dan shell Linux.

Mulailah dengan mengakses command line project Google Cloud Anda:

Cloud Shell di shell.cloud.google.com, atau
Terminal lokal dengan gcloud CLI terinstal

Menetapkan Project ID

gcloud config set project YOUR_PROJECT_ID_HERE

Mengaktifkan layanan API

gcloud services enable \
  cloudresourcemanager.googleapis.com \
  compute.googleapis.com \
  dns.googleapis.com \
  networksecurity.googleapis.com \
  certificatemanager.googleapis.com

Menetapkan variabel lingkungan shell

# set your region preference
export REGION_1="us-west1"

# set your zone preference
export ZONE_1="us-west1-c"

# fetch project info and verify vars set
export PROJECT_ID=$(gcloud config list --format="value(core.project)")
export PROJECT_NO=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")
echo ${REGION_1}
echo ${ZONE_1}
echo ${PROJECT_ID}
echo ${PROJECT_NO}

4. Dasar-dasar jaringan

Di bagian ini, Anda akan men-deploy fondasi jaringan dengan:

Jaringan VPC global dan subnet regional
Kebijakan firewall jaringan regional untuk mengamankan jaringan VPC
Cloud Router dan Cloud NAT untuk server guna mengambil paket software
Pencadangan alamat IP dan data DNS untuk ingress load balancer

Membuat resource jaringan

# create vpc network
gcloud compute networks create vnet-foo --subnet-mode=custom

# create subnet for clients
gcloud compute networks subnets create subnet-foo-1 \
  --network=vnet-foo \
  --region=${REGION_1} \
  --range=10.0.0.0/24 \
  --enable-private-ip-google-access

# create subnet for backend servers
gcloud compute networks subnets create subnet-foo-2 \
  --network=vnet-foo \
  --region=${REGION_1} \
  --range=172.16.0.0/24 \
  --enable-private-ip-google-access

# create proxy subnet
gcloud compute networks subnets create subnet-foo-3 \
  --purpose=REGIONAL_MANAGED_PROXY \
  --role=ACTIVE \
  --network=vnet-foo \
  --region=${REGION_1} \
  --range=172.16.128.0/23

Membuat komponen firewall

Kebijakan firewall jaringan regional dasar yang dibuat di sini akan digunakan nanti saat menambahkan target khusus load balancer. Kebijakan harus berada di region yang sama dengan load balancer.

Buat grup alamat

Mulailah dengan membuat grup alamat untuk mengidentifikasi rentang IP pemeriksaan health check sumber yang mendukung fungsi load balancer. Rentang ini harus diizinkan agar backend load balancer dianggap responsif. Objek ini juga akan digunakan nanti dengan aturan kebijakan firewall yang menargetkan load balancer.

# create address group
gcloud network-security address-groups create uhc-probes \
  --description="health check probes" \
  --type=IPv4 \
  --capacity=42 \
  --location=${REGION_1}

# add ip ranges to address group
gcloud network-security address-groups add-items uhc-probes \
  --items=35.191.0.0/16,130.211.0.0/22 \
  --location=${REGION_1}

Buat kebijakan firewall

# create fw policy
gcloud compute network-firewall-policies create fw-policy-foo-${REGION_1} \
  --description="foo fw ${REGION_1}" \
  --region=${REGION_1}

# create fw policy rule to allow in iap
gcloud compute network-firewall-policies rules create 1001 \
  --description="allow iap for ssh" \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1} \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp:22 \
  --src-ip-ranges=35.235.240.0/20

# create fw policy rule to allow in health checks
gcloud compute network-firewall-policies rules create 1002 \
  --description="allow health checks to backends" \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1} \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp \
  --src-address-groups=projects/${PROJECT_ID}/locations/${REGION_1}/addressGroups/uhc-probes

# create fw policy rule to allow in lb proxies
gcloud compute network-firewall-policies rules create 1003 \
  --description="allow lb proxy" \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1} \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp:80,tcp:443,tcp:8080 \
  --src-ip-ranges=172.16.128.0/23

# associate fw policy to vnet
gcloud compute network-firewall-policies associations create \
  --name=fw-policy-association-foo-${REGION_1} \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --network=vnet-foo \
  --firewall-policy-region=${REGION_1}

Mengonfigurasi layanan jaringan

Buat Cloud Router dan NAT Gateway

# create router for nat
gcloud compute routers create cr-nat-foo \
  --network=vnet-foo \
  --asn=16550 \
  --region=${REGION_1}

# create nat gateway
gcloud compute routers nats create natgw-foo \
  --router=cr-nat-foo \
  --region=${REGION_1} \
  --auto-allocate-nat-external-ips \
  --nat-all-subnet-ip-ranges

Mencadangkan alamat IP

# reserve vip for lb www service
gcloud compute addresses create vip-foo-www \
  --region=${REGION_1} \
  --subnet=subnet-foo-1 \
  --addresses=10.0.0.101

# reserve vip for lb api service
gcloud compute addresses create vip-foo-api \
  --region=${REGION_1} \
  --subnet=subnet-foo-1 \
  --addresses=10.0.0.102

# reserve vip for lb gcs service
gcloud compute addresses create vip-foo-gcs \
  --region=${REGION_1} \
  --subnet=subnet-foo-1 \
  --addresses=10.0.0.103

Membuat data DNS

# create dns zone
gcloud dns managed-zones create zone-foo \
  --description="private zone for foo" \
  --dns-name=foo.com \
  --networks=vnet-foo \
  --visibility=private

# create dns record for www service
gcloud dns record-sets create www.foo.com \
  --zone=zone-foo \
  --type=A \
  --ttl=300 \
  --rrdatas="10.0.0.101"

# create dns record for api service
gcloud dns record-sets create api.foo.com \
  --zone=zone-foo \
  --type=A \
  --ttl=300 \
  --rrdatas="10.0.0.102"

# create dns record for gcs service
gcloud dns record-sets create gcs.foo.com \
  --zone=zone-foo \
  --type=A \
  --ttl=300 \
  --rrdatas="10.0.0.103"

Hal ini mengakhiri bagian penyiapan jaringan... selanjutnya mengonfigurasi load balancer.

5. Layanan load balancer

Di bagian ini, Anda akan men-deploy komponen load balancer (layanan backend, peta URL, proxy target, dan aturan penerusan) untuk tiga layanan:

Layanan www (ilb-foo-www) di port 80
Layanan api (ilb-foo-api) di port 8080
Layanan gcs (ilb-foo-gcs) di port 443 dengan sertifikat TLS

Bersama dengan resource backend pendukung:

Instance VM yang menjalankan server HTTP dalam grup instance terkelola
Grup endpoint jaringan (NEG) Private Service Connect (PSC) ke Google API
Bucket Google Cloud Storage (GCS)

Menyiapkan resource backend

Membuat server grup instance VM

Load balancer www akan menggunakan server backend grup instance VM yang menjalankan server web Apache yang memproses port 80.

Load balancer api akan menggunakan grup instance VM yang sama yang memproses port 8080.

# create vm startup config with http server
cat > vm-server-startup.sh << 'OEOF'
#! /bin/bash
set -e
apt-get update
apt-get install apache2 -y
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://169.254.169.254/computeMetadata/v1/instance/name)"
vm_zone="$(curl -H "Metadata-Flavor:Google" \
http://169.254.169.254/computeMetadata/v1/instance/zone | cut -d/ -f4)"
echo "www served from: $vm_hostname in zone $vm_zone on port 80" | \
tee /var/www/html/index.html
echo "Listen 8080" | tee -a /etc/apache2/ports.conf
mkdir -p /var/www/api
echo "api served from: $vm_hostname in zone $vm_zone on port 8080" | \
tee /var/www/api/index.html
tee /etc/apache2/sites-available/api.conf << EOF
<VirtualHost *:8080>
    DocumentRoot /var/www/api
</VirtualHost>
EOF
a2ensite api.conf
systemctl restart apache2
OEOF

# create managed instance group template
gcloud compute instance-templates create mig-template-foo \
  --machine-type=e2-micro \
  --network=vnet-foo \
  --region=${REGION_1} \
  --subnet=subnet-foo-2 \
  --no-address \
  --shielded-secure-boot \
  --metadata-from-file=startup-script=vm-server-startup.sh

# create regional managed instance group
gcloud compute instance-groups managed create mig-foo \
  --region=${REGION_1} \
  --size=2 \
  --template=mig-template-foo \
  --base-instance-name=service-foo

# create named ports for instance group
gcloud compute instance-groups managed set-named-ports mig-foo \
  --named-ports=www-port:80,api-port:8080 \
  --region=${REGION_1}

Membuat bucket penyimpanan

Load balancer gcs akan menggunakan backend NEG PSC untuk terhubung melalui frontend Google API ke bucket Cloud Storage.

# create random bucket name
export BUCKET=$(openssl rand -hex 12)
echo ${BUCKET}

CATATAN: Variabel lingkungan akan hilang setelah sesi shell ditutup. Catat nama bucket jika diperlukan untuk diselesaikan pada sesi mendatang.

# create bucket
gcloud storage buckets create gs://${BUCKET} --location=${REGION_1}

# give compute sa object admin role on bucket
gcloud storage buckets add-iam-policy-binding gs://${BUCKET} \
  --member=serviceAccount:${PROJECT_NO}-compute@developer.gserviceaccount.com \
  --role=roles/storage.objectAdmin

Buat sertifikat

Load balancer gcs akan menghentikan permintaan HTTPS klien dengan sertifikat yang ditandatangani sendiri yang di-deploy ke proxy HTTPS target.

# create cert
openssl req -x509 -newkey rsa:2048 \
  -nodes \
  -days 365 \
  -keyout foo-gcs-key.pem \
  -out foo-gcs-cert.pem \
  -subj "/CN=Foo, Inc." \
  -addext "subjectAltName=DNS:gcs.foo.com"

# upload to certificate manager
gcloud certificate-manager certificates create cert-foo-gcs \
  --private-key-file=foo-gcs-key.pem \
  --certificate-file=foo-gcs-cert.pem \
  --location=${REGION_1}

Membuat komponen load balancer

Gunakan skrip berikut untuk mengotomatiskan deployment komponen load balancer. Hal ini akan membantu kecepatan dan akurasi di semua elemen konfigurasi yang terlibat.

Men-deploy skrip pembuatan load balancer

# create script file
cat > create_lbs.sh << EOF
#!/bin/bash
set -e

# --- Create load balancer for www service port 80 ---
echo "--- Creating Load Balancer for WWW Service (ilb-foo-www) on port 80 ---"

echo "ilb-foo-www: creating health check (hc-foo-www)"
gcloud compute health-checks create http hc-foo-www \
  --use-serving-port \
  --region=${REGION_1}

echo "ilb-foo-www: creating backend service (bes-foo-www)"
gcloud compute backend-services create bes-foo-www \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --port-name=www-port \
  --health-checks=hc-foo-www \
  --health-checks-region=${REGION_1} \
  --region=${REGION_1}

echo "ilb-foo-www: adding managed instance group (mig-foo) to backend service (bes-foo-www)"
gcloud compute backend-services add-backend bes-foo-www \
  --balancing-mode=UTILIZATION \
  --instance-group=mig-foo \
  --instance-group-region=${REGION_1} \
  --region=${REGION_1}

echo "ilb-foo-www: creating url map (ilb-foo-www)"
gcloud compute url-maps create ilb-foo-www \
  --default-service=bes-foo-www \
  --region=${REGION_1}

echo "ilb-foo-www: creating target http proxy (proxy-foo-www)"
gcloud compute target-http-proxies create proxy-foo-www \
  --url-map=ilb-foo-www \
  --url-map-region=${REGION_1} \
  --region=${REGION_1}

echo "ilb-foo-www: creating forwarding rule (fr-foo-www)"
gcloud compute forwarding-rules create fr-foo-www \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=vnet-foo \
  --subnet=subnet-foo-1 \
  --subnet-region=${REGION_1} \
  --address=vip-foo-www \
  --ports=80 \
  --target-http-proxy=proxy-foo-www \
  --target-http-proxy-region=${REGION_1} \
  --region=${REGION_1}

echo "--- Successfully created Load Balancer for WWW Service (ilb-foo-www) ---"
echo

# --- Create load balancer for api service port 8080 ---
echo "--- Creating Load Balancer for API Service (ilb-foo-api) on port 8080 ---"

echo "ilb-foo-api: creating health check (hc-foo-api)"
gcloud compute health-checks create http hc-foo-api \
  --use-serving-port \
  --region=${REGION_1}

echo "ilb-foo-api: creating backend service (bes-foo-api)"
gcloud compute backend-services create bes-foo-api \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --port-name=api-port \
  --health-checks=hc-foo-api \
  --health-checks-region=${REGION_1} \
  --region=${REGION_1}

echo "ilb-foo-api: adding managed instance group (mig-foo) to backend service (bes-foo-api)"
gcloud compute backend-services add-backend bes-foo-api \
  --balancing-mode=UTILIZATION \
  --instance-group=mig-foo \
  --instance-group-region=${REGION_1} \
  --region=${REGION_1}

echo "ilb-foo-api: creating url map (ilb-foo-api)"
gcloud compute url-maps create ilb-foo-api \
  --default-service=bes-foo-api \
  --region=${REGION_1}

echo "ilb-foo-api: creating target http proxy (proxy-foo-api)"
gcloud compute target-http-proxies create proxy-foo-api \
  --url-map=ilb-foo-api \
  --url-map-region=${REGION_1} \
  --region=${REGION_1}

echo "ilb-foo-api: creating forwarding rule (fr-foo-api)"
gcloud compute forwarding-rules create fr-foo-api \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=vnet-foo \
  --subnet=subnet-foo-1 \
  --subnet-region=${REGION_1} \
  --address=vip-foo-api \
  --ports=8080 \
  --target-http-proxy=proxy-foo-api \
  --target-http-proxy-region=${REGION_1} \
  --region=${REGION_1}

echo "--- Successfully created Load Balancer for API Service (ilb-foo-api) ---"
echo

# --- Create load balancer for gcs service port 443 ---
echo "--- Creating Load Balancer for GCS Service (ilb-foo-gcs) on port 443 ---"

echo "ilb-foo-gcs: creating network endpoint group (neg-psc-gcs)"
gcloud compute network-endpoint-groups create neg-psc-gcs \
  --network-endpoint-type=private-service-connect \
  --psc-target-service=storage.${REGION_1}.rep.googleapis.com \
  --region=${REGION_1}

echo "ilb-foo-gcs: creating backend service (bes-foo-gcs)"
gcloud compute backend-services create bes-foo-gcs \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTPS \
  --region=${REGION_1}

echo "ilb-foo-gcs: adding network endpoint group (neg-psc-gcs) to backend service (bes-foo-gcs)"
gcloud compute backend-services add-backend bes-foo-gcs \
  --network-endpoint-group=neg-psc-gcs \
  --network-endpoint-group-region=${REGION_1} \
  --region=${REGION_1}

echo "ilb-foo-gcs: creating url map (ilb-foo-gcs)"
gcloud compute url-maps create ilb-foo-gcs \
  --default-service=bes-foo-gcs \
  --region=${REGION_1}

echo "ilb-foo-gcs: creating target https proxy (proxy-foo-gcs)"
gcloud compute target-https-proxies create proxy-foo-gcs \
  --url-map=ilb-foo-gcs \
  --url-map-region=${REGION_1} \
  --certificate-manager-certificates=cert-foo-gcs \
  --region=${REGION_1}

echo "ilb-foo-gcs: creating forwarding rule (fr-foo-gcs)"
gcloud compute forwarding-rules create fr-foo-gcs \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=vnet-foo \
  --subnet=subnet-foo-1 \
  --subnet-region=${REGION_1} \
  --address=vip-foo-gcs \
  --ports=443 \
  --target-https-proxy=proxy-foo-gcs \
  --target-https-proxy-region=${REGION_1} \
  --region=${REGION_1}

echo "--- Successfully created Load Balancer for GCS Service (ilb-foo-gcs) ---"
echo

echo "All load balancers created successfully."
EOF

# make script executable
chmod +x create_lbs.sh

# run script
./create_lbs.sh

CATATAN: Skrip ini memerlukan waktu beberapa menit untuk selesai.

Memverifikasi pembuatan load balancer

Periksa apakah aturan penerusan dan layanan backend telah di-deploy.

# check forwarding rules
gcloud compute forwarding-rules list

# check backend services
gcloud compute backend-services list

Bagian penyiapan load balancer ini telah selesai... selanjutnya adalah mengonfigurasi instance VM klien.

6. Akses klien

Membuat resource klien VM

Di bagian ini, Anda akan men-deploy klien dan memverifikasi konektivitas menyeluruh.

Membuat instance VM

# set variables for client ip addresses
export VM_ALLOW_IP="10.0.0.11"
export VM_DENY_IP="10.0.0.12"
echo ${VM_ALLOW_IP}
echo ${VM_DENY_IP}

# create client 1 vm
gcloud compute instances create vm-allow \
  --machine-type=e2-micro \
  --zone=${ZONE_1} \
  --subnet=subnet-foo-1 \
  --no-address \
  --private-network-ip=${VM_ALLOW_IP} \
  --scopes=cloud-platform \
  --shielded-secure-boot

# create client 2 vm
gcloud compute instances create vm-deny \
  --machine-type=e2-micro \
  --zone=${ZONE_1} \
  --subnet=subnet-foo-1 \
  --no-address \
  --private-network-ip=${VM_DENY_IP} \
  --scopes=cloud-platform \
  --shielded-secure-boot

Menguji layanan dasar

Pengujian dari klien `vm-allow`

CATATAN: Instance VM akan aktif dan dapat diakses melalui ssh menggunakan IAP segera setelah perintah instances create dikeluarkan. Anda mungkin perlu menunggu sebentar jika permintaan gagal pada percobaan pertama.

# send request to foo www service
gcloud compute ssh vm-allow --zone=${ZONE_1} --command="
  curl -s www.foo.com"

# send request to foo api service
gcloud compute ssh vm-allow --zone=${ZONE_1} --command="
  curl -s api.foo.com:8080"

Uji upload file ke Google Cloud Storage melalui load balancer.

# send request to foo gcs service
gcloud compute ssh vm-allow --zone=${ZONE_1} --command="
  echo 'test one on the way' > test-upload-1.txt
  TOKEN=\$(gcloud auth print-access-token)
  curl -s -k -X POST \"https://gcs.foo.com/upload/storage/v1/b/${BUCKET}/o?uploadType=media&name=test-upload-object-1.txt\" \
  -H \"Authorization: Bearer \${TOKEN}\" \
  -H \"Content-Type: text/plain\" \
  --data-binary @test-upload-1.txt"

Respons Cloud Storage API mengonfirmasi bahwa jalur jaringan berfungsi dengan benar.

Pengujian dari klien `vm-deny`

# send request to foo www service
gcloud compute ssh vm-deny --zone=${ZONE_1} --command="
  curl -s www.foo.com"

# send request to foo api service
gcloud compute ssh vm-deny --zone=${ZONE_1} --command="
  curl -s api.foo.com:8080"

# send request to foo gcs service
gcloud compute ssh vm-deny --zone=${ZONE_1} --command="
  echo 'test two on the way' > test-upload-2.txt
  TOKEN=\$(gcloud auth print-access-token)
  curl -s -k -X POST \"https://gcs.foo.com/upload/storage/v1/b/${BUCKET}/o?uploadType=media&name=test-upload-object-2.txt\" \
  -H \"Authorization: Bearer \${TOKEN}\" \
  -H \"Content-Type: text/plain\" \
  --data-binary @test-upload-2.txt"

CATATAN: Pengujian ini juga akan berhasil karena belum ada aturan firewall yang menargetkan load balancer.

Ini mengakhiri semua bagian penyiapan utama... selanjutnya membuat aturan firewall load balancer.

7. Firewall load balancer

Di bagian ini, Anda akan men-deploy aturan kebijakan firewall yang menargetkan load balancer. Urutan konfigurasi akan membangun postur keamanan yang mengizinkan akses vm-allow dan memblokir traffic vm-deny ke semua layanan.

Mengizinkan traffic tertentu ke `fr-foo-www`

Tambahkan aturan kebijakan firewall baru ke kebijakan firewall yang ada fw-policy-foo-${REGION_1}

Mengizinkan rentang IP sumber yang mencakup alamat IP vm-allow dan mengecualikan alamat IP vm-deny
Tambahkan filter sumber tambahan INTRA_VPC untuk menggunakan jenis jaringan dalam aturan kebijakan firewall yang menargetkan load balancer

Jenis jaringan sumber INTRA_VPC dan VPC_NETWORKS didukung dalam aturan kebijakan firewall yang menargetkan load balancer jika digunakan bersama-sama dengan parameter sumber lainnya. Logika evaluasi adalah AND antara dua parameter sumber. Di sini, traffic harus memenuhi kriteria INTRA_VPC dan --src-ip-ranges=${VM_ALLOW_IP}/32 agar diizinkan.

Membuat aturan untuk mengizinkan penargetan `vm-allow` `fr-foo-www`

# create fw policy rule
gcloud beta compute network-firewall-policies rules create 2001 \
  --description="allow vm traffic to fr-www" \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1} \
  --enable-logging \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp \
  --src-network-type=INTRA_VPC \
  --src-ip-ranges=${VM_ALLOW_IP}/32 \
  --target-type=INTERNAL_MANAGED_LB \
  --target-forwarding-rules=projects/${PROJECT_ID}/regions/${REGION_1}/forwardingRules/fr-foo-www

Pengujian dari klien `vm-allow`

# send request to foo www service
gcloud compute ssh vm-allow --zone=${ZONE_1} --command="
  curl -s www.foo.com"

Pengujian dari klien `vm-deny`

# send request to foo www service
gcloud compute ssh vm-deny --zone=${ZONE_1} --command="
  curl -s www.foo.com"

CATATAN: Hal ini berhasil karena perilaku aturan kebijakan firewall default implisit untuk load balancer adalah --action=allow. Aturan penolakan default (catchall) diperlukan untuk mengubahnya.

Menolak traffic default ke `fr-foo-www`

Tambahkan aturan kebijakan firewall baru dengan prioritas yang lebih rendah (angka prioritas yang lebih tinggi).

Menolak semua traffic dari alamat IP sumber mana pun
Traffic dari vm-allow ke fr-foo-www akan diizinkan sebelum aturan penolakan diterapkan

Buat aturan untuk menolak traffic yang menargetkan `fr-foo-www`

# create fw policy rule
gcloud beta compute network-firewall-policies rules create 2999 \
  --description="allow vm traffic to fr-www" \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1} \
  --enable-logging \
  --action=deny \
  --direction=INGRESS \
  --layer4-configs=tcp \
  --src-ip-ranges=0.0.0.0/0 \
  --target-type=INTERNAL_MANAGED_LB \
  --target-forwarding-rules=projects/${PROJECT_ID}/regions/${REGION_1}/forwardingRules/fr-foo-www

Pertimbangan untuk health check

Seperti aturan kebijakan firewall yang menargetkan instance VM, aturan penolakan (implisit) untuk traffic ingress yang bersifat mencakup semua secara default akan memblokir traffic yang berasal dari rentang pemeriksaan health check yang ditujukan ke backend load balancer. Jadi, aturan izinkan eksplisit dikonfigurasi untuk mengizinkan rentang pemeriksaan health check ingress (lihat aturan 1002).

PENTING: Demikian pula, saat membuat aturan traffic masuk tolak semua (eksplisit) untuk target load balancer, aturan lain dengan prioritas yang lebih tinggi (angka prioritas yang lebih rendah) harus dibuat untuk mengizinkan traffic masuk dari rentang pemeriksaan health check. Aturan ini perlu menargetkan load balancer.

# create fw policy rule
gcloud beta compute network-firewall-policies rules create 2002 \
  --description="allow health checks to fr-www" \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1} \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp \
  --src-address-groups=projects/${PROJECT_ID}/locations/${REGION_1}/addressGroups/uhc-probes \
  --target-type=INTERNAL_MANAGED_LB \
  --target-forwarding-rules=projects/${PROJECT_ID}/regions/${REGION_1}/forwardingRules/fr-foo-www

Pengujian dari klien `vm-deny`

# send request to foo www service
gcloud compute ssh vm-deny --zone=${ZONE_1} --command="
  curl -s www.foo.com"

Sekarang, perintah ini akan gagal karena aturan firewall 2999 menolak semua traffic yang berasal dari jaringan VPC. Aturan dengan prioritas yang lebih tinggi (angka prioritas yang lebih rendah) 2001 hanya mengizinkan rentang sumber yang mencakup vm-allow.

Hentikan proses curl dengan menekan Ctrl+C.

# send request to foo api service
gcloud compute ssh vm-deny --zone=${ZONE_1} --command="
  curl -s api.foo.com:8080"

vm-deny masih dapat mengakses layanan API. Hal ini berhasil karena aturan firewall hanya diterapkan secara khusus ke aturan penerusan fr-foo-www dan tidak menargetkan fr-foo-api.

Memperbarui aturan untuk menargetkan semua load balancer

CATATAN: Aturan kebijakan firewall dapat diterapkan ke semua load balancer dalam jaringan VPC dengan menghilangkan --target-forwarding-rules=FR_NAME.

Ubah aturan kebijakan firewall agar kini berlaku untuk semua target aturan penerusan load balancer di jaringan VPC.

Buat aturan izinkan masuk baru 2003 yang menargetkan semua aturan penerusan untuk mengizinkan traffic VM (rentang IP vm-allow)
Buat aturan izinkan ingress baru 2004 yang menargetkan semua aturan penerusan untuk mengizinkan traffic health check (grup alamat uhc-probes).
Buat aturan penolakan masuk baru 2998 yang menargetkan semua aturan penerusan sebagai penolakan generik untuk semua traffic lainnya

Ubah aturan firewall untuk menargetkan semua load balancer

# create fw policy rule
gcloud beta compute network-firewall-policies rules create 2003 \
  --description="allow vm traffic to all vnet lb fr" \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1} \
  --enable-logging \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp  \
  --src-ip-ranges=${VM_ALLOW_IP}/32 \
  --target-type=INTERNAL_MANAGED_LB

# create fw policy rule
gcloud beta compute network-firewall-policies rules create 2004 \
  --description="allow health checks to all vnet lb fr" \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1} \
  --enable-logging \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp \
  --src-address-groups=projects/${PROJECT_ID}/locations/${REGION_1}/addressGroups/uhc-probes \
  --target-type=INTERNAL_MANAGED_LB

# create fw policy rule
gcloud beta compute network-firewall-policies rules create 2998 \
  --description="deny all vnet traffic to all vnet lb fr" \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1} \
  --enable-logging \
  --action=deny \
  --direction=INGRESS \
  --layer4-configs=tcp \
  --src-ip-ranges=0.0.0.0/0 \
  --target-type=INTERNAL_MANAGED_LB

Aturan kebijakan firewall sebelumnya yang menargetkan aturan penerusan load balancer eksplisit dapat dihapus karena kini berlebihan dengan aturan yang menargetkan semua aturan penerusan di jaringan VPC.

# delete redundant fw policy rules
gcloud beta compute network-firewall-policies rules delete 2001 \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1}

gcloud beta compute network-firewall-policies rules delete 2002 \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1}

gcloud beta compute network-firewall-policies rules delete 2999 \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1}

Pengujian dari klien `vm-deny`

# send request to foo api service
gcloud compute ssh vm-deny --zone=${ZONE_1} --command="
  curl -s api.foo.com:8080"

Sekarang, hal ini akan gagal karena fr-foo-api juga ditargetkan oleh semua aturan kebijakan firewall dengan --target-type=INTERNAL_MANAGED_LB.

Hentikan proses curl dengan menekan Ctrl+C.

Uji mendownload file dari Google Cloud Storage melalui load balancer.

# send request to foo gcs service
gcloud compute ssh vm-deny --zone=${ZONE_1} --command="
  TOKEN=\$(gcloud auth print-access-token)
  curl -s -k \"https://gcs.foo.com/storage/v1/b/${BUCKET}/o/test-upload-object.txt?alt=media\" \
  -H \"Authorization: Bearer \${TOKEN}\" \
  -o test-download.txt"

Hentikan proses curl dengan menekan Ctrl+C.

Pengujian dari klien `vm-allow`

# send request to foo www service
gcloud compute ssh vm-allow --zone=${ZONE_1} --command="
  curl -s www.foo.com"

# send request to foo api service
gcloud compute ssh vm-allow --zone=${ZONE_1} --command="
  curl -s api.foo.com:8080"

# send request to foo gcs service
gcloud compute ssh vm-allow --zone=${ZONE_1} --command="
  TOKEN=\$(gcloud auth print-access-token)
  curl -s -k \"https://gcs.foo.com/storage/v1/b/${BUCKET}/o/test-upload-object-1.txt?alt=media\" \
  -H \"Authorization: Bearer \${TOKEN}\" \
  -o test-download-1.txt"

Memverifikasi konten download

# send request from vm
gcloud compute ssh vm-allow --zone=${ZONE_1} --command="
  cat test-download-1.txt"

Semua layanan load balancer tersedia untuk vm-allow dan berhasil diblokir untuk vm-deny.

Ini mengakhiri bagian pengujian... selanjutnya kita akan melihat sekilas logging.

8. Firewall Rules Logging

Format log firewall memiliki kolom dan catatan untuk aturan yang menargetkan load balancer (--target-type=INTERNAL_MANAGED_LB).

Log akan berisi kolom tambahan berlabel load_balancer_details dengan informasi selengkapnya tentang load balancer tempat aturan kebijakan firewall ditargetkan. Hal ini analog dengan format kolom InstanceDetails saat instance VM ditargetkan dalam aturan kebijakan firewall.

load_balancer_details.forwarding_rule_name menampilkan aturan penerusan target dari aturan kebijakan firewall
load_balancer_details.type menunjukkan jenis load balancer berbasis proxy yang ditargetkan
load_balancer_details.url_map_name mencatat resource peta URL yang digunakan saat jenisnya adalah load balancer aplikasi

Melihat log

Kueri log firewall untuk melihat hasil aturan kebijakan firewall.

gcloud logging read \
  "logName=projects/${PROJECT_ID}/logs/compute.googleapis.com%2Ffirewall \
  AND (jsonPayload.connection.src_ip=\"${VM_ALLOW_IP}\" OR jsonPayload.connection.src_ip=\"${VM_DENY_IP}\")" \
  --project=${PROJECT_ID} \
  --freshness=30m \
  --limit=50 \
  --format="table(
    timestamp:label=TIMESTAMP,
    jsonPayload.connection.src_ip:label=SRC_IP,
    jsonPayload.connection.src_port:label=SRC_PORT,
    jsonPayload.connection.dest_ip:label=DEST_IP,
    jsonPayload.connection.dest_port:label=DEST_PORT,
    jsonPayload.disposition:label=ACTION,
    jsonPayload.rule_details.priority:label=PRIORITY,
    jsonPayload.load_balancer_details.forwarding_rule_name:label=FWD_RULE
  )"

Output log menampilkan aturan efektif yang diterapkan oleh kebijakan:

Semua traffic vm-allow ke semua load balancer diizinkan oleh aturan 2011
Semua traffic yang ditujukan ke load balancer ditolak oleh aturan 2998

TIMESTAMP                       SRC_IP     SRC_PORT  DEST_IP     DEST_PORT  ACTION   PRIORITY  FWD_RULE
YYYY-MM-DDTHH:MM:SS.850967068Z  10.0.0.11  48480     10.0.0.103  443        ALLOWED  2003      fr-foo-gcs
YYYY-MM-DDTHH:MM:SS.418613380Z  10.0.0.11  37340     10.0.0.101  80         ALLOWED  2003      fr-foo-www
YYYY-MM-DDTHH:MM:SS.213234118Z  10.0.0.12  55950     10.0.0.103  443        DENIED   2998      fr-foo-gcs
YYYY-MM-DDTHH:MM:SS.981484412Z  10.0.0.11  41738     10.0.0.101  80         ALLOWED  2003      fr-foo-www
YYYY-MM-DDTHH:MM:SS.189358071Z  10.0.0.12  55950     10.0.0.103  443        DENIED   2998      fr-foo-gcs
YYYY-MM-DDTHH:MM:SS.061463883Z  10.0.0.12  55950     10.0.0.103  443        DENIED   2998      fr-foo-gcs
YYYY-MM-DDTHH:MM:SS.965498098Z  10.0.0.12  53284     10.0.0.102  8080       DENIED   2998      fr-foo-api

Log juga dapat dilihat di Konsol Google Cloud menggunakan Logs Explorer. Buka console.cloud.google.com/logs/query dan gunakan log firewall VPC standar compute.googleapis.com/firewall.

logName=projects/${PROJECT_ID}/logs/compute.googleapis.com%2Ffirewall

Ini mengakhiri bagian logging... saatnya membersihkan!

9. Pembersihan

# delete client compute resources
gcloud -q compute instances delete vm-deny --zone=${ZONE_1}

gcloud -q compute instances delete vm-allow --zone=${ZONE_1}

# next

# delete load balancer resources for gcs
gcloud -q compute forwarding-rules delete fr-foo-gcs --region=${REGION_1}

gcloud -q compute target-https-proxies delete proxy-foo-gcs --region=${REGION_1}

gcloud -q compute url-maps delete ilb-foo-gcs --region=${REGION_1}

gcloud -q compute backend-services delete bes-foo-gcs --region=${REGION_1}

gcloud -q compute addresses delete vip-foo-gcs --region=${REGION_1}

# next

# delete load balancer resources for api
gcloud -q compute forwarding-rules delete fr-foo-api --region=${REGION_1}

gcloud -q compute target-http-proxies delete proxy-foo-api --region=${REGION_1}

gcloud -q compute url-maps delete ilb-foo-api --region=${REGION_1}

gcloud -q compute backend-services delete bes-foo-api --region=${REGION_1}

gcloud -q compute health-checks delete hc-foo-api --region=${REGION_1}

gcloud -q compute addresses delete vip-foo-api --region=${REGION_1}

# next

# delete load balancer resources for www
gcloud -q compute forwarding-rules delete fr-foo-www --region=${REGION_1}

gcloud -q compute target-http-proxies delete proxy-foo-www --region=${REGION_1}

gcloud -q compute url-maps delete ilb-foo-www --region=${REGION_1}

gcloud -q compute backend-services delete bes-foo-www --region=${REGION_1}

gcloud -q compute health-checks delete hc-foo-www --region=${REGION_1}

gcloud -q compute addresses delete vip-foo-www --region=${REGION_1}

# next

# delete service backend resources
gcloud -q storage rm --recursive gs://${BUCKET}

gcloud -q certificate-manager certificates delete cert-foo-gcs --location=${REGION_1}

gcloud -q compute network-endpoint-groups delete neg-psc-gcs --region=${REGION_1}

gcloud -q compute instance-groups managed delete mig-foo --region=${REGION_1}

gcloud -q compute instance-templates delete mig-template-foo --global

# next

# delete dns, nat, fw resources
gcloud -q dns record-sets delete gcs.foo.com --type=A --zone=zone-foo

gcloud -q dns record-sets delete api.foo.com --type=A --zone=zone-foo

gcloud -q dns record-sets delete www.foo.com --type=A --zone=zone-foo

gcloud -q dns managed-zones delete zone-foo

gcloud -q compute routers delete cr-nat-foo --region=${REGION_1}

gcloud -q compute network-firewall-policies associations delete \
  --firewall-policy=fw-policy-foo-${REGION_1} \
  --name=fw-policy-association-foo-${REGION_1} \
  --firewall-policy-region=${REGION_1}

gcloud -q compute network-firewall-policies delete fw-policy-foo-${REGION_1} --region=${REGION_1}

gcloud -q network-security address-groups delete uhc-probes --location=${REGION_1}

# next

# delete network resources
gcloud -q compute networks subnets delete subnet-foo-3 --region=${REGION_1}

gcloud -q compute networks subnets delete subnet-foo-2 --region=${REGION_1}

gcloud -q compute networks subnets delete subnet-foo-1 --region=${REGION_1}

gcloud -q compute networks delete vnet-foo

# next

# delete shell variables and local files
unset PROJECT_ID REGION_1 ZONE_1 VM_ALLOW_IP VM_DENY_IP BUCKET

rm vm-server-startup.sh create_lbs.sh foo-gcs-key.pem foo-gcs-cert.pem

# end

10. Kesimpulan

Selamat! Anda telah berhasil mengonfigurasi Cloud NGFW Essentials untuk load balancer.

Jangan ragu untuk memberikan komentar, pertanyaan, atau koreksi menggunakan formulir masukan ini

Terima kasih!

Cloud NGFW Essentials untuk Load Balancer

1. Pengantar

Yang Anda pelajari

Yang Anda perlukan

2. Konsep

Tingkatan fitur firewall

Pemfilteran bidang data

Target load balancer

Jaringan codelab

3. Penyiapan project

Mengakses project Anda

Menetapkan Project ID

Mengaktifkan layanan API

Menetapkan variabel lingkungan shell

4. Dasar-dasar jaringan

Membuat resource jaringan

Membuat komponen firewall

Buat grup alamat

Buat kebijakan firewall

Mengonfigurasi layanan jaringan

Buat Cloud Router dan NAT Gateway

Mencadangkan alamat IP

Membuat data DNS

5. Layanan load balancer

Menyiapkan resource backend

Membuat server grup instance VM

Membuat bucket penyimpanan

Buat sertifikat

Membuat komponen load balancer

Men-deploy skrip pembuatan load balancer

Memverifikasi pembuatan load balancer

6. Akses klien

Membuat resource klien VM

Membuat instance VM

Menguji layanan dasar

Pengujian dari klien vm-allow

Pengujian dari klien vm-deny

7. Firewall load balancer

Mengizinkan traffic tertentu ke fr-foo-www

Membuat aturan untuk mengizinkan penargetan vm-allow fr-foo-www

Pengujian dari klien vm-allow

Pengujian dari klien vm-deny

Menolak traffic default ke fr-foo-www

Buat aturan untuk menolak traffic yang menargetkan fr-foo-www

Pertimbangan untuk health check

Pengujian dari klien vm-deny

Memperbarui aturan untuk menargetkan semua load balancer

Ubah aturan firewall untuk menargetkan semua load balancer

Pengujian dari klien vm-deny

Pengujian dari klien vm-allow

8. Firewall Rules Logging

Melihat log

9. Pembersihan

10. Kesimpulan

Pengujian dari klien `vm-allow`

Pengujian dari klien `vm-deny`

Mengizinkan traffic tertentu ke `fr-foo-www`

Membuat aturan untuk mengizinkan penargetan `vm-allow` `fr-foo-www`

Pengujian dari klien `vm-allow`

Pengujian dari klien `vm-deny`

Menolak traffic default ke `fr-foo-www`

Buat aturan untuk menolak traffic yang menargetkan `fr-foo-www`

Pengujian dari klien `vm-deny`

Pengujian dari klien `vm-deny`

Pengujian dari klien `vm-allow`