Come creare un registro Docker privato su Ubuntu Linux

Stai cercando un posto dove archiviare in modo sicuro le tue immagini Docker personalizzate per i tuoi progetti personali o utilizzarle all'interno della tua organizzazione? O forse un sistema centralizzato per gestire i tuoi processi di Integrazione Continua e Deployment? Un luogo in cui puoi estrarre e caricare le tue immagini personalizzate per la tua applicazione a piacimento e migliorare il tasso di distribuzione?

Non guardare oltre! Un registro Docker privato rende tutto ciò possibile! Questo tutorial passo dopo passo ti guiderà nella creazione del tuo registro Docker privato. Tuffati per iniziare!

Prerequisiti

Per seguire questo tutorial, assicurati di avere quanto segue:

• Due Ubuntu 20.04 LTS dispositivi. Uno ospiterà il registro Docker e l'altro fungerà da macchina client per inviare richieste al registro Docker.

• NGINX è richiesto solo nella macchina host per impostare la crittografia SSL e l'autenticazione HTTP.
• Un nome di dominio registrato. NGINX indirizzerà il traffico al tuo nome di dominio registrato al registro Docker in esecuzione in un container.
• Per questo tutorial è necessario Docker sia nella macchina host che in quella client. L'installazione predefinita è sufficiente.

• Composizione Docker nel computer host del registro Docker per configurare e avviare i componenti per il registro Docker. Correlati:tutto ciò che devi sapere sull'utilizzo di Docker Compose

Configurazione del registro Docker

Il primo passaggio che devi eseguire è configurare il registro Docker sul dispositivo host, fornito come immagine gratuita su Docker Hub.

Invece di limitarti a emettere comandi Docker per eseguire questa attività, creerai un docker-compose.yml file. Il file utilizza il formato file di composizione Docker e può configurare i componenti necessari per il registro Docker con relativa facilità.

Per seguire, apri il tuo client SSH preferito e connettiti al dispositivo che sarà il server di registro.

1. Nella /home directory, crea una directory chiamata docker-registry con la mkdir comando:

# Creating working directory
mkdir docker-registry

2. Vai al registro della finestra mobile directory:

# Navigate to the working directory
cd ~/docker-registry

3. All'interno del registro-docker directory, crea una sottodirectory chiamata data . Dentro i dati directory è dove il registro Docker memorizzerà le immagini Docker. I dati directory funge da file system per il registro Docker per preservare le immagini Docker.

# Create filesystem to persist data
mkdir data

4. All'interno del registro-docker directory, crea una docker-compose.yml file:

# Create the docker-compose file
nano docker-compose.yml 

Troverai le configurazioni per impostare il registro nel file appena creato. Tra le impostazioni, noterai:

• Imposta il registry servizio con il registry:latest immagine con l'latest tag.
• Imposta la politica di riavvio per il registry servizio a always . A condizione che il motore Docker sia in esecuzione, il registry il servizio si riavvierà sempre quando viene interrotto.
• Le ports la sezione mappa la porta 5000 nel contenitore del registro per portare 5000 sul computer host.
• Il registry servizio nell'environment la sezione imposta la variabile di ambiente REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY ai dati directory creata in precedenza.
• Docker richiede un volume per rendere persistenti le immagini Docker nel registry contenitore. Aggiungerai i volumes oggetto per mappare i /dati directory sul computer host in /data directory nel contenitore.

La mappatura memorizzerà i dati sul file system della macchina host anziché all'interno del contenitore. Poiché Docker ora archivia i dati sulla macchina host, è possibile eseguirne il backup, la migrazione, la crittografia o la sostituzione.

Di seguito puoi vedere la configurazione YAML completa per i componenti necessari per avviare ed eseguire il registro Docker. Copia il codice YAML di seguito e incollalo in docker-compose.yml file che hai creato e salvalo con CTRL + S e premi CTRL + X per uscire:

version: '3.3' 
services:
  registry:
    image: registry:latest 
		restart: always
    ports:
    - "5000:5000"
    environment:
      REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: /data 
    volumes:
      - ./data:/data 

Docker-compose esegue più contenitori come un'unica applicazione. Il docker-compose.yml file configura questi contenitori multipli come parte dei servizi.

5. Ora esegui il file docker-compose e crea e avvia il registro Docker:

# Start docker registry application
sudo docker-compose up

Nell'output del comando seguente, puoi vedere il registro Docker in esecuzione. Per chiudere l'applicazione, premere CTRL + C .

Configurazione di NGINX

Ora che hai impostato il registro Docker, è il momento di configurare NGINX sul computer host. NGINX inoltrerà il traffico dai dispositivi client al registro Docker. Per questo tutorial, inoltrerai il traffico tramite un nome di dominio. Continua a leggere per affrontare questo passaggio.

Inizialmente, dovrai impostare il port forwarding NGINX per il tuo dominio tramite /etc/nginx/sites-available/your_domain_name file.

1. Crea il file con il seguente comando:

# Creating configuration for your domain
sudo nano /etc/nginx/sites-available/your_domain_name 

Troverai molti riferimenti a tuo_nome_dominio nelle seguenti sezioni . Questa stringa è un segnaposto. Non dimenticare di sostituirlo con un nome di dominio che possiedi quando provi tu stesso i comandi. Negli esempi register.joeshiett.xyz è il nome di dominio selezionato.

2. Copia la seguente configurazione NGINX e aggiungila a tuo_nome_dominio file che hai creato:

server {
	listen 80;
  # Replace your_domain_name with your domain name
  server_name your_domain_name;

    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://localhost:5000;
      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;
    }
}

3. Il port forwarding non è ancora completo. È necessario allegare prima un collegamento simbolico. Collegherai /etc/nginx/sites-available/tuo_nome_dominio file di configurazione in /etc/nginx/sites-enabled/. Il comando completo segue:

cd /etc/nginx/sites-enabled/ && sudo ln -s /etc/nginx/sites-available/your_domain_name .

4. Riavvia il servizio NGINX dopo aver creato il collegamento simbolico:

# Restarting Nginx service
sudo systemctl restart nginx 

Apri il browser sul tuo dispositivo client e vai a https://your_domain_name/v2/ per accedere a v2 endpoint, l'API HTTP Docker.

L'immagine seguente mostra l'output previsto dal terminale host dopo la navigazione verso il collegamento. L'immagine mostra anche che il browser ha inviato un GET richiesta all'API HTTP Docker tramite v2 punto finale.

Dopo essere passato a v2 endpoint tramite il collegamento, un oggetto JSON vuoto – {} – verrà visualizzato nella finestra del browser.

Configurazione della dimensione di caricamento del file NGINX

Il limite di dimensione di caricamento predefinito di NGINX è 1m , dove m sta per megabyte. Il limite predefinito non è quasi sufficiente per caricare le immagini Docker nel registro. Per modificare questo valore, modifica nginx.conf, quindi NGINX accetta caricamenti di file di grandi dimensioni.

1. Ancora una volta, accedi alla macchina host.

2. Modificare /etc/nginx/nginx.conf file:

3. Sotto http sezione in nginx.conf file, aggiungi la seguente riga per aumentare la dimensione del caricamento per ospitare 8.192 megabyte e salva il file:

client_max_body_size 8192m;

La configurazione sarà in qualche modo simile a questa:

Configurazione SSL

È necessario un certificato SSL per proteggere la connessione al registro Docker. Per aggiungere un certificato SSL, devi installare Certbot sull'host del registro.

Puoi installare Certbot con il gestore di pacchetti snap. Il gestore di pacchetti Snap è già preinstallato in Ubuntu 20.04.

1. Per installare Certbot, esegui il seguente comando sul tuo computer host:

# Install certbot using the snap package manager
sudo snap install --classic certbot

2. Aggiungi Certbot a PATH in modo che i comandi Certbot possano funzionare creando un collegamento simbolico:

# Attaching certbot to PATH
sudo ln -s /snap/bin/certbot /usr/bin/certbot

3. Esegui questo comando per ottenere un certificato e fare in modo che Certbot modifichi automaticamente la tua configurazione NGINX e abiliti anche l'accesso HTTPS per il tuo dominio:

# Creating a certificate and enabling HTTPS access
sudo certbot --nginx

Certbot modificherà il tuo_nome_dominio file di configurazione in /etc/nginx/sites-enabled/ directory e applica un certificato SSL al tuo nome di dominio.

L'immagine seguente mostra la configurazione finale per il tuo /etc/nginx/sites-enabled/your_domain_name il file apparirà dopo che Certbot ha applicato i certificati.

Se accedi a https://your_domain_name/ , scoprirai che è sicuro con il certificato di Certbot.

Configurazione dell'autenticazione HTTP per il registro Docker

È sempre una buona idea avere buone pratiche di sicurezza. Quindi proteggerai il tuo registro Docker e limiterai l'accesso solo a te e ad alcuni altri utenti che potresti voler aggiungere. Utilizzerai l'autenticazione HTTP, fornita da HTTP Basic Auth .

1. L'autenticazione HTTP richiede un htpasswd file con il tuo nome utente e password. Per creare il htpasswd autenticazione, dovrai installare apache2-utils pacchetto:

# Installing apache2-utils package
sudo apt-get install apache2-utils

2. Dopo aver installato apache2-utils crea un registry.credentials nel file /etc/nginx directory con il httpasswd comando. Aggiungi un nome utente preferito sostituendo your_username nel comando sottostante. Quindi, aggiungi una password di tua preferenza quando richiesto. Il comando completo e il suo output sono sotto.

# Creating to creating auth credentials
sudo htpasswd -c /etc/nginx/registry.credentials your_username

3. Dopo aver creato il registry.credentials , vai al tuo file di configurazione NGINX per il tuo registro Docker in /etc/nginx/sites-available/your_domain_name . Aggiungi il seguente testo al file di configurazione NGINX nel server sezione:

server {
	...
	...
	location / {
			...
			auth_basic            "Basic Auth";
      auth_basic_user_file  "/etc/nginx/registry.credentials";
			...
	}
}

4. Riavvia NGINX ancora una volta e riapplica le configurazioni con il seguente comando:

# Restarting nginx
sudo systemctl restart nginx

L'immagine qui sotto mostra che quando provi ad accedere a https://nome_dominio/ sul tuo browser, ti verrà chiesto di inserire il tuo nome utente e password. Per questo tutorial, il registro Docker viene eseguito in un sottodominio registry.joeshiett.xyz , con SSL abilitato.

Invio dell'immagine al repository Docker privato

Ora che il tuo registro Docker è in esecuzione e in grado di accettare caricamenti di file più grandi, invierai un'immagine su di esso. Per inviare un'immagine al registro Docker, devi accedere al tuo computer client.

Se non disponi di un'immagine Docker archiviata localmente sul tuo computer client, puoi estrarne una gratuita da Docker Hub.

1. Esegui il comando seguente per estrarre un'immagine Alpine Linux dall'hub Docker, imposta il nome dell'immagine come test-image ed esegui il contenitore nella shell interattiva:

# Pull and run Alpine container
sudo docker run --name test-image -it alpine:latest /bin/sh

2. Una volta all'interno del container Alpine, crea un file chiamato TEST . Questo file sarà quindi la conferma che l'immagine che estrai dal registro Docker è quella che stai modificando ora:

# create a file called TEST
touch /TEST

3. Esci dalla shell interattiva digitando exit sul tuo terminale.

4. Ora crea un'immagine Docker dal contenitore Alpine Docker denominata test-image , hai appena personalizzato:

# Creating Docker image
sudo docker commit test-image your_domain_name/test-image:latest

L'immagine Alpine che hai estratto e personalizzato in precedenza è ora disponibile localmente con un repository chiamato your_domain_name/test-image e tagga latest .

5. Per eseguire il push dell'immagine appena creata nel registro Docker, accedi al registro Docker con il comando seguente:

# Login to Docker registry
sudo docker login https://your_domain_name 

Ti verrà chiesto di inserire il nome utente e la password che hai impostato nella sezione precedente. L'output sarà:

...
Login Succeeded
...

6. Dopo aver effettuato l'accesso, invia l'immagine con tag al repository Docker:# Pushing docker image sudo docker push your_domain_name/test-image:latest

# Pushing docker image
sudo docker push your_domain_name/test-image:latest

L'output del comando sarà simile al seguente:

Estrazione dell'immagine dal repository Docker privato

Ora che hai eseguito il push dell'immagine Docker nel tuo repository Docker privato, è il momento di estrarre l'immagine che hai appena inviato.

1. Prima di tutto, devi accedere al tuo repository Docker privato:# Login to Docker registry sudo docker login https://your_domain_name

# Login to Docker registry
sudo docker login https://your_domain_name 

2. Dopo aver effettuato l'accesso, estrarrai l'immagine Docker creata in precedenza:

# Pull Docker image from Docker registry
sudo docker pull your_domain_name/test-image

Dall'immagine qui sotto, puoi vedere che Docker estrae l'test-image con successo.

3. È ora di eseguire una shell interattiva:

sudo docker run -it your_domain_name/test-image /bin/sh

4. Nella shell interattiva, eseguire il comando seguente:

ls

Dall'immagine qui sotto, puoi vedere che il TEST il file creato in precedenza si trova all'interno del contenitore.

Ora hai testato con successo il tuo registro Docker e sei a posto!

Conclusione

In questo tutorial, hai creato il tuo registro Docker privato. Hai installato i prerequisiti necessari; impostare l'autenticazione SSL e HTTP. E poi hai finalmente spinto ed estratto un'immagine dal tuo registro.

Quindi, quali pacchetti prevedi di inviare al tuo registro?