Docker-Leitfaden: Dockerizing Python Django-Anwendung
Docker ist ein Open-Source-Projekt, das Entwicklern und Systemadministratoren eine offene Plattform bietet, um Anwendungen als leichtgewichtige Container zu erstellen, zu paketieren und überall auszuführen. Docker automatisiert die Bereitstellung von Anwendungen innerhalb von Software-Containern.
Django ist ein in Python geschriebenes Webanwendungs-Framework, das der MVC (Model-View-Controller)-Architektur folgt. Es ist frei verfügbar und unter einer Open-Source-Lizenz veröffentlicht. Es ist schnell und soll Entwicklern helfen, ihre Anwendung so schnell wie möglich online zu stellen.
In diesem Tutorial zeige ich Ihnen Schritt für Schritt, wie Sie ein Docker-Image für ein vorhandenes Django-Anwendungsprojekt in Ubuntu 16.04 erstellen. Wir werden über das Andocken einer Python-Django-Anwendung lernen und dann die Anwendung mit Hilfe eines Andock-Skripts als Container für die Andock-Umgebung bereitstellen.
Um unsere Python-Django-Anwendung zu implementieren, benötigen wir zusätzliche Docker-Images. Wir brauchen ein nginx-Docker-Image für den Webserver und ein PostgreSQL-Image für die Datenbank.
Was werden wir tun?
- Docker-ce installieren
- Installieren Sie Docker-compose
- Konfigurieren Sie die Projektumgebung
- Erstellen und ausführen
- Testen Sie
Schritt 1 – Docker-ce installieren
In diesem Tutorial werden wir die docker-ce Community Edition aus dem Docker-Repository installieren. Wir werden die docker-ce Community-Edition und docker-compose installieren, die die Kompositionsdatei Version 3 unterstützen.
Bevor Sie docker-ce installieren, installieren Sie die benötigten Docker-Abhängigkeiten mit dem apt-Befehl.
sudo apt install -y \ apt-transport-https \ ca-certificates \ curl \ software-properties-common
Fügen Sie nun den Dockerschlüssel und das Repository hinzu, indem Sie die unten stehenden Befehle 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) \ stable"
Aktualisieren Sie das Repository und installieren Sie docker-ce.
sudo apt update sudo apt install -y docker-ce
Nachdem die Installation abgeschlossen ist, starten Sie den Docker-Dienst und ermöglichen es ihm, bei jedem Systemstart zu starten.
systemctl start docker systemctl enable docker
Als nächstes werden wir einen neuen Benutzer namens ‚omar‘ hinzufügen und ihn der Docker-Gruppe hinzufügen.
useradd -m -s /bin/bash omar usermod -a -G docker omar
Melden Sie sich als Omar-Benutzer an und führen Sie den Docker-Befehl wie unten gezeigt aus.
su - omar docker run hello-world
Stellen Sie sicher, dass Sie die Hallo-Welt-Nachricht von Docker erhalten.
Die Installation von Docker-ce ist abgeschlossen.
Schritt 2 – Installieren Sie Docker-compose
In diesem Tutorial verwenden wir die neueste Docker-Compose-Unterstützung für die Compose-Datei Version 3. Wir werden docker-compose manuell installieren.
Laden Sie die neueste Version von docker-compose mit dem Befehl curl in das Verzeichnis ‚/usr/local/bin‘ herunter und machen Sie es mit chmod ausführbar.
Führen Sie die folgenden Befehle 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 nun die Docker-Compose-Version.
docker-compose version
Und stellen Sie sicher, dass Sie die neueste Version des Docker-Composite 1.21 erhalten.
Die neueste Version von docker-compose, die die Version 3 von compose file unterstützt, wurde installiert.
Schritt 3 – Konfigurieren der Projektumgebung
In diesem Schritt werden wir die Python-Django-Projektumgebung konfigurieren. Wir werden ein neues Verzeichnis ‚guide01‘ erstellen und es zum Hauptverzeichnis für unsere Projektdateien machen, wie z.B. eine Dockerdatei, das Django-Projekt, die nginx-Konfigurationsdatei usw.
Melden Sie sich bei dem Benutzer ‚omar‘ an.
su - omar
Erstellen Sie ein neues Verzeichnis ‚guide01‘ und gehen Sie in das Verzeichnis.
mkdir -p guide01 cd guide01/
Erstellen Sie nun innerhalb des Verzeichnisses ‚guide01‘ die neuen Verzeichnisse ‚project‘ und ‚config‘.
mkdir project/ config/
Anmerkung:
- Verzeichnis ‚project‘: Alle unsere Python-Django-Projektdateien werden in diesem Verzeichnis abgelegt.
- Verzeichnis ‚config‘: Verzeichnis für die Projekt-Konfigurationsdateien, einschließlich nginx-Konfigurationsdatei, Python-Pip-Anforderungsdatei usw.
Erstellen Sie eine neue Datei ‚requirements.txt‘.
Als nächstes erstellen Sie eine neue Datei ‚requirements.txt‘ innerhalb des ‚config‘-Verzeichnisses mit dem Befehl vim.
vim config/requirements.txt
Fügen Sie die Konfiguration unten ein.
Django==2.0.4 gunicorn==19.7.0 psycopg2==2.7.4
Speichern und beenden.
Erstellen Sie die virtuelle Nginx-Host-Datei django.conf
Erstellen Sie unter dem Konfigurationsverzeichnis das Konfigurationsverzeichnis ’nginx‘ und fügen Sie die Konfigurationsdatei django.conf des virtuellen Hosts hinzu.
mkdir -p config/nginx/ vim config/nginx/django.conf
Fügen Sie dort die folgende Konfiguration ein.
upstream web {
ip_hash;
server web:8000;
}
# portal
server {
location / {
proxy_pass http://web/;
}
listen 8000;
server_name localhost;
location /static {
autoindex on;
alias /src/static/;
}
}
Speichern und beenden.
Erstellen Sie die Dockerdatei
Erstellen Sie eine neue ‚Dockerdatei‘ innerhalb des Verzeichnisses ‚guide01‘.
Führen Sie den folgenden Befehl aus.
vim Dockerfile
Fügen Sie nun das Skript Dockerfile unten ein.
FROM python:3.5-alpine ENV PYTHONUNBUFFERED 1
RUN apk update && \
apk add –virtual build-deps gcc python-dev musl-dev && \
apk add postgresql-dev bash
RUN mkdir /config
ADD /config/requirements.txt /config/
RUN pip install -r /config/requirements.txt
RUN mkdir /src
WORKDIR /src
Speichern und beenden.
Anmerkung:
Wir wollen die Docker-Images für unser Django-Projekt auf der Basis von Alpine Linux, der kleinsten Größe von Linux, erstellen. Unser Django-Projekt wird unter Alpine Linux mit Python 3.5 laufen und das Paket postgresql-dev für die Unterstützung der PostgreSQL-Datenbank hinzufügen. Und dann werden wir alle Python-Pakete, die in der Datei ‚requirements.txt‘ aufgeführt sind, mit dem Befehl python pip installieren und ein neues ‚/src‘ für unser Projekt erstellen.
Docker-compose-Skript erstellen
Erstellen Sie die Datei ‚docker-compose.yml‘ unter dem Verzeichnis ‚guide01‘ mit dem untenstehenden vim-Befehl.
vim docker-compose.yml
Fügen Sie dort die folgende Konfiguration ein.
version: '3' services: db: image: postgres:10.3-alpine container_name: postgres01 nginx: image: nginx:1.13-alpine container_name: nginx01 ports: - "8000:8000" volumes: - ./project:/src - ./config/nginx:/etc/nginx/conf.d depends_on: - web web: build: . container_name: django01 command: bash -c "python manage.py makemigrations && python manage.py migrate && python manage.py collectstatic --noinput && gunicorn hello_django.wsgi -b 0.0.0.0:8000" depends_on: - db volumes: - ./project:/src expose: - "8000" restart: always
Speichern und beenden.
Hinweis:
Mit diesem Dockerfile-Skript werden wir drei Dienste erstellen. Erstellen Sie den Datenbankdienst namens ‚db‘ mit dem alpinen PostgreSQL-Linux, erstellen Sie den ’nginx‘-Dienst erneut mit dem alpinen Nginx-Linux und erstellen Sie unseren Python-Django-Container unter Verwendung der benutzerdefinierten Docker-Bilder, die aus unserer Docker-Datei generiert werden.
Django-Projekt konfigurieren
Kopieren Sie Ihre Django-Projektdateien in das Verzeichnis ‚project‘.
cd ~/django cp -r * ~/guide01/project/
Gehen Sie zum ‚project‘-Verzeichnis und bearbeiten Sie die Anwendungseinstellung ’settings.py‘.
cd ~/guide01/project/ vim hello_django/settings.py
Anmerkung:
Wir werden eine einfache Django-Anwendung namens ‚hello_django‘ einsetzen.
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, die als Dienst namens ‚db‘ mit Standardbenutzer und -passwort läuft.
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'postgres',
'USER': 'postgres',
'HOST': 'db',
'PORT': 5432,
}
}
Und für das ‚STATIC_ROOT‘-Konfigurationsverzeichnis fügen Sie diese Zeile am Ende der Zeile der Datei hinzu.
STATIC_ROOT = os.path.join(BASE_DIR, 'static/')
Speichern und beenden Sie die Datei.
Jetzt sind wir bereit, das Django-Projekt unter dem Docker-Container zu erstellen und auszuführen.
Schritt 4 – Erstellen und Ausführen des Docker-Images
In diesem Schritt wollen wir ein Docker-Image für unser Django-Projekt mit der Konfiguration im Verzeichnis ‚guide01‘ erstellen.
Gehen Sie zum Verzeichnis ‚guide01‘.
cd ~/guide01/
Erstellen Sie nun die Docker-Images mit dem Befehl docker-compose.
docker-compose build
Starten Sie alle Dienste innerhalb des docker-compose-Skripts.
docker-compose up -d
Warten Sie ein paar Minuten, bis Docker unser Python-Image erstellt hat und die nginx- und postgresql-Docker-Bilder herunterladen.
Und wenn es fertig ist, überprüfen Sie laufende Container- und Docker-Listen-Images auf dem System mit den folgenden Befehlen.
docker-compose ps docker-compose images
Und nun erhalten Sie drei laufende Container und eine Liste von Docker-Bildern auf dem System, wie unten gezeigt.
Unsere Python-Django-Anwendung läuft jetzt im Docker-Container, und es wurden Docker-Images für unseren Dienst erstellt.
Schritt 5 – Testen
Öffnen Sie Ihren Webbrowser und geben Sie die Serveradresse mit Port 8000 ein, meine ist es:http://ovh01:8000/
Nun erhalten Sie die Standard-Django-Startseite.
Testen Sie als nächstes die Admin-Seite, indem Sie den Pfad ‚/admin‘ in der URL hinzufügen.
http://ovh01:8000/admin/
Und Sie sehen die Django-Administrator-Anmeldeseite.
Die Anwendung Dockerizing Python Django wurde erfolgreich abgeschlossen.