Chapitre 9. Astuces du système

# Chapitre 9. Astuces du système

Je décris ici les astuces de base pour configurer et gérer les systèmes, la plupart depuis la console.

## 9.1. Conseils pour la console

Quelques programmes utilitaires existent pour vous aider dans vos activités de console.

Tableau 9.1. Liste des programmes de prise en charge d'activités avec une console

paquet | popularité | taille | description
--- | --- | --- | ---
`mc` | V:43, I:183 | 1590 | consulter la Section 1.3, « Midnight Commander (MC) »
`bsdutils` | V:439, I:999 | 335 | `script`(1) commande permettant d'enregistrer une session de terminal
`screen` | V:54, I:199 | 1006 | multiplexeur de terminal avec une émulation de terminal VT100/ANSI
`tmux` | V:79, I:153 | 1292 | alternative de terminal multiple (utiliser « Control-B » à la place)
`fzf` | V:8, I:31 | 4651 | recherche approximative de texte
`fzy` | V:0, I:0 | 59 | recherche approximative de texte
`rlwrap` | V:1, I:12 | 328 | enveloppe de ligne de commande de la fonctionnalité readline
`ledit` | V:0, I:8 | 375 | enveloppe de ligne de commande de la fonctionnalité readline
`rlfe` | V:0, I:0 | 45 | enveloppe de ligne de commande de la fonctionnalité readline
`ripgrep` | V:9, I:30 | 5342 | recherche récursive rapide de chaines dans l’arborescence de code source avec filtrage automatique

### 9.1.1. Enregistrer proprement l’activité de la console

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 :

- utilisation de `tee` (utilisable pendant le processus de démarrage dans l'initramfs) :

      $ sh -i 2>&1 | tee typescript

- utilisation du `gnome-terminal` avec la mémoire tampon de lignes étendue pour le défilement ;

- utilisation de `screen` avec « `^A H` » (consulter la Section 9.1.2, « Le programme screen ») pour effectuer l’enregistrement de la console ;

- utilisation de `vim` avec « `:terminal` » pour entrer en mode terminal (utiliser « `Ctrl-W N` » pour quitter le mode terminal vers le mode normal et « `:w nom_fichier` » pour écrire le tampon dans un fichier ;

- utilisation d'`emacs` avec « `M-x shell` », « `M-x eshell` » ou « `M-x term` » pour accéder à la console d’enregistrement (utiliser « `C-x C-w` » pour écrire la mémoire tampon dans un fichier).

### 9.1.2. Le programme screen

`screen`(1) ne permet pas uniquement de faire tourner plusieurs processus dans une fenêtre de terminal, mais aussi à un processus de l’interpréteur de commandes distant de survivre à d’éventuelles interruptions de la connexion. Voici un scénario typique de `screen`(1) :

1. vous-vous connectez à une machine distante ;

2. vous démarrez `screen` sur une seule console ;

3. vous exécutez plusieurs programmes dans les fenêtres `screen` créées avec `^A c` (« Ctrl-A » suivi de « c ») ;

4. vous passez d’une des fenêtres multiples de `screen` à l’autre avec `^A n` (« Ctrl-A » suivi de « n ») ;

5. vous avez alors besoin de quitter votre terminal, mais vous ne voulez pas perdre votre travail en cours perdant la connexion.

6. vous pouvez détacher la session `screen` par différentes méthodes :

   - débrancher brutalement votre connexion réseau ;

   - entrer `^A d` (« Ctrl-A » suivi de « d ») et en quittant manuellement la connexion distante :

   - entrer `^A DD` (« Ctrl-A » suivi de « DD ») pour détacher `screen` et vous déconnecter.

7. Vous vous reconnectez à la même machine distante (même depuis un autre terminal) ;

8. Vous lancez `screen` avec « `screen -r` » ;

9. `screen` réattache magiquement toutes les fenêtres `screen` précédentes avec tous les programmes qui y tournent.

| Astuce
Avec `screen`, vous pouvez économiser des frais de connexion pour les connexions limitées, telles que les connexion commutées ou par paquets, parce que vous laissez un processus actif alors que vous êtes déconnecté. Vous pouvez le ré-attacher plus tard, lorsque vous vous reconnectez.

Dans une session `screen`, toutes les entrées clavier sont envoyées vers votre fenêtre actuelle sauf les séquences de touche de commande. Toutes les séquences de touche de commande `screen` sont entrées par `^A` (« Ctrl-A ») suivi d’un seule touche [plus les paramètres]. Voici celles dont il est important de se souvenir.

Tableau 9.2. Liste des raccourcis clavier de screen

affectation | signification
--- | ---
`^A ?` | afficher l’aide de screen (afficher les raccourcis clavier)
`^A c` | créer une nouvelle fenêtre et basculer vers celle-ci
`^A n` | aller à la fenêtre suivante
`^A p` | aller à la fenêtre précédente
`^A 0` | aller à la fenêtre 0
`^A 1` | aller à la fenêtre 1
`^A w` | afficher la liste des fenêtres
`^A a` | envoyer un Ctrl-A à la fenêtre actuelle en tant qu’entrée clavier
`^A h` | écrire dans un fichier une copie de la fenêtre actuelle
`^A H` | commencer et finir l’enregistrement de la fenêtre en cours vers un fichier
`^A ^X` | verrouiller le terminal (protégé par un mot de passe)
`^A d` | détacher la session screen du terminal
`^A DD` | détacher la session screen et se déconnecter

Consultez `screen`(1) pour davantage d’informations.

Consulter `tmux`(1) pour les fonctionnalités de la commande alternative.

### 9.1.3. Navigation dans les répertoires

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 :

- Vous pouvez accéder à un sous-répertoire très imbriqué avec un minimum d’efforts. Vous tapez d’abord «`cd **`» et appuyez sur `Tab`. Ensuite, vous recevrez une invite de commande avec les chemins des possibilités. La saisie de chaînes de chemin partiel, par exemple, `s/d/b toto`, réduira les chemins potentiels. Vous sélectionnez le chemin à utiliser avec `cd` et les curseur et touche Entrée ;

- Vous pouvez sélectionner une commande dans l’historique des commandes plus efficacement avec un minimum d’efforts. Vous appuyez sur `Ctrl-R` à l’invite de commandes. Ensuite, vous recevrez une invite avec les commandes potentielles. La saisie de chaînes de commande partielles, par exemple, `vim d`, réduira les possibilités. Vous sélectionnez celle à utiliser avec les curseur et touche Entrée.

### 9.1.4. Enveloppe pour Readline

Certaines commandes telles que `/usr/bin/dash`, qui ne disposent pas de la capacité d'édition de l'historique de lignes de commande, peuvent ajouter cette fonctionnalité de manière transparente en s'exécutant sous `rlwrap` ou ses équivalents.

     $ rlwrap dash -i

Cela fournit une plateforme pratique pour tester des points subtils de `dash` avec un environnement convivial de type `bash`.

### 9.1.5. Analyse de l’arborescence du code source

La commande `rg`(1) du paquet `ripgrep` offre une alternative plus rapide que la commande `grep`(1) pour analyser l’arborescence de code source à la recherche d’une situation typique. Il tire parti des processeurs multicœurs modernes et applique automatiquement des filtres satisfaisants pour ignorer certains fichiers.

## 9.2. Personnaliser vim

Après avoir appris les bases de `vim`(1) grâce à la Section 1.4.8, « Utilisation de vim », veuillez lire «Seven habits of effective text editing (2000)» (sept pratiques pour une édition efficace de texte) de Bram Moolenaar pour connaitre comment `vim` devrait être utilisé.

### 9.2.1. Personnalisation de vim avec des fonctionnalités internes

Le comportement de `vim` peut être modifié de manière significative en activant ses fonctionnalités internes à l’aide des commandes en mode `Ex` telles que « `set ...` » pour définir les options vim.

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\+\%#\@<!$/

### 9.2.2. Personnalisation de vim avec des paquets externes

Des paquets d'extensions externes intéressantes sont disponibles :

- Vim - l’éditeur de texte très répandu – le site officiel de l'amont de vim et des scripts pour vim ;

- VimAwsome – la liste des extensions de vim ;

- vim-scripts – paquet Debian : une collection de scripts pour vim.

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 :

- en utilisant «`git`» et «`git submodule`», les derniers paquets externes, tels que «`nom`», sont placés dans `~/.vim/pack/*/opt/nom` et similaires ;

- en ajoutant la ligne `:packadd! nom` au fichier vimrc de l’utilisateur, ces paquets sont placés dans `runtimepath`;

- vim charge ces paquets dans `runtimepath` lors de son initialisation ;

- à la fin de son initialisation, les étiquettes des documents installés sont mises à jour avec « `helptags ALL` ».

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.

Tableau 9.3. Informations sur l’initialisation de `vim`

saisies de clavier | information
--- | ---
`:help paquet` | explication sur le mécanisme des paquets vim
`:help runtimepath` | explication sur le mécanisme `runtimepath`
`:version` | états internes, y compris les fonctionnalités, pour le fichier vimrc
`:echo $VIM` | variable d’environnement « `$VIM` » utilisée pour localiser le fichier vimrc
`:set runtimepath?` | liste des répertoires dans lesquels rechercher tous les fichiers de prise en charge de l'environnement d’exécution
`:echo $VIMRUNTIME` | variable d’environnement « `$VIMRUNTIME` » utilisée pour localiser divers fichiers de prise en charge de l'environnement d’exécution fournis par le système

## 9.3. Enregistrer et présenter des données

### 9.3.1. Le démon de journal

De nombreux programmes traditionnels enregistrent leurs activités au format de fichier texte dans le répertoire « `/var/log/` ».

`logrotate`(8) est utilisée pour simplifier l’administration des fichiers journaux sur un système qui génère beaucoup de fichiers journaux.

De nombreux programmes récents enregistrent leurs activités au format de fichier binaire à l’aide du service Journal de `systemd-journald`(8) dans le répertoire « `/var/log/journal` ».

Vous pouvez consigner des données dans le Journal `systemd-journald`(8) à partir d’un script d’interpréteur à l’aide de la commande `systemd-cat`(1).

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

### 9.3.2. Analyseur de journaux

Voici les principaux analyseurs de journaux (« `~Gsecurity::log-analyzer` » dans `aptitude`(8)).

Tableau 9.4. Liste des analyseurs de journaux système

paquet | popularité | taille | description
--- | --- | --- | ---
`logwatch` | V:9, I:10 | 2435 | analyseur de journal avec une sortie sympathique en Perl
`fail2ban` | V:95, I:106 | 2191 | bannir les IP qui provoquent des erreurs d’authentification multiples
`analog` | V:3, I:88 | 3739 | analyseur des journaux du serveur web
`awstats` | V:5, I:8 | 6935 | analyseur des journaux du serveur web puissant ayant de nombreuses fonctionnalités
`sarg` | V:0, I:0 | 863 | générateur de rapport d’analyse de squid
`pflogsumm` | V:1, I:3 | 170 | résumer les entrées de journal de postfix
`fwlogwatch` | V:0, I:0 | 487 | analyseur des journaux du pare-feu
`squidview` | V:0, I:0 | 189 | surveiller et analyser les fichiers access.log de squid
`swatch` | V:0, I:0 | 99 | visualisateur de fichier journal avec correspondance d’expressions rationnelles, mise en évidence et « hooks »
`crm114` | V:0, I:0 | 1371 | analyseur et filtre de données diverses, dont les pourriels (CRM114)
`icmpinfo` | V:0, I:0 | 42 | interpréter les messages ICMP

| Note
CRM114 fournit une architecture de vocabulaire pour écrire des filtres fuzzy avec la bibliothèque d’expressions rationnelles TRE. Une de ses utilisations courantes est le filtrage des pourriels mais il peut aussi être utilisé pour l’analyse de journaux.

### 9.3.3. Affichage personnalisé des données de texte

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.

### 9.3.4. Affichage personnalisé de la date et de l’heure

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'` »).

Tableau 9.5. Exemples d’affichage pour la commande « `ls -l` » avec la valeur de style pour l’heure

valeur de style pour l’heure | locale | affichage de la date et l’heure
--- | --- | ---
`iso` | n’importe laquelle | `01-19 00:15`
`long-iso` | n’importe laquelle | `2009-01-19 00:15`
`full-iso` | n’importe laquelle | `2009-01-19 00:15:16.000000000 +0900`
`locale` | `C` | `Jan 19 00:15`
`locale` | `en_US.UTF-8` | `Jan 19 00:15`
`locale` | `es_ES.UTF-8` | `ene 19 00:15`
`+%d.%m.%y %H:%M` | n’importe laquelle | `19.01.09 00:15`
`+%d.%b.%y %H:%M` | `C` ou `en_US.UTF-8` | `19.Jan.09 00:15`
`+%d.%b.%y %H:%M` | `es_ES.UTF-8` | `19.ene.09 00:15`

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

### 9.3.5. Écho colorisé de l’interpréteur de commandes

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}"

### 9.3.6. Commandes colorisées

Les commandes colorisées sont pratiques pour examiner la sortie d’une commande dans l’environnement interactif. J’inclus ce qui suit dans mon fichier « `~/.bashrc` ».

    if [ "$TERM" != "dumb" ]; then
        eval "`dircolors -b`"
        alias ls='ls --color=always'
        alias ll='ls --color=always -l'
        alias la='ls --color=always -A'
        alias less='less -R'
        alias ls='ls --color=always'
        alias grep='grep --color=always'
        alias egrep='egrep --color=always'
        alias fgrep='fgrep --color=always'
        alias zgrep='zgrep --color=always'
    else
        alias ll='ls -l'
        alias la='ls -A'
    fi

L’utilisation d’alias réserve les effets de couleurs à l’utilisation interactives des commandes. Il a l’avantage sur l’exportation de la variable d’environnement « `export GREP_OPTIONS='--color=auto'` » car la couleur peut être affichée avec des programmes de visualisation (« pager » tels que `less`(1). Si vous souhaitez supprimer la couleur lors du tubage (« piping » à destination d’autres programmes, utilisez plutôt « `--color=auto` » dans l’exemple ci-dessus pour « `~/.bashrc` ».

| Astuce
Vous pouvez désactiver ces alias dans l’environnement interactif en appelant l’interpréteur de commandes par « `TERM=dumb bash` ».

### 9.3.7. Enregistrer l’activité de l’éditeur pour des répétitions complexes

Vous pouvez enregistrer l’activité de l’éditeur pour des répétitions complexes.

Pour Vim, de la manière suivante :

- « `qa` » : démarre l’enregistrement des caractères entrés dans le registre appelé « `a` ».

- … activité de l’éditeur

- « `q` » : termine l’enregistrement des caractères entrés.

- « `@a` » : exécute le contenu du registre « `a` ».

Pour Emacs, de la manière suivante :

- « :`C-x (` » : commencer la définition d’une macro clavier.

- … activité de l’éditeur

- « `C-x )` » : terminer la définition d’une macro clavier.

- « `C-x e` » : exécuter une macro clavier.

### 9.3.8. Enregistrer l’image graphique d’une application X

Il existe plusieurs manières d’enregistrer l’image graphique d’une application X, y compris un affichage `xterm`.

Tableau 9.6. Liste des outils de manipulation d’images

paquet | popularité | taille | écran | commande
--- | --- | --- | --- | ---
`gnome-screenshot` | V:13, I:111 | 1115 | Wayland | application de capture d’écran pour GNOME
`flameshot` | V:7, I:17 | 3532 | Wayland | application de capture d’écran pour steroid
`gimp` | V:35, I:229 | 31748 | Wayland + X | capture d’écran dans le menu de l’interface graphique
`x11-apps` | V:33, I:464 | 2461 | X | `xwd`(1)
`imagemagick` | I:290 | 77 | X | `import`(1)
`scrot` | V:4, I:53 | 141 | X | `scrot`(1)

### 9.3.9. Enregistrer les modifications dans des fichiers de configuration

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.

Tableau 9.7. Liste des paquets pouvant enregistrer l’historique de configuration

paquet | popularité | taille | description
--- | --- | --- | ---
`etckeeper` | V:24, I:27 | 157 | enregistrer les fichiers de configuration et leurs métadonnées avec Git (par défaut), Mercurial ou GNU Bazaar
`timeshift` | V:7, I:13 | 4481 | utilitaire de restauration du système utilisant rsync ou des instantanés BTRFS
`snapper` | V:6, I:8 | 2410 | outil de gestion d'instantané de systèmes de fichiers Linux

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

## 9.4. Surveiller, contrôler et démarrer l’activité des programmes

L’activité des programmes peut être surveillée et contrôlée à l’aide d’outils spécialisés.

Tableau 9.8. Liste des outils de surveillance et de contrôle de l’activité des programmes

paquet | popularité | taille | description
--- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | `nice`(1) : lancer un programme avec une priorité d’ordonnancement modifiée
`bsdutils` | V:439, I:999 | 335 | `renice`(1) : modifier la priorité d’ordonnancement d’un programme en cours d’exécution
`procps` | V:818, I:998 | 2404 | utilitaires du système de fichiers « `/proc` » : `ps`(1), `top`(1), `kill`(1), `watch`(1), …
`psmisc` | V:410, I:742 | 950 | utilitaires du système de fichiers « `/proc` » : `killall`(1), `fuser`(1), `peekfd`(1), `pstree`(1)
`time` | V:5, I:85 | 129 | `time`(1) : lancer un programme qui indique l’utilisation des ressources du système en fonction du temps
`sysstat` | V:123, I:162 | 1904 | `sar`(1), `iostat`(1), `mpstat`(1), … : outils de mesure des performances du système pour Linux
`isag` | V:0, I:3 | 109 | Générateur interactif de graphes de l’activité système pour sysstat
`lsof` | V:443, I:949 | 492 | `lsof`(8) : afficher la liste des fichiers ouverts par un processus en cours d’utilisation en utilisant l’option « `-p`
`strace` | V:10, I:103 | 3253 | `strace`(1) : tracer les appels système et les signaux
`ltrace` | V:0, I:11 | 420 | `ltrace`(1) : tracer les appels de bibliothèque
`xtrace` | V:0, I:0 | 353 | `xtrace`(1) : tracer la communication entre un client X11 et le serveur
`powertop` | V:33, I:232 | 696 | `powertop`(1) : information concernant la puissance électrique utilisée
`cron` | V:901, I:996 | 250 | faire tourner des processus en arrière plan selon un calendrier depuis le démon `cron`(8)
`anacron` | V:418, I:493 | 112 | ordonnanceur de type cron pour les systèmes qui ne tournent pas 24 heures sur 24
`at` | V:74, I:102 | 158 | `at`(1) ou `batch`(1) : lancer un travail à une heure déterminée ou en dessous d’un niveau de charge donné

| Astuce
Le paquet `procps` fournit des fonctions très basiques de surveillance, de contrôle et de lancement des activités du programme. Vous devriez toutes les apprendre.

### 9.4.1. Temps d’un processus

Afficher la durée du processus indiqué dans la commande.

    # time some_command >/dev/null
    real    0m0.035s       # time on wall clock (elapsed real time)
    user    0m0.000s       # time in user mode
    sys     0m0.020s       # time in kernel mode

### 9.4.2. La priorité d’ordonnancement

Une valeur de politesse (« nice » est utilisée pour contrôler la priorité d’ordonnancement du processus.

Tableau 9.9. Liste des valeurs de politesse pour la priorité d’ordonnancement

valeur de politesse | priorité d’ordonnancement
--- | ---
19 | la plus basse priorité d’un processus (poli)
0 | très haute priorité de processus pour un utilisateur
-20 | très haute priorité d’un processus pour root (non poli)

    # nice  -19 top                                      # very nice
    # nice --20 wodim -v -eject speed=2 dev=0,0 disk.img # very fast

Parfois, une valeur extrême de politesse (« nice ») fait plus de mal que de bien au système. Utilisez cette commande avec précaution.

### 9.4.3. La commande ps

La commande `ps`(1) sous Debian comporte à la fois les fonctionnalités de BSD et de SystemV, elle aide à identifier l’activité des processus de manière statique.

Tableau 9.10. Liste des styles de la commande ps

style | commande typique | fonction
--- | --- | ---
BSD | `ps aux` | afficher %CPU %MEM
System V | `ps -efH` | afficher le PPID

Les processus enfants zombies (« defunct ») peuvent être tués par l’identifiant du processus parent identifié dans le champ « `PPID` ».

La commande `pstree`(1) affiche une arborescence des processus.

### 9.4.4. La commande top

`top`(1) sous Debian a de riches fonctionnalités et aide à identifier de manière dynamique quels sont les processus qui ont une activité curieuse.

C'est un programme interactif en mode plein écran. Vous pouvez afficher l'aide sur son utilisation en tapant la touche « h » et la quitter en tapant la touche « q ».

### 9.4.5. Afficher les fichier ouverts par un processus

Vous pouvez afficher la liste des fichiers ouverts par un processus avec un identifiant de processus (PID), par exemple de 1 en faisant ce qui suit :

    $ sudo lsof -p 1

PID=1 est habituellement le programme `init`.

### 9.4.6. Tracer l’activité d’un programme

Vous pouvez tracer l’activité d’un programme avec `strace`(1), `ltrace`(1) ou `xtrace`(1) pour les appels système, les appels bibliothèque ou la communication entre le serveur et le client X11.

Vous pouvez tracer les appels système de la commande `ls` de la manière suivante :

    $ sudo strace ls

| Astuce
Utilisez le script strace-graph trouvé dans /usr/share/doc/strace/examples/ pour créer une belle arborescence.

### 9.4.7. Identification des processus qui utilisent des fichiers ou des sockets

Vous pouvez aussi identifier les processus qui utilisent des fichiers par `fuser`(1), par exemple pour « `/var/log/mail.log` » en faisant ce qui suit :

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

Vous voyez que le fichier « `/var/log/mail.log` » est ouvert en écriture par la commande `rsyslogd`(8).

Vous pouvez aussi identifier les processus qui utilisent des sockets par `fuser`(1), par exemple, pour « `smtp/tcp` » par ce qui suit :

    $ 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).

### 9.4.8. Répéter une commande avec un intervalle constant

`watch`(1) execute un programme de manière répétitive avec un intervalle constant tout en affichant sa sortie en plein écran.

    $ watch w

Cela permet l’affichage, mis à jour toutes les deux secondes, de qui est connecté au système.

### 9.4.9. Répéter une commande en bouclant entre des fichiers

Il existe plusieurs manières de répéter une boucle de commande entre des fichiers correspondant à une condition, par exemple, correspondant au motif « glob » « `*.ext` ».

- Méthode de la boucle « for» » de l’interpréteur de commandes (consultez Section 12.1.4, « Boucles de l’interpréteur de commandes ») :

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

- combinaison de `find`(1) et de `xargs`(1) :

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

- `find`(1) avec l’option « `-exec` » avec une commande :

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

- `find`(1) avec l’option « `-exec` » avec un court script de l’interpréteur :

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

### 9.4.10. Lancer un programme depuis l’interface graphique

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 :

The desktop environment sets `$XDG_DATA_HOME` and `$XDG_DATA_DIR` environment variables. For example, under the GNOME:

- « `$XDG_DATA_HOME` » n'est pas paramétré. (La valeur par défaut de « `$HOME/.local/share` » est utilisée.)

- « `$XDG_DATA_DIRS` » est paramétré à « `/usr/share/gnome:/usr/local/share/:/usr/share/` ».

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

- `$HOME/.local/share/` → `$HOME/.local/share/applications`

- `/usr/share/gnome/` → `/usr/share/gnome/applications/`

- `/usr/local/share/` → `/usr/local/share/applications`

- `/usr/share/` → `/usr/share/applications`

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

### 9.4.11. Personnaliser le programme à lancer

Certains programmes lancent automatiquement d’autres programmes. Voici des points-clés pour la personnalisation de ce processus :

- Menu de configuration des applications :

  - GNOME desktop: "Settings" → "Apps" → "Default Apps"

  - KDE desktop: "Application Launcher" → "System Settings" → "Default Applications"

  - navigateur Iceweasel : « Éditer » → « Préférences » → « Applications »

  - `mc`(1) : « `/etc/mc/mc.ext` »

- les variables d’environnement telles que « `$BROWSER` », « `$EDITOR` », « `$VISUAL` » et « `$PAGER` » (consulter `environ`(7))

- le système `update-alternatives`(1) pour des programmes tels que « `editor` », « `view` », « `x-www-browser` », « `gnome-www-browser` » et « `www-browser` » (consultez Section 1.4.7, « Définir un éditeur de texte par défaut »)

- le contenu des fichiers « `~/.mailcap` » et « `/etc/mailcap` » qui associe un type MIME avec un programme (consultez `mailcap`(5))

- le contenu des fichiers « `~/.mime.types` » et « `/etc/mime.types` » qui associe l’extension du nom de fichier avec un type MIME (consultez `run-mailcap`(1))

| Astuce
`update-mime`(8) met à jour le fichier ≤ `/etc/mailcap` » en utilisant le fichier « `/etc/mailcap.order` » (consultez `mailcap.order`(5)).

| Astuce
Le paquet `debianutils` fournit `sensible-browser`(1), `sensible-editor`(1), et `sensible-pager`(1) qui prennent des décisions raisonnables concernant l’éditeur, le visualisateur, le navigateur à appeler respectivement. Je vous recommande de lire ces scripts de l’interpréteur de commandes.

| Astuce

De façon à faire tourner une application de console telle que `mutt` sous environnement graphique en tant qu’application préférée, vous devriez créer une application graphique comme suit et définir « `/usr/local/bin/mutt-term` » comme étant votre application préférée à lancer comme suit :

    # cat /usr/local/bin/mutt-term <<EOF
    #!/bin/sh
    gnome-terminal -e "mutt \$@"
    EOF
    # chmod 755 /usr/local/bin/mutt-term

### 9.4.12. Tuer un processus

Utilisez `kill`(1) pour tuer (ou envoyer un signal à) un processus avec son identifiant de processus.

Utilisez `killall`(1) ou `pkill`(1) pour faire la même chose avec le nom de commande du processus et d’autres attributs.

Tableau 9.11. Liste des signaux couramment utilisés avec la commande kill

valeur du signal | nom du signal | action | remarque
--- | --- | --- | ---
0 | --- | aucun signal n'est envoyé (consulter `kill`(2)) | vérifier si le processus est en cours d'exécution
1 | SIGHUP | terminer le processus | terminal déconnecté (signal bloqué)
2 | SIGINT | terminer le processus | interruption à partir du clavier (`CTRL-C`)
3 | SIGQUIT | termine le processus et faire un dump core | quitter depuis le clavier (`CTRL-\`)
9 | SIGKILL | terminer le processus | signal kill imblocable
15 | SIGTERM | terminer le processus | signal kill blocable

### 9.4.13. Planifier des tâches qui s’exécutent une fois

Exécutez de la manière suivante la commande `at`(1) pour planifier un travail qui s’exécute une fois :

    $ echo 'command -args'| at 3:40 monday

### 9.4.14. Planifier des tâches qui s’exécutent régulièrement

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

### 9.4.15. Planifier des tâches lors d’évènements

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.

### 9.4.16. touche Alt-SysRq

Appuyer sur Alt-SysRq (Imp écr) suivi d’une touche fait reprendre magiquement le contrôle du système.

Tableau 9.12. Listes des touches notables de commande SAK (« Secure attention keys »)

touche suivant Alt-Sys | description de l’action
--- | ---
`k` | kill (tuer) tous les processus sur la console virtuelle actuelle (SAK)
`s` | synchroniser tous les systèmes de fichiers montés afin d'éviter la corruption des données
`u` | remonter en lecture seule tous les systèmes de fichiers montés (umount)
`r` | restaurer le clavier depuis le mode raw (brut) après un plantage de X

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` :

- 2 = 0x2 – contrôle du niveau de journalisation de la console (ON) ;

- 4 = 0x4 – contrôle du clavier (SAK, unraw) (ON) ;

- 8 = 0x8 – vidages de débogage des processus, etc. (OFF) ;

- 16 = 0x10 – activation de la commande sync (ON) ;

- 32 = 0x20 – remontage en lecture seule (ON) ;

- 64 = 0x40 – signalisation des processus (term, kill, oom-kill) (OFF) ;

- 128 = 0x80 – redémarrage/extinction (ON) ;

- 256 = 0x100 – définition de la priorité de toutes les tâches RT (ON).

## 9.5. Astuces de maintenance du système

### 9.5.1. Qui se trouve sur le système ?

Vous pouvez rechercher qui se trouve sur le système par les commandes suivantes :

- `who`(1) affiche qui est connecté ;

- `w`(1) affiche qui sont connectés et ce qu’ils font ;

- `last`(1) affiche une liste des derniers utilisateurs connectés ;

- `lastb`(1) affiche une liste des utilisateurs s’étant mal connectés.

| Astuce
« `/var/run/utmp` » et « `/var/log/wtmp` » conservent ces informations de l’utilisateur. Consultez `login`(1) et `utmp`(5).

### 9.5.2. Prévenir tout le monde

Vous pouvez envoyer un message à toutes les personnes connectées au système avec `wall`(1) en faisant ce qui suit :

    $ echo "We are shutting down in 1 hour" | wall

### 9.5.3. Identification du matériel

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 »).

Tableau 9.13. Listes des outils d’identification du matériel

paquet | popularité | taille | description
--- | --- | --- | ---
`pciutils` | V:254, I:992 | 280 | utilitaires PCI de Linux : `lspci`(8)
`usbutils` | V:80, I:887 | 322 | utilitaires USB de Linux : `lsusb`(8)
`nvme-cli` | V:22, I:30 | 2222 | utilitaires NVMe pour Linux : `nvme`(1)
`pcmciautils` | V:4, I:7 | 92 | utilitaires PCMCIA pour Linux : `pccardctl`(8)
`scsitools` | V:0, I:2 | 261 | collection d’outils pour la gestion des périphériques SCSI : `lsscsi`(8)
`procinfo` | V:0, I:6 | 149 | informations sur le système obtenues dans « `/proc` » : `lsdev`(8)
`lshw` | V:13, I:90 | 971 | informations concernant la configuration matérielle : `lshw`(1)
`discover` | V:27, I:685 | 81 | système d’identification du matériel : `discover`(8)

### 9.5.4. Configuration matérielle

Bien que l'essentiel de la configuration du matériel puisse être gérée au moyen des outils graphiques qui accompagnent les environnements de bureau graphiques modernes comme GNOME ou KDE, c’est une bonne idée de connaître certaines méthodes de base permettant de le configurer.

Tableau 9.14. Liste des outils de configuration du matériel

paquet | popularité | taille | description
--- | --- | --- | ---
`console-setup` | V:77, I:973 | 420 | fonte de la console Linux et utilitaires de table de caractères
`x11-xserver-utils` | V:312, I:542 | 559 | utilitaires pour le serveur X : `xset`(1), `xmodmap`(1)
`acpid` | V:58, I:90 | 158 | démon servant à gérer les événements délivrés par l’Interface avancée de configuration et de gestion de l’énergie ACPI (« Advanced Configuration and Power Interface »)
`acpi` | V:7, I:85 | 49 | utilitaire d’affichage des informations des périphériques ACPI
`sleepd` | V:0, I:0 | 84 | démon permettant de mettre un ordinateur portable en veille lorsqu’il est inactif
`hdparm` | V:117, I:222 | 246 | optimisation de l’accès aux disques durs (consultez Section 9.6.9, « Optimisation du disque dur »)
`smartmontools` | V:229, I:264 | 2455 | contrôle et surveillance des systèmes de stockage en utilisant S.M.A.R.T.
`setserial` | V:3, I:5 | 104 | collection d’outils pour gérer les ports série
`memtest86+` | V:0, I:19 | 12473 | collection d’outils pour gérer la mémoire physique
`scsitools` | V:0, I:2 | 261 | collection d’outils pour gérer le matériel SCSI
`setcd` | V:0, I:0 | 33 | optimisation de l’accès au lecteur de CD
`big-cursor` | I:0 | 26 | curseurs de souris plus grands pour X

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

### 9.5.5. Heure système et matérielle

Ce qui suit permet de définir l’heure du système et du matériel à MM/DD hh:mm, CCYY :

    # 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-timesyncd`pour la synchronisation avec l'heure du réseau. Voir `systemd-timesyncd`(8).

Consultez ce qui suit.

- Comment gérer précisément la date et l’heure

- Projet de services publics NTP

- Le paquet `ntp-doc`

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

### 9.5.6. Configuration du terminal

Il existe plusieurs composants pour configurer la console en mode caractères et les fonctionnalités du système `ncurses`(3).

- Le fichier « `/etc/terminfo/*/*` » (`terminfo`(5))

- La variable d’environnement « `$TERM` »(`term`(7))

- `setterm`(1), `stty`(1), `tic`(1) et `toe`(1)

Si l’entrée `terminfo` pour `xterm` ne fonctionne pas avec un `xterm` non Debian, changez le type de terminal dans « `$TERM` » de « `xterm` » pour une version limitée en fonctionnalités comme « `xterm-r6` » lorsque vous-vous connectez à distance à un système Debian. Consultez « `/usr/share/doc/libncurses5/FAQ` » pour davantage d’informations. « `dumb` » est le plus petit dénominateur commun pour « `$TERM` ».

### 9.5.7. L’infrastructure de gestion du son

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.

Tableau 9.15. Liste des paquets son

paquet | popularité | taille | description
--- | --- | --- | ---
`alsa-utils` | V:341, I:475 | 2702 | utilitaires de configuration et d’utilisation d’ALSA
`oss-compat` | V:0, I:10 | 18 | Compatibilité OSS sous ALSA évitant les erreurs « `/dev/dsp not found` »
`pipewire` | V:316, I:373 | 142 | serveur multimédia de moteur de traitement audio et vidéo – métapaquet
`pipewire-bin` | V:324, I:373 | 2094 | serveur multimédia de moteur de traitement audio et vidéo – programmes de serveur audio et en ligne de commande
`pipewire-alsa` | V:168, I:238 | 197 | serveur multimédia de moteur de traitement audio et vidéo – serveur audio pour remplacer ALSA
`pipewire-pulse` | V:280, I:340 | 64 | serveur multimédia de moteur de traitement audio et vidéo – serveur audio pour remplacer PulseAudio
`pulseaudio` | V:166, I:197 | 6606 | serveur PulseAudio
`libpulse0` | V:439, I:587 | 977 | bibliothèque de client pour PulseAudio
`jackd` | V:2, I:15 | 8 | serveur du kit de connexion audio JACK. (JACK) (faible latence)
`libjack0` | V:2, I:9 | 330 | bibliothèque du kit de connexion JACK. (JACK) (faible latence)
`libgstreamer1.0-0` | V:465, I:602 | 5280 | GStreamer : moteur de son de GNOME
`libphonon4qt5-4` | V:28, I:64 | 572 | Phonon : moteur de son de KDE

### 9.5.8. Désactiver l’économiseur d’écran

Pour désactiver l’écran de veille, utilisez les commandes suivantes :

Tableau 9.16. Liste des commandes pour désactiver l’économiseur d’écran

environnement | commande
--- | ---
Console Linux | `setterm -powersave off`
Système X Window (couper l’économiseur d’écran) | `xset s off`
X Window (désactive dpms) | `xset -dpms`
X Window (interface de configuration graphique d’économiseur d’écran) | `xscreensaver-command -prefs`

### 9.5.9. Désactiver les bips

On peut toujours débrancher le haut-parleur du PC pour désactiver les bips. La suppression du module du noyau `pcspkr` le fait pour vous.

Ce qui suit évite que le programme `readline`(3) utilisé par`bash`(1) ne bipe lors de l'apparition d'un caractère d'alerte (ASCII=7).

    $ echo "set bell-style none">> ~/.inputrc

### 9.5.10. Utilisation de la mémoire

Vous avez à votre disposition deux moyens d'obtenir l'état d'utilisation de la mémoire.

- Le message de démarrage du noyau dans « `/var/log/dmesg` » donne exactement la taille de la mémoire disponible.

- `free`(1) et `top`(1) affichent des informations concernant les ressources mémoire sur le système actif.

Voici un exemple.

    # grep '\] Memory' /var/log/dmesg
    [    0.004000] Memory: 990528k/1016784k available (1975k kernel code, 25868k reserved, 931k data, 296k init)
    $ free -k
                 total       used       free     shared    buffers     cached
    Mem:        997184     976928      20256          0     129592     171932
    -/+ buffers/cache:     675404     321780
    Swap:      4545576          4    4545572

Vous pourriez vous demander « dmesg me rapporte 990 Mo de mémoire libre et « free -k » me dit que 320 Mo sont libres. Il manque plus de 600 Mo… ».

Ne vous inquiétez pas de la taille importante de « `used` » et de la petite taille de « `free` » sur la ligne « `Mem:` », mais lisez ce qui se trouve sous celle-ci (675404 et 321780 dans l’exemple ci-dessous) et détendez-vous.

Pour mon MacBook avec 1Go=1048576k DRAM (la mémoire vidéo en prend une partie), je peux voir ce qui suit :

Tableau 9.17. Taille mémoire affichée

affiché | taille
--- | ---
Taille totale dans dmesg | 1016784k = 1Go - 31792k
Libre dans dmesg | 990528k
Total sous l’interpréteur de commandes | 997184k
Libre sous l’interpréteur de commandes | 20256k (mais réellement 321780k)

### 9.5.11. Vérification de la sécurité et de l’intégrité du système

Une mauvaise maintenance du système peut rendre votre système vulnérable à une attaque externe.

Pour la vérification de la sécurité et de l’intégrité du système, vous pouvez démarrer avec ce qui suit :

- Le paquet `debsums`, consultez `debsums`(1) et Section 2.5.2, « Fichier « Release » de plus haut niveau et authenticité ».

- Le paquet `chkrootkit`, consultez `chkrootkit`(1).

- La familles de paquets `clamav`, consultez `clamscan`(1) et `freshclam`(1).

- FAQ de sécurité Debian.

- Manuel de sécurisation de Debian.

Tableau 9.18. Liste d’outils pour la vérification de la sécurité et de l’intégrité du système

paquet | popularité | taille | description
--- | --- | --- | ---
`logcheck` | V:5, I:6 | 120 | démon pour poster à l’administrateur les anomalies des fichiers journaux du système
`debsums` | V:4, I:30 | 107 | utilitaire pour vérifier les fichiers des paquets installés d’après leur somme de contrôle MD5
`chkrootkit` | V:9, I:14 | 966 | détecteur de rootkit
`clamav` | V:8, I:39 | 33154 | utilitaire anti-virus pour UNIX ‑ interface en ligne de commandes
`tiger` | V:1, I:1 | 7800 | signale les vulnérabilités du système pour la sécurité
`tripwire` | V:1, I:1 | 5050 | vérificateur d’intégrité des fichiers et répertoires
`john` | V:1, I:7 | 469 | outils de casse des mots de passe actifs
`aide` | V:1, I:2 | 331 | Environnement avancé de détection d’intrusion (« Advanced Intrusion Detection Environment ») — bibliothèque statique
`integrit` | V:0, I:0 | 2939 | programme de vérification de l’intégrité des fichiers
`crack` | V:0, I:0 | 153 | programme pour deviner les mots de passe

Voici un script simple pour rechercher des fichiers typiques ayant des permissions incorrectes d’écriture pour tout le monde.

    # find / -perm 777 -a \! -type s -a \! -type l -a \! \( -type d -a -perm 1777 \)

| Attention
Comme le paquet `debsums` utilise des sommes de contrôle MD5 enregistrées de manière statique, on ne peut pas lui faire entièrement confiance comme outil d’audit de la sécurité envers des attaques malveillantes.

## 9.6. Astuces relatives au stockage des données

Booting your system as the Linux live system (see Section 3.2.2, « Linux live rescue system on USB » and Section 3.2.3, « Linux live rescue system from GRUB ») makes it easy for you to reconfigure data storage on the installed system.

Il se peut que vous deviez `umount`(8) certains périphériques manuellement à partir de la ligne de commande avant d'opérer sur eux s'ils sont automatiquement montés par le système de bureau graphique.

### 9.6.1. Utilisation de l’espace disque

L’utilisation de l’espace disque peut être estimée à l’aide de programmes fournis par les paquets `mount`, `coreutils` et `xdu` :

- `mount`(8) indique tous les systèmes de fichiers (disques) montés.

- `df`(1) indique l’espace disque occupé par les systèmes de fichiers.

- `du`(1) indique l’espace disque occupé par une arborescence de répertoires.

| Astuce
La sortie de `du`(1) peut être renvoyée vers `xdu`(1x) pour réaliser une présentation graphique et interactive avec « `du -k . |xdu` », « `sudo du -k -x / |xdu` », etc.

### 9.6.2. Configuration de la partition du disque

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.

Tableau 9.19. Listes de paquets de gestion de la partition du disque

paquet | popularité | taille | description
--- | --- | --- | ---
`util-linux` | V:897, I:999 | 4384 | divers utilitaires systèmes dont `fdisk`(8) et`cfdisk`(8)
`parted` | V:445, I:579 | 126 | programme GNU de redimensionnement des partitions Parted
`gparted` | V:13, I:92 | 2313 | éditeur de partitions de GNOME basé sur `libparted`
`gdisk` | V:20, I:309 | 940 | éditeur de partitions pour disque hybride GPT/MBR
`kpartx` | V:17, I:27 | 78 | programme pour créer des mappages de périphériques pour les partitions

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

### 9.6.3. Accès à une partition en utilisant l’UUID

Bien que la reconfiguration de votre partitionnement ou l’ordre d’activation des médias d’enregistrement amovibles puisse conduire à des noms de partition différents, vous pouvez toujours y accéder. Cela vous aidera aussi si vous avez plusieurs disques et que votre BIOS/UEFI ne leur donne pas toujours le même nom de périphérique.

- `mount`(8) avec l’option « `-U` » peut monter un périphérique en mode bloc en utilisant l’UUID plutôt que son nom de fichier de périphérique comme « `/dev/sda3` ».

- « `/etc/fstab` » (consultez `fstab`(5)) peut utiliser l’UUID.

- Les chargeurs initiaux (Section 3.1.2, « Étage 2 : le chargeur initial ») peuvent aussi utiliser UUID.

| Astuce
Vous pouvez tester l’UUID d’un périphérique spécial en mode bloc avec `blkid`(8). Vous pouvez également l’examiner et obtenir d'autres informations avec « `lsblk -f` ».

### 9.6.4. LVM2

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 :

- la prise en charge de device-mapper dans le noyau Linux (présent par défaut sur les noyaux Debian) ;

- la bibliothèque de prise en charge de device-mapper en espace utilisateur (paquet `libdevmapper*`) ;

- le paquet des outils LVM2 en espace utilisateur (`lvm2`).

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

- `lvm`(8) : les bases du mécanisme de LVM2 (liste de toutes les commandes LVM2) ;

- `lvm.conf`(5) : le fichier de configuration pour LVM2 ;

- `lvs`(8) : rapport d’informations sur les volumes logiques ;

- `vgs`(8) : rapport d’informations sur les groupes de volumes ;

- `pvs`(8) : rapport d’informations sur les volumes physiques.

### 9.6.5. Configuration de systèmes de fichiers

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

- `mkfs.ext4`(8) pour créer un nouveau système de fichiers ext4

- `fsck.ext4`(8) pour vérifier et réparer un système de fichiers ext4 existant

- `tune2fs`(8) pour configurer le superbloc d’un système de fichiers ext4

- `debugfs`(8) pour un débogage interactif du système de fichiers ext4. (Il possède la commande `undel` permettant de récupérer des fichiers effacés.)

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` et`fsck.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) et`e2fsck`(8)).

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

Tableau 9.20. Liste des paquets de gestion des systèmes de fichiers

paquet | popularité | taille | description
--- | --- | --- | ---
`e2fsprogs` | V:796, I:997 | 1549 | utilitaires pour les systèmes de fichiers ext2/ext3/ext4
`btrfs-progs` | V:48, I:76 | 5204 | utilitaire pour le système de fichiers Btrfs
`reiserfsprogs` | V:9, I:21 | 473 | utilitaire pour le système de fichiers Reiserfs
`zfsutils-linux` | V:31, I:32 | 1891 | utilitaires pour le système de fichiers OpenZFS
`dosfstools` | V:247, I:572 | 310 | utilitaire pour le système de fichiers FAT (Microsoft :MS-DOS, Windows)
`exfatprogs` | V:36, I:467 | 352 | utilitaires pour le système de fichiers exFAT entretenus par Samsung
`exfat-fuse` | V:2, I:50 | 73 | pilote de système de fichiers en lecture/écriture exFAT (Microsoft) pour FUSE
`xfsprogs` | V:36, I:86 | 4386 | utilitaire pour le système de fichiers XFS (SGI : IRIX)
`ntfs-3g` | V:193, I:527 | 1500 | pilote de système de fichiers en lecture/écriture NTFS (Microsoft : Windows NT, …) pour FUSE
`jfsutils` | V:0, I:7 | 1104 | utilitaire pour le système de fichiers JFS (IBM : AIX, OS/2)
`xorriso` | V:14, I:63 | 347 | utilities for the ISO-9660 filesystem and CD/DVD writing from libburnia
`wodim` | V:8, I:96 | 898 | command line CD/DVD writing tool from cdrkit
`genisoimage` | V:18, I:167 | 1567 | command line ISO-9660 filesystem tool from cdrkit
`reiser4progs` | V:0, I:1 | 1367 | utilitaire pour le système de fichiers Reiser4
`hfsprogs` | V:0, I:3 | 394 | utilitaire pour les systèmes de fichiers HFS et HFS Plus (Apple : Mac OS)
`zerofree` | V:5, I:119 | 30 | programme pour mettre à zéro les blocs libres des systèmes de fichiers ext2, ext3 et ext4

| 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 »).

### 9.6.6. Création et vérification de l’intégrité d’un système de fichiers

La commande `mkfs`(8) permet de créer un système de fichiers sur un système Linux. La commande `fsck`(8) permet de vérifier l’intégrité du système de fichiers et de le réparer sur un système Linux.

Maintenant, par défaut, Debian n'utilise pas `fsck` après la création d'un système de fichier.

| Attention
En général, il n’est pas sûr de faire tourner `fsck` sur un système de fichiers monté.

| Astuce

Vous pouvez exécuter la commande `fsck`(8) sans risque sur tous les systèmes de fichiers incluant le système de fichiers racine au redémarrage avec le paramètre "`enable_periodic_fsck`" dans "`/etc/mke2fs.conf`" et le compteur de montage maximum mis à 0 en utilisant "`tune2fs -c0 /dev/partition_name`". Voir `mke2fs.conf`(5) et `tune2fs`(8).

Vous trouverez les résultats de la commande `fsck`(8) lancée depuis le script de démarrage dans « `/var/log/fsck/` ».

### 9.6.7. Optimisation du système de fichiers à l’aide des options de montage

La configuration statique de base du système de fichiers est donnée par « `/etc/fstab` ». Par exemple,

    «file system»                   «mount point» «type» «options»    «dump» «pass»
    proc                                      /proc proc   defaults          0 0
    UUID=709cbe4c-80c1-56db-8ab1-dbce3146d2f7 /     ext4   errors=remount-ro 0 1
    UUID=817bae6b-45d2-5aca-4d2a-1267ab46ac23 none  swap   sw                0 0
    /dev/scd0                        /media/cdrom0  udf,iso9660 user,noauto  0 0

| Astuce
Un UUID (consultez Section 9.6.3, « Accès à une partition en utilisant l’UUID ») peut être utilisé pour identifier un périphérique bloc au lieu des noms de périphériques blocs normaux comme « `/dev/sda1` », ou « `/dev/sda2` »,…

Depuis Linux 2.6.30, le noyau utilise par défaut le comportement fourni par l’option « `relatime` ».

Consulter `fstab`(5) et `mount`(8).

### 9.6.8. Optimisation du système de fichiers à l’aide du superbloc

Les caractéristiques du système de fichiers peuvent être optimisées par l’intermédiaire de son superbloc en utilisant la commande `tune2fs`(8).

- L’exécution de « `sudo tune2fs -l /dev/sda1` » affiche le contenu du superbloc du système de fichiers situé sur « `/dev/sda1` ».

- L’exécution de « `sudo tune2fs -c 50 /dev/sda1` » modifie la fréquence des vérifications du système de fichiers (exécution de `fsck` lors du démarrage) à 50 démarrages sur « `/dev/sda1` ».

- L’exécution de la commande « `sudo tune2fs -j /dev/sda1` » ajoute la possibilité de journalisation au système de fichiers, c’est-à-dire la conversion de système de fichiers de ext2 vers ext3 sur « `/dev/sda1` » (effectuez cela sur un système de fichiers non monté).

- L’exécution de « `sudo tune2fs -O extents,uninit_bg,dir_index /dev/sda1 && fsck -pf /dev/sda1` » le convertit de ext3 vers ext4 sur « `/dev/sda1` ». (À effectuer sur un système de fichiers non monté.)

| Astuce
En dépit de son nom, `tune2fs`(8) ne fonctionne pas uniquement sur le système de fichiers ext2 mais aussi sur les systèmes de fichiers ext3 et ext4.

### 9.6.9. Optimisation du disque dur

| Avertissement
Veuillez vérifier votre matériel et lire la page de manuel `hdparm`(8) avant de jouer avec la configuration de vos disques durs parce que ce peut être assez dangereux pour l’intégrité des données.

Vous pouvez tester la vitesse de lecture d’un disque dur, par exemple « `/dev/sda` » par « `hdparm -tT /dev/sda` ». Vous pouvez accélérer certains disques (E)IDE avec « `hdparm -q -c3 -d1 -u1 -m16 /dev/sda` » en activant la prise en charge des E/S 32 bits (« (E)IDE 32-bit I/O support »), en positionnant l’indicateur d’utilisation de dma « using_dma flag », en positionnant l’indicateur de démasquage des interruptions (« interrupt-unmask flag ») et en positionnant les E/S multiples sur 15 secteurs (« multiple 16 sector I/O ») (dangereux !).

Vous pouvez tester la fonctionnalité de cache d’un disque dur, par exemple « `/dev/sda` » par « `hdparm -W /dev/sda` ». Vous pouvez désactiver le cache en écriture avec « `hdparm -W 0 /dev/sda` ».

Vous pouvez réussir à lire un CD-ROM vraiment mal pressé sur un lecteur de CD-ROM moderne rapide en le ralentissant avec « `setcd -x 2` ».

### 9.6.10. Optimisation du SSD

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

### 9.6.11. Utiliser SMART pour prédire les défaillances des disques durs

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

1. Activez la fonctionnalité SMART dans le BIOS.

2. Installez le paquet `smartmontools`.

3. Identifiez vos disques durs en affichant la liste avec `df`(1).

   - Supposons que le disque dur à surveiller soit « `/dev/sda` ».

4. Contrôlez la sortie de « `smartctl -a /dev/sda` » pour voir si la fonctionnalité SMART est effectivement activée.

   - Si elle ne l’est pas, activez-la avec « `smartctl -s on -a /dev/sda` ».

5. Autorisez le fonctionnement du démon `smartd`(8) par l’action suivante :

   - décommentez « `start_smartd=yes` » dans le fichier « `/etc/default/smartmontools` » ;

   - relancez le démon `smartd`(8) avec « `sudo systemctl restart smartmontools` ».

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

### 9.6.12. Indication du répertoire de stockage temporaire à l’aide de $TMPDIR

Les applications créent normalement des fichiers temporaires dans le répertoire de stockage temporaire « `/tmp` ». Si « `/tmp` » ne fournit pas assez d’espace, vous pouvez indiquer un autre répertoire de stockage temporaire à l’aide de la variable `$TMPDIR` pour les programmes qui l’intègrent.

### 9.6.13. Étendre l’espace de stockage utile à l’aide de LVM

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.

### 9.6.14. Extension de l’espace de stockage en montant une autre partition

Si vous avez une partition vide (par exemple « `/dev/sdx` »), vous pouvez la formater avec `mkfs.ext4`(1) et la monter (« `mount`(8) ») sur un répertoire où vous avez besoin de davantage d’espace (vous devrez copier les données d’origine).

    $ sudo mv work-dir old-dir
    $ sudo mkfs.ext4 /dev/sdx
    $ sudo mount -t ext4 /dev/sdx work-dir
    $ sudo cp -a old-dir/* work-dir
    $ sudo rm -rf old-dir

| Astuce
Vous pouvez aussi monter un fichier image de disque vide (consultez Section 9.7.5, « Réaliser le fichier image d’un disque vide ») en tant que périphérique de rebouclage (consultez Section 9.7.3, « Monter le fichier image du disque »). L’utilisation réelle du disque croît avec les données réellement enregistrées.

### 9.6.15. Extension de l’espace de stockage en remontant un autre répertoire

Si vous avez un répertoire vide (par exemple, « `/chemin/vers/répertoire-temporaire` ») sur une autre partition avec de l’espace disponible, vous pouvez le remonter avec l’option « `--bind` » vers un répertoire (par exemple « `répertoire-travail` ») où vous avez besoin de place.

    $ sudo mount --bind /path/to/emp-dir work-dir

### 9.6.16. Extension de l’espace de stockage utilisable en montant en superposition (overlay) un autre répertoire

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` ».

### 9.6.17. Extension de l’espace utilisable à l’aide de liens symboliques

| Attention
Il s'agit d'une méthode obsolète. Certains logiciels peuvent ne pas fonctionner correctement avec un « lien symbolique vers un répertoire ». Utilisez plutôt les approches de « montage » décrites ci-dessus.

Si vous avez un répertoire vide (par exemple, « `/chemin/vers/répertoire-temporaire` ») sur une autre partition avec de l’espace disponible, vous pouvez créer un lien symbolique vers ce répertoire avec `ln`(8).

    $ sudo mv work-dir old-dir
    $ sudo mkdir -p /path/to/emp-dir
    $ sudo ln -sf /path/to/emp-dir work-dir
    $ sudo cp -a old-dir/* work-dir
    $ sudo rm -rf old-dir

| Avertissement
N’utilisez pas de « liens symboliques vers un répertoire » pour un répertoire géré par le système comme par exemple « `/opt` ». De tels liens symboliques peuvent être écrasés lors de la mise à niveau du système.

## 9.7. Le fichier image du disque

Nous discutons ici des manipulations sur l’image disque.

### 9.7.1. Créer le fichier image du disque

The disk image file, "`disk.img`", of an unmounted device, e.g., the second SCSI or serial ATA drive "`/dev/sdb`", can be made by one of the following.

    # dd if=/dev/sdb of=disk.img; sync

    # cp /dev/sdb disk.img ; sync

    # cat /dev/sdb > disk.img ; sync

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/sda of=mbr.img bs=512 count=1
    # dd if=/dev/sda of=mbr-nopart.img bs=446 count=1
    # dd if=/dev/sda of=mbr-part.img skip=446 bs=1 count=66

- « `mbr.img` » : MBR avec la table des partitions

- « `mbr-nopart.img` » : MBR sans la table des partitions

- « `mbr-part.img` » : table de partition du MBR seul

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

### 9.7.2. Écrire directement sur le disque

The disk image file, "`disk.img`" can be written to an unmounted device, e.g., the second SCSI drive "`/dev/sdb`" with matching size, by one of the following.

    # dd if=disk.img of=/dev/sdb ; sync

    # cp disk.img /dev/sdb ; sync

    # cat disk.img >/dev/sdb ; sync

De la même manière, le fichier image de la partition du disque, « `partition.img` » peut être écrit sur une partition non montée, par exemple, la première partition du second disque SCSI « `/dev/sdb1` » avec la taille correspondante comme suit :

    # dd if=partition.img of=/dev/sdb1 ; sync

### 9.7.3. Monter le fichier image du disque

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

### 9.7.4. Nettoyage d’un fichier image du disque

Un fichier image disque « `disk.img` » peut être nettoyé de tous les fichiers supprimés pour donner une image propre « `new.img` » de la manière suivante :

    # mkdir old; mkdir new
    # mount -t auto -o loop disk.img old
    # dd bs=1 count=0 if=/dev/zero of=new.img seek=5G
    # mount -t auto -o loop new.img new
    # cd old
    # cp -a --sparse=always ./ ../new/
    # cd ..
    # umount new.img
    # umount disk.img

Si « `disk.img` » est un système de fichiers ext2, ext3 ou ext4, vous pouvez aussi utiliser `zerofree`(8) du paquet `zerofree` de la manière suivante :

    # losetup --show -f disk.img
    /dev/loop0
    # zerofree /dev/loop0
    # cp --sparse=always disk.img new.img
    # losetup -d /dev/loop0

### 9.7.5. Réaliser le fichier image d’un disque vide

Le fichier image du disque vide « `disk.img` », qui pourra s’étendre jusqu’à 5Gio peut être fait en utilisant `dd`(1) comme suit :

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

Au lieu d’utiliser `dd`(1), la fonction `fallocate`(8) spécialisée peut être utilisée ici.

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.

### 9.7.6. Créer un fichier image ISO9660

| Astuce
Both `genisoimage`(1) provided by cdrkit and `xorrisofs`(1) provided by Libburnia share the same command syntax except for the command name.

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.

### 9.7.7. Écriture directe sur CD/DVD-R/RW

| Astuce
DVD is only a large CD to `wodim`(1) provided by cdrkit and `xorrecord`(1) provided by Libburnia. These commands share the same command syntax except for the command name.

Vous pouvez rechercher un périphérique utilisable comme suit :

    # wodim --devices

Le CD-R vierge est alors inséré dans le graveur de CD et le fichier image ISO9660 « `cd.iso` » est écrit vers le périphérique, par exemple, « `/dev/sda` » en utilisant `wodim`(1) de la manière suivante :

    # wodim -v -eject dev=/dev/sda cd.iso

Si un CD-RW est utilisé à la place d’un CD-R, faites alors ce qui suit :

    # wodim -v -eject blank=fast dev=/dev/sda cd.iso

| Astuce
Si votre système de bureau monte automatiquement le CD, démontez-le par la commande « `sudo unmount /dev/sda` » depuis un terminal avant d’utiliser `wodim`(1).

### 9.7.8. Monter le fichier image ISO9660

Si « `cd.iso` » contient une image ISO9660, ce qui suit permet alors de le monter manuellement sur « `/cdrom` » :

    # mount -t iso9660 -o ro,loop cd.iso /cdrom

| Astuce
Les systèmes de bureau modernes peuvent monter automatiquement les supports amovibles tels que les CD formatés en ISO9960 (consultez Section 10.1.7, « Périphériques d’enregistrement amovibles »).

## 9.8. Les données binaires

Nous allons ici discuter de la manipulation directe des données binaires sur le support d’enregistrement.

### 9.8.1. Afficher et éditer des données binaires

La méthode la plus basique pour visualiser des données binaires est d’utiliser la commande « `od -t x1` ».

Tableau 9.21. Liste des paquets permettant de visualiser et d’éditer des données binaires

paquet | popularité | taille | description
--- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | paquet de base utilisant `od`(1) pour vider des fichiers (HEX, ASCII, OCTAL, …)
`bsdmainutils` | V:4, I:152 | 17 | paquets utilitaires qui utilisent `hd`(1) pour vider les fichiers (HEX, ASCII, OCTAL, …)
`hexedit` | V:1, I:8 | 70 | éditeurs et visualisateurs binaires (HEX, ASCII)
`bless` | V:0, I:1 | 924 | éditeur hexadécimal complet (GNOME)
`okteta` | V:1, I:12 | 1590 | éditeur hexadécimal complet (KDE4)
`ncurses-hexedit` | V:0, I:1 | 130 | éditeur et visualisateur binaire (HEX, ASCII, EBCDIC)
`beav` | V:0, I:0 | 137 | éditeur et visualisateur binaire (HEX, ASCII, EBCDIC, OCTAL, …)

| Astuce

HEX est utilisé comme l'acronyme du format hexadécimal en base 16. OCTAL désigne le format octal en base 8. ASCII est employé pour Code américain standard pour l’échange d’informations (« American Standard Code for Information Interchange ») c’est-à-dire le code pour texte normal en anglais. EBCDIC signifie Code d’échange étendu décimal codé binaire (« Extended Binary Coded Decimal Interchange Code »), il est utilisé avec par les systèmes d’exploitation des mainframe IBM.

### 9.8.2. Manipulation des fichiers sans monter le disque

Il existe des outils permettant de lire et d’écrire des fichiers sans avoir à monter le disque.

Tableau 9.22. Liste des paquets pour manipuler les fichiers sans monter le disque

paquet | popularité | taille | description
--- | --- | --- | ---
`mtools` | V:7, I:54 | 400 | utilitaires pour les fichiers MSDOS sans les monter
`hfsutils` | V:0, I:3 | 178 | utilitaires pour les fichiers HFS et HFS+ sans les monter

### 9.8.3. Redondance des données

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.

Tableau 9.23. Liste d’outils pour ajouter des données de redondance aux fichiers

paquet | popularité | taille | description
--- | --- | --- | ---
`par2` | V:10, I:119 | 298 | Parity Archive Volume Set, pour vérifier et réparer des fichiers
`dvdisaster` | V:0, I:1 | 1422 | protection des supports CD et DVD contre les pertes de données, les rayures et le vieillissement
`dvbackup` | V:0, I:0 | 413 | outil de sauvegarde utilisant des caméscopes MiniDV (fournissant `rsbep`(1))

### 9.8.4. Récupération de fichiers de données et analyse par autopsie

Il y a des outils pour la récupération des données et l’analyse par autopsie.

Tableau 9.24. Liste de paquets pour la récupération de données et l’analyse par autopsie

paquet | popularité | taille | description
--- | --- | --- | ---
`testdisk` | V:2, I:26 | 1495 | utilitaires pour l’examen de partitions et la récupération de disque
`magicrescue` | V:0, I:2 | 257 | utilitaire pour la récupération de fichiers et de recherche des octets magiques
`scalpel` | V:0, I:2 | 89 | récupérateur de fichiers sobre de haute performance
`myrescue` | V:0, I:2 | 83 | récupérer des données depuis des disques endommagés
`extundelete` | V:0, I:7 | 152 | utilitaire pour récupérer des fichiers effacés d’un système de fichiers ext3/4
`ext4magic` | V:0, I:3 | 235 | utilitaire pour récupérer des fichiers effacés d’un système de fichiers ext3/4
`ext3grep` | V:0, I:2 | 299 | outil pour aider à la récupération de fichiers effacés sur un système de fichiers ext3
`scrounge-ntfs` | V:0, I:1 | 49 | programme de récupération de données pour les systèmes de fichiers NTFS
`gzrt` | V:0, I:0 | 33 | boîte à outils de récupération gzip
`sleuthkit` | V:2, I:23 | 1729 | outil pour autopsie (« forensics analysis« ». (Sleuthkit)
`autopsy` | V:0, I:1 | 1026 | interface graphique à SleuthKit
`foremost` | V:0, I:4 | 102 | application d’autopsie pour la récupération de données
`guymager` | V:0, I:0 | 1047 | outil de création d’image d’autopsie basée sur Qt
`dcfldd` | V:0, I:2 | 113 | version améliorée de `dd` pour les autopsies et la sécurité

| Astuce
Vous pouvez annuler l'effacement de fichiers sur un système de fichiers ext2 en utilisant les commandes `list_deleted_inodes` et `undel` de `debugfs`(8) dans le paquet `e2fsprogs`.

### 9.8.5. Éclater un gros fichier en petits fichiers

Lorsque les données ont un volume trop important pour pouvoir être sauvegardée dans un seul fichier, vous pouvez en sauvegarder le contenu après l’avoir éclaté en morceaux de, par exemple, 2000Mio et réassembler ces morceaux par la suite sous la forme du fichier d’origine.

    $ split -b 2000m large_file
    $ cat x* >large_file

| Attention
Assurez-vous ne pas avoir de nom de fichier commençant par « `x` » afin d’éviter des plantages de nom.

### 9.8.6. Effacer le contenu d’un fichier

Pour effacer le contenu d’un fichier comme, par exemple, un fichier journal, n’utilisez pas la commande `rm`(1) pour supprimer le fichier et recréer ensuite un fichier vide parce qu’on peut encore accéder au fichier dans l’intervalle entre les commandes. Voici la manière sûre d’effacer le contenu d’un fichier :

    $ :>file_to_be_cleared

### 9.8.7. Fichiers fictifs

Les commandes suivantes créent des fichiers factices ou vides.

    $ dd if=/dev/zero    of=5kb.file bs=1k count=5
    $ dd if=/dev/urandom of=7mb.file bs=1M count=7
    $ touch zero.file
    $ : > alwayszero.file

Vous obtiendrez les fichiers suivants :

- « `5kb.file` » avec 5K de zéros ;

- « `7mb.file` » avec 7Mo de données aléatoires ;

- « `zero.file` » devrait être un fichier de 0 octet. S’il existait, son `mtime` est mis à jour alors que son contenu et sa taille sont conservés ;

- « `alwayszero.file` fait toujours 0 octet. S’il existait son `mtime` est mis à jour et son contenu vidé.

### 9.8.8. Effacer l’ensemble du disque dur

There are several ways to completely erase data from an entire hard disk like device, e.g., USB flash drive at "`/dev/sda`".

| Attention
Check your USB flash drive location with `mount`(8) first before executing commands here. The device pointed by "`/dev/sda`" may be SCSI hard disk or serial-ATA hard disk where your entire system resides.

Effacer tout le contenu du disque en réinitialisant toutes les données à 0 avec la commande suivante :

    # dd if=/dev/zero of=/dev/sda

Tout effacer en écrasant les données existantes par des données aléatoires par la commande suivante :

    # dd if=/dev/urandom of=/dev/sda

Effacer de manière très efficace toutes les données en les écrasant avec des données aléatoires par la commande suivante :

    # shred -v -n 1 /dev/sda

Vous pouvez également utiliser `badblocks`(8) avec l'option `-t random`.

Comme `dd`(1) est disponible depuis l’interpréteur de commandes de nombreux CD amorçables de Linux tels que le CD de l’installateur Debian, vous pouvez effacer complètement votre système installé en lançant la commande d’effacement du disque dur du système, par exemple, « `/dev/sda` », « `/dev/sda` », etc. depuis un tel média.

### 9.8.9. Effacer l’ensemble du disque dur

Unused area on an hard disk (or USB flash drive), e.g. "`/dev/sdb1`" may still contain erased data themselves since they are only unlinked from the filesystem. These can be cleaned by overwriting them.

    # mount -t auto /dev/sdb1 /mnt/foo
    # cd /mnt/foo
    # dd if=/dev/zero of=junk
    dd: writing to `junk': No space left on device
    ...
    # sync
    # umount /dev/sdb1

| Avertissement
This is usually good enough for your USB flash drive. But this is not perfect. Most parts of erased filenames and their attributes may be hidden and remain in the filesystem.

### 9.8.10. Récupérer des fichiers supprimés mais encore ouverts

Même si vous avez accidentellement supprimé un fichier, tant que ce fichier est en cours d’utilisation par une application quelconque, (en mode lecture ou écriture), il est possible de récupérer un tel fichier.

Essayez, par exemple, ce qui suit :

    $ echo foo > bar
    $ less bar
    $ ps aux | grep ' less[ ]'
    bozo    4775  0.0  0.0  92200   884 pts/8    S+   00:18   0:00 less bar
    $ rm bar
    $ ls -l /proc/4775/fd | grep bar
    lr-x------ 1 bozo bozo 64 2008-05-09 00:19 4 -> /home/bozo/bar (deleted)
    $ cat /proc/4775/fd/4 >bar
    $ ls -l
    -rw-r--r-- 1 bozo bozo 4 2008-05-09 00:25 bar
    $ cat bar
    foo

Exécutez sur un autre terminal (lorsque vous avez le paquet `lsof` installé) comme suit :

    $ ls -li bar
    2228329 -rw-r--r-- 1 bozo bozo 4 2008-05-11 11:02 bar
    $ lsof |grep bar|grep less
    less 4775 bozo 4r REG 8,3 4 2228329 /home/bozo/bar
    $ rm bar
    $ lsof |grep bar|grep less
    less 4775 bozo 4r REG 8,3 4 2228329 /home/bozo/bar (deleted)
    $ cat /proc/4775/fd/4 >bar
    $ ls -li bar
    2228302 -rw-r--r-- 1 bozo bozo 4 2008-05-11 11:05 bar
    $ cat bar
    foo

### 9.8.11. Rechercher tous les liens physiques

Les fichiers ayant des liens physiques peuvent être identifiés par « `ls -li` ».

    $ 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

### 9.8.12. Consommation d’espace disque invisible

Tous les fichiers supprimés mais ouverts prennent de l’espace disque même s’ils ne sont pas visibles par la commande `du`(1) normale. On peut en afficher la liste avec leur taille par la commande suivante :

    # lsof -s -X / |grep deleted

## 9.9. Astuces de chiffrement des données

Avec un accès physique à votre PC, n’importe qui peut facilement obtenir les privilèges de l’administrateur et accéder à tous les fichiers de votre PC (consultez Section 4.6.4, « sécuriser le mot de passe de l’administrateur »). Cela signifie qu’un système avec un mot de passe de connexion ne permet pas de sécuriser vos données personnelles ou sensibles en cas de vol de votre PC. Vous devez déployer des technologies de chiffrements des données pour assurer cette protection. Bien que GNU privacy guard (consultez Section 10.3, « Infrastructure de sécurité des données ») puisse chiffrer des fichiers, il demande quelques efforts de la part de l’utilisateur.

Dm-crypt facilite le chiffrement automatique des données à l’aide des modules natifs du noyau Linux avec un minimum d'efforts de l'utilisateur en utilisant device-mapper.

Tableau 9.25. Liste d’utilitaires de chiffrement des données

paquet | popularité | taille | description
--- | --- | --- | ---
`cryptsetup` | V:30, I:80 | 465 | utilitaires pour chiffrer un périphérique en mode bloc (dm-crypt / LUKS)
`cryptmount` | V:2, I:2 | 231 | utilitaires pour chiffrer un périphérique en mode bloc (dm-crypt / LUKS), l’accent étant mis sur le montage et le démontage par un utilisateur normal
`fscrypt` | V:0, I:1 | 6471 | utilitaires pour le chiffrement du système de fichiers Linux (fscrypt)
`libpam-fscrypt` | V:0, I:0 | 5589 | module PAM pour le chiffrement du système de fichiers Linux (fscrypt)

| Attention
Le chiffrement des données a un coût en matière de temps processeur, etc. Les données chiffrées deviennent inaccessibles si leur mot de passe est perdu. Veuillez peser les avantages et le coût.

| Note
Le système Debian dans son ensemble peut être installé sur un disque chiffré par l’installateur debian (lenny ou plus récent) en utilisant dm-crypt/LUKS et initramfs.

| Astuce
Consultez Section 10.3, « Infrastructure de sécurité des données » pour un utilitaire de chiffrement de l’espace utilisateur : GNU Privacy Guard.

### 9.9.1. Chiffrement des disques amovibles à l’aide de dm-crypt/LUKS

You can encrypt contents of removable mass devices, e.g. USB flash drive on "`/dev/sdx`", using dm-crypt/LUKS. You simply format it as the following.

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

### 9.9.2. Monter des disques amovibles chiffrés à l’aide de dm-crypt/LUKS

Par exemple, une partition de disque chiffrée créée avec dm-crypt/LUKS sur « `/dev/sdc5` » par l'installateur Debian peut être montée sur « `/mnt` » comme suit :

    $ sudo cryptsetup open /dev/sdc5 ninja --type luks
    Enter passphrase for /dev/sdc5: ****
    $ sudo lvm
    lvm> lvscan
      inactive          '/dev/ninja-vg/root' [13.52 GiB] inherit
      inactive          '/dev/ninja-vg/swap_1' [640.00 MiB] inherit
      ACTIVE            '/dev/goofy/root' [180.00 GiB] inherit
      ACTIVE            '/dev/goofy/swap' [9.70 GiB] inherit
    lvm> lvchange -a y /dev/ninja-vg/root
    lvm> exit
      Exiting.
    $ sudo mount /dev/ninja-vg/root /mnt

## 9.10. Le noyau

Debian distribue des noyaux Linux modulaires sous forme de paquets pour les architectures prises en compte.

Si vous lisez cette documentation, vous n'avez probablement pas besoin de compiler le noyau Linux par vous-même.

### 9.10.1. Paramètres du noyau

De nombreuses fonctionnalités du noyau peuvent être configurées par l’intermédiaire de paramètres du noyau de la manière suivante :

- Paramètres du noyau initialisés par le gestionnaire d’amorçage (consultez Section 3.1.2, « Étage 2 : le chargeur initial »)

- Paramètres du noyau modifiés par `sysctl`(8) lors du fonctionnement du système pour ceux auxquels on a accès par l’intermédiaire de sysfs (consultez Section 1.2.12, « procfs et sysfs »)

- Paramètres des modules définis par les paramètres de `modprobe`(8) lors de l’activation d’un module (consultez Section 9.7.3, « Monter le fichier image du disque »)

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.

### 9.10.2. En-têtes du noyau

La plupart des programmes normaux n’ont pas besoin des en-têtes du noyau et peuvent de fait être cassés si vous les utilisez directement pour la compilation. Ils devront être compilés avec les en-têtes se trouvant dans « `/usr/include/linux` » et « `/usr/include/asm` » qui sont fournis, sur les systèmes Debian, par le paquet `libc6-dev` (créé à partir du paquet source `glibc`).

| Note
Pour compiler certains programmes spécifiques au noyau, tels que les modules du noyau, à partir de la source externe et du démon automonteur (`amd`), vous devez inclure le chemin d’accès aux en-têtes de noyau correspondants, par exemple « `-I/usr/src/linux-particular-version/include/` », à votre ligne de commande.

### 9.10.3. Compiler le noyau et les modules associés

Debian a sa propre manière de compiler le noyau et les modules associés.

Tableau 9.26. Liste des paquets-clés à installer pour la compilation du noyau sur un système Debian

paquet | popularité | taille | description
--- | --- | --- | ---
`build-essential` | I:504 | 17 | paquets essentiels pour la construction de paquets Debian : `make`, `gcc`, …
`bzip2` | V:168, I:972 | 114 | utilitaires de compression et de décompression des fichiers bz2
`libncurses5-dev` | I:40 | 6 | bibliothèques de développement et documentations pour ncurses
`git` | V:382, I:597 | 50172 | git : système distribué de gestion de versions utilisé par le noyau de Linux
`fakeroot` | V:31, I:507 | 225 | fournit l’environnement fakeroot pour construire le paquet sans être administrateur (« root »)
`initramfs-tools` | V:479, I:988 | 52 | outil pour construire une image mémoire initiale (« initramds ») (spécifique à Debian)
`dkms` | V:74, I:146 | 235 | prise en charge dynamique des modules du noyau (dynamic kernel module support : DKMS) (générique)
`module-assistant` | V:0, I:14 | 391 | outil d’aide pour empaqueter un module (spécifique à Debian)
`devscripts` | V:5, I:33 | 2770 | scripts d’assistance pour un responsable de paquet Debian (spécifique à Debian)

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.

### 9.10.4. Compiler les sources du noyau : recommandations de l’équipe en charge du noyau Debian

Pour construire des paquets binaires d’un noyau personnalisé à partir des sources du noyau amont, vous devriez utiliser la cible « `deb-pkg` » fournie pour cela.

    $ sudo apt-get build-dep linux
    $ cd /usr/src
    $ wget https://mirrors.edge.kernel.org/pub/linux/kernel/v6.x/linux-version.tar.xz
    $ tar --xz -xvf linux-version.tar.xz
    $ cd linux-version
    $ cp /boot/config-version .config
    $ make menuconfig
     ...
    $ make deb-pkg

| Astuce
Le paquet linux-source-version fournit les sources du noyau Linux avec les correctifs Debian en tant que « `/usr/src/linux-version.tar.bz2` ».

Pour construire des paquets binaires particuliers à partir du paquet source Debian, vous devriez utiliser les cibles « `binary-arch_architecture_jeu_de_fonctionnalités_saveur` » dans « `debian/rules.gen` ».

    $ sudo apt-get build-dep linux
    $ apt-get source linux
    $ cd linux-3.*
    $ fakeroot make -f debian/rules.gen binary-arch_i386_none_686

Consultez les renseignements complémentaires :

- wiki Debian : KernelFAQ ;

- wiki Debian : DebianKernel ;

- Manuel du noyau Linux pour Debian : https://kernel-handbook.debian.net.

### 9.10.5. Pilotes de matériel et microprogramme

Le pilote de matériel est le code s’exécutant sur le CPU principal du système cible. La plupart des pilotes de matériel sont maintenant disponibles sont forme de logiciels libres et font partie des paquets normaux de Debian pour le noyau dans la section `main`.

- Pilote de processeur graphique

  - Pilote Intel (`main`)

  - Pilote AMD ou ATI (`main`)

  - Pilote NVIDIA (`main` pour le pilote nouveau et `non-free` pour les pilotes binaires pris en charge par le constructeur)

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.

- Paquets de données de microprogramme contenant les données chargées dans la mémoire volatile de l’équipement cible :

  - firmware-linux-free (`main`)

  - firmware-linux-nonfree (`non-free-firmware`)

  - firmware-linux-* (`non-free-firmware`)

  - *-firmware (`non-free-firmware`)

  - intel-microcode (`non-free-firmware`)

  - amd64-microcode (`non-free-firmware`)

- Paquets de mise à jour du microprogramme, qui mettent à jour les données sur la mémoire non volatile du périphérique cible :

  - fwupd (`main`) : démon de mise à jour de microprogramme qui télécharge les données du microprogramme à partir de Linux Vendor Firmware Service

  - gnome-firmware (`main`) : interface en GTK pour fwupd

  - plasma-discover-backend-fwupd (`main`) : interface en Qt pour fwupd

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

## 9.11. Système virtualisé

L’utilisation d’un système virtualisé permet de faire tourner simultanément plusieurs instances du système sur une plateforme unique.

| Astuce
Consulter le wiki de Debian à propos de la virtualisation du système.

### 9.11.1. Outils de virtualisation et d’émulation

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

- paquets d’émulation matérielle complète, tels que ceux installés par le métapaquet games-emulator ;

- émulation principalement au niveau du processeur avec certaines émulations de périphérique d’E/S, telle que QEMU ;

- virtualisation principalement au niveau du processeur avec certaines émulations de périphérique d'E/S, telle que KVM (machine virtuelle basée sur le noyau) ;

- virtualisation de conteneurs au niveau du système d’exploitation avec prise en charge au niveau du noyau, telle que LXC (Linux Containers), Docker, `systemd-nspawn`(1), etc. ;

- virtualisation de l’accès au système de fichiers au niveau du système d’exploitation avec le contournement de l’appel système de bibliothèque pour le chemin d’accès au fichier, telle que chroot ;

- virtualisation de l’accès au système de fichiers au niveau du système d’exploitation avec contournement de l’appel système de bibliothèque pour le propriétaire du fichier, tel que fakeroot ;

- émulation d’API du système d’exploitation, telle que Wine ;

- virtualisation au niveau de l’interpréteur avec sa sélection d’exécutables et ses contournements de bibliothèque d’exécution, telle que virtualenv et venv pour Python.

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

Tableau 9.27. Liste des outils de virtualisation

paquet | popularité | taille | description
--- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | utilitaires centraux GNU contenant `chroot`(8)
`util-linux` | V:897, I:999 | 4384 | miscellaneous system utilities which contain `unshare`(1)
`systemd-container` | V:72, I:76 | 2276 | outils conteneur/nspawn de systemd contenant `systemd-nspawn`(1)
`schroot` | V:5, I:7 | 2627 | outil spécialisé pour l’exécution d’un paquet binaire de Debian dans un chroot
`sbuild` | V:1, I:4 | 157 | outil pour construire des paquets binaires de Debian depuis les sources Debian
`debootstrap` | V:4, I:46 | 330 | amorcer un système Debian de base (écrit en sh)
`mmdebstrap` | V:5, I:10 | 574 | amorcer un système Debian (écrit en Perl)
`cdebootstrap` | V:0, I:1 | 114 | amorcer un système Debian (écrit en C)
`cloud-image-utils` | V:0, I:14 | 66 | utilitaires de gestion d’image d’infonuagique
`cloud-guest-utils` | V:4, I:18 | 71 | utilitaires de client d’infonuagique
`virt-manager` | V:12, I:49 | 2310 | gestionnaire de machine virtuelle : application de bureau pour la gestion des machines virtuelles
`libvirt-clients` | V:49, I:72 | 1155 | programmes pour la bibliothèque libvirt
`incus` | V:0, I:2 | 21 | Incus: gestionnaire de conteneur de système et de machine virtuelle
`podman` | V:25, I:29 | 81828 | podman: moteur pour exécuter des conteneurs basés sur OCI dans des « Pod »
`podman-docker` | V:2, I:2 | 275 | moteur pour exécuter des conteneurs basés sur OCI dans des « Pod » – enveloppe pour docker
`docker.io` | V:44, I:47 | 95958 | docker: environnement d’exécution de conteneur Linux
`games-emulator` | I:0 | 21 | games-emulator : émulateur de jeux de Debian
`bochs` | V:0, I:0 | 8180 | Bochs : émulateur PC IA-32
`qemu-system` | I:22 | 80 | QEMU : binaires pour l’émulation d’un système complet
`qemu-user` | V:5, I:9 | 464225 | QEMU : binaires pour l’émulation en mode utilisateur
`qemu-utils` | V:14, I:109 | 12157 | QEMU : utilitaires
`qemu-system-x86` | V:53, I:93 | 67511 | KVM : virtualisation complète sur les plateformes x86 ayant une virtualisation assistée par le matériel
`virtualbox` | V:3, I:4 | 151525 | VirtualBox : solution de virtualisation x86 sur i386 et amd64
`gnome-boxes` | V:1, I:6 | 6847 | Boxes: application simple de GNOME d’accès aux systèmes virtuels
`xen-tools` | V:0, I:1 | 719 | outils pour gérer le serveur virtuel XEN de Debian
`wine` | V:14, I:57 | 204 | Wine : implémentation de l’API Windows (suite standard)
`dosbox` | V:1, I:13 | 2697 | DOSBox : émulateur x86 avec graphisme Tandy/Herc/CGA/EGA/VGA/SVGA, son et DOS
`lxc` | V:9, I:12 | 1626 | Conteneurs Linux outils de l’espace utilisateur
`python3-venv` | V:8, I:136 | 6 | venv pour la création d’environnements Python virtuels (bibliothèque système)
`python3-virtualenv` | V:8, I:41 | 417 | virtualenv pour créer des environnements Python virtuels isolés
`pipx` | V:7, I:43 | 3613 | pipx pour installer des applications Python dans des environnements isolés

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.

### 9.11.2. Étapes de la virtualisation

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

La virtualisation met en œuvre plusieurs étapes :

- Créer un système de fichiers vide (une arborescence de fichiers ou une image disque).

  - L’arborescence de fichiers peut être créée par « `mkdir -p /path/to/chroot` ».

  - L’image disque brute peut être créée à l’aide de `dd`(1) (consultez Section 9.7.1, « Créer le fichier image du disque » et Section 9.7.5, « Réaliser le fichier image d’un disque vide »).

  - `qemu-img`(1) peut être utilisé pour créer et convertir des fichiers d’image disque pris en charge par QEMU.

  - Les formats de fichier brut et VMDK peuvent être utilisés en tant que formats courants par les outils de virtualisation.

- Monter l’image disque dans le système de fichiers avec `mount`(8) (optionnel).

  - Pour l’image disque brute, le montage doit être fait avec un périphérique de rebouclage ou des périphériques device mapper (consultez Section 9.7.3, « Monter le fichier image du disque »).

  - Les images disques prises en charge par QEMU seront montées en tant que périphériques réseau en mode bloc> (consultez Section 9.11.3, « Monter le fichier image du disque virtuel »).

- Peupler le système de fichiers cible avec les données requises.

  - L’utilisation de programmes tels que `debootstrap` et `cdebootstrap` facilite ce processus (consultez Section 9.11.4, « Système protégé (chroot) »).

  - Utiliser les installateurs des systèmes d’exploitation sous l’émulation du système complet.

- Lancer un programme dans l’environnement virtualisé.

  - chroot fournit un environnement virtualisé de base, suffisant pour y compiler des programmes, y faire tourner des applications en mode console et des démons.

  - QEMU fournit une émulation de processeur interplateformes.

  - QEMU avec KVM fournit une émulation système complète avec la virtualisation assistée par le matériel.

  - VirtualBox fournit une émulation du système complet sur i386 amd64 avec ou sans la virtualisation assistée par le matériel.

### 9.11.3. Monter le fichier image du disque virtuel

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

### 9.11.4. Système protégé (chroot)

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.

### 9.11.5. Systèmes de bureaux multiples

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.

[2] Exemples de personnalisation plus élaborée : « Vim Galore », « sensible.vim », ...

[3] vim-pathogen était populaire.

Chapitre 8. I18N et L10N |  | Chapitre 10. Gestion des données