Anleitung zum Einrichten einer privaten Docker-Registrierung unter Rocky Linux 8

Wenn Sie für eine Organisation arbeiten und Ihre Docker-Images für eine schnelle Bereitstellung intern behalten möchten, ist das Hosten eines privaten Docker-Repositorys perfekt. Mit einer privaten Docker-Registrierung können Sie Ihre Bildverteilungspipeline besitzen und eine strengere Kontrolle über die Bildspeicherung und -verteilung haben. Sie können Ihre Registrierung in Ihr CI/CD-System integrieren und so Ihren Arbeitsablauf verbessern.

In diesem Tutorial erfahren Sie, wie Sie eine private Docker-Registrierung auf einem Rocky Linux 8-basierten Server mit Amazon S3 als Speicherort einrichten und verwenden.

Voraussetzungen

• Zwei Linux-Server mit Rocky Linux 8. Ein Server fungiert als Registrierungshost, während der andere als Client verwendet wird, um Anfragen zu senden und Bilder vom Host zu empfangen.
• Ein registrierter Domänenname, der auf den Hostserver verweist. Wir werden registry.example.com verwenden für unser Tutorial.
• Ein Nicht-Root-Benutzer mit sudo-Berechtigungen auf beiden Maschinen.

Schritt 1 – Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet Firewalld Firewall. Überprüfen Sie den Status der Firewall.

$ sudo firewall-cmd --state
running

Die Firewall arbeitet mit verschiedenen Zonen, und die öffentliche Zone ist die Standardzone, die wir verwenden werden. Listet alle Dienste und Ports auf, die auf der Firewall aktiv sind.

$ sudo firewall-cmd --permanent --list-services

Es sollte die folgende Ausgabe zeigen.

cockpit dhcpv6-client ssh

HTTP- und HTTPS-Ports zulassen.

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

Überprüfen Sie den Status der Firewall erneut.

$ sudo firewall-cmd --permanent --list-services

Sie sollten eine ähnliche Ausgabe sehen.

cockpit dhcpv6-client http https ssh

Laden Sie die Firewall neu, um die Änderungen zu aktivieren.

$ sudo firewall-cmd --reload

Schritt 2 – Docker und Docker Compose installieren

Dieser Schritt ist sowohl auf dem Server als auch auf den Client-Rechnern erforderlich.

Installieren Sie das offizielle Docker-Repository.

$ sudo dnf install yum-utils
$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

Docker installieren.

$ sudo dnf install docker-ce docker-ce-cli containerd.io

Aktivieren Sie den Docker-Daemon und führen Sie ihn aus.

$ sudo systemctl enable docker --now

Fügen Sie Ihren Systembenutzer zur Docker-Gruppe hinzu, um die Verwendung von sudo zu vermeiden um Docker-Befehle auszuführen.

$ sudo usermod -aG docker $(whoami)

Melden Sie sich nach dem Abmelden erneut bei Ihrem Server an, um die Änderung zu aktivieren.

Laden Sie die neueste stabile Version von Docker Compose herunter und installieren Sie sie.

$ sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Ausführbare Berechtigungen auf die heruntergeladene Binärdatei anwenden.

$ sudo chmod +x /usr/local/bin/docker-compose

Installieren Sie das Docker-compose Bash Completion-Skript.

$ sudo curl \
    -L https://raw.githubusercontent.com/docker/compose/1.29.2/contrib/completion/bash/docker-compose \
    -o /etc/bash_completion.d/docker-compose

Laden Sie Ihre Profileinstellungen neu, damit die Bash-Vervollständigung funktioniert.

$ source ~/.bashrc

Schritt 3 – Konfigurieren Sie die Docker-Registrierung

Benutzerverzeichnisse erstellen

Erstellen Sie ein Verzeichnis für die Registrierungskonfiguration.

$ mkdir ~/docker-registry

Wechseln Sie zur docker-registry Verzeichnis.

$ cd ~/docker-registry

Erstellen Sie ein Verzeichnis zum Speichern des HTTP-Authentifizierungskennworts, der Nginx-Konfigurationsdateien und der SSL-Zertifikate.

$ mkdir auth

Erstellen Sie ein weiteres Verzeichnis zum Speichern von Nginx-Protokollen.

$ mkdir logs

Amazon S3-Bucket erstellen

Sie können die Registrierungsdaten und die Bilder auf Ihrem Server speichern oder einen Cloud-Hosting-Dienst verwenden. Für unser Tutorial verwenden wir den Amazon S3-Cloud-Service.

Der nächste Schritt besteht darin, die Konfigurationsdatei mit einigen wichtigen Einstellungen einzurichten. Diese Einstellungen können auch in der docker-compose.yml definiert werden Datei, aber es ist viel besser, eine separate Datei zu haben.

Erstellen Sie einen Bucket mit den folgenden Einstellungen.

• ACL sollte deaktiviert sein.
• Der öffentliche Zugriff auf den Bucket sollte deaktiviert werden.
• Bucket-Versionierung sollte deaktiviert werden.
• Aktivieren Sie die Bucket-Verschlüsselung mit von Amazon S3 verwalteten Schlüsseln. (SSE-S3)
• Objektsperre sollte deaktiviert sein.

Erstellen Sie einen IAM-Benutzer mit der folgenden Richtlinie.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:ListBucket",
        "s3:GetBucketLocation",
        "s3:ListBucketMultipartUploads"
      ],
      "Resource": "arn:aws:s3:::S3_BUCKET_NAME"
    },
    {
      "Effect": "Allow",
      "Action": [
        "s3:PutObject",
        "s3:GetObject",
        "s3:DeleteObject",
        "s3:ListMultipartUploadParts",
        "s3:AbortMultipartUpload"
      ],
      "Resource": "arn:aws:s3:::S3_BUCKET_NAME/*"
    }
  ]
}

Ersetzen Sie den S3_BUCKET_NAME mit dem Namen Ihres S3-Buckets.

Notieren Sie den geheimen Schlüssel, den geheimen Wert und die Bucket-Region Ihres später zu verwendenden Buckets.

Docker-Compose-Datei erstellen

Erstellen Sie die docker-compose.yml Datei und öffnen Sie sie zum Bearbeiten.

$ nano docker-compose.yml

Fügen Sie den folgenden Code ein.

version: '3.3'
services:
  registry:
    image: registry:2 
    restart: always
    environment:
      - REGISTRY_STORAGE=s3
      - REGISTRY_STORAGE_S3_REGION=us-west-2
      - REGISTRY_STORAGE_S3_BUCKET=hf-docker-registry
      - REGISTRY_STORAGE_S3_ENCRYPT=true
      - REGISTRY_STORAGE_S3_CHUNKSIZE=5242880
      - REGISTRY_STORAGE_S3_SECURE=true
      - REGISTRY_STORAGE_S3_ACCESSKEY=AKIA3FIG4NVFCJ6STMUA
      - REGISTRY_STORAGE_S3_SECRETKEY=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
      - REGISTRY_STORAGE_S3_V4AUTH=true
      - REGISTRY_STORAGE_S3_ROOTDIRECTORY=/image-registry
      - REGISTRY_STORAGE_CACHE_BLOBDESCRIPTOR=inmemory
      - REGISTRY_HEALTH_STORAGEDRIVER_ENABLED=false
  nginx:  
    image: "nginx:alpine"
    ports:
      - 443:443
    links:
      - registry:registry
    volumes:
      - ./auth:/etc/nginx/conf.d
      - ./auth/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./logs:/var/log/nginx
      - /etc/letsencrypt:/etc/letsencrypt

Speichern Sie die Datei, indem Sie Strg + X drücken und geben Sie Y ein wenn Sie dazu aufgefordert werden.

Lassen Sie uns durchgehen, was wir in unserer Compose-Datei eingerichtet haben.

1. Der erste Schritt besteht darin, das neueste Image von Version 2 der Docker-Registrierung vom Hub zu holen. Wir verwenden nicht das neueste Tag, da es bei einem Upgrade der Hauptversion zu Problemen führen kann. Wenn Sie es auf 2 setzen, können Sie alle 2.x-Updates abrufen und gleichzeitig verhindern, dass automatisch auf die nächste Hauptversion aktualisiert wird, was zu bahnbrechenden Änderungen führen kann.

2. Der Registrierungscontainer ist so eingestellt, dass er im Falle eines Fehlers oder eines unerwarteten Herunterfahrens immer neu gestartet wird.

3. Wir haben verschiedene Umgebungsvariablen für den Amazon S3-Speicher festgelegt. Lassen Sie uns sie schnell durchgehen.

   • REGISTRY_STORAGE legt die Speicherart fest. Wir haben s3 ausgewählt da wir Amazon S3 verwenden.
   • REGISTRY_STORAGE_S3_REGION legt die Region Ihres S3-Buckets fest.
   • REGISTRY_STORAGE_S3_BUCKET legt den Namen Ihres S3-Buckets fest.
   • REGISTRY_STORAGE_S3_ENCRYPT - Setzen Sie es auf "true", wenn Sie die Bucket-Verschlüsselung aktiviert haben.
   • REGISTRY_STORAGE_S3_CHUNKSIZE legt die Größe der Upload-Blöcke fest. Es sollte größer als 5 MB (5 * 1024 * 1024) sein.
   • REGISTRY_STORAGE_S3_SECURE - Setzen Sie es auf "true", wenn Sie HTTPS verwenden werden.
   • REGISTRY_STORAGE_S3_ACCESSKEY und REGISTRY_STORAGE_S3_SECRETKEY - Benutzeranmeldeinformationen, die Sie nach dem Erstellen Ihres IAM-Benutzers abgerufen haben.
   • REGISTRY_STORAGE_S3_V4AUTH - Setzen Sie es auf „true“, wenn Sie v4 der AWS-Authentifizierung verwenden. Wenn Sie Fehler bezüglich der S3-Anmeldung erhalten, setzen Sie sie auf „false“.
   • REGISTRY_STORAGE_S3_ROOTDIRECTORY - legt das Stammverzeichnis in Ihrem Bucket fest, unter dem Ihre Registrierungsdaten gespeichert werden.
   • REGISTRY_STORAGE_CACHE_BLOBDESCRIPTOR - legt den Speicherort für den Cache fest. In unserem Fall speichern wir es im Gedächtnis. Sie können es auch so einstellen, dass es Redis verwendet.
   • REGISTRY_HEALTH_STORAGEDRIVER_ENABLED – Legen Sie es auf „false“ fest, um den Speicherintegritätsprüfungsdienst der Registrierung zu deaktivieren. Es gibt einen Fehler in der Registrierung, der Probleme verursachen kann, wenn Sie ihn nicht auf "false" setzen.

4. Die Docker-Registrierung kommuniziert über Port 5000, den wir in unserem Server dem Docker offengelegt haben.

5. ./auth:/etc/nginx/conf.d Mapping stellt sicher, dass alle Nginx-Einstellungen im Container verfügbar sind.

6. ./auth/nginx.conf:/etc/nginx/nginx.conf:ro ordnet die Nginx-Einstellungsdatei vom System einer Datei im Container im schreibgeschützten Modus zu.

7. ./logs:/var/log/nginx ermöglicht den Zugriff auf die Nginx-Protokolle auf dem System durch Zuordnung zum Nginx-Protokollverzeichnis im Container.

8. Die Einstellungen der Docker-Registrierung werden in /etc/docker/registry/config.yml gespeichert Datei im Container, und wir haben sie der config.yml zugeordnet Datei im aktuellen Verzeichnis, die wir im nächsten Schritt erstellen werden.

Authentifizierung einrichten

Um die HTTP-Authentifizierung einzurichten, müssen Sie die httpd-tools installieren Paket.

$ sudo dnf install httpd-tools

Erstellen Sie die Passwortdatei in ~/docker-registry/auth Verzeichnis.

$ htpasswd -Bc ~/docker-registry/auth/nginx.htpasswd user1
New password:
Re-type new password:
Adding password for user user1

Das -c Flag weist den Befehl an, eine neue Datei zu erstellen, und das -B flag ist es, den von Docker unterstützten bcrypt-Algorithmus zu verwenden. Ersetzen Sie user1 mit einem Benutzernamen Ihrer Wahl.

Wenn Sie weitere Benutzer hinzufügen möchten, führen Sie den Befehl erneut aus, jedoch ohne -c Flagge.

$ htpasswd -B ~/docker-registry/auth/registry.password user2

Jetzt wird die Datei zur Authentifizierung dem Registrierungscontainer zugeordnet.

Schritt 4 – SSL installieren

Um ein SSL-Zertifikat mit Let's Encrypt zu installieren, müssen wir das Certbot-Tool herunterladen, das im Epel-Repository verfügbar ist.

Installieren Sie das EPEL-Repository und Certbot.

$ sudo dnf install epel-release 
$ sudo dnf install certbot

Generieren Sie ein SSL-Zertifikat.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d registry.example.com

Der obige Befehl lädt ein Zertifikat in /etc/letsencrypt/live/registry.example.com herunter Verzeichnis auf Ihrem Server.

Erstellen Sie eine Diffie-Hellman-Gruppe Zertifikat.

$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096

Testen Sie die Erneuerung des Zertifikats.

$ sudo certbot renew --dry-run

Wenn der Probelauf erfolgreich ist, bedeutet dies, dass Ihre Zertifikate automatisch verlängert werden.

Kopieren Sie die Dhparam-Datei in den Container

Kopieren Sie die Diffie-Hellman-Gruppe Zertifikat an ~/docker-registry/auth Verzeichnis, das dem Container zugeordnet wird.

$ sudo cp /etc/ssl/certs/dhparam.pem ~/docker-registry/auth

Schritt 5 – Nginx konfigurieren

Im nächsten Schritt wird der Nginx-Server als Front-End-Proxy für den Docker-Registrierungsserver konfiguriert. Die Docker-Registrierung wird mit einem eingebauten Server geliefert, der an Port 5000 betrieben wird. Wir werden ihn hinter Nginx stellen.

Erstellen und öffnen Sie die Datei ~/docker-registry/auth/nginx.conf zum Bearbeiten.

$ sudo nano ~/docker-registry/auth/nginx.conf

Fügen Sie den folgenden Code ein.

events {
    worker_connections  1024;
}

http {

  upstream docker-registry {
    server registry:5000;
  }

  ## Set a variable to help us decide if we need to add the
  ## 'Docker-Distribution-Api-Version' header.
  ## The registry always sets this header.
  ## In the case of nginx performing auth, the header is unset
  ## since nginx is auth-ing before proxying.
  map $upstream_http_docker_distribution_api_version $docker_distribution_api_version {
    '' 'registry/2.0';
  }

  server {
    listen 443 ssl http2;
    server_name registry.example.com;

    # SSL
    ssl_certificate /etc/letsencrypt/live/registry.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/registry.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/registry.example.com/chain.pem;

    access_log  /var/log/nginx/registry.access.log;
    error_log   /var/log/nginx/registry.error.log;

    # Recommendations from https://raymii.org/s/tutorials/Strong_SSL_Security_On_nginx.html
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers on;
    ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
    ssl_session_cache shared:SSL:10m;
    ssl_dhparam /etc/nginx.d/conf.d/dhparam.pem;
    resolver 8.8.8.8;

    # disable any limits to avoid HTTP 413 for large image uploads
    client_max_body_size 0;

    # required to avoid HTTP 411: see Issue #1486 (https://github.com/moby/moby/issues/1486)
    chunked_transfer_encoding on;

    location /v2/ {
      # Do not allow connections from docker 1.5 and earlier
      # docker pre-1.6.0 did not properly set the user agent on ping, catch "Go *" user agents
      if ($http_user_agent ~ "^(docker\/1\.(3|4|5(?!\.[0-9]-dev))|Go ).*$" ) {
        return 404;
      }

      # To add basic authentication to v2 use auth_basic setting.
      auth_basic "Registry realm";
      auth_basic_user_file /etc/nginx/conf.d/nginx.htpasswd;

      ## If $docker_distribution_api_version is empty, the header is not added.
      ## See the map directive above where this variable is defined.
      add_header 'Docker-Distribution-Api-Version' $docker_distribution_api_version always;

      proxy_pass                          http://docker-registry;
      proxy_set_header  Host              $http_host;   # required for docker client's sake
      proxy_set_header  X-Real-IP         $remote_addr; # pass on real client's IP
      proxy_set_header  X-Forwarded-For   $proxy_add_x_forwarded_for;
      proxy_set_header  X-Forwarded-Proto $scheme;
      proxy_read_timeout                  900;
    }
  }
}

Speichern Sie die Datei, indem Sie Strg + X drücken und geben Sie Y ein wenn Sie dazu aufgefordert werden, sobald Sie fertig sind.

Konfigurieren Sie SELinux so, dass Netzwerkverbindungen für die private Docker-Registrierung zugelassen werden.

$ sudo setsebool -P httpd_can_network_connect on

Schritt 6 – Starten Sie die Docker-Registrierung

Wechseln Sie in das Verzeichnis der Docker-Registrierung.

$ cd ~/docker-registry

Starten Sie den Docker-Container.

$ docker-compose up -d

Überprüfen Sie den Status der Container.

$ docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                                           NAMES
88d6addc1687   nginx:alpine   "/docker-entrypoint.…"   5 minutes ago   Up 5 minutes   80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp   docker-registry_nginx_1
2b112edc1c72   registry:2     "/entrypoint.sh /etc…"   5 minutes ago   Up 5 minutes   5000/tcp                                        docker-registry_registry_1

Melden Sie sich bei der Docker-Registrierung an.

$ docker login -u=testuser -p=testpassword https://registry.example.com

Sie können auch die URL https://registry.example.com/v2/ öffnen in Ihrem Browser, und es wird nach einem Benutzernamen und einem Passwort gefragt. Sie sollten eine leere Seite mit {} sehen drauf.

Sie können die URL auf dem Terminal mit curl überprüfen .

$ curl -u testuser -X GET https://registry.nspeaks.xyz/v2/
Enter host password for user 'testuser':
{}

Laden Sie das neueste Ubuntu-Docker-Image herunter.

$ docker pull ubuntu:latest

Kennzeichnen Sie dieses Bild für die private Registrierung.

$ docker tag ubuntu:latest registry.example.com/ubuntu2004

Schieben Sie das Image in die Registrierung.

$ docker push registry.example.com/ubuntu2004

Testen Sie, ob der Push erfolgreich war.

$ curl -u testuser -X GET https://registry.nspeaks.xyz/v2/_catalog
Enter host password for user 'testuser':
{"repositories":["ubuntu2004"]}

Geben Sie Ihr Nginx-Authentifizierungspasswort ein, wenn Sie dazu aufgefordert werden, und Sie sehen die Liste der über die Registrierung verfügbaren Repositories.

Überprüfen Sie die Liste der Docker-Images, die derzeit zur Verwendung verfügbar sind.

$ docker images
REPOSITORY                            TAG       IMAGE ID       CREATED       SIZE
registry                              2         d3241e050fc9   5 days ago    24.2MB
nginx                                 alpine    53722defe627   5 days ago    23.4MB
httpd                                 2         118b6abfbf55   5 days ago    144MB
ubuntu                                latest    ff0fea8310f3   2 weeks ago   72.8MB
registry.nspeaks.xyz/ubuntu2004       latest    ff0fea8310f3   2 weeks ago   72.8MB

Schritt 7 – Greifen Sie auf die Docker-Registrierung vom Clientcomputer aus zu und verwenden Sie sie

Melden Sie sich bei Ihrem Client-Server an. In Schritt 1 haben wir Docker auf dem Client-Rechner installiert.

Melden Sie sich vom Clientcomputer aus bei der privaten Docker-Registrierung an.

$ docker login -u=testuser -p=testpassword https://registry.example.com

Ziehen Sie das Ubuntu-Image aus der Registrierung.

$ docker pull registry.example.com/ubuntu2004

Alle Bilder auf Ihrem Client-Rechner auflisten.

$ docker images
REPOSITORY                        TAG        IMAGE ID       CREATED         SIZE
registry.nspeaks.xyz/ubuntu2004   latest     ff0fea8310f3   2 weeks ago     72.8MB

Erstellen und starten Sie einen Container mit dem heruntergeladenen Image.

$ docker run -it registry.example.com/ubuntu2004 /bin/bash

Sie werden bei der Shell im Ubuntu-Container angemeldet.

[email protected]:

Führen Sie den folgenden Befehl aus, um die Linux-Version zu überprüfen.

[email protected]$ cat /etc/os-release
NAME="Ubuntu"
VERSION="20.04.4 LTS (Focal Fossa)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 20.04.4 LTS"
VERSION_ID="20.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=focal
UBUNTU_CODENAME=focal

Jetzt können Sie beginnen, Ihre Docker-Registrierung von Ihren Client-Rechnern aus zu verwenden.

Schlussfolgerung

Damit ist unser Tutorial zum Einrichten einer privaten Docker-Registrierung auf einem Rocky Linux 8-basierten Server abgeschlossen, der Amazon S3 als Speicher verwendet. Wenn Sie Fragen haben, posten Sie diese in den Kommentaren unten.