Эта страница переведена с помощью Cloud Translation API.

Как осуществлять транзакции с цифровыми активами с использованием многосторонних вычислений и конфиденциального пространства

1. Обзор

Прежде чем начать, хотя это и не является абсолютно необходимым, знание следующих функций и концепций окажется полезным в этом практическом занятии.

Облачное хранилище, а именно, хранилища типа «корзины» (buckets).
Compute Engine, а именно конфиденциальная виртуальная машина.
Служебные счета
Контейнеры и удалённые репозитории
Условия федерации идентификаторов рабочих нагрузок и атрибутов

Что вы узнаете

В этой лабораторной работе представлена эталонная реализация для выполнения MPC-совместимой подписи блокчейна с использованием Confidential Space. Для иллюстрации концепций мы рассмотрим сценарий, в котором компания Primus хочет передать цифровые активы компании Secundus. В этом сценарии компания Primus использует MPC-совместимую модель, что означает, что вместо использования отдельных закрытых ключей она использует распределенные доли ключей. Эти доли ключей находятся у нескольких сторон, в данном случае у Алисы и Боба. Такой подход предоставляет компании Primus ряд преимуществ, включая упрощенный пользовательский интерфейс, операционную эффективность и контроль над своими закрытыми ключами.

Чтобы объяснить основные аспекты этого процесса, мы подробно опишем техническую настройку и проведем вас через процесс утверждения и подписания, который инициирует передачу цифровых активов от компании Primus компании Secundus. Обратите внимание, что Боб и Алиса, оба являющиеся сотрудниками компании Primus, должны утвердить транзакцию.

Хотя данная эталонная реализация демонстрирует операции подписи, она не охватывает все аспекты управления ключами MPC. Например, мы не обсуждаем генерацию ключей. Кроме того, существуют альтернативные и дополнительные подходы, такие как использование сторонних сервисов Google Cloud для генерации соподписей или создание соподписей блокчейна участниками в собственных средах, что представляет собой более децентрализованную архитектуру. Мы надеемся, что эта лабораторная работа вдохновит на разработку различных подходов к MPC в Google Cloud.

Вам предстоит работать с простым заданием, которое подписывает транзакцию Ethereum в конфиденциальном пространстве, используя ключи соподписанта. Подписание транзакций Ethereum — это процесс, посредством которого пользователь может авторизовать транзакцию в блокчейне Ethereum. Чтобы отправить транзакцию Ethereum, вам необходимо подписать её своим закрытым ключом. Это доказывает, что вы являетесь владельцем учетной записи и авторизуете транзакцию. Процесс подписания выглядит следующим образом:

Отправитель создает объект транзакции, в котором указываются адрес получателя, сумма отправляемых ETH и любые другие соответствующие данные.
Для хеширования данных транзакции используется закрытый ключ отправителя.
Затем хеш подписывается закрытым ключом.
Подпись прикрепляется к объекту транзакции.
Транзакция передается в сеть Ethereum.

Когда узел в сети получает транзакцию, он проверяет подпись, чтобы убедиться, что она подписана владельцем учетной записи. Если подпись действительна, узел добавляет транзакцию в блокчейн.

Для начала вам потребуется настроить необходимые облачные ресурсы. Затем вы запустите рабочую нагрузку в конфиденциальном пространстве. Данный практический пример проведет вас через следующие основные шаги:

Как настроить необходимые облачные ресурсы для работы Confidential Space
Как разрешить доступ к защищенным ресурсам на основе следующих атрибутов:
Что : контейнер рабочей нагрузки
Где : среда «Конфиденциальное пространство» (образ «Конфиденциальное пространство» на виртуальной машине «Конфиденциальное пространство»)
Кто : учетная запись, с которой выполняется рабочая нагрузка.
Как запустить рабочую нагрузку на конфиденциальной виртуальной машине, работающей под управлением образа Confidential Space VM.

Необходимые API

Для выполнения данного руководства необходимо включить следующие API в указанных проектах.

Название API	Название API
cloudkms.googleapis.com	Облачные KMS
compute.googleapis.com	Вычислительный движок
конфиденциальные вычисления.googleapis.com	Конфиденциальные вычисления
iamcredentials.googleapis.com	Я
artifactregistry.googleapis.com	Реестр артефактов

2. Настройка облачных ресурсов

Прежде чем начать

Клонируйте этот репозиторий, используя приведенную ниже команду, чтобы получить необходимые скрипты, используемые в рамках этого практического занятия.

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>

Включите выставление счетов для ваших проектов.
Включите 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 для компании A, например, export PRIMUS_INPUT_STORAGE_BUCKET='primus-input-bucket'
Для вашего проекта GCP в компании A можно установить следующие переменные:

$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

Настройка облачных ресурсов

На этом этапе вы настроите облачные ресурсы, необходимые для многосторонних вычислений. Для этой лабораторной работы вы будете использовать следующий закрытый ключ: 0000000000000000000000000000000000000000000000000000000000000001

В производственной среде вы будете генерировать собственный закрытый ключ. Однако для целей этой лабораторной работы мы разделим этот закрытый ключ на две части и зашифруем каждую из них. В производственной среде ключи никогда не следует хранить в файлах в открытом виде. Вместо этого закрытый ключ можно сгенерировать вне Google Cloud (или вообще пропустить этот шаг и заменить созданием пользовательского сегмента ключа MPC), а затем зашифровать, чтобы никто не имел доступа к закрытому ключу или его частям. Для целей этой лабораторной работы мы будем использовать CLI Gcloud.

Запустите следующий скрипт для настройки необходимых облачных ресурсов. В ходе этих шагов будут созданы следующие ресурсы:

Сегмент облачного хранилища ( $PRIMUS_INPUT_STORAGE_BUCKET ) для хранения зашифрованных фрагментов закрытых ключей.
Сегмент облачного хранилища ( $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. Создать рабочую нагрузку

Создать учетную запись службы рабочей нагрузки

Теперь вам нужно создать учетную запись службы для рабочей нагрузки с необходимыми ролями и разрешениями. Для этого запустите следующий скрипт , который создаст учетную запись службы рабочей нагрузки для компании A. Эта учетная запись службы будет использоваться виртуальной машиной, на которой выполняется рабочая нагрузка.

Учетная запись службы рабочей нагрузки ( $WORKLOAD_SERVICEACCOUNT ) будет обладать следующими ролями:

confidentialcomputing.workloadUser для получения токена подтверждения
logging.logWriter для записи логов в Cloud Logging.
objectViewer для чтения данных из сегмента облачного хранилища $PRIMUS_INPUT_STORAGE_BUCKET .
objectUser , который записывает результаты рабочей нагрузки в сегмент облачного хранилища $PRIMUS_RESULT_STORAGE_BUCKET .

./create_workload_service_account.sh

Создать рабочую нагрузку

Этот шаг включает создание образа Docker для рабочей нагрузки. В данном практическом задании используется простое приложение Node.js MPC, которое подписывает цифровые транзакции для передачи активов с использованием зашифрованных закрытых ключей. Вот код проекта рабочей нагрузки. Проект рабочей нагрузки включает следующие файлы.

package.json: Этот файл содержит список пакетов, которые следует использовать для приложения MPC, работающего с рабочей нагрузкой. В данном случае мы используем библиотеки @google-cloud/kms, @google-cloud/storage, ethers и fast-crc32c. Вот файл package.json, который мы будем использовать для этой практической работы.

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 decryptSymmetri>c = 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, который мы будем использовать в этом практическом задании.

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

Примечание: Метка "tee.launch_policy.allow_cmd_override"="true" в Dockerfile — это политика запуска, установленная автором образа. Она позволяет оператору переопределять CMD при выполнении рабочей нагрузки. По умолчанию allow_cmd_override установлено в false. Метка "tee.launch_policy.allow_env_override" сообщает Confidential Space, какие переменные среды могут использовать пользователи образа.

Запустите следующий скрипт , чтобы создать рабочую нагрузку, в которой выполняются следующие шаги:

Создайте реестр артефактов ( $PRIMUS_ARTIFACT_REPOSITORY ) для хранения образа Docker рабочей нагрузки.
Обновите код рабочей нагрузки, указав необходимые имена ресурсов. Вот код рабочей нагрузки, использованный в этом практическом задании.
Создайте Dockerfile для сборки образа Docker с кодом рабочей нагрузки. Dockerfile можно найти здесь .
Создайте и опубликуйте образ Docker в реестре артефактов ( $PRIMUS_ARTIFACT_REPOSITORY ), созданном на предыдущем шаге.
Предоставьте учетной записи $WORKLOAD_SERVICEACCOUNT права на чтение для $PRIMUS_ARTIFACT_REPOSITORY . Это необходимо для того, чтобы контейнер рабочей нагрузки мог загрузить образ Docker рабочей нагрузки из реестра артефактов.

./create_workload.sh

Создайте узел блокчейна.

Узел 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'" \
 --attr&&ibute-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/$PRIMU&&S_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. Загрузка Confidential Space и отображение результатов могут занять несколько минут. Вы поймете, что контейнер завершен, когда виртуальная машина перейдет в состояние остановки.

Перейдите на страницу браузера облачного хранилища .
Нажмите на $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 и щелкнуть «Последовательный порт 1 (консоль)», чтобы просмотреть журналы.

Проверьте транзакцию в блокчейне Ganache.

Вы также можете просмотреть транзакцию в журнале блокчейна.

Перейдите на страницу Cloud Compute Engine .
Щёлкните по VM ${ETHEREUM_NODE} .
Нажмите 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. Уборка

Вот скрипт, который можно использовать для очистки ресурсов, созданных нами в рамках этого практического задания. В ходе этой очистки будут удалены следующие ресурсы:

Входной сегмент хранилища, используемый для хранения зашифрованных частей ключей ( $PRIMUS_INPUT_STORAGE_BUCKET) .
Ключ шифрования ( $PRIMUS_KEY ).
Учетная запись службы, используемая для доступа к защищенным ресурсам ( $PRIMUS_SERVICEACCOUNT ).
Пул идентификаторов рабочих нагрузок ( $PRIMUS_WORKLOAD_IDENTITY_POOL ).
Учетная запись службы рабочей нагрузки ( $WORKLOAD_SERVICEACCOUNT ).
Экземпляры вычислительных ресурсов рабочей нагрузки ( $WORKLOAD_VM и $ETHEREUM_NODE ).
Сегмент хранения результатов используется для сохранения результатов транзакции ( $PRIMUS_RESULT_STORAGE_BUCKET ).
Реестр артефактов, используемый для хранения образа рабочей нагрузки ( $PRIMUS_ARTIFACT_REPOSITORY ).

./cleanup.sh

Если вы закончили изучение вопроса, пожалуйста, рассмотрите возможность удаления вашего проекта.

Перейдите в консоль облачной платформы.
Выберите проект, который хотите закрыть, затем нажмите кнопку «Удалить» вверху. Это запланирует удаление проекта.

Что дальше?

Посмотрите похожие обучающие материалы по программированию...