Attestierer mithilfe der Befehlszeile erstellen

Auf dieser Seite wird erläutert, wie Sie mit gcloud-Befehlen in der Befehlszeile einen Attestierer für die Binärautorisierung erstellen. Alternativ können Sie diese Schritte auch mit der Google Cloud Console oder der REST API 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.
  • 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 Informationen, die zum Festlegen der IAM-Richtlinie für Ihren Hinweis erforderlich sind:

    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.

Schlüsselpaar generieren

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.

Ein PKIX-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. Beim Deployment verwendet die Binärautorisierung diesen öffentlichen Schlüssel, um die vom privaten Schlüssel signierte Attestierung zu prüfen.

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

  1. Erstellen Sie den privaten Schlüssel:

    PRIVATE_KEY_FILE ist der Name der Datei, die den privaten Schlüssel zum Signieren der Attestierungsnutzlast enthält.

    PRIVATE_KEY_FILE="/tmp/ec_private.pem"
    openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}
    
  2. Extrahieren Sie den öffentlichen Schlüssel aus dem privaten Schlüssel und speichern Sie ihn in einer Datei:

    PUBLIC_KEY_FILE ist der Name der Datei, die den öffentlichen Schlüssel enthält, der im Attestierer gespeichert wird.

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

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.

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 die Attestiererressource in der Binärautorisierung:

    gcloud --project="${ATTESTOR_PROJECT_ID}" \
        beta container binauthz attestors create "${ATTESTOR_NAME}" \
        --attestation-authority-note="${NOTE_ID}" \
        --attestation-authority-note-project="${ATTESTOR_PROJECT_ID}"
    
  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 verknüpfte Attestierungen hat.

    gcloud beta container binauthz attestors add-iam-policy-binding \
      "projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}" \
      --member="serviceAccount:${DEPLOYER_SERVICE_ACCOUNT}" \
      --role=roles/binaryauthorization.attestorsVerifier
    
  4. Fügen Sie dem Attestierer den öffentlichen Schlüssel hinzu:

    PKIX (lokaler Schlüssel)

    1. Fügen Sie einem Attestierer einen lokal gespeicherten öffentlichen PKIX-Schlüssel hinzu:

      Fügen Sie nun den öffentlichen Schlüssel hinzu, den Sie zum Attestierer exportiert haben, damit er von der Binärautorisierung zur Identitätsprüfung verwendet werden kann:

      gcloud --project="${ATTESTOR_PROJECT_ID}" \
         beta container binauthz attestors public-keys add \
         --attestor="${ATTESTOR_NAME}" \
         --pkix-public-key-file=${PUBLIC_KEY_FILE} \
         --pkix-public-key-algorithm=ecdsa-p256-sha256
      

      Hinweis: Wenn Sie einem Attestierer einen öffentlichen Schlüssel hinzufügen und keine Schlüssel-ID (beliebiger String) angeben, wird für diesen automatisch ein Wert im RFC 6920-Format festgelegt: ni:///sha-256;.... Dabei ist ... ein codierter Hash des öffentlichen Schlüssels. Dieser Wert wird im Feld id der Befehlsausgabe zurückgegeben. Die zurückgegebene ID kann in PUBLIC_KEY_ID gespeichert und zum Erstellen einer Attestierung verwendet werden.

    2. Speichern Sie die ID des öffentlichen Schlüssels.

      Sie benötigen die ID des öffentlichen Schlüssels, wenn Sie eine Attestierung erstellen. Sie können die ID aus der Ausgabe des obigen Befehls binauthz attestors public-keys add speichern.

      Alternativ haben Sie jederzeit die Möglichkeit, die ID des öffentlichen Schlüssels des Attestierers mit dem Befehl gcloud container binauthz attestors describe ${ATTESTOR} aufzurufen.

      Um die ID des öffentlichen Schlüssels in einer Umgebungsvariablen zu speichern, geben Sie den folgenden Befehl ein:

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

    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
      

      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.
      • 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.
    2. Optional: Richten Sie einen KMS-Schlüssel ein:

      Erstellen Sie einen KMS-Schlüssel, der in einem Attestierer gespeichert werden kann. In diesem Schritt werden auch Umgebungsvariablen eingerichtet, die Sie weiter unten verwenden.

      So erstellen Sie einen Schlüssel und richten die Umgebungsvariablen ein:

      KMS_KEY_PROJECT_ID=${PROJECT_ID}
      KMS_KEYRING_NAME=my-binauthz-keyring
      KMS_KEY_NAME=my-binauthz-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
      
      1. Erstellen Sie einen KMS-Schlüsselbund:
      gcloud kms keyrings create ${KMS_KEYRING_NAME} \
        --location ${KMS_KEY_LOCATION}
      
      1. Erstellen Sie den Schlüssel:
      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}
      

      Weitere Informationen zum Erstellen von KMS-Schlüsseln finden Sie unter Asymmetrischen Schlüssel erstellen.

    3. Fügen Sie dem Attestierer den öffentlichen Schlüssel hinzu:

      gcloud --project="${ATTESTOR_PROJECT_ID}" \
          alpha 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}"
      

Erstellung des Attestierers prüfen

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

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

Weitere Informationen