Grundlegende Verwendung von Docker

Docker-Installation

1.1 Wenn Sie bereits eine alte Docker-Version installiert haben, können Sie diese mit dem folgenden Befehl deinstallieren:

yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine \
                  docker-ce

1.2.Docker installieren

DNS hinzufügen

vi /etc/sysconfig/network-scripts/ifcfg-ens33

Neu

DNS1=8.8.8.8
DNS2=8.8.4.4

Zunächst muss jeder die virtuelle Maschine mit dem Internet verbinden und das Yum-Tool installieren.

yum install -y yum-utils \
           device-mapper-persistent-data \
           lvm2 --skip-broken

Aktualisieren Sie dann die lokale Spiegelquelle:

Legen Sie die Docker-Bildquelle fest

yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

yum makecache fast

Geben Sie dann den Befehl ein:

yum install -y docker-ce

Docker-ce ist eine kostenlose Community-Version. Warten Sie einen Moment und Docker wird erfolgreich installiert.

1.3.Starten Sie Docker

Docker-Anwendungen müssen verschiedene Ports verwenden und die Firewall-Einstellungen nacheinander ändern. Es ist sehr problematisch, daher empfehle ich Ihnen, die Firewall direkt auszuschalten!

Bevor Sie Docker starten, schalten Sie unbedingt die Firewall aus! !

Bevor Sie Docker starten, schalten Sie unbedingt die Firewall aus! !

Bevor Sie Docker starten, schalten Sie unbedingt die Firewall aus! !

# 关闭
systemctl stop firewalld
# 禁止开机启动防火墙
systemctl disable firewalld

Starten Sie Docker über den Befehl:

systemctl start docker  # 启动docker服务

systemctl stop docker  # 停止docker服务

systemctl restart docker  # 重启docker服务

Geben Sie dann den Befehl ein, um die Docker-Version anzuzeigen:

docker -v
docker info

Wie im Bild gezeigt:

1.4. Bildbeschleunigung konfigurieren

Die Internetgeschwindigkeit des offiziellen Image Warehouse von Docker ist schlecht. Wir müssen einen inländischen Image-Service einrichten:

Weitere Informationen finden Sie in der Dokumentation zur Spiegelbeschleunigung von Alibaba Cloud: https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

Datei erstellen: /etc/docker/daemon.json

{
    
    
"registry-mirrors":["https://docker.mirrors.ustc.edu.cn","http://hubmirror.c.163.com"]
}

Die grundlegende Docker-Umgebung ist bisher gut.

2. Installieren Sie DockerCompose auf CentOS7

2.1.Herunterladen

Unter Linux müssen Sie es über den folgenden Befehl herunterladen:

# 安装
curl -L https://github.com/docker/compose/releases/download/1.23.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

Wenn die Download-Geschwindigkeit langsam ist oder der Download fehlschlägt, können Sie die im Vorkursmaterial bereitgestellte Docker-Compose-Datei verwenden:

Es ist auch möglich, in das Verzeichnis/usr/local/bin/ hochzuladen.

2.2. Dateiberechtigungen ändern

Dateiberechtigungen ändern:

# 修改权限
chmod +x /usr/local/bin/docker-compose

2.3.Base vervollständigt Befehle automatisch:

# 补全命令
curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

Wenn hier ein Fehler auftritt, müssen Sie Ihre Hosts-Datei ändern:

echo "199.232.68.133 raw.githubusercontent.com" >> /etc/hosts

3.Docker-Image-Warehouse

Der Aufbau eines Spiegellagers kann auf der Grundlage der offiziell von Docker bereitgestellten DockerRegistry erfolgen.

Offizielle Website-Adresse: https://hub.docker.com/_/registry

3.1. Vereinfachte Version des Spiegellagers

Die offizielle Docker-Registrierung von Docker ist eine Basisversion des Docker-Image-Warehouses, die über vollständige Funktionen der Warehouse-Verwaltung verfügt, jedoch nicht über eine grafische Oberfläche verfügt.

Die Konstruktionsmethode ist relativ einfach, die Befehle lauten wie folgt:

docker run -d \
    --restart=always \
    --name registry	\
    -p 5000:5000 \
    -v registry-data:/var/lib/registry \
    registry

Der Befehl stellt ein Daten-Volume „registry-data“ in das Verzeichnis „/var/lib/registry“ im Container ein. Dabei handelt es sich um das Verzeichnis, in dem die private Bildbibliothek Daten speichert.

Besuchen Sie http://YourIp:5000/v2/_catalog, um die Bilder anzuzeigen, die im aktuellen privaten Bilddienst enthalten sind

3.2. Version mit grafischer Oberfläche

Verwenden Sie DockerCompose, um DockerRegistry mit einer grafischen Oberfläche bereitzustellen. Der Befehl lautet wie folgt:

version: '3.0'
services:
  registry:
    image: registry
    volumes:
      - ./registry-data:/var/lib/registry
  ui:
    image: joxit/docker-registry-ui:static
    ports:
      - 8080:80
    environment:
      - REGISTRY_TITLE=传智教育私有仓库
      - REGISTRY_URL=http://registry:5000
    depends_on:
      - registry

3.3. Konfigurieren Sie die Docker-Vertrauensadresse

Unser privater Server verwendet das http-Protokoll, dem Docker standardmäßig nicht vertraut, daher müssen wir eine Konfiguration vornehmen:

# 打开要修改的文件
vi /etc/docker/deamon.json
# 添加内容：记得在JSON配置文件中加 ，（逗号）
"insecure-registries":["http://192.168.150.101:8080"]
# 重加载
systemctl deamon-reload
# 重启docker
systemctl restart docker

Praktische Docker-Artikel

1. Erste Einführung in Docker

1.1.Was ist Docker?

Obwohl Microservices verschiedene Vorteile haben, bringt die Aufteilung der Services große Probleme bei der Bereitstellung mit sich.

• In einem verteilten System gibt es viele abhängige Komponenten und es kommt häufig zu Konflikten, wenn verschiedene Komponenten bereitgestellt werden.
• Bei wiederholter Bereitstellung in Hunderten oder Tausenden von Diensten ist die Umgebung nicht unbedingt konsistent und es treten verschiedene Probleme auf

1.1.1. Umweltprobleme der Anwendungsbereitstellung

Großprojekte bestehen aus vielen Komponenten und die Betriebsumgebung ist komplexer. Bei der Bereitstellung treten einige Probleme auf:

• Abhängigkeiten sind komplex und es kann häufig zu Kompatibilitätsproblemen kommen

• Es gibt Unterschiede zwischen Entwicklungs-, Test- und Produktionsumgebungen
  Fügen Sie hier eine Bildbeschreibung ein

1.1.2.Docker löst Abhängigkeitskompatibilitätsprobleme

Docker hat diese Probleme tatsächlich clever gelöst. Wie schafft Docker das?

Um das Problem der Abhängigkeitskompatibilität zu lösen, wendet Docker zwei Methoden an:

• Packen Sie die Libs (Funktionsbibliothek), Deps (Abhängigkeiten) und Konfiguration der Anwendung zusammen mit der Anwendung

• Legen Sie jede Anwendung zur Ausführung in einen IsolationscontainerContainer, um gegenseitige Störungen zu vermeiden

Die direkte Verwendung von Kernel-Befehlen hat nichts mit der spezifischen Systemversion zu tun

1.1.3.Docker behebt Unterschiede in Betriebssystemumgebungen

Um das Problem der Unterschiede in verschiedenen Betriebssystemumgebungen zu lösen, müssen Sie zunächst die Betriebssystemstruktur verstehen. Am Beispiel eines Ubuntu-Betriebssystems sieht die Struktur wie folgt aus:

Die Struktur umfasst:

• Computerhardware: wie CPU, Speicher, Festplatte usw.
• Systemkernel: Der Kernel aller Linux-Distributionen ist Linux, wie CentOS, Ubuntu, Fedora usw. Der Kernel kann mit der Computerhardware interagieren und der Außenwelt Kernelanweisungen zum Betrieb der Computerhardware bereitstellen.
• Systemanwendungen: Anwendungen und Funktionsbibliotheken, die vom Betriebssystem selbst bereitgestellt werden. Diese Funktionsbibliotheken sind Kapselungen von Kernel-Anweisungen und einfacher zu verwenden.

Der auf die Computerinteraktion angewendete Prozess ist wie folgt:

1) Die Anwendung ruft Betriebssystemanwendungen (Funktionsbibliotheken) auf, um verschiedene Funktionen zu implementieren

2) Die Systemfunktionsbibliothek ist eine Kapselung des Kernel-Befehlssatzes und ruft Kernel-Anweisungen auf.

3) Kernel-Anweisungen bedienen Computerhardware

Ubuntu und CentOS SpringBoot basieren beide auf dem Linux-Kernel. Sie sind lediglich unterschiedliche Systemanwendungen und bieten unterschiedliche Funktionsbibliotheken:
Zu diesem Zeitpunkt handelt es sich um eine Ubuntu-Version der MySQL-Anwendung Wenn MySQL auf dem CentOS-System installiert ist und die Ubuntu-Funktionsbibliothek aufruft, wird festgestellt, dass sie nicht gefunden werden kann oder nicht übereinstimmt, und es wird ein Fehler gemeldet:

Wie löst Docker Probleme in verschiedenen Systemen? Umgebungen?

• Docker verpackt das Benutzerprogramm zusammen mit der aufzurufenden Systemfunktionsbibliothek (z. B. Ubuntu).
• Wenn Docker auf verschiedenen Betriebssystemen ausgeführt wird, basiert es direkt auf der gepackten Funktionsbibliothek und wird mit Hilfe des Linux-Kernels des Betriebssystems ausgeführt.

Wie im Bild gezeigt:

1.1.4. Zusammenfassung

Wie löst Docker die Kompatibilitätsprobleme komplexer Abhängigkeiten und Abhängigkeiten von verschiedenen Komponenten in großen Projekten?

• Docker ermöglicht das Zusammenpacken von Anwendungen, Abhängigkeiten, Funktionsbibliotheken und Konfigurationen während der Entwicklung, um ein tragbares Image zu bilden
• Docker-Anwendungen werden in Containern ausgeführt und verwenden einen Sandbox-Mechanismus, um sich gegenseitig zu isolieren

Wie löst Docker das Problem der Unterschiede zwischen Entwicklungs-, Test- und Produktionsumgebungen?

• Das Docker-Image enthält eine vollständige Betriebsumgebung, einschließlich Systemfunktionsbibliotheken, und basiert ausschließlich auf dem Linux-Kernel des Systems, sodass es auf jedem Linux-Betriebssystem ausgeführt werden kann.

Docker ist eine Technologie zur schnellen Bereitstellung und Ausführung von Anwendungen. Sie bietet folgende Vorteile:

• Das Programm, seine Abhängigkeiten und die Betriebsumgebung können in ein Image gepackt werden, das auf jedes Linux-Betriebssystem migriert werden kann
• Der Sandbox-Mechanismus wird verwendet, um zur Laufzeit einen isolierten Container zu bilden, sodass sich die einzelnen Anwendungen nicht gegenseitig stören.
• Das Starten und Entfernen kann bequem und schnell mit einer Befehlszeile durchgeführt werden

1.2. Der Unterschied zwischen Docker und virtuellen Maschinen

Mit Docker kann eine Anwendung sehr komfortabel auf jedem Betriebssystem ausgeführt werden. Die virtuellen Maschinen, denen wir zuvor ausgesetzt waren, können auch ein anderes Betriebssystem in einem Betriebssystem ausführen, um jede Anwendung im System zu schützen.

Was ist der Unterschied zwischen den beiden?

Virtuelle Maschine (virtuelle Maschine) simuliert Hardwaregeräte im Betriebssystem und führt dann ein anderes aus Ein Betriebssystem, beispielsweise ein Ubuntu-System in einem Windows-System, kann jede Ubuntu-Anwendung ausführen.

Docker ist nur eine Paketfunktionsbibliothek und simuliert kein vollständiges Betriebssystem, wie in der Abbildung gezeigt:

Zum Vergleich:

Der Unterschied zwischen Docker und virtueller Maschine:
Docker ist ein Systemprozess; virtuelle Maschine ist das Betriebssystem im Betriebssystem
Docker ist klein in Größe und Die Startgeschwindigkeit ist schnell und die Leistung ist gut; die virtuelle Maschine ist groß, die Startgeschwindigkeit ist langsam und die Leistung ist durchschnittlich

1.3.Docker-Architektur

1.3.1. Bilder und Container

In Docker gibt es mehrere wichtige Konzepte:

Image: Docker packt die Anwendung und ihre erforderlichen Abhängigkeiten, Funktionsbibliotheken, Umgebung, Konfiguration und andere Dateien zusammen, ein sogenanntes Image.

Container: Der Prozess, der nach der Ausführung der Anwendung im Bild erstellt wird, ist Container dass Docker den Containerprozess isoliert und für die Außenwelt unsichtbar macht.

Alle Anwendungen bestehen letztendlich aus Codes, die durch Bytes auf der FestplatteDateien gebildet werden. Erst wenn es ausgeführt wird, wird es in den Speicher geladen und bildet einen Prozess.

UndBild wird durch Packen einer Anwendungsdatei auf der Festplatte, ihrer Betriebsumgebung und einiger Systemfunktionsbibliotheksdateien gebildet. Dokumentpaket . Dieses Paket ist schreibgeschützt.

Container dient dazu, die in diesen Dateien geschriebenen Programme und Funktionen in den Speicher zu laden und einen Prozess zu bilden, der jedoch isoliert sein muss. Daher kann ein Image mehrmals gestartet werden, um mehrere Containerprozesse zu bilden.

1.3.2.DockerHub

Es gibt viele Open-Source-Anwendungen und das Packen dieser Anwendungen ist oft eine sich wiederholende Aufgabe. Um diese Doppelarbeit zu vermeiden, werden Benutzer ihre eigenen gepackten Anwendungsbilder, wie Redis- und MySQL-Bilder, in das Netzwerk stellen und sie teilen, genau wie beim Code-Sharing von GitHub.

• DockerHub: DockerHub ist eine offizielle Docker-Image-Hosting-Plattform. Eine solche Plattform heißt Docker Registry.

• Es gibt auch öffentliche Dienste, die DockerHub in China ähneln, wie zum BeispielNetEase Cloud Mirroring Service, Alibaba Cloud Mirroring Libraryusw.

Einerseits können wir unsere eigenen Bilder an DockerHub weitergeben, andererseits können wir auch Bilder von DockerHub abrufen:

1.3.3.Docker-Architektur

Wenn wir Docker zum Betrieb von Images und Containern verwenden möchten, müssen wir Docker installieren.

Docker ist ein CS-basiertes Programm, das aus zwei Teilen besteht:

• Server: Docker-Daemon, verantwortlich für die Verarbeitung von Docker-Anweisungen, die Verwaltung von Bildern, Containern usw.

• Client: Senden Sie Anweisungen über Befehle oder RestAPI an den Docker-Server. Anweisungen können lokal oder remote an den Server gesendet werden.

Wie im Bild gezeigt:

1.3.4. Zusammenfassung

Spiegel:

• Packen Sie die Anwendung und ihre Abhängigkeiten, Umgebung und Konfiguration zusammen

Container:

• Wenn ein Image ausgeführt wird, wird es zu einem Container. Ein Image kann mehrere Container ausführen.

Docker-Struktur:

• Server: empfängt Befehle oder Remote-Anfragen, betreibt Bilder oder Container

• Client: Senden Sie Befehle oder Anfragen an den Docker-Server

DockerHub:

• Ein Image-Hosting-Server, ähnlich dem Alibaba Cloud-Image-Service, zusammenfassend DockerRegistry genannt

2.Grundlegende Operationen von Docker

Starten Sie zunächst den Docker-Dienst

systemctl start  docker 

2.1. Spiegelbetrieb

2.1.1.Bildname

Schauen wir uns zunächst die Namenszusammensetzung des Bildes an:

• Spiegelnamen bestehen im Allgemeinen aus zwei Teilen: [Repository]:[Tag].
• Wenn kein Tag angegeben ist, ist der Standardwert „latest“, der die neueste Version des Bildes darstellt.

Wie im Bild gezeigt:

### 2.1.2. Spiegelbefehl

2.1.3.Fall 1 – Ziehen Sie das Bild herunter und betrachten Sie es

Anforderung: Ziehen Sie ein Nginx-Image von DockerHub und zeigen Sie es an

1) Gehen Sie zuerst zum Mirror Warehouse, um nach dem Nginx-Image zu suchen, z. B.DockerHub:
2) Ziehen Sie entsprechend dem Namen des Ansichtsbildes das benötigte Bild und übergeben Sie den Befehl: docker pull nginx
3) Verwenden Sie den Befehl: docker images, um das gezogene Bild anzuzeigen
docker rmi -f + image: tag delete image

2.1.4.Fall 2 – Bild speichern und importieren

Anforderung: Verwenden Sie Docker Save, um das Nginx-Image auf die Festplatte zu exportieren, und laden Sie es dann durch Laden wieder zurück

1) Verwenden Sie den Befehl docker xx --help, um die Syntax von Docker Save und Docker Load anzuzeigen

Um beispielsweise die Verwendung des Speicherbefehls anzuzeigen, können Sie den folgenden Befehl eingeben:

docker save --help

Befehlsformat:

docker save -o [保存的目标文件名称] [镜像名称]

2) Verwenden Sie Docker Save, um das Bild auf die Festplatte zu exportieren

Führen Sie den Befehl aus:

docker save -o nginx.tar nginx:latest

3) Verwenden Sie Docker Load, um das Bild zu laden

Löschen Sie zunächst das lokale Nginx-Image:

docker rmi nginx:latest

Führen Sie dann den Befehl aus, um die lokale Datei zu laden:

docker load -i nginx.tar

2.1.5.Übung

Anforderung: Gehen Sie zu DockerHub, um ein Redis-Image zu suchen und abzurufen

Ziel:

1) Gehen Sie zu DockerHub, um nach dem Redis-Image zu suchen

2) Überprüfen Sie den Namen und die Version des Redis-Images

3) Verwenden Sie den Docker-Pull-Befehl, um das Bild zu ziehen

4) Verwenden Sie den Docker-Speicherbefehl, um redis:latest in ein redis.tar-Paket zu packen

5) Verwenden Sie Docker RMI, um lokale Redis:latest zu löschen

6) Verwenden Sie Docker Load, um die Datei redis.tar neu zu laden

Ziehen

docker pull redis

Pack

docker save -o redis.tar redis:latest

Lösche Bild

docker rmi redis:latest

TAR-Datei laden

docker load -i redis.tar

2.2. Containerbetrieb

2.2.1. Containerbezogene Befehle

Container-Betriebsbefehle sind wie in der Abbildung dargestellt:

Der Containerschutz hat drei Zustände:

• Läuft: Der Prozess läuft normal
• Pause: Der Prozess wird angehalten, die CPU läuft nicht mehr und der Speicher wird nicht freigegeben.
• Stopp: Der Prozess wird beendet und der vom Prozess belegte Speicher, die CPU und andere Ressourcen werden recycelt.

In:

• Docker Run: Erstellen Sie einen Container und führen Sie ihn im laufenden Zustand aus

• Docker-Pause: Einen laufenden Container anhalten

• Docker unpause: Setzt einen Container aus einem angehaltenen Zustand fort

• Docker Stop: Stoppen Sie einen laufenden Container

• Docker Start: Einen gestoppten Container erneut ausführen lassen

• Docker RM: Einen Container löschen

2.2.2. Fall – Erstellen und Ausführen eines Containers

Befehl zum Erstellen und Ausführen eines Nginx-Containers:

docker run --name containerName -p 80:80 -d nginx

Befehlsinterpretation:

• Docker Run: Einen Container erstellen und ausführen
• –name: Geben Sie dem Container einen Namen, z. B. mn. Der Containername muss eindeutig sein.
• -p: Ordnen Sie den Host-Port dem Container-Port zu. Die linke Seite des Doppelpunkts ist der Host-Port und die rechte Seite ist der Container-Port.
• -d: Den Container im Hintergrund ausführen
• nginx: Bildname, z. B. nginx

docker run --name nm -p 80:80 -d nginx

Der Parameter hier-p ordnet den Container-Port dem Host-Port zu.

Standardmäßig ist der Container eine isolierte Umgebung. Wenn wir direkt auf Port 80 des Hosts zugreifen, können wir definitiv nicht auf Nginx im Container zugreifen.

Ordnen Sie nun die 80 des Containers der 80 des Hosts zu. Wenn wir auf den Port 80 des Hosts zugreifen, wird er der 80 des Containers zugeordnet, sodass wir auf nginx zugreifen können:

2.2.3. Fall – Geben Sie den Container ein und ändern Sie die Datei

Anforderungen: Geben Sie den Nginx-Container ein, ändern Sie den Inhalt der HTML-Datei und fügen Sie „Willkommen bei Chuanzhi Education“ hinzu

Tipps: Sie müssen den Befehl docker exec verwenden, um auf den Container zuzugreifen.

Gehen：

1) Betreten Sie den Container. Der Befehl zum Aufrufen des gerade erstellten Nginx-Containers lautet:

docker exec -it nm bash

Befehlsinterpretation:

• docker exec: Betreten Sie den Container und führen Sie einen Befehl aus

• -it: Erstellen Sie ein Standard-Eingabe- und Ausgabeterminal für den aktuell eingegebenen Container, sodass wir mit dem Container interagieren können

• mn: der Name des einzugebenden Containers

• bash: Befehl, der nach dem Betreten des Containers ausgeführt wird. Bash ist ein interaktiver Linux-Terminalbefehl

2) Geben Sie das Verzeichnis ein, in dem sich der HTML-Code von nginx befindet: /usr/share/nginx/html

Innerhalb des Containers wird ein unabhängiges Linux-Dateisystem simuliert, das wie ein Linux-Server aussieht:

Die Umgebung, die Konfiguration und die laufenden Dateien von nginx befinden sich alle in diesem Dateisystem, einschließlich der HTML-Datei, die wir ändern möchten.

Sehen Sie sich die Nginx-Seite auf der DockerHub-Website an und erfahren Sie den Speicherort des Nginx-HTML-Verzeichnisses./usr/share/nginx/html

Wir führen den Befehl aus und geben das Verzeichnis ein:

cd /usr/share/nginx/html

Sehen Sie sich die Dateien im Verzeichnis an:

3) Ändern Sie den Inhalt von index.html

Es gibt keinen vi-Befehl im Container und kann nicht direkt geändert werden. Wir verwenden den folgenden Befehl, um ihn zu ändern:

sed -i -e 's#Welcome to nginx#传智教育欢迎您#g' -e 's#<head>#<head><meta charset="utf-8">#g' index.html

1.1 Sed概述
sed编辑器时一种流编辑器，流编辑器会在编辑器处理数据之前基于预先提供的一组规则来编辑数据流。

sed编辑器可以根据命令来处理数据流中的数据，这些命令要么从命令行中输入，要存储在一个命令文本文件中

2.2.4. Zusammenfassung

Was sind die allgemeinen Parameter des Docker-Run-Befehls?

• –name: Geben Sie den Containernamen an
• -p: Portzuordnung angeben
• -d: Lassen Sie den Container im Hintergrund laufen

Strg + D Verlassen des aktuell eingegebenen Containers

Befehl zum Anzeigen von Containerprotokollen:

• Docker-Protokolle
• Fügen Sie den Parameter -f hinzu, um Protokolle kontinuierlich anzuzeigen

Containerstatus anzeigen:

• Docker PS
• docker ps -a Alle Container anzeigen, einschließlich der gestoppten

üben

Erstellen Sie den Reids-Container, führen Sie ihn aus und verwenden Sie den AOF-Persistenzmechanismus von Redis

Container erstellen

docker run --name myredis -p 6379:6379 -d redis redis-server --appendonly yes

Betreten Sie den Container

docker exec -it myredis bash

Stellen Sie eine Verbindung mit dem Redis-Client her

redis-cli

Oder geben Sie den Redis-Client direkt ein

docker exec -it myredis redis-cli

Daten festlegen

set num  666

2.3. Datenmengen (Containerdatenmanagement)

Im vorherigen Nginx-Fall müssen Sie beim Ändern der Nginx-HTML-Seite Nginx eingeben. Und da es keinen Editor gibt, ist das Ändern von Dateien auch sehr mühsam.

Dies ist die Folge der Kopplung zwischen dem Container und den Daten (Dateien im Container).

2.3.1.Was ist ein Datenvolumen?

**Datenvolumen (Volume)** ist ein virtuelles Verzeichnis, das auf ein Verzeichnis im Host-Dateisystem verweist.

Sobald das Datenvolumen gemountet ist, werden alle Vorgänge am Container auf das Hostverzeichnis angewendet, das dem Datenvolumen entspricht.

Auf diese Weise entspricht der Betrieb des Verzeichnisses /var/lib/docker/volumes/html auf dem Host dem Betrieb des Verzeichnisses /usr/share/nginx/html im Container.

2.3.2.Datensatz-Betriebsbefehle

Die grundlegende Syntax für Datenvolumenoperationen lautet wie folgt:

docker volume [COMMAND]

Der Docker-Volume-Befehl ist eine Datenvolumenoperation. Die nächste Operation wird gemäß dem Befehl bestimmt, der auf den Befehl folgt:

• create erstellt ein Volume
• inspect zeigt Informationen zu einem oder mehreren Volumes an
• ls listet alle Volumes auf
• Prune löscht nicht verwendete Volumes
• rm löscht ein oder mehrere angegebene Volumes
  
  

2.3.3.Datenvolumes erstellen und anzeigen

Anforderung: Erstellen Sie ein Daten-Volume und überprüfen Sie den Verzeichnisspeicherort des Daten-Volumes auf dem Host-Computer

① Datenvolumen erstellen

docker volume create html

② Alle Daten anzeigen

docker volume ls

Ergebnis:
③ Sehen Sie sich die Details zum Datenvolumen an

docker volume inspect html

Ergebnis:

Sie können sehen, dass das mit dem von uns erstellten HTML-Datenvolumen verknüpfte Hostverzeichnis das/var/lib/docker/volumes/html/_data-Verzeichnis ist.

小结：

Die Rolle von Datenmengen:

• Trennen und entkoppeln Sie den Container von den Daten, um den Betrieb der Daten im Container zu erleichtern und die Datensicherheit zu gewährleisten

Datenvolumenoperationen:

• Docker-Volume erstellen: Erstellen Sie ein Daten-Volume
• Docker-Volume ls: Alle Daten-Volumes anzeigen
• Docker-Volume-Inspektion: Details zum Datenvolumen anzeigen, einschließlich des Speicherorts des zugehörigen Hostverzeichnisses
• Docker-Volume rm: Löschen Sie das angegebene Datenvolumen
• Docker-Volume-Prune: Alle nicht verwendeten Daten-Volumes löschen

2.3.4.Datenvolumen bereitstellen

Wenn wir einen Container erstellen, können wir den Parameter -v verwenden, um ein Datenvolumen in einem Verzeichnis in einem Container bereitzustellen. Das Befehlsformat ist wie folgt:

docker run \
  --name mn \
  -v html:/root/html \
  -p 8080:80 \
  nginx

Das -v hier ist der Befehl zum Mounten des Datenvolumens:

• -v html:/root/htm: Hängen Sie das HTML-Datenvolumen im Verzeichnis /root/html im Container ein

2.3.5. Fall – Datenvolumen in Nginx einbinden

Anforderung: Erstellen Sie einen Nginx-Container und ändern Sie den Inhalt von index.html im HTML-Verzeichnis im Container

Analyse: Im letzten Fall haben wir den Nginx-Container eingegeben und kannten bereits den Speicherort des HTML-Verzeichnisses von Nginx /usr/share/nginx/html. Wir müssen dieses Verzeichnis mounten Laden Sie es in das HTML-Datenvolumen, um die Bearbeitung seines Inhalts zu erleichtern.

Tipp: Verwenden Sie den Parameter -v, um das Datenvolumen beim Ausführen des Containers bereitzustellen

Schritt:

① Erstellen Sie einen Container und mounten Sie das Datenvolumen im HTML-Verzeichnis im Container

docker run --name mn -v html:/usr/share/nginx/html -p 80:80 -d nginx

② Geben Sie den Speicherort des HTML-Datenvolumens ein und ändern Sie den HTML-Inhalt

# 查看html数据卷的位置
docker volume inspect html
# 进入该目录
cd /var/lib/docker/volumes/html/_data
# 修改文件
vi index.html

2.3.6. Fall – Mounten Sie ein lokales Verzeichnis für MySQL

Container können nicht nur Datenvolumes bereitstellen, sondern auch direkt im Hostverzeichnis. Die Beziehungen sind wie folgt:

• Mit Datenvolumenmodus: Hostverzeichnis --> Datenvolumen --> Verzeichnis innerhalb des Containers
• Direkter Mount-Modus: Host-Verzeichnis –> Verzeichnis im Container

Wie man liest:

Sprache:

Die Syntax für das Mounten von Verzeichnissen und Datenvolumes ist ähnlich:

• -v [Hostverzeichnis]:[Verzeichnis im Container]
• -v [Hostdatei]:[Datei im Container]

Anforderungen: Erstellen und führen Sie einen MySQL-Container aus und mounten Sie das Hostverzeichnis direkt im Container

Die Umsetzungsidee ist wie folgt:

1) Laden Sie die Datei mysql.tar in den Vorkursmaterialien auf die virtuelle Maschine hoch und laden Sie sie über den Ladebefehl als Bild

docker load -i mysql.tar

2) Erstellen Sie das Verzeichnis /tmp/mysql/data

3) Erstellen Sie das Verzeichnis /tmp/mysql/conf und laden Sie die in den Vorkursmaterialien bereitgestellte Datei hmy.cnf nach /tmp/mysql/conf hoch

4) Gehen Sie zu DockerHub, um die Informationen zu überprüfen, den MySQL-Container zu erstellen und auszuführen. Die Anforderungen sind:

① Mounten Sie /tmp/mysql/data im Datenspeicherverzeichnis im MySQL-Container-Docker run -d --name mysql5 -p 3306:3306 -v /tmp/mysql/data:/var/lib/mysql -v /tmp/ mysql /conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf -e MYSQL_ROOT_PASSWORD=123 mysql:5.7.25

Hinweis: MySQL auf der ursprünglichen virtuellen Maschine ist möglicherweise an Port 3306 gebunden. Wenn Sie Port 3306 zuordnen möchten, müssen Sie zuerst den ursprünglichen MSYQL-Port deaktivieren.

② Hängen Sie /tmp/mysql/conf/hmy.cnf in die Konfigurationsdatei des MySQL-Containers ein

③ Legen Sie das MySQL-Passwort fest

docker run  \
     --name mysql \
     -e MYSQL_ROOT_PASSWORD=123 \
     -p 3306:3306 \
     -v /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf \
     -v /tmp/mysql/data:/var/lib/mysql \
     -d \
     mysql:5.7.25

2.3.7. Zusammenfassung

Verwenden Sie im Docker-Run-Befehl den Parameter -v, um Dateien oder Verzeichnisse im Container bereitzustellen:

• -v Datenträgername: Verzeichnis innerhalb des Containers
• -v Hostdatei: Containerinhalt
• -v Hostverzeichnis: Verzeichnis innerhalb des Containers

Direktes Mounten von Datenvolumes und Verzeichnissen

• Die Kopplung der Datenvolumenmontage ist gering und Docker verwaltet das Verzeichnis. Das Verzeichnis ist jedoch tief und schwer zu finden.
• Das Mounten von Verzeichnissen ist stark gekoppelt und erfordert, dass wir das Verzeichnis selbst verwalten, aber das Verzeichnis ist leicht zu finden und anzuzeigen.

3. Benutzerdefiniertes Dockerfile-Image

Gängige Images finden Sie auf DockerHub, aber für Projekte, die wir selbst schreiben, müssen wir das Image selbst erstellen.

Um ein Bild anzupassen, müssen Sie zunächst die Struktur des Bildes verstehen.

3.1. Spiegelstruktur

Ein Image ist ein Paket einer Anwendung und ihrer erforderlichen Systemfunktionsbibliotheken, Umgebung, Konfiguration und Abhängigkeiten.

Nehmen wir MySQL als Beispiel, um die Struktur des Bildes zu betrachten:

Einfach ausgedrückt ist ein Image eine Datei, die durch Hinzufügen von Anwendungsdateien, Konfigurationsdateien, Abhängigkeitsdateien usw. auf der Grundlage der Systemfunktionsbibliothek und der Betriebsumgebung erstellt und anschließend ein Startskript geschrieben und zusammengepackt wird.

Wenn wir ein Image erstellen, implementieren wir tatsächlich den oben genannten Verpackungsprozess.

3.2.Dockerfile-Syntax

Wenn Sie ein benutzerdefiniertes Image erstellen, müssen Sie nicht jede Datei kopieren und packen.

Wir müssen Docker nur die Zusammensetzung unseres Images mitteilen, welche BaseImages benötigt werden, welche Dateien kopiert werden müssen, welche Abhängigkeiten installiert werden müssen und was das Startskript ist. Docker wird uns in Zukunft beim Erstellen des Images helfen.

Die Datei, die die oben genannten Informationen beschreibt, ist die Dockerfile-Datei.

Dockerfile ist eine Textdatei, die nacheinander Anweisungen (Anweisung) enthält. Verwenden Sie Anweisungen, um Erklären Sie, was zu tun ist, um das Image zu erstellen. Jede Anweisung bildet eine Ebene.

Aktualisierte detaillierte Syntaxanweisungen finden Sie in der offiziellen Website-Dokumentation: https://docs.docker.com/engine/reference/builder

3.3. Erstellen Sie ein Java-Projekt

3.3.1. Erstellen Sie Java-Projekte basierend auf Java8

Obwohl wir alle benötigten Installationspakete hinzufügen und das Image basierend auf dem Ubuntu-Basisimage erstellen können, ist dies ziemlich mühsam. In den meisten Fällen können wir also mit installierter Software Änderungen an einigen Basisbildern vornehmen.

Um beispielsweise ein Java-Projekt-Image zu erstellen, können Sie es auf Basis des vorbereiteten JDK-Basis-Images erstellen.

Anforderungen: Erstellen Sie ein Java-Projekt als Spiegel basierend auf dem Spiegel java:8-alpine

Die Umsetzungsidee ist wie folgt:

• ① Erstellen Sie ein neues leeres Verzeichnis, erstellen Sie dann eine neue Datei im Verzeichnis und nennen Sie sie Dockerfile

• ② Kopieren Sie die in den Vorkursmaterialien bereitgestellte Datei docker-demo.jar in dieses Verzeichnis

• ③ Docker-Datei schreiben:

  • a) Basierend auf Java:8-Alpine als Basis-Image

  • b) Kopieren Sie app.jar in das Bild

  • c) Freiliegender Anschluss

  • d) Eintrag ENTRYPOINT schreiben

    Der Inhalt ist wie folgt:

    FROM java:8-alpine
    COPY ./docker-demo.jar /tmp/app.jar
    EXPOSE 8090
    ENTRYPOINT java -jar /tmp/app.jar
    

• ④ Verwenden Sie den Docker-Build-Befehl, um das Image zu erstellen

• ⑤ Verwenden Sie Docker Run, um einen Container zu erstellen und auszuführen

Schritt 6: Führen Sie den Befehl aus:

docker build -t javaweb:1.0 .

Container ausführen

docker run --name web -p 8090:8090 -d javaweb:1.0

Besuchen Sie http://192.168.200.140:8090/hello/count, um die Seite anzuzeigen

3.4. Zusammenfassung

Zusammenfassung:

1. Der Kern einer Docker-Datei ist eine Datei, die den Image-Erstellungsprozess anhand von Anweisungen beschreibt.

2. Die erste Zeile der Docker-Datei muss „FROM“ sein, um aus einem Basis-Image zu erstellen

3. Das Basis-Image kann ein Basisbetriebssystem wie Ubuntu sein. Es kann auch ein von anderen erstellter Spiegel sein, zum Beispiel: java:8-alpine

4.Docker-Compose

Docker Compose kann uns helfen, verteilte Anwendungen schnell auf Basis von Compose-Dateien bereitzustellen, ohne Container einzeln manuell erstellen und ausführen zu müssen!

4.1. Erste Einführung in DockerCompose

Eine Compose-Datei ist eine Textdatei, die durch Anweisungen definiert, wie jeder Container im Cluster ausgeführt werden soll. Das Format ist wie folgt:

version: "3.8"
 services:
  mysql:
    image: mysql:5.7.25
    environment:
     MYSQL_ROOT_PASSWORD: 123 
    volumes:
     - "/tmp/mysql/data:/var/lib/mysql"
     - "/tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf"
  web:
    build: .
    ports:
     - "8090:8090"

Die obige Compose-Datei beschreibt ein Projekt, das zwei Container enthält:

• MySQL: ein Container, der auf der Grundlage einesmysql:5.7.25-Images erstellt und mit zwei Verzeichnissen gemountet wurde
• Web: ein temporär erstellter Bildcontainer basierend aufdocker build, der Port 8090 zuordnet

Detaillierte offizielle Syntaxreferenz-Website von DockerCompose: https://docs.docker.com/compose/compose-file/

Tatsächlich kann man sich die DockerCompose-Datei so vorstellen, dass sie mehrere Docker-Ausführungsbefehle in eine Datei schreibt, die Syntax unterscheidet sich jedoch geringfügig.

4.2. Installieren Sie DockerCompose

4.2.1.Herunterladen

Unter Linux müssen Sie es über den folgenden Befehl herunterladen:

# 安装
curl -L https://github.com/docker/compose/releases/download/1.23.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

Wenn die Download-Geschwindigkeit langsam ist oder der Download fehlschlägt, können Sie die Docker-Compose-Datei verwenden, die in den Materialien vor dem Unterricht bereitgestellt wird:

Sie können sie auch auf /usr/local/bin/ Verzeichnis .

4.2.2. Dateiberechtigungen ändern

Dateiberechtigungen ändern:

# 修改权限
chmod +x /usr/local/bin/docker-compose

4.2.3.Base-Autovervollständigungsbefehl:

# 补全命令
curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

Wenn hier ein Fehler auftritt, müssen Sie Ihre Hosts-Datei ändern:

echo "199.232.68.133 raw.githubusercontent.com" >> /etc/hosts

4.3. Mikroservice-Cluster bereitstellen

Anforderungen: Stellen Sie den zuvor erlernten Cloud-Demo-Microservice-Cluster mit DockerCompose bereit

realistischer Pfad：

① Überprüfen Sie den Cloud-Demo-Ordner in den Vorkursmaterialien. Die Docker-Compose-Datei wurde darin geschrieben.

② Ändern Sie Ihr Cloud-Demo-Projekt und benennen Sie die Datenbank- und Nacos-Adressen als Dienstnamen in Docker-Compose

③ Verwenden Sie das Maven-Paketierungstool, um jeden Microservice im Projekt als app.jar zu verpacken

④ Kopieren Sie die gepackte app.jar in jedes entsprechende Unterverzeichnis in cloud-demo

⑤ Laden Sie die Cloud-Demo auf die virtuelle Maschine hoch und stellen Sie sie mit docker-compose up -d bereit

4.3.1.Datei zusammenstellen

Überprüfen Sie den Cloud-Demo-Ordner, der in den Materialien vor dem Unterricht bereitgestellt wird. Die Docker-Compose-Datei wurde darin geschrieben und für jeden Mikrodienst wurde ein unabhängiges Verzeichnis vorbereitet:

Inhalt wie folgt:

version: "3.2"

services:
  nacos:
    image: nacos/nacos-server
    environment:
      MODE: standalone
    ports:
      - "8848:8848"
  mysql:
    image: mysql:5.7.25
    environment:
      MYSQL_ROOT_PASSWORD: 123
    volumes:
      - "$PWD/mysql/data:/var/lib/mysql"
      - "$PWD/mysql/conf:/etc/mysql/conf.d/"
  userservice:
    build: ./user-service
  orderservice:
    build: ./order-service
  gateway:
    build: ./gateway
    ports:
      - "10010:10010"

Wie Sie sehen, enthält es 5 Dienste:

• nacos: Dient als Registrierungszentrum und Konfigurationszentrum
  • image: nacos/nacos-server: Basierend auf dem Nacos/Nacos-Server-Image erstellt
  • environment:Umgebungsvariablen
    • MODE: standalone: Start im Einzelpunktmodus
  • ports:Portzuordnung, Port 8848 wird hier angezeigt
• mysql:Datenbank
  • image: mysql:5.7.25:Die Spiegelversion ist mysql:5.7.25
  • environment:Umgebungsvariablen
    • MYSQL_ROOT_PASSWORD: 123: Setzen Sie das Passwort des Datenbank-Root-Kontos auf 123
  • volumes: Datenvolumenmontage. Hier werden die Daten- und Conf-Verzeichnisse von MySQL gemountet, die die Daten enthalten, die ich im Voraus vorbereitet habe.
• userservice, orderservice, gateway: werden alle temporär auf Basis von Dockerfile erstellt

Wenn Sie sich das MySQL-Verzeichnis ansehen, können Sie sehen, dass die Tabellen cloud_order und cloud_user vorbereitet wurden:

Wenn Sie sich das Microservice-Verzeichnis ansehen, können Sie sehen, dass sie alle Dockerfile-Dateien enthalten:< /span>

Der Inhalt ist wie folgt:

FROM java:8-alpine
COPY ./app.jar /tmp/app.jar
ENTRYPOINT java -jar /tmp/app.jar

4.3.2. Microservice-Konfiguration ändern

Denn Microservices werden künftig als Docker-Container bereitgestellt und die Verbindung zwischen Containern erfolgt nicht über IP-Adressen, sondern über Containernamen. Hier ändern wir die MySQL- und Nacos-Adressen der Bestellservice-, Benutzerservice- und Gateway-Services für den Zugriff basierend auf Containernamen.

Wie folgt:

spring:
  datasource:
    url: jdbc:mysql://mysql:3306/cloud_order?useSSL=false
    username: root
    password: 123
    driver-class-name: com.mysql.jdbc.Driver
  application:
    name: orderservice
  cloud:
    nacos:
      server-addr: nacos:8848 # nacos服务地址

4.3.3.Verpackung

Als nächstes müssen wir jeden unserer Microservices verpacken. Da der Name des JAR-Pakets in der Docker-Datei, die wir zuvor gesehen haben, app.jar lautet, muss jeder unserer Microservices diesen Namen verwenden.

Dies kann durch Ändern des Paketnamens in pom.xml erreicht werden. Jeder Microservice muss geändert werden:

<build>
  <!-- 服务打包的最终名称 -->
  <finalName>app</finalName>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

Nach dem Verpacken:

4.3.4. Kopieren Sie das JAR-Paket in das Bereitstellungsverzeichnis

Die kompilierte und gepackte app.jar-Datei muss im selben Verzeichnis wie die Docker-Datei abgelegt werden. Hinweis: Die app.jar jedes Mikrodienstes wird im Verzeichnis abgelegt, das dem Dienstnamen entspricht. Machen Sie keinen Fehler.

Benutzerdienst:

4.3.5.Bereitstellung

Schließlich müssen wir den gesamten Cloud-Demo-Ordner für die DockerCompose-Bereitstellung auf die virtuelle Maschine hochladen.
In ein beliebiges Verzeichnis hochladen:

Bereitstellen:

Geben Sie das Cloud-Demo-Verzeichnis ein und führen Sie den folgenden Befehl aus:

docker-compose up -d

Greifen Sie dann im Browser auf die Anwendung zu

5.Docker-Image-Warehouse

5.1. Bauen Sie ein privates Spiegellager

5.1.1. Vereinfachte Version des Spiegellagers

Die offizielle Docker-Registrierung von Docker ist eine Basisversion des Docker-Image-Warehouses, die über vollständige Funktionen der Warehouse-Verwaltung verfügt, jedoch nicht über eine grafische Oberfläche verfügt.

Die Konstruktionsmethode ist relativ einfach, die Befehle lauten wie folgt:

docker run -d \
    --restart=always \
    --name registry	\
    -p 5000:5000 \
    -v registry-data:/var/lib/registry \
    registry

Der Befehl stellt ein Daten-Volume „registry-data“ in das Verzeichnis „/var/lib/registry“ im Container ein. Dabei handelt es sich um das Verzeichnis, in dem die private Bildbibliothek Daten speichert.

Besuchen Sie http://YourIp:5000/v2/_catalog, um die Bilder anzuzeigen, die im aktuellen privaten Bilddienst enthalten sind

5.1.2. Version mit grafischer Oberfläche

Verwenden Sie DockerCompose, um DockerRegistry mit einer grafischen Oberfläche bereitzustellen und die Datei /tmp/registry-ui/docker-compose.yml mit dem folgenden Inhalt zu erstellen:

version: '3.0'
services:
  registry:
    image: registry
    volumes:
      - ./registry-data:/var/lib/registry
  ui:
    image: joxit/docker-registry-ui:static
    ports:
      - 8080:80
    environment:
      - REGISTRY_TITLE=传智教育私有仓库
      - REGISTRY_URL=http://registry:5000
    depends_on:
      - registry

5.1.3. Konfigurieren Sie die Docker-Vertrauensadresse

Unser privater Server verwendet das http-Protokoll, dem Docker standardmäßig nicht vertraut, daher müssen wir eine Konfiguration vornehmen:

# 打开要修改的文件
vi /etc/docker/daemon.json
# 添加内容：
"insecure-registries":["http://192.168.200.140:8080"]
# 重加载
systemctl daemon-reload
# 重启docker
systemctl restart docker

Geben Sie das Verzeichnis /tmp/registry-ui ein und führen Sie den folgenden Befehl aus:

docker-compose up -d

docker tag java:8-alpine 192.168.63.129:8080/java:1.0 

docker push 192.168.63.129:8080/java:1.0 

docker pull 192.168.63.129:8080/java:1.0 

5.2. Bilder pushen und ziehen

Um ein Bild an einen privaten Bilddienst zu übertragen, müssen Sie es zunächst markieren. Die Schritte sind wie folgt:

① Markieren Sie das lokale Bild neu und das Namenspräfix ist die Adresse des privaten Lagers: 192.168.200.140:8080/

docker tag nginx:latest 192.168.200.140:8080/nginx:1.0 

② Schieben Sie das Bild

docker push 192.168.200.140:8080/nginx:1.0 

③ Ziehen Sie das Bild

docker pull 192.168.200.140:8080/nginx:1.0 

Besuchen Sie http://192.168.200.140:8080/, um die im aktuellen privaten Bilddienst enthaltenen Bilder anzuzeigen.