Gentoo - Installation

Installer Gentoo sur Raspberry Pi (OpenRC)

Cet article a été mis à jour, vous consultez ici une archive de cet article!

Table des matières

logo_gentoo

Introduction

Gentoo est une distribution GNU/Linux sympathique, conçue pour être optimisée pour le matériel de l'utilisateur. Tous les programmes sont donc compilés à partir du code source.

Dans cet article, nous allons installer cette distribution sur un Rasberry Pi 4 B !

Prérequis

En fonction du modèle du Raspberry Pi, on choisira un stage3 ARM ou ARM64.
Raspberry PI 3b, Raspberry PI 3b+, Raspberry PI Zero 2, Raspberry PI Zero 2 w, Raspberry PI 4b et Raspberry PI 5 sont compatibles ARM64

Sur notre machine, on devra avoir la commande git disponible !

-- Partitionnment du disque ou carte SD--

Si on opte pour un disque USB, il sera identifié par le Raspberry par /dev/sda
Si on opte pour une carte SD, elle sera identifiée par /dev/mmcblk0

Partitionner la carte SD ou le disque USB avec 2 partitions.
La table de partition peut être DOS ou GPT.
On fera 1 première partition en FAT32, le reste en ext4.

Le disque utilisé est /dev/sdh dans ce tuto :

Code BASH :

cfdisk /dev/sdh

Ce qui donne :

Code BASH :

                         Disk: /dev/sdh
    Size: 111,79 GiB, 120034123776 bytes, 234441648 sectors
               Label: dos, identifier: 0x4cd42d8e
    Device     Boot  Start       End   Sectors   Size Id Type
>>  /dev/sdh1  *      2048    616447    614400   300M  c W95 FAT
    /dev/sdh2       616448 234441647 233825200 111,5G 83 Linux
   [Bootable]  [ Delete ]  [ Resize ]  [  Quit  ]  [  Type  ]
   [  Help  ]  [  Write ]  [  Dump  ]

On formate la première en FAT32 :

Code BASH :

mkfs.vfat /dev/sdh1

On formate la seconde en EXT4 :

Code BASH :

mkfs.ext4 /dev/sdh2

On va monter notre futur système Gentoo dans /mnt/gentoo :

Code BASH :

mkdir /mnt/gentoo

On monte la parition root :

Code BASH :

mount /dev/sdh2 /mnt/gentoo

On montera /boot de Gentoo plus tard.

Installer les fichiers d'installation de Gentoo

Stage 3 : Le système

Le site de Gentoo propose les liens vers les "stage 3" de chaque architecture.

Se rendre dans la future racine de notre système :

Code BASH :

cd /mnt/gentoo

On récupérera le stage3 depuis le site de Gentoo : https://www.gentoo.org/downloads/

Pour aller plus vite, on pourra utiliser ce miroir allemand : https://ftp-stud.hs-esslingen.de/pub/Mirrors/gentoo/releases/arm64/autobuilds

Plusieurs stage3 sont à notre disposition :
- stage3-arm64-openrc : Stage 3 OpenRC (serveur)
- stage3-arm64-desktop-openrc : Stage 3 OpenRC (desktop) qui contient déjà des éléments si on veut installer Gentoo avec un interface graphique

Dans ce tutoriel, on partira sur stage3-arm64-openrc.

On télécharge avec wget :

Code BASH :

wget http://url-du-stage-3-selectionne.tar.xz

Extraire ensuite l'archive :

Code BASH :

tar xpvf stage3-*.tar.xz --xattrs-include='*.*' --numeric-owner

Installer les fichiers de la fondation Raspberry Pi

Avant toute chose, on va monter notre partition /boot :

Code BASH :

mount /dev/sdh1 /mnt/gentoo/boot

On va cloner plusieurs dépôts "git", on va se positionner dans /root de notre Gentoo pour travailler :

Code BASH :

cd /mnt/gentoo/root

On va récupérer le noyau Raspberry Pi et les micrologiciels :

Code BASH :

git clone --depth=1 https://github.com/raspberrypi/firmware

On copie les fichiers de boot dans le /boot de notre Gentoo :

Code BASH :

cp -a firmware/boot/* /mnt/gentoo/boot/

On copie les modules du noyau dans le /lib de notre Gentoo :

Code BASH :

cp -a firmware/modules /mnt/gentoo/lib/

Configuration

Quelques fichiers de configuration ont besoin d'être créés pour que notre Raspberry Pi puisse démarrer.

On revient à la racine :

Code BASH :

cd /mnt/gentoo

On va créer le fichier cmdline.txt qui va contenir les options pour démarrer notre système :

Code BASH :

nano /mnt/gentoo/boot/cmdline.txt

Le fichier ne doit contenir qu'une seule ligne :

Code BASH :

dwc_otg.lpm_enable=0 console=tty root=/dev/sda2 rootfstype=ext4 rootwait cma=256M@256M net.ifnames=0

root=/dev/sda2 car le SSD, une fois dans le Raspberry Pi sera identifié sda (premier disque)

Si on branche le disque sur un port USB 3.0, se référer à l'astuce suivante : https://www.linuxtricks.fr/wiki/raspberry-pi-4-regler-le-probleme-de-boot-sur-usb-3-io-error

On peut créer aussi le fichier config.txt :

Code BASH :

nano /mnt/gentoo/boot/config.txt

Code BASH :

# Si Raspberry Pi 3, indiquer qu'on est en 64 bits
arm_64bit=1
# Réduit les bords noirs, ajuste l'affichage écran.
disable_overscan=1
# Activer audio si nécessaire (charge snd_bcm2835)
dtparam=audio=on
# Activer le pilote DRM VC4 V3D
dtoverlay=vc4-kms-v3d

On va évidemment paramétrer le fichier /etc/fstab :

Code BASH :

nano /mnt/gentoo/etc/fstab

Voici un exemple pour monter / et /boot :

Code :


/dev/sda1       /boot   vfat    noatime,noauto,nodev,nosuid,noexec      0 0
/dev/sda2       /       ext4    noatime 0 0

Pas besoin de configurer le réseau de suite, le dhcp est actif sur l'interface réseau filaire.

On définira le nom d'hôte :

Code BASH :

nano /mnt/gentoo/etc/conf.d/hostname

Exemple :

Code :


hostname="gentoopi.linuxtricks.lan"

Définir le mot de passe root en éditant le fichier /etc/shadow :

Code BASH :

nano /mnt/gentoo/etc/shadow

Remplacer la ligne de root pour définir le mot de passe à raspberry :

Code :


root:$6$xxPVR/Td5iP$/7Asdgq0ux2sgNkklnndcG4g3493kUYfrrdenBXjxBxEsoLneJpDAwOyX/kkpFB4pU5dlhHEyN0SK4eh/WpmO0::0:99999:7:::

On définira l'agencement du clavier :

Code BASH :

nano /mnt/gentoo/etc/conf.d/keymaps

Et on mettra la disposition d'un clavier français :

Code :


keymap="fr"

On paramètrera la connexion en ssh.
Si on n'a pas de clé publique :

Code BASH :

nano /mnt/gentoo/etc/ssh/sshd_config

Et on définit la connexion par mot de passe pour root :

Code BASH :

#PermitRootLogin prohibit-password
PermitRootLogin yes

Ou alors on copie notre clé publique dans le fichier authorized_keys de root :

Code BASH :

mkdir /mnt/gentoo/root/.ssh

Code BASH :

nano /mnt/gentoo/root/.ssh/authorized_keys

Et on définit les bons droits :

Code BASH :

chmod 700 /mnt/gentoo/root/.ssh
chmod 600 /mnt/gentoo/root/.ssh/authorized_keys

On fait démarrer le service ssh au boot :

Code BASH :

cd /mnt/gentoo/etc/runlevels/default/

Code BASH :

ln -s /etc/init.d/sshd sshd

On démonte toutes les partitions :

Code BASH :

cd
umount -R /mnt/gentoo

Et on met le disque ou la carte SD dans le Raspberry Pi !

On se connecte en SSH et on peut continuer la configuration !

Configuration post-installation

Mot de passe root

On redéfinit le mot de passe root :
passwd

Ajouter des utilisateurs

On peut ajouter un utilisateur supplémentaire :

Code BASH :

useradd -m -G users,wheel,audio,video,portage -s /bin/bash adrien

Et on lui met un mot de passe :

Code BASH :

passwd adrien

Reparamétrer le serveur SSH

On peut également interdire de nouveau la connexion en tant que root par mot de passe à notre serveur SSH :

Code BASH :

nano /etc/ssh/sshd_config

Et on remet la valeur :

Code :


PermitRootLogin prohibit-password

On redémarre openssh pour prendre en compte cela :

Code BASH :

/etc/init.d/sshd restart

Configuration de l'horloge

On n'a pas d'horloge matérielle, on active donc un service d'horloge logicielle et on désactive hwclock :

Code BASH :

rc-update add swclock boot
rc-update del hwclock boot

On définit manuellement la date :

Code BASH :

date -s "YYYY-MM-DD HH:MM"

On peut supprimer l'archive stage3 pour faire de la place :

Code BASH :

rm /stage3*.tar.xz

Configuration make.conf

On peut paramétrer le fichier make.conf :

Code BASH :

nano -w /etc/portage/make.conf

Code BASH :

# USE flags globaux
USE=""
# Nombre de jobs pour compiler, 4 car 4CPU (vérifier avec la commande nproc) - Compter 2Go de RAM par job
MAKEOPTS="-j2" 
#Langue
L10N="fr"
# Pour ne pas avoir la compilation verbeuse
EMERGE_DEFAULT_OPTS="${EMERGE_DEFAULT_OPTS} --quiet-build=y" 
# Permet de pouvoir compiler sereinement lorsque gentoo est en prod
PORTAGE_SCHEDULING_POLICY="idle"

Initialiser portage

On va maintenant télécharger et extraire l'arbre de portage (la dernière version). C'est la liste de tous les logiciels disponibles sous Gentoo :

Code BASH :

emerge-webrsync

L'opération prend un petit peu de temps.

On peut éventuellemnt paramétrer des miroirs plus proches avec mirrorselect.
On installe d'abord l'outil :

Code BASH :

emerge -av1 app-portage/mirrorselect

Et on définit dans le make.conf un miroir proche :

Code BASH :

mirrorselect -i -o >> /etc/portage/make.conf

Configurer le profile

Ensuite, on va sélectionner son profil.

Lister les profils via :

Code BASH :

eselect profile list

Par défaut le profil sélectionné est celui avec une étoile et correspond à l'archive stage3 téléchargée précédemment.
Pour une archive OpenRC (non desktop), au moment de la mise à jour ce ce tuto :

Code :


  [15]  default/linux/arm64/23.0 (stable) *

Si on souhaite changer de profile, on peut en sélectionner un autre avec son numéro :

Code BASH :

eselect profile set XX

Problème des logiciels non-libres (Facultatif)

Si plus tard on ne veut pas s'embêter avec les licences et qu'on se fiche d'avoir des logiciels propriétaires (c'est mon cas) on autorise tout dans le fichier package.licence :

Code BASH :

mkdir /etc/portage/package.license

Copier vers le presse-papier

Code BASH :

echo "*/* *" >> /etc/portage/package.license/custom

Dépôts binaire (Facultatif)

Gentoo met à disposition des paquets binaires depuis décembre 2023.
Il semble y en avoir peu en ARM64 pour le moment.
Pour les configurer et les utiliser, consulter cet article : https://www.linuxtricks.fr/wiki/gentoo-parametrer-les-depots-binaires

Mise à jour du world

Une fois le profil sélectionné et le make.conf personnalisé, on peut faire une mise à jour du world avant de continuer :

Code BASH :

emerge -avuDN @world

Les paquets seront mis à jour et ceux dont les USE sont modifiés seront recompilés.

Locales

Les locales, ce sont la langue et l'encodage du système. Configurer tout cela pour du français :

Code BASH :

nano -w /etc/locale.gen

Mettre ceci pour du français compatible UTF-8 :

Code BASH :

fr_FR.UTF-8 UTF-8

On génère les locales :

Code BASH :

locale-gen

On liste ensuite les locales disponibles :

Code BASH :

eselect locale list

Et on sélectionne le Français :

Code BASH :

eselect locale set fr_FR.utf8

Configurer le fuseau horaire

Vu que nous sommes sur Paris en France, configurons ainsi le fuseau horaire :
echo "Europe/Paris" > /etc/timezone

Et on configure le paquet timezone-data :

Code BASH :

emerge --config sys-libs/timezone-data

Service NTP

Vu qu'on n'a pas d'horloge matérielle, il est important d'installer et configurer un serveur NTP :

Code BASH :

emerge -av net-misc/chrony

On démarre le service :

Code BASH :

/etc/init.d/chronyd start

On l'ajoute au démarrage de la machine :

Code BASH :

rc-update add chronyd default

Le fichier de config par défaut est suffisant juste pour le client NTP.

Outils et services de base (Facultatif)

Logs et Journalisation

On installe rsyslog et logrotate :

Code BASH :

emerge -av app-admin/rsyslog app-admin/logrotate

On démarre le service au boot :

Code BASH :

rc-update add rsyslog default

Planificateur de tâches

On installe cron :

Code BASH :

emerge -av sys-process/cronie

On démarre le service au boot :

Code BASH :

rc-update add cronie default

Quelques outils pratiques

Installons quelques outils pratiques autour de portage :

Code BASH :

emerge -av app-portage/gentoolkit app-portage/portage-utils  app-portage/eix

Quelques outils d'autocomplétion bash :

Code BASH :

emerge -av app-shells/bash-completion app-shells/gentoo-bashcomp

Quelques outils pratiques :

Code BASH :

emerge -av sys-process/htop app-misc/screen app-editors/vim

eix

On peut aussi installer eix pour la recherche rapide de paquets et d'autres outils agréables à utiliser :

Code BASH :

emerge -av app-portage/eix

On peut configurer la mise à jour de la base eix au même moment que emerge --sync
Pour cela, on peut créer un script qui appelle les commandes eix-associées après l'exécution de emerge --sync

Créer le dossier /etc/portage/postsync.d s'il n'existe pas

Code BASH :

mkdir /etc/portage/postsync.d

Créer un script :

Code BASH :

nano -w  /etc/portage/postsync.d/maj-eix

Voici ce que j'ai développé :

Code BASH :

#!/bin/bash
if [[ -e /var/cache/eix/portage.eix ]]
then
    rsync -ca /var/cache/eix/portage.eix /var/cache/eix/previous.eix
fi
eix-update
if [[ -e /var/cache/eix/previous.eix ]]
then
    eix-diff
fi

On rend le script exécutable évidemment :

Code BASH :

chmod +x /etc/portage/postsync.d/maj-eix

Le prochain emerge --sync appellera ce script automatiquement pour exécuter les commandes adéquates