Diese Seite wurde von der Cloud Translation API übersetzt.

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

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-Befehlszeile.
Wenn Sie die Images ausführen möchten, installieren Sie Docker.

Mit einer Build-Konfigurationsdatei erstellen

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

Erstellen Sie in dem Verzeichnis, das den Quellcode Ihrer Anwendung enthält, eine Datei mit dem Namen cloudbuild.yaml oder cloudbuild.json.
In der Build-Konfigurationsdatei:
- Fügen Sie ein name-Feld hinzu und geben Sie das vordefinierte Docker-Image an. Das vordefinierte Image wird in Container Registry unter gcr.io/cloud-builders/docker gespeichert. In der folgenden Beispielkonfigurationsdatei wird mit dem Feld name angegeben, 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: Ihre Cloud-Projekt-ID
- REPOSITORY: Der Name des 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: Ihre Cloud-Projekt-ID
  - REPOSITORY: Der Name Ihres Artifact Registry-Repositorys.
  - IMAGE_NAME ist der Name Ihres Container-Images.
  - DOCKERFILE_PATH: Pfad zu Ihrem Dockerfile.
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 Speicherort für Ihr Repository.
PROJECT_ID: Ihre Cloud-Projekt-ID
REPOSITORY: Der Name Ihres Artifact Registry-Repositorys.
IMAGE_NAME ist der Name Ihres Container-Images.

Mit Cloud Native Buildpacks erstellen

Mit Cloud Build können Sie ein Image ohne Dockerfile oder Build-Konfigurationsdatei erstellen. Sie können dazu Cloud Native Buildpacks 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-reseller.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 Sie das Feld images, in dem das Image nach Abschluss des Builds in Artifact Registry gespeichert wird.
Befehl docker push verwenden, mit dem das Image als Teil Ihres Build-Ablaufs in Artifact Registry gespeichert wird.

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

Container-Image in Artifact Registry speichern, nachdem der Build abgeschlossen ist:

Wenn das Ziel-Repository nicht vorhanden ist, erstellen Sie ein neues Repository.
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.
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. Das Image wird in Artifact Registry gespeichert. Das folgende Snippet zeigt eine Build-Konfiguration zum Erstellen eines Images und Speichern in Artifact Registry:
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"
]
}
```
Dabei gilt:
- LOCATION: Der regionale oder multiregionale Speicherort für Ihr Repository.
- PROJECT_ID: Ihre Cloud-Projekt-ID
- REPOSITORY: Der Name Ihres Artifact Registry-Repositorys.
- IMAGE_NAME ist der Name Ihres Container-Images.
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 in Artifact Registry als Teil des Build-Ablaufs speichern:

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.

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"
        ]
   }
  ]
}

Dabei gilt:

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

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:

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.

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"
    ]
}

Dabei gilt:

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

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.

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.

Docker für die Verwendung Ihrer Artifact Registry-Anmeldedaten konfigurieren, wenn mit Artifact Registry interagiert. Sie müssen diesen Schritt nur einmal ausführen. Verwenden Sie den folgenden Befehl, um sich mit dem gcloud-Anmeldedaten-Assistenten zu authentifizieren.
```
gcloud auth configure-docker HOSTNAME-LIST
```
Dabei ist HOSTNAME-LIST eine durch Kommas getrennte Liste von Repository-Hostnamen, die der Konfiguration für die Anmeldedatenhilfe 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
```
Führen Sie das zuvor erstellte Docker-Image aus:
```
docker run LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME
```
Dabei gilt:
- LOCATION: Der regionale oder multiregionale Speicherort für Ihr Repository.
- PROJECT_ID: Ihre 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.
```