Schnelle Einführung in Docker-Container für Django-Entwickler

Ursprünglicher Autor: Piotr Maliński
  • Übersetzung


Die Entwicklung eines solchen Projekts als Cashback-Service beinhaltet die Nutzung verschiedener Dienste, die für einen normalen Laptop nicht typisch sind, auch wenn es sich um einen Entwickler-Laptop handelt. Postgresql, Redis, Sellerie und so weiter. Der Wunsch nach einer komfortablen Entwicklungs- und Testumgebung führte dazu, dass wir eine Art Virtualisierungs- / Isolierungssystem verwenden mussten. Alternativ wird Vagrant seit einiger Zeit verwendet, ist aber immer noch weit verbreitet und unsere Suche nach dem besten Weg hat im Moment zu Docker geführt.

Docker- Eine Plattform zum Starten von Anwendungen in isolierten Containern. Durch die Verwendung von Containern unter Linux kann Software vom zugrunde liegenden System isoliert werden. Im Gegensatz zu Virtualbox ist der für die Gerätevirtualisierung erforderliche Systemaufwand ausgeschlossen. Docker unterstützt Sie bei der Entwicklung und Bereitstellung von Webanwendungen und -diensten. Mal sehen, wie das passiert.

Warum brauche ich einen Hafenarbeiter?
Docker kann auf verschiedene Arten verwendet werden. Es kann Dienste im Hintergrund bereitstellen, z. B. PostgreSQL mit einer bestimmten Version. Unsere Docker-Anwendung kann in Docker platziert werden, sodass wir Bilder ähnlicher Container verwenden können, um unsere Anwendung in der Produktion bereitzustellen.

Für Python-Entwickler kann Docker für jede Anwendung als virtualenv bezeichnet werden. Dies kann entweder ein Python-Interpreter oder ein Server sein. Dies ist sehr praktisch, wenn Sie neue Versionen testen oder veraltete Anwendungen auf Ihrem Server ausführen möchten.

Docker installieren Docker
ist in Repositorys auf verschiedenen Linux-Distributionen verfügbar. Benutzer von OSX und MS Windows können VirtualBox verwenden, auf dem das Linux-System installiert ist, um Docker auszuführen.

Um die neueste Version zu installieren, verwende ich PPA für Ubuntu. Wenn Docker installiert ist, können Sie sich der Docker-Gruppe hinzufügen, sodass Sie sudo in Zukunft nicht mehr verwenden müssen.

Erste Container
Wenn Docker bereit ist, können wir viele Container von registry.hub.docker.com aus starten , zum Beispiel Python. Um diesen Container auszuführen, gehen Sie einfach wie folgt vor:
docker run -it --rm python:3.4


Wenn Sie Docker starten, werden mehrere Dateien heruntergeladen. Wenn der Vorgang abgeschlossen ist, erhalten wir die Standardkonsole des Python-Interpreters. Der Befehl -it startet den Container interaktiv und bindet ihn zur Interaktion an die Konsole. --rm löscht den aktuellen Container nach dem Verlassen. "Python" ist der Name der Quelle für den Container. Nach „:“ sehen wir ein Tag, das normalerweise die Version anzeigt - in diesem Fall die Version von Python im Container.

Wir können auch das Standardverhalten des Containers ändern, zum Beispiel unser eigenes Skript ausführen. Um einen Befehl über die Befehlszeile zu verwenden, fügen Sie einfach Folgendes hinzu:

docker run -it --rm python:3.4 ls


Wenn unser Container gestartet wird, wird der Befehl "ls" in ihm gestartet, der alle Dateien und Filter im Hauptverzeichnis anzeigt.

Dockerfile
Das Dockerfile enthält das „Rezept“ für unseren Container. Wenn wir ein Skript in Python ausführen möchten, müssen wir Folgendes schreiben:

FROM python:3.4
ADD ./test.py /
RUN ls -al
CMD python test.py


FROM verweist auf den Basiscontainer, in diesem Fall auf das Python 3.4-Image. Weiterhin können wir ADD , RUN, ENV Befehle verwenden, um den Container zu konfigurieren. Das RUN- Team führt Aufgaben aus, wenn der Container erstellt wird. Der CMD- Befehl wird zu Beginn des Container-Starts ausgeführt. Image-Erstellungsvorgänge werden zwischengespeichert und überspringen die folgenden Versionen (der Befehl RUN aus dem Beispiel startet die Erstellung des ersten Builds, jedoch nicht des zweiten).

Im Terminal können wir folgendes schreiben:

docker build --tag=foo .
docker run  -it --rm foo


Django Dockerfile
django-ckeditor enthält eine Demo-Anwendung, die über manage.py und runserver gestartet werden kann. Lassen Sie uns versuchen, eine Dockdatei zu erstellen, die ein Image dieser Anwendung erstellt:

FROM python:3.4
MAINTAINER Piotr Maliński 
ADD . /ckeditor
ENV DJANGO_SETTINGS_MODULE ckeditor_demo.settings
RUN pip install -r /ckeditor/ckeditor_demo_requirements.txt
RUN pip install /ckeditor
RUN python /ckeditor/manage.py validate
RUN python /ckeditor/manage.py collectstatic --noinput
CMD python /ckeditor/manage.py runserver 0.0.0.0:8080


Ich verwende hier Python 3.4. Der gesamte Code aus dem Repository wird dem Ordner "ckeditor" des Containers hinzugefügt. Ich setze auch die Umgebungsvariable DJANGO_SETTINGS_MODULE, füge Abhängigkeiten hinzu und den Editor selbst. Weitere Validierung, Erfassung der Statik und am Ende von CMD den Server starten. Es ist auch praktisch, den Server außerhalb des Containers zugänglich zu machen. Dafür wird er mit einer IP-Adresse von 0.0.0.0 ausgeführt

dockebuild --tag=django-ckeditor .
dockerun -it --rm  --publish=192.168.0.110:8080:8080 django-ckeditor


Mit der Option --publish können öffentliche IP / Port-Adressen von einem ausgeführten lokalen Container einem lokalen Container zugeordnet werden. In diesem Beispiel ist 192.168.0.110 der Host-Port. Auf den öffentlichen Port kann über 8080 von meinem Localhost aus zugegriffen werden. Ohne die Veröffentlichungsoption kann auf den Server nur über die laufende IP-Adresse des Containers zugegriffen werden.
Die von mir gezeigte Dockerfile-Konfiguration ist nicht perfekt und funktioniert nur mit SQLite-Datenbanken. Mit Docker können Sie verschiedene Dienste in verschiedenen Containern ausführen. Versuchen wir zum Beispiel, eine PostgreSQL-Datenbank in einem zweiten Container zu verwenden.
Führen wir also die PostgreSQL-Instanz aus:

docker run -d postgres:9.4


Der Container startet im Hintergrund und wir können seinen Status und Namen mit dem docker ps-Befehl überprüfen . Die Standardnamen sind zufällig, zum Beispiel "clever_ptolemy". Jetzt haben wir eine Datenbank auf diesem Server erstellt, aber zuerst benötigen wir eine IP-Adresse. Wir können es von Docker Inspect INSTANCE_NAME erhalten , das eine Liste der Variablen im Container anzeigt , einschließlich der IP-Adresse. Außerdem können wir eine Datenbank erstellen:

createdb -h IP_ADDRESS DATABASE_NAME -U postgres


Die Datenbank wurde erstellt und jetzt können wir sie im Anwendungscontainer konfigurieren. Mit Docker können Sie dies mithilfe von Umgebungsvariablen tun. Für Django können Sie dj_database_url :
from os import environ verwenden

import dj_database_url
DATABASES = {'default': dj_database_url.parse(environ.get('DATABASE', 'postgres:///'))}


Jetzt müssen wir env eine Variable mit dem Datenbanknamen an den Container übergeben, damit es funktioniert. Es könnte so gemacht werden:

docker run -it --rm --link=POSTGRES_INSTANCE_NAME:OUR_NAME -e DATABASE=postgres://postgres@OUR_NAME/DATABASE_NAME --publish=192.168.0.110:8080:8080 django-ckeditor


Den Namen der Datenbankinstanz erhalten wir durch Ausführen des Befehls "docker ps" in der Konsole. "OUR_NAME" ist eine Verknüpfung, die wir später im Wert -e verwenden können. In meinem Fall sah es so aus:

docker run -it --rm --link=clever_ptolemy:db -e DATABASE=postgres://postgres@db/ckeditor --publish=192.168.0.110:8080:8080 django-ckeditor python /ckeditor/manage.py syncdb 
docker run -it --rm --link=clever_ptolemy:db -e DATABASE=postgres://postgres@db/ckeditor --publish=192.168.0.110:8080:8080 django-ckeditor


Der Befehl syncdb wird zuerst ausgeführt und erstellt Tabellen in der Datenbank. Als nächstes startet der Entwicklungsserver.

Feigenwerkzeug
Das oben beschriebene einfache Beispiel erfordert viele Namen und Verknüpfungen. Um den Prozess zu vereinfachen, gibt es verschiedene Tools wie Abb. In der YAML-Datei (fig.yml) können wir alle erforderlichen Schritte und Links angeben:

ckeditor:
  build: .
  command: python /ckeditor/manage.py runserver 0.0.0.0:8080
  links:
   - db
  ports:
   - "8080:8080"
db:
  image: postgres:9.4


Als Nächstes können wir mit dem Befehl fig build erstellen und c fig up ausführen, um die Funktionsweise der Anwendung anzuzeigen. Wir haben mehrere Labels und können syncdb ausführen und fig run NAME COMMAND verwenden , um zu helfen , wobei Name der Instanzname fig.yml ist. Nach dem Start von fig können Sie die Liste der Container mit dem Befehl "docker ps" überprüfen.

Weitere Informationen zur fig.yml-Syntax finden Sie auf der Anwendungsseite. Es gibt auch ein Django-Tutorial , das eine andere Möglichkeit zum Konfigurieren von Postgres bietet.

Jetzt auch beliebt: