Gentoo - Installation

Installer Gentoo facilement (Systemd)

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.

Gentoo utilise le gestionnaire de paquets Portage.

Ce didacticiel traite les cas d'installation en mode UEFI, partition standard ou LVM, avec le gestionnaire d'initialisation et de service 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 :



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



Insérer le CD dans la machine :happy1:

Booter sur le CD.

Sur l'invite de commande boot: valider en appuyant sur Entrée.

Le Live CD charge les modules et démarre.

Une invite demande de sélectionner la langue. Je choisis 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 configure le démon sshd

Code BASH :
vi /etc/ssh/sshd_config


Et on décommente PermitRootLogin qu'on positionne à yes

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



Il existe plusieurs manières de partitionner son disque, avec des outils différents.

Moi, je vais 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


Partitionner à sa guise, dans ce tutoriel, je vais 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, la 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).

Ce qui me donne avec la commande fdisk ce résultat au final :

Code BASH :
fdisk -l


Code :
Disk /dev/sda: 238.47 GiB, 256060514304 bytes, 500118192 sectors
Disk model: OCZ-VERTEX4
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk 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



On formate les partitions :

Code BASH :
mkfs.fat -F32 /dev/sda1
mkfs.ext4 /dev/sda2
mkfs.ext4 /dev/sda3


Si vous avez créé une partition swap, formater la partition avec :
Code BASH :
mkswap /dev/sdaX


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 :

Code BASH :
mkdir -p /mnt/gentoo/boot/EFI
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


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.

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-systemd-mergedusr : Stage 3 systemd (serveur) avec le usermerge (/bin est un lien vers /usr/bin, la même avec /sbin et /lib...)
- stage3-amd64-desktop-systemd : Stage 3 systemd (desktop) qui contient déjà des éléments si on veut installer Gentoo avec un interface graphique
- stage3-amd64-desktop-systemd-mergedusr : Stage 3 systemd (desktop) qui contient déjà des éléments si on veut installer Gentoo avec un interface graphique avec le usermerge

Dans ce tutoriel, je pars sur stage3-amd64-systemd-mergedusr. Je prends le mergedusr car c'est la même architecture que les Debian, Fedora et autres distributions utilisant systemd, même si cela nous éloigne de la philosophie de Gentoo.

On télécharge avec wget :

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


Extraire ensuite l'archive :

Code BASH :
tar xJvpf stage3-*.tar.xz


Il ne faut pas oublier le commutateur p qui permet de préserver les permissions !

On peut aussi ajouter à la fin --xattrs pour conserver les attributs étendus (facultatif).


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 architecture (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="-march=native -O2 -pipe"
CFLAGS="${COMMON_FLAGS}"
CXXFLAGS="${COMMON_FLAGS}"


On peut affiner plus l'optimisation de GCC, notamment le -march. plus d'infos ici suivant le matériel : https://wiki.gentoo.org/wiki/Safe_CFLAGS

Code BASH :
USE=""
MAKEOPTS="-j12" # 12 car 12CPU
LINGUAS="fr" #Langue (anciennement)
L10N="fr" #Langue
VIDEO_CARDS="fbdev vesa intel i915 nvidia nouveau radeon amdgpu radeonsi virtualbox vmware qxl" #Cartes graphiques, choisir les cartes adéquats. Garder fbdev (framebuffer) et vesa (générique)
INPUT_DEVICES="libinput synaptics keyboard mouse joystick wacom" # Périphériques d'entrées utilisés (clavier souris + si affinités)
EMERGE_DEFAULT_OPTS="${EMERGE_DEFAULT_OPTS} --quiet-build=y" # Pour ne pas avoir la compilation verbeuse
PORTAGE_SCHEDULING_POLICY="idle" # Permet de pouvoir compiler sereinement lorsque gentoo est en prod
 



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


On configure ensuite les dépôts en créant le dossier repos.conf :

Code BASH :
mkdir -p /mnt/gentoo/etc/portage/repos.conf


Puis on copie le fichier de config du dépôt Gentoo dans le futur système :

Code BASH :
cp /mnt/gentoo/usr/share/portage/config/repos.conf /mnt/gentoo/etc/portage/repos.conf/gentoo.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 dossiers proc et dev 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 CD pour basculer vers l'environnement final.

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


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 disponible 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


Quand j'ai mis à jour ce tutoriel, j'avais :

Code TEXT :
Available profile symlink targets:
  [1]   default/linux/amd64/17.1 (stable)
  [2]   default/linux/amd64/17.1/selinux (stable)
  [3]   default/linux/amd64/17.1/hardened (stable)
  [4]   default/linux/amd64/17.1/hardened/selinux (stable)
  [5]   default/linux/amd64/17.1/desktop (stable)
  [6]   default/linux/amd64/17.1/desktop/gnome (stable)
  [7]   default/linux/amd64/17.1/desktop/gnome/systemd (stable)
  [8]   default/linux/amd64/17.1/desktop/gnome/systemd/merged-usr (stable)
  [9]   default/linux/amd64/17.1/desktop/plasma (stable)
  [10]  default/linux/amd64/17.1/desktop/plasma/systemd (stable)
  [11]  default/linux/amd64/17.1/desktop/plasma/systemd/merged-usr (stable)
  [12]  default/linux/amd64/17.1/desktop/systemd (stable)
  [13]  default/linux/amd64/17.1/desktop/systemd/merged-usr (stable)
  [14]  default/linux/amd64/17.1/developer (exp)
  [15]  default/linux/amd64/17.1/no-multilib (stable)
  [16]  default/linux/amd64/17.1/no-multilib/hardened (stable)
  [17]  default/linux/amd64/17.1/no-multilib/hardened/selinux (stable)
  [18]  default/linux/amd64/17.1/no-multilib/systemd (dev)
  [19]  default/linux/amd64/17.1/no-multilib/systemd/merged-usr (dev)
  [20]  default/linux/amd64/17.1/no-multilib/systemd/selinux (exp)
  [21]  default/linux/amd64/17.1/no-multilib/systemd/selinux/merged-usr (exp)
  [22]  default/linux/amd64/17.1/systemd (stable)
  [23]  default/linux/amd64/17.1/systemd/merged-usr (stable) *
  [24]  default/linux/amd64/17.1/systemd/selinux (exp)
  [25]  default/linux/amd64/17.1/systemd/selinux/merged-usr (exp)
  [26]  default/linux/amd64/17.1/clang (exp)
  [27]  default/linux/amd64/17.1/systemd/clang (exp)
  [28]  default/linux/amd64/17.1/systemd/clang/merged-usr (exp)
  [29]  default/linux/amd64/17.0/x32 (dev)
  [30]  default/linux/amd64/17.0/x32/systemd (exp)
  [31]  default/linux/amd64/17.0/x32/systemd/merged-usr (exp)
  [32]  default/linux/amd64/17.0/musl (dev)
  [33]  default/linux/amd64/17.0/musl/clang (exp)
  [34]  default/linux/amd64/17.0/musl/hardened (exp)
  [35]  default/linux/amd64/17.0/musl/hardened/selinux (exp)
 


Le profil doit être le bon par rapport à l'archive stage3 récupérée (ici default/linux/amd64/17.1/systemd/merged-usr ).
Si le profile n'est pas bon, sélectionnez le bon grâce à son numéro :

Code BASH :
eselect profile set 23


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



On peut également "améliorer" la compilation en mentionnant les FLAGS que le CPU sait traiter (facultatif).
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 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"



On pourra affiner l'option -march=native par un autre paramètre
Installer resolve-march-native :
Code BASH :
emerge -av app-misc/resolve-march-native


Exécuter la commande resolve-march-native, chez moi elle renvoie :
Code :
-march=znver1 --param=l1-cache-line-size=64 --param=l1-cache-size=32 --param=l2-cache-size=512


Ensuite adapter le make.conf suivant votre cas en remplaçant la valeur de l'option -march :
Code TEXT :
COMMON_FLAGS="-march=znver1 -O2 -pipe"



Problème des logiciels non-libres



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 
echo "*/* *" >> /etc/portage/package.license/custom



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 (facultatif) :

Code BASH :
emerge -avuDN @world



Fichier fstab



Editer le fichier fstab pour renseigner les partitions et leur point de montage :

Code BASH :
nano -w /etc/fstab


Exemple :

Code BASH :
/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 :
ls -l /dev/disk/by-uuid/ 

Code :
lrwxrwxrwx 1 root root 10 Jul  6 06:18 03B2-F5E3 -> ../../sdb1
lrwxrwxrwx 1 root root 10 Jul  6 08:42 07d35d17-75de-4a82-b3a7-1ca1208a8cdb -> ../../sda2
lrwxrwxrwx 1 root root 10 Jul  6 08:42 0c4f7a1b-8ddc-4fdc-aaf1-11307cef1de2 -> ../../sda3
lrwxrwxrwx 1 root root 10 Jul  6 06:18 7CDB-00D9 -> ../../sdb2
lrwxrwxrwx 1 root root 10 Jul  6 08:39 DD08-A73E -> ../../sda1


Et donc mettre les entrées dans le fstab sous cette forme :
Code BASH :
UUID="07d35d17-75de-4a82-b3a7-1ca1208a8cdb"     /     ext4     defaults     0 1



Configurer le kernel



Facultatif si LVM



Si on utilise du LVM :

Si notre gentoo est installée en LVM, on active de manière globale le USE lvm :

Code BASH :
euse -E lvm


Puis on installe le paquet lvm2

Code BASH :
emerge lvm2


On démarre le service lvm et on l'ajoute au boot :

Code BASH :
systemctl enable lvm2-monitor.service


Il est également nécessaire de générer un initramfs. Sans cela, le système ne démarrera pas. (on verra plus bas).

Prérequis 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 -a linux-firmware



Cas 1 Installer les sources et compiler



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 -a gentoo-sources


On peut aussi installer les paquets pciutils et usbutils contenant les outils lspci et lsusb :

Code BASH :
emerge -a pciutils 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 BASH :
Available kernel symlink targets:
  [1]   linux-5.10.76-gentoo-r1


On sélectionne le noyau :
Code BASH :
eselect kernel set 1


On se rend dans les sources :

Code BASH :
cd /usr/src/linux


On fait 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 installe dracut :

Code BASH :
emerge -a dracut


Puis on génère le initramfs avec :

Code BASH :
 dracut -a lvm --kver $version


On peut aussi activer le module de manière permanente (c'est activé de base normalement) en créant un fichier /etc/dracut.conf.d/lvm.conf :

Code BASH :
add_dracutmodules+="lvm"


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

Code BASH :
dracut -a lvm --kver 4.19.86-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 veux 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 veux utiliser les IP dynamique, 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



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

Code BASH :
passwd nom_user



Installer le chargeur d'amorçage



Définir la variable GRUB_PLATFORMS dans le fichier make.conf :

Code BASH :
nano -w /etc/portage/make.conf


Cas BIOS :
Code TEXT :
GRUB_PLATFORMS="pc" 


Cas UEFI 64bits :
Code TEXT :
GRUB_PLATFORMS="pc efi-64" 


Ensuite, on installe grub2 :

Code BASH :
emerge -a grub


Une fois grub installé, on l'installe sur notre disque dur (cas UEFI) :

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


Dans le cas d'une installation BIOS, on va installer différemment :

Code BASH :
grub-install /dev/sda


Puis on génère 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 CD et on démonte tout ce dont on a plus besoin :

Code BASH :
cd /
umount -R /mnt/gentoo


On reboot, on enlève le Live CD et on croise les doigts :ange:

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.

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é :intello:

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
Cette page a été vue 8521 fois