Informations sur le système

La différence fondamentale entre Linux et Unix réside dans leur modèle de distribution et de développement. Unix est généralement considéré comme un système d'exploitation propriétaire, tandis que Linux est open source. Cela signifie que le code source du noyau Linux est accessible à tous et peut être modifié et redistribué, tandis que le code source d'Unix est généralement détenu et contrôlé par une entreprise ou une entité propriétaire.

En conséquence, le noyau utilisé par chaque système est différent : Linux utilise le noyau Linux, tandis qu'Unix utilise différents noyaux en fonction de la distribution spécifique.

De plus, chaque système a ses propres distributions ou variantes. Pour Linux, cela inclut des distributions populaires telles que Debian, Ubuntu, Red Hat, et CentOS, entre autres. Pour Unix, des exemples de distributions sont Solaris (développé par Oracle) et AIX (développé par IBM). Ces distributions offrent des fonctionnalités et des caractéristiques spécifiques, ainsi que différents niveaux de support et de compatibilité matérielle.

Documentation

En général, lors de l'installation de services, les informations sont documentées dans le répertoire /usr/share/doc.

De plus, il existe plusieurs commandes pour obtenir des informations sur les commandes, telles que man, info et --help.

Il est possible de trouver des informations sur les services en consultant les sites officiels correspondants ou en recherchant des réponses sur des forums en ligne.

Arborescence

Voici l'arborescence par défaut du système depuis la / (racine).

var : Ce répertoire regroupe tous les fichiers de données variables comme les logs systèmes ainsi que des logs sur les différents services, les services en cours d'exécution et autres. Ce dossier fait parti des répertoires qui prennent le plus de place selon le nombre de service qui tourne sur la machine. Nous avons notamment /var/lib qui contient les fichiers pour les bases de données (SGBD). Aussi, /var/log qui contient tous les fichiers de logs systèmes et applicatifs. Nous pouvons trouver également /var/lock qui contient des fichiers pour chaque application en cours d'exécution afin d'éviter de les lancers deux fois. Le fichier est automatiquement supprimer lors de l'arrêt du service. Dans le même fonctionnement, il existe /var/run qui a comme information supplémentaire le Processus ID (PID) Un autre, /var/spool qui contient la file d'attente pour les impressions, les mails, tâches planifiés, etc. Un dernier, /var/tmp qui à le même fonctionnement que le répertoire pour les fichiers temporaire (tmp), sauf qu'ici, il conserve les données plus longtemps. Généralement, une partition est réservé pour ce répertoire.
bin : Ce répertoire contient les exécutables qui sont nécessaire au bon fonctionnement du système. On peut retrouver les commandes comme date ou nano.
sbin : Ici on retrouve toutes les commandes pour l'administration du système comme par exemple iptables ou adduser.
lib : C'est un répertoire qui contient les librairie afin que les commandes puissent fonctionner. Les exécutables des dossiers bin et sbin utilisent donc ce répertoire.
dev : Il contient tous les périphériques connecté au système. Par exemple, le lecteur CD-ROM aura un fichier dans le dossier /dev/cdrom, tout comme une clé USB ou autre. Pour savoir à quoi correspond le dernier périphérique connecté nous pouvons utiliser la commande dmesg qui nous donnes donc les informations en question. Si on reprend l'exemple de la clé USB, il y aura un dossier ce nommant /dev/sdb et un sous dossier /dev/sdb1 si une partions est existante. On peut également voir quel nom de dossier correspond à quel identifiant en faisant la commande ls -ltr dans le répertoire /dev/disk/by-id/
etc : Contient tous les fichiers ne trouvant pas leur place dans les autres dossier. Nous pouvons par exemple /etc/init.d qui sert à démarrer les scripts ou les services de la machine.
proc : Il ne prend aucune place sur le disque, il stocké sur la RAM et il contient des fichiers qui concernent des informations sur le système comme l'utilisation de la mémoire, la liste de périphériques et autres.
sys : Ce répertoire de fichier virtuel qui à pour principal but de présenter sous forme de fichier les différents périphériques et d'indiquer les caractéristiques.
run : Ce dossier est système de fichier virtuel qui ne prend aucune place sur le disque. Il contient les fichiers des applications comme /var/lock et les fichiers PID comme dans /var/run.
home : Ce répertoire contient des dossiers pour chaque utilisateur du système. Les données des utilisateurs seront donc stockée dedans. Aussi, c'est ici ou les configurations spécifiques à chaque utilisateur seront présente, comme par exemple pour l'éditeur Vi, sa sera dans /home/user/.exrc
root : Ce répertoire à le même fonctionnement que le répertoire home, il stock donc les données liés à l'utilisateur root. La seul différence, c'est qu'il est dédié uniquement à l'utilisateur root pour des raisons de sécurité.
boot : Comme son nom l'indique, ce répertoire est consacré au démarrage de l'OS, il contient donc le noyau (Kernel) ainsi que d'autres fichier qui sont exécuté au démarrage.
tmp : Ce répertoire correspond aux fichiers temporaire qui sont automatiquement déplacé dedans et supprimer au bout de 30 jours.
mnt : Il est réservé au montage des périphériques sur le système.
usr : C'est le plus volumineux du système, il contient tous les programmes qui ne sont pas dans bin et sbin ainsi que la documentation et des sources sur les différents logiciels installé. Dedans, il existe donc /usr/bin, /usr/sbin ainsi que /usr/lib qui sont des sous-répertoires qui contient des données binaire supplémentaire qui ne sont pas obligatoire pour l'administration du système. Aussi, on peut y retrouver /usr/local qui contient les applications et les documents par rapport à la machine local. Il existe également /usr/share pour la documentation, nous pouvons d'ailleurs retrouver /usr/share/info, /usr/share/man et /usr/share/doc. Pour terminer, nous avons également /usr/src qui est un répertoire qui contient les sources des programmes open source installé sur la machine.
lost+found : Ce répertoire permet de récupérer des fichier perdu suite à un problème sur le système comme par exemple un arrêt involontaire suite à un problème d'alimentation. Il est créer automatiquement au démarrage du système.

Montage et accès aux médias amovibles

Sur les systèmes Linux, il est possible de stocker le contenu d'un dossier sur une partition différente, même si le dossier lui-même reste sur la partition principale. Cette partition peut se trouver sur un support de stockage différent.

Le premier exemple, le répertoire var est localisé sur la partition principale du disque dur, mais son contenu est stocké sur une autre partition qui se trouve également sur ce même disque.

Dans le second exemple, le dossier etc est situé sur la partition principale du disque dur, cependant le contenu est sur une autre partition qui se trouve sur un support de stockage différent, à savoir un CD-ROM.

La commande mount peut être utilisée pour monter un périphérique, comme illustré dans le deuxième exemple ci-dessus.

Manipulation des fichiers

Fichier et répertoires

Un fichier ou un répertoire doit fournir des indications sur son contenu.

Sur Windows, il n'est pas possible d'avoir deux fichiers avec le même nom dans un même dossier. Cependant, sur un système Linux, il est possible d'avoir plusieurs fichiers qui ont des noms similaires mais qui sont écrits avec des lettres majuscules ou minuscules différentes. Par exemple, un fichier nommé wiki, WIKI ou Wiki sera considéré comme trois fichiers différents.

On peut bien entendu mettre des lettres en minuscule de a à z, en majuscule de A à Z et des numéros de 0 à 9. Par contre, pour les caractères spéciaux, la plupart sont déconseillé, bloqué voir mis entre guillemet pour éviter d'avoir des confusions.

Pour avoir créer un fichier ou un répertoire caché, il suffit simplement d'ajouter un point . avant le nom du dossier ou du document.

Types de fichier

Il existe sept types de fichiers sous les systèmes Linux :

fichier standard ;
répertoire ;
lien symbolique ;
fichier pointant vers un périphérique (bloc) ;
fichier pointant vers un périphérique (caractère) ;
fichier tampon ;
fichier socket.

Les principaux sont les trois premiers de la liste, ce sont ceux que on retrouve le plus souvent.

Chemins

Sur un système Linux, il ne suffit pas d'avoir un nom pour retrouver un fichier, car ce dernier peut exister à plusieurs endroit. Il faut obligatoirement avoir son chemin. Il en existe trois différents.

Absolus

Un chemin absolu est une référence de fichier qui commence à partir de la racine de l'arborescence du système d'exploitation. Ainsi, pour accéder à un fichier en utilisant un chemin absolu, il faut commencer par la racine et naviguer jusqu'au dossier spécifique contenant le fichier. Par exemple, le fichier parser.conf peut être situé dans le dossier /etc/apparmor, ce qui signifie que son chemin absolu serait /etc/apparmor/parser.conf.

Relatifs

Un chemin relatif est une référence de fichier qui est basée sur l'emplacement actuel de l'utilisateur dans l'arborescence du système de fichiers. Par exemple, si l'utilisateur se trouve dans le répertoire home et recherche le fichier parser.conf qui se trouve dans le dossier /etc/apparmor, le chemin relatif serait ../etc/apparmor/parser.conf. Si l'utilisateur se trouve dans le dossier /home/support, le chemin relatif serait ../../etc/apparmor/parser.conf.

Personnels

Un chemin personnel est un chemin d'accès qui ne peut être utilisé que pour les sous-répertoires du dossier de l'utilisateur, par exemple /home/support pour l'utilisateur support. Il permet de rechercher un fichier spécifique dans ce dossier en utilisant le symbole ~ suivi du chemin d'accès du fichier. L'utilisation du symbole ~ permet de se placer directement dans le répertoire /home/support, sans avoir besoin de spécifier le chemin complet.

Organisation physique des fichiers (Inodes et blocs)

L'organisation des fichiers physique est séparé en deux parties :

La table des inodes ;
Les blocs de données.

Chaque fichier sur le système linux sont constitué par une structure qui ce nomme inode (index node) contenant des informations sur le fichier. En plus de cela, nous avons des blocs de données qui contiennent des données utilisateurs qui sont stockées dans le fichier.

Inode

Les inodes sont regroupés dans une table et sont identifiables par un numéro. Ils contiennent la totalité des informations d'un fichier, sauf son nom et son contenu :

Type de fichier ;
Droit d'accès sur le fichier ;
Nombre de liens physiques (références) ;
UID : ID de l'utilisateur propriétaire du fichier ;
GID : ID du groupe propriétaire du fichier ;
Taille réelle que le document fait ;
Date de la dernière modification faite sur le fichier et consultation ;
Adresse qui pointe vers les blocs de données qui constituent le fichier.

Il est possible d'avoir ces informations à l'aide de la commande stat ou ls -ld

Blocs de données

Les données d'un fichier (ex. nom du fichier et contenu) sont stockées dans des blocs de données qui sont eux-mêmes stockés sur le disque dur.

En résumé, l'inode est une structure de données qui contient des informations sur un fichier ou un répertoire spécifique, tandis que les blocs de données sont les unités de stockage de base utilisées pour stocker les données réelles d'un fichier sur le disque dur. Ensemble, ils permettent au système de fichiers Linux de gérer efficacement les fichiers et les répertoires stockés sur le disque dur

Droit d'accès aux fichiers

Comme sur tout OS standard, les distributions Linux sont capable de faire du multiutilisateurs. C'est ce qui permet d'avoir plusieurs utilisateurs sur la même machine tout en ayant chacun sont propre répertoire privé. Chaque utilisateur doit faire parti d'un groupe au minimum et il est possible de l'ajouter dans combien on souhaite afin de pouvoir par exemple gérer des accès sur des répertoires partagées.

Dans l'exemple ci-dessus, nous pouvons retrouver les informations suivantes :

Tarik et Charles font parties uniquement du groupe Support ;
Dominique fait partie du groupe Support mais fait également partie du groupe Opération ;
Marco fait également parti du groupe Support, mais lui aussi, fait partie d'un autre groupe qui est Développement ;
Marijan et Alan font partie du groupe Opération ;
Kieran et Aurélien font partie du groupe Développement.

Tous les utilisateurs ont leurs propres UID (User ID) ainsi que les groupes ont leurs propres GID (Group ID). Ce dernier est utilisé pour déterminer l'utilisateur ou le groupe propriétaire d'un fichier.

Hiérarchie des utilisateurs

Il existe principalement trois types d'utilisateur différent sur un système Linux.

root : cet utilisateur dispose des droits d'accès les plus élevés et n'est pas soumis aux questions de droit. Toutefois, il est déconseillé de l'utiliser comme compte principal. Il est pratiquement en mesure d'effectuer toutes les actions sur le système, étant donné que les fichiers se basent sur des identifiants et que cet utilisateur possède le UID 0. Pour le groupe, il fait parti du GID 0 également, donc le groupe administrateur.
standard : les utilisateurs standard sont ceux qu'on peut créer pour que des personnes réels ce connectent au système et puisse l'utiliser. Les User ID des utilisateurs standard est supérieur à 999. Les groupes ont également un Group ID supérieur à 999.
service : ces utilisateurs ne sont pas affecté à des personnes réels mais uniquement à des applications installés sur le système. Cela facilite la gestion des droits d'accès pour les services et démons. Leurs UID ce trouvent entre 1 et 499. Le GID des services ce trouvent entre 1 et 999.

Sudoers

Pour des questions de sécurité sur les système linux, les utilisateurs standards n'ont pas les droits suffisants afin d'effectuer des opérations tel que des installations de paquet sur la machine.

Afin d'effectuer des opérations, nous avons deux possibilités. La première et la moins recommandé est d'utiliser l'utilisateur root. Cela peut devenir très dangereux dans le cas où on fait une mauvais manipulation.

La deuxième est d'installer le paquets sudo et de gérer les autorisations pour les utilisateurs depuis ce dernier :

root$ apt install sudo

Pour ajouter des droits aux utilisateurs, il faut ce rendre dans le fichier /etc/sudoers.d :

root$ cat /etc/sudoers.d

#
# This file MUST be edited with the 'visudo' command as root.
#
# Please consider adding local content in /etc/sudoers.d/ instead of
# directly modifying this file.
#
# See the man page for details on how to write a sudoers file.
#
Defaults        env_reset
Defaults        mail_badpass
Defaults        secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

# Host alias specification

# User alias specification

# Cmnd alias specification

# User privilege specification
root    ALL=(ALL:ALL) ALL

# Allow members of group sudo to execute any command
%sudo   ALL=(ALL:ALL) ALL

# See sudoers(5) for more information on "@include" directives:

@includedir /etc/sudoers.d

Il est possible de laisser les droits totaux comme pour l'utilisateur root en ajouter cette ligne :

# Allow Marijan to run any command
marijan ALL=(ALL:ALL) ALL

Sinon, on peut autoriser uniquement certaines opérations :

# Allow Marijan only to reboot the system
marijan localhost=usr/bin/shutdown -r now

Il est également possible d'autoriser des groupes. La seul différence, c'est qu'il faut ajouter le symbole pourcentage (%) devant le nom du groupe.

Fichiers de Contrôle d'Accès

Il existe trois différents fichiers de contrôle d'accès sur Linux qui donnent certaines informations au sujet des utilisateurs et des groupes.

Le premier ce trouve dans le fichier /etc/passwd. Contrairement à ce que son nom indique, nous n'avons aucune information sur le mot de passe (password). Nous pouvons trouver les informations suivantes sur l'utilisateur :

marijan$ grep -i Marijan /etc/passwd
support:x:1000:1001::/home/marijan:/bin/bash

Voici dans l'ordre de séparations (:) ce que représente chaque parties de la ligne :

Nom d'utilisateur ;
Mot de passe (X) ;
UID ;
GID ;
Répertoire personnel ;
Shell ;

Le mot de passe ce trouve dans un autre répertoire qui est etc/shadow. Cependant, le mot de passe est haché, il est donc impossible de le savoir. Nous pouvons tout de même trouver diverses informations sur le mot de passe :

marijan$ grep -i Marijan /etc/shadow
marijan:$y$j9T$vsrjapt.8tYJySGDOq2r0.$TJf4/wgZksqKPfYnNemh/G2YMFItBApEqnYsLltqco1:19737:0:99999:7:::

Nom d'utilisateur ;
Mot de passe (haché) ;
Date de la dernière modification ;
Le délais minimum avant de changer de mot de passe ;
Le délais maximum avant de changer de mot de passe ;
Le délais avant de prévenir l'utilisateur de changer de mot de passe ;
Le délais après l'expiration du mot de passe avant de passer l'utilisateur en inactif ;
La date d'expiration du mot de passe ;

Pour les informations du groupe, ils ce trouvent dans le répertoire /etc/group :

marijan$ grep -i Marijan /etc/group
support:x:1001:marijan

Nom du groupe ;
Mot de passe ;
GID ;
Membres ;

Tous ces fichiers ne sont pas modifiable au travers d'un éditeur de texte comme VIM. Ils doivent être défini à la création ou alors modifier avec la commande usermod.

Accès

Les droits sur un fichier sont séparé en trois parties :

Utilisateur : le propriétaire du fichier, celui qui a créé le fichier ;
Groupe : par défaut, lors de la création d'un fichier il prend le groupe où l'utilisateur ce trouve. Cependant, il est possible de modifier ;
Autre : concerne toutes les autres personnes qui ne sont soit pas propriétaire du fichier ou dans le groupe défini.

Nous pouvons d'ailleurs retrouver ces informations dans les détailles d'un fichier :

Dans l'exemple ci-dessus, nous pouvons voir que le fichier wiki appartient à l'utilisateur marijan et au groupe support. La partie droit au début concerne les accès disponible pour l'utilisateur, le groupe et les autres. Plus précisément :

Comme nous pouvons le voir dans l'image ci-dessous, il existe trois niveaux de droit différents :

r : le droit Read permet de lire le fichier ;
w : le droit Write permet d'écrire dans le fichier ;
x : le droit eXecute permet d'exécuté le fichier.

Ici, l'utilisateur marijan à l'autorisation de lire et d'écrire dans le fichier. Par contre, le groupe support ainsi que les autres ont le droit uniquement de lire le contenu du fichier.

Pour les dossiers, c'est un peu plus complexe. Il est obligatoire d'avoir le droit d'exécuter (x) afin de connaître l'inode des fichiers dans le répertoire et de lire (r) pour connaître leurs noms. Car comme vu sous le chapitre d'organisation des fichiers, le nom est une chose, mais pour avoir les données il faut avoir l'inode. Afin de pouvoir supprimer/modifier/créer des dossiers, c'est le droit d'écriture (w) qui entre en jeu.

Accès supplémentaire

Il existe d'autres droits en plus qui sont moins connu et utilisé dont notamment le SUID, SGID et Sticky Bit.

SUID : Concerne le droit d'exécuté des fichiers par le propriétaire par un s (minuscule). Cette lettre signifie que n'importe quel utilisateur pourra exécuté l'objet. Utilisé par exemple avec le fichier passwd. On peut également définir l'exécution par un S (majuscule), cela veut dire que uniquement le propriétaire et les membres du groupe lié pourront exécuté l'élément. Même si le S ressemble beaucoup au simple droit d'exécuté, il est plus restreint et donc plus sécurisé.

SGID : Même concept que pour le SUID, sauf qu'il s'applique sur les groupes. Si on active le SGID sur un dossier par exemple, lorsqu'un utilisateur du groupe créer un fichier, ce dernier héritera des droits du dossier parent.

Sticky Bit : Concerne le droit de suppression par un t (minuscule), cela signifie que uniquement le propriétaire du fichier pourra supprimer le fichier même si les autres ont le droit de lecture et écriture. Cela permet d'empêcher la suppression malveillante des autres utilisateurs, tout en leur laissant la possibilité de lire et écrire. Lorsque le droit est un T (majuscule), cela veut dire que tout le monde possédant le droit d'écrire et lire pourront supprimer le fichier.

Ces types d'accès sont pratiques pour les travaux en groupe. Si on reprend l'exemple au tout début, nous avons Marijan et Dominique qui sont dans le groupe Operation. Pour Marijan, c'est le groupe principale. Par contre, pour Dominique, ce n'est pas le cas.

id marijan
uid=1001(marijan) gid=1004(operation) groups=1004(operation)

id dominique
uid=1002(dominique) gid=1002(support) groups=1002(support) 1003(operation)

Marijan à créer un groupe nommé Operation-Public. L'utilisateur propriétaire est donc Marijan et le groupe est Operation. Afin que les fichiers et dossiers que les autres membres vont créer héritent des mêmes droit que le dossier parent, Marijan à activer le SGID.

mkdir Operation-Public

chmod g+s Operation-Public

ls -l
drwxrwsr-x   2 marijan   operation  4096 Apr   4 10:23

Maintenant, tous les membres qui vont créer des fichiers et dossiers dedans auront comme propriétaire leur compte, mais comme groupe et droit celle du dossier parent. Cela permet que tous les membres du groupe du répertoire parent pourront accéder au fichier et y travailler, même s'ils n'ont pas créé le fichier eux-mêmes.

Imaginons maintenant que Marijan avec le Sticky Bit, cela veut dire que tous les membres de Operation ne pourront plus supprimer ou éditer les fichiers des autres utilisateurs du groupe. Ils pourront uniquement le faire sur leur propre fichier.

chmod +t Operation-Public

ls -l 
drwxrwsr-t   2 marijan   operation  4096 Apr   4 10:23 Operation-Public

Donc lorsque Dominique va tenter de supprimer ou d'éditer le fichier de Marijan, il ne pourra pas le faire car il n'a plus les droits nécessaire.

ls -l /Operation-Public/

-rw-r--r--   2 marijan   operation  4096 Apr   4 10:53 Marijan_File

Gestion des processus

Un processus sur Linux est un programme en cours d'exécution. Le système d'exploitation est capable de gérer et d'exécuté plusieurs processus en simultané.

Les processus qui tournent en permanence sont appelé les processus démon. Ces derniers comportent toujours un d à la fin de leur nom pour démon. Par exemple, pour le serveur web Apache, on a httpd.

Arborescence de processus

Tous les processus sont identifié par un PID (Processus IDentifier) et ce dernier est un numéro donné par le noyau au lancement du programme en question, il est donc pas possible de le choisir. Le noyau du système utilise une table pour la gestion des différentes tâches.

Deux primitives composent un processus :

fork : permet de créer un clone d'un processus ;
exec : permet au clone créer d'exécuté un programme différent.

Il existe donc une affiliation entre processus, un fils et un père. Tous les processus ont un père, sauf le premier qui est init (pour toutes les distributions avec la méthode SysV ou Systemd sur les plus récentes). Le PID de init est obligatoirement 1.

En avant-plan et arrière-plan

Il existe principalement deux types de processus, ceux qui s'exécute en avant-plan et ceux en arrière-plan.

Les processus en premier plan empêchent l'utilisateur d'interagir avec le terminal tant qu'ils ne sont pas terminés. Par exemple, lorsqu'on installe un paquet ou qu'on utilise vim, on ne peut rien faire d'autre que soit attendre la fin de l'installation, soit fermer la fenêtre vim.

Les processus en arrière-plan permettent à l'utilisateur de continuer à interagir avec le terminal et d'autres programmes pendant qu'ils s'exécutent. Pour exécuter un programme en arrière-plan, on peut ajouter le caractère & à la fin du nom du processus.

Shell

Il existe effectivement des interfaces graphiques pour la plupart des distributions Linux, mais l'utilisation de ligne de commande reste quelque chose de primordiale.

Effectivement, pour mieux comprendre le système et pour gagner en productivité, il est recommandé de privilégier le shell.

Le shell est automatiquement exécuté lorsque l'utilisateur ce connecte au terminal. C'est ce dernier qui permet de faire la traduction entre l'utilisateur et le système et d'exécuter des commandes sur ce dernier.

Nous pouvons comme le montre le schéma ci-dessous, voir le shell comme une coquille entre le système et l'utilisateur.

Il existe différents shell disponible sur les systèmes Linux, mais celui qui va nous intéresser est le Bash.

Kernel

Le noyau, tel que celui utilisé dans Linux, constitue le fondement essentiel d'un système d'exploitation. Il assure la liaison entre le matériel (hardware) et le logiciel (software) d'un système d'exploitation.

Pour illustrer, on pourrait le comparer à une bibliothèque, où d'un côté se trouvent les livres, les postes de travail et les ressources d'étude, et de l'autre, les étudiants. Le noyau agit alors comme le bibliothécaire qui facilite la communication et la gestion des ressources entre ces deux parties distinctes.

Fonctionnalités

Le kernel est responsable de quartes important tâches :

La gestion de la mémoire ;
Quel processus à besoin du CPU et pour combien de temps et à quel quantité ;
Interpréter les appareils physiques ;
Recevoir les tâches pour des services de la part des processus.

Le noyau est Monolithique, ce qui signifie qu'il est arrive à gérer plusieurs opérations par lui même comme par exemple la mémoire ainsi que l'utilisation du CPU. Il est également Modulaire car il est capable d'étendre ces capacités dynamiquement.

Le fonctionnement d'un processus est divisé en deux parties. D'un côté, nous avons donc le noyau avec les périphériques. Ceux-là sont donc gérer uniquement par le kernel, les processus et application n'ont pas accès. De l'autre, nous avons donc les processus et les applications.

Donc, imaginons qu'un application à besoin d'utiliser une partie de la mémoire où le CPU, comme indiqué dans le point 4 ci-dessus, c'est le kernel qui va prendre en charge la tâche et allouer l'espace nécessaire pour le bon fonctionnement de l'application.

Versions

Il est possible de voir la version du kernel utilisé sur Linux avec la commande suivante :

marijan$ uname
Linux

Il est possible d'avoir plus de détails sur le noyau en utilisant l'option suivante dans la commande :

marijan$ uname -r
5.10.0-27-amd64

5 : version du kernel ;
10 : version majeur ;
0 : version mineur ;
27 : Réalisations de patchs ;
amd : distribution spécifique.

Hardware

Quand une source externe, telle qu'une clé USB, est connectée à un ordinateur fonctionnant sous le système d'exploitation Linux, voici ce qui se passe :

Dans un premier temps, c'est l'espace du noyau qui va prendre l'information en détectant un nouveau périphérique connecté en chargeant les pilotes.
Ensuite, un event va être généré et cet event est intitulé uevents par le système et va être transmis à l'espace utilisateur sur le processus udev.
udev est responsable pour créer dynamiquement un espace node dans le répertoire /dev du système de fichier. Le contenu de la source externe va être visible depuis ce dernier.

Pour vérifier si une source externe est connecté à la machine, nous pouvons utiliser la commande suivante :

marijan$ dmesg

Il est possible de filtrer afin de trouver par exemple une clé USB en utilisant la commande grep.

Lors du démarrage de la machine, nous voyons pleins de ligne défilant à toutes vitesses. Ce sont les informations du kernel, dont notamment le chargement des pilotes pour les périphériques.

Outils

La commande udevadm permet la gestion pour udev en interrogeant ce dernier pour accéder à sa base de donnée des périphériques connectés :

marijan$ udevadm info --query=path --name=/dev/sda5

/devices/pci0000:00/0000:00:15.0/0000:03:00.0/host0/target0:0:0/0:0:0:0/block/sda/sda5

Cependant, il est obligatoire de préciser le nom exact du nœud afin de récupérer les informations.

Il est également possible de monitorer les derniers appareils connectés, déconnectés, etc. :

marijan$ udevadm monitor

UDEV - the event which udev sends out after rule processing
KERNEL - the kernel uevent

Pour trouver quel périphérique est connecté à quel nœud, nous pouvons utiliser la commande suivante :

marijan$ lsblk

NAME                    MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
fd0                       2:0    1    4K  0 disk
sda                       8:0    0   32G  0 disk
├─sda1                    8:1    0  487M  0 part /boot
├─sda2                    8:2    0    1K  0 part
└─sda5                    8:5    0 31.5G  0 part
  ├─demo--vm--vg-root   254:0    0 30.5G  0 lvm  /
  └─demo--vm--vg-swap_1 254:1    0  976M  0 lvm  [SWAP]
sr0                      11:0    1 1024M  0 rom

Le nombre majeur (MAJ) défini quel type de périphérique est utilisé. Voici une liste :

1 : RAM
3 : HARD Disque ou CD ROM
6 : Imprimantes
8 : SCSI Disque

Séquence de démarrage

La séquence de démarrage du système est divisé en quatre parties :

BIOS POST : POST signifie power-on, self-test. Dans cette partie, le BIOS démarre un POST test pour vérifier si la partie hardware de l'appareil fonctionne correctement. Si le POST ne passe pas, l'ordinateur ne va pas passer à la deuxième étape ;
Boot Loader (GRUB2) : une fois le POST passé, le BIOS exécute le boot code qui est localisé dans le premier secteur du disque dur. Sur Linux, cette partie ce trouve dans le répertoire /boot. C'est aussi ici que on choisi quel OS on souhaite démarrer si nous avons un dual boot. GRUB2 est aujourd'hui un des boot loader primaire dans les distribution Linux ;
Kernel Initialisation : le kernel est démarrer dans la mémoire et il exécute ces tâches dont l'initialisation des périphériques et la gestion de la mémoire et du CPU ;
INIT Process (systemd) : le systemd monte le système de fichier, les démarres et les gèrent afin d'assurer le bon fonctionnement du système d'exploitation ;

Il est possible de vérifier le init system utilisé en exécutant la commande suivante :

marijan$ ls -l /sbin/init

lrwxrwxrwx /sbin/init -> /lib/systemd/systemd

Runlevels

Sur Linux, nous avons la possibilité de démarrer le système soit en mode interface graphique, soit en mode shell directement (à condition que le système d'exploitation soit installé avec le support graphique). Ce choix dépend du niveau d'exécution runlevel sur lequel nous nous trouvons :

Runlevel	Systemd Targets	Fonction
5	graphical.target	Démarrage sur l'interface graphique
3	multiuser.target	Démarrage sur le shell

Effectivement, si nous sommes sur le runlevel 5, cela signifie que nous sommes sur l'interface graphique. Il est possible de vérifier le mode par défaut de le modifier avec la commande suivante :

marijan$ systemctl get-default
graphical.target

marijan$ systemctl set-default multi-user.target

Ici, nous avons modifier le Systemd Targets sur multiuser.target, qui est le runlevel 3 donc le shell. Il existe d'autres modes de runlevel pour des utilisations plus spécifique.

Gestionnaire de paquet

Il existe différents types de gestionnaires de paquets pour les distributions Linux existantes. De plus, il est important de souligner que pour classifier les différentes distributions, on se base sur le type de paquet utilisés.

Lorsque l'on souhaite installer une application sur notre système Linux, nous recherchons les paquets du logiciel en question. À l'intérieur, nous trouverons les informations suivantes :

Fichier binaires du logiciel ;
Les métadonnées ;
Les fichiers de configuration ;

Cependant, il ne suffit pas d'installer n'importe quel package. Par exemple, si nous installons le package d'une application en format .deb sur un système Ubuntu, nous pourrions rencontrer des erreurs. Cela est dû aux différentes dépendances requises par le système d'exploitation.

Afin de faciliter la tâche aux utilisateurs pour éviter de chercher le paquet à la main, le gestionnaire de paquet intervient. Ce dernier est par défaut installer sur les système d'exploitation et va automatiser l'installation :

Vérification de l'intégrité des paquets et de leur authenticité afin de s'assurer que cela provient d'un site sécurisé ;
Simplifier la gestion des paquets par l'installation, la mise à jour, la configuration et la suppression des paquets une fois installé ;
Grouper les paquets afin d'éviter les confusions pour l'utilisateur ;
Vérifier les dépendances des paquets par rapport au système d'exploitation afin d'éviter des problèmes à l'installation.

Red Hat Package Manager

Red Hat Package Manager ou RPM est le gestionnaire de paquet utilisé pour la distribution, comme son nom l'indique, Red Hat, mais pas uniquement. CentOS, Fedora ou encore d'autres distributions ce base dessus.

Voici quelques commandes par défaut pour la manipulation des paquets .rpm :

Pour l'installation, d'un paquet .rpm, nous pouvons exécuter la commande suivante :

marijan$ rpm -ivh telnet.rpm

Afin de désinstaller un paquet, exécutez la commande suivante :

marijan$ rpm -e telnet.rpm

Pour mettre à jour un paquet, faites la commande suivante :

marijan$ rpm -Uvh telnet.rpm

Par défaut, une base de données RPM est configurée sur le système dans le répertoire /var/lib/rpm. À l'intérieur, nous pouvons trouver toutes les informations sur les paquets du système. Cette fonctionnalité est pratique pour éviter les doublons de paquets, pour connaître la version du paquet et pour suivre toutes les modifications apportées au paquet depuis son installation. Nous pouvons vérifier par nous-mêmes en utilisant la commande suivante :

marijan$ rpm -q telnet.rpm

Il est possible de vérifier un paquet afin de s'assurer que tous les fichiers du paquet provienne bien du paquet originel. Cela est pratique afin de vérifier si le paquet à bien été installer depuis un site sécurisé. Voici la commande pour vérifier ce point :

marijan$ rpm -Vf <path>

Yellowdog Updater Modified

RPM n'est pas capable de gérer les dépendances des paquet par lui même, c'est pour cela qu'il existe des front-end comme Yellowdog Updater Modified, ou YUM, afin d'assurer le bon fonctionnement.

L'objectif est de simplifier la recherche de paquets et l'installation en général. En effet, YUM dispose de sa propre base de données contenant des centaines de paquets. De plus, par défaut, dans le répertoire /etc/yum.repos.d, nous trouvons un lien vers le dépôt logiciel (Software Repository). Ainsi, YUM téléchargera les paquets à partir de ce dépôt, assurant ainsi leur authenticité.

Aussi, il est possible d'installer des paquets qui ne proviennent pas de cette base de données en les ajoutant dans /etc/yum.repos.d/nginx.repo, par exemple. Cette pratique est utilisée dans les cas où la version du paquet n'est pas la plus récente dans la base de données YUM , ce qui peut parfois se produire.

Lors de l'installation d'un paquet, nous n'avons plus besoin de spécifié sont extension, simplement le nom. YUM va ensuite vérifier si il n'est pas déjà installer sur le système, puis va vérifier si il faut installer d'autres paquets afin d'assurer le fonctionnement et va mettre à jour si les paquets sont déjà présent mais pas sur la dernière version.

marijan$ yum install telnet

Il va ensuite faire un résumer du toute et va demander à l'utilisateur de confirmer l'installation.

Voici quelques commande de base sur YUM :

Il est possible de vérifier tous les paquets (.repo) installer sur le système :

marijan$ yum repolist

Avant d'installer un paquet, il est possible de vérifier ce que ce dernier va fournir :

marijan$ yum provides scp
opensss-clients-7...
Repo        : base
Matched from:
Filename    : /usr/bin/scp

Ici, nous pouvons apercevoir que SCP offre l'installation du paquet openssh-client.

Pour supprimer un paquet, utilisez la commande suivante :

marijan$ yum remove telnet

Pour mettre à jour, exécutez la suivante :

marijan$ yum update telnet

Il est possible de mettre à jour tous les paquets du système en une seul commande :

marijan$ yum update

Debian Package Manager

Debian Package Manager ou DPKG est le gestionnaire de paquet utilisé pour la distrubiton, comme son nom l'indique, Debian, mais pas uniquement. Ubuntu, PureOS ou encore d'autres distributions ce base dessus.

DPKG est très similaire à RPM, il a les mêmes fonctionnalités sauf qu'il est juste moins poussé que ce dernier.

Voici quelques commande par défaut pour la manipulation des paquets .deb :

Pour l'installation, d'un paquet .deb, nous pouvons exécuter la commande suivante :

marijan$ dpkg -i telnet.deb

Afin de désinstaller un paquet, exécutez la commande suivante :

marijan$ dpkg -r telnet.deb

Pour afficher une description un paquet, faites la commande suivante :

marijan$ dpkg -l telnet.deb

Il est possible de vérifier si un paquet est déjà installer sur la machine avec la commande suivante :

marijan$ dpkg -s telnet.deb

Il est possible de vérifier un paquet afin de s'assurer que tous les fichiers du paquet provienne bien du paquet originel. Cela est pratique afin de vérifier si le paquet à bien été installer depuis un site sécurisé. Voici la commande pour vérifier ce point :

marijan$ dpkg -p <path>

Advanced Packaging Tool / Advanced Packaging Tool Get

Comme RPM et YUM, DPKG n'est pas capable de gérer l'installation des paquets nécessaire pour faire fonctionner le service qu'on souhaite. C'est pour cela que nous utilisons des front-end comme Advanced Packaging Tool, ou APT (ou APT-GET), afin d'assurer l'installation complète.

Tout comme YUM, l'objectif est de simplifier la recherche de paquets et l'installation en général. APT dispose donc de sa propre base de données contenant des centaines de paquets. De plus, par défaut, dans le répertoire /etc/apt/sources.list, nous trouvons un lien vers le dépôt logiciel (Software Repository). Ainsi, APT téléchargera les paquets à partir de ce dépôt, assurant ainsi leur authenticité.

Il est également possible d'installer des paquets qui ne proviennent pas de son dépôt originel en le spécifiant durant l'installation.

APT et APT-GET ne dépende pas entres eux. Effectivement, ce sont deux outils distinct et APT est plus fréquemment utilisé car il est beaucoup plus user-friendly et un meilleur outil que APT-GET.

La raison de pourquoi APT est plus user-friendly est car par exemple lors de l'installation d'un paquet, les informations afficher sont plus courte, il affiche le nécessaire avec une barre de progression. Aussi, si on regarde pour voir si un paquet est déjà sur le système, APT affichera plus clairement les informations tandis que APT-GET, qui lui affichera un bloc de donnée.

Afin de mettre à jour tous les informations des paquets installer sur le système, nous pouvons utiliser la commande suivante :

marijan$ apt update

Pour mettre à jour les paquets du système, il suffit d'utiliser la commande suivante :

marijan$ apt upgrade

Il est possible de modifier le lien vers le dépôt logiciel (Software Repository) :

marijan$ apt edit-sources

Lors de l'installation d'un paquet, nous n'avons plus besoin de spécifié sont extension, simplement le nom. APT va ensuite vérifier si il n'est pas déjà installer sur le système, puis va vérifier si il faut installer d'autres paquets afin d'assurer le fonctionnement :

marijan$ apt install telnet

Il va ensuite faire un résumer du toute et va demander à l'utilisateur de confirmer l'installation.

Pour supprimer un paquet, utilisez la commande suivante :

marijan$ apt remove telnet

Il est possible de vérifier tous les paquets disponible :

marijan$ apt list| grep telnet

Le grep permet de chercher uniquement un paquet en particulier afin de vérifier si il est bien installer.

Il est possible de vérifier si un paquet en particulier est installer sur la machine en utilisant :

marijan$ apt search telnet

Redirection E/S

Redirection E/S, ou redirection d'entrée et de sortie (output, input en anglais) concerne les messages que nous avons lorsqu'on exécute une commande sur le shell.

Il en existe trois, dont notamment :

Standard Input : concerne l'entrée d'une commande :

marijan$ cat hello.txt

Standard Output : concerne la réponse lors de l'exécution de la commande :

marijan$ cat hello.txt
Salut c'est Marijan

Standard Error : concerne l'erreur qui nous es retourné en cas de problème :

marijan$ cat hello.txt
cat: hello.txt: No such file or directory

Il est possible de modifier le contenu d'un fichier en utilisant la commande echo, suivi du texte ainsi de une flèches vers la droite en direction du fichier souhaité. Par exemple :

marijan$ cat hello.txt
Salut c'est Marijan
marijan$ echo "Fichier de Marijan" > hello.txt
marijan$ cat hello.txt
Fichier de Marijan

Si on souhaite ajouter du contenu dans ce dernier, il suffit d'utiliser deux flèches vers la droite :

marijan$ cat hello.txt
Salut c'est Marijan
marijan$ echo "Fichier de Marijan" >> hello.txt
marijan$ cat hello.txt
Salut c'est Marijan
Fichier de Marijan

Pour les erreurs, même principes sauf que nous allons utiliser le chiffre deux suivi d'une flèche pour écraser le contenu. Ici, nous allons créer un fichier error.txt au passage :

marijan$ cat missing_file 2> error.txt
marijan$ cat error.txt
cat: missing_file : No such file or directory

Même principe, si on souhaite ajouter du contenu et non tout écraser, nous allons utiliser le chiffre deux suivi de deux flèches :

marijan$ cat missing_file 2>> hello.txt
marijan$ cat hello.txt
Salut c'est Marijan
Fichier de Marijan
cat: missing_file : No such file or directory

Si on souhaite redirigé les erreurs sans avoir quelque chose à la sortie, il suffit de rediriger vers le dossier /dev/null qui est le dossier où nous inscrivons tous ce qui n'est pas nécessaire.

marijan$ cat missing_file 2> /dev/null

Pour combiner l'a sortie avec l'entrée, nous pouvons utiliser les pipes. Le symbole du pipe est (|) et afin de rédigé la commande correctement, voici un exemple :

marijan$ grep Marijan hello.txt | less
Salut c'est Marijan
  (END)

Réseau

Dans cette section, vous pouvez trouver quelques commandes de base pour la configuration de la partie réseau sur les machines Linux.

Afin d'afficher et de modifier les interfaces sur la machine, utilisez la commande suivante :

marijan$ ip link

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: ens192: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP mode DEFAULT group default qlen 1000
    link/ether 00:50:56:01:03:3c brd ff:ff:ff:ff:ff:ff
    altname enp11s0

La première interface est la loopback, la seconde, ens192 est l'interface Ethernet de la machine. Ce qui peut être intéressant si nous souhaitons attribuer une adresse IP fixe à la machine, c'est le link/ether qui est l'adresse MAC de l'interface.

Pour voir l'adresse IP assigné à l'interface, exécutez la commande :

marijan$ ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: ens192: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:50:56:01:03:3c brd ff:ff:ff:ff:ff:ff
    altname enp11s0
    inet 172.16.0.15/16 brd 172.16.255.255 scope global ens192
       valid_lft forever preferred_lft forever
    inet6 fe80::250:56ff:fe01:33c/64 scope link
       valid_lft forever preferred_lft forever

Comme vu précédemment, nous retrouvons l'interface ens192 avec plus d'information notamment inet, qui est l'adresse IPv4 et inet6, qui est l'adresse IPv6.

Afin d'assigner l'adresse IP à l'interface, utilisez la commande suivante :

marijan$ ip addr add 192.168.X.X/24 dev eth0

Cette modification s'applique uniquement après le redémarrage de la machine.

Pour créer une route sur le système, exécutez la commande :

marijan$ ip route
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         172.16.0.1      0.0.0.0         UG    0      0        0 ens192
localnet        0.0.0.0         255.255.0.0     U     0      0        0 ens192

marijan$ ip route add 192.168.X.X /24 via 192.168.X.X

Accès et restrictions réseaux (iptables)

Afin de gérer les accès et les restrictions réseaux entres les différentes machines Linux, il existe principalement deux façons. La première, c'est d'installer un pare-feu afin de gérer les règles. La deuxième est sans doute la plus bénéfique en terme de coup, c'est d'utiliser l'outil iptables.

Sur les systèmes RedHat ou CentOS, il devrait être installer par défaut. Sur les distributions Debian ou Ubuntu, il faut l'installer à la main :

marijan$ apt install iptables

Une fois installer, on peut voir les règles par défaut en exécutant la commande suivante :

marijan$ iptables -L

Chain INPUT (policy ACCEPT)
target     prot opt source               destination

Chain FORWARD (policy ACCEPT)
target     prot opt source               destination

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination

Comme le démontre l'output ci-dessus, les trois types de règle sont les suivantes :

Chain Input : concernes les connexions entrantes sur la machine ;
Chain Forward : permet de transférer les connexions entrantes vers une machine distinct (ex. comment un routeur le fait) ;
Chain Output : concernes les connexions sortantes vers d'autres machines.

On utilise le terme Chain of rules (chaîne de règle) car chaque règles sur l'outil fait une vérification avant de valider la connexion.

Afin de mieux comprendre l'utilisation de IPTables, je vais utiliser le schéma réseau ci-dessous et appliquer des restrictions sur mes machines :

Dans un premier temps, je vais autoriser les connexions en SSH sur mon serveur d'application (172.16.238.10) uniquement à la machine utilisateur (172.16.238.187) sur le port 22 :

marijan$ iptables -A INPUT -p TCP -s 172.16.238.187 --dport 22 -j ACCEPT

Voici ce que les options signifient :

-A : type de règle (INPUT, OUTPUT, FORWARD) ;
-p : protocole ;
-s : IP source ;
-d : destination (si forward, output) ;
--dport : port de destination ;
-j : type d'action (ACCEPT, DROP, REJECT).

On peut désormais voir la règle sur notre table :

marijan$ iptables -L

Chain INPUT (policy ACCEPT)
target     prot opt source               destination
ACCEPT     tcp  --  172.16.238.187       anywhere         tcp  dpt:ssh

Si un autre utilisateur essaie de ce connecter au serveur d'application avec la table dans l'état ci-dessus, sa fonctionnerait aussi car nous n'avons pas restreint l'accès. Pour restreindre l'accès à tous et laisser uniquement les machines que nous autorisons, il suffit d'exécuter la commande suivante :

marijan$ iptables -A INPUT -p TCP --dport 22 -j DROP

Vu que nous n'avons pas spécifié la source, toutes les sources seront rejeté car nous avons utiliser un DROP. La table ressemble donc à ceci :

marijan$ iptables -L

Chain INPUT (policy ACCEPT)
target     prot opt source               destination
ACCEPT     tcp  --  172.16.238.187       anywhere         tcp  dpt:ssh
DROP       tcp  --  anywhere             anywhere         tcp  dpt:ssh

L'ordre des règles sur la table à une importance. Si le DROP était avant le ACCEPT, la règle autorisant la machine n'aurait pas pu fonctionner.

Nous allons maintenant terminer de configurer la table pour le serveur d'application.

Dans un premier temps, nous allons autoriser la sortie en direction du serveur de base de donnée sur le port en question :

marijan$ iptables -A OUTPUT-p TCP -d 172.16.238.11 --dport 5432 -j ACCEPT

Ensuite, nous allons également autoriser la sortie en direction vers notre repository serveur sur le port 80 :

marijan$ iptables -A OUTPUT-p TCP -d 172.16.238.15 --dport 80 -j ACCEPT

Nous allons accepter l'entrée du client sur le port HTTP :

marijan$ iptables -A INPUT -p TCP -s 172.16.238.138 --dport 80 -j ACCEPT

Pour terminer, nous allons bloquer toutes les connexions sortant depuis notre serveur d'application.

marijan$ iptables -A INPUT -p TCP --dport 80 -j DROP
marijan$ iptables -A INPUT -p TCP --dport 443 -j DROP

Voici un résumé de la table du serveur d'application :

marijan$ iptables -L

Chain INPUT (policy ACCEPT)
target     prot opt source               destination
ACCEPT     tcp  --  172.16.238.187       anywhere         tcp  dpt:ssh
DROP       tcp  --  anywhere             anywhere         tcp  dpt:ssh
ACCEPT     tcp  --  172.16.238.187       anywhere         tcp  dpt:http

Chain FORWARD (policy ACCEPT)
target     prot opt source               destination

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination
ACCEPT     tcp  --  anywhere             172.16.238.11         ttcp  dpt:postgresql
ACCEPT     tcp  --  anywhere             172.16.238.15         ttcp  dpt:http
DROP       tcp  --  anywhere             anywhere              ttcp  dpt:http
DROP       tcp  --  anywhere             anywhere              ttcp  dpt:https

Sachant que nous avons bloquer toutes les connexions sortantes depuis le serveur d'application vers le port 80 et 443, pour en autoriser une et la mettre au dessus de la règle en question, il suffit d'utiliser l'option -I à la place de -A :

marijan$ iptables -I OUTPUT -p TCP -d 172.16.238.100 --dport 443 -j ACCEPT

Pour supprimer une entrée, il suffit d'utiliser l'option -D ainsi que le type et le numéro de la ligne :

marijan$ iptables -D OUTPUT 5

Pour terminer les accès sur notre schéma, il nous restes plus qu'à autoriser les connexion entrantes uniquement pour le serveur d'application sur notre base de donnée :

marijan$ iptables -A INPUT -p TCP -s 172.16.238.10 --dport 5432 -j ACCEPT
marijan$ iptables -A INPUT -p TCP --dport 5432 -j DROP

Sur les machines, il est possible de voir quels connexions sont établis et sur quel port ils écoutent en utilisant la commande suivante :

marijan$ netstat -an | grep 5432
tcp     0     0 172.16.238.10:44060     172.16.238.11:5432     ESTABLISHED

Vu que nous n'avons pas défini dans la table le port d'entrée pour la base de donnée mais uniquement la sortie, le système va prendre un port aléatoire (44060 ici) et va toujours être différent. Il est important d'ajouter une entrée si nous souhaitons avoir quelque chose de fixe.

Connexion à distance et copie des fichiers (SSH/SCP)

Si nous établissons une machine virtuelle utilisant comme système d'exploitation Linux depuis par exemple un hyperviseur comme VMWare ESXi, afin d'accéder à la console de ce dernier facilement sans avoir à passer par la console web, nous pouvons utiliser le service Secure Shell (SSH) ainsi que Secure Copy (SCP) pour la copie des fichiers.

Afin de mettre en place ce service, il faudra installer sur la machine souhaité le paquet de communication sécurisé openssh-server :

marijan$ apt install openssh-server

La configuration de ce dernier ce passe dans son fichier /etc/ssh/sshd_config. Il faudra décommenter le port ainsi que le mettre à jour si nécessaire. Aussi, la ligne PermitRootLogin permet d'autoriser l'utilisateur root en connexion Secure Shell. Il est possible d'ajuster plusieurs choses pour ce type de connexion depuis ce fichier :

Include /etc/ssh/sshd_config.d/*.conf

Port 1339 <-------------
#AddressFamily any
#ListenAddress 0.0.0.0
#ListenAddress ::

#HostKey /etc/ssh/ssh_host_rsa_key
#HostKey /etc/ssh/ssh_host_ecdsa_key
#HostKey /etc/ssh/ssh_host_ed25519_key

# Ciphers and keying
#RekeyLimit default none

# Logging
#SyslogFacility AUTH
#LogLevel INFO

# Authentication:

#LoginGraceTime 2m
PermitRootLogin yes <-------------
#StrictModes yes
#MaxAuthTries 6
#MaxSessions 10

Afin de ce connecter sur une machine Linux depuis Windows, il faudra installer des outils comme Putty pour le SSH et WinSCP pour le SCP par exemple.

Depuis une machine Linux à une machine Linux, il est possible d'utiliser les commandes ssh ainsi que scp en spécifiant simplement l'adresse IP du serveur et son port si ce n'est pas celui par défaut (22).

Planificateur de tâches (cronjobs)

Pour éviter d'avoir à effectuer manuellement les mêmes tâches quotidiennes à la même heure chaque jour, il existe un outil appelé cronjobs.

Cronjobs permet d'exécuter une commande à la date et à l'heure souhaitées automatiquement, sans intervention de notre part.

Pour configurer ce dernier, il suffit d'exécuter la commande suivante depuis l'utilisateur désiré. Si la commande est exécutée en tant que sudo, le cronjob sera exécuté comme si c'était root qui l'avait mis en place :

marijan$ crontab -e

Cette commande va ouvrir un fichier où à la fin de ce dernier ce trouve les lignes pour ajouter une nouvelle opération.

# Edit this file to introduce tasks to be run by cron.
#
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
# ...
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
#
# For more information see the manual pages of crontab(5) and cron(8)
#
# m h  dom mon dow   command

m : minute ;
h : heure ;
dom : la date (ex. le 20) ;
mon : le mois (ex. le 3) ;
down : le jour de la semaine (ex. le 1 (lundi)) ;
command : la commande souhaité.

Si nous mettons des astérisques (*) pour le jour, le mois et la date, cela signifie qu'il le fera tous les jours, n'importe quel jour de la semaine et quel mois.

Création d'un service (systemd)

Cette section démontre comment créer son propre service en utilisant systemd (processus) ainsi comment faire un débogage de ce dernier. Afin de créer son service, voici quelques informations essentiels au sujet de notre programme :

Programme : ce dernier ce trouve dans le répertoire /usr/bin/project-marijan.sh ;
Dépendance : ce programme nécessite que l'application Python soit démarrer et ça, après que Postegres DB à été également démarré ;
Utilisateur : le service a besoin d'un utilisateur service qui ce nomme project_marijan ;
Erreur : en cas d'erreur, le service est sensé être redémarré automatiquement avec 10 secondes d'intervalles entre chaque essaie ;
Journaux : afin de pouvoir faire du débogage, le service aura ces propres logs ;
Démarrage : il sera démarrer uniquement si on démarre avec la partie graphique du système.

En premier temps, il faudra créer le fichier en question dans le répertoire /etc/systemd/system/project_marijan.service :

marijan$ vim /etc/systemd/system/project_marijan.service

[Service]
ExecStart= /bin/bash /usr/bin/project-marijan.sh

Dedans, nous avons créer la section Service nous avons spécifié le chemin pour notre programme. Les plus basiques des processus ont uniquement ces informations de renseigné.

Voici le fichier compléter avec toutes les informations que nous avons lister plus haut :

[Unit]
Description=Python Project Marijan
Documentation=wiki.stajic.me
After=postgresql.service

[Service]
ExecStart= /usr/bin/project-marijan.sh
User=project_marijan
Restart=on-failure
RestartSec=10

[Install]
WantedBy graphical.target

Afin de manipuler ce service, il est possible d'utiliser les commandes systemctl et journalctl.

Système de stockage

Cette section comporte de multiples informations à propos du système de stockage sur un système d'exploitation Linux.

Partitions

Nous avons le possibilité de partitionner un disque en plusieurs parties. Sur Linux, ces parties correspondent à des blocs.

Il est possible d'afficher les informations d'un disque avec son nom, les différentes partitions ainsi que d'autres informations en exécutant la commande suivante :

marijan$ lsblk

NAME                    MAJ:MIN RM   SIZE   RO TYPE MOUNTPOINT
sda                       8:0    0   120G   0  disk
├─sda1                    8:1    0   487M   0  part /boot/efi
├─sda2                    8:2    0   72.5G  0  part /media/MM/Data
├─sda3                    8:2    0   46.6G  0  part /

Dans l'exemple ci-dessus, il s'agit d'un SSD divisé en trois partitions. SDA 3 qui est la partition spécifique pour l'utilisateur root, SDA2 qui est monté sur un répertoire spécifique afin de faire des sauvegardes du système et finalement SDA1 qui est réservé pour le processus de démarrage qui contient le "boot loaders" pour le système d'exploitation de la machine.

Il n'est pas obligatoire de partitionner un disque, nous pouvons le laisser par défaut. Nous utilisons cette méthode afin de voir plus claire.

Les informations des partitions sont stockés dans un table que on peut affiche avec la commande lsblk, ou pour des informations plus avancés, en exécutant :

marijan$ fdisk -l /dev/sda
..
Disklabel type: gpt
Disk identifier: 0xb8f9e6cc

Device     Boot   Start      End  Sectors  Size Id Type
/dev/sda1  *       2048   999423   997376  487M 83 EFI System
/dev/sda2       1001470 67106815 66105346 31.5G  5 Linux filesystem
/dev/sda3       1001472 67106815 66105344 31.5G 8e Linux filesystem

Les informations supplémentaire que ce dernier fournis est notamment le Type utilisé, la taille du disque en bytes ainsi que les secteurs.

Avec le Master Boot Record (MBR), qui est un type de schéma de partition, Il existe principalement trois types de partitions :

Primaire : utilisé pour le démarrage d'un système d'exploitation, pas plus de 4 partitions de ce type par disque ;
Etendue : permet comme son nom d'indique d'étendre, dont notamment le type primaire à 4 autres partitions maximum ;
Logique : les partitions logiques sont celle qui sont créer dans les étendues ;

Le problème avec le MBR, c'est que nous sommes donc limité à 4 partition par disque, avec uniquement 2 TB de stockage maximum. Afin de faire face à ce problème, un nouveau type de schéma de partition est apparu, GUID Partition Table (GPT).

Avec GPT, la restriction de partition ainsi que d'espace de stockage a été solutionner. Nous pouvons donc effectivement créer autant de partition que l'on souhaite, sur un disque avec un stockage illimité.

Maintenant, si imaginons nous avons un deuxième disque dur /dev/sdb, et que nous souhaitons le partitionner en utilisant GPT, nous n'allons plus utiliser fdisk, mais gdisk suivi du chemin vers le nouveau disque.

marijan$ gdisk /dev/sdb

GPT fdisk (gdisk)

Parition table scan:
  MBR: protective
  BSD: not present
  APM: not present
  GPT: present

Found valid GPT with protective MBR; using GPT.

Command (? for help):

Système de fichier

Pour pouvoir écrire et lire sur un disque ou une partition que nous avons créer, il faut établir le système de fichier de ce dernier. Un des plus utilisé de nos jours est le système EXT4.

Afin de faire monter le système de fichier sur le disque en question, il suffit d'exécuter les commandes suivante :

marijan$ mkfs.ext4 /dev/sdb1

marijan$ mkdir /mnt/ext4
marijan$ mount /dev/sdb1 /mnt/ext4

marijan$ mount | grep /dev/sdb1
/dev/sbd1 on /mnt/ext4 type ext4 (rw, relatime,data=ordered)

En cas de redémarrage, la modification va automatiquement ce supprimer. Afin de l'appliquer en dure, il suffit de l'ajouter dans le fichier /etc/fstab.

marijan$ vim /etc/fstab

# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
#
# systemd generates mount units based on this file, see systemd.mount(5).
# Please run 'systemctl daemon-reload' after making changes here.
#
# <file system> <mount point>   <type>             <options>            <dump>  <pass>
  /dev/sdb1       /              ext4   defaults,relatime,errors=panic    0        1

Voici à quoi correspond chacune des catégories :

Filesystem : chemin où nous devons monter le système de fichier ;
Mountpoint : où le répertoire doit être monté ;
Type : type de système de fichier ;
Options : lecture et écriture ;
Dump : 0 = ignorer, 1 = faire une sauvegarde ;
Pass : 0 = ignorer, 1 ou 2 = système de fichier vérifier (FSCK) ;

Grâce aux redirections E/S, il est possible d'ajouter directement cette information dans le fichier /etc/fstab :

marijan$ echo "/dev/sdb1 /mnt/ext4 ext4 rw 0 0" >> /etc/fstab

Type de stockage

DAS

Le DAS Direct Attached Storage c'est lorsque que les disques de stockage sont directement reliés au serveur. Les échanges entre les disques et le serveur se font en mode bloc. Le désavantage c'est qu'il n'est pas possible d'utiliser les disques sur plusieurs machines en même temps.

SAN

Le SAN Storage Area Network c'est une armoire qui contient plusieurs baies de disque qui sont reliées au système d'information par un réseau dédié. Généralement on utilise de la fibre optique et pour ce faire, on utilise des switch FC (fibre optique). Les disques durs ne sont donc pas reliés directement au serveur. Pour y accéder, on utilise le mode bloc avec le système de fichier des serveurs. L'avantage c'est que nous pouvons utiliser un disque pour plusieurs serveurs en même temps. Aussi, il est possible d'ajouter des disques sans problème.

NAS

Le NAS Network Attached Storage est une baie de stockage qui a à disposition son propre système d'exploitation, logiciel de configuration, système de fichiers ainsi que des disques. Si on prend l'exemple d'une entreprise, le NAS est relié au réseau de l'entreprise pour stocker des fichiers. L'échange entre le NAS et un serveur ou un laptop se fait sous forme de fichier contrairement au NAS et DAS qui se font en mode bloc. Pour faire l'échange, on utilise les protocoles CIFS ou SMB pour Windows et NFS pour Linux/UNIX. L'avantage est qu'il permet l'accès à plusieurs personne en même temps. Il facilite également la tâche aux applications qui ont besoin du système de fichiers de façon intensive.

Commandes

lsb_release - Déterminer la distribution Linux

Pour déterminer la distribution Linux exacte en cours d'exécution sur votre machine, utilisez la commande lsb_release suivi du paramètre -a :

lsb_release -a

No LSB modules are available.
Distributor ID: Debian
Description:    Debian GNU/Linux 11 (bullseye)
Release:        11
Codename:       bullseye

man - Manuel

La plupart des distributions ont un manuel électronique préinstallé par défaut, que l'on peut utiliser en tapant man suivi de la commande que l'on souhaite rechercher.

man 7 signal

Il est divisé en 9 sections :

Commandes utilisateur ;
Appels système ;
Bibliothèques de programmation ;
Fichiers spéciaux et périphériques ;
Fichiers de configuration, format et conventions ;
Jeux ;
Divers ;
Commandes d'administration ;
Routines noyau.

Il est possible de modifier l'ordre de ces sections dans le fichier /etc/manpath.config.

Si l'utilisateur sait quelle section est nécessaire pour la commande recherchée, il peut simplement préciser le numéro de cette section entre le man et la commande souhaité.

Il est possible de rechercher un mot spécifique en utilisant la commande man avec l'option -k suivie du mot recherché.

cd - Changement de répertoire

La commande cd (Change Directory) permet de ce déplacer dans les différents répertoires de l'arboresance Linux.

cd /etc/apparmor

Pour naviguer vers le répertoire parent, il suffit d'ajouter deux points .. après la commande cd. Si l'on souhaite revenir au répertoire racine, il suffit d'entrer simplement la commande cd sans spécifier aucun répertoire supplémentaire. On peut également revenir répertoire en ajoutant un tirer - après le cd.

pwd - Affichage du chemin absolu

La commande pwd permet d'afficher le chemin absolu du répertoire où l'utilisateur ce trouve.

pwd

/etc/apparmor

ls - Affichage du contenu d'un répertoire

Cette commande permet d'afficher le contenu du répertoire où on ce trouve. On peut également lui spécifier le répertoire souhaitant être listé.

ls /etc/apparmor

parser.conf

Il existe plusieurs options intéressantes que nous pouvons ajouter à cette commande dont notamment -l qui permet d'afficher plus d'informations sur les fichiers dont notamment son type, les droits dessus, le propriétaire, le groupe, etc.

ls /etc/apparmor

-rw-r--r-- 1 root root 1597 Apr 3 2021 parser.conf

Aussi, pour afficher les documents et les dossiers cacher, il est possible d'utiliser l'option -a.

ls -a /home/support/cacher

.fichier_cacher .dossier_cacher

Avec l'option -R on peut avoir les fichiers ainsi que les répertoires avec le contenu des dossiers.

ls -R /home/support

./Desktop:
test.txt

./Documents:

./Download:

Une autre option, -t, permet d'afficher dans l'ordre de la dernière modification les fichiers du répertoire.

ls -t /home/support/test

test1.txt test2.txt

Une dernière option qui est -r, cette fois en minuscule, permet d'inverser l'ordre des fichiers d'un répertoire

ls -r /home/support/test

test2.txt test1.txt

file / stat - Affichage des informations

Il existe deux alternatives à la commande ls -l qui sont file et stat. Ces deux commandes fournissent des informations sur les fichiers et les dossiers.

En utilisant la commande file, on peut déterminer les types de fichiers, ce qui permet de savoir, par exemple, si test et test.txt sont des fichiers textes ou binaires.

file /home/support/test/test.txt

test : Directory
test/test.txt : ASCII text

Avec la commande stat, nous avons plus d'informations sur un fichier ou un répertoire.

stat /home/support/test/test.txt

  File: test.txt
  Size: 5
Device: b302h/45826d     Inœud : 261472      Liens : 1
Access: (0644/-rw-r--r--)  UID : (    0/    root)   GID : (    0/    root)
Access: 2021-11-26 12:00:17.702035921 +0100
Modify: 2021-11-26 12:00:17.702035921 +0100
Change: 2021-11-26 12:00:17.712035917 +0100
Birth: 2021-11-26 12:00:17.702035921 +0100

Fichier : Le nom du fichier ;
Taille : Taille réelle que le document fait ;
Blocs : Le nombre de Block que le fichier prend sur le stockage ;
Blocs d'E/S : Taille d'un bloc de données en octet sur la partition où est stocké le fichier ;
Type de fichier : Type de fichier ;
Accès : Droit d'accès sur le fichier ;
UID : ID de l'utilisateur propriétaire du fichier ;
GID : ID du groupe propriétaire du fichier ;
Accès : Date de la dernière consultation du fichier ;
Modif : Date de la dernière modification faite sur le fichier ;
Changt : Date de la dernière modification de l'inode du fichier (ex. changement de droits).

mkdir / rmdir - Création / Suppression de répertoire

La commande mkdir (Make Directory) permet de créer des répertoires.


mkdir /etc/wiki

Il est possible de créer plusieurs dossier à la suite en utilisant l'option -p.


mkdir -p /etc/wiki/wiki2

Ici, on a créer le dossier wiki et dans ce dernier, on a créer le répertoire wiki2.

Pour supprimer un dossier, il suffit d'utiliser la commande rmdir (Remove Directory).


rmdir /etc/wiki

Il est également possible d'utiliser l'option -p pour supprimer une suite de répertoire.

touch / rm - Création / Suppression d'un fichier

Il est possible d'utiliser la commande touch pour créer un fichier.

touche /etc/wiki/wiki.txt

Pour supprimer, il suffit d'utiliser la commande rm (remove).

rm /etc/wiki/wiki.txt

En ajoutant l'option -R (ou -r), il est possible de supprimer un répertoire.

cp - Copier / Coller du contenu

Cette commande permet de copier coller du contenu. Il faut précisé la source qu'on souhaite copier et la destination, donc où est-ce qu'on souhaite la coller.

cp /etc/wiki/test.txt /etc/test/test.txt

Ici, on a copier le fichier test.txt qui ce trouvait dans le répertoire /etc/wiki et nous l'avons collé vers /etc/test.

En ajoutant l'option -R (ou -r), il est possible de copier/coller un répertoire.

mv - Déplacement du contenu

Pour déplacer du contenu, il est possible d'utiliser la commande mv (Move).

mv /etc/wiki/test.txt /etc/test

Il n'est pas nécessaire d'utiliser des options lorsqu'on souhaite déplacer un répertoire. Cependant, si l'on déplace un fichier qui a le même nom qu'un fichier dans le répertoire de destination, il le remplacera.

ln - Création de lien entre fichier et répertoire

La commande ln permet de créer un lien physique d'un fichier ou d'un répertoire.

ln /etc/wiki/wiki.txt /etc/test/wiki_raccourci.txt

En utilisant la commande de création de lien, si l'option -s n'est pas spécifiée, le lien créé sera un lien dur qui pointe directement vers l'inode du fichier original plutôt que vers le fichier en tant que tel (hard link). En revanche, si l'option -s est ajoutée, un lien symbolique sera créé, qui est simplement un fichier distinct qui pointe vers le fichier original (soft link). Ce type de lien est comparable à un raccourci sous Windows.

mount / umount - Montage / Démontage d'un système de fichier

Les périphériques sont stockés dans le répertoire dev du système par défaut. Toutefois, si l'on souhaite monter un périphérique sur un répertoire spécifique du système, il suffit d'utiliser la commande suivante :

mount /dev/cdrom /etc/

Dans cet exemple, le CD-ROM a été monté sur le répertoire etc.

On aura donc à partir de maintenant, en plus du contenu de base stocké dans le répertoire etc, le contenu du CD-ROM sera également inclus.

Pour détacher un périphérique d'un répertoire, vous pouvez utiliser la commande suivante :

umount /dev/cdrom

Il est important de noter que si vous souhaitez démonter un périphérique, vous ne devez pas être situé dans le répertoire correspondant, sinon le démontage ne fonctionnera pas.

cat / more / less - Affichage du contenu d'un fichier

Ces trois commandes permettent d'afficher le contenu d'un fichier mais il existe bien entendu une différence entre les trois.

Lorsqu'on utilise la commande cat sur un fichier, le contenu entier de ce fichier est affiché.

cat /etc/wiki/wiki.txt

Le principal inconvénient de la commande cat est qu'elle affiche tout le contenu du fichier en une seule fois, ce qui peut rendre difficile la lecture de fichiers contenant beaucoup d'informations. En revanche, pour les fichiers de petite taille, la commande cat est pratique et peut être utilisée sans problème.

Ensuite, la commande more sur un fichier, le contenu est afficher page par page.

more /etc/wiki/wiki.txt

Pour les fichiers contenant beaucoup d'informations, sa permet d'afficher le contenu page par page, plutôt que la commande cat qui affiche tout le contenu d'un fichier en une seule fois. Cela rend la lecture des fichiers plus facile et plus pratique.

Pour terminer, la commande less est très similaire que more, mais avec des fonctionnalités en plus.

less /etc/wiki/wiki.txt

En effet, il est souvent plus pratique d'utiliser la commande less plutôt que cat, car less permet d'afficher le contenu des fichiers page par page, facilitant ainsi la lecture des fichiers volumineux. De plus, less offre des fonctionnalités supplémentaires telles que la recherche de texte, la possibilité de faire défiler le contenu du fichier à l'aide des touches fléchées, la possibilité de naviguer vers l'avant et l'arrière dans le contenu du fichier, et bien plus encore. Ces fonctionnalités sont similaires à celles que l'on peut trouver dans l'éditeur de texte Vim, ce qui peut être très utile pour les utilisateurs familiers avec cet éditeur.

vi - Éditeur de texte

La commande vi ou vim (Visual Editor Improved) est l'un des principaux éditeur de texte sur toutes les distributions Linux en shell.

vim /etc/wiki/wiki.txt>

vi est la version basique de l'éditeur de texte, vim est la version améliorer de ce dernier.

Modes de fonctionnement

Il existe trois modes de fonctionnement différent :

Commandes : Ce mode est celui par défaut lorsqu'on ouvre un fichier, il indique que chaque touche du clavier que nous allons faire peut-être un raccourci défini pour interagir avec le fichier (en dehors du contenu). Par exemple, pour passer en mode insertion, donc pour pouvoir inscrire du contenu, il suffit de faire le raccourcie i.
Insertion : Ce mode permet d'inscrire du contenu dans le fichier. Comme vu dans le point ci-dessus, pour passer dans ce mode il suffit de faire la commande i.
Ex : Ce mode permet permet également de passer de saisir des commandes qui apparaîtront en bas de l'écran du fichier sur lequel nous travaillons en utilisant les caractères spéciaux :, / ou ? suivi de l'instruction. Par exemple, pour rechercher un mot dans un fichier, nous pouvons utiliser la commande / suivi du mot recherché. Un autre exemple est la commande pour quitter le fichier en le sauvegardant : nous pouvons utiliser la commande : suivie de wq (pour Write Quit).

Si on souhaite quitter le mode insertion ou ex, il est possible de faire la touche Echap pour revenir au mode par défaut qui est commande.

Remplacement de caractères

Avec le mode Ex, on peut également rechercher et remplacer des caractères sur un fichier. La commande est composé de trois principales choses :

:s/[nom]/[nouveau nom]

Il est bien évidemment possible de la paramétrer en ajoutant des options comme à partir de quel ligne on souhaite remplacer, jusqu'à qu'elle ligne et si on souhaite remplacer toutes les occurrences, même celle qui n'ont pas forcément le même orthographe.

Pour imager la chose, nous avons un fichier qui contient les mots suivants :

Dominique
Dominique
Cédric
Dominique
Dominique
DomINique
DominiQUEe
Tarik
Dominique

Nous souhaitons remplacer tous les Dominique, peu importe l'écriture, part Marijan à partir de la 4ème ligne, jusqu'à la fin.

4,$s/Dominique/Marijan/i

4 : La ligne à partir de la quel commencer ;
$ : Permet d'indiquer la dernière ligne du fichier ;
s : Permet de lancer la recherche (search) ;
Dominique : Indique le mot à remplacer ;
Marijan : Indique le mot par le quel il a été remplacé ;
i : Paramètre indiquant pour remplacer tous les "Dominique", peu importe l'orthographe.

Il existe deux autres types de paramètres de base pour la commande de remplacement, en plus du i. Le premier est le I (i majuscule), qui est sensible à la casse, c'est-à-dire qu'il remplacera le mot indiqué uniquement s'il est orthographié de la même manière, en respectant la casse. Le second est le g, qui permet de remplacer toutes les occurrences du mot indiqué sur une ligne, car sans lui, il ne remplacera que la première occurrence.

Commandes externe

Il est possible d'exécuter des commandes shell tout en étant dans l'éditeur de texte. Pour ce faire, il faut être en mode Ex puis utiliser le caractère ! suivie de la commande en question.

:!date

Mon 20 Mar 2023 09:34:01 AM CET

Si on souhaite inscrire le résultat de la commande directement dans le fichier éditer, il suffit d'ajouter un r devant le !.

Options de l'éditeur

Il est possible de configurer l'éditeur en activant des options en mode Ex avec la commande set suivi du paramètre.

:set numbers

1  Hello
2  Marijan
3  Stajic

Dans l'exemple ci-dessus, nous avons utiliser la commande set suivi du paramètre numbers pour activer les nombres. Pour désactiver, il suffit d'ajouter un no devant l'option en question.

Cette option sera activé temporairement, c'est-à-dire qu'à la prochaine édition de fichier, l'option ne sera plus active. Pour sauvegarder le paramètre, il faut l'ajouter dans le fichier /home/user/.vimrc

Pour voir la configuration actuelle, il est possible de faire simplement la commande set. Si on souhaite avoir tous les détailles, il suffit de faire set suivi de all.

Liste de commandes

Voici une liste de commandes d'insertion :

Commande	Description
h	Permet de déplacer le curseur vers la gauche
l	Permet de déplacer le curseur vers la droite
j	Permet de déplacer le curseur vers le bas
k	Permet de déplacer le curseur vers le haut
0	Permet de revenir au premier caractère
$	Permet de ce rendre au dernier caractère
w	Permet de ce rendre au premier caractère du prochain mot
b	Permet de ce rendre au premier caractère du mot précédant
e	Permet de ce rendre au dernier caractère du prochain mot
G	Permet de ce rendre au premier caractère de la dernière ligne
[numéro]G	Permet de ce rendre au premier caractère de la ligne indiqué
Ctrl+b	Permet de déplacer le curseur et l'affichage d'une page vers le haut (page précédant)
Ctrl+f	Permet de déplacer le curseur et l'affichage d'une page vers le bas (page suivante)
i	Permet de passer en mode insertion
a	Permet de passer en mode insertion en passant directement au caractère après le curseur
o	Permet de passer en mode insertion en passant directement à la ligne suivante
I	Permet de passer en mode insertion en revenant au début de la ligne
A	Permet de passer en mode insertion en passant directement au dernier caractère de la ligne
O	Permet de passer en mode insertion en passant à la ligne du dessus
x	Permet de passer de supprimer le caractère après le curseur
X	Permet de passer de supprimer le caractère avant le curseur
dd	Permet de passer de supprimer une ligne entière
d0	Permet de passer de supprimer les caractères avant le curseur
d$	Permet de passer de supprimer les caractères après le curseur
dw	Permet de passer de supprimer le mot suivant
yy	Permet de copier une ligne entière
y0	Permet de copier les caractères avant le curseur
y$	Permet de copier les caractères après le curseur
p	Permet de coller ce qui a été copié
u	Permet d'annuler les actions précédentes
U	Permet d'annuler toutes les actions précédentes d'un seul coup
.	Permet de répéter la dernière action
zz	Permet d'enregistrer le fichier

Voici une liste de commandes du mode Ex :

:w [fichier]	Permet d'enregistrer un fichier
:q	Permet de quitter un fichier
:r	Permet de copier le contenu du fichier passé en paramètre et l'intégrer dans le fichier sur lequel nous sommes
/ [mot]	Permet de chercher un mot dans un fichier depuis le début du fichier
? [mot]	Permet de chercher un mot dans un fichier depuis la position du curseur
n	Lors d'une recherche avec un / ou ?, on peut passer au mot suivant avec

Il est bien entendu possible de combiner certaines commandes comme :w et :q pour quitter et enregistrer. Aussi, on peut forcer une action en ajoutant un ! à la fin de la commande comme par exemple :q! pour quitter un fichier sans l'enregistrer.

id / groups - Affichage de l'UID / GID

La commande id permet d'afficher l'UID de l'utilisateur avec le quel vous êtes connectés. Il est possible de spécifier le nom de l'utilisateur également.

id root

uid=0(root) gid=0(root) groups=0(root)

Il est également possible d'afficher le GID avec la commande groups.

groups

root

who / last - Affiche les utilisateurs actuellement connecté et les précédant

La commande who permet d'afficher la liste des utilisateurs actuellement connecté à la machine.

who

root     tty1         2024-03-21 11:21
root     pts/0        2024-03-27 13:51 (212.147.110.129)

Afin de voir les utilisateurs qui étaient connecté, utilisez la commande last.

last

root     pts/0        212.147.110.129  Wed Mar 27 13:51   still logged in
root     pts/0        212.147.110.129  Wed Mar 27 09:47 - 10:10  (00:22)
root     pts/0        212.147.110.1    Tue Mar 26 14:16 - 15:03  (00:47)
root     pts/0        212.147.110.1    Tue Mar 26 11:23 - 11:39  (00:15)
root     pts/0        212.147.110.1    Tue Mar 26 10:42 - 11:18  (00:35)

su - Changer d'utilisateur

Il n'est pas forcément nécessaire de ce déconnecter puis reconnecter pour changer d'utilisateur. En effet, une commande existe pour cela.

marijan$ su support
Password:
support$

Si on ne spécifie pas l'utilisateur après le su, l'utilisateur par défaut sera root.

useradd / deluser - Création / Suppression d'utilisateur

Pour créer un utilisateur sur Linux, il suffit d'utiliser la commande useradd. Une fois créer, pour modifier le mot de passe il suffit de faire la commande passwd suivi du nom de l'utilisateur.

useradd Alan

passwd Alan
New password:
Retype new password:

Il est possible de définir de nombreux paramètre lors de la création de l'utilisateur, en voici une liste :

-c : commentaire sur l'utilisateur ;
-d : répertoire personnel personnalisé ;
-e : date d'expiration du compte ;
-G : ajouter plusieurs groupe secondaire à l'utilisateur ;
-g : spécifique GID ;
-s : spécifique Shell ;
-u : spécifique UID ;

Pour supprimer, il suffit de faire la commande deluser.

deluser Alan

groupadd / delgroup - Création / Suppression de groupe

Afin de créer un groupe, il faut utiliser la commande groupadd suivi du nom du groupe.

groupadd Developpement

Pour supprimer, il faut faire delgroup suivi du nom.

delgroup Developpement

usermod - Modifier un compte utilisateur

Il est possible de modifier les paramètres d'un utilisateur en shell sur Linux avec la commande usermod.

Par exemple, pour l'ajouter dans un groupe, il suffit d'utiliser l'option -a pour l'ajout d'un groupe suivi de l'option -G pour indiquer le groupe.

usermod -aG Developpement Alan

Pour retirer du groupe, il suffit de faire la même commande, mais seulement avec l'option -G suivi du groupe.

usermod -G Developpement Alan

chgrp / chown - Groupe / Propriétaire modification des information

Il est possible d'attribuer un dossier ou un fichier à un groupe ou un propriétaire. Par défaut, lorsqu'un utilisateur créer un élément, le propriétaire c'est lui même et le groupe c'est son groupe principal. Il est possible de changer ces informations à partir du compte qui a créer le fichier ou à partir de root.

Pour modifier le groupe de l'élément, il suffit de faire la commande chgrp.

chgrp Developpement Developpement-Public

Pour le propriétaire, c'est le même principe sauf que la commande sera chown.

chown Kieran Developpement-Public

ls -l /Developpement-Public/
drwxrwxr-x   2 Kieran Developpement 4096 Apr   4 10:53 Developpement-Public

chmod - Modification des droits

La commande chmod permet de modifier les droits pour le propriétaire, un groupe ou les autres sur un fichier ou un dossier.

Pour ce faire, nous allons dans un premier temps spécifié les droits qu'on souhaite attribuer puis le nom de l'élément avec son emplacement si besoin.

Si par exemple on souhaite donner le droit de lecture et écriture au groupe, il suffit de faire la commande suivante :

chmod g+rw Developpement-File

ls -l
-rwxrw-r-x   2 Kieran Developpement 4096 Apr   4 10:53 Developpement-File

Lorsqu'on attribue des droits à un fichier en utilisant la commande chmod, on utilise les lettres u pour le propriétaire du fichier, g pour le groupe et o pour les autres utilisateurs.

Le symbole + est utilisé pour ajouter des droits, tandis que - est utilisé pour retirer des droits. Si l'on souhaite simplement appliquer les droits spécifiés sans les ajouter ou les retirer, on peut utiliser le symbole =.

Les droits attribués peuvent être spécifiés avec les lettres r pour la lecture, w pour l'écriture et x pour l'exécution. En plus de cela, il est possible d'utiliser les lettres s ou t pour les attributs de sécurité spéciaux, tels que le bit t pour le Sticky Bit et le bit s pour le SUID/SGID.

Notation octale

Il est possible d'attribuer les droits symboliques d'une manière plus compact, la notation octale. Cette notion est l'addition du tableau ci-dessous :

Droits	Notation binaire	Notation octale
---	000	0
--x	001	1
-w-	010	2
-wx	011	3
r--	100	4
r-x	101	5
rw-	110	6
rwx	111	7

Si l'on veut accorder différents niveaux d'accès à un fichier, par exemple, donner au propriétaire tous les droits, permettre au groupe de lire et exécuter seulement, et donner à tous les autres utilisateurs seulement le droit de lire, alors on peut utiliser une combinaison de chiffres pour représenter ces droits. En l'occurrence, on peut ajouter les chiffres 7 (pour tous les droits), 5 (pour lire et exécuter), et 4 (pour lire seulement) pour obtenir les niveaux d'accès désirés pour chaque type d'utilisateur.

chmod 754 Developpement-File

ls -l
-rwxr-xr--   2 Kieran Developpement 4096 Apr   4 10:53 Developpement-File

On peut également retrouver cette notion de notation octale pour les droits SUID/SGID et Sticky Bit :

Droits	Notation binaire	Notation octale
---	000	0
--t	001	1
-s-	010	2
-st	011	3
s--	100	4
s-t	101	5
ss-	110	6
sst	111	7

Si l'on souhaite activer une option particulière, comme le SGID, il faut spécifier le chiffre correspondant au début avant les autres chiffres qui représentent les droits d'accès. Par exemple, pour activer le SGID, on peut spécifier le chiffre 2 en premier, suivi des chiffres qui représentent les droits pour le propriétaire, le groupe et les autres utilisateurs. Cette notation octale permet de définir précisément les niveaux d'accès pour chaque utilisateur ou groupe d'utilisateurs sur l'élément en question.

chmod 2754 Developpement-File

ls -l
-rwxr-sr--   2 Kieran Developpement 4096 Apr   4 10:53 Developpement-File

Bien entendu, il existe des calculateurs en ligne afin d'éviter de le faire de tête à chaque fois.

umask - Droits par défaut

La commande umask permet de définir les droits par défaut pour les nouveaux fichiers et dossiers créés par un utilisateur.

umask -S

u=rwx,g=rx,o=rx

Lorsque vous exécutez la commande umask -S, elle affiche les droits par défaut sous forme symbolique pour le propriétaire, le groupe et les autres utilisateurs.

touch Developpement-File-2

ls -l
-rwxr-xr-x   2 Kieran Developpement 4096 Apr   4 10:53 Developpement-File

Dans l'exemple ci-dessus, les droits par défaut pour le propriétaire sont de lecture, écriture et exécution (u=rwx), tandis que les droits par défaut pour le groupe et les autres utilisateurs sont de lecture et exécution seulement (g=rx,o=rx).

Il est bien entendu possible de modifier ces droits par défaut en utilisant la commande umask suivi de la notation octale.

umask 0002

umask -S
u=rwx,g=rwx,o=rx

Les droits par défaut définis par umask ne sont qu'une partie des facteurs qui déterminent les droits d'accès d'un fichier ou d'un dossier. En effet, lorsque vous créez un élément dans un dossier parent qui a des permissions d'accès définies de manière récursive, les nouveaux éléments héritent des mêmes droits que le dossier parent.

Visualisation des processus

Il existe différentes commandes pour la visualisation des processus sur Linux.

ps - Liste

La commande ps permet d'afficher une liste de tous les processus en cours d'exécution sur le système en extrayant les informations depuis le noyau, ce qui permet d'obtenir une vue claire et structurée de ces processus. On l'utilise généralement pour surveiller, identifier ainsi que de les terminer (tuer) ceux en cours d'utilisation. Ces informations sont stockés dans le répertoire /proc, là ou le kernel inscrit toutes ces données.

ps

  PID  TTY          TIME CMD
 1088  tty3     00:00:00 login
 1113  tty3     00:00:00 bash
14671  tty3     00:00:00 ps

Afin de monitorer la chose de la façon la plus adéquat, il existe bien entendu des paramètres. Nous pouvons obtenir la liste avec la commande ps --help. Voici les plus fréquemment utilisés :

Nous avons généralement le paramètre -ef. Le premier paramètre permet d'afficher tous les processus (e) et le deuxième, permet d'afficher de nombreuses informations au sujet du processus en question (f).

ps -ef

UID         PID  PPID  C STIME TTY          TIME CMD
root          1     0  0 Jan05 ?        00:08:40 /sbin/init
root          2     0  0 Jan05 ?        00:00:01 [kthreadd]
root          3     2  0 Jan05 ?        00:00:00 [rcu_gp]
root          4     2  0 Jan05 ?        00:00:00 [rcu_par_gp]
root          6     2  0 Jan05 ?        00:00:00 [kworker/0:0H-events_highpri]
root          8     2  0 Jan05 ?        00:00:59 [kworker/0:1H-events_highpri]
root          9     2  0 Jan05 ?        00:00:00 [mm_percpu_wq]
root         10     2  0 Jan05 ?        00:00:48 [ksoftirqd/0]
root         11     2  0 Jan05 ?        00:13:16 [rcu_sched]

Nous pouvons également retrouver ps -aux. Il permet d'afficher le processus de tout les utilisateurs (a), ceux qui ne sont pas lié à un terminal (x) et le nom de l'utilisateur ainsi que la date de lancement (u).

ps -aux

USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.3 164100 10464 ?        Ss   08:25   0:01 /sbin/init
root           2  0.0  0.0      0     0 ?        S    08:25   0:00 [kthreadd]
root           3  0.0  0.0      0     0 ?        I<   08:25   0:00 [rcu_gp]
root           4  0.0  0.0      0     0 ?        I<   08:25   0:00 [rcu_par_gp]
root           6  0.0  0.0      0     0 ?        I<   08:25   0:00 [kworker/0:0H-events_highpri]
root           8  0.0  0.0      0     0 ?        I<   08:25   0:00 [mm_percpu_wq]
root           9  0.0  0.0      0     0 ?        S    08:25   0:00 [rcu_tasks_rude_]
root          10  0.0  0.0      0     0 ?        S    08:25   0:00 [rcu_tasks_trace]
root          11  0.0  0.0      0     0 ?        S    08:25   0:00 [ksoftirqd/0]

Voici un tableau expliquant à quoi correspond chaque en-tête des catégories de la commande ci-dessus.

Information	Description
%CPU	Pourcentage du temps que le processeur utilise depuis le lancement du processus.
%MEM	Pourcentage d'utilisation de la mémoire disponible depuis le lancement du processus.
CMD ou COMMAND	Nom de la commande à l'origine du processus.
GID ou GROUP	Nom du groupe sous le quel le processus s'exécute.
UID ou USER	Nom de l'utilisateur sous le quel le processus s'exécute.
NI	Niveau de la propriété du processus.
PID	Identifiant du processus.
PPID	Identifiant du processus père.
RSS	Quantité de mémoire vive utilisé (en Ko).
START ou STIME	Date du lancement du processus.
STAT	Statut du processus. Il en existe 5 différents : R (Running), T (sTopped), S (Sleeping), D (Device) et Z (Zombie).
TIME	Temps total de l'utilisation du processeur par le processus.
PPID	Identifiant du processus père.
TT ou TTY	Le nom du terminal où le processus est rattaché. Dans le cas ou il est rattaché à aucun, la valeur sera ?.

top - Liste (en directe)

La commande top à le même fonctionnement que ps, elle permet d'afficher les processus en cours et mettre à jour les informations en directe.

top - 15:04:34 up 110 days,  3:22,  1 user,  load average: 0.00, 0.00, 0.00
Tasks: 135 total,   1 running, 134 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.3 us,  0.0 sy,  0.0 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :   1994.3 total,    421.5 free,    307.0 used,   1265.8 buff/cache
MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.   1489.8 avail Mem

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
    1 root      20   0  170888  10836   7960 S   0.3   0.5   8:40.67 systemd
    2 root      20   0       0      0      0 S   0.0   0.0   0:01.01 kthreadd
    3 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 rcu_gp
    4 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 rcu_par_gp
    6 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 kworker/0:0H-events_highpri
    8 root       0 -20       0      0      0 I   0.0   0.0   0:59.90 kworker/0:1H-kblockd
    9 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 mm_percpu_wq
   10 root      20   0       0      0      0 S   0.0   0.0   0:48.22 ksoftirqd/0
   11 root      20   0       0      0      0 I   0.0   0.0  13:17.52 rcu_sched

Aussi, il est possible d'activer des informations supplémentaire sur les processus en cliquant sur la touche F.

* PID     = Process Id
* USER    = Effective User Name
* PR      = Priority
* NI      = Nice Value
* VIRT    = Virtual Image (KiB)
* RES     = Resident Size (KiB)
* SHR     = Shared Memory (KiB)
* S       = Process Status
* %CPU    = CPU Usage
* %MEM    = Memory Usage (RES)
* TIME+   = CPU Time, hundredths
* COMMAND = Command Name/Line
  PPID    = Parent Process pid
  UID     = Effective User Id
  RUID    = Real User Id
  RUSER   = Real User Name
  SUID    = Saved User Id
  SUSER   = Saved User Name
  GID     = Group Id
  GROUP   = Group Name
  PGRP    = Process Group Id
  TTY     = Controlling Tty
  TPGID   = Tty Process Grp Id

[...]

Pour quitter ce menu, il suffit de faire la touche Q. Il est possible d'activer par défaut certaines colonnes en modifiant le fichier /etc/toprc.

htop - Liste améliorée (en directe)

La commande htop est la version améliorée de la commande top. Elle permet également d'afficher les processus en cours et mettre à jour les informations en directe. La principal différence est que nous pouvons interagir avec la souris et nous avons une présentation différente, comme l'utilisation des jauges pour par exemple représenter l'utilisation du CPU.

htop

Aussi, par défaut la commande n'est pas installé.

pstree - Hiérarchiquement

La commande pstree à le même fonctionnement que ps, elle permet d'afficher les processus. La différence c'est que celle-ci permet de visualiser ces processus de manière hiérarchique, ce qui permet de voir leur filiation.

systemd─┬─VGAuthService
        ├─agetty
        ├─cron
        ├─dbus-daemon
        ├─focalboard-serv───5*[{focalboard-serv}]
        ├─mysqld───31*[{mysqld}]
        ├─nginx───nginx
        ├─php-fpm7.3───3*[php-fpm7.3]
        ├─php-fpm8.0───2*[php-fpm8.0]
        ├─2*[postgres───6*[postgres]]
        ├─rsyslogd───3*[{rsyslogd}]
        ├─snapd───9*[{snapd}]
        ├─sshd───sshd───bash───pstree
        ├─systemd───(sd-pam)
        ├─systemd-journal
        ├─systemd-logind
        ├─systemd-network
        ├─systemd-timesyn───{systemd-timesyn}
        ├─systemd-udevd
        ├─unattended-upgr───{unattended-upgr}
        └─vmtoolsd───{vmtoolsd}

Il est possible d'afficher leur PID avec le paramètre -p.

kill - Fin de tâche de processus

La commande kill permet d'envoyer un signal à un processus pour le stopper. Il existe différents types de signaux, chacun ayant son propre fonctionnement. Par défaut, lorsqu'on tente de tuer un processus, le signal envoyé est le 15.

La commande kill se compose de trois parties : tout d'abord, la commande, suivi du numéro du signal à envoyer (ou du nom complet du signal), et enfin l'identifiant de processus (PID) du processus à arrêter.

ps
  PID TTY          TIME CMD
16722 pts/0    00:00:00 bash
16940 pts/0    00:00:00 ps
16940 pts/0    00:00:00 vim

kill -15 vim

ps
  PID TTY          TIME CMD
16722 pts/0    00:00:00 bash
16940 pts/0    00:00:00 ps

Il est possible de terminer tous les processus correspondant à un nom spécifique sans avoir à spécifier leurs identifiants de processus individuels. Pour ce faire, on peut utiliser la commande killall.

Cette commande suit la même structure que la commande kill, à la différence qu'au lieu d'un PID, on spécifie un mot-clé correspondant au nom du processus à arrêter.

ps
  PID TTY          TIME CMD
16722 tty3    00:00:00 bash
16940 tty3    00:00:00 ps
16940 tty3    00:00:00 firefox1
16940 tty3    00:00:00 firefox2

killall -15 firefox

ps
  PID TTY          TIME CMD
16722 tty3    00:00:00 bash
16940 tty3    00:00:00 ps

Il est possible de trouver la liste des signaux disponibles en utilisant la commande kill avec l'option -l.

 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX

Alternativement, pour aussi avoir plus d'informations sur les signaux, il est également possible de se référer à la page 7 du manuel des signaux pour obtenir cette information.

jobs - Processus exécuté à partir du terminal

Il est possible de voir tous les processus exécuté depuis le terminal avec la commande jobs.

sleep 1111 &

ps
  PID TTY          TIME CMD
16722 tty3    00:00:00 bash
16940 tty3    00:00:00 ps
16875 tty3    00:00:00 sleep

jobs
[1]   Running          sleep 1111 &

Ici, nous avons exécuté la commande sleep en arrière-plan. Vu que nous l'avons exécuté depuis le terminal, nous pouvons le retrouver avec la commande jobs.

bg / fg - Passer en arrière-plan/avant-plan un processus

Si par erreur nous avons exécutée un processus en arrière-plan mais que nous souhaitons le passer en premier plan, il est possible de le faire avec la commande fg. Inversement, il est possible de passer un processus du premier plan en arrière plan avec bg.

Pour ce faire, par exemple pour un processus en arrière plan, nous allons dans un premier temps écrire la commande fg, ensuite nous allons utiliser le caractère % suivi du numéro du processus de la commande jobs.

sleep 1111 &

jobs
[1]   Running          sleep 1111 &

fg %1

Pour passer un processus en arrière-plan, c'est la même chose excepté la commande fg qui change par donc bg.

du / Voir la taille d'un fichier

Il est possible de voir la place qu'un fichier prend sur le système en utilisant la commande suivante :

du -sh test.img

98M    test.img

tar / Archivage de fichier

Afin d'archiver un fichier en shell sur un système Linux, il suffit d'utiliser la commande suivante :

tar -cf test.tar file1 file2 file3

Le paramètre -c est utilisé pour créer l'archive, -f représente le nom du fichier et les trois fichiers indiqué ci-dessus sont ceux que nous souhaitons ajouter à l'archive.

Pour voir le contenu d'un fichier .tar, il suffit d'exécuter les options suivante :

tar -tf test.tar

./file1
./file2
./file3

Pour extraire le contenu d'un fichier .tar, ajouter les options suivantes à la commande :

tar -xf test.tar

Lors de l'archivage, nous avons également la possibilité de réduire la taille du fichier en ajoutant -z à la compression :

tar -zcf test.tar file1 file2 file3

locate / Trouver un fichier dans le système

Afin de trouver un fichier parmi tous les répertoire du système, nous pouvons utiliser la commande suivante :

touch /usr/hello.txt

locate hello.txt
/usr/hello.txt

Par défaut, cette commande n'est pas installer sur le système.

Attention, il est important de noter que cette commande ce base sur sa base de donnée et si le fichier à été créer récemment, il ce pourrait qu'il ne soit pas encore inscrit dans cette dernière. Pour forcer la mise à jour, il suffit d'exécuté la commande suivante en tant qu'administrateur :

updatedb

grep / Trouver des termes spécifiques dans un fichier

Afin de trouver un terme spécifique dans un fichier du système, il suffit d'utiliser grep :

cat hello.txt

Salut c'est Marijan

grep Marijan hello.txt
Salut c'est "Marijan"

Attention, grep est sensible à la casse. Par exemple si le mot est en majuscule, il faut soit l'écrire correctement dans la commande par défaut, ou ajouter l'option suivante à la commande :

cat hello.txt

Salut c'est MARIJAN

grep Marijan -i hello.txt
Salut c'est "MARIJAN"

Il est possible de faire une recherche récursive, c'est-à-dire chercher un mot sans connaître le nom du fichier. Il suffit simplement de ce trouver dans le bon répertoire où le fichier contenant l'information ce trouve :

grep -r Marijan /home/marijan
./hello.txt: Salut c'est "Marijan"

Il est également possible d'afficher toutes les lignes ne contenant pas le mot spécifié :

cat hello.txt

Salut c'est MARIJAN
Tu vas bien ?
Moi oui

grep -v Marijan hello.txt

Tu vas bien ?
Moi oui

Par défaut, si nous chercherons par exemple le mot exam dans un fichier où nous avons deux mots contenant exam dedans, la commande va afficher les deux lignes :

cat hello.txt

Ceci est un example
Ce n'est pas un exam

grep exam hello.txt

Ceci est un example
Ce n'est pas un exam

Il est possible de respecter le faite d'afficher uniquement la ligne contenant le mot exam, et non un similaire en utilisant l'option suivante :

cat hello.txt

Ceci est un example
Ce n'est pas un exam

grep -w exam hello.txt

Ce n'est pas un exam

Pour éviter de manquer une ligne car le mot que on cherche contient exam par exemple, il est possible d'ajouter l'option :

cat hello.txt

Ceci est un example
Ce n'est pas un exam

grep -vw exam hello.txt

Ceci est un example

Il est possible d'afficher la ligne suivante et la ligne d'avant d'un mot que on cherche en ajoutant les options suivantes :

cat hello.txt

Dominique
Marijan
Charles

grep -A1 Marijan hello.txt

Marijan
Charles

grep -B1 Marijan hello.txt

Dominique
Marijan

Il est bien entendu possible de combiné les deux options afin d'afficher le mot avant et après.

systemctl / jounalctl - Manipulation des services

Afin de manipuler les différents services du système, nous pouvons utiliser ces deux commandes.

Pour démarrer ou arrêter un service ainsi que voir son statuts, nous pouvons utiliser la commande suivante :

marijan$ systemctl stop project_marijan.service

marijan$ systemctl start project_marijan.service

marijan$ systemctl status project_marijan.service

project_marijan.service - A high performance web server and a reverse proxy server
     Loaded: loaded (/lib/systemd/system/project_marijan.service; enabled; vendor preset: enabled)
     Active: active (running) since Wed 2024-04-10 10:48:08 CEST; 7s ago
       Docs: man:project_marijan(8)
    Process: 16444 ExecStartPre=/usr/sbin/project_marijan -t -q -g daemon on; master_process on; (code=exited, status=0/SUCCESS)
    Process: 16446 ExecStart=/usr/sbin/project_marijan -g daemon on; master_process on; (code=exited, status=0/SUCCESS)
   Main PID: 16662 (project_marijan)
      Tasks: 3 (limit: 3525)
     Memory: 4.4M
        CPU: 42ms
     CGroup: /system.slice/project_marijan.service
             ├─16662 project_marijan: master process /usr/sbin/project_marijan -g daemon on; master_process on;
             ├─16664 project_marijan: worker process
             └─16665 project_marijan: worker process

Apr 10 10:48:08 demo-vm systemd[1]: Starting A high performance web server and a reverse proxy server...
Apr 10 10:48:08 demo-vm systemd[1]: Started A high performance web server and a reverse proxy server.

Il est possible de redémarrer un service sans interrompre les fonctionnalités de base et donc couper complet le service en exécutant la commande :

marijan$ systemctl reload project_marijan.service

Afin d'activer un service au démarrage ou le désactiver, il suffit d'utiliser :

marijan$ systemctl enable project_marijan.service
marijan$ systemctl disable project_marijan.service

Il est possible d'exécuter une commande pour redémarrer uniquement les services qui ont subit une modification :

marijan$ systemctl daemon-reload

Il existe la possibilité de modifier un fichier de configuration d'un service en passant à travers d'une commande systemctl :

marijan$ systemctl edit project_marijan.service

Afin de vérifier et modifier le runlevel du système :

marijan$ systemctl get-default
graphical.target

marijan$ systemctl set-default multi-user.target

Afin de lister les unités, il suffit d'exécuter la commande suivante :

marijan$ systemctl list-units

Pour lister toutes les unités, même les inactives, il suffit d'ajouter l'option --all.

Même si les services ont généralement leurs propre fichier de logs, il est possible de l'afficher avec la commande suivante :

journalctl

Pour afficher spécifiquement les logs d'une unité, il suffit d'ajouter le paramètre -u suivi du nom. Pour voir les logs uniquement depuis le dernier démarrage, il faut utiliser l'option -u.

Linux - Principes de base de l'utilisation du système