Se usó la API de Cloud Translation para traducir esta página.

Crea certificadores mediante la CLI de gcloud

En esta página, se explica cómo crear un certificador en Autorización Binaria mediante Google Cloud CLI. Como alternativa, también puedes realizar estos pasos mediante la consola de Google Cloud o la API de REST. Esta tarea forma parte de la configuración de Autorización Binaria.

Usuarios de Cloud Build: En su lugar, puedes usar el certificador built-by-cloud-build para implementar solo imágenes compiladas por Cloud Build.

Un certificador es un recurso de Google Cloud que Autorización Binaria usa para verificar una certificación. Para obtener más información sobre las certificaciones, consulta la Descripción general de Autorización Binaria.

Para crear un certificador, haz lo siguiente:

Crea una nota en Artifact Analysis para almacenar los metadatos de confianza que se usan en el proceso de certificación.
Configura un par de claves de infraestructura de clave pública (X.509) (PKIX) que se pueda usar para verificar la identidad del certificador. [los pares de claves asimétricas que genera Cloud Key Management Service (Cloud KMS) tienen un formato compatible con PKIX].
Crea el certificador en la autorización binaria y asocia la nota y la clave pública que creaste.

En una configuración de un solo proyecto, debes crear el certificador en el mismo proyecto de Google Cloud en el que configuras la política de Autorización Binaria. Para obtener un instructivo de extremo a extremo de un solo proyecto que incluya estos pasos, consulta Comienza a usar Google Cloud CLI o Comienza a usar la consola de Google Cloud.

En una configuración de varios proyectos, te recomendamos que tengas proyectos separados: un proyecto de implementador, en el que se configura la política; un proyecto de certificador, en el que se almacenan tus certificadores y un proyecto de certificación para certificaciones. Para obtener un instructivo de extremo a extremo de varios proyectos que incluya estos pasos, consulta Configuración de varios proyectos.

Antes de comenzar

Antes de crear certificadores, haz lo siguiente:

Configurar el entorno del proyecto

En esta sección, configurarás variables de entorno.

Configura las variables de entorno para almacenar los nombres y números de tus proyectos. Si los proyectos de implementador y certificador se encuentran el mismo proyecto, usa el mismo ID del proyecto para ambas variables.

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

También debes obtener los nombres de las cuentas de servicio para los proyectos:

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"

Crea una nota de Artifact Analysis

Autorización Binaria usa Artifact Analysis para almacenar los metadatos de confianza que se usan en el proceso de autorización. En cada certificador que creas, se debe crear una nota de Artifact Analysis. Cada certificación se almacena como un caso de esta nota.

Para crear la nota, sigue estos pasos:

Configura variables de entorno para almacenar el ID de nota y una descripción legible por humanos:
```
NOTE_ID=NOTE_ID
NOTE_URI="projects/${ATTESTOR_PROJECT_ID}/notes/${NOTE_ID}"
DESCRIPTION=DESCRIPTION
```
Reemplaza lo siguiente:
- NOTE_ID: el nombre interno de la nota en caracteres alfanuméricos sin espacios (por ejemplo, test-attestor-note).
- NOTE_URI: la ruta completamente calificada al recurso de nota.
- DESCRIPTION: un nombre visible y legible por humanos de la nota (por ejemplo, Test Attestor Note).

En un editor de texto, crea un archivo JSON que describa la nota:

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

Envía una solicitud HTTP a la API de REST de Artifact Analysis para crear la nota:

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 que la nota se haya creado correctamente, ejecuta el siguiente 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/"

Establece permisos de IAM en la nota

Debes otorgar un rol de Identity and Access Management (IAM) a la cuenta de servicio del proyecto del certificador en el recurso de nota de Artifact Analysis. Para ello, agrega la cuenta de servicio del proyecto de certificador al rol containeranalysis.notes.occurrences.viewer en la política de IAM de la nota.

Para agregar el rol, haz lo siguiente:

Genera un archivo JSON que contenga la información necesaria para establecer la función de IAM en la nota:

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

Agrega la cuenta de servicio y las funciones de acceso solicitadas a la política de IAM para la nota que creaste:
```
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: Cuando agregas un rol a la política mediante el método anterior, se reemplaza cualquier rol existente en la nota. Si deseas conservar los roles existentes, asegúrate de incluirlos en el archivo de datos JSON anterior.

Uso de varios proyectos

Si almacenas el certificador en un proyecto y realizas la implementación en un proyecto separado, debes otorgar el rol roles/binaryauthorization.attestorsVerifier a la cuenta de servicio asociada con el proyecto del implementador en el certificador.

Configura claves criptográficas

Autorización Binaria te permite usar claves de PKIX para verificar las certificaciones.

Genera un par de claves

En esta guía, usarás el Algoritmo de firma digital de curva elíptica (ECDSA) que se recomienda para generar un par de claves de PKIX. También puedes usar pares de claves RSA o PGP. Consulta Algoritmos y propósitos de clave para obtener más información sobre los algoritmos de firma.

Un par de claves de PKIX consta de una clave privada que los firmantes usan para firmar certificaciones y una clave pública que agregas al certificador. En el momento de la implementación, Autorización Binaria usa esta clave pública para verificar la certificación.

PKIX (Cloud KMS)

Para crear el par de claves en Cloud KMS, haz lo siguiente:

A fin de configurar las variables de entorno necesarias para crear el par de claves, ejecuta los siguientes 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
```
Reemplaza lo siguiente:
- KMS_KEY_PROJECT_ID: el ID del proyecto en el que se almacenan las claves.
- KMS_KEY_LOCATION: es la ubicación de la clave.
- KMS_KEYRING_NAME: es el nombre del llavero de claves.
- KMS_KEY_NAME: el nombre de la clave.
- KMS_KEY_VERSION: es la versión de la clave.
- KMS_KEY_ALGORITHM: el algoritmo; se recomienda ec-sign-p256-sha256
- KMS_PROTECTION_LEVEL: el nivel de protección, por ejemplo, software.

Para crear el llavero de claves, ejecuta el siguiente comando:

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

Para crear la clave, ejecuta el siguiente 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}
```
Reemplaza lo siguiente:
- KMS_KEY_NAME: el nombre de la clave.
- KMS_KEY_LOCATION: es la ubicación de la clave.
- KMS_KEYRING_NAME: es el nombre del llavero de claves.
- KMS_KEY_PURPOSE: el propósito de la clave, configurado como ASYMMETRIC_SIGN
- KMS_KEY_ALGORITHM: el algoritmo, se recomienda ec-sign-p256-sha256.
- KMS_PROTECTION_LEVEL: el nivel de protección, por ejemplo, software.

PKIX (clave local)

Sigue estos pasos para generar un nuevo par de claves asimétricas local de PKIX y almacenarlo en un archivo:

Genera la clave privada:

PRIVATE_KEY_FILE es el nombre del archivo que contiene la clave privada que se usa para firmar la carga útil de la certificación.
```
PRIVATE_KEY_FILE="/tmp/ec_private.pem"
openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}
```
Extrae la clave pública de la clave privada y guárdala en un archivo:

PUBLIC_KEY_FILE es el nombre del archivo que contiene la clave pública que se almacena en el certificador.
```
PUBLIC_KEY_FILE="/tmp/ec_public.pem"
openssl ec -in ${PRIVATE_KEY_FILE} -pubout -out ${PUBLIC_KEY_FILE}
```

Crea el certificador

Para crear el certificador, sigue estos pasos:

Configura una variable de entorno para almacenar el nombre del certificador, como se define en la autorización binaria:
```
ATTESTOR_NAME=ATTESTOR_NAME
```
En el ejemplo anterior, ATTESTOR_NAME es el nombre del certificador que deseas crear (por ejemplo, build-secure o prod-qa).

Crea el recurso del certificador en la autorización binaria:

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

Agrega una vinculación de función de IAM para el proyecto del implementador al certificador. La autorización binaria usa esta vinculación cuando evalúa una política a fin de determinar si el proyecto tiene permisos para acceder a alguna certificación asociada.
```
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 agregar la clave pública al certificador, haz lo siguiente:
PKIX (Cloud KMS)
Para agregar la clave pública desde un par de claves de Cloud KMS al certificador, ejecuta el siguiente 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 (clave local)
Para agregar una clave pública de PKIX almacenada de forma local a un certificador, ejecuta el siguiente 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
```
Si agregas una clave pública a un certificador y no especificas un ID de clave (que puede ser cualquier string), se le otorgará uno de forma automática en el formato RFC 6920: ni:///sha-256;..., en el que ... es un hash codificado de la clave pública. Este valor se muestra en el campo id del resultado del comando. El ID que se muestra se puede guardar en PUBLIC_KEY_ID y se usa para crear una certificación.

Guarda el ID de clave pública

Para crear una certificación, necesitas el ID de la clave pública.

Para guardar el ID de la clave pública, puedes copiarlolo desde el resultado del comando binauthz attestors public-keys add anterior.

Como alternativa, puedes ver el ID de la clave pública del certificador en cualquier momento mediante el comando:

gcloud container binauthz attestors describe ${ATTESTOR}.

Para guardar tu ID de clave pública en una variable de entorno, ingresa el siguiente comando:

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

Verifica que se haya creado el certificador

Para verificar que se haya creado el certificador, ejecuta el siguiente comando:

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

¿Qué sigue?

Obtén más información sobre cómo crear certificaciones para tu certificador.
Actualiza tu política de Autorización Binaria para requerir certificaciones mediante la consola de Google Cloud, Google Cloud CLI y la API de REST.