Esta página foi traduzida pela API Cloud Translation.

Crie atestadores através da API REST

Esta página explica como criar um atestador personalizado na autorização binária através da API REST.

Em alternativa, também pode realizar estes passos através da CLI Google Cloud ou da Google Cloud consola. 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.

Vista geral

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

Para criar um atestador, tem de fazer 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.) Em alternativa, pode usar pares de chaves PGP em vez de chaves 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 Google Cloud mesmo projeto onde configura a política de autorização binária. Numa configuração com vários projetos, é muito provável que tenha um projeto de implementação onde a sua política está configurada e um projeto de atestação separado onde os seus atestadores estão armazenados.

Antes de começar

Defina o projeto predefinido

Defina o Google Cloud projeto predefinido, se ainda não o tiver feito:

PROJECT_ID=PROJECT_ID
gcloud config set project ${PROJECT_ID}

Configure o ambiente

Configure variáveis de ambiente para armazenar os nomes e os números dos seus projetos:

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

Se o projeto do atestador e do implementador for o mesmo, use o mesmo ID do projeto para ambas as variáveis.

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 uma nota de análise de artefactos:

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 notas
- DESCRIPTION é um nome a apresentar legível para humanos para a nota (por exemplo, Test Attestor Note)

Num editor de texto, crie um ficheiro JSON em /tmp/note_payload.json que descreva a nota de análise de artefactos:

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 autorizações na nota

Também tem de definir autorizações na nota de análise de artefactos que criou para que seja acessível à conta de serviço do projeto de atestação. Pode fazê-lo atualizando a política do IAM para a nota de forma a atribuir a função containeranalysis.notes.occurrences.viewer à conta.

Para definir as autorizações:

Gere um ficheiro JSON que contenha as informações necessárias para definir a política de 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"
```
Quando adiciona uma função à política através do método acima, esta substitui todas as funções existentes na nota. Se quiser preservar as funções existentes, certifique-se de que as inclui nos dados JSON quando definir a política.

Configure chaves criptográficas

A autorização binária permite-lhe usar chaves PKIX para validar de forma segura a identidade do signatário que criou uma atestação. Isto garante que apenas as partes validadas podem autorizar uma imagem de contentor. Em alternativa ao PKIX, também pode usar chaves PGP.

Crie um par de chaves PKIX

A autorização binária permite-lhe usar pares de chaves PKIX assimétricos para validar uma atestação. O par de chaves consiste numa chave privada, que o signatário usa para assinar digitalmente as atestações, e numa chave pública, que adiciona ao atestador. Posteriormente, o aplicador da autorização binária usa a chave pública no atestador para verificar se a atestação foi criada pelo signatário.

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

Os pares de chaves assimétricas gerados e armazenados no Cloud KMS estão em conformidade com o formato PKIX. Para criar uma chave do Cloud KMS para utilização com a autorização binária, consulte o artigo Criar chaves assimétricas. Certifique-se de que escolhe Assinatura assimétrica como a finalidade da chave quando a cria.

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}

PKIX (chave local)

Para gerar um novo par de chaves PKIX assimétricas locais e armazená-lo num ficheiro:

Gere a chave:

PRIVATE_KEY_FILE="/tmp/ec_private.pem"
openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}

Uma vez que este ficheiro contém uma chave pública e uma chave privada, tem de extrair a chave pública para um ficheiro separado para a poder adicionar ao atestador:
```
PUBLIC_KEY_FILE="/tmp/ec_public.pem"
openssl ec -in ${PRIVATE_KEY_FILE} -pubout -out ${PUBLIC_KEY_FILE}
```

Crie o atestador

O passo seguinte é criar o atestador na autorização binária com a nota de análise de artefactos associada. Também tem de adicionar a chave pública criptográfica.

Para criar o atestador:

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 atestador e anexe a chave de segurança pública:

PKIX (Cloud KMS)

Configure variáveis de ambiente adicionais para armazenar informações sobre o par de chaves do Cloud KMS para a chamada à API Binary Authorization.

KMS_CRYPTO_KEY_URI="projects/${KMS_KEY_PROJECT_ID}/locations/${KMS_KEY_LOCATION}/keyRings/${KMS_KEYRING_NAME}/cryptoKeys/${KMS_KEY_NAME}"
KMS_CRYPTO_KEY_VERSION_URI="${KMS_CRYPTO_KEY_URI}/cryptoKeyVersions/${KMS_KEY_VERSION}"
KMS_KEY_ID="//cloudkms.googleapis.com/v1/${KMS_CRYPTO_KEY_VERSION_URI}"

Transfira o ficheiro de chave pública do Cloud KMS e guarde-o num ficheiro com o nome /tmp/kms_public_key.pem no seu sistema local.

Gere um ficheiro JSON que contenha as informações necessárias para criar o atestador:

cat > /tmp/attestor.json << EOM
{
    "userOwnedDrydockNote": {
        "noteReference": "${NOTE_URI}",
        "publicKeys": {
            "id": "${KMS_KEY_ID}",
            "pkixPublicKey": {
                "signatureAlgorithm": "${KMS_KEY_ALGORITHM}",
                "publicKeyPem": $( \
                    python < /tmp/kms_public_key.pem \
                    -c 'import json, sys; print(json.dumps(sys.stdin.read()))' \
                )
            }
        }
    }
}
EOM

Crie o atestador:

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/attestor.json \
"https://binaryauthorization.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/attestors?attestorId=${ATTESTOR_NAME}"

PKIX (chave local)

Gere um ficheiro JSON que contenha as informações necessárias para criar o atestador:

cat > /tmp/attestor.json << EOM
{
   "userOwnedGrafeasNote": {
       "noteReference": "${NOTE_URI}",
       "publicKeys": {
           "pkixPublicKey": {
               "signatureAlgorithm": "ecdsa_p256_sha256",
               "publicKeyPem": $( \
                   python < ${PUBLIC_KEY_FILE} \
                   -c 'import json, sys; print(json.dumps(sys.stdin.read()))' \
               )
           }
       }
   }
}
EOM

Crie o atestador:

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/attestor.json \
"https://binaryauthorization.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/attestors?attestorId=${ATTESTOR_NAME}"

Adicione uma associação de função do IAM para o projeto de implementação ao atestador. Esta opção é usada pela autorização binária quando avalia uma política para determinar se o projeto tem autorizações para aceder ao atestador referenciado.

Gere um ficheiro JSON que contenha as informações necessárias para definir a política de IAM no seu atestador:

cat > /tmp/iam_request.json << EOM
{
  'resource': 'projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}',
  'policy': {
    'bindings': [
      {
        'role': 'roles/binaryauthorization.attestorsVerifier',
        'members': [
          'serviceAccount:${DEPLOYER_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://binaryauthorization.googleapis.com/v1beta1/projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}:setIamPolicy"

Confirme se o atestador foi criado

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

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

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 através da API REST Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Vista geral

Antes de começar

Defina o projeto predefinido

Configure o ambiente

Crie uma nota de análise de artefactos

Defina autorizações na nota

Configure chaves criptográficas

Crie um par de chaves PKIX

PKIX (Cloud KMS)

PKIX (chave local)

Crie o atestador

PKIX (Cloud KMS)

PKIX (chave local)

Confirme se o atestador foi criado

O que se segue?

Crie atestadores através da API REST