Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

Confidential GKE Node पर, दूर से प्रमाणित करने और सील करने की सुविधा (vTPM, SEV-SNP, TDX)

1. खास जानकारी

Confidential GKE (CGKE) नोड यह पक्का करते हैं कि वर्कलोड में मौजूद डेटा का इस्तेमाल एन्क्रिप्ट (सुरक्षित) करके किया जा रहा हो. CGKE वर्कलोड के लिए vTPM डिवाइस को चालू करने से, वर्कलोड को vTPM की सुविधाओं का इस्तेमाल करने की अनुमति मिलती है. इस कोडलैब में, आपको vTPM की सुविधाओं के बारे में जानकारी मिलेगी. साथ ही, cc-device-plugin का इस्तेमाल करके, Intel TDX और AMD SEV-SNP की हार्डवेयर प्रमाणित करने की सुविधा का फ़ायदा पाने का तरीका भी बताया जाएगा.

vTPM की मदद से, दूर से प्रमाणित करने की सुविधा का इस्तेमाल करके, दूर मौजूद कोई पक्ष यह पुष्टि कर सकता है कि वर्कलोड होस्ट करने वाले CGKE नोड, Confidential VMs (CVM) पर चल रहे हैं.
vTPM की अनुमति और vTPM सीलिंग.
Intel TDX और AMD SEV-SNP गेस्ट डिवाइसों का इस्तेमाल करके, हार्डवेयर की पुष्टि करना.

ऊपर दिए गए डायग्राम में दिखाया गया है कि इस कोडलैब के पहले हिस्से में ये चरण शामिल हैं:

CGKE नोड, चुने गए वर्कलोड के लिए vTPM डिवाइस को सेट अप और उपलब्ध कराते हैं.
किसी वर्कलोड को डिप्लॉय करें और उस वर्कलोड को होस्ट करने वाले CGKE नोड की पुष्टि करें.
हार्डवेयर की पुष्टि करने वाले कोटेशन को सीधे TDX या SEV-SNP डिवाइसों से फ़ेच करने के लिए, वर्कलोड डिप्लॉय करें.
सीक्रेट रिलीज़ वेब सर्वर सेटअप.

ऊपर दिए गए डायग्राम में दिखाया गया है कि इस कोडलैब के दूसरे हिस्से में ये चीज़ें शामिल हैं:

CGKE नोड पर, vTPM की अनुमति और vTPM सीलिंग सेट अप करना.

ऊपर दिए गए डायग्राम में दिखाया गया है कि इस कोडलैब के तीसरे हिस्से में ये चीज़ें शामिल हैं:

सेटअप फ़ेज़ के दौरान, cc-device-plugin हार्डवेयर डिवाइसों को सुरक्षित तरीके से कैसे मैप करता है.
रंटाइम फ़ेज़ के दौरान, हार्डवेयर अटेंशन कोटेशन को सीधे TDX या SEV-SNP डिवाइसों से फ़ेच करने के लिए, वर्कलोड डिप्लॉय करना. इसमें कोई अतिरिक्त शुल्क नहीं लगता.

आपको क्या सीखने को मिलेगा

CGKE वर्कलोड के लिए, vTPM डिवाइस को कैसे ऐक्सेस किया जा सकता है.
CGKE वर्कलोड पर, Confidential Computing API (Attestation Verifier सेवा) की मदद से, दूर से पुष्टि कैसे करें.
vTPM की अनुमति सेट अप करने और vTPM सीलिंग करने का तरीका.
cc-device-plugin का इस्तेमाल करके, CGKE वर्कलोड में SEV-SNP और TDX डिवाइसों को कैसे ऐक्सेस करें.
go-tdx-guest और go-sev-guest का इस्तेमाल करके, हार्डवेयर अटेस्टेशन कोट कैसे फ़ेच करें.

आपको इन चीज़ों की ज़रूरत होगी

Google Cloud Platform प्रोजेक्ट
Chrome या Firefox जैसे ब्राउज़र
Google Compute Engine (कोडलैब), Confidential VM, Confidential GKE नोड, और Artifact Registry के बारे में बुनियादी जानकारी
Intel TDX या AMD SEV-SNP के लिए: GKE का कम से कम v1.33.5-gke.1697000+ या v1.34.1-gke.2909000+ वर्शन और सही मशीन फ़ैमिली (TDX के लिए c3, SNP के लिए n2d).

2. सेटअप और ज़रूरी शर्तें

ज़रूरी एपीआई चालू करने के लिए, क्लाउड कंसोल या अपने लोकल डेवलपमेंट एनवायरमेंट में यह कमांड चलाएं:

gcloud auth login

gcloud services enable \
    cloudapis.googleapis.com \
    cloudshell.googleapis.com \
    container.googleapis.com \
    artifactregistry.googleapis.com \
    confidentialcomputing.googleapis.com \
    iamcredentials.googleapis.com \
    compute.googleapis.com

3. शेयर किए गए CGKE कंट्रोल प्लेन को सेट अप करना

इस चरण में, शेयर किया गया GKE कंट्रोल प्लैन और Artifact Registry Docker रिपॉज़िटरी सेट अप की जाती है.

1). एनवायरमेंट वैरिएबल सेट अप करें और शेयर किया गया GKE क्लस्टर बनाएं:

your-project-id की जगह अपना प्रोजेक्ट आईडी डालें. us-central1-c को अपनी पसंद के ज़ोन से बदलें. (रीजन और ज़ोन देखें)

export PROJECT_ID="your-project-id"
export ZONE="us-central1-c"
export CLUSTER_NAME="cgke-attestation-codelab"

gcloud config set project ${PROJECT_ID}

gcloud container clusters create ${CLUSTER_NAME} \
    --zone=${ZONE} \
    --num-nodes=1 \
    --machine-type=e2-medium \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --workload-metadata=GKE_METADATA

gcloud container clusters get-credentials ${CLUSTER_NAME} --zone=${ZONE}

2). वर्कलोड कंटेनर इमेज सेव करने के लिए, Artifact Registry Docker रिपॉज़िटरी बनाएं:

gcloud artifacts repositories create codelab-repo \
    --repository-format=docker \
    --location=us

अपने हिसाब से विकल्प चुनें

शेयर किया गया GKE कंट्रोल प्लैन और Artifact Registry रिपॉज़िटरी अब इस्तेमाल के लिए तैयार है. अपने हिसाब से विकल्प चुनें:

पहला विकल्प: vTPM की मदद से, दूर से प्रमाणित करने और सील करने की सुविधा (AMD SEV) — सीधे CGKE नोड सेट अप करने और vTPM डिवाइस को ऐक्सेस करने की सुविधा चालू करने पर जाएं.
दूसरा विकल्प: हार्डवेयर की पुष्टि करना (Intel TDX और AMD SEV-SNP) — सीधे हार्डवेयर की पुष्टि करने के लिए वर्कलोड डिप्लॉय करना पर जाएं. (क्या आपको सभी सुविधाएं एक्सप्लोर करनी हैं? सिर्फ़ पहले विकल्प को पूरा करें और फिर दूसरे विकल्प पर जाएं)

4. CGKE नोड सेट अप करना और चुने गए वर्कलोड के लिए vTPM डिवाइस को ऐक्सेस करने की अनुमति देना

इस चरण में, CGKE पर एक vTPM नोड पूल बनाया जाता है. साथ ही, CVM vTPM डिवाइस को वर्कलोड के लिए उपलब्ध कराने के लिए, डिवाइस प्लगिन लागू किया जाता है. कमांड चलाने के लिए, क्लाउड कंसोल या अपने लोकल डेवलपमेंट एनवायरमेंट पर जाएं.

1). AMD SEV नोड पूल जोड़ना

gcloud container node-pools create sev-pool \
    --cluster=${CLUSTER_NAME} \
    --zone=${ZONE} \
    --machine-type=n2d-standard-2 \
    --num-nodes=1 \
    --enable-confidential-nodes \
    --confidential-node-type=sev

2). डिफ़ॉल्ट नोड पूल मिटाएं (ज़रूरी नहीं, लेकिन लागत/शोर को कम करने के लिए सुझाव दिया जाता है)

gcloud container node-pools delete default-pool \
    --cluster=${CLUSTER_NAME} \
    --zone=${ZONE} \
    --quiet

3). डिवाइस प्लगिन शुरू करें, ताकि CGKE क्लस्टर, वर्कलोड के लिए vTPM डिवाइस को ऐक्सेस करने की अनुमति दे सके. हम नए संसाधन (google.com/cc) बनाने के लिए, Kubernetes डिवाइस प्लगिन का इस्तेमाल करते हैं. नए संसाधन से जुड़ा कोई भी वर्कलोड, वर्कर नोड पर मौजूद डिवाइसों को देख पाएगा.

gcloud container clusters get-credentials ${CLUSTER_NAME} --zone ${ZONE} --project ${PROJECT_ID}

kubectl apply -f https://raw.githubusercontent.com/google/cc-device-plugin/main/manifests/cc-device-plugin.yaml

नीचे दी गई कमांड की मदद से, डिप्लॉय किए गए cc-device-plugin को देखा जा सकता है.

kubectl get pods -A | grep "cc-device-plugin"

ध्यान दें: अगर GKE क्लस्टर में गोपनीय और गैर-गोपनीय, दोनों तरह के GKE वर्कर नोड हैं, तो हमारा सुझाव है कि ऑपरेटर सिर्फ़ गोपनीय GKE वर्कर नोड पर cc-device-plugin को डिप्लॉय करे.

(ज़रूरी नहीं). CGKE पॉड के लिए, Prometheus मॉनिटरिंग लागू करें. निगरानी की सुविधा चालू करने पर, आपको डिवाइस के प्लगिन होने की स्थिति के बारे में पता चलता है.

kubectl apply -f https://raw.githubusercontent.com/google/cc-device-plugin/main/manifests/cc-device-plugin-pod-monitoring.yaml

https://console.cloud.google.com/monitoring/metrics-explorer पर जाएं और cc-device-plugin मेट्रिक ढूंढें या PROMQL का इस्तेमाल करें. उदाहरण के लिए, यहां दी गई PROMQL कमांड से हर cc-device-plugin प्रोसेस के लिए सीपीयू सेकंड दिखते हैं.

rate(process_cpu_seconds_total[${__interval}])

5. वर्कलोड डिप्लॉय करना और वर्कलोड पर रिमोट अटेस्टेशन (vTPM) करना

इस चरण में, पिछले चरण में बनाए गए CGKE क्लस्टर पर एक वर्कलोड बनाया और डिप्लॉय किया जाता है. साथ ही, वर्कर नोड पर पुष्टि करने वाला टोकन (OIDC टोकन) पाने के लिए, vTPM की रिमोट पुष्टि की जाती है.

1). ऐप्लिकेशन कंटेनर इमेज बनाएं और उसे Artifact Registry में पुश करें. ऐप्लिकेशन कंटेनर इमेज में go-tpm टूल होता है. यह पुष्टि करने के सबूत इकट्ठा कर सकता है और उन्हें Attestation Verifier सेवा को भेज सकता है. इससे Attestation Verifier सेवा, पुष्टि करने वाला टोकन (ओआईडीसी टोकन) जनरेट कर सकती है.

ऐप्लिकेशन कंटेनर इमेज के लिए Dockerfile बनाएं.

cat << 'EOF' > Dockerfile
FROM golang:1.26.4 as builder
WORKDIR /
RUN git clone https://github.com/google/go-tpm-tools.git
WORKDIR /go-tpm-tools/cmd/gotpm
RUN CGO_ENABLED=0 GOOS=linux go build -o /gotpm

FROM debian:trixie
WORKDIR /
RUN apt-get update -y
RUN DEBIAN_FRONTEND=noninteractive apt-get install -y ca-certificates curl
RUN rm -rf /etc/apt/sources.list.d
COPY --from=builder /gotpm /gotpm
CMD ["tail", "-f", "/dev/null"]
EOF

ऐप्लिकेशन कंटेनर इमेज को Artifact Registry में पुश करें.

docker build -t us-docker.pkg.dev/${PROJECT_ID}/codelab-repo/go-tpm:latest .
docker push us-docker.pkg.dev/${PROJECT_ID}/codelab-repo/go-tpm:latest

2). Kubernetes सेवा खाता सेट अप करें, ताकि वह GCP संसाधनों पर GCP सेवा खाते की अनुमतियां पा सके.

Kubernetes सेवा खाता बनाएं codelab-ksa.

kubectl create serviceaccount codelab-ksa \
    --namespace default

कोई भूमिका Confidential_Computing_Workload_User बनाएं और उसे गोपनीय कंप्यूटिंग एपीआई ऐक्सेस करने की अनुमतियां दें.

gcloud iam roles create Confidential_Computing_Workload_User --project=${PROJECT_ID} \
    --title="CGKE Workload User" --description="Grants the ability to generate an attestation token in a GKE workload." \
    --permissions="confidentialcomputing.challenges.create,confidentialcomputing.challenges.verify,confidentialcomputing.locations.get,confidentialcomputing.locations.list" --stage=GA

GCP सेवा खाता बनाएं codelab-csa और उसे भूमिका Confidential_Computing_Workload_User के साथ बाइंड करें. ताकि codelab-csa के पास कॉन्फ़िडेंशियल कंप्यूटिंग एपीआई को ऐक्सेस करने की अनुमतियां हों.

gcloud iam service-accounts create codelab-csa \
    --project=${PROJECT_ID}

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:codelab-csa@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role "projects/${PROJECT_ID}/roles/Confidential_Computing_Workload_User"

gcloud iam service-accounts add-iam-policy-binding codelab-csa@${PROJECT_ID}.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/codelab-ksa]"

Kubernetes सेवा खाते codelab-ksa को GCP सेवा खाते codelab-csa से बाइंड करें. ताकि codelab-ksa के पास कॉन्फ़िडेंशियल कंप्यूटिंग एपीआई को ऐक्सेस करने की अनुमतियां हों.

kubectl annotate serviceaccount codelab-ksa \
    --namespace default \
    iam.gke.io/gcp-service-account=codelab-csa@${PROJECT_ID}.iam.gserviceaccount.com

3). डेमो ऐप्लिकेशन के लिए, ऐप्लिकेशन डिप्लॉयमेंट YAML बनाएं. चुने गए वर्कलोड को Kubernetes सेवा खाता codelab-ksa असाइन करें.

cat << EOF > deploy.yaml
apiVersion: v1
kind: Pod
metadata:
  name: go-tpm-demo
  labels:
    app.kubernetes.io/name: go-tpm-demo
spec:
  serviceAccountName: codelab-ksa
  nodeSelector:
    iam.gke.io/gke-metadata-server-enabled: "true"
    cloud.google.com/machine-family: "n2d" 
    cloud.google.com/gke-confidential-nodes-instance-type: "SEV"
  containers:
  - name: go-tpm
    image: us-docker.pkg.dev/${PROJECT_ID}/codelab-repo/go-tpm:latest
    resources:
      limits:
        google.com/cc: 1
EOF

4). CGKE क्लस्टर पर डिप्लॉयमेंट लागू करें.

kubectl apply -f deploy.yaml

5). वर्कलोड से कनेक्ट करें और रिमोट अटेस्टेशन लॉन्च करें, ताकि अटेस्टेशन टोकन (ओआईडीसी टोकन) फ़ेच किया जा सके.

kubectl exec -it go-tpm-demo -- /bin/bash
./gotpm token --event-log=/run/cc-device-plugin/binary_bios_measurements > attestation_token

6). टोकन को स्क्रीन पर प्रिंट करें, ताकि उसे कॉपी किया जा सके.

cat attestation_token

दावों को देखने के लिए, पुष्टि करने वाले टोकन को jwt.io में डिकोड किया जा सकता है.

6. सीक्रेट रिलीज़ वेब सर्वर सेट अप करना

इस चरण में, पिछले SSH सेशन से बाहर निकलें और दूसरी वर्चुअल मशीन सेट अप करें. इस वीएम पर, आपको सीक्रेट रिलीज़ वेब सर्वर सेट अप करना है. वेब सर्वर, मिले हुए Attestation Token और उसके दावों की पुष्टि करता है. अगर पुष्टि हो जाती है, तो यह अनुरोध करने वाले व्यक्ति को सीक्रेट पास कर देता है.

1). Cloud Console या अपने लोकल डेवलपमेंट एनवायरमेंट पर जाएं. वर्चुअल मशीन बनाएं.

gcloud config set project ${PROJECT_ID}

gcloud compute instances create cgke-attestation-codelab-web-server \
    --machine-type=n2d-standard-2 \
    --zone=${ZONE} \
    --image-family=ubuntu-2204-lts \
    --image-project=ubuntu-os-cloud

2). अपने नए वीएम से एसएसएच करें.

gcloud compute ssh --zone ${ZONE} cgke-attestation-codelab-web-server

3). Go एनवायरमेंट सेट अप करें.

wget https://go.dev/dl/go1.26.4.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.26.4.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin

4). सीक्रेट रिलीज़ वेब सर्वर के सोर्स कोड को सेव करने वाली ये दो फ़ाइलें बनाएं.

main.go बनाएं:

cat << 'EOF' > main.go
package main

import (
	"fmt"
	"net/http"
	"strings"
	"time"
	"log"

	"github.com/golang-jwt/jwt/v4"
)

const (
	theSecret = "This is the super secret information!"
)

func homePage(w http.ResponseWriter, r *http.Request) {
	tokenString := r.Header.Get("Authorization")
	if tokenString != "" {
		tokenString, err := extractToken(tokenString)
		if err != nil {
			http.Error(w, err.Error(), http.StatusUnauthorized)
		}

		tokenBytes := []byte(tokenString)
		// A method to return a public key from the well-known endpoint
		keyFunc := getRSAPublicKeyFromJWKsFile

		token, err := decodeAndValidateToken(tokenBytes, keyFunc)
		if err != nil {
			http.Error(w, "Invalid JWT Token", http.StatusUnauthorized)
		}

		if ok, err := isValid(token.Claims.(jwt.MapClaims)); ok {
			fmt.Fprintln(w, theSecret)
		} else {
			if err != nil {
				http.Error(w, "Error validating JWT claims: "+err.Error(), http.StatusUnauthorized)
			} else {
				http.Error(w, "Invalid JWT token Claims", http.StatusUnauthorized)
			}
		}
	} else {
		http.Error(w, "Authorization token required", http.StatusUnauthorized)
	}
}

func extractToken(tokenString string) (string, error) {
	if strings.HasPrefix(tokenString, "Bearer ") {
		return strings.TrimPrefix(tokenString, "Bearer "), nil
	}
	return "", fmt.Errorf("invalid token format")
}

func isValid(claims jwt.MapClaims) (bool, error) {
	// 1. Evaluating Standard Claims:
	subject, ok := claims["sub"].(string)
	if !ok {
		return false, fmt.Errorf("missing or invalid 'sub' claim")
	}
	fmt.Println("Subject:", subject)

	issuedAt, ok := claims["iat"].(float64)
	if !ok {
		return false, fmt.Errorf("missing or invalid 'iat' claim")
	}
	fmt.Println("Issued At:", time.Unix(int64(issuedAt), 0))

	// 2. Evaluating Remote Attestation Claims:
	hwModel, ok := claims["hwmodel"].(string)
	// Support attestation of both AMD SEV and Intel TDX
	if !ok || (hwModel != "GCP_AMD_SEV" && hwModel != "GCP_INTEL_TDX") {
		return false, fmt.Errorf("missing or invalid 'hwModel': %v", hwModel)
	}
	fmt.Println("hwmodel:", hwModel)

	swName, ok := claims["swname"].(string)
	if !ok || swName != "GCE" {
		return false, fmt.Errorf("missing or invalid 'swName'")
	}
	fmt.Println("swname:", swName)

	return true, nil
}


func main() {
	http.HandleFunc("/", homePage)
	fmt.Println("Server listening on :8080")
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		log.Fatalf("Server failed to start: %v", err)
	}
}
EOF

helper.go बनाएं:

cat << 'EOF' > helper.go
package main

import (
	"crypto/rsa"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"math/big"
	"net/http"

	"github.com/golang-jwt/jwt/v4"
)

const (
	socketPath     = "/run/container_launcher/teeserver.sock"
	expectedIssuer = "https://confidentialcomputing.googleapis.com"
	wellKnownPath  = "/.well-known/openid-configuration"
)

type jwksFile struct {
	Keys []jwk `json:"keys"`
}

type jwk struct {
	N   string `json:"n"`   // "nMMTBwJ7H6Id8zUCZd-L7uoNyz9b7lvoyse9izD9l2rtOhWLWbiG-7pKeYJyHeEpilHP4KdQMfUo8JCwhd-OMW0be_XtEu3jXEFjuq2YnPSPFk326eTfENtUc6qJohyMnfKkcOcY_kTE11jM81-fsqtBKjO_KiSkcmAO4wJJb8pHOjue3JCP09ZANL1uN4TuxbM2ibcyf25ODt3WQn54SRQTV0wn098Y5VDU-dzyeKYBNfL14iP0LiXBRfHd4YtEaGV9SBUuVhXdhx1eF0efztCNNz0GSLS2AEPLQduVuFoUImP4s51YdO9TPeeQ3hI8aGpOdC0syxmZ7LsL0rHE1Q",
	E   string `json:"e"`   // "AQAB" or 65537 as an int
	Kid string `json:"kid"` // "1f12fa916c3a0ef585894b4b420ad17dc9d6cdf5",

	// Unused fields:
	// Alg string `json:"alg"` // "RS256",
	// Kty string `json:"kty"` // "RSA",
	// Use string `json:"use"` // "sig",
}

type wellKnown struct {
	JwksURI string `json:"jwks_uri"` // "https://www.googleapis.com/service_accounts/v1/metadata/jwk/signer@confidentialspace-sign.iam.gserviceaccount.com"

	// Unused fields:
	// Iss                                   string `json:"issuer"`                                // "https://confidentialcomputing.googleapis.com"
	// Subject_types_supported               string `json:"subject_types_supported"`               // [ "public" ]
	// Response_types_supported              string `json:"response_types_supported"`              // [ "id_token" ]
	// Claims_supported                      string `json:"claims_supported"`                      // [ "sub", "aud", "exp", "iat", "iss", "jti", "nbf", "dbgstat", "eat_nonce", "google_service_accounts", "hwmodel", "oemid", "secboot", "submods", "swname", "swversion" ]
	// Id_token_signing_alg_values_supported string `json:"id_token_signing_alg_values_supported"` // [ "RS256" ]
	// Scopes_supported                      string `json:"scopes_supported"`                      // [ "openid" ]
}

func getWellKnownFile() (wellKnown, error) {
	httpClient := http.Client{}
	resp, err := httpClient.Get(expectedIssuer + wellKnownPath)
	if err != nil {
		return wellKnown{}, fmt.Errorf("failed to get raw .well-known response: %w", err)
	}

	wellKnownJSON, err := io.ReadAll(resp.Body)
	if err != nil {
		return wellKnown{}, fmt.Errorf("failed to read .well-known response: %w", err)
	}

	wk := wellKnown{}
	json.Unmarshal(wellKnownJSON, &wk)
	return wk, nil
}

func getJWKFile() (jwksFile, error) {
	wk, err := getWellKnownFile()
	if err != nil {
		return jwksFile{}, fmt.Errorf("failed to get .well-known json: %w", err)
	}

	// Get JWK URI from .wellknown
	uri := wk.JwksURI
	fmt.Printf("jwks URI: %v\n", uri)

	httpClient := http.Client{}
	resp, err := httpClient.Get(uri)
	if err != nil {
		return jwksFile{}, fmt.Errorf("failed to get raw JWK response: %w", err)
	}

	jwkbytes, err := io.ReadAll(resp.Body)
	if err != nil {
		return jwksFile{}, fmt.Errorf("failed to read JWK body: %w", err)
	}

	file := jwksFile{}
	err = json.Unmarshal(jwkbytes, &file)
	if err != nil {
		return jwksFile{}, fmt.Errorf("failed to unmarshall JWK content: %w", err)
	}

	return file, nil
}

// N and E are 'base64urlUInt' encoded: https://www.rfc-editor.org/rfc/rfc7518#section-6.3
func base64urlUIntDecode(s string) (*big.Int, error) {
	b, err := base64.RawURLEncoding.DecodeString(s)
	if err != nil {
		return nil, err
	}
	z := new(big.Int)
	z.SetBytes(b)
	return z, nil
}

func getRSAPublicKeyFromJWKsFile(t *jwt.Token) (any, error) {
	keysfile, err := getJWKFile()
	if err != nil {
		return nil, fmt.Errorf("failed to fetch the JWK file: %w", err)
	}

	// Multiple keys are present in this endpoint to allow for key rotation.
	// This method finds the key that was used for signing to pass to the validator.
	kid := t.Header["kid"]
	for _, key := range keysfile.Keys {
		if key.Kid != kid {
			continue // Select the key used for signing
		}

		n, err := base64urlUIntDecode(key.N)
		if err != nil {
			return nil, fmt.Errorf("failed to decode key.N %w", err)
		}
		e, err := base64urlUIntDecode(key.E)
		if err != nil {
			return nil, fmt.Errorf("failed to decode key.E %w", err)
		}

		// The parser expects an rsa.PublicKey: https://github.com/golang-jwt/jwt/blob/main/rsa.go#L53
		// or an array of keys. We chose to show passing a single key in this example as its possible
		// not all validators accept multiple keys for validation.
		return &rsa.PublicKey{
			N: n,
			E: int(e.Int64()),
		}, nil
	}

	return nil, fmt.Errorf("failed to find key with kid '%v' from well-known endpoint", kid)
}

func decodeAndValidateToken(tokenBytes []byte, keyFunc func(t *jwt.Token) (any, error)) (*jwt.Token, error) {
	var err error
	fmt.Println("Unmarshalling token and checking its validity...")
	token, err := jwt.NewParser().Parse(string(tokenBytes), keyFunc)

	fmt.Printf("Token valid: %v\n", token.Valid)
	if token.Valid {
		return token, nil
	}
	if ve, ok := err.(*jwt.ValidationError); ok {
		if ve.Errors&jwt.ValidationErrorMalformed != 0 {
			return nil, fmt.Errorf("token format invalid. Please contact the Confidential Space team for assistance")
		}
		if ve.Errors&(jwt.ValidationErrorNotValidYet) != 0 {
			// If device time is not synchronized with the Attestation Service you may need to account for that here.
			return nil, errors.New("token is not active yet")
		}
		if ve.Errors&(jwt.ValidationErrorExpired) != 0 {
			return nil, fmt.Errorf("token is expired")
		}
		return nil, fmt.Errorf("unknown validation error: %v", err)
	}

	return nil, fmt.Errorf("couldn't handle this token or couldn't read a validation error: %v", err)
}
EOF

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

go mod init google.com/codelab
go mod tidy
go get github.com/golang-jwt/jwt/v4
go build
./codelab

समस्या हल करना: go mod tidy चलाते समय, आपको यह चेतावनी दिख सकती है. इसे अनदेखा किया जा सकता है:

go: finding module for package github.com/golang-jwt/jwt/v4
go: downloading github.com/golang-jwt/jwt v3.2.2+incompatible
go: downloading github.com/golang-jwt/jwt/v4 v4.5.0
go: found github.com/golang-jwt/jwt/v4 in github.com/golang-jwt/jwt/v4 v4.5.0
go: google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible: import path "google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible" should not have @version
go: google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible/cmd/jwt: import path "google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible/cmd/jwt" should not have @version
go: google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible/request: import path "google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible/request" should not have @version
go: google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible/test: import path "google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible/test" should not have @version

6). कोई दूसरा क्लाउड कंसोल टैब या लोकल डेवलपमेंट एनवायरमेंट सेशन शुरू करें और यहां दिया गया निर्देश चलाएं. इससे आपको cgke-attestation-codelab-web-server-internal-ip मिल जाएगा.

gcloud compute instances describe cgke-attestation-codelab-web-server \
    --format='get(networkInterfaces[0].networkIP)' \
    --zone=${ZONE}

7). अपने CGKE वर्कलोड से कनेक्ट करें और रिमोट अटेंशन लॉन्च करें, ताकि अटेंशन टोकन (एक OIDC टोकन) फ़ेच किया जा सके. इसके बाद, attestation-token और cgke-attestation-codelab-web-server-internal-ip के कॉन्टेंट को यहां दिए गए निर्देश में एम्बेड करें. इससे आपको सीक्रेट रिलीज़ वेब सर्वर का सीक्रेट मिल जाएगा!

kubectl exec -it go-tpm-demo -- /bin/bash
./gotpm token --event-log=/run/cc-device-plugin/binary_bios_measurements > attestation_token
curl http://<cgke-attestation-codelab-web-server-internal-ip>:8080 -H "Authorization: Bearer $(cat ./attestation_token)"

इनकी जगह ये डालें:

cgke-attestation-codelab-web-server-internal-ip, cgke-attestation-codelab-web-server VM इंस्टेंस का इंटरनल आईपी है.

7. CGKE नोड पर vTPM सीलिंग

इस चरण में, CGKE नोड पर vTPM के मालिक की अनुमति सेट अप की जाती है. साथ ही, vTPM के मालिक के पासफ़्रेज़ के साथ वर्कलोड डिप्लॉय किया जाता है. इसके बाद, vTPM की सीलिंग की सुविधा का इस्तेमाल करके, वर्कलोड में डेटा को सील और अनसील करने के लिए, vTPM प्राइमरी कुंजी बनाई जाती है.

1). CGKE नोड पर वीटीपीएम के मालिक की पुष्टि करने की सुविधा सेट अप करें.

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

cat << 'EOF' > Dockerfile
FROM debian:latest

RUN echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections
RUN apt-get update

RUN apt -y install \
  autoconf-archive \
  libcmocka0 \
  libcmocka-dev \
  net-tools \
  build-essential \
  git \
  pkg-config \
  gcc \
  g++ \
  m4 \
  libtool \
  automake \
  libgcrypt20-dev \
  libssl-dev \
  uthash-dev \
  autoconf \
  uuid-dev \
  libcurl4-openssl-dev \
  libjson-c-dev

RUN mkdir /src

WORKDIR /src
RUN git clone https://github.com/tpm2-software/tpm2-tss
WORKDIR /src/tpm2-tss
RUN ./bootstrap
RUN ./configure --prefix=/usr/local
RUN make all install

WORKDIR /src
RUN git clone https://github.com/tpm2-software/tpm2-tools
WORKDIR /src/tpm2-tools
RUN apt-get -y install libcurl4 libcurl4-openssl-dev pandoc man-db
RUN ./bootstrap
RUN ./configure --prefix=/usr/local
RUN make all install

RUN apt-get -y install vim

ENTRYPOINT ["/bin/bash"]
EOF

एक बार चलने वाले जॉब कंटेनर की इमेज बनाएं और उसे Artifact Registry में पुश करें.

docker build -t us-docker.pkg.dev/${PROJECT_ID}/codelab-repo/tpm-tools:latest .
docker push us-docker.pkg.dev/${PROJECT_ID}/codelab-repo/tpm-tools:latest

Kubernetes जॉब के ज़रिए, एक बार होने वाली जॉब को पूरा करें. (चेतावनी: यह टास्क हर CVM पर vTPM को मिटा देता है. अगर आपका CVM डिस्क को एन्क्रिप्ट (सुरक्षित) करने के लिए vTPM का इस्तेमाल करता है, तो रीबूट करने के बाद यह टास्क आपके CVM को इस्तेमाल करने लायक नहीं छोड़ेगा. यह देखा जा सकता है कि आपकी डिस्क में FSTYPE crypto_LUKS है या नहीं (lsblk -f कमांड का इस्तेमाल करके)

cat << EOF > tpm-tools-task.yaml
apiVersion: batch/v1
kind: Job
metadata:
  name: tpm-tools-task
spec:
  template:
    spec:
      nodeSelector:
        cloud.google.com/machine-family: "n2d"
        cloud.google.com/gke-confidential-nodes-instance-type: "SEV"
      containers:
      - name: tpm-tools
        image: us-docker.pkg.dev/${PROJECT_ID}/codelab-repo/tpm-tools:latest
        command: ["/bin/sh", "-c"]
        args: ["tpm2_clear; tpm2_changeauth -c owner this_is_passphrase"]
        resources:
          limits:
            google.com/cc: 1
      restartPolicy: Never
EOF

अहम जानकारी: अगर आपको tpm-tools-task जॉब को फिर से चलाना है, तो पहले मौजूदा जॉब को मिटाएं:

kubectl delete job tpm-tools-task

एक बार होने वाले काम को लॉन्च करें. यह जॉब, सभी वर्कर नोड पर vTPM के मालिक का पासफ़्रेज़ सेट करती है.

kubectl apply -f tpm-tools-task.yaml

2). vTPM के मालिक का लंबा पासवर्ड सेव करने के लिए, Kubernetes सीक्रेट बनाएं.

kubectl create secret generic tpm-secret --from-literal=passphrase='this_is_passphrase'

3). एक डेमो ऐप्लिकेशन कंटेनर बनाएं और उसमें लंबा पासवर्ड डालें. डेमो ऐप्लिकेशन कंटेनर में, vTPM के साथ इंटरैक्ट करने के लिए tpm2-tools शामिल होता है.

डेमो ऐप्लिकेशन कंटेनर के लिए, डिप्लॉयमेंट की YAML फ़ाइल बनाएं.

cat << EOF > deploy_demo.yaml
apiVersion: v1
kind: Pod
metadata:
  name: tpm-tools-demo
  labels:
    app.kubernetes.io/name: tpm-tools-demo
spec:
  nodeSelector:
    cloud.google.com/machine-family: "n2d" 
    cloud.google.com/gke-confidential-nodes-instance-type: "SEV"
  containers:
  - name: tpm-tools
    image: us-docker.pkg.dev/${PROJECT_ID}/codelab-repo/tpm-tools:latest
    command: ["tail", "-f", "/dev/null"]
    resources:
      limits:
        google.com/cc: 1
    volumeMounts:
      - name: secret-volume
        mountPath: "/etc/tpmsecret"
        readOnly: true
  volumes:
    - name: secret-volume
      secret:
        secretName: tpm-secret
EOF

डेमो ऐप्लिकेशन डिप्लॉय करें.

kubectl apply -f deploy_demo.yaml

4). डेमो ऐप्लिकेशन कंटेनर में vTPM सीलिंग की सुविधा का इस्तेमाल करें.

डेमो ऐप्लिकेशन कंटेनर से कनेक्ट करें और पासफ़्रेज़ के साथ प्राइमरी कुंजी सेट करें.

kubectl exec -it tpm-tools-demo -- /bin/bash
tpm2_createprimary -C o -c primary.ctx -P $(cat /etc/tpmsecret/passphrase)

tpm2_createprimary, vTPM के साथ इंटरैक्ट करता है, ताकि तय की गई हैरारकी और टेंप्लेट के आधार पर प्राइमरी ऑब्जेक्ट जनरेट किया जा सके.

-C o: इससे पता चलता है कि प्राइमरी कुंजी, टीपीएम के मालिक के संगठन के तहत बनाई जाएगी.
-c primary.ctx: इससे बनाए गए मुख्य ऑब्जेक्ट के कॉन्टेक्स्ट (हैंडल और उससे जुड़ा डेटा) को primary.ctx फ़ाइल में सेव किया जाता है. बाद की कार्रवाइयों के लिए, यह कॉन्टेक्स्ट ज़रूरी है.

वर्कलोड, मुख्य कुंजी बनाने के लिए मालिक के गलत पासफ़्रेज़ का इस्तेमाल नहीं कर सकता.

tpm2_createprimary -C o -P wrong_passphrase

इस कमांड से ये गड़बड़ियां दिखती हैं:

WARNING:esys:src/tss2-esys/api/Esys_CreatePrimary.c:401:Esys_CreatePrimary_Finish() Received TPM Error
ERROR:esys:src/tss2-esys/api/Esys_CreatePrimary.c:135:Esys_CreatePrimary() Esys Finish ErrorCode (0x000009a2)
ERROR: Esys_CreatePrimary(0x9A2) - tpm:session(1):authorization failure without DA implications
ERROR: Unable to run tpm2_createprimary

इसके बाद, बनाई गई प्राइमरी कुंजी का इस्तेमाल डेटा को सील और अनसील करने के लिए किया जा सकता है.

echo "This is my secret message" > secret.txt
tpm2_create -C primary.ctx -u sealed.pub -r sealed.priv -i secret.txt
tpm2_load -C primary.ctx -u sealed.pub -r sealed.priv -c sealed.ctx
tpm2_unseal -c sealed.ctx -o unsealed.txt
cat unsealed.txt

tpm2_create, क्रिप्टोग्राफ़िक ऑब्जेक्ट जनरेट करने के लिए vTPM के साथ इंटरैक्ट करता है.

-C primary.ctx: यह उस प्राइमरी कुंजी के कॉन्टेक्स्ट का इस्तेमाल करता है जिसे हमने पहले बनाया था.
-u sealed.pub: सीलिंग कुंजी के सार्वजनिक हिस्से को sealed.pub में सेव करता है. इसकी ज़रूरत अनसीलिंग के लिए होती है.
-r sealed.priv: सीलिंग की के निजी हिस्से को sealed.priv में सेव करता है.
-i secret.txt: वह फ़ाइल जिसमें सील किया जाने वाला सीक्रेट मौजूद है.

tpm2_load: यह फ़ंक्शन, सार्वजनिक और निजी हिस्सों (sealed.pub, sealed.priv) का इस्तेमाल करके, सीलिंग कुंजी को टीपीएम में लोड करता है. साथ ही, इसके कॉन्टेक्स्ट को sealed.ctx में सेव करता है.

tpm2_unseal: इस फ़ंक्शन का इस्तेमाल करके, उस डेटा को डिक्रिप्ट (अनसील) किया जाता है जिसे पहले vTPM सीलिंग ऑब्जेक्ट का इस्तेमाल करके एन्क्रिप्ट (सील) किया गया था.

cat unsealed.txt: इससे सील किए गए सीक्रेट मैसेज को अनसील किया जाता है, ताकि यह पुष्टि की जा सके कि प्रोसेस पूरी हो गई है.

ध्यान दें कि primary.ctx और sealed.priv फ़ाइलों का इस्तेमाल सिर्फ़ एक vTPM डिवाइस पर किया जा सकता है. साथ ही, जिन लोगों के पास vTPM डिवाइस और इन फ़ाइलों का ऐक्सेस है वे सील किए गए डेटा को ऐक्सेस कर सकते हैं. डेटा को सील करने के लिए, पीसीआर वैल्यू पर नीति का इस्तेमाल किया जा सकता है. हालांकि, यह इस कोडलैब के दायरे से बाहर है.

8. हार्डवेयर की पुष्टि करने के लिए वर्कलोड डिप्लॉय करना: Intel TDX और AMD SEV-SNP

इस चरण में, Intel TDX या AMD SEV-SNP पर आधारित वर्कलोड बनाया जाता है. साथ ही, कॉन्फ़िडेंशियल GKE नोड पर हार्डवेयर-लेवल की पुष्टि की जाती है. ऊपर दिए गए आर्किटेक्चर डायग्राम में दिखाया गया है कि हम Intel TDX और AMD SEV-SNP आर्किटेक्चर के लिए, अटेस्टेशन कोटेशन पाने के लिए गेस्ट डिवाइस प्लगिन का इस्तेमाल करेंगे. कमांड चलाने के लिए, क्लाउड कंसोल या अपने लोकल डेवलपमेंट एनवायरमेंट पर जाएं.

आपको जिस कॉन्फ़िडेंशियल कंप्यूटिंग आर्किटेक्चर - Intel TDX या AMD SEV-SNP - की जांच करनी है उसे चुनें.

1). Intel TDX नोड पूल जोड़ना

gcloud container node-pools create tdx-pool \
    --cluster=${CLUSTER_NAME} \
    --zone=${ZONE} \
    --machine-type=c3-standard-4 \
    --num-nodes=1 \
    --enable-confidential-nodes \
    --confidential-node-type=tdx

2). AMD SEV-SNP नोड पूल जोड़ना

gcloud container node-pools create snp-pool \
    --cluster=${CLUSTER_NAME} \
    --zone=${ZONE} \
    --machine-type=n2d-standard-2 \
    --num-nodes=1 \
    --enable-confidential-nodes \
    --confidential-node-type=sev_snp \
    --min-cpu-platform="AMD Milan"

3). डिफ़ॉल्ट नोड पूल मिटाएं (ज़रूरी नहीं, लेकिन लागत/शोर को कम करने के लिए सुझाव दिया जाता है)

gcloud container node-pools delete default-pool \
    --cluster=${CLUSTER_NAME} \
    --zone=${ZONE} \
    --quiet

(ध्यान दें: अगर आपने पहले ही vTPM सेक्शन पूरा कर लिया है, तो यह पूल पहले ही मिटा दिया गया है. साथ ही, यहां "नहीं मिला" गड़बड़ियों को अनदेखा किया जा सकता है.)

4). डिवाइस प्लगिन शुरू करें, ताकि CGKE क्लस्टर, हार्डवेयर की पुष्टि करने वाले मेहमान डिवाइसों को वर्कलोड के लिए उपलब्ध करा सके. हम नए संसाधन (intel.com/tdx और amd.com/sev-snp) बनाने के लिए, Kubernetes डिवाइस प्लगिन का इस्तेमाल करते हैं. इन संसाधनों से जुड़ा कोई भी वर्कलोड, वर्कर नोड पर मौजूद गेस्ट डिवाइसों को ऐक्सेस कर पाएगा.

gcloud container clusters get-credentials ${CLUSTER_NAME} --zone ${ZONE} --project ${PROJECT_ID}

kubectl apply -f https://raw.githubusercontent.com/google/cc-device-plugin/main/manifests/cc-device-plugin.yaml

नीचे दी गई कमांड की मदद से, डिप्लॉय किए गए cc-device-plugin को देखा जा सकता है.

kubectl get pods -A | grep "cc-device-plugin"

ध्यान दें: अगर GKE क्लस्टर में Confidential और non-Confidential GKE वर्कर नोड, दोनों मौजूद हैं, तो हमारा सुझाव है कि ऑपरेटर सिर्फ़ Confidential GKE वर्कर नोड पर cc-device-plugin को डिप्लॉय करे.

9. हार्डवेयर की पुष्टि: Intel TDX और AMD SEV-SNP

इस सेक्शन में, आपको गेस्ट डिवाइस प्लगिन का इस्तेमाल करके, Intel TDX और AMD SEV-SNP आर्किटेक्चर के लिए अटेस्टेशन कोटेशन फ़ेच करके, गोपनीय GKE नोड में हार्डवेयर-लेवल का अटेस्टेशन करने का तरीका बताया जाएगा.

1). गेस्ट डिवाइस से हार्डवेयर अटेस्टेशन कोट पाने के लिए, Go ऐप्लिकेशन बनाएं.

cat << 'EOF' > main.go
package main

import (
	"crypto/rand"
	"log"
	"os"
	"strconv"
	"time"
	"unsafe"

	sevclient "github.com/google/go-sev-guest/client"
	"golang.org/x/sys/unix"
)

// TDX Linux ABI Definitions
const (
	iocTdxGetReport = 0xc4405401
)

type tdxReportReq struct {
	ReportData [64]byte
	TdReport   [1024]byte
}

func main() {
	ccType := os.Getenv("CC_TYPE") // Expected "tdx" or "snp"

	iterationsStr := os.Getenv("ITERATIONS")
	iterations := 100
	if val, err := strconv.Atoi(iterationsStr); err == nil && val > 0 {
		iterations = val
	}

	successCount := 0
	failureCount := 0
	startTime := time.Now()
	
	log.Printf("Starting Attestation test for CC_TYPE: %s (iterations: %d)", ccType, iterations)

	if ccType == "tdx" {
		devicePath := "/dev/tdx_guest"
		file, err := os.OpenFile(devicePath, os.O_RDWR|os.O_SYNC, 0)
		if err != nil {
			log.Fatalf("FATAL: Failed to open %s: %v", devicePath, err)
		}
		defer file.Close()

		for i := 1; i <= iterations; i++ {
			var reportData [64]byte
			rand.Read(reportData[:])
			req := tdxReportReq{ReportData: reportData}
			
			_, _, errno := unix.Syscall(unix.SYS_IOCTL, file.Fd(), uintptr(iocTdxGetReport), uintptr(unsafe.Pointer(&req)))
			if errno != 0 || (req.TdReport[0] == 0 && req.TdReport[10] == 0) {
				failureCount++
			} else {
				successCount++
			}
		}
	} else if ccType == "snp" {
		device, err := sevclient.OpenDevice()
		if err != nil {
			log.Fatalf("FATAL: Failed to open SEV-SNP device: %v", err)
		}
		defer device.Close()

		for i := 1; i <= iterations; i++ {
			var reportData [64]byte
			rand.Read(reportData[:])
			report, err := sevclient.GetRawReport(device, reportData)
			if err != nil || len(report) == 0 {
				failureCount++
			} else {
				successCount++
			}
		}
	}

	elapsed := time.Since(startTime)
	log.Printf("=== Test Completed ===")
	log.Printf("Total Iterations: %d", iterations)
	log.Printf("Success: %d, Failures: %d", successCount, failureCount)
	log.Printf("Total Time: %s", elapsed)
}
EOF

2). हार्डवेयर की पुष्टि करने वाले टेस्ट टूल के लिए, Dockerfile बनाएं:

cat << 'EOF' > Dockerfile
FROM golang:1.26.4 AS builder
WORKDIR /app
COPY main.go .
RUN go mod init cc-attestation
RUN go mod tidy
RUN CGO_ENABLED=0 GOOS=linux go build -o /cc-attestation-check main.go

FROM ubuntu:22.04
COPY --from=builder /cc-attestation-check /usr/local/bin/
CMD ["/usr/local/bin/cc-attestation-check"]
EOF

3). इमेज को बनाएं और उसे Artifact Registry में पुश करें:

docker build -t us-docker.pkg.dev/${PROJECT_ID}/codelab-repo/cc-attestation-check:latest .
docker push us-docker.pkg.dev/${PROJECT_ID}/codelab-repo/cc-attestation-check:latest

4). हार्डवेयर डिवाइसों को दिखाने के लिए, Intel TDX और AMD SEV-SNP, दोनों वर्कलोड के लिए ऐप्लिकेशन डिप्लॉयमेंट YAML बनाएं.

Intel TDX वर्कलोड के लिए, यह डिप्लॉयमेंट YAML बनाएं:

cat << EOF > deploy-tdx.yaml
apiVersion: v1
kind: Pod
metadata:
  name: tdx-attestation-pod
spec:
  restartPolicy: Never
  containers:
  - name: tdx-container
    image: us-docker.pkg.dev/${PROJECT_ID}/codelab-repo/cc-attestation-check:latest
    env:
    - name: CC_TYPE
      value: "tdx"
    - name: ITERATIONS
      value: "1000"
    resources:
      limits:
        intel.com/tdx: 1
  nodeSelector:
    cloud.google.com/gke-confidential-nodes-instance-type: "TDX"
    cloud.google.com/machine-family: "c3"
EOF

AMD SEV-SNP वर्कलोड के लिए, यह डिप्लॉयमेंट YAML बनाएं:

cat << EOF > deploy-snp.yaml
apiVersion: v1
kind: Pod
metadata:
  name: snp-attestation-pod
spec:
  restartPolicy: Never
  containers:
  - name: snp-container
    image: us-docker.pkg.dev/${PROJECT_ID}/codelab-repo/cc-attestation-check:latest
    env:
    - name: CC_TYPE
      value: "snp"
    - name: ITERATIONS
      value: "100"
    resources:
      limits:
        amd.com/sev-snp: 1
  nodeSelector:
    cloud.google.com/gke-confidential-nodes-instance-type: "SEV_SNP"
    cloud.google.com/machine-family: "n2d"
EOF

5). डप्लॉयमेंट को CGKE क्लस्टर पर लागू करें.

kubectl apply -f deploy-tdx.yaml
kubectl apply -f deploy-snp.yaml

6). पॉड के पूरा होने का इंतज़ार करें और हार्डवेयर की पुष्टि करने वाले लॉग की पुष्टि करें.

सबसे पहले, अपने पॉड की स्थिति देखें. इससे यह पक्का किया जा सकेगा कि वे शेड्यूल हो गए हैं और चल रहे हैं. जब तक उनकी स्थिति 'पूरा हो गया' या 'चल रहा है' न दिखे, तब तक इंतज़ार करें:

kubectl get pods -w

पॉड तैयार होने के बाद, लॉग देखें. इससे यह पुष्टि की जा सकेगी कि हार्डवेयर अटेंशन कोटेशन सही तरीके से फ़ेच किए गए हैं या नहीं:

# View the TDX attestation logs
kubectl logs tdx-attestation-pod

# View the SEV-SNP attestation logs
kubectl logs snp-attestation-pod

(आपको कुल एक्ज़ीक्यूशन टाइम, कुल इटरेशन, और लॉग किए गए सफल/असफल काउंट दिखेंगे.)

10. साफ़-सफ़ाई सेवा

अपने Google Cloud खाते से लगातार शुल्क लिए जाने से बचने के लिए, इस कोडलैब में बनाई गई संसाधनों को मिटाना ज़रूरी है.

Cloud Shell या अपने लोकल डेवलपमेंट एनवायरमेंट में, यहां दी गई कमांड चलाएं.

1). एनवायरमेंट वैरिएबल सेट करें:

export PROJECT_ID="your-project-id"
export ZONE="us-central1-c"
export CLUSTER_NAME="cgke-attestation-codelab"

gcloud config set project ${PROJECT_ID}

2). GKE संसाधन मिटाना

gcloud container clusters delete ${CLUSTER_NAME} \
    --zone=${ZONE} \
    --quiet

3). Artifact Registry को मिटाना

gcloud artifacts repositories delete codelab-repo \
    --location=us \
    --quiet

4). वेब सर्वर वीएम मिटाना

gcloud compute instances delete cgke-attestation-codelab-web-server \
    --zone=${ZONE}

5). IAM संसाधन मिटाना

# Delete the GCP service account
gcloud iam service-accounts delete codelab-csa@${PROJECT_ID}.iam.gserviceaccount.com \
    --quiet

# Delete the custom IAM role
gcloud iam roles delete Confidential_Computing_Workload_User \
    --project=${PROJECT_ID} \
    --quiet

11. आगे क्या करना है

Confidential GKE Node के बारे में ज़्यादा जानें.