Tutorial: Bereitstellen einer Django-App in AKS mit Azure Database for PostgreSQL – Flexible Server

GILT FÜR: Azure Database for PostgreSQL – Flexibler Server

In dieser Schnellstartanleitung wird eine Django-Anwendung in einem AKS-Cluster (Azure Kubernetes Service) mit Azure Database for PostgreSQL – Flexibler Server unter Verwendung der Azure CLI bereitgestellt.

AKS ist ein verwalteter Kubernetes-Dienst, mit dem Sie Cluster schnell bereitstellen und verwalten können. Azure Database for PostgreSQL – Flexible Server ist ein vollständig verwalteter Datenbankdienst, der eine differenziertere Steuerung und mehr Flexibilität in Bezug auf Verwaltungsfunktionen und Konfigurationseinstellungen für Datenbanken bietet.

Voraussetzungen

Sollten Sie über kein Azure-Abonnement verfügen, können Sie zunächst ein kostenloses Azure-Konto erstellen.

• Starten Sie Azure Cloud Shell in einem neuen Browserfenster. Sie können die Azure CLI auch auf Ihrem lokalen Computer installieren. Wenn Sie eine lokale Installation verwenden, melden Sie sich mit dem Befehl az login bei der Azure CLI an. Führen Sie die in Ihrem Terminal angezeigten Schritte aus, um den Authentifizierungsprozess abzuschließen.
• Führen Sie az version aus, um die installierte Version und die abhängigen Bibliotheken zu ermitteln. Führen Sie az upgrade aus, um das Upgrade auf die aktuelle Version durchzuführen. Für diesen Artikel ist die aktuelle Azure CLI-Version erforderlich. Bei Verwendung von Azure Cloud Shell ist die aktuelle Version bereits installiert.

Erstellen einer Ressourcengruppe

Eine Azure-Ressourcengruppe ist eine logische Gruppe, in der Azure-Ressourcen bereitgestellt und verwaltet werden. Erstellen Sie mit dem Befehl az-group-create am Speicherort eastus eine Ressourcengruppe namens django-project.

az group create --name django-project --location eastus

Die folgende Beispielausgabe zeigt, dass die Ressourcengruppe erfolgreich erstellt wurde:

{
  "id": "/subscriptions/<guid>/resourceGroups/django-project",
  "location": "eastus",
  "managedBy": null,
  
  "name": "django-project",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

Erstellen eines ACS-Clusters

Erstellen Sie mithilfe des Befehls az aks create einen AKS-Cluster. Im folgenden Beispiel wird ein Cluster mit dem Namen djangoappcluster mit einem Knoten erstellt. Dieser Schritt dauert einige Minuten.

az aks create --resource-group django-project --name djangoappcluster --node-count 1 --generate-ssh-keys

Nach wenigen Minuten ist die Ausführung des Befehls abgeschlossen, und es werden Informationen zum Cluster im JSON-Format zurückgegeben.

Herstellen einer Verbindung mit dem Cluster

Verwenden Sie zum Verwalten eines Kubernetes-Clusters den Kubernetes-Befehlszeilenclient kubectl. Bei Verwendung von Azure Cloud Shell ist kubectl bereits installiert.

Mit dem Befehl az aks get-credentials können Sie kubectl für die Verbindungsherstellung mit Ihrem Kubernetes-Cluster konfigurieren. Mit diesem Befehl werden die Anmeldeinformationen heruntergeladen, und die Kubernetes-Befehlszeilenschnittstelle wird für deren Verwendung konfiguriert.

az aks get-credentials --resource-group django-project --name djangoappcluster

Überprüfen Sie die Verbindung mit Ihrem Cluster mithilfe des Befehls kubectl get, um eine Liste der Clusterknoten zurückzugeben.

kubectl get nodes

Die folgende Beispielausgabe zeigt den in den vorherigen Schritten erstellten Knoten. Vergewissern Sie sich, dass der Knoten den Status Bereit hat:

NAME                       STATUS   ROLES   AGE     VERSION
aks-nodepool1-31718369-0   Ready    agent   6m44s   v1.12.8

Erstellen einer Instanz von Azure Database for PostgreSQL – Flexibler Server

Erstellen Sie mithilfe des Befehls az postgreSQL flexible-server create eine Instanz von Azure Database for PostgreSQL – Flexible Server. Mit dem folgenden Befehl wird ein Server mit Dienststandards und -werten aus dem lokalen Kontext Ihrer Azure CLI erstellt:

az postgres flexible-server create --public-access all

Der erstellte Server weist die folgenden Attribute auf:

• Bei der erstmaligen Bereitstellung des Servers wird eine neue leere Datenbank (postgres) erstellt. In dieser Schnellstartanleitung wird diese Datenbank verwendet.
• Er besitzt automatisch generierte Werte für Servername, Administratorbenutzername, Administratorkennwort und Ressourcengruppenname (sofern nicht bereits im lokalen Kontext angegeben) und befindet sich am gleichen Standort wie die Ressourcengruppe.
• Mithilfe des public-access-Arguments können Sie einen Server mit öffentlichem Zugriff auf einen beliebigen Client mit richtigem Benutzernamen und Kennwort erstellen.
• Da in dem Befehl der lokale Kontext verwendet wird, wird der Server in der Ressourcengruppe django-project und in der Region eastus erstellt.

Erstellen Ihres Django-Docker-Images

Erstellen Sie eine neue Django-Anwendung, oder verwenden Sie Ihr vorhandenes Django-Projekt. Stellen Sie sicher, dass sich der Code in dieser Ordnerstruktur befindet.

└───my-djangoapp
    └───views.py
    └───models.py
    └───forms.py
    ├───templates
          . . . . . . .
    ├───static
         . . . . . . .
└───my-django-project
    └───settings.py
    └───urls.py
    └───wsgi.py
        . . . . . . .
    └─── Dockerfile
    └─── requirements.txt
    └─── manage.py

Aktualisieren Sie ALLOWED_HOSTS in settings.py, um sicherzustellen, dass die Django-Anwendung die externe IP-Adresse verwendet, die der Kubernetes-App zugewiesen wird.

ALLOWED_HOSTS = ['*']

Aktualisieren Sie in der Datei settings.py den Abschnitt DATABASES={ }. Der folgende Codeausschnitt liest Datenbankhost, Benutzername und Kennwort aus der Kubernetes-Manifestdatei.

DATABASES={
   'default':{
      'ENGINE':'django.db.backends.postgresql_psycopg2',
      'NAME':os.getenv('DATABASE_NAME'),
      'USER':os.getenv('DATABASE_USER'),
      'PASSWORD':os.getenv('DATABASE_PASSWORD'),
      'HOST':os.getenv('DATABASE_HOST'),
      'PORT':'5432',
      'OPTIONS': {'sslmode': 'require'}
   }
}

Generieren der Datei „requirements.txt“

Erstellen Sie die Datei requirements.txt, um die Abhängigkeiten für die Django-Anwendung aufzulisten. Im Anschluss ist ein Beispiel für eine Datei vom Typ requirements.txt angegeben. Sie können pip freeze > requirements.txt verwenden, um die Datei „requirements.txt“ für Ihre vorhandene Anwendung zu generieren.

Django==2.2.17
postgres==3.0.0
psycopg2-binary==2.8.6
psycopg2-pool==1.1
pytz==2020.4

Erstellen eines Dockerfile

Erstellen Sie eine neue Datei namens Dockerfile, und kopieren Sie den folgenden Codeausschnitt. Mit diesem Dockerfile wird Python 3.8 eingerichtet. Außerdem werden alle Anforderungen installiert, die in der Datei „requirements.txt“ aufgeführt sind.

# Use the official Python image from the Docker Hub

FROM python:3.8.2

# Make a new directory to put our code in.

RUN mkdir /code

# Change the working directory.

WORKDIR /code

# Copy to code folder

COPY . /code/

# Install the requirements.

RUN pip install -r requirements.txt

# Run the application:

CMD python manage.py runserver 0.0.0.0:8000

Erstellen Ihres Images

Stellen Sie in einem Terminal mithilfe des Befehls cd sicher, dass Sie sich im Verzeichnis my-django-app befinden. Führen Sie den folgenden Befehl aus, um Ihr Bulletin Board-Image zu erstellen:

docker build --tag myblog:latest .

Stellen Sie Ihr Image in Docker Hub oder in Azure Container Registry bereit.

az aks update --name djangoappcluster --resource-group django-project --attach-acr <your-acr-name>

Erstellen einer Kubernetes-Manifestdatei

Eine Kubernetes-Manifestdatei definiert einen gewünschten Zustand (Desired State) für den Cluster – also beispielsweise, welche Containerimages ausgeführt werden sollen. Erstellen Sie eine Manifestdatei namens djangoapp.yaml, und fügen Sie die folgende YAML-Definition ein.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: django-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: django-app
  template:
    metadata:
      labels:
        app: django-app
    spec:
      containers:
      - name: django-app
        image: [DOCKER-HUB-USER-OR-ACR-ACCOUNT]/[YOUR-IMAGE-NAME]:[TAG]
        ports:
        - containerPort: 8000
        env:
        - name: DATABASE_HOST
          value: "SERVERNAME.postgres.database.azure.com"
        - name: DATABASE_USER
          value: "YOUR-DATABASE-USERNAME"
        - name: DATABASE_PASSWORD
          value: "YOUR-DATABASE-PASSWORD"
        - name: DATABASE_NAME
          value: "postgres"
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                  - key: "app"
                    operator: In
                    values:
                    - django-app
              topologyKey: "kubernetes.io/hostname"
---
apiVersion: v1
kind: Service
metadata:
  name: python-svc
spec:
  type: LoadBalancer
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8000
  selector:
    app: django-app

Bereitstellen von Django in einem AKS-Cluster

Stellen Sie die Anwendung über den Befehl kubectl apply bereit, und geben Sie den Namen Ihres YAML-Manifests an:

kubectl apply -f djangoapp.yaml

In der folgenden Beispielausgabe sind die erfolgreich erstellten Bereitstellungen und Dienste aufgeführt:

deployment "django-app" created
service "python-svc" created

Bei der Bereitstellung einer django-app können Sie Einzelheiten der Bereitstellung beschreiben, z. B. die Images, die für die App verwendet werden sollen, die Anzahl der Pods und die Pod-Konfiguration. Es wird ein python-svc-Dienst erstellt, um die Anwendung über eine externe IP-Adresse verfügbar zu machen.

Testen der Anwendung

Wenn die Anwendung ausgeführt wird, macht ein Kubernetes-Dienst das Anwendungs-Front-End im Internet verfügbar. Dieser Vorgang kann einige Minuten dauern.

Verwenden Sie zum Überwachen des Fortschritts den Befehl kubectl get service mit dem Argument --watch.

kubectl get service python-svc --watch

Zu Beginn wird die externe IP-Adresse (EXTERNAL-IP) für den Dienst django-app mit dem Status ausstehend angezeigt.

NAME               TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
django-app   LoadBalancer   10.0.37.27   <pending>     80:30572/TCP   6s

Sobald die externe IP-Adresse (EXTERNAL-IP) von pending (ausstehend) in eine tatsächliche öffentliche IP-Adresse geändert wurde, verwenden Sie CTRL-C, um die kubectl-Überwachung zu beenden. Die folgende Beispielausgabe zeigt eine gültige öffentliche IP-Adresse, die dem Dienst zugewiesen ist:

django-app  LoadBalancer   10.0.37.27   52.179.23.131   80:30572/TCP   2m

Öffnen Sie die externe IP-Adresse Ihres Diensts (http://<service-external-ip-address>) in einem Webbrowser, um die Django-Anwendung anzuzeigen.

Ausführen von Datenbankmigrationen

Für jede Django-Anwendung müssen Sie eine Datenbankmigration ausführen oder statische Dateien sammeln. Diese Django-Shellbefehle können Sie mit $ kubectl exec <pod-name> -- [COMMAND] ausführen. Vor dem Ausführen des Befehls müssen Sie mithilfe von kubectl get pods den Pod-Namen ermitteln.

$ kubectl get pods

Eine Ausgabe wie die folgende sollte angezeigt werden:

NAME                             READY   STATUS          RESTARTS   AGE
django-app-5d9cd6cd8-l6x4b     1/1     Running              0       2m

Nachdem Sie den Pod-Name gefunden haben, können Sie mit dem Befehl $ kubectl exec <pod-name> -- [COMMAND] Django-Datenbankmigrationen ausführen. Hinweis: /code/ ist das Arbeitsverzeichnis für das Projekt, das im o. g. Dockerfile definiert ist.

$ kubectl exec django-app-5d9cd6cd8-l6x4b -- python /code/manage.py migrate

Die Ausgabe würde wie folgt aussehen:

Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  . . . . . . 

Wenn Probleme auftreten, führen Sie kubectl logs <pod-name> aus, um festzustellen, welche Ausnahme von der Anwendung ausgelöst wird. Wird die Anwendung erfolgreich ausgeführt, wird bei Ausführung von kubectl logs eine Ausgabe wie die folgende angezeigt:

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).

You have 17 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.
December 08, 2020 - 23:24:14
Django version 2.2.17, using settings 'django_postgres_app.settings'
Starting development server at http://0.0.0.0:8000/
Quit the server with CONTROL-C.

Bereinigen der Ressourcen

Zum Vermeiden von Azure-Gebühren sollten Sie nicht benötigte Ressourcen bereinigen. Wenn der Cluster nicht mehr benötigt wird, entfernen Sie mit dem Befehl az group delete die Ressourcengruppe, den Containerdienst und alle zugehörigen Ressourcen.

az group delete --name django-project --yes --no-wait

Nächste Schritte

• Informieren Sie sich, wie Sie auf das Kubernetes-Webdashboard für Ihren AKS-Cluster zugreifen.
• Erfahren Sie, wie Sie Continuous Deployment aktivieren.
• Machen Sie sich mit der Vorgehensweise zum Skalieren Ihres Clusters vertraut.
• Informieren Sie sich über die Verwaltung Ihrer Instanz von Azure Database for PostgreSQL – Flexible Server
• Informieren Sie sich über das Konfigurieren von Serverparametern für Ihren Datenbankserver.