Python-Anwendungen erstellen

Auf dieser Seite wird beschrieben, wie Sie Cloud Build zum Erstellen, Testen und Bereitstellen von Python-Anwendungen konfigurieren. Wenn Sie Cloud Build noch nicht kennen, lesen Sie zuerst die Kurzanleitungen sowie die Übersicht über die Build-Konfiguration.

Mit Cloud Build können Sie jedes öffentlich verfügbare Container-Image zur Ausführung Ihrer Aufgaben verwenden. Auf dem öffentlichen python-Image von Docker Hub sind die Tools python und pip vorinstalliert. Sie können Cloud Build mit diesen Tools konfigurieren, um Abhängigkeiten zu installieren, Einheitentests zu erstellen und mit diesen Tools Einheitentests auszuführen.

Hinweis

Bei den Anleitungen auf dieser Seite wird davon ausgegangen, dass Sie mit Python vertraut sind. Außerdem gilt:

  • Cloud Build, Cloud Run, and Artifact Registry APIs aktivieren.

    Aktivieren Sie die APIs

  • Installieren Sie das Cloud SDK, um die gcloud-Befehle auf dieser Seite auszuführen.
  • Halten Sie Ihr Python-Projekt bereit, einschließlich der Datei requirements.txt.
  • Wenn Sie Ihre Python-Anwendung mithilfe von Cloud Build containerisieren möchten, benötigen Sie zusammen mit Ihrem Quellcode ein Dockerfile.
  • 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 mit der IAM-Seite zuweisen.

Python-Builds konfigurieren

In diesem Abschnitt wird eine beispielhafte Build-Konfigurationsdatei für eine Python-Anwendung beschrieben. Er enthält Build-Schritte zum Installieren von Anforderungen, Hinzufügen von Einheitentests sowie das Bestehen, Erstellen und Bereitstellen der Anwendung.

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

  2. Installationsanforderungen: Das Image python von Docker Hub ist auf pip vorinstalliert. Wenn Sie Abhängigkeiten von pip installieren möchten, fügen Sie einen Build-Schritt mit den folgenden Feldern hinzu:

    • name: Setzen Sie den Wert dieses Felds auf python, um für diese Aufgabe das Python-Image von Docker Hub zu verwenden.
    • entrypoint: Wenn Sie dieses Feld festlegen, wird der Standardeinstiegspunkt des Bildes ü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: Das Feld args eines Build-Schritts verwendet eine Liste von Argumenten und übergibt sie an das Image, auf das das Feld name verweist. Ü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.

    Der folgende Build-Schritt fügt Argumente hinzu, um Anforderungen aus der Datei requirements.txt zu installieren:

    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 dazu die Tests hinzu. folgende Felder in einem Build-Schritt:

    • name: Setzen Sie den Wert dieses Felds auf python, um das Python-Image aus Docker Hub für Ihre Aufgabe zu verwenden.
    • entrypoint: Setzen Sie den Wert dieses Felds auf python, 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 Kurzversion der mit Ihrem Build verknüpften Commit-ID erstellt. 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. Anwendung containerisieren: Nachdem Sie den Build-Schritt hinzugefügt haben, um zu gewährleisten, dass die Tests bestanden wurden, können Sie die Anwendung erstellen. Cloud Build bietet ein vordefiniertes Docker-Image, das Sie zum Containerisieren Ihrer Python-Anwendung verwenden können. Fügen Sie in einem Build-Schritt die folgenden Felder hinzu, um die Anwendung zu containerisieren:

    • name: Setzen Sie den Wert dieses Felds auf gcr.io/cloud-builders/docker, um das vordefinierte Docker-Image aus Container Registry 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 Kurzversion 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 zum Build-Zeitzeitpunkt automatisch ersetzt.

    # Docker Build
    - name: 'gcr.io/cloud-builders/docker'
      args: ['build', '-t',
             'us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA', '.']
  5. Container an Artifact Registry übertragen: Sie können den erstellten Container in Artifact Registry speichern, einem 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. Wenn Sie Cloud Build zum Speichern des Images in einem Artifact Registry-Docker-Repository konfigurieren möchten, fügen Sie einen Build-Schritt mit den folgenden Feldern hinzu:

    • name: Setzen Sie den Wert dieses Felds auf gcr.io/cloud-builders/docker, um das offizielle docker-Builder-Image für die Aufgabe aus Container Registry 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 im vorherigen Schritt erstellte Image in Artifact Registry verschoben:

    # Docker push to Google Artifact Registry
    - name: 'gcr.io/cloud-builders/docker'
      args: ['push',  'us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA']
  6. Container in Cloud Run bereitstellen: Fügen Sie einen Build-Schritt mit den folgenden Feldern hinzu, um das Image in Cloud Run bereitzustellen:

    • name: Setzen Sie den Wert dieses Felds auf google/cloud-sdk, um das Cloud SDK-Image zu verwenden, um den Befehl gcloud zum Bereitstellen des Images in Cloud Run aufzurufen.
    • 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',
             '--image=us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/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. Dazu geben Sie einen vorhandenen Bucket-Speicherort und einen Pfad zu den Testlogs an. Mit dem folgenden Build-Schritt werden die Testlogs gespeichert, die Sie in der JUNIT-XML-Datei in einem Cloud Storage-Bucket gespeichert haben:

    # 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/$_REPO_NAME/myimage:$SHORT_SHA', '.']
    
      # Docker push to Google Artifact Registry
      - name: 'gcr.io/cloud-builders/docker'
        args: ['push',  'us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA']
    
      # Deploy to Cloud Run
      - name: google/cloud-sdk
        args: ['gcloud', 'run', 'deploy', 'helloworld',
               '--image=us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/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/$_REPO_NAME/myimage:$SHORT_SHA
  8. Starten Sie den Build manuell oder verwenden Sie Build-Trigger.

Nächste Schritte