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

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

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

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

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

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

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

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

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

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

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

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

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

• अपने प्रोजेक्ट के लिए बिलिंग चालू करें.
• दोनों प्रोजेक्ट के लिए, गोपनीय कंप्यूटिंग एपीआई और नीचे दिए गए एपीआई चालू करें.

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	वह बकेट जिसमें एमपीसी लेन-देन का नतीजा सेव किया जाता है.
$PRIMUS_KEY	Primus Bank के लिए, $PRIMUS_INPUT_STORAGE_BUCKET में सेव किए गए डेटा को एन्क्रिप्ट करने के लिए इस्तेमाल की जाने वाली केएमएस पासकोड.
$PRIMUS_KEYRING	Primus Bank के लिए एन्क्रिप्शन पासकोड $PRIMUS_KEY बनाने के लिए इस्तेमाल की जाने वाली केएमएस की-रिंग.
$PRIMUS_WIP_PROVIDER	Workload Identity Pool Provider, जिसमें एट्रिब्यूट की शर्त शामिल होती है. इसका इस्तेमाल, एमपीसी वर्कलोड सेवा से साइन किए गए टोकन के लिए किया जाता है.
$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

Cloud के संसाधन सेट अप करना

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

./setup_resources.sh

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

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

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

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

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

./create_workload_service_account.sh

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

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

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

index.js: यह वर्कलोड ऐप्लिकेशन का एंट्री पॉइंट है. इससे यह तय होता है कि वर्कलोड कंटेनर के शुरू होने पर कौनसे निर्देश चलाए जाने चाहिए. हमने बिना हस्ताक्षर वाले लेन-देन का एक सैंपल भी शामिल किया है. आम तौर पर, यह लेन-देन किसी ऐसे ऐप्लिकेशन से किया जाता है जिस पर भरोसा नहीं किया जा सकता. यह ऐप्लिकेशन, उपयोगकर्ताओं से उनके हस्ताक्षर का अनुरोध करता है. यह index.js फ़ाइल, mpc.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 decryptSymmetric = 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: यह फ़ाइल, सेवा खाते के नाम पर काम करने के लिए, वर्कलोड आइडेंटिटी पूल के पाथ और जानकारी सेव करती है. यहां credential-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", इमेज के लेखक की ओर से सेट की गई लॉन्च नीति है. इससे ऑपरेटर को वर्कलोड को लागू करते समय, सीएमडी को बदलने की अनुमति मिलती है. डिफ़ॉल्ट रूप से, allow_cmd_override को false पर सेट किया जाता है. LABEL "tee.launch_policy.allow_env_override" से पता चलता है कि Confidential Space में, इमेज के उपयोगकर्ता कौनसे एनवायरमेंट वैरिएबल इस्तेमाल कर सकते हैं .

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

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

./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'" \
 --attribute-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/$PRIMUS_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 ब्राउज़र पेज पर जाएं.
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 पर क्लिक करें.
4. चल रहे 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 पर जाएं
• वह प्रोजेक्ट चुनें जिसे आपको बंद करना है. इसके बाद, सबसे ऊपर मौजूद "मिटाएं" पर क्लिक करें. इससे प्रोजेक्ट को मिटाने के लिए शेड्यूल किया जाता है.

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

इस तरह के कुछ अन्य कोडलैब देखें...

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

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

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