Cloud NGFW Essentials for Load Balancers

1. מבוא

בשיעור Codelab הזה נסביר על Cloud Next Generation Firewall ‏ (NGFW) Essentials למאזני עומסים פנימיים של אפליקציות (ALB) ולמאזני עומסי רשת (NLB) בשרת proxy באמצעות מדיניות אזורית של חומות אש ברשת.

‫Cloud NGFW הוא שירות חומת אש מבוזרת לחלוטין עם יכולות מתקדמות של הגנה מפני איומים ומיקרו-פילוח, שמיועד להגנה על עומסי עבודה ב-Google Cloud. הפעלת Cloud NGFW ברמת מאזן העומסים מחילה כללים עקביים של מדיניות חומת אש על כל תעבורת TCP שנכנסת למאזני עומסים פנימיים מבוססי-פרוקסי. היא מפשטת את הקצאת מצב האבטחה של הארגון על ידי אכיפה רחבה יותר של מדיניות בכל השירותים.

ב-Codelab הזה נסביר על המוצרים והתכונות הבאים של Cloud NGFW ומאזן עומסים ב-Cloud:

  • ‫Cloud NGFW Essentials
  • מדיניות אזורית של חומת אש בין רשתות
  • מאזן עומסים פנימי אזורי של אפליקציות (ALB)
  • קבוצה של מופעי מכונה מנוהלים (MIG) בעורף וקבוצה של נקודות קצה ברשת (NEG) מסוג Private Service Connect ‏ (PSC)

הערה: בתיעוד של Cloud NFGW אפשר למצוא את התכונות הנתמכות העדכניות ואת המגבלות של כללי מדיניות חומת האש עבור יעדים של איזון עומסים.

מה לומדים

  • הפעלת כללי מדיניות בסיסיים של חומת אש ב-Cloud NGFW שמטרגטים מאזני עומסים
  • הגנה על שירות פנימי של מאזן עומסים לצרכנים באמצעות מכונה וירטואלית וקצוות עורפיים של PSC
  • בדיקת גישת לקוח ואימות יומני חומת האש

מה צריך

2. מושגים

רמות של תכונות חומת האש

ל-Cloud NGFW יש שלוש רמות של תכונות: Essentials,‏ Standard ו-Enterprise. כל רמה מתקדמת מציעה רמות נוספות של סינון תעבורת רשת ויכולות בדיקה.

סיכום של יכולות הסינון של Cloud NGFW Essentials:

שכבה

יכולת

שכבות רשת

דוגמאות לפרמטרים של כללים

Essentials

סינון לפי כתובת IP וטווח כתובות IP

קניין רוחני (IP)

--src-ip-ranges=1.1.1.0/24,2.2.2.2/32

Essentials

קבוצות של כתובות

קניין רוחני (IP)

--src-address-groups=special-ranges

Essentials

סינון פרוטוקולים ויציאות

TCP

--layer4-configs=tcp

Essentials

תגים מאובטחים

מטא-נתונים

--src-secure-tags=tagValues/987654321098

Essentials

סינון לפי סוג הרשת

כתובת IP / מטא-נתונים

--src-network-type=INTRA_VPC

כללי ההעברה של מאזן העומסים מגדירים במפורש את יציאת ה-TCP של היעד. בפרמטר --layer4-configs= של כלל חומת האש אפשר לציין רק tcp. ערך היציאה משתמע מכלל ההעברה עצמו.

קבוצות כתובות וסוגי רשתות יכולים לעזור ליצור כללי מדיניות חומת אש יעילים יותר. סוגי הרשתות VPC_NETWORKS ו-INTRA_VPC נתמכים בכללים של מדיניות חומת האש למאזני עומסים.

הערה: כללי מדיניות חומת אש למאזני עומסים תומכים רק ב---direction=INGRESS. הכללים האלה נועדו לשלוט בגישה לשירותים שנחשפים על ידי איזון העומסים.

סינון במישור הנתונים

התכונות של Cloud NFGW Essentials כוללות כללי חומת אש בסיסיים עם שמירת מצב בשכבה 3 (כתובת IP) ובשכבה 4 (יציאת TCP). כל התכונות האלה של כללי מדיניות חומת האש מבוצעות ביעילות במישור הנתונים של מאזן העומסים בלי הצורך בבדיקה מלאה של החבילות.

כללי מדיניות של Cloud NGFW Essentials שמטרגטים מכונות וירטואליות נאכפים בבד של רשת ה-VPC המבוזרת כחלק מרשת הליבה של Google Cloud מוגדרת התוכנה (Andromeda). כללי מדיניות של חומת אש וסינון חבילות נאכפים ברמת ההיפר-ויזור של כל מופע של מכונה וירטואלית, לפני שהחבילה מגיעה לממשק הרשת של המופע של המכונה הווירטואלית.

אכיפת כללי המדיניות של Cloud NGFW Essentials שמטרגטים מאזני עומסים מתבצעת באמצעות הטכנולוגיות הבסיסיות של מאזני העומסים של Google Cloud, ובאופן ספציפי באמצעות תשתית פרוקסי השירות של Envoy. באמצעות אותה מבנה כללים ומודל משאבים של Cloud NFGW, סינון מנות עם שמירת מצב נאכף ישירות במישור הנתונים של מאזן העומסים מבוסס-הפרוקסי.

יעדים של מאזן עומסים

יש כמה הבדלים מרכזיים בין מדיניות Cloud NGFW שמיועדת למאזני עומסים לבין מדיניות שמיועדת למופעי מכונות וירטואליות.

אפשר להחיל כללים של מדיניות חומת האש על מאזן עומסים יחיד על ידי ציון --target-type=INTERNAL_MANAGED_LB יחד עם ההפניה הספציפית לכלל העברת התנועה של מאזן העומסים --target-forwarding-rules=FR_NAME. כדי לטרגט את כל כללי ההעברה של מאזן העומסים באזור של רשת ה-VPC (כאשר האזור מוגדר על ידי המדיניות), צריך להשמיט את ההפניה הספציפית ולהשתמש רק בדגל --target-type=INTERNAL_MANAGED_LB.

אם הפרמטר --target-type לא מוגדר בהגדרת הכלל, ברירת המחדל של הכלל היא להחיל אותו אוטומטית על כל מכונות ה-VM ולא על מאזני העומסים.

רשת Codelab

ב-Codelab הזה משתמשים בפרויקט יחיד עם רשת VPC אחת ובמשאבים הבאים:

  • שתי רשתות משנה אזוריות
  • מדיניות חומת אש אחת של רשת אזורית
  • שלושה מאזני עומסים פנימיים אזוריים של אפליקציות (ALB)
    • www שירות HTTP עם קצה עורפי של קבוצת מכונות וירטואליות
    • api שירות HTTP עם קצה עורפי של קבוצת מכונות וירטואליות
    • gcs שירות HTTPS עם בק-אנד של PSC NEG ל-Google APIs
  • שתי מכונות וירטואליות לבדיקת מדיניות שונות של הרשאה ודחייה

figure1

איור 1. רשת Codelab

כללי מדיניות חומת אש שמטרגטים מאזני עומסים מקושרים למשאבי כללי ההעברה של מאזן העומסים. מאזני עומסים מורכבים ממשאבים מוגדרים בנפרד שמוגדרים יחד כדי לספק שירות מלא של איזון עומסים. ההגדרה של כלל ההעברה מפנה ישירות למשאב ספציפי של שרת proxy לחלוקת העומס שהוגדר עבורו.

figure2

איור 1. ‫Cloud NFGW למשאבי מאזן עומסים

מסנני Cloud NGFW Essentials מתוכנתים במישור הנתונים של מאזן העומסים ומיושמים בשכבת שירותי פרוקסי היעד המוגדרת – בדומה לממשק של מכונה וירטואלית – באמצעות אותם מנגנוני חומת אש מבוזרים ועקביים לאכיפת מדיניות.

3. הגדרת הפרויקט

גישה לפרויקט

בשיעור Codelab הזה משתמשים בפרויקט אחד ב-Google Cloud. בשלבי ההגדרה נעשה שימוש בפקודות של gcloud cli CLI ושל מעטפת Linux.

כדי להתחיל, ניגשים לשורת הפקודה של הפרויקט בענן ב-Google Cloud:

הגדרת מזהה הפרויקט

gcloud config set project YOUR_PROJECT_ID_HERE

הפעלת שירותי API

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

הגדרת סביבת מעטפת

# 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. הבסיס לרשת

בקטע הזה נסביר איך פורסים תשתית רשת עם:

  • רשת VPC גלובלית ורשתות משנה אזוריות
  • מדיניות חומת אש אזורית ברשת כדי לאבטח את רשת ה-VPC
  • ‫Cloud Router ו-Cloud NAT כדי שהשרתים יוכלו לאחזר חבילות תוכנה
  • הזמנות של כתובות IP ורשומות DNS ל-Ingress של מאזן עומסים

יצירת משאבי רשת

# 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

יצירת רכיבים של חומת אש

מדיניות חומת האש האזורית הבסיסית שנוצרה כאן תשמש בהמשך להוספה של יעדים ספציפיים למאזן העומסים. המדיניות צריכה להיות באותו אזור שבו נמצא איזון העומסים.

יצירת קבוצת כתובות

מתחילים ביצירת קבוצת כתובות כדי לזהות את טווח כתובות ה-IP של בדיקת התקינות שתומך בפונקציונליות של איזון עומסים. כדי שהעורפים של מאזן העומסים ייחשבו תקינים, צריך לאפשר את הטווחים האלה. הוא ישמש גם בהמשך עם כללי מדיניות חומת האש שמטרגטים מאזני עומסים.

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

יצירת מדיניות חומת אש

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

הגדרת שירותי רשת

יצירת Cloud Router ושער NAT

# 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

שמירת כתובות 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

יצירת רשומות 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"

כאן מסתיים החלק של הגדרת הרשת… עכשיו נעבור להגדרת מאזני עומסים.

5. שירותי מאזן עומסים

בקטע הזה פורסים רכיבים של מאזן עומסים (שירותים לקצה העורפי, מיפוי של כתובות URL, שרתי proxy ביעד וכללי העברה) לשלושה שירותים:

  1. ‫www service (ilb-foo-www) on port 80
  2. ‫api service (ilb-foo-api) on port 8080
  3. שירות gcs (ilb-foo-gcs) ביציאה 443 עם אישור TLS

בנוסף למשאבי ה-Backend התומכים:

  1. מופעי מכונות וירטואליות שמריצים שרתי HTTP בקבוצת מופעי מכונה מנוהלים
  2. קבוצה של נקודות קצה ברשת (NEG) מסוג Private Service Connect ‏ (PSC) ל-Google APIs
  3. קטגוריה של Google Cloud Storage‏ (GCS)

הגדרת משאבים בקצה העורפי

יצירת שרתים של קבוצת מופעים של מכונות וירטואליות

מאזן העומסים www ישתמש בשרתי הקצה העורפי של קבוצת מכונות ה-VM שמריצים את שרת האינטרנט Apache ומאזינים ליציאה 80.

מאזן העומסים api ישתמש באותה קבוצת מכונות וירטואליות שמקשיבה ליציאה 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}

יצירת קטגוריית אחסון

מאזן העומסים (LB) של gcs ישתמש בבק-אנד של PSC NEG כדי להתחבר דרך קצה קדמי של Google APIs לקטגוריה של Cloud Storage.

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

הערה: משתני הסביבה נמחקים כשסוגרים את סשן המעטפת. אם צריך, רושמים את שם הקטגוריה כדי להשלים את הפעולה בסשן עתידי.

# 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

צור אישור

מאזן העומסים gcs יסיים את בקשות ה-HTTPS של הלקוח באמצעות אישור בחתימה עצמית שנפרס בשרת ה-proxy של יעד ה-HTTPS.

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

יצירת רכיבים של מאזן עומסים

אפשר להשתמש בסקריפט הבא כדי להפוך את הפריסה של רכיבי מאזן העומסים לאוטומטית. הפעולה הזו תעזור לשפר את המהירות והדיוק של כל רכיבי ההגדרה שמשתתפים בתהליך.

פריסת סקריפט ליצירת מאזן עומסים

# 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

הערה: יכול להיות שיחלפו כמה דקות עד שהסקריפט יסיים לפעול.

אימות של יצירת מאזן עומסים

בודקים שכללי ההעברה ושירותי הקצה העורפי נפרסו.

# check forwarding rules
gcloud compute forwarding-rules list

# check backend services
gcloud compute backend-services list

כאן מסתיים החלק של הגדרת מאזן העומסים… עכשיו נעבור להגדרת מכונות וירטואליות של לקוחות.

6. גישת לקוח

יצירת משאבי לקוח של מכונות וירטואליות

בקטע הזה נסביר איך לפרוס לקוחות ולאמת את הקישוריות מקצה לקצה.

יצירת מכונות וירטואליות

# 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

בדיקת שירות בסיסי

בדיקה מהלקוח vm-allow

הערה: המכונות הווירטואליות יעברו למצב אונליין ויהיה אפשר לגשת אליהן דרך ssh באמצעות IAP זמן קצר אחרי הפעלת הפקודות instances create. אם הבקשה נכשלת בניסיון הראשון, יכול להיות שצריך להמתין רגע ולנסות שוב.

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

בודקים את ההעלאה של קובץ ל-Google Cloud Storage דרך מאזן העומסים.

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

התגובה של Cloud Storage API מאשרת שנתיב הרשת פועל בצורה תקינה.

בדיקה מהלקוח 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"

הערה: הבדיקות האלה אמורות להצליח גם כן, כי עדיין לא הוגדרו כללי חומת אש שמוגדרים ל-Load Balancer.

סיימנו את כל החלקים העיקריים של ההגדרה. עכשיו נעבור ליצירת כללים של חומת אש למאזן העומסים.

7. חומת אש של מאזן עומסים

בקטע הזה נסביר איך פורסים כללים של מדיניות חומת אש שמטרגטים מאזני עומסים. רצף ההגדרות יבנה מצב אבטחה שיאפשר גישה ל-vm-allow ויחסום תנועה של vm-deny לכל השירותים.

אישור תנועה נבחרת אל fr-foo-www

מוסיפים כלל חדש למדיניות חומת האש הקיימת fw-policy-foo-${REGION_1}

  • מתן הרשאה לטווח כתובות IP של מקור שכולל את כתובות ה-IP‏ vm-allow ומחריג את כתובות ה-IP‏ vm-deny
  • מוסיפים עוד מסנן מקור INTRA_VPC כדי להשתמש בסוג הרשת בכלל של מדיניות חומת אש שמכוון למאזן העומסים

סוג הרשת של המקור INTRA_VPC ו-VPC_NETWORKS נתמך בכללים של מדיניות חומת האש שמטרגטים מאזני עומסים כשמשתמשים בו בשילוב עם פרמטר מקור אחר. לוגיקת ההערכה היא AND בין שני פרמטרים של מקורות. כדי לאפשר את התנועה, היא צריכה לעמוד בקריטריונים של INTRA_VPC ושל --src-ip-ranges=${VM_ALLOW_IP}/32.

יצירת כלל כדי לאפשר טירגוט של 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

בדיקה מהלקוח vm-allow

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

בדיקה מהלקוח vm-deny

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

הערה: הפעולה הזו מצליחה כי התנהגות ברירת המחדל המשתמעת של כלל מדיניות חומת האש למאזני עומסים היא --action=allow. כדי לשנות את זה, צריך כלל ברירת מחדל (catchall) של דחייה.

דחיית תנועה שמוגדרת כברירת מחדל אל fr-foo-www

מוסיפים כלל חדש למדיניות חומת האש עם עדיפות נמוכה יותר (מספר גבוה יותר).

  • דחיית כל התנועה מכל כתובת IP של מקור
  • תנועה מ-vm-allow אל fr-foo-www תאושר לפני הפעלת כלל הדחייה

יצירת כלל לדחיית טירגוט תנועה 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

שיקולים לגבי בדיקות תקינות

בדומה לכללים במדיניות חומת אש שמטרגטים מכונות וירטואליות, כלל ברירת המחדל (המשתמע) שמונע תעבורת נתונים נכנסת (ingress) חוסם תעבורה שמקורה בטווחים של בדיקות התקינות ומיועדת לשרתים עורפיים של מאזן העומסים. לכן הוגדר כלל הרשאה מפורש כדי לאפשר טווחים של בדיקות תקינות של תעבורת נתונים נכנסת (ingress) (ראו כלל 1002).

חשוב: באופן דומה, כשיוצרים כלל דחייה (מפורש) של תעבורת כניסה (ingress) ליעדים של מאזן עומסים, צריך ליצור כלל נוסף בעדיפות גבוהה יותר (מספר עדיפות נמוך יותר) כדי לאפשר תעבורת כניסה מטווח בדיקות התקינות. צריך לכוון את הכלל הזה למאזני העומסים.

# 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

בדיקה מהלקוח vm-deny

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

הפעולה הזו אמורה להיכשל עכשיו כי כלל חומת האש 2999 דוחה את כל תעבורת הנתונים שמגיעה מרשת ה-VPC. הכלל 2001 בעדיפות גבוהה יותר (מספר עדיפות נמוך יותר) אפשר רק טווח מקור שכולל את vm-allow.

מפסיקים את התהליך של curl על ידי לחיצה על 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 עדיין יש גישה לשירות ה-API. הפעולה הצליחה כי כלל חומת האש הוחל באופן ספציפי רק על כלל ההעברה fr-foo-www ולא על fr-foo-api.

עדכון הכללים לטירגוט של כל מאזני העומסים

הערה: אפשר להחיל כללים של מדיניות חומת אש על כל מאזני העומסים ברשת VPC על ידי השמטת --target-forwarding-rules=FR_NAME.

משנים את הכללים במדיניות חומת האש כך שיחולו עכשיו על כל יעדי כללי ההעברה של מאזן העומסים ברשת ה-VPC.

  1. יוצרים כלל allow חדש של תעבורת נתונים נכנסת (ingress) 2003 שמטרגט את כל כללי ההעברה כדי לאפשר תעבורת נתונים של מכונות וירטואליות (טווח כתובות ה-IP‏ vm-allow)
  2. יוצרים כלל חדש של תעבורת נתונים נכנסת (ingress) מסוג allow 2004 שמטרגט את כל כללי ההעברה כדי לאפשר תעבורה של בדיקות תקינות (קבוצת הכתובות uhc-probes).
  3. יצירת כלל חדש של דחייה לתעבורת נתונים נכנסת (ingress) 2998 שמכוון לכל כללי ההעברה כדחייה כללית לכל שאר התעבורה

שינוי כללים של חומת אש כדי לטרגט את כל מאזני העומסים

# 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

אפשר להסיר את הכללים הקודמים במדיניות חומת האש שמטרגטים כללי העברה של איזון עומסים ספציפיים, כי הם מיותרים עכשיו בגלל הכללים שמטרגטים את כל כללי ההעברה ברשת ה-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}

בדיקה מהלקוח vm-deny

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

הפעולה הזו אמורה להיכשל כי fr-foo-api מטורגט גם על ידי כל כללי מדיניות חומת האש עם --target-type=INTERNAL_MANAGED_LB.

מפסיקים את התהליך של curl על ידי לחיצה על Ctrl+C.

בודקים את ההורדה של קובץ מ-Google Cloud Storage דרך מאזן העומסים.

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

מפסיקים את התהליך של curl על ידי לחיצה על Ctrl+C.

בדיקה מהלקוח 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"

אימות תוכן ההורדה

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

כל שירותי איזון העומסים זמינים ל-vm-allow ונחסמים בהצלחה ל-vm-deny.

כאן מסתיים החלק של הבדיקה... עכשיו נסביר בקצרה על רישום ביומן.

8. רישום ביומן של כללי חומת האש

פורמט יומן חומת האש כולל שדות ורשומות של כללים שמכוונים למאזני עומסים (--target-type=INTERNAL_MANAGED_LB).

היומנים יכללו שדה נוסף עם התווית load_balancer_details ומידע נוסף על מאזן העומסים שאליו כוון הכלל של מדיניות חומת האש. זה דומה לפורמט של השדה InstanceDetails כשמכונות וירטואליות הן היעד בכללים של מדיניות חומת האש.

  • ‫load_balancer_details.forwarding_rule_name מציג את כלל ההעברה של היעד של כלל מדיניות חומת האש
  • ‫load_balancer_details.type מציין את סוג איזון העומסים שמבוסס על שרת proxy
  • ‫load_balancer_details.url_map_name מתעד את משאב מפת ה-URL שנעשה בו שימוש כשסוג המאזן הוא מאזן עומסים של אפליקציה

צפייה ביומנים

מריצים שאילתה ביומני חומת האש כדי לראות את התוצאות של כללי מדיניות חומת האש.

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

פלט היומן מציג את הכללים בפועל שנאכפים על ידי המדיניות:

  • הכלל 2011 מאפשר את כל התנועה של vm-allow לכל מאזני העומסים
  • הכלל 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

אפשר גם לראות את היומנים במסוף Google Cloud באמצעות Logs Explorer. עוברים אל console.cloud.google.com/logs/query ומשתמשים ביומן חומת האש הרגיל של VPC‏ compute.googleapis.com/firewall.

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

הגענו לסוף החלק של הרישום ביומן... עכשיו נעבור לניקוי!

9. הסרת המשאבים 

# 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. סיכום

מעולה! הגדרתם בהצלחה את Cloud NGFW Essentials למאזני עומסים.

אתם מוזמנים לשלוח הערות, שאלות או תיקונים באמצעות טופס המשוב הזה.

תודה!