Container-Images erstellen

Auf dieser Seite wird beschrieben, wie Cloud Build konfiguriert wird, um Docker-Images zu erstellen und zu speichern. Wenn Sie Cloud Build noch nicht kennen, lesen Sie zuerst die Kurzanleitungen sowie die Übersicht über die Build-Konfiguration.

Cloud Build bietet vordefinierte Images. auf die Sie in einer Cloud Build-Konfigurationsdatei verweisen können, Aufgaben. Diese Images werden von Google Cloud unterstützt und verwaltet. Sie können das unterstützte, vordefinierte Docker-Image um Docker-Befehle auszuführen und Docker-Images zu erstellen.

Hinweise

Die Anleitung auf dieser Seite setzt voraus, dass Sie mit Docker vertraut sind. Außerdem gilt:

  • Halten Sie Ihren Anwendungsquellcode zusammen mit dem Dockerfile bereit.
  • Sie benötigen ein Docker-Repository zum Speichern von Images in Artifact Registry oder Sie erstellen ein neues Repository.
  • Wenn Sie die gcloud-Befehle auf dieser Seite verwenden möchten, müssen Sie die Google Cloud CLI installieren.
  • Wenn Sie die Images ausführen möchten, installieren Sie Docker.
  • Wenn Sie die Bilder damit signieren möchten, folgen Sie der Anleitung unter Dienst-zu-Dienst-Zugriff autorisieren. um ein benutzerdefiniertes Dienstkonto zu erstellen und die Berechtigungen zu gewähren erforderlich, um ID-Tokens zu generieren.

Mit einer Build-Konfigurationsdatei erstellen

So erstellen Sie Ihr Docker-Image mit einer Build-Konfigurationsdatei:

  1. Erstellen Sie in dem Verzeichnis, das den Quellcode Ihrer Anwendung enthält, eine Datei mit dem Namen cloudbuild.yaml oder cloudbuild.json.

  2. In der Build-Konfigurationsdatei:

    • Fügen Sie ein name-Feld hinzu und geben Sie das vordefinierte Docker-Image an. Das vordefinierte Image wird unter gcr.io/cloud-builders/docker gespeichert. In der Beispielkonfigurationsdatei unten gibt das Feld name an, dass das vordefinierte Docker-Image von Cloud Build zum Ausführen der im Feld args angegebenen Aufgabe verwendet wird.

    • Fügen Sie im Feld args die Argumente zum Erstellen des Images hinzu.

      YAML

      steps:
- name: 'gcr.io/cloud-builders/docker'
  args: [ 'build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.' ]

      JSON

      {
 "steps": [
  {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
        "build",
        "-t",
        "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
        "."
       ]
   }
   ]
 }

      Ersetzen Sie die Platzhalterwerte in der obigen Build-Konfiguration durch Folgendes:

    • LOCATION: den regionalen oder multiregionalen Speicherort Ihres Docker-Repositorys in Artifact Registry.

    • PROJECT_ID ist Ihre Google Cloud-Projekt-ID.

    • REPOSITORY: der Name Ihres Docker-Repositorys in Artifact Registry.

    • IMAGE_NAME ist der Name Ihres Container-Images.

      Wenn sich Dockerfile und der Quellcode in verschiedenen Verzeichnissen befinden, fügen Sie -f und den Pfad zu Dockerfile der Argumentliste im Feld args hinzu:

      YAML 

      steps:
- name: 'gcr.io/cloud-builders/docker'
  args: [ 'build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '-f', 'DOCKERFILE_PATH', '.' ]

      JSON

      {
 "steps": [
  {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
        "build",
        "-t",
        "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME", '-f', 'DOCKERFILE_PATH', "."
       ]
   }
   ]
 }

      Ersetzen Sie die Platzhalterwerte in der obigen Build-Konfiguration durch Folgendes:

      • LOCATION: der regionale oder multiregionale Speicherort für Ihr Repository.
      • PROJECT_ID ist Ihre Google Cloud-Projekt-ID.
      • REPOSITORY: der Name Ihres Artifact Registry-Repositorys.
      • IMAGE_NAME ist der Name Ihres Container-Images.
      • DOCKERFILE_PATH: Pfad zu Ihrem Dockerfile.

  3. Starten Sie mit der Build-Konfigurationsdatei den Build:

    gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY

    Ersetzen Sie die Platzhalterwerte im obigen Befehl durch Folgendes:

    • CONFIG_FILE_PATH: der Pfad zur Build-Konfigurationsdatei
    • SOURCE_DIRECTORY: der Pfad oder URL zum Quellcode

    Wenn Sie CONFIG_FILE_PATH und SOURCE_DIRECTORY im Befehl gcloud builds submit nicht angeben, geht Cloud Build davon aus, dass sich die Konfigurationsdatei und der Quellcode im aktuellen Arbeitsverzeichnis befinden.

Mit einem Dockerfile erstellen

Mit Cloud Build können Sie ein Docker-Image mithilfe nur eines Dockerfile erstellen. Sie benötigen keine separate Build-Konfigurationsdatei.

Führen Sie zum Erstellen mit einem Dockerfile den folgenden Befehl aus dem Verzeichnis aus, das Ihren Quellcode und das Dockerfile enthält:

    gcloud builds submit --tag LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME

Ersetzen Sie die Platzhalterwerte im obigen Befehl durch Folgendes:

  • LOCATION: Der regionale oder multiregionale Standort für Ihr Repository.
  • PROJECT_ID ist Ihre Google Cloud-Projekt-ID.
  • REPOSITORY: der Name Ihres Artifact Registry-Repositorys.
  • IMAGE_NAME ist der Name Ihres Container-Images.

Mit den Buildpacks von Google Cloud entwickeln

Mit Cloud Build können Sie ein Image ohne Dockerfile oder Build-Konfigurationsdatei erstellen. Sie können dazu Buildpacks von Google Cloud

Führen Sie zum Erstellen mit Buildpacks den folgenden Befehl im Verzeichnis aus, das Ihren Quellcode enthält:

    gcloud builds submit --pack builder=BUILDPACK_BUILDER, \
        env=ENVIRONMENT_VARIABLE, \
        image=IMAGE_NAME

Ersetzen Sie die Platzhalterwerte in den obigen Befehlen durch Folgendes:

  • BUILDPACK_BUILDER: Der zu verwendende Buildpacks-Builder. Wenn Sie keinen Builder angeben, verwendet Cloud Build standardmäßig gcr.io/buildpacks/builder.
  • ENVIRONMENT_VARIABLE: Alle Umgebungsvariablen für Ihren Build.
  • IMAGE: die URL des Images in Artifact Registry. Die Bild-URL muss das Format LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME haben.

Hier einige Beispielbefehle:

  • Build mit dem Standard-gcr.io/buildpacks/builder ausführen, um das Image us-docker.pkg.dev/gcb-docs-project/containers/gke/hello-app zu erstellen:

      gcloud builds submit --pack image=us-docker.pkg.dev/gcb-docs-project/containers/gke/hello-app

  • Mehrere Umgebungsvariablen werden mit ^--^ als Trennzeichen an Ihren Build übergeben. Weitere Informationen zum Maskieren von Argumenten finden Sie unter gcloud topic escaping.

      gcloud builds submit --pack \
      ^--^image=gcr.io/my-project/myimage--env=GOOGLE_ENTRYPOINT='java -jar target/myjar.jar',GOOGLE_RUNTIME_VERSION='3.1.301'

Trigger zur Verwendung von Buildpacks konfigurieren: Zusätzlich zur Erstellung über die Befehlszeile können Sie Trigger so konfigurieren, dass Buildpacks automatisch zum Erstellen Ihres Images verwendet werden. Weitere Informationen finden Sie unter Build-Trigger erstellen und verwalten.

Verschiedene Möglichkeiten zum Speichern von Images in Artifact Registry

Sie können Cloud Build zum Speichern Ihres erstellten Images auf eine der folgenden Arten konfigurieren:

  • Mithilfe des images-Felds, das das Image nach Abschluss des Builds in Artifact Registry speichert
  • Mithilfe des docker push-Befehls, der das Image als Teil des Build-Ablaufs in Artifact Registry speichert

Der Unterschied zwischen der Verwendung des Feldes images und des Docker-Befehls push besteht darin, dass mit dem Feld images das gespeicherte Image in den Build-Ergebnissen angezeigt wird. Dazu gehören die Seite Build-Beschreibung für einen Build in der Google Cloud Console sowie die Ergebnisse von Build.get() und von gcloud builds list. Wenn Sie dagegen das Build-Image mit dem Docker-Befehl push speichern, wird das Image nicht in den Build-Ergebnissen angezeigt.

Wenn Sie das Image als Teil Ihres Build-Ablaufs speichern und in den Build-Ergebnissen anzeigen lassen möchten, verwenden Sie sowohl den Docker-Befehl push als auch das images-Feld in Ihrer Build-Konfigurationsdatei.

So speichern Sie ein Container-Image nach Ihrem Build in Artifact Registry abgeschlossen wird:

  1. Wenn das Ziel-Repository nicht vorhanden ist, erstellen Sie ein neues Repository.
  2. Erstellen Sie in dem Verzeichnis, das den Quellcode Ihrer Anwendung und das Dockerfile enthält, eine Datei mit dem Namen cloudbuild.yaml oder cloudbuild.json.

  3. Fügen Sie Ihrer Build-Konfigurationsdatei einen Build-Schritt hinzu, um ein Image zu erstellen, und fügen Sie dann ein images-Feld hinzu, das das erstellte Image angibt. Dadurch wird das Bild in Artifact Registry. Das folgende Snippet zeigt eine Build-Konfiguration, um ein Image zu erstellen und in Artifact Registry zu speichern:

    YAML 

    steps:
- name: 'gcr.io/cloud-builders/docker'
  args: [ 'build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.' ]
images: ['LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']

    JSON

    {
"steps": [
{
    "name": "gcr.io/cloud-builders/docker",
    "args": [
        "build",
        "-t",
        "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
        "."
    ]
}
],
"images": [
    "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME"
]
}

    Wobei:

    • LOCATION: Der regionale oder multiregionale Standort für Ihr Repository.
    • PROJECT_ID ist Ihre Google Cloud-Projekt-ID.
    • REPOSITORY: der Name Ihres Artifact Registry-Repositorys.
    • IMAGE_NAME ist der Name Ihres Container-Images.

  4. Starten Sie mit der Build-Konfigurationsdatei den Build:

    gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY

    Dabei gilt:

    • CONFIG_FILE_PATH ist der Pfad zur Build-Konfigurationsdatei.
    • SOURCE_DIRECTORY ist der Pfad oder die URL zum Quellcode.

So speichern Sie das Image als Teil Ihres Build-Ablaufs in Artifact Registry:

  1. Erstellen Sie in dem Verzeichnis, das den Quellcode Ihrer Anwendung und das Dockerfile enthält, eine Datei mit dem Namen cloudbuild.yaml oder cloudbuild.json.

  2. Fügen Sie der Build-Konfigurationsdatei einen docker-Build-Schritt hinzu, um ein Image zu erstellen, fügen Sie dann einen weiteren docker-Build-Schritt hinzu und übergeben Sie Argumente, um den push-Befehl aufzurufen:

    YAML

    steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.']
- name: 'gcr.io/cloud-builders/docker'
  args: ['push', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']

    JSON

    {
  "steps": [
   {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
          "build",
          "-t",
          "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
          "."
       ]
   },
   {
       "name": "gcr.io/cloud-builders/docker",
       "args": [
          "push",
          "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME"
        ]
   }
  ]
}

    Wobei:

    • LOCATION: Der regionale oder multiregionale Standort für Ihr Repository.
    • PROJECT_ID ist Ihre Google Cloud-Projekt-ID.
    • REPOSITORY: der Name Ihres Artifact Registry-Repositorys.
    • IMAGE_NAME ist der Name Ihres Container-Images.

  3. Starten Sie mit der Build-Konfigurationsdatei den Build:

    gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY

    Dabei gilt:

    • CONFIG_FILE_PATH ist der Pfad zur Build-Konfigurationsdatei.
    • SOURCE_DIRECTORY ist der Pfad oder die URL zum Quellcode.

So speichern Sie ein Image als Teil des Build-Ablaufs und sorgen dafür, dass es in den Build-Ergebnissen angezeigt wird:

  1. Erstellen Sie in dem Verzeichnis, das den Quellcode Ihrer Anwendung und das Dockerfile enthält, eine Datei mit dem Namen cloudbuild.yaml oder cloudbuild.json.

  2. Fügen Sie der Build-Konfigurationsdatei nach dem Schritt, mit dem das Image erstellt wird, einen Schritt hinzu, um den Docker-Befehl push aufzurufen, und fügen Sie dann das Feld images hinzu:

    YAML

    steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.']
- name: 'gcr.io/cloud-builders/docker'
  args: ['push', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']
images: ['LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']

    JSON

    {
    "steps": [
   {
       "name": "gcr.io/cloud-builders/docker",
       "args": [
           "build",
           "-t",
           "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
           "."
        ]
   },
   {
       "name": "gcr.io/cloud-builders/docker",
       "args": [
           "push",
           "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME"
        ]
   }
   ],
    "images": [
       "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME"
    ]
}

    Wobei:

    • LOCATION: Der regionale oder multiregionale Standort für Ihr Repository.
    • PROJECT_ID ist Ihre Google Cloud-Projekt-ID.
    • REPOSITORY: der Name Ihres Artifact Registry-Repositorys.
    • IMAGE_NAME ist der Name Ihres Container-Images.

  3. Starten Sie mit der Build-Konfigurationsdatei den Build:

    gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY

    Dabei gilt:

    • CONFIG_FILE_PATH ist der Pfad zur Build-Konfigurationsdatei.
    • SOURCE_DIRECTORY ist der Pfad oder die URL zum Quellcode.

Container-Images mit Cosignatur signieren

Wenn Sie Images in Artifact Registry speichern, können Sie eine weitere Sicherheitsebene hinzufügen mit der Methode cosign-Tool Erstellen Sie einen Eintrag darüber, welches Dienstkonto zum Initiieren eines Builds verwendet wird. Unterstützt von den Standard OpenID Connect (OIDC) können Auditoren anhand dieses Eintrags überprüfen, ob ein Image von einer vertrauenswürdigen Dienstkonto.

In den folgenden Schritten wird gezeigt, wie Sie mithilfe Ihrer cloudbuild.yaml-Konfigurationsdatei ein Identitätstoken abrufen und Ihr Container-Image signieren.

YAML 

  steps:
  - name: 'gcr.io/cloud-builders/docker'
    id: 'tag-and-push'
    script: |
      #!/bin/sh
      set -e
      docker build -t $_IMAGE .
      docker push "$_IMAGE"
      docker inspect $_IMAGE --format "$_IMAGE@{{.Id}}" >image_with_digest
  - name: 'gcr.io/cloud-builders/gcloud'
    id: 'generate-token'
    script: |
      #!/bin/sh
      set -e
      gcloud auth print-identity-token --audiences=sigstore > token
  - name: 'gcr.io/cloud-builders/docker'
    id: 'sign-image'
    script: |
      #!/bin/sh
      set -e
      docker run \
      --network=cloudbuild \
      --mount source=home-volume,target=/builder/home \
      --rm \
      -e SIGSTORE_NO_CACHE=true \
      -e HOME=/builder/home \
      gcr.io/projectsigstore/cosign \
      sign --identity-token=$(cat token) $(cat image_with_digest) -y
  service_account: '$_SERVICE_ACCOUNT'
  artifacts:
    images:
    - $_IMAGE
  substitutions:
    _IMAGE: 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME'
    _SERVICE_ACCOUNT_ID: 'SERVICE_ACCOUNT_ID'
    _SERVICE_ACCOUNT: projects/${PROJECT_ID}/serviceAccounts/${_SERVICE_ACCOUNT_ID}
  options:
    env:
    - '_IMAGE=$_IMAGE'
    dynamic_substitutions: true
    logging: CLOUD_LOGGING_ONLY

JSON

    {
        "steps": [
            {
                "name": "gcr.io/cloud-builders/docker",
                "id": "tag-and-push",
                "script": "#!/bin/sh set -e \ndocker build -t $_IMAGE . \ndocker push \"$_IMAGE\""
            },
            {
                "name": "gcr.io/cloud-builders/gcloud",
                "id": "generate-token-and-get-digest",
                "script": "#!/bin/sh set -e \ngcloud auth print-identity-token --audiences=sigstore > token \ngcloud container images describe \"$_IMAGE\" --format=\"value(image_summary.fully_qualified_digest)\" > image_with_digest"
            },
            {
                "name": "gcr.io/projectsigstore/cosign",
                "id": "sign-image",
                "script": "#!/busybox/sh cosign sign --identity-token=$(cat token) $(cat image_with_digest) -y",
                "env": [
                    "SIGSTORE_NO_CACHE=true"
                ]
            }
        ],
        "service_account": "$_SERVICE_ACCOUNT",
        "artifacts": {
            "images": [
                "$_IMAGE"
            ]
        },
        "substitutions": {
            "_IMAGE": "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
            "_SERVICE_ACCOUNT_ID": "SERVICE_ACCOUNT_ID",
            "_SERVICE_ACCOUNT": "projects/${PROJECT_ID}/serviceAccounts/${_SERVICE_ACCOUNT_ID}"
        },
        "options": {
            "env": [
                "_IMAGE=$_IMAGE"
            ],
            "dynamic_substitutions": true,
            "logging": "CLOUD_LOGGING_ONLY"
        }
    }

Wobei:

  • LOCATION ist der regionale oder multiregionale Standort des Repository, in dem das Image gespeichert ist, z. B. us-east1 oder us.

  • PROJECT_ID ist Ihre Google Cloud-Projekt-ID.

  • REPOSITORY ist der Name des Repositorys, in dem das Image gespeichert ist.

  • IMAGE_NAME ist der Image-Name.

  • SERVICE_ACCOUNT_ID ist die E-Mail-Adresse des benutzerdefiniertes Dienstkonto, mit dem Sie Ihren Build ausführen möchten. Eine E-Mail-Adresse für ein Dienstkonto sieht beispielsweise so aus: service-account-name@project-id.iam.gserviceaccount.com.

Zum Bestätigen der Signatur installieren Sie cosign. auf Ihrem lokalen Computer und führen Sie dann den Befehl cosign verify aus:

cosign verify \
--certificate-identity=SERVICE_ACCOUNT_ID \
--certificate-oidc-issuer=https://accounts.google.com \
IMAGE

Wobei:

  • SERVICE_ACCOUNT_ID ist die E-Mail-Adresse des vertrauenswürdigen Dienstkontos, das zum Erstellen des Container-Images verwendet wurde.
  • IMAGE ist der vollständige Image-Name einschließlich SHA256. Image-Digest.

Docker-Image ausführen

Sie können überprüfen, ob das von Ihnen erstellte Image wie erwartet funktioniert, indem Sie es mit Docker ausführen.

  1. Konfigurieren Sie Docker so, dass die Anmeldedaten von Artifact Registry für die Interaktion mit Artifact Registry verwendet werden. (Dieser Schritt ist nur einmal erforderlich.) Verwenden Sie den folgenden Befehl, um sich mit dem gcloud-Anmeldedaten-Helper zu authentifizieren.

    gcloud auth configure-docker HOSTNAME-LIST

    Dabei ist HOSTNAME-LIST eine durch Kommas getrennte Liste von Repository-Hostnamen, die der Credential Helper-Konfiguration hinzugefügt werden sollen.

    Führen Sie beispielsweise den folgenden Befehl aus, um die Regionen us-central1 und asia-northeast1 hinzuzufügen:

    gcloud auth configure-docker us-central1-docker.pkg.dev,asia-northeast1-docker.pkg.dev

  2. Führen Sie das zuvor erstellte Docker-Image aus:

    docker run LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME

    Wobei:

    • LOCATION: Der regionale oder multiregionale Standort für Ihr Repository.
    • PROJECT_ID ist Ihre Google Cloud-Projekt-ID.
    • REPOSITORY: der Name Ihres Artifact Registry-Repositorys.
    • IMAGE_NAME ist der Name Ihres Container-Images.

    Die Ausgabe sollte in etwa so aussehen:

    Hello, world! The time is Fri Feb  2 16:09:54 UTC 2018.

Nächste Schritte