HowtoForge

Wie man eine private Docker-Registry unter Ubuntu 22.04 einrichtet

von ·

Wenn du für ein Unternehmen arbeitest und deine Docker-Images intern aufbewahren möchtest, um sie schnell bereitzustellen, dann ist ein privates Docker-Repository perfekt. Mit einer privaten Docker-Registry kannst du deine Image-Verteilungspipeline selbst verwalten und hast eine bessere Kontrolle über die Speicherung und Verteilung der Images. Du kannst deine Registry in dein CI/CD-System integrieren und so deinen Workflow verbessern.

In diesem Tutorial erfährst du, wie du eine private Docker-Registry auf einem Ubuntu 22.04 Server einrichtest und verwendest und dabei Amazon S3 als Speicherort nutzt.

Voraussetzungen

  • Zwei Linux-Server mit Ubuntu 22.04. Ein Server wird als Registry-Host fungieren, während der andere als Client verwendet wird, um Anfragen zu senden und Images vom Host zu empfangen.
  • Ein registrierter Domainname, der auf den Hostserver zeigt. Für unseren Lehrgang werden wir registry.example.com verwenden.
  • Ein Nicht-Root-Benutzer mit sudo-Rechten auf beiden Rechnern.
  • Stelle sicher, dass alles auf dem neuesten Stand ist. 
    $ sudo apt update
$ sudo apt upgrade
  • Ein paar Pakete, die dein System benötigt. 
    $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y

    Einige dieser Pakete sind vielleicht schon auf deinem System installiert.

Schritt 1 – Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Ubuntu wird standardmäßig mit ufw (Uncomplicated Firewall) ausgeliefert.

Überprüfe, ob die Firewall läuft.

$ sudo ufw status

Du solltest die folgende Ausgabe erhalten.

Status: inactive

Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.

$ sudo ufw allow OpenSSH

Lasse auch HTTP- und HTTPS-Ports zu.

$ sudo ufw allow http
$ sudo ufw allow https

Aktiviere die Firewall

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Überprüfe den Status der Firewall erneut.

$ sudo ufw status

Du solltest eine ähnliche Ausgabe sehen.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Schritt 2 – Installiere Docker und Docker Compose

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

Ubuntu 22.04 wird mit einer älteren Version von Docker ausgeliefert. Um die neueste Version zu installieren, musst du zuerst den Docker GPG-Schlüssel importieren.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Erstelle eine Docker-Repository-Datei.

$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aktualisiere die Liste der System-Repositorys.

$ sudo apt update

Installiere die neueste Version von Docker.

$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Überprüfe, ob sie läuft.

$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since Thu 2023-04-13 09:37:09 UTC; 3min 47s ago
TriggeredBy: ? docker.socket
       Docs: https://docs.docker.com
   Main PID: 2106 (dockerd)
      Tasks: 7
     Memory: 26.0M
        CPU: 267ms
     CGroup: /system.slice/docker.service
             ??2106 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Standardmäßig benötigt Docker Root-Rechte. Wenn du vermeiden willst, dass du jedes Mal sudo verwendest, wenn du den Befehl docker ausführst, füge deinen Benutzernamen der Gruppe docker hinzu.

$ sudo usermod -aG docker $(whoami)

Um diese Änderung zu aktivieren, musst du dich vom Server abmelden und als derselbe Benutzer wieder anmelden oder den folgenden Befehl verwenden.

$ su - ${USER}

Bestätige, dass dein Benutzer der Docker-Gruppe hinzugefügt wurde.

$ groups
navjot wheel docker

Schritt 3 – Docker Registry konfigurieren

Benutzerverzeichnisse erstellen

Erstelle ein Verzeichnis für die Konfiguration der Registry.

$ mkdir ~/docker-registry

Wechsle in das Verzeichnis docker-registry.

$ cd ~/docker-registry

Erstelle ein Verzeichnis, in dem das Passwort für die HTTP-Authentifizierung, die Nginx-Konfigurationsdateien und die SSL-Zertifikate gespeichert werden.

$ mkdir auth

Erstelle ein weiteres Verzeichnis, um Nginx-Protokolle zu speichern.

$ mkdir logs

Amazon S3 Bucket erstellen

Du kannst die Registrierungsdaten und die Bilder auf deinem Server speichern oder einen Cloud-Hosting-Dienst nutzen. Für unser Tutorial werden wir den Amazon S3 Cloud Service verwenden.

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

Erstelle einen Bucket mit den folgenden Einstellungen.

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

Erstelle 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/*"
    }
  ]
}

Ersetze S3_BUCKET_NAME durch den Namen deines S3-Buckets.

Notiere dir den geheimen Schlüssel, den geheimen Wert und die Bucket-Region deines Buckets, die später verwendet werden sollen.

Docker Compose-Datei erstellen

Erstelle die Datei docker-compose.yml und öffne sie zur Bearbeitung.

$ nano docker-compose.yml

Füge den folgenden Code in die Datei ein.

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=AKIA3FIG4NVFNXKQXMSJ
      - 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

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Gehen wir nun durch, was wir in unserer Compose-Datei eingerichtet haben.

  1. Der erste Schritt besteht darin, das neueste Image der Version 2 der Docker-Registry aus dem Hub zu holen. Wir verwenden nicht das neueste Tag, weil es bei einem größeren Versions-Upgrade zu Problemen führen kann. Mit der Einstellung 2 kannst du alle 2.x-Updates abrufen und gleichzeitig verhindern, dass du automatisch auf die nächste Hauptversion aktualisiert wirst, was zu Problemen führen kann.
  2. Der Registrierungscontainer ist so eingestellt, dass er im Falle eines Fehlers oder eines unerwarteten Herunterfahrens immer neu startet.
  3. Wir haben verschiedene Umgebungsvariablen für den Amazon S3-Speicher gesetzt. Gehen wir sie kurz durch.
    • REGISTRY_STORAGE legt die Art des Speichers fest. Wir haben s3 gewählt, da wir Amazon S3 verwenden.
    • REGISTRY_STORAGE_S3_REGION legt die Region deines S3-Buckets fest.
    • REGISTRY_STORAGE_S3_BUCKET legt den Namen deines S3-Buckets fest.
    • REGISTRY_STORAGE_S3_ENCRYPT – setzt es auf true, wenn du die Bucket-Verschlüsselung aktiviert hast.
    • REGISTRY_STORAGE_S3_CHUNKSIZE legt die Größe der Upload-Chunks fest. Sie sollte größer als 5MB (5 * 1024 * 1024) sein.
    • REGISTRY_STORAGE_S3_SECURE – setze ihn auf true, wenn du HTTPS verwenden willst.
    • REGISTRY_STORAGE_S3_ACCESSKEY und REGISTRY_STORAGE_S3_SECRETKEY – Benutzeranmeldedaten, die du nach der Erstellung deines IAM-Benutzers erhalten hast.
    • REGISTRY_STORAGE_S3_V4AUTH – Setze es auf true, wenn du v4 der AWS-Authentifizierung verwendest. Wenn du Fehler bei der S3-Anmeldung bekommst, setze ihn auf false.
    • REGISTRY_STORAGE_S3_ROOTDIRECTORY – legt das Stammverzeichnis in deinem Bucket fest, in dem deine Registrierungsdaten gespeichert werden.
    • REGISTRY_STORAGE_CACHE_BLOBDESCRIPTOR – legt den Speicherort für den Cache fest. In unserem Fall speichern wir ihn im Speicher. Du kannst auch festlegen, dass Redis verwendet wird.
    • REGISTRY_HEALTH_STORAGEDRIVER_ENABLED – Setze diesen Wert auf false, um den Storage Health Check Service der Registry zu deaktivieren. Es gibt einen Fehler in der Registry, der zu Problemen führen kann, wenn du diesen Wert nicht auf false setzt.
  4. Die Docker Registry kommuniziert über Port 5000, den wir in unserem Server für Docker freigegeben haben.
  5. ./auth:/etc/nginx/conf.d mapping stellt sicher, dass alle Einstellungen von Nginx im Container verfügbar sind.
  6. ./auth/nginx.conf:/etc/nginx/nginx.conf:ro mappt die Nginx-Einstellungsdatei vom System auf eine Datei im Container im schreibgeschützten Modus.
  7. ./logs:/var/log/nginx ermöglicht den Zugriff auf die Nginx-Logs auf dem System, indem sie auf das Nginx-Logs-Verzeichnis im Container abgebildet wird.
  8. Die Einstellungen der Docker-Registry werden in der Datei /etc/docker/registry/config.yml im Container gespeichert, und wir haben sie auf die Datei config.yml im aktuellen Verzeichnis abgebildet, die wir im nächsten Schritt erstellen werden.

Authentifizierung einrichten

Um die HTTP-Authentifizierung einzurichten, musst du das Paket httpd-tools installieren.

$ sudo apt install apache2-utils -y

Erstelle die Passwortdatei im Verzeichnis ~/docker-registry/auth.

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

Das Flag -c weist den Befehl an, eine neue Datei zu erstellen, und das Flag -B sorgt dafür, dass der von Docker unterstützte bcrypt-Algorithmus verwendet wird. Ersetze user1 durch einen Benutzernamen deiner Wahl.

Wenn du weitere Benutzer hinzufügen möchtest, führe den Befehl erneut aus, aber ohne das -c Flag.

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

Jetzt wird die Datei zur Authentifizierung auf den Registrierungscontainer abgebildet.

Schritt 4 – SSL installieren

Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Ubuntu-Repository installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Bei Ubuntu 22.04 ist Snapd standardmäßig installiert. Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core && sudo snap refresh core

Installiere Certbot.

$ sudo snap install --classic certbot

Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.

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

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/registry.example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

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

Überprüfe den Certbot-Erneuerungsplanerdienst.

$ sudo systemctl list-timers

Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.

NEXT                        LEFT          LAST                        PASSED        UNIT                      ACTIVATES
.....
Sun 2023-04-14 00:00:00 UTC 19min left    Sat 2023-02-25 18:04:05 UTC n/a          snap.certbot.renew.timer  snap.certbot.renew.service
Sun 2023-04-14 00:00:20 UTC 19min left    Sat 2023-02-25 10:49:23 UTC 14h ago      apt-daily-upgrade.timer   apt-daily-upgrade.service
Sun 2023-04-14 00:44:06 UTC 3h 22min left Sat 2023-02-25 20:58:06 UTC 7h ago       apt-daily.timer           apt-daily.service

Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.

Kopiere die Dhparam-Datei in den Container

Kopiere das Diffie-Hellman-Gruppenzertifikat in das Verzeichnis ~/docker-registry/auth, das auf den Container abgebildet werden soll.

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

Schritt 5 – Nginx konfigurieren

Der nächste Schritt besteht darin, den Nginx-Server als Front-End-Proxy für den Docker-Registry-Server zu konfigurieren. Die Docker-Registry verfügt über einen eingebauten Server, der auf Port 5000 läuft. Wir werden ihn hinter Nginx platzieren.

Erstelle und öffne die Datei ~/docker-registry/auth/nginx.conf zum Bearbeiten.

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

Füge den folgenden Code in die Datei 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/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;
    }
  }
}

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Schritt 6 – Docker Registry starten

Wechsle in das Verzeichnis der Docker Registry.

$ cd ~/docker-registry

Starte den Docker-Container.

$ docker compose up -d

Überprüfe den Status der Container.

$ docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED              STATUS              PORTS                                      NAMES
3328b7e36bb2   nginx:alpine   "/docker-entrypoint.…"   About a minute ago   Up 3 seconds        80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp   docker-registry-nginx-1
bf7cdfc0e013   registry:2     "/entrypoint.sh /etc…"   About a minute ago   Up About a minute   5000/tcp                                 docker-registry-registry-1

Melde dich bei der Docker Registry an.

$ docker login -u=user1 -p=password https://registry.example.com

Du erhältst die folgende Ausgabe.

WARNING! Using --password via the CLI is insecure. Use --password-stdin.
WARNING! Your password will be stored unencrypted in /home/username/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded

Du kannst auch die URL https://registry.example.com/v2/ in deinem Browser öffnen und wirst nach einem Benutzernamen und Passwort gefragt. Du solltest eine leere Seite mit {} darauf sehen.

Du kannst die URL im Terminal mit curl überprüfen.

$ curl -u user1 -X GET https://registry.example.com/v2/
Enter host password for user 'user1':
{}

Lade das neueste Ubuntu-Docker-Image herunter.

$ docker pull ubuntu:latest

Markiere dieses Image für die private Registry.

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

Pushe das Image in die Registry.

$ docker push registry.example.com/ubuntu2204

Teste, ob der Push erfolgreich war.

$ curl -u user1 -X GET https://registry.example.com/v2/_catalog
Enter host password for user 'user1':
{"repositories":["ubuntu2204"]}

Gib dein Nginx-Authentifizierungspasswort ein, wenn du dazu aufgefordert wirst, und du siehst die Liste der über die Registry verfügbaren Repositories.

Melde dich über das Terminal ab, um die Anmeldedaten zu löschen.

$ docker logout https://registry.example.com
Removing login credentials for registry.example.com

Überprüfe die Liste der Docker-Images, die derzeit zur Verfügung stehen.

$ docker images
REPOSITORY                            TAG       IMAGE ID       CREATED       SIZE
registry                             2         8db46f9d7550   2 weeks ago   24.2MB
nginx                                alpine    8e75cbc5b25c   2 weeks ago   41MB
ubuntu                               latest    08d22c0ceb15   5 weeks ago   77.8MB
registry.example.com/ubuntu2204      latest    08d22c0ceb15   5 weeks ago   77.8MB

Schritt 7 – Zugriff und Nutzung der Docker-Registry vom Client-Rechner aus

Melde dich bei deinem Client-Server an. In Schritt 1 haben wir Docker auf dem Client-Rechner installiert.

Melde dich vom Client-Rechner aus bei der privaten Docker-Registry an.

$ docker login -u=user1 -p=password https://registry.example.com

Ziehe das Ubuntu-Image aus der Registry.

$ docker pull registry.example.com/ubuntu2204

Liste alle Images auf deinem Client-Rechner auf.

$ docker images
REPOSITORY                        TAG        IMAGE ID       CREATED         SIZE
registry.example.com/ubuntu2204   latest     08d22c0ceb15   5 weeks ago   77.8MB

Erstelle und starte einen Container mit dem heruntergeladenen Image.

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

Du wirst in der Shell innerhalb des Ubuntu-Containers angemeldet sein.

root@647899f255db:

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

root@a2da49fdbea9$ cat /etc/os-release
PRETTY_NAME="Ubuntu 22.04.2 LTS"
NAME="Ubuntu"
VERSION_ID="22.04"
VERSION="22.04.2 LTS (Jammy Jellyfish)"
VERSION_CODENAME=jammy
ID=ubuntu
ID_LIKE=debian
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"
UBUNTU_CODENAME=jammy

Jetzt kannst du deine Docker-Registry von deinen Client-Rechnern aus nutzen.

Fazit

Damit ist unsere Anleitung zum Einrichten einer privaten Docker-Registry auf einem Ubuntu 22.04 Server, der Amazon S3 als Speicherplatz nutzt, abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.

Das könnte dich auch interessieren …