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 Kurzanleitung und die Übersicht über die Build-Konfiguration.

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

Hinweis: Diese Anleitung richtet sich an Linux-Container. Informationen zu Windows Server-Containern finden Sie unter Images für mehrere Architekturen mit Cloud Build gke-windows-builder 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 haben ein Docker-Repository zum Speichern von Images in Artifact Registry oder erstellen ein neues Repository.
• Wenn Sie die gcloud-Befehle auf dieser Seite verwenden möchten, installieren Sie die Google Cloud CLI.
• Wenn Sie die Images ausführen möchten, installieren Sie Docker.
• Wenn Sie die Images mit cosign signieren möchten, folgen Sie der Anleitung unter Dienst-zu-Dienst-Zugriff autorisieren, um ein benutzerdefiniertes Dienstkonto zu erstellen und die zum Generieren von ID-Tokens erforderlichen Berechtigungen zu gewähren.

Build 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 folgenden Beispielkonfigurationsdatei gibt das Feld name an, dass das vordefinierte Docker-Image von Cloud Build verwendet wird, um die im Feld args angegebene Aufgabe auszuführen.

   • 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: der regionale oder multiregionale 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 Standort des Repositorys.
     • 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 des Repositorys.
• PROJECT_ID ist Ihre Google Cloud-Projekt-ID.
• REPOSITORY: der Name Ihres Artifact Registry-Repositorys.
• IMAGE_NAME ist der Name Ihres Container-Images.

Mit Buildpacks von Google Cloud erstellen

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

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

• Verwenden des Felds images, das das Image nach Abschluss des Builds in Artifact Registry speichert.
• Verwenden Sie den Befehl docker push, 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, die Ergebnisse von Build.get() und die Ergebnisse 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 Abschluss des Builds in Artifact Registry:

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 Image in Artifact Registry gespeichert. 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 des Repositorys.
   • 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
   

   Wobei:

   • 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 des 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 des Repositorys.
   • 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
   

   Wobei:

   • 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 des Repositorys.
   • 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
   

   Wobei:

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

Container-Images mit Cosign signieren

Wenn Sie Images in Artifact Registry speichern, können Sie eine weitere Sicherheitsebene hinzufügen, indem Sie mit dem cosign-Tool einen Eintrag darüber erstellen, welches Dienstkonto zum Initiieren eines Builds verwendet wird. Durch den OpenID Connect (OIDC)-Standard können Prüfer mit diesem Eintrag prüfen, ob ein Image von einem vertrauenswürdigen Dienstkonto erstellt wurde.

Hinweis: Die folgenden Schritte können nicht mit dem Cloud Build-Standarddienstkonto ausgeführt werden. Folgen Sie der Anleitung unter Dienst-zu-Dienst-Zugriff autorisieren, um ein benutzerdefiniertes Dienstkonto zu erstellen und die zum Generieren von ID-Tokens erforderlichen Berechtigungen zu gewähren.

Die folgenden Schritte zeigen, wie Sie mit der Konfigurationsdatei cloudbuild.yaml 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"
  - name: 'gcr.io/cloud-builders/gcloud'
    id: 'generate-token-and-get-digest'
    script: |
      #!/bin/sh
      set -e
      gcloud auth print-identity-token --audiences=sigstore > token
      gcloud 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

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 Speicherort des Repositorys, 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 benutzerdefinierten Dienstkontos, das Ihren Build ausführen soll. Die E-Mail-Adresse eines Dienstkontos sieht beispielsweise so aus: [e-mail].

Installieren Sie cosign auf Ihrem lokalen Computer und führen Sie dann den Befehl cosign verify aus, um die Signatur zu prüfen:

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 voraussichtlich zum Erstellen des Container-Images verwendet wurde.
• IMAGE ist der vollständige Image-Name, einschließlich des sha256-Image-Digest.

Hinweis: Sie müssen den Image-Digest angeben, da er eine unveränderliche Kennung für Ihr Image ist. Tags sind änderbar, wodurch sie weniger zuverlässig sind. Informationen zu Versionen finden Sie unter Container-Image-Versionen.

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 für die Interaktion mit Artifact Registry Ihre Artifact Registry-Anmeldedaten verwendet werden. Dies ist nur einmal erforderlich. Verwenden Sie den folgenden Befehl, um sich mit gcloud Credential 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 des Repositorys.
   • 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

• Weitere Informationen zum Erstellen von Java-Anwendungen
• Python-Anwendungen erstellen
• Go-Anwendungen erstellen
• Build-Artefakte in Cloud Storage speichern
• Build-Artefakte in Artifact Registry speichern
• Build-Fehler beheben