So dockerisieren Sie eine Python-Django-Anwendung

Docker ist ein Open-Source-Projekt, das Entwicklern und Systemadministratoren eine offene Plattform bietet, um Anwendungen als leichte Container zu erstellen, zu verpacken und überall auszuführen. Docker automatisiert die Bereitstellung von Anwendungen in Softwarecontainern.
Django ist ein in Python geschriebenes Web-Anwendungs-Framework, das der MVC-Architektur (Model-View-Controller) folgt. Es ist kostenlos und wird unter einer Open-Source-Lizenz veröffentlicht. Es ist schnell und wurde entwickelt, um Entwicklern zu helfen, ihre Apps so schnell wie möglich online zu bringen.
In diesem Tutorial zeige ich Ihnen Schritt für Schritt, wie Sie ein Docker-Image für eine vorhandene Django-Anwendung in Ubuntu 16.04 erstellen. Wir lernen, wie man eine Python-Django-Anwendung dockerisiert und dann ein Docker-Compose-Skript verwendet, um die Anwendung als Container in einer Docker-Umgebung bereitzustellen.
Um unsere Python Django-Anwendung bereitzustellen, benötigen wir andere Docker-Images: ein Nginx-Docker-Image für den Webserver und ein PostgreSQL-Image für die Datenbank.

Was sollen wir tun?

1. Installieren Sie Docker-ce
2. Installieren Sie Docker-Compose
3. Konfigurieren der Projektumgebung
4. Erstellen und Ausführen
5. prüfen

Schritt 1 – Docker-ce installieren

In diesem Tutorial installieren wir die Docker-CE Community Edition aus dem Docker-Repository. Wir werden die Docker-CE Community Edition und Docker-Compose installieren (das Version 3 von Compose-Dateien unterstützt).

Installieren Sie vor der Installation von docker-ce die erforderlichen Docker-Abhängigkeiten mit dem Befehl apt.

sudo apt install -y
apt-transport-https
CA-Zertifikate
Locke
Software-Eigenschaften-allgemein

Fügen Sie nun den Docker-Schlüssel und das Repository hinzu, indem Sie den folgenden Befehl ausführen.

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository
"deb [arch=amd64] https://download.docker.com/linux/ubuntu
$(lsb_release -cs)
stabil"

Installieren Sie Docker-ce

Aktualisieren Sie das Repository und installieren Sie docker-ce.

sudo apt update
sudo apt install -y docker-ce

Sobald die Installation abgeschlossen ist, starten Sie den Docker-Dienst und aktivieren Sie ihn, damit er bei jedem Systemstart gestartet wird.

systemctl starte Docker
systemctl aktiviert Docker

Als Nächstes fügen wir einen neuen Benutzer namens Omar hinzu und fügen ihn der Docker-Gruppe hinzu.

useradd -m -s /bin/bash omar
usermod -a -G Docker Omar

Starten Sie Docker

Melden Sie sich als Omar-Benutzer an und führen Sie den Docker-Befehl wie unten gezeigt aus

su-omar
Docker Run Hallo Welt

Stellen Sie sicher, dass Sie die Hallo-Welt-Nachricht von Docker erhalten

Überprüfen Sie die Docker-Installation

Die Docker-ce-Installation wurde abgeschlossen.

Schritt 2 – Docker-compose installieren

In diesem Tutorial verwenden wir das neueste Docker-Compose, das Version 3 der Compose-Datei unterstützt. Wir werden Docker-Compose manuell installieren

Verwenden Sie den Befehl curl, um die neueste Version von Docker-Compose in das Verzeichnis /usr/local/bin herunterzuladen, und erteilen Sie ihr mit dem Befehl chmod Ausführungsberechtigungen.

Führen Sie den folgenden Befehl aus:

sudo curl -L 
https://github.com/docker/compose/releases/download/1.21.0/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Überprüfen Sie jetzt die Docker-Compose-Version.

docker-compose version

Stellen Sie sicher, dass Sie die neueste Version von Docker-Compose installiert haben: 1.21

Installieren Sie Docker-Compose

Die neueste Version von Docker-Compose, die Version 3 der Compose-Datei unterstützt, ist installiert.

Schritt 3: Konfigurieren der Projektumgebung

In diesem Schritt konfigurieren wir die Python Django-Projektumgebung. Wir erstellen ein neues Verzeichnis „guide01“ und machen es zum Hauptverzeichnis für unsere Projektdateien, wie Dockerfile, Django-Projekt, Nginx-Konfigurationsdatei usw.

Melden Sie sich als Omar-Benutzer an.

su - omar

Erstellen Sie ein neues Verzeichnis, guide01, und wechseln Sie dorthin.

mkdir -p guide01
CD-Anleitung01/

Erstellen Sie jetzt im Verzeichnis guide01 zwei neue Verzeichnisse: project und config.

mkdir Projekt/Konfiguration/

Beachten:

• Projektverzeichnis: Alle unsere Python Django-Projektdateien werden in diesem Verzeichnis abgelegt.
• Konfigurationsverzeichnis: das Verzeichnis der Projektkonfigurationsdateien, einschließlich Nginx-Konfigurationsdateien, requirements.txt-Dateien von Python Pip usw.
  

Erstellen Sie eine neue requirements.txt-Datei

Erstellen Sie als Nächstes mit dem Befehl vim eine neue Datei requirements.txt im Konfigurationsverzeichnis.

vim config/anforderungen.txt

Fügen Sie die folgende Konfiguration ein:

Django==2.0.4
gunicorn==19.7.0
psycopg2==2.7.4

Speichern und beenden.

Erstellen Sie die virtuelle Nginx-Hostdatei django.conf
Erstellen Sie ein Nginx-Konfigurationsverzeichnis unter dem Konfigurationsverzeichnis und fügen Sie die virtuelle Host-Konfigurationsdatei django.conf hinzu.

mkdir -p konfiguration/nginx/
vim konfiguration/nginx/django.conf

Fügen Sie die folgende Konfiguration ein:

Upstream-Web {
ip_hash;
Server-Web:8000;
}
#Portal
Server {
Standort / {
Proxy-Passwort http://web/;
}
hör zu 8000;
Servername localhost;
Standort /static {
Autoindex aktiviert;
Alias ​​/src/static/;
}
}

Speichern und beenden.

Dockerfile erstellen
Erstellen Sie eine neue Dockerfile-Datei im Verzeichnis guide01.

Führen Sie den folgenden Befehl aus:

vim Dockerfile

Fügen Sie nun das folgende Dockerfile-Skript ein:

VON python:3.5-alpine
ENV PYTHONUNBUFFERED 1
APK-Update ausführen &&
apk add --virtual build-deps gcc python-dev musl-dev &&
apk hinzufügen postgresql-dev bash
Führen Sie mkdir /config aus.
HINZUFÜGEN /config/requirements.txt /config/
Führen Sie den Befehl „pip install -r /config/requirements.txt“ aus.
Führen Sie den Befehl mkdir /src aus.
ARBEITSVERZEICHNIS /src

Speichern und beenden.

Beachten:

Wir möchten ein Docker-Image für unser Django-Projekt basierend auf Alpine Linux erstellen, einer minimalen Linux-Distribution. Unser Django-Projekt wird auf Alpine Linux mit Python 3.5 ausgeführt und fügt das Paket postgresql-dev hinzu, um die PostgreSQL-Datenbank zu unterstützen. Anschließend installieren wir alle in requirements.txt aufgeführten Python-Pakete mit dem Befehl python pip und erstellen ein neues Verzeichnis /src für unser Projekt.

Erstellen Sie ein Docker-Compose-Skript

Verwenden Sie den Befehl vim, um eine Datei docker-compose.yml im Verzeichnis guide01 zu erstellen.

vim docker-compose.yml

Fügen Sie den folgenden Konfigurationsinhalt ein:

Version: '3'
Leistungen:
db:
Bild: postgres:10.3-alpine
Containername: postgres01
nginx:
Bild: nginx:1.13-alpine
Containername: nginx01
Häfen:
- "8000:8000"
Bände:
- ./Projekt:/src
- ./config/nginx:/etc/nginx/conf.d
hängt ab von:
- Netz
Webseite:
bauen: .
Containername: django01
Befehl: bash -c "python manage.py makemigrations && python manage.py migrieren && python manage.py collectstatic --noinput && gunicorn hello_django.wsgi -b 0.0.0.0:8000"
hängt ab von:
-db
Bände:
- ./Projekt:/src
exponieren:
- "8000"
Neustart: immer

Speichern und beenden.

Beachten:

Mit diesem Docker-Compose-Dateiskript erstellen wir drei Dienste. Erstellen Sie mit der Alpine-Linux-Version von PostgreSQL einen Datenbankdienst namens db, erstellen Sie erneut einen Nginx-Dienst mit der Alpine-Linux-Version von Nginx und erstellen Sie unseren Python-Django-Container mit dem benutzerdefinierten Docker-Image, das aus der Docker-Datei generiert wurde.

Konfigurieren der Projektumgebung

Konfigurieren des Django-Projekts

Kopieren Sie die Django-Projektdateien in das Projektverzeichnis.

cd ~/django
cp -r * ~/guide01/projekt/

Gehen Sie in das Projektverzeichnis und bearbeiten Sie die Anwendungseinstellungen settings.py.

cd ~/guide01/projekt/
vim hallo_django/settings.py

Beachten:

Wir werden eine einfache Django-Anwendung namens „hello_django“ bereitstellen.

Fügen Sie in der Zeile ALLOW_HOSTS den Dienstnamen „Web“ hinzu.

ALLOW_HOSTS = ['web']

Ändern Sie nun die Datenbankeinstellungen. Wir werden die PostgreSQL-Datenbank verwenden, um einen Dienst namens db mit dem Standardbenutzer und -kennwort auszuführen.

DATENBANKEN = {
'Standard': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'postgres',
'BENUTZER': 'postgres',
'HOST': 'Datenbank',
'PORT': 5432,
}
}

Fügen Sie diese Zeile für das Konfigurationsverzeichnis STATIC_ROOT am Ende der Datei hinzu.

STATIC_ROOT = os.path.join(BASE_DIR, 'static/')

Speichern und beenden.

Konfigurieren des Django-Projekts

Jetzt können wir das Django-Projekt im Docker-Container erstellen und ausführen.

Schritt 4: Erstellen und Ausführen des Docker-Image

In diesem Schritt möchten wir mithilfe der Konfiguration im Verzeichnis guide01 ein Docker-Image für unser Django-Projekt erstellen.

Geben Sie das Verzeichnis guide01 ein.

cd ~/guide01/
Erstellen Sie jetzt das Docker-Image mit dem Befehl „Docker-Compose“.

docker-compose build

Ausführen des Docker-Image

Starten Sie alle Dienste im Docker-Compose-Skript.

docker-compose up -d

Warten Sie einige Minuten, bis Docker unser Python-Image erstellt und die Docker-Images für Nginx und PostgreSQL heruntergeladen hat.

Erstellen Sie das Image mit Docker-Compose

Verwenden Sie nach Abschluss die folgenden Befehle, um laufende Container zu überprüfen und Docker-Images auf Ihrem System aufzulisten.

Docker-Compose PS
Docker-Compose-Bilder

Jetzt werden auf Ihrem System drei Container ausgeführt, die die Docker-Images wie unten gezeigt auflisten.

Docke-Compose PS-Befehl

Unsere Python-Django-Anwendung wird jetzt in einem Docker-Container ausgeführt und es wurde ein Docker-Image erstellt, das sie für uns bereitstellt.

Schritt 5 - Testen

Öffnen Sie einen Webbrowser und geben Sie die Serveradresse mit Port 8000 ein, meine ist: http://ovh01:8000/.

Jetzt sehen Sie die Standard-Homepage von Django.

Standard-Homepage des Django-Projekts

Testen Sie als Nächstes die Administrationsseiten, indem Sie der URL den Pfad /admin hinzufügen.

http://ovh01:8000/admin/

Sie sehen dann die Django-Administrator-Anmeldeseite.

Django-Verwaltung

Das Dockerisieren der Python-Django-Anwendung wurde erfolgreich abgeschlossen.

Zusammenfassen

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels einen gewissen Lernwert für Ihr Studium oder Ihre Arbeit hat. Vielen Dank für Ihre Unterstützung von 123WORDPRESS.COM. Wenn Sie mehr darüber erfahren möchten, schauen Sie sich bitte die folgenden Links an