कार्यस्थल पर सुरक्षा से जुड़े खतरों का पता लगाने वाले सिस्टम को सुरक्षित करना

1. परिचय

इस कोडलैब में, आपको एक बुनियादी डेमो ऐप्लिकेशन बनाना होगा. इससे यह पता चलेगा कि अनुपालन से जुड़ी पाबंदियों वाले प्रोजेक्ट में मौजूद किसी सेवा के लिए, Google Cloud की अलग-अलग सेवाओं को कैसे इंटिग्रेट किया जाता है. यह प्रोजेक्ट, सुरक्षा से जुड़ी इन सुविधाओं का इस्तेमाल करता है:

  • डेटा बाउंड्री, ताकि नियमों के दायरे में आने वाले एनवायरमेंट के लिए कंट्रोल को मैनेज किया जा सके
  • डेटा को सुरक्षित रखने के लिए, ग्राहक की ओर से मैनेज की जाने वाली एन्क्रिप्शन कुंजियां ( CMEK);
  • प्रोसेसिंग के दौरान डेटा को सुरक्षित रखने के लिए, GKE शील्डेड नोड और GKE कॉन्फ़िडेंशियल नोड;
  • Vertex AI को ऐक्सेस करने के लिए, GKE के लिए Workload Identity का इस्तेमाल करें. Vertex AI, इमेज प्रोसेसिंग के टास्क के लिए Gemini का इस्तेमाल करता है.
  • वीडियो स्ट्रीम से हार्ड हैट का पता लगाने की सुविधा को मैनेज करने के लिए, Vertex AI में जनरेटिव एआई

यह कोडलैब, सभी लेवल के डेवलपर के लिए है. इसमें शुरुआती डेवलपर भी शामिल हैं. आपको Google Cloud Shell में कमांड-लाइन इंटरफ़ेस और Python कोड का इस्तेमाल करना होगा. आपको Python का विशेषज्ञ होने की ज़रूरत नहीं है. हालांकि, कोड को पढ़ने की बुनियादी जानकारी होने से, आपको कॉन्सेप्ट समझने में मदद मिलेगी.

ध्यान दें: यह एक आसान कॉन्सेप्ट का सबूत है, न कि प्रोडक्शन ऐप्लिकेशन. इस सेवा को बाहरी ऐप्लिकेशन के साथ इंटिग्रेट करने के लिए, अतिरिक्त सावधानियां बरतें. जैसे, बाहरी ऐप्लिकेशन को इस सेवा का ऐक्सेस देने से पहले, उसकी पुष्टि करें और यह पक्का करें कि वह सुरक्षित है.

2. शुरू करने से पहले

प्रोजेक्ट सेटअप करना

../shared/_project-setup.md

Cloud Shell शुरू करें

Cloud Shell, Google Cloud में चलने वाला कमांड-लाइन एनवायरमेंट है. इसमें ज़रूरी टूल पहले से लोड होते हैं.

  1. Google Cloud Console में सबसे ऊपर मौजूद, Cloud Shell चालू करें पर क्लिक करें:

404e4cce0f23e5c5.png

  1. Cloud Shell से कनेक्ट होने के बाद, Cloud Shell में अपनी पुष्टि करने के लिए, यह कमांड चलाएं:
gcloud auth list
  1. यह पुष्टि करने के लिए कि आपका प्रोजेक्ट, gcloud के साथ इस्तेमाल करने के लिए कॉन्फ़िगर किया गया है, यह निर्देश चलाएं:
gcloud config get project
  1. पुष्टि करें कि प्रोजेक्ट आपकी उम्मीद के मुताबिक है. इसके बाद, अपना प्रोजेक्ट आईडी सेट करने के लिए, यहां दिया गया निर्देश चलाएं:
export PROJECT_ID=$(gcloud config get project)

IAM से जुड़ी ज़रूरी अनुमतियां

इस कोडलैब के लिए इस्तेमाल किए जाने वाले खाते में, ये IAM भूमिकाएं होनी चाहिए. ज़रूरी Google Cloud संसाधन (प्रोजेक्ट, फ़ोल्डर, GKE क्लस्टर, केएमएस कुंजियां, सेवा खाते वगैरह) बनाने और Assured Workload को कॉन्फ़िगर करने के लिए, ये अनुमतियां ज़रूरी हैं.

संगठन के लेवल पर:

  • roles/assuredworkloads.admin (Assured Workloads एडमिन): Assured Workloads संसाधन को बनाने और मैनेज करने के लिए. इससे यह पक्का किया जा सकता है कि अनुपालन से जुड़ी सेटिंग कॉन्फ़िगर की गई हैं.

बिलिंग खाते के लेवल पर (आपके बिलिंग खाते में):

  • roles/billing.accountUser (बिलिंग खाते का उपयोगकर्ता): इससे चुने गए बिलिंग खाते को लिंक किया जा सकता है.

कोडलैब वैरिएबल कॉन्फ़िगर करना

ज़रूरी इन्फ़्रास्ट्रक्चर बनाने के लिए, आपको ये एनवायरमेंट वैरिएबल देने होंगे:

# 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 चालू करें. Assured Workloads बनाने और मैनेज करने के लिए, इस एपीआई की ज़रूरत होती है.

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

Assured Workloads एनवायरमेंट बनाना

नीचे दिए गए निर्देश से, आपके डेमो के लिए एक सुरक्षित 'लैंडिंग ज़ोन' बनाया जाता है. इससे आपके चुने गए फ़ोल्डर और बिलिंग खाते में दो नए Google Cloud प्रोजेक्ट बन जाते हैं.

  • एक प्रोजेक्ट में आपका GKE क्लस्टर और ऐप्लिकेशन होस्ट किया जाता है.
  • दूसरा प्रोजेक्ट, ग्राहक की ओर से मैनेज की जाने वाली एन्क्रिप्शन कुंजियों (सीएमईके) को मैनेज करता है.

यह दोनों प्रोजेक्ट के लिए, 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)")

ज़रूरी Google Cloud API चालू करना

ऐप्लिकेशन बनाने से पहले, ज़रूरी सेवाओं के लिए ज़रूरी एपीआई चालू करें.

नीचे दिए गए निर्देश से, आपके प्राइमरी वर्कलोड प्रोजेक्ट में इस कोडलैब के लिए ज़रूरी सभी सेवाएं चालू हो जाती हैं.

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 क्लस्टर के लिए, मुख्य इंफ़्रास्ट्रक्चर बनाएं. इसके लिए, आपको अपने क्लस्टर के लिए एक अलग नेटवर्क सेट अप करना होगा. साथ ही, अपने नोड पर मौजूद डेटा को सुरक्षित रखने के लिए, एन्क्रिप्शन कुंजियां कॉन्फ़िगर करनी होंगी.

वीपीसी नेटवर्क को कॉन्फ़िगर करना

अपनी पसंद के मुताबिक वर्चुअल प्राइवेट क्लाउड (वीपीसी) और सबनेटवर्क बनाएं. इस तरीके से, आपको आईपी पते की रेंज पर पूरा कंट्रोल मिलता है. साथ ही, यह पक्का किया जाता है कि आपका क्लस्टर, आपकी ज़रूरत के हिसाब से अलग किया गया हो.

वीपीसी नेटवर्क और तय किए गए क्षेत्र में सबनेटवर्क बनाने के लिए, ये कमांड चलाएं.

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 की मदद से एन्क्रिप्शन कॉन्फ़िगर करना

डेटा-ऐट-रेस्ट के लिए, अनुपालन से जुड़ी सख्त ज़रूरी शर्तों को पूरा करने के लिए, ग्राहक की ओर से मैनेज की जाने वाली एन्क्रिप्शन कुंजियों (सीएमईके) का इस्तेमाल करें. इससे आपको उन कुंजियों को सीधे तौर पर कंट्रोल करने की सुविधा मिलती है जिनका इस्तेमाल आपके 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}"

एन्क्रिप्शन कुंजी, उस सेवा से अलग केएमएस प्रोजेक्ट में मौजूद होती है जिसे इसका इस्तेमाल करना है. इसलिए, वर्कलोड प्रोजेक्ट में Google Compute Engine सेवा एजेंट को कुंजी का ऐक्सेस चाहिए.

आपको वर्कलोड प्रोजेक्ट के GCE सेवा एजेंट को, इस कुंजी का इस्तेमाल करने की अनुमति साफ़ तौर पर देनी होगी. नीचे दी गई कमांड, कुंजी में आईएएम नीति बाइंडिंग जोड़ती है. इससे सेवा एजेंट को ज़रूरी भूमिका मिल जाती है.

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 सेवा खाता (केएसए) बनाएं.

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 खाते के तौर पर काम करने की अनुमति देना

दोनों सेवा खाते बन जाने के बाद, आखिरी चरण में इनके बीच लिंक बनाना होता है. यह दो चरणों वाली प्रोसेस है. सबसे पहले, अपने Google Cloud सेवा खाते में IAM नीति जोड़ें.

# 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 इमेज को रिपॉज़िटरी में बनाएं और पुश करें. सबसे पहले, सोर्स कोड को क्लोन करें और कंटेनर इमेज बनाएं. इसके बाद, इसे 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 मेनिफ़ेस्ट फ़ाइल में अपने ऐप्लिकेशन के संसाधनों को तय करें और उसे क्लस्टर पर लागू करें. इस कमांड से, फ़ाइल में तय किए गए डिप्लॉयमेंट और सेवा ऑब्जेक्ट बनाए जाते हैं.

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. ऐप्लिकेशन की टेस्टिंग

आखिरी चरण में, डेमो ऐप्लिकेशन को ऐक्सेस और टेस्ट करना होता है. इसमें सेवा को असाइन किया गया बाहरी आईपी पता वापस पाना और एक सामान्य फ़्रंटएंड के ज़रिए उससे इंटरैक्ट करना शामिल है.

सेवा का बाहरी आईपी पता वापस पाना

एक्सपोज़ की गई सेवा का बाहरी आईपी पता पाएं (इसे चालू होने में करीब 30 सेकंड लगते हैं)

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

फ़्रंटएंड को स्थानीय तौर पर चलाना

इस डेमो के लिए, फ़्रंटएंड एक सामान्य एचटीएमएल/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

Chrome में http://localhost:8001/index.html खोलें.

9. स्टोरेज में जगह बनाएं

लगातार लगने वाले शुल्क से बचने के लिए, इस कोडलैब में बनाए गए संसाधनों को मिटाएं.

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 का इस्तेमाल करता है.

आपको क्या मिला:

  • डेटा की सुरक्षा और निजता: आपने CMEK की मदद से Confidential GKE नोड को प्रोविज़न किया हो
  • डेटा बाउंड्री: आपने किसी ऐसे एनवायरमेंट के लिए प्लैटफ़ॉर्म के अनुपालन से जुड़े कंट्रोल चालू किए हैं जिस पर नियम लागू होते हैं

रेफ़रंस दस्तावेज़