मल्टी-पार्टी कंप्यूटेशन और गोपनीय स्पेस की मदद से, डिजिटल ऐसेट का लेन-देन करने का तरीका

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

शुरू करने से पहले, हालांकि यह ज़रूरी नहीं है, लेकिन इन सुविधाओं और कॉन्सेप्ट के बारे में जानकारी होने से, इस कोडलैब में मदद मिलेगी.

• Cloud Storage, खास तौर पर बकेट
• Compute Engine, खास तौर पर Confidential VM
• सेवा खाते
• कंटेनर और रिमोट रिपॉज़िटरी
• वर्कलोड आइडेंटिटी फ़ेडरेशन और एट्रिब्यूट की शर्तें

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

यह लैब, Confidential Space का इस्तेमाल करके, एमपीसी के मुताबिक ब्लॉकचेन पर हस्ताक्षर करने के लिए, रेफ़रंस लागू करने की सुविधा देती है. इन कॉन्सेप्ट को समझने के लिए, हम एक ऐसे उदाहरण पर नज़र डालेंगे जिसमें Primus कंपनी को अपनी डिजिटल ऐसेट, Secundus कंपनी को ट्रांसफ़र करनी हैं. इस उदाहरण में, कंपनी प्राइमस, एमपीएस के मुताबिक काम करने वाले मॉडल का इस्तेमाल करती है. इसका मतलब है कि अलग-अलग निजी पासकोड का इस्तेमाल करने के बजाय, वे डिस्ट्रिब्यूट किए गए पासकोड शेयर का इस्तेमाल करते हैं. इन मुख्य शेयर को कई पार्टियां मैनेज करती हैं. इस मामले में, मयंक और ऋतिक. इस तरीके से, Company Primus को कई फ़ायदे मिलते हैं. जैसे, उपयोगकर्ता अनुभव को बेहतर बनाना, ऑपरेशनल दक्षता बढ़ाना, और अपनी निजी कुंजियों पर कंट्रोल रखना.

इस प्रोसेस के बुनियादी पहलुओं के बारे में बताने के लिए, हम तकनीकी सेटअप के बारे में विस्तार से बताएंगे. साथ ही, हम आपको मंज़ूरी पाने और हस्ताक्षर करने की उस प्रोसेस के बारे में बताएंगे जिससे डिजिटल ऐसेट को कंपनी Primus से कंपनी Secundus में ट्रांसफ़र किया जा सकता है. कृपया ध्यान दें कि इस लेन-देन को मयंक और ऋतिक, दोनों को मंज़ूरी देनी होगी. ये दोनों, Primus कंपनी के कर्मचारी हैं.

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

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

1. भेजने वाला व्यक्ति, लेन-देन का एक ऑब्जेक्ट बनाता है. इसमें, पाने वाले का पता, भेजने के लिए ईटीएच की रकम, और अन्य ज़रूरी डेटा शामिल होता है.
2. भेजने वाले की निजी कुंजी का इस्तेमाल, लेन-देन के डेटा को हैश करने के लिए किया जाता है.
3. इसके बाद, हैश पर निजी पासकोड से हस्ताक्षर किया जाता है.
4. हस्ताक्षर को लेन-देन ऑब्जेक्ट से अटैच किया जाता है.
5. लेन-देन को Ethereum नेटवर्क पर ब्रॉडकास्ट किया जाता है.

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

शुरू करने के लिए, आपको ज़रूरी क्लाउड संसाधन कॉन्फ़िगर करने होंगे. इसके बाद, गोपनीय स्पेस में वर्कलोड चलाया जाएगा. इस कोडलैब में, आपको इन चरणों के बारे में जानकारी मिलेगी:

• कॉन्फ़िडेंशियल स्पेस को चलाने के लिए, ज़रूरी क्लाउड संसाधनों को कॉन्फ़िगर करने का तरीका
• इनके एट्रिब्यूट के आधार पर, सुरक्षित संसाधनों का ऐक्सेस देने का तरीका:
• क्या: वर्कलोड कंटेनर
• कहां: Confidential Space एनवायरमेंट (Confidential VM पर Confidential Space की इमेज)
• किसने: वह खाता जो वर्कलोड चला रहा है
• Confidential Space की वीएम इमेज चलाने वाले Confidential VM में वर्कलोड को कैसे चलाया जाता है

ज़रूरी एपीआई

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

एपीआई का नाम	एपीआई का टाइटल
cloudkms.googleapis.com	क्लाउड केएमएस (KMS)
compute.googleapis.com	Compute Engine
confidentialcomputing.googleapis.com	Confidential Computing
iamcredentials.googleapis.com	IAM
artifactregistry.googleapis.com	Artifact Registry

2. क्लाउड संसाधन सेट अप करना

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

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

git clone https://github.com/GoogleCloudPlatform/confidential-space.git

• इस कोडलैब के लिए डायरेक्ट्री बदलें.

cd confidential-space/codelabs/digital_asset_transaction_codelab/scripts

• पक्का करें कि आपने नीचे दिए गए ज़रूरी प्रोजेक्ट एनवायरमेंट वैरिएबल सेट किए हों. GCP प्रोजेक्ट सेट अप करने के बारे में ज़्यादा जानने के लिए, कृपया यह कोडलैब देखें. प्रोजेक्ट आईडी को वापस पाने का तरीका जानने के लिए, यह लेख पढ़ें. साथ ही, यह भी जानें कि प्रोजेक्ट आईडी, प्रोजेक्ट के नाम और प्रोजेक्ट नंबर से कैसे अलग होता है. .

export PRIMUS_PROJECT_ID=<GCP project id>

• अपने प्रोजेक्ट के लिए, बिलिंग की सुविधा चालू करें.
• दोनों प्रोजेक्ट के लिए, Confidential Computing API और यहां दिए गए एपीआई चालू करें.

gcloud services enable \
   cloudapis.googleapis.com \
    cloudkms.googleapis.com \
    cloudresourcemanager.googleapis.com \
    cloudshell.googleapis.com \
    container.googleapis.com \
    containerregistry.googleapis.com \
    iam.googleapis.com \
    confidentialcomputing.googleapis.com

• संसाधन के नामों के लिए वैरिएबल सेट करने के लिए, इस निर्देश का इस्तेमाल किया जा सकता है. ध्यान दें कि इससे कंपनी A के लिए, आपके GCP प्रोजेक्ट के संसाधन के नाम बदल जाएंगे. उदाहरण के लिए, export PRIMUS_INPUT_STORAGE_BUCKET='primus-input-bucket'
• कंपनी A के GCP प्रोजेक्ट के लिए, ये वैरिएबल सेट किए जा सकते हैं:

$PRIMUS_INPUT_STORAGE_BUCKET	वह बकेट जिसमें एन्क्रिप्ट की गई कुंजियां सेव की जाती हैं.
$PRIMUS_RESULT_STORAGE_BUCKET	यह बकेट, MPC लेन-देन के नतीजे को सेव करती है.
$PRIMUS_KEY	इस KMS कुंजी का इस्तेमाल, Primus Bank के लिए $PRIMUS_INPUT_STORAGE_BUCKET में सेव किए गए डेटा को एन्क्रिप्ट यानी सुरक्षित करने के लिए किया जाता है.
$PRIMUS_KEYRING	केएमएस की वह की-रिंग जिसका इस्तेमाल, Primus Bank के लिए एन्क्रिप्शन की $PRIMUS_KEY बनाने के लिए किया जाएगा.
$PRIMUS_WIP_PROVIDER	Workload Identity Pool Provider, जिसमें एट्रिब्यूट की शर्त शामिल होती है. इसका इस्तेमाल, MPC वर्कलोड सेवा से साइन किए गए टोकन के लिए किया जाता है.
$PRIMUS_SERVICEACCOUNT	यह सेवा खाता, सुरक्षित किए गए संसाधनों को ऐक्सेस करने के लिए $PRIMUS_WORKLOAD_IDENTITY_POOL का इस्तेमाल करता है. इस सेवा खाते के पास, $PRIMUS_INPUT_STORAGE_BUCKET बकेट में सेव की गई एन्क्रिप्ट (सुरक्षित) की गई कुंजियों को देखने की अनुमति होगी.
$PRIMUS_ARTIFACT_REPOSITORY	वर्कलोड कंटेनर इमेज को सेव करने के लिए, आर्टफ़ैक्ट रिपॉज़िटरी.
$WORKLOAD_SERVICEACCOUNT	वह सेवा खाता जिसके पास, वर्कलोड चलाने वाले Confidential VM को ऐक्सेस करने की अनुमति है.
$WORKLOAD_CONTAINER	Docker कंटेनर, जो वर्कलोड को चलाता है.
$WORKLOAD_IMAGE_NAME	वर्कलोड कंटेनर इमेज का नाम.
$WORKLOAD_IMAGE_TAG	वर्कलोड कंटेनर इमेज का टैग.

• संसाधन के नामों के लिए, अपने प्रोजेक्ट आईडी के आधार पर बाकी बचे वैरिएबल नामों को वैल्यू पर सेट करने के लिए, यहां दी गई स्क्रिप्ट चलाएं.

source config_env.sh

क्लाउड संसाधन सेट अप करना

इस चरण के तहत, आपको मल्टी-पार्टी कंप्यूटेशन के लिए ज़रूरी क्लाउड संसाधन सेट अप करने होंगे. इस लैब के लिए, आपको इस निजी पासकोड का इस्तेमाल करना होगा: 0000000000000000000000000000000000000000000000000000000000000001

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

ज़रूरी क्लाउड संसाधन सेट अप करने के लिए, यह स्क्रिप्ट चलाएं. इन चरणों के तहत, यहां दिए गए संसाधन बनाए जाएंगे:

• एन्क्रिप्ट किए गए निजी कुंजी के शेयर सेव करने के लिए, Cloud Storage बकेट ($PRIMUS_INPUT_STORAGE_BUCKET).
• डिजिटल ऐसेट के लेन-देन के नतीजे को सेव करने के लिए, Cloud Storage बकेट ($PRIMUS_RESULT_STORAGE_BUCKET).
• निजी पासकोड शेयर को एन्क्रिप्ट करने के लिए, केएमएस में एन्क्रिप्शन कुंजी ($PRIMUS_KEY) और कीरिंग ($PRIMUS_KEYRING).
• Workload Identity Pool ($PRIMUS_WORKLOAD_IDENTITY_POOL), जो अपने प्रोवाइडर के तहत कॉन्फ़िगर की गई एट्रिब्यूट की शर्तों के आधार पर दावों की पुष्टि करता है.
• ऊपर बताए गए वर्कलोड आइडेंटिटी पूल ($PRIMUS_WORKLOAD_IDENTITY_POOL) से जुड़ा एक सेवा खाता ($PRIMUS_SERVICEACCOUNT), जिसमें IAM का यह ऐक्सेस हो:
• roles/cloudkms.cryptoKeyDecrypter का इस्तेमाल करके, केएमएस की मदद से डेटा को डिक्रिप्ट किया जा सकता है.
• objectViewer Cloud Storage बकेट से डेटा पढ़ने के लिए.
• roles/iam.workloadIdentityUser का इस्तेमाल करके, इस सेवा खाते को Workload Identity Pool से कनेक्ट करें.

./setup_resources.sh

3. वर्कलोड बनाना

वर्कलोड सेवा खाता बनाना

अब आपको वर्कलोड के लिए, ज़रूरी भूमिकाओं और अनुमतियों के साथ एक सेवा खाता बनाना होगा. इसके लिए, यह स्क्रिप्ट चलाएं. इससे कंपनी A के लिए वर्कलोड सेवा खाता बन जाएगा. इस सेवा खाते का इस्तेमाल, वर्कलोड चलाने वाले वीएम के लिए किया जाएगा.

वर्कलोड सेवा खाते ($WORKLOAD_SERVICEACCOUNT) के पास ये भूमिकाएं होंगी:

• confidentialcomputing.workloadUser का इस्तेमाल करके, पुष्टि करने वाला टोकन पाएं
• Cloud Logging में लॉग लिखने के लिए logging.logWriter.
• objectViewer Cloud Storage बकेट से डेटा पढ़ने के लिए.$PRIMUS_INPUT_STORAGE_BUCKET
• objectUser Cloud Storage बकेट में वर्कलोड का नतीजा लिखने के लिए $PRIMUS_RESULT_STORAGE_BUCKET.

./create_workload_service_account.sh

वर्कलोड बनाना

इस चरण में, वर्कलोड की Docker इमेज बनाई जाती है. इस कोडलैब में, वर्कलोड एक सामान्य Node.js MPC ऐप्लिकेशन है. यह एन्क्रिप्ट (सुरक्षित) किए गए निजी पासकोड शेयर का इस्तेमाल करके, ऐसेट ट्रांसफ़र करने के लिए डिजिटल लेन-देन पर हस्ताक्षर करता है. वर्कलोड प्रोजेक्ट का कोड यहां दिया गया है. वर्कलोड प्रोजेक्ट में ये फ़ाइलें शामिल होती हैं.

package.json: इस फ़ाइल में उन पैकेज की सूची होती है जिनका इस्तेमाल, वर्कलोड MPC ऐप्लिकेशन के लिए किया जाना चाहिए. इस मामले में, हम @google-cloud/kms, @google-cloud/storage, ethers, और fast-crc32c लाइब्रेरी का इस्तेमाल कर रहे हैं. यहां package.json फ़ाइल दी गई है. इसका इस्तेमाल हम इस कोडलैब के लिए करेंगे.

index.js: यह वर्कलोड ऐप्लिकेशन का एंट्रीपॉइंट है. इससे यह तय होता है कि वर्कलोड कंटेनर के शुरू होने पर कौनसी कमांड चलनी चाहिए. हमने बिना हस्ताक्षर वाला एक ऐसा लेन-देन भी शामिल किया है जिसे आम तौर पर, गैर-भरोसेमंद ऐप्लिकेशन उपलब्ध कराता है. यह ऐप्लिकेशन, उपयोगकर्ताओं से उनके हस्ताक्षर मांगता है. यह index.js फ़ाइल, mpc.js से फ़ंक्शन भी इंपोर्ट करती है. इसे हम अगले चरण में बनाएंगे. यहां index.js फ़ाइल का कॉन्टेंट दिया गया है. इसे यहां भी देखा जा सकता है.

import {signTransaction, submitTransaction, uploadFromMemory} from './mpc.js';

const signAndSubmitTransaction = async () => {
  try {
    // Create the unsigned transaction object
    const unsignedTransaction = {
      nonce: 0,
      gasLimit: 21000,
      gasPrice: '0x09184e72a000',
      to: '0x0000000000000000000000000000000000000000',
      value: '0x00',
      data: '0x',
    };

    // Sign the transaction
    const signedTransaction = await signTransaction(unsignedTransaction);

    // Submit the transaction to Ganache
    const transaction = await submitTransaction(signedTransaction);

    // Write the transaction receipt
    uploadFromMemory(transaction);

    return transaction;
  } catch (e) {
    console.log(e);
    uploadFromMemory(e);
  }
};

await signAndSubmitTransaction();

mpc.js: इस फ़ाइल में लेन-देन पर हस्ताक्षर किए जाते हैं. यह kms-decrypt और credential-config से फ़ंक्शन इंपोर्ट करता है. इनके बारे में हम अगले सेक्शन में जानेंगे. mpc.js फ़ाइल का कॉन्टेंट यहां दिया गया है. इसे यहां भी देखा जा सकता है.

import {Storage} from '@google-cloud/storage';
import {ethers} from 'ethers';

import {credentialConfig} from './credential-config.js';
import {decryptSymmetric} from './kms-decrypt.js';

const providers = ethers.providers;
const Wallet = ethers.Wallet;

// The ID of the GCS bucket holding the encrypted keys
const bucketName = process.env.KEY_BUCKET;

// Name of the encrypted key files.
const encryptedKeyFile1 = 'alice_encrypted_key_share';
const encryptedKeyFile2 = 'bob_encrypted_key_share';

// Create a new storage client with the credentials
const storageWithCreds = new Storage({
  credentials: credentialConfig,
});

// Create a new storage client without the credentials
const storage = new Storage();

const downloadIntoMemory = async (keyFile) => {
  // Downloads the file into a buffer in memory.
  const contents =
      await storageWithCreds.bucket(bucketName).file(keyFile).download();

  return contents;
};

const provider =
    new providers.JsonRpcProvider(`http://${process.env.NODE_URL}:80`);

export const signTransaction = async (unsignedTransaction) => {
  /* Check if Alice and Bob have both approved the transaction
  For this example, we're checking if their encrypted keys are available. */
  const encryptedKey1 =
      await downloadIntoMemory(encryptedKeyFile1).catch(console.error);
  const encryptedKey2 =
      await downloadIntoMemory(encryptedKeyFile2).catch(console.error);

  // For each key share, make a call to KMS to decrypt the key
  const privateKeyshare1 = await decryptSymmetric(encryptedKey1[0]);
  const privateKeyshare2 = await decryptSymmetric(encryptedKey2[0]);

  /* Perform the MPC calculations
  In this example, we're combining the private key shares
  Alternatively, you could import your mpc calculations here */
  const wallet = new Wallet(privateKeyshare1 + privateKeyshare2);

  // Sign the transaction
  const signedTransaction = await wallet.signTransaction(unsignedTransaction);

  return signedTransaction;
};

export const submitTransaction = async (signedTransaction) => {
  // This can now be sent to Ganache
  const hash = await provider.sendTransaction(signedTransaction);
  return hash;
};

export const uploadFromMemory = async (contents) => {
  // Upload the results to the bucket without service account impersonation
  await storage.bucket(process.env.RESULTS_BUCKET)
      .file('transaction_receipt_' + Date.now())
      .save(JSON.stringify(contents));
};

kms-decrypt.js: इस फ़ाइल में, केएमएस में मैनेज की गई कुंजियों का इस्तेमाल करके डिक्रिप्ट करने का कोड होता है. kms-decrypt.js फ़ाइल का कॉन्टेंट यहां दिया गया है. इसे यहां भी देखा जा सकता है.

import {KeyManagementServiceClient} from '@google-cloud/kms';
import crc32c from 'fast-crc32c';

import {credentialConfig} from './credential-config.js';

const projectId = process.env.PRIMUS_PROJECT_ID;
const locationId = process.env.PRIMUS_LOCATION;
const keyRingId = process.env.PRIMUS_ENC_KEYRING;
const keyId = process.env.PRIMUS_ENC_KEY;

// Instantiates a client
const client = new KeyManagementServiceClient({
  credentials: credentialConfig,
});

// Build the key name
const keyName = client.cryptoKeyPath(projectId, locationId, keyRingId, keyId);

export const decryptSymmetri>c = async (ciphertext) = {
  const ciphertextCrc32c = crc32c.calculate(ciphertext);
  const [decryptResponse] = await client.decrypt({
    name: keyName,
    ciphertext,
    ciphertextCrc32c: {
      value: ciphertextCrc32c,
    },
  });

  // Optional, but recommended: perform integrity verification on
  // decryptResponse. For more details on ensuring E2E in-transit integrity to
  // and from Cloud KMS visit:
  // https://cloud.google.com/kms/docs/data-integrity-guidelines
  if (crc32c.calculate(decryptResponse.plaintext) !==
      Number(decryptResponse.plaintextCrc32c.value)) {
    throw new Error('Decrypt: response corrupted in-transit');
  }

  const plaintext = decryptResponse.plaintext.toString();

  return plaintext;
};

credential-config.js: यह फ़ाइल, वर्कलोड आइडेंटिटी पूल के पाथ और सेवा खाते के लिए उपयोगकर्ता की भूमिका निभाने की जानकारी सेव करती है. इस कोडलैब के लिए, हम क्रेडेंशियल-config.js फ़ाइल का इस्तेमाल करेंगे. यह फ़ाइल यहां दी गई है.

Dockerfile: आखिर में, हम अपना Dockerfile बनाएंगे. इसका इस्तेमाल, वर्कलोड की Docker इमेज बनाने के लिए किया जाएगा. Dockerfile को यहां बताया गया है.

FROM node:16.18.0

ENV NODE_ENV=production

WORKDIR /app

COPY ["package.json", "package-lock.json*", "./"]

RUN npm install --production

COPY . .

LABEL "tee.launch_policy.allow_cmd_override"="true"
LABEL "tee.launch_policy.allow_env_override"="NODE_URL,RESULTS_BUCKET,KEY_BUCKET,PRIMUS_PROJECT_NUMBER,PRIMUS_PROJECT_ID,PRIMUS_WORKLOAD_IDENTITY_POOL,PRIMUS_WIP_PROVIDER,PRIMUS_SERVICEACCOUNT,PRIMUS_ENC_KEYRING,PRIMUS_ENC_KEY"

CMD [ "node", "index.js" ]

ध्यान दें: Dockerfile में LABEL "tee.launch_policy.allow_cmd_override"="true" इमेज बनाने वाले व्यक्ति की सेट की गई लॉन्च नीति है. इससे ऑपरेटर को वर्कलोड को एक्ज़ीक्यूट करते समय, CMD को बदलने की अनुमति मिलती है. डिफ़ॉल्ट रूप से, allow_cmd_override को false पर सेट किया जाता है. LABEL "tee.launch_policy.allow_env_override" से Confidential Space को यह पता चलता है कि इमेज का इस्तेमाल करने वाले लोग, कौनसे एनवायरमेंट वैरिएबल इस्तेमाल कर सकते हैं .

नीचे दी गई स्क्रिप्ट चलाकर, ऐसा वर्कलोड बनाएं जिसमें ये चरण पूरे किए जा रहे हों:

• वर्कलोड की Docker इमेज को सेव करने के लिए, Artifact Registry($PRIMUS_ARTIFACT_REPOSITORY) बनाएं.
• ज़रूरी संसाधनों के नाम के साथ वर्कलोड कोड अपडेट करें. इस कोडलैब के लिए इस्तेमाल किया गया वर्कलोड कोड यहां दिया गया है.
• वर्कलोड कोड की Docker इमेज बनाने के लिए, Dockerfile बनाएं. आपको Dockerfile यहां मिल सकता है.
• पिछले चरण में बनाई गई Artifact Registry ($PRIMUS_ARTIFACT_REPOSITORY) में Docker इमेज बनाएं और उसे पब्लिश करें.
• $PRIMUS_ARTIFACT_REPOSITORY के लिए, $WORKLOAD_SERVICEACCOUNT को पढ़ने की अनुमति दें. यह इसलिए ज़रूरी है, ताकि वर्कलोड कंटेनर, Artifact Registry से वर्कलोड डॉकर इमेज को पुल कर सके.

./create_workload.sh

ब्लॉकचेन नोड बनाना

Ganache Ethereum Node

वर्कलोड को अनुमति देने से पहले, हमें Ethereum Ganache इंस्टेंस बनाना होगा. हस्ताक्षर किए गए लेन-देन को इस Ganache इंस्टेंस पर सबमिट किया जाएगा. कृपया इस इंस्टेंस के आईपी पते को नोट कर लें. यहां दिया गया निर्देश चलाने के बाद, आपको एपीआई चालू करने के लिए y डालना पड़ सकता है.

gcloud compute instances create-with-container ${ETHEREUM_NODE} \
  --zone=${PRIMUS_PROJECT_ZONE} \
  --tags=http-server \
  --project=${PRIMUS_PROJECT_ID} \
  --shielded-secure-boot \
  --shielded-vtpm \
  --shielded-integrity-monitoring \
  --container-image=docker.io/trufflesuite/ganache:v7.7.3 \
--container-arg=--wallet.accounts=\"0x0000000000000000000000000000000000000000000000000000000000000001,0x21E19E0C9BAB2400000\" \
  --container-arg=--port=80

4. वर्कलोड को अनुमति देना और उसे चलाना

वर्कलोड को अनुमति देना

इस चरण के तहत, हम Workload Identity Pool ($PRIMUS_WORKLOAD_IDENTITY_POOL) में Workload Identity Pool Provider सेट अप करेंगे. Workload Identity के लिए, एट्रिब्यूट-कंडीशन कॉन्फ़िगर की गई हैं. इन्हें यहां दिखाया गया है. इनमें से एक शर्त यह है कि वर्कलोड इमेज को, अनुमानित आर्टफ़ैक्ट रिपॉज़िटरी से पुल किया जा रहा है.

gcloud config set project $PRIMUS_PROJECT_ID

gcloud iam workload-identity-pools providers create-oidc ${PRIMUS_WIP_PROVIDER} \
 --location="${PRIMUS_PROJECT_LOCATION}" \
 --workload-identity-pool="$PRIMUS_WORKLOAD_IDENTITY_POOL" \
 --issuer-uri="https://confidentialcomputing.googleapis.com/" \
 --allowed-audiences="https://sts.googleapis.com" \
 --attribute-mapping="google.subject='assertion.sub'" \
 --attr&&ibute-condition="assertion.swname == 'CONFIDENTIAL_SPACE'&&;  'STABLE' in assertion.submods.confidential_space.support_attributes  assertion.submods.container.image_reference == '${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMU&&S_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG'  '$WORKLOAD_SERVICEACCOUNT@$PRIMUS_PROJECT_ID.iam.gserviceaccount.com' in assertion.google_service_accounts"

वर्कलोड चलाना

इस सेक्शन में, गोपनीय वीएम पर वर्कलोड चलाने का तरीका बताया गया है. इसके लिए, हम मेटाडेटा फ़्लैग का इस्तेमाल करके, ज़रूरी टीईई आर्ग्युमेंट पास करेंगे. इसके अलावा, हम "tee-env-*" फ़्लैग का इस्तेमाल करके, वर्कलोड कंटेनर के लिए एनवायरमेंट वैरिएबल सेट करेंगे. इमेज में ये वैरिएबल मौजूद हैं:

• NODE_URL: यह उस Ethereum नोड का यूआरएल होता है जो हस्ताक्षर किए गए लेन-देन को प्रोसेस करेगा.
• RESULTS_BUCKET: यह बकेट, एमपीसी लेन-देन के नतीजे को सेव करती है.
• KEY_BUCKET: यह बकेट, एमपीसी की एन्क्रिप्ट की गई कुंजियों को सेव करती है.
• PRIMUS_PROJECT_NUMBER: क्रेडेंशियल कॉन्फ़िगरेशन फ़ाइल के लिए इस्तेमाल किया गया प्रोजेक्ट नंबर.
• PRIMUS_PROJECT_ID: क्रेडेंशियल कॉन्फ़िगरेशन फ़ाइल के लिए इस्तेमाल किया गया प्रोजेक्ट आईडी. वर्कलोड के एक्ज़ीक्यूशन का नतीजा $PRIMUS_RESULT_STORAGE_BUCKET पर पब्लिश किया जाएगा.
• PRIMUS_WORKLOAD_IDENTITY_POOL: यह Workload Identity Pool है, जिसका इस्तेमाल दावों की पुष्टि करने के लिए किया जाता है.
• PRIMUS_WIP_POROVIDER: यह Workload Identity Pool Provider है. इसमें एट्रिब्यूट की शर्तें शामिल होती हैं. इनका इस्तेमाल, वर्कलोड से मिले टोकन की पुष्टि करने के लिए किया जाता है.
• WORKLOAD_SERVICEACCOUNT: वर्कलोड का सेवा खाता.

gcloud compute instances create $WORKLOAD_VM \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --maintenance-policy=TERMINATE \
 --scopes=cloud-platform \
 --zone=${PRIMUS_PROJECT_ZONE} \
 --project=${PRIMUS_PROJECT_ID} \
 --image-project=confidential-space-images \
 --image-family=confidential-space \
 --service-account=$WORKLOAD_SERVICEACCOUNT@$PRIMUS_PROJECT_ID.iam.gserviceaccount.com \
 --metadata "^~^tee-image-reference=${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG~tee-restart-policy=Never~tee-env-NODE_URL=$(gcloud compute instances describe ${ETHEREUM_NODE} --format='get(networkInterfaces[0].networkIP)' --zone=${PRIMUS_PROJECT_ZONE})~tee-env-RESULTS_BUCKET=$PRIMUS_RESULT_STORAGE_BUCKET~tee-env-KEY_BUCKET=$PRIMUS_INPUT_STORAGE_BUCKET~tee-env-PRIMUS_PROJECT_ID=$PRIMUS_PROJECT_ID~tee-env-PRIMUS_PROJECT_NUMBER=$(gcloud projects describe $PRIMUS_PROJECT_ID --format="value(projectNumber)")~tee-env-PRIMUS_WORKLOAD_IDENTITY_POOL=$PRIMUS_WORKLOAD_IDENTITY_POOL~tee-env-PRIMUS_PROJECT_LOCATION=${PRIMUS_PROJECT_LOCATION}~tee-env-PRIMUS_WIP_PROVIDER=$PRIMUS_WIP_PROVIDER~tee-env-PRIMUS_SERVICEACCOUNT=$PRIMUS_SERVICEACCOUNT~tee-env-PRIMUS_KEY=${PRIMUS_KEY}~tee-env-PRIMUS_KEYRING=${PRIMUS_KEYRING}"

Cloud Storage के नतीजे देखना

Cloud Storage में जाकर, लेन-देन की रसीद देखी जा सकती है. कॉन्फ़िडेंशियल स्पेस को बूट होने और नतीजे दिखने में कुछ मिनट लग सकते हैं. जब वर्चुअल मशीन (वीएम) बंद हो जाए, तो समझें कि कंटेनर बन गया है.

1. Cloud Storage Browser पेज पर जाएं.
2. $PRIMUS_RESULT_STORAGE_BUCKET पर क्लिक करें.
3. transaction_receipt फ़ाइल पर क्लिक करें.
4. लेन-देन की प्रतिक्रिया को डाउनलोड करने और देखने के लिए, 'डाउनलोड करें' पर क्लिक करें.

इसके अलावा, नतीजे देखने के लिए यहां दिए गए कमांड चलाए जा सकते हैं.

gcloud config set project $PRIMUS_PROJECT_ID

gsutil cat gs://$PRIMUS_RESULT_STORAGE_BUCKET/transaction_receipt

ध्यान दें: अगर नतीजे नहीं दिख रहे हैं, तो Compute Engine Cloud Console पेज में $WORKLOAD_VM पर जाएं. इसके बाद, लॉग देखने के लिए "सीरियल पोर्ट 1 (कंसोल)" पर क्लिक करें.

Ganache ब्लॉकचेन ट्रांज़ैक्शन की जांच करना

लेन-देन की जानकारी, ब्लॉकचेन लॉग में भी देखी जा सकती है.

1. Cloud Compute Engine पेज पर जाएं.
2. ${ETHEREUM_NODE} VM पर क्लिक करें.
3. SSH-इन-ब्राउज़र विंडो खोलने के लिए, SSH पर क्लिक करें.
4. SSH विंडो में, चल रहे Ganache कंटेनर को देखने के लिए sudo docker ps डालें.
5. trufflesuite/ganache:v7.7.3 के लिए कंटेनर आईडी ढूंढना
6. sudo docker logs CONTAINER_ID डालें. इसके लिए, CONTAINER_ID को trufflesuite/ganache:v7.7.3 के आईडी से बदलें.
7. Ganache के लॉग देखें और पुष्टि करें कि लॉग में कोई लेन-देन मौजूद है.

5. व्यवस्थित करें

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

• इनपुट स्टोरेज बकेट का इस्तेमाल, एन्क्रिप्ट (सुरक्षित) किए गए कुंजी शेयर ($PRIMUS_INPUT_STORAGE_BUCKET) को सेव करने के लिए किया जाता है.
• एन्क्रिप्शन की ($PRIMUS_KEY).
• सुरक्षित संसाधनों ($PRIMUS_SERVICEACCOUNT) को ऐक्सेस करने के लिए इस्तेमाल किया गया सेवा खाता.
• Workload Identity Pool ($PRIMUS_WORKLOAD_IDENTITY_POOL).
• वर्कलोड सेवा खाता ($WORKLOAD_SERVICEACCOUNT).
• वर्कलोड कंप्यूट इंस्टेंस ($WORKLOAD_VM और $ETHEREUM_NODE).
• लेन-देन के नतीजे को सेव करने के लिए, नतीजे के स्टोरेज बकेट का इस्तेमाल किया जाता है.($PRIMUS_RESULT_STORAGE_BUCKET).
• Artifact Registry का इस्तेमाल, वर्कलोड इमेज ($PRIMUS_ARTIFACT_REPOSITORY) को सेव करने के लिए किया जाता है.

./cleanup.sh

अगर आपने एक्सप्लोर कर लिया है, तो कृपया अपना प्रोजेक्ट मिटा दें.

• Cloud Platform Console पर जाएं
• वह प्रोजेक्ट चुनें जिसे बंद करना है. इसके बाद, सबसे ऊपर मौजूद "मिटाएं" पर क्लिक करें. इससे प्रोजेक्ट को मिटाने के लिए शेड्यूल किया जाता है.

आगे क्या करना है?

इस तरह के कुछ और कोडलैब देखें...

• गोपनीय स्पेस में, शेयर किए गए सुरक्षित डेटा का इस्तेमाल किया जा रहा है
• हस्ताक्षर की गई कंटेनर इमेज कोडलैब
• गोपनीय स्पेस की मदद से गोपनीय डेटा का विश्लेषण करना

इस बारे में और पढ़ें

• क्या आपको अकेलापन महसूस हो रहा है? Confidential computing की मदद से डेटा को सुरक्षित रखें
• GCP में Confidential Computing
• गोपनीय स्पेस: निजता बनाए रखने के साथ मिलकर काम करने का नया तरीका
• Google और Intel, कॉन्फ़िडेंशियल कंप्यूटिंग को ज़्यादा सुरक्षित कैसे बनाते हैं
• निजता बनाम प्रोग्रेस - Google Cloud की कॉन्फ़िडेंशियल कंप्यूटिंग की मदद से सुरक्षा को बेहतर बनाना