Gentoo - Installation

Installer Gentoo facilement (OpenRC)

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
  1. 32bits
  2. 64bits
2. Portage
Installer le système de base
Installer le chargeur d'amorçage
1. GRUB Legacy (0.97) (Obsolète)
2. GRUB2
Finalisation de l'installation du système
Derniers réglages

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 se site est basé sur Gentoo, mais est plus "facile" d'emploi

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 32bits : http://distfiles.gentoo.org/releases/x86/autobuilds/
Gentoo 64bits : http://distfiles.gentoo.org/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

Insérer le CD dans la machine

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. Le chargement est terminé lorsque le prompt livecd ~ # s'affiche.

On met le clavier en français, ce sera plus facile :

Code BASH :

 loadkeys fr

On vérifie que nous disposons bien d'une IP :

Code BASH :

ifconfig

Si besoin, demander une IP à notre serveur DHCP :

Code BASH :

dhcpcd

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

Code BASH :

ssh root@Ip_machine

On va se rendre dans le répertoire où nous installerons Gentoo en chroot :

Code BASH :

cd /mnt/gentoo

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

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 200Mo par exemple qui sera montée dans /boot/EFI

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 de 200Mo en fat32 :

Code BASH :

mkfs.vfat /dev/sda4

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 :

Code BASH :

mkdir /boot/EFI
mount /dev/sda4 /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 sur celle de Londres :

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.bz2

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

http://distfiles.gentoo.org/releases/x86/autobuilds

64bits

Code BASH :

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

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

http://distfiles.gentoo.org/releases/amd64/autobuilds

Extraire ensuite l'archive :

Code BASH :

tar xjvfp stage3-XXXXXXXXXX.tar.bz2

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

Portage

Télécharger et extraire l'arbre de portage :

Code BASH :

wget http://distfiles.gentoo.org/snapshots/portage-latest.tar.bz2
tar xvjf portage-latest.tar.bz2 -C /mnt/gentoo/usr

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.

Dans un premier temps, on se copie le fichier de résolution de noms DNS :

Code BASH :

cp -L /etc/resolv.conf /mnt/gentoo/etc/

On monte ensuite les dossiers proc et dev dans /mnt/gentoo

Code BASH :

mount -t proc none /mnt/gentoo/proc
mount -o bind /dev /mnt/gentoo/dev
mount -t sysfs /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"

Fichier make.conf

On édite le fichier make.conf pour lui ajouter quelques options supplémentaires :

Code BASH :

nano -w /etc/portage/make.conf

Code BASH :

MAKEOPTS="-j9" # 9 car j'ai 8 cœurs : nb cœurs+1
LINGUAS="fr" #Langue
L10N="fr" #Langue
VIDEO_CARDS="intel nvidia nouveau radeon vesa virtualbox" #Cartes graphiques, choisir les cartes adéquats

Si on souhaite par la suite installer une interface graphique, penser à ajouter les périphériques d'entrée utiles comme le clavier :

Code BASH :

INPUT_DEVICES="evdev"

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

Code BASH :

  nano -w /etc/env.d/02locale

Et y insérer

Code BASH :

LANG="fr_FR.UTF-8"
LC_COLLATE="C"

On génère les locales :

Code BASH :

locale-gen

On arrange aussi

On configure la disposition du clavier :

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

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

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

Code BASH :

nano -w /etc/conf.d/hwclock

Code BASH :

clock="UTC"

Configurer le kernel

Avec Genkernel de manière semi-automatique

Installer les sources du noyau et l'utilitaire genkernel :

Code BASH :

emerge -q gentoo-sources genkernel

On copie les fichiers de configuration qui ont été utilisés par le Live CD pour l'utiliser sur notre kernel :

32bits :

Code BASH :

zcat /proc/config.gz > /usr/share/genkernel/arch/x86/kernel-config

64bits :

Code BASH :

zcat /proc/config.gz > /usr/share/genkernel/arch/x86_64/kernel-config

On configure puis compile notre kernel :

Code BASH :

genkernel all --menuconfig

Avec la fenêtre Linux/x86 x.x.x-gentoo Kernel Configuration configurer les options du kernel qui nous intéressent. Terminer par Exit.

On vérifie que les fichiers nécessaire au boot sont bien la :

Code BASH :

ls boot
System.map-genkernel-x86_64-3.8.13-gentoo 
kernel-genkernel-x86_64-3.8.13-gentoo
initramfs-genkernel-x86_64-3.8.13-gentoo

Le résultat peut varier suivant l'architecture et la version du noyau.

En compilant à la main

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

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

Sauvegarder le fichier .config.

On compile le noyau (mettez comme valeur à "j" le nombre de processeurs +1) :

Code BASH :

make -j9

On installe les modules :

Code BASH :

make modules_install

Puis on installe le noyau :

Code BASH :

make install

Micrologiciels supplémentaires

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

Code BASH :

emerge -q linux-firmware

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 1
/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.

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

Installer le chargeur d'amorçage

La est le plus délicat, il ne faut pas se tromper.

Code BASH :

emerge -pv grub

Vérifier la version qui va s'installer.

GRUB Legacy (0.97) (Obsolète)

D'abord, on installe le logiciel GRUB :

Code BASH :

emerge -q grub:0

Maintenant, on édite le fichier de config de GRUB :

Code BASH :

nano -w /boot/grub/grub.conf

Je rappelle que /dev/sda1 est ma partition /, qui contient les fichiers du boot.

Si vous avez un /boot dédié sur une partition, relever le nom de la partition qui est montée sur /boot.

Voila mon fichier grub.conf avec le partitionnement utilisé depuis le début (Adapter avec les noms donnés par ls /boot) :

Code BASH :

default 0
timeout 30
#splashimage=(hd0,0)/boot/grub/splash.xpm.gz
title Gentoo Linux 3.8.13   
root (hd0,0)
kernel /boot/kernel-genkernel-x86_64-3.8.13-gentoo root=/dev/sda1
initrd /boot/initramfs-genkernel-x86_64-3.8.13-gentoo

Explication de root (hd0,0)

hd0 => /dev/sda

hd1 => /dev/sdb

etc.

hd0,0 => /dev/sda1

hd0,1 => /dev/sda2

On installe grub dans le secteur boot :

Code BASH :

grub                (Lance la console de grub)
grub> root (hd0,0)    (lieu de /boot ou / si pas de /boot)
grub> setup (hd0)     (Écrit GRUB dans le MBR.)
grub> quit            (Quitte la console GRUB.)

GRUB2

Ajuster "GRUB_PLATFORMS" dans le fichier make.conf si votre matériel est "exotique"

Dans un premier temps, on installe grub2 :

Code BASH :

emerge -q grub

Pour une installation UEFI, il faudra modifier le fichier /etc/portage/make.conf en y ajoutant GRUB_PLATFORMS="efi-64"

Code BASH :

nano -w /etc/portage/make.conf
 
GRUB_PLATFORMS="efi-64"

Une fois grub installé, il faut le paramétrer.

Code BASH :

mkdir /boot/grub
grub-mkconfig -o /boot/grub/grub.cfg

Puis on installe GRUB sur le 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

Finalisation de l'installation du système

Définir un mot de passe root

N'oublions pas le plus important, le mot de passe root !

Code BASH :

passwd

Client DHCP

Si par la suite on veut du réseau, c'est mieux d'avoir un client DHCP :

Code BASH :

emerge -q dhcpcd

Activer le réseau au redémarrage

Pour activer la carte réseau au démarrage, repérer son nom avec

Code BASH :

ip a

Ensuite (je prend comme exemple la mienne "enp0s3" 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

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

On peut configurer comme tout à l'heure la connexion à SSH en root (Attention si le serveur est connecté à Internet !!)

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 groupe_principal -G users,groupe1,group2,group3  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

Ne pas oublier d'initialiser le mot de passe via la commande

Code BASH :

passwd nom_user

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.bz2

On revient à la racine du live CD et on démonte tout ce dont on a plus besoin :

Code BASH :

cd 
umount -a

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

Voila Gentoo est installée

Derniers réglages

Logs et Journalisation

On installe rsyslog et logrotate :

Code BASH :

emerge -q rsyslog 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 -q vixie-cron

On démarre le service au boot :

Code BASH :

rc-update add vixie-cron 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 -q ntp

On démarre le service :

Code BASH :

/etc/init.d/ntpd start

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

Code BASH :

rc-update add ntpd default

Choisir son profil

Ils permettent de mettre certaines variables par défaut en fonction d'un type d'installation prédéfini.

Par exemple, si vous comptez utiliser KDE il est préférable d'utiliser un profile desktop/kde.

Listes des "profiles" :

Code BASH :

eselect profile list

Choix du "profile" :

Code BASH :

eselect profile set X

où X est le numéro du profil affiché dans la liste précédente.

Quelques outils

Outils divers

Installons quelques outils pratiques :

Code BASH :

emerge -q gentoolkit portage-utils htop app-misc/screen eix

Layman

Layman 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 layman

Code BASH :

emerge -q layman

Editer le fichier /etc/layman/layman.cfg et ajouter à la fin si cette variable n'est pas présente :

Code BASH :

conf_type : repos.conf

Ajouter une référence à layman dans le fichier make.conf

Code BASH :

echo "source /var/lib/layman/make.conf" >> /etc/portage/make.conf

Créer le fichier repos.conf s'il n'existe pas

Code BASH :

mkdir /etc/portage/repos.conf

Si layman 2.3 est installé forcer la mise à jour de layman :

Code BASH :

layman-updater -R

Initialiser un coup layman avec

Code BASH :

layman -L
layman -S

Exemple d'ajout d'overlay : (j'ai pris comme modèle l'overlay nommé calculate)

Code BASH :

layman -a calculate
eix-update

Et après on peut utiliser cet overlay et on y trouve les logiciels :

Code BASH :

eix calculate-sour
* sys-kernel/calculate-sources [1]
     Available versions:  
     (3.12.45) ~3.12.45^bs
     (3.14.48) ~3.14.48^bs
     (3.18.14) 3.18.14-r1^bs
     (3.18.19) ~3.18.19^bs
     (4.0.9) ~4.0.9^bs
     (4.1.3) ~4.1.3^bs
       {build firmware minimal plymouth symlink themes vmlinuz}
     Homepage:            http://www.calculate-linux.org
     Description:         Calculate Linux kernel image
[1] "calculate" /var/lib/layman/calculate
gentoo ~ # 
gentoo ~ # emerge -pv calculate-sources
These are the packages that would be merged, in order:
Calculating dependencies   * waiting for lock on /var/db/.pkg.portage_lockfile ...                                 [ ok ]
... done!
[ebuild  N     ] sys-kernel/calculate-sources-3.18.14-r1:3.18.14::calculate  USE="-build -firmware -minimal -plymouth -symlink -themes -vmlinuz" 419 KiB
Total: 1 package (1 new), Size of downloads: 419 KiB
 * IMPORTANT: 13 news items need reading for repository 'gentoo'.
 * Use eselect news read to view new items.

Et pour supprimer

Code BASH :

layman -d calculate
eix-update

Et voila, c'est terminé