Gestion des paquets

Gestion des paquets#

Hide code cell source

 
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import seaborn as sns

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

La gestion des logiciels est l’une des tâches les plus quotidiennes de l’administration Linux. Installer, mettre à jour, rechercher et supprimer des paquets de façon fiable et traçable est une compétence fondamentale. Sur les systèmes Debian et dérivés (Ubuntu, Linux Mint, Raspberry Pi OS, etc.), l’écosystème des paquets repose sur une architecture en couches : les fichiers .deb, l’outil bas niveau dpkg, et les gestionnaires de haut niveau apt et apt-get.

Ce chapitre couvre cette architecture en détail, des dépôts officiel aux PPA et dépôts tiers, des formats universels snap et flatpak, jusqu’à la compilation depuis les sources pour les cas où aucun paquet ne convient.

Architecture des paquets Debian#

Définition 43 (Paquet Debian)

Un paquet Debian (fichier .deb) est une archive contenant :

  • Les fichiers binaires et de données à installer sur le système.

  • Les métadonnées : nom, version, architecture, mainteneur, description, dépendances.

  • Des scripts de maintenance : preinst, postinst, prerm, postrm — exécutés avant et après l’installation ou la suppression.

  • Un fichier de copyright et un changelog.

Le format .deb est un fichier ar contenant deux archives tar.xz : control.tar.xz (métadonnées) et data.tar.xz (fichiers à installer).

Dépôts et sources#

Les paquets sont distribués depuis des dépôts (repositories) : des serveurs web qui hébergent des collections de fichiers .deb avec des index signés cryptographiquement.

# Fichier de configuration des sources (Debian/Ubuntu)
cat /etc/apt/sources.list

# Exemple de contenu typique (Ubuntu 24.04 LTS)
# deb http://fr.archive.ubuntu.com/ubuntu noble main restricted
# deb http://fr.archive.ubuntu.com/ubuntu noble-updates main restricted
# deb http://security.ubuntu.com/ubuntu noble-security main restricted universe

# Depuis Ubuntu 24.04, les sources sont aussi dans /etc/apt/sources.list.d/
ls /etc/apt/sources.list.d/

# Format .sources (nouveau format DEB822)
# Enabled: yes
# Types: deb
# URIs: http://fr.archive.ubuntu.com/ubuntu
# Suites: noble noble-updates noble-backports
# Components: main restricted universe multiverse

Remarque 37

Les composants d’un dépôt Ubuntu définissent la licence et le niveau de support des paquets :

  • main : logiciels libres maintenus officiellement par Canonical.

  • restricted : pilotes propriétaires supportés par Canonical.

  • universe : logiciels libres maintenus par la communauté.

  • multiverse : logiciels à licence non libre ou brevets logiciels.

Les suffixes des suites (noble-updates, noble-security, noble-backports) permettent d’affiner l’origine des mises à jour selon leur urgence et leur stabilité.

Structure d’un dépôt#

http://archive.ubuntu.com/ubuntu/
├── dists/
│   ├── noble/
│   │   ├── Release          # Métadonnées de la distribution
│   │   ├── Release.gpg      # Signature GPG
│   │   ├── main/
│   │   │   ├── binary-amd64/
│   │   │   │   ├── Packages.xz   # Index des paquets
│   │   │   │   └── Packages.gz
│   │   │   └── source/
│   │   └── universe/
└── pool/
    ├── main/
    │   └── a/apt/apt_2.7.14_amd64.deb
    └── universe/

apt : le gestionnaire de haut niveau#

apt (Advanced Package Tool) est l’interface de haut niveau qui gère automatiquement les dépendances, télécharge les paquets depuis les dépôts et appelle dpkg pour l’installation effective.

Définition 44 (apt vs apt-get)

apt est la commande recommandée pour un usage interactif depuis Debian Jessie et Ubuntu 16.04. Elle offre une interface plus conviviale qu”apt-get avec une barre de progression, des couleurs et des options simplifiées. apt-get reste préféré dans les scripts car son interface est stable et documentée comme rétrocompatible. apt-cache est remplacé par les sous-commandes apt search et apt show.

Mise à jour des sources et du système#

# Mettre à jour la liste des paquets disponibles (ne rien installer)
sudo apt update

# Mettre à jour tous les paquets installés vers leur dernière version
sudo apt upgrade

# Mise à jour avec suppression des paquets devenus obsolètes
sudo apt full-upgrade       # Anciennement apt-get dist-upgrade

# Combinaison typique pour maintenir le système à jour
sudo apt update && sudo apt upgrade -y

# Simulation sans exécuter réellement
sudo apt upgrade --dry-run

Installation et suppression#

# Installer un paquet
sudo apt install vim

# Installer plusieurs paquets d'un coup
sudo apt install vim git curl jq htop tree

# Installer une version spécifique
sudo apt install vim=2:9.0.1672-1

# Installer sans confirmation (mode non interactif)
sudo apt install -y vim

# Réinstaller un paquet (utile si les fichiers sont corrompus)
sudo apt install --reinstall vim

# Supprimer un paquet (conserver les fichiers de configuration)
sudo apt remove vim

# Supprimer complètement avec les fichiers de configuration
sudo apt purge vim

# Supprimer les dépendances orphelines devenues inutiles
sudo apt autoremove

# Combiner purge et autoremove
sudo apt purge vim && sudo apt autoremove

# Supprimer le cache de paquets téléchargés
sudo apt clean           # Vide tout /var/cache/apt/archives/
sudo apt autoclean       # Supprime uniquement les versions obsolètes

Recherche et information#

# Rechercher un paquet par nom ou description
apt search "éditeur de texte"
apt search vim

# Informations détaillées sur un paquet
apt show vim

# Informations sur un paquet installé ou disponible
apt show python3
apt show python3=3.12.0-1

# Lister les paquets installés
apt list --installed
apt list --installed | grep "^python"

# Lister les paquets pouvant être mis à jour
apt list --upgradable

# Lister toutes les versions disponibles d'un paquet
apt-cache policy vim
apt-cache policy python3

# Voir les dépendances d'un paquet
apt-cache depends vim
apt-cache rdepends vim    # Dépendances inverses (qui dépend de vim)

Exemple 27 (Automatiser les mises à jour non interactives)

Sur un serveur en production, on utilise souvent le mode non interactif pour les mises à jour automatiques :

#!/usr/bin/env bash
set -euo pipefail

export DEBIAN_FRONTEND=noninteractive

# Options dpkg pour éviter les questions interactives
APT_OPTS="-y -o Dpkg::Options::=--force-confdef -o Dpkg::Options::=--force-confold"

apt-get update
apt-get upgrade $APT_OPTS
apt-get autoremove -y
apt-get clean

echo "Mise à jour terminée le $(date)"

La variable DEBIAN_FRONTEND=noninteractive supprime toutes les questions interactives de debconf. Les options --force-confdef et --force-confold conservent les fichiers de configuration existants en cas de conflit, ce qui est généralement le comportement souhaité en production.


### `apt-cache` et informations avancées

```bash
# Afficher les statistiques du cache
apt-cache stats

# Rechercher dans les descriptions de paquets
apt-cache search "compression"
apt-cache search --names-only "^python3-"

# Afficher les fichiers qu'installerait un paquet
apt-file list vim     # Nécessite apt-file installé
apt-file search /usr/bin/vim

# Installer apt-file pour la recherche par fichier
sudo apt install apt-file
sudo apt-file update
apt-file search "libz.so"    # Quel paquet fournit ce fichier ?

dpkg : la couche basse#

dpkg est le gestionnaire de paquets de bas niveau. Il installe, supprime et interroge des paquets .deb directement, sans gérer les dépendances. C’est apt qui appelle dpkg après avoir résolu les dépendances.

Définition 45 (dpkg)

dpkg (Debian Package manager) est la couche fondamentale du système de gestion de paquets Debian. Il maintient une base de données dans /var/lib/dpkg/ qui enregistre tous les paquets installés, leurs fichiers et leur état. dpkg ne connaît pas les dépôts distants ni la résolution automatique des dépendances : c’est le rôle d”apt de préparer l’environnement avant d’appeler dpkg.

# Installer un fichier .deb local
sudo dpkg -i paquet.deb

# Si dpkg échoue à cause de dépendances manquantes, les résoudre avec apt
sudo dpkg -i paquet.deb || sudo apt-get install -f

# Supprimer un paquet (conserver la configuration)
sudo dpkg -r nom_paquet

# Supprimer complètement (purger)
sudo dpkg -P nom_paquet

# Lister tous les paquets installés
dpkg -l
dpkg -l | grep "^ii"    # Paquets correctement installés
dpkg -l | grep vim       # Filtrer

# Lister les fichiers installés par un paquet
dpkg -L vim
dpkg -L vim | head -20

# Savoir quel paquet a installé un fichier
dpkg -S /usr/bin/vim
dpkg -S /lib/x86_64-linux-gnu/libc.so.6

# Obtenir les informations d'un paquet installé
dpkg -s vim

# Vérifier l'intégrité des fichiers d'un paquet
dpkg -V vim

# Reconfigurer un paquet (réexécuter postinst)
sudo dpkg-reconfigure locales
sudo dpkg-reconfigure tzdata
sudo dpkg-reconfigure keyboard-configuration

# Inspecter un fichier .deb sans l'installer
dpkg-deb --info paquet.deb
dpkg-deb --contents paquet.deb
dpkg-deb -x paquet.deb /tmp/contenu/    # Extraire les fichiers

La base de données dpkg#

# Répertoire de la base de données
ls /var/lib/dpkg/

# Liste de tous les paquets et leur état
cat /var/lib/dpkg/status | head -30

# Fichiers de configuration des paquets installés
ls /var/lib/dpkg/info/*.list | head -5
cat /var/lib/dpkg/info/vim.list    # Fichiers du paquet vim

PPA et dépôts tiers#

Un PPA (Personal Package Archive) est un dépôt personnel hébergé sur Launchpad (Ubuntu). Il permet aux développeurs de distribuer des versions récentes de leurs logiciels pour Ubuntu, indépendamment du cycle de publication officiel.

# Ajouter un PPA (Ubuntu)
sudo add-apt-repository ppa:ondrej/php
sudo apt update
sudo apt install php8.3

# Lister les PPAs ajoutés
ls /etc/apt/sources.list.d/

# Supprimer un PPA
sudo add-apt-repository --remove ppa:ondrej/php
# Ou supprimer le fichier correspondant
sudo rm /etc/apt/sources.list.d/ondrej-ubuntu-php-*.list
sudo apt update

# Ajouter un dépôt tiers manuellement (méthode moderne avec clé GPG)
# Exemple : dépôt officiel Docker
# 1. Importer la clé GPG
curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
  | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# 2. Ajouter le dépôt
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" \
  | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 3. Mettre à jour et installer
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io

Remarque 38

La méthode ancienne consistait à ajouter les clés GPG dans /etc/apt/trusted.gpg avec apt-key add. Cette méthode est dépréciée depuis Debian Bullseye et Ubuntu 22.04 car elle ajoute la clé au trousseau global, ce qui la rend valide pour tous les dépôts. La méthode moderne consiste à stocker la clé dans /etc/apt/keyrings/ et à référencer explicitement ce fichier dans la ligne du dépôt avec signed-by=.... Ainsi, la clé ne s’applique qu’au dépôt concerné.

snap : paquets universels avec confinement#

snap est un format de paquets universel développé par Canonical, conçu pour fonctionner sur toutes les distributions Linux, avec un mécanisme de confinement (sandboxing) qui isole les applications du système.

Définition 46 (Snap)

Un snap est un paquet autonome qui contient l’application et toutes ses dépendances dans un système de fichiers compressé SquashFS, monté en lecture seule. Le démon snapd gère les snaps : installation, mise à jour automatique (en arrière-plan), révocations et confinement via AppArmor et seccomp. Les snaps sont distribués depuis le Snap Store de Canonical.

# Vérifier que snapd est installé
snap version
systemctl status snapd

# Rechercher un snap
snap find "éditeur de code"
snap find chromium

# Installer un snap
sudo snap install vlc
sudo snap install code --classic    # Mode classic : confinement réduit

# Lister les snaps installés
snap list

# Mettre à jour tous les snaps
sudo snap refresh

# Mettre à jour un snap spécifique
sudo snap refresh vlc

# Voir les informations d'un snap
snap info vlc

# Voir les révisions disponibles
snap info --verbose vlc

# Changer de canal (stable, candidate, beta, edge)
sudo snap switch vlc --channel=beta
sudo snap refresh vlc

# Supprimer un snap
sudo snap remove vlc
sudo snap remove vlc --purge    # Supprimer aussi les données sauvegardées

# Voir les connexions (permissions) d'un snap
snap connections vlc
snap interfaces vlc

# Accorder/révoquer une permission
sudo snap connect vlc:network
sudo snap disconnect vlc:network

# Lister les révisions précédentes installées
snap list --all vlc

# Revenir à une révision antérieure
sudo snap revert vlc

Canaux et mises à jour automatiques#

# Les canaux snap : {track}/{risk}/{branch}
# track : version majeure (ex: 22, 24, latest)
# risk : stable > candidate > beta > edge
# branch : pour les builds spéciaux

snap info ubuntu-frame
# channels:
#   latest/stable:    ...
#   latest/candidate: ...
#   latest/beta:      ...
#   22/stable:        ...

# Désactiver les mises à jour automatiques (non recommandé)
sudo snap set system refresh.hold="$(date --date='today + 30 days' +%Y-%m-%dT%H:%M:%S%:z)"

Remarque 39

Les avantages des snaps sont l’universalité (une seule version pour toutes les distributions), les mises à jour atomiques et automatiques, le confinement de sécurité, et la possibilité de revenir à une révision précédente. Les inconvénients sont le temps de démarrage plus long (le système de fichiers SquashFS doit être monté), la consommation d’espace disque plus importante (les snaps incluent leurs dépendances), la dépendance à Canonical pour le Snap Store, et le fait que les mises à jour ne peuvent pas être facilement repoussées. Pour les applications de bureau, flatpak est souvent préféré par la communauté pour son modèle plus ouvert.

flatpak : runtimes partagés et Flathub#

Flatpak est une alternative à snap pour les applications de bureau Linux, développée par la communauté (initialement par Red Hat).

Définition 47 (Flatpak)

Flatpak est un système de distribution d’applications pour Linux basé sur des runtimes partagés (GNOME, KDE, Freedesktop) qui fournissent les bibliothèques communes. Les applications ne contiennent que leur code propre, le runtime étant partagé entre les applications qui l’utilisent. Flatpak utilise Bubblewrap pour le confinement et OSTree pour le stockage de fichiers. Flathub est le dépôt central communautaire hébergeant des milliers d’applications.

# Installer flatpak (si absent)
sudo apt install flatpak

# Ajouter le dépôt Flathub
flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo

# Lister les dépôts configurés
flatpak remotes

# Rechercher une application
flatpak search vlc
flatpak search "spotify"

# Installer une application depuis Flathub
flatpak install flathub org.videolan.VLC
flatpak install flathub com.spotify.Client

# Lancer une application
flatpak run org.videolan.VLC

# Lister les applications installées
flatpak list
flatpak list --app       # Seulement les applications (pas les runtimes)
flatpak list --runtime   # Seulement les runtimes

# Mettre à jour toutes les applications
flatpak update

# Mettre à jour une application spécifique
flatpak update org.videolan.VLC

# Désinstaller
flatpak uninstall org.videolan.VLC
flatpak uninstall --unused    # Supprimer les runtimes inutilisés

# Voir les informations d'une application
flatpak info org.videolan.VLC

# Gérer les permissions
flatpak override org.videolan.VLC --filesystem=host
flatpak override org.videolan.VLC --nofilesystem=host
flatpak permissions

Compilation depuis les sources#

Parfois, aucun paquet ni snap ni flatpak ne correspond aux besoins : version trop ancienne dans les dépôts, paquet inexistant, besoin d’options de compilation personnalisées. La compilation depuis les sources reste une compétence essentielle.

Définition 48 (Compilation depuis les sources)

Compiler depuis les sources signifie télécharger le code source d’un programme et le transformer en binaire exécutable sur la machine locale. Sous Linux, la chaîne de compilation typique utilise GNU Autotools (./configure + make + make install) ou CMake selon le projet. Le résultat est un binaire optimisé pour le processeur local, avec exactement les fonctionnalités souhaitées.

Prérequis#

# Installer les outils de compilation essentiels
sudo apt install build-essential
# Installe : gcc, g++, make, libc-dev, etc.

# Pour les projets utilisant CMake
sudo apt install cmake

# Installer les bibliothèques de développement nécessaires
# Convention Debian : paquet-dev contient les headers
sudo apt install libssl-dev libcurl4-openssl-dev zlib1g-dev

# Voir les dépendances de build d'un paquet officiel
apt-get build-dep vim    # Installe les dépendances pour compiler vim

Le cycle ./configure + make + make install#

# 1. Télécharger et extraire les sources
wget https://ftp.gnu.org/gnu/wget/wget-latest.tar.gz
tar -xzf wget-latest.tar.gz
cd wget-*/

# 2. Lire la documentation
cat README
cat INSTALL

# 3. Configurer (détection de l'environnement, sélection des options)
./configure

# Avec options personnalisées
./configure --prefix=/usr/local \
            --with-ssl=openssl \
            --enable-ipv6 \
            --disable-nls

# Voir toutes les options disponibles
./configure --help

# 4. Compiler (utiliser tous les cœurs disponibles)
make -j$(nproc)
# -j$(nproc) : autant de jobs parallèles que de cœurs CPU

# 5. Tester (si une suite de tests existe)
make check
make test

# 6. Installer (dans /usr/local par défaut)
sudo make install

# Vérifier l'installation
which wget
wget --version

CMake#

# Projet CMake typique
git clone https://github.com/exemple/projet.git
cd projet/

# Créer un répertoire de build séparé (recommandé)
mkdir build && cd build/

# Configurer avec CMake
cmake ..
cmake .. -DCMAKE_BUILD_TYPE=Release \
         -DCMAKE_INSTALL_PREFIX=/usr/local \
         -DENABLE_TESTS=ON

# Compiler
cmake --build . -j$(nproc)
# Ou : make -j$(nproc)

# Installer
sudo cmake --install .

Créer un paquet .deb depuis les sources#

# Installer checkinstall pour créer un .deb depuis make install
sudo apt install checkinstall

# À la place de sudo make install
sudo checkinstall
# checkinstall pose quelques questions et crée un .deb
# Le paquet est alors géré par dpkg/apt

# Alternative avec dpkg-buildpackage
sudo apt install devscripts dh-make
dh_make --createorig -s
dpkg-buildpackage -us -uc
# Le .deb se retrouve dans le répertoire parent

Désinstaller un programme compilé depuis les sources#

# Si un Makefile uninstall existe
sudo make uninstall

# Sinon, avec stow (gestionnaire de liens symboliques)
sudo apt install stow
# Lors de l'installation, utiliser --prefix=/usr/local/stow/paquet
# puis : stow paquet  /  stow -D paquet pour désinstaller

# Ou : trouver et supprimer manuellement les fichiers
# (raison pour laquelle --prefix=/usr/local est recommandé)

Visualisation : couches apt / dpkg / .deb#

Hide code cell source

 
fig, axes = plt.subplots(1, 2, figsize=(16, 9))
palette = sns.color_palette("muted", 10)

# ---- Graphique 1 : couches du système de paquets ----
ax = axes[0]
ax.set_xlim(0, 10)
ax.set_ylim(0, 12)
ax.axis('off')
ax.set_title('Architecture du système de paquets Debian', fontsize=13,
             fontweight='bold')

couches_info = [
    (1.5, 10.5, 7.0, 1.0, "Utilisateur / Scripts d'administration",
     "apt, apt-get, aptitude, synaptic", palette[0]),
    (1.5, 8.8,  7.0, 1.0, "Gestionnaire de haut niveau (apt)",
     "Résolution des dépendances, téléchargement, mise à jour", palette[1]),
    (1.5, 7.1,  7.0, 1.0, "Gestion des dépôts",
     "/etc/apt/sources.list, GPG, cache", palette[2]),
    (1.5, 5.4,  7.0, 1.0, "Gestionnaire de bas niveau (dpkg)",
     "Installation/suppression des .deb, base de données", palette[3]),
    (1.5, 3.7,  7.0, 1.0, "Format de paquet (.deb)",
     "control.tar.xz + data.tar.xz + scripts", palette[4]),
    (1.5, 2.0,  7.0, 1.0, "Système de fichiers",
     "/usr/bin, /etc, /lib, /var/lib/dpkg", palette[5]),
]

for x, y, w, h, titre, detail, col in couches_info:
    rect = patches.FancyBboxPatch(
        (x, y), w, h * 1.2,
        boxstyle="round,pad=0.1", linewidth=2,
        edgecolor=col, facecolor=col, alpha=0.25
    )
    ax.add_patch(rect)
    border = patches.FancyBboxPatch(
        (x, y), w, h * 1.2,
        boxstyle="round,pad=0.1", linewidth=2,
        edgecolor=col, facecolor='none'
    )
    ax.add_patch(border)
    ax.text(5.0, y + h * 0.75, titre, ha='center', va='center',
            fontsize=10, fontweight='bold', color=col)
    ax.text(5.0, y + h * 0.25, detail, ha='center', va='center',
            fontsize=8.5, color='#555', style='italic')

# Flèches de flux
for i in range(len(couches_info) - 1):
    y_arrow = couches_info[i][1] - 0.1
    ax.annotate('', xy=(5.0, couches_info[i+1][1] + couches_info[i+1][3] * 1.2 + 0.1),
                xytext=(5.0, y_arrow),
                arrowprops=dict(arrowstyle='->', color='#555', lw=2))

# ---- Graphique 2 : comparaison apt / snap / flatpak / sources ----
ax = axes[1]
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
ax.axis('off')
ax.set_title('Comparaison des systèmes de distribution', fontsize=13,
             fontweight='bold')

systemes = [
    ("apt / dpkg",     palette[1], [
        ("Intégration système", 5),
        ("Universalité", 2),
        ("Fraîcheur des versions", 2),
        ("Confinement", 1),
        ("Facilité d'utilisation", 4),
    ]),
    ("snap",           palette[3], [
        ("Intégration système", 3),
        ("Universalité", 5),
        ("Fraîcheur des versions", 5),
        ("Confinement", 4),
        ("Facilité d'utilisation", 4),
    ]),
    ("flatpak",        palette[2], [
        ("Intégration système", 3),
        ("Universalité", 5),
        ("Fraîcheur des versions", 5),
        ("Confinement", 4),
        ("Facilité d'utilisation", 4),
    ]),
    ("Sources",        palette[5], [
        ("Intégration système", 4),
        ("Universalité", 1),
        ("Fraîcheur des versions", 5),
        ("Confinement", 1),
        ("Facilité d'utilisation", 1),
    ]),
]

criteres = [c for c, _ in systemes[0][2]]
n_criteres = len(criteres)
n_sys = len(systemes)

bar_w = 0.18
y_positions = [8.5, 7.2, 5.9, 4.6, 3.3]
max_val = 5.0
bar_scale = 1.4  # Chaque unité = 1.4 unités de l'axe x

for ci, (critere, y) in enumerate(zip(criteres, y_positions)):
    ax.text(0.1, y, critere, va='center', fontsize=9, color='#333')
    for si, (nom, col, scores) in enumerate(systemes):
        score = scores[ci][1]
        x_start = 3.8 + si * (bar_w + 0.02)
        bar_len = score / max_val * bar_scale
        rect = patches.Rectangle(
            (x_start, y - 0.25), bar_len, 0.5,
            facecolor=col, alpha=0.7, edgecolor='none'
        )
        ax.add_patch(rect)
        ax.text(x_start + bar_len + 0.05, y, str(score), va='center',
                fontsize=7.5, color=col, fontweight='bold')

# Légende
for i, (nom, col, _) in enumerate(systemes):
    x_leg = 4.0 + i * 1.5
    rect = patches.Rectangle((x_leg, 1.8), 0.4, 0.3,
                              facecolor=col, alpha=0.7)
    ax.add_patch(rect)
    ax.text(x_leg + 0.5, 1.95, nom, va='center', fontsize=8.5, color=col)

ax.text(5.0, 1.0, 'Score de 1 (faible) à 5 (excellent)', ha='center',
        fontsize=8, color='#888', style='italic')

plt.tight_layout()
plt.show()
_images/cfe3b48e35661a5abdfd99251cbf73ac9adc7ca6d0f1ee17a43ede277e9f803b.png

Résumé#

Ce chapitre a présenté l’écosystème complet de gestion des paquets sur les systèmes Debian/Ubuntu :

  • L”architecture en couches repose sur les fichiers .deb (format d’archive), dpkg (installation bas niveau, base de données), apt (résolution des dépendances, téléchargement depuis les dépôts) et les dépôts eux-mêmes (configurés dans /etc/apt/sources.list et /etc/apt/sources.list.d/).

  • apt update && apt upgrade maintient le système à jour ; apt install, apt remove, apt purge et apt autoremove gèrent l’installation et la suppression en gérant automatiquement les dépendances.

  • dpkg est la couche basse : -i pour installer un .deb local, -l pour lister, -L pour les fichiers d’un paquet, -S pour retrouver quel paquet a installé un fichier.

  • Les PPA et dépôts tiers permettent d’accéder à des versions récentes de logiciels ; la méthode moderne avec clés GPG dans /etc/apt/keyrings/ est à privilégier.

  • snap offre la distribution universelle avec mises à jour automatiques et confinement, au prix d’un démarrage plus lent. flatpak et Flathub constituent une alternative communautaire populaire pour les applications de bureau.

  • La compilation depuis les sources (./configure, make, make install ou CMake) reste indispensable quand aucun paquet adapté n’existe, avec checkinstall pour intégrer le résultat dans le gestionnaire de paquets.

Le chapitre suivant aborde la configuration de l’environnement shell : fichiers de démarrage, alias, fonctions, PATH, variables d’environnement, tmux et direnv.

Contenu