Kubernetes für Django: Skalierung und Sicherheit mit HTTPS

Django bietet ein leistungsstarkes Web-Framework für Python mit zahlreichen Funktionen. Wir zeigen Ihnen, wie Sie eine Django Polls-Anwendung in einem Kubernetes-Cluster bereitstellen können.

In diesem Tutorial werden wir eine containerisierte Django Polls-Anwendung in einem Kubernetes-Cluster bereitstellen. Django ist ein leistungsstarkes Web-Framework, das Ihnen hilft, Ihre Python-Anwendung schnell zu starten. Es enthält mehrere praktische Funktionen wie einen objektrelationalen Mapper, Benutzerauthentifizierung und eine anpassbare administrative Oberfläche für Ihre Anwendung. Es enthält auch ein Caching-Framework und fördert ein sauberes App-Design durch sein URL-Dispatcher- und Template-System.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

• Einen Kubernetes-Cluster 1.15+ mit aktivierter rollenbasierter Zugriffskontrolle (RBAC).
• Das kubectl-Befehlszeilentool auf Ihrem lokalen Rechner installiert und konfiguriert, um eine Verbindung zu Ihrem Cluster herzustellen.
• Einen registrierten Domainnamen.
• Einen ingress-nginx Ingress-Controller und den cert-manager TLS-Zertifikatsmanager in Ihrem Cluster installiert und konfiguriert, um TLS-Zertifikate auszustellen.
• Ein S3-Objektspeicher-Bucket wie z.B. ein centron Space, um die statischen Dateien Ihres Django-Projekts zu speichern.
• Eine PostgreSQL-Serverinstanz, Datenbank und Benutzer für Ihre Django-App.
• Ein Docker Hub-Konto und ein öffentliches Repository.
• Die Docker-Engine auf Ihrem lokalen Rechner installiert.

Schritt 1 — Klonen und Konfigurieren der Anwendung

In diesem Schritt werden wir den Anwendungscode von GitHub klonen und Einstellungen wie Datenbankanmeldeinformationen und Objektspeicherschlüssel konfigurieren. Beginnen Sie damit, den Anwendungscode von GitHub auf Ihren lokalen Rechner zu klonen und in das entsprechende Verzeichnis zu navigieren.

git clone --single-branch --branch polls-docker https://github.com/do-community/django-polls.git

cd django-polls

Der Anwendungscode enthält eine Dockerdatei, in der die Containerkonfiguration definiert ist. Sie können diese Datei mit einem Editor Ihrer Wahl öffnen und anpassen.

FROM python:3.7.4-alpine3.10

ADD django-polls/requirements.txt /app/requirements.txt

RUN set -ex \

&& apk add --no-cache --virtual .build-deps postgresql-dev build-base \

&& python -m venv /env \

&& /env/bin/pip install --upgrade pip \

&& /env/bin/pip install --no-cache-dir -r /app/requirements.txt \

&& runDeps="$(scanelf --needed --nobanner --recursive /env \

| awk '{ gsub(/,/, "\nso:", $2); print "so:" $2 }' \

| sort -u \

| xargs -r apk info --installed \

| sort -u)" \

&& apk add --virtual rundeps $runDeps \

&& apk del .build-deps

ADD django-polls /app

WORKDIR /app

ENV VIRTUAL_ENV /env

ENV PATH /env/bin:$PATH

EXPOSE 8000

CMD ["gunicorn", "--bind", ":8000", "--workers", "3", "mysite.wsgi"]

Schritt 2 — Erstellen des Datenbankschemas und Hochladen von Assets in den Objektspeicher

Nachdem der Container erstellt und konfiguriert wurde, verwenden Sie docker run, um den in der Dockerdatei festgelegten CMD zu überschreiben und das Datenbankschema mithilfe der manage.py makemigrations- und manage.py migrate-Befehle zu erstellen.

docker run --env-file env polls sh -c "python manage.py makemigrations && python manage.py migrate"

Anschließend können Sie einen Superuser für die Django-Anwendung erstellen:

docker run -i -t --env-file env polls sh

python manage.py createsuperuser

Generieren Sie dann die statischen Dateien für die Anwendung und laden Sie sie in den centron Space hoch:

docker run --env-file env polls sh -c "python manage.py collectstatic --noinput"

Schritt 3 — Pushen des Django-App-Images auf Docker Hub

Um Ihre App auf Kubernetes bereitzustellen, muss Ihr App-Image in einem Repository wie Docker Hub hochgeladen werden. Beginnen Sie damit, sich auf Ihrem lokalen Rechner bei Docker Hub anzumelden.

docker login

Dann taggen Sie das Image mit Ihrem Docker Hub-Benutzernamen und dem Repository-Namen und schieben Sie es ins Repo.

docker tag polls:latest your_dockerhub_username/your_dockerhub_repo_name:latest

docker push your_dockerhub_username/your_dockerhub_repo_name:latest

Schritt 4: Konfiguration der ConfigMap

Um Konfigurationsvariablen in die Laufzeitumgebung einzuspeisen, verwenden wir auf Kubernetes ConfigMaps und Secrets. ConfigMaps werden für nicht vertrauliche Informationen wie App-Einstellungen verwendet, während Secrets für sensible Daten wie API-Schlüssel und Datenbankanmeldeinformationen geeignet sind. Die Konfiguration erfolgt durch das Erstellen einer YAML-Datei und das Anwenden mittels `kubectl apply`.

apiVersion: v1

kind: ConfigMap

metadata:

name: polls-config

data:

DJANGO_ALLOWED_HOSTS: "*"

STATIC_ENDPOINT_URL: "https://your_space_name.space_region.centronspaces.com"

STATIC_BUCKET_NAME: "your_space_name"

DJANGO_LOGLEVEL: "info"

DEBUG: "True"

DATABASE_ENGINE: "postgresql_psycopg2"

Schritt 5: Einrichten des Secrets

Geheime Werte müssen base64-codiert sein. Wir erstellen ein Secret-Objekt in unserem Cluster, indem wir die Werte aus einer Umgebungsvariablen-Datei extrahieren und base64-codieren. Dies erfolgt ähnlich wie bei der Konfiguration der ConfigMap, jedoch unter Verwendung des Befehls `kubectl create secret`.

apiVersion: v1

kind: Secret

metadata:

name: polls-secret

type: Opaque

data:

DJANGO_SECRET_KEY: ""

DATABASE_NAME: ""

DATABASE_USERNAME: ""

DATABASE_PASSWORD: ""

DATABASE_HOST: ""

DATABASE_PORT: ""

STATIC_ACCESS_KEY_ID: ""

STATIC_SECRET_KEY: ""

STATIC_BUCKET_NAME: ""

STATIC_ENDPOINT_URL: ""

DJANGO_LOGLEVEL: ""

Schritt 6: Bereitstellen der Django-App mit einer Deployment-Datei

Ein Kubernetes-Deployment wird verwendet, um unsere Django-App bereitzustellen. Hier legen wir die Anzahl der Replikate fest und definieren die Containerkonfigurationen. Die Konfiguration erfolgt in einer YAML-Datei, die dann mittels `kubectl apply` angewendet wird.

apiVersion: apps/v1

kind: Deployment

metadata:

name: polls-app

labels:

app: polls

spec:

replicas: 2

selector:

matchLabels:

app: polls

template:

metadata:

labels:

app: polls

spec:

containers:

- image: your_dockerhub_username/app_repo_name:latest

name: polls

envFrom:

- secretRef:

name: polls-secret

- configMapRef:

name: polls-config

ports:

- containerPort: 8000

name: gunicorn

Schritt 7: Ermöglichen des externen Zugriffs über einen Service

Ein Kubernetes-Service wird erstellt, um einen stabilen Endpunkt für unsere App zu schaffen, der auch bei Änderungen an den Pods erhalten bleibt. Hier legen wir einen NodePort-Service fest, um vorübergehend auf die Django-App zuzugreifen. Die Konfiguration erfolgt ebenfalls in einer YAML-Datei, die dann angewendet wird.

apiVersion: v1

kind: Service

metadata:

name: polls

labels:

app: polls

spec:

type: NodePort

selector:

app: polls

ports:

- port: 8000

targetPort: 8000

Schritt 8: Konfigurieren von HTTPS mit Nginx Ingress und cert-manager

Abschließend richten wir HTTPS-Verschlüsselung für unsere App ein. Dies erfolgt durch die Verwendung von Ingress-Objekten und des cert-manager-Add-Ons. Nachdem die Konfiguration abgeschlossen ist, wird die Bereitstellung der Django-App mit HTTPS-Verschlüsselung in unserem Kubernetes-Cluster abgeschlossen sein.

apiVersion: networking.k8s.io/v1beta1

kind: Ingress

metadata:

name: polls-ingress

annotations:

kubernetes.io/ingress.class: "nginx"

cert-manager.io/cluster-issuer: "letsencrypt-staging"

spec:

tls:

- hosts:

- your_domain.com

secretName: polls-tls

rules:

- host: your_domain.com

http:

paths:

- backend:

serviceName: polls

servicePort: 8000

Fazit

Die Bereitstellung einer Django-App in Kubernetes erfordert einige Schritte zur Konfiguration von ConfigMaps, Secrets, Deployments, Services und Ingresses. Mit diesen Schritten kannst du jedoch eine skalierbare und sicher bereitgestellte Anwendung in deiner Kubernetes-Umgebung erstellen.