Python-Anwendungen erstellen, testen und in Container verlagern

Auf dieser Seite wird beschrieben, wie Sie Cloud Build so konfigurieren, dass Python-Anwendungen erstellt, getestet, in Containern bereitgestellt und bereitgestellt werden.

Mit Cloud Build können Sie jedes öffentlich verfügbare Container-Image zum Ausführen Ihrer Entwicklungsaufgaben verwenden, einschließlich Erstellen, Testen, Containerisieren, Hochladen in Artifact Registry, Bereitstellen und Speichern Ihrer Build-Logs. Im öffentlichen python-Image aus Docker Hub sind die Tools python und pip vorinstalliert. Sie können Cloud Build zum Installieren von Abhängigkeiten sowie zum Erstellen und Ausführen von Einheitentests mit diesen Tools konfigurieren.

Hinweis

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

  • Aktivieren Sie die APIs für Cloud Build, Cloud Run, Cloud Storage und Artifact Registry, falls sie noch nicht aktiviert sind.

    Rollen, die zum Aktivieren von APIs erforderlich sind

    Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Rolle „Inhaber“ (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. Informationen zum Zuweisen von Rollen

    APIs aktivieren

  • Zum Ausführen der gcloud-Befehle auf dieser Seite müssen Sie die Google Cloud CLI installieren.
  • Halten Sie Ihr Python-Projekt bereit, einschließlich der Datei requirements.txt. Sie benötigen ein Dockerfile zusammen mit Ihrem Quellcode.
  • Wenn Sie den erstellten Container in Artifact Registry speichern möchten, erstellen Sie ein Docker-Repository in Artifact Registry.
  • Wenn Sie Testlogs in Cloud Storage speichern möchten, erstellen Sie einen Bucket in Cloud Storage.

Erforderliche IAM-Berechtigungen

Eine Anleitung zum Zuweisen dieser Rollen finden Sie unter Rolle über die IAM-Seite zuweisen.

Python-Builds konfigurieren

Dieser Abschnitt enthält eine Beispiel-Build-Konfigurationsdatei für eine Python-Anwendung. Er enthält Build-Schritte, um Anforderungen zu installieren, Einheitentests hinzuzufügen und die Anwendung nach dem Bestehen der Tests zu erstellen und bereitzustellen.

  1. Erstellen Sie im Stammverzeichnis des Projekts eine Build-Konfigurationsdatei mit dem Namen cloudbuild.yaml.

  2. Anforderungen für die Installation: Beim Image python von Docker Hub ist pip vorinstalliert. Fügen Sie einen Build-Schritt mit den folgenden Feldern hinzu, um Abhängigkeiten aus pip zu installieren:

    • name: Legen Sie den Wert dieses Felds auf python fest, um für diese Aufgabe das Python-Image von Docker Hub zu verwenden.
    • entrypoint: Wenn Sie dieses Feld festlegen, wird der Standardeinstiegspunkt des Image überschrieben, auf das in name verwiesen wird. Legen Sie den Wert dieses Felds auf pip fest, um pip als Einstiegspunkt für den Build-Schritt aufzurufen und pip-Befehle auszuführen.
    • args: Im Feld args eines Build-Schritts wird eine Liste von Argumenten abgerufen und an das Image übergeben, auf das im Feld name verwiesen wird. Übergeben Sie die Argumente, um den Befehl pip install in diesem Feld auszuführen. Das Flag --user im Befehl pip install sorgt dafür, dass die nachfolgenden Build-Schritte auf die in diesem Build-Schritt installierten Module zugreifen können.

    Mit dem folgenden Build-Schritt werden Argumente zum Installieren von Anforderungen aus der Datei requirements.txt hinzugefügt:

    steps:
  # Install dependencies
  - name: python
    entrypoint: pip
    args: ["install", "-r", "requirements.txt", "--user"]

  3. Einheitentests hinzufügen: Wenn Sie in Ihrer Anwendung Einheitentests mit einem Test-Framework wie pytest definiert haben, können Sie Cloud Build so konfigurieren, dass die Tests ausgeführt werden: Fügen Sie folgende Felder in einem Build-Schritt hinzu:

    • name: Legen Sie den Wert dieses Felds auf python fest, um das Python-Image von Docker Hub für Ihre Aufgabe zu verwenden.
    • entrypoint: Legen Sie den Wert dieses Felds auf python fest, um python-Befehle auszuführen.
    • args: Fügen Sie die Argumente zum Ausführen des Befehls python pytest hinzu.

    Mit dem folgenden Build-Schritt wird die Logausgabe von pytest in einer JUnit-XML-Datei gespeichert. Der Name dieser Datei wird mithilfe der kurzen Version der Commit-ID erstellt, die Ihrem Build zugeordnet ist. Bei einem nachfolgenden Build-Schritt werden die Logs in dieser Datei in Cloud Storage gespeichert.

    # Run unit tests
- name: python
  entrypoint: python
  args: ["-m", "pytest", "--junitxml=${SHORT_SHA}_test_log.xml"]

  4. Containerisieren der Anwendung: Nachdem Sie den Build-Schritt hinzugefügt haben, um sicherzustellen, dass die Tests bestanden haben, können Sie die Anwendung erstellen. Cloud Build bietet ein vordefiniertes Docker-Image, mit dem Sie Ihre Python-Anwendung containerisieren können. Fügen Sie in einem Build-Schritt die folgenden Felder hinzu, um Ihre Anwendung zu containerisieren:

    • name: Legen Sie den Wert dieses Felds auf gcr.io/cloud-builders/docker fest, um das vordefinierte Docker-Image für Ihre Aufgabe zu verwenden.
    • args: Fügen Sie die Argumente für den Befehl docker build als Werte für dieses Feld hinzu.

    Mit dem folgenden Build-Schritt wird das Image myimage erstellt und mit der kurzen Version Ihrer Commit-ID getaggt. Der Build-Schritt verwendet die Standardsubstitutionen für die Projekt-ID, den Repository-Namen und die kurzen SHA-Werte. Daher werden diese Werte bei der Build-Erstellung automatisch ersetzt.

    # Docker Build
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 
         'us-central1-docker.pkg.dev/${PROJECT_ID}/${_ARTIFACT_REGISTRY_REPO}/myimage:${SHORT_SHA}', '.']

  5. Container in Artifact Registry übertragen: Sie können den erstellten Container in Artifact Registry speichern. Artifact Registry ist ein Google Cloud Dienst, mit dem Sie Build-Artefakte speichern, verwalten und sichern können. Dazu benötigen Sie ein vorhandenes Docker-Repository in Artifact Registry. Um Cloud Build so zu konfigurieren, dass das Image in einem Artifact Registry-Docker-Repository gespeichert wird, fügen Sie einen Build-Schritt mit den folgenden Feldern hinzu:

    • name: Legen Sie den Wert dieses Felds auf gcr.io/cloud-builders/docker fest, um das offizielle docker-Builder-Image für Ihre Aufgabe zu verwenden.
    • args: Fügen Sie die Argumente für den Befehl docker push als Werte dieses Felds hinzu. Geben Sie für die Ziel-URL das Artifact Registry-Docker-Repository ein, in dem Sie das Image speichern möchten.

    Mit dem folgenden Build-Schritt wird das Image, das Sie im vorherigen Schritt erstellt haben, per Push an Artifact Registry übertragen:

    # Docker push to Google Artifact Registry
- name: 'gcr.io/cloud-builders/docker'
  args: ['push',  'us-central1-docker.pkg.dev/${PROJECT_ID}/${_ARTIFACT_REGISTRY_REPO}/myimage:${SHORT_SHA}']

    Optional: Wenn Sie möchten, dass Cloud Build Informationen zur Build-Herkunft gemäß Supply-chain Levels for Software Artifacts (SLSA) generiert, gehen Sie so vor:

    • Verwenden Sie stattdessen das Feld images in Ihrem Build-Schritt, anstatt einen separaten Docker push-Build-Schritt zu verwenden.
    • Fügen Sie requestedVerifyOption: VERIFIED dem Abschnitt options Ihrer Build-Konfigurationsdatei hinzu.

  6. Container in Cloud Run bereitstellen: Um das Image in Cloud Run bereitzustellen, fügen Sie einen Build-Schritt mit den folgenden Feldern hinzu:

    • name: Setzen Sie den Wert dieses Felds auf google/cloud-sdk, um das gcloud CLI-Image zum Aufrufen des gcloud-Befehls zu verwenden, um das Image in Cloud Run bereitzustellen.
    • args: Fügen Sie die Argumente für den Befehl gcloud run deploy als Werte dieses Felds hinzu.

    Mit dem folgenden Build-Schritt wird das zuvor erstellte Image in Cloud Run bereitgestellt:

    # Deploy to Cloud Run
- name: google/cloud-sdk
  args: ['gcloud', 'run', 'deploy', 'helloworld-${SHORT_SHA}', 
         '--image=us-central1-docker.pkg.dev/${PROJECT_ID}/${_ARTIFACT_REGISTRY_REPO}/myimage:${SHORT_SHA}', 
         '--region', 'us-central1', '--platform', 'managed', 
         '--allow-unauthenticated']

  7. Testlogs in Cloud Storage speichern: Sie können Cloud Build so konfigurieren, dass alle Testlogs in Cloud Storage gespeichert werden. Geben Sie dazu einen vorhandenen Bucket-Speicherort und einen Pfad zu den Testlogs an. Mit dem folgenden Build-Schritt werden die Testlogs, die Sie in der JUNIT-XML-Datei gespeichert haben, in einem Cloud Storage-Bucket gespeichert:

    # Save test logs to Google Cloud Storage
artifacts:
  objects:
    location: gs://${_BUCKET_NAME}/
    paths:
      - ${SHORT_SHA}_test_log.xml

    Das folgende Snippet zeigt die vollständige Build-Konfigurationsdatei für alle oben beschriebenen Schritte:

    steps:
  # Install dependencies
  - name: python
    entrypoint: pip
    args: ["install", "-r", "requirements.txt", "--user"]

  # Run unit tests
  - name: python
    entrypoint: python
    args: ["-m", "pytest", "--junitxml=${SHORT_SHA}_test_log.xml"] 

  # Docker Build
  - name: 'gcr.io/cloud-builders/docker'
    args: ['build', '-t', 
           'us-central1-docker.pkg.dev/${PROJECT_ID}/${_ARTIFACT_REGISTRY_REPO}/myimage:${SHORT_SHA}', '.']

  # Docker push to Google Artifact Registry
  - name: 'gcr.io/cloud-builders/docker'
    args: ['push',  'us-central1-docker.pkg.dev/${PROJECT_ID}/${_ARTIFACT_REGISTRY_REPO}/myimage:${SHORT_SHA}']

  # Deploy to Cloud Run
  - name: google/cloud-sdk
    args: ['gcloud', 'run', 'deploy', 'helloworld-${SHORT_SHA}', 
           '--image=us-central1-docker.pkg.dev/${PROJECT_ID}/${_ARTIFACT_REGISTRY_REPO}/myimage:${SHORT_SHA}', 
           '--region', 'us-central1', '--platform', 'managed', 
           '--allow-unauthenticated']

# Save test logs to Google Cloud Storage
artifacts:
  objects:
    location: gs://${_BUCKET_NAME}/
    paths:
      - ${SHORT_SHA}_test_log.xml
# Store images in Google Artifact Registry 
images:
  - us-central1-docker.pkg.dev/${PROJECT_ID}/${_ARTIFACT_REGISTRY_REPO}/myimage:${SHORT_SHA}

  8. Build starten: Manuell oder mit Build-Triggern.

    Nach Abschluss des Builds können Sie sich die Repository-Details in Artifact Registry ansehen.

    Sie können auch Metadaten zur Build-Herkunft aufrufen und die Herkunft validieren.

Nächste Schritte