אבטחה של מערכת לזיהוי בטיחות במקום העבודה

1. מבוא

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

• גבולות נתונים כדי לעזור לטפל באמצעי בקרה בסביבות מפוקחות
• מפתחות הצפנה בניהול הלקוח ( CMEK) להגנה על נתונים במנוחה;
• ‫GKE Shielded Nodes ו-GKE Confidential Nodes כדי לעזור באבטחת הנתונים במהלך העיבוד.
• ‫Workload Identity for GKE כדי לנהל גישה ל-Vertex AI, שמשתמש ב-Gemini למשימות עיבוד תמונות.
• ‫AI גנרטיבי ב-Vertex A לניהול זיהוי של קסדות ממקור וידאו

שיעור ה-Codelab הזה מיועד למפתחים בכל הרמות, כולל מתחילים. תשתמשו בממשק שורת הפקודה ב-Google Cloud Shell ובקוד Python. לא צריך להיות מומחה ל-Python, אבל הבנה בסיסית של קריאת קוד תעזור לכם להבין את המושגים.

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

‫2. לפני שמתחילים

הגדרת פרויקט

../shared/_project-setup.md

מפעילים את Cloud Shell

‫Cloud Shell היא סביבת שורת פקודה שפועלת ב-Google Cloud וכוללת מראש את הכלים הנדרשים.

1. לוחצים על Activate Cloud Shell (הפעלת Cloud Shell) בחלק העליון של מסוף Google Cloud:

2. אחרי שמתחברים ל-Cloud Shell, מריצים את הפקודה הבאה כדי לאמת את האימות ב-Cloud Shell:

gcloud auth list

3. מריצים את הפקודה הבאה כדי לוודא שהפרויקט מוגדר לשימוש ב-gcloud:

gcloud config get project

4. מוודאים שהפרויקט הוא כמו שציפיתם, ואז מריצים את הפקודה הבאה כדי להגדיר את מזהה הפרויקט:

export PROJECT_ID=$(gcloud config get project)

הרשאות IAM נדרשות

לחשבון שבו משתמשים ב-Codelab הזה צריכות להיות ההרשאות הבאות של IAM. ההרשאות האלה נדרשות כדי ליצור את המשאבים הנדרשים ב-Google Cloud (פרויקטים, תיקיות, אשכולות GKE, מפתחות KMS, חשבונות שירות וכו') ולהגדיר את עומס העבודה המאובטח.

ברמת הארגון:

• ‫roles/assuredworkloads.admin (מנהל מערכת של Assured Workloads): כדי ליצור ולנהל את משאב Assured Workloads עצמו, ולוודא שההגדרות תואמות.

ברמת החשבון לחיוב (בחשבון לחיוב):

• roles/billing.accountUser (משתמש בחשבון לחיוב): כדי לקשר את החשבון לחיוב שצוין.

הגדרת משתנים ב-Codelab

כדי ליצור את התשתית הנדרשת, צריך לספק את משתני הסביבה הבאים:

# The ID of the Billing Account in the format (XXXXXX-XXXXXX-XXXXXX).
# This value will be used to attach in the projects created using Assured Workloads
export BILLING_ACCOUNT=

# The ID of a Google Cloud Platform organization
# Run `gcloud organizations list` to check all your available organizations
export GCP_ORGANIZATION=

# The numeric ID of a folder where the Assured Workloads will create the resources.
export FOLDER_ID=

# Region where the application will be deployed.
# Since you are using Assured Workloads, you MUST use one of the valid locations as described here: <https://docs.cloud.google.com/assured-workloads/docs/locations>
export REGION="us-central1"

# The ID of an existing Google Cloud project to be used for API quota and billing purposes.
# This project will only be used to enable the Assured Workloads API and create an Assured Workload.
export QUOTA_PROJECT_ID=

# Random suffix used to avoid naming collisions when creating the GCP projects.
export RANDOM_SUFFIX=$(cat /dev/urandom | tr -dc 'a-z0-9' | head -c 5 ; echo)

# The ID of the projects that will be created using Assured Workloads.
# You can modify this value if you want a custom id.
export PROJECT_ID="il5-gemini-vision-aw-${RANDOM_SUFFIX}"
export KMS_PROJECT_ID="il5-gemini-vision-kms-${RANDOM_SUFFIX}"

3. יצירת הבסיס של Assured Workloads

עכשיו אפשר להניח את היסודות לאפליקציה בסביבה מפוקחת. אפשר להשתמש ב-Assured Workloads כדי ליצור סביבה מבוקרת למשאבים וכך לאכוף את דרישות התאימות.

הגדרת פרויקט המכסה

מפעילים את Assured Workloads API בפרויקט המכסה. נדרש API כדי ליצור ולנהל Assured Workloads.

gcloud services enable assuredworkloads.googleapis.com \
  --project="${QUOTA_PROJECT_ID}"

יצירת סביבת Assured Workloads

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

• פרויקט אחד מארח את אשכול ה-GKE והאפליקציה.
• בפרויקט השני מנוהלים מפתחות ההצפנה בניהול הלקוח (CMEK).

הוא מחיל באופן אוטומטי את אמצעי הבקרה שצוינו לתאימות לרמה IL5 על שני הפרויקטים מרגע היצירה שלהם.

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

export ASSURED_WORKLOAD_ID=$(gcloud assured workloads create \
    --project="${QUOTA_PROJECT_ID}" \
    --display-name="DoD IL5 Gemini Vision Demo" \
    --compliance-regime="IL5" \
    --billing-account="billingAccounts/${BILLING_ACCOUNT}" \
    --location="${REGION}" \
    --organization="${GCP_ORGANIZATION}" \
    --provisioned-resources-parent="folders/${FOLDER_ID}" \
    --resource-settings="consumer-project-id=${PROJECT_ID},consumer-project-name=DoD IL5 Workloads,encryption-keys-project-id=${KMS_PROJECT_ID},encryption-keys-project-name=DoD IL5 KMS" \
    --labels="codelab=gemini-vision-demo" \
    --format="value(name)")

echo "Assured Workload created: ${ASSURED_WORKLOAD_ID}"

export WORKLOAD_FOLDER_ID=$(gcloud assured workloads describe ${ASSURED_WORKLOAD_ID} \
    --location="${REGION}" \
    --project="${QUOTA_PROJECT_ID}" \
    --format="json" | grep -B 1 "CONSUMER_FOLDER" | grep -oE "[0-9]{10,}")

echo "Assured Workload folder created: ${WORKLOAD_FOLDER_ID}"

gcloud projects create "${PROJECT_ID}" \
    --folder="${WORKLOAD_FOLDER_ID}" \
    --name="DoD IL5 Workloads"

gcloud billing projects link "${PROJECT_ID}" \
    --billing-account="${BILLING_ACCOUNT}"

export PROJECT_NUMBER=$(gcloud projects describe "${PROJECT_ID}" --format="value(projectNumber)")

הפעלת ממשקי API נדרשים של Google Cloud

לפני שמתחילים לפתח, צריך להפעיל את ממשקי ה-API הנדרשים לשירותים הרלוונטיים.

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

gcloud services enable \
    aiplatform.googleapis.com \
    artifactregistry.googleapis.com \
    cloudkms.googleapis.com \
    compute.googleapis.com \
    container.googleapis.com \
    iam.googleapis.com \
    logging.googleapis.com \
    monitoring.googleapis.com \
    --project="${PROJECT_ID}"

4. הגדרת התשתית של GKE

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

הגדרת רשת ה-VPC

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

מריצים את הפקודות הבאות כדי ליצור את רשת ה-VPC ואת רשת המשנה באזור שצוין.

export GKE_NETWORK_NAME="il5-gke-network"
export GKE_SUBNETWORK_NAME="il5-gke-subnet"

gcloud compute networks create "${GKE_NETWORK_NAME}" \
    --description="VPC network for GKE cluster in DoD IL5 Assured Workload" \
    --subnet-mode="custom" \
    --project="${PROJECT_ID}"

gcloud compute networks subnets create "${GKE_SUBNETWORK_NAME}" \
    --network="${GKE_NETWORK_NAME}" \
    --range="10.10.0.0/20" \
    --region="${REGION}" \
    --description="Subnet for GKE cluster nodes in DoD IL5 Assured Workload" \
    --project="${PROJECT_ID}"

הגדרת הצפנה באמצעות Cloud KMS

כדי לעמוד בדרישות תאימות מחמירות לנתונים במנוחה, צריך להשתמש במפתחות הצפנה בניהול הלקוח (CMEK). כך אתם מקבלים שליטה ישירה במפתחות שמשמשים להצפנת דיסקי האתחול של צמתי GKE.

export KMS_KEYRING_NAME="il5_gke_key_ring"
export KMS_KEY_NAME="il5_gke_key"

gcloud kms keyrings create "${KMS_KEYRING_NAME}" \
    --location="$REGION" \
    --project="${KMS_PROJECT_ID}"

gcloud kms keys create "${KMS_KEY_NAME}" \
    --keyring="${KMS_KEYRING_NAME}" \
    --location="${REGION}" \
    --purpose="encryption" \
    --project="${KMS_PROJECT_ID}"

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

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

gcloud kms keys add-iam-policy-binding "${KMS_KEY_NAME}" \
    --location="${REGION}" \
    --keyring="${KMS_KEYRING_NAME}" \
    --member="serviceAccount:service-${PROJECT_NUMBER}@compute-system.iam.gserviceaccount.com" \
    --role="roles/cloudkms.cryptoKeyEncrypterDecrypter" \
    --project="${KMS_PROJECT_ID}"

הגדרת חשבון שירות של צומת GKE

export GKE_NODE_SA=gke-node-sa

gcloud iam service-accounts create "${GKE_NODE_SA}" \
    --display-name="GKE Node Service Account" \
    --project="${PROJECT_ID}"

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${GKE_NODE_SA}@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/logging.logWriter"

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${GKE_NODE_SA}@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/monitoring.metricWriter"

5. יצירה והגדרה של אשכול GKE

עכשיו אפשר ליצור את אשכול GKE. הפקודה הבאה מקצה אשכול GKE עם כמה תכונות אבטחה מופעלות.

התהליך הזה נמשך כמה דקות כי Google Cloud מקצה את הצמתים ואת מישור הבקרה.

export GKE_CLUSTER=ppe-app

gcloud beta container clusters create "${GKE_CLUSTER}" \
    --project="$PROJECT_ID" \
    --region="$REGION" \
    --service-account="${GKE_NODE_SA}@${PROJECT_ID}.iam.gserviceaccount.com" \
    --release-channel="regular" \
    --machine-type="n2d-standard-4" \
    --image-type="COS_CONTAINERD" \
    --disk-type="pd-ssd" \
    --disk-size="50" \
    --boot-disk-kms-key="projects/${KMS_PROJECT_ID}/locations/${REGION}/keyRings/${KMS_KEYRING_NAME}/cryptoKeys/${KMS_KEY_NAME}" \
    --metadata disable-legacy-endpoints=true \
    --num-nodes="1" \
    --network="projects/${PROJECT_ID}/global/networks/${GKE_NETWORK_NAME}" \
    --subnetwork="projects/${PROJECT_ID}/regions/${REGION}/subnetworks/${GKE_SUBNETWORK_NAME}" \
    --security-posture="standard" \
    --workload-vulnerability-scanning="disabled" \
    --workload-pool="${PROJECT_ID}.svc.id.goog" \
    --workload-metadata=GKE_METADATA \
    --addons="HorizontalPodAutoscaling,HttpLoadBalancing,NodeLocalDNS,GcePersistentDiskCsiDriver" \
    --max-surge-upgrade=1 \
    --max-unavailable-upgrade=0 \
    --binauthz-evaluation-mode="DISABLED" \
    --no-enable-basic-auth \
    --enable-autoupgrade \
    --enable-autorepair \
    --enable-confidential-nodes \
    --confidential-node-type=sev \
    --enable-ip-access \
    --enable-ip-alias \
    --enable-managed-prometheus \
    --enable-dns-access \
    --enable-shielded-nodes \
    --shielded-integrity-monitoring \
    --shielded-secure-boot

מתבצע חיבור לאשכול החדש

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

הפקודה הזו מאחזרת את פרטי הכניסה ואת נקודת הקצה של האשכול, ומגדירה אוטומטית את קובץ ה-kubeconfig המקומי. אחרי הרצת הפקודה הזו, כל פקודות kubectl שתריצו יופנו לאשכול GKE החדש.

gcloud container clusters get-credentials "${GKE_CLUSTER}" \
    --region="${REGION}" \
    --project="${PROJECT_ID}" \
    --dns-endpoint

6. הגדרת זהות האפליקציה

כדי לקשר חשבון שירות של Kubernetes לחשבון שירות של Google Cloud IAM, צריך להגדיר Workload Identity.

יצירת חשבונות שירות

יוצרים חשבון שירות ייעודי של Kubernetes ‏ (KSA) בתוך האשכול.

export GKE_NAMESPACE=default
export GKE_SA=ppe-sa

kubectl create sa "${GKE_SA}" --namespace="${GKE_NAMESPACE}"

בשלב הבא, האפליקציה צריכה לקבל זהות ב-Google Cloud. יוצרים חשבון שירות ב-Cloud IAM של Google לאפליקציה. אחרי שיוצרים את חשבון השירות, מקצים לו את התפקידים הנדרשים.

# Create GCP service account
gcloud iam service-accounts create "${GKE_SA}" \
    --project="${PROJECT_ID}"
# Grant necessary roles
gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${GKE_SA}@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/aiplatform.user"

מתן אפשרות לחשבון השירות של Kubernetes להתחזות לחשבון השירות של IAM

אחרי שיוצרים את שני חשבונות השירות, השלב האחרון הוא ליצור את הקישור ביניהם. התהליך הזה כולל שני חלקים. קודם צריך להוסיף מדיניות IAM לחשבון השירות שלכם ב-Google Cloud.

# Allow the Kubernetes service account to act as GCP service account by using Workload Identity
gcloud iam service-accounts add-iam-policy-binding "${GKE_SA}@${PROJECT_ID}.iam.gserviceaccount.com" \
    --project="${PROJECT_ID}" \
    --role="roles/iam.workloadIdentityUser" \
    --member="serviceAccount:${PROJECT_ID}.svc.id.goog[${GKE_NAMESPACE}/${GKE_SA}]"

בשלב השני, מוסיפים הערה לחשבון השירות של Kubernetes.

kubectl annotate --namespace="${GKE_NAMESPACE}" serviceaccount "$GKE_SA" \
    iam.gke.io/gcp-service-account="${GKE_SA}@${PROJECT_ID}.iam.gserviceaccount.com"

אחרי שמבצעים את כל השלבים האלה, כל פוד שפועל באשכול עם חשבון השירות של Kubernetes יכול לגשת ל-Vertex API.

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

7. פיתוח ופריסה של אפליקציות

הגיע הזמן לארוז את האפליקציה, לאחסן אותה ולפרוס אותה באשכול GKE.

יצירת מאגר Artifact Registry

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

export REPOSITORY_ID=ppe-repo

gcloud artifacts repositories create "${REPOSITORY_ID}" \
  --repository-format=docker \
  --location="${REGION}" \
  --project="${PROJECT_ID}" \
  --description="Regional Docker repo for PPE App"

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

gcloud artifacts repositories add-iam-policy-binding "${REPOSITORY_ID}" \
    --location="${REGION}" \
    --role="roles/artifactregistry.reader" \
    --project="${PROJECT_ID}" \
    --member="serviceAccount:${GKE_NODE_SA}@${PROJECT_ID}.iam.gserviceaccount.com"

יצירה והעברה בדחיפה של קובץ אימג' של Docker

יוצרים את קובץ האימג' של Docker ומעבירים אותו בדחיפה למאגר. קודם כל, משכפלים את קוד המקור ויוצרים את קובץ האימג' של הקונטיינר. לאחר מכן, מתייגים אותו עם הנתיב המלא שלו ב-Artifact Registry ומעבירים אותו למאגר שיצרתם קודם.

git clone https://github.com/GoogleCloudPlatform/next-26-sessions.git

cd BRK3-034-workplace-safety

cd ppe

export IMAGE_TAG="${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_ID}/ppe-app:v15"
docker build -t "${IMAGE_TAG}" .
docker push "${IMAGE_TAG}"

פריסה ב-GKE

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

הפקודה הזו פורסת את נקודת הקצה analyze לגישה מחוץ לאשכול GKE. חשוב לוודא שנקודת הקצה הזו לא נגישה מרשתות לא מהימנות, כמו VPC ברירת המחדל. באפליקציות שמוכנות להפצה כדאי להשתמש באמצעי הגנה נוספים כמו Model Armor.

export GKE_DEPLOY=ppe-detector

cat <<EOF | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ${GKE_DEPLOY}
spec:
  replicas: 2
  selector:
    matchLabels:
      app: ${GKE_DEPLOY}
  template:
    metadata:
      labels:
        app: ${GKE_DEPLOY}
    spec:
      serviceAccountName: ${GKE_SA}
      containers:
      - name: ${GKE_DEPLOY}
        image: ${IMAGE_TAG}
        env:
        - name: PROJECT_ID
          value: ${PROJECT_ID}
        - name: LOCATION
          value: ${REGION}
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "1Gi"
---
apiVersion: v1
kind: Service
metadata:
  name: ${GKE_DEPLOY}
spec:
  type: LoadBalancer
  selector:
    app: ${GKE_DEPLOY}
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
EOF

8. בדיקת האפליקציה

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

אחזור כתובת ה-IP החיצונית של השירות

מקבלים את כתובת ה-IP החיצונית של השירות שנחשף (ההקצאה אורכת כ-30 שניות)

export IP_ADDRESS=$(kubectl get service "${GKE_DEPLOY}" -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo $IP_ADDRESS

הפעלת חזית הלקוח באופן מקומי

לצורך ההדגמה הזו, הקצה הקדמי הוא דף HTML/JavaScript פשוט שלא נכלל בפריסת GKE. הוא מיועד להרצה במחשב המקומי.

הקצה הקדמי צריך להיות מוגש מ-GCP באפליקציית ייצור. במכונה מקומית:

# Update the index.html file with the server IP address
cd frontend

# For Linux
sed -i "s#\(const BACKEND_URL = \"http://\)[^/]\+\(\/analyze\";\)#\1${IP_ADDRESS}\2#g" "index.html"

# For MacOS
#sed -i '' "s#\(const BACKEND_URL = #\"http://\)[^/]*\(\/analyze\";\)#\1${IP_ADDRESS}\2#g" "index.html"

python3 -m http.server 8001

פותחים את http://localhost:8001/index.html ב-Chrome.

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

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

השמדת אשכול GKE

כדי למחוק את כל האפליקציה, צריך למחוק את אשכול GKE. כדי לעשות זאת, מריצים את הפקודה:

gcloud container clusters delete "${GKE_CLUSTER}" \
    --region="$REGION" \
    --project="${PROJECT_ID}"

מחיקת Assured Workloads

מריצים את הפקודות הבאות כדי למחוק את כל המשאבים שקשורים ל-Assured Workloads.

# Workload project deletion
gcloud billing projects unlink "${PROJECT_ID}"
gcloud projects delete "${PROJECT_ID}"

# KMS project deletion
gcloud billing projects unlink "${KMS_PROJECT_ID}"
gcloud projects delete "${KMS_PROJECT_ID}"

# Assured Workload folder deletion
gcloud resource-manager folders delete ${WORKLOAD_FOLDER_ID} --quiet

# Assured Workload deletion
gcloud assured workloads delete "${ASSURED_WORKLOAD_ID}" \
    --location="${REGION}" \
    --organization="${GCP_ORGANIZATION}" \
    --project="${QUOTA_PROJECT_ID}"

10. מזל טוב

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

מה השגתם:

• הגנה על נתונים ופרטיות: הקצאתם Confidential GKE node עם CMEK
• גבולות נתונים: הפעלתם אמצעי בקרה לתאימות פלטפורמה בסביבה מפוקחת

מאמרי עזרה

• הצפנת נתונים בשימוש בעומסי עבודה באמצעות Confidential GKE Nodes
• שימוש במדיניות ארגונית מותאמת אישית
• סקירה כללית של גבולות הנתונים באמצעות Assured Workloads