Chapitre 9. Astuces du système

La simple utilisation de script(1) (consultez Section 1.4.9, « Enregistrer les actions de l’interpréteur de commandes ») pour enregistrer l’activité de l’interpréteur de commandes produit un fichier avec des caractères de contrôle. Cela peut être évité en utilisant col(1) comme suit :

$ script
Script started, file is typescript

faites quelque chose… et pressez Ctrl-D pour quitter script.

$ col -bx < typescript > cleanedfile
$ vim cleanedfile

Il existe d'autres méthodes pour enregistrer les activités des interpréteurs de commandes :

Dans la Section 1.4.2, « Personnaliser bash », deux astuces pour permettre une navigation rapide dans les répertoires sont décrites : $CDPATH et mc.

Si vous utilisez un programme de recherche approximative de texte, vous pouvez le faire sans taper le chemin exact. Pour fzf, incluez ce qui suit dans votre fichier ~/.bashrc :

FZF_KEYBINDINGS_PATH=/usr/share/doc/fzf/examples/key-bindings.bash
if [ -f $FZF_KEYBINDINGS_PATH ]; then
  . $FZF_KEYBINDINGS_PATH
fi

Par exemple :

Ces commandes en mode Ex peuvent être incluses dans le fichier traditionnel vimrc de l’utilisateur, « ~/.vimrc » ou « ~/.vim/vimrc » plus adapté à git. Voici un exemple très simple ^[2] :

""" Generic baseline Vim and Neovim configuration (~/.vimrc)
"""   - For NeoVim, use "nvim -u ~/.vimrc [filename]"
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
let mapleader = ' '             " :h mapleader
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
set nocompatible                " :h 'cp -- sensible (n)vim mode
syntax on                       " :h :syn-on
filetype plugin indent on       " :h :filetype-overview
set encoding=utf-8              " :h 'enc (default: latin1) -- sensible encoding
""" current vim option value can be verified by :set encoding?
set backspace=indent,eol,start  " :h 'bs (default: nobs) -- sensible BS
set statusline=%<%f%m%r%h%w%=%y[U+%04B]%2l/%2L=%P,%2c%V
set listchars=eol:¶,tab:⇄\ ,extends:↦,precedes:↤,nbsp:␣
set viminfo=!,'100,<5000,s100,h " :h 'vi -- bigger copy buffer etc.
""" Pick "colorscheme" from blue darkblue default delek desert elflord evening
""" habamax industry koehler lunaperche morning murphy pablo peachpuff quiet ron
""" shine slate torte zellner
colorscheme industry
""" don't pick "colorscheme" as "default" which may kill SpellUnderline settings
set scrolloff=5                 " :h 'scr -- show 5 lines around cursor
set laststatus=2                " :h 'ls (default 1)  k
""" boolean options can be unset by prefixing "no"
set ignorecase                  " :h 'ic
set smartcase                   " :h 'scs
set autoindent                  " :h 'ai
set smartindent                 " :h 'si
set nowrap                      " :h 'wrap
"set list                        " :h 'list (default nolist)
set noerrorbells                " :h 'eb
set novisualbell                " :h 'vb
set t_vb=                       " :h 't_vb -- termcap visual bell
set spell                       " :h 'spell
set spelllang=en_us,cjk         " :h 'spl -- english spell, ignore CJK
set clipboard=unnamedplus       " :h 'cb -- cut/copy/paste with other app
set hidden                      " :h 'hid
set autowrite                   " :h 'aw
set timeoutlen=300              " :h 'tm

Le plan de codage clavier de vim peut être modifié dans le fichier vimrc de l’utilisateur. Par exemple :

	Attention
	N'essayez pas de modifier les combinaisons de touches par défaut sans de très bonnes raisons.

""" Popular mappings (imitating LazyVim etc.)
""" Window moves without using CTRL-W which is dangerous in INSERT mode
nnoremap <C-H> <C-W>h
nnoremap <C-J> <C-W>j
nnoremap <C-K> <C-W>k
silent! nnoremap <C-L> <C-W>l
""" Window resize
nnoremap <C-LEFT> <CMD>vertical resize -2<CR>
nnoremap <C-DOWN> <CMD>resize -2<CR>
nnoremap <C-UP> <CMD>resize +2<CR>
nnoremap <C-RIGHT> <CMD>vertical resize +2<CR>
""" Clear hlsearch with <ESC> (<C-L> is mapped as above)
nnoremap <ESC> <CMD>noh<CR><ESC>
inoremap <ESC> <CMD>noh<CR><ESC>
""" center after jump next
nnoremap n nzz
nnoremap N Nzz
""" fast "jk" to get out of INSERT mode (<ESC>)
inoremap  jk <CMD>noh<CR><ESC>
""" fast "<ESC><ESC>" to get out of TERM mode (CTRL-\ CTRL-N)
tnoremap <ESC><ESC> <C-\><C-N>
""" fast "jk" to get out of TERM mode (CTRL-\ CTRL-N)
tnoremap jk <C-\><C-N>
""" previous/next trouble/quickfix item
nnoremap [q <CMD>cprevious<CR>
nnoremap ]q <CMD>cnext<CR>
""" buffers
nnoremap <S-H> <CMD>bprevious<CR>
nnoremap <S-L> <CMD>bnext<CR>
nnoremap [b <CMD>bprevious<CR>
nnoremap ]b <CMD>bnext<CR>
""" Add undo break-points
inoremap  , ,<C-G>u
inoremap  . .<C-G>u
inoremap  ; ;<C-G>u
""" save file
inoremap <C-S> <CMD>w<CR><ESC>
xnoremap <C-S> <CMD>w<CR><ESC>
nnoremap <C-S> <CMD>w<CR><ESC>
snoremap <C-S> <CMD>w<CR><ESC>
""" better indenting
vnoremap < <gv
vnoremap > >gv
""" terminal (Somehow under Linux, <C-/> becomes <C-_> in Vim)
nnoremap <C-_> <CMD>terminal<CR>
"nnoremap <C-/> <CMD>terminal<CR>
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
if ! has('nvim')
""" Toggle paste mode with <SPACE>p for Vim (no need for Nvim)
set pastetoggle=<leader>p
""" nvim default mappings for Vim.  See :h default-mappings in nvim
""" copy to EOL (no delete) like D for d
noremap Y y$
""" sets a new undo point before deleting
inoremap <C-U> <C-G>u<C-U>
inoremap <C-W> <C-G>u<C-W>
""" <C-L> is re-purposed as above
""" execute the previous macro recorded with Q
nnoremap Q @@
""" repeat last substitute and *KEEP* flags
nnoremap & :&&<CR>
""" search visual selected string for visual mode
xnoremap * y/\V<C-R>"<CR>
xnoremap # y?\V<C-R>"<CR>
endif

Pour que les combinaisons de touches ci-dessus fonctionnent correctement, le programme du terminal doit être configuré de manière à générer un « DEL ASCII » pour la touche Retour arrière et une « séquence d'échappement » pour la touche Suppression.

Diverses autres configurations peuvent être modifiées dans le fichier vimrc de l’utilisateur. Par exemple :

""" Use faster 'rg' (ripgrep package) for :grep
if executable("rg")
  set grepprg=rg\ --vimgrep\ --smart-case
  set grepformat=%f:%l:%c:%m
endif
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
""" Retain last cursor position :h '"
augroup RetainLastCursorPosition
  autocmd!
  autocmd BufReadPost *
    \ if line("'\"") > 0 && line ("'\"") <= line("$") |
    \   exe "normal! g'\"" |
    \ endif
augroup END
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
""" Force to use underline for spell check results
augroup SpellUnderline
  autocmd!
  autocmd ColorScheme * highlight SpellBad term=Underline gui=Undercurl
  autocmd ColorScheme * highlight SpellCap term=Underline gui=Undercurl
  autocmd ColorScheme * highlight SpellLocal term=Underline gui=Undercurl
  autocmd ColorScheme * highlight SpellRare term=Underline gui=Undercurl
augroup END
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
""" highlight tailing spaces except when typing as red (set after colorscheme)
highlight TailingWhitespaces ctermbg=red guibg=red
""" \s\+     1 or more whitespace character: <Space> and <Tab>
""" \%#\@<!  Matches with zero width if the cursor position does NOT match.
match TailingWhitespaces /\s\+\%#\@<!$/

Des paquets de greffon dans le paquet vim-scripts peuvent être activés en utilisant le fichier vimrc de l’utilisateur. Par exemple :

packadd! secure-modelines
packadd! winmanager
" IDE-like UI for files and buffers with <space>w
nnoremap <leader>w         :WMToggle<CR>

Le nouveau système de paquets natif de Vim fonctionne bien avec « git » et « git submodule ». Un tel exemple de configuration se trouve à mon dépôt git : dot-vim. Cela réalise essentiellement :

Pour en savoir plus, démarrez vim avec « vim --startuptime vimstart.log » pour vérifier la séquence d’exécution réelle et le temps passé pour chaque étape.

Il est assez déroutant de voir trop de façons^[3] de gérer et de charger ces paquets externes dans vim. Vérifier les informations originelles est la meilleure solution.

Consultez Section 3.4, « Messages du système » et Section 3.3, « Messages du noyau ».

Bien que des outils de visualisation de texte (« pager » tels que more(1) et less(1) (consulter la Section 1.4.5, « Le visualisateur de fichiers ») et des outils personnalisés de mise en évidence et de formatage (consulter la Section 11.1.8, « Mettre en évidence et formater des données en texte brut ») peuvent afficher des données textuelles de manière agréable, les éditeurs généralistes (consulter la Section 1.4.6, « L’éditeur de texte ») sont plus souples et paramétrables.

	Astuce
	Pour vim(1) et ses alias de visualisation de texte view(1), « :set hls » active la recherche avec mise en évidence.

Le format par défaut d’affichage de la date et de l’heure par la commande « "ls -l » dépend des paramètres régionaux (consulter la Section 1.2.6, « Horodatage » pour la valeur). La variable « $LANG » est d’abord visée, elle peut être surchargée par les variables d’environnement exportées « $LC_TIME » ou « $LC_ALL ».

Le format réel de l’affichage pour chaque paramètre linguistique dépend de la version de la bibliothèque C standard (paquet libc6) utilisée. Par exemple, les différentes versions de Debian ont des valeurs par défaut différentes. Pour les formats iso, consulter ISO 8601.

Si vous désirez vraiment personnaliser ce format d’affichage de la date et de l’heure plus loin que ne le fait locale, vous pouvez définir la valeur de style d’heure avec le paramètre « --time-style » ou par la valeur de « $TIME_STYLE » (consultez ls(1), date(1), « info coreutils 'ls invocation' »).

	Astuce
	Vous pouvez éviter de saisir une option longue sur la ligne de commande à l’aide de l’alias de commande (consulter la Section 1.5.9, « Alias de commande ») : alias ls='ls --time-style=+%d.%m.%y %H:%M'

L’écho de l’interpréteur de commandes sur la plupart des terminaux peut être colorisé en utilisant le code ANSI d’échappement (consultez « /usr/share/doc/xterm/ctlseqs.txt.gz »).

Essayez, par exemple, ce qui suit :

$ RED=$(printf "\x1b[31m")
$ NORMAL=$(printf "\x1b[0m")
$ REVERSE=$(printf "\x1b[7m")
$ echo "${RED}RED-TEXT${NORMAL} ${REVERSE}REVERSE-TEXT${NORMAL}"

Pour Vim, de la manière suivante :

Pour Emacs, de la manière suivante :

Il existe des outils spécialisés pour enregistrer les modifications apportées aux fichiers de configuration à l’aide de DVCS et pour créer des instantanés système sur Btrfs.

Vous pouvez également envisager l’approche de la Section 10.2.3, « Astuces de sauvegarde » avec un script local.

$ sudo fuser -v /var/log/mail.log
                     USER        PID ACCESS COMMAND
/var/log/mail.log:   root       2946 F.... rsyslogd

$ sudo fuser -v smtp/tcp
                     USER        PID ACCESS COMMAND
smtp/tcp:            Debian-exim   3379 F.... exim4

Vous savez maintenant que exim4(8) tourne sur votre système pour gérer les connexions TCP du port SMTP (25).

for x in *.ext; do if [ -f "$x"]; then command "$x" ; fi; done

find . -type f -maxdepth 1 -name '*.ext' -print0 | xargs -0 -n 1 command

find . -type f -maxdepth 1 -name '*.ext' -exec command '{}' \;

find . -type f -maxdepth 1 -name '*.ext' -exec sh -c "command '{}' && echo 'successful'" \;

Les exemple ci-dessus ont été écrits afin d’assurer une prise en compte correcte de noms de fichiers étranges tels que ceux qui comportent des espaces. Consultez Section 10.1.5, « Idiomes pour la sélection de fichiers » pour une utilisation avancée de find(1).

Pour l'interface en ligne de commande (CLI), le premier programme trouvé dans les répertoires spécifiés dans la variable d'environnement $PATH, et dont le nom correspond, est exécuté. Consulter Section 1.5.3, « La variable « $PATH » ».

Pour l’interface utilisateur graphique (GUI) conforme aux normes freedesktop.org, les fichiers *.desktop du dossier /usr/share/applications/ fournissent les attributs nécessaires pour l'affichage du menu graphique de chaque programme. Chaque paquet conforme au système de menu xdg de Freedesktop.org installe ses données de menu fournies par « *.desktop » sous « /usr/share/applications/ ». Les environnements de bureau modernes conformes à la norme Freedesktop.org utilisent ces données pour générer leur menu à l'aide du paquet xdg-utils. Consulter « /usr/share/doc/xdg-utils/README ».

Par exemple, le fichier chromium.desktop définit les attributs pour le "Navigateur Web Chromium" tel que "Name" pour le nom du programme, "Exec" pour le chemin et les paramètres d'exécution du programme, "Icon" pour l'icône utilisée, etc. (voir la Spécification d'Entrée de fichier Desktop) comme suit :

[Desktop Entry]
Version=1.0
Name=Chromium Web Browser
GenericName=Web Browser
Comment=Access the Internet
Comment[fr]=Explorer le Web
Exec=/usr/bin/chromium %U
Terminal=false
X-MultipleArgs=false
Type=Application
Icon=chromium
Categories=Network;WebBrowser;
MimeType=text/html;text/xml;application/xhtml_xml;x-scheme-handler/http;x-scheme-handler/https;
StartupWMClass=Chromium
StartupNotify=true

C’est une description extrêmement simplifiée. Les fichiers *.desktop sont analysés comme suit :

L'environnement de bureau définit les variables d'environnement $XDG_DATA_HOME et $XDG_DATA_DIR. Par exemple, sous GNOME 3 :

Les répertoires de base (voir Spécification du répertoire de base XDG et les répertoires des « applications » sont donc les suivants :

Les fichiers *.desktop sont parcourus dans ces répertoires applications dans cet ordre.

	Astuce
	Une entrée de menu « graphique » personnalisée peut être créée en ajoutant un fichier « *.desktop » dans le dossier « $HOME/.local/share/applications/ ».

	Astuce
	La ligne « Exec=... » n’est pas analysée par l’interpréteur. Utilisez la commande env(1) si des variables d’environnement doivent être définies.

	Astuce
	De la même façon, si un fichier « *.desktop » est créé dans le répertoire « autostart » dans ces répertoires de base, le programme spécifié dans le fichier « *.desktop » est exécuté automatiquement lorsque l'environnement de bureau est démarré. Consultez la Spécification de démarrage automatique d'applications.

Astuce

De la même façon, si un fichier « *.desktop » est créé dans le répertoire « $HOME/Desktop » et que l'environnement de bureau est configuré afin de prendre en charge l'exécution depuis une icône de bureau, le programme qui y est spécifié est exécuté lorsqu'on clique sur l'icône. Veuillez noter que le nom du répertoire « $HOME/Desktop » est dépendant de la localisation. Consultez xdg-user-dirs-update(1).

Utilisez cron(8) pour planifier des tâches qui s’exécutent régulièrement. Consultez crontab(1) et crontab(5).

Vous pouvez planifier le lancement des processus en tant qu’utilisateur normal, par exemple toto en créant un fichier crontab(5) file comme « /var/spool/cron/crontabs/toto » avec la commande « crontab -e ».

Voici un exemple de fichier crontab(5).

# use /usr/bin/sh to run commands, no matter what /etc/passwd says
SHELL=/bin/sh
# mail any output to paul, no matter whose crontab this is
MAILTO=paul
# Min Hour DayOfMonth Month DayOfWeek command (Day... are OR'ed)
# run at 00:05, every day
5  0  *  * *   $HOME/bin/daily.job >> $HOME/tmp/out 2>&1
# run at 14:15 on the first of every month -- output mailed to paul
15 14 1  * *   $HOME/bin/monthly
# run at 22:00 on weekdays(1-5), annoy Joe. % for newline, last % for cc:
0 22 *   * 1-5 mail -s "It's 10pm" joe%Joe,%%Where are your kids?%.%%
23 */2 1 2 *   echo "run 23 minutes after 0am, 2am, 4am ..., on Feb 1"
5  4 *   * sun echo "run at 04:05 every Sunday"
# run at 03:40 on the first Monday of each month
40 3 1-7 * *   [ "$(date +%a)" == "Mon" ] && command -args

	Astuce
	Sur un système qui ne tourne pas en permanence, installez le paquet anacron afin de planifier les tâches périodiques à des intervalles particulier dès que le temps de fonctionnement « uptime » de la machine le permet. Consultez anacron(8) et anacrontab(5).

	Astuce
	Vous pouvez lancer périodiquement les scripts de maintenance planifiée du système, depuis le compte de l’administrateur en les plaçant dans « /etc/cron.hourly/ », « /etc/cron.daily/ », « /etc/cron.weekly/ » ou « /etc/cron.monthly/ ». L"échéancier d’exécution de ces scripts peut être personnalisé dans « /etc/crontab » et « /etc/anacrontab ».

Systemd a une capacité de bas niveau pour planifier l’exécution de programmes sans démon cron. Par exemple, /lib/systemd/system/apt-daily.timer et /lib/systemd/system/apt-daily.service configurent des activités quotidiennes de téléchargement d’apt. Consulter systemd.timer(5) .

Systemd peut planifier des programmes non seulement pour des évènements d’horloge, mais aussi pour des évènements de montage. Consultez Section 10.2.3.3, « Sauvegarde déclenchée par des évènements d’horloge » et Section 10.2.3.2, « Sauvegarde déclenchée par des évènements de montage » pour des exemples.

Plus d’informations sur Guide de l'utilisateur et de l'administrateur du noyau Linux -> Linux Magic System Request Key Hacks.

	Astuce
	Depuis un terminal SSH, etc., vous pouvez utiliser la fonctionnalité Alt-SysRq en écrivant vers « /proc/sysrq-trigger ». Par exemple;, « echo s > /proc/sysrq-trigger; echo u > /proc/sysrq-trigger » depuis l’invite de l’interpréteur de commandes de l’administrateur syncs (synchronise) et umount (démonte) tous les systèmes de fichiers montés.

Le noyau Linux Debian amd64 actuel (2021) a /proc/sys/kernel/sysrq=438=0b110110110 :

Pour les périphériques similaires à PCI (AGP, PCI-Express, CardBus, ExpressCard, etc.), lspci(8) (probablement avec l’option « -nn ») est un bon point de départ pour l’identification du matériel.

Vous pouvez aussi identifier le matériel en lisant le contenu de « /proc/bus/pci/devices » ou en parcourant l’arborescence de répertoires se trouvant sous « /sys/bus/pci » (consultez Section 1.2.12, « procfs et sysfs »).

Ici, ACPI est une infrastructure de gestion de l’alimentation électrique du système plus récente qu’APM.

	Astuce
	L’ajustement de la fréquence d’horloge des processeurs modernes est gérée par des modules du noyaux tels que acpi_cpufreq.

# date MMDDhhmmCCYY
# hwclock --utc --systohc
# hwclock --show

Sur un système Debian, l’heure est normalement affichée en heure locale mais l’heure système et matérielle utilisent habituellement l’heure TUC(GMT).

Si l’heure matérielle est réglée en UTC, modifiez le réglage pour « UTC=yes » dans le fichier « /etc/default/rcS ».

La commande suivante relance la configuration du fuseau horaire utilisé par le système Debian.

# dpkg-reconfigure tzdata

Si vous désirez ajuster l’heure de votre système par l’intermédiaire du réseau, vous pouvez envisager l’utilisation du service NTP avec un paquet tel que ntp, ntpdate ou chrony.

	Astuce
	Sous systemd, utilisez plutôt systemd-timesyncdpour la synchronisation avec l'heure du réseau. Voir systemd-timesyncd(8).

Consultez ce qui suit.

	Astuce
	ntptrace(8) du paquet ntp peut suivre la trace d’une chaîne de serveurs NTP jusqu’à la source primaire.

Les pilotes de périphériques des cartes sons pour les versions actuelles de Linux sont fournies par Advanced Linux Sound Architecture (ALSA). ALSA fournit un mode d’émulation du système précédent Open Sound System (OSS) pour des raisons de compatibilité.

Les logiciels d’application peuvent être configurés non seulement pour accéder directement aux périphériques audio, mais aussi pour y accéder à l’aide d’un système de serveur audio standardisé. Actuellement, PulseAudio, JACK et PipeWire sont utilisés comme systèmes de serveur audio. Consulter la page wiki Debian sur Sound pour les dernières avancées.

Il y a habituellement un moteur de son commun pour chacun des environnements de bureau les plus courants. Chaque moteur de son utilisé par l’application peut choisir de se connecter à un serveur de son différent.

	Astuce
	Utilisez « cat /dev/urandom > /dev/audio » ou speaker-test(1) pour tester les hauts-parleurs (^C pour arrêter).

	Astuce
	Si vous n’arrivez pas à obtenir de sons, il est possible que votre haut-parleur soit connecté à une sortie muette (« muted »). Les systèmes de son modernes ont de nombreuses sorties. alsamixer(1) du paquet alsa-utils est pratique pour configurer les paramètres de volume et de coupure son.

Bien que fdisk(8) ait été considéré comme un standard pour la configuration de la partition du disque dur, parted(8) mérite une certaine attention. « Données de partition du disque », « table de partitions » et « Étiquette de disque » sont tous des synonymes.

Les anciens PC utilisent le schéma classique du MBR (Master Boot Record) (« enregistrement d'amorçage maître ») pour conserver les données de partitionnement du disque sur le premier secteur, c’est-à-dire, le secteur 0 LBA (512 octets).

Les PC récents avec une UEFI (Unified Extensible Firmware Interface) (« Interface micrologicielle extensible unifiée »), incluant les Mac basés sur Intel, utilisent le schéma GPT (GUID Partition Table) (« table de partitionnement GUID ») pour conserver les données de partitionnement du disque ailleurs que sur le premier secteur.

Alors que fdisk(8) a été l’outil standard de partitionnement de disque, parted(8) le remplace maintenant.

	Attention
	Bien que parted(8) prétend pouvoir créer et redimensionner aussi les systèmes de fichiers, il est plus sûr de toucher à ces choses-là en utilisant des outils spécialisés et bien maintenus tels que mkfs(8) (mkfs.msdos(8), mkfs.ext2(8), mkfs.ext3(8), mkfs.ext4(8), …) et resize2fs(8).

	Note
	De manière à passer de GPT à MBR, il vous faut d’abord effacer les premiers blocs du disque directement (consultez Section 9.8.6, « Effacer le contenu d’un fichier ») et utiliser « parted /dev/sdx mklabel gpt » ou « parted /dev/sdx mklabel msdos » afin de le mettre en place. Vous remarquerez que « msdos » est utilisé ici pour MBR.

LVM2 est un gestionnaire de volume logique pour le noyau Linux. Avec LVM2, les partitions peuvent être créées sur des volumes logiques plutôt que sur des disques durs physiques.

LVM requiert ce qui suit :

Démarrez l’apprentissage de LVM2 par la lecture des pages de manuel suivantes :

Pour le système de fichiers ext4, le paquet e2fsprogs fournit les éléments suivants :

Les commandes mkfs(8) et fsck(8) font partie du paquet e2fsprogs en tant que frontal à de nombreux programmes dépendant du système de fichiers (mkfs.fstype etfsck.fstype). Pour le système de fichiers ext4, il y a mkfs.ext4(8) et fsck.ext4(8) (ils sont liés par un lié symboliquement à mke2fs(8) ete2fsck(8)).

Des commandes semblables sont disponibles pour chaque système de fichiers pris en charge par Linux.

Astuce

Le système de fichiers ext4 est le système de fichiers par défaut pour les systèmes Linux. Son utilisation est fortement recommandée, sauf cas spécifiques. L’état de Btrfs peut être trouvé sur le wiki Debian sur btrfs et le wiki kernel.org sur btrfs. Il devrait être le prochain système de fichiers par défaut après le système de fichiers ext4. Certains outils permettent l’accès au système de fichiers sans prise en charge par le noyau Linux (consultez Section 9.8.2, « Manipulation des fichiers sans monter le disque »).

Les disques SSD (Solid State Drive) sont maintenant détectés automatiquement.

Réduisez les accès inutiles aux disques pour éviter l’usure du disque en montant « tmpfs » sur le chemin de données volatiles dans /etc/fstab.

Vous pouvez surveiller et enregistrer les disques durs conformes à SMART à l’aide du démon smartd(8).

	Astuce
	Le démon smartd(8) peut être personnalisé par l’intermédiaire du fichier /etc/smartd.conf y compris pour la manière d’être informé des avertissements.

Les partitions créées sur le gestionnaire de volumes logiques (LVM) (« Logical Volume Manager ») (fonctionnalité de Linux) au moment de l’installation peuvent être facilement redimensionnées en y concaténant des extensions (« extents ») ou en tronquant les extensions sur plusieurs périphériques de stockage sans reconfiguration majeure du système.

Si vous avez de l’espace utilisable sur une autre partition (p.ex., « /chemin/vers/espace_vide » et « /chemin/répertoire_travail »), vous pouvez y créer un répertoire et l’ajouter à un répertoire ancien (p.ex., « /chemin/vers/répertoire_ancien ») où vous avez besoin de place en utilisant OverlayFS pour les noyaux Linux 3.18 ou plus récents (Debian Stretch 9.0 ou plus récente).

$ sudo mount -t overlay overlay \
  -olowerdir=/path/to/old-dir,upperdir=/path/to/empty,workdir=/path/to/work

Ici, « /chemin/vers/espace_vide » et « /chemin/vers/répertoire_travail » doivent être des partitions autorisées en écriture et lecture pour écrire sur « /chemin/vers/répertoire_ancien ».

# cp /dev/sdb disk.img
# dd if=/dev/sdb of=disk.img

L’image disque du master boot record (MBR) (secteur principal d’amorçage) (consultez Section 9.6.2, « Configuration de la partition du disque ») qui se trouve sur le premier secteur du disque primaire IDE peut être faite en utilisant dd(1) comme suit :

# dd if=/dev/hda of=mbr.img bs=512 count=1
# dd if=/dev/hda of=mbr-nopart.img bs=446 count=1
# dd if=/dev/hda of=mbr-part.img skip=446 bs=1 count=66

Si vous avez un périphérique SCSI ou Serial ATA comme disque d’amorçage, remplacez « /dev/hda » avec « /dev/sda ».

Si vous réalisez une image d’une partition du disque d’origine, remplacez « /dev/hda » par « /dev/hda1 », etc.

L’image disque « partition.img », qui contient une partition image unique, peut être monté et démonté en utilisant le périphérique de rebouclage (loop device) de la manière suivante :

# losetup --show -f partition.img
/dev/loop0
# mkdir -p /mnt/loop0
# mount -t auto /dev/loop0 /mnt/loop0
...hack...hack...hack
# umount /dev/loop0
# losetup -d /dev/loop0

Cela peut être simplifié de la manière suivante :

# mkdir -p /mnt/loop0
# mount -t auto -o loop partition.img /mnt/loop0
...hack...hack...hack
# umount partition.img

Chaque partition de l’image disque « disk.img » contenant plusieurs partitions peut être montée en utilisant le périphérique de rebouclage (loop device).

# losetup --show -f -P disk.img
/dev/loop0
# ls -l /dev/loop0*
brw-rw---- 1 root disk   7,  0 Apr  2 22:51 /dev/loop0
brw-rw---- 1 root disk 259, 12 Apr  2 22:51 /dev/loop0p1
brw-rw---- 1 root disk 259, 13 Apr  2 22:51 /dev/loop0p14
brw-rw---- 1 root disk 259, 14 Apr  2 22:51 /dev/loop0p15
# fdisk -l /dev/loop0
Disk /dev/loop0: 2 GiB, 2147483648 bytes, 4194304 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
Disklabel type: gpt
Disk identifier: 6A1D9E28-C48C-2144-91F7-968B3CBC9BD1

Device         Start     End Sectors  Size Type
/dev/loop0p1  262144 4192255 3930112  1.9G Linux root (x86-64)
/dev/loop0p14   2048    8191    6144    3M BIOS boot
/dev/loop0p15   8192  262143  253952  124M EFI System

Partition table entries are not in disk order.
# mkdir -p /mnt/loop0p1
# mkdir -p /mnt/loop0p15
# mount -t auto /dev/loop0p1 /mnt/loop0p1
# mount -t auto /dev/loop0p15 /mnt/loop0p15
# mount |grep loop
/dev/loop0p1 on /mnt/loop0p1 type ext4 (rw,relatime)
/dev/loop0p15 on /mnt/loop0p15 type vfat (rw,relatime,fmask=0002,dmask=0002,allow_utime=0020,codepage=437,iocharset=ascii,shortname=mixed,utf8,errors=remount-ro)
...hack...hack...hack
# umount /dev/loop0p1
# umount /dev/loop0p15
# losetup -d /dev/loop0

En remplacement, des effets similaires peuvent être obtenus en utilisant les périphériques device mapper créés par kpartx(8) du paquet kpartx de la manière suivante :

# kpartx -a -v disk.img
add map loop0p1 (253:0): 0 3930112 linear 7:0 262144
add map loop0p14 (253:1): 0 6144 linear 7:0 2048
add map loop0p15 (253:2): 0 253952 linear 7:0 8192
# fdisk -l /dev/loop0
Disk /dev/loop0: 2 GiB, 2147483648 bytes, 4194304 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
Disklabel type: gpt
Disk identifier: 6A1D9E28-C48C-2144-91F7-968B3CBC9BD1

Device         Start     End Sectors  Size Type
/dev/loop0p1  262144 4192255 3930112  1.9G Linux root (x86-64)
/dev/loop0p14   2048    8191    6144    3M BIOS boot
/dev/loop0p15   8192  262143  253952  124M EFI System

Partition table entries are not in disk order.
# ls -l /dev/mapper/
total 0
crw------- 1 root root 10, 236 Apr  2 22:45 control
lrwxrwxrwx 1 root root       7 Apr  2 23:19 loop0p1 -> ../dm-0
lrwxrwxrwx 1 root root       7 Apr  2 23:19 loop0p14 -> ../dm-1
lrwxrwxrwx 1 root root       7 Apr  2 23:19 loop0p15 -> ../dm-2
# mkdir -p /mnt/loop0p1
# mkdir -p /mnt/loop0p15
# mount -t auto /dev/mapper/loop0p1 /mnt/loop0p1
# mount -t auto /dev/mapper/loop0p15 /mnt/loop0p15
# mount |grep loop
/dev/loop0p1 on /mnt/loop0p1 type ext4 (rw,relatime)
/dev/loop0p15 on /mnt/loop0p15 type vfat (rw,relatime,fmask=0002,dmask=0002,allow_utime=0020,codepage=437,iocharset=ascii,shortname=mixed,utf8,errors=remount-ro)
...hack...hack...hack
# umount /dev/mapper/loop0p1
# umount /dev/mapper/loop0p15
# kpartx -d disk.img

$ dd bs=1 count=0 if=/dev/zero of=disk.img seek=5G

Vous pouvez créer un système de fichiers ext4 sur cette image disque « disk.img » en utilisant le périphérique de rebouclage (loop device) de la manière suivante :

# losetup --show -f disk.img
/dev/loop0
# mkfs.ext4 /dev/loop0
...hack...hack...hack
# losetup -d /dev/loop0
$ du  --apparent-size -h disk.img
5.0G  disk.img
$ du -h disk.img
83M disk.img

Pour « disk.img », sa taille de fichier est de 5.0 Gio et son utilisation disque est uniquement de 83Mio. Cette discordance est possible car ext4 sait maintenir un fichier creux (sparse).

	Astuce
	L’utilisation réelle sur le disque du fichier creux croît au fur et à mesure qu’on y écrit des données .

En utilisant des opérations similaires sur les périphériques créés par loop device ou les périphériques device mapper comme dans Section 9.7.3, « Monter le fichier image du disque », vous pouvez partitionner cette image disque « disk.img » en utilisant parted(8) ou fdisk(8), et y créer un système de fichiers en utilisant mkfs.ext4(8), mkswap(8), etc.

On peut faire le fichier image ISO9660, « cd.iso », depuis l’arborescence de répertoire source située à « répertoire_source », en utilisant genisoimage(1) fourni parcdrkit de la manière suivante :

#  genisoimage -r -J -T -V volume_id -o cd.iso source_directory

De la même manière, on peut créer le fichier image ISO9660 amorçable « cdboot.iso » depuis une arborescence comme celle de debian-installer située en « source_directory », de la manière suivante :

#  genisoimage -r -o cdboot.iso -V volume_id \
   -b isolinux/isolinux.bin -c isolinux/boot.cat \
   -no-emul-boot -boot-load-size 4 -boot-info-table source_directory

Ici, le chargeur d’amorçage Isolinux (consultez Section 3.1.2, « Étage 2 : le chargeur initial ») est utilisé pour l’amorçage.

Vous pouvez calculer la valeur de la somme md5 (md5sum) et construire des image ISO9660 directement depuis un lecteur de CD-ROM de la manière suivante :

$ isoinfo -d -i /dev/cdrom
CD-ROM is in ISO 9660 format
...
Logical block size is: 2048
Volume size is: 23150592
...
# dd if=/dev/cdrom bs=2048 count=23150592 conv=notrunc,noerror | md5sum
# dd if=/dev/cdrom bs=2048 count=23150592 conv=notrunc,noerror > cd.iso

	Avertissement
	Vous devrez prendre garde d’éviter le bogue de lecture anticipée du système de fichiers ISO9660 de Linux comme ci-dessus afin d’obtenir les résultats corrects.

Les systèmes s’appuyant sur le RAID logiciel offert par le noyau Linux permettent une redondance des données au niveau du système de fichiers du noyau afin d’obtenir un haut niveau de fiabilité du système de stockage.

Il existe aussi des outils pour ajouter des données de redondance aux fichiers au niveau du programme applicatif permettant d’obtenir de hauts niveaux de fiabilité de stockage.

$ ls -li
total 0
2738405 -rw-r--r-- 1 root root 0 2008-09-15 20:21 bar
2738404 -rw-r--r-- 2 root root 0 2008-09-15 20:21 baz
2738404 -rw-r--r-- 2 root root 0 2008-09-15 20:21 foo

« tutu » et « toto » ont tous les deux un nombre de liens égal à "« 2 » (>1), ce qui indique qu’ils ont des liens physiques. Leur numéro d’inœud commun est « 2738404 ». Cela signifie qu’ils représentent le même fichier lié par des liens physiques. Si vous n’arrivez pas à trouver de fichiers liés par des liens physiques, vous pouvez les rechercher parinœud, par exemple « 2738404 », de la manière suivante :

# find /path/to/mount/point -xdev -inum 2738404

Vous pouvez chiffrer le contenu des périphériques de masse amovible, par exemple, une clé USB sur « /dev/sdx » en utilisant dm-crypt/LUKS. Il suffit de le formater de la manière suivante :

# fdisk /dev/sdx
... "n" "p" "1" "return" "return" "w"
# cryptsetup luksFormat /dev/sdx1
...
# cryptsetup open /dev/sdx1 secret
...
# ls -l /dev/mapper/
total 0
crw-rw---- 1 root root  10, 60 2021-10-04 18:44 control
lrwxrwxrwx 1 root root       7 2021-10-04 23:55 secret -> ../dm-0
# mkfs.vfat /dev/mapper/secret
...
# cryptsetup close secret

Ensuite, il peut être monté comme un disque normal sur « /media/nom_utilisateur/étiquette_disque », sauf pour la demande de mot de passe (consulter la Section 10.1.7, « Périphériques d’enregistrement amovibles ») dans un environnement de bureau moderne en utilisant le paquet udisks2. La différence est que toutes les données qui y sont écrites sont chiffrées. La saisie du mot de passe peut être automatisée à l’aide du trousseau de clés (consulter la Section 10.3.6, « Trousseau de mots de passe »).

Vous pouvez également formater les médias dans différents systèmes de fichiers, par exemple, ext4 avec « mkfs.ext4 /dev/mapper/sdx1 ». Si btrfs est utilisé à la place, le paquet udisks2-btrfs doit être installé. Pour ces systèmes de fichiers, il peut être nécessaire de configurer les propriétaires et les autorisations des fichiers.

Consulter le « Guide de l’utilisateur et de l’administrateur du noyau Linux -> Paramètres de ligne de commande du noyau » pour plus de détails.

Si vous utilisez un initrd dans Section 3.1.2, « Étage 2 : le chargeur initial », veuillez lire les informations correspondantes dans initramfs-tools(8), update-initramfs(8), mkinitramfs(8) et initramfs.conf(5).

	Avertissement
	Ne mettez pas de liens symboliques vers le répertoire de l’arborescence des source (par exemple « /usr/src/linux* ») depuis « /usr/include/linux » et « /usr/include/asm » lors de la compilation des sources du noyau de Linux. (Certains documents périmés le suggèrent.)

Note

Lors de la compilation du dernier noyau de Linux sous un système Debian stable, l’utilisation des derniers outils rétroportés depuis la distribution Debian unstable peuvent être nécessaires. module-assistant(8) (ou sa forme courte m-a) aide les utilisateurs à construire et installer facilement des paquets de module pour un ou plusieurs noyaux personnalisés. Le gestionnaire de modules dynamique du noyau (« dynamic kernel module support (DKMS) » est une nouvelle architecture indépendante de la distribution conçue pour permettre la mise à jour de modules individuels du noyau sans modifier l’ensemble du noyau. Cela est utilisé pour la maintenance de modules hors arborescence. Cela rend aussi très facile la reconstruction des modules après la mise à niveau des noyaux.

Le microprogramme est le code ou les données chargées sur le périphérique lié au système cible (par exemple le microcode de processeur, le code de rendu exécuté sur les processeurs graphiques, ou les données de FPGA ou de CPLD, etc.) Certains paquets de microprogramme sont disponibles sous forme de logiciel libre, mais beaucoup de paquets de microprogramme ne le sont pas car ils contiennent des données binaires sans les sources. L’installation de ces données de microprogramme est essentielle pour le bon fonctionnement du périphérique.

Veuillez noter que l'accès aux paquets non-free-firmware est fourni par le média d'installation officiel pour offrir une expérience d'installation fonctionnelle à l'utilisateur depuis Debian 12 Bookworm. La section non-free-firmware est décrite dans la Section 2.1.5, « Bases concernant l’archive Debian ».

Veuillez également noter que les données du microprogramme téléchargées par fwupd à partir de Linux Vendor Firmware Service et chargées dans le noyau Linux en cours d’exécution peuvent être non libres.

Il existe plusieurs plateformes d’outils de virtualisation et d'émulation :

La virtualisation des conteneurs utilise la Section 4.7.5, « Caractéristiques de sécurité de Linux » et c'est la technologie derrière la Section 7.7, « Bac à sable ».

Voici quelques paquets qui vous aideront à configurer le système virtualisé.

Consultez l’article de Wikipedia Comparaison de machines pour plateforme virtuelle pour une comparaison détaillée entre les différentes solutions de plateformes de virtualisation.

	Note
	Les noyaux par défaut de Debian prennent en charge KVM depuis lenny.

La virtualisation met en œuvre plusieurs étapes :

Pour le fichier image disque brut, consultez Section 8.1, « Les paramètres linguistiques (« locale ») ».

Pour d’autres fichiers d’images disques virtuels, vous pouvez utiliser qemu-nbd(8) pour les exporter en utilisant le protocole network block device et en les montant à l’aide du module nbd du noyau.

qemu-nbd(8) gère les formats de disques pris en compte par QEMU : raw, qcow2, qcow, vmdk, vdi, bochs, cow (mode utilisateur de Linux copy-on-write), parallels, dmg, cloop, vpc, vvfat (VFAT virtuelle) et host_device.

Le network block device peut gérer des partitions de la même manière que le périphérique de rebouclage (« loop device » (consultez Section 9.7.3, « Monter le fichier image du disque »). Vous pouvez monter la première partition de « disk.img » de la manière suivante :

# modprobe nbd max_part=16
# qemu-nbd -v -c /dev/nbd0 disk.img
...
# mkdir /mnt/part1
# mount /dev/nbd0p1 /mnt/part1

	Astuce
	Vous ne pouvez exporter que la première partition de « disk.img » en utilisant l’option « -P 1 » de qemu-nbd(8).

Si vous souhaitez essayer un nouvel environnement Debian à partir d’une console de terminal, je vous recommande d’utiliser chroot. Cela vous permet d’exécuter des applications console de Debian unstable et testing sans les risques habituels associés et sans redémarrage. chroot(8) est la méthode la plus basique.

	Attention
	Les exemples ci-dessous supposent que le système parent et le système chroot partagent la même architecture de CPU amd64.

Vous pouvez créer manuellement un environnement chroot(8) en utilisant debootstrap(1), cela demande des efforts non négligeables.

Le paquet sbuild pour construire les paquets Debian à partir des sources utilise l'environnement chroot géré par le paquet schroot. Il est livré avec un script d'aide sbuild-createchroot(1). Voyons comment il fonctionne en l'exécutant comme suit :

$ sudo mkdir -p /srv/chroot
$ sudo sbuild-createchroot -v --include=eatmydata,ccache unstable /srv/chroot/unstable-amd64-sbuild http://deb.debian.org/debian
 ...

Vous pouvez voir comment debootstrap(8) installe les données du système pour l’environnement unstable sous « /srv/chroot/unstable-amd64-sbuild » pour un système de construction minimal.

Vous pouvez vous connecter à cet environnement en utilisant schroot(1) :

$ sudo schroot -v -c chroot:unstable-amd64-sbuild

Vous voyez comment une interface système fonctionnant sous l'environnement unstable est créée.

	Note
	Le fichier « /usr/sbin/policy-rc.d », qui se termine toujours avec 101, évite que des programmes démons ne soient démarrés automatiquement sur le système Debian. Consulter « /usr/share/doc/init-system-helpers/README.policy-rc.d.gz ».

	Note
	Certains programmes sous chroot peuvent nécessiter l'accès à plus de fichiers du système parent pour fonctionner que ce que sbuild-createchroot fournit comme ci-dessus. Par exemple, « /sys », « /etc/passwd », « /etc/group », « /var/run/utmp », « /var/log/wtmp », etc., peuvent avoir besoin d'être montés par lien (« bind ») ou copiés.

	Astuce
	Le paquet sbuild aide à construire un système chroot et construit un paquet à l'intérieur du chroot en utilisant schroot comme dorsal. C'est un système idéal pour vérifier les dépendances de construction. Plus de détails sur sbuild sur le wiki Debian et l’exemple de configuration de sbuild dans le Guide pour les responsables Debian.

	Astuce
	La commande systemd-nspawn(1) aide à exécuter une commande ou un système d'exploitation dans un conteneur léger de manière similaire à chroot. Elle est plus puissante, car elle utilise des espaces de noms pour virtualiser pleinement arbre de processus, IPC, nom d’hôte, nom de domaine et, en option, réseau et bases de données utilisateur. Voir systemd-nspawn.

Si vous souhaitez essayer un nouvel environnement de bureau graphique de n'importe quel système d'exploitation, je vous recommande d'utiliser QEMU ou KVM sur un système Debian stable pour exécuter plusieurs systèmes de bureau en toute sécurité en utilisant la virtualisation. Cela vous permet d'exécuter n'importe quelle application de bureau, y compris celles de Debian unstable et testing sans les risques habituels qui y sont associés et sans redémarrage.

Comme un QEMU pur est très lent, il est recommandé de l’accélérer avec KVM lorsque le système hôte le prend en charge.

Virtual Machine Manager, également connu comme virt-manager, est un outil graphique pratique pour gérer les machines virtuelles KVM à l’aide de libvirt.

L’image disque virtuelle « virtdisk.qcow2 » qui contient un système Debian pour QEMU peut être créée en utilisant un CD minimal de debian-installer de la manière suivante :

$ wget https://cdimage.debian.org/debian-cd/5.0.3/amd64/iso-cd/debian-503-amd64-netinst.iso
$ qemu-img create -f qcow2 virtdisk.qcow2 5G
$ qemu -hda virtdisk.qcow2 -cdrom debian-503-amd64-netinst.iso -boot d -m 256
...

	Astuce
	Faire tourner d’autres distributions de GNU/Linux comme Ubuntu et Fedora sous une virtualisation est une bonne manière d’en étudier les astuces de configuration. D’autres systèmes d’exploitation propriétaires peuvent aussi tourner de manière agréable sous la virtualisation GNU/Linux.

Vous trouverez d'autres conseils sur le wiki Debian : virtualisation du système.