Como fazer transações de ativos digitais com computação de várias partes e o Confidential Space

1. Visão geral

Antes de começar, embora não seja totalmente necessário, um conhecimento prático dos seguintes recursos e conceitos será útil neste codelab.

• Cloud Storage, especificamente buckets
• Compute Engine, especificamente VM confidencial
• Contas de serviço
• Contêineres e repositórios remotos
• Federação de identidade da carga de trabalho e condições de atributo

O que você vai aprender

Este laboratório oferece uma implementação de referência para realizar a assinatura de blockchain compatível com MPC usando o Confidential Space. Para ilustrar os conceitos, vamos analisar um cenário em que a empresa Primus quer transferir recursos digitais para a empresa Secundus. Nesse cenário, a empresa Primus usa um modelo compatível com MPC, o que significa que, em vez de usar chaves privadas individuais, ela usa compartilhamentos de chaves distribuídas. Essas partes principais são mantidas por várias partes, neste caso, Alice e Beto. Essa abordagem oferece vários benefícios à Empresa Primus, incluindo experiência do usuário simplificada, eficiência operacional e controle sobre as chaves privadas.

Para explicar os aspectos fundamentais desse processo, vamos detalhar a configuração técnica e orientar você pelo processo de aprovação e assinatura que inicia a transferência de recursos digitais da Empresa Primus para a Empresa Secundus. O Beto e a Alice, que são funcionários da empresa Primus, precisam aprovar a transação.

Embora essa implementação de referência demonstre operações de assinatura, ela não aborda todos os aspectos do gerenciamento de chaves de MPC. Por exemplo, não discutimos a geração de chaves. Além disso, há abordagens alternativas e complementares, como usar serviços que não são do Google Cloud para gerar coassinaturas ou fazer com que os coassinantes criem assinaturas de blockchain nos próprios ambientes, o que é uma arquitetura mais descentralizada. Esperamos que este laboratório inspire diferentes abordagens para a MPC no Google Cloud.

Você vai trabalhar com uma carga de trabalho simples que assina uma transação do Ethereum no Confidential Space usando materiais de chaves de coassinante. A assinatura de transações do Ethereum é um processo pelo qual um usuário pode autorizar uma transação no blockchain do Ethereum. Para enviar uma transação do Ethereum, é necessário assiná-la com sua chave privada. Isso prova que você é o proprietário da conta e autoriza a transação. O processo de assinatura é o seguinte:

1. O remetente cria um objeto de transação que especifica o endereço do destinatário, a quantidade de ETH a ser enviada e outros dados relevantes.
2. A chave privada do remetente é usada para fazer hash dos dados da transação.
3. Em seguida, o hash é assinado com a chave privada.
4. A assinatura é anexada ao objeto de transação.
5. A transação é transmitida para a rede Ethereum.

Quando um nó na rede recebe uma transação, ele verifica a assinatura para garantir que ela foi feita pelo proprietário da conta. Se a assinatura for válida, o nó vai adicionar a transação ao blockchain.

Para começar, configure os recursos necessários do Cloud. Em seguida, você vai executar a carga de trabalho no Confidential Space. Este codelab vai orientar você pelas seguintes etapas gerais:

• Como configurar os recursos do Cloud necessários para executar o Confidential Space
• Como autorizar o acesso a recursos protegidos com base nos atributos de:
• O quê: o contêiner da carga de trabalho
• Onde: o ambiente do Confidential Space (a imagem do Confidential Space na VM confidencial)
• Quem: a conta que está executando a carga de trabalho
• Como executar a carga de trabalho em uma VM confidencial com a imagem da VM do Confidential Space

APIs necessárias

Você precisa ativar as seguintes APIs nos projetos especificados para concluir este guia.

Nome da API	Título da API
cloudkms.googleapis.com	Cloud KMS
compute.googleapis.com	Compute Engine
confidentialcomputing.googleapis.com	Computação confidencial
iamcredentials.googleapis.com	IAM
artifactregistry.googleapis.com	Artifact Registry

2. Configurar recursos do Cloud

Antes de começar

• Clone este repositório usando o comando abaixo para receber os scripts necessários que são usados como parte deste codelab.

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

• Mude o diretório deste codelab.

cd confidential-space/codelabs/digital_asset_transaction_codelab/scripts

• Verifique se você definiu as variáveis de ambiente necessárias do projeto, conforme mostrado abaixo. Para mais informações sobre como configurar um projeto do GCP, consulte este codelab. Consulte este link para saber como recuperar o ID do projeto e a diferença entre ele, o nome e o número do projeto. .

export PRIMUS_PROJECT_ID=<GCP project id>

• Ative o faturamento dos projetos.
• Ative a API Confidential Computing e as seguintes APIs nos dois projetos.

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

• Para definir as variáveis dos nomes de recursos, use o comando a seguir. Isso vai substituir os nomes de recursos específicos do seu projeto do GCP para a empresa A, por exemplo, export PRIMUS_INPUT_STORAGE_BUCKET='primus-input-bucket'
• As seguintes variáveis podem ser definidas para seu projeto do GCP na Empresa A:

$PRIMUS_INPUT_STORAGE_BUCKET	O bucket que armazena as chaves criptografadas.
$PRIMUS_RESULT_STORAGE_BUCKET	O bucket que armazena o resultado da transação de MPC.
$PRIMUS_KEY	A chave do KMS usada para criptografar os dados armazenados em $PRIMUS_INPUT_STORAGE_BUCKET para o Primus Bank.
$PRIMUS_KEYRING	O keyring do KMS que será usado para criar a chave de criptografia $PRIMUS_KEY para o Primus Bank.
$PRIMUS_WIP_PROVIDER	O provedor de pool de identidades da carga de trabalho que inclui a condição de atributo a ser usada para tokens assinados pelo serviço de carga de trabalho da MPC.
$PRIMUS_SERVICEACCOUNT	A conta de serviço que $PRIMUS_WORKLOAD_IDENTITY_POOL usa para acessar os recursos protegidos. Essa conta de serviço terá permissão para visualizar as chaves criptografadas armazenadas no bucket $PRIMUS_INPUT_STORAGE_BUCKET.
$PRIMUS_ARTIFACT_REPOSITORY	O repositório de artefatos para armazenar a imagem do contêiner da carga de trabalho.
$WORKLOAD_SERVICEACCOUNT	A conta de serviço com permissão para acessar a VM confidencial que executa a carga de trabalho.
$WORKLOAD_CONTAINER	O contêiner do Docker que executa a carga de trabalho.
$WORKLOAD_IMAGE_NAME	O nome da imagem do contêiner da carga de trabalho.
$WORKLOAD_IMAGE_TAG	A tag da imagem do contêiner da carga de trabalho.

• Execute o script a seguir para definir os nomes de variáveis restantes como valores com base no ID do projeto para nomes de recursos.

source config_env.sh

Configurar recursos do Cloud

Como parte dessa etapa, você vai configurar os recursos de nuvem necessários para a computação multipartidária. Neste laboratório, você vai usar a seguinte chave privada: 0000000000000000000000000000000000000000000000000000000000000001

Em um ambiente de produção, você vai gerar sua própria chave privada. No entanto, para este laboratório, vamos dividir essa chave privada em duas partes e criptografar cada uma delas. Em um cenário de produção, as chaves nunca devem ser armazenadas em arquivos de texto simples. Em vez disso, a chave privada pode ser gerada fora do Google Cloud (ou ignorada completamente e substituída pela criação personalizada de fragmentos de chave MPC) e criptografada para que ninguém tenha acesso à chave privada ou aos compartilhamentos de chaves. Para este laboratório, vamos usar a CLI gcloud.

Execute o script a seguir para configurar os recursos de nuvem necessários. Como parte dessas etapas, os recursos mencionados abaixo serão criados:

• Um bucket do Cloud Storage ($PRIMUS_INPUT_STORAGE_BUCKET) para armazenar as partes da chave privada criptografadas.
• Um bucket do Cloud Storage ($PRIMUS_RESULT_STORAGE_BUCKET) para armazenar o resultado da transação de recurso digital.
• Uma chave de criptografia ($PRIMUS_KEY) e um keyring ($PRIMUS_KEYRING) no KMS para criptografar os compartilhamentos de chaves privadas.
• Um pool de identidades da carga de trabalho ($PRIMUS_WORKLOAD_IDENTITY_POOL) para validar declarações com base nas condições de atributos configuradas no provedor.
• Uma conta de serviço ($PRIMUS_SERVICEACCOUNT) anexada ao pool de Identidade da carga de trabalho ($PRIMUS_WORKLOAD_IDENTITY_POOL) mencionado acima com o seguinte acesso do IAM:
• roles/cloudkms.cryptoKeyDecrypter para descriptografar os dados usando a chave do KMS.
• objectViewer para ler dados do bucket do Cloud Storage.
• roles/iam.workloadIdentityUser para conectar essa conta de serviço ao pool de identidades da carga de trabalho.

./setup_resources.sh

3. Criar carga de trabalho

Criar conta de serviço da carga de trabalho

Agora você vai criar uma conta de serviço para a carga de trabalho com os papéis e as permissões necessárias. Para fazer isso, execute o seguinte script, que vai criar uma conta de serviço de carga de trabalho para a Empresa A. Essa conta de serviço será usada pela VM que executa a carga de trabalho.

A conta de serviço da carga de trabalho ($WORKLOAD_SERVICEACCOUNT) terá os seguintes papéis:

• confidentialcomputing.workloadUser para receber um token de atestado
• logging.logWriter para gravar registros no Cloud Logging.
• objectViewer para ler dados do bucket do Cloud Storage $PRIMUS_INPUT_STORAGE_BUCKET.
• objectUser para gravar o resultado da carga de trabalho no bucket $PRIMUS_RESULT_STORAGE_BUCKET do Cloud Storage.

./create_workload_service_account.sh

Criar carga de trabalho

Esta etapa envolve a criação de uma imagem Docker de carga de trabalho. A carga de trabalho neste codelab é um aplicativo simples de MPC do Node.js que assina transações digitais para transferir recursos usando compartilhamentos de chaves privadas criptografadas. Aqui está o código do projeto de carga de trabalho. O projeto de carga de trabalho inclui os seguintes arquivos.

package.json::esse arquivo contém a lista de pacotes que devem ser usados para o aplicativo de MPC da carga de trabalho. Neste caso, estamos usando as bibliotecas @google-cloud/kms, @google-cloud/storage, ethers e fast-crc32c. Aqui está o arquivo package.json que vamos usar neste codelab.

index.js::é um ponto de entrada do aplicativo de carga de trabalho e especifica quais comandos devem ser executados quando o contêiner de carga de trabalho é iniciado. Também incluímos uma transação de amostra não assinada que normalmente seria fornecida por um aplicativo não confiável que pede a assinatura dos usuários. Esse arquivo index.js também importa funções de mpc.js, que vamos criar em seguida. Confira abaixo o conteúdo do arquivo index.js, que também pode ser encontrado aqui.

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::é aqui que a assinatura da transação acontece. Ele importa funções de "kms-decrypt" e "credential-config", que vamos abordar a seguir. Confira abaixo o conteúdo do arquivo mpc.js, que também pode ser encontrado aqui.

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:este arquivo contém o código para a descriptografia usando chaves gerenciadas no KMS. Confira abaixo o conteúdo do arquivo kms-decrypt.js, que também pode ser encontrado aqui.

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:o arquivo armazena os caminhos e detalhes do pool de identidades da carga de trabalho para a personificação da conta de serviço. Aqui está o arquivo credential-config.js que vamos usar neste codelab.

Dockerfile:por fim, vamos criar o Dockerfile que será usado para criar a imagem do Docker da carga de trabalho. Ele define o Dockerfile conforme especificado aqui.

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

Observação:LABEL "tee.launch_policy.allow_cmd_override"="true" no Dockerfile é uma política de inicialização definida pelo autor da imagem. Isso permite que o operador substitua o CMD ao executar a carga de trabalho. Por padrão, allow_cmd_override é definido como "false". O RÓTULO "tee.launch_policy.allow_env_override" informa ao Confidential Space quais variáveis de ambiente os usuários da imagem podem usar .

Execute o script a seguir para criar uma carga de trabalho em que as seguintes etapas estão sendo realizadas:

• Crie o Artifact Registry($PRIMUS_ARTIFACT_REPOSITORY) para armazenar a imagem do Docker da carga de trabalho.
• Atualize o código da carga de trabalho com os nomes dos recursos necessários. Aqui está o código da carga de trabalho usado neste codelab.
• Crie um Dockerfile para criar uma imagem do Docker do código de carga de trabalho. Confira o Dockerfile aqui.
• Crie e publique a imagem do Docker no Artifact Registry ($PRIMUS_ARTIFACT_REPOSITORY) criado na etapa anterior.
• Conceda permissão de leitura $WORKLOAD_SERVICEACCOUNT para $PRIMUS_ARTIFACT_REPOSITORY. Isso é necessário para que o contêiner da carga de trabalho extraia a imagem do Docker da carga de trabalho do Artifact Registry.

./create_workload.sh

Criar o nó de blockchain

Nó do Ethereum do Ganache

Antes de autorizar a carga de trabalho, precisamos criar a instância do Ethereum Ganache. A transação assinada seria enviada a essa instância do Ganache. Anote o endereço IP dessa instância. Depois de executar o comando abaixo, talvez seja necessário inserir y para ativar a 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. Autorizar e executar a carga de trabalho

Autorizar carga de trabalho

Como parte desta etapa, vamos configurar o provedor de pool de identidades da carga de trabalho no pool de identidades da carga de trabalho ($PRIMUS_WORKLOAD_IDENTITY_POOL). Há condições de atributo configuradas para a identidade da carga de trabalho, conforme mostrado abaixo. Uma das condições é validar se a imagem da carga de trabalho está sendo extraída do repositório de artefatos esperado.

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"

Executar carga de trabalho

Nesta seção, explicamos como executar a carga de trabalho em uma VM confidencial. Para isso, vamos transmitir os argumentos de TEE necessários usando a flag de metadados. Além disso, vamos definir variáveis de ambiente para o contêiner de carga de trabalho usando a flag "tee-env-*". A imagem tem as seguintes variáveis:

• NODE_URL: o URL do nó do Ethereum que vai processar a transação assinada.
• RESULTS_BUCKET: o bucket que armazena o resultado da transação de MPC.
• KEY_BUCKET: o bucket que armazena as chaves criptografadas por MPC.
• PRIMUS_PROJECT_NUMBER: o número do projeto usado no arquivo de configuração de credenciais.
• PRIMUS_PROJECT_ID: o ID do projeto usado para o arquivo de configuração de credenciais. O resultado da execução da carga de trabalho será publicado em $PRIMUS_RESULT_STORAGE_BUCKET.
• PRIMUS_WORKLOAD_IDENTITY_POOL: o pool de identidades da carga de trabalho usado para validar declarações.
• PRIMUS_WIP_POROVIDER: o provedor de pool de Identidade da carga de trabalho que inclui as condições de atributo a serem usadas para validar os tokens apresentados pela carga de trabalho.
• WORKLOAD_SERVICEACCOUNT: a conta de serviço da carga de trabalho.

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

Verificar os resultados do Cloud Storage

Você pode conferir o recibo da transação no Cloud Storage. Pode levar alguns minutos para o espaço confidencial ser inicializado e os resultados aparecerem. Você vai saber que o contêiner foi concluído quando a VM estiver no estado interrompido.

1. Acesse a página Navegador do Cloud Storage.
2. Clique em $PRIMUS_RESULT_STORAGE_BUCKET.
3. Clique no arquivo transaction_receipt.
4. Clique em "Download" para baixar e conferir a resposta da transação.

Como alternativa, execute os comandos a seguir para ver o resultado.

gcloud config set project $PRIMUS_PROJECT_ID

gsutil cat gs://$PRIMUS_RESULT_STORAGE_BUCKET/transaction_receipt

Observação:se os resultados não aparecerem, acesse $WORKLOAD_VM na página do console do Cloud do Compute Engine e clique em "Porta serial 1 (console)" para ver os registros.

Verificar a transação de blockchain do Ganache

Também é possível conferir a transação no registro do blockchain.

1. Acesse a página Cloud Compute Engine.
2. Clique em ${ETHEREUM_NODE} VM.
3. Clique em SSH para abrir a janela SSH no navegador.
4. Na janela do SSH, digite sudo docker ps para ver o contêiner do Ganache em execução.
5. Encontre o ID do contêiner para trufflesuite/ganache:v7.7.3
6. Insira sudo docker logs CONTAINER_ID, substituindo CONTAINER_ID pelo ID de trufflesuite/ganache:v7.7.3.
7. Confira os registros do Ganache e confirme se há uma transação listada neles.

5. Limpar

Aqui está o script que pode ser usado para limpar os recursos criados como parte deste codelab. Como parte dessa limpeza, os seguintes recursos serão excluídos:

• Bucket de armazenamento de entrada usado para armazenar compartilhamentos de chaves criptografadas ($PRIMUS_INPUT_STORAGE_BUCKET).
• Chave de criptografia ($PRIMUS_KEY).
• Conta de serviço usada para acessar recursos protegidos ($PRIMUS_SERVICEACCOUNT).
• Pool de identidade da carga de trabalho ($PRIMUS_WORKLOAD_IDENTITY_POOL).
• Conta de serviço da carga de trabalho ($WORKLOAD_SERVICEACCOUNT).
• Instâncias de computação de carga de trabalho ($WORKLOAD_VM e $ETHEREUM_NODE).
• Bucket de armazenamento de resultados usado para armazenar o resultado da transação.($PRIMUS_RESULT_STORAGE_BUCKET).
• Registro do artefato usado para armazenar a imagem da carga de trabalho ($PRIMUS_ARTIFACT_REPOSITORY).

./cleanup.sh

Se você já terminou de explorar, considere excluir o projeto.

• Acesse o Console do Cloud Platform.
• Selecione o projeto que você quer encerrar e clique em "Excluir" na parte de cima. Isso programa a exclusão do projeto.

Qual é a próxima etapa?

Confira alguns codelabs semelhantes:

• Dados compartilhados seguros em uso com o Confidential Space
• Codelab de imagem de contêiner assinada
• Analisar dados confidenciais com o Confidential Space

Leia mais

• Está se sentindo isolado? A computação confidencial para salvar
• Computação confidencial no GCP
• Espaço confidencial: o futuro da colaboração que preserva a privacidade
• Como o Google e a Intel tornam a Computação Confidencial mais segura
• Privacidade x progresso: como avançar na segurança com a computação confidencial do Google Cloud