475 lines
11 KiB
Markdown
475 lines
11 KiB
Markdown
# Easy Slack !
|
|
|
|
**Easy Slack** rassemble mes notes pour installer et configurer simplement une **Slackware64 15.0**, que ce soit pour une station de travail avec KDE Plasma ou pour un serveur sans interface graphique.
|
|
|
|
L'idée est de rester simple, aussi proche que possible des outils fournis par Slackware, tout en arrivant rapidement à un système agréable à utiliser.
|
|
|
|
Ce guide ne couvre pas :
|
|
|
|
* le Secure Boot ;
|
|
* les partitions chiffrées.
|
|
|
|
## Table des matières
|
|
|
|
* [Installation](#installation)
|
|
* [Configuration avant le premier démarrage](#configuration-avant-le-premier-démarrage)
|
|
* [Utilisateur](#utilisateur)
|
|
* [Station de travail KDE Plasma](#station-de-travail-kde-plasma)
|
|
* [Fin](#fin)
|
|
* [Après l'installation](#après-linstallation)
|
|
* [Maintenance](#maintenance)
|
|
* [SlackBuilds.org et sbopkg](#slackbuildsorg-et-sbopkg)
|
|
* [Outils supplémentaires](#outils-supplémentaires)
|
|
* [Documentation](#documentation)
|
|
|
|
## Installation
|
|
|
|
### Partitionner le(s) disque(s)
|
|
|
|
Créez une nouvelle table de partitions GPT avec `fdisk`, puis partitionnez avec `cfdisk`.
|
|
|
|
L'installateur se chargera de formater les partitions si nécessaire.
|
|
|
|
Le schéma ci-dessous est celui que j'utilise. Une partition `/boot` séparée n'est pas obligatoire, mais je la conserve ici pour avoir une organisation identique entre mes machines.
|
|
|
|
#### UEFI
|
|
|
|
* 512M pour la partition EFI montée sur `/boot/efi` ;
|
|
* 1G pour la partition `/boot` ;
|
|
* le reste comme partition racine `/` ;
|
|
* éventuellement une partition `/home`.
|
|
|
|
La partition EFI doit être de type **EFI System**.
|
|
|
|
#### BIOS
|
|
|
|
Sur une machine BIOS utilisant GPT :
|
|
|
|
* 2M pour une partition **BIOS boot** non formatée ;
|
|
* 1G pour la partition `/boot` ;
|
|
* le reste comme partition racine `/` ;
|
|
* éventuellement une partition `/home`.
|
|
|
|
La petite partition BIOS boot permet à GRUB de s'installer correctement sur un disque GPT. C'est notamment utile sur certains VPS.
|
|
|
|
### Installer le système
|
|
|
|
Lancez simplement :
|
|
|
|
```sh
|
|
# setup
|
|
```
|
|
|
|
Et bienvenue dans les années 90, laissez-vous guider !
|
|
|
|
Au moment de choisir les séries de paquets :
|
|
|
|
* pour une station de travail KDE Plasma, je n'installe pas `E/` ni `XFCE/` ;
|
|
* pour un serveur sans interface graphique, je n'installe pas `E/`, `KDE/`, `T/`, `TCL/`, `X/`, `XAP/`, `XFCE/` ni `Y/`.
|
|
|
|
Slackware recommande une installation complète car elle ne gère pas automatiquement les dépendances. La sélection ci-dessus est donc volontaire et suppose de savoir quels composants seront utilisés.
|
|
|
|
Passez également l'installation de `lilo` ou `elilo` : GRUB sera installé juste après.
|
|
|
|
> Attention à ne pas redémarrer : le système n'est pas encore bootable.
|
|
|
|
## Configuration avant le premier démarrage
|
|
|
|
### Connexion
|
|
|
|
Vérifiez la connexion Internet :
|
|
|
|
```sh
|
|
# ping -c 3 www.slackware.com
|
|
```
|
|
|
|
Si le réseau n'est pas configuré, repérez l'interface adéquate :
|
|
|
|
```sh
|
|
# ip addr
|
|
```
|
|
|
|
Puis lancez `dhcpcd` :
|
|
|
|
```sh
|
|
# dhcpcd <interface>
|
|
```
|
|
|
|
La connexion devrait être fonctionnelle.
|
|
|
|
### Chroot
|
|
|
|
Le nouveau système est monté dans `/mnt` par l'installateur.
|
|
|
|
Montez les pseudo-systèmes nécessaires :
|
|
|
|
```sh
|
|
# mount -t proc /proc /mnt/proc
|
|
# mount --rbind /sys /mnt/sys
|
|
# mount --rbind /dev /mnt/dev
|
|
# mount --rbind /run /mnt/run
|
|
```
|
|
|
|
Copiez temporairement la configuration DNS :
|
|
|
|
```sh
|
|
# cp /etc/resolv.conf /mnt/etc/resolv.conf
|
|
```
|
|
|
|
Puis entrez dans le nouveau système :
|
|
|
|
```sh
|
|
# chroot /mnt /bin/bash
|
|
# source /etc/profile
|
|
```
|
|
|
|
En UEFI, vérifiez que la partition EFI est bien montée :
|
|
|
|
```sh
|
|
# findmnt /boot/efi
|
|
```
|
|
|
|
### Locale
|
|
|
|
Éditez le fichier :
|
|
|
|
```sh
|
|
# nvi /etc/profile.d/lang.sh
|
|
```
|
|
|
|
et utilisez par exemple :
|
|
|
|
```sh
|
|
export LANG=fr_FR.UTF-8
|
|
```
|
|
|
|
Si `csh` ou un de ses dérivés est utilisé, adaptez également `/etc/profile.d/lang.csh`.
|
|
|
|
### Synchronisation de l'heure
|
|
|
|
Pour synchroniser automatiquement l'horloge avec le pool public NTP, éditez le fichier :
|
|
|
|
```sh
|
|
# nvi /etc/ntp.conf
|
|
```
|
|
|
|
Le pilote d'horloge locale fourni dans le fichier par défaut est désormais déconseillé. Commentez :
|
|
|
|
```text
|
|
#server 127.127.1.0
|
|
#fudge 127.127.1.0 stratum 10
|
|
```
|
|
|
|
et ajoutez à la place :
|
|
|
|
```text
|
|
tos orphan 10
|
|
```
|
|
|
|
Laissez les quatre lignes `server` du pool public commentées et ajoutez :
|
|
|
|
```text
|
|
pool pool.ntp.org
|
|
tos minclock 4 minsane 3
|
|
tos maxclock 8
|
|
```
|
|
|
|
Dans la section des restrictions, conservez les règles existantes et ajoutez :
|
|
|
|
```text
|
|
restrict source limited kod nomodify notrap noquery
|
|
```
|
|
|
|
Cette règle autorise les associations dynamiques créées par `pool` sans retirer les restrictions appliquées par défaut aux autres sources.
|
|
|
|
Activez ensuite le service `ntpd` :
|
|
|
|
```sh
|
|
# chmod +x /etc/rc.d/rc.ntpd
|
|
```
|
|
|
|
Il sera démarré automatiquement avec le système. Une fois le service lancé, les associations peuvent être vérifiées avec :
|
|
|
|
```sh
|
|
# ntpq -n -p
|
|
```
|
|
|
|
### Slackpkg
|
|
|
|
Éditez le fichier :
|
|
|
|
```sh
|
|
# nvi /etc/slackpkg/mirrors
|
|
```
|
|
|
|
et décommentez un miroir pour Slackware64 15.0. Le miroir de redirection officiel convient très bien :
|
|
|
|
```text
|
|
https://mirrors.slackware.com/slackware/slackware64-15.0/
|
|
```
|
|
|
|
Puis initialisez `slackpkg` :
|
|
|
|
```sh
|
|
# slackpkg update gpg
|
|
# slackpkg update
|
|
```
|
|
|
|
> **Important :** si, comme dans ce guide, vous n'avez pas installé certaines séries de paquets, pensez à les ajouter à la blacklist. Sans cela, `slackpkg install-new` pourra notamment proposer de nouveaux paquets appartenant à ces séries lors d'une prochaine mise à jour.
|
|
|
|
Éditez le fichier :
|
|
|
|
```sh
|
|
# nvi /etc/slackpkg/blacklist
|
|
```
|
|
|
|
et ajoutez par exemple pour une station de travail KDE Plasma :
|
|
|
|
```text
|
|
e/
|
|
xfce/
|
|
```
|
|
|
|
ou pour un serveur sans interface graphique :
|
|
|
|
```text
|
|
e/
|
|
kde/
|
|
t/
|
|
tcl/
|
|
x/
|
|
xap/
|
|
xfce/
|
|
y/
|
|
```
|
|
|
|
### Noyau `generic`
|
|
|
|
Par défaut, le noyau `huge` est utilisé. Si vous préférez ne charger que les modules utiles à votre machine, vous pouvez passer au noyau `generic`. Slackware fournit pour cela `geninitrd`, qui génère `/boot/initrd.gz` pour le noyau pointé par `/boot/vmlinuz-generic` :
|
|
|
|
```sh
|
|
# geninitrd
|
|
```
|
|
|
|
Après cette commande, il faut normalement exécuter `grub-mkconfig` afin d'adapter la configuration de GRUB… mais comme GRUB n'est pas encore installé, la suite arrive juste après !
|
|
|
|
### GRUB
|
|
|
|
#### UEFI
|
|
|
|
```sh
|
|
# grub-install --target=x86_64-efi --bootloader-id=GRUB --efi-directory=/boot/efi
|
|
```
|
|
|
|
#### BIOS
|
|
|
|
Installez GRUB sur le disque entier, et non sur une partition :
|
|
|
|
```sh
|
|
# grub-install --target=i386-pc /dev/sda
|
|
```
|
|
|
|
Sur un VPS, le disque peut par exemple être `/dev/vda`, et sur un NVMe `/dev/nvme0n1`.
|
|
|
|
Générez ensuite le menu :
|
|
|
|
```sh
|
|
# grub-mkconfig -o /boot/grub/grub.cfg
|
|
```
|
|
|
|
## Utilisateur
|
|
|
|
Créez le premier utilisateur :
|
|
|
|
```sh
|
|
# adduser
|
|
```
|
|
|
|
## Station de travail KDE Plasma
|
|
|
|
Les réglages suivants concernent uniquement une station de travail avec interface graphique.
|
|
|
|
### Clavier X11
|
|
|
|
Même si **Plasma (Wayland)** est utilisé, X11 reste disponible comme solution de repli. Configurez donc également sa disposition de clavier.
|
|
|
|
Slackware 15.0 fournit deux fichiers de configuration, l'un pour `evdev` et l'autre pour `libinput`.
|
|
|
|
Copiez-les dans `/etc` :
|
|
|
|
```sh
|
|
# cp /usr/share/X11/xorg.conf.d/90-keyboard-layout-evdev.conf /etc/X11/xorg.conf.d/
|
|
# cp /usr/share/X11/xorg.conf.d/91-keyboard-layout-libinput.conf /etc/X11/xorg.conf.d/
|
|
```
|
|
|
|
Puis éditez les deux fichiers et remplacez :
|
|
|
|
```text
|
|
Option "XkbLayout" "us"
|
|
```
|
|
|
|
par :
|
|
|
|
```text
|
|
Option "XkbLayout" "fr"
|
|
```
|
|
|
|
Le réglage du clavier de la console, choisi pendant l'installation, est indépendant de celui de X11.
|
|
|
|
### Démarrage graphique
|
|
|
|
Éditez `/etc/inittab` :
|
|
|
|
```sh
|
|
# nvi /etc/inittab
|
|
```
|
|
|
|
et remplacez :
|
|
|
|
```text
|
|
id:3:initdefault:
|
|
```
|
|
|
|
par :
|
|
|
|
```text
|
|
id:4:initdefault:
|
|
```
|
|
|
|
## Fin
|
|
|
|
C'est terminé ! Vous pouvez sortir du `chroot` et redémarrer la machine :
|
|
|
|
```sh
|
|
# exit
|
|
# reboot
|
|
```
|
|
|
|
Au premier démarrage, résistez à la tentation d'installer quoi que ce soit : commencez par mettre Slackware 15.0 à jour. Elle a probablement quelques bricoles à rattraper depuis 2022 !
|
|
|
|
## Après l'installation
|
|
|
|
Quelques réglages propres à mes stations de travail KDE Plasma sont regroupés dans [docs/post-install.md](docs/post-install.md).
|
|
|
|
## Maintenance
|
|
|
|
### Mise à jour
|
|
|
|
Pour une mise à jour complète de Slackware 15.0 :
|
|
|
|
```sh
|
|
# slackpkg update
|
|
# slackpkg install-new
|
|
# slackpkg upgrade-all
|
|
```
|
|
|
|
`slackpkg clean-system` permet ensuite de retirer les paquets qui ne font plus partie de Slackware. Examinez attentivement la liste proposée : les paquets tiers y apparaissent également s'ils ne sont pas blacklistés.
|
|
|
|
```sh
|
|
# slackpkg clean-system
|
|
```
|
|
|
|
### Mise à jour du noyau
|
|
|
|
> **Important :** ne redémarrez pas avec un noyau `generic` mis à jour avant d'avoir régénéré l'initrd.
|
|
|
|
Avant de redémarrer :
|
|
|
|
```sh
|
|
# geninitrd
|
|
# grub-mkconfig -o /boot/grub/grub.cfg
|
|
```
|
|
|
|
## SlackBuilds.org et sbopkg
|
|
|
|
Vous souhaitez des logiciels supplémentaires ?
|
|
|
|
Faites un petit tour sur [SlackBuilds.org](https://slackbuilds.org/), qui fournit des SlackBuilds validés pour Slackware 15.0.
|
|
|
|
> Les SlackBuilds sont des « recettes » pour compiler les programmes sous Slackware.
|
|
|
|
Il est possible de les utiliser directement, mais la gestion manuelle des dépendances devient vite fastidieuse. Pour simplifier les choses, plusieurs outils existent. J'utilise `sbopkg`.
|
|
|
|
Cet outil est disponible [ici](https://www.sbopkg.org/downloads.php). Téléchargez le paquet, puis installez-le avec :
|
|
|
|
```sh
|
|
# installpkg sbopkg-*.tgz
|
|
```
|
|
|
|
Synchronisez le dépôt :
|
|
|
|
```sh
|
|
# sbopkg -r
|
|
```
|
|
|
|
Pour éviter que les paquets SlackBuilds.org soient proposés par `slackpkg clean-system`, décommentez dans `/etc/slackpkg/blacklist` :
|
|
|
|
```text
|
|
[0-9]+_SBo
|
|
```
|
|
|
|
Ajoutez également `sbopkg` à la blacklist pour conserver ce paquet.
|
|
|
|
### Installer des logiciels
|
|
|
|
Pour installer un paquet SlackBuilds.org sans dépendances supplémentaires :
|
|
|
|
```sh
|
|
# sbopkg -i <paquet>
|
|
```
|
|
|
|
Si des dépendances sont requises, générez d'abord une queue :
|
|
|
|
```sh
|
|
# sqg -p <paquet>
|
|
```
|
|
|
|
La queue est enregistrée dans `/var/lib/sbopkg/queues` et contient les dépendances dans le bon ordre.
|
|
|
|
Relancez ensuite :
|
|
|
|
```sh
|
|
# sbopkg -i <paquet>
|
|
```
|
|
|
|
Si `sbopkg` trouve à la fois le paquet et une queue du même nom, choisissez **Q** pour utiliser la queue et installer les dépendances dans le bon ordre.
|
|
|
|
### Mettre à jour les logiciels installés
|
|
|
|
Synchronisez d'abord le dépôt local, puis recherchez les mises à jour disponibles :
|
|
|
|
```sh
|
|
# sbopkg -r
|
|
# sbopkg -c
|
|
```
|
|
|
|
Créez ensuite une queue contenant les paquets à mettre à jour :
|
|
|
|
```sh
|
|
# sqg -p "<paquet1 paquet2 paquet3>" -o updates
|
|
# sbopkg -i updates
|
|
```
|
|
|
|
`sqg` ajoute automatiquement les dépendances nécessaires et les place dans le bon ordre.
|
|
|
|
Le fichier `updates.sqf` peut être supprimé et recréé à chaque mise à jour.
|
|
|
|
> `sbopkg -c` signale des mises à jour potentielles. Consultez le `README` du SlackBuild si une version nécessite une procédure particulière.
|
|
|
|
## Outils supplémentaires
|
|
|
|
* [Ruby avec rbenv depuis SlackBuilds.org](docs/ruby.md)
|
|
* [Neovim pour Ruby depuis SlackBuilds.org](docs/neovim.md)
|
|
* [Docker depuis SlackBuilds.org](docs/docker.md)
|
|
* [virt-manager depuis SlackBuilds.org](docs/virt-manager.md)
|
|
|
|
## Documentation
|
|
|
|
* [Installation de Slackware](https://docs.slackware.com/slackware:install)
|
|
* [Guide du débutant Slackware](https://docs.slackware.com/slackware:beginners_guide)
|
|
* [Slackpkg](https://docs.slackware.com/slackware:slackpkg)
|
|
* [Localisation](https://docs.slackware.com/slackware:localization)
|
|
* [Configuration du clavier](https://docs.slackware.com/howtos:window_managers:keyboard_layout)
|
|
* [SlackBuilds.org pour Slackware 15.0](https://slackbuilds.org/repository/15.0/)
|
|
* [sbopkg](https://www.sbopkg.org/)
|