🐧 Système Unix - S5

Année: 2022-2023 (Semestre 5)
Crédits: 3 ECTS
Type: Systèmes d’Exploitation

PART A: PRÉSENTATION GÉNÉRALE

Objectifs du cours

Ce cours introduit les systèmes d’exploitation Unix/Linux en se concentrant sur l’utilisation pratique de la ligne de commande, la programmation shell, et l’administration système de base. L’accent est mis sur la maîtrise des outils essentiels pour le développement et l’exploitation de systèmes embarqués.

Compétences visées

• Maîtriser la ligne de commande Unix/Linux
• Programmer des scripts shell pour l’automatisation
• Gérer les fichiers, processus et permissions
• Utiliser les outils de traitement de texte (grep, sed, awk)
• Comprendre l’architecture du système de fichiers
• Effectuer des tâches d’administration système basiques
• Combiner les commandes avec pipes et redirections
• Résoudre des problèmes pratiques avec les outils Unix

Organisation

• Volume horaire: Cours, TD et vidéos pédagogiques
• Évaluation: Examen écrit + exercices pratiques
• Semestre: 5 (2022-2023)
• Prérequis: Notions d’informatique de base

PART B: EXPÉRIENCE, CONTEXTE ET FONCTION

Contenu pédagogique

Le cours couvre les fondamentaux d’Unix à travers une approche pratique.

1. Fondamentaux Unix

Philosophie Unix:

Principes de conception:

• Tout est fichier (périphériques, sockets, processus)
• Programmes simples faisant une seule chose bien
• Combinaison d’outils avec pipes
• Interfaces textuelles pour faciliter l’automatisation
• Système multi-utilisateurs et multi-tâches

Architecture système:

Figure : Architecture en couches d'un système Unix/Linux

Shells disponibles:

• bash (Bourne Again Shell): le plus répandu
• sh (Bourne Shell): shell historique
• zsh (Z Shell): shell avancé avec auto-complétion
• csh/tcsh (C Shell): syntaxe proche du C

2. Système de fichiers

Arborescence standard:

Structure hiérarchique partant de la racine (/).

Types de fichiers:

• Fichier régulier (-): fichier normal
• Répertoire (d): dossier
• Lien symbolique (l): raccourci vers un autre fichier
• Périphérique bloc (b): disque dur, USB
• Périphérique caractère (c): terminal, imprimante
• Socket (s): communication inter-processus
• Pipe nommé (p): canal de communication

Commandes de navigation:

pwd                    # Afficher répertoire courant
cd /chemin/vers/dir    # Changer de répertoire
cd ..                  # Remonter d'un niveau
cd ~                   # Aller au home
cd -                   # Revenir au répertoire précédent
ls                     # Lister fichiers
ls -l                  # Liste détaillée
ls -a                  # Afficher fichiers cachés
ls -lh                 # Tailles lisibles (KB, MB)

Manipulation de fichiers:

# Création
touch fichier.txt      # Créer fichier vide
mkdir dossier          # Créer répertoire
mkdir -p a/b/c         # Créer arborescence

# Copie et déplacement
cp source dest         # Copier fichier
cp -r dir1 dir2        # Copier répertoire récursivement
mv ancien nouveau      # Renommer/déplacer

# Suppression
rm fichier             # Supprimer fichier
rm -r dossier          # Supprimer répertoire récursivement
rm -f fichier          # Forcer suppression
rmdir dossier          # Supprimer répertoire vide

Visualisation de fichiers:

cat fichier            # Afficher contenu complet
more fichier           # Afficher page par page
less fichier           # Naviguer dans le fichier
head fichier           # Afficher premières lignes
head -n 20 fichier     # Afficher 20 premières lignes
tail fichier           # Afficher dernières lignes
tail -f fichier        # Suivre ajouts en temps réel (logs)

3. Permissions et droits d’accès

Système de permissions:

Format: drwxrwxrwx

• Premier caractère: type de fichier
• 3 caractères suivants: droits du propriétaire (user)
• 3 suivants: droits du groupe (group)
• 3 derniers: droits des autres (others)

Types de permissions:

Représentation numérique:

Chaque permission a une valeur:

• r = 4
• w = 2
• x = 1

Exemples:

• 755 = rwxr-xr-x (propriétaire: tout, autres: lecture+exécution)
• 644 = rw-r–r– (propriétaire: lecture+écriture, autres: lecture seule)
• 700 = rwx—— (propriétaire seul a tous les droits)
• 777 = rwxrwxrwx (tous les droits pour tout le monde)

Commandes de gestion:

# Modifier permissions
chmod 755 fichier              # Mode numérique
chmod u+x fichier              # Ajouter exécution pour user
chmod g-w fichier              # Retirer écriture pour group
chmod o+r fichier              # Ajouter lecture pour others
chmod a+x fichier              # Ajouter exécution pour all

# Modifier propriétaire
chown utilisateur fichier      # Changer propriétaire
chown user:group fichier       # Changer user et group
chgrp groupe fichier           # Changer groupe uniquement

Permissions spéciales:

SUID (Set User ID): 4xxx ou u+s

• Le fichier s’exécute avec les droits du propriétaire
• Exemple: /usr/bin/passwd (permet aux users de changer leur mot de passe)

SGID (Set Group ID): 2xxx ou g+s

• Le fichier s’exécute avec les droits du groupe
• Sur un répertoire: fichiers créés héritent du groupe

Sticky bit: 1xxx ou +t

• Sur répertoire: seul le propriétaire peut supprimer ses fichiers
• Exemple: /tmp (répertoire partagé mais fichiers protégés)

Exemple de l’examen:

chmod 1777 /tmp/test3    # Sticky bit + tous droits
chmod 750 /tmp/test1     # rwxr-x---
chmod 640 fichier        # rw-r-----

4. Gestion des processus

Concept de processus:

Un processus est un programme en cours d’exécution.

Attributs principaux:

• PID (Process ID): identifiant unique
• PPID (Parent Process ID): processus parent
• UID: utilisateur propriétaire
• État: running, sleeping, stopped, zombie
• Priorité: nice value

Commandes de gestion:

# Afficher processus
ps                    # Processus de l'utilisateur courant
ps aux                # Tous les processus détaillés
ps -ef                # Format long
top                   # Monitoring en temps réel
htop                  # Version améliorée de top

# Contrôle des processus
kill PID              # Envoyer signal TERM (terminaison propre)
kill -9 PID           # Signal KILL (terminaison forcée)
killall nom           # Tuer par nom de programme
pkill motif           # Tuer selon motif

# Arrière-plan
commande &            # Lancer en arrière-plan
jobs                  # Lister jobs
fg %1                 # Ramener job 1 au premier plan
bg %1                 # Continuer job 1 en arrière-plan
Ctrl+Z                # Suspendre processus courant

Analyse de l’exemple de l’examen:

Commande: ps -ef | awk '{print $3}' | sort | uniq -c | awk '{print $2,$1}' | grep -v PPID

Décomposition:

1. ps -ef: liste tous les processus
2. awk '{print $3}': extrait colonne PPID (parent)
3. sort: trie les PPID
4. uniq -c: compte occurrences de chaque PPID
5. awk '{print $2,$1}': inverse colonnes (PPID puis count)
6. grep -v PPID: exclut l’en-tête

Résultat: liste des processus avec leur nombre d’enfants.

5. Programmation Shell (Bash)

Structure de base d’un script:

#!/bin/bash
# Shebang: indique l'interpréteur à utiliser

# Ceci est un commentaire

echo "Premier script shell"

Exécution:

chmod +x script.sh     # Rendre exécutable
./script.sh            # Exécuter

Variables:

# Déclaration (pas d'espace autour du =)
nom="Cedric"
age=25
i=3

# Utilisation
echo "Je m'appelle $nom"
echo "J'ai ${age} ans"

# Variables d'environnement
echo $HOME             # Répertoire personnel
echo $PATH             # Chemins de recherche des commandes
echo $USER             # Nom utilisateur

Lecture d’entrée:

echo "Entrez un nombre:"
read nombre
echo "Vous avez saisi: $nombre"

# Lecture dans variable spécifique
read -p "Nom: " nom

Structures conditionnelles:

# if-then-else
if test $i -eq 3
then
  echo "i vaut 3"
else
  echo "i ne vaut pas 3"
fi

# Forme alternative avec crochets
if [ $i -eq 3 ]
then
  echo "i vaut 3"
fi

# Opérateurs de comparaison numérique
# -eq (égal), -ne (différent), -lt (inférieur)
# -le (inférieur ou égal), -gt (supérieur), -ge (supérieur ou égal)

# Comparaisons de chaînes
if [ "$str1" = "$str2" ]
then
  echo "Chaînes identiques"
fi

# Tests de fichiers
if [ -f fichier ]      # Fichier existe
if [ -d dossier ]      # Répertoire existe
if [ -r fichier ]      # Fichier lisible
if [ -w fichier ]      # Fichier modifiable
if [ -x fichier ]      # Fichier exécutable

# Case
case $var in
  1) echo "Un" ;;
  2) echo "Deux" ;;
  *) echo "Autre" ;;
esac

Boucles:

# Boucle for avec séquence
for i in $(seq 1 100)
do
  echo $i
done

# Boucle for sur fichiers
for fichier in *.txt
do
  echo "Traitement de $fichier"
done

# Boucle for sur résultat de commande
for fichier in $(ls *)
do
  echo $fichier
done

# Boucle while
compteur=1
while [ $compteur -le 10 ]
do
  echo $compteur
  compteur=$((compteur + 1))
done

# Boucle while avec lecture de fichier
while read ligne
do
  echo "Ligne: $ligne"
done < fichier.txt

# Until (inverse de while)
until [ $compteur -gt 10 ]
do
  echo $compteur
  compteur=$((compteur + 1))
done

Tableaux:

# Déclaration
tab[0]="premier"
tab[1]="deuxième"

# Ou
declare -a tab
tab=("un" "deux" "trois")

# Remplissage en boucle
n=4
for i in $(seq 1 $n)
do
  tab[$i]="element$i"
done

# Accès
echo ${tab[0]}         # Premier élément
echo ${tab[*]}         # Tous les éléments
echo ${#tab[*]}        # Nombre d'éléments

Fonctions:

# Définition
ma_fonction() {
  echo "Bonjour $1"    # $1 = premier argument
  return 0             # Code de retour
}

# Appel
ma_fonction "Cedric"

Erreurs courantes à éviter:

D’après l’examen:

1. Oublier le ! dans le shebang: #!/bin/bash
2. Espaces autour du =: utiliser i=3 pas i = 3
3. Mauvaise syntaxe de boucle: for i in $(seq 1 100) pas for i in 1..100
4. Mauvais test: if [ $i -eq 3 ] pas if test $i == 3 then
5. Fermer avec fi pas end
6. Utiliser $i pour lire la variable, pas $REPLY
7. Accès tableau: ${tab[*]} pas ${tab}
8. Substitution de commande: $(commande) ou `commande`

6. Traitement de texte

grep (recherche de motifs):

grep "motif" fichier              # Rechercher motif
grep -i "motif" fichier           # Insensible à la casse
grep -v "motif" fichier           # Inverser (lignes sans motif)
grep -r "motif" repertoire/       # Récursif dans répertoire
grep -n "motif" fichier           # Afficher numéros de lignes
grep -c "motif" fichier           # Compter occurrences
grep -E "regex" fichier           # Expressions régulières étendues

sed (éditeur de flux):

# Substitution
sed 's/ancien/nouveau/' fichier         # Première occurrence par ligne
sed 's/ancien/nouveau/g' fichier        # Toutes occurrences
sed -i 's/ancien/nouveau/g' fichier     # Modifier fichier en place

# Suppression
sed '/motif/d' fichier                  # Supprimer lignes contenant motif
sed '1d' fichier                        # Supprimer première ligne
sed '1,5d' fichier                      # Supprimer lignes 1 à 5

awk (langage de traitement):

# Afficher colonnes
awk '{print $1}' fichier               # Première colonne
awk '{print $1, $3}' fichier           # Colonnes 1 et 3
awk '{print $NF}' fichier              # Dernière colonne

# Avec conditions
awk '$3 > 100 {print $1}' fichier      # Si colonne 3 > 100

# Exemple de l'examen
ps -ef | awk '{print $3}'              # Extraire PPID
echo "$ligne" | awk '{print $1}'       # Extraire premier champ

Autres outils:

sort fichier                 # Trier lignes
sort -n fichier              # Tri numérique
sort -r fichier              # Tri inverse
uniq fichier                 # Supprimer doublons consécutifs
uniq -c fichier              # Compter occurrences
wc fichier                   # Compter lignes, mots, caractères
wc -l fichier                # Compter lignes seulement
cut -d':' -f1 fichier        # Extraire premier champ (délimiteur :)

7. Redirections et pipes

Flux standard:

• stdin (0): entrée standard (clavier)
• stdout (1): sortie standard (écran)
• stderr (2): sortie d’erreur (écran)

Redirections:

# Redirection de sortie
commande > fichier           # Écraser fichier
commande >> fichier          # Ajouter à fichier
commande 2> erreurs.txt      # Rediriger erreurs
commande 2>&1                # Erreurs vers sortie standard
commande &> fichier          # Sortie et erreurs vers fichier

# Redirection d'entrée
commande < fichier           # Lire depuis fichier
while read ligne
do
  echo $ligne
done < fichier.txt

# Pipe (sortie d'une commande = entrée de la suivante)
commande1 | commande2
ps aux | grep firefox
cat fichier | sort | uniq

Exemple complexe de l’examen:

ps -ef | awk '{print $3}' | sort | uniq -c | awk '{print $2,$1}' | grep -v PPID > /tmp/f

Chaîne de traitement avec 5 pipes combinant plusieurs outils.

8. Administration système de base

Informations système:

uname -a                # Info complète système
hostname                # Nom de la machine
whoami                  # Utilisateur courant
who                     # Utilisateurs connectés
w                       # Utilisateurs et activité
uptime                  # Temps de fonctionnement et charge
date                    # Date et heure

Gestion des disques:

df -h                   # Espace disque (human-readable)
du -sh dossier          # Taille d'un répertoire
du -sh *                # Taille de tous éléments

Gestion des utilisateurs:

passwd                  # Changer son mot de passe
sudo commande           # Exécuter avec droits root
su                      # Devenir root
su - utilisateur        # Changer d'utilisateur

Recherche de fichiers:

find /chemin -name "*.txt"           # Par nom
find /chemin -type f                 # Fichiers réguliers
find /chemin -type d                 # Répertoires
find /chemin -mtime -7               # Modifiés depuis 7 jours
find /chemin -size +100M             # Taille > 100 Mo
locate fichier                       # Recherche rapide (base de données)
which commande                       # Localiser exécutable

Archivage et compression:

# tar (tape archive)
tar -cvf archive.tar fichiers/      # Créer archive
tar -xvf archive.tar                # Extraire archive
tar -tvf archive.tar                # Lister contenu

# Avec compression
tar -czvf archive.tar.gz fichiers/  # Créer + gzip
tar -xzvf archive.tar.gz            # Extraire gzip
tar -cjvf archive.tar.bz2 fichiers/ # Créer + bzip2

# zip/unzip
zip -r archive.zip dossier/
unzip archive.zip

Liens:

# Lien symbolique (raccourci)
ln -s /chemin/cible lien            # Créer lien symbolique

# Lien dur (même inode)
ln fichier_original lien_dur        # Créer lien dur

Figure : Exemple de configuration réseau sous Unix/Linux - TP pratique

PART C: ASPECTS TECHNIQUES

Exercices pratiques des examens

Exercice 1: Création d’arborescence avec permissions

Objectif: reproduire exactement une structure de fichiers avec les bonnes permissions.

# Création de l'arborescence
mkdir -p /tmp/test/test1 /tmp/test/test2 /tmp/test/test3

# Création des fichiers
touch /tmp/test/test1/f1
touch /tmp/test/test2/f2
touch /tmp/test/test3/f3

# Attribution des permissions aux répertoires
chmod 750 /tmp/test/test1    # rwxr-x---
chmod 754 /tmp/test/test2    # rwxr-xr--
chmod 1777 /tmp/test/test3   # rwxrwxrwt (avec sticky bit)

# Attribution des permissions aux fichiers
chmod 640 /tmp/test/test1/f1 # rw-r-----
chmod 444 /tmp/test/test2/f2 # r--r--r--
chmod 700 /tmp/test/test3/f3 # rwx------

Explications permissions spéciales:

chmod 1777: le 1 devant correspond au sticky bit.

• Permet à chacun de créer des fichiers dans le répertoire
• Mais seul le propriétaire peut supprimer ses propres fichiers
• Typique pour /tmp

Exercice 2: Correction de script shell

Script avec erreurs:

#/bin/bash                          # ERREUR: manque !

for i in 1..100                     # ERREUR: syntaxe incorrecte
do
 echo $i
done

for i in ls *                       # ERREUR: manque $()
do
  echo $i
done

i = 3                               # ERREUR: espaces autour de =

if test $i == 3 then                # ERREUR: -eq au lieu de ==, then mal placé
  echo yes
else
  echo no
end                                 # ERREUR: doit être fi

echo "un entier stp"
read i
echo entier saisi : $REPLY          # ERREUR: doit être $i

n=4
for i in `seq 1 $n` 
do
  tab[i]="toto" 
done
echo ${tab}                         # ERREUR: doit être ${tab[*]}

Version corrigée:

#!/bin/bash

for i in $(seq 1 100)
do
 echo $i
done

for i in $(ls *)
# ou plus simple: for i in *
do
  echo $i
done

i=3

if [ $i -eq 3 ]
then
  echo yes
else
  echo no
fi

echo "un entier stp"
read i
echo entier saisi : $i

n=4
for i in $(seq 1 $n)
do
  tab[$i]="toto"
done
echo ${tab[*]}

Exercice 3: Analyse de pipeline complexe

Script d’analyse des processus parents:

#!/bin/bash

# Pipeline complexe
ps -ef | awk '{print $3}' | sort | uniq -c | awk '{print $2,$1}' | grep -v PPID > /tmp/f

# Boucle de traitement
while read v
do
  a=$(echo $v | awk '{print $1}')   # PID
  b=$(echo $v | awk '{print $2}')   # Nombre d'enfants
  echo le processus $a a $b enfants 
done < /tmp/f

Explication détaillée du pipeline:

1. ps -ef: affiche tous les processus avec PID, PPID, etc.
2. awk '{print $3}': extrait la 3e colonne (PPID)
3. sort: trie les PPID numériquement
4. uniq -c: compte les occurrences de chaque PPID unique
5. awk '{print $2,$1}': inverse l’ordre (PPID puis compteur)
6. grep -v PPID: exclut la ligne d’en-tête
7. > /tmp/f: sauvegarde dans fichier temporaire

Résultat dans /tmp/f: chaque ligne contient un PID et le nombre de fois qu’il apparaît comme parent (nombre d’enfants).

La boucle while:

Lit chaque ligne du fichier /tmp/f et extrait:

• Variable a: le PID du processus
• Variable b: le nombre d’enfants de ce processus

Affiche: “le processus XXX a YYY enfants”

Exercice 4: Permissions et sécurité

Analyse des permissions d’un jeu:

drwxr-xr-x 2 etudiant etudiants 4096 jeu/
-r-sr-xr-x 1 etudiant etudiants 133792 le_binaire_du_jeu
-rw------- 1 etudiant etudiants 39 le_fichier_des_scores

Analyse:

Le binaire (r-sr-xr-x):

• Bit SUID activé (s à la place de x pour user)
• Tous peuvent l’exécuter (r-x pour group et others)
• Le jeu s’exécute avec les droits de etudiant
• Permet d’accéder au fichier des scores

Le fichier des scores (rw——-):

• Accessible en lecture/écriture uniquement par etudiant
• Autres utilisateurs ne peuvent ni lire ni écrire
• Protection des scores contre la triche

Logique:

• Les joueurs exécutent le binaire avec SUID
• Le programme s’exécute comme etudiant
• Il peut donc modifier le fichier des scores
• Mais les joueurs ne peuvent pas modifier directement les scores
• Empêche la triche tout en permettant le jeu

Commandes essentielles à maîtriser

Navigation et fichiers:

pwd, cd, ls, mkdir, rmdir, touch, cp, mv, rm, cat, more, less, head, tail

Permissions:

chmod, chown, chgrp, umask

Processus:

ps, top, kill, killall, bg, fg, jobs

Recherche:

find, locate, which, whereis, grep

Traitement texte:

grep, sed, awk, sort, uniq, wc, cut, tr

Système:

uname, hostname, whoami, who, w, df, du, free, date

Archivage:

tar, gzip, gunzip, zip, unzip

PART D: ANALYSE ET RÉFLEXION

Compétences acquises

Ligne de commande:

• Maîtrise des commandes essentielles Unix
• Navigation efficace dans le système de fichiers
• Gestion des fichiers et répertoires
• Utilisation de la documentation (man)

Scripting:

• Automatisation de tâches répétitives
• Programmation shell avec bash
• Structures de contrôle (boucles, conditions)
• Manipulation de variables et tableaux
• Traitement de fichiers texte

Administration système:

• Gestion des permissions et sécurité
• Gestion des processus
• Surveillance du système
• Archivage et sauvegarde

Outils avancés:

• Pipes et redirections pour combiner commandes
• Expressions régulières pour recherche
• Traitement de flux avec awk et sed
• Analyse de logs et fichiers

Applications pratiques

Unix/Linux est omniprésent dans l’informatique moderne:

Développement logiciel:

• Environnement de développement
• Compilation et build
• Gestion de versions (Git)
• Tests automatisés

Systèmes embarqués:

• Linux embarqué sur Raspberry Pi, BeagleBone
• Systèmes IoT
• Routeurs et équipements réseau
• Android (basé sur Linux)

Serveurs et Cloud:

• Serveurs web (Apache, Nginx)
• Bases de données (MySQL, PostgreSQL)
• Services cloud (AWS, Azure, GCP)
• Conteneurs (Docker, Kubernetes)

Administration système:

• Gestion de serveurs
• Automatisation (scripts, cron)
• Monitoring et logs
• Sauvegardes

DevOps:

• Déploiement continu (CI/CD)
• Automatisation d’infrastructure
• Configuration management (Ansible, Puppet)
• Orchestration de conteneurs

Liens avec autres cours

Méthodologie de travail

Apprentissage par la pratique:

La meilleure façon d’apprendre Unix est de pratiquer quotidiennement:

• Utiliser le terminal au lieu de l’interface graphique
• Écrire des scripts pour automatiser ses tâches
• Lire le man des commandes
• Expérimenter dans une VM pour éviter les erreurs

Ressources utiles:

• man commande: documentation intégrée
• commande --help: aide rapide
• /usr/share/doc: documentation détaillée
• StackOverflow et forums Linux
• Livres: “The Linux Command Line”, “Unix and Linux System Administration Handbook”

Bonnes pratiques:

Scripts:

• Toujours inclure le shebang
• Commenter son code
• Gérer les erreurs
• Tester avant déploiement

Sécurité:

• Principe du moindre privilège
• Éviter d’exécuter en root
• Vérifier les permissions
• Sauvegarder avant modifications importantes

Mon opinion

Ce cours est fondamental pour tout ingénieur informatique ou électronique.

Points forts:

• Compétences immédiatement applicables
• Universalité (Unix/Linux partout)
• Efficacité de la ligne de commande
• Automatisation puissante avec scripts

Importance professionnelle:

Unix/Linux est incontournable pour:

• Développement sur systèmes embarqués
• Administration de serveurs
• DevOps et Cloud
• IoT et objets connectés
• Intelligence artificielle (environnements de calcul)

Productivité:

Maîtriser la ligne de commande permet:

• Automatiser tâches répétitives (gain de temps)
• Traiter volumes importants de données
• Travailler sur systèmes distants (SSH)
• Scripter solutions sur mesure
• Diagnostiquer problèmes efficacement

Complémentarité avec autres compétences:

Unix s’intègre parfaitement avec:

• Programmation C/C++ (compilation, debugging)
• Développement web (serveurs, déploiement)
• Data science (traitement de données)
• Cybersécurité (analyse de logs, forensics)

Perspectives d’évolution

Technologies émergentes:

Conteneurs: Docker et Kubernetes utilisent intensivement Unix.

Edge Computing: Linux sur dispositifs embarqués.

Automatisation: Infrastructure as Code (Terraform, Ansible).

Cloud natif: Microservices sur Linux.

Conseils pratiques

Pour progresser:

1. Utiliser Linux comme système principal (dual-boot ou VM)
2. Personnaliser son environnement (bashrc, aliases)
3. Contribuer à des projets open-source
4. Installer un serveur personnel (web, NAS)
5. Automatiser ses tâches quotidiennes avec scripts

Erreurs à éviter:

• Ne jamais exécuter rm -rf / même par curiosité
• Toujours vérifier avant rm -rf
• Sauvegarder avant modifications système
• Tester scripts dans un environnement de test
• Lire la documentation avant utilisation

Bilan personnel: Ce cours a fourni les bases essentielles pour travailler efficacement en environnement Unix/Linux. La maîtrise de la ligne de commande et des scripts shell est une compétence transversale précieuse pour toute carrière en informatique ou électronique. Ces connaissances sont quotidiennement utiles, que ce soit pour le développement, l’administration système, ou le déploiement d’applications. La philosophie Unix (outils simples et combinables) reste d’actualité et influence de nombreux systèmes modernes.

📚 Documents de Cours

Voici les supports de cours en PDF pour approfondir le système Unix :