Come configurare e utilizzare il registro Docker privato

Introduzione

Se desideri garantire uno sviluppo CI/CD senza problemi utilizzando la piattaforma Docker, prendi in considerazione la creazione di un registro Docker privato. Non solo velocizza la consegna, ma è anche un modo pratico per distribuire le risorse e condividere le immagini Docker tra i container.

In questo tutorial, scopri come configurare un registro Docker privato e configurarlo per l'accessibilità esterna.

Prerequisiti

• Accesso a un account utente con sudo o root privilegi
• Un server client
• Un server per il registro Docker privato
• Docker e Docker–Componi su entrambi i server
• Nginx sul server Docker Registry privato

Cos'è un registro Docker privato

Registro Docker è un'applicazione lato server e parte del prodotto platform-as-a-service di Docker. Ti consente di archiviare localmente tutte le tue immagini Docker in un'unica posizione centralizzata.

Quando configuri un registro privato, assegni un server per comunicare con Docker Hub su Internet. Il ruolo del server è estrarre e inviare immagini, archiviarle localmente e condividerle tra altri host Docker.

Eseguendo un registro accessibile dall'esterno, puoi risparmiare risorse preziose e accelerare i processi. Il software ti consente di estrarre immagini senza doverti connettere al Docker Hub, risparmiando larghezza di banda e proteggendo il sistema da potenziali minacce online.

Gli host Docker possono accedere al repository locale tramite una connessione sicura e copiare immagini dal registro locale per creare i propri contenitori.

Prima di iniziare

Come elencato nella sezione dei prerequisiti, la guida presuppone che Docker e Docker-Compose siano già installati su tutti i server.

Per verificare di avere il software richiesto, puoi verificare le loro versioni di rilascio con i comandi:

docker version

docker-compose version

Un'altra cosa che vorrai assicurarti è che il servizio Docker sia stato avviato e sia impostato per essere abilitato all'avvio:

sudo systemctl start docker

sudo systemctl enable docker

Installa e configura il registro Docker privato

Fase 1:crea le directory del registro

Inizia a configurare il server che ospiterà il registro privato. Per prima cosa vuoi creare una nuova directory che memorizzerà tutti i file di configurazione richiesti.

1. Il comando seguente crea una nuova directory di progetto denominata registry e due sottodirectory:nginx e auth :

mkdir -p registry/{nginx, auth}

2. Passa al registry e crea due nuove directory all'interno di nginx :

cd registry/

mkdir -p nginx/{conf.d/,ssl}

3. Visualizza la gerarchia delle directory appena create digitando:

tree

Passaggio 2:crea lo script Docker-Componi e definisci i servizi

Successivamente, devi creare e configurare un nuovo docker-compose.yml sceneggiatura. Lo script definisce la versione Docker-Compose, nonché i servizi necessari per configurare un registro privato.

1. Crea un nuovo file, mentre sei nel registry directory, con un editor di testo di tua preferenza:

nano docker-compose.yml

2. Ci sono alcune cose che devi definire in questo file di configurazione, quindi segui attentamente e aggiungi attentamente ogni sezione del contenuto:

version: '3'
services:
#Registry
  registry:
    image: registry:2
    restart: always
    ports:
    - "5000:5000"
    environment:
      REGISTRY_AUTH: htpasswd
      REGISTRY_AUTH_HTPASSWD_REALM: Registry-Realm
      REGISTRY_AUTH_HTPASSWD_PATH: /auth/registry.passwd
      REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: /data
    volumes:
      - registrydata:/data
      - ./auth:/auth
    networks:
      - mynet
#Nginx Service
  nginx:
    image: nginx:alpine
    container_name: nginx
    restart: unless-stopped
    tty: true
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/conf.d/:/etc/nginx/conf.d/
      - ./nginx/ssl/:/etc/nginx/ssl/
    networks:
      - mynet
#Docker Networks
networks:
  mynet:
    driver: bridge
#Volumes
volumes:
  registrydata:
    driver: local

3. Salva e chiudi il file.

Spiegazione della configurazione:

Innanzitutto, definisci la versione di Docker-Compose che desideri utilizzare. In questo esempio, è version: '3' . Si passa quindi alla definizione di tutti i componenti del registro Docker, a cominciare dal #Registry servizio.

Docker Registry è essenzialmente un contenitore che esegue l'immagine del registro, motivo per cui l'immagine è definita come registry:2 .

Aggiunta del restart: always ti assicura di avviare Docker Registry come servizio non appena avvii il sistema.

Determinazione delle porte 5000:5000 indica a Docker che l'host e il contenitore in esecuzione comunicano sui numeri di porta definiti.

Il servizio monterà il volume della finestra mobile registrydata e la directory locale auth , insieme al relativo file di autenticazione registry.passwd .

L'elemento successivo è il #Nginx Service . La configurazione delinea il servizio eseguito sulle porte 80:80 (HTTPS) e 443:443 (HTTP). Monta la directory locale per la configurazione virtuale (conf.d ) e certificati SSL (ssl ).

Infine, imposta mynet con un bridge driver e i registrydata con un driver locale come parametri per la rete personalizzata.

Fase 3:configura Nginx Port Forwarding

Il passaggio successivo è la configurazione di un host virtuale Nginx e la configurazione per il servizio Nginx.

1. Passa a nginx/conf.d/ directory che hai creato nel passaggio precedente:

cd nginx/conf.d/

2. Crea un nuovo file host virtuale denominato registry.conf :

nano registry.conf

3. Aggiungi il seguente contenuto:

upstream docker-registry {
    server registry:5000;
}

server {
    listen 80;
    server_name registry.example-server.com;
    return 301 https://registry.example-server.com$request_uri;
}

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

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

    # Log files for Debug
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;

    location / {
        # 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;
        }

        proxy_pass                          http://docker-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;
    }

}

4. Salva il file e torna alla shell del terminale.

Fase 4:aumenta la dimensione di caricamento del file Nginx

Per impostazione predefinita, Nginx limita la dimensione del caricamento del file a 1 MB . Poiché molte immagini Docker superano questo numero, la procedura migliore è aumentare la dimensione massima del file su Nginx. Assicurati di poter caricare immagini di dimensioni file maggiori impostando il max_body_size a 2 GB .

1. Crea un file di configurazione aggiuntivo con:

nano additional.conf

2. Aggiungi la seguente riga nel file:

client_max_body_size 2G;

3. Salva e chiudi il file.

Fase 5:configura il certificato SSL e l'autenticazione di base

1. I file dei certificati SSL del tuo dominio devono essere copiati in ssl directory. Per farlo, esegui i comandi:

cp /path/to/ssl/fullchain.pem ssl/

cp /path/to/ssl/privkey.pem ssl/

2. Quindi, passa a auth directory:

cd auth

3. E richiedi un nuovo file di password denominato registry.passwd per il tuo utente:

htpasswd -Bc registry.passwd example

4. Digita una password complessa e riscrivila per confermare. Con questo, hai aggiunto una password per il tuo utente.

Passaggio 6:aggiungi il certificato CA radice

Ora devi aggiungere il certificato della CA radice a Docker e al sistema su cui stai lavorando.

1. Esporta il .crt file con OpenSSL digitando:

openssl x509 -in rootCA.pem -inform PEM -out rootCA.crt

2. Copia il certificato radice in una nuova directory per i certificati Docker:

mkdir -p /etc/docker/certs.d/registry.example-server.com/

cp rootCA.crt /etc/docker/certs.d/example-server.com/

3. Quindi, copia lo stesso certificato in un'altra nuova directory con il nome /usr/share/ca-certificate/extra :

mkdir -p .usr.share.ca-certificates/extra/

cp rootCA.crt /usr/share/ca-certificates/extra/

4. Riconfigurare il ca-certificate appena creato pacchetto digitando:

dpkg-reconfigure ca-certificates

5. Infine, riavvia il servizio Docker:

systemctl restart docker

Passaggio 7:esegui il registro Docker

Con tutto configurato e pronto, puoi creare il contenitore Docker Registry utilizzando Docker-Compose:

docker-compose up -d

Controlla se il registro e i servizi Nginx sono in esecuzione:

docker-compose ps

netstat -plntu

L'output dovrebbe mostrarti i servizi e le porte assegnate.

Trascina l'immagine dall'hub Docker a un registro privato

1. Per archiviare localmente un'immagine da Docker Hub nel tuo registro privato, utilizza il docker pull comando:

docker pull [docker_image]

2. Aggiungi un tag all'immagine per etichettarla per il registro privato:

docker image tag [docker_image] registry.example-server.com/[new_image_name]

3. Puoi verificare se l'immagine Docker è disponibile localmente chiedendo al sistema di elencare tutte le immagini memorizzate localmente:

docker images

Come inviare l'immagine Docker al registro privato

1. Per inviare un'immagine da un host Docker al server del registro Docker privato, devi prima accedere al registro con il comando:

docker login https://registry.example-server.com/v2/

2. Digita il nome utente e password hai definito per l'host virtuale.

3. Ora puoi inviare la tua immagine al registro privato con il comando:

docker push registry.example-server.com/[new_image_name]

4. Visualizza un elenco di immagini archiviate nel registro Docker privato:

http -a example https://registry.example-server.com/v2/_catalog