Administrer un ordinateur Linux

Introduction

Pourquoi administrer un serveur ?

L'administration d'un ordinateur a (entre autres) pour objectifs :
Ce module se concentrera sur le système d'exploitation Linux. En effet, si Windows domine les parts de marchés pour les ordinateurs de bureaux (69% contre 4,5% pour Linux), Linux est majoritaire sur les serveurs (96,4%), et les mobiles (71% avec Android). Linux est aussi très utilisé comme poste de travail par les développeurs.

Attentes et objectifs du module

Dans le cadre de votre formation, ce module vous permettra :
Dans le cadre de ce module, il ne vous sera pas demandé de retenir les étapes de configurations par coeur, mais d'être capable de suivre des séries d'instructions, en comprenant ce que vous faites, leur effets et raisons. Vous devrez ainsi :

REPL et scripts

Dans le cadre de vos cours précédents, vous avez déjà manipulé plusieurs langages de scripts (R, Python, SQL). Vous utilisiez alors un interpréteur (Rscript, python3, sqlite3) pour exécuter des instructions écrites dans ces langages.
En Python, vous saisissiez vos instructions dans un fichier qui était lu et exécuté par l'interpréteur Python. On parlait alors de script Python.
En revanche, en SQL, vous utilisiez une interface REPL (Read-Eval-Print Loop). Vous écriviez alors une ligne que sqlite3 lisait (read), interprétait (eval), puis vous en affichait le résultat (print). Après chaque exécution, l'interpréteur vous affichait une invite (ici ) pour vous indiquer que vous pouviez saisir une nouvelle instruction :
Les interpréteurs supportent bien souvent ces deux modes (scripts et REPL). Il est par exemple tout à fait possible de donner un fichier SQL à sqlite3, ou de lancer python3 en mode REPL :
Pour administrer un système Linux, on utilise principalement Shell (un autre langage de script), avec l'interpréteur shell Bash. Comme pour les autres langages de script, il est possible de l'utiliser avec des scripts Shell, mais aussi via une interface REPL.
Cependant, le vocabulaire sera légèrement différent. On parlera de :

Les serveurs

Les serveurs sont des ordinateurs fournissant divers services à ses utilisateurs :
💡 Le terme service fait référence au logiciel, quand le terme serveur peut faire référence au matériel ou au logiciel.
Les serveurs sont très utiles dans le cadre de vos activités (notamment pour effectuer des calculs intensifs) :

Les commandes

Il existe plusieurs types de commandes (cf ) :

Alias et réécritures de la ligne de commande

En réalité, le Shell n'exécute pas directement une ligne de commande, mais opère quelques réécritures avant de l'exécuter. Notamment, les ensembles de chemins, et sont en réalité remplacés par le Shell avant d'exécuter la ligne de commande.
💡 demande au Shell d'afficher chaque ligne de commandes avant de l'exécuter (très utile pour déboguer) :
💡 indique au Shell d'interpréter les caractères échappés, dont :
Un alias est une commande qui, lors de sa réécriture, sera remplacée par un bout de ligne de commande, e.g. :
💡 Les alias peuvent être utilisés pour simplifier l'écriture de lignes de commandes complexes et difficiles à retenir.

Les fichiers exécutables

Les commandes ne sont usuellement rien de plus qu'un exécutable (i.e. un script ou un programme). Il est ainsi possible de créer une commande à partir d'un script Python qui sera alors exécuté lorsque la commande est appelée :
Vous remarquerez que la première ligne du script est un peu bizarre : .
Il s'agit du Shebang. Il permet d'indiquer au Shell l'interpréteur à utiliser pour exécuter le script (ici python3).
💡 Il est aussi possible d'indiquer des arguments à transmettre à l'interpréteur :
💡 Pour créer une commande à partir d'un script, nous fournirons une commande .

Chemins relatifs dans les scripts

⚠ Dans un script, les chemins relatifs sont évalués relativement au dossier de travail actuel, et non relativement à l'emplacement du script. Il convient donc de faire attention aux chemins relatifs dans les scripts.
💡 Vous pouvez alors soit :
Pour information :

Les arguments

Bien évidemment le script peut accéder aux arguments de la ligne de commande par laquelle il a été invoqué :
Le script reçoit ainsi les arguments sous la forme d'un tableau de chaînes de caractères qu'il peut ensuite traiter et interpréter de manière totalement arbitraire.
⚠ Le premier élément de ce tableau () est la commande exécutée.

Traiter les arguments avec argparse

Il est cependant préférable d'utiliser une bibliothèque dédiée (e.g. argparse en Python) qui fournira diverses fonctionnalités :
Il suffit alors de déclarer les différents arguments de la commande et la bibliothèque se chargera alors du reste :
Par convention, on distingue 3 types d'arguments :
Arguments positionnels Arguments nommés Drapeaux (flags)
Idem Python, i-ème argument
mis dans le i-ème paramètre.		 Idem Python,
ou 		Booléen dont la valeur dépend de la
présence de l'argument.
💡 Il est possible d'associer un nom court (d'un caractère) aux drapeaux, permettant de fusionner les arguments :
💡 Une fois les paramètres déclarés, vous pouvez utiliser la commande, e.g. pour en afficher l'usage :
⚠ À l'inverse de Python, les drapeaux et arguments nommés sont usuellement écrits avant les arguments positionnels.
💡 a de nombreux autres arguments notamment :

Administrer l'ordinateur

Pour des raisons évidentes de sécurité, on ne souhaite pas que n'importe qui puisse faire n'importe quoi. Ainsi seul l'administrateur (utilisateur , aussi appelé super utilisateur) peut effectuer des opérations d'administration comme :

Sudo

Pour exécuter des lignes de commandes en tant qu'administrateur, on la préfixe par (superuser do).
💡 permet de réexécuter la ligne de commande précédente avec les droits d'administration :
💡 Si vous avez plusieurs lignes de commandes à exécuter, vous pouvez utiliser afin d'ouvrir un Shell en tant que . L'invite de commande sera alors terminée par au lieu de :
Vous devrez ainsi utiliser afin d'exécuter les lignes de commandes d'administration présentées par la suite.

Gestion des paquets

Sous Linux, un logiciel (ou une bibliothèque) est distribué sous la forme d'un paquet (fichier pour Debian/Ubuntu). Les gestionnaire de paquets permettent alors d'aisément :

Installer/Désinstaller un paquet

Par défaut, les distributions Debian/Ubuntu utilisent le gestionnaire de paquet :
⚠ Bien qu'il soit possible de télécharger un fichier et de l'installer directement via (commande utilisée en interne par ), cela n'est pas recommandé. En effet, vous risquez ensuite de vous retrouver avec des problèmes de résolution de dépendances lors de mises à jour.

Mise à jours des paquets

La mise à jours des paquets s'effectue en 2 temps :
  1. : télécharger la liste des paquets et des mises à jours.
  2. : télécharger les mises à jours et les installer.
En interne, lit les fichiers afin d'obtenir la liste des dépôts de paquets à interroger.
⚠ Cette liste est très sensible. En effet, un dépôt corrompu pourrait fournir des paquets corrompus lors d'installations ou de mises à jour.

Mise à jours de la distribution

Lorsque vous souhaitez mettre à jour votre distribution Linux, il est recommandé de suivre les étapes suivantes :
  1. Préparation :
    • Branchez l'alimentation de l'ordinateur sur secteur.
    • Connectez l'ordinateur via Ethernet si possible.
    • Prévoyez un second ordinateur avec accès à Internet.
    • Prévoyez une clef USB bootable.
    • Faites une sauvegarde de vos fichiers.
  2. Mettez vos paquets le plus à jours possible :
    1. Téléchargez la liste des mises à jours avec .
    2. Alternez les et jusqu'à épuisement des mises à jours.
    3. pour autoriser la désinstallation de dépendances lors de la mise à jour.
    4. Si un paquet pose problème, et que vous savez ce que vous faites, (ré/dés)installez-le.
    5. Recommencez jusqu'à épuisement des mises à jours
  3. Dans les sources apt, remplacez la version de votre distribution par la version suivante, puis reprenez à l'étape 2.
    💡 affiche la version actuelle de votre distribution.
⚠ N'essayez pas de mettre à jours votre distribution d'un coup en sautant plusieurs versions :
💡 Il est important de bien prendre son temps et de ne surtout pas paniquer en cas de problèmes lors de la mise à jour. N'éteignez pas l'ordinateurs tant que les problèmes de paquets ne sont pas résolus.

Arrêter et redémarrer l'ordinateur

💡 Sous Linux il n'est pas nécessaire de redémarrer après une mise à jour.

Gestion des utilisateurs

Gérer les comptes utilisateurs :
💡 À la création d'un utilisateur, le contenu de (skeleton) est copié dans son nouvel home. Ce dossier permet alors de définir les fichiers de configuration (e.g. ) des nouveaux utilisateurs, voire même e.g. un .
💡 Les utilisateurs systèmes n'ont pas de dossier home et ne peuvent pas se connecter. Ils sont généralement utilisés pour exécuter des logiciels/scripts/services requérant des droits spécifiques sans pour autant les exécuter en tant que .

Les groupes d'utilisateurs

Gérer les droits de chaque utilisateur un à un serait fastidieux et source d'erreurs, e.g. :
Il est ainsi bien souvent préférable d'attribuer des droits, non pas à un utilisateur donné, mais à un groupe d'utilisateur. Il suffit alors d'ajouter (ou de retirer) des utilisateurs à ce groupe, pour leur attribuer (ou retirer) des droits. Par exemple, les membres du groupe peuvent exécuter n'importe quelle commande en tant qu'administrateur. Il suffit donc d'ajouter (ou de retirer) des utilisateurs à ce groupes pour leur permettre (ou interdire) d'administrer l'ordinateur.
Cela permet notamment d'aisément visualiser qui peut faire quoi. Par exemple, pour savoir qui peut exécuter des commandes d'administrations, il suffit d'afficher les membres du groupe . Pour savoir ce qu'un utilisateur a le droit de faire, il suffit d'afficher les groupes auxquels il appartient.
💡 Les commandes sont des versions bas niveau et non-interactives des commandes présentées ci-dessus.

Sudoers

Il est fréquent de vouloir donner certains droits d'administrations à un utilisateur, sans pour autant lui donner l'intégralité des droits. Par exemple l'autoriser à mettre à jour les paquets (, ), sans lui permettre e.g. d'administrer les utilisateurs du système. Pour cela on va définir les commandes (ou lignes de commandes) qu'un utilisateur (ou groupe d'utilisateur) aura le droit d'exécuter avec .
⚠ Certains droits peuvent permettre une escalade de privilège. Par exemple, pouvoir ajouter des utilisateurs à n'importe quel groupe d'utilisateur, permet de s'ajouter au groupe , et ainsi d'obtenir un accès administrateur complet.
Ces droits sont définis dans les fichiers , et sont édités via la commande .
Les lignes suivent le format , et se lisent comme suit :
"Autorise (ou interdit) l'utilisateur (ou le groupe ) à exécuter la commande en tant qu'administrateur".
⚠ Pour des raisons de sécurité, il faut préciser le chemin complet de la commande ( pour l'obtenir).
💡 affiche les droits sudoers de l'utilisateur (ou de l'utilisateur actuel si non précisé).
⚠ sudo applique la dernière règle correspondante à la situation.
💡 Vous pouvez aussi autoriser (ou interdire) une ligne de commande précise, et éventuellement utiliser des expressions régulières pour les arguments (vues plus tard dans la formation) :