Come installare Gitea su Ubuntu usando Docker

Introduzione

Quando si lavora sullo sviluppo del software, è importante essere in grado di gestire il codice sorgente in modo efficiente e tracciabile. Gestione del codice sorgente (SCM ) sono un modo eccellente per fornire un processo efficiente e flessibile per lavorare su progetti di qualsiasi dimensione con un numero qualsiasi di sviluppatori. Nel corso degli anni sono esistiti molti software SCM diversi, da CVS a SubVersion, da Perforce a Mercurial, ma l'attuale leader del settore è Git, che ha visto una crescita importante con la popolarità di siti come GitHub e GitLab.

Tuttavia, con account gratuiti su questi servizi orientati verso repository open source pubblici, la capacità di lavorare su software privato o proprietario comporta un costo per lo sviluppatore. Inoltre, l'accesso al repository spetta a un'organizzazione esterna e molti preferirebbero controllare il proprio software dall'inizio alla fine.

A tal fine, negli ultimi anni sono state sviluppate diverse soluzioni self-hosted come Gogs, Gitea e GitLab. Questo tutorial si concentra sulla configurazione di una delle soluzioni più popolari, Gitea, per consentirti di ospitare repository privati ​​e gestire i tuoi progetti durante l'intero ciclo di vita. Gitea è piccolo, autonomo e leggero, il che lo rende un processo rapido da implementare senza spendere troppo per i requisiti hardware. Utilizzerai un'installazione Docker di Gitea, che garantisce che il software sia mantenuto aggiornato.

Prerequisiti

Prima di iniziare questo tutorial, dovresti avere quanto segue:

• Un server Ubuntu 20.04 con un utente non root configurato con sudo privilegi come descritto nella configurazione iniziale del server per Ubuntu 20.04.
• Docker installato sul tuo server. Segui i passaggi 1 e 2 di Come installare Docker su Ubuntu 20.04 per installare Docker.
• Docker Compose installato sul tuo server. Segui il Passaggio 1 della nostra guida su Come installare e utilizzare Docker Compose su Ubuntu 20.04 per configurarlo.
• Un nome di dominio puntato al tuo server. Se stai utilizzando un Droplet DigitalOcean, puoi farlo seguendo la nostra documentazione sui domini e DNS. Questo tutorial utilizzerà your_domain negli esempi in tutto.

Passaggio 1:creazione dell'utente Git

Gitea, come molti repository di codice sorgente, utilizza SSH per accedere a repository remoti. Ciò consente agli utenti di controllare l'accesso al proprio codice gestendo le proprie chiavi SSH all'interno di Gitea stessa. Affinché gli utenti possano accedere all'host tramite SSH, tuttavia, dovrai creare un git utente sulla macchina host. Questo passaggio viene completato prima in modo che tu possa accedere all'utente e all'ID gruppo dell'utente.

Innanzitutto, crea l'utente sull'host che accetterà queste connessioni:

sudo adduser --system --shell /bin/bash --gecos 'Git Version Control' --group --disabled-password --home /home/git git

In questo comando crei un utente di sistema che utilizza bash come shell, ma non ha una password di accesso. Questo ti permette di usare sudo per eseguire comandi come quell'utente ma impedisce l'accesso come tale. Hai anche impostato la directory home dell'utente su /home/git .

Questo comando produrrà alcune informazioni sull'utente che ha appena creato:

OutputAdding system user `git' (UID 112) ...
Adding new group `git' (GID 119) ...
Adding new user `git' (UID 112) with group `git' ...
Creating home directory `/home/git' …

Prendere nota dei valori UID e GID forniti qui (in questo caso, un UID di 112 e un GID di 119 ), poiché verranno utilizzati in un passaggio futuro.

Passaggio 2:installazione dell'immagine Gitea Docker

Gitea ha un'immagine disponibile nel repository Docker globale, il che significa che, utilizzando Docker Compose, puoi installare ed eseguire quell'immagine come servizio con poco lavoro extra. L'immagine stessa esegue i servizi Web e SSH di Gitea, consentendo l'accesso a Git sia dal browser che dalla riga di comando.

Per avviare il contenitore Gitea, utilizzerai Docker Compose, uno strumento dichiarativo per la creazione di un ambiente.

Per cominciare, crea una directory per ospitare il tuo servizio e inseriscila:

mkdir ~/gitea
cd ~/gitea

Una volta lì, crea un file chiamato docker-compose.yml utilizzando il tuo editor di testo preferito. L'esempio seguente usa nano . Questo file conterrà le descrizioni dei container che verranno eseguiti come parte dell'installazione di Gitea:

nano docker-compose.yml

Aggiungi quanto segue in questo nuovo file:

~/gitea/docker-compose.yml

version: "3"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:1.16.5
    container_name: gitea
    environment:
      - USER_UID=UID_from_step_1
      - USER_GID=GID_from_step_1
    restart: always
    networks:
      - gitea
    volumes:
      - ./gitea:/data
      - /home/git/.ssh/:/data/git/.ssh
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "127.0.0.1:3000:3000"
      - "127.0.0.1:2222:22"

Esaminiamo cosa fa questo file:

• version: "3" :questo consente a Docker di comporre quale versione del file di configurazione è.
• networks :questa sezione dichiara l'impostazione di rete della nostra raccolta di contenitori. In questo caso, un gitea la rete viene creata, ma non viene esposta all'esterno.
• services
  • image: gitea/gitea:1.16.5 :specifica che utilizzeremo Gitea versione 1.16.5; tuttavia puoi modificare il valore dopo i due punti per specificare altre versioni, sia una versione specifica, una versione principale come :1 o un tag come :latest o :dev .
  • environment :la sezione ambiente specifica le variabili di ambiente che saranno disponibili per l'immagine durante l'installazione e l'esecuzione. In questo caso, stiamo specificando un utente e un ID gruppo per l'ambiente, utilizzando l'UID e il GID forniti nell'output di adduser comando nel passaggio 1.
  • restart: always :questa riga indica a Docker di riavviare sempre il container se va giù, sia perché il container stesso va in crash o perché lo fa la macchina host; in sostanza, Gitea si avvierà all'avvio.
  • networks :specifica che il servizio Gitea avrà accesso e sarà accessibile sulla rete sopra indicata.
  • ./gitea:/data e /home/git/.ssh/:/data/git/.ssh :questi sono i luoghi in cui Gitea memorizzerà i suoi repository e i relativi dati. Attualmente, questo è mappato alla cartella denominata gitea nella directory corrente. Docker creerà questa cartella all'avvio del contenitore se non esiste. Il .ssh cartella verrà descritta più avanti nel passaggio 6.
  • /etc/timezone e /etc/localtime :questi due file contengono informazioni sul fuso orario e l'ora sulla macchina host. Mappandoli direttamente nel contenitore come file di sola lettura (specificati con il :ro finale parte delle definizioni), il contenitore avrà le stesse informazioni dell'host.
  • ports :Gitea ascolta le connessioni su due porte. Ascolta le connessioni HTTP sulla porta 3000 , dove serve l'interfaccia web per il repository del codice sorgente e ascolta le connessioni SSH sulla porta 22 . In questo caso, stai mantenendo la porta 3000 per le connessioni HTTP mappandolo allo stesso numero, e stai mappando la porta sul container di Gitea dal solito 22 a 2222 per evitare conflitti portuali. Nel passaggio 6, imposterai uno shim SSH per indirizzare il traffico a Gitea quando richiesto.

Nota: Questo è un esempio minimo di un file Docker Compose per Gitea. Esistono diverse altre opzioni che è possibile includere, come l'utilizzo di MySQL o PostGreSQL come database di backup o un volume denominato per l'archiviazione. Questa configurazione minima utilizza SQLite come database di backup e un volume che utilizza la directory denominata gitea per magazzino. Puoi leggere di più su queste opzioni nella documentazione di Gitea.

Salva e chiudi il file. Se hai usato nano per modificare il file, puoi farlo premendo CTRL + X , Y , quindi ENTER .

Con questo file in posizione puoi quindi visualizzare i contenitori utilizzando Docker Compose:

docker-compose up

Questo comando tirerà giù le immagini, avvierà il contenitore Gitea e restituirà l'output in questo modo:

Output[+] Running 9/9
 ⠿ server Pulled                                                                                                  8.2s
   ⠿ e1096b72685a Pull complete                                                                                   1.4s
   ⠿ ac9df86bb932 Pull complete                                                                                   3.3s
   ⠿ 6d34ed99b58a Pull complete                                                                                   3.4s
   ⠿ a8913d040fab Pull complete                                                                                   3.6s
   ⠿ a5d3a72a2366 Pull complete                                                                                   5.3s
   ⠿ 1f0dcaae29cc Pull complete                                                                                   5.6s
   ⠿ f284bcea5adb Pull complete                                                                                   7.3s
   ⠿ 0f09c34c97e3 Pull complete                                                                                   7.5s
[+] Running 2/2
 ⠿ Network gitea_gitea  Created                                                                                   0.2s
 ⠿ Container gitea      Created                                                                                   0.2s
Attaching to gitea
gitea  | Generating /data/ssh/ssh_host_ed25519_key...
gitea  | Generating /data/ssh/ssh_host_rsa_key...
gitea  | Generating /data/ssh/ssh_host_dsa_key...
gitea  | Generating /data/ssh/ssh_host_ecdsa_key...
gitea  | Server listening on :: port 22.
gitea  | Server listening on 0.0.0.0 port 22.
gitea  | 2022/03/31 17:26:21 cmd/web.go:102:runWeb() [I] Starting Gitea on PID: 14
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:21:PreloadSettings() [I] AppPath: /usr/local/bin/gitea
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:22:PreloadSettings() [I] AppWorkPath: /app/gitea
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:23:PreloadSettings() [I] Custom path: /data/gitea
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:24:PreloadSettings() [I] Log path: /data/gitea/log
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:25:PreloadSettings() [I] Configuration file: /data/gitea/conf/app.ini
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:26:PreloadSettings() [I] Prepare to run install page
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:29:PreloadSettings() [I] SQLite3 is supported
gitea  | 2022/03/31 17:26:21 cmd/web.go:208:listen() [I] Listen: http://0.0.0.0:3000
gitea  | 2022/03/31 17:26:21 cmd/web.go:212:listen() [I] AppURL(ROOT_URL): http://localhost:3000/

Questo lascerà il contenitore in esecuzione in primo piano, tuttavia, e si fermerà non appena esci dal processo con Ctrl + C o perdendo la connessione. Per fare in modo che il contenitore venga eseguito in background come processo separato, puoi aggiungere il -d flag al comando Componi:

docker-compose up -d

Riceverai una notifica quando il contenitore verrà avviato e quindi restituito alla tua shell.

Fase 3:installazione di Nginx come proxy inverso

L'esecuzione di un servizio Web come Gitea dietro un proxy inverso è una pratica comune, poiché i moderni software server come Apache o Nginx possono gestire più facilmente più servizi su una macchina, bilanciare il carico su più server e gestire SSL. Inoltre, ciò ti consentirà di impostare un nome di dominio che punta alla tua istanza Gitea in esecuzione su porte HTTP(S) standard.

Ai fini di questo tutorial, useremo Nginx. Innanzitutto, aggiorna gli elenchi dei pacchetti sul tuo computer host:

sudo apt update

Quindi, installa Nginx usando apt :

sudo apt install nginx

Ora, mentre stai usando il firewall ufw , dovrai consentire l'accesso a queste porte:

sudo ufw allow "Nginx Full"

Una volta installato, dovresti essere in grado di accedere al tuo server nel tuo browser visitando http://your_domain . Questo ti porterà a una pagina molto semplice che ti dà il benvenuto su Nginx.

A questo punto, dovrai creare una voce proxy inverso per indirizzare il traffico in entrata tramite Nginx all'istanza Gitea in esecuzione in Docker. Crea un nuovo file in Nginx sites-available directory utilizzando il tuo editor di testo preferito. L'esempio seguente usa nano :

sudo nano /etc/nginx/sites-available/gitea

In questo file, imposta un nuovo blocco server con richieste a / proxy alla tua istanza Gitea:

/etc/nginx/sites-available/gitea

server {
    # Listen for requests on your domain/IP address.
    server_name your_domain;

    root /var/www/html;

    location / {
        # Proxy all requests to Gitea running on port 3000
        proxy_pass http://localhost:3000;
        
        # Pass on information about the requests to the proxied service using headers
        proxy_set_header HOST $host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Una volta terminata la modifica del file, salvalo e chiudilo.

Nota: Per ulteriori informazioni sulla comprensione di ciò che sta accadendo all'interno di queste direttive, vedere l'esercitazione Comprendere il proxy HTTP Nginx, il bilanciamento del carico, il buffering e la memorizzazione nella cache.

Nginx determina quali siti servirà effettivamente in base alla presenza o meno di tali file nei suoi sites-enabled directory. Questo è gestito tramite collegamenti simbolici che puntano ai file nei sites-available directory. Dovrai creare uno di quei link simbolici per Nginx per iniziare a servire Gitea:

sudo ln -s /etc/nginx/sites-available/gitea /etc/nginx/sites-enabled/gitea

Prima di riavviare Nginx per rendere attive le modifiche, dovresti fare in modo che Nginx stesso controlli che tali modifiche siano valide testando la sua configurazione.

sudo nginx -t

Se tutto è a posto, questo comando restituirà un output come il seguente:

Outputnginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

In caso di problemi, ti dirà cosa e dove si trovano.

Quando sei pronto per procedere con questa modifica, riavvia il servizio di sistema Nginx:

sudo systemctl restart nginx

Ora, quando visiti http://your_domain nel tuo browser dovresti trovarti sulla pagina di configurazione iniziale di Gitea pronta per essere compilata.

Passaggio 4:installazione di Certbot e configurazione dei certificati TLS

Grazie a Certbot e all'autorità di certificazione gratuita Let's Encrypt, aggiungere la crittografia TLS alla tua app di installazione Gitea richiederà solo due comandi.

Innanzitutto, installa Certbot e il suo plug-in Nginx:

sudo apt install certbot python3-certbot-nginx

Quindi, esegui certbot in --nginx mode e specifica lo stesso dominio che hai utilizzato in Nginx server_name direttiva di configurazione:

sudo certbot --nginx -d your_domain_here

Ti verrà chiesto di accettare i termini di servizio di Let's Encrypt e di inserire un indirizzo email.

Successivamente, ti verrà chiesto se desideri reindirizzare tutto il traffico HTTP su HTTPS. Dipende da te, ma in genere è consigliato e sicuro da fare.

Successivamente, Let's Encrypt confermerà la tua richiesta e Certbot scaricherà il tuo certificato:

OutputCongratulations! You have successfully enabled https://your_domain

You should test your configuration at:
https://www.ssllabs.com/ssltest/analyze.html?d=your_domain
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at:
   /etc/letsencrypt/live/your_domain/fullchain.pem
   Your key file has been saved at:
   /etc/letsencrypt/live/your_domain/privkey.pem
   Your cert will expire on 2022-05-09. To obtain a new or tweaked
   version of this certificate in the future, simply run certbot again
   with the "certonly" option. To non-interactively renew *all* of
   your certificates, run "certbot renew"
 - Your account credentials have been saved in your Certbot
   configuration directory at /etc/letsencrypt. You should make a
   secure backup of this folder now. This configuration directory will
   also contain certificates and private keys obtained by Certbot so
   making regular backups of this folder is ideal.
 - If you like Certbot, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

Certbot ricaricherà automaticamente Nginx con la nuova configurazione e i nuovi certificati. Ricarica il tuo sito nel browser e dovrebbe passare automaticamente a HTTPS se hai scelto l'opzione di reindirizzamento.

Il tuo sito è ora sicuro ed è possibile continuare con la procedura di configurazione basata sul Web.

Puoi trovare maggiori informazioni sulla protezione dei domini con Let's Encrypt nel tutorial Come proteggere Nginx con Let's Encrypt su Ubuntu 20.04.

Passaggio 5:configurazione di Gitea e aggiunta di un primo utente

Ora puoi passare alla configurazione stessa di Gitea e alla creazione del primo utente amministratore. Visita la tua istanza Gitea aprendo https://your_domain in un browser. Nella schermata di configurazione iniziale di Gitea, ci saranno diverse opzioni per il servizio:

Alcuni di questi, come il titolo del sito, dipendono dal tuo caso d'uso particolare, anche se ai fini di questo tutorial dovrai modificare quanto segue:

• Dominio del server: il dominio del server che hai configurato nel passaggio 3
• URL base Gitea: l'URL completo che utilizzerai per accedere a Gitea nel browser, incluso il protocollo. Ad esempio, https://your_domain .

Quando salvi le modifiche alla configurazione, verrai indirizzato alla pagina di accesso di Gitea.

Nota: Una volta salvata la configurazione, il servizio Gitea si riavvierà. Poiché l'operazione potrebbe richiedere alcuni secondi, potresti riscontrare un errore Nginx che indica 502 Bad Gateway . Se riscontri questo errore, attendi qualche secondo e riavvia la pagina.

Poiché non hai ancora un utente, dovrai prima crearne uno. Fai clic su Hai bisogno di un account? Registrati ora link sotto il modulo di accesso per registrare un nuovo utente. Come primo utente sul sistema, questo utente verrà creato come amministratore. Se configuri le impostazioni e-mail nella schermata di configurazione, potresti dover prima verificare il tuo account.

Dopo aver effettuato l'accesso come tale utente, fare clic sull'icona dell'utente nell'angolo in alto a destra della pagina e quindi fare clic su Amministrazione sito dal menu a discesa verrai indirizzato a una pagina in cui potrai eseguire lavori di manutenzione, gestire account utente e organizzazioni e configurare ulteriormente Gitea.

Creazione di un repository di test

Per testare Gitea, sia sull'interfaccia web che utilizzando Git stesso, crea un repository di test. Puoi sempre eliminare questo repository in un secondo momento.

Fare clic su + accedi nell'angolo in alto a destra della pagina, quindi fai clic su + Nuovo repository dal menu a tendina. Qui ti verrà presentata una schermata che ti consente di nominare e personalizzare il tuo repository con informazioni come la sua descrizione, impostazioni come se è privato o meno e qualsiasi contenuto predefinito come un README o .gitignore file.

Dopo aver premuto Crea repository , avrai un nuovo repository con cui giocare.

Passaggio 6:configurazione di uno spessore SSH

Il passaggio finale del processo consiste nel preparare la macchina host con uno spessore SSH. Poiché Gitea è in esecuzione in un container Docker, non può accettare connessioni SSH sulla porta predefinita di 22 , poiché questo entrerà in conflitto con l'host. Nella docker-compose.yml file che hai creato sopra, Docker è stato incaricato di mappare una porta sull'host sulla porta 22 sul contenitore in modo che accetti connessioni SSH alla porta 2222 . Inoltre, le authorized_keys SSH il file non sarà accessibile a qualcuno che accede all'host tramite SSH per impostazione predefinita.

Per tenerne conto, dovrai creare uno shim SSH che passerà le connessioni SSH a git utente sull'host nel contenitore. Nel file di composizione, hai anche specificato che l'UTENTE nel contenitore avrà un ID utente e gruppo di 1000 e, nella schermata di configurazione di Gitea, hai detto al servizio di utilizzare l'utente denominato git .

Creazione dell'utente Git e della sua chiave SSH

Successivamente, dovrai creare una chiave SSH per l'utente. Questo verrà utilizzato solo in un passaggio seguente e non verrà condiviso con nessuno al di fuori dell'host.

sudo -u git ssh-keygen -t rsa -b 4096 -C "Gitea Host Key"

Questo comando usa sudo per creare una chiave SSH come l'utente che hai creato sopra. In questo caso, la chiave sarà una chiave RSA a 4096 bit. Ti verranno poste una serie di domande, ad esempio quale password desideri per la chiave e come denominare il file della chiave. Premi ENTER per ciascuno di essi, lasciandoli vuoti per accettare l'impostazione predefinita.

Avviso :Se imposti una password sulla chiave, non potrai utilizzare lo spessore.

Dovrai assicurarti che l'utente all'interno del contenitore Gitea accetti questa chiave. Puoi farlo aggiungendolo a .ssh/authorized_keys file:

sudo -u git cat /home/git/.ssh/id_rsa.pub | sudo -u git tee -a /home/git/.ssh/authorized_keys
sudo -u git chmod 600 /home/git/.ssh/authorized_keys

Questi comandi funzionano tutti con lo shim poiché la directory /home/git/.ssh sull'host è montato come volume sul contenitore, il che significa che i contenuti sono condivisi tra di loro. Quando viene ricevuta una connessione all'host tramite git su SSH, utilizzerà le stesse authorized_keys file come contenitore.

Creazione dello script Shim SSH

Il passaggio finale per lo shim è creare uno stub gitea comando sull'host. Questo è ciò che consente ai comandi git di funzionare su SSH:quando viene stabilita una connessione SSH, verrà eseguito un comando predefinito. Questa gitea il comando sull'host è ciò che indirizzerà la connessione SSH al container.

Per questo script, usa cat per scrivere nel file /usr/local/bin/gitea :

cat <<"EOF" | sudo tee /usr/local/bin/gitea
#!/bin/sh
ssh -p 2222 -o StrictHostKeyChecking=no [email protected] "SSH_ORIGINAL_COMMAND=\"$SSH_ORIGINAL_COMMAND\" $0 $@"
EOF

Il comando in questo script SSH va al container Gitea Docker, passando il contenuto del comando originale usato da git .

Infine, assicurati che lo script sia eseguibile:

sudo chmod +x /usr/local/bin/gitea

Test delle connessioni SSH Git

Puoi provare il pull da e il push ai repository Git sulla tua istanza Gitea aggiungendo la tua chiave SSH al tuo utente Gitea.

Avrai bisogno del contenuto della tua chiave pubblica SSH. Questo di solito risiede in un file chiamato qualcosa come ~/.ssh/id_rsa.pub , a seconda dell'algoritmo utilizzato durante la creazione della chiave:

cat ~/.ssh/id_rsa.pub

Nota: Se devi creare una chiave SSH per la prima volta, puoi imparare come farlo con questo tutorial Come configurare le chiavi SSH su Ubuntu 20.04.

Copia l'output di questo comando.

In Gitea, fai clic sull'icona dell'utente nell'angolo in alto a destra e seleziona Impostazioni . Nella pagina delle impostazioni, ci saranno una serie di schede in alto. Fai clic su Chiavi SSH/GPG , quindi Aggiungi chiave accanto a Gestisci chiavi SSH . Incolla la chiave nell'ampia area di testo del modulo, quindi fai clic su Aggiungi chiave pulsante sotto di esso.

Ora vai al repository di test che hai creato nel passaggio 3 e copia l'URL SSH fornito. Sul tuo computer locale, clona il repository:

git clone git@your_domain:username/test

Questo utilizzerà SSH per clonare il repository. Se hai impostato una password sulla tua chiave SSH, ti verrà chiesto di fornirla.

Spostati in quella directory, crea un nuovo file:

cd test
touch just_testing

Quindi, aggiungilo alle modifiche in scena:

git add just_testing

Infine, esegui il commit di quel file:

git commit -am "Just testing pushing over SSH!"

Ora dovresti essere in grado di inviare le modifiche al repository remoto:

git push origin master

Quando aggiorni la pagina nel tuo browser, il tuo nuovo file apparirà nel repository.

Conclusione

Hai impostato un servizio Gitea utilizzando Docker per ospitare autonomamente i tuoi repository di codice sorgente. Da qui, sarai in grado di lavorare su repository sia pubblici che privati, utilizzando flussi di lavoro familiari come revisioni del codice pull-request e progetti organizzati dall'organizzazione. Gitea funziona bene anche con vari strumenti di integrazione e distribuzione continua (CI/CD) come Drone, Jenkins e GoCD. Inoltre, l'utilizzo di volumi Docker come questo ti consente di estendere lo spazio di archiviazione per adattarlo ai contenuti Git LFS (archiviazione di file di grandi dimensioni) sulla rete o di archiviazione a blocchi.