Installare Gogs su CentOS 7: guida passo passo

Questa guida mostra come installare e configurare Gogs su CentOS 7 usando PostgreSQL come database e Nginx come reverse proxy. Copre installazione di Go e Git, creazione dell’utente git, configurazione di systemd, controllo del firewall/SELinux, e suggerimenti per sicurezza e backup.

Importante: questa guida presuppone accesso root e un server CentOS 7 aggiornato.

Panoramica e obiettivi

Gogs è un servizio Git open source scritto in Go. È leggero e pensato per essere ospitato su hardware minimo. L’interfaccia web di Gogs è simile a GitHub e supporta diversi motori di database (MySQL, PostgreSQL, SQLite, MSSQL, TiDB). In questa guida useremo PostgreSQL e Nginx.

Obiettivi pratici:

• Installare dipendenze (EPEL, PostgreSQL, Git, Go)
• Compilare e avviare Gogs come utente git
• Configurare Gogs per usare PostgreSQL su 127.0.0.1
• Configurare systemd per avviare Gogs come servizio
• Mettere Nginx come reverse proxy su porta 80
• Controlli di sicurezza base: firewall, SELinux, HTTPS

Prerequisiti:

• Server CentOS 7 con accesso root
• Conoscenza di base di shell e vim

Varianti di intento e parole chiave correlate

Primario: installare Gogs su CentOS 7 Varianti utili: Gogs CentOS, Gogs con PostgreSQL, Gogs Nginx reverse proxy, Git self-hosted, installazione Go Git server

Requisiti e elenco dei passaggi

• CentOS 7 aggiornato
• Privilegi root o sudo

Passaggi principali:

1. Installare repository EPEL
2. Installare e configurare PostgreSQL
3. Installare Go e Git
4. Installare Gogs e compilarlo
5. Configurare Gogs
6. Eseguire Gogs come servizio systemd
7. Installare e configurare Nginx come reverse proxy
8. Testare l’installazione e compiere controlli di sicurezza

Step 1 - Installare repository EPEL

Installa il repository EPEL con yum:

sudo yum -y install epel-release

Questo rende disponibili pacchetti come nginx e alcuni strumenti utili.

Nota: se il server è offline, scarica il pacchetto epel-release e installalo localmente.

Step 2 - Installare e configurare PostgreSQL

Gogs supporta diversi database. In questa guida useremo PostgreSQL.

Installa PostgreSQL:

sudo yum -y install postgresql-server postgresql-contrib

Inizializza il database:

sudo postgresql-setup initdb

Passa all’utente postgres per modificare la configurazione:

su - postgres
cd data/
vim postgresql.conf

Modifica la riga listen_addresses così da limitare l’ascolto a localhost:

listen_addresses = '127.0.0.1'

Poi modifica le regole di autenticazione:

vim pg_hba.conf

Cambia la linea per l’host locale in modo da usare md5:

host    all             all             127.0.0.1/32            md5

Salva, esci e avvia PostgreSQL al boot:

sudo systemctl start postgresql
sudo systemctl enable postgresql

Verifica che PostgreSQL sia in ascolto sulla porta 5432:

netstat -plntu

Crea database e utente per Gogs:

su - postgres
psql
CREATE USER git CREATEDB;
\password git
CREATE DATABASE gogs_production OWNER git;
exit

Nota: scegli una password robusta per l’utente git. Se preferisci, usa un file .pgpass per connessioni non interattive.

Important: se prevedi connessioni remote tra host diversi, configura listen_addresses e firewall con attenzione. In questa guida manteniamo PostgreSQL accessibile solo da localhost.

Step 3 - Installare Go e Git

Installa Git:

sudo yum -y install git

Crea l’utente git che eseguirà Gogs:

useradd -m -s /bin/bash git
passwd git

Accedi come git e crea una directory per i pacchetti locali:

su - git
mkdir -p /home/git/local
cd ~/local

Scarica una versione di Go compatibile. Nell’esempio usiamo go1.9.2 (sostituisci con una versione più recente se necessario):

wget https://dl.google.com/go/go1.9.2.linux-amd64.tar.gz

Estrai l’archivio e rimuovi il file .tar.gz:

tar -xf go1.9.2.linux-amd64.tar.gz
rm -f go1.9.2.linux-amd64.tar.gz

Imposta le variabili d’ambiente per l’utente git (GOROOT e GOPATH):

cd ~
echo 'export GOROOT=$HOME/local/go' >> $HOME/.bashrc
echo 'export GOPATH=$HOME/go' >> $HOME/.bashrc
echo 'export PATH=$PATH:$GOROOT/bin:$GOPATH/bin' >> $HOME/.bashrc
source ~/.bashrc

Verifica l’installazione di Go:

go version

Consiglio: usa una versione di Go ancora supportata. Aggiornare Go può richiedere la ricompilazione di Gogs.

Step 4 - Installare Gogs

Accedi come git e scarica il sorgente di Gogs con go get:

su - git
go get -u github.com/gogits/gogs

Il codice verrà messo in $GOPATH/src/github.com/gogits/gogs. Compila Gogs:

cd $GOPATH/src/github.com/gogits/gogs
go build

Se la build riesce, avvia Gogs in modalità web per test rapido:

./gogs web

Il server partirà su porta 3000 e sarà raggiungibile pubblicamente (per impostazione predefinita). Nell’esempio la macchina usa l’IP 192.168.33.10:

http://192.168.33.10:3000/

Premi Ctrl+C per fermare l’istanza di test.

Step 5 - Configurare Gogs

Crea una copia custom della configurazione e modifica i parametri di server e database:

cd $GOPATH/src/github.com/gogits/gogs
mkdir -p custom/conf/
cp conf/app.ini custom/conf/app.ini
vim custom/conf/app.ini

Nel blocco [server] imposta Gogs per ascoltare su 127.0.0.1:

[server]
PROTOCOL = http
DOMAIN = localhost
ROOT_URL = %(PROTOCOL)s://%(DOMAIN)s:%(HTTP_PORT)s/
HTTP_ADDR = 127.0.0.1
HTTP_PORT = 3000

Nel blocco [database] inserisci i dati del database creato prima:

[database]
DB_TYPE = postgres
HOST = 127.0.0.1:5432
NAME = gogs_production
USER = git
PASSWD = aqwe123@

Salva e avvia di nuovo per verificare:

./gogs web

Importante: non lasciare password in chiaro in repository. Proteggi custom/conf/app.ini con permessi appropriati (owner git, chmod 600 se necessario).

Step 6 - Eseguire Gogs come servizio systemd

Per avere Gogs in background e avviato al boot, crea un file systemd:

cd /etc/systemd/system
vim gogs.service

Incolla la configurazione del servizio (adatta i percorsi se hai usato percorsi diversi):

[Unit]
Description=Gogs
After=syslog.target
After=network.target
After=mariadb.service mysqld.service postgresql.service memcached.service redis.service

[Service]
Type=simple
User=git
Group=git
WorkingDirectory=/home/git/go/src/github.com/gogits/gogs
ExecStart=/home/git/go/src/github.com/gogits/gogs/gogs web
Restart=always
Environment=USER=git HOME=/home/git

[Install]
WantedBy=multi-user.target

Ricarica systemd e avvia il servizio:

systemctl daemon-reload
systemctl start gogs
systemctl enable gogs

Verifica stato e porte:

netstat -plntu
systemctl status gogs

Suggerimento: se il servizio non parte, controlla i log con journalctl -u gogs -b.

Step 7 - Installare e configurare Nginx come reverse proxy

Installa Nginx dal repository EPEL:

yum -y install nginx

Crea un file di configurazione per il virtual host di Gogs:

cd /etc/nginx
vim conf.d/gogs.conf

Esempio di configurazione minima:

server {
    listen 80;
    server_name git.hakase-labs.co;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $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;
    }
}

Queste direttive proxy_set_header sono importanti per preservare host e informazioni client.

Salva, testa la configurazione e avvia nginx:

nginx -t
systemctl restart nginx
systemctl enable nginx

Verifica che nginx stia ascoltando su porta 80:

netstat -plntu

Note su SSL: per produzione abilita HTTPS (Let’s Encrypt o certificati aziendali). Configura proxy_pass su http://127.0.0.1:3000 e termina TLS su Nginx.

Step 8 - Testare l’installazione

Apri il browser su:

http://git.hakase-labs.co/

Nella pagina di installazione web inserisci le informazioni PostgreSQL create in Step 2. Poi crea l’account amministratore e clicca Install Gogs.

Compila la sezione Admin account settings con utente, email e password.

Al termine verrai reindirizzato alla dashboard utente:

Ecco la Dashboard di amministrazione:

Gogs è ora operativo con PostgreSQL e Nginx su CentOS 7.

Controlli di sicurezza e hardening

• Firewall: apri solo le porte necessarie (80/443). Se usi firewall-cmd:

firewall-cmd --permanent --add-service=http
firewall-cmd --permanent --add-service=https
firewall-cmd --reload

• SELinux: CentOS 7 ha SELinux abilitato. Se hai problemi con Nginx che proxy_pass a 127.0.0.1, controlla audit.log. Per test puoi temporaneamente impostare SELinux in permissive:

sudo setenforce 0

Ma non lasciare SELinux disabilitato in produzione: invece risolvi i booleans o i contesti corretti.

• Permessi: assicurati che solo l’utente git legga app.ini e chiavi.

chown git:git custom/conf/app.ini
chmod 600 custom/conf/app.ini

• Backup DB: pianifica backup regolari del database PostgreSQL (pg_dump), e backup dei repo Git e della directory custom.

Procedure consigliate e checklist per ruoli

Amministratore di sistema:

• Verificare che systemd avvii gogs e che i permessi su /home/git siano corretti
• Configurare firewall e SELinux
• Automatizzare backup DB e directory Gogs

Sviluppatore/DevOps:

• Verificare clone/push/pull sui repo creati
• Testare webhooks e integrazioni
• Verificare che le chiavi SSH degli utenti siano correttamente memorizzate

Amministratore di Gogs:

• Configurare SMTP per le email di notifica
• Creare utenti e team
• Monitorare lo storage dei repository e il database

Risoluzione dei problemi comuni

Gogs non parte: controlla i log di systemd:

journalctl -u gogs -b --no-pager

Problemi database: verifica connessione con psql usando le stesse credenziali specificate in app.ini.

Nginx mostra errore 502: verifica che Gogs sia attivo su 127.0.0.1:3000 e che proxy_pass punti correttamente. Controlla i log di Gogs per errori di binding.

Problemi SSL: assicurati che le direttive ssl_certificate e ssl_certificate_key in nginx siano corrette e leggibili dal processo nginx.

Alternative e varianti

• Database: puoi usare MySQL/MariaDB o SQLite per ambienti più piccoli. PostgreSQL è consigliato per produzione.
• Distribuzione: Gogs può essere installato tramite pacchetti precompilati o container (Docker). Docker semplifica l’isolamento, ma richiede gestione di volumi e rete.
• Sostituti: se servono funzionalità più avanzate (CI integrato, gestione utenti enterprise), valuta Gitea (fork di Gogs mantenuto attivamente) o GitLab per esigenze complesse.

Checklist di accettazione prima della produzione

• Gogs avviato come servizio e riavvia automaticamente
• Connessione al database funzionante e testata
• Nginx gestisce il traffico esterno e reindirizza correttamente a Gogs
• Backup DB e dei repository pianificati
• HTTPS attivo su Nginx
• SELinux e firewall configurati correttamente

Piccola guida operativa rapida (SOP)

1. Prima di aggiornare Gogs: eseguire backup DB e copia della directory custom e dei repo.
2. Per aggiornare Gogs via sorgente: fermare service, pull dei sorgenti, go build, riavviare service.
3. Per rollback: ripristinare backup DB e directory repository, riavviare service.

Glossario veloce

• Gogs: servizio Git scritto in Go, per self-hosted Git
• GOPATH/GOROOT: variabili d’ambiente per l’ambiente di sviluppo Go
• systemd: init system di CentOS 7 per gestire servizi
• Nginx reverse proxy: web server che instrada le richieste al backend

Note sulla privacy e conformità

Se ospiti repository contenenti dati personali, applica politiche di retention e accesso, e valuta obblighi GDPR (registro trattamenti, backup crittografati e controllo accessi).

Riepilogo

Seguendo questi passaggi puoi installare Gogs su CentOS 7 con PostgreSQL e Nginx. Ricorda di applicare le pratiche di sicurezza (backup, permessi, SSL) e di testare push/pull e automazioni prima di operare in produzione.

Riferimenti

https://gogs.io/docs/installation

Importante: aggiorna le versioni di Go e Gogs a quelle attualmente supportate e mantieni i tuoi pacchetti di sistema aggiornati.