Web Development

Deployment von Django-Apps in Kubernetes

Als Open-Source-Plattform für die Orchestrierung von Containern, welche das Deployment, die Skalierung und die Lastverteilung automatisiert, bietet Kubernetes eine unvergleichliche Ausfallsicherheit sowie Flexibilität in Bezug auf die Verwaltung Ihrer Django-Anwendungen.

Ganz gleich, ob Sie ein kleines Projekt launchen oder eine komplexe Anwendung verwalten möchten: Kubernetes stellt Ihnen eine robuste Umgebung zur Verfügung, um Ihre Django-App zu optimieren. Gleichzeitig wird sichergestellt, dass sie den Anforderungen der modernen Webentwicklung gerecht wird.

Durch die Automatisierung des Deployments, der Skalierung und des Betriebs von containerisierten Anwendungen bietet Kubernetes (oder K8s) zahlreiche Vorteile für Organisationen in der schnelllebigen Technologiebranche.

Unabhängig davon, ob Sie Django-Entwickler*in sind und Ihre Deployment-Fähigkeiten verbessern möchten, oder Kubernetes-Fan mit Interesse an der Django-Integration, hat dieser Leitfaden für jeden etwas zu bieten.

In der Einführung zu diesem Tutorial wird die symbiotische Beziehung zwischen Django und Kubernetes untersucht, die es Ihnen ermöglicht, Ihre Webanwendung nahtlos zu containerisieren, Workloads über Cluster zu verteilen und hohe Verfügbarkeit zu gewährleisten.

Das Django-Framework – ein leistungsstarkes Python-Web-Framework – steht für Effizienz und Einfachheit in der Welt der Webentwicklung. Django wurde aus dem Bedürfnis heraus geboren, schnelle, robuste und leicht zu wartende Webanwendungen zu erstellen, und hat sich mittlerweile als bevorzugte Wahl für Entwickler*innen und Organisationen etabliert.

Django steht für die Philosophie „Alles inklusive“. Es bietet eine umfangreiche Auswahl an integrierten Tools, Bibliotheken und Konventionen, die den Entwicklungsprozess erheblich vereinfachen. Django vereinfacht komplexe Aufgaben wie URL-Routing, Datenbankintegration und Benutzerauthentifizierung, sodass sich Entwickler*innen ganz auf ihre Anwendungen konzentrieren können.

Einer der wichtigsten Vorteile von Django ist die Einhaltung des Prinzips „Don’t repeat yourself“ (DRY), wodurch Redundanzen reduziert und die Wartbarkeit des Codes verbessert werden. Außerdem folgt es dem Architekturmuster Model-View-Controller (MVC), wodurch Apps strukturiert werden und einfach zu verwalten sind.

Django legt außerdem großen Wert auf Sicherheit und ist daher weniger anfällig für gängige Web-Schwachstellen. Es bietet von Grund auf integrierte Funktionen, die einen effektiven Schutz gegen Cross-Site-Scripting (XSS) und Cross-Site-Request-Forgery (CSRF) gewährleisten. Django wartet mit einer starken Kombination aus Geschwindigkeit, Einfachheit sowie Sicherheit auf und ist die ideale Wahl für Entwickler*innen, die mit minimalem Aufwand robuste, funktionsreiche Webanwendungen erstellen möchten.

Container-Orchestratoren sind unverzichtbare Tools für die Verwaltung und Automatisierung der Bereitstellung, der Skalierung und des Betriebs von containerisierten Anwendungen. Auf dem Markt gibt es mehrere Container-Orchestratoren. Die beliebtesten sind folgende:

1. Kubernetes, die führende Open-Source-Plattform für Container-Orchestrierung, bietet eine robuste und anpassungsfähige Umgebung für den Umgang mit containerisierten Anwendungen. Kubernetes automatisiert Aufgaben wie Skalierung, Lastverteilung sowie Container-Zustandsprüfungen und hat ein umfassendes Ökosystem von Erweiterungen vorzuweisen.

2. Docker Swarm ist eine Lösung für die Container-Orchestrierung, welche von Docker bereitgestellt wird. Docker Swarm wurde mit dem Ziel entwickelt, unkompliziert eingerichtet und mühelos genutzt werden zu können. Es bietet sich besonders für kleinere Anwendungen oder Organisationen an, die bereits mit Docker vertraut sind, da es die gleiche Befehlszeilenschnittstelle und API nutzt wie Docker selbst.

3. OpenShift ist eine von Red Hat entwickelte Kubernetes-Plattform für Unternehmen. OpenShift fügt Entwicklungs- sowie Betriebstools zu Kubernetes hinzu und vereinfacht das Deployment und die Verwaltung von containerisierten Anwendungen.

4. Nomad, entwickelt von HashiCorp, ist ein schlanker und benutzerfreundlicher Orchestrator, der Container und nicht containerisierte Anwendungen verwalten kann.

5. Apache Mesos ist ein Open-Source-Kernel für verteilte Systeme. DC/OS (Betriebssystem für Rechenzentren) ist eine auf Mesos aufbauende Plattform für Unternehmen. DC/OS erweitert Mesos um zusätzliche Funktionen für die Verwaltung und Skalierung von containerisierten Anwendungen.

Software-Teams arbeiten hauptsächlich mit verwalteten Plattformen, die von bekannten Cloud-Anbietern wie AWS, Google Cloud Platform und Azure bereitgestellt werden. Diese Cloud-Anbieter stellen Dienste wie Amazon EKS, Google GKE und Azure AKS zur Verfügung, die allesamt verwaltete Kubernetes-Lösungen sind. Diese Dienste optimieren die Einrichtung, Erweiterung sowie Verwaltung von Kubernetes-Clustern und lassen sich nahtlos in die jeweiligen Cloud-Umgebungen integrieren, um eine effiziente Container-Orchestrierung und Anwendungsbereitstellung zu gewährleisten.

In diesem Tutorial beginnen wir mit der Erstellung einer minimalen Django-Anwendung. Anschließend werden wir die Anwendung containerisieren und sie im letzten Schritt mit Docker Desktop in einem lokalen Kubernetes-Cluster bereitstellen.

Falls Sie noch wenig Erfahrung im Umgang mit dem Django-Framework haben und gerne eine Django-Anwendung von Grund auf entwickeln möchten, dann ist dieser Blogbeitrag genau das Richtige für Sie.

Sie können den in diesem Tutorial verwendeten Quellcode hier aufrufen.

Beginnen wir mit der Erstellung einer neuen Django-Anwendung in PyCharm.

Um Ihr Projekt zu erstellen, starten Sie PyCharm und klicken Sie auf New Project. Falls PyCharm bereits läuft, wählen Sie File | New Project im Hauptmenü aus.

Geben Sie wichtige Details wie den Projektnamen, den Ort und den Interpretertyp an, indem Sie entweder venv oder eine benutzerdefinierte Umgebung verwenden.

Klicken Sie dann auf Create.

PyCharm nimmt Ihnen Arbeit ab, indem es Ihr Projekt einrichtet und die virtuelle Umgebung erstellt.

Sobald das Projekt erstellt wurde, installieren Sie Gunicorn – dabei handelt es sich um einen beliebten, in Python geschriebenen HTTP-Server, der eine „Web Server Gateway Interface“ (WSGI) nutzt. Gunicorn ist ein Webserver mit Prefork-Worker-Modell für Python-Webanwendungen. Das Tool wird häufig in Kombination mit Web-Frameworks wie Django, Flask sowie anderen verwendet, um Webanwendungen bereitzustellen und über das Internet zugänglich zu machen.

Das Toolfenster Python Packages bietet die schnellste und einfachste Möglichkeit, Pakete für den aktuell ausgewählten Python-Interpreter in der Vorschau anzuzeigen und zu installieren.

Sie können das Toolfenster über View | Tool Windows | Python Packages öffnen.

Psycopg 2 ist eine Python-Bibliothek, die für die Verbindung zu und die Interaktion mit PostgreSQL-Datenbanken verwendet wird. Psycopg 2 bietet eine Python-Schnittstelle für die Arbeit mit PostgreSQL, einem der beliebtesten Open-Source-Managementsysteme für relationalen Datenbanken. Psycopg 2 ermöglicht es Python-Entwickler*innen, verschiedene Datenbankoperationen wie das Einfügen, Aktualisieren und Abrufen von Daten sowie die Ausführung von SQL-Abfragen und die Verwaltung von Datenbankverbindungen aus Python-Programmen heraus durchzuführen.

Bevor Sie psycopg2 installieren, müssen Sie die Abhängigkeiten auf Systemebene einspielen: brew install libpq für macOS und apt-get install libpq-dev für Linux.

Referenz: postgresql.org/docs/16/libpq.html

libpq ist die Client-Bibliothek für PostgreSQL. Es handelt sich um eine C-Bibliothek, welche die notwendigen Funktionen für Client-Anwendungen bereitstellt, um sich mit PostgreSQL-Datenbankservern zu verbinden, mit ihnen zu interagieren und sie zu verwalten.

Nachdem Sie die entsprechenden Änderungen vorgenommen haben, aktualisieren Sie den Abschnitt in settings.py in Bezug auf DATABASES.

Achten Sie stets darauf, dass Sie Ihre geheimen Anmeldedaten über Umgebungsvariablen übermitteln.

In Django ist STATIC_ROOT eine Konfigurationseinstellung, die verwendet wird, um den absoluten Dateisystempfad anzugeben, in dem gesammelte statische Dateien gespeichert werden, wenn Sie den Verwaltungsbefehl collectstatic ausführen. Zu den statischen Dateien gehören in der Regel CSS, JavaScript, Bilder und andere Assets, die von Ihrer Webanwendung verwendet werden. Die Einstellung STATIC_ROOT ist ein wesentlicher Bestandteil der Bereitstellung statischer Dateien in einer Produktionsumgebung.

Setzen Sie eine Umgebungsvariable für STATIC_ROOT in Zeile 127 ein. Diese Variable verweist auf einen Dateipfad, der zu einem persistenten Kubernetes-Volume führt. Die Konfiguration dieses Set-ups wird später genauer erläutert.

Um statische Dateien zu sammeln, führen Sie den folgenden Befehl aus:

python manage.py collectstatic

Dieser Befehl sammelt die statischen Dateien und legt sie im Verzeichnis STATIC_ROOT ab. Sie können diese Assets dann direkt über einen NGINX- oder Apache-Webserver bereitstellen – ein effizienterer Ansatz für Produktionsumgebungen.

Ein Dockerfile ist ein einfaches Textdokument, das Direktiven für die Erstellung von Docker-Images enthält.

1. FROM python:3.11: Diese Zeile gibt das Basis-Image für das Docker-Image an, wobei das offizielle Python-3.11-Image von Docker Hub verwendet wird. Die Anwendung wird auf Grundlage dieses Basis-Image erstellt und ausgeführt. Python ist bereits vorinstalliert.

2. ENV PYTHONUNBUFFERED 1: Diese Zeile setzt die Umgebungsvariable PYTHONUNBUFFERED auf 1. Häufig wird empfohlen, diese Umgebungsvariable zu setzen, wenn Sie Python in Docker-Containern ausführen, um sicherzustellen, dass Python die Ausgabe nicht buffert. Dies ermöglicht es, Protokolle und Debugging-Informationen für die Anwendung in Echtzeit zu erhalten.

3. WORKDIR /app: Diese Zeile setzt das Arbeitsverzeichnis innerhalb des Docker-Containers auf /app. Alle nachfolgenden Befehle werden in diesem Verzeichnis ausgeführt.

4. COPY . /app: Diese Zeile kopiert den Inhalt des aktuellen Verzeichnisses (das Verzeichnis, in dem sich die Dockerdatei befindet) in das Verzeichnis /app innerhalb des Containers. Dazu gehören Ihr Anwendungscode und sämtliche Dateien, die für das Docker-Image benötigt werden.

5. RUN pip install -r requirements.txt: Diese Zeile führt den Befehl pip install aus, um die Python-Abhängigkeiten zu installieren, die in der Datei requirements.txt aufgeführt sind, welche sich im Verzeichnis /app befindet. Dies ist eine gängige Praxis für Python-Anwendungen, da Sie auf diese Weise die Abhängigkeiten der Anwendung verwalten können.

6. EXPOSE 8000: Diese Zeile teilt Docker mit, dass der Container auf Port 8000 lauscht. Der Port wird nicht wirklich öffentlich gemacht. Es handelt sich um eine Metadaten-Deklaration, die angibt, welche Ports der Container verwenden darf.

7. CMD ["gunicorn", "django_kubernetes_tutorial.wsgi:application", "--bind", "0.0.0.0:8000"]: Diese Zeile gibt den Standardbefehl an, der beim Starten des Containers ausgeführt wird. Gunicorn wird verwendet, um die Django-Anwendung bereitzustellen. Das Binding von Gunicorn erfolgt so, dass es auf allen Netzwerkschnittstellen (0.0.0.0) auf Port 8000 mit der WSGI-Anwendung lauscht, die unter django_kubernetes_tutorial.wsgi:application definiert ist.

Besuchen Sie hub.docker.com und melden Sie sich entweder an oder registrieren Sie sich auf der Plattform.

Klicken Sie auf Create repository.

Als Nächstes geben Sie den Namen des Repositorys an und stellen die Sichtbarkeit auf „Public“. Falls Sie mit sensiblen oder vertraulichen Informationen arbeiten, stellen Sie die Sichtbarkeit auf Private.

Nachdem das Repository erstellt wurde, müssen Sie das Docker-Image generieren und es dann in die Registry pushen.

Bevor Sie den Befehl ausführen, vergewissern Sie sich, dass die Datei requirements.txt aktuell ist, indem Sie Folgendes ausführen:

pip freeze > requirements.txt

Um ein Image zu erstellen, führen Sie den folgenden Befehl aus:

docker build -t mukulmantosh/django-kubernetes:1.0 .

docker build -t /django-kubernetes:1.0 .

Dieser Befehl hängt von Ihren spezifischen Umständen ab und Sie müssen Ihren persönlichen Benutzernamen verwenden.

Anschließend müssen Sie sich bei Docker Hub authentifizieren, um das Image in die Registry zu pushen.

Geben Sie den folgenden Befehl in das Terminal ein:

docker login

Geben Sie Ihren Benutzernamen und Ihr Passwort ein. Sobald die Daten erfolgreich authentifiziert wurden, können Sie das Image pushen, indem Sie Folgendes ausführen:

docker push mukulmantosh/django-kubernetes:1.0 

docker push /django-kubernetes:1.0 

Sobald das Image erfolgreich gepusht wurde, können Sie die Änderungen in Docker Hub einsehen.

Falls Sie nicht vorhaben, weitere Images in die Registry zu pushen, können Sie sich abmelden, indem Sie den folgenden Befehl ausführen:

docker logout

Falls Sie dieses Image lokal pullen möchten, besuchen Sie hub.docker.com/r/mukulmantosh/django-kubernetes.

Dieser Abschnitt des Tutorials beschreibt das Deployment von Anwendungen in lokalen Kubernetes-Clustern.

Für dieses Tutorial werden wir Docker Desktop verwenden, aber Sie können auch minikube oder kind nutzen.

In Kubernetes sind Namespaces virtuelle Partitionen innerhalb eines Clusters, die zur Gruppierung und Isolierung von Ressourcen sowie Objekten verwendet werden. Auf diese Weise können Sie mehrere virtuelle Cluster innerhalb eines einzigen physischen Clusters erstellen.

Sie können Namespaces mit kubectl, dem Kubernetes-Befehlszeilen-Tool, oder durch Definition in YAML-Manifesten beim Deployment von Ressourcen erstellen und verwalten.

• Wenn Sie Docker Desktop als bevorzugte Plattform für die Ausführung von Kubernetes gewählt haben, müssen Sie Kubernetes in den Einstellungen aktivieren, indem Sie auf das Kontrollkästchen Enable Kubernetes klicken.

Führen Sie den folgenden Befehl im Terminal aus, um einen Namespace zu erstellen:

kubectl create ns django-app

Lassen Sie uns zunächst eine PostgreSQL-Instanz in unserem Kubernetes-Cluster in der lokalen Umgebung einrichten.

In Kubernetes bezeichnet ein persistentes Volumen (PV) einen Teil des Speichers im Cluster, den ein Administrator bereitgestellt hat. Durch die Speicherung von Daten auf eine Art und Weise, die unabhängig vom Lebenszyklus eines Pods ist, ermöglichen PV eine entkoppelte und flexiblere Verwaltung sowie Abstraktion von Speicherressourcen. Das bedeutet, dass die Daten auch dann erhalten bleiben, wenn der Pod, der sie verwendet, gelöscht oder auf einen anderen Knoten im Cluster verschoben wird.

Erstellen wir nun ein persistentes Volumen und nennen wir es pv.yml.

Diese YAML-Konfiguration definiert eine PersistentVolume-Ressource mit dem Namen postgres-pv mit einer Kapazität von einem Gigabyte. Die Ressource wird mit dem Zugriffsmodus ReadWriteOnce gemountet und über einen lokalen Pfad im Dateisystem des Knotens unter /data/db bereitgestellt. Dieses PV kann verwendet werden, um persistenten Speicher für Pods bereitzustellen, die Zugriff auf ein Verzeichnis im Dateisystem des Knotens benötigen. Es eignet sich für Anwendungen wie PostgreSQL oder andere zustandsbehaftete Dienste, die persistenten Speicher erfordern.

Für die Produktion empfehlen wir entweder die Verwendung von Cloud-Lösungen wie AWS RDS oder Google CloudSQL oder die Verwendung von Kubernetes StatefulSets.

In Kubernetes bezeichnet PersistentVolumeClaim (PVC) ein Ressourcenobjekt, das von einem Pod verwendet wird, um eine bestimmte Menge an Speicher mit bestimmten Eigenschaften von einem PV anzufordern. PVCs bieten Anwendungen die Möglichkeit, Speicherressourcen zu beanspruchen, ohne die Details der zugrunde liegenden Speicherinfrastruktur kennen zu müssen.

Durch die Erstellung und Verwendung von PVCs bietet Kubernetes eine Möglichkeit, Speicherressourcen für Anwendungen dynamisch zuzuweisen sowie zu verwalten und gleichzeitig die zugrunde liegende Speicherinfrastruktur zu abstrahieren, was die Arbeit mit und die Verwaltung von zustandsbehafteten Anwendungen in containerisierten Umgebungen erleichtert.

Lassen Sie uns einen PVC erstellen – nennen wir ihn pvc.yml.

Ein PVC fordert Speicherressourcen an und ist an ein PV gebunden, das den eigentlichen Speicher bereitstellt.

Diese YAML-Konfiguration definiert einen PersistentVolumeClaim mit dem Namen postgres-pvc innerhalb des Namespace django-app. Der PVC fordert einen Gigabyte Speicherplatz mit dem Zugriffsmodus ReadWriteOnce an und gibt explizit die StorageClass manual an. Dieser PVC soll an ein bestehendes PV mit dem Namen postgres-pv gebunden werden. Damit wird dieses Volume für die Verwendung durch Pods innerhalb des Namespace django-app reserviert, die auf diesen PVC verweisen.

In Kubernetes bezeichnet eine ConfigMap ein API-Objekt, das zum Speichern von Konfigurationsdaten in Schlüssel-Wert-Paaren verwendet wird. ConfigMaps bieten eine Möglichkeit, die Konfigurationsdaten vom Anwendungscode zu entkoppeln. So lassen sich Konfigurationen leichter verwalten und aktualisieren, ohne dass Container verändert und neu bereitgestellt werden müssen. Sie sind besonders nützlich für die Konfiguration von Anwendungen, Microservices und anderen Komponenten innerhalb eines Kubernetes-Clusters.

Lassen Sie uns eine ConfigMap erstellen – nennen wir sie cm.yml.

Obwohl in diesem Tutorial ConfigMaps verwendet werden, wird aus Sicherheitsgründen empfohlen, sensible Anmeldedaten in Kubernetes Secrets zu speichern oder Alternativen wie Bitnami Sealed Secrets, AWS Parameter Store oder HashiCorp Vault in Erwägung zu ziehen.

In Kubernetes bezeichnet ein Deployment ein Ressourcenobjekt, das zur Verwaltung der Bereitstellung und Skalierung von Anwendungen verwendet wird. Ein Deployment ist Teil der Kubernetes-API-Gruppe und bietet eine deklarative Möglichkeit, den gewünschten Zustand Ihrer Anwendung zu definieren und zu verwalten.

Ein Deployment ist eine Kubernetes-Ressource auf höherer Ebene, die für die Verwaltung und Skalierung von Anwendungs-Pods verwendet wird.

Diese YAML-Konfiguration definiert ein Deployment namens postgres im Namespace django-app. Die Konfiguration stellt eine einzelne Replik einer PostgreSQL-Datenbank (Version 16.0) mit persistentem Speicher bereit. Der Datenbank-Pod trägt die Bezeichnung app: postgresdb und der Speicher wird von einem PVC namens postgres-pvc bereitgestellt. Die Konfiguration und die Anmeldedaten für den PostgreSQL-Container werden über eine ConfigMap namens db-secret-credentials übermittelt.

In Kubernetes bezeichnet ein Service ein Ressourcenobjekt, das verwendet wird, um eine Gruppe von Pods als Netzwerkdienst bereitzustellen. Services ermöglichen die Netzwerkkommunikation zwischen verschiedenen Teilen Ihrer Anwendung, die in einem Kubernetes-Cluster laufen, und bieten einen stabilen Endpunkt für den Zugriff von Clients auf diese Teile. Services abstrahieren die zugrunde liegende Netzwerkinfrastruktur und erleichtern so die Verbindung und Auffindung der Komponenten Ihrer Anwendung.

Diese YAML-Konfiguration definiert einen NodePort-Service mit dem Namen postgres-service innerhalb des Namespace django-app. Die Konfiguration stellt den PostgreSQL-Service, der in Pods mit der Bezeichnung „app: postgresdb“ läuft, auf Port 5432 innerhalb des Clusters zur Verfügung. Externe Clients können über Port 30004 von jeder IP-Adresse eines Node aus auf den Service zugreifen. Dieser Service bietet eine Möglichkeit, die PostgreSQL-Datenbank von außerhalb des Kubernetes-Clusters zugänglich zu machen.

Diese YAML-Datei definiert ein PersistentVolume mit dem Namen staticfiles-pv mit einer Speicherkapazität von einem Gigabyte, auf dem mehrere Pods gleichzeitig lesen und schreiben können. Der Speicher wird von einem lokalen Hostpfad bereitgestellt, der sich in /data/static befindet. Die statischen Django-Dateien werden an diesem Ort gespeichert.

Diese YAML-Datei definiert einen PVC namens staticfiles-pvc im Namespace django-app. Es wird Speicherplatz mit einer Kapazität von mindestens einem Gigabyte von einem PV mit der StorageClass „manual“ angefordert und es wird angegeben, dass ReadWriteMany-Zugriff benötigt wird. Der Claim bindet sich ausdrücklich an ein bestehendes PV mit dem Namen staticfiles-pv, um den Speicherbedarf zu decken. Dadurch können Pods im Namespace django-app diesen PVC verwenden, um auf den vom zugehörigen PV bereitgestellten Speicher zuzugreifen und diesen zu nutzen.

Diese YAML-Datei definiert eine ConfigMap namens app-cm im Namespace django-app und enthält verschiedene Schlüssel-Wert-Paare, die Konfigurationsdaten speichern. Diese ConfigMap kann von Pods oder anderen Ressourcen innerhalb des Namespace django-app verwendet werden, um auf Konfigurationseinstellungen wie Datenbank-Verbindungsinformationen und statische Dateipfade zuzugreifen.

Diese YAML-Datei definiert ein Deployment mit dem Namen django-app-deploy im Namespace django-app. Es wird eine Replik (Pod) erstellt, auf der ein Container mit einem bestimmten Docker-Image und einer bestimmten Konfiguration läuft. Der Pod ist mit zwei Volumes verbunden, postgres-db-storage und staticfiles, die durch PVCs abgesichert sind. Der Container ist so konfiguriert, dass er Umgebungsvariablen aus einer ConfigMap namens app-cm verwendet und auf Port 8000 lauscht. Die Volumen werden an bestimmten Pfaden innerhalb des Containers gemountet, um den Zugriff auf den Datenbankspeicher und statische Dateien zu ermöglichen. Dieses Deployment ist eine gängige Methode, um eine Django-Anwendung mit Kubernetes auszuführen.

Falls Sie daran interessiert sind, Bilder aus einer privaten Registry zu pullen, dann können Sie hier mehr erfahren.

Der Service lauscht auf Port 8000 und leitet den eingehenden Traffic an Pods weiter, die als app: django-application gekennzeichnet sind. Dies ist eine gängige Konfiguration für die Freigabe und die Lastenverteilung von Webanwendungen in einem Kubernetes-Cluster, in dem mehrere Instanzen derselben Anwendung ausgeführt werden. Der Service sorgt dafür, dass der Traffic gleichmäßig verteilt wird.

NGINX ist ein leistungsstarker Web- und Reverse-Proxy-Server, der für seine Geschwindigkeit, Zuverlässigkeit und Skalierbarkeit bekannt ist. Er wickelt den Webtraffic, die Lastverteilung sowie die Bereitstellung von Inhalten effizient ab und ist daher eine beliebte Wahl für Websites und Anwendungen.

Diese YAML-Datei definiert eine Kubernetes-ConfigMap namens nginx-cm im Namespace django-app und enthält ein Schlüssel-Wert-Paar, wobei der Schlüssel default.conf und der Wert eine mehrzeilige NGINX-Konfigurationsdatei ist, welche die Anfrage an den Backend-Server weiterleitet.

Diese YAML-Datei definiert ein Deployment, das Pods erstellt und verwaltet, auf denen ein NGINX-Container mit bestimmten Volumen und Konfigurationen läuft. Das Deployment stellt sicher, dass eine Replik dieses Pods immer im Namespace django-app läuft. Außerdem überschreibt es die Standardkonfiguration von NGINX, indem es diese durch die ConfigMap nginx-cm ersetzt.

Diese YAML-Konfiguration erstellt einen Kubernetes-Service namens nginx-service im Namespace django-app. Die Konfiguration stellt Pods mit der Bezeichnung app:nginx auf Port 80 innerhalb des Clusters zur Verfügung und macht den Service auch auf NodePort 30005 auf jedem Cluster-Knoten zugänglich. Dadurch kann der externe Traffic die Pods, auf denen die NGINX-Anwendung läuft, über den NodePort-Service erreichen.

In Kubernetes bezeichnet ein Job ein Ressourcenobjekt, das eine einzelne Arbeitseinheit oder eine endliche Aufgabe darstellt. Jobs sind so konzipiert, dass sie Aufgaben bis zum Ende ausführen, wobei eine bestimmte Anzahl von Aufgaben erfolgreich abgeschlossen werden muss.

Diese YAML-Konfiguration definiert einen Kubernetes-Job namens django-db-migrations im Namespace django-app. Der Job führt einen Container mit einem benutzerdefinierten Docker-Image für Django-Migrationen aus und bindet einen PVC ein, um Speicherplatz für datenbankbezogene Dateien bereitzustellen. Falls der Job fehlschlägt, kann er bis zu 15 Mal wiederholt werden. Der Pod wird nach Abschluss noch 100 Sekunden lang beibehalten. Dieser Job erstellt neue Tabellen in PostgreSQL.

Diese YAML-Konfiguration definiert einen Kubernetes-Job namens django-staticfiles im Namespace django-app. Der Job führt einen Container mit einem benutzerdefinierten Docker-Image aus, um statische Dateien für eine Django-Anwendung zu sammeln, und mountet einen PVC, um die statischen Dateien zu speichern. Falls der Job fehlschlägt, kann er bis zu dreimal wiederholt werden. Der Pod wird nach Abschluss noch für 100 Sekunden zu Debugging-Zwecken beibehalten. Dieser Job kopiert die statischen Dateien in den mountPath, der /data/static lautet.

Um die Anwendung zu starten, wechseln Sie in das Verzeichnis k8s und führen Sie den folgenden Befehl aus:

Verwenden Sie nach dem Deployment der Anwendung den folgenden Befehl, um den Status der laufenden Pods zu überprüfen:

kubectl get pods -n django-app -w

Sobald alle Ihre Anwendungen eingerichtet sind, erstellen Sie einen Superuser, mit dem Sie sich in den Django-Admin-Bereich einloggen können.

Führen Sie den folgenden Befehl aus, um die Liste der laufenden Pods einzusehen:

kubectl get pods -n django-app

Um in die Container-Shell zu gelangen, führen Sie Folgendes aus:

kubectl exec -it -n django-app -- sh

Führen Sie anschließend Folgendes aus:

python manage.py createsuperuser

Sobald Sie den Superuser erfolgreich erstellt haben, öffnen Sie http://127.0.0.1:30005 in einem Browser. Sie werden auf die Standard-Begrüßungsseite weitergeleitet.

Wechseln Sie dann über http://127.0.0.1:30005/admin in den Django-Admin-Bereich.

Geben Sie den soeben vergebenen Benutzernamen und das entsprechende Passwort ein.

Sobald Sie sich authentifiziert haben, werden Sie zur Django-Administrationsseite weitergeleitet.

Wenn Sie versuchen, sich über localhost:30005/admin anzumelden, erhalten Sie möglicherweise den Fehler 403 Forbidden (CSRF).

Sie können diesen in der Datei settings.py unter CSRF_TRUSTED_ORIGINS beheben.

CSRF_TRUSTED_ORIGINS ist eine Einstellung in Django, die verwendet wird, um eine Liste von vertrauenswürdigen Origins für den Schutz vor Cross-Site-Request-Forgery (CSRF) anzugeben. CSRF ist eine Sicherheitslücke, die auftreten kann, wenn ein Angreifer einen Benutzer dazu verleitet, unwissentlich eine unerwünschte Anfrage an eine Webanwendung zu stellen. Um dies zu verhindern, enthält Django eingebauten CSRF-Schutz.

CSRF_TRUSTED_ORIGINS ermöglicht es Ihnen, eine Liste von Origins (Websites) zu definieren, von denen CSRF-geschützte Anfragen akzeptiert werden. Jede Anfrage, die von einem Origin ausgeht, der nicht in dieser Liste enthalten ist, wird als potenziell bösartig eingestuft und entsprechend blockiert.

Diese Einstellung kann verwendet werden, um bestimmte Cross-Origin-Anfragen an Ihre Django-Anwendung zuzulassen und gleichzeitig die Sicherheit gegen CSRF-Angriffe zu gewährleisten. Das ist besonders hilfreich in Szenarien, in denen Ihre Anwendung mit anderen Webdiensten oder APIs interagieren muss, die auf verschiedenen Domains gehostet werden.

Falls Sie GUI-Tools wie Kubernetes Dashboard verwenden, können Sie Ihre laufenden Pods, Deployments, persistenten Volumes usw. leicht visualisieren.

PyCharm verfügt über einen erweiterten Editor und umfassende Laufzeitunterstützung, die speziell für Kubernetes entwickelt wurden. Diese leistungsstarken Tools bieten eine Vielzahl von Funktionen, die darauf abzielen, Ihre Kubernetes-Verwaltung zu optimieren, z. B.:

• Durchsuchen von Cluster-Objekten, Extrahieren und Bearbeiten ihrer Konfigurationen und Beschreiben derselben.
• Anzeige von Ereignissen.
• Ansehen und Herunterladen von Pod-Protokollen.
• Anhängen der Pod-Konsole.
• Ausführen von Shell in Pods.
• Weiterleitung von Ports an einen Pod.
• Anwenden von Ressourcen-YAML-Konfigurationen aus dem Editor.
• Löschen von Ressourcen aus dem Cluster.
• Vervollständigung der ConfigMap- und Secret-Einträge aus dem Cluster.
• Konfigurieren der Pfade zu kubectl.
• Konfigurieren der benutzerdefinierten kubeconfig-Dateien; global und pro Projekt.
• Wechseln von Kontexten und Namespaces.
• Verwendung des API-Schemas (einschließlich CRD) des aktiven Clusters zur Bearbeitung von Ressourcenmanifesten.

Sehen Sie sich dieses Video an, um mehr über die Arbeit mit Kubernetes in PyCharm Professional zu erfahren.

Testen Sie PyCharm kostenlos für Ihre Kubernetes-Aufgaben!

Haben Sie bereits ein umfassenderes Verständnis von Kubernetes? Dann unternehmen Sie den nächsten Schritt in Ihrer Programmierkarriere, indem Sie sich mit Cloud-Lösungen beschäftigen. Sehen Sie sich unsere Tutorials zu AWS EKS und Google Kubernetes Engine an.

Autor des ursprünglichen Blogposts