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?

  1. Docker-ce installieren
  2. Installieren Sie Docker-compose
  3. Konfigurieren Sie die Projektumgebung
  4. Erstellen und ausführen
  5. 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"

Docker-ce installieren

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

Start Docker

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.

Docker-Installation prüfen

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.

Installieren Sie Docker-compose

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.

Konfigurieren der Projektumgebung

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.

Django-Projekt konfigurieren

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

Docker-Bild ausführen

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.

Verwenden Sie Docker-Compose-Funktion zum Aufbau des Bildes

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.

docke-compose ps-Befehl

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.

Standardmäßige Django-Projekt-Homepage

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.

Django-Verwaltung

Die Anwendung Dockerizing Python Django wurde erfolgreich abgeschlossen.

Verweis

Das könnte Dich auch interessieren …