Gentoo - Installation

Installer Gentoo facilement (Systemd)

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

Table des matières

Introduction
Avant installation
Partitionnement
Installer les fichiers d'installation de Gentoo
1. Stage 3 : Le système
Configuration essentielle avant le chroot
1. Configuration du fichier make.conf
2. Sélection des miroirs
Installer le système de base
Finalisation de l'installation du système
1. Préparation au redémarrage
Configuration des services systemd de base
Derniers réglages
Installer un environnement de bureau

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.

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

Si ça ne marche pas, on peut renseigner les DNS de Google :

Code BASH :

echo "namserver 8.8.8.8" > /etc/resolv.conf

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.

A partir d'ici, je ne saisirai les commandes que depuis la machine distante !

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 sélectionné n'est pas le bon, on passera le nom du disque après la commande cfdisk, exemple ici avec un disque nvme :

Code BASH :

cfdisk /dev/nvme0n1

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  ]

Pour la partition EFI, si vous n'en aviez pas, sélectionnez bien le type EFI System (ce qui appose le flag boot et esp).

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

Dans le cas d'une partition, on formate la partition :

Code BASH :

mkswap /dev/sdaX

On active le swap :

Code BASH :

swapon /mnt/gentoo/swap

Exemple partitionnement LVM

Si vous suivez cette voie, assurez-vous de connaitre LVM. Plus d'infos : https://www.linuxtricks.fr/wiki/lvm-sous-linux-volumes-logiques

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  ]

Pour la partition EFI, si vous n'en aviez pas, sélectionnez bien le type EFI System (ce qui appose le flag boot et esp).

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/

Pour aller plus vite, on pourra utiliser ce miroir allemand : http://ftp-stud.hs-esslingen.de/pub/Mirrors/gentoo/releases/amd64/autobuilds/ (pour du 64bits).

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

Il faut bien comprendre que le système Gentoo que nous installons se trouve dans /mnt/gentoo du live CD.

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

Le montage et le chroot peut se faire avec la commande suivante depuis le live Gentoo :

Code BASH :

arch-chroot /mnt/gentoo

On met à jour des variables d'environnement :

Code BASH :

env-update && source /etc/profile

Vous pouvez avoir ce message :

Code TEXT :

!!! Section 'gentoo' in repos.conf has location attribute set to nonexistent directory: '/var/db/repos/gentoo'
!!! Invalid Repository Location (not a dir): '/var/db/repos/gentoo'

C'est normal, les dossiers de portage ne sont pas encore installés. On va le faire juste après.

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

Pour utiliser les UUID au lieu des noms des partitions, vous pouvez les récupérer avec la commande :

Code BASH :

blkid

Et donc mettre les entrées dans le fstab sous cette forme :

Code BASH :

UUID="07d35d17-75de-4a82-b3a7-1ca1208a8cdb"     /     ext4     defaults     0 1

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

Pour utiliser les UUID au lieu des noms des partitions, vous pouvez les récupérer avec la commande :

Code BASH :

blkid

Et donc mettre les entrées dans le fstab sous cette forme :

Code BASH :

UUID="1a7db55e-5c90-42b7-acf4-1c4146f7ce7e"      /               ext4            defaults,noatime        0 1

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

[/style]

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

Si vous avez cette erreur (récemment rencontrée) :

Code TEXT :

Could not delete variable: Read-only file system

Remontez en lecture/écriture efivars :

Code BASH :

mount -o remount,rw /sys/firmware/efi/efivars

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

Vous devez stipuler d'avoir lu les licences linux-fw-redistributable no-source-code de linux-firmware en ajoutant la ligne qui va bien dans package.license :

Code BASH :

mkdir /etc/portage/package.license

Code BASH :

echo "sys-kernel/linux-firmware linux-fw-redistributable no-source-code" >> /etc/portage/package.license/custom

Cas 1 Installer les sources et les compiler manuellement

On pourra se référer au tuto http://www.linuxtricks.fr/wiki/compiler-son-kernel-linux#paragraph_la-personnalisation

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

Pour EFI, bien activer ceci le support des partitions GPT :

Code TEXT :

-*- Enable the block layer --->
    ...
    Partition Types --->
    [*] Advanced partition selection
      ...
      [*] EFI GUID Partition support

et le support EFI :

Code TEXT :

Processor type and features  --->
    [*] EFI runtime service support 
    [*]   EFI stub support
 
Firmware Drivers  --->
    <*> EFI Variable Support via sysfs

Si on a utilisé précédemment du LVM, activer ceci :

Code TEXT :

Device Drivers  --->
   Multiple devices driver support (RAID and LVM)  --->
       <*> Device mapper support
           <*> Crypt target support
           <*> Snapshot target
           <*> Mirror target
           <*> Multipath target
               <*> I/O Path Selector based on the number of in-flight I/Os
               <*> I/O Path Selector based on the service time

Plus d'infos sur le Wiki Gentoo concernant les matériels :
Exemples CPU :
AMD Ryzen : https://wiki.gentoo.org/wiki/Ryzen
Exemples GPU :
AMDGPU : https://wiki.gentoo.org/wiki/AMDGPU
NVidia : https://wiki.gentoo.org/wiki/NVIDIA
Exemples de PC :
Dell XPS 13 9350 : https://wiki.gentoo.org/wiki/Dell_XPS_13_9350
Et sur la gestion de l'énergie pour les PC portables :
https://wiki.gentoo.org/wiki/Power_management/Guide

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

Si l'initrd n'a pas été créé automatiquement avec installkernel, on la génère avec :

Code BASH :

dracut --kver $version

Exemple, si mon noyau s'appelle 6.6.47-gentoo-adrien

Code BASH :

dracut --kver 6.6.47-gentoo-adrien

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.1.31-gentoo-dist
    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

Pour les dépôts se synchronisant avec git, s'assurer de l'installer :

Code BASH :

emerge -av dev-vcs/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