Een containerregister is een opslagcatalogus waar u containerafbeeldingen van kunt halen en aansturen.

Er zijn veel openbare en private registries beschikbaar voor ontwikkelaars, zoals Docker Hub, Amazon ECR en Google Cloud Artifact Registry. Maar soms wil je in plaats van te vertrouwen op een externe leverancier de afbeeldingen zelf hosten. Dit geeft je meer controle over hoe het register is geconfigureerd en waar de containerafbeeldingen zijn gehost.

Dit artikel is een hands-on handleiding die je leert hoe je een Container Registry zelf kunt hosten.

Inhoudsopgave

U zult het meest uit dit artikel halen als u al bekend is met gereedschappen als Docker en NGINX, en een algemeen beeld heeft van wat een container is.

Wat is een containerimage?

Voordat we over containerregistries gaan, lees eerst wat een containerimage is. In een notendop is een containerimage een pakket dat alle bestanden, bibliotheken en configuraties bevat om een container te laten draaien. Ze zijn samengesteld uit lagen waarin elke laag een set bestandsysteemwijzigingen voorstelt die bestanden toevoegen, verwijderen of wijzigen.

De meest voorkomende manier om een containerimage te maken is door een Dockerfile te gebruiken.

# bouw een image
docker build -t pliutau/hello-world:v0 .

# controleer de images lokaal
docker images
# REPOSITORY    TAG       IMAGE ID       CREATED          SIZE
# hello-world   latest    9facd12bbcdd   22 seconden geleden   11MB

Dit creëert een containerafbeelding die op uw lokale machine wordt opgeslagen. Maar wat als u deze afbeelding wilt delen met anderen of hem op een andere machine wilt gebruiken? Dat is waar containerregistraties komen in.

Wat is een Container Registry?

Een containerregister is een opslagcatalogus waar u afbeeldingen van containers uit kan pompen en ook weer in kan pompen. De afbeeldingen zijn ingedeeld in repositories, die collecties zijn van aan elkaar gerelateerde afbeeldingen met dezelfde naam. Bijvoorbeeld, op de Docker Hub-register is nginx de naam van de repository die verschillende versies van de NGINX-afbeeldingen bevat.

Enkele registraties zijn openbaar, wat betekent dat de afbeeldingen die op hen worden gehost toegankelijk zijn voor iedereen op het internet. Openbare registraties zoals Docker Hub zijn een goede optie om open-sourceprojecten te hosten.

Aan de andere kant bieden private registraties een manier om veiligheid en privacy in te brengen bij het opslaan van containerafbeeldingen voor bedrijfsomgevingen, of in de cloud of op locatie. Deze private registraties komen vaak met geavanceerde beveiligingsfuncties en technische ondersteuning.

Er is een groeiende lijst van private registraties beschikbaar, zoals Amazon ECR, GCP Artifact Registry, GitHub Container Registry, en Docker Hub biedt ook een private repository-functie.

Als ontwikkelaar heb je te maken met een containerregister wanneer je de docker push en docker pull commando’s gebruikt.

docker push docker.io/pliutau/hello-world:v0

# In het geval van Docker Hub kunnen we het registergedeelte ook overslaan
docker push pliutau/hello-world:v0

Laten we eens kijken naar de anatomie van een URL voor containerafbeeldingen:

docker pull docker.io/pliutau/hello-world:v0@sha256:dc11b2...
                |            |            |          |
                ↓            ↓            ↓          ↓
             registry    repository      tag       digest

Waarom u misschien een containerregister zelf wilt hosten

Soms wilt u uw afbeeldingen zelf hosten in plaats van te vertrouwen op een provider zoals AWS of GCP. Dit houdt je infrastructuur intern en maakt je minder afhankelijk van externe leveranciers. In sommige sterk gereguleerde branches is dit zelfs een vereiste.

Een zelf gehost register draait op je eigen servers, waardoor je meer controle hebt over hoe het register is geconfigureerd en waar de container images worden gehost. Tegelijkertijd brengt het kosten met zich mee voor het onderhouden en beveiligen van het register.

Hoe host u zelf een containerregister

Er zijn verschillende open-source containerregisteroplossingen beschikbaar. De populairste wordt officieel ondersteund door Docker en heet registry, met zijn implementatie voor het opslaan en distribueren van containerimages en artefacten. Dit betekent dat u uw eigen register in een container kunt uitvoeren.

Hier volgen de belangrijkste stappen om een register op een server uit te voeren:

  • Installeer Docker en Docker Compose op de server.

    .

  • Configureer en voer de registry container uit.

  • Start NGINX voor het afhandelen van TLS en het doorsturen van verzoeken naar de registratiecontainer.

  • Installeer SSL-certificaten en configureer een domein.

Stap 1: Installeer Docker en Docker Compose op de server

U kunt elke server gebruiken die Docker ondersteunt. Bijvoorbeeld, u kunt een DigitalOcean Droplet met Ubuntu gebruiken. Voor deze demo heb ik Google Cloud Compute gebruikt om een VM met Ubuntu aan te maken.

neofetch

# OS: Ubuntu 20.04.6 LTS x86_64
# CPU: Intel Xeon (2) @ 2.200GHz
# Geheugen: 3908MiB

Nadat we binnen in onze VM zijn, moeten we Docker en Docker Compose installeren. Docker Compose is optioneel, maar maakt het gemakkelijker om multi-containertoepassingen te beheren.

# installeer docker engine en docker-compose
sudo snap install docker

# controleer de installatie
docker --version
docker-compose --version

Stap 2: Configureer en start de registratiecontainer

Volgende moeten we onze registratiecontainer configureren. Het volgende compose.yaml bestand zal een registratiecontainer maken met een volume voor het opslaan van de afbeeldingen en een volume voor het opslaan van het wachtwoordbestand.

services:
  registry:
    image: registry:latest
    environment:
      REGISTRY_AUTH: htpasswd
      REGISTRY_AUTH_HTPASSWD_REALM: Registry Realm
      REGISTRY_AUTH_HTPASSWD_PATH: /auth/registry.password
      REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: /data
    volumes:
      # De passwordbestand mounten
      - ./registry/registry.password:/auth/registry.password
      # Het data directory mounten
      - ./registry/data:/data
    ports:
      - 5000

Het passwordbestand dat is gedefinieerd in REGISTRY_AUTH_HTPASSWD_PATH wordt gebruikt om gebruikers te authenticate bij het pushen of pullen van afbeeldingen uit het register. We moeten een passwordbestand aanmaken met de htpasswd opdracht. We moeten ook een map aanmaken voor het opslaan van de afbeeldingen.

mkdir -p ./registry/data

# install htpasswd
sudo apt install apache2-utils

# Maak een passwordbestand. Gebruikersnaam: busy, Wachtwoord: bee
htpasswd -Bbn busy bee > ./registry/registry.password

Nu kunnen we het register container starten. Als u deze boodschap ziet, dan werkt alles zoals het moet:

docker-compose up

# succesvolle uitvoering moet iets als dit afgeven:
# registry | level=info msg="listening on [::]:5000"

Stap 3: Start NGINX voor TLS-handling

ALS eerder gezegd, kunnen we NGINX gebruiken om TLS te behandelen en aanvragen door te sturen naar het register container.

Het Docker Register vereist een geldig vertrouwd SSL-certificaat om te kunnen werken. U kunt iets als Let’s Encrypt gebruiken of het handmatig verkrijgen. Zorg ervoor dat u een domeinnaam hebt die naar uw server wijst (registry.pliutau.com in mijn geval). Voor deze demo heb ik de certificaten reeds met behulp van certbot verkregen en geplaatst in de ./nginx/certs map.

Als we onze Docker Registry in een container draait, kunnen we ook NGINX in een container draaien door de volgende service toe te voegen aan het compose.yaml bestand:

services:
  registry:
    # ...
  nginx:
    image: nginx:latest
    depends_on:
      - registry
    volumes:
      # mount de nginx configuratie
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      # mount de certificaten die zijn verkregen van Let's Encrypt
      - ./nginx/certs:/etc/nginx/certs
    ports:
      - "443:443"

Ons nginx.conf bestand zou er ongeveer zo uitzien:

worker_processes auto;

events {
    worker_connections 1024;
}

http {
    upstream registry {
        server registry:5000;
    }

    server {
        server_name registry.pliutau.com;
        listen 443 ssl;

        ssl_certificate /etc/nginx/certs/fullchain.pem;
        ssl_certificate_key /etc/nginx/certs/privkey.pem;

        location / {
            # belangrijke instelling voor grote afbeeldingen
            client_max_body_size                1000m;

            proxy_pass                          http://registry;
            proxy_set_header  Host              $http_host;
            proxy_set_header  X-Real-IP         $remote_addr;
            proxy_set_header  X-Forwarded-For   $proxy_add_x_forwarded_for;
            proxy_set_header  X-Forwarded-Proto $scheme;
            proxy_read_timeout                  900;
        }
    }
}

Klaar om te beginnen!

Na deze stappen kunnen we onze registry en Nginx containers uitvoeren.

docker-compose up

Nu, vanaf de clientkant, kun je de afbeeldingen van uw registry pushen en pullen. Maar eerst moeten we aanmelden bij de registry.

docker login registry.pliutau.com

# Gebruikersnaam: busy
# Wachtwoord: bee
# Login gelukt

Tijd om onze afbeelding te bouwen en naar onze eigen gehoste registry te pushen:

docker build -t registry.pliutau.com/pliutau/hello-world:v0 .

docker push registry.pliutau.com/pliutau/hello-world:v0
# v0: digest: sha256:a56ea4... size: 738

Op uw server kun je de geuploadte afbeeldingen in de data map controleren:

ls -la ./registry/data/docker/registry/v2/repositories/

Andere opties

Volgens het voorbeeld hierboven kun je de registry ook op Kubernetes draaien. Of u kunt een gehoste registrydienst gebruiken zoals Harbor, dat een open-source registry is met geavanceerde beveiligingsfuncties en compatible is met Docker en Kubernetes.

Ook als u een UI wilt voor uw eigen gehoste containerregister, kunt u een project zoals joxit/docker-registry-ui gebruiken en het in een apart container laten draaien.

Conclusie

Gehoste containerregistraties geven u volledige controle over uw register en de manier waarop het wordt geïmplementeerd. Tegelijkertijd gaat het om het onderhoud en de beveiliging van het register.

Welke reden u ook heeft om een gehost register te draaien, kunt u nu zien hoe dit gebeurt. Vanaf hier kunt u de verschillende opties vergelijken en de beste keuze maken die bij uw behoeften past.

U kunt de volledige broncode voor deze demo vinden op GitHub. Ook kunt u het als video bekijken op onze YouTube-kanaal.