Git + Forgejo

Posté 21/05/2026 Mis à jour 19/08/2026

Par Yann

14 min lire

Git + Forgejo

Forgejo est une forge logicielle libre et opensource, écrite en langage Go et dont l’interface web contient du JavaScript pour sa partie dynamique, elle présente une interface web complète, et qui à la particularité de proposer la possibilité de fédération d’instance via ActivityPub. Source Wikipédia

Forgejo

Pour installer Forgejo, on a besoin d’un compte système git dédié (Installation from binary)

Installer le binaire Forgejo

Le lien pour les releases: https://codeberg.org/forgejo/forgejo/releases Les instructions suivantes sont pour l’installation de la dernière version de Forgejo sur un système Linux architecture amd64.

wget https://code.forgejo.org/forgejo/forgejo/releases/download/v16.0.2/forgejo-16.0.2-linux-amd64
chmod +x forgejo-16.0.2-linux-amd64

Tous les binaires Forgejo sont signés avec notre clé GPG pour vérifier leur authenticité et se prémunir contre les modifications indésirables.
Pour valider la signature, téléchargez le fichier de signature qui se termine par .asc pour le binaire que vous avez téléchargé et utilisez le Outil en ligne de commande GPG:

        
      
gpg --keyserver keys.openpgp.org --recv EB114F5E6C0DC2BCDD183550A4B61A2DC593710
wget https://code.forgejo.org/forgejo/forgejo/releases/download/v16.0.2/forgejo-16.0.2-linux-amd64.asc
gpg --verify forgejo-16.0.2-linux-amd64.asc forgejo-16.0.2-linux-amd64

Notez que la clé GPG est mise à jour régulièrement et doit être téléchargée à chaque fois pour s’assurer de la dernière La version est utilisée.

Ensuite, copiez le binaire Forgejo téléchargé sur /usr/local/bin/(le renommer en « forgejo ») et le rendre exécutable:

        
      
sudo cp forgejo-*-linux-amd64 /usr/local/bin/forgejo
sudo chmod 755 /usr/local/bin/forgejo
# suppression fichier après copie
rm forgejo-*-linux-amd64

Assurez-vous gitet git-lfssont installés sur votre système. Sur Debian GNU/Linux vous pouvez utiliser:

sudo apt install git git-lfs

Créer compte git avec home

Créer un utilisateur gitsur le système. Forgejo s’exécutera sous cet utilisateur, et lors de l’accès à git via SSH (qui est la valeur par défaut), cet utilisateur fait partie de l’URL (par exemple dans git clone git@git.example.com:YourOrg/YourRepo.gitles gitavant le @est l’utilisateur que vous allez créer maintenant).

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

Le compte git est essentiel car Forgejo s’exécute sous cet utilisateur pour gérer les dépôts de manière sécurisée.

Créer les répertoires pour Forgejo

Création des répertoires que Forgejo va utiliser et définir les autorisations d’accès de manière appropriée:

        
sudo mkdir /var/lib/forgejo
sudo chown git:git /var/lib/forgejo && sudo chmod 750 /var/lib/forgejo

Il s’agit du répertoire dans lequel Forgejo stockera ses données, y compris vos dépôts Git.

        
sudo mkdir /etc/forgejo
sudo chown root:git /etc/forgejo && sudo chmod 770 /etc/forgejo

Ceci est le répertoire dans lequel la configuration de Forgejo, appelée app.ini, est stockée. Au départ, il doit être accessible en écriture par Forgejo, mais après l’installation, vous pouvez le rendre en lecture seule pour Forgejo car il ne devrait alors plus le modifier.

Configuration forgejo

Service systemd forgejo

Créer le service systemd /etc/systemd/system/forgejo.service

[Unit]
Description=Forgejo (Beyond coding. We forge.)
After=network.target

[Service]
RestartSec=2s
Type=simple
User=git
Group=git
WorkingDirectory=/var/lib/forgejo/
ExecStart=/usr/local/bin/forgejo web --config /etc/forgejo/app.ini
Restart=always
Environment=USER=git HOME=/home/git FORGEJO_WORK_DIR=/var/lib/forgejo

[Install]
WantedBy=multi-user.target

Si vous n’utilisez pas sqlite, mais MySQL ou MariaDB ou PostgreSQL, vous devrez modifier ce fichier (/etc/systemd/system/forgejo.service) et décommenter les correspondants Wants=et After=lignes. Sinon, cela devrait fonctionner tel quel.

Nginx (forgejo.rnmkcy.eu)

Créer le fichier de configuration nginx /etc/nginx/conf.d/forgejo.rnmkcy.eu.conf

        
      
server {
    listen 80;
    server_name forgejo.rnmkcy.eu;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    listen [::]:443 ssl;
    http2 on;
    server_name forgejo.rnmkcy.eu;

    # Certificats SSL
    include /etc/nginx/conf.d/ssl-modern.inc;

    # Logs
    access_log /var/log/nginx/forgejo.access.log;
    error_log /var/log/nginx/forgejo.error.log;
    
    # Security headers
    server_tokens off;
    add_header X-Content-Type-Options nosniff always;
    add_header X-XSS-Protection "1; mode=block" always;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_redirect off;

        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

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

        proxy_read_timeout 90;
        proxy_connect_timeout 10;
        proxy_send_timeout 30;
    }
}

Vérifier et recharger nginx

        
sudo nginx -t
sudo systemctl reload nginx

Démarrer Forgejo

Après avoir ajouté ou modifié un fichier de service système, vous devrez recharger le fichier système.

sudo systemctl daemon-reload

Activer et démarrer Forgejo

        
sudo systemctl enable forgejo --now
sudo systemctl status forgejo

Configurer Forgejo

Ouvrir le lien https://forgejo.rnmkcy.eu pour la configuration initiale.

Type de base de données: SQLite3
Emplacement: /var/lib/forgejo/data/forgejo.db
Titre du site: Forgejo
Slogan de l’instance: Au-delà du codage. Nous forgeons.
Emplacement racine des dépôts: /var/lib/forgejo/data/forgejo-repositories
Répertoire racine Git LFS: /var/lib/forgejo/data/lfs
Exécuter avec le compte d’un autre utilisateur: git
Domaine du serveur: forgejo.rnmkcy.eu
Port du serveur SSH: ‘ ‘ Port d’écoute du serveur SSH. Laissez le vide pour le désactiver.
Port d’écoute HTTP de Forgejo: 3000
URL de base: https://forgejo.rnmkcy.eu/
Chemin des journaux: /var/lib/forgero/log
Désactiver la création de compte
Activer la vérification de mise à jour

⚠️Vous ne pouvez pas désactiver la création de nouveaux utilisateurs avant d’avoir créé un compte administrateur.

Cliquer sur Installer Forgejo

Il peut être logique de créer le compte administrateur dès maintenant (Paramètres du compte administrateur), Encore plus si vous avez désactivé l’auto-enregistrement.
La plupart des paramètres peuvent être modifiés /etc/forgejo/app.iniplus tard.

Une fois que vous avez terminé de configurer, cliquez Install Forgejoet quelques secondes plus tard, vous devriez être sur le tableau de bord (si vous avez créé un compte administrateur) ou à l’écran de connexion/s’inscrire, où vous peut créer un compte pour ensuite accéder au tableau de bord.

Il faut s’enregistrer

Création du compte

Cliquer sur administration du site (le premier utilisateur est administrateur)

Configuration supplémentaire app.ini

Arrêtez le service de forgejo:

sudo systemctl stop forgejo.service

Rendre le dossier /etc/forgejo/ et le fichier app.ini en lecture seule pour l’utilisateur git (Forgejo n’y écrit pas après la configuration initiale) :

        
      
sudo chmod 750 /etc/forgejo && sudo chmod 640 /etc/forgejo/app.ini

Maintenant, (en tant que root), modifier /etc/forgejo/app.ini.

sudo nano /etc/forgejo/app.ini

NOTE: Vous trouverez Configuration Cheat Sheet et Example app.ini qui contiennent toutes les options, y compris les descriptions, utiles.

Forgejo permet de télécharger des fichiers dans les dépôts Git via l’interface Web. Par défaut la taille du fichier pour les téléchargements est limité à 3MB par fichier, et 5 fichiers à la fois.
Pour l’augmenter, sous le [repository]section, ajouter un [repository.upload]section avec une ligne comme FILE_MAX_SIZE = 4095(ce serait 4095MB, environ 4Go) et MAX FILES = 20

[repository]
ROOT = /var/lib/forgejo/data/forgejo-repositories

[repository.upload]
;; max size for files to the repo via web interface, in MB,
;; defaults to 3 (this sets a limit of about 4GB)
FILE_MAX_SIZE = 4095
;; by default 5 files can be uploaded at once, increase to 20
MAX_FILES = 20

[server] 

Des restrictions similaires existent pour les pièces jointes aux requêtes issues/pull, configurées dans le [attachment]sections MAX_SIZE(par défaut 4MB) et MAX_FILES(par défaut 5) paramètres.

Par défaut, les téléchargements de données LFS expirent après 20 minutes - cela peut être trop court pour les gros fichiers, connexions lentes ou stockage LFS lent (git-lfs semble redémarrer automatiquement le téléchargement puis - Ce qui signifie qu’il peut prendre pour toujours et utiliser beaucoup de trafic).. Si vous allez utiliser LFS avec de gros téléchargements, augmentez ainsi la limite, en ajoutant la ligne LFS_HTTP_AUTH_EXPIRY = 180m(pendant 180 minutes) à la [server]section.

Par défaut, les fichiers LFS sont stockés dans le système de fichiers, dans /var/lib/forgejo/data/lfs. Dans le [lfs]section vous pouvez modifier le PATH = ...ligne pour stocker ailleurs, mais vous pouvez aussi configurer Forgejo pour stocker les fichiers dans un S3-like Object-Storage.

Si vous souhaitez utiliser le message électronique à l’échelle du système, activez l’envoi de courriels en modifiant la section[mailer]

[mailer]
;; send mail with systemwide "sendmail"
ENABLED = true
PROTOCOL = sendmail
FROM = "Forgejo Git" <noreply@yourdomain.com>

Vous pouvez tester l’envoi d’un courrier en cliquant sur le bouton utilisateur en haut à droite de la page Forgejo (« Profil et paramètres »), puis Site Administration, alors Configurationet sous Mailer Configurationtapez votre adresse de courrier et cliquez Send Testing Email.

Par défaut, Forgejo écoutera sur le port 3000, mais cela peut être changé à 80 avec HTTP_PORT

[server]
HTTP_PORT = 80

Les modifications app.ini

Ajouter un [repository.upload]section avec une ligne comme FILE_MAX_SIZE = 4095(ce serait 4095MB, environ 4Go) et MAX FILES = 20

[repository]
ROOT = /var/lib/forgejo/data/forgejo-repositories

[repository.upload]
;; max size for files to the repo via web interface, in MB,
;; defaults to 3 (this sets a limit of about 4GB)
FILE_MAX_SIZE = 4095
;; by default 5 files can be uploaded at once, increase to 20
MAX_FILES = 20

[server] 

Désactiver la création de nouveaux utilisateurs, basculer DISABLE_REGISTRATION à true

        
[service]
DISABLE_REGISTRATION = true

Lorsque vous avez terminé d’éditer l’app.ini, enregistrez-le et redémarrez le service Forgejo:

sudo systemctl start forgejo.service

Jetons accès (token)

Création jeton

Créer des jetons d’accès pour pousser des paquets vers Forgejo

Section “Configuration”, “Applications” et sélectionnez “Nouveau jeton d’accès”. Nommez le jeton et assurez-vous de sélectionner les options “Lecture et écriture” pour la gestion de paquets.

Générer un nouveau jeton

Après génération
Dès la génération, copiez le jeton immédiatement, comme il ne sera plus affiché.

Utilisation jeton

Pour un usage permanent via credential.helper=store :

Activer le helper permanent :

git config --global credential.helper store

Faire un push “la première fois” (Git te demandera login/token) :

git push -u origin main

Quand il demande :

Username : forgeadmin # login Forgejo
Password : token Forgejo

Vérifier que c’est bien mémorisé :

cat ~/.git-credentials

À partir de là, les futurs git push ne redemanderont plus le token.

Authentification OAuth2 (ACTIVE)

Authelia client oidc forgejo

Générer un secret client (insecure_secret) via la commande suivante :

        
      
authelia crypto hash generate pbkdf2 --variant sha512 --random --random.length 72 --random.charset rfc3986

La commande précédente renvoie 2 lignes

Random Password: -G3xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Digest: $pbkdf2-sha512xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

⚠️ Veuillez noter le mot de passe en clair (Random Password) ainsi que le hachage $pbkdf2 (Digest) du mot de passe pour une utilisation ultérieure.

Application Root URL: https://forgejo.rnmkcy.eu/
Authelia Root URL: https://auth.rnmkcy.eu/
ID du client: forgejo
Secret du client: insecure_secret
Nom de l’authentification (Forgejo): authelia:
- Cette option détermine l’URI de redirection dans le format de https://forgejo.rnmkcy.eu/user/oauth2/<Authentication Name>/callback. Cela signifie que si vous modifiez cette valeur, vous devez mettre à jour l’URI de redirection.

Ajouter la configuration client forgejo au fichier authelia dans la rubrique identity_providers oidc

        
      
identity_providers:
  oidc:
    ## The other portions of the mandatory OpenID Connect 1.0 configuration go here.
    ## See: https://www.authelia.com/c/oidc
    clients:
      - client_id: 'immich'    
        #------------------------------------- 

Le client oidc forgejo

        
      
      - client_id: 'forgejo'
        client_name: 'Forgejo'
        client_secret: '$pbkdf2-xxxxxxxxxxxxxxx'  # The digest of 'insecure_secret'.
        public: false
        authorization_policy: 'two_factor'
        require_pkce: true
        pkce_challenge_method: 'S256'
        consent_mode: 'implicit'
        redirect_uris:
          - 'https://forgejo.rnmkcy.eu/user/oauth2/authelia/callback'
        scopes:
          - 'openid'
          - 'email'
          - 'profile'
          - 'groups'
        response_types:
          - 'code'
        grant_types:
          - 'authorization_code'
        access_token_signed_response_alg: 'none'
        userinfo_signed_response_alg: 'none'
        token_endpoint_auth_method: 'client_secret_post'

Redémarrer authelia

sudo systemctl restart authelia

Authentification OAuth2 (Authelia)

Authelia utilise une base ldap pour authentifier les utilisateurs
Il faut ajouter forgeadmin/MotPasse à la base LLDAP https://lldap.home.arpa/
KeepassXC, cloner l’enregistrement forgeadmin/MotPasse https://forgejo en .rnmkcy.eu
Sur l’enregistrement cloné modifier le lien https://auth.rnmkcy.eu
Se connecter à Authelia https://auth.rnmkcy.eu avec forgeadmin/MotPasse pour ajouter une authentification TOTP qui sera utilisée comme second facteur

mémoriser le code secret TOTP dans keepassxc Forgejo Authelia

Pour configurer Forgejo avec Authelia en tant que fournisseur OpenID Connect 1.0

Se connecter en administrateur

1 - Administration du site

Paramètres administrateur

Ajouter Une Source D’authentification:

Type d’authentification: OAuth2

Configurez les options suivantes:

- Nom de l'authentification: `authelia`
- Fournisseur OAuth2: `OpenID Connect`
- ID client (clé): `forgejo`
- Secret du client: `insecure_secret` (random password)
- URL de découverte OpenID Connect: `https://auth.rnmkcy.eu/.well-known/openid-configuration`
- Champs d'application supplémentaires: `email profile groups`

Après avoir validé:

2 - Configuration

Paramètres utilisateur

Désactiver authentification à deux facteurs, si existant
Supprimer les(s) clé(s) de sécurité

Connexion Forgejo via OAuth2

A la première connexion, “Se connecter avec authelia”, il faudra saisir le code TOPT, login/mot de passe pour créer la liaison

Les connexions suivantes

Redirection vers authelia

Saisie code TOTP

Accepter

Authelia affiche l’écran “Demande de consentement” parce que le client OIDC Forgejo déclenche un flow où le consentement explicite est requis.

Pour désactiver/éviter, il faut passer le consent_mode du client Forgejo en implicit.
Ajouter dans la config authelia du client correspondant (client_id: forgejo) :
1 2 3 4 - client_id: 'forgejo' client_name: 'Forgejo' ... consent_mode: 'implicit'

Créer la liaison

Page forgejo

Checklist récupération accès admin Forgejo

1. Sauvegarde immédiate

Avant toute modification :

# Base de données
sudo cp /var/lib/forgejo/data/forgejo.db /var/lib/forgejo/data/forgejo.db.bak-$(date +%F-%H%M)

# Config
sudo cp /etc/forgejo/app.ini /etc/forgejo/app.ini.bak-$(date +%F-%H%M)

Si tu as des dépôts / fichiers annexes importants, assure-toi que tes backups habituels sont à jour.

2. Vérifier l’état des comptes dans la DB

sudo -u git sqlite3 /var/lib/forgejo/data/forgejo.db

-- Liste des utilisateurs
SELECT id, name, email, is_admin, is_active, login_type, login_name
FROM "user"
ORDER BY id;

-- Sources d’authentification
SELECT id, type, name, is_active
FROM login_source
ORDER BY id;

Points à vérifier :

Au moins un compte avec is_admin = 1 et is_active = 1.
Cohérence entre login_type / login_name et ton mode d’authentification (local vs OIDC/Authelia).

3. Réinitialiser / définir un mot de passe local admin

Si tu as accès shell au serveur :

sudo -u git forgejo --config /etc/forgejo/app.ini admin user list

Pour changer le mot de passe d’un compte admin (ex. yannig) :

sudo -u git forgejo --config /etc/forgejo/app.ini admin user change-password \
  --username yannig --password 'NouveauMotDePasseFort'

Pour forcer un compte en admin :

sudo -u git forgejo --config /etc/forgejo/app.ini admin user change \
  --username yannig --admin true

4. Contourner Authelia / OIDC pour tester

Tunnel SSH :

  ssh -L 3000:127.0.0.1:3000 ton_user@ton_serveur

Dans le navigateur : http://localhost:3000
Connexion avec login/mot de passe local.
Vérifier l’accès à “Site administration”.

Si ça marche en direct mais pas via Authelia → problème de mapping OIDC, pas de droit admin dans Forgejo.

5. Lier un compte local à Authelia (OIDC)

Si la connexion OIDC ne tombe pas sur le bon compte :

Dans Forgejo (admin, via tunnel) :
- Site administration → Authentication sources → authelia (OpenID).
- Noter le claim utilisé comme identifiant (souvent preferred_username ou email).

Dans SQLite :

 sudo -u git sqlite3 /var/lib/forgejo/data/forgejo.db

Si le claim est preferred_username = yannig :

  UPDATE "user"
  SET login_type = 6,
      login_name = 'yannig'
  WHERE name = 'yannig';

Si le claim est email = yannig@yannig.net :

  UPDATE "user"
  SET login_type = 6,
      login_name = 'yannig@yannig.net'
  WHERE name = 'yannig';

Redémarrer Forgejo :
1 systemctl restart forgejo
Re-tester la connexion via Authelia.

6. Vérification post-réparation

Se connecter via Authelia.
Vérifier :
- Nom du compte affiché (doit être yannig).
- Accès à “Site administration”.

Optionnel : reverifier dans SQLite :

  SELECT id, name, email, is_admin, login_type, login_name
  FROM "user"
  WHERE name = 'yannig';

Machine, CWWK

debian

Cet article est sous licence CC BY 4.0 par l'auteur.

Forgejo

Forgejo

Installer le binaire Forgejo

Créer compte git avec home

Créer les répertoires pour Forgejo

Configuration forgejo

Service systemd forgejo

Nginx (forgejo.rnmkcy.eu)

Démarrer Forgejo

Configurer Forgejo

Configuration supplémentaire app.ini

Les modifications app.ini

Jetons accès (token)

Création jeton

Utilisation jeton

Authentification OAuth2 (ACTIVE)

Authelia client oidc forgejo

Authentification OAuth2 (Authelia)

1 - Administration du site

2 - Configuration

Connexion Forgejo via OAuth2

Checklist récupération accès admin Forgejo

1. Sauvegarde immédiate

2. Vérifier l’état des comptes dans la DB

3. Réinitialiser / définir un mot de passe local admin

4. Contourner Authelia / OIDC pour tester

5. Lier un compte local à Authelia (OIDC)

6. Vérification post-réparation

Tags tendance