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.
