TCO/L2 Année Universitaire : 2021 / 2022

UNIVERSITE D’ANTANANARIVO
----------------------
ECOLE SUPERIEURE POLYTECHNIQUE
-----------------------
MENTION TELECOMMUNICATION

Domaine : Sciences de l’Ingénieur

Mention : Télécommunication
Parcours : IRS/IRC

Par : RAKOTOMALALA Fanevantsoa

TACHES D’UN ADMINISTRATEUR SYSTEME

SOUS LINUX

Enseignant : Mr. RANDRIAMIHAJARISON Jimmy

ii
 Table des matières

INTRODUCTION .................................................................................................................... 1

CHAPITRE 1 TACHES D’UN ADMINISTRATEUR SYSTEME ..................................... 2

1.1 Généralités ....................................................................................................................... 2

1.2 Principe générale de l’administration système ............................................................ 2

1.2.1 Gestion des ressources .............................................................................................. 2

1.2.2 Partitionnement ......................................................................................................... 5

1.2.3 Gestion des services ................................................................................................... 7

1.2.4 Gestion de la sécurité ................................................................................................ 9

iii
 INTRODUCTION

Un système d’exploitation ou OS pour Operating System, définit un ensemble de programmes

chargé d’établir une relation entre différentes ressources matérielles, les applications et
l’utilisateur. Dans un ordinateur, le système d’exploitation a plusieurs missions. Il gère, entre
autres, le processeur et la mémoire vive, optimise l’exécution des applications en leur attribuant
les ressources nécessaires, fournit un certain nombre d’informations sur le bon fonctionnement
de l’ordinateur. Il permet l’utilisation de périphériques dans les meilleures conditions et protège
l’accès aux ressources.

Ces diverses tâches faites par l’ordinateur néanmoins ne peuvent être automatisé que par le biais
d’une personne capable de gérer la totalité du système d’exploitation.

1
 CHAPITRE 1 TACHES D’UN ADMINISTRATEUR SYSTEME

1.1 Généralités

L’administration système est un travail effectué par des experts informatiques pour une
organisation. Le travail consiste à s’assurer que les systèmes informatiques et tous les services
connexes fonctionnent bien. Les tâches d’administration système sont très souvent variées et
varient souvent en fonction du type de systèmes informatiques gérés, bien que la plupart d’entre
elles partagent certaines tâches communes qui peuvent être exécutées de différentes manières.

En informatique, le titre d’administrateur systèmes désigne la personne responsable des

serveurs d’une organisation.

1.2 Principe générale de l’administration système

Un système informatique bien structuré met en œuvre trois concepts clefs :

— les utilisateurs, qui identifient de manière non ambigüe les acteurs qui peuvent utiliser le
système, leurs droits et ce que le système peut faire en leur nom,

— les fichiers, qui sauvegardent de manière fiable à la fois les données, les programmes qui les
manipulent et les paramètres qui déterminent les comportements du système et de ses services,

— enfin les processus, qui sont les programmes en train de « tourner » sur la machine à un
moment donné.

Un administrateur a donc pour rôle de gérer les ressources, les services, et la sécurité du système
d’exploitation.

1.2.1 Gestion des ressources

1.2.1.1 Système de fichiers

L’organisation et le stockage des informations et des données sur les fichiers, le système de
fichiers doit fournir à l’utilisateur une vision structurée de ses données, permettant de les
distinguer, de les retrouver, de les traiter et de les manipuler, par exemple sous forme de fichiers
au sein d’une arborescence de répertoires avec les commandes associées. De même, chaque
système de fichiers doit fournir le nécessaire pour que les programmes puissent y accéder.
Un système de fichiers Unix est organisé sous forme d’un arbre de répertoires et de sous-
répertoires à partir d’une racine commune. C’est une arborescence. Chaque répertoire fait partie
d’une organisation et propose lui-même une organisation : le système de fichiers dispose d’une

2
hiérarchie ordonnée. L’arborescence elle-même peut être répartie sur plusieurs supports et
systèmes de fichiers.
1.2.1.2 Arborescence

Les fichiers qui sont utiles au système Unix sont souvent placés à des adresses communes à
tous les systèmes installés, établies principalement par des habitudes des super-users (root) dans
le monde entier, donc par le poids de l’histoire.

D’un système à l’autre, on constate cependant quelques variations qui sont généralement
motivées par les objectifs principaux du système considéré. La spécification de ces différences
constitue l’essentiel de ce qu’on appelle une « distribution » d’Unix. Parmi ces distributions,
on peut citer BSD, Mageia, Fedora, RedHat, Debian, Ubuntu, etc.

D’une distribution à une autre, la structure de l’arborescence peut donc changer mais les
répertoires suivants sont généralement présents.

/home : contient la quasi-totalité des « home directories » des utilisateurs.

/etc : contient les fichiers qui paramètrent les fonctions principales du système (utilisateurs et
mots de passe, structure du réseau local, structure générale de l’arborescence, propriétés de
l’environnement graphique, etc.).

/usr : contient la majorité des commandes utiles aux utilisateurs ainsi que les bibliothèques et
les fichiers de paramètres correspondants.

/var : contient la plupart des informations à propos de l’état courant du système (messages
d’information réguliers, paramètres changeant avec le temps, etc).

/dev : contient tous les fichiers de type devices et leur gestion. On peut noter en particulier
/dev/null qui est un fichier très spécial : tout le monde peut le lire et écrire dedans mais il reste
toujours vide, c’est une « poubelle de données » souvent utile pour passer sous silence des
messages inutiles comme on le verra plus loin.

D’un point de vue technique, les disques qui contiennent les fichiers peuvent être découpés en
morceaux appelés des partitions afin de faciliter leur sauvegarde et de limiter les dégats en cas
de défaillance matérielle. La structure interne d’une partition repose sur une spécification
technique qui est généralement appelée ext4 et il est par ailleurs possible « d’importer » des
partitions non Unix, comme FAT, NTFS ou autre.

3
Une de ces partitions contient le répertoire / et les autres sont alors des sous arbres de
l’arborescence globale. Le fichier /etc/fstab définit cette arborescence « à gros grains » entre
partitions.

1.2.1.3 Métadonnées

Un fichier est décrit par des propriétés appelées les métadonnées. Sous Linux, il s’agit de
l’inode. Le contenu (les données) est placé dans d’autres blocs du support de stockage. Le
contenu des métadonnées diffère d’un système de fichiers à un autre. Cependant on y retrouve
sous Linux :
➢ les droits ;
➢ les dernières dates d’accès et de modification ;
➢ le propriétaire et le groupe ;
➢ la taille ;
➢ le nombre de blocs utilisés ;
➢ le type de fichiers ;
➢ le compteur de liens ;
➢ un arbre d’adresses de blocs de données.
1.2.1.4 Les noms des fichiers

Les noms peuvent avoir une longueur de 255 caractères. L’extension n’a pas d’existence en tant
que composante du système de fichiers contrairement à ce qui se passe sous Windows. Le type
du fichier est déterminé par son contenu, notamment les premiers octets permettant de
déterminer le type MIME.

La commande file procède ainsi. L’extension n’est qu’une simple composante du nom du
fichier, et incluse dans les 255 caractères. Elle est surtout utile pour que l’utilisateur différencie
rapidement les fichiers entre eux.

Les noms des fichiers Unix ne sont pas placés dans les méta-données mais dans une table de
catalogue. C’est pour ça qu’il est possible de donner plusieurs noms à un même fichier.

1.2.1.5 Manipulation système de fichier

Les commandes de « formatage » telles que celles présentes sous Microsoft n’existent pas de
manière identique sous Linux. Un formatage de type Microsoft est en fait la création et la
vérification d’un système de fichiers sur une partition. La première étape est le remplissage des
différents secteurs, blocs, et clusters de zéros (ou d’un autre motif binaire) avec une vérification

4
du support, et la seconde l’écriture d’un système de fichiers. Cette seule dernière opération
suffit à la création d’un système de fichiers vierge sur le disque ou la partition.

La commande pour créer un système de fichiers est la suivante

Ce typefs determine le type de système de fichiers. Il existe un programme par type de système
de fichiers :

➢ ext2 : mkfs.ext2
➢ ext3 : mkfs.ext3
➢ reiserfs : mkfs.reiserfs
➢ vfat : mkfs.vfat (pour tous les formats FAT, mais mkfs.msdos existe)
➢ ntfs : mkfs.ntfs

1.2.2 Partitionnement

Le partitionnement consiste en un découpage logique du disque. Le disque physique, réel, est

fractionné en plusieurs disques virtuels, logiques, les partitions. Chaque partition est vue
comme un disque indépendant et contient son propre système de fichiers.

1.2.2.1 MBR

Le premier secteur est le MBR, Master Boot Record, ou zone d’amorce. D’une taille de 512
octets il contient dans ses 444 premiers octets une routine (un programme) d’amorçage destiné
soit à démarrer le système d’exploitation sur la partition active, soit un chargeur de démarrage
(bootloader), puis 4 octets d’une signature optionnelle (Windows), 2 octets nuls, et les 64 octets
suivants contiennent la table des quatre partitions primaires. Le tout finit par une signature
0xAA55 sur deux octets.

5
1.2.2.2 Types de partitions

Chaque partition dispose d’un type permettant de déterminer son contenu. C’est un identifiant
numérique codé sur un octet généralement présenté en hexadécimal. Il semble important d’en
fournir une liste ici pour que vous compreniez bien la finalité de cet identifiant. Les valeurs les
plus communes sont en gras.

Comme le type de partition devrait refléter le système de fichiers qu’elle contient, une partition
de type 0x0c devrait contenir un système de fichiers de type FAT32 LBA (gros disques). Une
partition de type 0x83 devrait contenir un système de fichiers Linux. Mais lequel ? Vous avez
vu qu’il en existe plusieurs...

Notez la prédominance des types de partition pour Windows. Windows se base essentiellement
sur ce type pour en déterminer le contenu. Rien n’empêche de créer une partition de type Linux
et d’y placer un système de fichiers FAT32. Cependant si vous faites ceci, Windows ne
reconnaîtra pas la partition (considérée de type inconnu) et vous ne pourrez pas accéder au
contenu.

Linux reconnaît généralement (des exceptions sont possibles) le contenu d’une partition par le
système de fichiers qui y réside. Vous pouvez créer un système de fichiers ext3 dans une
partition de type 0x0e et constater que tout fonctionne. Le type 0x83 peut accueillir tout système
de fichiers Linux : ext2, ext3, reiserfs, jfs, xfs...

1.2.2.3 Manipuler les partitions

Commandes de bases

Les outils fdisk, cfdisk, sfdisk ou encore parted permettent de manipuler les partitions, sans
compter les outils graphiques disponibles durant l’installation ou dans les panneaux de
configuration.

➢ fdisk est le plus ancien et le plus utilisé des outils de partitionnement. Il n’a aucun
rapportavec le fdisk de Microsoft. Il est à base de menus et raccourcis textuels.
➢ cfdisk est un peu plus « visuel » et s’utilise avec les flèches directionnelles. Il permet
les mêmes opérations que fdisk mais de manière plus conviviale.
➢ sfdisk fonctionne en interactif ou non, est assez compliqué mais plus précis.
➢ parted permet des opérations très avancées sur les partitions comme par exemple leur
redimensionnement.
6
1.2.3 Gestion des services

1.2.3.1 Commandes de bases

Les services sont des scripts d’initialisation gérés initialement par System V.

Pour lister les services disponibles sur le distribution, on utilise la ligne de commande suivante :

Exemple de résultat :

7
Manipulation :

Les commandes principales sont les suivantes :

Exemple de redémarrage d’un service avec systemctl :

1.2.3.2 Gestion des utilisateurs

Le système identifie ses utilisateurs autorisés non seulement par leur « nom de login » mais
aussi et surtout pas leur identifiant, qui est simplement un nombre entier positif : l’UID (User
IDentification). C’est évidemment la combinaison du nom de login et du mot de passe associé
qui permet au système de « reconnaître » ses utilisateurs autorisés et de leur autoriser l’accès à
cet UID.

Les utilisateurs sont structurés en groupes : chaque utilisateur appartient à un groupe par défaut
(souvent le nom de l’équipe ou du service où il travaille) et s’il est autorisé à rejoindre d’autres

8
groupes, il peut le faire en utilisant la commande newgrp (à condition de connaître le mot de
passe du groupe ou d’y être admis dans le fichier /etc/group).

L’utilisateur root appartient au groupe root et certains autres utilisateurs virtuels peuvent
appartenir au groupe

Enfin un utilisateur possède un processus d’accueil : c’est le processus qui est lancé par le
système au moment où il se connecte avec succès (nom de login et mot de passe reconnus).
C’est aussi celui qui est lancé lorsque l’utilisateur ouvre une fenêtre de « terminal ». Ce genre
de processus est appelé un shell. Il s’agit le plus souvent de /bin/bash et ce processus attend tout
simplement que l’utilisateur tape une commande (donc un nom de fichier) pour l’exécuter.

Lorsque l’utilisateur bénéficie d’un environnement graphique (c’est le cas en général), c’est
simplement que le shell lance immédiatement les processus de l’environnement graphique au
lieu d’attendre que l’utilisateur tape une commande.

Certains utilisateurs virtuels ont un processus d’accueil plus restreint que bash, par exemple
l’utilisateur

1.2.4 Gestion de la sécurité

1.2.4.1 Droit d’accès

Outre son numéro de inode qui le caractérise, tout fichier quel que soit son type a :

— un propriétaire, qui est un utilisateur reconnu du système,

— et un groupe, qui n’est pas nécessairement celui par défaut de son propriétaire, ni même
obligatoirement un groupe auquel son propriétaire a accès (bien que la plupart des fichiers aient
en pratique le groupe par défaut de leur propriétaire) ;

— les « autres » utilisateurs, c’est-à-dire ceux qui ne sont ni propriétaire ni membre du groupe
du fichier, peuvent néanmoins avoir le droit d’utiliser le fichier si le propriétaire l’accepte.

Tout fichier peut être lu ou écrit/modifié ou encore exécuté. Pour un fichier de type répertoire,
le droit de lecture signifie l’autorisation de faire ls, le droit d’écriture signifie l’autorisation de
modifier la liste des fils (création, suppression, renom) et le droit d’exécution signifie
l’autorisation d’y faire un cd. Pour un fichier plat, le droit d’exécution signifie généralement
soit qu’il s’agit de code machine qui peut directement être chargé pour lancer un processus, soit
qu’il s’agit des sources d’un programme (en python, en shell ou tout autre langage) qui peut
être interprété par un programme ad hoc pour lancer un processus.

9
Le propriétaire peut attribuer les droits qu’il veut aux 3 types d’utilisateurs du fichier (lui-même,
le groupe et les autres). Il peut même s’interdire des droits (utile s’il craint de faire une fausse
manoeuvre !). Il y a donc 9 droits à préciser pour chaque fichier :

Et l’encodage se fait par puissances de 2 de sorte que la somme de chaque colonne détermine
les droits de chacun des trois types d’utilisateur. La commande pour modifier les droits d’un
fichier est chmod ; par exemple :

— chmod 640 adresseDeMonFichier donne les droits de lecture et écriture au propriétaire, le

droit de lecture aux membres du groupe du fichier, et aucun droit aux autres.

— chmod 551 adresseDeMonFichier donne les droits de lecture et exécution au propriétaire et

au groupe, et seulement le droit d’exécution aux autres.

— chmod 466 adresseDeMonFichier donne le droit de lecture au propriétaire,mais les droits de

lecture et écriture aux membres du groupe ainsi qu’aux autres. . .

Le nombre à trois chiffre est appelé le mode du fichier (et le ch de chmod est pour « change »).
Naturellement seuls le propriétaire d’un fichier (et root bien sûr, puisqu’il a tous les droits)
peuvent effectuer un chmod sur un fichier.

L’option « -l » (=format long) de ls permet de connaître les droit d’accès d’un fichier :

Le résultat de ls -l fournit les informations suivantes :

— Le premier caractère indique le type du fichier : un tiret pour un fichier plat (comme dans
l’exemple), un d pour un répertoire 2 (directory), un l pour un lien symbolique, un c pour un
device (caractère spécial), etc.

10
— Les 3 caractères suivants indiquent les droits du propriétaire du fichier dans l’ordre read,
write, execute : un tiret indique que le droit n’est pas donné, sinon la lettre correspondante
apparaît (voir les deux exemples).

— Les 3 caractères suivants indiquent les droits des membres du groupe du fichier selon le
même principe.

— Les 3 caractères suivants indiquent les droits des autres utilisateurs, toujours selon le même
principe.

— Ensuite vient le nombre de liens qui pointent sur le i-node du fichier. La plupart du temps
c’est 1 pour les fichiers qui ne sont pas des répertoires, et de 1 + le nombre de répertoires fils
pour un répertoire (il s’agit du lien « standard » sur le répertoire, du lien. et du lien.. de chaque
répertoire fils).

— Suivent le nom du propriétaire et le nom du groupe du fichier.

— Puis la taille du fichier (nombre d’octets, 5 dans l’exemple).

— Puis la date et l’heure de dernière modification du fichier (ou la date et l’année si plus d’un
an).

— Et enfin le nom du fichier.

Seul root peut changer le propriétaire d’un fichier, en utilisant la commande chown (change
owner) :

# whoami

root

# chown untel ceFichier

2. « ls -l nomRepertoire » fournit la liste des fils du répertoire. Pour avoir les information du
répertoire lui-même au lieu de ses fils, on doit ajouter l’option -d

# chown untel.ungroupe cetAutreFichier

(Sous la seconde forme, chown permet de modifier aussi le groupe du fichier).

Lorsqu’un utilisateur a le droit d’exécuter un fichier plat, le processus qu’il lance ainsi
appartient à l’utilisateur qui l’a lancé, c’est-à-dire qu’il agit en son nom et non pas au nom de

11
l’utilisateur qui possède le fichier. Cela suppose donc d’avoir pleinement confiance en
l’honnêteté du propriétaire de ce fichier. . .

12