Einführung

Das offizielle Docker-Tutorial war ziemlich gut organisiert und leicht zu verstehen, also habe ich es durchgearbeitet. Ich dachte jedoch, dass die Tutorials dazu neigen, auf Englisch zu zögern, deshalb habe ich sie ins Japanische übersetzt, damit sie für jemanden hilfreich sind. Da wir uns in einer Windows-Umgebung befinden, erklären wir dies in der Windows-Benutzeroberfläche.

Annahme

・ Docker installiert ・ Git installiert

Starten Sie das Tutorial

Wenn Sie das Lernprogramm im installierten Zustand starten möchten, klicken Sie auf das Docker-Symbol und dann auf Lernen, um das Lernprogramm zu starten. Vor der Installation sollte das Lernprogramm automatisch gestartet werden, wenn die Installation abgeschlossen ist.

Der folgende Bildschirm wird angezeigt. Starten Sie ihn daher.

clone Klonen Sie den Code für das Tutorial

git clone https://github.com/docker/getting-started.git

Build

docker build -t docker101tutorial .

Verwenden Sie diesen Befehl "build", wenn Sie ein Docker-Image aus "Dokerfile" erstellen. -t docker 101 tutorial gibt den Tag-Namen des Docker-Images an. t ist eine Abkürzung für tag. . Zeigt an, dass sich die Docker-Datei im aktuellen Verzeichnis befindet. Zusammenfassend bedeutet der obige Befehl, ein Docker-Image aus der Doker-Datei im aktuellen Verzeichnis mit dem Tag-Namen "docker101tutorial" zu erstellen. Das Docker-Image ist das Verzeichnis, das die zum Ausführen der Anwendung erforderlichen Dateien enthält, und die Quelle des Containers.

Run

docker run -d -p 80:80 --name docker-tutorial docker101tutorial

Der Befehl run ist ein Befehl zum Erstellen und Starten eines Containers aus einem Docker-Image und kann gleichzeitig erstellt und gestartet werden. Es gibt auch einen Befehl zum Erstellen von "Docker erstellen" und einen Befehl zum Starten von "Docker starten". Das Erstellen und anschließende Starten hat dasselbe Verhalten wie das Ausführen. -d gibt an, dass im Trennmodus gestartet werden soll. Wenn dies angegeben ist, kann es im Hintergrund gestartet werden. Wenn Sie beginnen, ohne dies anzugeben, werden Informationen an das Terminal ausgegeben und belegt. Geben Sie diese an, wenn Sie dies vermeiden möchten. Der obige Befehl startet einen Container mit dem Namen "docker-tutorial" aus einem Docker-Image mit dem Namen "docker101tutorial". Wenn Docker zu diesem Zeitpunkt nicht gestartet werden kann, ändern Sie den Port auf der Hostseite auf 8080.

1. 1. Lass uns anfangen

Wenn Sie auf localhost: 80 zugreifen und der folgende Bildschirm angezeigt wird, haben Sie Zugriff auf den Container für das Lernprogramm. Von hier aus werde ich es gemäß diesem Tutorial ins Japanische übersetzen. Ich füge hier und da auch meine Kommentare hinzu.

(Ergänzung) Der so beschriebene Ort ist mein Kommentar (Ergänzung).

Über den ausgeführten Befehl

Ich werde den folgenden Befehl erklären, der den Container erstellt und gestartet hat.

docker run -d -p 80:80 docker/getting-started

---d: Container im Hintergrundmodus erstellen / starten ---p 80: 80: Ordnen Sie Port 80 auf der Hostseite Port 80 auf der Containerseite zu --docker / Erste Schritte: Zu verwendendes Bild

Dieser Befehl kann wie unten gezeigt abgekürzt werden. docker run -dp 80:80 docker/getting-started

The Docker Dashboard Hier werde ich das Docker Dashboard einmal erklären. Durch Starten des Dashboards können Sie das Containerprotokoll überprüfen und die Shell im Container starten. Darüber hinaus können Sie es im Browser öffnen, neu starten, löschen und verschiedene Vorgänge intuitiv mit der Benutzeroberfläche ausführen.

Wenn Sie auf das Dashboard zugreifen, wird der folgende Bildschirm geöffnet und Sie können bestätigen, dass der Container ausgeführt wird. "Jolly_bouman" ist ein zufälliger Name, daher sollte es ein anderer Name sein.

Was ist ein Container?

Was ist ein Container? Einfach ausgedrückt handelt es sich um einen Prozess auf dem Host-Computer und auf einem Computer, der von anderen Prozessen isoliert ist. Ein Prozess ist ein Programm, das auf einem Computer ausgeführt wird. Bei der Prozessisolierung werden die Namespaces und cgroups-Funktionen von Linux verwendet.

Was ist ein Containerbild?

Was ist ein Containerbild? Das Image ist die Quelle (Vorlage) des Containers, der in der Ausführungsumgebung ausgeführt wird. Die Identität des Container-Images ist das Verzeichnis, das die zum Ausführen der Anwendung erforderlichen Dateien enthält. Es enthält Umgebungsvariablen, standardmäßig auszuführende Befehle und andere Metadaten.

2. Anwendung

Die Anwendung, die Sie in diesem Lernprogramm ausführen, ist eine ToDo-App, die auf Node.js ausgeführt wird. Sie müssen nicht mit Node.js vertraut sein. Hier bereiten wir eine ToDo-App vor, die mindestens funktioniert. Führen Sie die folgenden Schritte aus, um die App zu starten und den Betrieb zu überprüfen.

Bewerbung abrufen

Laden Sie den Quellcode von http: // localhost: 80 / assets / app.zip herunter.

(Ergänzung) Geben Sie die obige Adresse in Ihren Browser ein, um den Quellcode herunterzuladen. Ändern Sie den Port entsprechend.

Entpacken Sie die Zip-Datei und Sie sehen package.json und zwei Unterverzeichnisse (src und spec).

Container-Image erstellen

Um die Anwendung zu erstellen, verwenden wir hier "Dockerfile". Dockerfile ist ein textbasiertes Skript, wie Anweisungen zum Generieren eines Container-Images. Führen Sie die folgenden Schritte aus, um ein Docker-Image zu erstellen.

Erstellen Sie eine Docker-Datei in derselben Verzeichnishierarchie wie package.json und schreiben Sie Folgendes. Die Docker-Datei benötigt keine Erweiterung.

FROM node:12-alpine WORKDIR /app COPY . . RUN yarn install --production CMD ["node", "src/index.js"]

 2. Öffnen Sie ein Terminal, wechseln Sie in das App-Verzeichnis und führen Sie den folgenden Befehl aus.

    ```
docker build -t getting-started .

Verwenden Sie diesen Befehl, um ein neues Container-Image aus einer Docker-Datei zu generieren. Wenn Sie das Terminal nach dem Ausführen überprüfen, werden Sie feststellen, dass Sie eine große Anzahl von "Ebenen" heruntergeladen haben. Dies liegt daran, dass wir das Image "node: 12-alpie" als Basis-Image verwendet haben. Wenn Sie dieses Image nicht auf Ihrem Computer haben, müssen Sie es herunterladen. Wenn der Download abgeschlossen ist, kopieren Sie ihn in Ihre Anwendung (COPY ..) und installieren Sie die Anwendungsabhängigkeiten mit Garn ( RUN yarn install --production). Die Abhängigkeitsinstallation wird mit dem Befehl "RUN yarn install --production" ausgeführt, der alles andere als die unter "devDependencies" in package.json in der Anwendung aufgeführten installiert. Das in devDependencies beschriebene Paket ist ein Paket, das zum Zeitpunkt der Entwicklung erforderlich ist und in der Produktversion (--production) nicht erforderlich ist, daher wird --production angegeben. CMD ist ein Befehl, der standardmäßig ausgeführt wird, wenn ein Container von einem Container-Image aus gestartet wird. Dies bedeutet, dass beim Ausführen von "Docker Run XXXX" der Befehl "Node src / index.js" ausgeführt wird. Das letzte "." Des "Docker Build" -Befehls bedeutet, dass sich die "Docker-Datei" im aktuellen Verzeichnis befindet.

(Ergänzung) Standardmäßig sucht Docker nach dem Namen "Dockerfile", aber Sie können einen Alias mit -f angeben. Wenn Sie es "Dockerfile.base" nennen möchten, verwenden Sie den folgenden Befehl docker build -t sample -f Dockerfile.base .

Starten Sie den Container

Nachdem das Image fertig ist, verwenden Sie den Befehl docker run, um die Anwendung auszuführen.

Geben Sie das Image an und starten Sie den Container mit dem Befehl docker run.

docker run -dp 3000:3000 getting-started

 `-d` bedeutet, den Container im Hintergrund zu starten, und` -p` ordnet Port 3000 auf der Hostseite Port 3000 auf der Containerseite zu. Ohne diese Portzuordnung können Sie nicht auf die Anwendung zugreifen.
 2. Sie können auf die Anwendung zugreifen, indem Sie auf [http: // localhost: 3000](http: // localhost: 3000) zugreifen.
 3. Sie sollten sehen, dass das Element wie erwartet hinzugefügt wurde. Sie können es als vollständig markieren und das hinzugefügte Element löschen.

 Wir werden hier einige Änderungen vornehmen, um mehr über die Verwaltung von Containern zu erfahren.


## 3. 3. Anwendungsaktualisierung
 Führen Sie die folgenden Schritte aus, um Ihre Anwendung zu aktualisieren.

 1. Ändern Sie die 56. Zeile von `src / static / js / app.js` wie folgt.
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/187747/70f53862-a69a-61b5-9637-c9396aebf7c2.png)

 2. Erstellen Sie die aktualisierte Version des Bildes. Führen Sie den folgenden Befehl aus.
`docker build -t getting-started .`

 3. Starten Sie einen neuen Container mit dem aktualisierten Code.
`docke run -dp 3000:3000 getting-started`

 Wenn ich diesen Code ausführe, sollte ein Fehler ähnlich dem folgenden angezeigt werden:
`docker: Error response from daemon: driver failed programming external connectivity on endpoint laughing_burnell 
(bb242b2ca4d67eba76e79474fb36bb5125708ebdabd7f45c8eaf16caaabde9dd): Bind for 0.0.0.0:3000 failed: port is already allocated.`
 
 Die Ursache für diesen Fehler ist, dass der alte Container noch auf Port 3000 ausgeführt wird. Auf der Hostseite kann nur ein Prozess von einem Port belegt werden.
 Die Lösung besteht darin, den alten Container zu löschen.

### Ersetzen Sie den alten Behälter
 Stoppen Sie zuerst, um den Container zu löschen. Es kann nicht ohne anzuhalten gelöscht werden.
 Es gibt zwei Möglichkeiten, einen alten Container zu löschen. Löschen Sie ihn also nach Belieben.

#### Container löschen (mit CLI)
 1. Holen Sie sich die Container-ID mit dem Befehl `docker ps`

    ```
docker ps

Verwenden Sie Docker Stop, um den Container anzuhalten

Bitte ersetzen Sie den Platz durch die Container-ID, die Docker ps erhalten hat.

docker stop

 3. Löschen Sie den gestoppten Container mit dem Befehl `docker rm`

    ```
docker rm <the-container-id>

Mit den folgenden Befehlen können Sie einen Container mit einem einzeiligen Befehl stoppen und löschen. docker rm -f <the-container-id>

Container löschen (mit Docker Dashboard)

Mit dem Docker-Dashboard können Sie einen Container mit nur zwei Klicks löschen. Sie können einen Container einfacher und intuitiver löschen als mit der CLI.

Öffnen Sie das Dashboard und bewegen Sie die Maus über den Container, den Sie löschen möchten. Auf der rechten Seite wird eine Aktionsschaltfläche angezeigt.
Klicken Sie auf das Papierkorbsymbol, um den Container zu löschen
Vergewissern Sie sich, dass der Container nicht mehr vorhanden ist

Starten Sie die aktualisierte Anwendung

Starten Sie die aktualisierte Anwendung

docker run -dp 3000:3000 getting-started

 2. Gehen Sie zu [http: // localhost: 3000](http: // localhost: 3000) und stellen Sie sicher, dass der Text aktualisiert wird
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/187747/4a4315be-b138-73e3-400a-25384e698db6.png)


### (Zusammenfassung von Kapitel 3)
 Ich habe die Anwendung aktualisiert, aber ich denke, Sie haben die folgenden zwei Punkte bemerkt.

 1. Alle zu Beginn registrierten Elemente sind verschwunden. Dies ist nicht gut für eine Aufgabenlisten-App, daher werden wir in einem späteren Kapitel darüber sprechen.
 2. Bei kleinen Änderungen waren viele Schritte erforderlich, um die App zu aktualisieren. Wir werden in einem späteren Kapitel sehen, wie man neu erstellt und nicht jedes Mal einen neuen Container starten muss.

 Bevor wir darüber sprechen, wie Elemente aufbewahrt werden, werfen wir einen kurzen Blick auf das Teilen von Bildern.

## 4. Anwendungsfreigabe
 Nachdem das Bild vollständig ist, teilen wir es. Um ein Docker-Image freizugeben, müssen Sie das Docker-Repository verwenden. Verwenden wir "Docker Hub", der alle von uns verwendeten Bilder enthält.

### Repository erstellen
 Erstellen wir ein Repository in Docker Hub, um das Image zu übertragen.

 1. Melden Sie sich bei [Docker Hub] an (https://hub.docker.com/).
 2. Klicken Sie auf ** Repository erstellen **
 3. Nennen Sie das Repository "Erste Schritte". Stellen Sie außerdem sicher, dass die Sichtbarkeit "Öffentlich" ist.
 4. Klicken Sie auf die Schaltfläche Erstellen

 Auf der rechten Seite der Seite befindet sich ein Abschnitt ** Docker-Befehle **, in dem Beispielbefehle zum Ausführen des Bilds aufgeführt sind.
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/187747/21a8f219-b8c2-f416-1080-98b925628800.png)

### Bildschub
 1. Öffnen Sie die Befehlszeile und geben Sie den soeben überprüften Push-Befehl ein. Ersetzen Sie zu diesem Zeitpunkt "Docker" durch Ihre eigene Docker-ID.

    ```
$ docker push docker/getting-started
The push refers to repository [docker.io/docker/getting-started]
An image does not exist locally with the tag: docker/getting-started

Ich habe versagt. Der Push-Befehl sollte nach einem Bild mit dem Namen Docker / Erste Schritte gesucht haben, konnte es aber nicht finden. Führen Sie den Befehl docker image ls aus, um REPOSITORY zu überprüfen. Sicher gibt es kein Bild von einem solchen Namen. Um dies zu lösen, geben Sie dem Bild einen Alias mit "tag". 2. Melden Sie sich bei Docker Hub an. Docker Login -u IHR-BENUTZER-NAME (Geben Sie Ihr Passwort nach der Ausführung ein) 3. Ersetzen Sie "IHR BENUTZERNAME" durch Ihre Docker-ID.

```

docker tag getting-started YOUR-USER-NAME/getting-started

 4. Führen Sie den Push-Befehl erneut aus. Wenn Sie den Befehl von Docker Hub kopieren, geben Sie keinen "Tagnamen" ein. Wenn Sie in Docker kein Tag angeben, wird das neueste Tag verwendet.

    ```
docker push YOUR-USER-NAME/getting-started

Starten Sie das Image in einer neuen Instanz

Zu diesem Zeitpunkt haben Sie das Image erstellt und in die Registrierung verschoben. Ich möchte das Push-Image in einer völlig neuen Umgebung starten. Verwenden wir hier "Play with Docker".

Öffnen Sie Play with Docker.
Melden Sie sich mit Ihrem Docker Hub-Konto an
Klicken Sie nach dem Anmelden in der linken Seitenleiste auf "+ NEUE INSTANZ HINZUFÜGEN". (Wenn es nicht angezeigt wird, versuchen Sie, den Browser ein wenig zu verkleinern.) Nach einer Weile wird der folgende Bildschirm im Browser angezeigt.
Starten Sie die Anwendung, die Sie zuvor auf dem Terminal gepusht haben 　docker run -dp 3000:3000 YOUR-USER-NAME/getting-started
Wenn Sie es starten, wird eine Schaltfläche mit der Bezeichnung "3000" angezeigt. Klicken Sie also darauf. Sie können sehen, dass die an Docker Hub übertragene Anwendung gestartet wurde. Wenn Sie keine Schaltfläche haben, klicken Sie auf ** OPEN PORT ** und geben Sie 3000 ein.

(Zusammenfassung von Kapitel 4)

In diesem Kapitel wurde erläutert, wie Sie das erstellte Image in die Registrierung übertragen und freigeben. Ich habe versucht, eine neue Anwendung mit dem Bild zu starten, das mit Play with Docker übertragen wurde. Dies entspricht der sogenannten CI-Pipeline, in der Sie Bilder erstellen und übertragen können, um die neuesten Bilder in Ihrer Produktionsumgebung zu erhalten.

5. DB-Persistenz

Wie Sie vielleicht nicht bemerkt haben, verliert die TODO-App jedes Mal Daten, wenn Sie einen Container starten. Lassen Sie uns verstehen, warum dies passiert und wie der Container funktioniert.

Container-Dateisystem

Der Container wird mit verschiedenen Bildebenen gestartet.

(Ergänzung) Das Docker-Image ist ein Zustand, in dem sich die Anweisungen jeder Docker-Datei als Bild überlappen, und hier scheinen diese überlappenden Zustände als "Ebenen" ausgedrückt zu werden. Docker behält jede Anweisung von Dockerfile als Bild bei und verwendet diese Bilder, um den Container zu starten.

Jeder Container erhält einen eigenen "Arbeitsbereich", in dem Dateien erstellt, aktualisiert und gelöscht werden. Auch für dasselbe Bild sind keine Änderungen in anderen Containern erkennbar.

(Ergänzung) Kratzraum: Stellen Sie sich hier einen Speicherplatz vor, der von anderen Prozessen isoliert ist.

Lassen Sie uns tatsächlich Ihre Hand bewegen und überprüfen

Um dies zu bestätigen, starten wir zwei Container und bearbeiten die Dateien in jedem. Sie können sehen, dass in einem Container bearbeitete Dateien im anderen Container nicht verfügbar sind.

Starten Sie den Ubuntu-Container. Dieser Container gibt eine Zufallszahl von 1 bis 10000 an /data.txt aus

docker run -d ubuntu bash -c "shuf -i 1-10000 -n 1 -o /data.txt && tail -f /dev/null"

 Dieser Befehl startet die Bash-Shell und ruft zwei Befehle auf (&& verbindet die beiden Befehle). Der erste Befehl schreibt eine Zufallszahl in /data.txt. Der zweite Befehl überwacht einfach die Datei, um den Container am Laufen zu halten.
 > (Ergänzung)
 Entfernen Sie den zweiten Befehl und && und führen Sie ihn aus. Der gestartete Container wird sofort gestoppt und Sie können die Dateien im Container nicht sehen.
 2. Überprüfen Sie den Ausgabewert. Öffnen Sie das Dashboard, fahren Sie mit der Maus über den Container, in dem das Ubuntu-Bild ausgeführt wird, und klicken Sie auf die Schaltfläche ganz links (CLI).
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/187747/f61691f3-0d27-dca0-d433-65a7cee97cff.png)
 Führen Sie im Container den folgenden Befehl aus, um den Inhalt von /data.txt zu überprüfen.

    ```
cat /data.txt

Wenn Sie die Befehlszeile verwenden möchten, können Sie dasselbe mit dem Befehl docker exec tun. Führen Sie den folgenden Befehl aus, nachdem Sie die Container-ID mit "Docker ps" erhalten haben.

```

docker exec cat /data.txt

 Sie können sehen, dass die Zufallszahlen angezeigt werden.
 3. Als nächstes starten wir einen anderen Container mit demselben Ubuntu-Image. Dann können Sie sehen, dass /data.txt nicht existiert.

    ```
docker run -it ubuntu ls /

/data.txt existiert nicht, da diese Datei in den Arbeitsbereich des ersten Containers geschrieben wurde. 4. Verwenden Sie den Befehl docker rm -f, um unnötige Container zu löschen.

Containervolumen

Wie wir gesehen haben, ist ein Container derjenige, der beim Start gemäß dem Inhalt des Bildes startet. Selbst wenn Sie einen Container erstellen und Dateien aktualisieren oder löschen, gehen diese Änderungen verloren, sobald der Container gelöscht wird. Alle Änderungen sind für jeden Container unabhängig. Sie können Volumes verwenden, um zu verhindern, dass sie verschwinden.

Mit Volumes können Sie einen bestimmten Dateisystempfad eines Containers mit einem Hostcomputer verbinden. Wenn das Verzeichnis auf der Containerseite bereitgestellt ist, kann die Änderung auch auf der Seite des Hostcomputers bestätigt werden. Wenn Sie beim Starten des Containers dasselbe Verzeichnis bereitstellen, können Sie dieselbe Datei auf der Containerseite überprüfen. Mit anderen Worten, die Daten gehen nicht verloren.

Es gibt zwei Arten von Volumes. Lassen Sie uns zuerst von ** benannten Volumes ** aus überprüfen.

Löschen Sie keine TODO-Daten

Standardmäßig werden TODO-Anwendungsdaten in der SQLite-Datenbank unter /etc/todos/todo.db gespeichert. Sie müssen nicht mit SQLite vertraut sein. Es ist nur eine Beziehungsdatenbank, in der alle Daten in einer Datei gespeichert sind. Diese Methode ist nicht für große Anwendungen geeignet, eignet sich jedoch gut für kleine Apps wie diese TODO-App. Später werden wir sehen, wie Sie zu einem anderen Datenbankmodul wechseln.

Wenn es sich bei der Datenbank um eine einzelne Datei handelt, sollten Sie in der Lage sein, den Container an der Stelle neu zu starten, an der er aufgehört hat, indem Sie diese Datei auf der Hostseite belassen und für den nächsten neuen Container verfügbar machen. Durch Erstellen eines Volumes und Anhängen des Volumes an das Verzeichnis, in dem die Daten gespeichert sind (dies wird als "Mounten" bezeichnet), können die Daten kontinuierlich verwendet werden. Wenn der Container die Daten in die Datei todo.db schreibt, werden die Daten auf dem Volume auf der Hostseite gespeichert.

Wie ich bereits sagte, werden wir hier ** benanntes Volume ** verwenden. Sie können sich das genannte Volume nur als einen Eimer Daten vorstellen. Wenn Sie dies verwenden, reicht es aus, sich nur den Datenträgernamen zu merken. Sie müssen nicht wissen, wo sich der physische Speicherbereich befindet, und Docker verwaltet die Zuordnung zwischen dem Datenträgernamen und dem Speicherbereich. Jedes Mal, wenn Sie Volume verwenden, sucht Docker die tatsächlichen Daten.

Erstellen Sie ein Volume mit dem Befehl "Docker Volume Create".

docker volume create todo-db

 2. Löschen Sie die TODO-App, die diese benannten Volumes nicht mit Dashboard verwendet. (Oder entfernen Sie es mit `docker rm -f <container-id>`)
 3. Starten Sie als Nächstes den TODO-App-Container. Geben Sie diesmal die Volume-Bereitstellung mit dem Flag -v an. Dadurch wird das angegebene Volume ausgenutzt und in `/ etc / todos` gemountet. Dadurch können alle im Pfad `/ etc / todos` generierten Dateien auf der Hostseite gespeichert werden.

    ```
docker run -dp 3000:3000 -v todo-db:/etc/todos getting-started

Versuchen Sie nach dem Starten des Containers, einige Elemente hinzuzufügen.
Löschen Sie den TODO-App-Container. Verwenden Sie das Dashboard oder verwenden Sie "Docker ps", um die Container-ID abzurufen, und verwenden Sie dann "Docker rm -f ", um sie zu löschen.
Geben Sie denselben Befehl wie oben gezeigt erneut ein und führen Sie ihn aus
Öffnen Sie die App und Sie sollten sehen, dass Sie das Element haben, das Sie gerade hinzugefügt haben
Löschen Sie den Container nach der Bestätigung wie zuvor.

Jetzt wissen Sie, wie Sie die Daten aufbewahren.

(Ergänzung) Standardmäßig sind zwei Arten von Volumes verfügbar, ** benannte Volumes ** und ** Bind Mount **. Der Hauptunterschied zwischen ihnen ist der Datenverwaltungsort auf der Hostseite. Wie oben gezeigt, waren benannte Volumes in Ordnung, wenn dem Benutzer nur der Volume-Name bekannt war. Mit anderen Worten, es ist Sache des Dockers, zu entscheiden, wo die tatsächlichen Daten gespeichert werden sollen. Mit ** bind mount ** können Sie dann angeben, welches Verzeichnis auf der Hostseite auf welchem Verzeichnis auf der Containerseite gemountet werden soll. Mit anderen Worten kann der Datenverwaltungsort auf der Hostseite beliebig ausgewählt werden.

(Information) Pro-Tipp Named Volumes und Bind Mounts (im nächsten Kapitel erläutert) sind die beiden Hauptvolumes, die standardmäßig bei der Installation der Docker-Engine unterstützt werden. Sie unterstützen jedoch auch NFS, SFTP, NetApp und viele mehr. Es gibt ein Volume-Treiber-Plug-In. Dies ist eine besonders wichtige Technik, wenn Container auf mehreren Hosts in einer Clusterumgebung wie Swarm oder Kubernetes gestartet werden.

Überprüfen Sie die Details der Lautstärke

Sie fragen sich möglicherweise: "Wo sind die gespeicherten Daten bei Verwendung des benannten Volumes?" Wenn Sie es wissen möchten, können Sie es lösen, indem Sie den folgenden Befehl ausführen.

docker volume inspect todo-db
[
    {
        "CreatedAt": "2019-09-26T02:18:36Z",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/todo-db/_data",
        "Name": "todo-db",
        "Options": {},
        "Scope": "local"
    }
]

Mountpoint gibt an, wo die Daten tatsächlich gespeichert sind. Auf vielen Computern benötigen Sie Administratorrechte, um vom Host aus auf dieses Verzeichnis zugreifen zu können, aber die Daten sind mit Sicherheit vorhanden.

(Informationen) Zugriff auf Volumendaten direkt auf Docker Desktop Wenn Sie sich den Mountpoint von todo-db oben ansehen, denken Sie möglicherweise, dass er in einem solchen Verzeichnis nirgendwo vorhanden ist. Beim Starten von Docker Desktop werden die Docker-Befehle tatsächlich in einer kleinen VM auf Ihrem Computer ausgeführt. Wenn Sie also die Daten im Mountpoint-Verzeichnis anzeigen möchten, müssen Sie eine Verbindung innerhalb der VM herstellen. Es gibt viele Möglichkeiten, dies zu tun, wenn Sie googeln.

(Zusammenfassung von Kapitel 5)

Ich konnte eine Anwendung erstellen, die Daten behält, auch wenn ich den Container lösche und neu starte. Wie wir im vorherigen Kapitel gesehen haben, dauert es jedoch einige Zeit, Änderungen am Image vorzunehmen und es neu zu erstellen. Sie können Ihre App mit Bind Mounts besser erstellen. Im nächsten Kapitel werden wir uns mit Bind-Mounts befassen.

6. Verwenden Sie Bind Mounts

Im vorherigen Kapitel haben wir uns angesehen, wie Daten mit ** benanntem Volume ** gespeichert werden. ** benannte Volumes ** sind sehr nützlich, wenn Sie nur die Daten speichern möchten, da Sie sich keine Gedanken darüber machen müssen, wo die tatsächlichen Daten gespeichert sind.

Sie können ** Bind Mounts ** verwenden, um sicherzustellen, dass Sie die Kontrolle darüber haben, wo auf Ihrem Host Sie Mounten möchten. Dies wird ungefähr zum Speichern von Daten verwendet, aber auch, wenn Sie dem Container neue Daten hinzufügen möchten. Sie können den Quellcode beim Starten der Anwendung auf der Containerseite bereitstellen und mithilfe von Bind Mounts den Quellcode ändern und den Vorgang in Echtzeit überprüfen.

Knotenbasierte Anwendungen verfügen über ein Tool namens nodemon, das Dateiänderungen überwacht und die App bei Änderungen in anderen Sprachen und Frameworks neu startet. Hat ein gleichwertiges Werkzeug.

Volumentyp-Vergleichstabelle

Bindungs-Mounts und benannte Volumes sind die Hauptvolumes, die standardmäßig in der Docker-Engine verwendet werden können, aber zusätzlich andere Anwendungsfälle (SFTP). Ceph, [NetApp](https://netappdvp.readthedocs.io/en/ Zur Unterstützung von Stable /), [S3](https: //github.com/elementar/docker-s3-volume) usw. stehen verschiedene Volume-Treiber zur Verfügung.

Starten Sie den Entwicklungsmodus-Container

Gehen Sie wie folgt vor, um einen Container zu starten, der den Entwicklungsworkflow unterstützt:

--Mounten Sie den Quellcode in einem Container --Installieren Sie alle Abhängigkeiten (einschließlich "dev" Abhängigkeiten)

Starten Sie nodemon, um Dateiänderungen zu überwachen

Stellen Sie sicher, dass der Container "Erste Schritte" nicht gestartet ist
Führen Sie den folgenden Befehl aus. Die Bedeutung des Befehls wird später erläutert

docker run -dp 3000:3000 \
    -w /app -v "$(pwd):/app" \
    node:12-alpine \
    sh -c "yarn install && yarn run dev"

Wenn Sie PowerShell verwenden, verwenden Sie bitte den folgenden Befehl.

docker run -dp 3000:3000 `
    -w /app -v "$(pwd):/app" `
    node:12-alpine `
    sh -c "yarn install && yarn run dev"

---dp 3000: 3000: Beginnen Sie mit dem Hintergrund und ordnen Sie Port 3000 auf der Hostseite Port 3000 auf der Containerseite zu. ---w / app: Einstellen des Arbeitsverzeichnisses. Wenn der Befehl ausgeführt wird, wird das hier angegebene Verzeichnis zum aktuellen Verzeichnis. ---v "$ (pwd): / app" : Hängt das aktuelle Verzeichnis auf der Hostseite und das Verzeichnis / app auf der Containerseite ein. --node: 12-plpine: Zu verwendendes Bild. Beachten Sie, dass dies ein anwendungsbasiertes Image aus der Docker-Datei ist. --sh -c "Garninstallation && Garnlauf-Entwickler": Starten Sie die Shell mit "sh" (es gibt keine "Bash" in alpine), und führen Sie dann "Garninstallation" aus, um alle Abhängigkeiten und zu installieren Führen Sie yarn run dev aus. Wie Sie unter package.json sehen können, startet das Ausführen des dev-Skripts nodemon`.

1. Überprüfen Sie die Protokolle mit Docker-Protokollen -f . Wenn das Display wie das folgende aussieht, können Sie loslegen.

docker logs -f <container-id>
$ nodemon src/index.js
[nodemon] 1.19.2
[nodemon] to restart at any time, enter `rs`
[nodemon] watching dir(s): *.*
[nodemon] starting `node src/index.js`
Using sqlite database at /etc/todos/todo.db
Listening on port 3000

Wenn Sie das Protokoll überprüfen können, drücken Sie zum Beenden Strg + C.

Jetzt ändern wir die App. Ändern Sie die Zeile 109 von "src / static / js / app.js" wie folgt.
Aktualisieren (oder öffnen) Sie die Seite, damit die Änderungen sofort wirksam werden. Es dauert einige Sekunden, bis der Knotenserver neu gestartet wird. Wenn Sie eine Fehlermeldung erhalten, versuchen Sie es mit einer Aktualisierung.
Fühlen Sie sich frei, Änderungen vorzunehmen. Wenn Sie zufrieden sind, stoppen Sie den Container und erstellen Sie ein neues Image mit "Docker Build -t Getting Started".

Bindungs-Mounts werden häufig verwendet, um eine lokale Entwicklungsumgebung zu erstellen. Der Vorteil ist, dass die Entwicklungsmaschine keine Build-Tools benötigt. Einfach "Docker Run" und die Entwicklungsumgebung wird gezogen und bereit. Wir werden in Zukunft über Docker Compose sprechen, was den Befehl vereinfachen kann.

(Kapitel 6 Zusammenfassung)

Wir haben gesehen, wie Sie die Datenbank beibehalten und schneller auf Ihre Bedürfnisse und Anforderungen reagieren können. Um sich auf die Produktionsumgebung vorzubereiten, müssen wir die Datenbank von SQLite auf etwas verschieben, das einfacher skaliert werden kann. Der Einfachheit halber verwenden wir hier eine relationale Datenbank und aktualisieren sie, um MySQL in Ihrer Anwendung zu verwenden. Wir werden im nächsten Kapitel sehen, wie die Container die Kommunikation untereinander ermöglichen.

7. Multi-Container-Anwendung

Bisher haben wir uns mit Einzelcontaineranwendungen befasst, aber als nächstes möchten wir MySQL zur TODO-App hinzufügen. Möglicherweise haben Sie Fragen wie "Wo starten Sie MySQL?" "Im selben Container installieren oder unabhängig starten?" Im Allgemeinen sollte in jedem Container eines getan werden. Der Grund ist wie folgt.

Es ist durchaus möglich, dass Sie die API und das Front-End unabhängig von der Datenbank skalieren möchten.
Indem Sie jeden Container unabhängig machen, können Sie Updates und Versionsverwaltung unabhängig voneinander durchführen.
Es ist geeignet, wenn Sie keine Datenbank in Ihrer Anwendung erstellen müssen und einen verwalteten Dienst für eine Produktionsdatenbank verwenden möchten.
Zum Starten mehrerer Prozesse ist ein separater Prozessmanager erforderlich (ein Container kann nur einen Prozess starten). Dies erschwert das Starten und Herunterfahren.

Es gibt viele andere Gründe. Hier konfigurieren wir die Anwendung wie folgt.

Containernetzwerke

Standardmäßig werden Container unabhängig von anderen Prozessen ausgeführt und können auch auf demselben Computer nicht mit anderen Containern / Prozessen verbunden werden. Wie kann ich einen Container mit einem anderen Container verbinden? Die Antwort lautet ** Vernetzung **. Sie müssen nicht die gleichen Kenntnisse wie ein Netzwerktechniker haben. Denken Sie nur an Folgendes.

Wenn sich zwei Container im selben Netzwerk befinden, können sie eine Verbindung miteinander herstellen

Starten Sie MySql

Es gibt zwei Möglichkeiten, den Container im Netzwerk zu platzieren. 1) Platzieren Sie das Netzwerk beim Start. 2) Stellen Sie eine Verbindung zum gestarteten Container her. Hier erstellen wir zuerst ein Netzwerk und hängen es an, wenn der MySQL-Container startet.

Erstellen Sie ein Netzwerk

docker network create todo-app

 2. Starten Sie MySQL und schließen Sie das Netzwerk an. Einige Umgebungsvariablen werden festgelegt, um die Datenbank zu initialisieren. (Wenn Sie weitere Informationen wünschen, überprüfen Sie bitte [MuSQL Docker Hub-Liste](https://hub.docker.com/_/mysql/).)

    ```
docker run -d \
    --network todo-app --network-alias mysql \
    -v todo-mysql-data:/var/lib/mysql \
    -e MYSQL_ROOT_PASSWORD=secret \
    -e MYSQL_DATABASE=todos \
    mysql:5.7

Wenn Sie PowerShell verwenden, verwenden Sie bitte den folgenden Befehl.

```

docker run -d --network todo-app --network-alias mysql -v todo-mysql-data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=secret -e MYSQL_DATABASE=todos ` mysql:5.7

 Sie können sehen, dass zusätzlich zu den Umgebungsvariablen für die Datenbankinitialisierung das Flag "--network-alias" vorhanden ist. Wir werden später darüber sprechen.

    > (Pro-tip)
 Im obigen Befehl wird das benannte Volume "todo-mysql-data" verwendet, um es in / var / lib / mysql, dem Datenspeicherziel von MYSQL, bereitzustellen. Ich habe das Volume jedoch nicht mit dem Befehl "Docker Volume Create" erstellt. Docker erstellt automatisch einen neuen benannten Datenträgernamen, falls angegeben.

 3. Stellen Sie eine Verbindung her, um sicherzustellen, dass die Datenbank ausgeführt wird

    ```
docker exec -it <mysql-container-id> mysql -p

Sie werden nach einem Passwort gefragt, geben Sie also "secret" ein. Überprüfen Sie die "todos" -Datenbank, wenn Sie die MySQL-Shell aufrufen.

```

mysql>　SHOW DATABASES;

 Sie sollten eine Ausgabe ähnlich der folgenden erhalten:

    ```
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
| todos              |
+--------------------+
5 rows in set (0.00 sec)

Sie wissen, dass die ToDo-Datenbank bereit ist.

Stellen Sie eine Verbindung zu MySQL her

Nachdem wir bestätigt haben, dass MySQL ausgeführt wird, verwenden wir es. Nur wie ...? Wenn Sie einen anderen Container im selben Netzwerk haben, wie finden Sie diesen Container (obwohl ich mich erinnere, dass jeder Container eine IP hat)?

Um dies zu verstehen, verwenden Sie den Container nicolaka / netshoot. In diesem Container sind eine Reihe nützlicher Tools zur Fehlerbehebung und zum Debuggen im Netzwerk installiert.

Starten Sie einen neuen Container mit dem Bild nicolaka / netshoot. Vergessen Sie nicht, eine Verbindung zum selben Netzwerk herzustellen.

docker run -it --network todo-app nicolaka/netshoot

 2. Wenn Sie den obigen Befehl eingeben, wird er in den Container eingegeben. Führen Sie daher den Befehl `dig` aus (dieser Befehl ist ein praktisches DNS-Tool). Überprüfen Sie die IP-Adresse des Hostnamens "mysql".

    ```
dig mysql

Sie erhalten folgende Ausgabe:

```

; <<>> DiG 9.14.1 <<>> mysql ;; global options: +cmd ;; Got answer: ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 32162 ;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0 ;; QUESTION SECTION: ;mysql. IN A ;; ANSWER SECTION: mysql. 600 IN A 172.23.0.2 ;; Query time: 0 msec ;; SERVER: 127.0.0.11#53(127.0.0.11) ;; WHEN: Tue Oct 01 23:47:24 UTC 2019 ;; MSG SIZE rcvd: 44


 Wenn Sie sich "ANTWORT ABSCHNITT" ansehen, sehen Sie den "A" -Datensatz des Hostnamens "mysql", der in die IP-Adresse 172.23.0.2 aufgelöst wurde. (Die IP-Adresse hängt von der Umgebung ab.) Normalerweise ist `mysql` kein gültiger Hostname, aber Docker kann die IP-Adresse eines Containers mit einem Netzwerkalias auflösen (erinnern Sie sich an das Flag` --network-alias`, oder?).
 Dies bedeutet, dass Sie eine Verbindung zur Datenbank herstellen können, indem Sie einfach über die TODO-App eine Verbindung zum Hostnamen "mysql" herstellen. Es ist nie einfacher!

### Verbinden Sie die TODO-App mit MySQL und starten Sie sie
 Die TODO-App unterstützt das Festlegen einiger Umgebungsvariablen für MySQL-Verbindungen. Die folgenden vier.

 --`MYSQL_HOST`: Der Name des Hosts, auf dem der MySQL-Server ausgeführt wird
 --`MYSQL_USER`: Benutzername für die Verbindung
 --`MYSQL_PASSWORD`: Passwort für die Verbindung
 --`MYSQL_DB`: Zu verwendender Datenbankname

 > Achtung!
 Die Verwendung von Umgebungsvariablen zum Einrichten von Verbindungen ist in einer Entwicklungsumgebung in Ordnung, wird jedoch definitiv nicht empfohlen, wenn Apps in einer Produktionsumgebung ausgeführt werden. Der frühere Docker-Sicherheitsleiter Diogo Monica erklärt, warum [großartiger Blog-Beitrag](https://diogomonica.com/2017/03/27/why-you-shouldnt-use-env-variables-for-secret-data/ ).

 Starten wir nun den Entwicklungsumgebungscontainer.

 1. Verbinden Sie den MySQL-Container mit dem TODO-App-Netzwerk, indem Sie die oben genannten Umgebungsvariablen angeben.

    ```
docker run -dp 3000:3000 \
  -w /app -v "$(pwd):/app" \
  --network todo-app \
  -e MYSQL_HOST=mysql \
  -e MYSQL_USER=root \
  -e MYSQL_PASSWORD=secret \
  -e MYSQL_DB=todos \
  node:12-alpine \
  sh -c "yarn install && yarn run dev"

Wenn Sie PowerShell verwenden, verwenden Sie den folgenden Befehl.

```

docker run -dp 3000:3000 -w /app -v "$(pwd):/app" --network todo-app -e MYSQL_HOST=mysql -e MYSQL_USER=root -e MYSQL_PASSWORD=secret -e MYSQL_DB=todos node:12-alpine sh -c "yarn install && yarn run dev"

 2. Wenn Sie die Containerprotokolle mit dem Befehl `docker logs <container-id>` überprüfen, können Sie sehen, dass Sie die MySQL-Datenbank verwenden.

    ```
# Previous log messages omitted
$ nodemon src/index.js
[nodemon] 1.19.2
[nodemon] to restart at any time, enter `rs`
[nodemon] watching dir(s): *.*
[nodemon] starting `node src/index.js`
Connected to mysql db at host mysql
Listening on port 3000
```　
 3. Öffnen Sie die TODO-App in Ihrem Browser und versuchen Sie, einige Elemente hinzuzufügen.
 4. Versuchen Sie, eine Verbindung zur MySQL-Datenbank herzustellen, und stellen Sie sicher, dass die von Ihnen hinzugefügten Elemente definitiv zur Datenbank hinzugefügt wurden. Das Passwort ist ** geheim **.

    ```
docker exec -ti <mysql-container-id> mysql -p todos

Führen Sie nach dem Aufrufen der MySQL-Shell den folgenden Befehl aus.

```

mysql> select * from todo_items; +--------------------------------------+--------------------+-----------+ | id | name | completed | +--------------------------------------+--------------------+-----------+ | c906ff08-60e6-44e6-8f49-ed56a0853e85 | Do amazing things! | 0 | | 2912a79e-8486-4bc3-a4c5-460793a575ab | Be awesome! | 0 | +--------------------------------------+--------------------+-----------+

 Der Name ändert sich je nach hinzugefügtem Element, aber ich konnte bestätigen, dass es sicher gespeichert wurde.

 Überprüfen Sie das Docker Dashboard. Sie können sehen, dass die beiden Container ausgeführt werden, sie sind jedoch nicht in einer App zusammengefasst. Jeder Container wird unabhängig gestartet, aber die TODO-App ist mit dem MySQL-Container verbunden.

### (Kapitel 7 Zusammenfassung)
 Ich habe die TODO-App-Daten in einem separaten externen MySQL-Container gespeichert. Erfahren Sie dann etwas über das Containernetzwerk [Service Discovery](https://ja.wikipedia.org/wiki/%E3%82%B5%E3%83%BC%E3%83%93%E3%82%B9) Verwenden Sie DNS, um zu sehen, wie% E3% 83% 87% E3% 82% A3% E3% 82% B9% E3% 82% AB% E3% 83% 90% E3% 83% AA) implementiert ist Ich habe es bestätigt.

 Ich war jedoch ein wenig überfordert, weil ich ein Netzwerk erstellen, einen Container starten, Umgebungsvariablen angeben, Ports öffnen und viele andere Dinge tun musste, um eine Anwendung zu starten. Es kann gewesen sein. Ich kann mich nicht an so viele Dinge erinnern und es ist schwer, es jemandem zu erzählen.
 Das nächste Kapitel beschreibt Docker Compose. Mit Docker Compose können Sie Ihre Anwendung auf viel einfachere Weise für andere freigeben und die in diesem Kapitel behandelten Apps mit einfachen Befehlen starten.

## 8. Verwenden Sie Docker Compose
 [Docker Compose](https://docs.docker.com/compose/) ist ein Tool, mit dem Sie Anwendungen mit mehreren Containern definieren und gemeinsam nutzen können. Mit Docker Compose können Sie einen Dienst in einer YAML-Datei definieren und den Dienst mit einem einzigen Befehl starten oder zerstören.
 Der Vorteil von Docker Compose besteht darin, dass Sie Ihre Anwendung in einer Datei definieren können (platzieren Sie die Datei in der Stammrichtung Ihres Projekts) und es einer anderen Person erleichtern können, sich Ihrem Projekt anzuschließen. Wenn Sie dem Projekt beitreten möchten, müssen Sie lediglich das Repository klonen und die Anwendung mit dem Befehl Docker Compose starten. Es gibt viele Projekte, die dies auf Github und GitLab verwenden.

### Installieren Sie Docker Compose
 Wenn Sie Docker Desktop / Toolbox auf Ihrem Windows oder Mac installiert haben, ist Docker Compose bereits installiert. Docker Compose ist bereits für Play-with-Docker installiert. Wenn Sie Linux verwenden, führen Sie die folgenden Schritte aus (https://docs.docker.com/compose/install/), um die Installation durchzuführen.

 Nach der Installation können Sie die Versionsinformationen mit dem folgenden Befehl überprüfen.

docker-compose version


### Erstellen Sie eine Docker Compose-Datei

 1. Erstellen Sie eine Docker-compose.yml-Datei (Compose-Datei) im Stammverzeichnis Ihres Projekts
 2. Schreiben Sie zunächst die Schemaversion in die Erstellungsdatei. In den meisten Fällen ist es am besten, die neueste Version zu verwenden. Die Referenz der Compose-Datei (https://docs.docker.com/compose/compose-file/) enthält die aktuelle Schemaversion und Kompatibilitätstabelle.

    ```
version: 3.7

Definieren Sie als Nächstes die Liste der Dienste (oder Container), die Sie als Anwendung starten möchten.

version: "3.7" services:

 Als nächstes werde ich den Dienst zum Erstellen von Dateien erläutern.

### Definieren Sie den Dienst der App
 Rufen Sie den folgenden Befehl auf, mit dem der Container für die App definiert wurde.

docker run -dp 3000:3000
-w /app -v "$(pwd):/app"
--network todo-app
-e MYSQL_HOST=mysql
-e MYSQL_USER=root
-e MYSQL_PASSWORD=secret
-e MYSQL_DB=todos
node:12-alpine
sh -c "yarn install && yarn run dev"

 Wenn Sie PowerShell verwenden, war dies der folgende Befehl.


 1. Registrieren Sie zunächst den Dienst und definieren Sie das Container-Image. Sie können den Namen des Dienstes nach Ihren Wünschen festlegen. Dieser Name wird automatisch zu einem Alias für Ihr Netzwerk. Dieser Alias ist nützlich zum Definieren von MySQL-Diensten.

    ```
version: "3.7"
services:
  app:
    image: node:12-alpine

Normalerweise wird der "Befehl" in der Nähe der Definition von "Bild" platziert, aber es gibt keine Einschränkung für die Reihenfolge.

version: "3.7" services: app: image: node:12-alpine command: sh -c "yarn install && yarn run dev"

 3. Schauen wir uns als nächstes den in `ports` definierten Befehl` -p 3000 3000` an. Die Beschreibung hier lautet [kurze Syntax](https://docs.docker.com/compose/compose-file/#short-syntax-1) und ist detaillierter [lange Syntax](https: //). Es gibt auch eine Variable docs.docker.com/compose/compose-file/#long-syntax-1).

    ```
version: "3.7"
services:
  app:
    image: node:12-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000

Als nächstes folgt das durch working_dir ( -w / app) definierte Arbeitsverzeichnis und die durch volume (-v "$ (pwd): / app") definierte Volume-Zuordnung. Ebenfalls auf dem Volume Short und Long / # long-syntax-3) Es gibt eine Syntax.

version: "3.7" services: app: image: node:12-alpine command: sh -c "yarn install && yarn run dev" ports: - 3000:3000 working_dir: /app volumes: - ./:/app


 5. Schließlich gibt es die "Umgebung", die die Umgebungsvariablen definiert.

    ```
version: "3.7"
services:
  app:
    image: node:12-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: secret
      MYSQL_DB: todos

Definition des MySQL-Dienstes

Definieren wir den MySQL-Dienst. Als ich den Container erstellt habe, habe ich den folgenden Befehl verwendet.

docker run -d \
  --network todo-app --network-alias mysql \
  -v todo-mysql-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=secret \
  -e MYSQL_DATABASE=todos \
  mysql:5.7

Im Fall von PowerShell ist dies wie folgt.

docker run -d `
  --network todo-app --network-alias mysql `
  -v todo-mysql-data:/var/lib/mysql `
  -e MYSQL_ROOT_PASSWORD=secret `
  -e MYSQL_DATABASE=todos `
  mysql:5.7

Definieren wir zunächst einen neuen Dienst mit dem Namen "mysql". Zu diesem Zeitpunkt wird mysql automatisch zu einem Netzwerkalias. Geben Sie das Bild wie beim Definieren der App an.

version: "3.7" services: app: # The app service definition mysql: image: mysql:5.7

 2. Als nächstes folgt die Definition der Volumenzuordnung. Das benannte Volume wird automatisch erstellt, wenn Sie den Container mit dem Befehl "docker run" starten. Im Fall von "Docker Compose" wird es jedoch nicht automatisch erstellt. Sie müssen `volume:` definieren und den Einhängepunkt angeben. Geben Sie einfach den Datenträgernamen an und die Standardoptionen werden verwendet. Es gibt auch viele Optionen (https://docs.docker.com/compose/compose-file/#volume-configuration-reference).

    ```
version: "3.7"
services:
  app:
    # The app service definition
  mysql:
    image: mysql:5.7
    volumes:
      - todo-mysql-data:/var/lib/mysql
volumes:
  todo-mysql-data:

Geben Sie abschließend die Umgebungsvariablen an.

version: "3.7" services: app: # The app service definition mysql: image: mysql:5.7 volumes: - todo-mysql-data:/var/lib/mysql environment: MYSQL_ROOT_PASSWORD: secret MYSQL_DATABASE: todos volumes: todo-mysql-data:

 Bis zu diesem Punkt fasst "docker-compose.yml" wie folgt zusammen.

    ```
version: "3.7"
services:
  app:
    image: node:12-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: secret
      MYSQL_DB: todos
  mysql:
    image: mysql:5.7
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: todos
volumes:
  todo-mysql-data:

Beginnen wir mit der Anwendung

Nachdem Sie "docker-compose.yml" erstellt haben, starten wir die App.

Stellen Sie sicher, dass keine andere App oder Kopie der Datenbank ausgeführt wird. (Überprüfen Sie die ID mit docker ps und löschen Sie sie mit rm if <ids>)
Starten Sie die Anwendung mit dem Befehl docker compose up. Fügen Sie zu diesem Zeitpunkt das Flag "-d" hinzu, um es im Hintergrund zu starten.

docker-compose up -d

 Sie erhalten die folgende Ausgabe.

    ```
Creating network "app_default" with the default driver
Creating volume "app_todo-mysql-data" with default driver
Creating app_app_1   ... done
Creating app_mysql_1 ... done

Sie können sehen, dass sowohl das Volume als auch das Netzwerk erstellt werden. Docker Compose erstellt das Netzwerk standardmäßig automatisch. Daher habe ich die Netzwerkerstellung in docker-compose.yml nicht definiert. 3. Überprüfen Sie die Protokolle mit dem Befehl docker-compose logs -f. Sie können sehen, dass das Protokoll für jeden Dienst in einer Zeile ausgegeben wird. Dieses Protokoll ist nützlich, wenn Sie zeitbezogene Störungen überwachen möchten. Das "-f" -Flag soll dem Protokoll "folgen", damit es sofort gedruckt wird, wenn das Protokoll erstellt wird.

```

mysql_1 | 2019-10-03T03:07:16.083639Z 0 [Note] mysqld: ready for connections. mysql_1 | Version: '5.7.27' socket: '/var/run/mysqld/mysqld.sock' port: 3306 MySQL Community Server (GPL) app_1 | Connected to mysql db at host mysql app_1 | Listening on port 3000

 Der Dienstname wird am Anfang aufgelistet, um die Nachrichten von jedem Dienst zu unterscheiden. Wenn Sie nur einen bestimmten Dienst protokollieren möchten, fügen Sie den Dienstnamen am Ende hinzu, z. B. mit dem Befehl "docker-comopse log -f app".
 > (Nützliche Informationen) Warten Sie auf DB, bis die App gestartet wird
 Wenn die Anwendung ausgeführt wird, wartet die App auf den Start von MySQL und ist bereit, bevor die Verbindung hergestellt wird. Docker bietet keine integrierte Unterstützung für das Warten, bis ein anderer Container vollständig gestartet und bereit ist, bevor ein anderer Container gestartet wird. Bei knotenbasierten Projekten können Sie die Warteportabhängigkeit nutzen. Ähnliche Projekte existieren in anderen Sprachen und Frameworks.
 4. An diesem Punkt können Sie sehen, dass die Anwendung ausgeführt wird. Sie können sehen, dass es mit nur einem Befehl ausgeführt werden kann!

### Überprüfen Sie die App im Docker Dashboard
 Wenn Sie das Docker-Dashboard öffnen, können Sie sehen, was unter dem Namen ** app ** gruppiert ist. Dies ist der von Docker Compose zugewiesene Projektname, der mehrere Container zu einem kombiniert. Der Projektname ist standardmäßig der Verzeichnisname, in dem sich "docker-compose.yml" befindet.
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/187747/1a051b66-4da8-6c24-a001-0e5437544cee.png)

 Wenn Sie die App erweitern, werden die beiden in der Erstellungsdatei definierten Container angezeigt. Jeder Name ist leicht verständlich geschrieben und hat das Format "<Projektname> _ <Dienstname> _ <Replikatnummer>". Dies ist also der Container der App und die Datenbank von MySQL Sie können auf einen Blick erkennen.
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/187747/2cebbc84-3cdf-105b-2b23-062c630f95a4.png)

### Halten Sie an und löschen Sie den Container
 Wenn Sie den Container anhalten und löschen möchten, verwenden Sie den Befehl "Docker-Compose Down" oder klicken Sie im Docker-Dashboard auf das Papierkorbsymbol. Der Container wird gestoppt und das Netzwerk gelöscht.

 > Volume löschen
 Mit den Standardeinstellungen wird das benannte Volume ** nicht gelöscht **, wenn es mit dem Befehl `docker-compose down` gestoppt wird. Wenn Sie es entfernen möchten, müssen Sie das Flag "--volumes" hinzufügen.
 Das benannte Volume wird nicht gelöscht, auch wenn es vom Docker Dashboard gelöscht wird.

 Nach dem Stoppen und Löschen können Sie ein weiteres Projekt mit "Docker-Compose Up" starten.

### (Zusammenfassung von Kapitel 8)
 In diesem Abschnitt haben Sie Docker Compose kennengelernt und festgestellt, dass das Definieren und Freigeben von Multi-Service-Anwendungen erheblich einfacher ist. Ich habe auch eine Erstellungsdatei erstellt, indem ich Befehle entsprechend dem entsprechenden Erstellungsformat geschrieben habe.

 Damit ist das Tutorial abgeschlossen. Die Docker-Dateien, die ich bisher verwendet habe, haben jedoch große Probleme. Daher werde ich in den folgenden Kapiteln die Best Practices für die Image-Erstellung beschreiben, um mehr darüber zu erfahren.



 Das ist vorerst alles.
 Ich werde die nächsten Kapitel 9 und 10 nach Bedarf hinzufügen.

 Kapitel 9: Best Practices für die Image-Erstellung
 Kapitel 10: Was ist als nächstes zu tun?

[Einführung in Docker] Offizielles Tutorial (japanische Übersetzung)