Django in Google Kubernetes Engine ausführen

Django-Apps, die auf GKE ausgeführt werden, werden dynamisch dem Traffic entsprechend skaliert.

In dieser Anleitung wird davon ausgegangen, dass Sie mit der Django-Webentwicklung vertraut sind. Wenn Sie mit der Django-Entwicklung noch nicht vertraut sind, sollten Sie zuerst Ihre erste Django-Anwendung schreiben.

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

In dieser Anleitung wird Django 5 verwendet, das mindestens Python 3.10 erfordert.

Außerdem muss Docker installiert sein.

Ziele

In dieser Anleitung wird Folgendes beschrieben:

Cloud SQL-Datenbank erstellen und verbinden
Secret-Werte von Kubernetes erstellen und verwenden
Django-Anwendung in Google Kubernetes Engine bereitstellen

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Neuen Nutzern von Google Cloud steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweis

Melden Sie sich in Ihrem Google Cloud -Konto an. Wenn Sie mit Google Cloudnoch 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.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Cloud SQL, GKE and Compute Engine APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Installieren Sie die gcloud CLI.

Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Cloud SQL, GKE and Compute Engine APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Installieren Sie die gcloud CLI.

Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren:

gcloud init

Umgebung vorbereiten

Beispielanwendung klonen

Den Code für die Django-Beispielanwendung finden Sie im Repository GoogleCloudPlatform/python-docs-samples auf GitHub.

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

Gehen Sie zum Verzeichnis mit dem Beispielcode:

Linux/macOS

cd python-docs-samples/kubernetes_engine/django_tutorial

Windows

cd python-docs-samples\kubernetes_engine\django_tutorial

Python-Einrichtung bestätigen

Diese Anleitung setzt auf Python, um die Beispielanwendung auf Ihrem Computer auszuführen. Der Beispielcode erfordert auch die Installation von Abhängigkeiten.

Weitere Informationen finden Sie im Leitfaden zur Python-Entwicklungsumgebung.

Prüfen Sie, ob Python mindestens Version 3.10 hat.
```
 python -V
```
Sie sollten Python 3.10.0 oder höher haben.

Hinweis: Wenn die Versionsnummer mit "2" beginnt, müssen Sie möglicherweise python3 anstelle von python ausführen. Wenn ja, sollten Sie bei der Ausführung von python-Befehlen auf die ausgewählte Python-Installation verweisen.

Erstellen Sie eine virtuelle Python-Umgebung und installieren Sie Abhängigkeiten:

Linux/macOS

python -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt

Windows

python -m venv venv
venv\scripts\activate
pip install --upgrade pip
pip install -r requirements.txt

Cloud SQL Auth-Proxy herunterladen, um von Ihrem lokalen Computer aus eine Verbindung zu Cloud SQL herzustellen

Nach der Bereitstellung verwendet die Anwendung den in die Google Kubernetes Engine-Umgebung integrierten Cloud SQL Auth-Proxy, um mit der Cloud SQL-Instanz zu kommunizieren. Sie müssen jedoch eine lokale Kopie des Cloud SQL Proxys in Ihrer Entwicklungsumgebung installieren und verwenden, um die Anwendung lokal zu testen. Weitere Informationen finden Sie im Leitfaden für den Cloud SQL Auth-Proxy.

Der Cloud SQL Auth-Proxy verwendet die Cloud SQL API, um mit Ihrer SQL-Instanz zu interagieren. Dazu ist eine Authentifizierung der Anwendung über die gcloud CLI erforderlich.

Authentifizieren und rufen Sie Anmeldedaten für die API ab:
```
gcloud auth application-default login
```
Laden Sie den Cloud SQL Auth-Proxy herunter und installieren Sie ihn auf Ihrem lokalen Computer.
Linux 64-Bit
1. Laden Sie den Cloud SQL Auth-Proxy herunter:
  curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.linux.amd64
2. Machen Sie den Cloud SQL Auth-Proxy ausführbar:
  chmod +x cloud-sql-proxy
Linux 32-Bit
1. Laden Sie den Cloud SQL Auth-Proxy herunter:
  curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.linux.386
2. Wenn der Befehl curl nicht gefunden wird, führen Sie sudo apt install curl aus und wiederholen Sie den Downloadbefehl.
3. Machen Sie den Cloud SQL Auth-Proxy ausführbar:
  chmod +x cloud-sql-proxy
macOS 64-Bit
1. Laden Sie den Cloud SQL Auth-Proxy herunter:
  curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.darwin.amd64
2. Machen Sie den Cloud SQL Auth-Proxy ausführbar:
  chmod +x cloud-sql-proxy
Mac M1
1. Laden Sie den Cloud SQL Auth-Proxy herunter:
  curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.darwin.arm64
2. Machen Sie den Cloud SQL Auth-Proxy ausführbar:
  chmod +x cloud-sql-proxy
Windows 64-Bit
Klicken Sie mit der rechten Maustaste auf https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.x64.exe und wählen Sie Link speichern unter aus, um den Cloud SQL Auth-Proxy herunterzuladen. Benennen Sie die Datei in cloud-sql-proxy.exe um.

Windows 32-Bit
Klicken Sie mit der rechten Maustaste auf https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.x86.exe und wählen Sie Link speichern unter aus, um den Cloud SQL Auth-Proxy herunterzuladen. Benennen Sie die Datei in cloud-sql-proxy.exe um.
Docker-Image des Cloud SQL Auth-Proxys

Der Cloud SQL Auth-Proxy hat verschiedene Container-Images, z. B. distroless, alpine und buster. Das standardmäßige Cloud SQL Auth-Proxy-Container-Image verwendet distroless, das keine Shell enthält. Wenn Sie eine Shell oder verwandte Tools benötigen, laden Sie ein auf alpine oder buster basierendes Image herunter. Weitere Informationen finden Sie unter Container-Images von Cloud SQL Auth-Proxy.

Sie können das neueste Image mithilfe von Docker mit dem folgenden Befehl auf Ihren lokalen Computer übertragen:
```
docker pull gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.21.1
```
Hinweis: Der Cloud SQL Auth-Proxy verwendet ein Repository, das die Domain gcr.io unterstützt, aber Images aus Artifact Registry bereitstellt. Weitere Informationen finden Sie unter Von Container Registry wechseln.
Andere Betriebssysteme
Für andere Betriebssysteme, die hier nicht aufgeführt sind, können Sie den Cloud SQL Auth-Proxy aus der Quelle kompilieren.
Sie können den Download an einen gemeinsam genutzten Speicherort verschieben, z. B. in einen Speicherort in Ihrem PATH oder in Ihr Basisverzeichnis. Wenn Sie das tun, müssen Sie beim Starten des Cloud SQL Auth-Proxys später in der Anleitung bei der Verwendung von cloud-sql-proxy-Befehlen auf den ausgewählten Speicherort verweisen.

Sicherungsdienste erstellen

In dieser Anleitung werden verschiedene Google Cloud -Dienste verwendet, um die Datenbank, den Medienspeicher und den Secret-Speicher bereitzustellen, die das bereitgestellte Django-Projekt unterstützen. Diese Dienste werden in einer bestimmten Region bereitgestellt. Zur Steigerung der Effizienz zwischen den Diensten sollten alle Dienste in derselben Region bereitgestellt werden. Weitere Informationen zur nächstgelegenen Region finden Sie unter Produktverfügbarkeit nach Region.

Cloud SQL for PostgreSQL-Instanz einrichten

Django unterstützt offiziell mehrere relationale Datenbanken, bietet aber für PostgreSQL die beste Unterstützung. PostgreSQL wird von Cloud SQL unterstützt. In dieser Anleitung wird daher dieser Datenbanktyp verwendet.

Im folgenden Abschnitt wird das Erstellen einer PostgreSQL-Instanz, einer Datenbank und eines Datenbanknutzers für die Anwendung beschrieben.

Erstellen Sie die PostgreSQL-Instanz:
Console
1. Wechseln Sie in der Google Cloud Console zur Seite Cloud SQL-Instanzen.
  
  Zur Seite "Cloud SQL-Instanzen"
2. Klicken Sie auf Instanz erstellen.
3. Klicken Sie auf PostgreSQL auswählen.
4. Wählen Sie unter SQL-Version die Option „Enterprise“ aus.
5. Wählen Sie unter Versionsvoreinstellung die Option „Sandbox“ aus.
6. Geben Sie im Feld Instanz-ID den Wert INSTANCE_NAME ein.
7. Geben Sie das Passwort für den Postgres-Nutzer ein.
8. Übernehmen Sie für die anderen Felder die Standardwerte.
9. Klicken Sie auf Instanz erstellen.
Es dauert einige Minuten, bis die Instanz einsatzbereit ist.
gcloud
- Erstellen Sie die PostgreSQL-Instanz:
  gcloud sql instances create INSTANCE_NAME \ --project PROJECT_ID \ --database-version POSTGRES_16 \ --tier db-n1-standard-2 \ --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.
Erstellen Sie in der erstellten Instanz eine Datenbank:
Console
1. Wechseln Sie auf der Instanzseite zum Tab Datenbanken.
2. Klicken Sie auf Datenbank erstellen.
3. Geben Sie im Dialogfeld Datenbankname DATABASE_NAME ein.
4. Klicken Sie auf Erstellen.
gcloud
- Erstellen Sie die Datenbank in 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 in der Instanz.
Erstellen Sie einen Datenbanknutzer:

Hinweis: Nutzer, die auf diese Weise erstellt wurden, erhalten zusätzliche Datenbankrechte. Eine alternative Methode finden Sie unter Datenbanknutzerberechtigungen einschränken.
Console
1. Wechseln Sie auf der Instanzseite zum Tab Nutzer.
2. Klicken Sie auf Nutzerkonto hinzufügen.
3. Im Dialogfeld Authentifizierungstyp auswählen unter „Integrierte Authentifizierung“:
4. Geben Sie den Nutzernamen DATABASE_USERNAME ein.
5. Geben Sie das Passwort DATABASE_PASSWORD ein.
6. Klicken Sie auf Add.
gcloud
- Erstellen Sie den Nutzer in der kürzlich erstellten Instanz:
  gcloud sql users create DATABASE_USERNAME \ --instance INSTANCE_NAME \ --password DATABASE_PASSWORD
  Ersetzen Sie PASSWORD durch ein sicheres Passwort.

Dienstkonto erstellen

Für den Proxy ist ein Dienstkonto mit Bearbeitungsberechtigungen für Ihre Cloud SQL-Instanz erforderlich. Weitere Informationen zu Dienstkonten finden Sie in der Google Cloud Authentifizierungsübersicht.

Wenn Sie eine Verbindung über Compute Engine herstellen, müssen Sie darauf achten, dass für Ihre VM der richtige Wert für scope festgelegt ist, um eine Verbindung über die Cloud SQL Admin API herzustellen.

Konfigurieren Sie das Dienstkonto mit einem der folgenden Zugriffsbereiche:

https://www.googleapis.com/auth/sqlservice.admin
https://www.googleapis.com/auth/cloud-platform

Rufen Sie in der Google Cloud Console die Seite Dienstkonten auf.
Zur Seite „Dienstkonten“
Wählen Sie das Projekt aus, in dem sich die Cloud SQL-Instanz befindet.
Klicken Sie auf Dienstkonto erstellen.
Geben Sie im Feld Name des Dienstkontos einen Namen für das Dienstkonto ein.
Ändern Sie die Dienstkonto-ID in einen eindeutigen, leicht erkennbaren Wert und klicken Sie dann auf Erstellen und fortfahren.
Klicken Sie auf das Feld Rolle auswählen und wählen Sie eine der folgenden Rollen aus:
- Cloud SQL > Cloud SQL-Client
- Cloud SQL > Cloud SQL-Bearbeiter
- Cloud SQL > Cloud SQL-Administrator
Klicken Sie auf Fertig, um das Erstellen des Dienstkontos abzuschließen.
Klicken Sie auf das Aktionsmenü für das neue Dienstkonto und wählen Sie Schlüssel verwalten aus.
Klicken Sie auf das Drop-down-Menü Schlüssel hinzufügen und dann auf Neuen Schlüssel erstellen.
Prüfen Sie, ob der Schlüsseltyp JSON ist, und klicken Sie dann auf Erstellen.
Die Datei mit dem privaten Schlüssel wird auf Ihren Computer heruntergeladen. Sie können die Datei an einen anderen Speicherort verschieben. Bewahren Sie die Schlüsseldatei sicher auf.

Datenbankeinstellungen konfigurieren

Verwenden Sie die folgenden Befehle, um Umgebungsvariablen für den Datenbankzugriff festzulegen. Diese Umgebungsvariablen werden für lokale Tests verwendet.

Linux/macOS

export DATABASE_NAME=DATABASE_NAME
export DATABASE_USER=DATABASE_USERNAME
export DATABASE_PASSWORD=DATABASE_PASSWORD

Windows

set DATABASE_USER=DATABASE_USERNAME
set DATABASE_PASSWORD=DATABASE_PASSWORD

GKE-Konfiguration einrichten

Diese Anwendung wird in einer einzigen Kubernetes-Konfiguration namens polls dargestellt. Ersetzen Sie in polls.yaml den Platzhalter <your-project-id> durch IhreGoogle Cloud Projekt-ID (PROJECT_ID).

Führen Sie den folgenden Befehl aus und notieren Sie den Wert von connectionName:

gcloud sql instances describe INSTANCE_NAME --format "value(connectionName)"

Ersetzen Sie in der Datei polls.yaml die Variable <your-cloudsql-connection-string> durch den Wert connectionName.

App auf lokalem Computer ausführen

Nachdem die Sicherungsdienste konfiguriert wurden, können Sie die App jetzt auf Ihrem Computer ausführen. Diese Einrichtung ermöglicht die lokale Entwicklung, das Erstellen eines Superuser und das Anwenden von Datenbankmigrationen.

Starten Sie den Cloud SQL Auth-Proxy in einem separaten Terminal:
Linux/macOS
```
./cloud-sql-proxy PROJECT_ID:REGION:INSTANCE_NAME
```
Windows
```
cloud-sql-proxy.exe PROJECT_ID:REGION:INSTANCE_NAME
```
Dadurch wird eine Verbindung vom lokalen Computer zur Cloud SQL-Instanz hergestellt, sodass lokale Tests durchgeführt werden können. Brechen Sie die Ausführung des Cloud SQL Auth-Proxys nicht ab, solange Sie die Anwendung noch lokal testen. Wenn Sie diesen Prozess in einem separaten Terminal ausführen, können Sie weiter arbeiten, während dieser Prozess ausgeführt wird.
Legen Sie im ursprünglichen Terminal die Projekt-ID lokal fest:
Linux/macOS
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Windows
```
set GOOGLE_CLOUD_PROJECT=PROJECT_ID
```

Führen Sie die Django-Migrationen aus, um die Modelle und Assets einzurichten:

python manage.py makemigrations
python manage.py makemigrations polls
python manage.py migrate
python manage.py collectstatic

Starten Sie den Django-Webserver:
```
python manage.py runserver 8080
```
Rufen Sie in Ihrem Browser http://localhost:8080 auf.

Wenn Sie Cloud Shell verwenden, klicken Sie auf die Schaltfläche Webvorschau und wählen Sie Vorschau auf Port 8080 aus.

Auf der Seite wird der folgende Text angezeigt: "Hello, world. Sie befinden sich im Umfragenindex." Der auf Ihrem Computer ausgeführte Django-Webserver stellt die Beispiel-App-Seiten bereit.
Drücken Sie Ctrl/Cmd+C, um den lokalen Webserver zu beenden.

Admin-Konsole von Django verwenden

Um sich in der Admin-Konsole von Django anzumelden, müssen Sie einen Superuser erstellen. Da Sie eine lokal zugängliche Verbindung zur Datenbank haben, können Sie Verwaltungsbefehle ausführen:

Erstellen Sie einen Superuser: Sie werden aufgefordert, einen Nutzernamen, eine E-Mail-Adresse und ein Passwort einzugeben.
```
python manage.py createsuperuser
```
Starten Sie einen lokalen Webserver:
```
python manage.py runserver
```
Wechseln Sie in Ihrem Browser zu http://localhost:8000/admin.
Melden Sie sich mit dem Nutzernamen und dem Passwort an, die Sie beim Ausführen von createsuperuser verwendet haben.

Stellen Sie die Anwendung in GKE bereit:

Wenn die App in Google Cloudbereitgestellt wird, verwendet sie den Gunicorn-Server. Gunicorn stellt keine statischen Inhalte bereit, sodass die App zur Bereitstellung statischer Inhalte Google Cloud Storage verwendet.

Statische Ressourcen sammeln und hochladen

Erstellen Sie einen Cloud Storage-Bucket und machen Sie ihn öffentlich lesbar.

gcloud storage buckets create gs://PROJECT_ID_MEDIA_BUCKET
gcloud storage buckets add-iam-policy-binding gs://PROJECT_ID_MEDIA_BUCKET --member=allUsers role=roles/storage.legacyObjectReader

Sammeln Sie alle lokalen statischen Inhalte in einem Ordner:
```
python manage.py collectstatic
```

Laden Sie die statischen Inhalte zu Cloud Storage hoch:

gcloud storage rsync ./static gs://PROJECT_ID_MEDIA_BUCKET/static --recursive

Setzen Sie in mysite/settings.py den Wert von STATIC_URL auf die folgende URL und ersetzen Sie [YOUR_GCS_BUCKET] durch Ihren Bucket-Namen:
```
http://storage.googleapis.com/PROJECT_ID_MEDIA_BUCKET/static/
```

GKE einrichten

Zur Initialisierung von GKE rufen Sie die Seite Cluster auf.

Zur Cluster-Seite

Wenn Sie GKE zum ersten Mal in einem Projekt verwenden, müssen Sie warten, bis die Meldung "Kubernetes Engine wird vorbereitet. Dies kann einige Minuten dauern" nicht mehr angezeigt wird.
GKE-Cluster erstellen:
```
gcloud container clusters create polls \
  --scopes "https://www.googleapis.com/auth/userinfo.email","cloud-platform" \
  --num-nodes 4 --zone "us-central1-a"
```
Wenn eine Fehlermeldung wie Project is not fully initialized with the default service accounts angezeigt wird, müssen Sie möglicherweise Google Kubernetes Engine initialisieren.

GKE initialisieren

Wenn Sie eine Fehlermeldung erhalten haben, rufen Sie die Google Cloud Console auf, um GKE in Ihrem Projekt zu initialisieren.

ZUR CLUSTERSEITE

Warten Sie, bis die Meldung "Kubernetes Engine wird aktiviert. Dies kann einige Minuten dauern" erlischt.
Nachdem der Cluster erstellt wurde, verwenden Sie das kubectl-Befehlszeilentool, das in die gcloud CLI integriert ist, um mit dem GKE-Cluster zu interagieren. Da gcloud und kubectl separate Tools sind, muss kubectl für die Interaktion mit dem richtigen Cluster konfiguriert sein.
```
gcloud container clusters get-credentials polls --zone "us-central1-a"
```

Cloud SQL einrichten

Es sind mehrere Secrets erforderlich, damit die GKE-App eine Verbindung zu Ihrer Cloud SQL-Instanz herstellen kann. Ein Secret ist für den Zugriff auf Instanzebene (die Verbindung) erforderlich, die anderen beiden für den Datenbankzugriff. Weitere Informationen zu den beiden Ebenen der Zugriffskontrolle finden Sie unter Instanzzugriffskontrolle.
1. Geben Sie zum Erstellen des Secrets für den Zugriff auf Instanzebene den Speicherort (PATH_TO_CREDENTIAL_FILE) des JSON-Dienstkontoschlüssels an, den Sie beim Erstellen Ihres Dienstkontos heruntergeladen haben (siehe Dienstkonto erstellen):
```
kubectl create secret generic cloudsql-oauth-credentials \
  --from-file=credentials.json=PATH_TO_CREDENTIAL_FILE
```
2. Verwenden Sie zum Erstellen der Secrets für den Datenbankzugriff die SQL-Datenbank, den Nutzernamen und das Passwort, die Sie beim Erstellen von Backing Services definiert haben. Weitere Informationen finden Sie unter Cloud SQL for PostgreSQL-Instanz einrichten:
```
kubectl create secret generic cloudsql \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=DATABASE_USERNAME \
  --from-literal=password=DATABASE_PASSWORD
```
Rufen Sie das öffentliche Docker-Image für den Cloud SQL-Proxy ab.
```
docker pull b.gcr.io/cloudsql-docker/gce-proxy
```
Erstellen Sie ein Docker-Image und ersetzen Sie dabei <your-project-id> durch Ihre Projekt-ID.
```
docker build -t gcr.io/PROJECT_ID/polls .
```
Konfigurieren Sie Docker so, dass gcloud als Credential Helper verwendet wird. Dadurch können Sie das Image an Container Registry übertragen:
```
gcloud auth configure-docker
```
Übertragen Sie das Docker-Image per Push. Ersetzen Sie <your-project-id> durch Ihre Projekt-ID.
```
docker push gcr.io/PROJECT_ID/polls
```
Hinweis :Für diesen Befehl ist Schreibzugriff auf Cloud Storage erforderlich. Wenn Sie diese Anleitung für eine Compute Engine-Instanz ausführen, verfügen Sie möglicherweise nur über Lesezugriff auf Cloud Storage. Wenn Sie Schreibzugriff erhalten möchten, müssen Sie ein Dienstkonto erstellen. Anschließend können Sie sich auf Ihrer Instanz mit dem Dienstkonto authentifizieren.
Erstellen Sie die GKE-Ressource:
```
kubectl create -f polls.yaml
```
Hinweis: Wenn Sie andere Namen verwendet haben (außer cloudsql-oauth-credentials und cloudsql), als Sie die Secrets in den vorherigen Befehlen erstellt haben, müssen Sie die Datei polls.yaml für diese neuen Namen aktualisieren.

Anwendung in GKE bereitstellen

Nach der Erstellung der Ressourcen befinden sich im Cluster drei polls-Pods. Prüfen Sie den Status der Pods:

kubectl get pods

Warten Sie einige Minuten, bis sich der Status der Pods in Running befindet. Wenn die Pods nicht bereit sind oder neu gestartet werden, können Sie die Logs für einen bestimmten Pod abrufen, um das Problem zu ermitteln. [YOUR-POD-ID] ist Teil der Ausgabe, die vom vorherigen kubectl get pods - Befehl zurückgegeben wurde.

kubectl logs [YOUR_POD_ID]

Ausführung der App in Google Cloudansehen

Wenn die Pods einsatzbereit sind, können Sie die externe IP-Adresse des Load-Balancers abrufen:

kubectl get services polls

Notieren Sie sich die Adresse EXTERNAL-IP und rufen Sie in Ihrem Browser http://[EXTERNAL-IP] auf, um die Landingpage von Django-Abfragen aufzurufen und auf die Administratorkonsole zuzugreifen.

Den Code verstehen

Beispielanwendung

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.

Datenbankkonfiguration

settings.py enthält die Konfiguration für Ihre SQL-Datenbank:

DATABASES = {
    "default": {
        # If you are using Cloud SQL for MySQL rather than PostgreSQL, set
        # 'ENGINE': 'django.db.backends.mysql' instead of the following.
        "ENGINE": "django.db.backends.postgresql",
        "NAME": os.getenv("DATABASE_NAME"),
        "USER": os.getenv("DATABASE_USER"),
        "PASSWORD": os.getenv("DATABASE_PASSWORD"),
        "HOST": "127.0.0.1",
        "PORT": "5432",
    }
}

Konfigurationen für Kubernetes-Pods

Die Datei polls.yaml gibt zwei Kubernetes-Ressourcen an. Der erste ist der Dienst, der einen konsistenten Namen und eine interne IP-Adresse für die Django-Web-App definiert. Der zweite ist ein HTTP-Load-Balancer mit einer öffentlichen externen IP-Adresse.

# The polls service provides a load-balancing proxy over the polls app
# pods. By specifying the type as a 'LoadBalancer', Kubernetes Engine will
# create an external HTTP load balancer.
# For more information about Services see:
#   https://kubernetes.io/docs/concepts/services-networking/service/
# For more information about external HTTP load balancing see:
#   https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/
apiVersion: v1
kind: Service
metadata:
  name: polls
  labels:
    app: polls
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: polls

Der Dienst stellt einen Netzwerknamen und eine IP-Adresse bereit und GKE-Pods führen den Anwendungscode hinter dem Dienst aus. Die Datei polls.yaml gibt ein Deployment an, mit dem deklarative Updates für GKE-Pods zur Verfügung gestellt werden. Der Dienst leitet den Traffic zum Deployment um, indem er die Auswahl des Dienstes mit dem Label des Deployments abgleicht. In diesem Fall entspricht der Selektor polls dem Label polls.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: polls
  labels:
    app: polls
spec:
  replicas: 3
  selector:
    matchLabels:
      app: polls
  template:
    metadata:
      labels:
        app: polls
    spec:
      containers:
      - name: polls-app
        # Replace  with your project ID or use `make template`
        image: gcr.io/<your-project-id>/polls
        # This setting makes nodes pull the docker image every time before
        # starting the pod. This is useful when debugging, but should be turned
        # off in production.
        imagePullPolicy: Always
        env:
            - name: DATABASE_NAME
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: database
            - name: DATABASE_USER
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: username
            - name: DATABASE_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: password
        ports:
        - containerPort: 8080

      - image: gcr.io/cloudsql-docker/gce-proxy:1.16
        name: cloudsql-proxy
        command: ["/cloud_sql_proxy", "--dir=/cloudsql",
                  "-instances=<your-cloudsql-connection-string>=tcp:5432",
                  "-credential_file=/secrets/cloudsql/credentials.json"]
        volumeMounts:
          - name: cloudsql-oauth-credentials
            mountPath: /secrets/cloudsql
            readOnly: true
          - name: ssl-certs
            mountPath: /etc/ssl/certs
          - name: cloudsql
            mountPath: /cloudsql
      volumes:
        - name: cloudsql-oauth-credentials
          secret:
            secretName: cloudsql-oauth-credentials
        - name: ssl-certs
          hostPath:
            path: /etc/ssl/certs
        - name: cloudsql
          emptyDir: {}

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Projekt löschen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, zum Beispiel eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, anstatt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Wechseln Sie in der Google Cloud -Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Einzelne Ressourcen löschen

Wenn Sie das Projekt nicht löschen möchten, löschen Sie die einzelnen Ressourcen.

Löschen Sie den Google Kubernetes Engine-Cluster:
```
gcloud container clusters delete polls
```
Löschen Sie das Docker-Image, das Sie in Container Registry hochgeladen haben:
```
gcloud container images delete gcr.io/PROJECT_ID/polls
```

Löschen Sie die Cloud SQL-Instanz:

gcloud sql instances delete INSTANCE_NAME

Django in Google Kubernetes Engine ausführen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Ziele

Kosten

Hinweis

Umgebung vorbereiten

Beispielanwendung klonen

Linux/macOS

Windows

Python-Einrichtung bestätigen

Linux/macOS

Windows

Cloud SQL Auth-Proxy herunterladen, um von Ihrem lokalen Computer aus eine Verbindung zu Cloud SQL herzustellen

Linux 64-Bit

Linux 32-Bit

macOS 64-Bit

Mac M1

Windows 64-Bit

Windows 32-Bit

Docker-Image des Cloud SQL Auth-Proxys

Andere Betriebssysteme

Sicherungsdienste erstellen

Cloud SQL for PostgreSQL-Instanz einrichten

Console

gcloud

Console

gcloud

Console

gcloud

Dienstkonto erstellen

Datenbankeinstellungen konfigurieren

Linux/macOS

Windows

GKE-Konfiguration einrichten

App auf lokalem Computer ausführen

Linux/macOS

Windows

Linux/macOS

Windows

Admin-Konsole von Django verwenden

Stellen Sie die Anwendung in GKE bereit:

Statische Ressourcen sammeln und hochladen

GKE einrichten

GKE initialisieren

Cloud SQL einrichten

Anwendung in GKE bereitstellen

Ausführung der App in Google Cloudansehen

Den Code verstehen

Beispielanwendung

Datenbankkonfiguration

Konfigurationen für Kubernetes-Pods

Bereinigen

Projekt löschen

Einzelne Ressourcen löschen

Nächste Schritte

Django in Google Kubernetes Engine ausführen