Installer Gentoo facilement (Systemd)
Table des matières
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.
Gentoo utilise le gestionnaire de paquets Portage.
Ce tutoriel traite de l'installation avec systemd.
Pour installer Gentoo avec son système d'initialisation OpenRC : https://www.linuxtricks.fr/wiki/installer-gentoo-facilement-openrc
Dans un premier temps, il est nécessaire de télécharger le CD d'installation. Prendre l'iso disponible ici :
Vérifier que la machine dispose du réseau, surtout d'Internet.
Disposer d'une deuxième machine avec un client SSH est un plus (le copier coller sera plus facile)
Graver sur une clé USB l'image ISO avec la méthode que vous utilisez habituellement.
Sur l'invite de commande boot: valider en appuyant sur Entrée.
Le Live CD charge les modules et démarre.
On est invité à sélectionner la disposition du clavier. Pour le français, saisir 18 (fr).
Le chargement est terminé lorsque le prompt livecd ~ # s'affiche.
Si le clavier n'est pas en français :
On vérifie que nous disposons bien d'une IP :
Si besoin, demander une IP à notre serveur DHCP :
Dans le cas d'une interface wi-fi, on pourra utiliser l'outil semi-graphique
On teste la connexion à internet (Ctrl+C pour annuler) :
On démarre le service ssh :
Et on initialise le mot de passe root :
On se connecte depuis un autre PC sur notre Gentoo :
Ce sera plus facile pour faire du copier/coller.
Il existe plusieurs manières de partitionner son disque, avec des outils différents.
On va utiliser cfdisk, il est plus "facile" à utiliser que fdisk.
Si le disque est vierge et qu'on doit sélectionner un label (Table de partition) :
- En UEFI : Sélectionner gpt
- En BIOS : Sélectionner dos
Partitionner à sa guise, dans ce tutoriel, on va faire :
Avec cfdisk, créer les partitions :
On formate les partitions :
On monte la partition racine dans/mnt/gentoo :
Dans le cas UEFI, monter aussi la partition FAT32 dans /boot/EFI.
Si vous avez une partition /boot séparée, montez-la d'abord !
On créé les points de montage des autres partitions et on monte celles-ci dans leurs dossiers respectifs (exemple avec /home sur /dev/sda3)
Je vais créer mon fichier swap de 2Go et on positionne les bons droits :
On formate le swap :
On active le swap :
Pour un exemple LVM on va faire :
Avec cfdisk, créer les partitions :
On formate les partitions :
On créé la partie LVM :
On formate la partie LVM :
On monte le volume logique racine dans/mnt/gentoo :
On monte créé le dossier boot et on monte la partition boot :
Dans le cas UEFI, monter aussi la partition FAT32 dans /boot/EFI.
On créé les points de montage des autres volumes logiques et on monte ceux-ci dans leurs dossiers respectifs :
On active le swap :
Le site de Gentoo propose les liens vers les "stage 3" de chaque architecture. Prendre celle qui convient le mieux.
Se rendre dans la future racine de notre système :
On récupérera le stage3 depuis le site de Gentoo : https://www.gentoo.org/downloads/
Plusieurs stage3 sont à notre disposition :
- stage3-amd64-systemd : Stage 3 systemd (serveur)
- stage3-amd64-desktop-systemd : Stage 3 systemd (desktop) qui contient déjà des éléments si on veut installer Gentoo avec un interface graphique
Dans ce tutoriel, on partira surstage3-amd64-systemd.
On télécharge avec wget :
Extraire ensuite l'archive :
On édite le fichier make.conf pour lui ajouter quelques options supplémentaires.
Le fichier /etc/portage/make.conf est le fichier de configuration dans lequel on va définir les variables de notre future installation (nombre de coeurs, carte vidéo, périphériques d'entrée, langue, choix des variables d'utilisation, etc... )
On peut d'abord vérifier que les variables concernant la compilation sont :
On peut affiner plus l'optimisation de GCC, plus d'infos ici suivant le matériel : https://wiki.gentoo.org/wiki/Safe_CFLAGS
Voici un exemple de variables à définir (adaptez suivant les commentaires) :
Si notre gentoo est installée en LVM, on active de manière globale le USE lvm dans notre fichier make.conf :
On sélectionne un miroir proche qu'on ajoute dans le make.conf :
Dans un premier temps, on se copie le fichier de résolution de noms DNS dans la future arborescence :
On monte ensuite les pseudo systèmes de fichiers proc et dev et sys dans /mnt/gentoo :
On change l’environnement du live pour basculer vers l'environnement final. Pour cela on chroot le système :
On met à jour des variables d'environnement :
Pour ne pas s’emmêler les pinceaux, on peut ajouter un repère à notre prompt pour bien distinguer que l'on est en chroot :
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 :
L'opération prend un petit peu de temps.
Ensuite, on va sélectionner son profil.
Lister les profils via :
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 Systemd (non desktop), au moment de la mise à jour ce ce tuto :
Si on souhaite changer de profile, on peut en sélectionner un autre avec son numéro :
Il est nécessaire d'avoir initialisé un ID pour sa machine (nécessaire pour systemd-networkd entre autres) :
On peut également "améliorer" la compilation en mentionnant les FLAGS que le CPU sait traiter.
Bien que la variable s'appelle CPU_FLAGS_X86, elle concerne le 32 bits (x86) et 64 bits (amd64) .
Installer app-portage/cpuid2cpuflags :
Exécuter la commande :
Chez moi elle renvoie :
Ajouter la variable dans le make.conf CPU_FLAGS_X86 et les flags utilisables par votre CPU, ce qui fait chez moi :
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 :
Gentoo met à disposition des paquets binaires depuis décembre 2023.
Pour les configurer et les utiliser, consulter cet article : https://www.linuxtricks.fr/wiki/gentoo-parametrer-les-depots-binaires
Une fois le profil sélectionné et le make.conf personnalisé, on peut faire une mise à jour du world avant de continuer :
Les paquets seront mis à jour et ceux dont les USE sont modifiés seront recompilés.
Editer le fichier fstab pour renseigner les partitions et leur point de montage :
Exemple :
Editer le fichier fstab pour renseigner les partitions et leur point de montage :
Exemple :
Définir la variable GRUB_PLATFORMS dans le fichier make.conf :
Ensuite, on installe grub2 :
Une fois grub installé, on l'installe sur MBR du disque système :
Spécifier dans la configuration de GRUB qu'on utilise systemd.
Editer le fichier de configuration :
Décommenter et modifier la ligne suivante :
La configuration sera générée avec installkernel (paragraphe suivant)
Définir la variable GRUB_PLATFORMS dans le fichier make.conf :
Ensuite, on installe grub2 :
Une fois grub installé, on installe les fichiers dans la partition EFI :
Spécifier dans la configuration de GRUB qu'on utilise systemd.
Editer le fichier de configuration :
Décommenter et modifier la ligne suivante :
La configuration sera générée avec installkernel (paragraphe suivant)
Grâce à installkernel, au moment de l'installation du kernel, l'initrd sera automatiquement créé et la configuration de grub générée.
Cet outil est bian pratique. Sans lui, le kernel sera installé dans /boot avec un nom qui ne sera pas détecté par GRUB. De plus, il est hautement recommandé par Gentoo.
On active les USE dracut et grub :
On install ensuite l'outil :
On installe le paquet lvm2
On démarre le service lvm et on l'ajoute au boot :
Il est nécessaire de générer un initramfs. Sans cela, le système ne démarrera pas. (on verra plus bas).
On peut aussi installer linux-firmware, si on a du matériel spécifique (dans tous les cas, ça ne mange pas de pain) :
Installer les sources du noyau :
On peut aussi installer les paquets pciutils et usbutils contenant les outils lspci et lsusb :
On créé le lien symbolique /usr/src/linux. D'abord on liste les kernels :
La réponse au moment de l'édition du tuto :
On sélectionne le noyau :
On se rend dans les sources :
On nettoie les sources :
Pour partir sur un noyau minimaliste, on pourra générer une configuration basique :
On règle les options du noyau :
Sauvegarder le fichier .config.
On compile le noyau (mettez comme valeur à "j" le nombre de CPU, retourné par la commande nproc) :
On installe les modules :
Puis on installe le noyau :
On marque dracut installé manuellement, c'est plus sûr (même si c'est une dépendance de installkernel) :
Si on ne veut pas s'embêter à compiler le noyau, on peut installer un kernel Gentoo précompilé avec les patchs de Gentoo.
Le initramFS sera généré automatiquement.
Pour cela, on installera simplement le paquet gentoo-kernel-bin :
Et voilà !
On pourra par la suite compiler le noyau avec sa propre configuration comme illustré dans le cas 1 juste au dessus.
A noter que si on veut regénérer le initramfs, on pourra utiliser la commande :
Avec systemd, on a à notre disposition systemd-networkd.
Si on veut utiliser les IP fixe, il faut configurer une unité network :
Insérer la configuration minimale pour une connexion filaire (adaptez le nom de l'interface) :
Et on active au boot le service systemd :
Si on veut récupérer automatiquement une adresse IP, il faut configurer une unité network :
Insérer la configuration minimale pour une connexion filaire :
Et on active au boot le service systemd :
N'oublions pas le plus important, le mot de passe root !
N'oublions pas de lancer le service SSH au boot, s'il s'agit d'un serveur :
On pourra configurer à notre guise le serveur SSH en éditant le fichier de config :
On ne va pas se promener sur notre nouveau système en root non ?
Pour cela, il faut ajouter un utilisateur au moins :
Voici une brève descriptions des groupes plutôt utiles :
Exemple :
Ne pas oublier d'initialiser le mot de passe via la commande passwd à notre utilisateur créé.
Exemple :
GRUB est nécessaire par l'outil installkernel que nous avons installé précédemment.
Il est donc installé à ce stade.
Vérifier que la configuration de GRUB ait bien été générée :
Si ce n'est pas le cas, regénérer la configuration :
On sort du chroot :
On supprime les fichiers précédemment téléchargés :
On revient à la racine du live et on démonte tout ce dont on a plus besoin :
On reboot :
On enlève le live USB.
Une fois redémarré sur le système de base maintenant booté avec systemd, on va pouvoir paramétrer les locales, le nom d'hôte etc avec les commandes systemd.
Ce n'est pas possible depuis le live en chroot.
Les locales, c'est la langue du système et son encodage.
Par défaut, sans configuration, la commande localectl indique :
Définir en français la locale, on va générer les locales :
Mettre ceci pour du français compatible UTF-8
On génère les locales :
Ensuite, on les définit avec systemd, le clavier de la console et de l'interface graphique (pour plus tard, ça sera fait) :
Vérifier la bonne prise en compte :
Qui renvoie :
Vu que nous sommes sur Paris en France, configurons ainsi le fuseau horaire :
On vérifie avec timedatectl la bonne prise en compte :
Qui renvoie chez moi pour ce tuto :
Configurer le nom d'hôte de la machine. Par défaut le nom est Gentoo, pour le personnaliser on utilisera la commande hostnamectl :
On vérifie avec localectl la bonne prise en compte :
Qui renvoie chez moi pour ce tuto :
On peut aussi configurer à notre guise le fichier hosts :
Exemple :
Par défaut, systemd-journald est déjà installé et activé, nous n'avons rien à faire.
Il est inutile d'installer rsyslog et logrotate.
Par défaut, systemd fournit les timers pour planifier des tâches.
Cependant, on pourra installer cron :
On démarre le service au boot :
Systemd fournit la synchronisation NTP nativement avec systemd-timesyncd mais qui n'est pas activé.
On va donc le paramétrer au lieu d'utiliser un outil annexe comme chrony pour synchroniser l'horloge automatiquement via le réseau :
On vérifie que le service est fonctionnel :
Qui renvoie :
Installons quelques outils pratiques autour de portage :
Quelques outils d'autocomplétion bash :
Quelques outils pratiques :
Si on a installé eix, on peut configurer la mise à jour de la base 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 :
On rend le script exécutable évidemment :
eselect-repository permet d'ajouter des "overlays" c'est à dire des dépôts complémentaires. Je le trouve plus utile sur un PC que sur un serveur.
Installer eselect-repository :
Lister les overlays :
Activer un overlay :
Désactiver un overlay :
Ajouter un overlay non listé (non officiel) :
Exemple avec mon overlay :
Et voila, c'est terminé
Si on veut installer un environnement de bureau, retrouvez la suite dans un second article ici : https://www.linuxtricks.fr/wiki/installer-gentoo-facilement-environnement-de-bureau-systemd
- Introduction
- Avant installation
- Partitionnement
- Installer les fichiers d'installation de Gentoo
- Configuration essentielle avant le chroot
- Installer le système de base
- Copie des informations DNS
- Montage et chroot
- Portage
- Configurer le profile
- Créer le machine-id
- Optimisation de la compilation (Facultatif)
- Problème des logiciels non-libres (Facultatif)
- Dépôts binaire (Facultatif)
- Mise à jour du world
- Fichier fstab
- Installer le chargeur d'amorçage
- Cas UEFI
- Configurer le kernel
- Configuration du réseau
- Définir un mot de passe root
- Configuration finale
- Finalisation de l'installation du système
- Configuration des services systemd de base
- Derniers réglages
- Installer un environnement de bureau
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.
Gentoo utilise le gestionnaire de paquets Portage.
Ce tutoriel traite de l'installation avec systemd.
Pour installer Gentoo avec son système d'initialisation OpenRC : https://www.linuxtricks.fr/wiki/installer-gentoo-facilement-openrc
Avant installation
Obtenir le média d'installation
Dans un premier temps, il est nécessaire de télécharger le CD d'installation. Prendre l'iso disponible ici :
- Gentoo 64bits : http://distfiles.gentoo.org/releases/amd64/autobuilds/ ou chez Esslingen http://ftp-stud.hs-esslingen.de/pub/Mirrors/gentoo/releases/amd64/autobuilds/
- Gentoo toutes architectures : Se rendre directement sur la page officielle de Gentoo et choisir la bonne ISO https://www.gentoo.org/downloads/
Prérequis
Vérifier que la machine dispose du réseau, surtout d'Internet.
Disposer d'une deuxième machine avec un client SSH est un plus (le copier coller sera plus facile)
Préparer l'installation
Graver sur une clé USB l'image ISO avec la méthode que vous utilisez habituellement.
Sur l'invite de commande boot: valider en appuyant sur Entrée.
Le Live CD charge les modules et démarre.
On est invité à sélectionner la disposition du clavier. Pour le français, saisir 18 (fr).
Le chargement est terminé lorsque le prompt livecd ~ # s'affiche.
Si le clavier n'est pas en français :
Code BASH :
loadkeys fr
On vérifie que nous disposons bien d'une IP :
Code BASH :
ip a
Si besoin, demander une IP à notre serveur DHCP :
Code BASH :
dhcpcd
Dans le cas d'une interface wi-fi, on pourra utiliser l'outil semi-graphique
Code BASH :
net-setup
On teste la connexion à internet (Ctrl+C pour annuler) :
Code BASH :
ping -c2 linuxtricks.fr
Configurer l'accès distant ssh
Sur la machine locale
On démarre le service ssh :
Code BASH :
/etc/init.d/sshd start
Et on initialise le mot de passe root :
Code BASH :
passwd
Sur la machine distante
On se connecte depuis un autre PC sur notre Gentoo :
Code BASH :
ssh root@Ip_machine
Ce sera plus facile pour faire du copier/coller.
Partitionnement
Préparer le disque
Il existe plusieurs manières de partitionner son disque, avec des outils différents.
On va utiliser cfdisk, il est plus "facile" à utiliser que fdisk.
Code BASH :
cfdisk
Si le disque est vierge et qu'on doit sélectionner un label (Table de partition) :
- En UEFI : Sélectionner gpt
- En BIOS : Sélectionner dos
Exemple partitionnement simple
Partitionner à sa guise, dans ce tutoriel, on va faire :
- une partition EFI de 100Mo
- une partition racine de 70Go
- une partition /home du reste
- un fichier de 2Go pour le swap : /swap
Avec cfdisk, créer les partitions :
Code BASH :
Disk: /dev/sda Size: 238.47 GiB, 256060514304 bytes, 500118192 sectors Label: gpt, identifier: 39E9351F-D279-E74C-B075-EB2017B341BE Device Start End Sectors Size Type >> /dev/sda1 2048 206847 204800 100M EFI System /dev/sda2 206848 147007487 146800640 70G Linux filesystem /dev/sda3 147007488 500117503 353110016 168.4G Linux filesystem [ Delete ] [ Resize ] [ Quit ] [ Type ] [ Help ] [ Write ] [ Dump ]
On formate les partitions :
Code BASH :
mkfs.fat -F32 /dev/sda1
Code BASH :
mkfs.ext4 /dev/sda2
Code BASH :
mkfs.ext4 /dev/sda3
On monte la partition racine dans/mnt/gentoo :
Code BASH :
mount /dev/sda2 /mnt/gentoo
Dans le cas UEFI, monter aussi la partition FAT32 dans /boot/EFI.
Si vous avez une partition /boot séparée, montez-la d'abord !
Code BASH :
mkdir -p /mnt/gentoo/boot/EFI
Code BASH :
mount /dev/sda1 /mnt/gentoo/boot/EFI
On créé les points de montage des autres partitions et on monte celles-ci dans leurs dossiers respectifs (exemple avec /home sur /dev/sda3)
Code BASH :
mkdir -p /mnt/gentoo/home mount /dev/sda3 /mnt/gentoo/home
Je vais créer mon fichier swap de 2Go et on positionne les bons droits :
Code BASH :
dd if=/dev/zero of=/mnt/gentoo/swap bs=1G count=2 chmod 600 /mnt/gentoo/swap
On formate le swap :
Code BASH :
mkswap /mnt/gentoo/swap
On active le swap :
Code BASH :
swapon /mnt/gentoo/swap
Exemple partitionnement LVM
Pour un exemple LVM on va faire :
- une partition EFI de 100Mo
- une partition boot de 1Go
- un volume physique (le reste du disque)
- un volume group rootvg
- un volume logique rootlv pour la racine de 50G
- un volume logique swaplv de 2G
- un volume logique homelv du reste
Avec cfdisk, créer les partitions :
Code :
Disk: /dev/sda
Size: 128 GiB, 137438953472 bytes, 268435456 sectors
Label: gpt, identifier: 2798A895-B765-44C4-8AFE-D985D3A5D7CE
Device Start End Sectors Size Type
>> /dev/sda1 2048 206847 204800 100M EFI System
/dev/sda2 206848 2303999 2097152 1G Linux filesystem
/dev/sda3 2304000 268433407 266129408 126.9G Linux LVM
[ Delete ] [ Resize ] [ Quit ] [ Type ] [ Help ] [ Write ]
[ Dump ]
On formate les partitions :
Code BASH :
mkfs.fat -F32 /dev/sda1
Code BASH :
mkfs.ext4 /dev/sda2
On créé la partie LVM :
Code BASH :
pvcreate /dev/sda3
Code BASH :
vgcreate rootvg /dev/sda3
Code BASH :
lvcreate -n rootlv -L 50G rootvg
Code BASH :
lvcreate -n swaplv -L 2G rootvg
Code BASH :
lvcreate -n homelv -l +100%FREE rootvg
On formate la partie LVM :
Code BASH :
mkfs.ext4 /dev/rootvg/rootlv
Code BASH :
mkfs.ext4 /dev/rootvg/homelv
Code BASH :
mkswap /dev/rootvg/swaplv
On monte le volume logique racine dans/mnt/gentoo :
Code BASH :
mount /dev/rootvg/rootlv /mnt/gentoo
On monte créé le dossier boot et on monte la partition boot :
Code BASH :
mkdir /mnt/gentoo/boot
Code BASH :
mount /dev/sda2 /mnt/gentoo/boot
Dans le cas UEFI, monter aussi la partition FAT32 dans /boot/EFI.
Code BASH :
mkdir /mnt/gentoo/boot/EFI
Code BASH :
mount /dev/sda1 /mnt/gentoo/boot/EFI
On créé les points de montage des autres volumes logiques et on monte ceux-ci dans leurs dossiers respectifs :
Code BASH :
mkdir /mnt/gentoo/home
Code BASH :
mount /dev/rootvg/homelv /mnt/gentoo/home
On active le swap :
Code BASH :
swapon /dev/rootvg/swaplv
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. Prendre celle qui convient le mieux.
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/
Plusieurs stage3 sont à notre disposition :
- stage3-amd64-systemd : Stage 3 systemd (serveur)
- stage3-amd64-desktop-systemd : Stage 3 systemd (desktop) qui contient déjà des éléments si on veut installer Gentoo avec un interface graphique
Dans ce tutoriel, on partira surstage3-amd64-systemd.
On télécharge avec wget :
Code BASH :
wget http://url-du-stage-3-selectionne.tar.xz
Extraire ensuite l'archive :
Code BASH :
tar xvpf stage3-*.tar.xz --xattrs-include='*.*' --numeric-owner
Configuration essentielle avant le chroot
Configuration du fichier make.conf
On édite le fichier make.conf pour lui ajouter quelques options supplémentaires.
Le fichier /etc/portage/make.conf est le fichier de configuration dans lequel on va définir les variables de notre future installation (nombre de coeurs, carte vidéo, périphériques d'entrée, langue, choix des variables d'utilisation, etc... )
Code BASH :
nano -w /mnt/gentoo/etc/portage/make.conf
On peut d'abord vérifier que les variables concernant la compilation sont :
Code BASH :
COMMON_FLAGS="-O2 -pipe -march=native" CFLAGS="${COMMON_FLAGS}" CXXFLAGS="${COMMON_FLAGS}"
On peut affiner plus l'optimisation de GCC, plus d'infos ici suivant le matériel : https://wiki.gentoo.org/wiki/Safe_CFLAGS
Voici un exemple de variables à définir (adaptez suivant les commentaires) :
Code BASH :
# USE flags globaux USE="" # Nombre de jobs pour compiler, 12 car 12CPU (vérifier avec la commande nproc) - Compter 2Go de RAM par job MAKEOPTS="-j12" #Langue (anciennement) LINGUAS="fr" #Langue L10N="fr" #Cartes graphiques, choisir les cartes adéquats. Garder fbdev (framebuffer) et vesa (générique) VIDEO_CARDS="fbdev vesa intel i915 nvidia nouveau radeon amdgpu radeonsi virtualbox vmware qxl" # Périphériques d'entrées utilisés (clavier souris + si affinités) INPUT_DEVICES="libinput synaptics keyboard mouse joystick wacom" # 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"
Si notre gentoo est installée en LVM, on active de manière globale le USE lvm dans notre fichier make.conf :
Code BASH :
USE="lvm"
Sélection des miroirs
On sélectionne un miroir proche qu'on ajoute dans le make.conf :
Code BASH :
mirrorselect -i -o >> /mnt/gentoo/etc/portage/make.conf
Installer le système de base
Copie des informations DNS
Dans un premier temps, on se copie le fichier de résolution de noms DNS dans la future arborescence :
Code BASH :
cp -L /etc/resolv.conf /mnt/gentoo/etc/
Montage et chroot
On monte ensuite les pseudo systèmes de fichiers proc et dev et sys dans /mnt/gentoo :
Code BASH :
mount -t proc /proc /mnt/gentoo/proc mount --rbind /dev /mnt/gentoo/dev mount --rbind /sys /mnt/gentoo/sys
On change l’environnement du live pour basculer vers l'environnement final. Pour cela on chroot le système :
Code BASH :
chroot /mnt/gentoo /bin/bash
On met à jour des variables d'environnement :
Code BASH :
env-update && source /etc/profile
Pour ne pas s’emmêler les pinceaux, on peut ajouter un repère à notre prompt pour bien distinguer que l'on est en chroot :
Code BASH :
export PS1="[chroot] $PS1"
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.
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 Systemd (non desktop), au moment de la mise à jour ce ce tuto :
Code TEXT :
[22] default/linux/amd64/23.0/systemd (stable) *
Si on souhaite changer de profile, on peut en sélectionner un autre avec son numéro :
Code BASH :
eselect profile set XX
Créer le machine-id
Il est nécessaire d'avoir initialisé un ID pour sa machine (nécessaire pour systemd-networkd entre autres) :
Code BASH :
systemd-machine-id-setup
Optimisation de la compilation (Facultatif)
On peut également "améliorer" la compilation en mentionnant les FLAGS que le CPU sait traiter.
Bien que la variable s'appelle CPU_FLAGS_X86, elle concerne le 32 bits (x86) et 64 bits (amd64) .
Installer app-portage/cpuid2cpuflags :
Code BASH :
emerge -av app-portage/cpuid2cpuflags
Exécuter la commande :
Code BASH :
cpuid2cpuflags
Chez moi elle renvoie :
Code :
CPU_FLAGS_X86: aes avx avx2 f16c fma3 mmx mmxext pclmul popcnt rdrand sha sse sse2 sse3 sse4_1 sse4_2 sse4a ssse3
Ajouter la variable dans le make.conf CPU_FLAGS_X86 et les flags utilisables par votre CPU, ce qui fait chez moi :
Code :
CPU_FLAGS_X86="aes avx avx2 f16c fma3 mmx mmxext pclmul popcnt rdrand sha sse sse2 sse3 sse4_1 sse4_2 sse4a ssse3"
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
Code BASH :
echo "*/* *" >> /etc/portage/package.license/custom
Dépôts binaire (Facultatif)
Gentoo met à disposition des paquets binaires depuis décembre 2023.
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.
Fichier fstab
Exemple partitionnement standard
Editer le fichier fstab pour renseigner les partitions et leur point de montage :
Code BASH :
nano -w /etc/fstab
Exemple :
Code :
/dev/sda2 / ext4 defaults,noatime 0 1
/dev/sda3 /home ext4 defaults,noatime 0 2
/swap none swap sw 0 0
/dev/sda1 /boot/EFI vfat defaults 0 0
Exemple partitionnement LVM
Editer le fichier fstab pour renseigner les partitions et leur point de montage :
Code BASH :
nano -w /etc/fstab
Exemple :
Code :
/dev/sda2 /boot ext4 defaults,noatime 0 2
/dev/sda1 /boot/EFI vfat defaults 0 0
/dev/rootvg/rootlv / ext4 defaults,noatime 0 1
/dev/rootvg/homelv /home ext4 defaults,noatime 0 2
/dev/rootvg/swaplv none swap sw 0 0
Installer le chargeur d'amorçage
Cas BIOS
Définir la variable GRUB_PLATFORMS dans le fichier make.conf :
Code BASH :
nano -w /etc/portage/make.conf
Code TEXT :
GRUB_PLATFORMS="pc"
Ensuite, on installe grub2 :
Code BASH :
emerge -av sys-boot/grub
Une fois grub installé, on l'installe sur MBR du disque système :
Code BASH :
grub-install /dev/sda
Spécifier dans la configuration de GRUB qu'on utilise systemd.
Editer le fichier de configuration :
Code BASH :
nano -w /etc/default/grub
Décommenter et modifier la ligne suivante :
Code BASH :
GRUB_CMDLINE_LINUX="init=/lib/systemd/systemd"
La configuration sera générée avec installkernel (paragraphe suivant)
Cas UEFI
Définir la variable GRUB_PLATFORMS dans le fichier make.conf :
Code BASH :
nano -w /etc/portage/make.conf
Code TEXT :
GRUB_PLATFORMS="efi-64"
Ensuite, on installe grub2 :
Code BASH :
emerge -av sys-boot/grub
Une fois grub installé, on installe les fichiers dans la partition EFI :
Code BASH :
grub-install --target=x86_64-efi --efi-directory=/boot/EFI
Spécifier dans la configuration de GRUB qu'on utilise systemd.
Editer le fichier de configuration :
Code BASH :
nano -w /etc/default/grub
Décommenter et modifier la ligne suivante :
Code BASH :
GRUB_CMDLINE_LINUX="init=/lib/systemd/systemd"
La configuration sera générée avec installkernel (paragraphe suivant)
Configurer le kernel
installkernel
Grâce à installkernel, au moment de l'installation du kernel, l'initrd sera automatiquement créé et la configuration de grub générée.
Cet outil est bian pratique. Sans lui, le kernel sera installé dans /boot avec un nom qui ne sera pas détecté par GRUB. De plus, il est hautement recommandé par Gentoo.
On active les USE dracut et grub :
Code BASH :
echo "sys-kernel/installkernel dracut grub" >> /etc/portage/package.use/installkernel
On install ensuite l'outil :
Code BASH :
emerge -av sys-kernel/installkernel
LVM (Si concerné)
On installe le paquet lvm2
Code BASH :
emerge -av lvm2
On démarre le service lvm et on l'ajoute au boot :
Code BASH :
systemctl enable lvm2-monitor.service
Il est nécessaire de générer un initramfs. Sans cela, le système ne démarrera pas. (on verra plus bas).
linux-firmware
On peut aussi installer linux-firmware, si on a du matériel spécifique (dans tous les cas, ça ne mange pas de pain) :
Code BASH :
emerge -av sys-kernel/linux-firmware
Cas 1 Installer les sources et les compiler manuellement
Installer les sources du noyau :
Code BASH :
emerge -av sys-kernel/gentoo-sources
On peut aussi installer les paquets pciutils et usbutils contenant les outils lspci et lsusb :
Code BASH :
emerge -av sys-apps/pciutils sys-apps/usbutils
On créé le lien symbolique /usr/src/linux. D'abord on liste les kernels :
Code BASH :
eselect kernel list
La réponse au moment de l'édition du tuto :
Code :
Available kernel symlink targets:
[1] linux-6.6.47-gentoo
On sélectionne le noyau :
Code BASH :
eselect kernel set 1
On se rend dans les sources :
Code BASH :
cd /usr/src/linux
On nettoie les sources :
Code BASH :
make mrproper
Pour partir sur un noyau minimaliste, on pourra générer une configuration basique :
Code BASH :
make defconfig
On règle les options du noyau :
Code BASH :
make menuconfig
Sauvegarder le fichier .config.
On compile le noyau (mettez comme valeur à "j" le nombre de CPU, retourné par la commande nproc) :
Code BASH :
make -j12
On installe les modules :
Code BASH :
make modules_install
Puis on installe le noyau :
Code BASH :
make install
On marque dracut installé manuellement, c'est plus sûr (même si c'est une dépendance de installkernel) :
Code BASH :
emerge --noreplace sys-kernel/dracut
Cas 2 Installer un noyau binaire
Si on ne veut pas s'embêter à compiler le noyau, on peut installer un kernel Gentoo précompilé avec les patchs de Gentoo.
Le initramFS sera généré automatiquement.
Pour cela, on installera simplement le paquet gentoo-kernel-bin :
Code BASH :
emerge -av sys-kernel/gentoo-kernel-bin
Et voilà !
On pourra par la suite compiler le noyau avec sa propre configuration comme illustré dans le cas 1 juste au dessus.
A noter que si on veut regénérer le initramfs, on pourra utiliser la commande :
Code BASH :
emerge --config sys-kernel/gentoo-kernel-bin
Configuration du réseau
Avec systemd, on a à notre disposition systemd-networkd.
IP Fixe
Si on veut utiliser les IP fixe, il faut configurer une unité network :
Code BASH :
nano -w /etc/systemd/network/50-static.network
Insérer la configuration minimale pour une connexion filaire (adaptez le nom de l'interface) :
Code :
[Match]
Name=enp4s0
[Network]
Address=192.168.21.203/24
Gateway=192.168.21.254
DNS=192.168.21.251
Et on active au boot le service systemd :
Code BASH :
systemctl enable systemd-networkd.service
IP Dynamique
Si on veut récupérer automatiquement une adresse IP, il faut configurer une unité network :
Code BASH :
nano -w /etc/systemd/network/50-dhcp.network
Insérer la configuration minimale pour une connexion filaire :
Code :
[Match]
Name=en*
[Network]
DHCP=yes
Et on active au boot le service systemd :
Code BASH :
systemctl enable systemd-networkd.service
Définir un mot de passe root
N'oublions pas le plus important, le mot de passe root !
Code BASH :
passwd
Configuration finale
Service SSH
N'oublions pas de lancer le service SSH au boot, s'il s'agit d'un serveur :
Code BASH :
systemctl enable sshd.service
On pourra configurer à notre guise le serveur SSH en éditant le fichier de config :
Code BASH :
nano -w /etc/ssh/sshd_config
Ajout d'utilisateurs
On ne va pas se promener sur notre nouveau système en root non ?
Pour cela, il faut ajouter un utilisateur au moins :
Code BASH :
useradd -m -G users,groupe1,group2,group3 -s /bin/bash nom_user
Voici une brève descriptions des groupes plutôt utiles :
- audio : accès autorisé aux périphériques audio
- cdrom : accès direct autorisé aux lecteurs optiques
- portage : permet d'utiliser emerge --pretend
- plugdev : permet de monter de périphériques à chaud et de les utiliser, par exemple des appareils photos : numériques ou des clés USB
- video : accès autorisé au matériel de capture vidéo et à l'accélération matérielle
- wheel : commande su utilisable
Exemple :
Code BASH :
useradd -m -G users,wheel,audio,cdrom,video,portage -s /bin/bash adrien
Ne pas oublier d'initialiser le mot de passe via la commande passwd à notre utilisateur créé.
Exemple :
Code BASH :
passwd adrien
Générer la configuration de GRUB
GRUB est nécessaire par l'outil installkernel que nous avons installé précédemment.
Il est donc installé à ce stade.
Vérifier que la configuration de GRUB ait bien été générée :
Code BASH :
ls -l /boot/grub/grub.cfg
Si ce n'est pas le cas, regénérer la configuration :
Code BASH :
grub-mkconfig -o /boot/grub/grub.cfg
Finalisation de l'installation du système
Préparation au redémarrage
On sort du chroot :
Code BASH :
exit
On supprime les fichiers précédemment téléchargés :
Code BASH :
rm -f /mnt/gentoo/*.tar.xz
On revient à la racine du live et on démonte tout ce dont on a plus besoin :
Code BASH :
cd /
Code BASH :
umount -R /mnt/gentoo
On reboot :
Code BASH :
reboot
On enlève le live USB.
Configuration des services systemd de base
Une fois redémarré sur le système de base maintenant booté avec systemd, on va pouvoir paramétrer les locales, le nom d'hôte etc avec les commandes systemd.
Ce n'est pas possible depuis le live en chroot.
Locales
Les locales, c'est la langue du système et son encodage.
Par défaut, sans configuration, la commande localectl indique :
Code TEXT :
System Locale: LANG=C.UTF8 VC Keymap: (unset) X11 Layout: (unset)
Définir en français la locale, on va générer les locales :
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
Ensuite, on les définit avec systemd, le clavier de la console et de l'interface graphique (pour plus tard, ça sera fait) :
Code BASH :
localectl set-locale fr_FR.UTF-8
localectl set-keymap fr
localectl set-x11-keymap fr
Vérifier la bonne prise en compte :
Code BASH :
localectl
Qui renvoie :
Code TEXT :
System Locale: LANG=fr_FR.UTF-8 VC Keymap: fr X11 Layout: fr
Configurer le fuseau horaire
Vu que nous sommes sur Paris en France, configurons ainsi le fuseau horaire :
Code BASH :
timedatectl set-timezone Europe/Paris
On vérifie avec timedatectl la bonne prise en compte :
Code BASH :
timedatectl
Qui renvoie chez moi pour ce tuto :
Code TEXT :
Local time: jeu. 2023-07-06 19:07:07 CEST Universal time: jeu. 2023-07-06 17:07:07 UTC RTC time: jeu. 2023-07-06 17:07:07 Time zone: Europe/Paris (CEST, +0200) System clock synchronized: no NTP service: inactive RTC in local TZ: no
Définir le nom d'hôte
Configurer le nom d'hôte de la machine. Par défaut le nom est Gentoo, pour le personnaliser on utilisera la commande hostnamectl :
Code BASH :
hostnamectl set-hostname gentoolinuxtricks
On vérifie avec localectl la bonne prise en compte :
Code BASH :
hostnamectl
Qui renvoie chez moi pour ce tuto :
Code TEXT :
Static hostname: gentoolinuxtricks Icon name: computer-laptop Chassis: laptop Machine ID: b3802f9056374b6c9ea4c96e0ca2c875 Boot ID: 9bda11bfcecb4707bc30db2601655f41 Operating System: Gentoo Linux Kernel: Linux 6.6.62-gentoo-adrien Architecture: x86-64 Hardware Vendor: ASUSTeK COMPUTER INC. Hardware Model: N76VZ Firmware Version: N76VZ.202 Firmware Date: Fri 2012-03-16
On peut aussi configurer à notre guise le fichier hosts :
Code BASH :
nano -w /etc/hosts
Exemple :
Code TEXT :
127.0.0.1 gentoolinuxtricks.domaine.lan gentoolinuxtricks localhost
Derniers réglages
Logs et Journalisation
Par défaut, systemd-journald est déjà installé et activé, nous n'avons rien à faire.
Il est inutile d'installer rsyslog et logrotate.
Planificateur de tâches
Par défaut, systemd fournit les timers pour planifier des tâches.
Cependant, on pourra installer cron :
Code BASH :
emerge -a sys-process/cronie
On démarre le service au boot :
Code BASH :
systemctl enable --now cronie.service
Service NTP
Systemd fournit la synchronisation NTP nativement avec systemd-timesyncd mais qui n'est pas activé.
On va donc le paramétrer au lieu d'utiliser un outil annexe comme chrony pour synchroniser l'horloge automatiquement via le réseau :
Code BASH :
timedatectl set-ntp true
On vérifie que le service est fonctionnel :
Code BASH :
timedatectl timesync-status
Qui renvoie :
Code TEXT :
Server: 129.151.225.244 (0.gentoo.pool.ntp.org) Poll interval: 32s (min: 32s; max 34min 8s) Leap: normal Version: 4 Stratum: 2 Reference: 91EECB0E Precision: 1us (-24) Root distance: 33.882ms (max: 5s) Offset: +1.323512s Delay: 28.430ms Jitter: 0 Packet count: 1 Frequency: +0,000ppm
Quelques outils
Outils divers
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/nmon sys-process/htop app-misc/screen app-editors/vim
Si on a installé eix, on peut configurer la mise à jour de la base 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 :
Code BASH :
mkdir /etc/portage/postsync.d
Code BASH :
nano -w /etc/portage/postsync.d/maj-eix
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
eselect-repository
eselect-repository permet d'ajouter des "overlays" c'est à dire des dépôts complémentaires. Je le trouve plus utile sur un PC que sur un serveur.
Installer eselect-repository :
Code BASH :
emerge -a eselect-repository
Lister les overlays :
Code BASH :
eselect repository list
Activer un overlay :
Code BASH :
eselect repository enable nom
Désactiver un overlay :
Code BASH :
eselect repository disable nom
Ajouter un overlay non listé (non officiel) :
Code BASH :
eselect repository add nom synctype syncurl
Exemple avec mon overlay :
Code BASH :
eselect repository add adrien-overlay git https://github.com/aaaaadrien/adrien-overlay.git
Et voila, c'est terminé
Installer un environnement de bureau
Si on veut installer un environnement de bureau, retrouvez la suite dans un second article ici : https://www.linuxtricks.fr/wiki/installer-gentoo-facilement-environnement-de-bureau-systemd