Esta página foi traduzida pela API Cloud Translation.

Crie atestadores com a CLI gcloud

Esta página explica como criar um atestador na autorização binária através da CLI do Google Cloud. Em alternativa, pode realizar estes passos através da Google Cloud consola ou da API REST. Esta tarefa faz parte da configuração da autorização binária.

Utilizadores do Cloud Build: em alternativa, pode usar o built-by-cloud-build atestador para implementar apenas imagens criadas pelo Cloud Build.

Um atestador é um Google Cloud recurso que a autorização binária usa para validar uma atestação. Para saber mais sobre as atestações, consulte a vista geral da autorização binária.

Para criar um atestador, faça o seguinte:

Crie uma nota na Análise de artefactos para armazenar metadados fidedignos usados no processo de atestação.
Configure um par de chaves de infraestrutura de chave pública (X.509) (PKIX) que pode ser usado para validar a identidade do atestador. (Os pares de chaves assimétricas gerados pelo Cloud Key Management Service (Cloud KMS) estão no formato compatível com PKIX.)
Crie o próprio atestador na autorização binária e associe a nota e a chave pública que criou.

Numa configuração de projeto único, cria o atestador no mesmo Google Cloud projeto onde configura a política de autorização binária. Para um tutorial completo de projeto único que inclua estes passos, consulte o artigo Comece a usar a CLI Google Cloud ou Comece a usar a Google Cloud consola.

Numa configuração com vários projetos, recomendamos que tenha projetos separados: um projeto de implementação, onde a sua política está configurada; um projeto de atestação, onde os seus atestadores estão armazenados; e um projeto de atestação para atestações. Para um tutorial abrangente de vários projetos que inclua estes passos, consulte a configuração de vários projetos.

Antes de começar

Antes de criar atestadores, faça o seguinte:

Configure o ambiente do projeto

Nesta secção, configura as variáveis de ambiente.

Configure variáveis de ambiente para armazenar os nomes e os números dos seus projetos. Se os projetos do atestador e do implementador forem o mesmo projeto, use o mesmo ID do projeto para ambas as variáveis.

DEPLOYER_PROJECT_ID=DEPLOYER_PROJECT_ID=
DEPLOYER_PROJECT_NUMBER="$(
    gcloud projects describe "${DEPLOYER_PROJECT_ID}" \
      --format="value(projectNumber)"
)"

ATTESTOR_PROJECT_ID=ATTESTOR_PROJECT_ID
ATTESTOR_PROJECT_NUMBER="$(
    gcloud projects describe "${ATTESTOR_PROJECT_ID}" \
    --format="value(projectNumber)"
)"

Também tem de obter os nomes das contas de serviço dos projetos:

DEPLOYER_SERVICE_ACCOUNT="service-${DEPLOYER_PROJECT_NUMBER}@gcp-sa-binaryauthorization.iam.gserviceaccount.com"
ATTESTOR_SERVICE_ACCOUNT="service-${ATTESTOR_PROJECT_NUMBER}@gcp-sa-binaryauthorization.iam.gserviceaccount.com"

Crie uma nota de análise de artefactos

A autorização binária usa a análise de artefactos para armazenar metadados fidedignos usados no processo de autorização. Para cada atestador que criar, tem de criar uma nota de análise de artefactos. Cada atestação é armazenada como uma ocorrência desta nota.

Para criar a nota, siga estes passos:

Configure variáveis de ambiente para armazenar o ID da nota e uma descrição legível por humanos:
```
NOTE_ID=NOTE_ID
NOTE_URI="projects/${ATTESTOR_PROJECT_ID}/notes/${NOTE_ID}"
DESCRIPTION=DESCRIPTION
```
Substitua o seguinte:
- NOTE_ID: o nome interno da nota em carateres alfanuméricos sem espaços, por exemplo, test-attestor-note
- NOTE_URI: o caminho totalmente qualificado para o recurso de nota
- DESCRIPTION: um nome a apresentar legível por humanos para a nota, por exemplo, Test Attestor Note

Num editor de texto, crie um ficheiro JSON que descreva a nota:

cat > /tmp/note_payload.json << EOM
{
  "name": "${NOTE_URI}",
  "attestation": {
    "hint": {
      "human_readable_name": "${DESCRIPTION}"
    }
  }
}
EOM

Crie a nota enviando um pedido HTTP para a API REST Artifact Analysis:

curl -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
    -H "x-goog-user-project: ${ATTESTOR_PROJECT_ID}" \
    --data-binary @/tmp/note_payload.json  \
    "https://containeranalysis.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/notes/?noteId=${NOTE_ID}"

Para verificar se a nota foi criada com êxito, execute o seguinte comando:

curl \
    -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
    -H "x-goog-user-project: ${ATTESTOR_PROJECT_ID}" \
    "https://containeranalysis.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/notes/"

Defina as autorizações IAM na nota

Tem de conceder uma função de Identity and Access Management (IAM) à conta de serviço do projeto de atestação no recurso de nota de análise de artefactos. Para tal, adicione a conta de serviço do projeto do atestador à função de containeranalysis.notes.occurrences.viewer na política de IAM da nota.

Para adicionar a função, faça o seguinte:

Gere um ficheiro JSON que contenha as informações necessárias para definir a função do IAM na sua nota:

cat > /tmp/iam_request.json << EOM
{
  "resource": "${NOTE_URI}",
  "policy": {
    "bindings": [
      {
        "role": "roles/containeranalysis.notes.occurrences.viewer",
        "members": [
          "serviceAccount:${ATTESTOR_SERVICE_ACCOUNT}"
        ]
      }
    ]
  }
}
EOM

Adicione a conta de serviço e as funções de acesso pedidas à política de IAM para a nota que criou:
```
curl -X POST  \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "x-goog-user-project: ${ATTESTOR_PROJECT_ID}" \
    --data-binary @/tmp/iam_request.json \
    "https://containeranalysis.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/notes/${NOTE_ID}:setIamPolicy"
```
Nota: quando adiciona uma função à política através do método acima, substitui quaisquer funções existentes na nota. Se quiser preservar as funções existentes, certifique-se de que as inclui no ficheiro de dados JSON anterior.

Utilização em vários projetos

Se armazenar o atestador num projeto e implementar num projeto separado, tem de conceder a função roles/binaryauthorization.attestorsVerifier à conta de serviço associada ao projeto de implementação no atestador.

Configure chaves criptográficas

A Autorização binária permite-lhe usar chaves PKIX para validar atestados.

Gere um par de chaves

Neste guia, usa o algoritmo de assinatura digital de curva elíptica (ECDSA) recomendado para gerar um par de chaves PKIX. Também pode usar pares de chaves RSA ou PGP. Consulte Principais finalidades e algoritmos para mais informações sobre os algoritmos de assinatura.

Um par de chaves PKIX compreende uma chave privada que os signatários usam para assinar atestações e uma chave pública que adiciona ao atestador. No momento da implementação, a autorização binária usa esta chave pública para validar a atestação.

PKIX (Cloud KMS)

Para criar o par de chaves no Cloud KMS, faça o seguinte:

Para configurar as variáveis de ambiente necessárias para criar o par de chaves, execute os seguintes comandos:
```
KMS_KEY_PROJECT_ID=KMS_KEY_PROJECT_ID
KMS_KEY_LOCATION=KMS_KEY_LOCATION
KMS_KEYRING_NAME=KMS_KEYRING_NAME
KMS_KEY_NAME=KMS_KEY_NAME
KMS_KEY_VERSION=KMS_KEY_VERSION
KMS_KEY_PURPOSE=asymmetric-signing
KMS_KEY_ALGORITHM=KMS_KEY_ALGORITHM
KMS_PROTECTION_LEVEL=KMS_PROTECTION_LEVEL
```
Substitua o seguinte:
- KMS_KEY_PROJECT_ID: o ID do projeto onde as chaves estão armazenadas
- KMS_KEY_LOCATION: a localização da chave
- KMS_KEYRING_NAME: o nome do conjunto de chaves
- KMS_KEY_NAME: o nome da chave
- KMS_KEY_VERSION: a versão da chave
- KMS_KEY_ALGORITHM: o algoritmo; ec-sign-p256-sha256 é a recomendação
- KMS_PROTECTION_LEVEL: o nível de proteção, por exemplo, software

Para criar o conjunto de chaves, execute o seguinte comando:

gcloud kms keyrings create ${KMS_KEYRING_NAME} \
    --location ${KMS_KEY_LOCATION}

Para criar a chave, execute o seguinte comando:
```
gcloud kms keys create ${KMS_KEY_NAME} \
    --location ${KMS_KEY_LOCATION} \
    --keyring ${KMS_KEYRING_NAME}  \
    --purpose ${KMS_KEY_PURPOSE} \
    --default-algorithm ${KMS_KEY_ALGORITHM} \
    --protection-level ${KMS_PROTECTION_LEVEL}
```
Substitua o seguinte:
- KMS_KEY_NAME: o nome da chave
- KMS_KEY_LOCATION: a localização da chave
- KMS_KEYRING_NAME: o nome do conjunto de chaves
- KMS_KEY_PURPOSE: a finalidade da chave, definida como ASYMMETRIC_SIGN
- KMS_KEY_ALGORITHM: o algoritmo, ec-sign-p256-sha256 é recomendado
- KMS_PROTECTION_LEVEL: o nível de proteção, por exemplo, software

PKIX (chave local)

Para gerar um novo par de chaves PKIX assimétricas locais e armazená-lo num ficheiro, faça o seguinte:

Gere a chave privada:

PRIVATE_KEY_FILE é o nome do ficheiro que contém a chave privada usada para assinar a carga útil de atestação.
```
PRIVATE_KEY_FILE="/tmp/ec_private.pem"
openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}
```
Extraia a chave pública da chave privada e armazene-a num ficheiro:

PUBLIC_KEY_FILE é o nome do ficheiro que contém a chave pública armazenada no atestador.
```
PUBLIC_KEY_FILE="/tmp/ec_public.pem"
openssl ec -in ${PRIVATE_KEY_FILE} -pubout -out ${PUBLIC_KEY_FILE}
```

Crie o atestador

Para criar o atestador, siga estes passos:

Configure uma variável de ambiente para armazenar o nome do atestador, conforme definido na autorização binária:
```
ATTESTOR_NAME=ATTESTOR_NAME
```
onde ATTESTOR_NAME é o nome do atestador que quer criar (por exemplo, build-secure ou prod-qa).

Crie o recurso de atestador na autorização binária:

gcloud --project="${ATTESTOR_PROJECT_ID}" \
    container binauthz attestors create "${ATTESTOR_NAME}" \
    --attestation-authority-note="${NOTE_ID}" \
    --attestation-authority-note-project="${ATTESTOR_PROJECT_ID}"

Adicione uma associação de função do IAM para o projeto de implementação ao atestador. Isto é usado pela autorização binária quando avalia uma política para determinar se o projeto tem autorizações para aceder a quaisquer atestações associadas.
```
gcloud container binauthz attestors add-iam-policy-binding \
    "projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}" \
    --member="serviceAccount:${DEPLOYER_SERVICE_ACCOUNT}" \
    --role=roles/binaryauthorization.attestorsVerifier
```
Para adicionar a chave pública ao atestador, faça o seguinte:
PKIX (Cloud KMS)
Para adicionar a chave pública de um par de chaves do Cloud KMS ao atestador, execute o seguinte comando:
```
gcloud --project="${ATTESTOR_PROJECT_ID}" \
    container binauthz attestors public-keys add \
    --attestor="${ATTESTOR_NAME}" \
    --keyversion-project="${KMS_KEY_PROJECT_ID}" \
    --keyversion-location="${KMS_KEY_LOCATION}" \
    --keyversion-keyring="${KMS_KEYRING_NAME}" \
    --keyversion-key="${KMS_KEY_NAME}" \
    --keyversion="${KMS_KEY_VERSION}"
```
PKIX (chave local)
Para adicionar uma chave pública PKIX armazenada localmente a um atestador, execute o seguinte comando:
```
gcloud --project="${ATTESTOR_PROJECT_ID}" \
    container binauthz attestors public-keys add \
    --attestor="${ATTESTOR_NAME}" \
    --pkix-public-key-file=${PUBLIC_KEY_FILE} \
    --pkix-public-key-algorithm=ecdsa-p256-sha256
```
Se adicionar uma chave pública a um atestador e não especificar um ID da chave (que pode ser qualquer string), é-lhe automaticamente atribuído um no formato RFC 6920: ni:///sha-256;..., onde ... é um hash codificado da chave pública. Este valor é devolvido no campo id do resultado do comando. O ID devolvido pode ser guardado em PUBLIC_KEY_ID e usado para criar uma atestação.

Guarde o ID da chave pública

Para criar uma atestação, precisa do ID da chave pública.

Para guardar o ID da chave pública, pode copiá-lo a partir do resultado do comando binauthz attestors public-keys add acima.

Em alternativa, pode ver o ID da chave pública do atestador em qualquer altura através do seguinte comando:

gcloud container binauthz attestors describe ${ATTESTOR}.

Para guardar o ID da chave pública numa variável de ambiente, introduza o seguinte comando:

PUBLIC_KEY_ID=$(gcloud container binauthz attestors describe ${ATTESTOR_NAME} \
--format='value(userOwnedGrafeasNote.publicKeys[0].id)')

Confirme se o atestador foi criado

Para verificar se o atestador foi criado, execute o seguinte comando:

gcloud container binauthz attestors list \
    --project="${ATTESTOR_PROJECT_ID}"

O que se segue?

Saiba como criar atestações para o seu atestador.
Atualize a sua política de autorização binária para exigir atestações através da Google Cloud consola, da Google Cloud CLI e da API REST.

Crie atestadores com a CLI gcloud Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Configure o ambiente do projeto

Crie uma nota de análise de artefactos

Defina as autorizações IAM na nota

Utilização em vários projetos

Configure chaves criptográficas

Gere um par de chaves

PKIX (Cloud KMS)

PKIX (chave local)

Crie o atestador

PKIX (Cloud KMS)

PKIX (chave local)

Guarde o ID da chave pública

Confirme se o atestador foi criado

O que se segue?

Crie atestadores com a CLI gcloud