Docker Command Not Found auf dem Mac: Fehlerbehebung und Einrichtung Ihrer Docker-Umgebung

Einführung

Docker hat die Anwendungsentwicklung revolutioniert, indem es Entwicklern ermöglicht, Anwendungen in isolierten Umgebungen, sogenannten Containern, zu erstellen, bereitzustellen und auszuführen. Mac-Benutzer stoßen manchmal auf den Fehler "docker command not found", was frustrierend sein kann, wenn man mit der Containerisierung beginnt. Dieses Lab führt Sie durch das Verständnis von Docker-Konzepten, die Überprüfung Ihrer Docker-Installation, die Fehlerbehebung bei häufigen Problemen und die Einrichtung einer geeigneten Docker-Umgebung für Ihre Entwicklungsarbeit.

Docker-Grundlagen verstehen und Installation überprüfen

Docker bietet eine standardisierte Möglichkeit, Anwendungen und ihre Abhängigkeiten in Containern zu verpacken, wodurch sie über verschiedene Umgebungen hinweg portierbar werden. Bevor wir Docker-Probleme beheben, wollen wir sicherstellen, dass wir die Grundlagen verstehen und unsere Installation überprüfen.

Was ist Docker?

Docker ist eine Plattform, die Containerisierungstechnologie verwendet, um das Erstellen, Bereitstellen und Ausführen von Anwendungen zu erleichtern. Im Gegensatz zu virtuellen Maschinen teilen sich Docker-Container den Kernel des Host-Systems, laufen aber in isolierten Umgebungen, was sie leichtgewichtig und effizient macht.

Wichtige Komponenten von Docker sind:

Docker Engine: Die Laufzeitumgebung, die Container erstellt und ausführt
Docker Images: Nur-Lese-Vorlagen, die zum Erstellen von Containern verwendet werden
Docker Container: Laufende Instanzen von Docker Images
Docker Registry: Ein Repository zum Speichern und Teilen von Docker Images
Dockerfile: Eine Textdatei mit Anweisungen zum Erstellen eines Docker Images

Überprüfen der Docker-Installation

Unsere Lab-Umgebung hat Docker bereits installiert. Überprüfen wir dies, indem wir die Docker-Version überprüfen:

docker --version

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Docker version 20.10.21, build 20.10.21-0ubuntu1~22.04.3

Überprüfen wir nun, ob der Docker-Daemon läuft:

sudo systemctl status docker

Sie sollten eine Ausgabe sehen, die anzeigt, dass Docker aktiv (läuft) ist. Die Ausgabe sieht ähnlich aus wie:

● docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since ...

Drücken Sie q, um die Statusansicht zu verlassen.

Wenn Docker aus irgendeinem Grund nicht läuft, können Sie es mit folgendem Befehl starten:

sudo systemctl start docker

Ihren ersten Container ausführen

Überprüfen wir, ob Docker korrekt funktioniert, indem wir einen einfachen "hello-world"-Container ausführen:

docker run hello-world

Dieser Befehl lädt das hello-world-Image herunter, falls es noch nicht lokal verfügbar ist, und führt es in einem Container aus. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Hello from Docker!
This message shows that your installation appears to be working correctly.
...

Die Ausgabe erklärt, was Docker getan hat, um diesen Container auszuführen, und bietet eine gute Einführung in die Funktionsweise von Docker.

Laufende Container überprüfen

Um alle aktuell laufenden Container anzuzeigen, verwenden Sie:

docker ps

Da der hello-world-Container sofort nach der Anzeige seiner Nachricht beendet wird, werden Sie ihn wahrscheinlich nicht in dieser Liste sehen. Um alle Container anzuzeigen, einschließlich derer, die gestoppt wurden, verwenden Sie:

docker ps -a

Dies zeigt alle Container, ihre IDs, die Images, aus denen sie erstellt wurden, wann sie erstellt wurden und ihren aktuellen Status.

Nun haben Sie überprüft, dass Docker in Ihrer Umgebung installiert ist und korrekt funktioniert, und Sie haben Ihren ersten Container ausgeführt!

Arbeiten mit Docker Images und Containern

Nachdem Sie nun überprüft haben, dass Docker korrekt funktioniert, wollen wir detaillierter lernen, wie man mit Docker Images und Containern arbeitet.

Docker Images verstehen

Docker Images sind die Blaupausen für Container. Sie enthalten den Anwendungscode, Bibliotheken, Abhängigkeiten, Tools und andere Dateien, die für die Ausführung einer Anwendung benötigt werden.

Lassen Sie uns Docker Images mit einigen grundlegenden Befehlen erkunden:

Verfügbare Images auflisten

Um alle auf Ihrem System verfügbaren Docker Images anzuzeigen:

docker images

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    feb5d9fea6a5   X months ago    13.3kB

Images von Docker Hub abrufen

Docker Hub ist ein Cloud-basierter Registry-Dienst, in dem Sie Docker Images finden und teilen können. Lassen Sie uns ein beliebtes Image abrufen:

docker pull nginx

Dieser Befehl lädt das neueste nginx Webserver-Image herunter. Sie sehen eine Fortschrittsausgabe, während verschiedene Ebenen des Images heruntergeladen werden:

Using default tag: latest
latest: Pulling from library/nginx
...
Digest: sha256:...
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest

Führen Sie docker images erneut aus, um das neu heruntergeladene nginx Image in Ihrer Liste zu sehen.

Arbeiten mit Containern

Nachdem wir nun einige Images haben, wollen wir lernen, wie man Container erstellt und verwaltet.

Einen Container ausführen

Lassen Sie uns einen nginx Container ausführen, der eine Webseite bereitstellt:

docker run --name my-nginx -p 8080:80 -d nginx

Dieser Befehl tut mehrere Dinge:

--name my-nginx: Benennt den Container "my-nginx"
-p 8080:80: Ordnet Port 8080 auf Ihrem Host Port 80 im Container zu
-d: Führt den Container im Detached-Modus (im Hintergrund) aus
nginx: Gibt das zu verwendende Image an

Überprüfen, ob der Container läuft

Überprüfen Sie, ob Ihr Container läuft:

docker ps

Sie sollten Ihren nginx Container in der Liste der laufenden Container sehen:

CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                  NAMES
a1b2c3d4e5f6   nginx     "/docker-entrypoint.…"   X seconds ago    Up X seconds    0.0.0.0:8080->80/tcp   my-nginx

Auf den Webserver zugreifen

Sie können auf den nginx Webserver zugreifen, indem Sie in Ihrer LabEx VM-Umgebung einen Webbrowser öffnen und zu Folgendem navigieren:

http://localhost:8080

Alternativ können Sie curl vom Terminal aus verwenden:

curl http://localhost:8080

Sie sollten die Standard-HTML-Willkommensseite von nginx sehen.

Container-Logs anzeigen

Um die Logs für Ihren Container anzuzeigen:

docker logs my-nginx

Dies zeigt die Zugriffsprotokolle für den nginx Server.

Container stoppen und entfernen

Um einen laufenden Container zu stoppen:

docker stop my-nginx

Um einen Container zu entfernen (er muss zuerst gestoppt werden):

docker rm my-nginx

Überprüfen Sie, ob der Container entfernt wurde:

docker ps -a

Der Container mit dem Namen "my-nginx" sollte nicht mehr in der Liste erscheinen.

Nun verstehen Sie die Grundlagen der Arbeit mit Docker Images und Containern. Sie haben Images von Docker Hub abgerufen, Container ausgeführt, Ports zugeordnet, Logs angezeigt und Container-Lebenszyklen verwaltet.

Erstellen Ihrer eigenen Docker Images mit Dockerfiles

Bisher haben wir vorgefertigte Docker Images von Docker Hub verwendet. Lassen Sie uns nun lernen, wie man mit Dockerfiles eigene, benutzerdefinierte Docker Images erstellt.

Was ist ein Dockerfile?

Ein Dockerfile ist eine Textdatei, die Anweisungen zum Erstellen eines Docker Images enthält. Es gibt das Basis-Image an, fügt Dateien hinzu, installiert Software, legt Umgebungsvariablen fest und konfiguriert den Container, der aus dem Image erstellt wird.

Erstellen Ihres ersten Dockerfiles

Lassen Sie uns eine einfache Webanwendung mit Node.js erstellen und sie als Docker Image verpacken.

Erstellen Sie zuerst ein neues Verzeichnis für Ihr Projekt:

mkdir -p ~/project/node-app
cd ~/project/node-app

Erstellen Sie nun eine einfache Node.js-Anwendung. Erstellen Sie zuerst eine Datei namens app.js:

nano app.js

Fügen Sie der Datei den folgenden Code hinzu:

const http = require("http");

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader("Content-Type", "text/plain");
  res.end("Hello World from Docker!\n");
});

const port = 3000;
server.listen(port, () => {
  console.log(`Server running at http://localhost:${port}/`);
});

Speichern Sie die Datei, indem Sie Ctrl+O, dann Enter drücken, und beenden Sie nano mit Ctrl+X.

Erstellen Sie als Nächstes eine package.json-Datei, um Ihre Node.js-Anwendung zu definieren:

nano package.json

Fügen Sie den folgenden Inhalt hinzu:

{
  "name": "docker-node-app",
  "version": "1.0.0",
  "description": "A simple Node.js app for Docker",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "author": "",
  "license": "ISC"
}

Speichern und beenden Sie nano.

Erstellen Sie nun ein Dockerfile:

nano Dockerfile

Fügen Sie den folgenden Inhalt hinzu:

## Use an official Node.js runtime as the base image
FROM node:14-alpine

## Set the working directory in the container
WORKDIR /usr/src/app

## Copy package.json and package-lock.json
COPY package.json ./

## Install dependencies
RUN npm install

## Copy the application code
COPY app.js ./

## Expose the port the app runs on
EXPOSE 3000

## Command to run the application
CMD ["npm", "start"]

Speichern und beenden Sie nano.

Erstellen Ihres Docker Images

Nachdem Sie nun ein Dockerfile haben, können Sie Ihr Docker Image erstellen:

docker build -t my-node-app .

Dieser Befehl erstellt ein Image aus Ihrem Dockerfile:

-t my-node-app: Taggt das Image mit dem Namen "my-node-app"
.: Gibt an, dass sich das Dockerfile im aktuellen Verzeichnis befindet

Sie sehen eine Ausgabe, die den Build-Fortschritt anzeigt:

Sending build context to Docker daemon  X.XXkB
Step 1/7 : FROM node:14-alpine
 ---> XXXXXXXXXX
Step 2/7 : WORKDIR /usr/src/app
 ---> XXXXXXXXXX
...
Successfully built XXXXXXXXXX
Successfully tagged my-node-app:latest

Ausführen Ihres benutzerdefinierten Docker Images

Führen Sie nun einen Container mit Ihrem neu erstellten Image aus:

docker run --name node-app-container -p 3000:3000 -d my-node-app

Überprüfen Sie, ob der Container läuft:

docker ps

Sie sollten Ihren Container in der Liste sehen:

CONTAINER ID   IMAGE         COMMAND         CREATED          STATUS          PORTS                    NAMES
XXXXXXXXXX     my-node-app   "npm start"     X seconds ago    Up X seconds    0.0.0.0:3000->3000/tcp   node-app-container

Testen Ihrer Anwendung

Testen Sie die Anwendung, indem Sie eine HTTP-Anfrage an sie senden:

curl http://localhost:3000

Sie sollten Folgendes sehen:

Hello World from Docker!

Das Dockerfile verstehen

Lassen Sie uns die Schlüsselkomponenten unseres Dockerfiles überprüfen:

FROM node:14-alpine: Gibt das zu verwendende Basis-Image an
WORKDIR /usr/src/app: Legt das Arbeitsverzeichnis innerhalb des Containers fest
COPY package.json ./: Kopiert Dateien vom Host in den Container
RUN npm install: Führt während des Build-Prozesses einen Befehl innerhalb des Containers aus
EXPOSE 3000: Dokumentiert, dass der Container Port 3000 abhört
CMD ["npm", "start"]: Gibt den Befehl an, der beim Start des Containers ausgeführt werden soll

Bereinigung

Lassen Sie uns aufräumen, indem wir den Container stoppen und entfernen:

docker stop node-app-container
docker rm node-app-container

Sie haben nun gelernt, wie Sie mit Dockerfiles Ihre eigenen Docker Images erstellen, diese Images erstellen und Container basierend auf ihnen ausführen können. Dies ist eine grundlegende Fähigkeit für die Docker-Entwicklung.

Datenverwaltung mit Docker Volumes

Eine Herausforderung bei der Arbeit mit Docker-Containern ist die Datenpersistenz. Container sind kurzlebig, was bedeutet, dass alle innerhalb eines Containers erstellten Daten verloren gehen, wenn der Container entfernt wird. Docker Volumes lösen dieses Problem, indem sie eine Möglichkeit bieten, Daten außerhalb von Containern zu persistieren.

Docker Volumes verstehen

Docker Volumes sind der bevorzugte Mechanismus zur Persistenz von Daten, die von Docker-Containern generiert und verwendet werden. Sie werden vollständig von Docker verwaltet und sind von der Verzeichnisstruktur des Host-Dateisystems isoliert.

Vorteile der Verwendung von Volumes sind:

Volumes lassen sich einfacher sichern oder migrieren als Bind-Mounts
Sie können Volumes mit Docker CLI-Befehlen verwalten
Volumes funktionieren sowohl auf Linux- als auch auf Windows-Containern
Volumes können sicherer zwischen mehreren Containern geteilt werden
Volume-Treiber ermöglichen es Ihnen, Volumes auf Remote-Hosts, Cloud-Anbietern zu speichern oder den Inhalt von Volumes zu verschlüsseln

Erstellen und Verwenden von Docker Volumes

Lassen Sie uns einen einfachen MySQL-Datenbank-Container erstellen, der ein Volume verwendet, um seine Daten zu persistieren.

Erstellen eines Volumes

Erstellen Sie zuerst ein Docker Volume:

docker volume create mysql-data

Sie können alle Volumes mit folgendem Befehl auflisten:

docker volume ls

Sie sollten Ihr neues Volume in der Liste sehen:

DRIVER    VOLUME NAME
local     mysql-data

Ausführen eines Containers mit einem Volume

Lassen Sie uns nun einen MySQL-Container ausführen, der dieses Volume verwendet:

docker run --name mysql-db -e MYSQL_ROOT_PASSWORD=mysecretpassword -v mysql-data:/var/lib/mysql -p 3306:3306 -d mysql:5.7

Dieser Befehl:

--name mysql-db: Benennt den Container "mysql-db"
-e MYSQL_ROOT_PASSWORD=mysecretpassword: Legt eine Umgebungsvariable zur Konfiguration von MySQL fest
-v mysql-data:/var/lib/mysql: Mountet das Volume "mysql-data" in das Verzeichnis, in dem MySQL seine Daten speichert
-p 3306:3306: Ordnet Port 3306 auf dem Host Port 3306 im Container zu
-d: Führt den Container im Detached-Modus aus
mysql:5.7: Gibt das zu verwendende Image an

Warten Sie einen Moment, bis der Container gestartet ist, und überprüfen Sie dann, ob er läuft:

docker ps

Interaktion mit der Datenbank

Lassen Sie uns eine Datenbank und eine Tabelle erstellen, um die Datenpersistenz zu demonstrieren. Stellen Sie zuerst eine Verbindung zum MySQL-Container her:

docker exec -it mysql-db bash

Stellen Sie innerhalb des Containers eine Verbindung zum MySQL-Server her:

mysql -u root -pmysecretpassword

Erstellen Sie eine neue Datenbank und Tabelle:

CREATE DATABASE testdb;
USE testdb;
CREATE TABLE users (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255));
INSERT INTO users (name) VALUES ('John'), ('Jane'), ('Bob');
SELECT * FROM users;

Sie sollten die eingefügten Daten sehen:

+----+------+
| id | name |
+----+------+
|  1 | John |
|  2 | Jane |
|  3 | Bob  |
+----+------+

Beenden Sie die MySQL-Eingabeaufforderung und den Container:

exit
exit

Testen der Volume-Persistenz

Lassen Sie uns nun den Container stoppen und entfernen und dann einen neuen Container mit demselben Volume erstellen:

docker stop mysql-db
docker rm mysql-db

Erstellen Sie einen neuen Container mit demselben Volume:

docker run --name mysql-db-new -e MYSQL_ROOT_PASSWORD=mysecretpassword -v mysql-data:/var/lib/mysql -p 3306:3306 -d mysql:5.7

Stellen Sie nun eine Verbindung zum neuen Container her und überprüfen Sie, ob unsere Daten persistent sind:

docker exec -it mysql-db-new bash
mysql -u root -pmysecretpassword
USE testdb
SELECT * FROM users

Sie sollten dieselben Daten sehen, die wir zuvor eingefügt haben:

+----+------+
| id | name |
+----+------+
|  1 | John |
|  2 | Jane |
|  3 | Bob  |
+----+------+

Beenden Sie die MySQL-Eingabeaufforderung und den Container:

exit
exit

Dies zeigt, dass die Daten auch nach dem Entfernen des ursprünglichen Containers persistent waren, da sie in einem Docker Volume gespeichert wurden.

Untersuchen und Verwalten von Volumes

Sie können ein Volume untersuchen, um weitere Informationen darüber zu erhalten:

docker volume inspect mysql-data

Dies zeigt Details wie den Mount-Punkt und den verwendeten Treiber an:

[
  {
    "CreatedAt": "YYYY-MM-DDTHH:MM:SS+00:00",
    "Driver": "local",
    "Labels": {},
    "Mountpoint": "/var/lib/docker/volumes/mysql-data/_data",
    "Name": "mysql-data",
    "Options": {},
    "Scope": "local"
  }
]

Um aufzuräumen, lassen Sie uns den Container stoppen und entfernen:

docker stop mysql-db-new
docker rm mysql-db-new

Wenn Sie auch das Volume entfernen möchten:

docker volume rm mysql-data

Sie haben nun gelernt, wie Sie Docker Volumes verwenden, um Daten zwischen Container-Lebenszyklen zu persistieren, was für zustandsbehaftete Anwendungen wie Datenbanken unerlässlich ist.

Docker-Netzwerke erkunden

Docker-Netzwerke ermöglichen es Containern, miteinander und mit der Außenwelt zu kommunizieren. Das Verständnis der Netzwerkfähigkeiten von Docker ist entscheidend für die Erstellung von Multi-Container-Anwendungen.

Docker-Netzwerktypen

Docker bietet standardmäßig mehrere Netzwerktreiber:

bridge: Der Standard-Netzwerktreiber. Container im selben Bridge-Netzwerk können kommunizieren.
host: Entfernt die Netzwerkisolation zwischen dem Container und dem Host.
none: Deaktiviert alle Netzwerkfunktionen für einen Container.
overlay: Verbindet mehrere Docker-Daemons und ermöglicht die Kommunikation von Swarm-Diensten.
macvlan: Weist einem Container eine MAC-Adresse zu, wodurch er im Netzwerk als physisches Gerät erscheint.

Erkundung des Standard-Bridge-Netzwerks

Wenn Sie Docker installieren, erstellt es automatisch ein Standard-Bridge-Netzwerk. Lassen Sie uns dieses erkunden:

docker network ls

Sie sollten eine ähnliche Ausgabe sehen:

NETWORK ID     NAME      DRIVER    SCOPE
XXXXXXXXXXXX   bridge    bridge    local
XXXXXXXXXXXX   host      host      local
XXXXXXXXXXXX   none      null      local

Sie können das Standard-Bridge-Netzwerk untersuchen:

docker network inspect bridge

Dieser Befehl liefert detaillierte Informationen über das Netzwerk, einschließlich der damit verbundenen Container, des IP-Adressbereichs und des Gateways.

Erstellen und Verwenden von benutzerdefinierten Bridge-Netzwerken

Lassen Sie uns ein benutzerdefiniertes Bridge-Netzwerk für eine bessere Container-Isolation erstellen:

docker network create my-network

Überprüfen Sie, ob das Netzwerk erstellt wurde:

docker network ls

Sie sollten Ihr neues Netzwerk in der Liste sehen:

NETWORK ID     NAME           DRIVER    SCOPE
XXXXXXXXXXXX   bridge         bridge    local
XXXXXXXXXXXX   host           host      local
XXXXXXXXXXXX   my-network     bridge    local
XXXXXXXXXXXX   none           null      local

Lassen Sie uns nun zwei Container in diesem Netzwerk ausführen und die Kommunikation zwischen ihnen demonstrieren.

Starten Sie zuerst einen NGINX-Container im benutzerdefinierten Netzwerk:

docker run --name web-server --network my-network -d nginx

Als Nächstes lassen Sie uns einen Alpine Linux-Container ausführen und ihn verwenden, um die Konnektivität zum NGINX-Container zu testen:

docker run --name alpine --network my-network -it alpine sh

Installieren Sie im Alpine-Container curl und testen Sie die Konnektivität zum NGINX-Container:

apk add --update curl
curl web-server

Die Ausgabe sollte das HTML der NGINX-Willkommensseite sein. Dies funktioniert, da Docker eingebettetes DNS für Container in benutzerdefinierten Netzwerken bereitstellt, wodurch diese Containernamen in IP-Adressen auflösen können.

Geben Sie exit ein, um den Alpine-Container zu verlassen:

exit

Verbinden von Containern mit mehreren Netzwerken

Container können mit mehreren Netzwerken verbunden werden. Lassen Sie uns ein weiteres Netzwerk erstellen:

docker network create another-network

Verbinden Sie den vorhandenen web-server-Container mit diesem neuen Netzwerk:

docker network connect another-network web-server

Überprüfen Sie, ob der Container jetzt mit beiden Netzwerken verbunden ist:

docker inspect web-server -f '{{json .NetworkSettings.Networks}}' | json_pp

Sie sollten sehen, dass der Container sowohl mit my-network als auch mit another-network verbunden ist.

Ausführen von Containern mit Port-Veröffentlichung

Wenn Sie den Dienst eines Containers von außerhalb des Docker-Hosts zugänglich machen möchten, müssen Sie seine Ports veröffentlichen:

docker run --name public-web -p 8080:80 -d nginx

Dieser Befehl ordnet Port 8080 auf dem Host Port 80 im Container zu. Sie können auf den NGINX-Webserver zugreifen mit:

curl http://localhost:8080

Sie sollten die NGINX-Willkommensseite sehen.

Bereinigung

Lassen Sie uns die von uns erstellten Container und Netzwerke bereinigen:

docker stop web-server alpine public-web
docker rm web-server alpine public-web
docker network rm my-network another-network

Überprüfen Sie, ob die Container und Netzwerke entfernt wurden:

docker ps -a
docker network ls

Container-Kommunikation verstehen

Dieser Schritt hat gezeigt, wie Docker-Netzwerke Folgendes ermöglichen:

Container-zu-Container-Kommunikation mithilfe benutzerdefinierter Netzwerke
DNS-Auflösung mithilfe von Containernamen
Verbindung von Containern mit mehreren Netzwerken
Bereitstellung von Containerdiensten für die Außenwelt mithilfe der Port-Veröffentlichung

Diese Netzwerkfähigkeiten sind unerlässlich für die Erstellung komplexer Multi-Container-Anwendungen, bei denen Komponenten miteinander und mit externen Diensten kommunizieren müssen.

Zusammenfassung

Herzlichen Glückwunsch zum Abschluss dieses Docker-Labs! Sie haben wesentliche Docker-Konzepte und -Fähigkeiten erlernt, die die Grundlage für die containerbasierte Entwicklung und Bereitstellung bilden.

In diesem Lab haben Sie:

Die Docker-Installation überprüft und Ihren ersten Container ausgeführt
Mit Docker-Images und -Containern gearbeitet, einschließlich des Abrufens von Images von Docker Hub und der Verwaltung von Container-Lebenszyklen
Ihr eigenes benutzerdefiniertes Docker-Image mithilfe eines Dockerfiles erstellt
Docker Volumes verwendet, um Daten zwischen Container-Lebenszyklen zu persistieren
Docker-Netzwerke erkundet, um die Container-zu-Container-Kommunikation zu ermöglichen

Diese Fähigkeiten ermöglichen es Ihnen:

Anwendungen und ihre Abhängigkeiten in portablen Containern zu verpacken
Standardisierte Umgebungen für Entwicklung, Tests und Produktion zu erstellen
Microservices-Architekturen zu implementieren, bei denen jede Komponente in ihrem eigenen Container ausgeführt wird
Datenpersistenz für zustandsbehaftete Anwendungen sicherzustellen
Komplexe Multi-Container-Anwendungen mit ordnungsgemäßer Isolation und Kommunikation zu erstellen

Docker ist zu einem unverzichtbaren Werkzeug in der modernen Softwareentwicklung geworden, und das Wissen, das Sie erworben haben, wird in einer Vielzahl von Entwicklungs- und Betriebsszenarien wertvoll sein.

Docker Command Not Found auf dem Mac: Fehlerbehebung und Einrichtung Ihrer Umgebung

Einführung

Docker-Grundlagen verstehen und Installation überprüfen

Was ist Docker?

Überprüfen der Docker-Installation

Ihren ersten Container ausführen

Laufende Container überprüfen

Arbeiten mit Docker Images und Containern

Docker Images verstehen

Verfügbare Images auflisten

Images von Docker Hub abrufen

Arbeiten mit Containern

Einen Container ausführen

Überprüfen, ob der Container läuft

Auf den Webserver zugreifen

Container-Logs anzeigen

Container stoppen und entfernen

Erstellen Ihrer eigenen Docker Images mit Dockerfiles

Was ist ein Dockerfile?

Erstellen Ihres ersten Dockerfiles

Erstellen Ihres Docker Images

Ausführen Ihres benutzerdefinierten Docker Images

Testen Ihrer Anwendung

Das Dockerfile verstehen

Bereinigung

Datenverwaltung mit Docker Volumes

Docker Volumes verstehen

Erstellen und Verwenden von Docker Volumes

Erstellen eines Volumes

Ausführen eines Containers mit einem Volume

Interaktion mit der Datenbank

Testen der Volume-Persistenz

Untersuchen und Verwalten von Volumes

Docker-Netzwerke erkunden

Docker-Netzwerktypen

Erkundung des Standard-Bridge-Netzwerks

Erstellen und Verwenden von benutzerdefinierten Bridge-Netzwerken

Verbinden von Containern mit mehreren Netzwerken

Ausführen von Containern mit Port-Veröffentlichung

Bereinigung

Container-Kommunikation verstehen

Zusammenfassung