Effectuer les opérations de base concernant l'exploitation

des fonctions du système d'exploitation

➢ Extraire la VM Fedora Workstation 33
➢ Importer la VM
Copier et extraire le dossier Fedora-Workstation-33 sur le disque dur
(exemple Documents)
3 méthodes d'Importation des VMs sous Hyper-V
Aucune VM (linux-fedora-workstation-33) sur le serveur Hyper-V
✓ Importer VM → choisir option(2) restaurer VM avec un ID Unique
existant
✓ Renommer la VM Fedora-Workstation-33-ID101/102
VM existante (linux-fedora-workstation-33) sur le serveur Hyper-V
✓ Importer VM → choisir option(3) copier VM et créer un ID Unique
→ choisir un nouveau emplacement pour le disque →DossierFWS-
33-ID101/102
✓ Renommer la VM Fedora-Workstation-33-ID101/102
VM existante (linux-fedora-workstation-33) sur le serveur Hyper-V
✓ Supprimer la VM non désirée
✓ Supprimer le disque dur de la VM
✓ Importer la VM → choisir option (2) restaurer VM avec ID Unique
existant
✓ Renommer la VM Fedora-Workstation-33-ID101/102
➢ Démarrer de la VM Fedora Workstation 33
➢ Ouvrir une session en tant que Admin01 avec le Mot de Passe
Pa$$w0rd2022
➢ Démarrer le Terminal (Shell)
Les éditions Fedora (voir le site officiel de Fedora)
Le Shell : interpréteur de commandes, le Shell par défaut sous fedora est le shell
bash
Ouvrir un Terminal sous Gnome :
 Activités → liste des applications → Utilitaires → Terminal
 Activités → taper Terminal
 Ajouter/Supprimer le Terminal aux Favoris
L'invite du Shell : [admin01@localhost ~]$
Le répertoire Personnel de Admin01 : (~) est /home/admin01/
[admin01@localhost ~]$ ls
[admin01@localhost ~]$ ls -l
[admin01@localhost ~]$ ls -la
[admin01@localhost ~]$ tree
Le symbole $ signifie Simple utilisateur (Standard)
Le symbole # signifie Root (Administrateur Système par défaut linux)
Le Root : Administrateur Système (Super Utilisateur) accès total au système
d'exploitation
Exemple [admin01@localhost ~]$ ls -l /etc/passwd,
Utilisateur standard : par défaut possède les droits de lecture et écriture sur son
répertoire Personnel et exécuter les commandes utilisateurs se trouvant dans /bin
/usr/bin /usr/local/bin ne peuvent pas modifier le système
$ whoami (connaître l'utilisateur en cours actuellement connecté)
$ groups (les groupes de l'utilisateur en cours)
$ hostname (nom de l'ordinateur, voir /etc/hostname)
Pour fedora workstation 33 et lors de la création d'un compte Administrateur,
l'utilisateur est ajouté au groupe Wheel (préconfiguré pour la commande sudo)
Sudo : programme permettant de donner des droits supplémentaires à des
utilisateurs normaux (standards) (commandes d'administration système exp
création/suppression des comptes utilisateurs)
Liste des commandes autorisées par sudo
$ sudo -l (par défaut ALL toutes les commandes)
$man 5 sudoers (documentation sur le fichier /etc/sudoers)
L'accès en tant que root (administrateur) est potentiellement dangereux (su,
sudo)
La commande su (switch/substitut user) est une commande permettant
d'exécuter un interpréteur de commande en changeant d'identité (UID, GID)
Exemple (UID=0, GID=0 c'est le root)
$ id (affiche l'identificateur UID et de groupes de l'utilisateur)
Su permet l'accès au système en tant que root
Changer le mot de passe du root
$ sudo passwd root (Pa$$w0rd2021)
Accès en mode root (se connecter en tant que root sans changer
d'environnement)
$ su (demande de mot de passe)
# pwd (remarquer le répertoire personnel de l'utilisateur)
# groups (c'est le root)
# exit (se déconnecter)
Accès en mode root (se connecter en tant que root avec changement
d'environnement)
$ su - (mot de passe root)
# remarquer le tilde ~ (répertoire personnel de l'utilisateur root)
# pwd (/root)
# exit
$ clear
Accès en mode utilisateur standard (se connecter en tant que utilisateur01
sans changement d'environnement)
$ su utilisateur01 (mot de passe)
$ pwd (répertoire de travail d'un autre utilisateur)
$ exit
Accès en mode utilisateur standard (se connecter en tant que utilisateur01
avec changement d'environnement)
$ su – utilisateur01
$ pwd (répertoire personnel de l'utilisateu01)
$ exit
Pour limiter l'accès à la commande su, ajouter l'utilisateur au groupe
administratif Wheel
Mode commande :
$ groups utilisateur01
$ sudo usermod -a -G wheel utilisateur01
$ groups utilisateur01
Supprimer l'utilisateur du groupe administratif Wheel
$ groups utilisateur01
$ sudo usermod -G "" utilisateur01
$ groups utilisateur01
$ exit
Mode Graphique :
Activités  applications  paramètres  déverrouiller  mot de passe
compte utilisateur  activer le mode administrateur
Supprimer l'utilisateur du groupe Wheel
La commande sudo : une autre méthode pour donner un accès administratif aux
utilisateurs.
Exemple : ajouter un compte utilisateur standard
$ sudo adduser tri102
$ cat /etc/passwd
$ groups tri102
$ id tri102
$ cat /etc/group
Exemple : supprimer un compte utilisateur standard
$ sudo userdel -r tri102
$ cat /etc/passwd
$ shutdown -r +3
$ shutdown -h now
$ shutdown -P +0
Organisation du système de fichier Linux (racine /)
Le système de fichier linux peut résider sur différentes partitions, différents
supports physiques ou autres machines sur le réseau
Affichage de l'arborescence du système
$ tree -d / | more
$ tree -d -L 1 / | more
$ tree -d -L 2 / | more
Chemin Absolu : emplacement à partir de la racine /
Chemin relatif : emplacement à partir du répertoire en cours (niveau actuel)
$ pwd (affiche le répertoire actif)
. Répertoire en cours
.. Répertoire parent
~ Répertoire personnel de l'utilisateur
$ cd ~
$ cd
Types de fichiers linux
Fichiers normaux (ordinaires, réguliers)
Répertoires (dossiers, catalogues)
Fichiers spéciaux (/dev périphériques)
Lien symbolique
Les tubes nommés …
Lister (afficher le contenu d'un répertoire) ls (list stored)
$ ls (affichage du contenu répertoire en cours)
$ ls -l (affichage détaillé des attributs des fichiers)
$ ls ~ (affichage contenu répertoire en cours)
$ ls -F (affichage des types de fichiers)
$ touch fichier1.txt (créer un fichier vide ou modifier la date de modification)
$ ls -l > fichier1.txt (rediriger le résultat vers le fichier)
$ ls -l
$ cat fichier1.txt
Affichage avec un tri par date :
$ ls -lt (du plus récent)
$ ls -ltr (inversé)
Affichage des attributs fichiers et répertoires :
$ ls -la (fichiers cachés)
$ ls -l fichier1.txt
$ ls -l /home
$ ls -ld /home
$ ls -1 (affichage sur une colonne)
$ ls -r (affichage en ordre alphabétique inversé)
$ ls *.txt
Se déplacer dans les répertoires et sous répertoires (changer de répertoire) :
$ pwd
$ cd /
$ cd ~
$ cd
$ cd /
$ cd $HOME
$ ls -la
$ cd .
$ cd ..
$ pwd
Exemple : chemin Absolu (complet)
$ cd /etc
$ ls -l
$ clear
$ pwd
$ cd /home/admin01
$ cd /etc/X11
Exemple : chemin Relatif
$ cd ../rpm
$ cd ..
$ cd X11
$ cd ../../home/admin01

Créer des repertoires : mkdir (make directory) créer un ou plusieurs

répertoires ou une arborescence
$ mkdir rep1
$ mkdir rep1/rep2
$ mkdir -p rep3/rep4
$ mkdir rep5 rep6 rep7
$ ls -R
$ tree
$ mkdir rep8 $home/rep1/rep2/rep9
$ mkdir -p rep10/{rep11, rep12/rep13/rep14}
$ tree
$ ls -R
Supprimer des repertoires : rmdir (remove directory) , rm
Rmdir rep1 rep2 …repn
Le répertoire doit être vide
Ne peut pas supprimer une arborescence
$ tree
$ rmdir rep5
$ rmdir rep6 rep7 rep8
$ rmdir rep1 (impossible repertoire n'est pas vide)
$ rmdir -p rep1/rep2/rep9
$ touch rep3/rep4/fichier.txt
$ tree
$ rm -r rep3
$ tree
$ rm -rf rep10
$ rm fichier1.txt
$ touch fichier1 fichier2 fichier3
$ ls f*
$ rm f*
Copier un fichier : cp source destination
$ ls -l > fichier1.txt
$ cp fichier1.txt fichier2.txt
$ ls -1
$ more fichier2.txt
Renommer ou déplacer un ou plusieurs fichiers ou répertoires : mv
$ mv fichier2.txt document.txt (renommer)
$ ls -1
$ ls -l document.txt (taille , le nombre de liens)
$ mv fichier1.txt Documents (déplacer)
$ tree
Lien symbolique et lien physique : ln source lien
$ ln document.txt lien_phy_document.txt
$ ln -s document.txt lien_symb_document.txt
$ ls -l
$ ls -F
Exercice01
/home/admin01

drapports dcv dimages

rapport1.txt cv1.txt image1.jpg

rapport2.txt cv2.txt image2.jpg
rapport3.txt lettre1.txt image3.gif

Créer l'arborescence
$ mkdir drapports dcv dimages
$ cd drapports
$ touch rapport1.txt rapport2.txt rapport3.txt
$ cd ../dcv
$ touch cv1.txt cv2.txt lettre1.txt
$ cd ../dimages
$ touch image1.jpg image2.jpg image3.gif
Changer du répertoire en cours au répertoire personnel
$ cd ~
Afficher le contenu détaillé du répertoire personnel
$ ls -l
Afficher le chemin absolu du répertoire courant
$ pwd
Passer du répertoire personnel au répertoire dimages
$ cd dimages
Afficher les fichiers qui commencent par im
$ ls im*
Afficher les images de type gif
$ ls *gif
Copier le fichier cv1.txt dans le dossier drapports
$ cp ../dcv/cv1.txt ../drapports
Supprimer le répertoire drapports avec son contenu
$ rm -r ../drapports
Passer au répertoire personnel
$ cd $HOME
Créer un lien symbolique lien_symb_dimages vers le répertoire dimages
$ ln -s dimages lien_symb_dimages

Les droits d'accès aux fichiers :

La protection d'un fichier repose sur trois droits d'accès :
Opération de lecture (r read)
Opération d'écriture (w write)
Opération exécution (x exécute)
Les trois droits d'accès (rwx) sont appliqués sur trois catégories d'utilisateurs :
Le propriétaire (u user)
Le groupe propriétaire (g group)
Les autres utilisateurs (o others)
Droits d'accès des fichiers et dossiers:
Droit Répertoires Fichiers
r read Explorer(afficche la liste des fichiers) Voir le contenu
w write Ajout/suppression/renommer fichier Modifier le contenu
x exécute Se positionner sur le répertoire cd Exécuter

Visualiser les droits d'accès :

$ ls -l
$ touch fichier1
$ mkdir rep1
$ ls -l
Modifier les droits d'accès :
Le propriétaire ou le root (super-utilisateur) peut modifier les droits d'accès
d'un fichier (chmod)
La commande chmod permet de modifier les droits d'un fichier en notation
symbolique ou numérique (octale)
Syntaxe :
Chmod [who]op[permission] nom_fichier
Who: (u user) , (g group) , (o others) , (a all)
Op : + ajouter droits, - supprimer droits, = affecter un droit absolu
Permission : est une combinaison des lettres r w x
Exemple :
$ ls -l fichier1
$ chmod ug+x fichier1 (aucun sens pour les fichier non exécutables)
$ ls -l fichier1
La notation octale :
Une lettre = 1 binaire
Un tiret = 0 binaire
Exemple : rwxrwxr-- = 774
$ ls -l fichier1
$ chmod 754 fichier1
$ ls -l fichier1
Initialisation des droits d'accès :
La commande umask permet de définir un masque de protection des fichiers lors
de la création. (fixer les droits qui seront enlevés par défaut lors de la création
de nouveau fichiers)
Le masque doit être en base 8
Les permissions standards sont :
666 pour les fichiers (non exécutables)
777 pour les dossiers
Droit positionné sur le fichier = droit standard – umask
$ umask
$ touch fichier2
$ ls -l fichier2
$ umask 0022
$ touch fichier3
$ ls -l fichier? Ou $ ls -l fichier[23]
Affichage des droits symboliques par défaut:
$ umask -S
$ mkdir rep3
$ ls -ld fichier3 rep3
$ umask 0002
$ umask
La variable umask prend la valeur initiale (0002) une fois déconnecter de la
session
Exit
Reconnexion
La représentation octale
$ chmod 700 repertoire
$ ls -ld repertoire
La commande chown:
$ ls -l
$ sudo chown :utilisateur01 fichier1
$ ls -l fichier1
$ sudo chown root:root fichier1
$ ls -l fichier1
 $ chmod o-r fichier1 (erreur)
$ sudo chmod o-r fichier1
$ ls -la
$ rm fichier1(avec confirmation)
$ touch fichier1
$ ls -l
$ sudo chown root:root fichier1
$ ls -l
$ rm -f fichier1 (sans confirmation)
La commande chgrp :
$ touch fichier1
$ sudo chgrp root fichier1
$ ls -l
$ sudo chown root fichier1
$ ls -la
$ rm -f fichier1 (sans confirmation)
Exercice :
Dans votre répertoire courant, vous créez un répertoire courant essai_droit. Par
défaut, ce répertoire est à 775 (rwxrwxr-x). Quelles sont les commandes (en
notation symbolique et en base8) pour lui donner les droits suivants (on suppose
qu'après chaque commande on remet le répertoire à 775) :
Propriétaire Groupe Les autres
Lecture Écriture Accès Lecture Écriture Accès Lecture Écriture Accès
Commande1 oui oui oui oui non oui non non oui
Commande2 oui non oui non oui non non non oui
Commande3 non oui non non non oui oui non non
Commande4 non non oui oui non oui non non non
Commande1 :
$ mkdir essai_droit
$ ls -ld
$ chmod g-w,o-r essai_droit
$ ls -ld essai_droit
$ chmod 751 essai_droit
$ ls -ld essai_droit
$ chmod 775 essai_droit
Commande2 :
$ chmod u-w,g-rx,o-r essai_droit
$ ls -ld essai_droit
$ chmod 521 essai_droit
$ ls -ld essai_droit
$ chmod 775 essai_droit
Commande3 :
$ chmod u-rx,g-rw,o-x essai_droit
$ ls -ld essai_droit
$ chmod 214 essai_droit
$ ls -ld essai_droit
$ chmod 775 essai_droit
Commande4 :
$ chmod u-rw,g-w,o-rx essai_droit
$ ls -ld essai_droit
$ chmod 150 essai_droit
$ ls -ld essai_droit
$ chmod 775 essai_droit
Exercices :
Ex01:
Créer la structure suivante dans votre répertoire personnel :
/home/admin01
Rep1
Fichier2
Rep2
Fichier3
Fichier1

$ mkdir -p rep1/rep2
$ touch fichier1 rep1/fichier2 rep1/rep2/fichier3
$ tree

Ex02:
1) Dans votre répertoire personnel, créer un répertoire test. Créer les sous-
répertoires pub et bin du répertoire test.
$ mkdir -p test/{pub,bin}
$ tree
2) Modifier les droits d'accès de façon que :
• Le répertoire test et son sous-répertoire pub soient accessibles en
lecture et exécution pour tous, et en écriture pour le propriétaire
seul.
$ chmod a=rx,u+w test test/pub
$ ls -ld test test/pub
$ ls -la test
• Le répertoire bin soit accessible en exécution pour tous, et en
lecture et écriture pour le propriétaire et son groupe.
$ chmod a=x,ug+rw test/bin
$ chmod a=rwx,o-rw test/bin
$ ls -ld test/bin
3) Aller dans le répertoire test. Créer un fichier doc.txt. Recopier le fichier
dans pub.
 $ cd test
$ touch doc.txt
$ cp doc.txt pub
$ tree
4) Aller dans bin. Afficher à l'écran le contenu de test/pub/doc.txt.
$ cd bin
$ cat ../pub/doc.txt
5) Afficher la liste des fichiers contenus dans test et ses sous-répertoires.
$ ls -R ../
EX03 :
1) Créer un dossier nommé droits et un document monDoc.txt à l’intérieur
de ce dossier.
$ mkdir droits
$ touch droits/mondoc.txt
$ tree
2) Quels sont les droits d’accès sur le fichier que vous venez de créer pour
l’utilisateur ? le groupe ? les autres ?
$ ls -l droits/mondoc.txt
$ stat droits/mondoc.txt
3) Convertir en octal les droits d’accès du fichier mondoc.txt
664
$ stat droits/mondoc.txt
4) Modifier les droits sur monDoc.txt tel qu’il soit accessible en lecture
pour tout le monde (les accès en écriture et exécution sont laissés par
défaut).
$ ls -l droits/mondoc.txt
$ chmod a+r droits/mondoc.txt (commande facultative)
5) Modifier les droits sur le document tel qu’il ait les droits suivants :
rwxr–xr––
$ chmod ug+x,g-w droits/mondoc.txt
$ chmod u+x,g+x-w droits/mondoc.txt
6) Supprimer les droits de lecture au groupe et aux autres utilisateurs.
$ chmod go-r droits/mondoc.txt
7) Ajouter les droits d’exécutions aux autres utilisateurs.
$ chmod o+x droits/mondoc.txt
8) Ecrire avec plusieurs façons, l’accès total au document par tous les
utilisateurs.
$ chmod go+rw droits/mondoctxt
$ chmod a=rwx droits/mondoc.txt
 $ chmod ugo+rwx droits/mondoc.txt
$ chmod 777 droits/mondoc.txt
Autres …

Les commandes de base sur les fichiers :

La commande cat
$ Cat fichier1 fichier2 … (affiche le contenu de fichier1, fichier2 … sur la sortie
standard)
$ cat /etc/passwd
$ cat /etc/group
La commande WC (word count)
Pour compter le nombre de lignes, de caractères et de mots dans un fichier
$ wc -l /etc/passwd
$ wc -w /etc/passwd
$ wc -c /etc/passwd
$ wc -m /etc/passwd nombre de caractères
$ wc -L /etc/passwd la longueur de la plus grande ligne
La commande head
$ head [-nX] fichier1 fichier2 … (afficher les n premiers lignes des fichiers
fichier1 fichier2 … sur la sortie standard) par défaut les 10 premières lignes
$ head /etc/passwd
$ head -n4 /etc/passwd
La commande tail
$ tail [-nX] fichier1 fichier2 … (afficher les n dernières lignes des fichiers
fichier1 fichier2 … sur la sortie standard) par défaut les 10 dernières lignes
$ tail /etc/passwd
$ tail -n4 /etc/passwd
$ head -n12 /etc/passwd | tail -n1
$ head -n20 /etc/group | tail -n3
La commande de recherche des fichiers find
$ find chemin critères options
La commande find est récursive
Option -print (afficher les résultats sur écran)
Critères de recherche : ensemble de paramètres reliés par un et logique
-name : sélection par noms de fichiers, possibilité d'utiliser les wildcards
(globbing)
$ touch fichier1 fichier2 fich3 Fich3
$ mkdir folder1 folder2
$ ls -l
Exemple : rechercher la liste des fichiers depuis l'emplacement courant et
commençant par "fich"
$ find . -name "fich*" -print
Exemple : rechercher la liste des fichiers depuis l'emplacement courant et
commençant par "fich" ou "Fich"
$ find . -name "[fF]ich*" -print
-type : (sélection par type de fichier d dossier, f file, l lien symbolique, ….)
Exemple : afficher tous les répertoires dont le nom commence par "fo"
$ find . -name "fo*" -type d -print
Exemple : afficher tous les fichiers dont le nom commence par "fich" ou "Fich"
$ find . -name "[fF]ich*" -type f -print
-user et -group : recherche sur le propriétaire et le groupe propriétaire des
fichiers
$ find . -type f -user admin01 -group admin01 -print
$ find . -type d -user admin01 -group admin01 -print
$ find ~ -type f -name "fich*" -user admin01 -group admin01 -print
$ find $HOME -type f -name "fich*" -user admin01 -group admin01 -print
$ find . -type f -name "fich*" -user admin01 -group admin01 -print
-size : recherche par taille de fichiers (par défaut c'est une recherche par bloc de
512 octets, b bloc de 512o, c un caractère 1octet, w un mot de 2 octets, k 1ko
1024 octets)
$ find -size +5k
$ find -size – 5b
$ find -size 0c
$ find -type d -size -5k
-perm : recherche sur les autorisations d'accès aux fichiers en octal
(- avoir au moins les droits désirés)
(+ avoir au moins l'un des droits désirés)
Exemple : recherche des dossiers dans le répertoire courant qui ont au moins le
droit d'exécution pour tout le monde)
$ find . -type d -perm -111 -print
Exemple : afficher tous les répertoires dont le nom commence par "fo"
Les options :
-print
-ls
$ find . -size 0c -ls

Administration des Utilisateurs et des Groupes :

➢ Un utilisateur linux dispose d'un login et d'un mot de passe
➢ Chaque utilisateur est identifié par UID unique (valeur numérique)
➢ Un compte utilisateur est l'association (login, UID, GID)
➢ Les UID et GID sont utilisés pour le contrôle des droits d'accès et des
processus lancés
➢ Le UID root est 0
➢ Le GID root est 0
➢ Les UID sous fedora commencent à partir de 1000
➢ Un groupe GID regroupe et organise des utilisateurs
➢ Un utilisateur est membre d'au moins un groupe
 ➢ Un utilisateur à un groupe principal et des groupes secondaires
(supplémentaires)
➢ Un utilisateur dispose de tous les droits associés à ses groupes secondaires
Afficher les informations sur un utilisateur :
$ whoami (utilisateur en cours)
$ id (utilisateur en cours)
$ id utilisateur01 (autre utilisateur)
Le propriétaire (utilisateur) et le groupe propriétaire (groupe principal) sont
appliqués lors de la création d'un fichier
$ touch fichier.txt
$ ls -l fichier.txt
Le fichier /etc/passwd : regroupe l'ensemble des utilisateurs du système, chaque
ligne représente un utilisateur
1) Nom (login)
2) Mot de Passe (x MP crypté sur /etc/shadow) (! Compte verrouillé)
3) UID
4) GID
5) Info utilisateur (descriptif, le nom affiché)
6) Répertoire personnel
7) Shell
$ cat /etc/passwd | wc -l (nombre de comptes utilisateurs)
$ wc -l /etc/passwd
Les mots de passe sont cryptés en SHA512
Le fichier des mots de passe cryptés (/etc/shadow) : fichier sécurisé accessible
que pour le root, contient les mots de passe cryptés
$ sudo /etc/shadow
Champ1 : login
Champ2 : mot de passe crypté $xx$ : type de cryptage, !! mot de passe vide
…
root:$6$...:15399:0:99999:7:::
(1) (2) (3) (4) (5) (6)(7,8,9)
1 Login.

2 Mot de passe chiffré.

3 Date du dernier changement.

4 Durée de vie minimale du mot de passe.

5 Durée de vie maximale du mot de passe.

6 Nombre de jours avant avertissement.

7 Délai avant désactivation du compte après expiration.

8 Délai d’expiration du compte.

9 Réservé pour une utilisation future.

Les groupes : chaque utilisateur possède son propre groupe (groupe principal)
Le fichier /etc/group : les groupes utilisateurs avec la liste des utilisateurs dont
il est le groupe secondaire
$ cat /etc/group
$ wc -l /etc/group
Nom du groupe:MP:GID:liste utilisateurs
$ groups (affichage des groupes de l'utilisateur en cours)
$ groups utilisateur01 admin01 (groupes de l'utilisateur x)

Ajouter des utilisateurs :

Useradd [option] login
-c commentaire
-d chemin du répertoire personnel
-g groupe principal
-G liste des groupes secondaires séparés par des virgules
-m créer le répertoire personnel
-s shell
…
Exemple :
$ sudo useradd utilisateur1 ou # useradd utilisateur1
Le mot de passe n'est pas crée
$ sudo passwd utilisateur1
$ cat /etc/passwd
$ cat /etc/group
$ sudo cat /etc/shadow
L'utilisateur peut changer son mot de passe (ancien mot de passe est demandé)
Le root à le droit de changer le mot de passe de tous les utilisateurs (sans
demande de l'ancien mot de passe)
$ sudo chage -l utilisateur1 (propriétés du mot de passe)
Exemple : créer un utilisateur, les groupes doivent êtres crées avant
$ sudo groupadd groupe1
$ sudo groupadd groupe2
$ sudo groupadd groupe 3
$ sudo groupadd groupe4
$ sudo useradd -c "Belhajjam Morad" -f 0 -G groupe1,groupe2,groupe3 -s
/bin/bash bmorad
$ sudo passwd bmorad
$ su – bmorad
$ pwd
$ whoami
$ groups
$ cat /etc/passwd
$ /etc/group
$ exit
$ ls -l /home (repertoire personnel bmorad)
Supprimer un compte utilisateur avec répertoire personnel
$ sudo userdel -r bmorad
$ ls -l /home
$ cat /etc/passwd
$ cat /etc/group

Afficher les groupes secondaires d'un compte utilisateur

$ groups utilisateur1
Modifier les groupes secondaires d'un utilisateur
$ sudo usermod -G groupe1,groupe2,groupe3 utilisateur1
$ groups utilisateur1
$ sudo usermod -aG groupe4 utilisateur1
$ groups utilisateur1
$ cat /etc/group
Exemple : créer un utilisateur utilisateur2 avec un groupe principal groupe1 et
groupes secondaires groupe2 et groupe3
$ sudo useradd -g groupe1 -G groupe2,groupe3 utilisateur2
$ sudo passwd utilisateur2
$ su – utilisateur2
$ pwd
$ whoami
$ groups
$ exit
Modifier le répertoire personnel de l'utilisateur et le descriptif , puis
supprimer l'utilisateur du groupe secondaire groupe3
$ ls -l /home
$ sudo usermod -d /home/ut2 -c "le login 2" -G groupe2 -m utilisateur 2
$ ls -l /home
$ groups utilisateur2
$ cat /etc/passwd
Supprimer l'utilisateur utilisateur2 et son répertoire personnel
$ sudo userdel -r utilisateur2
$ cat /etc/passwd
$ cat /etc/group
Supprimer le mot de passe de l'utilisateur (passwd)
$ sudo passwd -d utilisateur1
$ su – utilisateur1
$ exit
$ cat /etc/passwd
$ sudo cat /etc/shadow
$ sudo passwd utilisateur1
Supprimer le mot de passe de l'utilisateur ( vi /etc/shadow)
$ sudo vi /etc/shadow
Vider le champs mot de passe
Enregistrer : wq!
Tester l'accès sans mot de passe
$ su – utilisateur1
$ exit
$ sudo passwd utilisateur1
Changer le login de l'utilisateur1 en ut1
$ sudo usermod -l ut1 utilisateur1
$ cat /etc/passwd
$ cat /etc/group
Supprimer ut1 avec répertoire personnel
$ sudo userdel -r ut1
Supprimer les groupes
$ sudo groupdel groupe1
$ sudo groupdel groupe2
$ sudo groupdel groupe3
$ sudo groupdel groupe4
$ sudo groupdel utilisateur1
$ cat /etc/group
Modification de groupes
$ sudo groupadd groupe1
$ cat /etc/group
$ sudo groupmod -n groupe3 groupe1 (modifier le nom)
$ cat /etc/group

Les Redirections :
Rediriger l'affichage de l'écran vers un fichier, une imprimante ou tout autre
périphérique, les messages d'erreurs vers un autre fichier, remplacer la saisie
clavier par le contenu d'un fichier.
Linux utilise des canaux d'entrées/sorties pour lire et écrire les données.
Les canaux par défaut de linux:
Canal d'entrée standard : le clavier
Canal de sortie standard : l'écran
Canal d'erreurs standard : redirigé vers l'écran
Redirection des flux de données vers des fichiers :
Flux de sortie (>) : rediriger la sortie standard (écran)
$ ls -l > fresultat.txt
$ cat fresultat.txt
Le fichier est créé ou son contenu est écrasé s'il existe
Les redirections sont mises en place avant l'exécution des commandes (fichier
crée avant l'exécution de la commande)
La double redirection (>>) : le résultat de la commande est ajouté en fin de
fichier.
$ cal >> fresultat.txt
$ ls >> fresultat.txt
$ clear
$ cat resultat.txt
Flux en entrée : les commandes peuvent recevoir des données à partir d'un
fichier au lieu de l'entrée standard (clavier) (<) redirection en entrée
$ wc < fresultat.txt
$ tr "[a-z]" "[A-Z]" < /etc/passwd
La redirection << : permet la saisie d'un texte jusqu’à un point donné et l'envoi
de son contenu à une commande ou un filtre
Après la << vous indiquez une chaîne de fin de saisie
$ tr "[a-z]" "[A-Z]" << fin
Les priorités : < , > , <<
Les canaux stabdars:
Canal d'entrée standard : stdin, descripteur 0
Canal de sortie standard : stdout, descripteur 1
Canal d'erreur standard : stderr, descripteur 2
$ rmdir dresultat (message d'erreur, par défaut envoyé sur écran)
$ rmdir dresultat 2> ferreur.log
$ ls -l
$ cat fereur.log
Rediriger les deux canaux de sortie dans un seul fichier, on utilise (>&)
$ ls -l > fresultat.txt 2>&1
Le fichier contient la sortie standard et les erreurs
$ wc < fresultat.txt > ftotal.txt
$ cat ftotal.txt
Les Tubes (Piplines) : les tubes ou pipes permettent de rediriger directement le
canal de sortie d'une commande vers le canal d'entrée d'une autre commande |
$ ls -l | wc
$ ls -l | wc > fresultat.txt
$ cat fresultat.txt
$ ls -l | wc | wc (plusieurs pipes)
La commande cat : permet de créer, fusionner ou afficher des fichiers sur la
sortie standard (écran) ou sur un autre fichier.
cat [option] [fichier]
Créer un fichier avec la commande cat
$ cat > fichier1.txt
texte
cours 1
fichier1
partie 1
Ctrl + d
$ ls -l
Afficher le contenu d'un fichier sur écran
$ cat fichier1.txt
$ cat /etc/passwd
$ cat >> fichier1.txt (ajouter du texte en fin de fichier)
$ cat fichier1.txt /etc/passwd /etc/group
$ cat *.txt
Redirection du contenu à l'aide de la commande cat
$ cat fichier1.txt > fichier2.txt (le fichier et crée ou écrasé)
$ cat fichier2.txt
$ cat fichier1.txt >> fichier2.txt (ajout du contenu en fin de fichier)
Concaténation des fichiers (fusion)
$ cat fichier1.txt fichier2.txt > fichier.txt
$ cat fichier.txt
Afficher les numéros de lignes
$ cat -n fichier.txt
La commande Find (suite) :
-exec : exécuter la commande pour chaque occurrence trouvée
-exec : doit être la dernière option de find
-exec : doit se terminer par \;
{} : substitution du fichier (passer le fichier résultat comme paramètre de la
commande)
$ touch f1.pdf f2.pdf f3.pdf
$ find -type f -name "*.pdf" -exec rm -f {} \;
$ touch f1.pdf f2.pdf f3.pdf
$ find . -type f -name "*.pdf" -ok rm -f {} \;
$ find . -iname "fich*" -exec ls {} \;
Les opérateurs logiques : ! or and
$ find . \(-name [fF]* ! -size +1b\) -print
Exercice01 : utilisation des wildcards
Globbing (wildcards = jokers, plages de valeurs [0-9], les filtres sur les fichiers)
: permet de nommer plusieurs fichiers grâce à des caractères "jokers", filtres,
plages de valeurs.
? un seul caractère
Astérisque * 0 ou n caractères
[chars] liste, liste alphabétique, liste numérique (acceptée)
[!chars] liste, liste alphabétique, liste numérique (refusée)
Exemples:
abc? : nom de fichier de 4 lettres commençant par abc
abc* : nom de fichier de trois lettres ou plus commençant par abc
*abc* : nom de fichier de 3 lettres ou plus contenant la chaîne abc
[ab]c : nom de fichier composé de deux lettres commencant par a ou A
[a-m]* : nom de fichier commencant par une lettre entre a et m
*[0-1][0-9] : nom de fichier se terminant par un nombre entre 00 et 19
[13579]*[a-z] commence par un chiffre impair et se termine par une minuscule
{a,b,c} fichiers nommés a b et c
{a*,*b*,*c} fichiers qui commencent par a , contient b ou se terminent par c
*{.doc,.odt,.rtf} fichiers *.doc, *.odt, *.rtf

Lister tous les fichiers : (ls)

• se terminant par '5'
$ ls *5
• commençant par 'annee4'
$ ls annee4*
• commençant par 'annee4' et de 7 lettres maximum
$ ls annee4?
• commençant par 'annee' avec aucun chiffre numérique
$ ls annee[!0-9]*
• contenant la chaîne 'ana'
$ ls *ana*
• commençant par 'a' ou 'A'
$ ls [aA]*
Exercice02 : utilisation de find
1) Chercher tous les fichiers dont le nom est "passwd"
2) Trouver tous les fichiers du groupe "root"
3) Chercher tous les fichiers dont la taille est supérieure à 20Mo
4) Chercher tous les répertoires se trouvant sous /etc.
5) Chercher tous les fichiers de l'utilisateur admin01
La commande grep (filtrer des données) : rechercher une chaîne de caractères
(texte, mot, …) dans un fichier et afficher les lignes dans lesquelles la
chaîne(mot) a été trouvé.
grep chaîne nom-fichier
$ ls -l
$ grep cours fichier.txt
$ grep cours fichier.txt fichier1.txt fichier2.txt
$ grep cours *.txt
$ grep admin01 /etc/passwd /etc/group (afficher les propriétés d'un utilisateur et
ses groupes)
$ grep " cours 1" *.txt (utiliser les guillemets pour des mots séparés par des
espaces)
Option -i (ne pas tenir compte de la casse Majuscule/Minuscule)
$ cat fichier1.txt
$ cat >> fichier1.txt
Cours 1
Ctrl +d
$ grep cours fichier1.txt
$ grep -i cours fichier1.txt
Option -n (afficher les numéros de lignes)
$ grep -n cours fichier.txt
$ grep -ni cours fichier1.txt
Option -v (inverser la recherche, ignorer un texte, afficher les lignes qui ne
contiennent pas un mot)
$ grep -v cours fichier.txt
$ grep -vi cours fichier1.txt
Option -r (recherche dans tous les fichiers et sous dossiers : récursive)
$ grep -r cours /home/admin01
$ grep -r cours . (identique)
Utiliser grep avec des expressions régulières (recherche avancée)
Principaux caractères spéciaux utilisés dans les expressions régulières :
. Caractère quelconque
^ début de lignes
$ fin de ligne
[…] un des caractères entre crochet
? élément précédent est optionnel (présent 0 ou 1 fois)
+ élément précédent doit être présent 1 ou plusieurs fois
* élément précédent doit être présent 0,1 ou plusieurs fois
| ou logique
() groupement d'expression
[^…] plage des caractères interdits
Option -E (étendue) pour utiliser l'expression régulière (équivalent à egrep)
$ grep [-E] cours fichier.txt
$ grep [-E] Cours fichier1.txt
$ grep [-E] ^f fichier.txt
$ grep [-E] ^admin01 /etc/passwd /etc/group (afficher les ligne qui commencent
par admin01)
$ grep [-E] /bin/bash$ /etc/passwd (les comtes qui utilisent le shell bash, lignes
qui se terminent par /bin/bash)
$ grep [-E] [Cc]ours fichier1.txt (lignes qui contiennent Cours ou cours,
commence par C ou c)
$ grep [-E] [1-4] fichier.txt (un nombre compris entre 1 et 4)
$ grep ^[a-f] /etc/passwd (les lignes qui commencent par une lrttre de a à f)
Le ou logique : |
$ grep "admin01\|root" /etc/passwd (lignes qui contiennent admin01 ou root ou
les deux)
$ grep "^admin01\|root" /etc/passwd
$ grep "^admin01\|^root" /etc/passwd
$ grep -E "^admin01|^root" /etc/passwd (identique)
$ grep -E "^(admin01|root)" /etc/passwd (identique)
$ grep -n -E "ro?" /etc/passwd (aucune occurrence ou une seule)
$ grep -n -E "ro+" /etc/passwd (une occurrence ou plusieurs)
$ grep -n -E "ro*" /etc/passwd (aucune , une ou plusieurs)
$ grep -n -E "ro{1,2}" /etc/passwd
$ grep -n -E "ro{2,3}" /etc/passwd
$ grep -n -E "ro{2,} /etc/passwd
$ gerp -n -E "^ro{2,}" /etc/passwd
La commande sort trier le contenu d'un fichier :
Créer un nouveau fichier list-tri-102.txt
$ cat > list-tri-102.txt
kaddouri
idrissi
benanou
Belfkih
lahbichi
amara
el aouadi
ctrl + d
$ ls -l
$ cat list-tri-102.txt
$ sort list-tri-102.txt (le fichier est trié alphabétiquement et affiché sur écran
dans un ordre croissant, la commande ne fait pas la différence entre Majuscule
et minuscule).
$ sort -o list-triée list-tri-102.txt (- output le résultat du trie est enregistré dans
un fichier list-triée)
Trier en ordre inverse (décroissant):
$ sort -r list-tri-102.txt
Trier des nombres:
Créer un fichier nombres.txt
$ cat > nombres.txt
140
27
38
12
3
20
15
Ctrl + d
$ cat nombres.txt
$ sort nombres.txt (ne distingue pas les nombres, il les considère comme des
caractères)
$ sort -n nombres.txt (trier des nombres)

Syntaxe sort
Sort -k<position> [-n][-r] -t<délimiteur> fichier
Exemples :
$ cat /etc/passwd
$ sort -k3 -nt ':' /etc/passwd
$ sort -k1,1 -t: /etc/passwd
Remarque : par défaut sort trie selon l'ordre numérique d'abord, puis par ordre
alphabétique.
Archivage et compression sous linux:
gzip et bzip2 peuvent compresser un seul fichier à la fois et ne peuvent pas créer
un paquetage de plusieurs fichiers
archiver en utilisant l’outil Tar (Tape archiver)
la solution c’est de créer une archive compressée , en utilisant Tar et (gzip ou
bzip2) pour avoir un résultat .tar.gz ou .tar.bz2
créer une archive : tar -cvf destination source
-c : créer l’archive
-v : mode détail
-f : file (archiver dans un fichier)
Archiver les fichiers texte dans une archive :
$ Ls -l > fichier1.txt
$ Ls -l > fichier2.txt
$ Ls -l > fichier3.txt
$ mkdir archive_txt
$ mv *.txt archive_txt
$ tar -cvf archivetxt.tar archive_txt
Afficher le contenu de l’archive sans l’extraire :
$ tar -tvf archivetxt.tar
Ajouter un fichier à l’archive:
$ ls -l > archive_txt/fichier4.txt
$ tar -rvf archivetxt.tar archive_txt/fichier4.txt
$ tar -tvf archivetxt.tar
Extraire les fichiers de l’archive dans le répertoire en cours:
$ cd Documents
$ tar -xvf ../archivetxt.tar
gzip et bzip2 pour compresser une archive:
bzip2 : meilleur taux de compression
Compresser l’archive archivetxt.tar avec gzip:
$ gzip archivetxt.tar
Décompresser l’archive gunzip:
$ gunzip archivetxt.tar.gz
La compression la plus puissante bzip2:
$ bzip2 archivetxt.tar
La décompression bunzip2:
$ bunzip2 archivetxt.tar.bz2
La Comparaison entre gzip et bzip2:
$ gzip -v dnsmasq.conf
$ gunzip dnsmasq.conf.gz
$ bzip2 -v dnsmasq.conf
$ bunzip2 dnsmasq.conf.bz2
Archiver et compresser en même temps avec tar et gzip :
$ tar -zcvf archivetxt.tar.gz archive_txt
Décompresser l’archive compressée :
$ tar -zxvf archivetxt.tar.gz
Archiver et compresser en même temps avec tar et bzip2 :
$ tar -jcvf archivetxt.tar.bz2 archive_txt
Décompresser l’archive compressée :
$ tar -jxvf archivetxt.tar.bz2