Crea certificadores mediante la herramienta de gcloud

En esta página, se explica cómo crear un certificador en la autorización binaria mediante la herramienta de línea de comandos de gcloud. Como alternativa, también puedes realizar estos pasos mediante Google Cloud Console o la API de REST. Esta tarea forma parte de la configuración de la autorización binaria.

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

Para crear un certificador, debes hacer lo siguiente:

  • Crea una nota en Container Analysis para almacenar los metadatos de confianza que se usan en el proceso de certificación.
  • Configura un par de claves de 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. En una configuración de varios proyectos, lo más probable es que tengas un proyecto de implementador en el que se configure la política y un proyecto de certificador independiente en el que se almacenen los certificadores.

Configure el entorno

Configura las variables de entorno para almacenar los nombres y números de tus proyectos:

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

Si los proyectos de implementador y certificador se encuentran el mismo proyecto, usa el mismo ID del proyecto para ambas variables. Para ver un instructivo de extremo a extremo que describa la separación de obligaciones mediante múltiples proyectos, consulta Configuración de varios proyectos.

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 Container Analysis

La autorización binaria usa Container 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 Container Analysis. Cada certificación se almacena como un caso de esta nota.

Para crear una nota de Container Analysis, sigue estos pasos:

  1. Configura variables de entorno para almacenar el ID de nota y una descripción legible:

    NOTE_ID=NOTE_ID
    NOTE_URI="projects/${ATTESTOR_PROJECT_ID}/notes/${NOTE_ID}"
    DESCRIPTION=DESCRIPTION
    

    Reemplaza lo siguiente:

    • NOTE_ID es el nombre interno de la nota en caracteres alfanuméricos sin espacios (por ejemplo, test-attestor-note).
    • NOTE_URI es la ruta completamente calificada al recurso de nota.
    • DESCRIPTION es el nombre visible y legible de la nota (por ejemplo, Test Attestor Note).
  2. En un editor de texto, crea un archivo JSON en /tmp/note_payload.json que describa la nota de Container Analysis:

    cat > /tmp/note_payload.json << EOM
    {
      "name": "${NOTE_URI}",
      "attestation": {
        "hint": {
          "human_readable_name": "${DESCRIPTION}"
        }
      }
    }
    EOM
    
  3. Envía una solicitud HTTP a la API de REST de Container 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 creó de forma correcta, 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 Identity and Access Management en la nota

Debes otorgar una función de Identity and Access Management (IAM) a la cuenta de servicio del proyecto del certificador en el recurso de nota de Container Analysis. Para ello, agrega la cuenta de servicio del proyecto del certificador a la función containeranalysis.notes.occurrences.viewer en la política de IAM de la nota.

Para agregar la función, sigue estos pasos:

  1. 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
    
  2. 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"
    

Uso de varios proyectos

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

Configura claves criptográficas

La autorización binaria te permite usar claves de PKIX para verificar de forma segura la identidad del firmante que creó una certificación. Esto garantiza que solo las partes verificadas puedan autorizar una imagen de contenedor. Como alternativa a PKIX, también puedes usar las claves de PGP.

Genera un par de claves

En esta guía, se usa el Algoritmo de firma digital de curva elíptica (ECDSA) recomendado para generar un par de claves de PKIX. También puedes usar las claves de RSA o PGP para firmar. 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 el firmante usa para firmar de forma digital las certificaciones, y una clave pública, que agregas al certificador. En el momento de la implementación, la autorización binaria usa esta clave pública para verificar la certificación que firma la clave privada.

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

  1. 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}
    
  2. 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 almacenará en el certificador.

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

Los pares de claves asimétricas que se generaron y almacenaron en Cloud KMS son compatibles con el formato PKIX. Para crear una clave de Cloud KMS que se pueda usar con la autorización binaria, consulta Crea claves asimétricas. Asegúrate de elegir la firma asimétrica como propósito de la clave cuando crees la clave.

Crea el certificador

El siguiente paso es crear el certificador en la autorización binaria con la nota de Container Analysis asociada. También debes agregar la clave criptográfica pública.

Para crear el certificador, sigue estos pasos:

  1. 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).

  2. 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}"
    
  3. 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
    
  4. Agrega la clave pública al certificador:

    PKIX (clave local)

    1. Agrega una clave pública de PKIX almacenada de forma local a un certificador:

      Ahora, agrega la clave pública que exportaste al certificador a fin de que la autorización binaria pueda usarla para la verificación de identidad:

      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
      

      Nota: 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.

    2. Guarda el ID de la clave pública.

      Cuando crees una certificación, necesitarás el ID de la clave pública. Para guardar el ID de la clave pública, puedes guardarlo 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)')
      

    PKIX (Cloud KMS)

    1. Configura las variables de entorno para almacenar información sobre el par de claves administradas por Cloud KMS:

      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: es 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. Te recomendamos ec-sign-p256-sha256.
      • KMS_PROTECTION_LEVEL: el nivel de protección, por ejemplo, software.
    2. Crea un llavero de claves de Cloud KMS:

      gcloud --project ${KMS_KEY_PROJECT_ID} kms keyrings create \
        ${KMS_KEYRING_NAME} \
        --location ${KMS_KEY_LOCATION}
      
    3. Crea la clave:

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

      Para obtener más información sobre cómo crear claves de KMS, consulta Crea una clave asimétrica.

    4. Agrega la clave pública al certificador:

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

Verifica que se haya creado el certificador

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

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

¿Qué sigue?