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, um Ihre Aufgaben auszuführen. Diese Images werden von Google Cloudunterstü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 dem gke-windows-builder von Cloud Build erstellen.

Hinweis

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 Bilder mit Cosign 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, die zum Generieren von ID-Tokens erforderlich sind.

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 vorgefertigte 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",
             "."
            ]
        }
        ]
      }
     

   Wobei:

   • LOCATION: der regionale oder multiregionale Standort Ihres Docker-Repositorys in Artifact Registry.
   • PROJECT_ID: Projekt-ID in Google Cloud .
   • 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', "."
            ]
        }
        ]
      }
     

     Wobei:

     • LOCATION: der regionale oder multiregionale Speicherort für Ihr Repository.
     • PROJECT_ID: Projekt-ID in Google Cloud .
     • 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
   

   Wobei:

   • 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

Wobei:

• LOCATION: der regionale oder multiregionale Speicherort für Ihr Repository.
• PROJECT_ID: Projekt-ID in Google Cloud .
• 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. Sie können dazu 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

Wobei:

• 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 so konfigurieren, dass ein erstelltes Image auf eine der folgenden Arten gespeichert wird:

• Mit dem Feld images können Sie ein Docker-Image nach Abschluss des Builds in Artifact Registry speichern.
• Verwenden Sie das Feld artifacts.oci, um ein OCI-Image nach Abschluss des Builds in Artifact Registry zu speichern.
• Verwenden Sie den Befehl docker push, um ein Container-Image als Teil Ihres Build-Ablaufs in Artifact Registry zu speichern.

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 derGoogle Cloud -Konsole 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.

Container-Image nach Abschluss des Builds in Artifact Registry speichern

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 Speicherort für Ihr Repository.
   • PROJECT_ID: Projekt-ID in Google Cloud .
   • 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.

Image als Teil des Build-Ablaufs in Artifact Registry speichern

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 Speicherort für Ihr Repository.
   • PROJECT_ID: Projekt-ID in Google Cloud .
   • 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.

Image als Teil des Build-Ablaufs speichern und in den Build-Ergebnissen anzeigen lassen

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 Speicherort für Ihr Repository.
   • PROJECT_ID: Projekt-ID in Google Cloud .
   • 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.

OCI-Image nach Abschluss des Builds in Artifact Registry speichern

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 Ihrer Build-Konfigurationsdatei ein artifacts-Feld hinzu, das das erstellte OCI-Image angibt. Bei dieser Konfiguration wird das OCI-Image in Artifact Registry gespeichert. Im folgenden Beispiel wird eine Build-Konfiguration gezeigt, mit der ein OCI-Image erstellt und in Artifact Registry gespeichert wird:

   YAML

   artifacts:
     oci:
     - file: 'OCI_IMAGE_PATH'
       registryPath: 'https://LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY'
       tags: ["primary_image"]
   

   JSON

   {
     "artifacts": {
       "oci": [
         {
           "file": "OCI_IMAGE_PATH",
           "registryPath": "https://LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY",
           "tags": ["primary_image"]
         }
       ]
     }
   }
   

   Wobei:

   • OCI_IMAGE_PATH ist die Adresse des lokalen Verzeichnisses, das das hochzuladende OCI-Image enthält, z. B. /.pack/layout-repo/my-app.
   • LOCATION ist der regionale oder multiregionale Standort für Ihr Repository.
   • PROJECT_ID ist die Google Cloud -Projekt-ID.
   • REPOSITORY: der Name Ihres Artifact Registry-Repositorys.

Container-Images mit Cosign signieren

Wenn Sie Images in Artifact Registry speichern, können Sie eine weitere Sicherheitsebene hinzufügen, indem Sie mit dem Tool cosign einen Datensatz erstellen, in dem aufgezeichnet wird, welches Dienstkonto zum Starten eines Builds verwendet wird. Auf Grundlage des OpenID Connect (OIDC)-Standards können Prüfer anhand dieses Eintrags überprü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 vom Nutzer angegebenes Dienstkonto zu erstellen und die Berechtigungen zu erteilen, die zum Generieren von ID-Tokens erforderlich sind.

In den folgenden Schritten wird gezeigt, wie Sie mit 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 Speicherort des Repositorys, in dem das Image gespeichert ist, z. B. us-east1 oder us.

• PROJECT_ID: Projekt-ID in Google Cloud .

• 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 vom Nutzer angegebenen Dienstkontos, mit dem Sie den Build ausführen möchten. Die E-Mail-Adresse eines Dienstkontos sieht beispielsweise so aus: [e-mail].

Um die Signatur zu prüfen, 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 des sha256-Image-Digest.

Hinweis :Sie müssen das Image-Digest angeben, da es sich um einen unveränderlichen Bezeichner für Ihr Image handelt. Tags sind veränderlich und daher weniger zuverlässig. 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 die Anmeldedaten von Artifact Registry für die Interaktion mit Artifact Registry verwendet werden. (Dies ist nur einmal erforderlich.) Verwenden Sie den folgenden Befehl, um sich mit dem 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 Speicherort für Ihr Repository.
   • PROJECT_ID: Projekt-ID in Google Cloud .
   • 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