Attestierer mit der REST API erstellen

Auf dieser Seite wird erläutert, wie Sie mit der REST API einen Attestierer in der Binärautorisierung erstellen. Alternativ können Sie diese Schritte auch mit gcloud-Befehlen in der Befehlszeile oder mit der Google Cloud Console ausführen. Diese Aufgabe ist Teil der Einrichtung der Binärautorisierung.

Übersicht

Ein Attestierer ist eine GCP-Ressource, mit der die Binärautorisierung eine Attestierung prüft. Weitere Informationen zu Attestierungen finden Sie in der Übersicht über die Binärautorisierung.

So erstellen Sie einen Attestierer:

  • Erstellen Sie einen Hinweis in Container Analysis, um darin vertrauenswürdige Metadaten zu speichern, die für den Attestierungsvorgang verwendet werden.
  • Richten Sie ein PKIX-Schlüsselpaar ein, mit dem die Identität des Attestierers geprüft werden kann. Asymmetrische Schlüsselpaare, die vom Cloud Key Management Service (Cloud KMS) generiert werden, haben ein PKIX-kompatibles Format. Sie können anstelle von PKIX-Schlüsseln auch PGP-Schlüsselpaare verwenden.
  • Erstellen Sie den Attestierer in der Binärautorisierung und verknüpfen Sie den Hinweis mit dem öffentlichen Schlüssel, den Sie erstellt haben.

In einer Einzelprojekteinrichtung erstellen Sie den Attestierer im selben Google Cloud-Projekt, in dem Sie die Richtlinie für die Binärautorisierung konfigurieren. Bei einer Einrichtung mit mehreren Projekten haben Sie höchstwahrscheinlich ein Bereitstellerprojekt, in dem Ihre Richtlinie konfiguriert ist, sowie ein separates Attestiererprojekt, in dem Ihre Attestierer gespeichert sind.

Standardprojekt festlegen

Legen Sie das Google Cloud-Standardprojekt fest, falls Sie dies noch nicht getan haben:

PROJECT_ID=PROJECT_ID
gcloud config set project ${PROJECT_ID}

Umgebung einrichten

Richten Sie Umgebungsvariablen zum Speichern Ihrer Projektnamen und -nummern ein:

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

Wenn Ihr Attestiererprojekt mit Ihrem Bereitstellerprojekt identisch ist, verwenden Sie für beide Variablen dieselbe Projekt-ID.

Außerdem müssen Sie die Dienstkontonamen für die Projekte abrufen:

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"

Container Analysis-Hinweis erstellen

Die Binärautorisierung verwendet Container Analysis, um vertrauenswürdige Metadaten zu speichern, die für den Autorisierungsvorgang verwendet werden. Für jeden von Ihnen erstellten Attestierer muss ein Container Analysis-Hinweis angelegt werden. Jede Attestierung wird als Vorkommen dieses Hinweises gespeichert.

So erstellen Sie einen Container Analysis-Hinweis:

  1. Richten Sie Umgebungsvariablen zum Speichern der Hinweis-ID und einer für Menschen lesbare Beschreibung ein:

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

    Dabei gilt:

    • NOTE_ID ist der interne Name des Hinweises in alphanumerischen Zeichen ohne Leerzeichen (z. B. test-attestor-note).
    • NOTE_URI ist der voll qualifizierte Pfad zur Hinweisressource.
    • DESCRIPTION ist ein für Menschen lesbarer Anzeigename für den Hinweis (z. B. Test Attestor Note).
  2. Erstellen Sie in einem Texteditor eine JSON-Datei in /tmp/note_payload.json, die den Container Analysis-Hinweis beschreibt:

    cat > /tmp/note_payload.json << EOM
    {
      "name": "${NOTE_URI}",
      "attestation": {
        "hint": {
          "human_readable_name": "${DESCRIPTION}"
        }
      }
    }
    EOM
    
  3. Erstellen Sie den Hinweis durch Senden einer HTTP-Anfrage an die Container Analysis REST API:

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

So prüfen Sie, ob der Hinweis erstellt wurde:

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

Berechtigungen für den Hinweis festlegen

Sie müssen auch Berechtigungen für den von Ihnen erstellten Container Analysis-Hinweis festlegen, damit er für das Dienstkonto des Attestiererprojekts zugänglich ist. Aktualisieren Sie dazu die IAM-Richtlinie für den Hinweis und weisen Sie dem Konto die Rolle containeranalysis.notes.occurrences.viewer zu.

So legen Sie die Berechtigungen fest:

  1. Erstellen Sie eine JSON-Datei mit den erforderlichen Informationen, um die IAM-Richtlinie für Ihren Hinweis festzulegen:

    cat > /tmp/iam_request.json << EOM
    {
      'resource': '${NOTE_URI}',
      'policy': {
        'bindings': [
          {
            'role': 'roles/containeranalysis.notes.occurrences.viewer',
            'members': [
              'serviceAccount:${ATTESTOR_SERVICE_ACCOUNT}'
            ]
          }
        ]
      }
    }
    EOM
    
  2. Fügen Sie der IAM-Richtlinie für den von Ihnen erstellten Hinweis das Dienstkonto und die angeforderten Zugriffsrollen hinzu:

    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"
    

Kryptografische Schlüssel einrichten

Mit der Binärautorisierung können Sie mithilfe von PKIX-Schlüsseln die Identität des Signaturgebers, der eine Attestierung erstellt hat, sicher prüfen. Dies gewährleistet, dass nur bestätigte Nutzer ein Container-Image autorisieren können. Alternativ zu PKIX haben Sie auch die Möglichkeit, PGP-Schlüssel zu verwenden.

PKIX-Schlüsselpaar erstellen

Mit der Binärautorisierung können Sie zur Bestätigung einer Attestierung asymmetrische PKIX-Schlüsselpaare verwenden. Das Schlüsselpaar besteht aus einem privaten Schlüssel, mit dem der Signaturgeber Attestierungen digital signiert, und einem öffentlichen Schlüssel, den Sie dem Attestierer hinzufügen. Später prüft der Erzwinger der Binärautorisierung anhand des öffentlichen Schlüssels im Attestierer, ob die Attestierung vom Signaturgeber erstellt wurde.

In diesem Leitfaden wird der empfohlene Elliptic Curve Digital Signing Algorithm (ECDSA) verwendet, um ein PKIX-Schlüsselpaar zu erstellen. Sie können zum Signieren auch RSA- oder PGP-Schlüssel verwenden. Weitere Informationen zu Signieralgorithmen finden Sie unter Schlüsselzwecke und Algorithmen.

Die in Cloud KMS erstellten und gespeicherten asymmetrischen Schlüsselpaare sind mit dem PKIX-Format konform. Informationen zum Erstellen eines Cloud KMS-Schlüssels für die Binärautorisierung finden Sie unter Asymmetrische Schlüssel erstellen. Achten Sie darauf, dass beim Erstellen des Schlüssels als Schlüsselzweck Asymmetrisches Signieren ausgewählt wird.

So erstellen Sie ein neues lokales asymmetrisches PKIX-Schlüsselpaar und speichern es in einer Datei:

  1. Erstellen Sie den Domainschlüssel:

    PRIVATE_KEY_FILE="/tmp/ec_private.pem"
    openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}
    
  2. Da diese Datei einen öffentlichen und einen privaten Schlüssel enthält, müssen Sie den öffentlichen Schlüssel in eine eigene Datei extrahieren, damit Sie ihn dem Attestierer hinzufügen können:

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

Attestierer erstellen

Im nächsten Schritt erstellen Sie den Attestierer in der Binärautorisierung mit dem verknüpften Container Analysis-Hinweis. Außerdem müssen Sie den kryptografischen öffentlichen Schlüssel hinzufügen.

So erstellen Sie den Attestierer:

  1. Richten Sie eine Umgebungsvariable zum Speichern des Namens des Attestierers wie in der Binärautorisierung definiert ein:

    ATTESTOR_NAME=ATTESTOR_NAME
    

    Dabei ist ATTESTOR_NAME der Name des Attestierers, den Sie erstellen möchten (z. B. build-secure oder prod-qa).

  2. Erstellen Sie den Attestierer und hängen Sie den öffentlichen Sicherheitsschlüssel an:

    PKIX (lokaler Schlüssel)

    1. Erstellen Sie eine JSON-Datei, die die zum Erstellen des Attestierers erforderlichen Informationen enthält:

      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
      
    2. Erstellen Sie den Attestierer:

      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 (Cloud KMS)

    1. Richten Sie Umgebungsvariablen zum Speichern von Informationen über das von Cloud KMS verwaltete Schlüsselpaar ein:

      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_TYPE=KMS_KEY_TYPE
      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}"
      

      Dabei gilt:

      • KMS_KEY_PROJECT_ID ist die ID des Projekts, in dem die Schlüssel gespeichert sind.
      • KMS_KEY_LOCATION ist der Speicherort des Schlüssels (z. B. global).
      • KMS_KEYRING_NAME ist der Name des Schlüsselbunds.
      • KMS_KEY_NAME ist der Name des Schlüssels.
      • KMS_KEY_VERSION ist die Schlüsselversion.
      • KMS_KEY_TYPE ist der Verschlüsselungstyp für den Schlüssel (z. B. ECDSA_P256_SHA256).
    2. Laden Sie die öffentliche Schlüsseldatei von Cloud KMS herunter und speichern Sie sie auf Ihrem lokalen System in einer Datei namens /tmp/kms_public_key.pem.

    3. Erstellen Sie eine JSON-Datei, die die zum Erstellen des Attestierers erforderlichen Informationen enthält:

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

      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}"
      
  3. Fügen Sie dem Attestierer eine IAM-Rollenbindung für das Bereitstellerprojekt hinzu. Diese wird von der Binärautorisierung verwendet, wenn eine Richtlinie ausgewertet wird, um festzustellen, ob das Projekt Berechtigungen zum Zugriff auf den entsprechenden Attestierer hat.

    Erstellen Sie eine JSON-Datei mit den Informationen, die zum Festlegen der IAM-Richtlinie für Ihren Attestierer erforderlich sind:

    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
    

    Fügen Sie der IAM-Richtlinie für den von Ihnen erstellten Hinweis das Dienstkonto und die angeforderten Zugriffsrollen hinzu:

    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/v1/projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}:setIamPolicy"
    

Erstellung des Attestierers prüfen

So prüfen Sie, ob der Attestierer erstellt wurde:

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

Weitere Informationen