Website-Suche

So dockerisiert man eine Django-Anwendung unter Linux

In diesem Tutorial zeige ich Ihnen, wie Sie eine Docker-Umgebung für Ihr Django-Projekt einrichten, wenn Sie sich noch in der Entwicklungsphase befinden. Obwohl ich Ubuntu 18.04 verwende, sind die Schritte für jede Linux-Distribution gleich, die Installation von Docker und docker-compose ausgenommen.

In jedem typischen Softwareentwicklungsprojekt haben wir normalerweise einen Entwicklungsprozess, der in der Regel beim Entwickler beginnt, über das Versionskontrollsystem (VCS) bis hin zur Produktion verläuft. Wir werden versuchen, uns an die Regeln zu halten, damit Sie verstehen, wo jedes DevOps-Tool eingesetzt wird.

DevOps dreht sich ganz darum, den altmodischen Spruch „Aber auf meinem Laptop funktioniert es!“ zu beseitigen. Die Containerisierung mit Docker erstellt die Produktionsumgebung für Ihre Anwendung, sodass sie überall eingesetzt werden kann: Einmal entwickeln, überall bereitstellen!

1) Docker Engine installieren

Sie benötigen eine Docker-Laufzeitumgebung auf Ihrem Server/Desktop. Unsere Docker-Installationsanleitungen sollten dabei sehr hilfreich sein.

Wie man Docker auf CentOS/Debian/Ubuntu installiert

2) Umgebung einrichten

Ich habe ein GitHub-Repo für dieses Projekt eingerichtet, das django-docker-dev-app heißt. Ihr könnt es gerne forken oder klonen/herunterladen.

Erstellen Sie zunächst den Ordner, in dem Ihr Projekt gespeichert werden soll. Mein Arbeitsordner heißt django-docker-dev-app. Wechseln Sie in den Ordner und öffnen Sie ihn dann in Ihrer IDE.

Dockerfile

In einer containerisierten Umgebung leben alle Anwendungen in einem Container. Container selbst bestehen aus mehreren Images. Sie können Ihr eigenes Image erstellen oder andere Images von Docker Hub verwenden. Eine Dockerfile ist ein Textdokument von Docker, das Docker liest, um ein Image automatisch zu erstellen/aufzubauen. Unser Dockerfile wird alle Abhängigkeiten auflisten, die für unser Projekt erforderlich sind.

Erstellen Sie eine Datei mit dem Namen Dockerfile.

nano Dockerfile

Geben Sie im Dateityp Folgendes ein:

#base image
FROM python:3.9-alpine

#maintainer
LABEL Author="CodeGenes"

# The enviroment variable ensures that the python output is set straight
# to the terminal with out buffering it first
ENV PYTHONBUFFERED 1

#copy requirements file to image 
COPY ./requirements.txt /requirements.txt

#let pip install required packages
RUN pip install -r requirements.txt

#directory to store app source code
RUN mkdir /app

#switch to /app directory so that everything runs from here
WORKDIR /app

#copy the app code to image working directory
COPY ./app /app

#create user to run the app(it is not recommended to use root)
#we create user called user with -D -> meaning no need for home directory
RUN adduser -D user

#switch from root to user to run our app
USER user

Erstellen Sie die requirements.txt-Datei und fügen Sie die Anforderungen Ihres Projekts hinzu.

Django
djangorestframework

Erstelle den App-Ordner, der den Quellcode enthalten wird. Jetzt sind wir bereit, unser Image zu erstellen!

mkdir app

Öffnen Sie ein Terminal in Ihrem Projekt und geben Sie den folgenden Befehl ein, um unser Image zu erstellen:

 docker build .

Am Ende weist Docker an, im selben Verzeichnis nach einer Dockerfile zu suchen. Hätten Sie die Datei an einem anderen Ort gehabt, hätten wir den Pfad zu dieser Datei angegeben. Docker ruft dann die dafür erforderlichen Images vom Docker Hub ab, um Ihr Image zu erstellen.

Verwendung von Docker Compose

Aus den Docker-Dokumenten: Compose ist ein Tool zum Definieren und Ausführen von Multi-Container-Docker-Anwendungen. Mit Compose verwenden Sie eine YAML-Datei, um die Dienste Ihrer Anwendung zu konfigurieren. Dann können Sie mit einem einzigen Befehl alle Dienste aus Ihrer Konfiguration erstellen und starten.

  • Docker Compose unter Linux installieren

Da unser Projekt in Zukunft viele Dienste benötigen wird, ist es besser, eine Multi-Container-Umgebung dafür zu erstellen. Zum Beispiel könnten wir einen Container für unser Frontend, einen weiteren für eine Datenbank und einen weiteren für ein Backend benötigen, wenn wir auf eine Microservice-Architektur umstellen. Wir werden eine docker-compose-Datei erstellen, die die verschiedenen Dienste und Container definiert, die unser Projekt benötigen wird.

Erstellen Sie eine Datei mit dem Namen docker-compose.yml

version: "3"
services:
  ddda:
    build:
      context: .
    ports:
      - "8000:8000"
    volumes:
      - ./app:/app
    command: >
      sh -c "python manage.py runserver 0.0.0.0:8000"

Beachte das YAML-Dateiformat!!! Wir haben einen Dienst namens ddda (Django Docker Dev App).

Wir sind jetzt bereit, unseren Service zu erstellen:

docker-compose build

Nach einem erfolgreichen Build sehen Sie: Erfolgreich markiert djangodockerdevapp_ddda:latest

Es bedeutet, dass unser Image djangodockerdevapp_ddda:latest heißt und unser Dienst ddda heißt.

Beachten Sie nun, dass wir unser Django-Projekt noch nicht erstellt haben! Wenn Sie das obige Verfahren erfolgreich durchgeführt haben, dann Glückwunsch, Sie haben die Docker-Umgebung für Ihr Projekt eingerichtet! Als Nächstes starten Sie Ihre Entwicklung, indem Sie Folgendes tun:

Erstellen Sie das Django-Projekt:

 docker-compose run ddda sh -c “django-admin.py startproject app .”

Um Ihren Container auszuführen:

docker-compose up

Besuche dann http://localhost:8000/

Migrationen erstellen

$ docker-compose exec ddda python manage.py migrate

Von nun an wirst du Django-Befehle wie den obigen Befehl ausführen, indem du deinen Befehl nach dem Dienstnamen ddda hinzufügst.

Das war’s vorerst. Ich weiß, es ist einfach und es gibt viele Funktionen, die wir noch nicht behandelt haben, wie zum Beispiel eine Datenbank, aber das ist ein Anfang!

Das Projekt ist hier auf GitHub verfügbar.

Mehr über Docker:

  • Docker-Images/-Container exportieren und importieren
  • Installiere die Harbor Docker Image Registry auf CentOS/Debian/Ubuntu
  • Wie man lokale Kubernetes-Cluster in Docker ausführt