Skalierung und Absicherung einer Django-Anwendung mit Docker, Nginx und Let's Encrypt

Erfahren Sie, wie Sie Ihre Django-Anwendung mithilfe von Docker, Nginx und Let's Encrypt skalieren und absichern können. Wir führen Sie durch den Prozess der horizontalen Skalierung, um eine hochverfügbare Architektur zu schaffen und gleichzeitig die Sicherheit Ihrer Anwendung zu verbessern.

In Cloud-Umgebungen gibt es mehrere Möglichkeiten, eine Django-Anwendung zu skalieren und abzusichern. Durch horizontale Skalierung und die Ausführung mehrerer Kopien Ihrer Anwendung können Sie ein fehlertoleranteres und hochverfügbares System aufbauen und gleichzeitig die Durchsatzrate erhöhen, sodass Anfragen gleichzeitig verarbeitet werden können. Eine Möglichkeit, eine Django-App horizontal zu skalieren, besteht darin, zusätzliche App-Server bereitzustellen, auf denen Ihre Django-Anwendung und ihr WSGI-HTTP-Server (wie Gunicorn oder uWSGI) ausgeführt werden. Um eingehende Anfragen über diese Gruppe von App-Servern zu routen und zu verteilen, können Sie einen Lastenausgleicher und Reverse-Proxy wie Nginx verwenden. Nginx kann auch statische Inhalte zwischenspeichern und TLS-Verbindungen beenden, die verwendet werden, um HTTPS und sichere Verbindungen zu Ihrer App bereitzustellen.

Dockerisierung und Skalierung

Die Ausführung Ihrer Django-Anwendung und des Nginx-Proxys innerhalb von Docker-Containern stellt sicher, dass diese Komponenten unabhängig von der Umgebung, in die sie bereitgestellt werden, gleich funktionieren. Container bieten zudem viele Funktionen, die das Verpacken und Konfigurieren Ihrer Anwendung erleichtern. In diesem Tutorial werden wir eine containerisierte Django- und Gunicorn-Polls-Anwendung horizontal skalieren, indem wir zwei Anwendungsserver bereitstellen, die jeweils eine Kopie eines Django- und Gunicorn-App-Containers ausführen.

Einrichtung der Infrastruktur

Bevor wir beginnen, stellen Sie sicher, dass Sie über die folgenden Voraussetzungen verfügen:

1. Drei Ubuntu 18.04 Server:
   • Zwei Server werden als Anwendungsserver verwendet, um Ihre Django- und Gunicorn-App auszuführen.
   • Ein Server wird als Proxyserver verwendet, um Nginx und Certbot auszuführen.
   • Alle sollten einen Nicht-Root-Benutzer mit Sudo-Berechtigungen und eine aktive Firewall haben.
2. Docker auf allen drei Servern installiert.
3. Einen registrierten Domainnamen, den wir in diesem Tutorial als `your_domain.com` verwenden.
4. Einen A-DNS-Eintrag mit `your_domain.com`, der auf die öffentliche IP-Adresse Ihres Proxy-Servers zeigt.
5. Einen S3-Objektspeicherbereich wie ein centron Space, um die statischen Dateien Ihres Django-Projekts zu speichern, und ein Set von Zugriffsschlüsseln für diesen Space.
6. Eine PostgreSQL-Serverinstanz, Datenbank und Benutzer für Ihre Django-App.

Schritt-für-Schritt-Anleitung

Schritt 1: Konfiguration des ersten Django-Anwendungsservers

Beginnen wir mit dem Klonen des Django-Anwendungsrepositorys auf dem ersten App-Server und dem Bauen des Anwendungs-Docker-Images.

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

cd django-polls

docker build -t polls .

Dann konfigurieren wir die Umgebung und erstellen das Datenbankschema:

nano env

# Füllen Sie die Umgebungsvariablen aus

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

Erstellen Sie schließlich einen administrativen Benutzer und generieren Sie die statischen Dateien:

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

python manage.py createsuperuser

CTRL+D # Beenden Sie den Container

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

docker run --env-file env -p 80:8000 polls

Schritt 2: Konfiguration des zweiten Django-Anwendungsservers

Wiederholen Sie die Schritte für den zweiten App-Server:

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

cd django-polls

docker build -t polls .

# Konfigurieren Sie die Umgebung

docker run -d --rm --name polls --env-file env -p 80:8000 polls

Schritt 3: Konfiguration des Nginx-Docker-Containers

Loggen Sie sich auf dem Proxy-Server ein und konfigurieren Sie Nginx:

mkdir conf

nano conf/nginx.conf

Fügen Sie die Nginx-Konfiguration ein und starten Sie den Container:

docker run --rm --name nginx -p 80:80 -p 443:443 \

-v ~/conf/nginx.conf:/etc/nginx/conf.d/nginx.conf:ro \

-v /var/www/html:/var/www/html \

nginx:1.19.0

Schritt 4 — Konfiguration von Certbot und Let's Encrypt-Zertifikatserneuerung

In diesem Schritt werden wir Certbot konfigurieren und ein Let's Encrypt-Zertifikat erneuern. Certbot ist ein von der Electronic Frontier Foundation entwickelter Let's Encrypt-Client. Er stellt kostenlose TLS-Zertifikate von der Let's Encrypt-Zertifizierungsstelle bereit, die es Browsern ermöglichen, die Identität Ihrer Webserver zu überprüfen. Da Docker auf unserem Nginx-Proxyserver installiert ist, verwenden wir das Certbot Docker-Image, um die TLS-Zertifikate zu provisionieren und zu erneuern.

Einrichtung des Zertifikats mit Certbot:

1. Vorbereitung:

Stellen Sie sicher, dass Sie einen DNS-A-Eintrag auf die öffentliche IP-Adresse des Proxy-Servers haben.

2. Provisionierung eines Testzertifikats:

Führen Sie auf Ihrem Proxy-Server folgenden Befehl aus, um eine Testversion der Zertifikate mit dem certbot Docker-Image zu erstellen:

docker run -it --rm -p 80:80 --name certbot \

-v "/etc/letsencrypt:/etc/letsencrypt" \

-v "/var/lib/letsencrypt:/var/lib/letsencrypt" \

certbot/certbot certonly --standalone --staging -d deine_domain.de

3. Überprüfung:

Nach erfolgreicher Domainvalidierung sollten Sie die Bestätigung sehen, dass das Zertifikat erstellt wurde. Der Befehl lautet:

sudo cat /etc/letsencrypt/live/deine_domain.de/fullchain.pem

4. Nginx-Test:

Starten Sie den Nginx-Server und testen Sie die Konfiguration.

5. Zertifikatserneuerung:

Stoppen Sie den Nginx-Server, und führen Sie Certbot erneut aus, diesmal ohne den --staging-Flag.

docker run -it --rm -p 80:80 --name certbot \

-v "/etc/letsencrypt:/etc/letsencrypt" \

-v "/var/lib/letsencrypt:/var/lib/letsencrypt" \

certbot/certbot certonly --standalone -d deine_domain.de

6. Neustart des Nginx-Servers:

Starten Sie den Nginx-Server erneut, um das neue Zertifikat zu verwenden.

Automatisierte Zertifikaterneuerung:

Damit Ihr Zertifikat gültig bleibt, müssen Sie es regelmäßig erneuern. Verwenden Sie Certbot im Webroot-Modus anstelle des Standalone-Modus und automatisieren Sie den Prozess.

Schritt 5 — Externen Zugriff auf Django-App-Server verhindern

In dieser Phase blockieren wir den direkten Zugriff auf die Django-App-Server von externen Quellen und leiten alle Anfragen durch den Nginx-Proxy.

1. Konfiguration von UFW

Ändern Sie die UFW-Konfiguration, um den externen Zugriff auf die von Docker geöffneten Host-Ports zu blockieren.

2. Anwenden der Änderungen

Starten Sie UFW neu, um die neue Konfiguration zu übernehmen.

3. Überprüfung

Stellen Sie sicher, dass Sie nicht mehr über den Port 80 auf die App-Server zugreifen können.

Fazit

Mit diesen Schritten haben Sie ein produktionsreifes TLS-Zertifikat mit Certbot eingerichtet und den Zugriff auf die Django-App-Server über den Nginx-Proxy gesichert. Es ist wichtig, regelmäßige Zertifikatserneuerungen zu automatisieren und die Sicherheit durch Konfigurationen wie UFW zu erhöhen. Dies stellt sicher, dass Ihr System geschützt ist und reibungslos läuft. Skalierung und Absicherung einer Django-Anwendung mit Docker, Nginx und Let’s Encrypt