# Forge

## Ce que c'est

Une forge, aussi appelée forge logicielle, forge de code ou forge Git, est le
serveur qu'une équipe choisit comme lieu de référence pour ses dépôts, avec les
services qui les entourent. Chaque clone complet d'un dépôt Git contient tout
l'historique : en principe, aucune copie ne prévaut sur une autre. En pratique,
une équipe a besoin d'un endroit où pousser le code, qui décide des droits de
lecture et d'écriture et où se déroulent les discussions sur ce code. Cet endroit
est la forge.

À la base, une forge conserve des dépôts nus, c'est-à-dire l'historique sans
fichiers extraits dans un répertoire de travail, et utilise un ou plusieurs des
protocoles de transfert de Git. Le livre Git en recense quatre : le protocole
local pour un répertoire de la même machine, HTTP, SSH et le protocole propre à
Git, dont le démon écoute sur le port 9418 sans aucune authentification. Tout le
reste s'ajoute à cette base, dans des proportions très variables.

La documentation de Forgejo décrit le côté le plus complet de cette gamme :
suivi des tickets, demandes d'intégration, wiki intégré, registre de paquets
pour de nombreux écosystèmes de langages, Forgejo Actions pour exécuter des
tâches, miroirs de dépôts, migration depuis d'autres services, protection des
branches et des étiquettes, et webhooks. Soft Serve se situe à l'autre extrémité.
Il se présente comme un « serveur Git auto-hébergeable pour la ligne de
commande » : un seul binaire, `soft`, qui sert les dépôts par SSH, HTTP ou le
protocole Git, contrôle les accès à l'aide de clés publiques SSH et prend en
charge les collaborateurs, les dépôts privés et les webhooks. Ce sont deux
forges ; elles diffèrent par la part du travail de l'équipe qu'elles cherchent
à réunir.

Les forges ont aussi commencé à communiquer entre elles. ForgeFed est un
protocole de fédération des plateformes d'hébergement et de collaboration sur
des projets logiciels, conçu comme une extension d'ActivityPub. Il représente
les dépôts, les gestionnaires de tickets, les gestionnaires de correctifs, les
projets et les équipes comme des acteurs qui s'envoient des activités. Il vise
un langage commun aux réseaux de forges et d'outils de gestion de projets : une
personne pourrait ouvrir, depuis un serveur, un ticket concernant un dépôt d'un
autre serveur, et un dépôt pourrait changer de serveur tandis que son ancienne
copie resterait archivée en lecture seule et renverrait vers sa nouvelle adresse.

## Pourquoi c'est important

La forge est le lieu où les règles peuvent être imposées. Une règle sur la
machine d'un développeur ne s'applique que tant que cette machine est correctement
configurée ; un hook sur le serveur s'exécute à chaque push. Le hook
`pre-receive` de Git reçoit sur l'entrée standard chaque référence poussée,
sous la forme d'un ancien identifiant, d'un nouvel identifiant et d'un nom. S'il
se termine avec un code non nul, aucune référence n'est mise à jour. La
protection des branches, les revues obligatoires et les vérifications de signature
des commits sur les grandes forges affinent la même idée : la copie partagée
refuse ce que l'équipe a convenu de ne pas accepter.

Choisir une forge, c'est aussi choisir qui détient le code. Un service hébergé
prend en charge les coûts d'exploitation et la disponibilité. En contrepartie,
le code, la liste des accès et toutes les discussions résident sur le matériel
d'un tiers et sont soumis à ses conditions. L'auto-hébergement inverse cet
échange. Aucun choix n'est gratuit. La différence compte surtout pour une
entreprise qui indique à ses clients où se trouvent leurs données.

Une forge détient aussi des données que Git ne conserve pas. Les commits et les
étiquettes voyagent avec chaque clone ; les tickets, les fils de revue, les
listes d'accès et les hooks côté serveur appartiennent à la seule forge. Cette
séparation détermine ce qu'une sauvegarde doit couvrir et ce qu'une migration
entre forges doit emporter.

## À quoi cela ressemble en pratique

L'entreprise exploite sa propre forge. Trois projets présentés sur ce site
montrent ce qu'il a fallu mettre en place.

Son code source était auparavant hébergé par un service tiers. Le projet de
[déploiement de sa propre forge Git](/fr/portfolio/your-code-on-your-own-hardware/)
part d'un constat : exploiter une forge implique d'en assurer l'authentification,
le contrôle d'accès, le stockage, les sauvegardes et la façade publique. La forge
est Soft Serve, un seul binaire supervisé par le système d'exploitation, choisi
pour son approche centrée sur SSH et l'absence d'interface web d'administration.
Elle est configurée comme une forge privée : les accès anonymes et sans clé sont refusés, et
chaque dépôt déclaré est marqué privé. Son service SSH n'écoute que sur
l'interface de bouclage, sur le port 23231 ; les accès extérieurs passent par un
hôte de rebond. Un multiplexeur permettant de partager un port public entre HTTPS
et Git sur SSH a été écrit, puis laissé désactivé : un point d'écoute inutilisé
reste une surface d'attaque. Le résultat est énoncé simplement : l'entreprise
héberge son propre code sur son propre matériel.

Le dépôt de ce site y réside lui aussi. Ses consignes désignent la forge
auto-hébergée, Soft Serve sur SSH, comme dépôt distant canonique, qualifient
l'ancienne copie hébergée de miroir historique et précisent qu'il n'y a pas de CI
hébergée : les contrôles de qualité s'exécutent localement et dans les hooks Git.

Un hook côté serveur doit être testé dans l’environnement qui reçoit un véritable push Git. Il a donc été
[testé avec un vrai dépôt nu et un vrai push](/fr/portfolio/rehearsed-the-forge-ci-hook-found-2-defects/)
avant d'être considéré comme fiable. Le test crée un dépôt nu, installe le hook,
clone, crée un commit, pousse et vérifie les deux chemins : acceptation et refus.
Il a révélé deux défauts, invisibles à la lecture du fichier. Le second est
instructif : lorsqu'il exécute un hook, Git exporte une variable désignant le
répertoire du dépôt. La suite de tests lancée par le hook en héritait ; dix-neuf
tests échouaient sur du code correct, jusqu'à ce que l'environnement soit nettoyé
à la frontière entre les deux contextes. La page en précise aussi la limite :
le test ne construit pas de push comportant des mises à jour forcées ou des
suppressions de branches.

Tout cela partage
[un hôte à un seul cœur et 512 Mo de mémoire](/fr/portfolio/a-whole-company-on-one-small-server/)
avec tous les autres services de l'entreprise accessibles au public : sept
domaines TLS, un
service onion, des serveurs Gemini et Gopher et le blocage des intrusions.
L'automatisation des sauvegardes est implémentée séparément ; cela ne signifie
pas que les sauvegardes sont actives. Une forge dotée d'un panneau web aurait
ajouté une application résidente à ce budget, d'où l'exclusion de ces plateformes
dès la conception. Sur cet hôte, la mémoire disponible est descendue jusqu'à
environ 310 Mo sur 464 au cours d'une journée de mesures enregistrées.

## Où les problèmes surviennent

Sur certaines forges, les visiteurs anonymes ont un accès en lecture par défaut.
La documentation de Soft Serve indique qu'à l'installation, les connexions
anonymes disposent de droits de lecture seule, contrôlés par `anon-access` et
`allow-keyless`. Une forge privée règle le premier sur `no-access` et le second
sur false. Il est utile de vérifier le résultat depuis une machine sans clé
chargée. Le démon propre à Git est encore plus radical : le livre Git précise
qu'un dépôt servi par ce démon est soit clonable par tout le monde, soit non
servi.

Un hook qui appelle Git dans un autre répertoire agit sur le mauvais dépôt.
Pendant un push, Git exécute les hooks de réception dans le dépôt nu et exporte
`GIT_DIR` et des variables apparentées pour que les commandes Git du hook le
retrouvent. Tous les processus qu'il lance en héritent, y compris des tests dans
une copie de travail située ailleurs. Le manuel githooks demande de supprimer
ces variables avant de travailler sur un autre dépôt. Un hook `pre-receive`
minimal qui teste chaque commit poussé dans un répertoire temporaire le fait dans
un sous-shell :

```sh
while read -r _ newrev _; do
  git cat-file -e "$newrev^{commit}" 2>/dev/null || continue
  tree=$(mktemp -d)
  git archive "$newrev" | tar -x -C "$tree"
  (
    unset $(git rev-parse --local-env-vars)
    cd "$tree" && ./run-tests
  ) || exit 1
done
```

Une forge restaurée retrouve son code, mais pas ses règles. N'importe quel clone
peut repeupler les dépôts d'un serveur perdu, mais le livre Git rappelle que les
hooks côté serveur et les paramètres similaires restent sur le serveur. Les
tickets, revues, clés et listes d'accès n'ont jamais fait partie des clones.
Sauvegarder une forge implique de sauvegarder son répertoire de données et sa
configuration, de restaurer les deux quelque part et de vérifier qu'un push que
le hook doit refuser est effectivement refusé.

Chaque point d'écoute ouvert par une forge est un élément à défendre. L'exemple
de configuration de Soft Serve place SSH sur le port 23231, HTTP sur 23232, le
démon Git sur 9418 et un serveur de statistiques sur 23233. Une équipe qui pousse
uniquement par SSH peut désactiver les autres ou les lier à l'interface de
bouclage : les ports ouverts correspondent alors aux seuls usages réels.

Changer de forge emporte le code et laisse les discussions derrière. Un push
miroir copie toutes les références sous `refs/`, branches et étiquettes comprises,
et rien d'autre. Les tickets, fils de revue, labels et listes d'accès nécessitent
l'outil de migration de la nouvelle forge, ou un protocole comme ForgeFed :
celui-ci copie les commits, les étiquettes, les tickets, les demandes de fusion
et les commentaires, puis laisse l'ancien dépôt archivé avec un lien vers le
nouveau.

## Pour aller plus loin

- [Spécification ForgeFed](https://forgefed.org/spec/) — le protocole de
  fédération des forges, ses acteurs, ses activités et le processus de migration
  qui archive l'ancien dépôt.
- [Soft Serve](https://github.com/charmbracelet/soft-serve) — la documentation du
  projet : un serveur Git en un seul binaire, centré sur SSH, avec notamment
  les paramètres `anon-access` et `allow-keyless`.
- [Documentation Forgejo](https://forgejo.org/docs/latest/) — les guides
  d'administration et d'utilisation d'une forge auto-hébergée complète, de
  l'installation aux sauvegardes, aux Actions et aux miroirs.
- [githooks](https://git-scm.com/docs/githooks) — tous les hooks exécutés par Git,
  dont `pre-receive`, et l'environnement dont hérite un hook de push.
- [Les protocoles](https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protocols)
  — les quatre moyens utilisés par Git pour transférer des données entre
  machines, et leurs coûts de configuration et de sécurité.
- [ActivityPub](https://www.w3.org/TR/activitypub/) — la recommandation du W3C
  étendue par ForgeFed.

<https://engineer.company/fr/glossary/forge/>
