Installer Gogs sur CentOS 7 avec PostgreSQL et Nginx

Public visé

• Administrateurs système et DevOps souhaitant auto-héberger un service Git léger.
• Utilisateurs de CentOS 7 avec privilèges root.

Prérequis

• Serveur CentOS 7
• Accès root ou sudo

Sommaire

• Étape 1 - Installer le dépôt EPEL
• Étape 2 - Installer et configurer PostgreSQL
• Étape 3 - Installer Go et Git
• Étape 4 - Installer Gogs
• Étape 5 - Configurer Gogs
• Étape 6 - Exécuter Gogs comme service systemd
• Étape 7 - Configurer Nginx en reverse proxy
• Étape 8 - Tests et finalisation
• Sécurité, dépannage, alternatives et checklist d’exploitation

Étape 1 - Installer le dépôt EPEL

La première étape consiste à ajouter le dépôt EPEL (Extra Packages for Enterprise Linux). Exécutez :

sudo yum -y install epel-release

Le dépôt EPEL est maintenant disponible sur votre serveur CentOS 7.

Étape 2 - Installer et configurer PostgreSQL

Gogs prend en charge plusieurs SGBD (MySQL, PostgreSQL, SQLite3, MSSQL, TiDB). Ici nous utilisons PostgreSQL.

Installez PostgreSQL :

sudo yum -y install postgresql-server postgresql-contrib

Initialisez la base de données :

sudo postgresql-setup initdb

Connectez-vous en tant qu’utilisateur postgres pour modifier la configuration :

su - postgres

Éditez le fichier de configuration et forcez PostgreSQL à écouter uniquement sur localhost :

cd data/
vim postgresql.conf

Modifiez la ligne :

listen_addresses = '127.0.0.1'

Ensuite éditez la configuration d’authentification :

vim pg_hba.conf

Pour l’accès local, utilisez md5 :

host    all             all             127.0.0.1/32            md5

Démarrez et activez le service PostgreSQL :

sudo systemctl start postgresql
sudo systemctl enable postgresql

Vérifiez que PostgreSQL écoute sur 127.0.0.1:5432 :

netstat -plntu

Créez la base de données et l’utilisateur pour Gogs :

su - postgres
psql

Dans psql :

CREATE USER git CREATEDB;
\password git
CREATE DATABASE gogs_production OWNER git;
exit

Important: choisissez un mot de passe fort pour l’utilisateur git. Notez-le de manière sécurisée.

Étape 3 - Installer Go et Git

Installez Git via yum :

sudo yum -y install git

Ajoutez un utilisateur système git :

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

Connectez-vous en tant que git et créez un dossier local :

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

Téléchargez la version de Go indiquée dans le guide (ici un exemple) :

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

Extrayez et supprimez l’archive :

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

Définissez les variables d’environnement pour git (GOROOT, GOPATH, PATH) :

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

Assurez-vous d’utiliser bash comme shell par défaut. Vérifiez la version de Go :

go version

Go est installé pour l’utilisateur git.

Remarque: vous pouvez installer une version plus récente de Go si souhaité ; adaptez le nom d’archive et les chemins en conséquence.

Étape 4 - Installer Gogs

Téléchargez le code source de Gogs avec go get :

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

Compilez Gogs :

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

Exécutez Gogs en mode web pour un test simple :

./gogs web

Par défaut Gogs écoute sur le port 3000 et est accessible publiquement (à moins que vous ne l’ayez lié à 127.0.0.1). Dans l’exemple :

http://192.168.33.10:3000/

Appuyez sur Ctrl+C pour arrêter le serveur de test.

Étape 5 - Configurer Gogs

Créez un dossier custom/conf pour la configuration personnalisée :

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

Dans la section [server], forcez l’adresse d’écoute à 127.0.0.1 pour ne pas exposer directement Gogs :

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

Dans [database], renseignez vos paramètres PostgreSQL :

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

Sauvegardez et relancez Gogs pour vérifier la configuration :

./gogs web

Important: n’utilisez pas de mot de passe en clair dans des dépôts ou scripts non sécurisés ; limitez l’accès au fichier custom/conf/app.ini.

Étape 6 - Exécuter Gogs comme service sur CentOS 7

Créez un service systemd pour Gogs afin qu’il se lance au démarrage :

cd /etc/systemd/system
vim gogs.service

Collez la configuration suivante :

[Unit]
 Description=Gogs
 After=syslog.target
 After=network.target
 After=mariadb.service mysqld.service postgresql.service memcached.service redis.service
  
 [Service]
 # Modify these two values and uncomment them if you have
 # repos with lots of files and get an HTTP error 500 because
 # of that
 ###
 #LimitMEMLOCK=infinity
 #LimitNOFILE=65535
 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

Rechargez systemd, démarrez et activez le service :

systemctl daemon-reload
systemctl start gogs
systemctl enable gogs

Gogs tourne maintenant comme service.

Vérifiez son état :

netstat -plntu
systemctl status gogs

Étape 7 - Installer et configurer Nginx en reverse proxy pour Gogs

Installez Nginx depuis EPEL :

yum -y install nginx

Créez une configuration virtuelle pour Gogs :

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

Exemple de configuration :

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

    location / {
        proxy_pass http://127.0.0.1:3000;
    }
}

Testez la configuration Nginx :

nginx -t

Redémarrez et activez Nginx :

systemctl restart nginx
systemctl enable nginx

Vérifiez que le port 80 est ouvert :

netstat -plntu

Remarque: pour la production, utilisez préférentiellement TLS (voir section Sécurité).

Étape 8 - Tests

Ouvrez un navigateur :

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

Sur la page d’installation, renseignez les informations PostgreSQL précédemment créées :

Dans la section Admin, créez le compte administrateur :

Cliquez sur “Install Gogs” et vous êtes redirigé vers le tableau de bord :

Gogs est maintenant installé avec PostgreSQL et Nginx sur CentOS 7.

Dépannage rapide

• Erreur 502/504 via Nginx : vérifiez que Gogs écoute sur 127.0.0.1:3000 et que le service systemd est actif.
• Échec de connexion à PostgreSQL : contrôlez pg_hba.conf, redémarrez PostgreSQL et vérifiez le mot de passe de l’utilisateur git.
• Problèmes de compilation Go : vérifiez GOPATH et que go build s’exécute sans erreur dans $GOPATH/src/github.com/gogits/gogs.
• Problèmes de droits : assurez-vous que l’utilisateur git possède les répertoires et fichiers nécessaires.

Commandes utiles pour diagnostiquer

systemctl status gogs
journalctl -u gogs -n 200
tail -n 200 /home/git/go/src/github.com/gogits/gogs/log/*
systemctl status postgresql
nginx -t
ss -plntu | grep -E ":80|:3000|:5432"

Sécurité et durcissement

1. Activez TLS avec un certificat valide (Let’s Encrypt). Proxyz HTTPS vers 127.0.0.1:3000 en gardant HTTP interne.
2. Restreignez l’accès SSH et limitez les utilisateurs sudo.
3. Configurez un pare-feu (firewalld/iptables) pour n’ouvrir que les ports nécessaires (80/443, SSH si besoin).
4. Désactivez l’accès direct à l’interface Gogs depuis l’extérieur en liant Gogs à 127.0.0.1.
5. Sauvegardez régulièrement la base PostgreSQL et le dossier repos/ de Gogs.
6. Considérez l’usage d’un scan de sécurité périodique (vulnérabilités, dépendances Go obsolètes).

Exemple minimal de configuration Nginx avec TLS (à adapter) :

server {
    listen 443 ssl;
    server_name git.example.com;
    ssl_certificate /etc/letsencrypt/live/git.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/git.example.com/privkey.pem;

    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;
    }
}

Important: n’exposez pas l’utilisateur et le mot de passe PostgreSQL dans des dépôts ou dans des logs.

Sauvegarde et plan de reprise (SOP minimal)

• Sauvegarde de la base PostgreSQL :

pg_dump -U git -Fc gogs_production > /var/backups/gogs_production_$(date +%F).dump

• Sauvegarde des dépôts et configurations :

tar -czf /var/backups/gogs_files_$(date +%F).tar.gz /home/git/go/src/github.com/gogits/gogs/custom /home/git/go/src/github.com/gogits/gogs/data

• Restauration : restaurer la base psql puis déployer les fichiers sauvegardés et redémarrer systemd.

Alternatives et choix techniques

• Alternatives à Gogs : Gitea (fork de Gogs, plus actif), GitLab CE (plus complet mais plus lourd), Bitbucket Server.
• Choix de la base : SQLite convient pour petits déploiements; PostgreSQL offre plus de fiabilité en production.
• Déploiement : pour la haute disponibilité, déployer PostgreSQL séparément, utiliser un proxy de mise à l’échelle et sauvegardes centralisées.

Contre-exemples — quand Gogs n’est pas adapté :

• Vous avez besoin d’intégration CI/CD avancée native, de gestion d’utilisateurs d’entreprise poussée ou de fonctionnalités d’analytics étendues. Dans ce cas, GitLab ou une solution managée peut être plus adaptée.

Checklist d’exploitation par rôle

Admin système:

• Installer et patcher le système d’exploitation.
• Gérer les sauvegardes PostgreSQL et des dépôts.
• Configurer TLS et pare-feu.

DevOps:

• Créer les hooks et pipelines externes.
• Intégrer Gogs avec les systèmes d’authentification (LDAP/SSO si nécessaire).

Développeur:

• Vérifier les accès SSH/HTTP.
• Tester clone/push/pull sur un dépôt de test.

Glossaire (1-ligne)

• Gogs: un service Git léger écrit en Go pour auto-hébergement.
• GOPATH/GOROOT: variables d’environnement pour l’outil Go.
• systemd: gestionnaire de services sur CentOS 7.
• Reverse proxy: serveur frontal (ex. Nginx) qui relaie les requêtes vers une application interne.

Notes RGPD et confidentialité

• Les données utilisateurs (identifiants, e-mails, dépôts privés) doivent être stockées et sauvegardées de manière sécurisée.
• Documentez la durée de conservation des données et fournissez des moyens de suppression sur demande.
• Si vous traitez des données personnelles d’utilisateurs en UE, assurez-vous d’avoir des bases légales et des procédures pour les demandes d’accès/suppression.

Migration et compatibilité

• Pour migrer de SQLite vers PostgreSQL : exportez les données et réimportez dans PostgreSQL selon la documentation Gogs.
• Si vous migrez de Gogs vers Gitea : Gitea propose des outils et une doc pour importer les dépôts et utilisateurs.
• Conservez des backups avant toute migration. Testez la migration sur un environnement de staging.

Résumé

• Installer EPEL, PostgreSQL, Go, Git, Gogs et Nginx.
• Exécuter Gogs en local (127.0.0.1:3000) et exposer via Nginx.
• Créer un service systemd pour production.
• Mettre en place TLS, sauvegardes et restrictions d’accès.

Référence

https://gogs.io/docs/installation