7 days of WordPress plugins, themes & templates - for free!* Unlimited asset downloads! Start 7-Day Free Trial
Advertisement
  1. Code
  2. Web Development

Einfache Bereitstellung von Redis-gestützten Web-Apps mit Docker

Scroll to top
Read Time: 23 mins

German (Deutsch) translation by Władysław Łucyszyn (you can also view the original English article)

Die Leute, die Docker machen, beschreiben es gerne mit einer Metapher für ein ziemlich altes Stück Technologie: den Versandcontainer.

Obwohl wir heute noch nicht einmal an sie denken oder sie bemerken, war der Versandbehälter zu seiner Zeit tatsächlich ein ziemlich revolutionäres Stück Technologie. Unabhängig von der Form oder Größe des Originalartikels konnte der Eigentümer des Bootes/Flugzeugs/LKWs/was-haben-du-mit einem standardisierten Behälter leicht herausfinden, wie viele Ressourcen er zuweisen musste.

Docker versucht, diesen Komfort in die Serverwelt zu bringen. Es ist die natürliche Erweiterung von Tools wie Vagrant, die es Ihnen ermöglichen, dieselbe virtuelle Maschine, die Sie in der Entwicklung verwenden, in Produktionsumgebungen bereitzustellen. Virtuelle Maschinen im Vagrant-Stil sind großartig, aber sie sind schwer. Ihre Ausführung erfordert viele Ressourcen, von denen viele überflüssig sind: Ein Vagrant-Image lädt eine komplett neue Linux-Kopie in eine vorhandene. Wäre es nicht besser, wenn Sie den Komfort und die Einheitlichkeit von Vagrant nutzen könnten, ohne das gesamte Betriebssystem neu laden zu müssen? Genau das macht Docker.

Einführung

In diesem Tutorial werde ich Sie durch den gesamten Docker-Workflow führen. Wir gehen zuerst die Schritte durch, um eine einfache Python-Webanwendung zu erhalten, die einige Python-Abhängigkeiten aufweist und für die Persistenz von einer Redis-Datenbank abhängt. Dann installieren wir Docker und installieren alle Anforderungen der Web-App (Redis-, Python- und Python-Abhängigkeiten) in einem Docker-Image. Wir verwenden dann dieses Image und stellen es auf einem anderen Server bereit.

Wir werden nur eine Spielzeug-Beispiel-App bereitstellen, aber die Schritte zum Bereitstellen Ihrer eigenen echten Apps sind sehr ähnlich.

Um zu beginnen, benötigen Sie entweder eine Linux-Box, auf der eine aktuelle Version von Ubuntu ausgeführt wird, oder eine virtuelle Maschine, auf der eine aktuelle Version von Ubuntu ausgeführt wird. Wenn Sie das Tutorial vollständig befolgen und die App bereitstellen möchten, benötigen Sie auch eine zweite Maschine (oder eine zweite virtuelle Maschine) für die Bereitstellung.

Docker installieren

Der erste Schritt besteht darin, Docker selbst zu installieren. Docker befindet sich in einer sehr schnellen Entwicklung, daher ändert sich der einfachste Weg, es zu installieren, oft recht schnell. Sehen Sie sich den Abschnitt "Erste Schritte" von Docker an, wenn Sie die neuesten Entwicklungen ausprobieren möchten.

Befolgen Sie andernfalls die folgenden Schritte, und wir richten eine auf Vagrant-VMs basierende Installation von Docker ein, die auf allen gängigen Betriebssystemen funktioniert. Besuchen Sie zuerst die Website von Vagrant und installieren Sie die neuesten Vagrant- und VirtualBox-Versionen für Ihr Betriebssystem.

Sobald Vagrant installiert ist, erstellen Sie einen neuen Ordner, öffnen Sie dort eine Eingabeaufforderung und gehen Sie wie folgt vor:

Vagrant hat sich gerade darum gekümmert, eine virtuelle Maschine mit Ubuntu 12.04 für Sie zu erstellen, und Sie werden jetzt per SSH in die Eingabeaufforderung geleitet. Wir können jetzt den Ubuntu-Installationsanweisungen von Docker folgen. Überprüfen Sie die Website, ob sich seit dem Schreiben Änderungen ergeben haben, aber höchstwahrscheinlich können Sie die folgenden Befehle direkt in das Terminal einfügen:

Sie werden beim Neustart der VM zur Eingabeaufforderung Ihres lokalen Computers zurückgeleitet. Warten Sie also einen Moment und führen Sie einen weiteren Vorgang durch:

... zu SSH zurück in Ihre VM. Nachdem die Voraussetzungen von Docker erfolgreich installiert wurden, müssen wir Docker selbst installieren. Fügen Sie den folgenden Befehl ein:

... das ein einfaches Docker-Installationsskript von der Docker-Site holt und es ausführt. Docker sollte nun erfolgreich installiert sein, also fangen wir an, damit zu spielen.

Erste Schritte mit Docker

Sobald apt-get seine Magie beendet hat, gehen Sie wie folgt vor:

... um zu überprüfen, ob die Installation erfolgreich war. Wenn es funktioniert, lädt Docker ein Ubuntu Docker-Image herunter und nach einiger Zeit landen Sie bei einer Root-Eingabeaufforderung. Fühlen Sie sich frei, ein wenig herumzuspielen, Sie werden feststellen, dass Sie sich in einer Umgebung befinden, die vollständig von Ihrem Host-Rechner getrennt ist. Sie haben wahrscheinlich das root- und #-Zeichen in der Eingabeaufforderung bemerkt. Sie werden als Root-Benutzer in einer neuen virtuellen Umgebung ausgeführt. Wenn Sie einen users-Befehl ausgeben, sehen Sie, dass Ihre anderen Benutzer nicht mehr vorhanden sind.

Es lohnt sich, sich eine Minute Zeit zu nehmen, um zu erklären, was der docker-Befehl, den Sie gerade eingegeben haben, getan hat und wie diese Magie passiert ist.

Der run Command

Das Docker-Dienstprogramm scheint sich stark von der Befehlszeilenschnittstelle von git inspirieren zu lassen und verwendet daher Unterbefehle. In diesem Fall haben wir den Unterbefehl run ausgeführt. Der Befehl run erfordert zwei Argumente: ein Bild und einen Befehl.

Es ist auch schlau. Wenn Sie also (wie in diesem Fall) dieses Image nicht installiert haben, fragt es das zentrale Docker-Repository ab und lädt eines für Sie herunter. Hier haben wir es angewiesen, ein ubuntu-Image auszuführen und Docker informiert, dass es /bin/bash in diesem Image starten soll. Die -t und -i weisen Docker an, ein TTY zuzuweisen und im "interaktiven Modus" auszuführen, mit anderen Worten, um eine Eingabeaufforderung zu erhalten. Der Grund dafür ist, dass Docker etwas anders funktioniert als andere Virtualisierungssoftware, die Sie vielleicht kennen. Docker-Images "booten" nicht, sie laufen einfach. Sie verwenden die vorhandene Linux-Installation, sodass ein Docker-Image sofort gestartet werden kann. In gewisser Weise ist Docker dem chroot-Befehl von Linux näher als den traditionelleren Virtualisierungstools wie VMWare oder VirtualBox.

Es gibt einige andere wichtige Unterschiede zu Standard-Virtualisierungstools. Machen wir ein kurzes Experiment, erstellen eine Datei und drucken deren Inhalt aus:

Wenn Sie jetzt tun:

Es wird gerne ausgedruckt:

Soweit so gut, unser albernes Experiment funktioniert genau wie erwartet. Beenden wir Docker und kehren wir zur Eingabeaufforderung unseres Hostcomputers zurück:

Wenn Sie Docker mit dem gleichen Befehl neu starten, den Sie zuvor verwendet haben:

... Sie werden feststellen, dass sich die Dinge nicht mehr so verhalten, wie Sie es erwarten. Wenn Sie versuchen, die Datei, die wir beim letzten Mal erstellt haben, abzufangen, erhalten Sie jetzt eine Fehlermeldung:

So was ist los? Änderungen an Docker-Images werden nicht standardmäßig beibehalten. Um Ihre Änderungen an einem Docker-Image zu speichern, müssen Sie commit im git-Stil festschreiben. Dies mag ein wenig gewöhnungsbedürftig sein, ist aber sehr mächtig, da Sie sie auch im git-Stil "verzweigen" können (dazu später mehr).

Neue Bilder speichern

Lassen Sie uns jetzt etwas Nützlicheres tun. Lassen Sie uns python, redis und einige andere Dienstprogramme installieren, die wir in Kürze verwenden werden, um unsere Demo-App auszuführen. Danach commit wir uns, unsere Änderungen beizubehalten. Starten Sie eine Kopie von Docker auf dem neuesten Ubuntu-Image:

Das Ubuntu-Basisimage enthält möglicherweise kein Python. Überprüfen Sie daher, ob Sie eine Kopie haben, indem Sie an der Eingabeaufforderung python eingeben. Wenn Sie eine Fehlermeldung erhalten, installieren wir sie:

So weit, ist es gut. Es ist möglich, dass wir später andere Projekte erstellen möchten, die Python verwenden, also lassen Sie uns diese Änderungen speichern. Öffnen Sie eine weitere Eingabeaufforderung (wenn Sie die oben empfohlene Vagrant-Installation verwenden, müssen Sie vagrant ssh erneut von einer separaten Eingabeaufforderung aus ausführen) und gehen Sie wie folgt vor:

Sie erhalten eine Liste wie unten mit allen Docker-Containern, die derzeit ausgeführt werden:

Wichtig ist die Zahl unter der ID-Spalte: Dies ist die ID Ihres Containers. Diese sind eindeutig. Wenn Sie Ihren Container verlassen und dasselbe Image erneut ausführen, sehen Sie dort eine neue Nummer.

Nachdem wir nun Python installiert haben, speichern wir unsere Änderungen. Dazu verwenden Sie den commit-Befehl, der zwei Argumente benötigt: den Container, dessen Änderungen Sie speichern möchten, und den Image-Namen. Die Docker-Konvention sieht vor, eine Benutzer-ID gefolgt von einem / und dem Kurznamen des Images zu verwenden. Nennen wir es in diesem Fall also tuts/python. Geben Sie den folgenden Befehl aus, um Ihre Python-Installation zu speichern, und stellen Sie sicher, dass Sie die ID für Ihren Container aus dem letzten Schritt ersetzen

Nach einigen Sekunden kehrt es mit einer Reihe von Buchstaben und Zahlen zurück. Dies ist die ID des gerade gespeicherten Bildes. Sie können dieses Bild jederzeit ausführen und entweder über diese ID-Nummer oder den leichter zu merkenden tuts/python-Namen, den wir ihm zugewiesen haben, darauf verweisen.

Lassen Sie uns eine Kopie des gerade erstellten Bildes ausführen:

Zu diesem Zeitpunkt sollten zwei Terminalfenster geöffnet sein, in denen zwei separate Docker-Sitzungen ausgeführt werden.

Sie werden jetzt feststellen, dass Sie keine Fehlermeldung mehr erhalten, wenn Sie python in eine der beiden eingeben. Versuchen Sie, im zweiten Fenster eine Datei zu erstellen:

Wechseln Sie nun zurück zu Ihrem ursprünglichen Docker-Fenster und versuchen Sie, sich die Datei anzusehen:

Sie erhalten eine Fehlermeldung. Dies liegt daran, dass Sie eine völlig andere "virtuelle Maschine" ausführen, die auf dem Image basiert, das Sie mit dem Befehl docker commit erstellt haben. Ihre Dateisysteme sind völlig getrennt.

Wenn Sie ein weiteres Terminal öffnen (auch hier müssen Sie vagrant ssh ausführen, wenn Sie Vagrant verwenden) und gehen Sie wie folgt vor:

... Sie werden sehen, dass docker jetzt zwei laufende Images auflistet, nicht nur eines. Sie können jedes dieser Bilder separat festlegen. Um mit der git-Metapher fortzufahren, arbeiten Sie jetzt mit zwei Zweigen und sie können "divergieren".

Lassen Sie uns fortfahren und das letzte Fenster schließen, das wir geöffnet haben. Wenn Sie docker ps erneut ausführen, wird jetzt nur noch eine ID aufgelistet. Aber was ist, wenn Sie zu einem vorherigen Container zurückkehren möchten? Wenn Sie Folgendes eingeben:

Docker listet auch alle vorherigen Container auf. Sie können einen beendeten Container nicht ausführen, aber Sie können die IDs früherer Container verwenden, um neue Images zu übertragen. Wenn Sie das neue Image ausführen, kehren Sie dann effektiv zum Zustand Ihres vorherigen Containers zurück.

Schließen wir die neuen Fenster, die wir geöffnet haben, und wechseln Sie zurück zum Terminal für die erste Docker-Sitzung, die wir gestartet haben. Wenn Sie zurück sind, können Sie weitere Tools für unsere kleine App installieren. In diesem Fall müssen wir den Python-Paketmanager, zwei Python-Module installieren, damit Python als Webserver fungieren und mit redis interagieren kann, und den Redis-Server selbst.

Sobald diese abgeschlossen sind, lassen Sie uns dieses Image festschreiben. Führen Sie in einem anderen Terminalfenster den folgenden Befehl aus:

... und notieren Sie sich die ID und übergeben Sie sie unter dem Namen tuts/pyredis:

Wir haben jetzt also ein Docker-Image, das die notwendigen Tools enthält, um eine kleine Python-Webanwendung mit Redis als Back-End auszuführen. Wenn Sie zukünftige Projekte haben, die denselben Stack verwenden, müssen Sie sie nur starten: docker run -t -i tuts/pyredis /bin/bash und Commit, sobald Sie Ihren Quellcode hinzugefügt haben.

Okay, unser Back-End ist eingerichtet. Jetzt die App selbst einrichten!

Bringen Sie Ihre Quell-App in das Bild

Ich habe eine kleine Beispiel-App erstellt, die die bisher installierten Redis- und Python-Module verwendet. Die App ist recht einfach, sie zeigt nur eine Liste der Redis-Schlüssel an und bietet eine rudimentäre Benutzeroberfläche, um sie hinzuzufügen und zu bearbeiten. Lassen Sie uns zuerst den Quellcode auf Ihren Host-Rechner (die vagrant ssh-Sitzung) übertragen:

Im Home-Verzeichnis Ihres Host-Rechners haben Sie nun einen pyredis-Ordner, der das von uns verwendete python-Skript enthält. Wie können wir diese App in unser Docker-Image kopieren?

Nun, Docker hat eine nette Funktion, mit der Sie ein lokales Verzeichnis in Ihrem Container mounten können. Lassen Sie uns ein weiteres Docker-Image ausführen und den Ordner mounten:

Dies ist genau wie unsere run-Befehle von zuvor, mit dem Zusatz des Parameters -v.

Mit diesem Befehl können Sie einen Ordner zwischen Docker und Ihrem Hostcomputer freigeben. Die : geben die zu teilenden Pfade an. In unserem Fall teilen wir unseren pyredis-Ordner, der sich unter ~/pyredis auf unserem Computer befindet, und mounten ihn unter /tuts im Docker-Image. Das rw am Ende steht für "read-write" und bedeutet, dass Änderungen am Docker-Image auch auf unserem Computer angezeigt werden.

An Ihrer Docker-Eingabeaufforderung können Sie jetzt Folgendes tun:

... und sehen Sie sich den Inhalt des Ordners ~/pyredis auf Ihrem Computer an.

Diese Freigabe ist jedoch temporär, wenn Sie dieses Docker-Image auf einem anderen Computer ausführen oder dieses Image ohne die Option -v erneut ausführen, hat das Image keinen Zugriff mehr darauf. Kopieren wir es an einen anderen Ort im eigentlichen Docker-Image:

Da Änderungen an Docker-Dateisystemen standardmäßig nur kurzlebig sind, speichern wir dies im Image, indem wir erneut docker ps ausführen, um unsere Container-ID zu erhalten und unsere Änderungen zu übernehmen:

Sie werden feststellen, dass wir uns hier für denselben Bildnamen entschieden haben, den wir beim letzten Mal festgelegt haben, tuts/pyredis. Docker aktualisiert das Image und protokolliert alle Ihre Änderungen für Sie. Wie bei git können Sie, wenn Sie es vermasseln, zu einer guten Version zurückkehren, indem Sie einfach die ID des docker run. Um den Verlauf eines Bildes anzuzeigen, versuchen Sie Folgendes:

Sie werden so etwas sehen:

Dies ist eine Geschichte aller Commits, die wir bei der Erstellung des tuts/pyredis-Images gemacht haben, einschließlich derer, die wir an andere Namen wie tuts/python gebunden haben. Wenn Sie direkt vor dem Kopieren unserer pyredis-App nach /pyredis zum Commit zurückkehren möchten, können Sie es versuchen (ändern Sie die IDs so, dass sie mit Ihrer übereinstimmen):

... und Sie werden feststellen, dass es kein /pyredis-Verzeichnis gibt.

Ausführen der App

So, jetzt haben wir alle Teile an Ort und Stelle. Der nächste Schritt besteht darin, die App tatsächlich aus ihrem Container heraus auszuführen. Da wir eine Web-App bereitstellen, müssen wir auch eine Möglichkeit für den Zugriff auf die App über das Web angeben. Der run-Befehl hat Sie(wieder) abgedeckt. Der Befehl run von Docker unterstützt die Option -p, mit der Sie angeben können, wie Ports zugeordnet werden.

Wenn Sie Vagrant zum Ausführen von Docker verwenden, müssen Sie die Portweiterleitung von Vagrant einrichten, bevor wir aussagekräftige Tests durchführen können. Wenn Sie Vagrant nicht verwenden, überspringen Sie diesen Schritt einfach.

Einrichten von Vagrant-Portweiterleitungen

Wenn Sie Vagrant verwenden, um dies zu testen, müssen Sie die Portweiterleitung einrichten, damit der Webbrowser Ihres lokalen Computers auf die Ports der Vagrant-VM zugreifen kann, die wiederum an den Port der Docker-Instanz weiterleitet. In unserem Fall richten wir den Port 9000 unseres lokalen Computers so ein, dass er an den 9000 unserer Vagrant-VM weitergeleitet wird, der wiederum an den Port 8080 unserer tuts/pyredis Docker-Instanz weiterleitet.

Gehen Sie auf Ihrem lokalen Computer zurück zu dem Ordner, in dem Sie zuerst vagrant init eingegeben haben. Dort finden Sie eine Textdatei, die einfach Vagrantfile heißt. Öffnen Sie es in Ihrem bevorzugten Texteditor und suchen Sie nach dem folgenden Teil:

Entkommentieren Sie die letzte Zeile und ändern Sie die Ports von 80 und 8080 auf 8080 und 9000. Das Ergebnis sollte so aussehen:

Führen Sie nun aus:

... was dazu führt, dass sich die Vagrant VM mit den richtigen Portweiterleitungen neu startet. Sobald dies abgeschlossen ist, können Sie vagrant ssh erneut ausführen und das Tutorial fortsetzen.

Unsere kleine pyredis-App öffnet standardmäßig einen kleinen Webserver auf Port 8080. Mit dem folgenden Befehl können Sie auf Port 8080 über Port 9000 auf Ihrem Host-Rechner zugreifen:

Sie erhalten eine Docker-Root-Eingabeaufforderung, also starten wir unsere App:

Wenn alles gut geht, sehen Sie Folgendes:

Dies bedeutet, dass der Server läuft. Starten Sie auf Ihrem lokalen Computer einen Webbrowser und verweisen Sie ihn auf localhost:9000 (wenn Sie dieses Tutorial auf einem Remote-Server durchführen, stellen Sie sicher, dass Sie Netzwerkzugriff auf Port 9000 haben und ersetzen Sie localhost durch die Adresse Ihres Webservers ).

Mit etwas Glück sollten Sie den Hauptbildschirm unserer kleinen App sehen. Fahren Sie fort und fügen Sie ein paar Schlüssel hinzu und ändern Sie einige Werte. Die Daten sollten bestehen bleiben. Wenn Sie jedoch Ihre Docker-Eingabeaufforderung verlassen und Docker neu starten, ist die Datenbank wieder leer, was Sie beachten sollten, wenn Sie Ihre Datenbank in einem Docker-Container hosten möchten.

Speichern Ihrer Laufkonfiguration

Das ist alles großartig zum Testen, aber das Ziel hier ist es, Ihre App bereitstellen zu können. Sie möchten nicht jedes Mal die Befehle eingeben müssen, um Ihre App manuell zu starten.

Docker kommt wieder zur Rettung. Wenn Sie einen Commit ausführen, kann Docker automatisch einige Ausführungsinformationen speichern, z. B. welche Ports zuzuordnen sind und welche Befehle ausgeführt werden sollen, wenn das Image gestartet wird. Auf diese Weise müssen Sie nur docker <image_name> eingeben und Docker kümmert sich um den Rest. Echte Containerisierung.

Für unser Skript haben wir nur zwei Befehle, die beim Start ausgeführt werden:

Der einfachste Weg, dies zu tun, besteht darin, ein kleines Startskript zu erstellen, das diese beiden Befehle ausführt. Lassen Sie uns unsere tuts/pyredis erneut starten und ein kleines Startskript hinzufügen (einfach direkt kopieren und in die Docker-Eingabeaufforderung einfügen):

Dadurch wurden die Befehle, die wir zum Starten unseres Python-Servers verwenden, in einem kleinen Bash-Skript namens launch.sh gespeichert und das ausführbare Bit so festgelegt, dass es einfacher ausgeführt werden kann.

Nachdem sich das Skript nun erfolgreich im Image befindet, übergeben Sie es von einem anderen Terminal aus, damit es bestehen bleibt (denken Sie daran, einen docker ps auszuführen, um zuerst die ID Ihres neuesten Containers zu erhalten):

Lassen Sie uns das testen. Wenn Sie Ihre Docker-Eingabeaufforderung verlassen und sie mit dem folgenden Befehl erneut ausführen, sollten Sie wie beim letzten Mal auf die pyredis-Web-App unter localhost:9000 zugreifen können.

Ok, jetzt können wir unsere kleine App mit einem einzigen Befehl ausführen. Aber es gibt noch mehr! Mit Docker können Sie einige Standardkonfigurationsinformationen mit Ihren Commits speichern. Auf diese Weise müssen wir nicht jedes Mal daran denken, unsere Portzuordnungs- und Startbefehlsinformationen einzugeben, und Sie können einfach ein Docker-Image an jemand anderen weitergeben. Sie können es dann mit einem einfachen docker run<image_name> und Docker kümmert sich um den Rest.

Um dies zu konfigurieren, müssen Sie einige JSON-Informationen an den Commit-Befehl übergeben. Es gibt viele Parameter, die Sie verwenden können, aber im Moment beschäftigen wir uns nur mit der Zuordnung von Ports und Initialisierungsskripten. Starten Sie Ihren bevorzugten Texteditor und fügen Sie Folgendes ein:

Dies stellt die Informationen dar, die wir in die Option -p eingegeben haben, sowie den Pfad zum Startskript. Ein wichtiger Hinweis ist, dass für die Option cmd jede Stelle, an der Sie normalerweise ein Leerzeichen verwenden würden, tatsächlich als separater Parameter übergeben wird.

Speichern Sie dieses JSON-Snippet in einer Datei namens runconfig.json und aktualisieren wir Docker, um es zu verwenden.

Wenn Sie es jetzt tun:

Sie sehen, wie die bottle startet und Sie können über den Browser auf die App zugreifen.

Bereitstellen öffentlicher Bilder auf einem Server über die öffentliche Docker-Registrierung

Die Entwickler von Docker haben eine öffentliche Registrierung erstellt, aus der jeder Docker-Images pushen und abrufen kann. Dies bedeutet, dass die Bereitstellung Ihrer neuen App auf einem Remoteserver so einfach ist, wie sie in die zentrale Registrierung von Docker übertragen und dann von einem Server abgerufen wird, auf dem Docker installiert ist.

Dies ist ziemlich einfach, daher verweise ich Sie auf die Dokumentation von Docker. Wenn Sie stattdessen privat bereitstellen möchten, lesen Sie den/die nächsten Abschnitt(e).

Bereitstellen privater Bilder auf einem Server (der einfache Weg)

Großartig, also haben wir jetzt ein einfach zu verwendendes Docker-Image, das auf Ihrem Computer ausgeführt wird. Der nächste Schritt besteht darin, es auf einem Server bereitzustellen!

Dieser Teil ist etwas kompliziert. Das Distributionsmodell von Docker basiert auf der Idee von Repositorys. Sie können Ihre Docker-Images so oft Sie möchten in ein Docker-Repository pushen und ziehen, und verschiedene Server können alle gerne unterschiedliche Images abrufen. Das ist großartig, aber leider ist ein wenig Arbeit erforderlich, um Ihr eigenes Repository zu hosten. Wenn Sie Open-Source-Software hosten oder erstellen, können Sie einfach das öffentliche Docker-Repository direkt zum Speichern Ihrer Images verwenden. Wenn Sie jedoch proprietären Code bereitstellen, möchten Sie dies wahrscheinlich nicht. Damit bleiben Ihnen zwei Möglichkeiten:

  1. Sie können die Repository-Funktionen von Docker vollständig umgehen und Images manuell übertragen.
  2. Sie können Ihr eigenes Repository erstellen.

Die erste ist einfacher, verliert jedoch viele der cooleren Funktionen von Docker, wie das Aufbewahren der Historie Ihrer Images und die Möglichkeit, die Portzuordnung und die Konfiguration im Image zu speichern. Wenn Ihnen diese wichtig sind, fahren Sie mit dem nächsten Abschnitt fort, um zu erfahren, wie Sie Ihr eigenes (privates) Docker-Repository einrichten. Wenn Sie Ihre Images nur auf Ihren Servern bereitstellen möchten, können Sie diese Methode verwenden.

Der erste Schritt besteht darin, Ihren Container in ein .tar-Archiv zu exportieren. Sie können dies über den export-Befehl von Docker tun. Um die Beispiel-App bereitzustellen, die wir in diesem Tutorial verwendet haben, gehen Sie wie folgt vor:

Docker wird einige Zeit sitzen und verarbeiten, aber danach haben Sie eine Datei pyredis.tar, die das von Ihnen erstellte Image enthält. Sie können dann pyredis.tar auf Ihren Server kopieren und Folgendes ausführen:

Docker sitzt wieder eine Weile und spuckt schließlich die ID des neuen Images aus, das es erstellt hat. Sie können commit dies einem einprägsameren Namen zuordnen, indem Sie Folgendes tun:

Unsere Tutorial-App ist jetzt bereitgestellt und Sie können sie mit dem gleichen run-Befehl wie zuvor ausführen:

Bereitstellen privater Bilder auf einem Server (die coole Art)

Die coolere Art, Ihre App bereitzustellen, besteht darin, Ihr eigenes Docker-Repository zu hosten. Installieren Sie Docker auf einem Computer und führen Sie den folgenden Befehl aus:

Warten Sie ein wenig, bis die Teile heruntergeladen sind, und Sie sollten bald einige Nachrichten zum Starten von Unicorn und zum Booten von Workern sehen.

Dies bedeutet, dass Ihre Docker-Registrierung betriebsbereit ist (in einem eigenen Docker-Container) und für Ihren lokalen Computer über Port 5000 zugänglich ist. Etwas umwerfend, aber großartig. Lassen Sie uns zuerst unsere Anmeldeinformationen festlegen und dann das Docker-Image, das wir zuvor im Tutorial erstellt haben, in unsere neue Registrierung übertragen. Führen Sie in einem neuen Terminal Folgendes aus:

Geben Sie den Benutzernamen, das Passwort und die E-Mail-Adresse ein, die Sie mit Ihrem Docker-Repository verwenden möchten.

Um die tuts/pyredis-App in das Repo zu verschieben, müssen wir sie zuerst mit den Adressinformationen des privaten Repositorys "taggen" wie folgt:

Dies weist Docker an, ein neues "Tag" von tuts/pyredis zu erstellen und es mit dem Repository zu verknüpfen, das unter localhost:5000 ausgeführt wird. Sie können sich dieses Tag als den Namen dieses Bildes im Repository vorstellen. Aus Konsistenzgründen habe ich die Namen gleich belassen und sie mit localhost:5000/tuts/pyredis gekennzeichnet, aber dieser Name könnte leicht etwas ganz anderes sein (wie localhost:5000/pyredis_prod.)

Wenn Sie jetzt docker images ausführen, sehen Sie, dass ein neues Image mit dem Namen localhost:5000/tuts/pyredis aufgelistet ist. Der Mechanismus von Docker zum Angeben von Repositorys ist eng mit seinem Mechanismus für die Benennung (oder Tagging, wie Docker es ausdrückt) verbunden, also ist dies alles, was Sie brauchen.

Um das von uns erstellte Image in unser Repository zu verschieben, führen Sie einfach docker push und den vollständigen Namen des markierten Image (einschließlich der Adresse) aus:

Docker verbindet sich mit Ihrem Repository unter localhost:5000 und beginnt mit dem Pushen Ihrer Änderungen. Im anderen Terminalfenster (das samalba/docker-registry läuft) werden viele Nachrichten über die verschiedenen beteiligten HTTP-Anfragen angezeigt, und in diesem werden Informationen zum Upload angezeigt. Das dauert eine Weile, also solltest du dir vielleicht einen Kaffee holen.

Ein Vorbehalt, da unser Docker-Repository selbst in einem Docker-Container ausgeführt wird, müssen wir das Image des Repositorys nach Abschluss des Pushs festschreiben. Da die Änderungen des Docker-Dateisystems nur kurzlebig sind, verschwindet das Image, das wir in das Repository verschoben haben, standardmäßig, sobald wir unseren lokalen samalba/docker-registry-Docker-Container schließen.

Führen Sie dazu den üblichen docker ps aus, um die ID des laufenden samalba/docker-registry-Containers abzurufen, und übergeben Sie ihn dann an einen neuen Container. Dies ist nicht ideal, wenn Sie dies in der Produktion tun möchten, möchten Sie Docker-Volumes konfigurieren oder die Option -v von oben verwenden, um die Repository-Datei direkt auf dem Server zu speichern, anstatt im Container, aber das ist nicht Gegenstand dieses Tutorials .

Nun zum spaßigen Teil: Bereitstellung unseres neuen Docker-Images auf einem neuen Server. Da Docker-Repositorys zum Zeitpunkt dieses Schreibens keine Sicherheits- oder Authentifizierungsmechanismen haben, werden wir unsere Arbeit über sichere SSH-Tunnel erledigen. Von der virtuellen Maschine, auf der Sie das tuts/pyredis-Tutorial eingerichtet haben, ssh in Ihren Produktionsserver und leiten Sie Port 5000 wie folgt weiter:

Das Flag -R für ssh bedeutet, dass, wenn Sie sich mit localhost:5000 auf Ihrem Produktionsserver verbinden, SSH die Verbindung zurück an Port 5000 auf Ihrer virtuellen Maschine weiterleitet, die wiederum an den samalba/docker-registry-Container weitergeleitet wird, in dem unsere Repo lebt.

Wenn Docker nicht auf diesem Server installiert ist, fahren Sie fort und installieren Sie es gemäß den Installationsanweisungen. Sobald Docker ausgeführt wird, ist die Bereitstellung Ihres Images so einfach wie:

Da wir einen Tunnel über SSH erstellt haben, geht Docker davon aus, dass er vom localhost:5000 des Remote-Servers zieht, aber dies wird tatsächlich zum localhost:5000 Ihrer lokalen VM getunnelt, der wiederum an Docker umgeleitet wird. Geben Sie ihm etwas Zeit zum Herunterladen, aber sobald es fertig ist, sollten Sie in der Lage sein, unsere Pyredis-App genau so auszuführen, wie wir sie auf der ursprünglichen VM ausgeführt haben, einschließlich der gespeicherten Ausführungskonfiguration und der Ports:

Zusammenfassung und nächste Schritte

Das sind die Grundlagen von Docker. Mit diesen Informationen können Sie jetzt Docker-Images erstellen und verwalten, sie per Push und Pull in öffentliche und private Repositorys ziehen und auf separaten Servern bereitstellen.

Dies ist ein Einführungs-Tutorial, daher gibt es viele Docker-Funktionen, die hier nicht behandelt wurden. Zwei der bemerkenswertesten sind Dockerfiles und Volumes.

Dockerfiles sind Textdateien, die Docker ausführen kann, um Docker-Images zu initialisieren und bereitzustellen. Sie können den Prozess der Erstellung vieler Docker-Images erheblich beschleunigen, aber da der Schwerpunkt hier auf der Erstellung und Bereitstellung eines einzelnen Images lag, wurden sie nicht behandelt. Wenn Sie mehr darüber erfahren möchten, lesen Sie die Dokumentation von Docker.

Das zweite Merkmal sind Volumen. Volumes funktionieren ein bisschen wie die freigegebenen Ordner, die wir mit der Option -v behandelt haben, da sie es Docker-Containern ermöglichen, ihre Daten beizubehalten. Im Gegensatz zur Ordnerfreigabe mit -v werden sie nicht mit dem Hostsystem geteilt, aber sie können zwischen Bildern geteilt werden. Eine gute Einführung finden Sie in diesem Tutorial.

Advertisement
Did you find this post useful?
Want a weekly email summary?
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.