Cara Melakukan Transaksi Aset Digital dengan Komputasi Banyak Pihak dan Confidential Space

Cara Melakukan Transaksi Aset Digital dengan Komputasi Banyak Pihak dan Confidential Space

Tentang codelab ini

subjectTerakhir diperbarui Jan 9, 2025
account_circleDitulis oleh Devon Yarbrough, Bertrand Portier, Chris Diya, Meetrajsinh Vala

1. Ringkasan

Sebelum kita memulai, meskipun tidak sepenuhnya diperlukan, pengetahuan tentang fitur dan konsep berikut akan sangat membantu dalam codelab ini.

4670cd5427aa39a6.png

Yang akan Anda pelajari

Lab ini menyediakan implementasi referensi untuk melakukan penandatanganan blockchain yang mematuhi MPC menggunakan Confidential Space. Untuk mengilustrasikan konsep tersebut, kita akan membahas skenario saat Perusahaan Primus ingin mentransfer aset digital ke Perusahaan Secundus. Dalam skenario ini, Perusahaan Primus menggunakan model yang mematuhi MPC, yang berarti bahwa alih-alih menggunakan kunci pribadi individual, mereka menggunakan bagian kunci terdistribusi. Bagian kunci ini dimiliki oleh beberapa pihak, dalam hal ini Alice dan Bob. Pendekatan ini memberikan beberapa manfaat kepada Perusahaan Primus, termasuk pengalaman pengguna yang disederhanakan, efisiensi operasional, dan kontrol atas kunci pribadi mereka.

Untuk menjelaskan aspek mendasar dari proses ini, kami akan menjelaskan detail penyiapan teknis dan memandu Anda melalui proses persetujuan dan penandatanganan yang memulai transfer aset digital dari Perusahaan Primus ke Perusahaan Secundus. Perhatikan bahwa Bob dan Alice, yang keduanya adalah karyawan Perusahaan Primus, harus menyetujui transaksi tersebut.

Meskipun implementasi referensi ini menunjukkan operasi tanda tangan, implementasi ini tidak mencakup semua aspek pengelolaan kunci MPC. Misalnya, kita tidak membahas pembuatan kunci. Selain itu, ada pendekatan alternatif dan pelengkap, seperti menggunakan layanan non-Google Cloud untuk membuat tanda tangan bersama atau meminta penanda tangan bersama membuat tanda tangan blockchain di lingkungan mereka sendiri, yang merupakan arsitektur yang lebih terdesentralisasi. Kami harap lab ini menginspirasi berbagai pendekatan terhadap MPC di Google Cloud.

Anda akan menggunakan workload sederhana yang menandatangani transaksi Ethereum di Confidential Space menggunakan materi kunci penanda tangan bersama. Penandatanganan transaksi Ethereum adalah proses yang memungkinkan pengguna memberikan otorisasi pada transaksi di blockchain Ethereum. Untuk mengirim transaksi Ethereum, Anda harus menandatanganinya dengan kunci pribadi. Hal ini membuktikan bahwa Anda adalah pemilik akun dan mengizinkan transaksi. Proses penandatanganan adalah sebagai berikut:

  1. Pengirim membuat objek transaksi yang menentukan alamat penerima, jumlah ETH yang akan dikirim, dan data relevan lainnya.
  2. Kunci pribadi pengirim digunakan untuk melakukan hashing pada data transaksi.
  3. Hash kemudian ditandatangani dengan kunci pribadi.
  4. Tanda tangan dilampirkan ke objek transaksi.
  5. Transaksi disiarkan ke jaringan Ethereum.

Saat node di jaringan menerima transaksi, node akan memverifikasi tanda tangan untuk memastikan bahwa transaksi ditandatangani oleh pemilik akun. Jika tanda tangan valid, node akan menambahkan transaksi ke blockchain.

Untuk memulai, Anda akan mengonfigurasi resource Cloud yang diperlukan. Kemudian, Anda akan menjalankan workload di Confidential Space. Codelab ini akan memandu Anda melalui langkah-langkah tingkat tinggi berikut:

  • Cara mengonfigurasi resource Cloud yang diperlukan untuk menjalankan Confidential Space
  • Cara memberikan otorisasi akses ke resource yang dilindungi berdasarkan atribut:
  • Apa: penampung beban kerja
  • Di mana: lingkungan Confidential Space (image Confidential Space di Confidential VM)
  • Siapa: akun yang menjalankan beban kerja
  • Cara menjalankan beban kerja di Confidential VM yang menjalankan image VM Confidential Space

API yang diperlukan

Anda harus mengaktifkan API berikut di project yang ditentukan agar dapat menyelesaikan panduan ini.

Nama API

Judul 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. Menyiapkan Resource Cloud

Sebelum memulai

  • Clone repositori ini menggunakan perintah di bawah untuk mendapatkan skrip yang diperlukan yang digunakan sebagai bagian dari codelab ini.
git clone https://github.com/GoogleCloudPlatform/confidential-space.git
  • Ubah direktori untuk codelab ini.
cd confidential-space/codelabs/digital_asset_transaction_codelab/scripts
  • Pastikan Anda telah menetapkan variabel lingkungan project yang diperlukan seperti yang ditunjukkan di bawah. Untuk informasi selengkapnya tentang cara menyiapkan project GCP, lihat codelab ini. Anda dapat membaca artikel ini untuk mendapatkan detail tentang cara mengambil project ID dan perbedaannya dengan nama project dan nomor project. .
export PRIMUS_PROJECT_ID=<GCP project id>
  • Aktifkan Penagihan untuk project Anda.
  • Aktifkan Confidential Computing API dan ikuti API untuk kedua project.
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
  • Untuk menetapkan variabel untuk nama resource, Anda dapat menggunakan perintah berikut. Perhatikan bahwa tindakan ini akan mengganti nama resource khusus untuk project GCP Anda bagi perusahaan A, misalnya, export PRIMUS_INPUT_STORAGE_BUCKET='primus-input-bucket'
  • Variabel berikut dapat ditetapkan untuk project GCP Anda di Perusahaan A:

$PRIMUS_INPUT_STORAGE_BUCKET

Bucket yang menyimpan kunci terenkripsi.

$PRIMUS_RESULT_STORAGE_BUCKET

Bucket yang menyimpan hasil transaksi MPC.

$PRIMUS_KEY

Kunci KMS yang digunakan untuk mengenkripsi data yang disimpan di $PRIMUS_INPUT_STORAGE_BUCKET untuk Primus Bank.

$PRIMUS_KEYRING

Keyring KMS yang akan digunakan untuk membuat kunci enkripsi $PRIMUS_KEY untuk Primus Bank.

$PRIMUS_WIP_PROVIDER

Penyedia Kumpulan Workload Identity yang menyertakan kondisi atribut yang akan digunakan untuk token yang ditandatangani oleh layanan workload MPC.

$PRIMUS_SERVICEACCOUNT

Akun layanan yang digunakan $PRIMUS_WORKLOAD_IDENTITY_POOL untuk mengakses resource yang dilindungi. Akun layanan ini akan memiliki izin untuk melihat kunci terenkripsi yang disimpan di bucket $PRIMUS_INPUT_STORAGE_BUCKET.

$PRIMUS_ARTIFACT_REPOSITORY

Repositori artefak untuk menyimpan image container beban kerja.

$WORKLOAD_SERVICEACCOUNT

Akun layanan yang memiliki izin untuk mengakses Confidential VM yang menjalankan workload.

$WORKLOAD_CONTAINER

Container Docker yang menjalankan beban kerja.

$WORKLOAD_IMAGE_NAME

Nama image container beban kerja.

$WORKLOAD_IMAGE_TAG

Tag image container workload.

  • Jalankan skrip berikut untuk menetapkan nama variabel yang tersisa ke nilai berdasarkan project ID Anda untuk nama resource.
source config_env.sh

Menyiapkan resource Cloud

Sebagai bagian dari langkah ini, Anda akan menyiapkan resource cloud yang diperlukan untuk komputasi multipihak. Untuk lab ini, Anda akan menggunakan kunci pribadi berikut: 0000000000000000000000000000000000000000000000000000000000000001

Dalam lingkungan produksi, Anda akan membuat kunci pribadi Anda sendiri. Namun, untuk tujuan lab ini, kita akan membagi kunci pribadi ini menjadi dua bagian dan mengenkripsi setiap bagian. Dalam skenario produksi, kunci tidak boleh disimpan dalam file teks biasa. Sebagai gantinya, kunci pribadi dapat dibuat di luar Google Cloud (atau dilewati sepenuhnya dan diganti dengan pembuatan shard kunci MPC kustom), lalu dienkripsi sehingga tidak ada yang memiliki akses ke kunci pribadi atau bagian kunci. Untuk tujuan lab ini, kita akan menggunakan Gcloud CLI.

Jalankan skrip berikut untuk menyiapkan resource cloud yang diperlukan. Sebagai bagian dari langkah-langkah ini, resource yang disebutkan di bawah akan dibuat:

  • Bucket Cloud Storage ($PRIMUS_INPUT_STORAGE_BUCKET) untuk menyimpan bagian kunci pribadi terenkripsi.
  • Bucket Cloud Storage ($PRIMUS_RESULT_STORAGE_BUCKET) untuk menyimpan hasil transaksi aset digital.
  • Kunci enkripsi ($PRIMUS_KEY) dan ring kunci ($PRIMUS_KEYRING) di KMS untuk mengenkripsi bagian kunci pribadi.
  • Workload identity pool ($PRIMUS_WORKLOAD_IDENTITY_POOL) untuk memvalidasi klaim berdasarkan kondisi atribut yang dikonfigurasi di bawah penyedianya.
  • Akun layanan ($PRIMUS_SERVICEACCOUNT) yang dilampirkan ke kumpulan identitas beban kerja ($PRIMUS_WORKLOAD_IDENTITY_POOL) yang disebutkan di atas dengan akses IAM berikut:
  • roles/cloudkms.cryptoKeyDecrypter untuk mendekripsi data menggunakan kunci KMS.
  • objectViewer untuk membaca data dari bucket Cloud Storage.
  • roles/iam.workloadIdentityUser untuk menghubungkan akun layanan ini ke workload identity pool.
./setup_resources.sh

3. Membuat Beban Kerja

Membuat akun layanan workload

Sekarang Anda akan membuat akun layanan untuk beban kerja dengan peran dan izin yang diperlukan. Untuk melakukannya, jalankan skrip berikut, yang akan membuat akun layanan beban kerja untuk Perusahaan A. Akun layanan ini akan digunakan oleh VM yang menjalankan beban kerja.

Akun layanan beban kerja ($WORKLOAD_SERVICEACCOUNT) akan memiliki peran berikut:

  • confidentialcomputing.workloadUser untuk mendapatkan token pengesahan
  • logging.logWriter untuk menulis log ke Cloud Logging.
  • objectViewer untuk membaca data dari bucket Cloud Storage $PRIMUS_INPUT_STORAGE_BUCKET.
  • objectUser untuk menulis hasil beban kerja ke bucket Cloud Storage $PRIMUS_RESULT_STORAGE_BUCKET.
./create_workload_service_account.sh

Membuat beban kerja

Langkah ini melibatkan pembuatan image Docker beban kerja. Beban kerja dalam codelab ini adalah aplikasi MPC Node.js sederhana yang menandatangani transaksi digital untuk mentransfer aset menggunakan bagian kunci pribadi terenkripsi. Di sini adalah kode project beban kerja. Project beban kerja mencakup file berikut.

package.json: File ini berisi daftar paket yang harus digunakan untuk aplikasi MPC beban kerja. Dalam hal ini, kita menggunakan library @google-cloud/kms, @google-cloud/storage, ethers, dan fast-crc32c. Di sini adalah file package.json yang akan kita gunakan untuk codelab ini.

index.js: Ini adalah titik entri aplikasi beban kerja dan menentukan perintah yang harus dijalankan saat penampung beban kerja dimulai. Kami juga menyertakan contoh transaksi tanpa tanda tangan yang biasanya disediakan oleh aplikasi tidak tepercaya yang meminta tanda tangan pengguna. File index.js ini juga mengimpor fungsi dari mpc.js, yang akan kita buat berikutnya. Berikut adalah konten file index.js dan Anda juga dapat menemukannya di sini.

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: Di sinilah penandatanganan transaksi dilakukan. Fungsi ini mengimpor fungsi dari kms-decrypt dan credential-config, yang akan kita bahas selanjutnya. Berikut adalah konten file mpc.js dan Anda juga dapat menemukannya di sini.

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: File ini berisi kode untuk dekripsi menggunakan kunci yang dikelola di KMS. Berikut adalah konten file kms-decrypt.js dan Anda juga dapat menemukannya di sini.

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: File ini menyimpan jalur dan detail workload identity pool untuk peniruan akun layanan. Di sini adalah file credential-config.js yang akan kita gunakan untuk codelab ini.

Dockerfile: Terakhir, kita akan membuat Dockerfile yang akan digunakan untuk mem-build image docker beban kerja. menentukan Dockerfile seperti yang ditentukan di sini.

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

Catatan: LABEL "tee.launch_policy.allow_cmd_override"="true" di Dockerfile adalah kebijakan peluncuran yang ditetapkan oleh penulis image. Hal ini memungkinkan operator mengganti CMD saat menjalankan beban kerja. Secara default, allow_cmd_override ditetapkan ke salah. LABEL "tee.launch_policy.allow_env_override" memberi tahu Confidential Space variabel lingkungan yang dapat digunakan pengguna image .

Jalankan skrip berikut untuk membuat workload tempat langkah-langkah berikut dilakukan:

  • Buat Artifact Registry($PRIMUS_ARTIFACT_REPOSITORY) untuk menyimpan image docker beban kerja.
  • Perbarui kode beban kerja dengan nama resource yang diperlukan. Di sini adalah kode beban kerja yang digunakan untuk codelab ini.
  • Buat Dockerfile untuk mem-build image Docker dari kode beban kerja. Anda dapat menemukan Dockerfile di sini.
  • Build dan publikasikan image Docker ke Artifact Registry ($PRIMUS_ARTIFACT_REPOSITORY) yang dibuat pada langkah sebelumnya.
  • Berikan izin baca $WORKLOAD_SERVICEACCOUNT untuk $PRIMUS_ARTIFACT_REPOSITORY. Hal ini diperlukan agar penampung beban kerja dapat mengambil image docker beban kerja dari Artifact Registry.
./create_workload.sh

Membuat Node Blockchain

Node Ethereum Ganache

Sebelum memberikan otorisasi pada workload, kita perlu membuat instance Ethereum Ganache. Transaksi yang ditandatangani akan dikirim ke instance Ganache ini. Catat alamat IP instance ini. Setelah menjalankan perintah di bawah, Anda mungkin perlu memasukkan y untuk mengaktifkan 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. Memberi Otorisasi dan Menjalankan Workload

Memberi Otorisasi pada Beban Kerja

Sebagai bagian dari langkah ini, kita akan menyiapkan penyedia workload identity pool di bagian workload identity pool ($PRIMUS_WORKLOAD_IDENTITY_POOL). Ada kondisi atribut yang dikonfigurasi untuk workload identity seperti yang ditunjukkan di bawah. Salah satu kondisinya adalah memvalidasi image workload yang diambil dari repositori artefak yang diharapkan.

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"

Menjalankan Beban Kerja

Bagian ini menjelaskan cara menjalankan workload di Confidential VM. Untuk melakukannya, kita akan meneruskan argumen TEE yang diperlukan menggunakan tanda metadata. Selain itu, kita akan menetapkan variabel lingkungan untuk penampung beban kerja menggunakan flag "tee-env-*". Gambar memiliki variabel berikut:

  • NODE_URL: URL node Ethereum yang akan memproses transaksi yang ditandatangani.
  • RESULTS_BUCKET: Bucket yang menyimpan hasil transaksi mpc.
  • KEY_BUCKET: Bucket yang menyimpan kunci terenkripsi mpc.
  • PRIMUS_PROJECT_NUMBER: Nomor project yang digunakan untuk file konfigurasi kredensial.
  • PRIMUS_PROJECT_ID: Project ID yang digunakan untuk file konfigurasi kredensial. Hasil eksekusi beban kerja akan dipublikasikan ke $PRIMUS_RESULT_STORAGE_BUCKET.
  • PRIMUS_WORKLOAD_IDENTITY_POOL: Workload identity pool yang digunakan untuk memvalidasi klaim.
  • PRIMUS_WIP_POROVIDER: Penyedia workload identity pool yang menyertakan kondisi atribut yang akan digunakan untuk memvalidasi token yang ditampilkan oleh workload.
  • WORKLOAD_SERVICEACCOUNT: Akun layanan workload.
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}"

Memeriksa Hasil Cloud Storage

Anda dapat melihat tanda terima transaksi di Cloud Storage. Mungkin perlu waktu beberapa menit agar Ruang Rahasia melakukan booting dan hasil muncul. Anda akan mengetahui bahwa penampung sudah selesai saat VM dalam status dihentikan.

  1. Buka halaman Browser Cloud Storage.
  2. Klik $PRIMUS_RESULT_STORAGE_BUCKET.
  3. Klik file transaction_receipt.
  4. Klik Download untuk mendownload dan melihat respons transaksi.

Atau, Anda dapat menjalankan perintah berikut untuk melihat hasilnya.

gcloud config set project $PRIMUS_PROJECT_ID
gsutil cat gs://$PRIMUS_RESULT_STORAGE_BUCKET/transaction_receipt

Catatan: Jika hasil tidak muncul, Anda dapat membuka $WORKLOAD_VM di halaman Konsol Cloud Compute Engine dan mengklik "Serial port 1 (console)" untuk melihat log.

Memeriksa Transaksi Blockchain Ganache

Anda juga dapat melihat transaksi di log blockchain.

  1. Buka halaman Cloud Compute Engine.
  2. Klik ${ETHEREUM_NODE} VM.
  3. Klik SSH untuk membuka jendela SSH-in-browser.
  4. Di jendela SSH, masukkan sudo docker ps untuk melihat penampung Ganache yang sedang berjalan.
  5. Menemukan ID penampung untuk trufflesuite/ganache:v7.7.3
  6. Masukkan sudo docker logs CONTAINER_ID yang mengganti CONTAINER_ID dengan ID untuk trufflesuite/ganache:v7.7.3.
  7. Lihat log untuk Ganache dan konfirmasi bahwa ada transaksi yang tercantum dalam log.

5. Pembersihan

Berikut adalah skrip yang dapat digunakan untuk membersihkan resource yang telah kita buat sebagai bagian dari codelab ini. Sebagai bagian dari pembersihan ini, resource berikut akan dihapus:

  • Bucket penyimpanan input yang digunakan untuk menyimpan bagian kunci terenkripsi ($PRIMUS_INPUT_STORAGE_BUCKET).
  • Kunci enkripsi ($PRIMUS_KEY).
  • Akun layanan yang digunakan untuk mengakses resource yang dilindungi ($PRIMUS_SERVICEACCOUNT).
  • Workload identity pool ($PRIMUS_WORKLOAD_IDENTITY_POOL).
  • Akun layanan beban kerja ($WORKLOAD_SERVICEACCOUNT).
  • Instance Compute Beban Kerja ($WORKLOAD_VM & $ETHEREUM_NODE).
  • Bucket penyimpanan hasil yang digunakan untuk menyimpan hasil transaksi.($PRIMUS_RESULT_STORAGE_BUCKET).
  • Artifact Registry yang digunakan untuk menyimpan image beban kerja ($PRIMUS_ARTIFACT_REPOSITORY).
./cleanup.sh

Jika Anda sudah selesai menjelajahi, pertimbangkan untuk menghapus project Anda.

  • Buka Cloud Platform Console
  • Pilih project yang ingin dinonaktifkan, lalu klik "Hapus" di bagian atas. Tindakan ini akan menjadwalkan penghapusan project.

Apa selanjutnya?

Lihat beberapa codelab serupa ini...

Bacaan lebih lanjut