Django in Cloud Run ausführen

Die Bereitstellung von zustandsorientierten Anwendungen wie Django umfasst das gemeinsame Einbinden mehrerer Dienste, die durch ihre Interaktion ein zusammenhängendes Projekt bilden.

Bei dieser Anleitung wird vorausgesetzt, dass Sie mit der Django-Webentwicklung vertraut sind. Der Beispielcode dient zum Einbinden von grundlegenden Ansichten, Modellen und Routenkonfigurationen. In Verbindung mit dem interaktiven Django-Administrator zeigt dieses Codebeispiel, wie Sie verwaltete Datenbanken, Objektspeicher, verschlüsselte Secrets und Build-Pipelines in serverloses Computing einbinden.

In dieser Anleitung wird insbesondere Django beschrieben. Sie können diesen Bereitstellungsprozess auch mit anderen Django-basierten Frameworks wie Wagtail und Django CMS verwenden.

Diagramm mit der Architektur des Deployments
Die Django-Website wird über Cloud Run bereitgestellt. Er nutzt mehrere Sicherungsdienste, um unterschiedliche Datentypen (relationale Datenbankinformationen, Medien) zu speichern. Assets, Konfigurations-Secrets und Container-Images. Die Back-End-Dienste werden im Rahmen einer Build- und Migrationsaufgabe von Cloud Build aktualisiert.

Kosten

Hinweis

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  4. Cloud Run, Cloud SQL, Cloud Build, Secret Manager, and Compute Engine APIs aktivieren.

    Aktivieren Sie die APIs

  5. Installieren und initialisieren Sie das Cloud SDK.
  6. Achten Sie darauf, dass das für diese Anleitung verwendete Konto über ausreichende Berechtigungen verfügt.

Django App klonen

Nachdem Sie die Voraussetzungen erfüllt haben, laden Sie die Django-Beispiel-App herunter und stellen Sie sie bereit. In den folgenden Abschnitten erfahren Sie, wie Sie die Anwendung konfigurieren, ausführen und bereitstellen.

Django-App klonen

Der Code für die Django-Beispiel-App befindet sich im Repository GoogleCloudPlatform/python-docs-samples auf GitHub.

  1. Sie können entweder das Beispiel als ZIP-Datei herunterladen und entpacken oder das Repository auf Ihren lokalen Computer klonen:

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

  2. Gehen Sie zum Verzeichnis mit dem Beispielcode:

Linux/macOS

  cd python-docs-samples/run/django

Windows

  cd python-docs-samples\run\django

Sicherungsdienste vorbereiten

In dieser Anleitung werden verschiedene Google Cloud-Dienste verwendet, um die Datenbank, den Medienspeicher und den geheimen Speicher zur Verfügung zu stellen, der das bereitgestellte Django-Projekt unterstützt. Diese Dienste werden in einer bestimmten Region bereitgestellt. Aus Gründen der Effizienz zwischen Diensten empfiehlt es sich, alle Dienste in derselben Region bereitzustellen. Weitere Informationen zur nächstgelegenen Region finden Sie unter Regionale Produkte.

Cloud SQL for PostgreSQL-Instanz einrichten

Django unterstützt mehrere relationale Datenbanken, bietet aber für PostgreSQL die beste Unterstützung. Dies ist einer der in Cloud SQL angebotenen Datenbanktypen.

In den folgenden Abschnitten wird die Erstellung einer PostgreSQL-Instanz, einer Datenbank und eines Datenbanknutzers für die Umfrage-App beschrieben.

PostgreSQL-Instanz erstellen

Console

  1. Wechseln Sie in der Cloud Console zur Seite Cloud SQL-Instanzen.

    Zur Seite "Cloud SQL-Instanzen"

  2. Klicken Sie auf Instanz erstellen.

  3. Klicken Sie auf PostgreSQL.

  4. Geben Sie im Feld Instanz-ID einen Namen für die Instanz ein (INSTANCE_NAME).

  5. Geben Sie das Passwort für den Postgres-Nutzer ein.

  6. Übernehmen Sie für die anderen Felder die Standardwerte.

  7. Klicken Sie auf Erstellen.

gcloud

  1. Erstellen Sie die PostgreSQL-Instanz:

    gcloud sql instances create INSTANCE_NAME \
    --project PROJECT_ID \
    --database-version POSTGRES_12 \
    --tier db-f1-micro \
    --region REGION

    Dabei gilt:

    • INSTANCE_NAME: der Name der Cloud SQL-Instanz
    • PROJECT_ID: die Google Cloud-Projekt-ID
    • REGION: die Google Cloud-Region

    Es dauert einige Minuten, bis die Instanz erstellt und einsatzbereit ist.

  2. Legen Sie ein Passwort für den Nutzer postgres fest.

    gcloud sql users set-password postgres \
    --instance INSTANCE_NAME --prompt-for-password

Datenbank erstellen

Console

  1. Wechseln Sie in der Cloud Console zur Seite Cloud SQL-Instanzen.

    Zur Seite "Cloud SQL-Instanzen"

  2. Wählen Sie die Instanz INSTANCE_NAME aus.

  3. Wechseln Sie zum Tab Datenbanken.

  4. Klicken Sie auf Datenbank erstellen.

  5. Geben Sie im Dialogfeld Datenbankname DATABASE_NAME ein.

  6. Klicken Sie auf Erstellen.

gcloud

  • Erstellen Sie die Datenbank innerhalb der kürzlich erstellten Instanz:

    gcloud sql databases create DATABASE_NAME \
    --instance INSTANCE_NAME

    Ersetzen Sie DATABASE_NAME durch einen Namen für die Datenbank innerhalb der Instanz.

Nutzer erstellen

Console

  1. Aktivieren Sie Cloud Shell in der Cloud Console.

    Cloud Shell aktivieren

  2. Verwenden Sie in Cloud Shell den integrierten gcloud-Client, um eine Verbindung zur Instanz INSTANCE_NAME herzustellen:

    gcloud sql connect INSTANCE_NAME --user postgres

  3. Geben Sie das Nutzerpasswort für Postgres ein.

    Du verwendest jetzt psql. Die postgres=>-Eingabeaufforderung sollte nun angezeigt werden.

  4. Erstellen Sie einen Nutzer:

    CREATE USER 'django' WITH PASSWORD 'PASSWORD';

    Ersetzen Sie PASSWORD durch ein ausreichend geheimes Passwort.

  5. Gewähren Sie dem neuen Nutzer uneingeschränkte Rechte für die neue Datenbank:

    GRANT ALL PRIVILEGES ON DATABASE 'DATABASE_NAME' TO 'django';

  6. Beenden Sie psql:

    \q

gcloud

  1. Stellen Sie eine Verbindung zur SQL-Instanz her:

    gcloud sql connect INSTANCE_NAME --user postgres

    Ersetzen Sie INSTANCE_NAME durch die erstellte Cloud SQL-Instanz.

  2. Geben Sie das Nutzerpasswort für Postgres ein.

    Du verwendest jetzt psql. Die postgres=>-Eingabeaufforderung sollte nun angezeigt werden.

  3. Erstellen Sie einen Nutzer:

    CREATE USER 'django' WITH PASSWORD 'PASSWORD';

  4. Gewähren Sie dem neuen Nutzer uneingeschränkte Rechte für die neue Datenbank:

    GRANT ALL PRIVILEGES ON DATABASE 'DATABASE_NAME' TO 'django';

  5. Beenden Sie psql:

    \q

Cloud Storage-Bucket einrichten

Sie können die in Django enthaltenen statischen Inhalte sowie von Nutzern hochgeladene Medien in einem hochverfügbaren Objektspeicher mit Cloud Storage speichern. Das Paket django-storages[google] steuert die Interaktion von Django mit diesem Speicher-Back-End.

Console

  1. Wechseln Sie in der Cloud Console zum Cloud Storage-Browser.

    Browser aufrufen

  2. Klicken Sie auf Bucket erstellen.
  3. Geben Sie auf der Seite Bucket erstellen die Bucket-Informationen ein. Klicken Sie auf Weiter, um mit dem nächsten Schritt fortzufahren.
    • Geben Sie unter Bucket benennen einen Namen ein, der den Anforderungen für Bucket-Namen entspricht.
    • Wählen Sie unter Standort Folgendes aus: PROJECT_ID-media
    • Wählen Sie unter Standardspeicherklasse für Ihre Daten auswählen Folgendes aus: Standard.
    • Wählen Sie unter Zugriffssteuerung für Objekte auswählen eine Option für die Zugriffssteuerung aus.
    • Geben Sie für Erweiterte Einstellungen (optional) eine Verschlüsselungsmethode, eine Aufbewahrungsrichtlinie oder Bucket-Labels an.
  4. Klicken Sie auf Erstellen.

gcloud

Das gsutil-Befehlszeilentool wurde bei der Installation des Cloud SDK installiert.

  • Erstellen Sie einen Cloud Storage-Bucket:

    gsutil mb -l REGION gs://PROJECT_ID-media

Secret-Werte im Secret Manager speichern

Nachdem die Sicherungsdienste konfiguriert sind, benötigt Django Informationen zu diesen Diensten. Anstatt diese Werte direkt in den Django-Quellcode einzufügen, wird in dieser Anleitung Secret Manager zum sicheren Speichern dieser Informationen verwendet.

Cloud Run und Cloud Build nutzen die jeweiligen Dienstkonten für Secrets, die durch eine E-Mail-Adresse mit der Projektnummer interagieren.

Django-Umgebungsdatei als Secret Manager-Secret erstellen

Sie speichern die Einstellungen, die zum Starten von Django erforderlich sind, in einer sicheren .env-Datei. Der Beispielcode verwendet die Secret Manager API, um den Secret-Wert abzurufen, und das Paket django-environ, um die Werte in die Django-Umgebung zu laden. Der Zugriff auf Secrets ist für Cloud Build und Cloud Run so konfiguriert, dass sie mit beiden Diensten ausgeführt werden können.

  1. Erstellen Sie eine Datei mit dem Namen .env und definieren Sie den Datenbank-Verbindungsstring, den Namen des Medien-Buckets sowie einen neuen SECRET_KEY-Wert:

    DATABASE_URL=postgres://django:PASSWORD@//cloudsql/PROJECT_ID:REGION:INSTANCE_NAME/DATABASE_NAME
GS_BUCKET_NAME=PROJECT_ID-media
SECRET_KEY=(a random string, length 50)

  2. Speichern Sie das Secret in Secret Manager:

Console

  1. Rufen Sie in der Cloud Console die Seite „Secret Manager“ auf.

    Zur Seite "Secret Manager"

  2. Klicken Sie auf Secret erstellen.

  3. Geben Sie im Feld Name django_settings ein.

  4. Wählen Sie im Dialogfeld Datei hochladen die lokal gespeicherte .env-Datei aus.

  5. Klicken Sie auf Secret erstellen.

  6. Notieren Sie sich die unter Details für django_settings angezeigte Projektnummer:

    projects/PROJECTNUM/secrets/django_settings

  7. Klicken Sie auf Mitglied hinzufügen.

  8. Geben Sie in das Feld Neue Mitglieder PROJECTNUM-compute@developer.gserviceaccount.com ein und drücken Sie dann Enter.

  9. Geben Sie in das Feld Neue Mitglieder PROJECTNUM@cloudbuild.gserviceaccount.com ein und drücken Sie dann Enter.

  10. Wählen Sie im Drop-down-Menü Rolle die Option Secret Manager Secret Accessor aus.

  11. Klicken Sie auf Speichern.

gcloud

  1. Erstellen Sie ein neues Secret, django_settings:

    gcloud secrets create django_settings --replication-policy automatic

  2. Fügen Sie die Datei .env als Version des Secrets hinzu.

    gcloud secrets versions add django_settings --data-file .env

  3. Prüfen Sie Folgendes, um die Erstellung des Secrets zu bestätigen:

    gcloud secrets describe django_settings

    Notieren Sie sich die Projektnummer.

    projects/PROJECTNUM/secrets/django_settings

  4. Gewähren Sie dem Cloud Run-Dienstkonto Zugriff auf das Secret:

    gcloud secrets add-iam-policy-binding django_settings \
    --member serviceAccount:PROJECTNUM-compute@developer.gserviceaccount.com \
    --role roles/secretmanager.secretAccessor

  5. Gewähren Sie dem Cloud Build-Dienstkonto Zugriff auf das Secret:

    gcloud secrets add-iam-policy-binding django_settings \
    --member serviceAccount:PROJECTNUM@cloudbuild.gserviceaccount.com \
    --role roles/secretmanager.secretAccessor

    Achten Sie in der Ausgabe darauf, dass bindings die beiden Dienstkonten als Mitglieder auflistet.

Secret für das Administratorpasswort von Django erstellen

Der Django-Administrator wird normalerweise durch Ausführen des interaktiven Verwaltungsbefehls createsuperuser erstellt.

In dieser Anleitung wird eine Datenmigration verwendet, um den Administrator zu erstellen, wobei das genannte Passwort aus Secret Manager abgerufen wird.

Console

  1. Rufen Sie in der Cloud Console die Seite „Secret Manager“ auf.

  2. Klicken Sie auf Secret erstellen.

  3. Geben Sie im Feld Name superuser_password ein.

  4. Geben Sie in das Feld Secret-Wert ein zufälliges Passwort ein.

  5. Klicken Sie auf Secret erstellen.

  6. Notieren Sie sich die unter Details für superuser_password angezeigte Projektnummer (projects/PROJECTNUM/secrets/superuser_password).

  7. Klicken Sie auf Mitglied hinzufügen.

  8. Geben Sie in das Feld Neue Mitglieder PROJECTNUM@cloudbuild.gserviceaccount.com ein und drücken Sie dann Enter.

  9. Wählen Sie im Drop-down-Menü Rolle die Option Secret Manager Secret Accessor aus.

  10. Klicken Sie auf Speichern.

gcloud

  1. Erstellen Sie ein neues Secret, superuser_password:

    gcloud secrets create superuser_password --replication-policy automatic

  2. Fügen Sie ein zufällig generiertes Passwort als Version des Secrets hinzu:

    cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c30 > superuser_password

gcloud secrets versions add superuser_password --data-file superuser_password

  3. Gewähren Sie Cloud Build Zugriff auf das Secret:

    gcloud secrets add-iam-policy-binding superuser_password \
    --member serviceAccount:PROJECTNUM@cloudbuild.gserviceaccount.com \
    --role roles/secretmanager.secretAccessor

    Achten Sie in der Ausgabe darauf, dass bindings nur Cloud Build als Mitglied auflistet.

Cloud Build Zugriff auf Cloud SQL gewähren

Damit Cloud Build die Datenbankmigrationen anwenden kann, müssen Sie Cloud Build Berechtigungen für den Zugriff auf Cloud SQL erteilen.

Console

  1. Wechseln Sie in der Cloud Console zur Seite Identitäts- und Zugriffsverwaltung.

    Zur Seite „Identitäts- und Zugriffsverwaltung“

  2. Wenn Sie den Eintrag für PROJECTNUM@cloudbuild.gserviceaccount.com bearbeiten möchten, klicken Sie auf Bearbeiten.

  3. Klicken Sie auf Weitere Rolle hinzufügen.

  4. Wählen Sie im Dialogfeld Rolle auswählen die Option Cloud SQL-Client aus.

  5. Klicken Sie auf Speichern.

gcloud

  1. Gewähren Sie Cloud Build die Berechtigung, auf Cloud SQL zuzugreifen:

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member serviceAccount:PROJECTNUM@cloudbuild.gserviceaccount.com \
    --role roles/cloudsql.client

Erste Bereitstellung der Anwendung

Da die Sicherungsdienste nun eingerichtet sind, können Sie jetzt den Cloud Run-Dienst bereitstellen.

  1. Verwenden Sie die bereitgestellte Datei cloudmigrate.yaml, um mithilfe von Cloud Build das Image zu erstellen, die Datenbankmigrationen auszuführen und die statischen Assets zu füllen:

    gcloud builds submit --config cloudmigrate.yaml \
    --substitutions _INSTANCE_NAME=INSTANCE_NAME,_REGION=REGION

    Dieser erste Build-Vorgang kann einige Minuten dauern.

  2. Wenn der Build erfolgreich ist, stellen Sie den Cloud Run-Dienst zum ersten Mal bereit. Legen Sie die Dienstregion, das Basis-Image und die verbundene Cloud SQL-Instanz fest:

    gcloud run deploy polls-service \
    --platform managed \
    --region REGION \
    --image gcr.io/PROJECT_ID/polls-service \
    --add-cloudsql-instances PROJECT_ID:REGION:INSTANCE_NAME \
    --allow-unauthenticated

    Aus der angezeigten Ausgabe sollte hervorgehen, dass die Bereitstellung erfolgreich war, und es sollte eine Dienst-URL ausgegeben werden:

    Service [polls-service] revision [polls-service-00001-tug] has been deployed
and is serving 100 percent of traffic at https://polls-service--uc.a.run.app

  3. Rufen Sie die Dienst-URL auf, um sich den bereitgestellten Dienst anzeigen zu lassen.

    Screenshot der Landingpage der Umfrage-App
    Wenn in der Dienst-URL „You're at the polls index“ („Sie befinden sich im Umfrageindex“) angezeigt wird, wurde die Django-Anwendung erfolgreich bereitgestellt.

  4. Wenn Sie sich als Django-Administrator anmelden möchten, fügen Sie /admin an die URL an und melden Sie sich mit dem Nutzernamen admin und dem zuvor festgelegten Passwort an.

    Screenshot des Django-Administrators
    Nach der Authentifizierung wird der Django-Administrator angezeigt. In der Umfrage-App ist das Fragenmodell zu sehen.

Mindestberechtigungen festlegen (optional)

Standardmäßig wird dieser Dienst mit dem Standarddienstkonto von Compute bereitgestellt. In einigen Fällen kann die Verwendung des Standarddienstkontos jedoch zu viele Berechtigungen gewähren. Wenn Sie stärker einschränken möchten, müssen Sie ein eigenes Dienstkonto erstellen und nur die Berechtigungen erteilen, die für Ihren Dienst erforderlich sind. Die erforderlichen Berechtigungen variieren je nach Dienst. Dies hängt von den Ressourcen ab, die von einem bestimmten Dienst verwendet werden.

Für diesen Dienst sind mindestens folgende Projektrollen erforderlich:

  • Cloud Run-Aufrufer
  • Cloud SQL-Client
  • Storage-Administrator im Medien-Bucket
  • Secret Manager-Zugriffsfunktion im Django-Einstellungs-Secret. (Der Zugriff auf das Django-Administratorschlüssel ist nicht erforderlich.

So erstellen Sie ein Dienstkonto mit den erforderlichen Berechtigungen:

  1. Erstellen Sie in Cloud Shell ein Dienstkonto mit den erforderlichen Rollen:

    gcloud iam service-accounts create polls-service-account
SERVICE_ACCOUNT=polls-service-account@PROJECT_ID.iam.gserviceaccount.com

# Cloud Run Invoker
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member serviceAccount:${SERVICE_ACCOUNT} \
    --role roles/run.Invoker

# Cloud SQL Client
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member serviceAccount:${SERVICE_ACCOUNT} \
    --role roles/cloudsql.client

# Storage Admin, on the media bucket
gsutil iam ch \
    serviceAccount:${SERVICE_ACCOUNT}:roles/storage.objectAdmin \
    gs://PROJECT_ID-media

# Secret Accessor, on the Django settings secret.
gcloud secrets add-iam-policy-binding django_settings \
    --member serviceAccount:${SERVICE_ACCOUNT} \
    --role roles/secretmanager.secretAccessor

  2. Stellen Sie den Dienst bereit und verknüpfen Sie ihn mit dem neuen Dienstkonto:

    gcloud run deploy polls-service \
    --platform managed \
    --region REGION \
    --image gcr.io/PROJECT_ID/polls-service \
    --service-account ${SERVICE_ACCOUNT}

Anwendung noch einmal bereitstellen

Die ersten Schritte zum Bereitstellen waren zwar komplex, aber die erneute Bereitstellung ist relativ einfach.

  1. Führen Sie das Build- und Migrationsskript von Cloud Build aus:

    gcloud builds submit --config cloudmigrate.yaml \
    --substitutions _INSTANCE_NAME=INSTANCE_NAME,_REGION=REGION

  2. Stellen Sie den Dienst bereit und geben Sie dabei nur die Region und das Image an:

    gcloud run deploy polls-service \
    --platform managed \
    --region REGION \
    --image gcr.io/PROJECT_ID/polls-service

Code verstehen

Die Django-Beispiel-App wurde mit den Django-Standardtools erstellt. Mit den folgenden Befehlen werden das Projekt und die Umfrage-App erstellt:

django-admin startproject mysite .
python manage.py startapp polls

Die grundlegenden Ansichten, Modelle und Routenkonfigurationen werden aus Erste Django-Anwendung schreiben (Teil 1 und Teil 2) kopiert.

Secrets aus Secret Manager

Die Datei settings.py enthält Code, der die Secret Manager Python API verwendet, um die neueste Version des benannten Secrets abzurufen und mit django-environ in die Umgebung zu übertragen:

run/django/mysite/settings.py 
env = environ.Env(DEBUG=(bool, False))
env_file = os.path.join(BASE_DIR, ".env")

# Attempt to load the Project ID into the environment, safely failing on error.
try:
    _, os.environ["GOOGLE_CLOUD_PROJECT"] = google.auth.default()
except google.exceptions.DefaultCredentialsError:
    pass

if os.path.isfile(env_file):
    # Use a local secret file, if provided

    env.read_env(env_file)
# ...
elif os.environ.get("GOOGLE_CLOUD_PROJECT", None):
    # Pull secrets from Secret Manager
    project_id = os.environ.get("GOOGLE_CLOUD_PROJECT")

    client = secretmanager.SecretManagerServiceClient()
    settings_name = os.environ.get("SETTINGS_NAME", "django_settings")
    name = f"projects/{project_id}/secrets/{settings_name}/versions/latest"
    payload = client.access_secret_version(name=name).payload.data.decode("UTF-8")

    env.read_env(io.StringIO(payload))
else:
    raise Exception("No local .env or GOOGLE_CLOUD_PROJECT detected. No secrets found.")

Mit django_settings wurden mehrere Secret-Werte gespeichert, um die Anzahl der verschiedenen Secrets zu reduzieren, die konfiguriert werden mussten.

Obwohl superuser_password direkt über die Befehlszeile hätte erstellt werden können, wurde stattdessen die dateibasierte Methode verwendet. Beim Generieren über die Befehlszeile wurde mit head -c geprüft, wie lange der verwendete, zufällig generierte String ist. Gleichzeitig wurde sichergestellt, dass am Ende der Datei kein Zeilenvorschubzeichen enthalten war. Dies hätte bei der Eingabe des Passworts als Django-Administrator zu Problemen geführt.

Datenbankverbindung

Da das django_settings-Secret einen speziell formatierten String für die Datenbankverbindung enthielt, kann die Datenbankhilfsfunktion von django-environ aufgerufen werden, um den Wert DATABASES zuzuweisen:

run/django/mysite/settings.py 
# Use django-environ to parse the connection string
DATABASES = {"default": env.db()}

# If the flag as been set, configure to use proxy
if os.getenv("USE_CLOUD_SQL_AUTH_PROXY", None):
    DATABASES["default"]["HOST"] = "127.0.0.1"
    DATABASES["default"]["PORT"] = 5432

Im Gegensatz zur Definition separater Werte für die Komponenten der Datenbankverbindungsinformationen wurde diese Methode verwendet.

In der Cloud gespeichert

Die Datei settings.py verwendet auch django-storages, um den Cloud Storage-Medien-Bucket direkt in das Projekt einzubinden:

run/django/mysite/settings.py 
# Define static storage via django-storages[google]
GS_BUCKET_NAME = env("GS_BUCKET_NAME")

DEFAULT_FILE_STORAGE = "storages.backends.gcloud.GoogleCloudStorage"
STATICFILES_STORAGE = "storages.backends.gcloud.GoogleCloudStorage"
GS_DEFAULT_ACL = "publicRead"

Automatisierung mit Cloud Build

Die cloudmigrate.yaml-Datei führt nicht nur die typischen Image-Build-Schritte aus, mit denen das Container-Image erstellt und in die Container Registry übertragen wird, sondern auch die Django-Befehle migrate und collectstatic. Diese benötigen Zugriff auf die Datenbank. Erreicht wird dies mit app-engine-exec-wrapper, einer Hilfefunktion für Cloud SQL Proxy:

run/django/cloudmigrate.yaml 
steps:
  - id: "build image"
    name: "gcr.io/cloud-builders/docker"
    args: ["build", "-t", "gcr.io/${PROJECT_ID}/${_SERVICE_NAME}", "."]

  - id: "push image"
    name: "gcr.io/cloud-builders/docker"
    args: ["push", "gcr.io/${PROJECT_ID}/${_SERVICE_NAME}"]

  - id: "apply migrations"
    name: "gcr.io/google-appengine/exec-wrapper"
    args:
      [
        "-i",
        "gcr.io/$PROJECT_ID/${_SERVICE_NAME}",
        "-s",
        "${PROJECT_ID}:${_REGION}:${_INSTANCE_NAME}",
        "-e",
        "SETTINGS_NAME=${_SECRET_SETTINGS_NAME}",
        "--",
        "python",
        "manage.py",
        "migrate",
      ]

  - id: "collect static"
    name: "gcr.io/google-appengine/exec-wrapper"
    args:
      [
        "-i",
        "gcr.io/$PROJECT_ID/${_SERVICE_NAME}",
        "-s",
        "${PROJECT_ID}:${_REGION}:${_INSTANCE_NAME}",
        "-e",
        "SETTINGS_NAME=${_SECRET_SETTINGS_NAME}",
        "--",
        "python",
        "manage.py",
        "collectstatic",
        "--verbosity",
        "2",
        "--no-input",
      ]

substitutions:
  _INSTANCE_NAME: django-instance
  _REGION: us-central1
  _SERVICE_NAME: polls-service
  _SECRET_SETTINGS_NAME: django_settings

images:
  - "gcr.io/${PROJECT_ID}/${_SERVICE_NAME}"

In dieser Konfiguration werden Substitutionsvariablen verwendet. Wenn Sie die Werte direkt in der Datei ändern, kann das Flag --substitutions zum Zeitpunkt der Migration weggelassen werden.

In dieser Konfiguration werden nur vorhandene Migrationen angewendet. Fügen Sie einen Schritt makemigrations hinzu, um diese Konfiguration zur Generierung von Migrationen zu erweitern.

Wenn Sie die Cloud Build-Konfiguration erweitern möchten, um die Bereitstellung in eine einzige Konfiguration aufzunehmen, ohne zwei Befehle ausführen zu müssen, finden Sie weitere Informationen unter Kontinuierliche Bereitstellung aus Git mit Cloud Build. Dies erfordert die beschriebenen IAM-Änderungen.

Erstellung von Superusern mit Datenmigrationen

Der Django-Verwaltungsbefehl createsuperuser kann nur interaktiv ausgeführt werden, das heißt, wenn der Nutzer Informationen als Reaktion auf eine Eingabeaufforderung eingeben kann. Sie können diesen Befehl zwar mit dem Cloud SQL-Proxy verwenden und Befehle innerhalb einer lokalen Docker-Konfiguration ausführen, Sie können den Superuser aber auch als Datenmigration erstellen:

run/django/mysite/migrations/0001_createsuperuser.py 
import os

from django.contrib.auth.models import User
from django.db import migrations
from django.db.backends.postgresql.schema import DatabaseSchemaEditor
from django.db.migrations.state import StateApps

import google.auth
from google.cloud import secretmanager

def createsuperuser(apps: StateApps, schema_editor: DatabaseSchemaEditor) -> None:
    """
    Dynamically create an admin user as part of a migration
    Password is pulled from Secret Manger (previously created as part of tutorial)
    """
    if os.getenv("TRAMPOLINE_CI", None):
        # We are in CI, so just create a placeholder user for unit testing.
        admin_password = "test"
    else:
        client = secretmanager.SecretManagerServiceClient()

        # Get project value for identifying current context
        _, project = google.auth.default()

        # Retrieve the previously stored admin password
        PASSWORD_NAME = os.environ.get("PASSWORD_NAME", "superuser_password")
        name = f"projects/{project}/secrets/{PASSWORD_NAME}/versions/latest"
        admin_password = client.access_secret_version(name=name).payload.data.decode(
            "UTF-8"
        )

    # Create a new user using acquired password, stripping any accidentally stored newline characters
    User.objects.create_superuser("admin", password=admin_password.strip())

class Migration(migrations.Migration):

    initial = True
    dependencies = []
    operations = [migrations.RunPython(createsuperuser)]

Clean-up

  1. Wechseln Sie in der Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.