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

• https://forgejo.socheleau.fr/
• HowTo Forgejo

Installer binaire Forgejo

Utilisateur su

su -
# OU
sudo -s

Télécharger

Les instructions suivantes sont pour l’installation de la dernière version de Forgejo sur un système Linux avec une architecture amd64.
Pour d’autres plates-formes et architectures ainsi que les dernières versions, assurez-vous de trouver les fichiers appropriés et modifier les instructions ci-dessous en conséquence.
Un miroir des versions est disponible au cas où codeberg.org ne serait pas accessible. Pour l’utiliser remplacer codeberg.orgavec code.forgejo.org

# sudo -s
cd /usr/local/bin
VERSION=15.0.2
wget https://codeberg.org/forgejo/forgejo/releases/download/v$VERSION/forgejo-$VERSION-linux-amd64
chmod 755 forgejo-$VERSION-linux-amd64
ln -s forgejo-$VERSION-linux-amd64 forgejo
mkdir -p /etc/forgejo/

Mise à jour

Le processus de mise à jour est assez simple et similaire au processus d’installation. Après avoir bien regardé s’il n’y a pas d’actions à faire manuellement dans les notes de publications de la nouvelle version, on peut simplement télécharger le dernier binaire dans /usr/local/bin/. Lui appliquer les bon droits (chmod 755) et mettre à jour le lien symbolique /usr/local/bin/forgejo vers ce nouveau binaire.

Il ne reste plus qu’à redémarrer l’instance. C’est terminé !

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

Configuration

Dans la suite de cette documentation, on se place dans le cas d’une instance simple, fonctionnant avec l’utilisateur git. On part du principe que :

• MySQL est déjà installé
• Le compte UNIX git existe sur la machine.
• La configuration sera écrire dans /etc/forgejo/git.ini
• Tous les fichiers de forgejo seront dans /home/git/ Attention, il ne doit pas y avoir de noexec
• L’adresse de l’instance sera forgejo.rnmkcy.eu

Côté fichiers applicatifs, on va se retrouver avec la hiérarchie suivante :

$ tree /home/git
├── internals 
│   ├── custom            << Fichiers de customisation de l'interface web de forgejo
│   │   ├── public        << Fichiers servis par le serveur web
│   │   └── templates     << Templates des pages
│   │       └── home.tmpl
│   │ 
│   └── data              << Toutes les données de forgejo (autres que les dépôts git)
│       ├── avatars
│       ├── indexers
│       ├── lfs
│       └── sessions
│
├── log                    << Journaux applicatifs
│   ├── gitea.log
│   ├── http.log
│   ├── serv.log
│   └── xorm.log
│
└── repositories            << Données des dépôts git
    └── foo
        └── hello_world.git

Ces dossiers seront créés au premier lancement de Forgejo. Il faut donc s’assurer que certaines variables d’environnement sont bien positionnées.

Lors de la première exécution de Forgejo, une page d’installation va demander tous les paramètres nécessaires pour initialiser l’instance. Celle-ci va aussi permettre de créer le premier compte administrateur.

/etc/forgejo/git.ini

Avant de commencer, on doit initialiser le fichier de configuration de forgejo avec les commandes suivantes.

touch /etc/forgejo/git.ini
chown git:git /etc/forgejo/git.ini

On ajoute aussi quelques réglages initiaux, pour que l’interface de Forgejo soit directement fonctionnelle (avec des logs en cas de souci) :

nano /etc/forgejo/git.ini

APP_NAME = Forgejo
RUN_USER = git
RUN_MODE = prod

[server]
PROTOCOL               = http+unix
DOMAIN                 = forgejo.rnmkcy.eu
HTTP_ADDR              = /run/forgejo/forgejo.sock
UNIX_SOCKET_PERMISSION = 666
OFFLINE_MODE           = true
SSH_DOMAIN             = forgejo.rnmkcy.eu
ROOT_URL               = http://forgejo.rnmkcy.eu/
ENABLE_GZIP            = true
LANDING_PAGE           = home
DISABLE_SSH            = false
SSH_PORT               = 22
LFS_START_SERVER       = true

[service]
REGISTER_EMAIL_CONFIRM                 = true
DISABLE_REGISTRATION                   = true
SHOW_REGISTRATION_BUTTON               = true
ENABLE_CACHE_AVATAR                    = false
#ENABLE_NOTIFY_MAIL                     = true
ENABLE_NOTIFY_MAIL                     = false
ENABLE_REVERSE_PROXY_AUTHENTICATION    = false
ENABLE_REVERSE_PROXY_AUTO_REGISTRATION = false
ALLOW_ONLY_EXTERNAL_REGISTRATION       = false
ENABLE_CAPTCHA                         = true
REQUIRE_SIGNIN_VIEW                    = false
DEFAULT_USER_VISIBILITY                = limited
NO_REPLY_ADDRESS                       = forgejo.rnmkcy.eu

[repository]
ROOT                   = /home/git/repositories
MAX_CREATION_LIMIT     = 0

[log]
ROOT_PATH              = /home/git/log/
MODE                   = file
LEVEL                  = Info

[i18n]
LANGS = fr-FR, en-US
NAMES = Français,English

systemd

On peut utiliser l’unité systemd suivante. Elle est inspirée de celle proposée par les développeurs de Forgejo. Nous l’avons ajustée pour correspondre au dossiers et réglages choisis plus haut.

nano /etc/systemd/system/Forgejo.service

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

[Service]
ExecStartPre=/bin/mkdir -m 0755 -p /run/forgejo
ExecStartPre=/bin/chown git: /run/forgejo
PermissionsStartOnly=yes

User=git
Group=git

Type=simple
RestartSec=2s
Restart=always

WorkingDirectory=/home/git
ExecStart=/usr/local/bin/forgejo web --config /etc/forgejo/git.ini
Environment=GITEA_WORK_DIR=/home/git/internals 


[Install]
WantedBy=multi-user.target

Lancer le service après rechargement

systemctl daemon-reload
systemctl start Forgejo
# si aucune erreur, activer le service
systemctl enable Forgejo

MySQL

Par défaut, Forgejo utilise une base SQLite. Mais on peut utiliser MySQL (ou PostgreSQL), voir plus bas. Forgejo nécessite seulement une base MySQL avec un compte.

mysqladmin create git
mysql -e "GRANT ALL PRIVILEGES ON git.* TO 'git'@localhost IDENTIFIED BY 'PASSWORD';"

Côté forgejo.ini, la base de donnée MySQL se configure avec la section ci-dessous.

Note : La page d’installation peut remplir cette section de la configuration automatiquement.

[database]
DB_TYPE  = mysql
HOST     = /run/mysqld/mysqld.sock
NAME     = git
USER     = git
PASSWD   = PASSWORD

PostgreSQL (Non Utilisé)

[database]
DB_TYPE = postgres
HOST = localhost
NAME = git
USER = git
PASSWD = PASSWORD
SCHEMA = 
SSL_MODE = disable

Nginx

Créer le fichier de configuration nginx

nano /etcnginx/conf.d/forgejo.rnmkcy.eu.conf

Contenu

upstream forgejo_git {
    server unix:/run/forgejo/forgejo.sock;
}
server {
    listen 80;
    listen [::]:80;
    server_name  forgejo.rnmkcy.eu;

    # redirect all plain HTTP requests to HTTPS
    return 301 https://gitea.rnmkcy.eu$request_uri;
}

server {
    # ipv4 listening port/protocol
    listen       443 ssl;
    # ipv6 listening port/protocol
    listen           [::]:443 ssl;
    http2 on;
    server_name forgejo.rnmkcy.eu;

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

    location / {
        proxy_pass http://forgejo_git;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_read_timeout 10;
    }
}

HTTPS

Après avoir activé le HTTPS sur le vhost nginx faisant office de reverse-proxy, il est utile d’ajuster quelques paramètres de configuration.

• Mettre à jour le ROOT_URL pour remplacer http://forgejo.rnmkcy.eu par https://forgejo.rnmkcy.eu
• Ajouter COOKIE_SECURE = true dans la section [session]
• (Optionnel) Rajouter le préfixe __Secure- au nom des cookies. Il s’agit des paramètres COOKIE_NAME dans la section [session] ainsi que COOKIE_USERNAME et COOKIE_REMEMBER_NAME dans la section [security]

  Recharger nginx

  vérification

  nginx -t
  

  Rechargement

  systemctl reload nginx
  

  Redis (Facultatif)

On peut utiliser Redis comme support pour les sessions et le cache de Forgejo.

Cache

# cat /etc/forgejo/git.ini
[cache]
ADAPTER = redis
HOST    = network=tcp,addr=127.0.0.1:6379,password=PASSWORD,db=1,pool_size=100,idle_timeout=180

Sessions

# cat /etc/forgejo/git.ini
[session]
PROVIDER         = redis
PROVIDER_CONFIG  = network=tcp,addr=127.0.0.1:6379,password=PASSWORD,db=0,pool_size=100,idle_timeout=180

Fail2Ban (Facultatif)

/etc/fail2ban/jail.d/forgejo.conf :

[forgejo]
enabled   = true
port      = http,https,ssh
filter    = forgejo
logpath   = /home/git/log/gitea.log
maxretry  = 20
findtime  = 300
bantime   = 900

Remarque : Ce n’est pas une erreur, à l’heure actuelle (version 10.0), le nom du log s’appelle toujours gitea.log par défaut

/etc/fail2ban/filter.d/forgejo.conf :

[Definition]
failregex =  .*(Failed authentication attempt|invalid credentials|Attempted access of unknown user).* from <HOST>
ignoreregex =

SMTP (Facultatif)

Configuration avec un Postfix local :

[mailer]
ENABLED = true
FROM = git@rnmkcy.eu
PROTOCOL = sendmail
SENDMAIL_PATH = /usr/sbin/sendmail

Il faudra configurer OpenDKIM afin de signer les emails via DKIM, ainsi que bien configurer SPF et DMARC pour le domaine utilisé.

Connexion site

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

Cliquer sur Installer Forgejo

Patienter…

Configuration terminée

Authentification LLDAP

Se connecter en administrateur (le premier utilisateur est administrateur)

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

Authentification OpenID

Notes communes

1. Le OpenID Connect 1.0 client_id paramètre:
   1. Cela doit être une valeur unique pour chaque client.
   2. La valeur utilisée dans ce guide est simplement à des fins de lisibilité et de démonstration et vous ne devriez pas utiliser cette valeur dans la production et devrait plutôt utiliser le Comment générer un identifiant client ou un secret client? FAQ. Nous recommandons 64 caractères aléatoires, mais vous pouvez utiliser n’importe quelle valeur arbitraire qui répond aux autres critères.
   3. Cela ne doit contenir que des caractères sans réserve RFC3986.
   4. Cela ne doit pas dépasser 100 caractères de longueur.
2. Le OpenID Connect 1.0 client_secret paramètre:
   1. La valeur utilisée dans ce guide est simplement à des fins de démonstration et vous ne devriez absolument pas l’utiliser valeur dans la production et devrait plutôt utiliser le Comment puis-je générer un identifiant client ou un secret client ? FAQ.
   2. Cette chaîne peut être stockée sous forme de texte clair dans la configuration d’Authelia, mais ce comportement est obsolète et ne l’est pas garantie d’être soutenu à l’avenir. Voir le guide Plaintext pour plus information.
   3. Lorsque le secret est stocké sous forme de hachage dans la configuration Authelia (fortement recommandé), le coût de Le hachage peut, si trop grand, causer des délais d’attente pour les clients. Voir le Régler le guide des facteurs de travail pour plus d’informations.
3. L’exemple de configuration pour Authelia:
   1. Ne contient qu’un exemple de configuration pour l’enregistrement du client et vous DEVEZ également configurer les exigences éléments du guide de configuration du fournisseur OpenID Connect 1.0.
   2. Ne contient qu’une petite partie de toutes les options disponibles pour un client enregistré et les utilisateurs peuvent souhaiter configurer des portions qui ne font pas partie de ce guide ou les configurer différemment, car il est important de à la fois vous familiariser avec les autres options disponibles et l’effet de chacune des options configurées dans cette section en consultant la configuration des clients OpenID Connect 1.0 guide

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'

Forgejo Web GUI

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

Se connecter en administrateur

Ajouter Une Source D’authentification:

Configurez les options suivantes: - Nom de l’authentification: authelia - Fournisseur OAuth2: OpenID Connect - ID client (clé): forgejo - Secret du client: insecure_secret - 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é:

Utiliser des jetons d’accès (token)

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

Ce guide essentiel est conçu pour générer les jetons d’accès nécessaires pour pousser les paquets vers Forgejo.

1. Connectez-vous à Forgejo en utilisant votre compte personnel, comme décrit dans Forgejo.
2. Accédez aux paramètres Forgejo de l’utilisateur en cliquant dans le coin supérieur droit de l’écran:

Cliquer sur “Configuration”

1. Recherchez la section “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.

1. 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