Criar seu primeiro ambiente do Espaço confidencial

Neste guia, Alex e Bola querem descobrir quem tem o salário mais alto sem revelar números um ao outro. Eles decidem usar o Confidential Space para manter os dados confidenciais e concordam em assumir os seguintes papéis:

  • Alex: colaborador de dados, autor de carga de trabalho

  • Bola: colaborador de dados, operador de carga de trabalho

Essa organização foi projetada para manter as coisas o mais simples possível para este guia. No entanto, é possível que o autor e o operador da carga de trabalho sejam totalmente independentes dos colaboradores de dados, e você pode ter quantos colaboradores quiser.

Antes de começar

Neste guia, você verá um cenário do Confidential Space usando uma única conta em uma organização com acesso a vários projetos. Assim, é possível conferir todo o processo. Em uma implantação de produção, os colaboradores, autores de carga de trabalho e operadores de carga de trabalho têm contas separadas e os próprios projetos contidos em organizações discretas, inacessíveis uns aos outros e mantendo os dados confidenciais separados.

O Confidential Space pode interagir com muitos serviços do Google Cloudpara produzir resultados, incluindo, entre outros:

Neste guia, usamos e pressupomos uma compreensão básica de todos esses recursos.

Funções exigidas

Para ter as permissões necessárias para concluir este guia, peça ao administrador para conceder a você os papéis do IAM a seguir no projeto:

  • Administrador do Cloud KMS (roles/cloudkms.admin) para os colaboradores de dados (Alex e Bola).
  • Administrador de pool de Identidade da carga de trabalho do IAM (roles/iam.workloadIdentityPoolAdmin) para os colaboradores de dados (Alex e Bola).
  • Administrador do Service Usage (roles/serviceusage.serviceUsageAdmin) para os colaboradores de dados (Alex e Bola).
  • Administrador de armazenamento (roles/storage.admin) para os colaboradores de dados (Alex e Bola) e para o operador de carga de trabalho (Bola).
  • Administrador da conta de serviço (roles/iam.serviceAccountAdmin) para o operador de carga de trabalho (Bola).
  • Administrador do Compute (roles/compute.admin) para o operador de carga de trabalho (Bola).
  • Administrador de segurança (roles/securityAdmin) para o operador de carga de trabalho (Bola).
  • Administrador do Artifact Registry (roles/artifactregistry.admin) para o autor da carga de trabalho (Alex).

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Configurar recursos de colaboradores de dados

Alex e Bola precisam de projetos independentes que contenham os seguintes recursos:

  • Os dados confidenciais em si.

  • Uma chave para criptografar esses dados e mantê-los confidenciais.

  • Um bucket do Cloud Storage para armazenar os dados criptografados.

  • Um pool de Identidade da carga de trabalho. A carga de trabalho que processa os dados confidenciais usa o pool para acessar os dados particulares e descriptografá-los.

Para começar, acesse o console do Google Cloud :

Acessar o console do Google Cloud

Configurar os recursos do Alex

Para configurar os recursos do Alex, siga as instruções a seguir.

  1. Clique em Ativar o Cloud Shell.
  2. No Cloud Shell, insira o comando a seguir para criar um projeto para o Alex, substituindo ALEX_PROJECT_ID por um nome de sua escolha:

    gcloud projects create ALEX_PROJECT_ID
  3. Alterne para o projeto recém-criado:

    gcloud config set project ALEX_PROJECT_ID
  4. Ative as APIs exigidas pelo Alex como colaborador de dados e autor da carga de trabalho:

    gcloud services enable \
        artifactregistry.googleapis.com \
        cloudkms.googleapis.com \
        iamcredentials.googleapis.com
  5. Crie um keyring e uma chave de criptografia com o Cloud Key Management Service:

    gcloud kms keyrings create ALEX_KEYRING_NAME \
        --location=global
    
    gcloud kms keys create ALEX_KEY_NAME \
        --location=global \
        --keyring=ALEX_KEYRING_NAME \
        --purpose=encryption
  6. Conceda ao Alex o papel cloudkms.cryptoKeyEncrypter para que ele possa usar a chave recém-criada para criptografar dados:

    gcloud kms keys add-iam-policy-binding \
        "projects/ALEX_PROJECT_ID/locations/global/\
    keyRings/ALEX_KEYRING_NAME/\
    cryptoKeys/ALEX_KEY_NAME" \
        --member=user:$(gcloud config get-value account) \
        --role=roles/cloudkms.cryptoKeyEncrypter
  7. Crie o pool de identidades de carga de trabalho do Alex:

    gcloud iam workload-identity-pools create ALEX_POOL_NAME \
        --location=global
  8. Crie um bucket do Cloud Storage para os dados de entrada e outro para armazenar os resultados:

    gcloud storage buckets create gs://ALEX_INPUT_BUCKET_NAME \
        gs://ALEX_OUTPUT_BUCKET_NAME
  9. Crie um arquivo que contenha apenas o salário do Alex como número:

    echo 123456 > ALEX_SALARY.txt
  10. Criptografe o arquivo e faça upload dele para o bucket do Alex:

    gcloud kms encrypt \
        --ciphertext-file="ALEX_ENCRYPTED_SALARY_FILE" \
        --plaintext-file="ALEX_SALARY.txt" \
        --key="projects/ALEX_PROJECT_ID/locations/global/\
    keyRings/ALEX_KEYRING_NAME/\
    cryptoKeys/ALEX_KEY_NAME"
    gcloud storage cp ALEX_ENCRYPTED_SALARY_FILE gs://ALEX_INPUT_BUCKET_NAME

Configurar os recursos do Bola

Para configurar os recursos do Bola, siga as instruções a seguir.

  1. No Cloud Shell, digite o seguinte comando para criar um projeto para o Bola, substituindo BOLA_PROJECT_ID por um nome de sua escolha:

    gcloud projects create BOLA_PROJECT_ID
  2. Alterne para o projeto recém-criado:

    gcloud config set project BOLA_PROJECT_ID
  3. Ative as APIs que o Bola exige como colaborador de dados e operador de carga de trabalho:

    gcloud services enable \
        cloudkms.googleapis.com \
        compute.googleapis.com \
        confidentialcomputing.googleapis.com \
        iamcredentials.googleapis.com
  4. Crie um keyring e uma chave de criptografia com o Cloud Key Management Service:

    gcloud kms keyrings create BOLA_KEYRING_NAME \
        --location=global
    
    gcloud kms keys create BOLA_KEY_NAME \
        --location=global \
        --keyring=BOLA_KEYRING_NAME \
        --purpose=encryption
  5. Conceda ao Bola o papel cloudkms.cryptoKeyEncrypter para que ele possa usar a chave recém-criada para criptografar dados:

    gcloud kms keys add-iam-policy-binding \
        "projects/BOLA_PROJECT_ID/locations/global/\
    keyRings/BOLA_KEYRING_NAME/\
    cryptoKeys/BOLA_KEY_NAME" \
        --member=user:$(gcloud config get-value account) \
        --role=roles/cloudkms.cryptoKeyEncrypter
  6. Crie o pool de identidades da carga de trabalho do Bola:

    gcloud iam workload-identity-pools create BOLA_POOL_NAME \
        --location=global
  7. Crie um bucket do Cloud Storage para os dados de entrada e outro para armazenar os resultados:

    gcloud storage buckets create gs://BOLA_INPUT_BUCKET_NAME \
        gs://BOLA_OUTPUT_BUCKET_NAME
  8. Crie um arquivo que contenha apenas o salário de Bola como número:

    echo 111111 > BOLA_SALARY.txt
  9. Criptografe o arquivo e faça upload dele para o bucket do Bola:

    gcloud kms encrypt \
        --ciphertext-file="BOLA_ENCRYPTED_SALARY_FILE" \
        --plaintext-file="BOLA_SALARY.txt" \
        --key="projects/BOLA_PROJECT_ID/locations/global/\
    keyRings/BOLA_KEYRING_NAME/\
    cryptoKeys/BOLA_KEY_NAME"
    gcloud storage cp BOLA_ENCRYPTED_SALARY_FILE gs://BOLA_INPUT_BUCKET_NAME

Crie uma conta de serviço para a carga de trabalho

Neste guia, Bola opera e executa a carga de trabalho, mas qualquer pessoa pode assumir esses papéis, incluindo terceiros. A instância de VM que Bola cria para executar a carga de trabalho tem uma conta de serviço anexada, que tem permissão para gerar tokens de atestado, gravar registros, ler os dados criptografados de Alex e Bola e gravar resultados em buckets específicos do Cloud Storage.

Conclua as etapas a seguir no projeto do Bola para configurar a conta de serviço:

  1. Crie uma conta de serviço para executar a carga de trabalho:

    gcloud iam service-accounts create WORKLOAD_SERVICE_ACCOUNT_NAME
    
  2. Conceda ao Bola o papel iam.serviceAccountUser para que ele possa anexar a conta de serviço à VM de carga de trabalho mais tarde:

    gcloud iam service-accounts add-iam-policy-binding \
        WORKLOAD_SERVICE_ACCOUNT_NAME@BOLA_PROJECT_ID.iam.gserviceaccount.com \
        --member=user:$(gcloud config get-value account) \
        --role=roles/iam.serviceAccountUser
    
  3. Conceda à conta de serviço o papel confidentialcomputing.workloadUser para que ela possa solicitar um token de atestado:

    gcloud projects add-iam-policy-binding BOLA_PROJECT_ID \
        --member=serviceAccount:WORKLOAD_SERVICE_ACCOUNT_NAME@BOLA_PROJECT_ID.iam.gserviceaccount.com \
        --role=roles/confidentialcomputing.workloadUser
    
  4. Conceda à conta de serviço o papel logging.logWriter para gravar registros no Cloud Logging para que seja possível verificar o progresso da carga de trabalho:

    gcloud projects add-iam-policy-binding BOLA_PROJECT_ID \
        --member=serviceAccount:WORKLOAD_SERVICE_ACCOUNT_NAME@BOLA_PROJECT_ID.iam.gserviceaccount.com \
        --role=roles/logging.logWriter
    
  5. Conceda à conta de serviço acesso de leitura aos buckets do Alex e do Bola que contêm os dados criptografados e acesso de gravação para cada um dos buckets de resultados:

    gcloud storage buckets add-iam-policy-binding gs://ALEX_INPUT_BUCKET_NAME \
        --member=serviceAccount:WORKLOAD_SERVICE_ACCOUNT_NAME@BOLA_PROJECT_ID.iam.gserviceaccount.com \
        --role=roles/storage.objectViewer
    
    gcloud storage buckets add-iam-policy-binding gs://ALEX_OUTPUT_BUCKET_NAME \
        --member=serviceAccount:WORKLOAD_SERVICE_ACCOUNT_NAME@BOLA_PROJECT_ID.iam.gserviceaccount.com \
        --role=roles/storage.objectAdmin
    
    gcloud storage buckets add-iam-policy-binding gs://BOLA_INPUT_BUCKET_NAME \
        --member=serviceAccount:WORKLOAD_SERVICE_ACCOUNT_NAME@BOLA_PROJECT_ID.iam.gserviceaccount.com \
        --role=roles/storage.objectViewer
    
    gcloud storage buckets add-iam-policy-binding gs://BOLA_OUTPUT_BUCKET_NAME \
        --member=serviceAccount:WORKLOAD_SERVICE_ACCOUNT_NAME@BOLA_PROJECT_ID.iam.gserviceaccount.com \
        --role=roles/storage.objectAdmin
    

    Isso pressupõe que o usuário que concede o acesso tenha o papel de Administrador do Storage (roles/storage.admin) no projeto que contém o bucket do Cloud Storage que está sendo operado.

Criar a carga de trabalho

Neste guia, Alex fornece o código para a carga de trabalho e cria uma imagem Docker para contê-la, mas qualquer pessoa pode assumir esses papéis, incluindo um terceiro.

Alex precisa criar os seguintes recursos para a carga de trabalho:

  • O código que executa a carga de trabalho.

  • Um repositório do Docker no Artifact Registry que pode ser acessado pela conta de serviço que executa a carga de trabalho.

  • Uma imagem Docker que contém e executa o código da carga de trabalho.

Para criar e configurar os recursos, conclua as seguintes etapas no projeto do Alex:

  1. Alterne para o projeto do Alex:

    gcloud config set project ALEX_PROJECT_ID
    
  2. Clique em Abrir editor para abrir o editor do Cloud Shell e crie um novo arquivo com o nome salary.go. Copie o código a seguir no arquivo e salve-o:

    package main
    
    import (
      "context"
      "fmt"
      "io"
      "os"
      "strconv"
      "strings"
      "time"
    
      kms "cloud.google.com/go/kms/apiv1"
      kmspb "cloud.google.com/go/kms/apiv1/kmspb"
      "cloud.google.com/go/storage"
      "google.golang.org/api/option"
    )
    
    type collaborator struct {
      name         string
      wipName      string
      keyName      string
      inputBucket  string
      inputFile    string
      outputBucket string
    }
    
    // The following values are pulled from environment variables
    
    // Alex's values
    var collaborator1Name string = os.Getenv("COLLAB_1_NAME") // Alex's name
    var collaborator1EncryptedSalaryFileName string = os.Getenv("COLLAB_1_ENCRYPTED_SALARY") // The name of Alex's encrypted salary file.
    var collaborator1BucketInputName string = os.Getenv("COLLAB_1_INPUT_BUCKET") // The name of the storage bucket that contains Alex's encrypted salary file.
    var collaborator1BucketOutputName string = os.Getenv("COLLAB_1_OUTPUT_BUCKET") // The name of the storage bucket to store Alex's results in.
    var collaborator1KMSKeyringName string = os.Getenv("COLLAB_1_KEYRING_NAME") // Alex's Key Management Service key ring.
    var collaborator1KMSKeyName string = os.Getenv("COLLAB_1_KEY_NAME") // Alex's Key Management Service key.
    var collaborator1ProjectName string = os.Getenv("COLLAB_1_PROJECT_ID") // Alex's project ID.
    var collaborator1ProjectNumber string = os.Getenv("COLLAB_1_PROJECT_NUMBER") // Alex's project number.
    var collaborator1PoolName string = os.Getenv("COLLAB_1_POOL_NAME") // Alex's workload identity pool name.
    
    // Bola's values
    var collaborator2Name string = os.Getenv("COLLAB_2_NAME") // Bola's name
    var collaborator2EncryptedSalaryFileName string = os.Getenv("COLLAB_2_ENCRYPTED_SALARY") // The name of Bola's encrypted salary file.
    var collaborator2BucketInputName string = os.Getenv("COLLAB_2_INPUT_BUCKET") // The name of the storage bucket that contains Bola's encrypted salary file.
    var collaborator2BucketOutputName string = os.Getenv("COLLAB_2_OUTPUT_BUCKET") // The name of the storage bucket to store Bola's results in.
    var collaborator2KMSKeyringName string = os.Getenv("COLLAB_2_KEYRING_NAME") // Bola's Key Management Service key ring.
    var collaborator2KMSKeyName string = os.Getenv("COLLAB_2_KEY_NAME") // Bola's Key Management Service key.
    var collaborator2ProjectName string = os.Getenv("COLLAB_2_PROJECT_ID") // Bola's project ID.
    var collaborator2ProjectNumber string = os.Getenv("COLLAB_2_PROJECT_NUMBER") // Bola's project number.
    var collaborator2PoolName string = os.Getenv("COLLAB_2_POOL_NAME") // Bola's workload identity pool name.
    
    var collaborators = [2]collaborator{
      {
        collaborator1Name,
        "projects/" + collaborator1ProjectNumber + "/locations/global/workloadIdentityPools/" + collaborator1PoolName + "/providers/attestation-verifier",
        "projects/" + collaborator1ProjectName + "/locations/global/keyRings/" + collaborator1KMSKeyringName + "/cryptoKeys/" + collaborator1KMSKeyName,
        collaborator1BucketInputName,
        collaborator1EncryptedSalaryFileName,
        collaborator1BucketOutputName,
      },
      {
        collaborator2Name,
        "projects/" + collaborator2ProjectNumber + "/locations/global/workloadIdentityPools/" + collaborator2PoolName + "/providers/attestation-verifier",
        "projects/" + collaborator2ProjectName + "/locations/global/keyRings/" + collaborator2KMSKeyringName + "/cryptoKeys/" + collaborator2KMSKeyName,
        collaborator2BucketInputName,
        collaborator2EncryptedSalaryFileName,
        collaborator2BucketOutputName,
      },
    }
    
    const credentialConfig = `{
            "type": "external_account",
            "audience": "//iam.googleapis.com/%s",
            "subject_token_type": "urn:ietf:params:oauth:token-type:jwt",
            "token_url": "https://sts.googleapis.com/v1/token",
            "credential_source": {
              "file": "/run/container_launcher/attestation_verifier_claims_token"
            }
            }`
    
    func main() {
      fmt.Println("workload started")
      ctx := context.Background()
    
      storageClient, err := storage.NewClient(ctx) // Using the default credential on the Compute Engine VM
      if err != nil {
        panic(err)
      }
    
      // Get and decrypt
      s0, err := getSalary(ctx, storageClient, collaborators[0])
      if err != nil {
        panic(err)
      }
    
      s1, err := getSalary(ctx, storageClient, collaborators[1])
      if err != nil {
        panic(err)
      }
    
      res := ""
      if s0 > s1 {
        res = fmt.Sprintf("%s earns more!\n", collaborators[0].name)
      } else if s1 > s0 {
        res = fmt.Sprintf("%s earns more!\n", collaborators[1].name)
      } else {
        res = "You earn the same!\n"
      }
    
      now := time.Now()
      for _, cw := range collaborators {
        outputWriter := storageClient.Bucket(cw.outputBucket).Object(fmt.Sprintf("comparison-result-%d", now.Unix())).NewWriter(ctx)
    
        _, err = outputWriter.Write([]byte(res))
        if err != nil {
          fmt.Printf("Could not write: %v", err)
          panic(err)
        }
        if err = outputWriter.Close(); err != nil {
          fmt.Printf("Could not close: %v", err)
          panic(err)
        }
      }
    }
    
    func getSalary(ctx context.Context, storageClient *storage.Client, cw collaborator) (float64, error) {
      encryptedBytes, err := getFile(ctx, storageClient, cw.inputBucket, cw.inputFile)
      if err != nil {
        return 0.0, err
      }
      decryptedByte, err := decryptByte(ctx, cw.keyName, cw.wipName, encryptedBytes)
      if err != nil {
        return 0.0, err
      }
      decryptedNumber := strings.TrimSpace(string(decryptedByte))
      num, err := strconv.ParseFloat(decryptedNumber, 64)
      if err != nil {
        return 0.0, err
      }
      return num, nil
    }
    
    func decryptByte(ctx context.Context, keyName, wippro string, encryptedData []byte) ([]byte, error) {
      cc := fmt.Sprintf(credentialConfig, wippro)
      kmsClient, err := kms.NewKeyManagementClient(ctx, option.WithCredentialsJSON([]byte(cc)))
      if err != nil {
        return nil, fmt.Errorf("creating a new KMS client with federated credentials: %w", err)
      }
    
      decryptRequest := &kmspb.DecryptRequest{
        Name:       keyName,
        Ciphertext: encryptedData,
      }
      decryptResponse, err := kmsClient.Decrypt(ctx, decryptRequest)
      if err != nil {
        return nil, fmt.Errorf("could not decrypt ciphertext: %w", err)
      }
    
      return decryptResponse.Plaintext, nil
    }
    
    func getFile(ctx context.Context, c *storage.Client, bucketName string, objPath string) ([]byte, error) {
      bucketHandle := c.Bucket(bucketName)
      objectHandle := bucketHandle.Object(objPath)
    
      objectReader, err := objectHandle.NewReader(ctx)
      if err != nil {
        return nil, err
      }
      defer objectReader.Close()
    
      s, err := io.ReadAll(objectReader)
      if err != nil {
        return nil, err
      }
    
      return s, nil
    }
    
  3. Verifique se todas as partes leem e auditam o código-fonte.

  4. Crie um arquivo chamado Dockerfile no Editor do Cloud Shell com o seguinte conteúdo:

    # Compile the provided Go code to a statically linked binary
    FROM golang:latest AS build
    WORKDIR /build
    COPY salary.go .
    RUN go mod init salary
    RUN go get cloud.google.com/go/kms/apiv1 cloud.google.com/go/storage google.golang.org/api/option google.golang.org/genproto/googleapis/cloud/kms/v1
    RUN CGO_ENABLED=0 go build -trimpath
    
    # Build the workload container image
    FROM alpine:latest AS run
    WORKDIR /test
    COPY --from=build /build/salary /test/salary
    ENTRYPOINT ["/test/salary"]
    CMD []
    
    # Allow the workload to access the following environment variables
    LABEL "tee.launch_policy.allow_env_override"="\
    COLLAB_1_NAME,\
    COLLAB_2_NAME,\
    COLLAB_1_ENCRYPTED_SALARY,\
    COLLAB_2_ENCRYPTED_SALARY,\
    COLLAB_1_INPUT_BUCKET,\
    COLLAB_2_INPUT_BUCKET,\
    COLLAB_1_OUTPUT_BUCKET,\
    COLLAB_2_OUTPUT_BUCKET,\
    COLLAB_1_KEYRING_NAME,\
    COLLAB_2_KEYRING_NAME,\
    COLLAB_1_KEY_NAME,\
    COLLAB_2_KEY_NAME,\
    COLLAB_1_PROJECT_ID,\
    COLLAB_2_PROJECT_ID,\
    COLLAB_1_PROJECT_NUMBER,\
    COLLAB_2_PROJECT_NUMBER,\
    COLLAB_1_POOL_NAME,\
    COLLAB_2_POOL_NAME"
    
    # Restrict the container to run only in non-root mode.
    LABEL "tee.launch_policy.nonroot_container"="nonrootonly"
    

    Esse Dockerfile usa um build de vários estágios para primeiro compilar o código Go e, em seguida, copia a versão compilada desse código para o contêiner de carga de trabalho final. Ele também permite que variáveis de ambiente específicas sejam usadas nesse contêiner de carga de trabalho e restringe o contêiner para ser executado no modo não raiz. Os valores dessas variáveis de ambiente são mapeados posteriormente para os recursos específicos em que a carga de trabalho precisa operar.

  5. Clique em Abrir terminal para voltar ao Cloud Shell ou invoque o terminal integrado ao editor do Cloud Shell no menu Visualizar.

  6. Criar um repositório do Docker no Artifact Registry:

    gcloud artifacts repositories create REPOSITORY_NAME \
        --repository-format=docker \
        --location=us
    
  7. Conceda à conta de serviço que executará a carga de trabalho o papel de Leitor do Artifact Registry (roles/artifactregistry.reader) para que ela possa ler do repositório:

    gcloud artifacts repositories add-iam-policy-binding REPOSITORY_NAME \
        --location=us \
        --member=serviceAccount:WORKLOAD_SERVICE_ACCOUNT_NAME@BOLA_PROJECT_ID.iam.gserviceaccount.com \
        --role=roles/artifactregistry.reader
    
  8. Atualize suas credenciais do Docker para incluir o nome de domínio us-docker.pkg.dev:

    gcloud auth configure-docker us-docker.pkg.dev
    
  9. Crie uma imagem Docker a partir de Dockerfile. Para isso, digite o seguinte comando no terminal:

    docker build -t \
        "us-docker.pkg.dev/ALEX_PROJECT_ID/\
    REPOSITORY_NAME/WORKLOAD_CONTAINER_NAME:latest" .
    
  10. Envie a imagem Docker para o Artifact Registry:

    docker push \
        us-docker.pkg.dev/ALEX_PROJECT_ID/REPOSITORY_NAME/WORKLOAD_CONTAINER_NAME
    
  11. A resposta push do Docker lista o resumo SHA256 da imagem, que é necessário para autorizar a carga de trabalho. A saída será assim:

    sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
    

    Copie o resumo da imagem (incluindo o prefixo sha256:) em um local que possa ser referenciado. Também é possível inserir o resumo no exemplo de código a seguir para preencher previamente o restante dos exemplos de código neste guia que precisam do valor:

    WORKLOAD_CONTAINER_IMAGE_DIGEST
    
  12. Certifique-se de que todas as partes auditem a imagem Docker e verifique se ela é confiável antes de autorizar o uso.

Autorizar a carga de trabalho

Com a carga de trabalho aprovada por ambas as partes, Alex e Bola precisam adicionar o Google Cloud Attestation como um provedor aos pools de identidade da carga de trabalho. O provedor especifica o serviço de atestado a ser usado e as propriedades que a carga de trabalho precisa corresponder para que possa operar nos dados de Alex ou Bola. Se um agente malicioso mudar a imagem Docker ou alterar outra propriedade medida, o acesso à carga de trabalho será negado.

Este guia usa mapeamentos de atributos para fornecer acesso direto aos recursos para a carga de trabalho com base no resumo da imagem. No entanto, em outras situações, talvez você prefira usar a identidade temporária de conta de serviço para acessar os recursos. Consulte Acesso à carga de trabalho externa para saber mais.

Para configurar os provedores do Alex e do Bola com as condições necessárias, siga estas etapas:

  1. Digite o seguinte comando para criar o provedor do Alex:

    gcloud iam workload-identity-pools providers create-oidc attestation-verifier \
        --location=global \
        --workload-identity-pool=ALEX_POOL_NAME \
        --issuer-uri="https://confidentialcomputing.googleapis.com/" \
        --allowed-audiences="https://sts.googleapis.com" \
        --attribute-mapping="google.subject=\"gcpcs\
    ::\"+assertion.submods.container.image_digest+\"\
    ::\"+assertion.submods.gce.project_number+\"\
    ::\"+assertion.submods.gce.instance_id,\
    attribute.image_digest=assertion.submods.container.image_digest" \
        --attribute-condition="assertion.swname == 'CONFIDENTIAL_SPACE'"
    
  2. Consiga o número do projeto do Alex para o próximo comando:

    gcloud projects describe ALEX_PROJECT_ID --format="value(projectNumber)"
    
  3. Conceda à identidade federada definida pelo provedor de Alex o papel cloudkms.cryptoKeyDecrypter, especificando o atributo image_digest para que apenas os contêineres de carga de trabalho com o resumo especificado possam descriptografar as chaves do KMS:

    gcloud kms keys add-iam-policy-binding \
        "projects/ALEX_PROJECT_ID/locations/global/\
    keyRings/ALEX_KEYRING_NAME/\
    cryptoKeys/ALEX_KEY_NAME" \
        --member="principalSet://iam.googleapis.com/\
    projects/ALEX_PROJECT_NUMBER/locations/global/\
    workloadIdentityPools/ALEX_POOL_NAME/\
    attribute.image_digest/WORKLOAD_CONTAINER_IMAGE_DIGEST" \
        --role=roles/cloudkms.cryptoKeyDecrypter
    
  4. Mude para o projeto do Bola:

    gcloud config set project BOLA_PROJECT_ID
    
  5. Digite o seguinte comando para criar o provedor do Bola:

    gcloud iam workload-identity-pools providers create-oidc attestation-verifier \
        --location=global \
        --workload-identity-pool=BOLA_POOL_NAME \
        --issuer-uri="https://confidentialcomputing.googleapis.com/" \
        --allowed-audiences="https://sts.googleapis.com" \
        --attribute-mapping="google.subject=\"gcpcs\
    ::\"+assertion.submods.container.image_digest+\"\
    ::\"+assertion.submods.gce.project_number+\"\
    ::\"+assertion.submods.gce.instance_id,\
    attribute.image_digest=assertion.submods.container.image_digest" \
        --attribute-condition="assertion.swname == 'CONFIDENTIAL_SPACE'"
    
  6. Encontre o número do projeto do Bola para o próximo comando:

    gcloud projects describe BOLA_PROJECT_ID --format="value(projectNumber)"
    
  7. Conceda à identidade federada definida pelo provedor de Bola o papel cloudkms.cryptoKeyDecrypter, especificando o atributo image_digest para que apenas os contêineres de carga de trabalho com o resumo especificado possam descriptografar as chaves do KMS:

    gcloud kms keys add-iam-policy-binding \
        "projects/BOLA_PROJECT_ID/locations/global/\
    keyRings/BOLA_KEYRING_NAME/\
    cryptoKeys/BOLA_KEY_NAME" \
        --member="principalSet://iam.googleapis.com/\
    projects/BOLA_PROJECT_NUMBER/locations/global/\
    workloadIdentityPools/BOLA_POOL_NAME/\
    attribute.image_digest/WORKLOAD_CONTAINER_IMAGE_DIGEST" \
        --role=roles/cloudkms.cryptoKeyDecrypter
    

Testar a carga de trabalho

Com os provedores adicionados aos pools de identidade da carga de trabalho do Alex e do Bola e os recursos necessários ativos, é hora do operador da carga de trabalho testar a carga de trabalho.

Para testar a carga de trabalho, crie uma nova instância de VM confidencial no projeto do Bola que tenha as seguintes propriedades:

Para testar a carga de trabalho, digite o seguinte comando no Cloud Shell do Bola:

gcloud compute instances create WORKLOAD_VM_2_NAME \
    --confidential-compute-type=SEV \
    --shielded-secure-boot \
    --scopes=cloud-platform \
    --zone=us-west1-b \
    --maintenance-policy=MIGRATE \
    --min-cpu-platform="AMD Milan" \
    --image-project=confidential-space-images \
    --image-family=confidential-space-debug \
    --service-account=WORKLOAD_SERVICE_ACCOUNT_NAME@BOLA_PROJECT_ID.iam.gserviceaccount.com \
    --metadata="^~^tee-image-reference=us-docker.pkg.dev/\
ALEX_PROJECT_ID/REPOSITORY_NAME/WORKLOAD_CONTAINER_NAME:latest\
~tee-container-log-redirect=true\
~tee-nonroot-container=true\
~tee-env-COLLAB_1_NAME=Alex\
~tee-env-COLLAB_2_NAME=Bola\
~tee-env-COLLAB_1_ENCRYPTED_SALARY=ALEX_ENCRYPTED_SALARY_FILE\
~tee-env-COLLAB_2_ENCRYPTED_SALARY=BOLA_ENCRYPTED_SALARY_FILE\
~tee-env-COLLAB_1_INPUT_BUCKET=ALEX_INPUT_BUCKET_NAME\
~tee-env-COLLAB_2_INPUT_BUCKET=BOLA_INPUT_BUCKET_NAME\
~tee-env-COLLAB_1_OUTPUT_BUCKET=ALEX_OUTPUT_BUCKET_NAME\
~tee-env-COLLAB_2_OUTPUT_BUCKET=BOLA_OUTPUT_BUCKET_NAME\
~tee-env-COLLAB_1_KEYRING_NAME=ALEX_KEYRING_NAME\
~tee-env-COLLAB_2_KEYRING_NAME=BOLA_KEYRING_NAME\
~tee-env-COLLAB_1_KEY_NAME=ALEX_KEY_NAME\
~tee-env-COLLAB_2_KEY_NAME=BOLA_KEY_NAME\
~tee-env-COLLAB_1_PROJECT_ID=ALEX_PROJECT_ID\
~tee-env-COLLAB_2_PROJECT_ID=BOLA_PROJECT_ID\
~tee-env-COLLAB_1_PROJECT_NUMBER=ALEX_PROJECT_NUMBER\
~tee-env-COLLAB_2_PROJECT_NUMBER=BOLA_PROJECT_NUMBER\
~tee-env-COLLAB_1_POOL_NAME=ALEX_POOL_NAME\
~tee-env-COLLAB_2_POOL_NAME=BOLA_POOL_NAME"

Ver andamento

É possível ver o progresso da carga de trabalho no projeto do Bola acessando o Explorador de registros.

Acessar a Análise de Registros

Para mostrar apenas as entradas de registro do Confidential Space, filtre pelos seguintes campos de registro, se estiverem disponíveis:

  • Tipo de recurso: instância de VM

  • ID da instância: o ID da instância da VM

  • Nome do registro: confidencial-space-launcherer

Para atualizar o registro, clique em Ir para momento atual. Também é possível rolar para resultados anteriores e, em seguida, rolar para o final do registro novamente para carregar as entradas mais recentes.

Ver os resultados

Se a tarefa da carga de trabalho terminar e retornar 0, isso significa que não ocorreram erros e é hora de verificar a saída nos buckets de saída de Alex e Bola:

  1. Alterne para o projeto do Alex:

    gcloud config set project ALEX_PROJECT_ID
    
  2. Liste todos os arquivos no bucket de resultados:

    gcloud storage ls gs://ALEX_OUTPUT_BUCKET_NAME
    
  3. Leia o arquivo mais recente listado, substituindo ALEX_OUTPUT_CLOUD_STORAGE_PATH pelo caminho do arquivo, incluindo o gs://:

    gcloud storage cat ALEX_OUTPUT_CLOUD_STORAGE_PATH
    

    Se não houver nenhum arquivo, depure sua carga de trabalho.

  4. Mude para o projeto do Bola:

    gcloud config set project BOLA_PROJECT_ID
    
  5. Liste todos os arquivos no bucket de resultados:

    gcloud storage ls gs://BOLA_OUTPUT_BUCKET_NAME
    
  6. Leia o arquivo mais recente listado, substituindo BOLA_RESULTS_CLOUD_STORAGE_PATH pelo caminho do arquivo, incluindo o gs://:

    gcloud storage cat BOLA_RESULTS_CLOUD_STORAGE_PATH
    

    Se não houver nenhum arquivo, depure sua carga de trabalho.

  7. Depois de ler os resultados, interrompa a instância de VM:

    gcloud compute instances stop WORKLOAD_VM_2_NAME --zone=us-west1-b
    

Ao ler os arquivos, Alex e Bola descobrem quem ganha mais sem nunca revelar o salário um para o outro.

Depurar e reiniciar a carga de trabalho

Um ambiente do Confidential Space tem muitas partes, e é possível que algo tenha sido configurado incorretamente, o que faz com que a carga de trabalho falhe.

Ao contrário da imagem de produção do Confidential Space, a imagem de depuração mantém a instância de VM em execução após a conclusão da carga de trabalho. Isso significa que, se os registros não revelarem o suficiente para resolver o problema, a próxima etapa será se conectar à instância de VM por SSH e continuar a depuração.

Depois de concluir a depuração, interrompa a instância de VM:

gcloud compute instances stop WORKLOAD_VM_2_NAME --zone=us-west1-b

Para executar a carga de trabalho no ambiente depurado, inicie a VM novamente:

gcloud compute instances start WORKLOAD_VM_2_NAME --zone=us-west1-b

Reforçar a proteção do ambiente para produção

Depois de testar a carga de trabalho, é hora de proteger o ambiente do Confidential Space para implantação de produção. Alex e Bola precisam adicionar uma declaração support_attributes aos provedores para verificar se a imagem de produção do Confidential Space é usada para a carga de trabalho:

  1. Alterne para o projeto do Alex:

    gcloud config set project ALEX_PROJECT_ID
    
  2. Digite o seguinte comando para atualizar o provedor do Alex:

    gcloud iam workload-identity-pools providers update-oidc attestation-verifier \
        --location=global \
        --workload-identity-pool=ALEX_POOL_NAME \
        --issuer-uri="https://confidentialcomputing.googleapis.com/" \
        --allowed-audiences="https://sts.googleapis.com" \
        --attribute-mapping="google.subject=\"gcpcs\
    ::\"+assertion.submods.container.image_digest+\"\
    ::\"+assertion.submods.gce.project_number+\"\
    ::\"+assertion.submods.gce.instance_id,\
    attribute.image_digest=assertion.submods.container.image_digest" \
        --attribute-condition="assertion.swname == 'CONFIDENTIAL_SPACE' \
            && 'STABLE' in assertion.submods.confidential_space.support_attributes"
    
  3. Mude para o projeto do Bola:

    gcloud config set project BOLA_PROJECT_ID
    
  4. Digite o seguinte comando para atualizar o provedor do Bola:

    gcloud iam workload-identity-pools providers update-oidc attestation-verifier \
        --location=global \
        --workload-identity-pool=BOLA_POOL_NAME \
        --issuer-uri="https://confidentialcomputing.googleapis.com/" \
        --allowed-audiences="https://sts.googleapis.com" \
        --attribute-mapping="google.subject=\"gcpcs\
    ::\"+assertion.submods.container.image_digest+\"\
    ::\"+assertion.submods.gce.project_number+\"\
    ::\"+assertion.submods.gce.instance_id,\
    attribute.image_digest=assertion.submods.container.image_digest" \
        --attribute-condition="assertion.swname == 'CONFIDENTIAL_SPACE' \
            && 'STABLE' in assertion.submods.confidential_space.support_attributes"
    

Implantar a carga de trabalho de produção

Bola precisa criar uma instância de VM separada para executar a carga de trabalho de produção. As seguintes coisas são diferentes em comparação com a carga de trabalho de teste:

  • O SO é baseado na imagem de produção do Confidential Space. O SSH está desativado, e a instância de VM é interrompida após a conclusão da carga de trabalho.

  • O redirecionamento de geração de registros foi removido. Somente os registros básicos que não expõem informações sensíveis são mostrados no Cloud Logging.

Para implantar a carga de trabalho de produção, digite o seguinte comando no Cloud Shell do Bola:

gcloud compute instances create WORKLOAD_VM_NAME \
    --confidential-compute-type=SEV \
    --shielded-secure-boot \
    --scopes=cloud-platform \
    --zone=us-west1-b \
    --maintenance-policy=MIGRATE \
    --image-project=confidential-space-images \
    --image-family=confidential-space \
    --service-account=WORKLOAD_SERVICE_ACCOUNT_NAME@BOLA_PROJECT_ID.iam.gserviceaccount.com \
    --metadata="^~^tee-image-reference=us-docker.pkg.dev/\
ALEX_PROJECT_ID/REPOSITORY_NAME/WORKLOAD_CONTAINER_NAME:latest\
~tee-nonroot-container=true\
~tee-env-COLLAB_1_NAME=Alex\
~tee-env-COLLAB_2_NAME=Bola\
~tee-env-COLLAB_1_ENCRYPTED_SALARY=ALEX_ENCRYPTED_SALARY_FILE\
~tee-env-COLLAB_2_ENCRYPTED_SALARY=BOLA_ENCRYPTED_SALARY_FILE\
~tee-env-COLLAB_1_INPUT_BUCKET=ALEX_INPUT_BUCKET_NAME\
~tee-env-COLLAB_2_INPUT_BUCKET=BOLA_INPUT_BUCKET_NAME\
~tee-env-COLLAB_1_OUTPUT_BUCKET=ALEX_OUTPUT_BUCKET_NAME\
~tee-env-COLLAB_2_OUTPUT_BUCKET=BOLA_OUTPUT_BUCKET_NAME\
~tee-env-COLLAB_1_KEYRING_NAME=ALEX_KEYRING_NAME\
~tee-env-COLLAB_2_KEYRING_NAME=BOLA_KEYRING_NAME\
~tee-env-COLLAB_1_KEY_NAME=ALEX_KEY_NAME\
~tee-env-COLLAB_2_KEY_NAME=BOLA_KEY_NAME\
~tee-env-COLLAB_1_PROJECT_ID=ALEX_PROJECT_ID\
~tee-env-COLLAB_2_PROJECT_ID=BOLA_PROJECT_ID\
~tee-env-COLLAB_1_PROJECT_NUMBER=ALEX_PROJECT_NUMBER\
~tee-env-COLLAB_2_PROJECT_NUMBER=BOLA_PROJECT_NUMBER\
~tee-env-COLLAB_1_POOL_NAME=ALEX_POOL_NAME\
~tee-env-COLLAB_2_POOL_NAME=BOLA_POOL_NAME"

A maneira de visualizar o progresso e os resultados é a mesma de quando você testou a carga de trabalho.

Quando a carga de trabalho de produção é concluída, a instância de VM é interrompida. Para ver resultados diferentes, mude os salários, criptografe-os novamente, faça o upload deles para os respectivos buckets do Cloud Storage e reinicie a instância de VM para executar a carga de trabalho de novo:

gcloud compute instances start WORKLOAD_VM_NAME --zone=us-west1-b

Limpeza

Para remover os recursos criados neste guia, siga as instruções a seguir.

Limpar os recursos do Alex

  1. Alterne para o projeto do Alex:

    gcloud config set project ALEX_PROJECT_ID
    
  2. Exclua o pool de identidades de carga de trabalho do Alex:

    gcloud iam workload-identity-pools delete ALEX_POOL_NAME \
        --location=global
    
  3. Exclua os buckets do Cloud Storage do Alex:

    gcloud storage rm gs://ALEX_INPUT_BUCKET_NAME \
        gs://ALEX_OUTPUT_BUCKET_NAME --recursive
    
  4. Exclua os arquivos de salário do Alex, o código do Go e o Dockerfile:

    rm ALEX_SALARY.txt \
        ALEX_ENCRYPTED_SALARY_FILE \
        salary.go \
        Dockerfile
    
  5. Opcional: desative ou destrua a chave do Cloud Key Management Service do Alex.

  6. Opcional: encerre o projeto do Alex.

Limpar os recursos do Bola

  1. Mude para o projeto do Bola:

    gcloud config set project BOLA_PROJECT_ID
    
  2. Exclua a VM que executou o fluxo de trabalho de teste:

    gcloud compute instances delete WORKLOAD_VM_2_NAME --zone=us-west1-b
    
  3. Exclua a VM que executou o fluxo de trabalho de produção:

    gcloud compute instances delete WORKLOAD_VM_NAME --zone=us-west1-b
    
  4. Exclua a conta de serviço que executou a carga de trabalho:

    gcloud iam service-accounts delete \
        WORKLOAD_SERVICE_ACCOUNT_NAME@BOLA_PROJECT_ID.iam.gserviceaccount.com
    
  5. Exclua o pool de identidades da carga de trabalho do Bola:

    gcloud iam workload-identity-pools delete BOLA_POOL_NAME \
        --location=global
    
  6. Exclua os buckets do Cloud Storage do Bola:

    gcloud storage rm gs://BOLA_INPUT_BUCKET_NAME \
        gs://BOLA_OUTPUT_BUCKET_NAME --recursive
    
  7. Exclua os arquivos de salário do Bola:

    rm BOLA_SALARY.txt \
        BOLA_ENCRYPTED_SALARY_FILE
    
  8. Opcional: desative ou destrua a chave do Cloud Key Management Service do Bola.

  9. Opcional: encerre o projeto do Bola.