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 auch mit der Google Cloud Console oder der REST API ausführen. Diese Aufgabe ist Teil der Einrichtung der Binärautorisierung.

Hinweis: Ein vollständiges End-to-End-Beispiel mit diesen Schritten finden Sie unter Erste Schritte mit der Google Cloud CLI oder Erste Schritte mit der Google Cloud Console..

Ein Attestierer ist eine Google Cloud-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.

Umgebung einrichten

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

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

Wenn Ihr Attestiererprojekt mit Ihrem Bereitstellerprojekt identisch ist, verwenden Sie für beide Variablen dieselbe Projekt-ID. Eine End-to-End-Anleitung, die die Trennung von Aufgaben mithilfe mehrerer Projekte beschreibt, finden Sie unter Mehrere Projekte einrichten.

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:

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

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 von Identity and Access Management für den Hinweis festlegen

Sie müssen dem Dienstkonto des Attestiererprojekts in der Container Analysis-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 nutzen

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 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 Signer 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:

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

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:

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
```
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}" \
   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 ein, um Informationen über das von Cloud KMS verwaltete Schlüsselpaar zu speichern:
```
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. Wir empfehlen ec-sign-p256-sha256.
  - KMS_PROTECTION_LEVEL: Das Schutzniveau, z. B. software.
2. Erstellen Sie einen Cloud KMS-Schlüsselbund:
```
gcloud --project ${KMS_KEY_PROJECT_ID} kms keyrings create \
  ${KMS_KEYRING_NAME} \
  --location ${KMS_KEY_LOCATION}
```
3. Erstellen Sie den Schlüssel:
```
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}
```
  Weitere Informationen zum Erstellen von KMS-Schlüsseln finden Sie unter Asymmetrischen Schlüssel erstellen.
4. Fügen Sie dem Attestierer den öffentlichen Schlüssel hinzu:
```
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}"
```

Erstellung des Attestierers prüfen

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

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