דף זה תורגם על ידי Cloud Translation API.

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

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

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

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

מה תלמדו

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

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

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

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

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

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

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

איך להגדיר את משאבי הענן שנחוצים להרצת Confidential Space
איך מאשרים גישה למשאבים מוגנים על סמך המאפיינים של:
מה: מאגר עומס העבודה
איפה: סביבת Confidential Space (תמונת Confidential Space ב-Confidential VM)
מי: החשבון שמפעיל את עומס העבודה
איך להריץ את עומס העבודה ב-VM עם Confidential Space שמבוססת על קובץ האימג' של 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. הגדרת משאבים ב-Cloud

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

משכפלים את המאגר הזה באמצעות הפקודה הבאה כדי לקבל את הסקריפטים הנדרשים שמשמשים כחלק מה-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	הספק של Workload Identity Pool, שכולל את התנאי של המאפיין שישמש לאסימונים שנחתמו על ידי שירות 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

הגדרה של משאבי Cloud

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

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

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

קטגוריה של 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 כדי לקבל אסימון אימות (attestation)
logging.logWriter כדי לכתוב יומנים ב-Cloud Logging.
objectViewer כדי לקרוא נתונים מהקטגוריה $PRIMUS_INPUT_STORAGE_BUCKET של Cloud Storage.
objectUser כדי לכתוב את התוצאה של עומס העבודה בקטגוריה $PRIMUS_RESULT_STORAGE_BUCKET של Cloud Storage.

./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-פענוח ומ-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-פענוח.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: לסיום, ניצור את קובץ ה-Docker שישמש ליצירת קובץ האימג' של Docker של עומס העבודה. מגדיר את קובץ ה-Docker כפי שמצוין כאן.

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" בקובץ Docker הוא מדיניות הפעלה שהוגדרה על ידי מחבר התמונה. היא מאפשרת לאופרטור לעקוף את ה-CMD במהלך ביצוע עומס העבודה. כברירת מחדל, הערך של Allow_cmd_override הוא False. LABEL "tee.launch_policy.allow_env_override" מנחה את Confidential Space לגבי אילו משתני תמונה המשתמשים יכולים להשתמש .

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

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

./create_workload.sh

יצירת צומת הבלוקצ'יין

צומת Ganache Ethereum

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

gcloud config set project $PRIMUS_PROJECT_ID

gcloud compute instances create-with-container mpc-lab-ethereum-node \
  --zone=${PRIMUS_PROJECT_ZONE}\
  --tags=http-server \
  --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)

אישור עומס עבודה (workload)

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

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"

הפעלת עומס העבודה (workload)

הקטע הזה מסביר איך להריץ את עומס העבודה ב-Confidential VM. לשם כך, נעביר את ארגומנטים מסוג 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 config set project $PRIMUS_PROJECT_ID

gcloud compute instances create $WORKLOAD_VM \
 --confidential-compute-type=SEV \
 --shielded-secure-boot \
 --maintenance-policy=TERMINATE \
 --scopes=cloud-platform \
 --zone=${PRIMUS_PROJECT_ZONE} \
 --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 mpc-lab-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. יכול להיות שיחלפו כמה דקות עד ש-Confidential Space יתחיל לפעול והתוצאות יופיעו. אפשר לדעת שהקונטיינר הסתיים כשהמכונה הווירטואלית נמצאת במצב עצירה.

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

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

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

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

נכנסים לדף Cloud Compute Engine.
לוחצים על mpc-lab-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_KEYRING).
חשבון שירות שמשמש לגישה למשאבים מוגנים ($PRIMUS_SERVICEACCOUNT).
מאגר זהויות של עומסי עבודה ($PRIMUS_WORKLOAD_IDENTITY_POOL).
חשבון שירות של עומס עבודה ($WORKLOAD_SERVICEACCOUNT).
מכונות מחשוב של עומסי עבודה (workloads).
קטגוריית אחסון התוצאות שמשמשת לאחסון תוצאת העסקה.($PRIMUS_RESULT_STORAGE_BUCKET).
רישום ארטיפקטים משמש לאחסון תמונה של עומס עבודה ($PRIMUS_ARTIFACT_REPOSITORY).

./cleanup.sh

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

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

מה השלב הבא?

התנסות בכמה מ-Codelabs הדומות האלה...