Usar a verificação de atestado de assinatura simples

Esta página mostra como usar a verificação de atestado de assinatura simples da validação contínua (CV, na sigla em inglês) da autorização binária. A verificação confere os atestados de imagens de contêiner associadas a pods em execução em um cluster do Google Kubernetes Engine (GKE) em que o CV está ativado.

Custos

Neste guia, usamos os seguintes serviços do Google Cloud:

  • Autorização binária, mas a CV está disponível gratuitamente durante o estágio de Visualização
  • GKE
  • Cloud Key Management Service

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços.

Antes de começar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. Install the Google Cloud CLI.

  3. To initialize the gcloud CLI, run the following command: 

    gcloud init

  4. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  5. Make sure that billing is enabled for your Google Cloud project.

  6. Enable the Binary Authorization, Cloud Key Management Service, Google Kubernetes Engine APIs: 

    gcloud services enable binaryauthorization.googleapis.com cloudkms.googleapis.com container.googleapis.com
  7. Install the Google Cloud CLI.

  8. To initialize the gcloud CLI, run the following command: 

    gcloud init

  9. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  10. Make sure that billing is enabled for your Google Cloud project.

  11. Enable the Binary Authorization, Cloud Key Management Service, Google Kubernetes Engine APIs: 

    gcloud services enable binaryauthorization.googleapis.com cloudkms.googleapis.com container.googleapis.com
  12. Verifique se a CLI gcloud está atualizada para a versão mais recente.
  13. Instale a ferramenta de linha de comando kubectl.
  14. Se as políticas de autorização binária e os clusters do GKE estiverem em projetos diferentes, verifique se a autorização binária está ativada nos dois projetos.

Funções exigidas

Esta seção mostra como definir papéis para essa verificação.

Informações gerais

Se você executar todos os produtos mencionados neste guia no mesmo projeto, não será necessário definir permissões. A autorização binária configura os papéis corretamente quando ativada. Se você executar os produtos em projetos diferentes, será necessário definir os papéis conforme descrito nesta seção.

Para garantir que o agente de serviço de autorização binária em cada projeto tenha as permissões necessárias para avaliar a verificação de atestado da assinatura simples da CV, peça ao administrador para conceder ao agente de serviço de autorização binária os seguintes papéis do IAM:

  • Se o projeto de cluster for diferente do projeto de política: Avaliador de política de autorização binária (roles/binaryauthorization.policyEvaluator) no Agente de serviço de autorização binária do projeto de cluster, para acessar o projeto de política
  • Se o projeto de atestado for diferente do projeto de política: Visualizador de ocorrências do Container Analysis (roles/containeranalysis.occurrences.viewer) no Agente de serviço de autorização binária do projeto de política, para acessar o projeto de atestado

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

O administrador também pode conceder as permissões necessárias ao agente de serviço de autorização binária em cada projeto por meio de papéis personalizados ou outros papéis predefinidos.

Conceder papéis usando a CLI gcloud

Para garantir que o agente de serviço de autorização binária em cada projeto tenha as permissões necessárias para avaliar a verificação de atestado de assinatura simples da CV, conceda ao agente de serviço de autorização binária os seguintes papéis de IAM:

  1. Conceda permissão ao Agente de serviço de autorização binária do projeto de cluster para acessar a política no projeto de política.

    1. Consiga o agente de serviço de autorização binária do projeto de cluster:

      PROJECT_NUMBER=$(gcloud projects list --filter="projectId:CLUSTER_PROJECT_ID" \
  --format="value(PROJECT_NUMBER)")
CLUSTER_SERVICE_ACCOUNT="service-$PROJECT_NUMBER@gcp-sa-binaryauthorization.iam.gserviceaccount.com"

      Substitua CLUSTER_PROJECT_ID pelo ID do projeto do cluster.

    2. Permita que a CV avalie a política no cluster:

      gcloud projects add-iam-policy-binding POLICY_PROJECT_ID \
    --member="serviceAccount:$CLUSTER_SERVICE_ACCOUNT" \
    --role='roles/binaryauthorization.policyEvaluator'

      Substitua POLICY_PROJECT_ID pelo ID do projeto que contém a política.

  2. Permita que o agente de serviço de autorização binária do projeto de política acesse os atestados no projeto:

    1. Consiga o agente de serviço de autorização binária do projeto de política:

      PROJECT_NUMBER=$(gcloud projects list \
  --filter="projectId:POLICY_PROJECT_ID" \
  --format="value(PROJECT_NUMBER)")
SERVICE_ACCOUNT="service-$PROJECT_NUMBER@gcp-sa-binaryauthorization.iam.gserviceaccount.com"

      Substitua POLICY_PROJECT_ID pelo ID do projeto que contém a política.

    2. Conceda o papel:

      gcloud projects add-iam-policy-binding ATTESTATION_PROJECT_ID \
    --member="serviceAccount:$SERVICE_ACCOUNT" \
    --role='roles/containeranalysis.occurrences.viewer'

      Substitua ATTESTATION_PROJECT_ID pelo ID do projeto que contém seus atetados.

Criar um par de chaves.

Nesta seção, você cria um par de chaves assimétricas do Algoritmo de assinatura digital de curva elíptica (ECDSA, na sigla em inglês).

Você usa a chave privada para assinar a imagem, o que cria o atestado. Inclua a chave pública em uma política da plataforma. Quando a CV verifica o atestado, ela usa a chave pública para verificá-lo.

É possível usar o Cloud Key Management Service ou chaves locais, mas recomendamos o uso de chaves do Cloud KMS para produção.

PKIX (Cloud KMS)

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

  1. Configure as variáveis de ambiente necessárias para criar o par de chaves. Para isso, preencha os marcadores no comando a seguir e execute-o.

    KMS_KEY_PROJECT_ID=KMS_KEY_PROJECT_ID
KMS_KEYRING_NAME=KMS_KEYRING_NAME
KMS_KEY_NAME=KMS_KEY_NAME
KMS_KEY_LOCATION=global
KMS_KEY_PURPOSE=asymmetric-signing
KMS_KEY_ALGORITHM=ec-sign-p256-sha256
KMS_PROTECTION_LEVEL=software
KMS_KEY_VERSION=1
KEY_FILE=KEY_FILE

    Substitua:

    • KMS_KEY_PROJECT_ID: ID do projeto;
    • KMS_KEYRING_NAME: um nome para o keyring do Cloud KMS
    • KMS_KEY_NAME: um nome para a chave do Cloud KMS
    • KEY_FILE: um caminho local para salvar sua Chave do Cloud KMS

  2. Crie o keyring:

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

  3. Crie a chave:

    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} \
    --project=${KMS_KEY_PROJECT_ID}

  4. Exporte o material da chave pública para um arquivo:

    gcloud kms keys versions get-public-key ${KMS_KEY_VERSION} \
    --key=${KMS_KEY_NAME} \
    --keyring=${KMS_KEYRING_NAME} \
    --location=${KMS_KEY_LOCATION} \
    --output-file=${KEY_FILE} \
    --project=${KMS_KEY_PROJECT_ID}

Chave local

Para criar o par de chaves localmente, faça o seguinte:

  1. Crie a chave privada:

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

  2. Extraia a chave pública da chave privada:

    PUBLIC_KEY_FILE="/tmp/ec_public.pem"
openssl ec -in ${PRIVATE_KEY_FILE} -pubout -out ${PUBLIC_KEY_FILE}

Criar uma política de plataforma

Para criar uma política da plataforma de CV com uma simples verificação de atestado de assinatura, faça isto:

  1. Crie o arquivo YAML de política da plataforma de verificação de atestado de assinatura simples:

    PKIX (Cloud KMS) 

    cat > /tmp/my-policy.yaml << EOF
gkePolicy:
  checkSets:
  - checks:
    - simpleSigningAttestationCheck:
        containerAnalysisAttestationProjects:
        - projects/ATTESTATION_PROJECT_ID
        attestationAuthenticators:
          pkixPublicKeySet:
            pkixPublicKeys:
              publicKeyPem: |
$(awk '{printf "                %s\n", $0}' ${KEY_FILE})
              signatureAlgorithm: ECDSA_P256_SHA256
              keyId: |
                projects/${KMS_KEY_PROJECT_ID}/locations/${KMS_KEY_LOCATION}/keyRings/${KMS_KEYRING_NAME}/cryptoKeys/${KMS_KEY_NAME}/cryptoKeyVersions/${KMS_KEY_VERSION}
EOF

    Substitua ATTESTATION_PROJECT_ID pelo ID do projeto que armazena atestados criados usando essa chave do Cloud KMS.

    Chave local 

    cat > /tmp/my-policy.yaml <<EOF
gkePolicy:
  checkSets:
  - checks:
    - simpleSigningAttestationCheck:
        containerAnalysisAttestationProjects:
        - projects/ATTESTATION_PROJECT_ID
        attestationAuthenticators:
          pkixPublicKeySet:
            pkixPublicKeys:
              publicKeyPem: |
$(awk '{printf "                %s\n", $0}' /tmp/ec_public.pem)
              signatureAlgorithm: ECDSA_P256_SHA256
              keyId: |
                PUBLIC_KEY_ID
EOF

    Substitua:

    • ATTESTATION_PROJECT_ID: o ID do projeto que armazena atestados criados usando a chave local
    • PUBLIC_KEY_ID: um ID que identifica exclusivamente sua chave local.

  2. Crie a política da plataforma:

    Antes de usar os dados do comando abaixo, faça estas substituições:

    • POLICY_ID: um ID de política de plataforma de sua escolha Se a política estiver em outro projeto, use o nome completo do recurso: projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID.
    • POLICY_PATH: um caminho para o arquivo de política.
    • POLICY_PROJECT_ID: o ID do projeto de política.

    Execute o seguinte comando:

    Linux, macOS ou Cloud Shell

    gcloud beta container binauthz policy create POLICY_ID \
    --platform=gke \
    --policy-file=POLICY_PATH \
    --project=POLICY_PROJECT_ID

    Windows (PowerShell)

    gcloud beta container binauthz policy create POLICY_ID `
    --platform=gke `
    --policy-file=POLICY_PATH `
    --project=POLICY_PROJECT_ID

    Windows (cmd.exe)

    gcloud beta container binauthz policy create POLICY_ID ^
    --platform=gke ^
    --policy-file=POLICY_PATH ^
    --project=POLICY_PROJECT_ID

  3. Armazene o valor do ID para uso posterior:

    PUBLIC_KEY_ID="PUBLIC_KEY_ID"

    Substitua PUBLIC_KEY_ID pelo ID especificado no campo keyId no arquivo da política da plataforma mostrado anteriormente neste guia.

    A chave privada é usada quando os atestados são criados, conforme descrito posteriormente neste guia.

Ativar a CV

É possível criar um novo cluster ou atualizar um cluster para usar o monitoramento de CV com políticas de plataforma com base em verificação.

Criar um cluster que use o monitoramento de CV

Nesta seção, você cria um cluster que usa apenas o monitoramento de CV com políticas de plataforma com base em verificação.

Antes de usar os dados do comando abaixo, faça estas substituições:

  • CLUSTER_NAME: um nome de cluster.
  • LOCATION: o local, por exemplo, us-central1 ou asia-south1.
  • POLICY_PROJECT_ID: o ID do projeto em que a política está armazenada.
  • POLICY_ID: o ID da política.
  • CLUSTER_PROJECT_ID: o ID do projeto do cluster.

Execute o seguinte comando:

Linux, macOS ou Cloud Shell

gcloud beta container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --binauthz-evaluation-mode=POLICY_BINDINGS \
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID \
    --project=CLUSTER_PROJECT_ID

Windows (PowerShell)

gcloud beta container clusters create CLUSTER_NAME `
    --location=LOCATION `
    --binauthz-evaluation-mode=POLICY_BINDINGS `
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID `
    --project=CLUSTER_PROJECT_ID

Windows (cmd.exe)

gcloud beta container clusters create CLUSTER_NAME ^
    --location=LOCATION ^
    --binauthz-evaluation-mode=POLICY_BINDINGS ^
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ^
    --project=CLUSTER_PROJECT_ID

Criar um cluster que use aplicação e monitoramento de CV

Nesta seção, você cria um cluster que usa a aplicação de política project-singleton e o monitoramento de CV com políticas de plataforma com base em verificação:

Antes de usar os dados do comando abaixo, faça estas substituições:

  • CLUSTER_NAME: um nome de cluster.
  • LOCATION: o local, por exemplo, us-central1 ou asia-south1.
  • POLICY_PROJECT_ID: o ID do projeto em que a política está armazenada.
  • POLICY_ID: o ID da política.
  • CLUSTER_PROJECT_ID: o ID do projeto do cluster.

Execute o seguinte comando:

Linux, macOS ou Cloud Shell

gcloud beta container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE \
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID \
    --project=CLUSTER_PROJECT_ID

Windows (PowerShell)

gcloud beta container clusters create CLUSTER_NAME `
    --location=LOCATION `
    --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE `
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID `
    --project=CLUSTER_PROJECT_ID

Windows (cmd.exe)

gcloud beta container clusters create CLUSTER_NAME ^
    --location=LOCATION ^
    --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE ^
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ^
    --project=CLUSTER_PROJECT_ID

Atualizar um cluster para usar o monitoramento de CV

Nesta seção, você atualiza um cluster para usar o monitoramento de CV somente com políticas de plataforma com base em verificação. Se o cluster já tiver a aplicação da política de projeto singleton ativada, a execução desse comando a desativará. Em vez disso, atualize o cluster com a aplicação e o monitoramento de CV ativados.

Antes de usar os dados do comando abaixo, faça estas substituições:

  • CLUSTER_NAME: o nome do cluster
  • LOCATION: o local, por exemplo: us-central1 ou asia-south1
  • POLICY_PROJECT_ID: o ID do projeto em que a política está armazenada
  • POLICY_ID: o ID da política
  • CLUSTER_PROJECT_ID: o ID do projeto do cluster

Execute o seguinte comando:

Linux, macOS ou Cloud Shell

gcloud beta container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --binauthz-evaluation-mode=POLICY_BINDINGS \
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID \
    --project=CLUSTER_PROJECT_ID

Windows (PowerShell)

gcloud beta container clusters update CLUSTER_NAME `
    --location=LOCATION `
    --binauthz-evaluation-mode=POLICY_BINDINGS `
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID `
    --project=CLUSTER_PROJECT_ID

Windows (cmd.exe)

gcloud beta container clusters update CLUSTER_NAME ^
    --location=LOCATION ^
    --binauthz-evaluation-mode=POLICY_BINDINGS ^
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ^
    --project=CLUSTER_PROJECT_ID

Atualizar um cluster para usar a aplicação e o monitoramento de CV

Nesta seção, você atualiza um cluster para usar a aplicação da política de projeto singleton e o monitoramento de CV com políticas de plataforma com base em verificação.

Antes de usar os dados do comando abaixo, faça estas substituições:

  • CLUSTER_NAME: um nome de cluster
  • LOCATION: o local, por exemplo: us-central1 ou asia-south1
  • POLICY_PROJECT_ID: o ID do projeto em que a política está armazenada
  • POLICY_ID: o ID da política
  • CLUSTER_PROJECT_ID: o ID do projeto do cluster

Execute o seguinte comando:

Linux, macOS ou Cloud Shell

gcloud beta container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE \
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID \
    --project=CLUSTER_PROJECT_ID

Windows (PowerShell)

gcloud beta container clusters update CLUSTER_NAME `
    --location=LOCATION `
    --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE `
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID `
    --project=CLUSTER_PROJECT_ID

Windows (cmd.exe)

gcloud beta container clusters update CLUSTER_NAME ^
    --location=LOCATION ^
    --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE ^
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ^
    --project=CLUSTER_PROJECT_ID

Criar a nota do Artifact Analysis

Nesta seção, você cria um exemplo de observação do Artifact Analysis para vincular atestados. Para criar a nota, faça o seguinte:

  1. Crie as variáveis de nota:

    NOTE_PROJECT_ID=NOTE_PROJECT_ID
NOTE_ID="test-note"
NOTE_URI="projects/${NOTE_PROJECT_ID}/notes/${NOTE_ID}"
DESCRIPTION="CV test note"

    Substitua NOTE_PROJECT_ID: o ID do projeto que contém a nota.

  2. Crie o arquivo de conteúdo da nota:

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

  3. Crie a nota:

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

    Substitua NOTE_PROJECT_ID: o ID do projeto que contém a nota

  4. Opcional: para verificar se você criou a nota:

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

    Substitua NOTE_PROJECT_ID pelo ID do projeto que contém a nota.

Testar CV

Nesta seção, você testa a CV implantando a imagem em que criou um atestado. Nesse caso, a verificação de atestado simples de CV verifica o atestado e não produz entrada de registro.

Em seguida, você tenta implantar uma imagem diferente que não tem atestado. Nesse caso, a verificação de CV não encontra o atestado e registra a violação no Cloud Logging.

Para criar as variáveis que você usa para testar a CV, execute o seguinte :

IMAGE_PATH="us-docker.pkg.dev/google-samples/containers/gke/hello-app"
IMAGE_DIGEST="sha256:37e5287945774f27b418ce567cd77f4bbc9ef44a1bcd1a2312369f31f9cce567"
IMAGE_TO_ATTEST="${IMAGE_PATH}@${IMAGE_DIGEST}"

Criar um atestado

Para atender à simples verificação de atestado de assinatura, a imagem precisa de um atestado.

É possível criar um atestado usando a gcloud CLI ou a API REST.

PKIX (Cloud KMS)

gcloud

Para criar um atestado usando a gcloud CLI, faça o seguinte:

  1. Assine a imagem e crie o atestado usando a codificação pré-autenticação (PAE). (recomendado):

    gcloud beta container binauthz attestations sign-and-create \
    --artifact-url=${IMAGE_TO_ATTEST} \
    --keyversion=${KMS_KEY_VERSION} \
    --keyversion-key=${KMS_KEY_NAME} \
    --keyversion-keyring=${KMS_KEYRING_NAME} \
    --keyversion-location=${KMS_KEY_LOCATION} \
    --note=${NOTE_URI} \
    --pae-encode-payload \
    --dsse-type=DSSE_TYPE

    Substitua DSSE_TYPE pelo tipo DSSE para codificação PAE. O padrão da flag é application/vnd.dev.cosign.simplesigning.v1+json.

API REST

Para criar um atestado usando a API REST, faça o seguinte:

  1. Crie um arquivo de payload de assinatura:

    cat > /tmp/generated_payload.json << EOM
{
  "critical": {
    "identity": {
      "docker-reference": "${IMAGE_PATH}"
    },
    "image": {
      "docker-manifest-digest": "${IMAGE_DIGEST}"
    },
    "type": "Google Cloud BinAuthz container signature"
  }
}
EOM

  2. Assine o payload:

    gcloud kms asymmetric-sign \
    --version=${KMS_KEY_VERSION} \
    --key=${KMS_KEY_NAME} \
    --keyring=${KMS_KEYRING_NAME} \
    --location=${KMS_KEY_LOCATION} \
    --digest-algorithm=sha256 \
    --input-file=/tmp/generated_payload.json \
    --signature-file=/tmp/ec_signature \
    --project=${KMS_KEY_PROJECT_ID}

  3. Crie o conteúdo do atestado:

    cat > /tmp/attestation.json << EOM
{
"resourceUri": "${IMAGE_TO_ATTEST}",
"note_name": "${NOTE_URI}",
"attestation": {
  "serialized_payload": "$(base64 --wrap=0 /tmp/generated_payload.json)",
  "signatures": [{
    "public_key_id": "${PUBLIC_KEY_ID}",
    "signature": "$(base64 --wrap=0 /tmp/ec_signature)"
  }]
}
}
EOM

  4. Crie o atestado:

    curl -X POST "https://containeranalysis.googleapis.com/v1/projects/${NOTE_PROJECT_ID}/occurrences/" \
  -H "Content-Type: application/json" \
  -H "X-Goog-User-Project: ${NOTE_PROJECT_ID}" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  --data-binary @/tmp/attestation.json

    Substitua NOTE_PROJECT_ID pelo ID do projeto que contém a nota.

Chave local

gcloud

  1. Crie um arquivo de payload de assinatura:

    cat > /tmp/generated_payload.json << EOM
{
  "critical": {
    "identity": {
      "docker-reference": "${IMAGE_PATH}"
    },
    "image": {
      "docker-manifest-digest": "${IMAGE_DIGEST}"
    },
    "type": "Google Cloud BinAuthz container signature"
  }
}
EOM

  2. Crie o arquivo de payload da assinatura:

    openssl dgst -sha256 -sign ${PRIVATE_KEY_FILE} /tmp/generated_payload.json > /tmp/ec_signature

  3. Crie o atestado:

    gcloud container binauthz attestations create \
    --project=ATTESTATION_PROJECT_ID \
    --artifact-url=${IMAGE_TO_ATTEST} \
    --note=${NOTE_URI} \
    --signature-file=/tmp/ec_signature \
    --public-key-id=PUBLIC_KEY_ID

API REST

  1. Crie um arquivo de payload de assinatura:

    cat > /tmp/generated_payload.json << EOM
{
  "critical": {
    "identity": {
      "docker-reference": "${IMAGE_PATH}"
    },
    "image": {
      "docker-manifest-digest": "${IMAGE_DIGEST}"
    },
    "type": "Google Cloud BinAuthz container signature"
  }
}
EOM

  2. Crie o arquivo de payload da assinatura:

    openssl dgst -sha256 -sign ${PRIVATE_KEY_FILE} /tmp/generated_payload.json > /tmp/ec_signature

  3. Crie o conteúdo do atestado:

    cat > /tmp/attestation.json << EOM
{
"resourceUri": "${IMAGE_TO_ATTEST}",
"note_name": "${NOTE_URI}",
"attestation": {
  "serialized_payload": "$(base64 --wrap=0 /tmp/generated_payload.json)",
  "signatures": [{
    "public_key_id": "${PUBLIC_KEY_ID}",
    "signature": "$(base64 --wrap=0 /tmp/ec_signature)"
  }]
}
}
EOM

  4. Crie o atestado:

    curl -X POST "https://containeranalysis.googleapis.com/v1/projects/${NOTE_PROJECT_ID}/occurrences/" \
  -H "Content-Type: application/json" \
  -H "X-Goog-User-Project: ${NOTE_PROJECT_ID}" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  --data-binary @/tmp/attestation.json

Implantar a imagem que tem um atestado

Para implantar uma imagem em que nenhum atestado foi criado, faça isto:

  1. Configurar kubectl:

    gcloud container clusters get-credentials CLUSTER_NAME \
    --location=LOCATION \
    --project=CLUSTER_PROJECT_ID

    Substitua:

    • CLUSTER_NAME: o nome do cluster.
    • LOCATION: o local do cluster
    • CLUSTER_PROJECT_ID: o ID do projeto do cluster

  2. Implante um serviço e verifique a implantação em relação à política de autorização binária:

    kubectl run hello-app-with-attestation --image=$IMAGE_PATH@$IMAGE_DIGEST

    O pod foi implantado. Como a imagem tem um atestado, a CV não produz entradas de registro relacionadas a esse pod.

Implantar uma imagem sem atestado

Nesta seção, você implanta uma imagem que não tem um atestado associado.

Como a política requer atestados e essa imagem não tem um, a CV registra a violação regularmente enquanto o contêiner está em execução.

Para implantar a imagem, execute o seguinte comando:

kubectl run hello-app-without-attestation \
    --image=gcr.io/google-samples/hello-app@sha256:845f77fab71033404f4cfceaa1ddb27b70c3551ceb22a5e7f4498cdda6c9daea

O pod foi implantado. Como a imagem não tem um atestado, a CV produz entradas de registro enquanto o pod está em execução.

Ver registros das entradas de CV

É possível pesquisar entradas do Cloud Logging para encontrar erros de configuração de CV e violações de validação da política da plataforma de CV.

A CV registra erros e violações no Cloud Logging em 24 horas. Geralmente, as entradas aparecem em algumas horas.

Acessar registros de erros de configuração do CV

Para ver os registros de erros de configuração do CV, execute o seguinte comando:

gcloud logging read \
     --order="desc" \
     --freshness=7d \
     --project=CLUSTER_PROJECT_ID \
    'logName:"binaryauthorization.googleapis.com%2Fcontinuous_validation" "configErrorEvent"'

A saída a seguir mostra um erro de configuração em que uma política de CV da plataforma não foi encontrada:

{
  "insertId": "141d4f10-72ea-4a43-b3ec-a03da623de42",
  "jsonPayload": {
    "@type": "type.googleapis.com/google.cloud.binaryauthorization.v1beta1.ContinuousValidationEvent",
    "configErrorEvent": {
      "description": "Cannot monitor cluster 'us-central1-c.my-cluster': Resource projects/123456789/platforms/gke/policies/my-policy does not exist."
    }
  },
  "resource": {
    "type": "k8s_cluster",
    "labels": {
      "cluster_name": "my-cluster",
      "location": "us-central1-c",
      "project_id": "my-project"
    }
  },
  "timestamp": "2024-05-28T15:31:03.999566Z",
  "severity": "WARNING",
  "logName": "projects/my-project/logs/binaryauthorization.googleapis.com%2Fcontinuous_validation",
  "receiveTimestamp": "2024-05-28T16:30:56.304108670Z"
}

Conferir violações de validação da política da plataforma de CVs

Se nenhuma imagem violar as políticas de plataforma que você ativou, nenhuma entrada aparecerá nos registros.

Para ver as entradas de registro da CV dos últimos sete dias, execute o seguinte comando:

gcloud logging read \
     --order="desc" \
     --freshness=7d \
     --project=CLUSTER_PROJECT_ID \
    'logName:"binaryauthorization.googleapis.com%2Fcontinuous_validation" "policyName"'

Substitua CLUSTER_PROJECT_ID pelo ID do projeto de cluster.

Tipos de verificação

Os registros da CV verificam as informações de violação para checkResults. Na entrada, o valor checkType indica a verificação. Os valores para cada verificação são os seguintes:

  • ImageFreshnessCheck
  • SigstoreSignatureCheck
  • SimpleSigningAttestationCheck
  • SlsaCheck
  • TrustedDirectoryCheck
  • VulnerabilityCheck

Exemplo de registro

A entrada de registro da CV de exemplo a seguir descreve uma imagem não compatível que viola a verificação de diretório confiável:

{
  "insertId": "637c2de7-0000-2b64-b671-24058876bb74",
  "jsonPayload": {
    "podEvent": {
      "endTime": "2022-11-22T01:14:30.430151Z",
      "policyName": "projects/123456789/platforms/gke/policies/my-policy",
      "images": [
        {
          "result": "DENY",
          "checkResults": [
            {
              "explanation": "TrustedDirectoryCheck at index 0 with display name \"My trusted directory check\" has verdict NOT_CONFORMANT. Image is not in a trusted directory",
              "checkSetName": "My check set",
              "checkSetIndex": "0",
              "checkName": "My trusted directory check",
              "verdict": "NON_CONFORMANT",
              "checkType": "TrustedDirectoryCheck",
              "checkIndex": "0"
            }
          ],
          "image": "gcr.io/my-project/hello-app:latest"
        }
      ],
      "verdict": "VIOLATES_POLICY",
      "podNamespace": "default",
      "deployTime": "2022-11-22T01:06:53Z",
      "pod": "hello-app"
    },
    "@type": "type.googleapis.com/google.cloud.binaryauthorization.v1beta1.ContinuousValidationEvent"
  },
  "resource": {
    "type": "k8s_cluster",
    "labels": {
      "project_id": "my-project",
      "location": "us-central1-a",
      "cluster_name": "my-test-cluster"
    }
  },
  "timestamp": "2022-11-22T01:44:28.729881832Z",
  "severity": "WARNING",
  "logName": "projects/my-project/logs/binaryauthorization.googleapis.com%2Fcontinuous_validation",
  "receiveTimestamp": "2022-11-22T03:35:47.171905337Z"
}

Limpar

Nesta seção, descrevemos como limpar o monitoramento de CV configurado anteriormente neste guia.

É possível desativar o monitoramento de CV ou a autorização binária e a CV no cluster.

Desativar a autorização binária em um cluster

Para desativar a aplicação do CV e da autorização binária no seu cluster, execute o seguinte comando:

gcloud beta container clusters update CLUSTER_NAME \
    --binauthz-evaluation-mode=DISABLED \
    --location=LOCATION \
    --project=CLUSTER_PROJECT_ID

Substitua:

  • CLUSTER_NAME: o nome do cluster.
  • LOCATION: o local do cluster
  • CLUSTER_PROJECT_ID: o ID do projeto do cluster

Desativar o monitoramento de políticas com base em verificações em um cluster

Para desativar o CV com políticas baseadas em verificação no cluster e reativar a aplicação usando a política de autorização binária, execute o seguinte comando:

gcloud beta container clusters update CLUSTER_NAME  \
    --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE \
    --location=LOCATION \
    --project="CLUSTER_PROJECT_ID"

Substitua:

  • CLUSTER_NAME: o nome do cluster.
  • LOCATION: o local do cluster
  • CLUSTER_PROJECT_ID: o ID do projeto do cluster

Observe que --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE é equivalente à sinalização --enable-binauthz mais antiga.

Exclua a política:

Para excluir a política, execute o comando a seguir. Não é necessário excluir a política de plataforma com base em verificação para desativar esse tipo de auditoria.

gcloud beta container binauthz policy delete POLICY_ID \
    --platform=gke \
    --project="POLICY_PROJECT_ID"

Substitua:

  • POLICY_ID: o ID da política
  • POLICY_PROJECT_ID: o ID do projeto de política

A seguir