Git + Forgejo

Posté 21/05/2026 Mis à jour 06/06/2026

Par Yann

7 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é

Créer compte git avec home

        
      
sudo adduser --system --shell /bin/bash --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.

Cette commande crée :

Un utilisateur système git
Un groupe git
Le répertoire home /home/git
Pas de mot de passe (accès via SSH uniquement)

Installer Forgejo (binaire)

        
      
cd /tmp
VERSION=15.0.2
wget https://codeberg.org/forgejo/forgejo/releases/download/v$VERSION/forgejo-$VERSION-linux-amd64
chmod +x forgejo-$VERSION-linux-amd64
sudo mv forgejo-$VERSION-linux-amd64 /usr/local/bin/forgejo

Configuration forgejo

⚠️ Si on ne définit pas explicitement le WORK_PATH, Forgejo le déduira du chemin du binaire (/usr/local/bin), et donc APP_DATA_PATH deviendra /usr/local/bin/data. Le compte git n’a pas les droits pour créer/écrire dans /usr/local/bin/data, ce qui bloquera l’installation.

Solution : définir explicitement WORK_PATH et APP_DATA_PATH

Créer les répertoires de données

        
      
sudo mkdir -p /var/lib/forgejo/data
sudo mkdir -p /var/lib/forgejo/log
sudo mkdir -p /var/lib/forgejo/custom

sudo chown -R git:git /var/lib/forgejo
sudo chmod -R 750 /var/lib/forgejo

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

[Unit]
Description=Forgejo
After=network.target

[Service]
User=git
Group=git
WorkingDirectory=/var/lib/forgejo
ExecStart=/usr/local/bin/forgejo web -c /etc/forgejo/app.ini
Restart=always
Environment=HOME=/home/git
Environment=GITEA_WORK_DIR=/var/lib/forgejo
Environment=APP_DATA_PATH=/var/lib/forgejo/data

[Install]
WantedBy=multi-user.target

Créer le dossier de configuration

        
      
sudo mkdir -p /etc/forgejo
sudo chown root:git /etc/forgejo
sudo chmod 750 /etc/forgejo

Créer app.ini avec l’utilisateur git

        
      
sudo tee /etc/forgejo/app.ini > /dev/null << 'EOF'
[server]
DOMAIN = forgejo.rnmkcy.eu
ROOT_URL = https://forgejo.rnmkcy.eu/
HTTP_PORT = 3000
WORK_PATH = /var/lib/forgejo
APP_DATA_PATH = /var/lib/forgejo/data
LOG_FILE = /var/lib/forgejo/log/forgejo.log

[database]
DB_TYPE = sqlite3
PATH = /var/lib/forgejo/data/forgejo.db

[log]
MODE = console, file
LEVEL = info

[actions]
ENABLED = false

[service]
DISABLE_REGISTRATION = false
EOF

changer le propriétaire pour que git puisse le lire

sudo chown git:git /etc/forgejo/app.ini
sudo chmod 640 /etc/forgejo/app.ini

Vérifier que Forgejo peut lire le fichier

        
      
sudo -u git cat /etc/forgejo/app.ini

Configuration 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;
    
    # Redirection HTTP vers HTTPS
    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;

    # Reverse proxy vers Forgejo (port 3000 par défaut)
    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_redirect off;
        
        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;
        proxy_set_header X-Url-Scheme $scheme;
        
        proxy_read_timeout 90;
        proxy_connect_timeout 10;
        proxy_send_timeout 30;
    }

    # Cache des fichiers statiques
    location ~* \.(html|css|js|png|jpg|jpeg|gif|ico|svg|eot|woff|ttf|woff2)$ {
        proxy_pass http://127.0.0.1:3000;
        expires max;
        add_header Cache-Control "public, immutable";
    }
}

Vérifier et recharger nginx

        
sudo nginx -t
sudo systemctl reload nginx

Démarrer Forgejo

        
      
sudo systemctl daemon-reload
sudo systemctl enable forgejo --now
sudo systemctl status forgejo

OPTIONNEL mai recommandé, définir APP_DATA_PATH dans app.ini, dans /etc/forgejo/app.ini, ajouter :

APP_DATA_PATH = /var/lib/forgejo/data

Cela garantit que Forgejo utilise toujours ce chemin, même si le WORK_PATH change.

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

Cliquer sur Installer Forgejo

Ifaut s’enregistrer

Création du compte

Se connecter en administrateur (le premier utilisateur est administrateur)

Authentification LLDAP (NON UTILISEE)

Un serveur LLDAP est disponible localement: http://127.0.0.1:3890

Sélectionner LDAP (via BindDN)

Hôte: Le ip/hostname de votre serveur LLDAP, 127.0.0.1
Port: Port de votre serveur lldap 3890
Bind DN: uid=admin,ou=people,dc=rnmkcy,dc=eu
Bind Mot de passe admin lldap
Base de recherche utilisateur: ou=people,dc=rnmkcy,dc=eu
Filtre utilisateur: Si vous voulez que tous les utilisateurs puissent se connecter, utilisez (&(objectClass=person)(|(uid=%[1]s)(mail=%[1]s))) L’utilisateur ‘yann’ est dans le groupe ‘git’ (&(|(objectclass=inetOrgPerson))(|(memberof=cn=git,ou=groups,dc=rnmkcy,dc=eu)))

Pour se connecter, ils peuvent utiliser leur adresse e-mail ou leur nom d’utilisateur.

Si vous voulez seulement des membres un groupe spécifique pour être en mesure de se connecter, dans ce cas le groupe git_user, utiliser

(&(memberof=cn=git_user,ou=groups,dc=rnmkcy,dc=eu)(|(uid=%[1]s)(mail=%[1]s)))

Pour plus d’informations sur le filtre, voir: https://docs.gitea.io/en-us/authentication/#ldap-via-binddn

Filtre Admin (facultatif): Utiliser (memberof=cn=lldap_admin,ou=groups,dc=rnmkcy,dc=eu) si vous voulez que les administrateurs lldap deviennent des administrateurs Gitea. Laissez vide sinon.
Attribut nom d’utilisateur: uid
Attribut Prénom: givenName
Attribut Nom de famille : sn
Email Attribute: mail
Avatar Attribute: jpegPhoto

Au final

Forgejo authentification OAuth2

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'
        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

Forgejo source authentification OAuth2

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

Se connecter en administrateur, administration du site

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`

Mettre à jour éventuellement le paramètre suivant pour spécifier quels groupes d’oids ont accès admin à Forgejo - Nom de la revendication fournissant des noms de groupe pour cette source. (facultatif)

Après avoir validé:

LLDAP + Authelia

LLDAP

Il faut ajouter Utilisateur/MotPasse: https://lldap.home.arpa/

Authelia

keepassxc permet de mémorisier le code secret TOTP et donc de générer le code

Dupliquer dans keepassxc Utilisateur/MotPasse avec un lien différent https://auth.rnmkcy.eu
Ouvrir le lien https://auth.rnmkcy.eu et créer une authentification 2 facteurs TOTP

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

Page forgejo

Paramètres utilisateur

Se connecter avec son compte forgejo
Accédez aux Paramètres utilisateur en cliquant sur Configuration

Jetons d’accès (token)

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é. Ce jeton est essentiel pour pousser les paquets à Gitea:
{ .normal}

La connexion git se fait de la façon suivante:

git clone https://github.com/username/repo.git <--- HTTPS, pas SSH
# Username: votre_nom_d'utilisateur
# Password: your_token <-------- LE JETON (TOKEN), pas votre mot de passe

Sécurité

Paramètres utilisateur, Sécurité

Machine, CWWK

debian

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