Gentoo - Installation

Installer Gentoo facilement (OpenRC)

Cet article a été mis à jour, vous consultez ici une archive de cet article!
Table des matières

logo_gentoo



Introduction




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

Gentoo utilise le gestionnaire de paquets Portage.

Calculate Linux dont je parle beaucoup sur ce site est basé sur Gentoo, mais est plus "facile" d'emploi :intello:

Ce didacticiel traite les cas d'installation en mode :

- BIOS ou UEFI

- Partition standard ou LVM



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 16 (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 racine de 20Go
  • une partition /home de 10Go
  • une partition SWAP de 2Go



Dans le cas d'une installation UEFI, il faut faire une partition supplémentaire de 100Mo par exemple qui sera montée dans /boot/EFI

Avec cfdisk, la créer de type EFI System (ce qui appose le flag boot et esp).



Code BASH :
                                  cfdisk (util-linux 2.22.2)
                                     Disk Drive: /dev/sda
                               Size: 32212254720 bytes, 32.2 GB
                     Heads: 255   Sectors per Track: 63   Cylinders: 3916
    Name           Flags        Part Type    FS Type             [Label]          Size (MB)
 ---------------------------------------------------------------------------------------------
    sda1           Boot          Primary     Linux                                 20003.89    
    sda2                         Primary     Linux                                 10001.95
    sda3                         Primary     Linux swap / Solaris                   1998.75
                                 Pri/Log     Free Space                              207.70   *
     [ Bootable ]  [  Delete  ]  [   Help   ]  [ Maximize ]  [  Print   ]  [   Quit   ]
     [   Type   ]  [  Units   ]  [  Write   ]
                                 Wrote partition table to disk
                         Toggle bootable flag of the current partition
 


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

Code BASH :
fdisk -l
Disk /dev/sda: 32.2 GB, 32212254720 bytes, 62914560 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000
   Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *          63    39070079    19535008+  83  Linux
/dev/sda2        39070080    58605119     9767520   83  Linux
/dev/sda3        58605120    62508914     1951897+  82  Linux swap / Solaris
 


On formate les partitions :

Code BASH :
mkfs.ext4 /dev/sda1
mkfs.ext4 /dev/sda2
mkswap /dev/sda3
 


Dans le cas d'une installation UEFI, formater la partition avec :

Code BASH :
mkfs.fat -F32 /dev/sdXY


On monte la partition racine dans /mnt/gentoo

Code BASH :
mount /dev/sda1 /mnt/gentoo


On créé les points de montage des autres partitions et on monte celles-ci dans leurs dossiers respectifs (exemple avec /home sur /dev/sda2)

Code BASH :
mkdir /mnt/gentoo/home
mount /dev/sda2 /mnt/gentoo/home


On en profite pour monter le SWAP :

Code BASH :
swapon /dev/sda3


Dans le cas UEFI, monter aussi la partition FAT32 dans /boot/EFI (Dans cfdisk, créer la partition de type EFI System) :

Code BASH :
mkdir /mnt/gentoo/boot/EFI
mount /dev/sda4 /mnt/gentoo/boot/EFI


Vérifier que la date est au format UTC (c'est à dire à l'heure de Londres).

Code BASH :
date
Thu Jul 25 08:29:50 UTC 2013


C'est OK dans mon cas.

Modifier si besoin la date et l'heure :

Code BASH :
date MMJJhhmmAAAA




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




32bits



Code BASH :
wget http://distfiles.gentoo.org/releases/x86/autobuilds/current-stage3-i686/stage3-i686-*.tar.xz


Remplacer dans l'URL l'étoile (*) par la date de construction de l'archive.

http://distfiles.gentoo.org/releases/x86/autobuilds ou chez Esslingen : https://ftp-stud.hs-esslingen.de/pub/Mirrors/gentoo/releases/x86/autobuilds/current-stage3-i686/


64bits



Code BASH :
wget http://distfiles.gentoo.org/releases/amd64/autobuilds/current-stage3-amd64/stage3-amd64-*.tar.xz


Remplacer dans l'URL l'étoile (*) par la date de construction de l'archive.

http://distfiles.gentoo.org/releases/amd64/autobuilds ou chez Esslingen : http://ftp-stud.hs-esslingen.de/pub/Mirrors/gentoo/releases/amd64/autobuilds/current-stage3-amd64/


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" #Cartes graphiques, choisir les cartes adéquats. Garder fbdev (framebuffer) et vesa (générique)
INPUT_DEVICES="libinput synaptics keyboard mouse evdev jokstick 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
 



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


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.0 (stable)
  [2]   default/linux/amd64/17.0/selinux (stable)
  [3]   default/linux/amd64/17.0/hardened (stable)
  [4]   default/linux/amd64/17.0/hardened/selinux (stable)
  [5]   default/linux/amd64/17.0/desktop (stable)
  [6]   default/linux/amd64/17.0/desktop/gnome (stable)
  [7]   default/linux/amd64/17.0/desktop/gnome/systemd (stable)
  [8]   default/linux/amd64/17.0/desktop/plasma (stable)
  [9]   default/linux/amd64/17.0/desktop/plasma/systemd (stable)
  [10]  default/linux/amd64/17.0/developer (stable)
  [11]  default/linux/amd64/17.0/no-multilib (stable)
  [12]  default/linux/amd64/17.0/no-multilib/hardened (stable)
  [13]  default/linux/amd64/17.0/no-multilib/hardened/selinux (stable)
  [14]  default/linux/amd64/17.0/systemd (stable)
  [15]  default/linux/amd64/17.0/x32 (dev)
  [16]  default/linux/amd64/17.1 (stable)
  [17]  default/linux/amd64/17.1/selinux (stable)
  [18]  default/linux/amd64/17.1/hardened (stable)
  [19]  default/linux/amd64/17.1/hardened/selinux (stable)
  [20]  default/linux/amd64/17.1/desktop (stable)
  [21]  default/linux/amd64/17.1/desktop/gnome (stable)
  [22]  default/linux/amd64/17.1/desktop/gnome/systemd (stable)
  [23]  default/linux/amd64/17.1/desktop/plasma (stable)
  [24]  default/linux/amd64/17.1/desktop/plasma/systemd (stable)
  [25]  default/linux/amd64/17.1/developer (stable)
  [26]  default/linux/amd64/17.1/no-multilib (stable)
  [27]  default/linux/amd64/17.1/no-multilib/hardened (stable)
  [28]  default/linux/amd64/17.1/no-multilib/hardened/selinux (stable)
  [29]  default/linux/amd64/17.1/systemd (stable)
  [30]  default/linux/amd64/17.0/musl (exp)
  [31]  default/linux/amd64/17.0/musl/hardened (exp)
  [32]  default/linux/amd64/17.0/musl/hardened/selinux (exp)
  [33]  default/linux/amd64/17.0/uclibc (exp)
  [34]  default/linux/amd64/17.0/uclibc/hardened (exp)
 


Sélectionner le profil qui vous convient (ici default/linux/amd64/17.1 ) :

Code BASH :
eselect profile set 16


Vérifier de nouveau avec

Code BASH :
eselect profile list


que le profil sélectionné est bon.

Si on compte installer une Gentoo graphique, on sélectionne dès à présent le profil «desktop».

A noter su'un profile desktop installera beaucoup de choses avant le premier reboot. Même si on veut installer Gentoo avec un environnement de bureau, on pourra changer le profile après.


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


Locales




Les locales, c'est la langue du système et son encodage. Configurer tout cela pour du français :

Code BASH :
nano -w /etc/locale.gen


Mettre ceci pour du français compatible UTF-8

Code BASH :
fr_FR.UTF-8 UTF-8


On génère les locales :

Code BASH :
locale-gen


On liste ensuite les locales disponibles :

Code BASH :
eselect locale list


La liste donne ceci chez moi :

On sélectionne sa locale concernée (renseigne le /etc/env.d/02locale automatiquement) :

Code BASH :
eselect locale set X


On configure la disposition du clavier pour la console TTY :

Code BASH :
nano -w /etc/conf.d/keymaps


Modifier la ligne keymap ainsi pour disposer d'un clavier AZERTY :

Code BASH :
keymap="fr"


On met à jour l'environnement :

Code BASH :
env-update && source /etc/profile && export PS1="[chroot] $PS1"




Configurer le fuseau horaire




Vu que nous sommes sur Paris en France, configurons ainsi le fuseau horaire :

Code BASH :
cp /usr/share/zoneinfo/Europe/Paris /etc/localtime


Vu que nous sommes sur Paris en France, configurons ainsi le fuseau horaire :

Code BASH :
echo "Europe/Paris" > /etc/timezone


Et on configure le paquet timezone-data :

Code BASH :
emerge --config sys-libs/timezone-data


Après changement du fuseau horaire, n'hésitez pas à voir si l'heure est bonne.

Code BASH :
date


Si besoin, redéfinir la date :

Code BASH :
date MMJJhhmmAAAA




Vérifier que l'horloge est bien en UTC :

Code BASH :
nano -w /etc/conf.d/hwclock


Code BASH :
clock="UTC"


Dans le cadre d'une VM, il est nécessaire d'appliquer cette commande pour synchroniser l'horloge matérielle à l'horloge système :

Code BASH :
hwclock --systohc




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/BOOT              /boot           ext2            defaults,noatime         1 2
/dev/sda1               /               ext4            defaults,noatime         0 1
/dev/sda2               /home           ext4            defaults,noatime         0 2
/dev/sda3               none            swap            sw              0 0
 


Pour des UUID :

Code BASH :
UUID="aaaaa-aaaa-aaa-aaaaa"     /mnt/test     ext4     defaults     0 0


Dans le cas EFI, il n'est pas nécessaire de monter la partition EFI dans le fichier fstab.

Si on veut le faire :

Code BASH :
/dev/sda4              /boot/EFI           vfat            defaults         0 0


Concernant les 2 derniers chiffres, ça concerne la vérification des systèmes de fichiers au démarrage si demandé :

0 0 (pas de vérification, utile pour le SWAP)

0 1 première partition à être vérifiée par fsck (Partition racine uniquement)

0 2 partitions vérifiées après la racine (/home, /var ou autre partition)




Configurer le kernel




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


Dans le cas d'un matériel spécifique, on peut aussi installer linux-firmware :

Code BASH :
emerge -a 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 
echo "sys-kernel/linux-firmware linux-fw-redistributable no-source-code" >> /etc/portage/package.license/custom 




On se rend dans les sources :

Code BASH :
cd /usr/src/linux


On fait nettoie les sources :

Code BASH :
make mrproper


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


Si on utilise du LVM :

Si notre gentoo est installée en LVM, on installe le paquet lvm2

Code BASH :
 emerge lvm2


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

Code BASH :
/etc/init.d/lvm start
rc-update add lvm boot


Vérifier que use_lvmetad = 1 est bien à 1 dans /etc/lvm/lvm.conf

Il est également nécessaire de générer un initramfs. Sans cela, le système ne démarrera pas.

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.

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.

Définir le nom d'hôte




Configurer le nom d'hôte de la machine. Éditer le fichier hostname :

Code BASH :
nano -w /etc/conf.d/hostname


Code TEXT :
hostname="gentoo"


On peut aussi configurer à notre guise le fichier hosts :

Code BASH :
nano -w /etc/hosts


Exemple :

Code TEXT :
127.0.0.1       gentoo.domaine.lan gentoo localhost


Configuration du réseau



Marquer comme installé manuellement netifrc :

Code BASH :
emerge -a --noreplace net-misc/netifrc


IP Fixe



Pour configurer une IP fixe, repérer le nom de l'interface réseau avec

Code BASH :
ip a


Ensuite, on édite a configuration de l'interface réseau (je prends un exemple avec le nom eth0) :

Code BASH :
nano -w /etc/conf.d/net


Ajouter la configuration du réseau. Voici un exemple sur mon serveur :

Code BASH :
config_enp0s3="192.168.21.251/24"
routes_enp0s3="default via 192.168.21.254"
dns_servers="8.8.8.8"



IP Dynamique



Si on veux utiliser les IP dynamique, il faut installer un client DHCP :

Code BASH :
emerge -a dhcpcd


Repérer le nom de l'interface réseau avec

Code BASH :
ip a


Ensuite, on édite a configuration de l'interface réseau (je prends un exemple avec le nom eth0) :

Code BASH :
nano -w /etc/conf.d/net


Ajouter une ligne (ou l'éditer) de la configuration du réseau pour indiquer qu'on utilise DHCP :

Code BASH :
config_enp0s3="dhcp"


Wi-Fi



Si on a utilisé le Wi-Fi avec le LiveCD, penser à installer wpa_supplicant

Code BASH :
emerge -a net-wireless/wpa_supplicant


Ajouter le réseau et la clé associée dans la config du système :

Code BASH :
wpa_passphrase ssid passphraseduwifi >>  /etc/wpa_supplicant/wpa_supplicant.conf


Il ne faut pas oublier de démarrer le service la prochaine fois :

Code BASH :
rc-update add wpa_supplicant default


Activer le réseau au redémarrage




Pour activer la carte réseau au démarrage, il suffit de créer un lien symbolique du service réseau avec le nom de l'interface

Code BASH :
cd /etc/init.d
ln -sv net.lo net.enp0s3


Puis on active ce service au démarrage :

Code BASH :
rc-update add net.enp0s3 default


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 :
 rc-update add sshd default




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 :

Cas BIOS :

Code TEXT :
GRUB_PLATFORMS="pc" 


Cas UEFI 64bits :

Code TEXT :
GRUB_PLATFORMS="pc efi-64" 


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


Ensuite, on installe grub2 :

Code BASH :
emerge -a grub


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

Code BASH :
grub-install /dev/sda


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

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


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:

Voila Gentoo est installée :magic:



Derniers réglages




Logs et Journalisation




On installe rsyslog et logrotate :

Code BASH :
emerge -a app-admin/rsyslog app-admin/logrotate


On démarre le service au boot :

Code BASH :
rc-update add rsyslog default




Planificateur de tâches




On installe cron :

Code BASH :
emerge -a sys-process/cronie


On démarre le service au boot :

Code BASH :
rc-update add cronie default




Service NTP




Si on le souhaite, on peut installer le service NTP pour synchroniser l'horloge automatiquement via le réseau :

Code BASH :
emerge -a net-misc/ntp


On démarre le service :

Code BASH :
/etc/init.d/ntp-client start


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

Code BASH :
rc-update add ntp-client default




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 le fait que eix-sync fasse : emerge --sync + layman -S + eix-update + eix-diff en configurant /etc/eix-sync.conf :

Code BASH :
echo '*' > /etc/eix-sync.conf


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