איך רוכשים עסקאות בנכסים דיגיטליים באמצעות מחשוב על ידי גורמים מרובים ומרחב סודי

1. סקירה כללית

לפני שמתחילים, כדאי להכיר את התכונות והמושגים הבאים, למרות שלא חובה להכיר אותם כדי להשתמש ב-codelab הזה.

‫Cloud Storage, במיוחד קטגוריות
‫Compute Engine, במיוחד מכונות וירטואליות חסויות
חשבונות שירות
מאגרי תגים ומאגרים מרוחקים
איחוד שירותי אימות הזהות של עומסי עבודה ותנאי מאפיינים

מה תלמדו

ב-Lab הזה מוצגת הטמעה לדוגמה של חתימה על בלוקצ'יין בהתאם ל-MPC באמצעות Confidential Space. כדי להמחיש את המושגים, נציג תרחיש שבו חברת Primus רוצה להעביר נכסים דיגיטליים לחברת Secundus. בתרחיש הזה, חברת Primus משתמשת במודל שתואם ל-MPC, כלומר במקום להשתמש במפתחות פרטיים נפרדים, היא משתמשת בשיתופי מפתחות מבוזרים. מפתחות השיתוף האלה מוחזקים על ידי כמה צדדים, במקרה הזה עינת וירון. לגישה הזו יש כמה יתרונות עבור חברת Primus, כולל חוויית משתמש פשוטה יותר, יעילות תפעולית ושליטה במפתחות הפרטיים.

כדי להסביר את ההיבטים הבסיסיים של התהליך הזה, נפרט את ההגדרה הטכנית ונדריך אתכם בתהליך האישור והחתימה שמתחיל את ההעברה של נכסים דיגיטליים מחברת Primus לחברת Secundus. חשוב לזכור שגם בוב וגם אליס, שעובדים בחברת Primus, צריכים לאשר את העסקה.

למרות שההטמעה לדוגמה הזו מדגימה פעולות חתימה, היא לא כוללת את כל ההיבטים של ניהול מפתחות MPC. לדוגמה, אנחנו לא דנים ביצירת מפתחות. בנוסף, יש גישות חלופיות ומשלימות, כמו שימוש בשירותים שאינם של Google Cloud כדי ליצור חתימות משותפות, או שימוש בחותמים משותפים כדי ליצור חתימות בלוקצ'יין בסביבות שלהם, שהיא ארכיטקטורה מבוזרת יותר. אנחנו מקווים שהמעבדה הזו תעורר השראה לגישות שונות ל-MPC ב-Google Cloud.

תעבדו עם עומס עבודה פשוט שחותם על טרנזקציית Ethereum ב-Confidential Space באמצעות חומרי מפתח של חותם משותף. חתימה על עסקת Ethereum היא תהליך שבו משתמש יכול לאשר עסקה בבלוקצ'יין של Ethereum. כדי לשלוח טרנזקציה של Ethereum, צריך לחתום עליה באמצעות המפתח הפרטי. כך נוכל לוודא שאתם הבעלים של החשבון ושאתם מאשרים את העסקה. תהליך החתימה הוא כזה:

השולח יוצר אובייקט של טרנזקציה שמציין את כתובת הנמען, את כמות ה-ETH לשליחה וכל נתון רלוונטי אחר.
המפתח הפרטי של השולח משמש לגיבוב נתוני העסקה.
לאחר מכן, הגיבוב נחתם באמצעות המפתח הפרטי.
החתימה מצורפת לאובייקט העסקה.
הטרנזקציה משודרת לרשת Ethereum.

כשצומת ברשת מקבלת טרנזקציה, היא מאמתת את החתימה כדי לוודא שהיא נחתמה על ידי הבעלים של החשבון. אם החתימה תקפה, הצומת יוסיף את העסקה לבלוקצ'יין.

כדי להתחיל, צריך להגדיר את משאבי הענן הנדרשים. לאחר מכן, מריצים את עומס העבודה ב-Confidential Space. בשיעור הזה תלמדו איך לבצע את השלבים הבאים:

איך מגדירים את משאבי הענן הנדרשים להרצת Confidential Space
איך מאשרים גישה למשאבים מוגנים על סמך המאפיינים של:
מה: מאגר עומס העבודה
איפה: בסביבת Confidential Space (התמונה של Confidential Space ב-Confidential VM)
מי: החשבון שמריץ את עומס העבודה
איך מריצים את עומס העבודה במכונה וירטואלית חסויה שמופעלת באמצעות תמונת מכונה וירטואלית של Confidential Space

ממשקי API נדרשים

כדי להשלים את ההדרכה הזו, צריך להפעיל את ממשקי ה-API הבאים בפרויקטים שצוינו.

שם ה-API	שם ה-API
cloudkms.googleapis.com	Cloud KMS
compute.googleapis.com	Compute Engine
confidentialcomputing.googleapis.com	Confidential Computing
iamcredentials.googleapis.com	IAM
artifactregistry.googleapis.com	Artifact Registry

2. הגדרת משאבי ענן

לפני שמתחילים

משכפלים את המאגר הזה באמצעות הפקודה שלמטה כדי לקבל את הסקריפטים הנדרשים שמשמשים כחלק מה-codelab הזה.

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

שינוי הספרייה של ה-codelab הזה.

cd confidential-space/codelabs/digital_asset_transaction_codelab/scripts

מוודאים שהגדרתם את משתני הסביבה הנדרשים של הפרויקט כמו שמוצג בהמשך. מידע נוסף על הגדרת פרויקט ב-GCP זמין ב-codelab הזה. כאן אפשר לקבל פרטים על אופן האחזור של מזהה הפרויקט ועל ההבדלים בינו לבין שם הפרויקט ומספר הפרויקט. .

export PRIMUS_PROJECT_ID=<GCP project id>

מפעילים את החיוב בפרויקטים.
מפעילים את Confidential Computing API ואת ממשקי ה-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

כדי להגדיר את המשתנים לשמות המשאבים, אפשר להשתמש בפקודה הבאה. שימו לב שהפעולה הזו תחליף את שמות המשאבים שספציפיים לפרויקט GCP שלכם עבור חברה א', לדוגמה, export PRIMUS_INPUT_STORAGE_BUCKET='primus-input-bucket'
אפשר להגדיר את המשתנים הבאים בפרויקט GCP של חברה א':

$PRIMUS_INPUT_STORAGE_BUCKET	הקטגוריה שבה מאוחסנים המפתחות המוצפנים.
$PRIMUS_RESULT_STORAGE_BUCKET	הקטגוריה שבה מאוחסנת תוצאת העסקה של MPC.
$PRIMUS_KEY	מפתח ה-KMS שמשמש להצפנת הנתונים שמאוחסנים ב- $PRIMUS_INPUT_STORAGE_BUCKET עבור Primus Bank.
$PRIMUS_KEYRING	מחזיק המפתחות של KMS שבו ייעשה שימוש ליצירת מפתח ההצפנה $PRIMUS_KEY עבור Primus Bank.
$PRIMUS_WIP_PROVIDER	הספק של מאגר הזהויות של עומסי העבודה, שכולל את תנאי המאפיין לשימוש באסימונים שנחתמו על ידי שירות עומסי העבודה של MPC.
$PRIMUS_SERVICEACCOUNT	חשבון השירות שמשמש את $PRIMUS_WORKLOAD_IDENTITY_POOL כדי לגשת למשאבים המוגנים. לחשבון השירות הזה תהיה הרשאה לצפייה במפתחות המוצפנים ששמורים בדלי ‎ $PRIMUS_INPUT_STORAGE_BUCKET.
$PRIMUS_ARTIFACT_REPOSITORY	מאגר הארטיפקטים לאחסון קובץ האימג' של הקונטיינר של עומס העבודה.
$WORKLOAD_SERVICEACCOUNT	חשבון השירות שיש לו הרשאה לגשת למכונה הווירטואלית החסויה שמריצה את עומס העבודה.
$WORKLOAD_CONTAINER	קונטיינר Docker שמפעיל את עומס העבודה.
$WORKLOAD_IMAGE_NAME	השם של קובץ האימג' בקונטיינר של עומס העבודה.
$WORKLOAD_IMAGE_TAG	התג של תמונת הקונטיינר של עומס העבודה.

מריצים את הסקריפט הבא כדי להגדיר את שמות המשתנים שנותרו לערכים שמבוססים על מזהה הפרויקט שלכם עבור שמות משאבים.

source config_env.sh

הגדרת משאבי ענן

במסגרת השלב הזה, תגדירו את משאבי הענן שנדרשים לחישוב רב-צדדי. בשיעור ה-Lab הזה תשתמשו במפתח הפרטי הבא: 0000000000000000000000000000000000000000000000000000000000000001

בסביבת ייצור, תצטרכו ליצור מפתח פרטי משלכם. עם זאת, לצורך המעבדה הזו, נפצל את המפתח הפרטי לשני חלקים ונקודד כל אחד מהם. בתרחיש ייצור, אסור לאחסן מפתחות בקבצים של טקסט פשוט. במקום זאת, אפשר ליצור את המפתח הפרטי מחוץ ל-Google Cloud (או לדלג על השלב הזה ולהחליף אותו ביצירה של שברי מפתח MPC בהתאמה אישית), ואז להצפין אותו כך שלאף אחד לא תהיה גישה למפתח הפרטי או לשברי המפתח. לצורך ה-Lab הזה נשתמש ב-CLI של gcloud.

מריצים את הסקריפט הבא כדי להגדיר את משאבי הענן הנדרשים. במסגרת השלבים האלה, ייצרו המשאבים הבאים:

קטגוריה של Cloud Storage‏ ($PRIMUS_INPUT_STORAGE_BUCKET) לאחסון החלקים של המפתח הפרטי המוצפן.
קטגוריה של Cloud Storage‏ ($PRIMUS_RESULT_STORAGE_BUCKET) לאחסון התוצאה של העסקה בנכס דיגיטלי.
מפתח הצפנה ($PRIMUS_KEY) וצרור מפתחות ($PRIMUS_KEYRING) ב-KMS להצפנה של חלקי המפתח הפרטי.
מאגר זהויות של עומסי עבודה ($PRIMUS_WORKLOAD_IDENTITY_POOL) כדי לאמת טענות על סמך תנאי מאפיינים שהוגדרו בספק שלו.
חשבון שירות ($PRIMUS_SERVICEACCOUNT) שמצורף למאגר זהויות של כוח העבודה ($PRIMUS_WORKLOAD_IDENTITY_POOL) שצוין למעלה, עם גישת IAM הבאה:
‫roles/cloudkms.cryptoKeyDecrypter כדי לפענח את הנתונים באמצעות מפתח ה-KMS.
‫objectViewer כדי לקרוא נתונים מהקטגוריה ב-Cloud Storage.
‫roles/iam.workloadIdentityUser כדי לחבר את חשבון השירות הזה למאגר הזהויות של עומסי העבודה.

./setup_resources.sh

3. יצירת עומס עבודה

יצירת חשבון שירות לעומס עבודה

עכשיו יוצרים חשבון שירות לעומס העבודה עם התפקידים וההרשאות הנדרשים. כדי לעשות את זה, מריצים את הסקריפט הבא, שייצור חשבון שירות של עומס עבודה עבור חברה א'. המכונה הווירטואלית שמריצה את עומס העבודה תשתמש בחשבון השירות הזה.

לחשבון השירות של עומס העבודה ($WORKLOAD_SERVICEACCOUNT) יהיו התפקידים הבאים:

‫confidentialcomputing.workloadUser כדי לקבל טוקן אישור
‫logging.logWriter כדי לכתוב יומנים ב-Cloud Logging.
‫objectViewer כדי לקרוא נתונים מהקטגוריה של Cloud Storage.$PRIMUS_INPUT_STORAGE_BUCKET
‫objectUser כדי לכתוב את תוצאת עומס העבודה לקטגוריית Cloud Storage‏ $PRIMUS_RESULT_STORAGE_BUCKET.

./create_workload_service_account.sh

יצירת עומס עבודה

בשלב הזה יוצרים תמונת Docker של עומס העבודה. עומס העבודה ב-codelab הזה הוא אפליקציית MPC פשוטה של Node.js שחותמת על עסקאות דיגיטליות להעברת נכסים באמצעות מפתחות פרטיים מוצפנים. כאן הוא קוד הפרויקט של עומס העבודה. פרויקט עומס העבודה כולל את הקבצים הבאים.

‫package.json: הקובץ הזה מכיל את רשימת החבילות שצריך להשתמש בהן באפליקציית ה-MPC של עומס העבודה. במקרה הזה, אנחנו משתמשים בספריות @google-cloud/kms,‏ @google-cloud/storage,‏ ethers ו-fast-crc32c. כאן נמצא קובץ package.json שבו נשתמש ב-codelab הזה.

‫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. בהמשך מופיע התוכן של הקובץ 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 שבו נשתמש ב-codelab הזה.

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

הערה: התווית LABEL "tee.launch_policy.allow_cmd_override"="true" בקובץ Dockerfile היא מדיניות הפעלה שהוגדרה על ידי יוצר התמונה. היא מאפשרת למפעיל לבטל את ה-CMD כשמריצים את עומס העבודה. כברירת מחדל, הערך של allow_cmd_override הוא false. התווית tee.launch_policy.allow_env_override אומרת ל-Confidential Space באילו משתני סביבה משתמשים בתמונות יכולים להשתמש .

מריצים את הסקריפט הבא כדי ליצור עומס עבודה שבו מתבצעים השלבים הבאים:

יוצרים Artifact Registry ‏($PRIMUS_ARTIFACT_REPOSITORY) כדי לאחסן את קובץ האימג' של Docker של עומס העבודה.
מעדכנים את קוד עומס העבודה בשמות המשאבים הנדרשים. כאן אפשר למצוא את קוד העומס שמשמש ב-codelab הזה.
יוצרים קובץ Dockerfile כדי ליצור קובץ אימג' של Docker של קוד עומס העבודה. כאן אפשר למצוא את קובץ Dockerfile.
יוצרים את קובץ האימג' של Docker ומפרסמים אותו ב-Artifact Registry‏ ($PRIMUS_ARTIFACT_REPOSITORY) שנוצר בשלב הקודם.
נותנים ל-$WORKLOAD_SERVICEACCOUNT הרשאת קריאה ל-$PRIMUS_ARTIFACT_REPOSITORY. הפעולה הזו נדרשת כדי שהקונטיינר של עומס העבודה יוכל לשלוף את תמונת Docker של עומס העבודה מ-Artifact Registry.

./create_workload.sh

יצירת צומת Blockchain

צומת Ganache Ethereum

לפני שמאשרים את עומס העבודה, צריך ליצור את מופע Ethereum Ganache. העסקה החתומה תישלח למופע הזה של Ganache. חשוב לשים לב לכתובת ה-IP של המופע הזה. אחרי שמריצים את הפקודה שלמטה, יכול להיות שיהיה צורך להזין y כדי להפעיל את ה-API.

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. אישור והרצה של עומס עבודה

מתן הרשאה לעומס עבודה

במסגרת השלב הזה, נגדיר את הספק של מאגר הזהויות של עומסי העבודה במאגר הזהויות של עומסי העבודה ($PRIMUS_WORKLOAD_IDENTITY_POOL). מוגדרים תנאים למאפיינים של הזהות של עומס העבודה, כפי שמוצג בהמשך. אחד התנאים הוא לאמת שתמונת עומס העבודה נמשכת ממאגר הארטיפקטים הצפוי.

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 באמצעות דגל המטא-נתונים. בנוסף, נגדיר משתני סביבה למאגר של עומס העבודה באמצעות הדגל tee-env-*. בתמונה יש את המשתנים הבאים:

‫NODE_URL: כתובת ה-URL של צומת Ethereum שיעבד את העסקה החתומה.
‫RESULTS_BUCKET: דלי שבו מאוחסנת התוצאה של טרנזקציית ה-MPC.
‫KEY_BUCKET: הבאקט שבו מאוחסנים המפתחות המוצפנים של MPC.
‫PRIMUS_PROJECT_NUMBER: מספר הפרויקט שמשמש לקובץ ההגדרות של פרטי הכניסה.
‫PRIMUS_PROJECT_ID: מזהה הפרויקט שמשמש בקובץ ההגדרות של פרטי הכניסה. התוצאה של הפעלת עומס העבודה תפורסם ב-$PRIMUS_RESULT_STORAGE_BUCKET.
‫PRIMUS_WORKLOAD_IDENTITY_POOL: מאגר הזהויות של עומסי העבודה ששימש לאימות הטענות.
‫PRIMUS_WIP_POROVIDER: ספק מאגר הזהויות של כוח העבודה שכולל את תנאי המאפיינים שמשמשים לאימות אסימונים שמוצגים על ידי עומס העבודה.
‫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. יכול להיות שיחלפו כמה דקות עד שהמרחב המאובטח יופעל והתוצאות יופיעו. המכונה הווירטואלית תהיה במצב עצירה כשהקונטיינר יסיים את הפעולה.

נכנסים לדף Cloud Storage Browser.
לוחצים על $PRIMUS_RESULT_STORAGE_BUCKET.
לוחצים על הקובץ transaction_receipt.
לוחצים על 'הורדה' כדי להוריד את תגובת העסקה ולצפות בה.

אפשר גם להריץ את הפקודות הבאות כדי לראות את התוצאה.

gcloud config set project $PRIMUS_PROJECT_ID

gsutil cat gs://$PRIMUS_RESULT_STORAGE_BUCKET/transaction_receipt

הערה: אם התוצאות לא מופיעות, אפשר לעבור אל $WORKLOAD_VM בדף Compute Engine Cloud Console וללחוץ על Serial port 1 (console) (יציאה טורית 1 (מסוף)) כדי להציג את היומנים.

בדיקת העסקה בבלוקצ'יין של Ganache

אפשר גם לראות את העסקה ביומן הבלוקצ'יין.

נכנסים לדף Cloud Compute Engine.
לוחצים על ${ETHEREUM_NODE} VM.
לוחצים על SSH כדי לפתוח את חלון ה-SSH בדפדפן.
בחלון ה-SSH, מזינים sudo docker ps כדי לראות את מאגר Ganache שפועל.
מזהה מאגר של trufflesuite/ganache:v7.7.3
מזינים sudo docker logs CONTAINER_ID ומחליפים את CONTAINER_ID במזהה של trufflesuite/ganache:v7.7.3.
בודקים את היומנים של Ganache ומוודאים שיש טרנזקציה שמופיעה ביומנים.

5. הסרת המשאבים

כאן מופיע הסקריפט שאפשר להשתמש בו כדי לנקות את המשאבים שיצרנו כחלק מה-Codelab הזה. כחלק מהניקוי הזה, המשאבים הבאים יימחקו:

קטגוריית אחסון של קלט שמשמשת לאחסון של שיתופי מפתחות מוצפנים ($PRIMUS_INPUT_STORAGE_BUCKET).
מפתח הצפנה ($PRIMUS_KEY).
חשבון שירות שמשמש לגישה למשאבים מוגנים ($PRIMUS_SERVICEACCOUNT).
מאגר זהויות של עומסי עבודה ($PRIMUS_WORKLOAD_IDENTITY_POOL).
חשבון שירות של עומס העבודה ($WORKLOAD_SERVICEACCOUNT).
מכונות וירטואליות של Workload ($WORKLOAD_VM ו-$ETHEREUM_NODE).
קטגוריית אחסון של תוצאות שמשמשת לאחסון תוצאות העסקה ($PRIMUS_RESULT_STORAGE_BUCKET).
מאגר Artifact Registry שמשמש לאחסון תמונת עומס העבודה ($PRIMUS_ARTIFACT_REPOSITORY).

./cleanup.sh

אם סיימתם את הבדיקה, כדאי למחוק את הפרויקט.

נכנסים אל Cloud Platform Console.
בוחרים את הפרויקט שרוצים לסגור ולוחצים על 'מחיקה' בחלק העליון. הפעולה הזו תגרום לכך שהפרויקט יתוזמן למחיקה.

מה השלב הבא?

כדאי לעיין במדריכי Codelab דומים נוספים…