Come installare GitLab con Docker su Ubuntu 20.04 LTS

Questo tutorial esiste per queste versioni del sistema operativo

Ubuntu 18.04 (Castoro bionico)

Su questa pagina

Passaggio 1 - Installa Docker e Docker Compose
Passaggio 2 - Configurazione della directory GitLab
1. Crea una directory di dati GitLab e un file .env
2. Crea lo script docker-compose.yml
3. Genera certificati SSL e DHAPARAM
1. Controlla lo stato del servizio GitLab all'interno del contenitore
2. Accedi al contenitore GitLab
3. Modifica la configurazione di GitLab gitlab.rb
GitLab è un gestore di repository open source basato su Rails sviluppato da GitLab Inc. È un gestore di repository git basato sul Web che consente al tuo team di collaborare alla codifica, al test e alla distribuzione di applicazioni. GitLab offre diverse funzionalità, tra cui wiki, monitoraggio dei problemi, revisioni del codice e feed di attività.
In questo tutorial, ti mostreremo come installare GitLab usando Docker e Docker Compose. Inoltre, utilizzeremo Ubuntu 20.04 come sistema operativo principale e installeremo la finestra mobile dal repository ufficiale di Ubuntu FocalFossa.

Prerequisiti
- Ubuntu Server 20.04
- Minimo 4 GB di RAM
- Privilegi di root
Che cosa faremo?
- Installa Docker e Docker Compose
- Configura il progetto GitLab Docker
- Crea un contenitore GitLab
- GitLab dopo l'installazione
Passaggio 1: installare Docker e Docker Compose
Innanzitutto, installeremo i pacchetti docker e docker-compose sul nostro sistema Ubuntu 20.04. E useremo i pacchetti docker forniti dal repository ufficiale di Ubuntu FocalFossa.
Aggiorna tutti i repository all'ultima versione e installa docker e docker-compose utilizzando il comando apt di seguito.
```
sudo apt update
sudo apt install docker.io containerd docker-compose
```
Una volta completata l'installazione, avviare il servizio docker e aggiungerlo all'avvio del sistema.
```
systemctl start docker
systemctl enable docker
```
Successivamente, controlla il servizio docker utilizzando il comando systemctl di seguito.
```
systemctl status docker
```
Di conseguenza, il servizio docker è attivo e funzionante su Ubuntu 20.04 Server.
Per verificare l'installazione della finestra mobile, eseguire il comando docker \hello-world\ di seguito.
```
docker run hello-world
```
Ora riceverai il messaggio \hello-world\ dalla finestra mobile come di seguito.
Ora siamo pronti per installare GitLab utilizzando docker container e docker-compose.
Passaggio 2: configurare la directory GitLab
In questo passaggio, configureremo la nostra directory di progetto per l'installazione di GitLab.
Crea una nuova directory chiamata gitlab ed entraci.
```
mkdir -p gitlab; cd gitlab/
```
La directory \gitlab\ verrà utilizzata per archiviare tutti gli script docker e la configurazione per GitLab.
Crea una directory di dati GitLab e un file .env
In questa sezione, creeremo una nuova directory per archiviare tutti i nostri dati GitLab e creeremo un nuovo file \.env\ che verrà utilizzato dalla finestra mobile.
Crea una nuova directory di dati GitLab \/srv/gitlab\ utilizzando il comando mkdir di seguito.
```
mkdir -p /srv/gitlab/{config/ssl,logs,data}
```
Successivamente, nella directory del progetto \gitlab\, crea un nuovo file \.env\ utilizzando l'editor vim.
```
vim .env
```
Definisci la variabile di ambiente \GITLAB_HOME\ con il valore come directory dei dati di GitLab \/srv/gitlab\ come di seguito.
```
GITLAB_HOME=/srv/gitlab
```
Salva e chiudi.

Lo script docker-compose.yml utilizzerà la variabile di ambiente per i volumi Gitlab.
Crea lo script docker-compose.yml
Successivamente, creeremo un nuovo \docker-compose.yml\ che verrà utilizzato per creare il nostro contenitore GitLab.
Crea il nuovo file docker-compose.yml utilizzando il comando vim di seguito.
```
vim docker-compose.yml
```
Definisci il servizio chiamato \web\ con l'immagine dell'ultima versione di \gitlab-ce\ e cambia il \hostname\ con il tuo nome di dominio GitLab.
```
web:
  image: 'gitlab/gitlab-ce:latest'
  restart: always
  hostname: 'gitlab.hakase-labs.io'
```
Configura l'ambiente per l'installazione di Gitlab come di seguito. E assicurati di modificare \external_url\ con il protocollo sicuro HTTPS e modificare \gitlab_rails[gitlab_shell_ssh_port]\ con la tua porta SSH alternativa per il contenitore.
```
  environment:
    GITLAB_OMNIBUS_CONFIG: |
      # Add any other gitlab.rb configuration here, each on its own line
      external_url 'https://gitlab.hakase-labs.io'
      gitlab_rails['gitlab_shell_ssh_port'] = 2224
      nginx['redirect_http_to_https'] = true
      nginx['ssl_certificate'] = "/etc/gitlab/ssl/fullchain.pem"
      nginx['ssl_certificate_key'] = "/etc/gitlab/ssl/privkey.pem"
      nginx['ssl_dhparam'] = "/etc/gitlab/ssl/dhparams.pem"
```
Successivamente, definisci le porte per il contenitore GitLab come di seguito. E assicurati di cambiare la porta SSH \2224\ con la tua porta personalizzata e abbinarla alla porta \gitlab_shell_ssh_port\ in alto.
```
  ports:
    - '80:80'
    - '443:443'
    - '2224:22'
```
Successivamente, definisci il volume o le tue directory di dati GitLab. Tutte le directory dei dati di GitLab sono disponibili nella directory \GITLAB_HOME\, che è impostata sulla variabile d'ambiente nel file \.env\ in alto.
```
  volumes:
    - '${GITLAB_HOME}/config:/etc/gitlab'
    - '${GITLAB_HOME}/logs:/var/log/gitlab'
    - '${GITLAB_HOME}/data:/var/opt/gitlab'
    - '${GITLAB_HOME}/config/ssl:/etc/gitlab/ssl'
```
Salva e chiudi.
Di seguito la configurazione completa.
```
web:
  image: 'gitlab/gitlab-ce:latest'
  restart: always
  hostname: 'gitlab.hakase-labs.io'

  environment:
    GITLAB_OMNIBUS_CONFIG: |
      # Add any other gitlab.rb configuration here, each on its own line
      external_url 'https://gitlab.hakase-labs.io'
      gitlab_rails['gitlab_shell_ssh_port'] = 2224
      nginx['redirect_http_to_https'] = true
      nginx['ssl_certificate'] = "/etc/gitlab/ssl/fullchain.pem"
      nginx['ssl_certificate_key'] = "/etc/gitlab/ssl/privkey.pem"
      nginx['ssl_dhparam'] = "/etc/gitlab/ssl/dhparams.pem"  

  ports:
    - '80:80'
    - '443:443'
    - '2224:22'

  volumes:
    - '${GITLAB_HOME}/config:/etc/gitlab'
    - '${GITLAB_HOME}/logs:/var/log/gitlab'
    - '${GITLAB_HOME}/data:/var/opt/gitlab'
    - '${GITLAB_HOME}/config/ssl:/etc/gitlab/ssl'
```
Di conseguenza, è stato creato lo script \docker-compose.yml\ per l'installazione del progetto GitLab.
Genera certificati SSL e DHAPARAM
In questa fase, genereremo l'SSL Letsencrypt per la nostra installazione di GitLab.
Sul tuo server, installa lo strumento certbot utilizzando il comando apt di seguito.
```
sudo apt install certbot
```
Successivamente, genera il certificato SSL per GitLab utilizzando il comando certbot di seguito.
```
certbot certonly --rsa-key-size 2048 --standalone --agree-tos --no-eff-email --email  -d gitlab.hakase-labs.io
```
Una volta completato tutto, i tuoi certificati saranno disponibili nella directory /etc/letsencrypt/live/gitlab.yourdomain.
Ora copia il file del certificato \fullchain.pem\ e \privkey.pem\ nella directory \/srv/gitlab/config/ssl/\.
```
cp /etc/letsencrypt/live/gitlab.hakase-labs.io/fullchain.pem /srv/gitlab/config/ssl/
cp /etc/letsencrypt/live/gitlab.hakase-labs.io/privkey.pem /srv/gitlab/config/ssl/
```
E SSL Letsencrypt per GitLab è pronto.
Successivamente, genera il certificato DHPARAM \dhparam.pem\ utilizzando il comando openssl di seguito.
```
sudo openssl dhparam -out /srv/gitlab/config/ssl/dhparams.pem 2048
```
E tutti i certificati per l'installazione di GitLab sono stati generati ed erano pronti per creare il contenitore GitLab.
Passaggio 3: crea il contenitore GitLab
In questo passaggio, creeremo il nostro contenitore GitLab utilizzando tutta la configurazione che abbiamo creato sopra e utilizzando il comando docker-compose.
Prima di andare oltre, puoi controllare tutti i file disponibili nella directory del progetto \gitlab\ e nella struttura delle directory della directory dei dati di GitLab.
```
ls -lah ~/gitlab/
tree /srv/gitlab
```
Di seguito il risultato che otterrai.
Successivamente, vai alla directory del progetto \~/gitlab\ e crea il contenitore GitLab utilizzando il comando \docker-compose\ di seguito.
```
cd ~/gitlab
docker-compose up -d
```
Una volta completato tutto, otterrai il risultato come di seguito.
Ora controlla il contenitore in esecuzione e le porte \LISTEN\ sul tuo sistema Ubuntu usando il seguente comando.
```
docker-compose ps
ss -plnt
```
E otterrai che il contenitore \gitlab_web_1\ è attivo e funzionante e avrai la porta HTTP, HTTPS e SSH \2224\ utilizzata dal contenitore GitLab.
Come si può vedere, il contenitore GitLab è attivo e funzionante ed eravamo pronti per configurare la nostra installazione GitLab.
Passaggio 4: post installazione di GitLab
Apri il browser Web e digita l'URL di installazione di GitLab nella barra degli indirizzi.
E otterrai la pagina di reimpostazione della password di GitLab.
Digita la tua nuova password per l'utente predefinito \root\ e fai clic sul pulsante \Cambia la tua password\.
Ora otterrai la pagina di accesso di GitLab come di seguito.
Accedi con l'utente predefinito \root\ e la tua nuova password, quindi fai clic su \Accedi\.
E otterrai il GitLab Dashboard come di seguito.
Come si può vedere, l'installazione di GitLab tramite docker e docker-compose è stata completata.
Passaggio 5: configurazione di base del contenitore GitLab
Dopo l'installazione di GitLab, puoi aggiungere alcune configurazioni aggiuntive al contenitore GitLab senza distruggere il contenitore GitLab. Per questo passaggio, ti mostreremo il modo di base per gestire il contenitore GitLab.
Prima di andare oltre, vai alla directory del progetto \~/gitlab\ e controlla lo stato del contenitore usando il seguente comando.
```
cd ~/gitlab
docker-compose ps
```
Otterrai che il contenitore GitLab è attivo e funzionante.
Controlla lo stato del servizio GitLab all'interno del contenitore
Per controllare tutti i servizi GitLab all'interno del contenitore Gitlab, utilizzare il comando \docker exec\ come di seguito.
```
sudo docker exec -it gitlab_web_1 gitlab-ctl status
```
Di seguito il risultato che otterrai.
Come si può vedere, tutti i componenti del servizio GitLab sono attivi e funzionanti.
Accedi al contenitore GitLab
Per accedere tramite SSH al contenitore GitLab, utilizzare \docker exec\ con la shell \bash\ all'interno del contenitore come di seguito.
```
sudo docker exec -it gitlab_web_1 /bin/bash
```
Ora controlla la versione predefinita di Ubuntu del contenitore GitLab.
```
cat /etc/lsb-release
```
Otterrai il contenitore GitLab basato su Ubuntu 16.04 Xenial.
Ora digita \exit\ per uscire dal contenitore GitLab.
Modifica la configurazione di GitLab gitlab.rb
Successivamente, per modificare la configurazione di GitLab all'interno del contenitore, è possibile utilizzare l'\editor\ predefinito sul contenitore docker stesso.
Modifica la configurazione \/etc/gitlab/gitlab.rb\ all'interno del contenitore utilizzando il comando docker di seguito.
```
sudo docker exec -it gitlab_web_1 editor /etc/gitlab/gitlab.rb
```
Ora vedrai sullo schermo l'editor predefinito \nano\, con il file di configurazione \gitlab.rb\.
Digita la tua configurazione, salva ed esci.
Successivamente, per applicare le nuove modifiche a GitLab, riavvia il servizio contenitore Gitlab utilizzando il comando seguente.
```
sudo docker restart gitlab_web_1
```
Ora assicurati che non ci siano errori, controlla lo stato del contenitore GitLab usando il seguente comando.
```
sudo docker-compose ps
```
Ora assicurati che il cotainer GitLab sia nello stato \Up (healty)\.
Di conseguenza, è stata applicata la nuova configurazione per GitLab.
Infine, l'installazione di GitLab tramite docker e docker-compose è stata completata con successo.

Come installare GitLab con Docker su Ubuntu 20.04 LTS

Questo tutorial esiste per queste versioni del sistema operativo

Su questa pagina

Passaggio 1: installare Docker e Docker Compose

Passaggio 2: configurare la directory GitLab

Crea una directory di dati GitLab e un file .env

Crea lo script docker-compose.yml

Genera certificati SSL e DHAPARAM

Passaggio 3: crea il contenitore GitLab

Passaggio 4: post installazione di GitLab

Passaggio 5: configurazione di base del contenitore GitLab

Controlla lo stato del servizio GitLab all'interno del contenitore

Accedi al contenitore GitLab

Modifica la configurazione di GitLab gitlab.rb