Cách giao dịch tài sản kỹ thuật số bằng cơ chế tính toán nhiều bên và không gian bảo mật

1. Tổng quan

Trước khi bắt đầu, mặc dù không hoàn toàn cần thiết, nhưng kiến thức về các tính năng và khái niệm sau đây sẽ hữu ích trong lớp học lập trình này.

Cloud Storage, cụ thể là các bộ chứa
Compute Engine, cụ thể là Máy ảo bảo mật
Tài khoản dịch vụ
Vùng chứa và kho lưu trữ từ xa
Liên kết danh tính cho khối lượng công việc và điều kiện thuộc tính

Kiến thức bạn sẽ học được

Phòng thí nghiệm này cung cấp một cách triển khai tham chiếu để thực hiện quy trình ký blockchain tuân thủ MPC bằng Confidential Space. Để minh hoạ các khái niệm này, chúng ta sẽ xem xét một trường hợp trong đó Công ty Primus muốn chuyển tài sản kỹ thuật số cho Công ty Secundus. Trong trường hợp này, Công ty Primus sử dụng một mô hình tuân thủ MPC, tức là thay vì sử dụng các khoá riêng tư riêng lẻ, họ sử dụng các phần khoá được phân phối. Các phần khoá này do nhiều bên nắm giữ, trong trường hợp này là Alice và Bob. Phương pháp này mang lại cho Công ty Primus một số lợi ích, bao gồm trải nghiệm người dùng đơn giản, hiệu quả hoạt động và quyền kiểm soát khoá riêng tư của họ.

Để giải thích các khía cạnh cơ bản của quy trình này, chúng tôi sẽ trình bày chi tiết về chế độ thiết lập kỹ thuật và hướng dẫn bạn quy trình phê duyệt và ký tên để bắt đầu chuyển tài sản kỹ thuật số từ Công ty Primus sang Công ty Secundus. Xin lưu ý rằng cả Bob và Alice (đều là nhân viên của Công ty Primus) đều phải phê duyệt giao dịch.

Mặc dù chế độ triển khai tham chiếu này minh hoạ các thao tác ký, nhưng không bao gồm tất cả các khía cạnh của việc quản lý khoá MPC. Ví dụ: chúng tôi không thảo luận về việc tạo khoá. Ngoài ra, còn có các phương pháp thay thế và bổ sung, chẳng hạn như sử dụng các dịch vụ không phải của Google Cloud để tạo chữ ký đồng thời hoặc yêu cầu người ký đồng thời tạo chữ ký blockchain trong môi trường của riêng họ. Đây là một cấu trúc phi tập trung hơn. Chúng tôi hy vọng phòng thí nghiệm này sẽ truyền cảm hứng cho nhiều phương pháp tiếp cận khác nhau đối với MPC trên Google Cloud.

Bạn sẽ làm việc với một khối lượng công việc đơn giản, ký một giao dịch Ethereum trong Confidential Space bằng cách sử dụng các thành phần khoá đồng ký. Ký giao dịch Ethereum là một quy trình mà người dùng có thể uỷ quyền cho một giao dịch trên chuỗi khối Ethereum. Để gửi một giao dịch Ethereum, bạn cần ký giao dịch đó bằng khoá riêng tư. Điều này chứng minh rằng bạn là chủ sở hữu của tài khoản và cho phép giao dịch. Quy trình ký như sau:

Người gửi tạo một đối tượng giao dịch chỉ định địa chỉ người nhận, số lượng ETH cần gửi và mọi dữ liệu liên quan khác.
Khoá riêng tư của người gửi được dùng để băm dữ liệu giao dịch.
Sau đó, hàm băm được ký bằng khoá riêng tư.
Chữ ký được đính kèm vào đối tượng giao dịch.
Giao dịch được phát đến mạng Ethereum.

Khi một nút trên mạng nhận được một giao dịch, nút đó sẽ xác minh chữ ký để đảm bảo rằng giao dịch đó được ký bởi chủ sở hữu tài khoản. Nếu chữ ký hợp lệ, nút sẽ thêm giao dịch vào chuỗi khối.

Để bắt đầu, bạn sẽ định cấu hình các tài nguyên cần thiết trên Cloud. Sau đó, bạn sẽ chạy khối lượng công việc trong Confidential Space. Lớp học lập trình này sẽ hướng dẫn bạn thực hiện các bước chung sau:

Cách định cấu hình các tài nguyên cần thiết trên đám mây để chạy Confidential Space
Cách cho phép truy cập vào các tài nguyên được bảo vệ dựa trên các thuộc tính của:
What: vùng chứa tải
Nơi: môi trường Confidential Space (hình ảnh Confidential Space trên Confidential VM)
Ai: tài khoản đang chạy khối lượng công việc
Cách chạy khối lượng công việc trong một Máy ảo bảo mật đang chạy hình ảnh Máy ảo trong Không gian bảo mật

API bắt buộc

Bạn phải bật các API sau trong các dự án được chỉ định để có thể hoàn thành hướng dẫn này.

Tên API	Tiêu đề API
cloudkms.googleapis.com	Cloud KMS
compute.googleapis.com	Compute Engine
confidentialcomputing.googleapis.com	Điện toán bảo mật
iamcredentials.googleapis.com	IAM
artifactregistry.googleapis.com	Artifact Registry

2. Thiết lập tài nguyên trên đám mây

Trước khi bắt đầu

Sao chép kho lưu trữ này bằng lệnh bên dưới để lấy các tập lệnh bắt buộc được dùng trong lớp học lập trình này.

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

Thay đổi thư mục cho lớp học lập trình này.

cd confidential-space/codelabs/digital_asset_transaction_codelab/scripts

Đảm bảo bạn đã thiết lập các biến môi trường dự án bắt buộc như minh hoạ bên dưới. Để biết thêm thông tin về cách thiết lập một dự án GCP, vui lòng tham khảo lớp học lập trình này. Bạn có thể tham khảo bài viết này để biết thông tin chi tiết về cách truy xuất mã dự án và mã này khác với tên dự án và số dự án như thế nào. .

export PRIMUS_PROJECT_ID=<GCP project id>

Bật tính năng Thanh toán cho các dự án của bạn.
Bật Confidential Computing API và các API sau cho cả hai dự án.

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

Để đặt các biến cho tên tài nguyên, bạn có thể dùng lệnh sau. Xin lưu ý rằng thao tác này sẽ thay thế tên tài nguyên dành riêng cho dự án GCP của bạn cho công ty A, ví dụ: export PRIMUS_INPUT_STORAGE_BUCKET='primus-input-bucket'
Bạn có thể đặt các biến sau cho dự án GCP của mình trong Công ty A:

$PRIMUS_INPUT_STORAGE_BUCKET	Nhóm lưu trữ các khoá đã mã hoá.
$PRIMUS_RESULT_STORAGE_BUCKET	Bộ chứa lưu trữ kết quả giao dịch MPC.
$PRIMUS_KEY	Khoá KMS dùng để mã hoá dữ liệu được lưu trữ trong $PRIMUS_INPUT_STORAGE_BUCKET cho Ngân hàng Primus.
$PRIMUS_KEYRING	Bộ khoá KMS sẽ được dùng để tạo khoá mã hoá $PRIMUS_KEY cho Ngân hàng Primus.
$PRIMUS_WIP_PROVIDER	Nhà cung cấp Workload Identity Pool (WIP) bao gồm điều kiện thuộc tính để sử dụng cho các mã thông báo do dịch vụ tải MPC ký.
$PRIMUS_SERVICEACCOUNT	Tài khoản dịch vụ mà $PRIMUS_WORKLOAD_IDENTITY_POOL dùng để truy cập vào các tài nguyên được bảo vệ. Tài khoản dịch vụ này sẽ có quyền xem các khoá đã mã hoá được lưu trữ trong vùng chứa $PRIMUS_INPUT_STORAGE_BUCKET.
$PRIMUS_ARTIFACT_REPOSITORY	Kho lưu trữ cấu phần phần mềm để lưu trữ hình ảnh vùng chứa của khối lượng công việc.
$WORKLOAD_SERVICEACCOUNT	Tài khoản dịch vụ có quyền truy cập vào Máy ảo bảo mật chạy khối lượng công việc.
$WORKLOAD_CONTAINER	Vùng chứa Docker chạy khối lượng công việc.
$WORKLOAD_IMAGE_NAME	Tên của hình ảnh vùng chứa tải.
$WORKLOAD_IMAGE_TAG	Thẻ của hình ảnh vùng chứa khối lượng công việc.

Chạy tập lệnh sau để đặt các tên biến còn lại thành giá trị dựa trên mã dự án cho tên tài nguyên.

source config_env.sh

Thiết lập tài nguyên trên đám mây

Trong bước này, bạn sẽ thiết lập các tài nguyên đám mây cần thiết cho tính toán nhiều bên. Trong phòng thí nghiệm này, bạn sẽ sử dụng khoá riêng tư sau: 0000000000000000000000000000000000000000000000000000000000000001

Trong môi trường sản xuất, bạn sẽ tạo khoá riêng tư của riêng mình. Tuy nhiên, cho mục đích của phòng thí nghiệm này, chúng ta sẽ chia khoá riêng tư này thành hai phần và mã hoá từng phần. Trong trường hợp phát hành chính thức, bạn không bao giờ được lưu trữ khoá trong các tệp văn bản thuần tuý. Thay vào đó, khoá riêng tư có thể được tạo bên ngoài Google Cloud (hoặc bỏ qua hoàn toàn và thay thế bằng quy trình tạo phân đoạn khoá MPC tuỳ chỉnh), sau đó được mã hoá để không ai có quyền truy cập vào khoá riêng tư hoặc các phân đoạn khoá. Để phục vụ mục đích của lớp học lập trình này, chúng ta sẽ sử dụng Gcloud CLI.

Chạy tập lệnh sau đây để thiết lập các tài nguyên đám mây cần thiết. Trong các bước này, các tài nguyên được đề cập dưới đây sẽ được tạo:

Một bộ chứa Cloud Storage ($PRIMUS_INPUT_STORAGE_BUCKET) để lưu trữ các phần khoá riêng tư đã mã hoá.
Bộ chứa Cloud Storage ($PRIMUS_RESULT_STORAGE_BUCKET) để lưu trữ kết quả của giao dịch tài sản kỹ thuật số.
Khoá mã hoá ($PRIMUS_KEY) và chuỗi khoá ($PRIMUS_KEYRING) trong KMS để mã hoá các phần khoá riêng tư.
Một nhóm danh tính tải ($PRIMUS_WORKLOAD_IDENTITY_POOL) để xác thực các yêu cầu dựa trên các điều kiện thuộc tính được định cấu hình trong nhà cung cấp của nhóm.
Một tài khoản dịch vụ ($PRIMUS_SERVICEACCOUNT) được đính kèm vào nhóm danh tính tải ($PRIMUS_WORKLOAD_IDENTITY_POOL) được đề cập ở trên với quyền truy cập IAM sau đây:
roles/cloudkms.cryptoKeyDecrypter để giải mã dữ liệu bằng khoá KMS.
objectViewer để đọc dữ liệu từ bộ chứa Cloud Storage.
roles/iam.workloadIdentityUser để kết nối tài khoản dịch vụ này với nhóm danh tính tải.

./setup_resources.sh

3. Tạo đơn vị công việc

Tạo tài khoản dịch vụ cho tải

Giờ đây, bạn sẽ tạo một tài khoản dịch vụ cho khối lượng công việc với các vai trò và quyền bắt buộc. Để thực hiện việc này, hãy chạy tập lệnh sau đây. Tập lệnh này sẽ tạo một tài khoản dịch vụ tải công việc cho Công ty A. VM chạy tải sẽ sử dụng tài khoản dịch vụ này.

Tài khoản dịch vụ của tải ($WORKLOAD_SERVICEACCOUNT) sẽ có các vai trò sau:

confidentialcomputing.workloadUser để lấy mã chứng thực
logging.logWriter để ghi nhật ký vào Cloud Logging.
objectViewer để đọc dữ liệu từ bộ chứa Cloud Storage $PRIMUS_INPUT_STORAGE_BUCKET.
objectUser để ghi kết quả của tải vào bộ chứa $PRIMUS_RESULT_STORAGE_BUCKET Cloud Storage.

./create_workload_service_account.sh

Tạo đơn vị công việc

Bước này liên quan đến việc tạo một hình ảnh Docker cho khối lượng công việc. Tải trong lớp học lập trình này là một ứng dụng MPC Node.js đơn giản, ký các giao dịch kỹ thuật số để chuyển tài sản bằng cách sử dụng các phần khoá riêng tư đã mã hoá. Đây là mã dự án của khối lượng công việc. Dự án khối lượng công việc bao gồm các tệp sau.

package.json: Tệp này chứa danh sách các gói nên dùng cho ứng dụng MPC của khối lượng công việc. Trong trường hợp này, chúng ta sẽ sử dụng các thư viện @google-cloud/kms, @google-cloud/storage, ethers và fast-crc32c. Đây là tệp package.json mà chúng ta sẽ dùng cho lớp học lập trình này.

index.js: Đây là một điểm truy cập của ứng dụng khối lượng công việc và chỉ định những lệnh cần chạy khi vùng chứa khối lượng công việc khởi động. Chúng tôi cũng đã đưa vào một giao dịch mẫu chưa ký mà thường do một ứng dụng không đáng tin cậy cung cấp, yêu cầu người dùng ký tên. Tệp index.js này cũng nhập các hàm từ mpc.js mà chúng ta sẽ tạo tiếp theo. Dưới đây là nội dung của tệp index.js và bạn cũng có thể tìm thấy nội dung này tại đây.

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: Đây là nơi diễn ra quá trình ký giao dịch. Thao tác này nhập các hàm từ kms-decrypt và credential-config mà chúng ta sẽ đề cập đến tiếp theo. Dưới đây là nội dung của tệp mpc.js và bạn cũng có thể tìm thấy tệp này tại đây.

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: Tệp này chứa mã để giải mã bằng các khoá được quản lý trong KMS. Dưới đây là nội dung của tệp kms-decrypt.js và bạn cũng có thể tìm thấy tệp này tại đây.

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: Tệp này lưu trữ các đường dẫn và thông tin chi tiết về nhóm danh tính tải cho hoạt động mạo danh tài khoản dịch vụ. Đây là tệp credential-config.js mà chúng ta sẽ dùng cho lớp học lập trình này.

Dockerfile: Cuối cùng, chúng ta sẽ tạo Dockerfile dùng để tạo hình ảnh Docker của tải trọng. xác định Dockerfile như được chỉ định tại đây.

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

Lưu ý: LABEL "tee.launch_policy.allow_cmd_override"="true" trong Dockerfile là chính sách khởi chạy do tác giả hình ảnh đặt. Thao tác này cho phép người vận hành ghi đè CMD khi thực thi khối lượng công việc. Theo mặc định, allow_cmd_override được đặt thành false. NHÃN "tee.launch_policy.allow_env_override" cho biết Confidential Space những biến môi trường mà người dùng hình ảnh có thể sử dụng .

Chạy tập lệnh sau đây để tạo một khối lượng công việc trong đó các bước sau đang được thực hiện:

Tạo Artifact Registry($PRIMUS_ARTIFACT_REPOSITORY) để lưu trữ hình ảnh Docker của tải.
Cập nhật mã tải với tên tài nguyên bắt buộc. Đây là mã tải được dùng cho lớp học lập trình này.
Tạo Dockerfile để tạo một hình ảnh Docker cho mã khối lượng công việc. Bạn có thể tìm thấy Dockerfile tại đây.
Tạo và xuất bản hình ảnh Docker vào Artifact Registry ($PRIMUS_ARTIFACT_REPOSITORY) được tạo ở bước trước.
Cấp cho $WORKLOAD_SERVICEACCOUNT quyền đọc đối với $PRIMUS_ARTIFACT_REPOSITORY. Điều này là cần thiết để vùng chứa khối lượng công việc kéo hình ảnh Docker khối lượng công việc từ Artifact Registry.

./create_workload.sh

Tạo nút Blockchain

Nút Ethereum Ganache

Trước khi uỷ quyền cho tải, chúng ta cần tạo phiên bản Ethereum Ganache. Giao dịch đã ký sẽ được gửi đến phiên bản Ganache này. Vui lòng ghi lại địa chỉ IP của phiên bản này. Sau khi chạy lệnh bên dưới, bạn có thể cần nhập y để bật 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. Uỷ quyền và chạy khối lượng công việc

Uỷ quyền cho khối lượng công việc

Trong bước này, chúng ta sẽ thiết lập nhà cung cấp nhóm danh tính tải trong nhóm danh tính tải ($PRIMUS_WORKLOAD_IDENTITY_POOL). Có các điều kiện thuộc tính được định cấu hình cho danh tính tải như minh hoạ bên dưới. Một trong các điều kiện là xác thực hình ảnh tải được kéo từ kho lưu trữ cấu phần phần mềm dự kiến.

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"

Chạy khối lượng công việc

Phần này giải thích cách chạy khối lượng công việc trên VM bảo mật. Để làm việc này, chúng ta sẽ truyền các đối số TEE bắt buộc bằng cách sử dụng cờ siêu dữ liệu. Ngoài ra, chúng ta sẽ đặt các biến môi trường cho vùng chứa tải bằng cờ "tee-env-*". Hình ảnh này có các biến sau:

NODE_URL: URL của nút Ethereum sẽ xử lý giao dịch đã ký.
RESULTS_BUCKET: Nhóm lưu trữ kết quả giao dịch mpc.
KEY_BUCKET: Nhóm lưu trữ các khoá được mã hoá mpc.
PRIMUS_PROJECT_NUMBER: Số dự án dùng cho tệp cấu hình thông tin đăng nhập.
PRIMUS_PROJECT_ID: Mã dự án dùng cho tệp cấu hình thông tin đăng nhập. Kết quả thực thi của khối lượng công việc sẽ được xuất bản lên $PRIMUS_RESULT_STORAGE_BUCKET.
PRIMUS_WORKLOAD_IDENTITY_POOL: Nhóm danh tính tải dùng để xác thực các yêu cầu.
PRIMUS_WIP_POROVIDER: Nhà cung cấp nhóm danh tính tải bao gồm các điều kiện thuộc tính để dùng xác thực mã thông báo do tải trình bày.
WORKLOAD_SERVICEACCOUNT: Tài khoản dịch vụ của khối lượng công việc.

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

Kiểm tra kết quả trên Cloud Storage

Bạn có thể xem biên nhận giao dịch trong Cloud Storage. Có thể mất vài phút để Confidential Space khởi động và kết quả xuất hiện. Bạn sẽ biết khi nào vùng chứa hoàn tất khi máy ảo ở trạng thái dừng.

Chuyển đến trang Cloud Storage Browser (Trình duyệt bộ nhớ đám mây).
Nhấp vào $PRIMUS_RESULT_STORAGE_BUCKET.
Nhấp vào tệp transaction_receipt.
Nhấp vào Tải xuống để tải xuống và xem phản hồi giao dịch.

Hoặc, bạn có thể chạy các lệnh sau để xem kết quả.

gcloud config set project $PRIMUS_PROJECT_ID

gsutil cat gs://$PRIMUS_RESULT_STORAGE_BUCKET/transaction_receipt

Lưu ý: Nếu không thấy kết quả, bạn có thể chuyển đến $WORKLOAD_VM trong trang Compute Engine Cloud Console rồi nhấp vào "Serial port 1 (console)" (Cổng nối tiếp 1 (bảng điều khiển)) để xem nhật ký.

Kiểm tra giao dịch trên chuỗi khối Ganache

Bạn cũng có thể xem giao dịch trong nhật ký blockchain.

Truy cập vào trang Cloud Compute Engine.
Nhấp vào biểu tượng ${ETHEREUM_NODE} VM.
Nhấp vào SSH để mở cửa sổ SSH trong trình duyệt.
Trong cửa sổ SSH, hãy nhập sudo docker ps để xem vùng chứa Ganache đang chạy.
Tìm mã vùng chứa cho trufflesuite/ganache:v7.7.3
Nhập sudo docker logs CONTAINER_ID thay thế CONTAINER_ID bằng mã nhận dạng cho trufflesuite/ganache:v7.7.3.
Xem nhật ký cho Ganache và xác nhận rằng có một giao dịch được liệt kê trong nhật ký.

5. Dọn dẹp

Đây là tập lệnh có thể dùng để dọn dẹp các tài nguyên mà chúng ta đã tạo trong lớp học lập trình này. Trong quá trình dọn dẹp này, các tài nguyên sau đây sẽ bị xoá:

Thùng lưu trữ đầu vào dùng để lưu trữ các phần khoá được mã hoá ($PRIMUS_INPUT_STORAGE_BUCKET).
Khoá mã hoá ($PRIMUS_KEY).
Tài khoản dịch vụ dùng để truy cập vào các tài nguyên được bảo vệ ($PRIMUS_SERVICEACCOUNT).
Nhóm Workload Identity ($PRIMUS_WORKLOAD_IDENTITY_POOL).
Tài khoản dịch vụ của khối lượng công việc ($WORKLOAD_SERVICEACCOUNT).
Các phiên bản điện toán của khối lượng công việc ($WORKLOAD_VM và $ETHEREUM_NODE).
Bộ chứa lưu trữ kết quả dùng để lưu trữ kết quả giao dịch ($PRIMUS_RESULT_STORAGE_BUCKET).
Sổ đăng ký cấu phần phần mềm dùng để lưu trữ hình ảnh tải ($PRIMUS_ARTIFACT_REPOSITORY).

./cleanup.sh

Nếu bạn đã khám phá xong, vui lòng cân nhắc việc xoá dự án.

Chuyển đến Bảng điều khiển Cloud Platform
Chọn dự án mà bạn muốn tắt, rồi nhấp vào "Xoá" ở trên cùng. Thao tác này sẽ lên lịch xoá dự án.

Tiếp theo là gì?

Hãy xem một số lớp học lập trình tương tự này...