Diese Seite wurde von der Cloud Translation API übersetzt.

Attestierer mit der gcloud CLI erstellen

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

Cloud Build-Nutzer: Sie können stattdessen den Attestierer built-by-cloud-build verwenden, um nur von Cloud Build erstellte Images bereitzustellen.

Ein Attestierer ist eine Google Cloud-Ressource, mit der die Binärautorisierung eine Attestierung prüft. Weitere Informationen zu Attestierungen finden Sie unter Überblick über die Binärautorisierung.

So erstellen Sie einen Attestierer:

Erstellen Sie einen Hinweis in Artefaktanalyse, um darin vertrauenswürdige Metadaten zu speichern, die für den Attestierungsvorgang verwendet werden.
Richten Sie ein PKIX-Schlüsselpaar (Public-Key-Infrastruktur, X.509) ein, mit dem die Identität des Attestators 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. Eine End-to-End-Anleitung für ein einzelnes Projekt, die diese Schritte enthält, finden Sie unter Erste Schritte mit der Google Cloud CLI oder Erste Schritte mit der Google Cloud Console.

Bei einer Einrichtung mit mehreren Projekten empfehlen wir, separate Projekte zu haben: ein Bereitstellerprojekt, in dem Ihre Richtlinie konfiguriert ist; ein Attestiererprojekt, in dem Ihre Attestierer gespeichert sind, und ein Attestierungsprojekt für Attestierungen. Eine End-to-End-Anleitung für mehrere Projekte, die diese Schritte enthält, finden Sie unter Mehrere Projekte einrichten.

Hinweise

Führen Sie vor dem Erstellen von Attestierern die folgenden Schritte aus:

Projektumgebung einrichten

In diesem Abschnitt richten Sie Umgebungsvariablen ein.

Richten Sie Umgebungsvariablen zum Speichern Ihrer Projektnamen und -nummern ein: Wenn Ihr Attestiererprojekt mit Ihrem Bereitstellerprojekt identisch ist, verwenden Sie für beide Variablen dieselbe Projekt-ID.

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

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"

Artefaktanalyse-Hinweis erstellen

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

So erstellen Sie den Hinweis:

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
```
Ersetzen Sie Folgendes:
- 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).

Erstellen Sie in einem Texteditor eine JSON-Datei, in der der Hinweis beschrieben wird:

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

Erstellen Sie den Hinweis durch Senden einer HTTP-Anfrage an die Artifact 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}"

Um zu prüfen, ob der Hinweis erstellt wurde, führen Sie folgenden Befehl aus:

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

IAM-Berechtigungen für den Hinweis festlegen

Sie müssen dem Dienstkonto des Attestiererprojekts in der Artefaktanalyse-Hinweisressource eine IAM-Rolle (Identity and Access Management) zuweisen. Fügen Sie dazu das Dienstkonto des Attestiererprojekts der Rolle containeranalysis.notes.occurrences.viewer in der IAM-Richtlinie des Hinweises hinzu.

So fügen Sie die Rolle hinzu:

Erstellen Sie eine JSON-Datei mit den Informationen, die zum Festlegen der IAM-Rolle 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

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"
```
Hinweis: Wenn Sie der Richtlinie mithilfe der obigen Methode eine Rolle hinzufügen, werden alle vorhandenen Rollen für den Hinweis ersetzt. Wenn Sie vorhandene Rollen beibehalten möchten, nehmen Sie diese in die vorherige JSON-Datendatei auf.

Mehrere Projekte verwenden

Wenn Sie den Attestierer in einem Projekt speichern und in einem separaten Projekt bereitstellen, müssen Sie dem Dienstkonto, das dem Bereitstellerprojekt auf dem Attestierer zugeordnet ist, die Rolle roles/binaryauthorization.attestorsVerifier zuweisen.

Kryptografische Schlüssel einrichten

Mit der Binärautorisierung können Sie mithilfe von PKIX-Schlüsseln Attestierungen prüfen.

Schlüsselpaar generieren

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

Ein PKIX-Schlüsselpaar besteht aus einem privaten Schlüssel, mit dem Unterzeichner Attestierungen signieren, und einen öffentlichen Schlüssel, den Sie dem Attestierer hinzufügen. Beim Deployment verwendet die Binärautorisierung diesen öffentlichen Schlüssel, um die Attestierung zu prüfen.

PKIX (Cloud KMS)

So erstellen Sie das Schlüsselpaar in Cloud KMS:

Führen Sie die folgenden Befehle aus, um Umgebungsvariablen einzurichten, die zum Erstellen des Schlüsselpaars erforderlich sind:
```
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
```
Ersetzen Sie Folgendes:
- KMS_KEY_PROJECT_ID: die ID des Projekts, in dem die Schlüssel gespeichert sind.
- KMS_KEY_LOCATION: der Speicherort des Schlüssels
- KMS_KEYRING_NAME: der Name des Schlüsselbunds
- KMS_KEY_NAME: der Name des Schlüssels
- KMS_KEY_VERSION: die Schlüsselversion
- KMS_KEY_ALGORITHM: der Algorithmus; ec-sign-p256-sha256 wird empfohlen
- KMS_PROTECTION_LEVEL: das Schutzniveau, z. B. software.

Führen Sie den folgenden Befehl aus, um das Schlüsselbund zu erstellen:

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

Führen Sie den folgenden Befehl aus, um den Schlüssel zu erstellen:
```
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}
```
Ersetzen Sie Folgendes:
- KMS_KEY_NAME: der Name des Schlüssels
- KMS_KEY_LOCATION: der Speicherort des Schlüssels
- KMS_KEYRING_NAME: der Name des Schlüsselbunds
- KMS_KEY_PURPOSE: der Zweck des Schlüssels, festgelegt auf ASYMMETRIC_SIGN
- KMS_KEY_ALGORITHM: der Algorithmus, ec-sign-p256-sha256 wird empfohlen
- KMS_PROTECTION_LEVEL: das Schutzniveau, z. B. software.

PKIX (lokaler Schlüssel)

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

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

Attestierer erstellen

So erstellen Sie den Attestierer:

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

Erstellen Sie die Attestiererressource in der Binärautorisierung:

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

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 container binauthz attestors add-iam-policy-binding \
    "projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}" \
    --member="serviceAccount:${DEPLOYER_SERVICE_ACCOUNT}" \
    --role=roles/binaryauthorization.attestorsVerifier
```
So fügen Sie dem Attestierer den öffentlichen Schlüssel hinzu:
PKIX (Cloud KMS)
Führen Sie den folgenden Befehl aus, um dem Attestierer den öffentlichen Schlüssel aus einem Cloud KMS-Schlüsselpaar hinzuzufügen:
```
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 (lokaler Schlüssel)
Führen Sie folgenden Befehl aus, um einem Attestierer einen lokal gespeicherten öffentlichen PKIX-Schlüssel hinzuzufügen:
```
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
```
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.

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 kopieren.

Alternativ haben Sie jederzeit die Möglichkeit, die ID des öffentlichen Schlüssels des Attestierers mit dem folgenden Befehl aufzurufen:

gcloud container binauthz attestors describe ${ATTESTOR}.

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

Erstellung des Attestierers prüfen

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob der Attestierer erstellt wurde:

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

Nächste Schritte

Weitere Informationen zum Erstellen von Attestierungen für Ihren Attestierer
Aktualisieren Sie Ihre Richtlinie für die Binärautorisierung so, dass Attestierungen über die Google Cloud Console, das Google Cloud CLI und die REST API erforderlich sind.