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

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

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

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

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

מה תלמדו

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

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

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

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

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

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

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

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

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

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

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 ואת ממשקי ה-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 כדי לגשת למשאבים המוגנים. לחשבון השירות הזה תהיה הרשאה להציג את המפתחות המוצפנים שמאוחסנים בקטגוריה (bucket) $PRIMUS_INPUT_STORAGE_BUCKET.
$PRIMUS_ARTIFACT_REPOSITORY	מאגר הארטיפקטים לאחסון קובץ האימג' של קונטיינר עומס העבודה.
$WORKLOAD_SERVICEACCOUNT	חשבון השירות שיש לו הרשאה לגשת למכונה הווירטואלית הסודית שמריצה את עומס העבודה.
$WORKLOAD_CONTAINER	קונטיינר Docker שבו פועל עומס העבודה.
$WORKLOAD_IMAGE_NAME	השם של קובץ האימג' בקונטיינר של עומס העבודה.
$WORKLOAD_IMAGE_TAG	התג של קובץ האימג' בקונטיינר של עומס העבודה.

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

source config_env.sh

הגדרת משאבים ב-Cloud

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

בסביבת ייצור, תצטרכו ליצור מפתח פרטי משלכם. עם זאת, למטרות הסדנה הזו, נחלק את המפתח הפרטי לשני חלקים ונצפין כל אחד מהם. בתרחיש ייצור, לעולם אסור לאחסן מפתחות בקבצים של טקסט ללא הצפנה. במקום זאת, אפשר ליצור את המפתח הפרטי מחוץ ל-Google Cloud (או לדלג עליו לגמרי ולהחליף אותו ביצירה של פלחי מפתחות מותאמים אישית של MPC) ואז להצפין אותו כך שאף אחד לא יקבל גישה למפתח הפרטי או לפלחי המפתחות. במסגרת הסדנה הזו נשתמש ב-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 כדי לקרוא נתונים מהקטגוריה $PRIMUS_INPUT_STORAGE_BUCKET ב-Cloud Storage.
objectUser כדי לכתוב את תוצאת עומס העבודה בקטגוריה $PRIMUS_RESULT_STORAGE_BUCKET של Cloud Storage.

./create_workload_service_account.sh

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

בשלב הזה יוצרים קובץ אימג' של Docker של עומס העבודה. עומס העבודה בקודלאב הזה הוא אפליקציית 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. התווית LABEL "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 Node

לפני שמאשרים את עומס העבודה, צריך ליצור את המכונה של 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"

הפעלת עומס עבודה

בקטע הזה נסביר איך להריץ את עומס העבודה ב-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 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. יכול להיות שיחלפו כמה דקות עד שהפעלת Confidential Space והתוצאות יופיעו. תדעו שהקונטיינר סיים לפעול כשהמכונה הווירטואלית תהיה במצב מושבת.

נכנסים לדף 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) כדי להציג את היומנים.

בדיקת העסקה ב-Ganache Blockchain

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

עוברים לדף 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 Compute ($WORKLOAD_VM ו-$ETHEREUM_NODE).
קטגוריית האחסון של התוצאות שמשמשת לאחסון תוצאת העסקה.($PRIMUS_RESULT_STORAGE_BUCKET).
מאגר הארטיפקטים שבו מאוחסן קובץ האימג' של כוח העבודה ($PRIMUS_ARTIFACT_REPOSITORY).

./cleanup.sh

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

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

מה השלב הבא?

כדאי לעיין בחלק מהמדריכים הבאים בנושא Codelab…