Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

การรักษาความปลอดภัยของระบบตรวจจับความปลอดภัยในที่ทำงาน

1. บทนำ

ภายใน Codelab นี้ คุณจะได้สร้างแอปพลิเคชันสาธิตพื้นฐานที่แสดงวิธีผสานรวมบริการต่างๆ ของ Google Cloud สำหรับบริการที่อยู่ในโปรเจ็กต์ที่มีข้อจำกัดด้านการปฏิบัติตามข้อกำหนด โปรเจ็กต์นี้ใช้ความสามารถด้านความปลอดภัยต่อไปนี้

ขอบเขตข้อมูล เพื่อช่วยจัดการการควบคุมสำหรับสภาพแวดล้อมที่มีการควบคุม
คีย์การเข้ารหัสที่จัดการโดยลูกค้า ( CMEK) เพื่อปกป้องข้อมูลที่เก็บไว้
โหนด GKE ที่มีการป้องกัน และ โหนด GKE ที่เป็นความลับ เพื่อช่วยรักษาความปลอดภัยของข้อมูลระหว่างการประมวลผล
Workload Identity สำหรับ GKE เพื่อจัดการการเข้าถึง Vertex AI ซึ่งใช้ Gemini สำหรับงานประมวลผลรูปภาพ
Generative AI ใน Vertex AI เพื่อจัดการการตรวจหาหมวกนิรภัยจากวิดีโอสตรีม

Codelab นี้เหมาะสำหรับนักพัฒนาซอฟต์แวร์ทุกระดับ รวมถึงผู้เริ่มต้น คุณจะได้ใช้อินเทอร์เฟซบรรทัดคำสั่งใน Google Cloud Shell และโค้ด Python คุณไม่จำเป็นต้องเป็นผู้เชี่ยวชาญด้าน Python แต่ความเข้าใจพื้นฐานเกี่ยวกับวิธีอ่านโค้ดจะช่วยให้คุณเข้าใจแนวคิดต่างๆ ได้

หมายเหตุ: นี่เป็นเพียงการพิสูจน์แนวคิดแบบง่าย ไม่ใช่แอปพลิเคชันที่พร้อมใช้งานจริง โปรดใช้ความระมัดระวังเพิ่มเติม เช่น การเข้าถึงภายนอกที่ตรวจสอบสิทธิ์และปลอดภัยสำหรับบริการนี้ในสถานการณ์จริง

2. ก่อนเริ่มต้น

การตั้งค่าโปรเจ็กต์

../shared/_project-setup.md

เริ่มต้น Cloud Shell

Cloud Shell คือสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานใน Google Cloud ซึ่งโหลดเครื่องมือที่จำเป็นไว้ล่วงหน้า

คลิกเปิดใช้งาน Cloud Shell ที่ด้านบนของคอนโซล Google Cloud

เมื่อเชื่อมต่อกับ Cloud Shell แล้ว ให้เรียกใช้คำสั่งนี้เพื่อยืนยันการตรวจสอบสิทธิ์ ใน Cloud Shell

gcloud auth list

เรียกใช้คำสั่งต่อไปนี้เพื่อยืนยันว่าโปรเจ็กต์ได้รับการกำหนดค่าให้ใช้กับ gcloud แล้ว

gcloud config get project

ยืนยันว่าโปรเจ็กต์เป็นไปตามที่คาดไว้ แล้วเรียกใช้คำสั่งด้านล่างเพื่อตั้งค่ารหัสโปรเจ็กต์

export PROJECT_ID=$(gcloud config get project)

สิทธิ์ IAM ที่จำเป็น

บัญชีที่คุณใช้สำหรับ Codelab นี้ต้องมีบทบาท IAM ต่อไปนี้ คุณต้องมีสิทธิ์เหล่านี้เพื่อสร้างทรัพยากร Google Cloud ที่จำเป็น (โปรเจ็กต์ โฟลเดอร์ คลัสเตอร์ GKE คีย์ KMS บัญชีบริการ ฯลฯ) และกำหนดค่า Assured Workload

ที่ระดับองค์กร

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 Workload

คำสั่งต่อไปนี้จะสร้าง "Landing Zone" ที่ปลอดภัยสำหรับการสาธิต โดยจะสร้างโปรเจ็กต์ Google Cloud ใหม่ 2 รายการภายใต้โฟลเดอร์และบัญชีสำหรับการเรียกเก็บเงินที่คุณระบุ

โปรเจ็กต์หนึ่งโฮสต์คลัสเตอร์ GKE และแอปพลิเคชัน
อีกโปรเจ็กต์หนึ่งจัดการคีย์การเข้ารหัสที่จัดการโดยลูกค้า (CMEK)

ระบบจะใช้การควบคุมการปฏิบัติตามข้อกำหนด IL5 ที่ระบุกับทั้ง 2 โปรเจ็กต์โดยอัตโนมัติตั้งแต่ตอนที่สร้าง

เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างสภาพแวดล้อมภาระงาน

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

การเปิดใช้ Google Cloud APIs ที่จำเป็น

ก่อนสร้าง ให้เปิดใช้ 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

สร้าง Virtual Private Cloud (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 สร้างบัญชีบริการ Google Cloud IAM สำหรับแอปพลิเคชัน หลังจากสร้างบัญชีบริการแล้ว ให้มอบบทบาทที่จำเป็นให้กับบัญชีดังกล่าว

# 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

เมื่อสร้างบัญชีบริการทั้ง 2 บัญชีแล้ว ขั้นตอนสุดท้ายคือการสร้างลิงก์ระหว่างบัญชีทั้ง 2 กระบวนการนี้มี 2 ส่วน ขั้นแรก ให้เพิ่มนโยบาย 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 ดึงและดำเนินการ ซึ่งทำได้โดยการกำหนดทรัพยากรของแอปพลิเคชันในไฟล์ Manifest ของ Kubernetes แล้วนำไปใช้กับคลัสเตอร์ คำสั่งนี้จะสร้างออบเจ็กต์การทำให้ใช้งานได้และออบเจ็กต์บริการที่กำหนดไว้ในไฟล์

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 Workload

# 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 ด้วย CMEK
ขอบเขตข้อมูล: คุณได้เปิดใช้การควบคุมการปฏิบัติตามข้อกำหนดของแพลตฟอร์มสำหรับสภาพแวดล้อมที่มีการควบคุม