Ricerca nel sito web

Come installare GitLab con Docker su Ubuntu 22.04


Questo tutorial esiste per queste versioni del sistema operativo

  • Ubuntu 22.04 (Jammy Jellyfish)
  • Ubuntu 18.04 (Bionic Beaver)

Su questa pagina

  1. Prerequisiti
  2. Passaggio 1: configurazione del firewall
  3. Passaggio 2 - Installa le dipendenze
  4. Passaggio 3: modifica della porta SSH del sistema
  5. Passaggio 4 - Installa Docker e Docker Compose
  6. Passaggio 5: configurazione dei volumi Docker
  7. Passaggio 6 - Installa Gitlab utilizzando Docker Compose
  8. Passaggio 7 - Configura Gitlab
    1. Accesso a Gitlab
    2. Limita le iscrizioni pubbliche
    3. Configura il profilo Gitlab
    4. Cambia la password di root
    5. Cambia nome utente
    6. Disattiva le metriche Prometheus e migliora la privacy

    1. Aggiunta della chiave SSH
    2. Creazione di un progetto

    Gitlab Server è una versione open source del controllo della versione Gitlab ospitato nel cloud. Il vantaggio di ospitare autonomamente i tuoi repository rispetto al cloud hosting è il controllo totale sul tuo codice.

    Questa guida ti insegnerà come installare Gitlab Server utilizzando Docker su un server Ubuntu 22.04. Il server Gitlab offre due edizioni: l'edizione Community gratuita e l'edizione Enterprise a pagamento. Installeremo l'edizione Community. Se desideri più funzionalità, puoi aggiornarlo facilmente all'edizione Enterprise.

    Prerequisiti

    • A server running Ubuntu 22.04.

    • A non-root user with sudo privileges.

    • Uncomplicated Firewall(UFW) is enabled and running.

    • A Fully Qualified domain name (FQDN) pointing to the server like, gitlab.example.com.

    • Everything is updated.

      $ sudo apt update && sudo apt upgrade
      

    Passaggio 1: configurare il firewall

    Il primo passo prima di installare qualsiasi pacchetto è configurare il firewall per consentire le connessioni HTTP e HTTPS.

    Controlla lo stato del firewall.

    $ sudo ufw status
    

    Dovresti vedere qualcosa di simile al seguente.

    Status: active
    
    To                         Action      From
    --                         ------      ----
    OpenSSH                    ALLOW       Anywhere
    OpenSSH (v6)               ALLOW       Anywhere (v6)
    

    Consenti porte HTTP e HTTPs.

    $ sudo ufw allow http
    $ sudo ufw allow https
    

    Apri la porta 587 per la ricezione di posta tramite SMTP. È possibile che tu stia utilizzando una porta diversa con il tuo mailer SMTP.

    $ sudo ufw allow http
    $ sudo ufw allow 587
    

    Controlla di nuovo lo stato per confermare.

    $ sudo ufw status
    Status: active
    
    To                         Action      From
    --                         ------      ----
    OpenSSH                    ALLOW       Anywhere
    80/tcp                     ALLOW       Anywhere
    443                        ALLOW       Anywhere
    587                        ALLOW       Anywhere
    OpenSSH (v6)               ALLOW       Anywhere (v6)
    80/tcp (v6)                ALLOW       Anywhere (v6)
    443 (v6)                   ALLOW       Anywhere (v6)
    587 (v6)                   ALLOW       Anywhere (v6)
    

    Passaggio 2: installa le dipendenze

    Prima di installare Gitlab, dobbiamo installare alcuni pacchetti che saranno richiesti nel corso del nostro tutorial.

    $ sudo apt install ca-certificates curl openssh-server apt-transport-https gnupg lsb-release -y
    

    Alcuni di questi pacchetti potrebbero essere preinstallati sul tuo sistema.

    Passaggio 3: modifica della porta SSH del sistema

    Gitlab utilizza la porta SSH predefinita che entrerà in conflitto con la porta SSH del sistema. Per ottenere i migliori risultati, è meglio modificare la porta predefinita del sistema.

    Per fare ciò, apri il file /etc/ssh/sshd_config per la modifica.

    $ sudo nano /etc/ssh/sshd_config
    

    Trova la seguente riga, rimuovi l'hash (#) davanti e cambia il valore da 22 a qualsiasi altra tua scelta. Per il nostro tutorial, abbiamo scelto 2425 cambiando

    #Port 22
    

    a

     Port 2425
    

    Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

    Riavvia il servizio SSH.

    $ sudo systemctl restart sshd
    

    Apri la porta 2425 nel firewall.

    $ sudo ufw allow 2425
    

    Chiudi la sessione SSH corrente e accedi nuovamente utilizzando la nuova porta.

    $ ssh <serverIP> -p 2425
    

    Passaggio 4: installare Docker e Docker Compose

    Aggiungi la chiave GPG ufficiale di Dockers.

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

    Eseguire il comando seguente per aggiungere il repository Docker.

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

    Aggiorna il sistema per includere il repository Docker.

    $ sudo apt update
    

    Installa Docker.

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

    Questo tutorial utilizzerà il plug-in Docker Compose v2 invece del vecchio binario legacy. Pertanto, il comando per eseguirlo è cambiato da docker-compose a docker compose e questo si riflette qui.

    Docker viene eseguito con privilegi elevati, quindi dovrai utilizzare sudo frequentemente per eseguire i comandi. L'opzione migliore è aggiungere il tuo account utente Linux al gruppo utenti docker.

    $ sudo usermod -aG docker ${USER}
    

    La variabile $ {USER} preleva l'account di sistema attualmente connesso. Se non hai effettuato l'accesso con l'utente a cui desideri concedere i privilegi, sostituisci $ {USER} con il nome utente.

    Per richiedere la nuova appartenenza al gruppo, disconnettersi dal server e riconnettersi oppure utilizzare il seguente comando. Verrà richiesta la password dell'utente.

    $ su - $(USER)
    

    Passaggio 5: configurare i volumi Docker

    Prima di procedere con l'installazione, è necessario impostare la posizione per i dati e la configurazione di Gitlab a cui accedere tramite i volumi Docker.

    Crea la directory del volume Docker.

    $ sudo mkdir /srv/gitlab -p
    

    Crea una directory per il file di composizione Docker.

    $ mkdir ~/gitlab-docker
    

    Passa alla rubrica.

    $ cd ~/gitlab-docker
    

    Crea un file di variabile di ambiente e aprilo per la modifica.

    $ nano .env
    

    Incolla il codice seguente per definire la variabile $GITLAB_HOME.

    GITLAB_HOME=/srv/gitlab
    

    Il contenitore Gitlab utilizza volumi montati su host per archiviare dati persistenti. La tabella seguente mostra il mapping della posizione locale delle directory Gitlab alla posizione dei contenitori e il rispettivo utilizzo.

    Local Location Container Location Usage
    $GITLAB_HOME/data /var/opt/gitlab For storing application data.
    $GITLAB_HOME/logs /var/log/gitlab For storing logs.
    $GITLAB_HOME/config /etc/gitlab For storing Gitlab configuration.

    Passaggio 6: installa Gitlab utilizzando Docker Compose

    Assicurati di essere all'interno della directory di composizione Docker di Gitlab.

    Crea e apri il file di configurazione di composizione di Docker per la modifica.

    $ nano docker-compose.yml
    

    Incolla il seguente codice al suo interno.

    version: '3.6'
    services:
      web:
        image: 'gitlab/gitlab-ee:latest'
        container_name: 'gitlab-howtoforge'
        restart: always
        hostname: 'gitlab.example.com'
        environment:
          GITLAB_OMNIBUS_CONFIG: |
            external_url 'https://gitlab.example.com'
            gitlab_rails['smtp_enable'] = true
            gitlab_rails['smtp_address'] = "email-smtp.us-west-2.amazonaws.com"
            gitlab_rails['smtp_user_name'] = "SESUsername"
            gitlab_rails['smtp_password'] = "SESKey"
            gitlab_rails['smtp_domain'] = "example.com"
            gitlab_rails['smtp_enable_starttls_auto'] = true
            gitlab_rails['smtp_port'] = 587
            gitlab_rails['smtp_authentication'] = "login"
            gitlab_rails['gitlab_email_from'] = ''
            gitlab_rails['gitlab_email_reply_to'] = ''
            # Add any other gitlab.rb configuration here, each on its own line
        ports:
          - '80:80'
          - '443:443'
          - '22:22'
          - '587:587'
        volumes:
          - '$GITLAB_HOME/config:/etc/gitlab'
          - '$GITLAB_HOME/logs:/var/log/gitlab'
          - '$GITLAB_HOME/data:/var/opt/gitlab'
        shm_size: '256m'
    

    Diamo un'occhiata a tutte le opzioni definite nel file.

    • image si riferisce alla posizione dell'immagine Docker di Gitlab su Dockerhub.
    • nome_container consente di applicare un'etichetta al contenitore docker, da utilizzare quando si fa riferimento al contenitore all'interno di una rete Docker.
    • restart specifica una politica di riavvio per il contenitore. Impostandolo su sempre significa che un contenitore, se chiuso, verrà automaticamente riavviato.
    • hostname definisce il nome host interno del contenitore o, in questo caso, l'URL in cui verrà installato Gitlab.
    • environment fornisce la variabile GITLAB_OMNIBUS_CONFIG che consente di inserire qualsiasi impostazione di configurazione di Gitlab.
    • external_url si riferisce al dominio in cui verrà installato il tuo Gitlab. L'utilizzo del protocollo https garantisce l'installazione automatica del certificato SSL Lets Encrypt.
    • Dettagli SMTP: abbiamo incluso i dettagli SMTP in modo che l'istanza Gitlab possa inviare email e notifiche importanti. Per il nostro tutorial, stiamo utilizzando il servizio SES di Amazon. Puoi comunque utilizzare qualsiasi servizio di tua scelta. Consulta la documentazione di Gitlab per i mailer SMTP per sapere come configurarli.
    • le porte indicano al contenitore di pubblicare le porte o un intervallo di porte sull'host. Poiché Gitlab necessita delle porte 22(SSH), 80(HTTP), 443(HTTPS) e 587(SMTP), sono state esposte al sistema. Se vuoi che Gitlab utilizzi una porta non standard sul tuo server (probabilmente perché non è disponibile), dovresti fornire prima la porta dell'host e poi la porta del contenitore. Ad esempio, poiché il tuo server sta già utilizzando la porta SSH (22), puoi dire a Gitlab di utilizzare SSH tramite una porta diversa, ad esempio 3333. Quindi cambierai 22:22 nel file sopra in 3333:22. Dovrai anche aggiungere la riga gitlab_rails[gitlab_shell_ssh_port]=3333 sotto GITLAB_OMNIBUS_CONFIG sopra.
    • volume definisce le directory presenti sul server per memorizzare i dati persistenti. Come definito nel passaggio 5, $GITLAB_HOME può ora essere utilizzato nel file di composizione per montare le directory pertinenti sul contenitore.
    • shm_size fa riferimento alla memoria condivisa utilizzata dal contenitore. Per impostazione predefinita, Docker alloca 64 MB alla directory della memoria condivisa (montata in /dev/shm). Questo può rivelarsi insufficiente per le metriche Prometheus generate dal contenitore Gitlab. Pertanto, un minimo di 256 MB di memoria condivisa garantisce il buon funzionamento della finestra mobile. Puoi aumentare il suo valore a seconda della RAM del tuo sistema. In alternativa, puoi disabilitare le metriche di Prometheus dall'area di amministrazione dopo l'installazione. Esploreremo questo nel passaggio successivo.

    Avvia il contenitore Gitlab Docker.

    $ docker compose up -d
    

    Ci vorranno alcuni minuti per completare il processo. Puoi seguire l'avanzamento utilizzando i log di Docker.

    $ docker logs gitlab-howtoforge -f
    

    Premere Ctrl + C per uscire dal monitoraggio del registro.

    Puoi controllare lo stato del contenitore Gitlab usando il seguente comando.

    $ docker ps
    

    A partire da Gitlab 14.0, genera automaticamente una password di root e la memorizza nel file initiall_root_password. Questo file può essere trovato nella directory /srv/gitlab/config. Eseguire il seguente comando per visualizzare la password di root.

    $ sudo cat /srv/gitlab/config/initial_root_password
    

    Riceverai un output simile.

    # WARNING: This value is valid only in the following conditions
    #          1. If provided manually (either via `GITLAB_ROOT_PASSWORD` environment variable or via `gitlab_rails['initial_root_password']` setting in `gitlab.rb`, it was provided before database was seeded for the first time (usually, the first reconfigure run).
    #          2. Password hasn't been changed manually, either via UI or via command line.
    #
    #          If the password shown here doesn't work, you must reset the admin password following https://docs.gitlab.com/ee/security/reset_user_password.html#reset-your-root-password.
    
    Password: Hz3t7Etn18wB6VAfBWyDlYbN2VQdMCO0xIIENfDHcFo=
    
    # NOTE: This file will be automatically deleted in the first reconfigure run after 24 hours.
    

    Copia la password e salvala per un uso successivo. Ora che tutto è pronto, possiamo procedere con la configurazione.

    Passaggio 7: configurare Gitlab

    Accesso a Gitlab

    Apri l'URL https://gitlab.example.com nel tuo browser e otterrai la seguente schermata di accesso.

    Inserisci root come nome utente e password, che hai ottenuto nel passaggio precedente per accedere alla dashboard di Gitlab. Al momento dell'accesso, verrai indirizzato alla seguente schermata del dashboard.

    Come puoi vedere, Gitlab ha già creato un progetto per monitorare l'istanza.

    Limita le iscrizioni pubbliche

    Per impostazione predefinita, chiunque può creare un account e ottenere l'accesso. Se non lo desideri, puoi disattivarlo. Fortunatamente, l'impostazione viene mostrata sotto forma di una schermata pop-up sulla dashboard. Fai clic sul pulsante Disattiva per limitare le iscrizioni pubbliche sulla tua istanza Gitlab. In questo modo verrai reindirizzato alla seguente pagina delle impostazioni.

    Deseleziona l'opzione Registrazione abilitata per limitarli. Premere il pulsante Salva modifiche per applicare l'impostazione.

    Nel caso in cui non vedi il pop-up nella tua dashboard, puoi accedere alla pagina delle impostazioni facendo clic sul pulsante Menu e accedendo al pannello di amministrazione da lì.

    Una volta all'interno del pannello di amministrazione, passa il mouse sopra l'opzione Impostazioni nella barra laterale sinistra e fai clic sul sottomenu Generale. Da lì puoi raggiungere il pannello Restrizioni di registrazione.

    Configura il profilo Gitlab

    Il tuo profilo predefinito è praticamente blando e non ha nulla da mostrare per questo. Per modificarlo, fai clic sull'icona dell'utente nell'angolo in alto a sinistra per visualizzare il menu a discesa e seleziona l'opzione Modifica profilo.

    Verrai indirizzato alla pagina delle impostazioni del profilo in cui puoi aggiungere il tuo nome, e-mail e altre informazioni su di te. Fai clic su Aggiorna impostazioni profilo quando hai finito. Non tornare alla homepage perché abbiamo altre cose da configurare qui.

    Cambia password di root

    Questo è uno dei passaggi più importanti. Dovresti cambiare immediatamente la tua password di root predefinita. Con le versioni precedenti, Gitlab richiedeva di modificarlo come parte dell'installazione, ma ora lo ha reso facoltativo. Per modificare la password, fai clic sul menu Password nella barra laterale di sinistra.

    Inserisci i dettagli della tua password e fai clic su Salva password per apportare la modifica. Verrai disconnesso dalla tua istanza e dovrai accedere di nuovo.

    Cambia nome utente

    Puoi cambiare il tuo nome utente Gitlab predefinito da root a qualsiasi cosa tu scelga. Per farlo, fai clic sul menu Account dalla barra laterale di sinistra.

    Una volta sulla pagina, inserisci il tuo nuovo nome utente e fai clic sul pulsante Aggiorna nome utente per apportare la modifica. Verrà richiesta nuovamente la conferma. Premere nuovamente il pulsante Aggiorna nome utente per confermare la modifica.

    Dovresti anche abilitare l'autenticazione a due fattori qui per migliorare la sicurezza del tuo account.

    Disattiva le metriche Prometheus e migliora la privacy

    Nel passaggio precedente, abbiamo discusso di aumentare la dimensione della memoria condivisa per il droplet e di mantenerla a un minimo di 256 MB. È necessario principalmente per archiviare i dati relativi alle metriche di Prometheus sul disco. Se non stai utilizzando la funzione, dovresti disabilitarla. Puoi farlo solo dopo l'installazione. Per disabilitarlo, apri il Pannello di amministrazione dalla barra dei menu.

    Una volta all'interno del pannello di amministrazione, apri l'opzione di menu Impostazioni >> Metriche e profilazione.

    Nella pagina Metriche, espandi la sezione Metriche - Prometheus e deseleziona l'opzione Abilita endpoint metriche di integrità e prestazioni. Fare clic sul pulsante Salva modifiche per implementare la modifica.

    Gitlab raccoglie anche informazioni sull'utilizzo da ogni installazione. Se apprezzi la privacy e non vuoi che accada, espandi l'opzione Statistiche sull'utilizzo nella stessa pagina e deseleziona l'opzione Abilita ping del servizio. Fare clic sul pulsante Salva modifiche per implementare la modifica.

    Step 8 - Creazione del tuo primo progetto

    Proviamo a creare il nostro primo progetto e spingere un commit.

    Aggiunta della chiave SSH

    Prima di procedere oltre, dovremmo aggiungere la nostra chiave SSH. Questo ci permette di interagire con la nostra installazione senza utilizzare alcuna password. Se disponi di una chiave SSH, puoi saltare il seguente comando. Se non ne hai uno, puoi crearne uno usando il seguente comando.

    $ ssh-keygen -t ed25519 -C "gitlab.example.com"
    

    Questo comando è comune a macOS, Linux e Git Bash/WSL su Windows. Accetta le impostazioni predefinite e inserisci una passphrase sicura. Stiamo creando le chiavi SSH su Windows Powershell Terminal.

    Generating public/private rsa key pair.
    Generating public/private ed25519 key pair.
    Enter file in which to save the key (C:\Users\<username>/.ssh/id_ed25519):
    Enter same passphrase again:
    Your identification has been saved in C:\Users\<username>/.ssh/id_ed25519.
    Your public key has been saved in C:\Users\<username>/.ssh/id_ed25519.pub.
    SHA256:CI3Ja1LSTN+j4LQnDYkAoP+DvZB8SWrD26zDyUBRbUY gitlab.example.com
    +--[ED25519 256]--+
    |* ..+E           |
    |. + / o o        |
    | o = B o .       |
    |. o B = S        |
    |.o X +           |
    | +X.*            |
    | .=B o           |
    +----[SHA256]-----+
    

    Aggiungere l'identità della chiave privata all'agente di autenticazione SSH. Assicurati che il servizio dell'agente di autenticazione OpenSSH sia in esecuzione se sei su Windows. Se sei su Linux o macOS, esegui il seguente comando.

    $ eval $(ssh-agent -s)
    

    Aggiungi la chiave.

    $ ssh-add C:\Users\<username>/.ssh/id_ed25519
    

    Su Linux e macOS, il comando cambierà in

    $ ssh-add ~/.ssh/id_ed25519
    

    Ti verrà richiesta la passphrase. Inseriscilo e la chiave verrà aggiunta.

    Successivamente, dobbiamo salvare queste impostazioni nel file ~/.ssh/config. Su Windows, questa sarà la directory C:\Users\\.ssh. Incolla il seguente codice alla fine del file.

    Host gitlab.example.com
      PreferredAuthentications publickey
      IdentityFile ~/.ssh/id_ed25519
    

    In questo file, il nome del percorso rimarrà lo stesso in tutti i sistemi operativi. Salva il file.

    Successivamente, dobbiamo copiare la chiave pubblica sul nostro account Gitlab. Puoi visualizzare la tua chiave pubblica tramite il seguente comando. Il nome del percorso funzionerà di nuovo su tutti i sistemi operativi qui.

    $ cat ~/.ssh/id_ed25519.pub
    

    Otterrai un risultato simile.

    ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAml2KPhmGkdMWv7jksLKO13u3g1zI9CumKDQSpv7lYh gitlab.example.com
    

    Apri le impostazioni del tuo profilo in Gitlab e seleziona il menu Chiavi SSH dalla barra laterale sinistra.

    Incolla la chiave SSH nella casella fornita e fai clic su Aggiungi chiave per procedere.

    Successivamente, dobbiamo verificare se la nostra connessione SSH funziona correttamente. Esegui il seguente comando sul tuo terminale PC.

    $ ssh -T 
    

    Otterrai un risultato simile. Innanzitutto, ti verrà chiesto di aggiungere la chiave SSH all'elenco degli host conosciuti del tuo sistema. Digita sì per procedere. Riceverai anche un avviso che la chiave SSH per l'istanza Gitlab e l'IP del tuo server non sono gli stessi e ti verrà nuovamente chiesto se desideri continuare. Digita di nuovo sì. Infine, riceverai un messaggio di successo che conferma la tua connessione alla tua istanza Gitlab.

    The authenticity of host 'gitlab.example.com (192.0.2.0)' can't be established.
    ECDSA key fingerprint is SHA256:g5mOqAY2A3lhXW0flnLGdSU7RrDnbRFKVJCquAhLXqk.
    Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
    Warning: Permanently added 'gitlab.example.com' (ECDSA) to the list of known hosts.
    Warning: the ECDSA host key for 'gitlab.example.com' differs from the key for the IP address '192.0.2.0'
    Are you sure you want to continue connecting (yes/no)? yes
    Offending key for IP in C:\Users\navjo/.ssh/known_hosts:7
    Welcome to GitLab, @navjot!
    

    Ora possiamo passare alla creazione del nostro primo repository e fare alcuni commit.

    Creazione di un progetto

    Ogni repository in Gitlab appartiene a un progetto. Un progetto include un repository, un tracker dei problemi, richieste di unione, wiki, pipeline di integrazione continua e distribuzione continua (CI/CD) e molte altre funzionalità.

    Per creare il tuo primo repository, fai clic sul pulsante Nuovo progetto nella tua home page.

    Verrai indirizzato alla pagina Nuovo progetto dove ti verranno fornite più opzioni su come creare un nuovo progetto.

    Selezionare l'opzione Crea progetto vuoto per procedere. Nella pagina successiva, inserisci il nome del progetto. Seleziona il tuo nome utente dal menu a discesa nell'opzione URL progetto. Imposta lo slug del tuo progetto. Inserisci una descrizione del progetto se lo desideri e modifica la visibilità del progetto secondo le tue necessità. Puoi inizializzare il tuo repository con un file README.

    Al termine, fai clic su Crea progetto. Sarai indirizzato alla pagina del tuo repository con un solo file README.md vuoto.

    Ora che il nostro repository è attivo, proviamo ad aggiungere un registro delle modifiche dalla riga di comando. Inserisci i seguenti comandi sul tuo computer per creare un file CHANGELOG e inviarlo nuovamente al tuo repository. Assicurati di aver installato Git sul tuo computer.

    Il primo passo è clonare il repository. Puoi clonare utilizzando SSH o HTTPS. Clonare usando SSH. Ti verrà chiesta la passphrase.

    $ git clone :user/howtoforge-test.git
    

    Immettere il resto dei comandi per creare e inviare il file CHANGELOG.

    $ cd howtoforge-test
    $ touch CHANGELOG  # Or create the file in your editor and enter a project description
    $ git add CHANGELOG
    $ git commit -m "add Changelog"
    $ git push -u origin main
    

    Verrà nuovamente richiesta la passphrase durante il comando push.

    Torna alla pagina del tuo progetto Gitlab e vedrai il file CHANGELOG al suo interno. Congratulazioni! Hai creato con successo il tuo primo progetto e hai inserito un file in esso.

    Passaggio 9: gestisci il contenitore Gitlab

    Vediamo come puoi gestire il contenitore Gitlab usando semplici comandi.

    Se in qualsiasi momento desideri arrestare il contenitore, emetti il seguente comando dall'interno della directory di composizione di Docker.

    $ docker compose down
    

    Per avviarli di nuovo, emetti il seguente comando.

    $ docker compose up -d
    

    Se desideri modificare qualsiasi impostazione o aggiungere un'impostazione alla tua istanza Gitlab, puoi farlo modificando il file docker-compose.yml nella variabile GITLAB_OMNIBUS_CONFIG. Una volta apportata la modifica, sarà necessario riavviare il contenitore per implementare la modifica. Immettere i seguenti comandi per aggiornare il contenitore con la nuova configurazione.

    $ docker compose down --remove-orphans
    $ docker compose up -d
    

    Per riavviare il contenitore, immetti il seguente comando. Tuttavia, il seguente comando di riavvio non rileva alcuna modifica apportata al file di composizione Docker.

    $ docker compose restart
    

    Accedi alla shell del contenitore.

    $ docker exec -it <container name> bash
    

    Passaggio 10: eseguire il backup di Gitlab

    Il backup di Gitlab può essere eseguito tramite un singolo comando.

    $ docker exec -t gitlab-howtoforge gitlab-backup create
    

    Il file di backup viene salvato nella directory /srv/gitlab/data/backups. Questo backup non contiene il tuo file di configurazione gitlab-secrets.json. Questo file si trova nella directory /srv/gitlab/config. Pertanto, è necessario eseguire il backup di questo file separatamente. C'è un altro file di configurazione, gitlab.rb, che contiene tutte le impostazioni per l'istanza Gitlab. Ma nel nostro caso, abbiamo usato la variabile GITLAB_OMNIBUS_CONFIG nel nostro file di composizione, quindi questo file non è usato da Gitlab. Per apportare modifiche a Gitlab, dovrai definirle tramite la variabile. Pertanto, sarà necessario eseguire anche il backup del file di composizione.

    Puoi creare una voce cron per eseguire regolarmente il backup dell'installazione di Gitlab.

    Passaggio 11: ripristinare Gitlab

    Per ripristinare Gitlab, dovresti avere un'installazione di Gitlab funzionante su un altro sistema. Sarà inoltre necessario copiare la directory di configurazione e sovrascrivere la configurazione delle installazioni esistenti.

    Il ripristino di Gitlab richiede l'esecuzione di diversi comandi. Innanzitutto, è necessario interrompere i processi connessi al database.

    $ docker exec -it <name of container> gitlab-ctl stop puma
    $ docker exec -it <name of container> gitlab-ctl stop sidekiq
    

    Sostituisci con il nome del container sul tuo nuovo server.

    Verificare che i processi siano inattivi prima di continuare.

    $ docker exec -it <name of container> gitlab-ctl status
    

    Copia il file di backup nella directory /srv/gitlab/data/backups. Crea la directory se non esiste.

    Eseguire il comando di ripristino. Devi rimuovere la parte _gitlab_backup.tar del nome file dal comando.

    $ docker exec -it <name of container> gitlab-backup restore BACKUP=11493107454_2018_04_25_10.6.4-ce
    

    Copia il file gitlab-secrets.json e sovrascrivi la copia esistente nella directory /srv/gitlab/config del nuovo server. Inoltre, copia tutte le impostazioni di Gitlab dal file di composizione di cui è stato eseguito il backup al file nel contenitore più recente.

    Riavvia il contenitore Gitlab. Non possiamo utilizzare direttamente il comando docker compose restart poiché non raccoglierà le modifiche apportate al file di composizione di cui abbiamo bisogno.

    $ docker compose down --remove-orphans
    $ docker compose up -d
    

    Controlla GitLab.

    $ docker exec -it <name of container> gitlab-rake gitlab:check SANITIZE=true
    

    Passaggio 12: aggiorna Gitlab

    Per aggiornare Gitlab, il primo passo è eseguire un backup come mostrato nella fermata precedente.

    Successivamente, passa alla directory di composizione di Gitlabs Docker.

    $ cd ~/gitlab-docker
    

    Successivamente, arresta e rimuovi il contenitore esistente. I tuoi dati verranno comunque conservati.

    $ docker compose down --remove-orphans
    

    Estrai l'ultima versione dell'immagine docker di Gitlab.

    $ docker compose pull
    

    Riavvia i contenitori.

    $ docker compose up -d
    

    Questo processo va bene per l'aggiornamento tra versioni secondarie di Gitlab, ma quando esegui l'aggiornamento a una versione principale, dovrai seguire passaggi aggiuntivi e prendere precauzioni. È necessario fare riferimento alla documentazione di Gitlabs prima di eseguire l'aggiornamento.

    Conclusione

    Questo conclude il nostro tutorial in cui hai imparato come installare Gitlab usando Docker su un server Ubuntu 22.04. Hai anche creato il tuo primo progetto e hai eseguito il commit di un file dal tuo PC. Se hai domande, pubblicale nei commenti qui sotto.