🐧 Introduction a Linux

Comprendre le systeme d'exploitation des professionnels

⏱ 5 min
Debutant

🎯 Objectifs d'apprentissage

  • Comprendre ce qu'est Linux et son histoire
  • Connaitre les avantages de Linux pour les serveurs
  • Identifier les principales distributions
  • Comprendre la philosophie Open Source
👨‍🎓
Conseil de Mentor (30 ans d'experience)

"J'ai commence ma carriere avec Unix en 1994. Aujourd'hui, Linux alimente plus de 90% des serveurs web mondiaux, tous les superordinateurs du TOP500, et la majorite des appareils IoT. Maitriser Linux n'est pas optionnel pour un architecte systeme - c'est fondamental."

📖 Qu'est-ce que Linux ?

Linux est un systeme d'exploitation open source cree en 1991 par Linus Torvalds, un etudiant finlandais. Il voulait un systeme UNIX-like gratuit pour son PC personnel.

💡
Definition cle: Systeme d'exploitation

Un systeme d'exploitation (OS) est le logiciel qui gere le materiel de l'ordinateur et fournit des services aux programmes. C'est l'intermediaire entre vous et la machine.

Techniquement, "Linux" designe uniquement le noyau (kernel). Un systeme Linux complet comprend:

  • Le Kernel Linux - Coeur du systeme, gere le materiel
  • GNU Tools - Utilitaires de base (ls, cp, grep...)
  • Shell - Interface en ligne de commande (Bash, Zsh)
  • Gestionnaire de paquets - Installation de logiciels
  • Interface graphique (optionnelle sur serveur)

📈 Pourquoi Linux domine les serveurs ?

Avantage Explication Impact
Gratuit Pas de licence a payer Economies massives
Stable Uptimes de plusieurs annees Moins de maintenance
Securise Peu de virus, mises a jour rapides Protection des donnees
Leger Fonctionne sans GUI Plus de ressources pour les apps
Flexible 100% configurable Adapte a tous les besoins
Open Source Code source visible Transparence, audit possible

📦 Les distributions Linux

Une distribution est un "package" complet de Linux avec des logiciels pre-configures. Voici les principales familles:

                         LINUX KERNEL
                              |
        +---------------------+---------------------+
        |                     |                     |
    DEBIAN                RED HAT               ARCH
        |                     |                     |
   +----+----+           +----+----+               |
   |         |           |         |               |
Ubuntu   Debian       RHEL      Fedora          Arch
   |                     |                     Manjaro
Mint                  CentOS
                      Rocky
                      AlmaLinux

Utilisation serveurs:
- RHEL/CentOS/Rocky: Entreprises (support commercial)
- Ubuntu Server: Cloud, startups
- Debian: Stabilite maximale
⭐
Pour ce cours

Nous utilisons RHEL/Rocky Linux car c'est le standard en entreprise. Les commandes sont similaires sur CentOS, AlmaLinux et Fedora. Les differences avec Debian/Ubuntu seront indiquees.

🧠 Verifiez votre comprehension

Quel pourcentage des serveurs web mondiaux utilisent Linux ?

A Environ 50%
B Environ 70%
C Plus de 90%
D 100%

📚 Points cles a retenir

  • Linux = Kernel cree par Linus Torvalds en 1991
  • Open Source = Code visible et modifiable
  • 90%+ des serveurs web utilisent Linux
  • RHEL/Rocky = Standard entreprise | Ubuntu = Cloud/Startups
  • Avantages: Gratuit, stable, securise, leger, flexible

🏗 Architecture Linux

Comprendre la structure interne du systeme

⏱ 10 min
Intermediaire

🎯 Objectifs d'apprentissage

  • Comprendre les couches d'un systeme Linux
  • Connaitre le role du Kernel
  • Maitriser le processus de demarrage (boot)
  • Comprendre Systemd et les runlevels

🔭 Les couches de Linux

+------------------------------------------------------------------+
|                      APPLICATIONS                                 |
|           (Firefox, Apache, MySQL, Docker, etc.)                  |
+------------------------------------------------------------------+
                              |
+------------------------------------------------------------------+
|                         SHELL                                     |
|              (Bash, Zsh, Fish, etc.)                              |
|        Interface entre l'utilisateur et le systeme               |
+------------------------------------------------------------------+
                              |
+------------------------------------------------------------------+
|                    GNU UTILITIES                                  |
|        (ls, cp, mv, grep, awk, sed, etc.)                         |
|              Outils standard Unix/Linux                           |
+------------------------------------------------------------------+
                              |
+------------------------------------------------------------------+
|                        KERNEL                                     |
|  +----------------+  +----------------+  +----------------+       |
|  | Process Mgmt   |  | Memory Mgmt    |  | Device Drivers |       |
|  | (processus)    |  | (memoire)      |  | (materiels)    |       |
|  +----------------+  +----------------+  +----------------+       |
|  +----------------+  +----------------+                           |
|  | File Systems   |  | Network Stack  |                           |
|  | (fichiers)     |  | (reseau)       |                           |
|  +----------------+  +----------------+                           |
+------------------------------------------------------------------+
                              |
+------------------------------------------------------------------+
|                       HARDWARE                                    |
|         (CPU, RAM, Disque, Carte reseau, etc.)                    |
+------------------------------------------------------------------+
💡
Le Kernel (Noyau)

Le kernel est le coeur de Linux. Il gere:
- Processus: Creation, planification, terminaison
- Memoire: Allocation RAM, swap, protection
- Drivers: Communication avec le materiel
- Fichiers: Lecture/ecriture sur disques
- Reseau: Pile TCP/IP, sockets

🔌 Processus de demarrage (Boot)

Quand vous allumez un serveur Linux, voici ce qui se passe:

SEQUENCE DE BOOT LINUX (UEFI + Systemd)

1. BIOS/UEFI
   |
   | POST (Power-On Self-Test)
   | Detecte le materiel
   v
2. BOOTLOADER (GRUB2)
   |
   | Charge le kernel en memoire
   | Passe les parametres boot
   v
3. KERNEL
   |
   | Initialise les drivers
   | Monte le filesystem racine
   | Lance le premier processus
   v
4. SYSTEMD (PID 1)
   |
   | Premier processus utilisateur
   | Gere tous les autres services
   v
5. SERVICES
   |
   | Reseau, SSH, HTTP, DB...
   v
6. LOGIN PROMPT
   |
   | Console ou interface graphique

Les composants du boot

Composant Role Fichiers cles
GRUB2 Bootloader - Charge le kernel /boot/grub2/grub.cfg
Kernel Noyau du systeme /boot/vmlinuz-*
Initramfs Systeme de fichiers temporaire /boot/initramfs-*
Systemd Gestionnaire de services /etc/systemd/system/

⚙ Systemd: Le chef d'orchestre

Systemd est le gestionnaire de systeme et de services moderne de Linux. Il remplace les anciens scripts init.d.

❌ Ancien systeme (SysV init)
  • Scripts shell sequentiels
  • Demarrage lent
  • Pas de gestion des dependances
  • Difficile a debugger
✅ Systemd (moderne)
  • Demarrage parallele
  • Gestion des dependances
  • Journalisation integree (journald)
  • Cgroups pour l'isolation

Commandes systemctl essentielles

Bash
# Voir le statut d'un service systemctl status nginx # Demarrer un service systemctl start nginx # Arreter un service systemctl stop nginx # Redemarrer un service systemctl restart nginx # Activer au demarrage systemctl enable nginx # Desactiver au demarrage systemctl disable nginx # Voir tous les services systemctl list-units --type=service # Voir les services en echec systemctl --failed
👨‍🎓
Experience de terrain

"En 30 ans, j'ai vu l'evolution de init.d vers Systemd. Certains puristes ont resiste au changement, mais Systemd a revolutionne la gestion des services. Aujourd'hui, comprendre systemctl est indispensable pour tout administrateur Linux."

🛠 Lab Pratique: Explorer le boot

Verifier la version du kernel
Terminal
uname -r # Resultat attendu: 5.14.0-284.el9.x86_64
Voir le temps depuis le dernier boot
Terminal
uptime # Exemple: 14:23:45 up 45 days, 3:22, 2 users, load average: 0.15, 0.10, 0.08
Lister les services actifs
Terminal
systemctl list-units --type=service --state=running
Voir les logs de boot
Terminal
journalctl -b # Affiche les logs depuis le dernier boot

🧠 Verifiez votre comprehension

Quel est le PID (Process ID) de Systemd ?

A PID 0
B PID 1
C PID 100
D Variable selon le systeme

📚 Points cles a retenir

  • Linux = Couches: Hardware -> Kernel -> Utilities -> Shell -> Apps
  • Boot: BIOS/UEFI -> GRUB2 -> Kernel -> Systemd -> Services
  • Systemd = PID 1, gestionnaire de services moderne
  • systemctl = commande pour gerer les services
  • journalctl = commande pour voir les logs

📁 Systeme de Fichiers Linux

Maitriser la hierarchie FHS

⏱ 8 min
Debutant

🎯 Objectifs d'apprentissage

  • Comprendre la structure FHS (Filesystem Hierarchy Standard)
  • Connaitre le role de chaque repertoire principal
  • Faire le parallele avec Windows
  • Naviguer efficacement dans l'arborescence

📌 Le Filesystem Hierarchy Standard (FHS)

Contrairement a Windows avec ses lettres de lecteur (C:, D:), Linux utilise une arborescence unique partant de la racine /.

/                           <-- Racine (root) - Point de depart UNIQUE
|
+-- /bin                    <-- Binaires essentiels (ls, cp, cat...)
|
+-- /boot                   <-- Fichiers de demarrage (kernel, grub)
|
+-- /dev                    <-- Fichiers de peripheriques (disques, terminals)
|
+-- /etc                    <-- Configuration systeme (nginx.conf, passwd)
|
+-- /home                   <-- Repertoires utilisateurs
|   +-- /azureuser          <-- Votre dossier personnel
|
+-- /lib, /lib64            <-- Bibliotheques partagees
|
+-- /opt                    <-- Applications optionnelles tierces
|   +-- /semarchy           <-- Notre application Semarchy!
|
+-- /proc                   <-- Systeme de fichiers virtuel (infos kernel)
|
+-- /root                   <-- Repertoire de l'admin root
|
+-- /sbin                   <-- Binaires systeme (fdisk, iptables)
|
+-- /tmp                    <-- Fichiers temporaires
|
+-- /usr                    <-- Programmes utilisateurs
|   +-- /bin                <-- Programmes supplementaires
|   +-- /local              <-- Installation locales
|
+-- /var                    <-- Donnees variables
    +-- /log                <-- Fichiers de logs
    +-- /lib                <-- Donnees d'applications (bases, etc.)
    +-- /www                <-- Sites web (parfois)

Comparaison Windows / Linux

Windows Linux Usage
C:\ / Racine du systeme
C:\Users\ /home/ Dossiers utilisateurs
C:\Program Files\ /usr/ ou /opt/ Applications
C:\Windows\System32\ /bin/, /sbin/ Binaires systeme
Panneau de configuration /etc/ Configuration
C:\Windows\Logs\ /var/log/ Fichiers de logs
⭐
Les repertoires les plus importants

En tant qu'administrateur, vous passerez 90% de votre temps dans:
/etc - Configuration
/var/log - Logs
/opt - Applications
/home - Vos fichiers

💾 Tout est fichier sous Linux

Une philosophie fondamentale de Linux: tout est represente comme un fichier.

Type Exemple Description
Fichier regulier /etc/passwd Fichier texte ou binaire classique
Repertoire /home/ Conteneur pour d'autres fichiers
Peripherique bloc /dev/sda Disque dur
Peripherique caractere /dev/tty Terminal
Lien symbolique /usr/bin/python -> python3 Raccourci vers un autre fichier
Socket /var/run/docker.sock Communication inter-processus

🛠 Lab Pratique: Explorer le systeme de fichiers

Voir l'arborescence
Terminal
# Lister la racine ls -la / # Si tree est installe tree -L 1 /
Trouver ou vous etes
Terminal
pwd # Print Working Directory # Resultat: /home/azureuser
Voir l'espace disque
Terminal
df -h # -h = human readable (GB, MB au lieu de bytes)
Voir la taille des dossiers
Terminal
du -sh /var/log # -s = summary, -h = human readable

📚 Points cles a retenir

  • / = racine unique (pas de C:, D: comme Windows)
  • /etc = configuration | /var/log = logs | /opt = apps
  • /home = dossiers utilisateurs
  • Tout est fichier sous Linux (meme les peripheriques)
  • pwd = ou suis-je | df -h = espace disque | du -sh = taille dossier

⌨ Commandes Linux Essentielles

Les 25 commandes que vous utiliserez tous les jours

⏱ 15 min
Intermediaire

🎯 Objectifs d'apprentissage

  • Maitriser les commandes de navigation
  • Gerer les fichiers et dossiers
  • Comprendre les pipes et redirections
  • Utiliser les commandes d'information systeme
👨‍🎓
Conseil de Mentor

"Ces 25 commandes representent 95% de ce que vous taperez au quotidien. Ne les memorisez pas toutes d'un coup - pratiquez-les une par une. Apres quelques semaines, elles deviendront des reflexes."

📌 Navigation

Navigation
# Ou suis-je ? pwd # Print Working Directory # Lister les fichiers ls # Liste simple ls -l # Liste detaillee ls -la # + fichiers caches ls -lh # + tailles lisibles ls -ltr # + tries par date # Changer de repertoire cd /opt/semarchy # Chemin absolu cd semarchy # Chemin relatif cd .. # Repertoire parent cd ~ # Home directory cd - # Repertoire precedent

📁 Gestion des fichiers

Fichiers
# Voir le contenu d'un fichier cat fichier.txt # Affiche tout le fichier less fichier.txt # Navigation page par page (q pour quitter) head -20 fichier.txt # 20 premieres lignes tail -20 fichier.txt # 20 dernieres lignes tail -f fichier.log # Suivre en temps reel # Copier, deplacer, supprimer cp source.txt dest.txt # Copier un fichier cp -r dossier/ backup/ # Copier un dossier (-r = recursif) mv ancien.txt nouveau.txt # Renommer/deplacer rm fichier.txt # Supprimer un fichier rm -rf dossier/ # Supprimer un dossier (ATTENTION!) # Creer touch nouveau.txt # Creer un fichier vide mkdir dossier # Creer un dossier mkdir -p a/b/c # Creer une arborescence
⚠
DANGER: rm -rf

La commande rm -rf supprime tout sans demander confirmation.
JAMAIS faire rm -rf / ou rm -rf * avec sudo!
Toujours verifier deux fois avant d'executer.

🔍 Recherche

Recherche
# Rechercher des fichiers find /opt -name "*.conf" # Par nom find /var/log -size +100M # Par taille (+100 MB) find / -type f -mtime -1 # Modifies dernieres 24h # Rechercher du texte dans les fichiers grep "error" fichier.log # Chercher "error" grep -i "error" fichier.log # Ignorer la casse grep -r "password" /etc/ # Recursif dans un dossier grep -n "error" fichier.log # Afficher les numeros de ligne # Localiser une commande which python # Chemin de l'executable whereis nginx # Chemin + man + source

🔁 Pipes et Redirections

L'une des forces de Linux: combiner des commandes simples pour faire des operations complexes.

PIPES (|) - Envoyer la sortie d'une commande vers une autre

commande1 | commande2 | commande3

Exemple:
cat access.log | grep "ERROR" | wc -l
    |              |            |
    |              |            +-- Compter les lignes
    |              +-- Filtrer les lignes avec "ERROR"
    +-- Lire le fichier


REDIRECTIONS - Envoyer vers/depuis des fichiers

>   Ecraser dans un fichier     echo "test" > fichier.txt
>>  Ajouter a un fichier        echo "test" >> fichier.txt
<   Lire depuis un fichier      mysql < script.sql
2>  Rediriger les erreurs       cmd 2> errors.log
&>  Sortie + erreurs            cmd &> output.log
Exemples pratiques
# Compter les erreurs dans un log grep -c "ERROR" /var/log/messages # Top 10 des IP dans un access log cat access.log | awk '{print $1}' | sort | uniq -c | sort -rn | head -10 # Trouver les 5 plus gros fichiers find /var -type f -exec du -h {} + | sort -rh | head -5 # Sauvegarder la liste des paquets installes rpm -qa > packages_installed.txt # Suivre un log et filtrer tail -f /var/log/messages | grep --line-buffered "nginx"

💻 Information systeme

Systeme
# Informations systeme uname -a # Infos kernel hostnamectl # Nom et OS uptime # Temps depuis le boot # Ressources free -h # Memoire disponible df -h # Espace disque top # Processus en temps reel (q pour quitter) htop # Version amelioree de top # Reseau ip addr # Adresses IP ss -tulpn # Ports en ecoute ping google.com # Test connectivite

🛠 Lab Pratique: Combiner les commandes

Scenario: Vous devez analyser les logs de connexion SSH.

Voir les tentatives de connexion echouees
Terminal
grep "Failed password" /var/log/secure | tail -20
Compter les echecs par IP
Terminal
grep "Failed password" /var/log/secure | \ awk '{print $(NF-3)}' | \ sort | uniq -c | \ sort -rn | head -10

📚 Aide-memoire des 25 commandes

CategorieCommandes
Navigationpwd, ls, cd
Fichierscat, less, head, tail, cp, mv, rm, touch, mkdir
Recherchefind, grep, which
Systemeuname, uptime, free, df, top
Reseauip, ss, ping
Outilssort, uniq, wc, awk

👥 Utilisateurs & Permissions

Gerer les acces et la securite du systeme

⏱ 15 min
Intermediaire

🎯 Objectifs d'apprentissage

  • Comprendre le modele de securite Linux (utilisateurs, groupes)
  • Gerer les utilisateurs avec useradd, usermod, userdel
  • Maitriser les permissions chmod et chown
  • Configurer sudo et le fichier sudoers
  • Utiliser les ACL pour des permissions avancees
👨‍🎓
Conseil de Mentor

"La securite Linux repose sur un principe simple: le moindre privilege. Chaque utilisateur et processus ne doit avoir que les permissions strictement necessaires. Maitrisez ce concept et vous eviterez 90% des failles de securite."

👤 Le modele de securite Linux

Linux utilise un modele de securite base sur trois concepts fondamentaux:

MODELE DE SECURITE LINUX

+------------------+     +------------------+     +------------------+
|   UTILISATEUR    |     |     GROUPE       |     |     AUTRES       |
|     (User)       |     |    (Group)       |     |    (Others)      |
+------------------+     +------------------+     +------------------+
        |                        |                        |
        v                        v                        v
   Proprietaire            Membres du groupe       Tous les autres
   du fichier              proprietaire            utilisateurs

Chaque fichier a:
- Un proprietaire (user)
- Un groupe proprietaire (group)
- Des permissions pour user/group/others

Fichiers de configuration des utilisateurs

Fichier Contenu Exemple
/etc/passwd Liste des utilisateurs azureuser:x:1000:1000::/home/azureuser:/bin/bash
/etc/shadow Mots de passe chiffres azureuser:$6$xxx...::0:99999:7:::
/etc/group Liste des groupes docker:x:988:azureuser
💡
Format de /etc/passwd

username:x:UID:GID:commentaire:home:shell
- UID: User ID (0=root, 1-999=systeme, 1000+=utilisateurs)
- GID: Group ID principal
- x: Mot de passe dans /etc/shadow

👷 Gestion des utilisateurs

Gestion utilisateurs
# Creer un utilisateur sudo useradd -m -s /bin/bash john # -m = creer le home directory # -s = specifier le shell # Creer avec plus d'options sudo useradd -m -s /bin/bash -c "John Doe" -G docker,wheel john # -c = commentaire (nom complet) # -G = groupes supplementaires # Definir le mot de passe sudo passwd john # Demande le nouveau mot de passe # Modifier un utilisateur sudo usermod -aG docker john # Ajouter au groupe docker sudo usermod -s /bin/zsh john # Changer le shell sudo usermod -L john # Verrouiller le compte sudo usermod -U john # Deverrouiller # Supprimer un utilisateur sudo userdel john # Garde le home sudo userdel -r john # Supprime aussi le home
⚠
Attention avec usermod -G

Sans l'option -a, usermod -G remplace tous les groupes!
Toujours utiliser usermod -aG (append) pour ajouter a un groupe.

👥 Gestion des groupes

Gestion groupes
# Creer un groupe sudo groupadd developers # Ajouter un utilisateur a un groupe sudo usermod -aG developers john # Voir les groupes d'un utilisateur groups john id john # Lister les membres d'un groupe getent group docker # Supprimer un groupe sudo groupdel developers # Changer le groupe principal sudo usermod -g developers john

🔒 Permissions Linux (chmod)

Chaque fichier a 3 types de permissions pour 3 categories:

LECTURE DES PERMISSIONS (ls -l)

-rwxr-xr-x  1  root  root  4096  Jan 15 10:30  script.sh
|___|___|___
  |   |   |
  |   |   +-- Others (autres): r-x = lecture + execution
  |   +------ Group (groupe):  r-x = lecture + execution
  +---------- User (proprio):  rwx = lecture + ecriture + execution

SIGNIFICATION:
r (read)    = 4  = Lire le fichier / Lister le dossier
w (write)   = 2  = Modifier le fichier / Creer dans le dossier
x (execute) = 1  = Executer le script / Entrer dans le dossier
- (aucun)   = 0  = Permission refusee

Notation numerique (octale)

Permission Binaire Octal Signification
---0000Aucune permission
--x0011Execution seule
-w-0102Ecriture seule
-wx0113Ecriture + Execution
r--1004Lecture seule
r-x1015Lecture + Execution
rw-1106Lecture + Ecriture
rwx1117Toutes les permissions
chmod - Changer les permissions
# Notation octale (la plus courante) chmod 755 script.sh # rwxr-xr-x (executable par tous) chmod 644 config.txt # rw-r--r-- (lisible par tous) chmod 600 secret.key # rw------- (prive) chmod 700 ~/bin # rwx------ (dossier prive) # Notation symbolique chmod u+x script.sh # Ajouter execution pour user chmod g-w fichier.txt # Retirer ecriture pour group chmod o-rwx secret.txt # Retirer tout pour others chmod a+r fichier.txt # Ajouter lecture pour all # Recursif sur un dossier chmod -R 755 /var/www/html
💡
Permissions communes

755 = Scripts executables, dossiers
644 = Fichiers de configuration
600 = Fichiers secrets (cles SSH, mots de passe)
700 = Dossiers prives

👤 Propriete (chown)

chown - Changer le proprietaire
# Changer le proprietaire sudo chown john fichier.txt # Changer proprietaire ET groupe sudo chown john:developers fichier.txt # Changer seulement le groupe sudo chown :developers fichier.txt # ou sudo chgrp developers fichier.txt # Recursif sudo chown -R www-data:www-data /var/www/html

🔐 Sudo et sudoers

sudo permet d'executer des commandes avec les privileges root sans se connecter en root.

Configuration sudo
# Executer une commande en root sudo systemctl restart nginx # Ouvrir un shell root sudo -i # Executer en tant qu'autre utilisateur sudo -u postgres psql # Editer le fichier sudoers (TOUJOURS avec visudo!) sudo visudo
⭐
Fichier /etc/sudoers

Syntaxe: utilisateur machine=(run_as) commandes

Exemples:
root ALL=(ALL) ALL - root peut tout faire
%wheel ALL=(ALL) ALL - groupe wheel peut tout faire
john ALL=(ALL) NOPASSWD: /bin/systemctl - john peut utiliser systemctl sans mot de passe

Ajouter un utilisateur aux sudoers
# Methode 1: Ajouter au groupe wheel (RHEL) ou sudo (Debian) sudo usermod -aG wheel john # RHEL/CentOS/Rocky sudo usermod -aG sudo john # Debian/Ubuntu # Methode 2: Fichier dans /etc/sudoers.d/ echo "john ALL=(ALL) NOPASSWD: ALL" | sudo tee /etc/sudoers.d/john sudo chmod 440 /etc/sudoers.d/john

📋 ACL (Access Control Lists)

Les ACL permettent des permissions plus fines que le modele user/group/others.

ACL - Permissions avancees
# Voir les ACL d'un fichier getfacl fichier.txt # Donner acces en lecture a un utilisateur specifique setfacl -m u:john:r fichier.txt # Donner acces a un groupe specifique setfacl -m g:developers:rw fichier.txt # ACL par defaut pour un dossier (heritees par nouveaux fichiers) setfacl -d -m u:john:rwx /shared # Supprimer une ACL setfacl -x u:john fichier.txt # Supprimer toutes les ACL setfacl -b fichier.txt

🛠 Lab Pratique: Gestion des utilisateurs

Creer un utilisateur developpeur
Terminal
sudo useradd -m -s /bin/bash -c "Dev User" devuser sudo passwd devuser id devuser
Creer un dossier projet partage
Terminal
sudo mkdir /opt/projet sudo groupadd projet sudo chown root:projet /opt/projet sudo chmod 775 /opt/projet sudo usermod -aG projet devuser sudo usermod -aG projet azureuser
Verifier les permissions
Terminal
ls -la /opt/projet groups devuser getfacl /opt/projet

🧠 Verifiez votre comprehension

Quelle permission octale correspond a "rw-r--r--" ?

A 755
B 644
C 600
D 777

📚 Points cles a retenir

  • Utilisateurs: useradd, usermod -aG, userdel
  • Groupes: groupadd, /etc/group
  • Permissions: r=4, w=2, x=1 | 755=rwxr-xr-x, 644=rw-r--r--
  • Propriete: chown user:group fichier
  • Sudo: ajouter au groupe wheel (RHEL) ou sudo (Debian)
  • ACL: setfacl/getfacl pour permissions avancees

📦 Gestion des Paquets

Installer, mettre a jour et gerer les logiciels

⏱ 12 min
Intermediaire

🎯 Objectifs d'apprentissage

  • Comprendre les gestionnaires de paquets Linux
  • Maitriser DNF/YUM (RHEL) et APT (Debian)
  • Gerer les repositories
  • Effectuer des mises a jour systeme
👨‍🎓
Conseil de Mentor

"Les mises a jour regulieres sont cruciales pour la securite. En production, je recommande de planifier des fenetres de maintenance mensuelles pour les patchs. Toujours tester sur un environnement de dev/staging avant la prod!"

📦 Les gestionnaires de paquets

Un gestionnaire de paquets automatise l'installation, la mise a jour et la suppression des logiciels.

ECOSYSTEME DES PAQUETS LINUX

+------------------+                    +------------------+
|   Famille RHEL   |                    |  Famille Debian  |
+------------------+                    +------------------+
| Format: .rpm     |                    | Format: .deb     |
| Outil bas: rpm   |                    | Outil bas: dpkg  |
| Outil haut: dnf  |                    | Outil haut: apt  |
| (ancien: yum)    |                    |                  |
+------------------+                    +------------------+
        |                                       |
        v                                       v
+------------------+                    +------------------+
| RHEL, Rocky,     |                    | Debian, Ubuntu,  |
| CentOS, Fedora,  |                    | Linux Mint       |
| AlmaLinux        |                    |                  |
+------------------+                    +------------------+

Notre VM: Rocky Linux = DNF

💻 DNF - Commandes essentielles (RHEL/Rocky)

DNF - Recherche et info
# Rechercher un paquet dnf search nginx # Informations sur un paquet dnf info nginx # Lister les paquets installes dnf list installed # Lister les paquets disponibles dnf list available | grep docker # Voir quel paquet fournit un fichier dnf provides /usr/bin/vim
DNF - Installation et suppression
# Installer un paquet sudo dnf install nginx # Installer sans confirmation sudo dnf install -y nginx # Installer plusieurs paquets sudo dnf install -y vim htop wget curl # Reinstaller un paquet sudo dnf reinstall nginx # Supprimer un paquet sudo dnf remove nginx # Supprimer un paquet + dependances inutilisees sudo dnf autoremove nginx
DNF - Mises a jour
# Verifier les mises a jour disponibles dnf check-update # Mettre a jour tous les paquets sudo dnf update -y # Mettre a jour un paquet specifique sudo dnf update nginx # Mises a jour de securite uniquement sudo dnf update --security # Voir l'historique des transactions dnf history # Annuler une transaction (rollback) sudo dnf history undo 15

📂 Gestion des repositories

Les repositories sont des serveurs contenant les paquets disponibles.

Repositories
# Lister les repos actives dnf repolist # Lister tous les repos (actives et desactivees) dnf repolist all # Activer un repo sudo dnf config-manager --enable epel # Desactiver un repo sudo dnf config-manager --disable epel # Ajouter le repo EPEL (Extra Packages for Enterprise Linux) sudo dnf install -y epel-release # Nettoyer le cache sudo dnf clean all
💡
EPEL - Un repo indispensable

EPEL (Extra Packages for Enterprise Linux) contient des milliers de paquets supplementaires non inclus dans RHEL/Rocky. Essentiel pour htop, certbot, et bien d'autres.

📄 Comparaison DNF / APT

Action DNF (RHEL/Rocky) APT (Debian/Ubuntu)
Installer dnf install nginx apt install nginx
Supprimer dnf remove nginx apt remove nginx
Mettre a jour la liste dnf check-update apt update
Mettre a jour les paquets dnf update apt upgrade
Rechercher dnf search nginx apt search nginx
Infos paquet dnf info nginx apt show nginx

📦 RPM - Gestion bas niveau

RPM - Commandes directes
# Installer un .rpm telecharge sudo rpm -ivh package.rpm # -i = install, -v = verbose, -h = progress bar # Lister tous les paquets installes rpm -qa # Rechercher un paquet installe rpm -qa | grep nginx # Infos sur un paquet installe rpm -qi nginx # Lister les fichiers d'un paquet rpm -ql nginx # Trouver quel paquet a installe un fichier rpm -qf /usr/bin/vim

🛠 Lab Pratique: Gestion des paquets

Installer EPEL et htop
Terminal
sudo dnf install -y epel-release sudo dnf install -y htop htop # q pour quitter
Verifier les mises a jour de securite
Terminal
dnf updateinfo list security dnf updateinfo summary
Explorer l'historique DNF
Terminal
dnf history dnf history info 1

🧠 Verifiez votre comprehension

Quelle commande installe un paquet sans demander de confirmation?

A dnf install nginx
B dnf install -y nginx
C dnf add nginx
D dnf get nginx

📚 Points cles a retenir

  • DNF = gestionnaire de paquets pour RHEL/Rocky/CentOS
  • APT = gestionnaire pour Debian/Ubuntu
  • dnf install -y, dnf update, dnf remove
  • EPEL = repo supplementaire indispensable
  • rpm -qa = lister tous les paquets installes
  • dnf history = voir et annuler les transactions

⚙ Services & Systemd

Gerer les services et le demarrage du systeme

⏱ 12 min
Intermediaire

🎯 Objectifs d'apprentissage

  • Maitriser systemctl pour gerer les services
  • Comprendre les units systemd
  • Analyser les logs avec journalctl
  • Creer un service personnalise

⚙ Systemd en detail

Systemd est le gestionnaire de systeme et de services moderne. Il gere:

  • Le demarrage du systeme
  • Les services (daemons)
  • Les montages de disques
  • Les timers (cron moderne)
  • Les logs (journald)

Types d'units systemd

Type Extension Usage
Service .service Daemons (nginx, docker, sshd)
Socket .socket Activation par socket
Timer .timer Taches planifiees
Mount .mount Points de montage
Target .target Groupes d'units (multi-user, graphical)

💻 Commandes systemctl

Gestion des services
# Statut d'un service systemctl status nginx systemctl status docker # Demarrer / Arreter / Redemarrer sudo systemctl start nginx sudo systemctl stop nginx sudo systemctl restart nginx # Recharger la config (sans restart) sudo systemctl reload nginx # Activer au demarrage sudo systemctl enable nginx # Desactiver au demarrage sudo systemctl disable nginx # Activer ET demarrer en une commande sudo systemctl enable --now nginx
Analyse du systeme
# Lister tous les services systemctl list-units --type=service # Services actifs uniquement systemctl list-units --type=service --state=running # Services en echec systemctl --failed # Voir les dependances d'un service systemctl list-dependencies nginx # Analyser le temps de boot systemd-analyze systemd-analyze blame # Temps par service

📋 Anatomie d'un fichier .service

/etc/systemd/system/mon-app.service
[Unit] Description=Mon Application Web Documentation=https://example.com/docs After=network.target # Demarre apres le reseau Wants=docker.service # Souhaite que docker soit la [Service] Type=simple # simple, forking, oneshot, notify User=www-data # Utilisateur d'execution Group=www-data WorkingDirectory=/opt/mon-app ExecStart=/opt/mon-app/start.sh ExecStop=/opt/mon-app/stop.sh Restart=on-failure # Redemarre en cas d'echec RestartSec=5 # Delai avant restart [Install] WantedBy=multi-user.target # Active en mode multi-utilisateur
💡
Apres modification d'un service

Toujours executer sudo systemctl daemon-reload apres avoir modifie un fichier .service pour que systemd recharge la configuration.

📜 Journalctl - Les logs systemd

Journalctl
# Tous les logs journalctl # Logs d'un service specifique journalctl -u nginx journalctl -u docker # Suivre en temps reel journalctl -f journalctl -u nginx -f # Logs depuis le dernier boot journalctl -b # Logs des dernieres heures/minutes journalctl --since "1 hour ago" journalctl --since "2024-01-15 10:00" --until "2024-01-15 12:00" # Logs d'erreur uniquement journalctl -p err # Espace utilise par les logs journalctl --disk-usage # Nettoyer les anciens logs sudo journalctl --vacuum-time=7d

🛠 Lab Pratique: Creer un service

Creer un script simple
Terminal
sudo tee /opt/mon-service.sh > /dev/null << 'EOF' #!/bin/bash while true; do echo "$(date): Service actif" >> /var/log/mon-service.log sleep 60 done EOF sudo chmod +x /opt/mon-service.sh
Creer le fichier service
Terminal
sudo tee /etc/systemd/system/mon-service.service > /dev/null << 'EOF' [Unit] Description=Mon Service de Test [Service] ExecStart=/opt/mon-service.sh Restart=always [Install] WantedBy=multi-user.target EOF
Activer et tester
Terminal
sudo systemctl daemon-reload sudo systemctl start mon-service systemctl status mon-service journalctl -u mon-service -f

📚 Points cles a retenir

  • systemctl start/stop/restart/status SERVICE
  • systemctl enable --now = activer + demarrer
  • journalctl -u SERVICE -f = logs en temps reel
  • daemon-reload apres modification de .service
  • Services dans /etc/systemd/system/

📈 Processus & Performance

Surveiller et optimiser le systeme

⏱ 12 min
Intermediaire

🎯 Objectifs d'apprentissage

  • Comprendre les processus Linux
  • Utiliser ps, top, htop pour surveiller
  • Gerer les processus (kill, nice)
  • Analyser les ressources systeme

⚙ Qu'est-ce qu'un processus?

Un processus est une instance d'un programme en cours d'execution. Chaque processus a:

  • PID - Process ID unique
  • PPID - Parent Process ID
  • UID - Utilisateur proprietaire
  • Etat - Running, Sleeping, Stopped, Zombie
HIERARCHIE DES PROCESSUS

systemd (PID 1)
    |
    +-- sshd
    |     +-- sshd (session)
    |           +-- bash
    |                 +-- vim
    |                 +-- ps
    |
    +-- dockerd
    |     +-- containerd
    |           +-- container1
    |           +-- container2
    |
    +-- nginx (master)
          +-- nginx (worker)
          +-- nginx (worker)

💻 Commandes de surveillance

ps - Snapshot des processus
# Processus de l'utilisateur courant ps # Tous les processus (format standard) ps aux # Tous les processus (format complet) ps -ef # Processus d'un utilisateur ps -u azureuser # Arbre des processus ps auxf pstree # Filtrer par nom ps aux | grep nginx pgrep -l nginx
top / htop - Temps reel
# Moniteur en temps reel top # Raccourcis dans top: # q = quitter # M = trier par memoire # P = trier par CPU # k = tuer un processus # htop (version amelioree) htop # F6 = trier, F9 = kill, F10 = quitter

💣 Gestion des processus

Signaux et kill
# Terminer proprement (SIGTERM) kill 1234 kill -15 1234 # Forcer l'arret (SIGKILL) kill -9 1234 # Tuer par nom pkill nginx killall nginx # Recharger la config (SIGHUP) kill -1 1234 # Lister les signaux kill -l
Signal Numero Action
SIGTERM 15 Terminaison propre (defaut)
SIGKILL 9 Force l'arret (ne peut pas etre ignore)
SIGHUP 1 Recharge la configuration
SIGSTOP 19 Suspend le processus
SIGCONT 18 Reprend le processus

📈 Ressources systeme

Surveillance ressources
# Memoire free -h # total used free shared buff/cache available # Mem: 15Gi 8.2Gi 1.1Gi 234Mi 6.1Gi 6.5Gi # CPU lscpu # Infos CPU mpstat 1 5 # Stats CPU toutes les 1s, 5 fois # Disque I/O iostat -xz 1 5 # Stats disque iotop # I/O par processus # Charge systeme uptime # load average: 0.15, 0.10, 0.08 # = moyenne 1min, 5min, 15min # Ideal: < nombre de CPUs # Resume complet vmstat 1 5 # Virtual memory stats
💡
Comprendre le Load Average

Le load average represente le nombre moyen de processus en attente de CPU.
- Sur 4 CPUs, un load de 4.0 = 100% utilisation
- Un load de 8.0 sur 4 CPUs = surcharge (processus en file d'attente)

📚 Points cles a retenir

  • ps aux = liste tous les processus
  • top/htop = surveillance temps reel
  • kill -15 (propre) vs kill -9 (force)
  • free -h = memoire, df -h = disque
  • Load average doit etre < nombre de CPUs

💾 Stockage & LVM

Gerer les disques et les volumes

⏱ 15 min
Avance

🎯 Objectifs d'apprentissage

  • Comprendre les partitions et systemes de fichiers
  • Utiliser LVM pour la gestion flexible des volumes
  • Monter et demonter des disques
  • Surveiller l'espace disque

💾 Architecture du stockage

HIERARCHIE DU STOCKAGE LINUX

Disque physique (/dev/sda, /dev/nvme0n1)
    |
    +-- Partition 1 (/dev/sda1) --> /boot (500M)
    |
    +-- Partition 2 (/dev/sda2) --> LVM
            |
            +-- Volume Group (vg_data)
                    |
                    +-- Logical Volume (lv_root) --> /
                    +-- Logical Volume (lv_home) --> /home
                    +-- Logical Volume (lv_var)  --> /var

💻 Commandes de base

Informations disques
# Lister les disques lsblk fdisk -l # Espace disque utilise df -h # Taille des dossiers du -sh /var/* du -sh /* 2>/dev/null | sort -h # Trouver les gros fichiers find / -type f -size +100M 2>/dev/null # Points de montage mount | grep "^/dev" cat /etc/fstab

📦 LVM - Logical Volume Manager

LVM permet de gerer les disques de facon flexible: agrandir, reduire, deplacer sans demonter.

Concept Commandes Description
Physical Volume (PV) pvcreate, pvs, pvdisplay Disque ou partition physique
Volume Group (VG) vgcreate, vgs, vgdisplay Pool de stockage (1+ PV)
Logical Volume (LV) lvcreate, lvs, lvdisplay Volume utilisable (comme partition)
Commandes LVM
# Voir l'etat LVM pvs # Physical Volumes vgs # Volume Groups lvs # Logical Volumes # Details pvdisplay vgdisplay lvdisplay # Agrandir un volume logique sudo lvextend -L +10G /dev/vg_data/lv_var # ou utiliser tout l'espace libre sudo lvextend -l +100%FREE /dev/vg_data/lv_var # Agrandir le filesystem apres lvextend sudo resize2fs /dev/vg_data/lv_var # ext4 sudo xfs_growfs /var # xfs

📂 Montage des disques

Montage
# Monter temporairement sudo mount /dev/sdb1 /mnt/data # Demonter sudo umount /mnt/data # Montage permanent (editer /etc/fstab) # Format: device mountpoint type options dump pass /dev/sdb1 /mnt/data ext4 defaults 0 2 # Tester fstab sans reboot sudo mount -a

📚 Points cles a retenir

  • lsblk, df -h = voir les disques
  • LVM: PV -> VG -> LV
  • lvextend + resize2fs/xfs_growfs pour agrandir
  • /etc/fstab = montages permanents

💻 Introduction au Bash

Le langage de script du sysadmin

⏱ 10 min
Debutant

🎯 Objectifs d'apprentissage

  • Comprendre ce qu'est Bash et son utilite
  • Ecrire votre premier script
  • Comprendre le shebang et l'execution
  • Maitriser les bonnes pratiques
👨‍🎓
Conseil de Mentor

"Bash est votre meilleur ami pour automatiser les taches repetitives. En 30 ans, j'ai ecrit des milliers de scripts. Commencez simple - meme un script de 5 lignes qui vous fait gagner 2 minutes par jour represente 12 heures par an!"

💡 Qu'est-ce que Bash?

Bash (Bourne Again SHell) est:

  • Un interpreteur de commandes (le terminal que vous utilisez)
  • Un langage de script pour automatiser des taches
  • Le shell par defaut sur la plupart des distributions Linux

📄 Votre premier script

mon-premier-script.sh
#!/bin/bash # Mon premier script Bash # Auteur: Votre nom # Date: 2024 echo "Bonjour, je suis un script Bash!" echo "Nous sommes le $(date)" echo "Vous etes connecte en tant que: $USER" echo "Sur la machine: $(hostname)"

Execution du script

Terminal
# Methode 1: Rendre executable puis lancer chmod +x mon-premier-script.sh ./mon-premier-script.sh # Methode 2: Appeler bash directement bash mon-premier-script.sh
💡
Le Shebang (#!)

#!/bin/bash est le "shebang". Il indique au systeme quel interpreteur utiliser.
- #!/bin/bash = Script Bash
- #!/usr/bin/python3 = Script Python
- #!/bin/sh = Shell POSIX (plus portable)

✅ Bonnes pratiques

Template de script robuste
#!/bin/bash #=============================================== # Script: backup.sh # Description: Sauvegarde des fichiers importants # Auteur: Votre nom # Version: 1.0 #=============================================== # Options de securite set -e # Arrete si une commande echoue set -u # Erreur si variable non definie set -o pipefail # Erreur si un pipe echoue # Variables readonly SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" readonly LOG_FILE="/var/log/backup.log" # Fonctions log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE" } # Script principal main() { log "Demarrage du script" # Votre code ici log "Fin du script" } # Point d'entree main "$@"
⚠
set -e : Votre filet de securite

Sans set -e, un script continue meme si une commande echoue. Avec, il s'arrete immediatement. Indispensable en production!

📚 Points cles a retenir

  • Shebang #!/bin/bash en premiere ligne
  • chmod +x pour rendre executable
  • set -euo pipefail pour la robustesse
  • Commenter et documenter vos scripts

📋 Variables Bash

Stocker et manipuler des donnees

⏱ 12 min
Intermediaire

🎯 Objectifs d'apprentissage

  • Declarer et utiliser des variables
  • Comprendre les variables d'environnement
  • Maitriser les substitutions de commandes
  • Manipuler les chaines de caracteres

📋 Declaration de variables

Variables de base
# Declaration (PAS d'espace autour du =) nom="Jean" age=30 fichier="/etc/passwd" # Utilisation (avec $) echo "Bonjour $nom" echo "Age: $age ans" # Accolades pour delimiter echo "Fichier: ${fichier}.backup" # Variable en lecture seule readonly CONFIG="/etc/app.conf" # Variable locale (dans une fonction) local temp="valeur"
⚠
Erreur classique

nom = "Jean" est FAUX! Pas d'espaces autour du =
Correct: nom="Jean"

🌐 Variables d'environnement

Variables d'environnement
# Variables predefinies echo $USER # Utilisateur courant echo $HOME # Repertoire home echo $PWD # Repertoire courant echo $PATH # Chemins des executables echo $SHELL # Shell actuel echo $HOSTNAME # Nom de la machine # Variables speciales de script echo $0 # Nom du script echo $1 # Premier argument echo $2 # Deuxieme argument echo $# # Nombre d'arguments echo $@ # Tous les arguments echo $? # Code retour derniere commande echo $$ # PID du script # Exporter une variable (visible par sous-processus) export MA_VAR="valeur"

🔄 Substitution de commandes

Substitution
# Stocker le resultat d'une commande date_actuelle=$(date) nb_fichiers=$(ls | wc -l) ip_locale=$(hostname -I | awk '{print $1}') echo "Date: $date_actuelle" echo "Nombre de fichiers: $nb_fichiers" echo "IP: $ip_locale" # Ancienne syntaxe (moins lisible) date_old=`date`

🔧 Manipulation de chaines

Operations sur chaines
fichier="/home/user/documents/rapport.pdf" # Longueur echo ${#fichier} # 33 # Extraction (substring) echo ${fichier:0:5} # /home echo ${fichier: -3} # pdf (3 derniers) # Remplacement echo ${fichier/pdf/txt} # rapport.txt echo ${fichier//o/O} # Remplace tous les o # Extraction de chemins echo ${fichier##*/} # rapport.pdf (basename) echo ${fichier%/*} # /home/user/documents (dirname) # Valeur par defaut echo ${var:-"defaut"} # "defaut" si var vide echo ${var:="defaut"} # Assigne "defaut" si var vide

🔢 Tableaux

Tableaux Bash
# Declaration serveurs=("web1" "web2" "db1" "db2") # Acces echo ${serveurs[0]} # web1 echo ${serveurs[2]} # db1 echo ${serveurs[@]} # Tous les elements echo ${#serveurs[@]} # Nombre d'elements (4) # Ajout serveurs+=("cache1") # Boucle sur tableau for srv in "${serveurs[@]}"; do echo "Serveur: $srv" done

📚 Points cles a retenir

  • Pas d'espace autour de = : nom="valeur"
  • $VAR ou ${VAR} pour utiliser
  • $(commande) pour substitution
  • $1, $2, $@ pour les arguments
  • $? = code retour (0 = succes)

🔀 Conditions & Boucles

Controler le flux d'execution

⏱ 15 min
Intermediaire

🎯 Objectifs d'apprentissage

  • Maitriser if/elif/else
  • Comprendre les operateurs de test
  • Utiliser les boucles for, while, until
  • Controler les boucles avec break et continue

🔀 Conditions if/else

Structure if
# Syntaxe de base if [ condition ]; then echo "Condition vraie" elif [ autre_condition ]; then echo "Autre condition vraie" else echo "Aucune condition vraie" fi # Exemple pratique if [ -f "/etc/passwd" ]; then echo "Le fichier existe" else echo "Le fichier n'existe pas" fi

Operateurs de test

Type Operateur Signification
Fichiers-f fichierFichier existe et est regulier
-d dossierDossier existe
-r fichierFichier lisible
-w fichierFichier modifiable
Chaines-z "$var"Variable vide
-n "$var"Variable non vide
"$a" = "$b"Chaines egales
Nombres$a -eq $bEgal (equal)
$a -ne $bDifferent (not equal)
$a -lt $bPlus petit (less than)
$a -gt $bPlus grand (greater than)
Exemples de tests
# Test de fichier if [ -f "$config_file" ] && [ -r "$config_file" ]; then source "$config_file" fi # Test de nombre if [ "$count" -gt 10 ]; then echo "Plus de 10 elements" fi # Test de chaine if [ -z "$username" ]; then echo "Erreur: username non defini" exit 1 fi # Operateurs logiques if [ "$age" -ge 18 ] && [ "$age" -lt 65 ]; then echo "Adulte actif" fi # Double crochet (plus moderne) if [[ "$nom" == *"admin"* ]]; then echo "C'est un admin" fi

🔄 Boucle for

Boucles for
# Liste de valeurs for serveur in web1 web2 db1; do echo "Ping $serveur" ping -c 1 "$serveur" &>/dev/null && echo "OK" || echo "FAIL" done # Fichiers dans un dossier for fichier in /var/log/*.log; do echo "Traitement de $fichier" done # Sequence de nombres for i in {1..10}; do echo "Iteration $i" done # Style C for ((i=0; i<10; i++)); do echo "Index: $i" done # Lire un fichier ligne par ligne while IFS= read -r ligne; do echo "Ligne: $ligne" done < fichier.txt

🔁 Boucles while et until

while et until
# While: tant que condition vraie count=0 while [ $count -lt 5 ]; do echo "Count: $count" ((count++)) done # Attendre qu'un service demarre while ! systemctl is-active --quiet nginx; do echo "En attente de nginx..." sleep 2 done echo "Nginx est actif!" # Until: jusqu'a ce que condition vraie until [ -f "/tmp/ready.flag" ]; do echo "En attente du fichier..." sleep 1 done # Break et continue for i in {1..100}; do [ $i -eq 5 ] && continue # Saute l'iteration 5 [ $i -eq 10 ] && break # Arrete a 10 echo $i done

📚 Points cles a retenir

  • [ condition ] avec espaces obligatoires
  • -f (fichier), -d (dossier), -z (vide)
  • -eq, -ne, -lt, -gt pour nombres
  • for item in liste; do ... done
  • while [ condition ]; do ... done

🛠 Fonctions Bash

Organiser et reutiliser le code

⏱ 12 min
Intermediaire

🎯 Objectifs d'apprentissage

  • Creer et appeler des fonctions
  • Passer des parametres
  • Retourner des valeurs
  • Gerer la portee des variables

🛠 Syntaxe des fonctions

Declaration de fonctions
# Syntaxe 1 (recommandee) ma_fonction() { echo "Hello depuis ma fonction" } # Syntaxe 2 function autre_fonction { echo "Autre syntaxe" } # Appel ma_fonction autre_fonction

📥 Parametres et retours

Parametres de fonction
# Fonction avec parametres saluer() { local nom="$1" # Premier parametre local age="$2" # Deuxieme parametre echo "Bonjour $nom, vous avez $age ans" } # Appel saluer "Jean" 30 # Tous les parametres afficher_args() { echo "Nombre d'arguments: $#" echo "Tous les arguments: $@" for arg in "$@"; do echo "- $arg" done } afficher_args un deux trois
Valeurs de retour
# Code de retour (0 = succes, autre = erreur) fichier_existe() { local fichier="$1" if [ -f "$fichier" ]; then return 0 # Succes else return 1 # Echec fi } if fichier_existe "/etc/passwd"; then echo "Le fichier existe" fi # Retourner une valeur (via echo) calculer() { local a="$1" local b="$2" echo $((a + b)) # "Retourne" la somme } resultat=$(calculer 5 3) echo "5 + 3 = $resultat"

🎯 Exemple complet

Script avec fonctions
#!/bin/bash set -euo pipefail # Variables globales LOG_FILE="/var/log/mon-script.log" # Fonction de log log() { local level="$1" shift echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$level] $*" | tee -a "$LOG_FILE" } # Fonction de verification check_root() { if [ "$(id -u)" -ne 0 ]; then log "ERROR" "Ce script doit etre execute en root" exit 1 fi } # Fonction de backup backup_file() { local source="$1" local dest="${source}.backup.$(date +%Y%m%d)" if [ -f "$source" ]; then cp "$source" "$dest" log "INFO" "Backup cree: $dest" return 0 else log "WARN" "Fichier source introuvable: $source" return 1 fi } # Main main() { log "INFO" "Demarrage du script" check_root backup_file "/etc/nginx/nginx.conf" log "INFO" "Script termine" } main "$@"

📚 Points cles a retenir

  • nom_fonction() { ... } pour declarer
  • $1, $2, $@ pour les parametres
  • local var="valeur" pour variables locales
  • return 0/1 pour code de retour
  • echo pour "retourner" une valeur

📄 Grep, Sed, Awk

Les outils de traitement de texte

⏱ 15 min
Avance

🎯 Objectifs d'apprentissage

  • Maitriser grep pour la recherche
  • Utiliser sed pour la substitution
  • Comprendre awk pour le traitement avance
  • Combiner ces outils efficacement
👨‍🎓
Conseil de Mentor

"Grep, Sed et Awk sont les 'trois mousquetaires' du traitement de texte sous Linux. Maitrisez-les et vous pourrez analyser n'importe quel fichier de log ou de config en quelques secondes."

🔍 Grep - Recherche de motifs

Grep essentials
# Recherche simple grep "error" /var/log/messages # Ignorer la casse grep -i "error" /var/log/messages # Afficher les numeros de ligne grep -n "error" /var/log/messages # Compter les occurrences grep -c "error" /var/log/messages # Recherche recursive grep -r "password" /etc/ # Inverser (lignes sans le motif) grep -v "debug" /var/log/app.log # Regex etendue grep -E "error|warning|critical" /var/log/messages # Contexte (lignes avant/apres) grep -A 3 -B 2 "exception" app.log

📝 Sed - Editeur de flux

Sed essentials
# Substitution simple (premiere occurrence) sed 's/ancien/nouveau/' fichier.txt # Substitution globale (toutes les occurrences) sed 's/ancien/nouveau/g' fichier.txt # Modifier le fichier en place sed -i 's/ancien/nouveau/g' fichier.txt # Backup avant modification sed -i.bak 's/ancien/nouveau/g' fichier.txt # Supprimer des lignes sed '/pattern/d' fichier.txt # Contenant pattern sed '5d' fichier.txt # Ligne 5 sed '1,10d' fichier.txt # Lignes 1 a 10 # Afficher des lignes specifiques sed -n '5p' fichier.txt # Ligne 5 seulement sed -n '5,10p' fichier.txt # Lignes 5 a 10 # Inserer/Ajouter sed '1i\Premiere ligne' fichier.txt # Inserer au debut sed '$a\Derniere ligne' fichier.txt # Ajouter a la fin

📊 Awk - Traitement de donnees

Awk essentials
# Afficher une colonne (par defaut: espace/tab) awk '{print $1}' fichier.txt # Colonne 1 awk '{print $1, $3}' fichier.txt # Colonnes 1 et 3 awk '{print $NF}' fichier.txt # Derniere colonne # Specifier le separateur awk -F':' '{print $1}' /etc/passwd # Usernames awk -F',' '{print $2}' data.csv # CSV # Filtrer les lignes awk '/error/' fichier.log # Contenant "error" awk '$3 > 100' data.txt # Colonne 3 > 100 # Calculs awk '{sum += $1} END {print sum}' numbers.txt # Formattage awk '{printf "%-20s %10d\n", $1, $2}' data.txt # Variables speciales # $0 = ligne complete # $1, $2... = colonnes # NF = nombre de champs # NR = numero de ligne # FS = separateur de champ

🎯 Exemples pratiques

Cas d'usage reels
# Top 10 des IPs dans un access log awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -10 # Extraire les emails d'un fichier grep -oE '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z]{2,}' fichier.txt # Remplacer dans tous les fichiers .conf find /etc -name "*.conf" -exec sed -i 's/old/new/g' {} \; # Analyser la RAM par processus ps aux | awk '{sum[$11] += $6} END {for (p in sum) print sum[p], p}' | sort -rn | head -10 # Extraire les erreurs 500 des logs nginx awk '$9 == 500' /var/log/nginx/access.log # Calculer la taille totale des logs find /var/log -name "*.log" -exec du -b {} \; | awk '{sum += $1} END {print sum/1024/1024 " MB"}'

📚 Points cles a retenir

  • grep: recherche (-i ignore casse, -r recursif, -v inverse)
  • sed: substitution s/old/new/g, -i pour modifier en place
  • awk: colonnes $1 $2, -F separateur, calculs
  • Combiner avec pipes: grep | awk | sort | uniq

🐍 Python pour SysAdmin

Automatisation avancee avec Python

⏱ 12 min
Intermediaire

🎯 Objectifs d'apprentissage

  • Comprendre pourquoi utiliser Python en administration
  • Maitriser les bases du langage
  • Ecrire des scripts d'automatisation simples
👨‍🎓
Conseil de Mentor

"Bash est parfait pour les scripts simples, mais Python devient indispensable des que la logique se complexifie. APIs REST, parsing JSON, gestion d'erreurs avancee - Python excelle la ou Bash atteint ses limites."

💡 Pourquoi Python?

Bash - Ideal pour
  • Scripts courts (< 100 lignes)
  • Enchainer des commandes
  • Manipulation de fichiers simple
Python - Ideal pour
  • Logique complexe
  • APIs REST / JSON / YAML
  • Gestion d'erreurs robuste
  • Librairies riches

💻 Syntaxe de base

Python basics
#!/usr/bin/env python3 # Variables nom = "serveur-web-01" port = 8080 actif = True tags = ["production", "web", "nginx"] config = {"host": "0.0.0.0", "port": 8080} # Affichage print(f"Serveur: {nom} sur port {port}") # Conditions if actif and port > 1024: print("Serveur actif sur port non-privilegie") elif port <= 1024: print("Port privilegie - root requis") else: print("Serveur inactif") # Boucles for tag in tags: print(f"Tag: {tag}") for i in range(5): print(f"Iteration {i}") # Fonctions def verifier_port(port): """Verifie si un port est valide.""" return 1 <= port <= 65535 if verifier_port(8080): print("Port valide")

📦 Librairies utiles

Librairie Usage
os, sysInteractions systeme
subprocessExecuter des commandes
pathlibManipulation de chemins
json, yamlParsing de fichiers config
requestsRequetes HTTP/API
paramikoSSH en Python
loggingLogs structures

📚 Points cles a retenir

  • Python 3 avec #!/usr/bin/env python3
  • Indentation = structure du code
  • f-strings pour le formatage: f"valeur: {var}"
  • Librairies standard puissantes

📁 Python: Fichiers & OS

Manipuler le systeme avec Python

⏱ 15 min
Intermediaire

📁 Manipulation de fichiers

Fichiers en Python
from pathlib import Path # Lire un fichier contenu = Path("/etc/hostname").read_text() print(contenu) # Ecrire dans un fichier Path("/tmp/test.txt").write_text("Hello World\n") # Lire ligne par ligne with open("/var/log/messages", "r") as f: for ligne in f: if "error" in ligne.lower(): print(ligne.strip()) # Verifier existence config = Path("/etc/nginx/nginx.conf") if config.exists() and config.is_file(): print(f"Taille: {config.stat().st_size} bytes")

⚙ Executer des commandes

subprocess
import subprocess # Methode simple result = subprocess.run(["ls", "-la"], capture_output=True, text=True) print(result.stdout) # Avec verification d'erreur try: result = subprocess.run( ["systemctl", "status", "nginx"], capture_output=True, text=True, check=True ) print("Nginx OK") except subprocess.CalledProcessError: print("Nginx KO") # Commande shell complete result = subprocess.run( "ps aux | grep nginx | wc -l", shell=True, capture_output=True, text=True )

📄 JSON et YAML

Parsing de configs
import json import yaml # pip install pyyaml # JSON with open("config.json") as f: config = json.load(f) print(config["database"]["host"]) # YAML with open("docker-compose.yml") as f: compose = yaml.safe_load(f) for service in compose["services"]: print(f"Service: {service}") # Ecrire JSON data = {"status": "ok", "count": 42} with open("output.json", "w") as f: json.dump(data, f, indent=2)

📚 Points cles a retenir

  • pathlib.Path pour les fichiers modernes
  • subprocess.run() pour les commandes
  • json.load()/dump() pour JSON
  • yaml.safe_load() pour YAML

🎯 Projet: Script de Backup

Mettre en pratique vos connaissances

⏱ 20 min
Avance

🎯 Objectif du projet

Creer un script de backup automatise qui:

  • Sauvegarde des dossiers configures
  • Compresse les fichiers
  • Rotation des anciennes sauvegardes
  • Log les operations

💻 Version Bash

backup.sh
#!/bin/bash set -euo pipefail # Configuration BACKUP_DIR="/opt/backups" SOURCES=("/etc/nginx" "/opt/semarchy") RETENTION_DAYS=7 LOG_FILE="/var/log/backup.log" # Fonctions log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"; } # Creation du dossier mkdir -p "$BACKUP_DIR" # Backup TIMESTAMP=$(date +%Y%m%d_%H%M%S) for src in "${SOURCES[@]}"; do if [ -d "$src" ]; then name=$(basename "$src") archive="${BACKUP_DIR}/${name}_${TIMESTAMP}.tar.gz" log "Backup de $src vers $archive" tar -czf "$archive" -C "$(dirname "$src")" "$(basename "$src")" fi done # Rotation log "Suppression des backups > $RETENTION_DAYS jours" find "$BACKUP_DIR" -name "*.tar.gz" -mtime +$RETENTION_DAYS -delete log "Backup termine"

🐍 Version Python

backup.py
#!/usr/bin/env python3 import tarfile import logging from pathlib import Path from datetime import datetime, timedelta # Configuration BACKUP_DIR = Path("/opt/backups") SOURCES = [Path("/etc/nginx"), Path("/opt/semarchy")] RETENTION_DAYS = 7 # Logging logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler('/var/log/backup.log'), logging.StreamHandler() ] ) def backup(): BACKUP_DIR.mkdir(parents=True, exist_ok=True) timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') for src in SOURCES: if src.exists(): archive = BACKUP_DIR / f"{src.name}_{timestamp}.tar.gz" logging.info(f"Backup de {src} vers {archive}") with tarfile.open(archive, "w:gz") as tar: tar.add(src, arcname=src.name) def rotate(): cutoff = datetime.now() - timedelta(days=RETENTION_DAYS) for f in BACKUP_DIR.glob("*.tar.gz"): if datetime.fromtimestamp(f.stat().st_mtime) < cutoff: logging.info(f"Suppression: {f}") f.unlink() if __name__ == "__main__": logging.info("Demarrage backup") backup() rotate() logging.info("Backup termine")
💡
Automatisation avec cron

Ajoutez au crontab: 0 2 * * * /opt/scripts/backup.sh
Execute le backup tous les jours a 2h du matin.

🏆 Felicitations!

Vous avez complete la section Scripting! Vous savez maintenant:

  • Ecrire des scripts Bash robustes
  • Utiliser Python pour l'automatisation
  • Combiner les deux selon les besoins

📦 Introduction a Git

Le controle de version pour tous

⏱ 10 min
Debutant

🎯 Objectifs d'apprentissage

  • Comprendre le controle de version
  • Configurer Git
  • Connaitre les concepts de base

💡 Pourquoi Git?

  • Historique - Chaque modification est tracee
  • Collaboration - Travail en equipe sur le meme code
  • Branches - Experimenter sans casser le code principal
  • Rollback - Revenir en arriere si probleme

⚙ Configuration initiale

Configuration Git
# Identite git config --global user.name "Votre Nom" git config --global user.email "votre@email.com" # Editeur par defaut git config --global core.editor "vim" # Verifier la config git config --list

📊 Concepts fondamentaux

ZONES GIT

+------------------+     +------------------+     +------------------+
|  Working Dir     | --> |   Staging Area   | --> |   Repository     |
|  (vos fichiers)  |     |     (index)      |     |    (.git/)       |
+------------------+     +------------------+     +------------------+
         |                       |                        |
      git add               git commit               git push

📚 Points cles a retenir

  • Git = controle de version distribue
  • Working Directory -> Staging -> Repository
  • Configurer user.name et user.email d'abord

📋 Commandes Git de base

Les commandes du quotidien

⏱ 12 min
Intermediaire

💻 Commandes essentielles

Git basics
# Initialiser un repo git init # Cloner un repo existant git clone https://github.com/user/repo.git # Voir le statut git status # Ajouter au staging git add fichier.txt # Un fichier git add . # Tous les fichiers # Creer un commit git commit -m "Description du changement" # Voir l'historique git log git log --oneline # Version compacte # Voir les differences git diff # Non-staged git diff --staged # Staged

🌐 Travail avec remote

Remote operations
# Ajouter un remote git remote add origin https://github.com/user/repo.git # Voir les remotes git remote -v # Envoyer les commits git push origin main # Recuperer les changements git pull origin main # Fetch sans merge git fetch origin

📚 Points cles a retenir

  • git add -> git commit -> git push
  • git status pour voir l'etat
  • git pull pour recuperer les changements

🔨 Branches & Merging

Travailler en parallele

⏱ 12 min
Intermediaire

🔨 Gestion des branches

Branches
# Lister les branches git branch # Locales git branch -a # Toutes # Creer une branche git branch feature-login # Changer de branche git checkout feature-login # ou (moderne) git switch feature-login # Creer et changer en une commande git checkout -b feature-login git switch -c feature-login # Supprimer une branche git branch -d feature-login

🔄 Merge

Merge
# Se placer sur la branche cible git checkout main # Fusionner la feature git merge feature-login # En cas de conflit # 1. Editer les fichiers en conflit # 2. git add fichiers_resolus # 3. git commit 
WORKFLOW DE BRANCHES

main:     A---B-------E---F  (merge)
               \     /
feature:        C---D

📚 Points cles a retenir

  • git branch / git checkout -b pour creer
  • git merge pour fusionner
  • Resoudre les conflits manuellement si besoin

🚀 Workflows Git Pro

Bonnes pratiques en equipe

⏱ 10 min
Avance

🚀 GitFlow simplifie

GITFLOW SIMPLIFIE

main        ----*-----------*-----------*---- (production)
                 \         /
develop     ------*---*---*---*---*---*------ (integration)
                   \     /   \       /
feature/x   --------*---*     \     /
                               \   /
feature/y   --------------------*-*

✅ Bonnes pratiques

  • Commits atomiques - Un commit = un changement logique
  • Messages clairs - "Fix login bug" pas "update"
  • Pull avant push - Evite les conflits
  • Branches courtes - Merger frequemment
  • Ne jamais forcer sur main - git push --force interdit!
Workflow typique
# 1. Mettre a jour main git checkout main git pull origin main # 2. Creer une branche feature git checkout -b feature/add-backup-script # 3. Travailler et commiter git add . git commit -m "Add automated backup script" # 4. Pousser la branche git push -u origin feature/add-backup-script # 5. Creer une Pull Request sur GitHub/GitLab # 6. Apres review et merge, nettoyer git checkout main git pull git branch -d feature/add-backup-script

🏆 Felicitations!

Vous maitrisez maintenant Git! Vous etes pret pour l'examen final.

📚 Revision Espacee

Renforcez votre memoire avec les flashcards

🧠
La repetition espacee

La science montre que reviser a intervalles reguliers ameliore la retention de 200%. Cliquez sur les cartes pour voir la reponse, puis evaluez si vous connaissiez la reponse.

Flashcards Linux

Quel est le PID de systemd ?
PID 1 - C'est le premier processus lance par le kernel
Ou se trouvent les fichiers de configuration ?
/etc/ - Contient tous les fichiers de config systeme
Commande pour voir l'espace disque ?
df -h (disk free, human readable)
Que fait le pipe ( | ) ?
Envoie la sortie d'une commande vers l'entree d'une autre
Commande pour suivre un log en temps reel ?
tail -f fichier.log

🏆 Examen Final - Phase 1

Validez vos connaissances en Fondamentaux

⏱ 30 min
Evaluation
🎯
Instructions

Cet examen comporte 15 questions couvrant tous les modules de la Phase 1.
Objectif: 80% de bonnes reponses pour valider la phase.
Vous pouvez recommencer autant de fois que necessaire.

Section A: Linux (5 questions)

1. Quel est le PID du processus systemd?

APID 0
BPID 1
CPID 100

2. Quelle permission octale correspond a rwxr-xr-x?

A644
B755
C777

3. Quelle commande ajoute un utilisateur au groupe docker?

Ausermod -G docker john
Busermod -aG docker john
Cgroupadd docker john

4. Ou se trouvent les fichiers de configuration systeme?

A/var/
B/opt/
C/etc/

5. Quelle commande installe un paquet sans confirmation sur RHEL?

Adnf install nginx
Bdnf install -y nginx
Capt install nginx

Section B: Bash (5 questions)

6. Quel shebang utiliser pour un script Bash?

A#!/bin/bash
B#/bin/bash
C//bin/bash

7. Comment acceder au premier argument d'un script?

A$0
B$1
C$@

8. Quel operateur teste si un fichier existe?

A-d fichier
B-f fichier
C-z fichier

9. Quelle commande remplace du texte dans un fichier?

Agrep 's/old/new/g' fichier
Bsed 's/old/new/g' fichier
Cawk 's/old/new/g' fichier

10. Dans awk, comment afficher la premiere colonne?

Aawk '{print $0}'
Bawk '{print $1}'
Cawk '{print column1}'

Section C: Git (5 questions)

11. Quelle commande initialise un nouveau depot Git?

Agit start
Bgit init
Cgit create

12. Quelle sequence pour sauvegarder des modifications?

Agit commit, git add, git push
Bgit add, git commit, git push
Cgit push, git add, git commit

13. Comment creer et basculer sur une nouvelle branche?

Agit branch -n feature
Bgit checkout -b feature
Cgit new branch feature

14. Quelle commande fusionne une branche dans main?

Agit merge feature (depuis main)
Bgit combine feature
Cgit join feature main

15. Que fait git pull?

AEnvoie les commits locaux
BRecupere et fusionne les commits distants
CSupprime une branche

🏆 Felicitations!

Vous avez termine l'examen de la Phase 1 - Fondamentaux!

Si vous avez obtenu au moins 12/15 (80%), vous etes pret pour la Phase 2: Infrastructure.


Resume de ce que vous avez appris:

  • ✅ Administration Linux (fichiers, users, services)
  • ✅ Scripting Bash (variables, conditions, fonctions)
  • ✅ Outils de texte (grep, sed, awk)
  • ✅ Python pour l'automatisation
  • ✅ Git et controle de version
Retour au menu principal →