Python-Anwendungen erstellen

Auf dieser Seite wird beschrieben, wie Sie Cloud Build so konfigurieren, dass es Python-Anwendungen erstellt, testet und bereitstellt. 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. Im öffentlichen python-Image aus Docker Hub sind die Tools python und pip vorinstalliert. Mit diesen Tools können Sie Cloud Build für die Installation von Abhängigkeiten konfigurieren, Einheitentests erstellen und Einheitentests ausführen.

Hinweis

Bei der Anleitung 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

  • Zum Ausführen des Befehls gcloud auf dieser Seite installieren Sie das Cloud SDK.
  • Halten Sie Ihr Python-Projekt bereit, einschließlich der Datei requirements.txt.
  • Wenn Sie Ihre Python-Anwendung mit Cloud Build containerisieren möchten, benötigen Sie Ihren 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 mithilfe der IAM-Seite gewähren.

Python-Builds konfigurieren

In diesem Abschnitt wird eine Beispiel-Build-Konfigurationsdatei für eine Python-Anwendung beschrieben. Sie enthält Build-Schritte, um Anforderungen zu installieren, Einheitentests hinzuzufügen und nach Abschluss der Tests die Anwendung zu erstellen, bereitzustellen und bereitzustellen.

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

  2. Installationsanforderungen: Im python-Image von Docker Hub ist pip vorinstalliert. Zum Installieren von Abhängigkeiten aus pip fügen Sie einen Build-Schritt mit den folgenden Feldern hinzu:

    • name: Legen Sie den Wert dieses Felds auf python fest, um das Python-Image aus Docker Hub für diese Aufgabe zu verwenden.
    • entrypoint: Wenn Sie dieses Feld festlegen, wird der Standardeinstiegspunkt des in name referenzierten Images überschrieben. Legen Sie den Wert dieses Felds auf pip fest, um pip als Einstiegspunkt des Build-Schritts aufzurufen und pip-Befehle auszuführen.
    • args: Das Feld args eines Build-Schritts übergibt eine Liste von Argumenten an das Image, auf das im Feld name verwiesen wird. Übergeben Sie die Argumente zum Ausführen des Befehls pip install in diesem Feld.

    Im 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 Einheitentests in Ihrer Anwendung mithilfe eines Test-Frameworks wie pytest definiert haben, können Sie Cloud Build so konfigurieren, dass die Tests durch Hinzufügen des folgenden Feldern in einem Build-Schritt:

    • name: Legen Sie den Wert dieses Feldes auf python fest, um das Python-Image aus 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 pytest in einer JUNIT-XML-Datei gespeichert. Der Name dieser Datei wird mithilfe der kurzen Version der mit Ihrem Build verknüpften Commit-ID erstellt. Durch einen 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: Nachdem Sie den Build-Schritt hinzugefügt haben, um sicherzustellen, dass die Tests bestanden wurden, können Sie die Anwendung erstellen. Cloud Build bietet ein vordefiniertes Docker-Image, mit dem Sie Ihre Python-Anwendung containerisieren können. Zur Containerisierung Ihrer Anwendung fügen Sie einem Build-Schritt die folgenden Felder hinzu:

    • name: Legen Sie den Wert dieses Feldes auf gcr.io/cloud-builders/docker fest, 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. Für den Build-Schritt werden die Standardsubstitutionen für die Projekt-ID, den Repository-Namen und kurze SHA-Werte verwendet. Diese Werte werden bei der Build-Erstellung 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 in die Artifact Registry übertragen: Sie können den erstellten Container in Artifact Registry speichern. Dieser Google Cloud-Dienst ist zum Speichern, Verwalten und Schützen von Build-Artefakten verwendet. Dafür benötigen Sie ein vorhandenes Docker-Repository in Artifact Registry. Damit Sie Cloud Build so konfigurieren können, dass das Image in einem Docker-Repository von Artifact Registry 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 aus Container Registry für Ihre Aufgabe zu verwenden.
    • args: Fügen Sie die Argumente für den Befehl docker push als Werte in diesem Feld hinzu. Geben Sie als Ziel-URL das Docker-Repository von Artifact Registry an, in dem Sie das Image speichern möchten.

    Mit dem folgenden Build-Schritt wird das im vorherigen Schritt erstellte Image per Push in die Artifact Registry übertragen:

    # 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: Legen Sie den Wert dieses Feldes auf google/cloud-sdk fest, um mit dem Cloud SDK-Image den gcloud-Befehl aufzurufen, 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',
             '--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. Der folgende Build-Schritt speichert die Testlogs, die Sie in der JUNIT-XML-Datei gespeichert haben, in einem Cloud Storage-Bucket:

    # 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 mithilfe von Build-Triggern.

Nächste Schritte