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

1. परिचय

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

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

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

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

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

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

../shared/_project-setup.md

Cloud Shell शुरू करना

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

  1. Google Cloud कंसोल में सबसे ऊपर, 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 क्लस्टर, KMS की, सेवा खाते वगैरह) बनाने और 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 Workload एनवायरमेंट बनाना

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

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

प्रोजेक्ट बनने के बाद से ही, उन पर IL5 के नियमों के मुताबिक काम करने के लिए तय किए गए कंट्रोल अपने-आप लागू हो जाते हैं.

Workload एनवायरमेंट बनाने के लिए, यह कमांड चलाएं.

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 के ज़रूरी एपीआई चालू करना

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

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

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

ऐसा इसलिए, क्योंकि एन्क्रिप्शन कुंजी, 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 का एक अलग सेवा खाता (केएसए) बनाएं.

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 में डेटाबेस बनाना

ऐप्लिकेशन चलाने से पहले, उसे डॉकर कंटेनर के तौर पर पैकेज करें और 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"

डॉकर इमेज बनाना और उसे पुश करना

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

रेफ़रंस के तौर पर इस्तेमाल किए जाने वाले दस्तावेज़