Docker Registry mit selbstsigniertem SSL-Zertifikat konfigurieren – Anleitung

Einführung

Docker hat sich zu einem unverzichtbaren Werkzeug für Entwickler und DevOps-Teams entwickelt und ermöglicht die nahtlose Bereitstellung und Verwaltung von containerisierten Anwendungen. Bei der Arbeit mit einer privaten Docker-Registry ist die Sicherung der Kommunikation zwischen Docker-Clients und dem Registry-Server entscheidend für den Schutz Ihrer Container-Images.

In diesem Lab lernen Sie, wie Sie eine lokale Docker-Registry einrichten und diese mit einem selbstsignierten SSL-Zertifikat sichern. Dieser Ansatz ist ideal für Entwicklungsumgebungen, Tests und Lernumgebungen, in denen Sie eine sichere Registry benötigen, ohne ein Zertifikat von einer vertrauenswürdigen Zertifizierungsstelle (Trusted Authority) zu erwerben.

Am Ende dieses Tutorials verfügen Sie über eine funktionierende Docker-Registry, die HTTPS für die sichere Kommunikation verwendet, sodass Sie Docker-Images sicher in Ihrer Entwicklungsumgebung pushen und pullen können.

Einrichten einer einfachen Docker-Registry

Bevor wir unsere Docker-Registry mit SSL sichern, wollen wir zunächst verstehen, was eine Docker-Registry ist und eine einfache Registry einrichten, mit der wir arbeiten können.

Was ist eine Docker-Registry?

Eine Docker-Registry ist ein Speicher- und Verteilungssystem für Docker-Container-Images. Sie ermöglicht Ihnen:

Ihre Docker-Images an einem zentralen Ort zu speichern
Images mit Ihrem Team oder Ihrer Organisation zu teilen
Den Zugriff auf Ihre Images zu kontrollieren
Container aus Ihren Images in verschiedenen Umgebungen bereitzustellen

Docker Hub ist die bekannteste öffentliche Registry, aber für viele Organisationen ist eine private Registry aus Gründen der Sicherheit, Leistung und Kontrolle unerlässlich.

Einrichten einer einfachen Registry

Beginnen wir damit, eine einfache, unsichere Docker-Registry auszuführen:

Erstellen Sie ein Verzeichnis, um unsere Registry-Daten zu speichern:
```
mkdir -p ~/project/registry-data
```
Führen Sie eine einfache Docker-Registry mit dem offiziellen Image aus:
```
docker run -d -p 5000:5000 --restart=always --name registry -v ~/project/registry-data:/var/lib/registry registry:2
```
Dieser Befehl:
- Führt den Registry-Container im Detached-Modus (-d) aus
- Mappt Port 5000 auf Ihrem Host auf Port 5000 im Container
- Legt fest, dass der Container automatisch neu gestartet wird, wenn er stoppt
- Nennt den Container "registry"
- Mountet das von uns erstellte Verzeichnis, um Registry-Daten zu speichern

Überprüfen Sie, ob die Registry läuft:

docker ps

Sie sollten eine ähnliche Ausgabe sehen:

CONTAINER ID   IMAGE        COMMAND                  CREATED         STATUS         PORTS                    NAMES
a7d8098de3a2   registry:2   "/entrypoint.sh /etc…"   5 seconds ago   Up 4 seconds   0.0.0.0:5000->5000/tcp   registry

Testen Sie die Registry, indem Sie ein Beispiel-Image pushen:

Zuerst ein kleines Image pullen:
```
docker pull hello-world
```
Taggen Sie es für Ihre lokale Registry:
```
docker tag hello-world localhost:5000/hello-world
```
Pushen Sie es in Ihre Registry:
```
docker push localhost:5000/hello-world
```
Sie sollten eine Ausgabe sehen, die zeigt, dass das Image in Ihre Registry gepusht wird.
Stoppen Sie den Registry-Container, bevor wir ihn in den nächsten Schritten sichern:
```
docker stop registry
docker rm registry
```

Diese einfache Registry funktioniert, hat aber eine erhebliche Einschränkung: Sie verwendet HTTP, was unsicher ist. Docker-Clients weigern sich standardmäßig, von unsicheren Registries zu pushen oder zu pullen. In den nächsten Schritten werden wir unsere Registry mit SSL sichern.

Generieren eines selbstsignierten SSL-Zertifikats

Nachdem wir die Grundlagen der Docker-Registry verstanden haben, sichern wir sie, indem wir ein selbstsigniertes SSL-Zertifikat generieren. Dieses Zertifikat ermöglicht die HTTPS-Kommunikation mit unserer Registry.

Was ist ein selbstsigniertes Zertifikat?

Ein selbstsigniertes Zertifikat ist ein SSL-Zertifikat, das nicht von einer vertrauenswürdigen Zertifizierungsstelle (CA - Certificate Authority) signiert wurde. Obwohl sie nicht für Produktionsumgebungen geeignet sind, die dem öffentlichen Internet ausgesetzt sind, eignen sich selbstsignierte Zertifikate perfekt für Entwicklung, Tests und interne Anwendungen.

Generieren des Zertifikats und des Schlüssels

Wir verwenden OpenSSL, ein weit verbreitetes Kryptografie-Toolkit, um unser Zertifikat zu erstellen:

Erstellen Sie ein Verzeichnis, um unsere Zertifikate zu speichern:
```
mkdir -p ~/project/registry-certs
cd ~/project/registry-certs
```
Generieren Sie einen privaten Schlüssel:
```
openssl genrsa -out registry.key 2048
```
Dieser Befehl generiert einen 2048-Bit-RSA-Privatschlüssel. Sie sollten keine Ausgabe sehen, wenn dies erfolgreich war.

Erstellen Sie eine Zertifikatsignierungsanforderung (CSR - Certificate Signing Request) mit dem privaten Schlüssel:

openssl req -new -key registry.key -out registry.csr

Sie werden aufgefordert, Informationen einzugeben, die in Ihrem Zertifikat enthalten sein sollen:

Country Name (2 letter code) [AU]:US
State or Province Name (full name) [Some-State]:California
Locality Name (eg, city) []:San Francisco
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Example Company
Organizational Unit Name (eg, section) []:IT
Common Name (e.g. server FQDN or YOUR name) []:localhost
Email Address []:[email protected]

Hinweis: Geben Sie für Common Name localhost ein, da wir uns auf unserem lokalen Rechner mit der Registry verbinden.

Sie werden auch nach Folgendem gefragt:

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:

Sie können diese leer lassen, indem Sie die Eingabetaste drücken.

Generieren Sie das selbstsignierte Zertifikat mit der CSR:

openssl x509 -req -days 365 -in registry.csr -signkey registry.key -out registry.crt

Dieser Befehl erstellt ein selbstsigniertes Zertifikat, das 365 Tage gültig ist.

Sie sollten eine ähnliche Ausgabe sehen:

Signature ok
subject=C = US, ST = California, L = San Francisco, O = Example Company, OU = IT, CN = localhost, emailAddress = [email protected]
Getting Private key

Überprüfen Sie, ob die Zertifikats- und Schlüsseldateien erstellt wurden:

ls -l

Sie sollten drei Dateien sehen:

total 12
-rw-r--r-- 1 labex labex 1220 [date] registry.crt
-rw-r--r-- 1 labex labex 1054 [date] registry.csr
-rw-r--r-- 1 labex labex 1679 [date] registry.key

Jetzt haben wir die notwendigen Dateien, um unsere Docker-Registry zu sichern. Im nächsten Schritt konfigurieren wir unsere Registry so, dass sie dieses Zertifikat für die HTTPS-Kommunikation verwendet.

Konfigurieren der Docker-Registry mit SSL-Zertifikat

Nachdem wir unser selbstsigniertes Zertifikat haben, können wir unsere Docker-Registry so konfigurieren, dass sie SSL für die sichere Kommunikation verwendet.

Einrichten der sicheren Registry

Erstellen wir zunächst eine einfache Konfigurationsdatei für unsere Registry. Diese Datei gibt die HTTPS-Einstellungen an:
```
mkdir -p ~/project/registry-config
cd ~/project/registry-config
nano config.yml
```
Fügen Sie die folgende Konfiguration zur Datei hinzu:
```
version: 0.1
storage:
  filesystem:
    rootdirectory: /var/lib/registry
http:
  addr: 0.0.0.0:5000
  tls:
    certificate: /certs/registry.crt
    key: /certs/registry.key
```
Diese Konfiguration weist die Registry an:
- Das Dateisystem für die Speicherung zu verwenden
- Auf allen Schnittstellen auf Port 5000 zu lauschen
- TLS (HTTPS) mit unserem Zertifikat und Schlüssel zu verwenden
Speichern und beenden Sie die Datei, indem Sie Ctrl+X, dann Y und dann Enter drücken.

Führen wir nun unsere Registry mit dem SSL-Zertifikat aus:

docker run -d -p 5000:5000 --restart=always --name registry \
  -v ~/project/registry-data:/var/lib/registry \
  -v ~/project/registry-certs:/certs \
  -v ~/project/registry-config/config.yml:/etc/docker/registry/config.yml \
  registry:2

Dieser Befehl:

Mountet unser Zertifikats- und Schlüsselverzeichnis
Mountet unsere Konfigurationsdatei
Verwendet dasselbe Datenverzeichnis, das wir zuvor erstellt haben

Überprüfen Sie, ob die Registry läuft:
```
docker ps
```
Sie sollten eine Ausgabe sehen, die anzeigt, dass der Registry-Container läuft.

Konfigurieren des Docker-Clients, um dem Zertifikat zu vertrauen

Standardmäßig vertrauen Docker-Clients keinen selbstsignierten Zertifikaten. Wir müssen Docker anweisen, unserem Zertifikat zu vertrauen:

Erstellen Sie ein Verzeichnis, in dem Docker vertrauenswürdige Zertifikate speichert:
```
sudo mkdir -p /etc/docker/certs.d/localhost:5000
```

Kopieren Sie unser Zertifikat in dieses Verzeichnis:

sudo cp ~/project/registry-certs/registry.crt /etc/docker/certs.d/localhost:5000/ca.crt

Starten Sie den Docker-Dienst neu, um die Änderungen zu übernehmen:
```
sudo systemctl restart docker
```
Dies kann einige Sekunden dauern.
Da das Neustarten von Docker unseren Registry-Container stoppt, starten wir ihn erneut:
```
docker start registry
```
Überprüfen Sie erneut, ob die Registry läuft:
```
docker ps
```

Jetzt ist unsere Docker-Registry so konfiguriert, dass sie HTTPS mit unserem selbstsignierten Zertifikat verwendet, und unser Docker-Client ist so konfiguriert, dass er diesem Zertifikat vertraut, wenn er sich mit localhost:5000 verbindet.

Testen der sicheren Docker-Registry

Nachdem unsere Docker-Registry mit SSL läuft, testen wir sie, indem wir Images pushen und pullen. Dadurch wird bestätigt, dass alles korrekt funktioniert.

Testen mit einem Beispiel-Image

Zuerst ziehen wir ein Beispiel-Image, das wir zum Testen verwenden können:
```
docker pull alpine:latest
```
Sie sollten eine Ausgabe sehen, die anzeigt, dass Docker das Alpine Linux-Image herunterlädt.
Taggen Sie das Image für unsere sichere Registry:
```
docker tag alpine:latest localhost:5000/alpine:latest
```
Dieser Befehl erstellt ein neues Tag, das auf unsere lokale Registry verweist.

Pushen Sie das Image in unsere sichere Registry:

docker push localhost:5000/alpine:latest

Sie sollten eine Ausgabe sehen, die anzeigt, dass die Image-Layer in Ihre Registry gepusht werden:

The push refers to repository [localhost:5000/alpine]
213ec9aee27d: Pushed
latest: digest: sha256:69e70a79f2d41ab5d637de98c1e0b055206ba40a8145e7bddb55ccc04e13cf8f size: 528

Entfernen Sie das lokale Image, um sicherzustellen, dass wir aus der Registry pullen:
```
docker rmi localhost:5000/alpine:latest
docker rmi alpine:latest
```

Pullen Sie das Image aus unserer sicheren Registry:

docker pull localhost:5000/alpine:latest

Sie sollten eine Ausgabe sehen, die anzeigt, dass Docker das Image aus Ihrer Registry herunterlädt:

latest: Pulling from alpine
213ec9aee27d: Pull complete
Digest: sha256:69e70a79f2d41ab5d637de98c1e0b055206ba40a8145e7bddb55ccc04e13cf8f
Status: Downloaded newer image for localhost:5000/alpine:latest
localhost:5000/alpine:latest

Überprüfen des Registry-Inhalts

Untersuchen wir den Inhalt unserer Registry mithilfe der Docker Registry API:

Listen Sie alle Repositories in der Registry auf:
```
curl -X GET https://localhost:5000/v2/_catalog --cacert ~/project/registry-certs/registry.crt
```
Sie sollten eine Ausgabe wie folgt sehen:
```
{ "repositories": ["alpine", "hello-world"] }
```
Dies zeigt alle Images, die wir in unsere Registry gepusht haben.

Listen Sie alle Tags für das alpine-Repository auf:

curl -X GET https://localhost:5000/v2/alpine/tags/list --cacert ~/project/registry-certs/registry.crt

Sie sollten eine Ausgabe wie folgt sehen:

{ "name": "alpine", "tags": ["latest"] }

Verstehen, was wir erreicht haben

Fassen wir zusammen, was wir getan haben:

Eine Docker-Registry mit HTTPS unter Verwendung eines selbstsignierten SSL-Zertifikats eingerichtet
Unseren Docker-Client so konfiguriert, dass er diesem Zertifikat vertraut
Erfolgreich Images in unsere sichere Registry gepusht und aus dieser gepullt

Diese Einrichtung bietet:

Verschlüsselte Kommunikation: Alle Daten, die zwischen Docker-Client und Registry übertragen werden, sind verschlüsselt.
Grundlage für die Authentifizierung: SSL ist der erste Schritt zur Implementierung der Authentifizierung.
Docker-Client-Kompatibilität: Docker-Clients benötigen standardmäßig HTTPS für Nicht-localhost-Registries.

Sie können diese sichere Registry jetzt für Ihre Entwicklungs- und Testanforderungen verwenden. Für Produktionsumgebungen würden Sie typischerweise ein Zertifikat von einer vertrauenswürdigen Zertifizierungsstelle anstelle eines selbstsignierten Zertifikats verwenden.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben erfolgreich eine sichere Docker-Registry mit einem selbstsignierten SSL-Zertifikat eingerichtet. Folgendes haben Sie erreicht:

Eine grundlegende Docker-Registry eingerichtet und ihren Zweck und ihre Funktionalität verstanden
Ein selbstsigniertes SSL-Zertifikat zur Sicherung Ihrer Registry generiert
Die Docker-Registry so konfiguriert, dass sie HTTPS mit Ihrem Zertifikat verwendet
Ihren Docker-Client so konfiguriert, dass er dem selbstsignierten Zertifikat vertraut
Die sichere Registry erfolgreich getestet, indem Sie Images gepusht und gepullt haben

Mit diesen Fähigkeiten können Sie sichere private Registries für Ihre Entwicklungs- und Testumgebungen erstellen. Private Registries geben Ihnen die Kontrolle darüber, wo Ihre Docker-Images gespeichert werden und wer darauf zugreifen kann, während die SSL-Verschlüsselung sicherstellt, dass Ihre Daten während der Übertragung sicher bleiben.

Für Produktionsumgebungen würden Sie typischerweise Zertifikate von einer vertrauenswürdigen Zertifizierungsstelle verwenden, aber der Konfigurationsprozess wäre ähnlich wie in diesem Lab gelernt.

Jetzt können Sie in Ihren eigenen Projekten und Entwicklungsworkflows sicher sichere Docker-Registries implementieren und so die Sicherheit Ihrer containerisierten Anwendungen erhöhen.

Konfiguration einer Docker Registry mit selbstsigniertem SSL-Zertifikat