So verwenden Sie Docker-Compose, um Django-Anwendungen offline bereitzustellen

Unsere Intranetumgebung muss eine CMS-ähnliche Anwendung bereitstellen, die über Funktionen wie CRUD einiger Tabellen, Datenexport und Personalberechtigungsverwaltung verfügt. Da ich der Meinung bin, dass Django für diese Art von Arbeit gut geeignet ist und der Entwicklungsaufwand nicht groß ist, habe ich Django als Entwicklungsgrundlage gewählt. Die Entwicklungsfunktion ist relativ einfach und fast alle der oben genannten Funktionen werden mithilfe von Plug-Ins wie xadmin erreicht. Es gibt jedoch ein Problem, das wir nicht umgehen können, nämlich die Bereitstellung in einer Intranetumgebung, in der Tools wie pip nicht verwendet werden können. Glücklicherweise ist im Intranet ein Yum-Server verfügbar. Daher haben wir beschlossen, Docker auf dem Intranetserver zu installieren und dann den Container der Entwicklungsumgebung zur Bereitstellung in die Produktionsumgebung zu kopieren. Hier sind die wichtigsten Schritte:

1. Installieren Sie Docker-ce für die Entwicklungsumgebung
2. Installieren Sie Docker-Compose für die Entwicklungsumgebung
3. Konfigurieren der Entwicklungsumgebung
4. Container speichern
5. Installieren Sie Docker-ce und Docker-Compose für die Produktionsumgebung
6. Senden Sie die Containerdatei und führen Sie sie aus

Hinweis: Meine Entwicklungsumgebung hier ist Ubuntu 18.04 und die Produktionsumgebung ist Centos 7.2. Sollten Sie eine andere Umgebung nutzen, prüfen Sie bitte selbst die Unterschiede und verwenden Sie die für Ihr System passenden Befehle.

Installieren Sie Docker-ce für die Entwicklungsumgebung

Docker und Docker-Compose sind die Kernpunkte dieser Bereitstellung. Ich werde versuchen, den Django-Anwendungsteil zu reduzieren. Docker ist für den zugrunde liegenden Teil der Containervirtualisierung verantwortlich. Docker-Compose ist ein Container-Orchestrierungstool. Damit müssen wir keine Shells schreiben, um Container zu verbinden. Lassen Sie uns zuerst Docker-ce installieren. Hier beziehen wir uns hauptsächlich auf die offizielle Dokumentation von Docker. Wenn das, was ich geschrieben habe, nicht detailliert genug ist oder veraltet ist, können Sie auf der offiziellen Website maßgeblichere und aktuellere Dokumente einsehen.

Deinstallieren Sie alte Versionen

Vor der Installation müssen Sie die alte Version von Docker deinstallieren. Wenn Sie ein neues System verwenden, können Sie diesen Schritt überspringen.

$ sudo apt entfernen docker docker-engine docker.io containerd runc

Installieren Sie das verwendete Apt-Repository

Apt-Paketindex aktualisieren

$ sudo apt-Update

Erlauben Sie apt, über https auf das Repository zuzugreifen

$ sudo apt installieren \
  apt-transport-https \
  CA-Zertifikate \
  Locke \
  gnupg-agent \
  Software-Eigenschaften-allgemein

Fügen Sie den offiziellen GPG-Schlüssel von Docker hinzu

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg |

Docker-Repository hinzufügen

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

Installieren Sie Docker-ce

Nach den oben genannten Vorbereitungen ist die Installation von Docker-ce einfach. Wenn Sie mit Ubuntu vertraut sind, können Sie es schnell installieren.

$ 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.

$ sudo systemctl Docker starten
$ sudo systemctl Docker aktivieren

Installieren Sie Docker-Compose für die Entwicklungsumgebung

Nachdem Docker-ce installiert ist, ist Docker-Compose einfach zu verwenden. Wenn Sie Linux oder eine andere Plattform verwenden, können Sie die kompilierte Binärdatei von Docker-Compose direkt herunterladen und verwenden.

Nach dem Herunterladen ändern Sie die Berechtigungen und fügen Sie die ausführbare Datei hinzu

$ sudo chmod +x /usr/local/bin/docker-compose

Abschließend können Sie die Versionsnummer von Docker-Compose überprüfen, um festzustellen, ob die Installation erfolgreich war.

$ docker-compose --version
Docker-Compose-Version 1.24.0-rc1, Build 0f3d4dda

Konfigurieren der Entwicklungsumgebung

Die Entwicklungsumgebung ist hier die Django-Umgebung. Zur Vereinfachung der Demonstration versuche ich, ein neu erstelltes Django-Projekt zu verwenden.

Erstellen Sie ein neues Django-Projekt

Erstellen Sie ein neues Django-Projekt und erstellen Sie zunächst einen Ordner der obersten Ebene, um die Projektdateien in diesem Ordner abzulegen. Die Verzeichnisstruktur sieht ungefähr so ​​aus:

--Projekt
 --Dockerfile
 --docker-compose.yml
 --meine Seite
  --manage.py
  --requirements.txt

Erstellen Sie zunächst einen Projektordner

$ mkdir-Projekt

Erstellen Sie dann ein neues Django-Projekt, oder kopieren Sie ein vorhandenes Projekt.

$ django-admin.py startprojekt meinesite

Generieren Sie die Datei requirements.txt

Im vorherigen Schritt gibt es bereits ein Django-Projekt namens mysite. Angenommen, wir legen requirements.txt in diesen Ordner und der Inhalt lautet wie folgt:

$ cat-Anforderungen.txt

entschärftxml==0.5.0
diff-match-patch==20181111
Django==2.1.7
django-crispy-forms==1.7.2
django-formtools==2.1
django-import-export==1.2.0
django-reversion==3.0.3
et-xmlfile==1.0.1
Zukunft == 0.15.2
httplib2==0.9.2
jdcal == 1,4
odfpy==1.4.0
openpyxl==2.6.0
pytz==2018.9
PyYAML==3.13
sechs==1.10.0
tablib==0.12.1
unicodecsv==0.14.1
xadmin==0.6.1
xlrd==1.2.0
xlwt==1.3.0
mysqlclient==1.4.2

Dies sind natürlich die Abhängigkeiten, die mein Projekt benötigt. Ihre Abhängigkeiten können sich von meinen unterscheiden.

Erstellen Sie ein neues Dockerfile

Nachdem wir nun das Projekt und seine Abhängigkeitsdateien haben, besteht der nächste Schritt darin, ein Docker-Image der laufenden Umgebung für unser Django-Projekt zu erstellen. Erstellen Sie zunächst eine Docker-Datei, um das Docker-Image zu erstellen. Erstellen Sie im Projektordner ein neues Dockerfile mit folgendem Inhalt:

$ Katze Dockerdatei

VON python:3.6.8
ENV PYTHONUNBUFFERED 1

Führen Sie mkdir /config aus.
HINZUFÜGEN /mysite/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/meinesite

Lassen Sie mich diese Datei kurz erklären.

VON python:3.6.8

Das Basisimage, das ich hier verwende, ist Python: 3.6.8. Das Basisimage ist Ubuntu, mit dem ich besser vertraut bin. Wenn Sie mit Alpine besser vertraut sind, können Sie auch Alpine verwenden, das viel kleiner ist.

ENV PYTHONUNBUFFERED 1

Mit dem Schlüsselwort „Env“ können Sie Umgebungsvariablen für jedes Betriebssystem erstellen.

ENV PYTHONUNBUFFERED 1

Wenn Sie es beispielsweise zum Speichern Ihrer Django-Schlüssel verwenden, könnten Sie Folgendes schreiben:

ENV DJANGO_SECRET_KEY l!fafmjcqyn+j+zz1@2@wt$o8w8k(_dhgub%41l#k3zi2m-b%m

Verwenden Sie es in Ihrem Code wie folgt:

Betriebssystem importieren
SECRET_KEY = os.environ['DJANGO_SECRET_KEY']

Wie der Name schon sagt, führt RUN Befehle im Container aus. Hier erstellt der RUN-Befehl zwei Ordner, /config und /src, und installiert die Abhängigkeitsumgebung von Python.

Führen Sie mkdir /config aus.
Führen Sie den Befehl mkdir /src aus.
Führen Sie den Befehl „pip install -r /config/requirements.txt“ aus.

HINZUFÜGEN

HINZUFÜGEN /mysite/requirements.txt /config/

Fügen Sie lokale Dateien zum WORKDIR des Containers hinzu

ARBEITSVERZEICHNIS /src/meinesite

Es gibt den Standardpfad für alle nachfolgenden Befehle an, die im Container ausgeführt werden sollen. Die auszuführenden Befehle sind später in der Docker-Compose-Datei zu sehen.

Erstellen Sie ein neues Docker-Compose-Skript

Docker-Compose kann zum Verwalten mehrerer Container verwendet werden. Das manuelle Hinzufügen umfangreicher Parameter zum Ausführen von Containern und zum Verbinden von Containern kann jetzt von Docker-Compose übernommen werden. Der Inhalt meiner docker-compose.yml ist wie folgt:

$ Katze docker-compose.yml

Version: '3'
Leistungen:
  db:
   Bild:mysql:5.7
   Containername: mysite_db
   Häfen:
    - „3306:3306“
   Umfeld:
    MYSQL_ROOT_PASSWORD: meineSite
    MYSQL_DATABASE: meine Site
    SPRACHE: C.UTF-8
  Webseite:
   bauen: .
   Containername: mysite_web
   Befehl: bash -c "python manage.py makemigrations && python manage.py migrate && python manage.py runserver 0.0.0.0:8000"
   hängt ab von:
    -db
   Bände:
    - ./meinesite:/src
   Neustart: immer
   Häfen:
    - "8002:8000"

Lassen Sie mich diese Docker-Compose-Datei kurz erklären.

Version: '3'

Bezieht sich auf die Version von Docker-Compose. Verschiedene Versionen unterstützen leicht unterschiedliche Konfigurationselemente. Von Diensten verwaltete Dienste. In unserem Beispiel gibt es zwei Dienste: db und web. Ich werde die Konfigurationselemente in den beiden Diensten separat erklären:

Das Image verwendet direkt das vorhandene Image vom Docker Hub oder lokal. Dieses verwendet MySQL5.7. Containername gibt den Namen des Containers an. Ports gibt die Portzuordnung des Containers zum Host an. Der Port vorne ist der Host-Port und der Port hinten ist der Container-Port. Umgebung gibt die Umgebung an, in der der aktuelle Dienst ausgeführt wird. Einzelheiten zur Umgebung finden Sie in der Beschreibung des aktuellen Images. Wir können diejenigen konfigurieren, die unterstützt werden. In diesem Fall geben wir das MySQL-Root-Passwort, die Standarddatenbank und den Datenbankzeichensatz an. web:build kompiliert das Image. Dabei wird das Dockerfile im aktuellen Ordner verwendet. command ist der Befehl, der nach dem Start des Containers ausgeführt wird. depends_on ist der Dienst, von dem der aktuelle Container abhängt. Das heißt, der Dienst in der Abhängigkeit muss erfolgreich gestartet werden, bevor der aktuelle Dienst gestartet werden kann. volumes ist das Volume, das vom aktuellen Container gemountet werden soll. Der vordere Teil bezieht sich auf das Host-Verzeichnis, und der hintere Teil ist das Container-Verzeichnis. restart gibt die Neustartstrategie des Containers an. Im aktuellen Fall wird er immer wieder neu gestartet, wenn ein Fehler auftritt. Hier wird der Port 8000 des Containers dem Port 8002 des Hosts zugeordnet und der Zugriff auf den Webdienst erfolgt über Port 8002.

Konfigurieren des Django-Projekts

Ändern Sie nun die Datei settings.py des Mysite-Projekts entsprechend der aktuellen Containerumgebung.

$ vim meinesite/meinesite/einstellungen.py

Suchen Sie in der Datei nach dem Abschnitt ALLOW_HOSTS und fügen Sie dort „web“ mit folgendem Inhalt hinzu:

ALLOW_HOSTS = [
  ...
  'Netz'
]

Ändern Sie dann den DATABASES-Teil in settings.py und ändern Sie die Parameter in die Parameter der MySQL-Dienstdatenbank. Der Inhalt ist wie folgt:

DATENBANKEN = {
  'Standard': {
    'ENGINE': 'django.db.backends.mysql',
    'NAME': 'meine Site',
    'BENUTZER': 'root',
    'PASSWORT': 'meine Site',
    'HOST': 'db'
  }
}

Die MySQL-Verbindungsparameter werden hier in der Umgebung des Datenbankteils der Datei docker-compose.yml definiert. Es ist erwähnenswert, dass der Parameter HOST-Wert db ist. Nachdem Docker-Compose die Container gestartet hat, werden diese Container verbunden. Die Container können sich gegenseitig über den Dienstnamen anpingen, genau wie über den Domänennamen, sodass „HOST“ hier direkt mit „db“ ausgefüllt werden kann.

Erstellen Sie das Projekt mit Docker-Compose

Nach den oben genannten Bemühungen sind wir im Grunde bereit. Wir können unser Image erstellen. Hier gibt es zwei Dienste. DB muss nur das lokale Image zur Laufzeit herunterladen oder verwenden, und Web muss auch mit Dockerfile erstellt werden.

$ Docker-Compose-Build

Nach einer Weile des Herunterladens bzw. Erstellens wird die Information angezeigt, dass das Image erfolgreich erstellt wurde.

Ausführen des Projekts und Testen

Nach Abschluss des Builds verfügen wir über ein Image des Webdienstes. Wir verwenden nun Docker-Compose, um den Dienst zu starten.

$ docker-compose up -d

Dieser Vorgang kann je nach Netzwerkgeschwindigkeit auch eine Weile dauern. Dabei wird das MySQL-Image heruntergeladen, ein Container basierend auf den Datenbank- und Web-Images erstellt und der Container ausgeführt. Nach Abschluss können Sie Docker-Compose PS und Docker-Compose Images verwenden, um die von uns generierten Container und Bilder anzuzeigen

$ Docker-Compose ps

Name Befehl Status Ports       
---------------------------------------------------------------------------------------------------
mysite_db docker-entrypoint.sh mysqld Hoch 0.0.0.0:3306->3306/tcp, 33060/tcp
mysite_web bash -c python manage.py m … Hoch 0.0.0.0:8002->8000/tcp

$ Docker-Compose-Bilder

Container-Repository-Tag Bild-ID Größe
--------------------------------------------------------
mysite_db mysql 5.7 e47e309f72c8 355 MB
mysite_web mysite_web neueste 3989acbcc3c9 938 MB

Sie können Docker-Compose auch verwenden, um Dienste zu stoppen und zu starten. Eine genauere Verwendung finden Sie in der offiziellen Dokumentation.

$ Docker-Compose starten
Datenbank wird gestartet ... fertig
Web wird gestartet ... fertig

$ Docker-Compose-Stopp
mysite_web wird gestoppt … fertig
mysite_db wird gestoppt ... fertig

Sie können sehen, dass die Reihenfolge des Stoppens und Startens der Dienste hier regulär ist. Beim Starten wird zuerst der abhängige Dienst gestartet und dann der Dienst, der davon abhängt. Beim Starten des Dienstes ist es genau umgekehrt. Nachdem der Dienst normal ausgeführt wird, können Sie auf den Browser zugreifen, um zu testen, ob der Dienst normal gestartet wird.

Container speichern

Wenn mit dem Dienst alles normal ist, müssen wir den aktuellen Container speichern und die Bereitstellung auf der neuen Plattform vorbereiten. Hinweis: Verwenden Sie „Speichern“, um das Image zu speichern. „Speichern“ enthält Informationen wie den Verbindungsstatus zwischen Containern. Wenn Sie „Exportieren“ verwenden, um das Image in die Produktionsumgebung zu exportieren, können Sie „docker-compose“ nicht verwenden, um den Dienst wiederherzustellen.

$ docker save -o mysql.tar mysql:5.7
$ docker save -o meinesite.tar meinesite_web:neueste

Wenn der obige Befehl erfolgreich ausgeführt wird, werden zwei TAR-Dateien im aktuellen Verzeichnis zusammen mit den Dateien Dockerfile und docker-compose.yml im Projektverzeichnis generiert und können auf die Produktionsmaschine migriert werden.

Installieren Sie Docker-ce und Docker-Compose für die Produktionsumgebung

Da die Produktionsumgebung CentOS ist, können Sie yum direkt zur Installation verwenden

$ sudo yum installiere docker-ce

Stellen Sie Docker-Compose nach der erfolgreichen Installation auf dem Produktionsserver bereit, indem Sie auf die Entwicklungsumgebung verweisen.

Senden Sie die Containerdatei und führen Sie sie aus

Verwenden Sie scp oder andere Tools, um mysql.tar, mysite.tar, Docker-compose.yml und Projektordner an den Produktionsserver zu senden, und suchen Sie einen geeigneten Ordner zum Speichern dieser Dateien, wobei die ursprüngliche Verzeichnisstruktur beibehalten wird. Lassen Sie uns zunächst die beiden Bilder auf dem Produktionsserver wiederherstellen

$ docker load -i mysql.tar
$ docker load -i mysite_web.tar

Warten Sie einen Moment, bis die Ausführung abgeschlossen ist. Sie sehen dann, dass der aktuelle Server bereits über diese beiden Bilder verfügt.

REPOSITORY TAG BILD ID ERSTELLT GRÖSSE
mysite_web latest 3989acbcc3c9 vor 2 Tagen 983MB
mysql 5.7 e47e309f72c8 vor 3 Wochen 372 MB

Bevor wir den Build-Container ausführen, müssen wir eine einfache Änderung an docker-compose.yml vornehmen. Möglicherweise ist Ihnen aufgefallen, dass der Produktionsserver kein Internet hat, sodass wir das Image nicht mehr erstellen können. Wir haben auch das Image der Entwicklungsumgebung so kopiert, wie es ist, sodass der Webdienst dieses Mal vom Image aus ausgeführt werden kann. Der Inhalt ist wie folgt:

Version: '3'
Leistungen:
  db:
   ...
  Webseite:
   Bild: mysite_web:latest
   ...

Löschen Sie einfach das Build-Element im Web und fügen Sie ein Bildelement hinzu. Der Inhalt ist das Bild, das wir kopiert haben. Später können wir den Container erstellen und den Dienst starten.

$ docker-compose up -d

Ergebnis

Name Befehl Status Ports       
----------------------------------------------------------------------------------------
mysite_web bash -c python manage.py m … Hoch 0.0.0.0:8002->8000/tcp      
mysite_db docker-entrypoint.sh mysqld Hoch 0.0.0.0:3306->3306/tcp, 33060/tcp

Öffnen Sie den Browser erneut, um zu sehen, ob er normal startet.

Nachtrag

Es gibt noch viele weitere Einsatzmöglichkeiten für Docker-Compose und ich werde in zukünftigen Projekten ausführlichere Einführungen in andere Bereiche geben. Vielen Dank, dass Sie sich meine Arbeit ansehen. Ich hoffe, sie hilft Ihnen ein wenig.

Referenzdokumentation

Holen Sie sich Docker CE für Ubuntu
Installieren Sie Docker Compose

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.