<style> .slides { font-size: 3rem; background: url('https://images.unsplash.com/photo-1629654297299-c8506221ca97?q=80&w=2274&auto=format&fit=crop&ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D') center/cover no-repeat; } .slides > section { position: absolute; inset: 0; background: rgba(255, 255, 255, 0.1); backdrop-filter: blur(12px); -webkit-backdrop-filter: blur(12px); border: 1px solid rgba(255, 255, 255, 0.2); color: white; display: grid; place-content: center; box-sizing: border-box; } .slides > section:first-of-type { font-size: 6rem; } .slides h1, .slides h2, .slides h3, .slides h4, .slides h5, .slides h6, h1, h2, h3, h4, h5, h6 { color: #e74c3c; } .slides strong, .slides em { color: #ff9676; } .slides pre code { width: auto; max-height: initial; } .slides code { color: #ffbd96; font-style: italic; } .slides p { padding: 0 2.4rem; } .slides .alert { width: 90%; margin: auto; } .slides ul, .slides ol { width: calc(100% - 4rem); } html, body, .ui-content { color: #ecf0f1; } .markdown-body h1, .markdown-body h2, .markdown-body h3, .markdown-body h4, .markdown-body h5, .markdown-body h6 { color: #ecf0f1; border-bottom-color: #ffffff4d; } .markdown-body img { background-color: transparent; } .ui-toc-dropdown { background-color: #2c3e50; } .ui-toc-label.btn { background-color: #192b38; color: #fff; } .ui-toc-dropdown .nav>.active>a, .ui-toc-dropdown .nav>li>a:hover, .ui-toc-dropdown .nav>li>a:focus { color: #fff; border-left: 2px solid #fff; } .expand-toggle:hover, .expand-toggle:focus, .back-to-top:hover, .back-to-top:focus, .go-to-bottom:hover, .go-to-bottom:focus { color: #fff; } .markdown-body blockquote { color: #bcbcbc; } .markdown-body table tr { background-color: #4b5f70; } .markdown-body table tr:nth-child(2n) { background-color: #3e4f5f; } .markdown-body code, .markdown-body tt { color: #f0f0f0; background-color: rgba(230, 230, 230, 0.3); } a, .open-files-container li.selected a { color: #3498db; } </style> # Linux (VM / WSL) --- # Introduction à Linux --- ## Histoire de Linux Linux a été créé en **1991** par **Linus Torvalds**, alors étudiant à l'université d'Helsinki en Finlande. Linus a développé Linux comme un projet personnel pour explorer les fonctionnalités des processeurs **80386**. Initialement, Linux était un noyau (kernel) destiné à fonctionner sur les ordinateurs personnels, mais il a rapidement évolué pour devenir un système d'exploitation complet. - **1991** : Première version publique de Linux (version 0.01). - **1992** : Linux est placé sous licence **GPL** (General Public License), ce qui en fait un logiciel libre et open-source. - **Aujourd'hui** : Linux est utilisé partout, des serveurs aux smartphones (via Android), en passant par les supercalculateurs et les systèmes embarqués. ---  *Linus Torvalds, créateur de Linux* --- ## Avantages de Linux Linux est largement utilisé pour plusieurs raisons : ### 1. **Open-source** - Le code source de Linux est librement accessible, ce qui permet à quiconque de le modifier, de l'améliorer et de le redistribuer. - Exemple : Les entreprises comme Red Hat et Canonical (Ubuntu) ont construit des business models autour de Linux. ### 2. **Sécurité** - Linux est réputé pour sa robustesse face aux virus et aux attaques. - Les permissions strictes et la séparation des privilèges rendent difficile l'exécution de code malveillant. --- ### 3. **Stabilité** - Les systèmes Linux sont connus pour leur fiabilité, même après des mois d'utilisation sans redémarrage. - Exemple : De nombreux serveurs web fonctionnent sous Linux sans interruption pendant des années. ### 4. **Flexibilité** - Linux est hautement personnalisable et peut être adapté à presque tous les besoins. - Exemple : Vous pouvez choisir parmi des dizaines de distributions, chacune optimisée pour un usage spécifique (bureau, serveur, développement, etc.). --- Très bien ! Je vais remplacer CentOS par d'autres distributions sans faire de comparaison directe, et j'ajouterai des images pour rendre le contenu plus visuel et engageant. Voici la version révisée : --- # Distributions Linux populaires --- <div> <div class="debian-slide"></div> ## Debian ### Description Debian est une distribution Linux stable et fiable, souvent utilisée comme base pour d'autres distributions. Elle est connue pour son engagement envers les logiciels libres et sa grande communauté de contributeurs. ### Cas d'utilisation - **Serveurs** : Debian est largement utilisé pour les serveurs en raison de sa stabilité. - **Stations de travail** : Idéal pour les développeurs et les utilisateurs avancés. ### Gestionnaire de paquets - **`dpkg`** : Gestionnaire de paquets de bas niveau. - **`apt`** : Outil de gestion de paquets de haut niveau. </div> <style> .debian-slide { position: absolute; inset: 0; width: 100%; height: 100%; opacity: 0.3; background: url('https://upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Debian-OpenLogo.svg/240px-Debian-OpenLogo.svg.png') center / contain no-repeat; } </style> --- <div> <div class="ubuntu-slide"></div> ## Ubuntu ### Description Ubuntu est une distribution conviviale, basée sur Debian, et est l'une des distributions Linux les plus populaires. Elle est particulièrement adaptée aux débutants et aux environnements de bureau. ### Cas d'utilisation - **Bureau** : Ubuntu est largement utilisé pour les ordinateurs de bureau et les ordinateurs portables. - **Développement** : Idéal pour les développeurs grâce à son large écosystème de logiciels. ### Gestionnaire de paquets - **`apt`** : Outil de gestion de paquets. </div> <style> .ubuntu-slide { position: absolute; inset: 0; width: 100%; height: 100%; opacity: 0.3; background: url('https://upload.wikimedia.org/wikipedia/commons/thumb/9/9e/UbuntuCoF.svg/240px-UbuntuCoF.svg.png') center / contain no-repeat; } </style> --- <div> <div class="fedora-slide"></div> ## Fedora ### Description Fedora est une distribution innovante, souvent utilisée pour tester de nouvelles technologies. Elle est soutenue par Red Hat et est connue pour son cycle de publication rapide. ### Cas d'utilisation - **Développement** : Fedora est souvent utilisé par les développeurs pour expérimenter de nouvelles fonctionnalités. - **Bureautique** : Convient également pour une utilisation quotidienne. ### Gestionnaire de paquets - **`dnf`** : Outil de gestion de paquets moderne. </div> <style> .fedora-slide { position: absolute; inset: 0; width: 100%; height: 100%; opacity: 0.3; background: url('https://upload.wikimedia.org/wikipedia/commons/thumb/4/41/Fedora_icon_%282021%29.svg/240px-Fedora_icon_%282021%29.svg.png') center / contain no-repeat; } </style> --- <div> <div class="almalinux-slide"></div> ## AlmaLinux ### Description AlmaLinux est une distribution communautaire conçue pour être une alternative stable et fiable, compatible avec les systèmes d'entreprise. Elle est soutenue par CloudLinux et offre un support à long terme. ### Cas d'utilisation - **Serveurs d'entreprise** : AlmaLinux est idéal pour les environnements de production. - **Migration facile** : Compatible avec les systèmes basés sur RPM. ### Gestionnaire de paquets - **`dnf`** : Outil de gestion de paquets. </div> <style> .almalinux-slide { position: absolute; inset: 0; width: 100%; height: 100%; opacity: 0.3; background: url('https://upload.wikimedia.org/wikipedia/commons/thumb/1/13/AlmaLinux_Icon_Logo.svg/512px-AlmaLinux_Icon_Logo.svg.png') center / contain no-repeat; } </style> --- <div> <div class="rocky-slide"></div> ## Rocky Linux ### Description Rocky Linux est une distribution communautaire créée pour offrir une alternative stable et fiable, compatible avec les systèmes d'entreprise. Il est soutenu par une communauté active et des entreprises. ### Cas d'utilisation - **Serveurs d'entreprise** : Rocky Linux est conçu pour les environnements de production. - **Support à long terme** : Offre un support étendu pour les entreprises. ### Gestionnaire de paquets - **`dnf`** : Outil de gestion de paquets. </div> <style> .rocky-slide { position: absolute; inset: 0; width: 100%; height: 100%; opacity: 0.3; background: url('https://upload.wikimedia.org/wikipedia/commons/thumb/7/77/Rocky_Linux_logo.svg/2048px-Rocky_Linux_logo.svg.png') center / contain no-repeat; } </style> --- <div> <div class="opensuse-slide"></div> ## OpenSUSE ### Description OpenSUSE est une distribution flexible, idéale pour les environnements de serveurs et de développement. Elle est connue pour son outil de configuration YaST et son gestionnaire de paquets ZYpp. ### Cas d'utilisation - **Serveurs** : OpenSUSE est utilisé pour les serveurs en raison de sa flexibilité. - **Développement** : Idéal pour les développeurs grâce à ses outils avancés. ### Gestionnaire de paquets - **`zypper`** : Outil de gestion de paquets. </div> <style> .opensuse-slide { position: absolute; inset: 0; width: 100%; height: 100%; opacity: 0.3; background: url('https://upload.wikimedia.org/wikipedia/commons/thumb/d/d0/OpenSUSE_Logo.svg/400px-OpenSUSE_Logo.svg.png') center / contain no-repeat; } </style> --- <div> <div class="oracle-slide"></div> ## Oracle Linux ### Description Oracle Linux est une distribution basée sur RHEL, conçue pour les environnements d'entreprise. Il est gratuit pour une utilisation de base, mais le support est payant. ### Cas d'utilisation - **Serveurs d'entreprise** : Oracle Linux est largement utilisé dans les environnements d'entreprise. - **Compatibilité avec RHEL** : Offre une compatibilité élevée avec les systèmes basés sur RHEL. ### Gestionnaire de paquets - **`yum`** ou **`dnf`** : Outils de gestion de paquets. </div> <style> .oracle-slide { position: absolute; inset: 0; width: 100%; height: 100%; opacity: 0.3; background: url('https://upload.wikimedia.org/wikipedia/commons/thumb/4/46/Oracle_linux_logo.svg/1024px-Oracle_linux_logo.svg.png') center / contain no-repeat; } </style> --- ## Conclusion Ces distributions Linux offrent une variété d'options pour différents cas d'utilisation, des serveurs d'entreprise aux environnements de bureau et de développement. Que vous recherchiez la stabilité, la flexibilité ou l'innovation, il existe une distribution Linux adaptée à vos besoins. ---  *Timeline des distributions Linux* [Wikepedia Linux Distribution Timeline](https://fr.m.wikipedia.org/wiki/Fichier:Linux_Distribution_Timeline.svg) --- ## Structure des répertoires Linux (complète) | Répertoire | Description | |------------------|-----------------------------------------------------------------------------| | **`/`** | **Racine** : Le point de départ de la hiérarchie du système de fichiers. | | **`/bin`** | **Binaires essentiels** : Contient les commandes de base pour tous les utilisateurs (ex: `ls`, `cp`). | | **`/boot`** | **Fichiers de démarrage** : Contient les fichiers nécessaires au démarrage du système (ex: noyau Linux). | | **`/dev`** | **Périphériques** : Contient les fichiers représentant les périphériques matériels (ex: `/dev/sda` pour un disque dur). | | **`/etc`** | **Configuration système** : Contient les fichiers de configuration du système et des applications. | | **`/home`** | **Répertoires personnels** : Chaque utilisateur a un sous-répertoire ici pour stocker ses fichiers personnels. | | **`/lib`** | **Bibliothèques système** : Contient les bibliothèques partagées nécessaires aux programmes système. | --- | Répertoire | Description | |------------------|-----------------------------------------------------------------------------| | **`/media`** | **Points de montage pour médias amovibles** : Utilisé pour monter automatiquement les clés USB, CD, etc. | | **`/mnt`** | **Points de montage temporaires** : Utilisé pour monter manuellement des systèmes de fichiers temporaires. | | **`/opt`** | **Logiciels optionnels** : Souvent utilisé pour installer des logiciels tiers. | | **`/proc`** | **Informations système** : Un système de fichiers virtuel qui expose les informations du noyau et des processus. | | **`/root`** | **Répertoire personnel de root** : Le répertoire personnel de l'utilisateur root (superutilisateur). | | **`/run`** | **Données d'exécution** : Contient des fichiers temporaires liés aux processus en cours d'exécution. | --- | Répertoire | Description | |------------------|-----------------------------------------------------------------------------| | **`/sbin`** | **Binaires système essentiels** : Contient les commandes réservées à l'administrateur système (ex: `fdisk`, `ifconfig`). | | **`/srv`** | **Données de service** : Contient les données pour les services fournis par le système (ex: fichiers web pour un serveur HTTP). | | **`/tmp`** | **Fichiers temporaires** : Utilisé pour stocker des fichiers temporaires. Les fichiers peuvent être supprimés au redémarrage. | | **`/usr`** | **Logiciels utilisateur** : Contient les programmes, bibliothèques et fichiers partagés par les utilisateurs. | | **`/var`** | **Données variables** : Contient des fichiers qui changent fréquemment, comme les logs (`/var/log`), les bases de données, etc. | --- ### Répertoires supplémentaires (moins courants mais importants) | Répertoire | Description | |------------------|-----------------------------------------------------------------------------| | **`/lost+found`**| **Fichiers récupérés** : Contient les fichiers récupérés après un crash du système de fichiers. | | **`/sys`** | **Informations du noyau** : Un système de fichiers virtuel qui expose les informations du noyau et du matériel. | | **`/selinux`** | **SELinux** : Contient les fichiers liés à SELinux (un module de sécurité avancé). | | **`/snap`** | **Paquets Snap** : Utilisé pour stocker les applications installées via Snap (un système de gestion de paquets). | --- ### Exemple d'arborescence Linux Voici un exemple visuel d'une arborescence Linux typique : ```bash! / ├── bin ├── boot ├── dev ├── etc ├── home │ ├── user1 │ └── user2 ├── lib ├── media ├── mnt ├── opt ├── proc ├── root ├── run ├── sbin ├── srv ├── tmp ├── usr │ ├── bin │ ├── lib │ └── local └── var ├── log ├── cache └── lib ``` --- ### Pourquoi cette structure ? La structure des répertoires Linux est standardisée par la **Filesystem Hierarchy Standard (FHS)**. Cela permet une organisation cohérente des fichiers sur tous les systèmes Linux, ce qui facilite la maintenance et la gestion. --- ### Exercice pratique : Explorer les répertoires 1. Ouvrez un terminal. 2. Utilisez `cd` pour naviguer dans les répertoires suivants : ```bash cd /var/log ls ``` Cela vous montrera les fichiers de logs du système. 3. Explorez `/proc` pour voir les informations sur les processus en cours d'exécution : ```bash cd /proc ls ``` 4. Utilisez `tree` (si installé) pour visualiser l'arborescence d'un répertoire : ```bash tree /home ``` --- ### Conclusion La structure des répertoires Linux est conçue pour être logique et organisée. En comprenant cette structure, vous pouvez naviguer plus efficacement dans le système et mieux comprendre où sont stockés les fichiers et les programmes. --- # Commandes de base --- ## Navigation dans le système de fichiers ### `pwd` : Afficher le répertoire courant - **Description** : Affiche le chemin absolu du répertoire courant. - **Exemple** : ```bash pwd ``` Sortie : ``` /home/user ``` --- ### `cd` : Changer de répertoire - **Description** : Permet de naviguer entre les répertoires. - **Exemples** : ```bash cd /home/user/Documents # Aller dans le répertoire Documents cd .. # Remonter d'un niveau cd ~ # Retourner au répertoire personnel ``` --- ### `ls` : Lister les fichiers et répertoires - **Description** : Affiche le contenu d'un répertoire. - **Options courantes** : - `-a` : Affiche tous les fichiers, y compris les fichiers cachés. - `-l` : Affiche les détails des fichiers (permissions, propriétaire, taille, etc.). - `-h` : Affiche les tailles de fichiers de manière lisible (Ko, Mo, Go). - `-R` : Liste récursive (affiche le contenu des sous-répertoires). - `-t` : Trie les fichiers par date de modification (du plus récent au plus ancien). - `-tr` : Trie les fichiers par date de modification (du plus ancien au plus récent). --- - **Exemples** : ```bash ls # Liste les fichiers du répertoire courant ls -la # Affiche tous les fichiers avec des détails ls -lh # Affiche les tailles de fichiers de manière lisible ls -R # Liste récursive ls -t # Trie par date de modification ls --all --format=long # Équivalent à `ls -la` ``` --- ## Manipulation de fichiers ### `cp` : Copier des fichiers ou répertoires - **Description** : Copie un fichier ou un répertoire vers un autre emplacement. - **Options courantes** : - `-r` : Copie récursive (pour les répertoires). - `-v` : Mode verbeux (affiche les fichiers copiés). - **Exemples** : ```bash cp fichier.txt /backup/ # Copie un fichier cp -r dossier/ /backup/ # Copie un répertoire cp -v fichier.txt /backup/ # Copie en mode verbeux ``` --- ### `mv` : Déplacer ou renommer des fichiers - **Description** : Déplace un fichier ou un répertoire, ou le renomme. - **Exemples** : ```bash mv fichier.txt /backup/ # Déplace un fichier mv ancien_nom.txt nouveau_nom.txt # Renomme un fichier ``` --- ### `rm` : Supprimer des fichiers ou répertoires - **Description** : Supprime un fichier ou un répertoire. - **Options courantes** : - `-r` : Supprime récursive (pour les répertoires). - `-f` : Force la suppression (ignore les avertissements). - **Exemples** : ```bash rm fichier.txt # Supprime un fichier rm -r dossier/ # Supprime un répertoire rm -rf dossier/ # Force la suppression d'un répertoire ``` --- ### `touch` : Créer un fichier vide - **Description** : Crée un fichier vide ou met à jour la date de modification d'un fichier existant. - **Exemple** : ```bash touch nouveau_fichier.txt ``` --- ### `mkdir` : Créer un répertoire - **Description** : Crée un nouveau répertoire. - **Options courantes** : - `-p` : Crée les répertoires parents si nécessaire. - **Exemples** : ```bash mkdir nouveau_dossier # Crée un répertoire mkdir -p dossier/sous_dossier # Crée une arborescence de répertoires ``` --- ## Visualisation de fichiers ### `cat` : Afficher le contenu d'un fichier - **Description** : Affiche le contenu d'un fichier. - **Exemple** : ```bash cat fichier.txt ``` --- ### `less` : Afficher un fichier page par page - **Description** : Permet de parcourir un fichier page par page. - **Exemple** : ```bash less fichier.txt ``` - **Commandes dans `less`** : - `espace` : Page suivante. - `b` : Page précédente. - `q` : Quitter. --- ### `head` : Afficher le début d'un fichier - **Description** : Affiche les premières lignes d'un fichier. - **Options courantes** : - `-n` : Nombre de lignes à afficher. - **Exemple** : ```bash head -n 10 fichier.txt # Affiche les 10 premières lignes ``` --- ### `tail` : Afficher la fin d'un fichier - **Description** : Affiche les dernières lignes d'un fichier. - **Options courantes** : - `-n` : Nombre de lignes à afficher. - `-f` : Suit les nouvelles lignes ajoutées en temps réel (utile pour les logs). - **Exemple** : ```bash tail -n 10 fichier.txt # Affiche les 10 dernières lignes tail -f /var/log/syslog # Suit les logs en temps réel ``` --- ## Recherche de fichiers ### `find` : Rechercher des fichiers - **Description** : Recherche des fichiers selon des critères spécifiques. - **Options courantes** : - `-name` : Recherche par nom. - `-size` : Recherche par taille. - `-mtime` : Recherche par date de modification. - **Exemples** : ```bash find /home/user -name "*.txt" # Recherche tous les fichiers .txt find /var/log -mtime -7 # Recherche les fichiers modifiés il y a moins de 7 jours find / -size +100M # Recherche les fichiers de plus de 100 Mo ``` --- ### `locate` : Rechercher des fichiers rapidement - **Description** : Recherche des fichiers en utilisant une base de données pré-indexée. - **Syntaxe** : `locate [options] <motif>` - **Exemples** : ```bash locate fichier.txt # Recherche un fichier locate -i FICHIER.TXT # Ignore la casse locate -c fichier.txt # Compte les résultats locate -r ".*\.log$" # Utilise une expression régulière ``` - **Mise à jour de la base** : `sudo updatedb` (nécessaire pour les fichiers récents). --- ### `grep` : Rechercher du texte dans des fichiers - **Description** : Recherche un motif dans un fichier ou un flux de texte. - **Options courantes** : - `-i` : Ignore la casse. - `-r` : Recherche récursive dans les répertoires. - **Exemples** : ```bash grep "motif" fichier.txt # Recherche un motif dans un fichier grep -i "motif" fichier.txt # Ignore la casse grep -r "motif" /chemin/du/repertoire # Recherche récursive ``` --- ## Conclusion Cette section couvre les bases de Linux, de son histoire à ses commandes essentielles. Avec ces connaissances, vous pouvez commencer à naviguer et à interagir efficacement avec un système Linux. --- # Gestion des utilisateurs et des groupes --- ## Création d'utilisateurs ### `useradd` : Créer un utilisateur La commande `useradd` est utilisée pour créer un nouvel utilisateur. Elle est souvent utilisée dans les scripts ou pour des configurations avancées. ### Options courantes : - `-m` : Crée le répertoire personnel de l'utilisateur. - `-s` : Spécifie le shell de l'utilisateur. - `-g` : Définit le groupe principal de l'utilisateur. - `-G` : Ajoute l'utilisateur à des groupes supplémentaires. --- ### Exemples : 1. **Créer un utilisateur avec un répertoire personnel** : ```bash sudo useradd -m nouvel_utilisateur ``` Cela crée un utilisateur nommé `nouvel_utilisateur` avec un répertoire personnel dans `/home/nouvel_utilisateur`. 2. **Créer un utilisateur avec un shell spécifique** : ```bash sudo useradd -m -s /bin/bash nouvel_utilisateur ``` Cela définit `/bin/bash` comme shell par défaut. 3. **Créer un utilisateur avec un groupe principal et des groupes supplémentaires** : ```bash sudo useradd -m -g utilisateurs -G sudo,developers nouvel_utilisateur ``` Cela crée un utilisateur avec `utilisateurs` comme groupe principal et l'ajoute aux groupes `sudo` et `developers`. --- ### `adduser` : Créer un utilisateur (version interactive) La commande `adduser` est plus conviviale et interactive que `useradd`. Elle est souvent préférée pour les configurations manuelles. #### Exemple : ```bash sudo adduser nouvel_utilisateur ``` Cela vous invite à définir un mot de passe et à fournir des informations supplémentaires (nom complet, numéro de téléphone, etc.). --- ## Modification d'utilisateurs ### `usermod` : Modifier un utilisateur La commande `usermod` permet de modifier les propriétés d'un utilisateur existant. ### Options courantes : - `-l` : Change le nom de l'utilisateur. - `-d` : Change le répertoire personnel de l'utilisateur. - `-s` : Change le shell de l'utilisateur. - `-aG` : Ajoute l'utilisateur à des groupes supplémentaires (sans supprimer les groupes existants). --- ### Exemples : 1. **Changer le nom d'un utilisateur** : ```bash sudo usermod -l nouveau_nom ancien_nom ``` 2. **Changer le répertoire personnel** : ```bash sudo usermod -d /nouveau/home -m nouvel_utilisateur ``` L'option `-m` déplace également le contenu de l'ancien répertoire. 3. **Ajouter un utilisateur à un groupe supplémentaire** : ```bash sudo usermod -aG sudo nouvel_utilisateur ``` Cela ajoute `nouvel_utilisateur` au groupe `sudo`. --- ### `passwd` : Changer le mot de passe d'un utilisateur La commande `passwd` permet de définir ou de modifier le mot de passe d'un utilisateur. ### Exemples : 1. **Changer son propre mot de passe** : ```bash passwd ``` 2. **Changer le mot de passe d'un autre utilisateur** : ```bash sudo passwd nouvel_utilisateur ``` --- ## Suppression d'utilisateurs ### `userdel` : Supprimer un utilisateur La commande `userdel` permet de supprimer un utilisateur du système. #### Options courantes : - `-r` : Supprime également le répertoire personnel de l'utilisateur. #### Exemples : 1. **Supprimer un utilisateur** : ```bash sudo userdel nouvel_utilisateur ``` 2. **Supprimer un utilisateur et son répertoire personnel** : ```bash sudo userdel -r nouvel_utilisateur ``` --- ## Gestion des groupes ### `groupadd` : Créer un groupe La commande `groupadd` permet de créer un nouveau groupe. #### Exemple : ```bash sudo groupadd mon_groupe ``` --- ### `groupmod` : Modifier un groupe La commande `groupmod` permet de modifier les propriétés d'un groupe existant. #### Options courantes : - `-n` : Change le nom du groupe. #### Exemple : ```bash sudo groupmod -n nouveau_nom ancien_nom ``` --- ### `groupdel` : Supprimer un groupe La commande `groupdel` permet de supprimer un groupe du système. #### Exemple : ```bash sudo groupdel mon_groupe ``` --- ## Exercice pratique 1. **Créer un nouvel utilisateur** : ```bash sudo adduser utilisateur_test ``` 2. **Ajouter l'utilisateur à un groupe supplémentaire** : ```bash sudo usermod -aG sudo utilisateur_test ``` 3. **Changer le mot de passe de l'utilisateur** : ```bash sudo passwd utilisateur_test ``` 4. **Supprimer l'utilisateur et son répertoire personnel** : ```bash sudo userdel -r utilisateur_test ``` --- ## Conclusion La gestion des utilisateurs et des groupes est une compétence essentielle pour administrer un système Linux. Avec ces commandes, vous pouvez créer, modifier et supprimer des utilisateurs et des groupes, ainsi que gérer leurs permissions et leurs accès. --- # Scripting Bash --- ## Introduction au scripting ### Pourquoi utiliser des scripts Bash ? Les scripts Bash permettent d'automatiser des tâches répétitives, de gérer des opérations complexes et d'exécuter des commandes en séquence. Ils sont essentiels pour : - **Automatisation** : Exécuter des tâches sans intervention manuelle. - **Productivité** : Gagner du temps en regroupant plusieurs commandes dans un seul fichier. - **Reproductibilité** : Assurer que les mêmes étapes sont suivies à chaque exécution. - **Maintenance** : Faciliter la gestion des systèmes en centralisant les opérations. --- ## Structure d'un script Bash Un script Bash est un fichier texte contenant une série de commandes. Il commence généralement par une **shebang** (`#!/bin/bash`) pour indiquer que le script doit être exécuté avec Bash. ### Exemple de script simple ```bash #!/bin/bash # Ce script affiche "Bonjour, monde !" echo "Bonjour, monde !" ``` --- ## Exemples de scripts ### 1. Script de sauvegarde Ce script sauvegarde un répertoire dans un fichier compressé. ```bash #!/bin/bash # Script de sauvegarde DATE=$(date +%Y-%m-%d) BACKUP_DIR="/backup" SOURCE_DIR="/home/user/Documents" # Crée une archive compressée tar -czf $BACKUP_DIR/backup_$DATE.tar.gz $SOURCE_DIR # Affiche un message de confirmation echo "Sauvegarde terminée : $BACKUP_DIR/backup_$DATE.tar.gz" ``` --- ### 2. Script de surveillance de l'espace disque Ce script surveille l'espace disque et envoie une alerte si l'espace utilisé dépasse un seuil. ```bash #!/bin/bash # Script de surveillance de l'espace disque THRESHOLD=90 # Seuil en pourcentage # Récupère l'espace utilisé USAGE=$(df / | grep / | awk '{print $5}' | sed 's/%//g') # Vérifie si le seuil est dépassé if [ $USAGE -gt $THRESHOLD ]; then echo "Alerte : L'espace disque est presque plein ($USAGE%) !" else echo "Espace disque OK : $USAGE% utilisé." fi ``` --- ### 3. Script de nettoyage des fichiers temporaires Ce script supprime les fichiers temporaires plus anciens que 7 jours. ```bash #!/bin/bash # Script de nettoyage des fichiers temporaires TEMP_DIR="/tmp" DAYS=7 # Supprime les fichiers anciens find $TEMP_DIR -type f -mtime +$DAYS -exec rm -f {} \; # Affiche un message de confirmation echo "Nettoyage terminé : fichiers de plus de $DAYS jours supprimés." ``` --- ## Bonnes pratiques pour écrire des scripts Bash 1. **Commentaires** : Ajoutez des commentaires pour expliquer le fonctionnement du script. ```bash # Ce script sauvegarde le répertoire Documents ``` 2. **Variables** : Utilisez des variables pour stocker des valeurs réutilisables. ```bash BACKUP_DIR="/backup" ``` 3. **Gestion des erreurs** : Vérifiez les erreurs avec `if` ou `||`. ```bash if [ $? -ne 0 ]; then echo "Erreur : La commande a échoué." fi ``` 4. **Permissions** : Rendez le script exécutable avec `chmod`. ```bash chmod +x mon_script.sh ``` 5. **Tests** : Testez votre script dans un environnement isolé avant de l'utiliser en production. --- ## Exercice pratique 1. **Créer un script de sauvegarde** : - Sauvegardez un répertoire de votre choix dans un fichier compressé. - Ajoutez un message de confirmation à la fin. 2. **Créer un script de surveillance** : - Surveillez l'espace disque et affichez une alerte si l'espace utilisé dépasse 80 %. 3. **Créer un script de nettoyage** : - Supprimez les fichiers temporaires de plus de 7 jours. --- ## Conclusion Le scripting Bash est un outil puissant pour automatiser des tâches sous Linux. Avec des scripts bien structurés et des bonnes pratiques, vous pouvez améliorer votre productivité et la gestion de vos systèmes. --- # Gestionnaires de paquets sous Linux --- ## Qu'est-ce qu'un gestionnaire de paquets ? Un **gestionnaire de paquets** est un outil qui permet d'installer, de mettre à jour, de configurer et de supprimer des logiciels sur un système Linux. Il gère les dépendances entre les paquets et assure que les logiciels sont correctement installés. --- ## Principaux gestionnaires de paquets ### 1. **APT** (Advanced Package Tool) - **Distributions** : Debian, Ubuntu, Linux Mint. - **Commandes principales** : - `apt update` : Met à jour la liste des paquets disponibles. - `apt upgrade` : Met à jour les paquets installés. - `apt install <paquet>` : Installe un paquet. - `apt remove <paquet>` : Supprime un paquet. - `apt search <mot-clé>` : Recherche un paquet. - `apt show <paquet>` : Affiche les détails d'un paquet. #### Exemples : ```bash sudo apt update sudo apt install vim sudo apt remove vim sudo apt search nginx ``` --- ### 2. **YUM** (Yellowdog Updater Modified) - **Distributions** : CentOS, RHEL (avant la version 8). - **Commandes principales** : - `yum install <paquet>` : Installe un paquet. - `yum update` : Met à jour les paquets installés. - `yum remove <paquet>` : Supprime un paquet. - `yum search <mot-clé>` : Recherche un paquet. - `yum info <paquet>` : Affiche les détails d'un paquet. #### Exemples : ```bash sudo yum install httpd sudo yum update sudo yum remove httpd sudo yum search nginx ``` --- ### 3. **DNF** (Dandified YUM) - **Distributions** : Fedora, CentOS 8+, RHEL 8+. - **Commandes principales** : - `dnf install <paquet>` : Installe un paquet. - `dnf update` : Met à jour les paquets installés. - `dnf remove <paquet>` : Supprime un paquet. - `dnf search <mot-clé>` : Recherche un paquet. - `dnf info <paquet>` : Affiche les détails d'un paquet. #### Exemples : ```bash sudo dnf install vim sudo dnf update sudo dnf remove vim sudo dnf search nginx ``` --- ### 4. **Zypper** - **Distributions** : openSUSE. - **Commandes principales** : - `zypper install <paquet>` : Installe un paquet. - `zypper update` : Met à jour les paquets installés. - `zypper remove <paquet>` : Supprime un paquet. - `zypper search <mot-clé>` : Recherche un paquet. - `zypper info <paquet>` : Affiche les détails d'un paquet. #### Exemples : ```bash sudo zypper install vim sudo zypper update sudo zypper remove vim sudo zypper search nginx ``` --- ### 5. **Pacman** - **Distributions** : Arch Linux, Manjaro. - **Commandes principales** : - `pacman -S <paquet>` : Installe un paquet. - `pacman -Syu` : Met à jour tous les paquets. - `pacman -R <paquet>` : Supprime un paquet. - `pacman -Ss <mot-clé>` : Recherche un paquet. - `pacman -Si <paquet>` : Affiche les détails d'un paquet. #### Exemples : ```bash sudo pacman -S vim sudo pacman -Syu sudo pacman -R vim sudo pacman -Ss nginx ``` --- ## Bonnes pratiques pour utiliser les gestionnaires de paquets 1. **Mettre à jour régulièrement** : - Avant d'installer ou de mettre à jour des paquets, mettez toujours à jour la liste des paquets disponibles. ```bash sudo apt update # Debian/Ubuntu sudo yum check-update # CentOS/RHEL sudo dnf check-update # Fedora ``` 2. **Vérifier les dépendances** : - Les gestionnaires de paquets gèrent automatiquement les dépendances, mais il est bon de vérifier les conflits potentiels. --- 3. **Nettoyer le cache** : - Supprimez les paquets téléchargés inutiles pour libérer de l'espace. ```bash sudo apt clean # Debian/Ubuntu sudo yum clean all # CentOS/RHEL sudo dnf clean all # Fedora ``` 4. **Utiliser des dépôts officiels** : - Évitez les dépôts non officiels pour réduire les risques de sécurité. --- ## Exercice pratique 1. **Installer un paquet** : - Utilisez le gestionnaire de paquets de votre distribution pour installer `vim`. ```bash sudo apt install vim # Debian/Ubuntu sudo yum install vim # CentOS/RHEL sudo dnf install vim # Fedora ``` 2. **Mettre à jour les paquets** : - Mettez à jour tous les paquets installés sur votre système. ```bash sudo apt update && sudo apt upgrade # Debian/Ubuntu sudo yum update # CentOS/RHEL sudo dnf update # Fedora ``` 3. **Rechercher un paquet** : - Recherchez un paquet comme `nginx` pour voir s'il est disponible. ```bash sudo apt search nginx # Debian/Ubuntu sudo yum search nginx # CentOS/RHEL sudo dnf search nginx # Fedora ``` --- ## Conclusion Les gestionnaires de paquets sont des outils essentiels pour gérer les logiciels sous Linux. Que vous utilisiez `apt`, `yum`, `dnf`, `zypper` ou `pacman`, ces outils vous permettent d'installer, de mettre à jour et de supprimer des paquets de manière efficace et sécurisée. --- # Sécurité de base --- ## Configuration de pare-feu avec `ufw` `ufw` (Uncomplicated Firewall) est un outil simple pour configurer un pare-feu sous Linux. Il est basé sur `iptables` mais est beaucoup plus facile à utiliser. --- ### Installation de `ufw` Sur la plupart des distributions, `ufw` est installé par défaut. Sinon, vous pouvez l'installer avec : - **Debian/Ubuntu** : ```bash sudo apt update sudo apt install ufw ``` - **CentOS/RHEL** : ```bash sudo yum install ufw ``` - **Fedora** : ```bash sudo dnf install ufw ``` --- ### Activer et désactiver `ufw` 1. **Activer `ufw`** : ```bash sudo ufw enable ``` 2. **Désactiver `ufw`** : ```bash sudo ufw disable ``` --- ### Configurer des règles de pare-feu #### Autoriser un port ```bash sudo ufw allow 22 # Autorise le port SSH sudo ufw allow 80 # Autorise le port HTTP ``` #### Refuser un port ```bash sudo ufw deny 23 # Bloque le port Telnet ``` #### Autoriser une plage de ports ```bash sudo ufw allow 6000:6007/tcp # Autorise les ports 6000 à 6007 ``` #### Supprimer une règle ```bash sudo ufw delete allow 80 # Supprime la règle autorisant le port 80 ``` --- ### Vérifier l'état de `ufw` 1. **Afficher les règles actives** : ```bash sudo ufw status ``` 2. **Afficher les règles avec plus de détails** : ```bash sudo ufw status verbose ``` --- ## Gestion des clés SSH Les clés SSH permettent une connexion sécurisée sans mot de passe. Elles sont plus sûres que les mots de passe car elles reposent sur une cryptographie asymétrique. --- # Gestion des clés SSH et Connexion à distance --- ## Introduction à SSH **SSH** (Secure Shell) est un protocole de communication sécurisé permettant de se connecter à distance à un serveur ou une machine. Il remplace les anciens protocoles non sécurisés comme Telnet en chiffrant toutes les communications. ### Pourquoi utiliser SSH ? - **Sécurité** : Les données sont chiffrées, ce qui empêche les interceptions. - **Authentification** : Possibilité d'utiliser des clés SSH pour une connexion sans mot de passe. - **Polyvalence** : SSH permet également de transférer des fichiers (via SCP ou SFTP) et de rediriger des ports. ---- ## Génération des clés SSH Les **clés SSH** sont une méthode d'authentification plus sécurisée que les mots de passe. Elles reposent sur une paire de clés cryptographiques : - **Clé privée** : Gardée secrète sur votre machine locale. - **Clé publique** : Placée sur le serveur distant. ---- ### Étapes pour générer une paire de clés SSH 1. **Générer la paire de clés** : ```bash ssh-keygen -t rsa -b 4096 ``` - `-t rsa` : Type de clé (RSA). - `-b 4096` : Taille de la clé (4096 bits pour une sécurité renforcée). 2. **Choisir un emplacement** : - Par défaut, les clés sont stockées dans `~/.ssh/id_rsa` (clé privée) et `~/.ssh/id_rsa.pub` (clé publique). 3. **Ajouter une phrase secrète (optionnelle)** : - Une phrase secrète ajoute une couche de sécurité supplémentaire. Elle sera demandée à chaque utilisation de la clé. ---- ## Copier la clé publique sur un serveur distant Pour permettre une connexion sans mot de passe, vous devez copier votre clé publique sur le serveur distant. 1. **Utiliser `ssh-copy-id`** : ```bash ssh-copy-id utilisateur@serveur ``` - Cela ajoute automatiquement la clé publique au fichier `~/.ssh/authorized_keys` sur le serveur. 2. **Se connecter sans mot de passe** : ```bash ssh utilisateur@serveur ``` - Si une phrase secrète a été définie, elle vous sera demandée. ---- ## Connexion SSH ### Commandes de base 1. **Se connecter à un serveur** : ```bash ssh utilisateur@serveur ``` - Par défaut, SSH utilise le port **22**. 2. **Spécifier un port personnalisé** : ```bash ssh -p 1234 utilisateur@serveur ``` 3. **Rediriger un port local vers un port distant** : ```bash ssh -L 9000:localhost:8080 utilisateur@serveur ``` - Cela redirige le port local `9000` vers le port `8080` du serveur distant. 4. **Exécuter une commande à distance** : ```bash ssh utilisateur@serveur "commande" ``` - Exemple : `ssh utilisateur@serveur "ls -l"`. ---- ## Transfert de fichiers avec SCP **SCP** (Secure Copy) est un outil permettant de transférer des fichiers entre machines via SSH. ### Commandes de base 1. **Copier un fichier local vers un serveur distant** : ```bash scp fichier.txt utilisateur@serveur:/chemin/destination ``` 2. **Copier un fichier distant vers la machine locale** : ```bash scp utilisateur@serveur:/chemin/fichier.txt /chemin/local ``` 3. **Copier un répertoire entier** : ```bash scp -r dossier/ utilisateur@serveur:/chemin/destination ``` 4. **Spécifier un port personnalisé** : ```bash scp -P 1234 fichier.txt utilisateur@serveur:/chemin/destination ``` --- ## Options courantes de SCP | Option | Description | |--------|-----------------------------------------------------------------------------| | `-P` | Spécifie un port personnalisé (par défaut : 22). | | `-r` | Copie récursive des répertoires. | | `-p` | Préserve les permissions et les dates de modification des fichiers. | | `-q` | Mode silencieux (n'affiche que les erreurs critiques). | | `-c` | Compresse les données pendant le transfert. | | `-v` | Mode verbeux (affiche des informations détaillées sur le transfert). | --- ## Bonnes pratiques pour SSH et SCP 1. **Utiliser des clés SSH** : Évitez les mots de passe pour une sécurité renforcée. 2. **Désactiver l'authentification par mot de passe** : - Éditez le fichier `/etc/ssh/sshd_config` sur le serveur : ```bash PasswordAuthentication no PermitRootLogin no ``` - Redémarrez le service SSH : ```bash sudo systemctl restart sshd ``` 3. **Changer le port SSH par défaut** : Cela réduit les attaques automatisées. - Modifiez le fichier `/etc/ssh/sshd_config` : ```bash Port 2222 ``` 4. **Utiliser `fail2ban`** : Cet outil bloque les adresses IP après plusieurs tentatives de connexion infructueuses. --- ## Exercices pratiques ### Exercice 1 : Génération et utilisation des clés SSH 1. Générez une paire de clés SSH. 2. Copiez la clé publique sur un serveur distant. 3. Connectez-vous au serveur sans mot de passe. ### Exercice 2 : Transfert de fichiers avec SCP 1. Créez un fichier `test.txt` sur votre machine locale. 2. Transférez-le vers un serveur distant. 3. Téléchargez un fichier du serveur vers votre machine locale. ### Exercice 3 : Redirection de port 1. Redirigez un port local vers un port distant. 2. Accédez à un service distant via le port redirigé. --- ## Conclusion SSH et SCP sont des outils essentiels pour administrer des serveurs distants de manière sécurisée. Avec les clés SSH, vous pouvez éviter les risques liés aux mots de passe, et SCP facilite le transfert de fichiers entre machines. En suivant les bonnes pratiques, vous pouvez renforcer la sécurité de vos connexions et protéger vos systèmes contre les attaques. --- ## Bonnes pratiques de sécurité ### 1. Mises à jour régulières - **Mettre à jour le système** : ```bash sudo apt update && sudo apt upgrade # Debian/Ubuntu sudo yum update # CentOS/RHEL sudo dnf update # Fedora ``` - **Automatiser les mises à jour** : - Sur Debian/Ubuntu, utilisez `unattended-upgrades`. - Sur CentOS/RHEL, utilisez `yum-cron`. --- ### 2. Gestion des permissions - **Restreindre l'accès aux fichiers sensibles** : ```bash chmod 600 ~/.ssh/id_rsa # Fichier de clé privée chmod 700 ~/.ssh # Répertoire .ssh ``` - **Utiliser `sudo` au lieu de root** : - Évitez d'utiliser le compte root directement. - Ajoutez des utilisateurs au groupe `sudo` : ```bash sudo usermod -aG sudo utilisateur ``` ---- ## Un fichier et/ou un dossier a : - un propriétaire - un groupe - des droits Les droits permettent de définir l'accès à ce fichier. On peut les caractériser de 2 manières : - un nombre (755) - 9 caractères : (rwx rw- r-x) ---- ### 3 groupes: - les droits d'accès du *propriétaire* - les droits d'accès du *groupe* - les droits des *autres comptes du système* | *r* | *w* | *x* | |:----------------:|:-----------------:|:----------:| | accès en lecture | accès en écriture | exécutable | ---- ### Tout est binaire | Symbolique | Binaire | Octale | |:----------:|:-------:|:------:| | - - - | 0 0 0 | 0 | | - - x | 0 0 1 | 1 | | - w - | 0 1 0 | 2 | | - w x | 0 1 1 | 3 | | r - - | 1 0 0 | 4 | | r - x | 1 0 1 | 5 | | r w - | 1 1 0 | 6 | | r w x | 1 1 1 | 7 | ---- ### Changer les droits ```bash= # équivalent en chiffre # User | Group | Other # 7 | 5 | 5 drwxr-xr-x 1 nobody users 0 Nov 5 00:06 influxdb ``` Si je souhaite changer les droits pour que : - #### seul le propriétaire y ait accès ```bash= sudo chmod 700 influxdb ``` - #### tous aient le droit de lire et exécuter ```bash= sudo chmod 555 influxdb ``` ---- - #### Autres informations ```bash= # ajout des droits d'éxécution pour tous chmod +x "nouveau fichier" # ajout des droits de lecture pour tous chmod +r "nouveau fichier" # retrait des droits d'écriture et d'exécution pour tous chmod -wx "nouveau fichier" # changement des droits d'une autre manière chmod ugo=rx "nouveau fichier" # même résulat : a => all chmod a=rx "nouveau fichier" # mais aussi chmod u=- "nouveau fichier" & chmod g=r "nouveau fichier" & chmod o=w "nouveau fichier" # R => récursif chmod -R 544 /home/sam/learning ``` ---- ### Changer de propriétaire / de groupe ```bash= chown [-option] [utilisateur][:groupe] cible1 [cible2 ..] # retrouver tous les utilisateurs cat /etc/passwd # nom:mdp:UID:GID:infos(num, nom complet, etc.):home:shell $ root:x:0:0:Console and webGui login account:/root:/bin/bash ``` #### Changement de propétaire ```bash= chown toto "nouveau fichier" ``` #### Changement de propétaire et de groupe ```bash= chown toto:m2i "nouveau fichier" # -R => récursif chown -R toto:m2i /home/sam/learning ``` ---- #### Changement de groupe ```bash= chgrp [-option] [groupe] cible1 [cible2 ..] # retrouver tous les groupes cat /etc/group # nom : mdp : ID groupe : nom(s) utilisateur du groupe $ avahi:x:214:sam ``` ```bash= chgrp m2i "nouveau fichier" # -R => récursif chown -R m2i /home/sam/learning ``` --- ### 3. Surveillance des logs - **Consulter les logs système** : ```bash sudo journalctl -xe # Affiche les logs récents ``` - **Surveiller les connexions SSH** : ```bash sudo grep "Failed password" /var/log/auth.log # Debian/Ubuntu sudo grep "Failed password" /var/log/secure # CentOS/RHEL ``` --- ### 4. Utilisation de SELinux/AppArmor - **SELinux** (CentOS/RHEL) : - Activez SELinux pour renforcer la sécurité : ```bash sudo setenforce 1 ``` - **AppArmor** (Debian/Ubuntu) : - Activez AppArmor pour restreindre les applications : ```bash sudo systemctl enable apparmor sudo systemctl start apparmor ``` --- ## Exercice pratique 1. **Configurer `ufw`** : - Autorisez les ports SSH (22) et HTTP (80). - Bloquez le port Telnet (23). 2. **Générer et utiliser des clés SSH** : - Générez une paire de clés SSH. - Copiez la clé publique sur un serveur distant. - Désactivez l'authentification par mot de passe. 3. **Appliquer les bonnes pratiques** : - Mettez à jour votre système. - Restreignez les permissions des fichiers sensibles. - Surveillez les logs système. --- ## Conclusion La sécurité est un aspect essentiel de l'administration système. Avec des outils comme `ufw`, des clés SSH et des bonnes pratiques, vous pouvez protéger efficacement votre système contre les menaces. --- # Les différents shells sous Linux --- ## Introduction Un **shell** est une interface entre l'utilisateur et le système d'exploitation. Il interprète les commandes et les exécute. Voici les principaux shells sous Linux : --- ## 1. **Bash (Bourne-Again Shell)** - **Description** : Le shell le plus populaire, successeur du Bourne Shell (sh). - **Caractéristiques** : Autocomplétion, historique des commandes, scripting puissant. - **Cas d'usage** : Utilisation quotidienne, scripts système. - **Exemple** : ```bash echo "Bonjour, monde !" ``` --- ## 2. **sh (Bourne Shell)** - **Description** : Un des premiers shells Unix, simple et portable. - **Caractéristiques** : Compatible avec de nombreux scripts système. - **Cas d'usage** : Scripts système, compatibilité. - **Exemple** : ```bash #!/bin/sh echo "Ce script utilise sh." ``` --- ## 3. **Zsh (Z Shell)** - **Description** : Une version améliorée de Bash, hautement personnalisable. - **Caractéristiques** : Correction automatique, thèmes, plugins (Oh My Zsh). - **Cas d'usage** : Développeurs, utilisateurs avancés. - **Exemple** : ```bash alias ll="ls -la" ``` --- ## 4. **Ksh (Korn Shell)** - **Description** : Combine les fonctionnalités de `sh` et `csh`. - **Caractéristiques** : Scripting avancé, tableaux, expressions régulières. - **Cas d'usage** : Environnements professionnels, scripts complexes. - **Exemple** : ```bash #!/bin/ksh print "Ce script utilise ksh." ``` --- ## 5. **csh (C Shell) et tcsh** - **Description** : Syntaxe proche du langage C. - **Caractéristiques** : Interactivité, moins populaire aujourd'hui. - **Cas d'usage** : Environnements académiques. - **Exemple** : ```bash #!/bin/csh echo "Ce script utilise csh." ``` --- ## 6. **Fish (Friendly Interactive Shell)** - **Description** : Shell moderne et convivial. - **Caractéristiques** : Suggestions intelligentes, configuration simple. - **Cas d'usage** : Débutants, utilisateurs interactifs. - **Exemple** : ```bash echo "Fish est intuitif et coloré." ``` --- ## Comparaison rapide | Shell | Points forts | Cas d'usage | |-------|--------------|-------------| | **Bash** | Polyvalent, scripting | Utilisation générale | | **sh** | Simple, portable | Scripts système | | **Zsh** | Personnalisable, plugins | Développeurs | | **Ksh** | Scripting avancé | Environnements pro | | **csh/tcsh** | Syntaxe proche du C | Académique | | **Fish** | Convivial, suggestions | Débutants | --- ## Changer de shell 1. **Vérifier le shell actuel** : ```bash echo $SHELL ``` 2. **Lister les shells disponibles** : ```bash cat /etc/shells ``` 3. **Changer de shell temporairement** : ```bash zsh # Essayer Zsh ``` 4. **Changer de shell par défaut** : ```bash chsh -s /bin/zsh # Remplacer par le shell souhaité ``` --- ## Conclusion Choisissez **Bash** pour une utilisation générale, **Zsh** pour la personnalisation, ou **Fish** pour une expérience conviviale. Explorez et trouvez celui qui vous convient ! --- ## Commandes Internes et Externes **Internes** Partie intégrante du Shell(builtin) Exemple : cd, set, export, etc. **Externes** Situées à l'intérieur de fichiers individuels Binaires ou script ---- ### Externes ```bash= $ which nano /usr/bin/echo ``` ### Internes ```bash= $ echo $PATH /usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin ``` ### Comment faire la différence ? ```bash= $ type echo echo is a shell builtin # Interne ``` ```bash= $ type man man is /usr/bin/man # Externe ``` --- # Symboles ' et " En tant qu’utilisateur de Linux, vous allez avoir à créer et manipuler des fichiers ou des variables de bien des manières. Il est plutôt facile de travailler avec des noms de fichier courts, et des valeurs simples, mais cela devient beaucoup plus compliqué lorsqu'il y a des caractères du type : espace, !, ?, et autres caractères spéciaux. Les Shell fournissent une fonctionnalité appelée les « quotes » qui encapsule les données à l'intérieur de symboles comme : " " et ' '. ---- ## Essayons afin de voir l'importance des symboles ' et " Entre ces quotes, tous les caractères spéciaux perdent leur signification sauf : - $ (dollar) - \ (backslash) - ` (backquotes/backticks) ```bash= echo je suis $USER ``` ```bash= echo "je suis $USER" ``` Il n'y a aucune différences car *echo* attend une liste de arguments. Et si l'on souhaite créer un fichier de nom : `nouveau fichier` ```bash= # touch permet de créer de nouveaux fichiers touch nouveau fichier # puis ls -l # afin de vérifier si c'est bon ``` Alors ? ---- Recommençons! Commençons par supprimer les fichiers. ```bash= # rm remove rm nouveau fichier ``` Pour jouer avec le shell, nous allons créer un dossier et nous déplacer dedans. ```bash= # Création d'un dossier pour nous entrainer mkdir learning # MaKe directory # Déplacement dans un dossier cd learning # Change Directory ``` ```bash= touch "nouveau fichier" ``` Alors ? ---- ## Simple ou Double quotes ? ```bash= echo je suis $USER ``` Puis ```bash= echo 'je suis $USER' ``` Ici, nous voyons que *$USER* n'est pas remplacé par le *nom de l'utilisateur*. ```bash= # caractère d'échappement echo \$USER ``` Lorsque l'on utilise : - les *simples quotes*, il n'y a pas d'interprétation des variables. - le *backslash*, on échappe *le caractère* suivant. Dans ce cas, le *$* est considéré comme une chaîne de caractères. --- # Variables Locales et Environnementales ---- ## Locales - Disponibles uniquement dans le Shell courant. - Pas d'héritage ```bash= utilisateur=Sam # Attention pas d'espaces avant et après le = !!!! echo $utilisateur $ Sam unset utilisateur # Suppression de la variable echo $utilisateur ``` ---- ## Environnementales / Externes - Disponibles dans tous les Shell et dans tous les subprocesses - Passer des données de configuration aux commandes - S'écrivent en lettres capitales (PATH, DATE, USER, etc.) ```bash= utilisateur=Sam export utilisateur echo $utilisateur # sur la même ligne export utilisateur=Sam ``` --- # Les commandes de Base Ouvrir un terminal : sur le bureau -> cliquez droit -> ouvrir terminale #### Passer en Super Utilisateur (root) ```bash= sudo su ``` #### Sortir du Super Utilisateur (root) ```bash= exit ``` #### Changer d'utilisateur ```bash= su username # actuellement nous n'avons pas d'autres utilisateurs. # Nous verrons pour en créer un par la suite. ``` --- # Obtenir de l'aide ```bash= cat --help ``` ```bash= man cat ``` ```bash= info cat ``` Pour quitter, *info* et *man*, il faut appyer sur la touche *q* du clavier. ---- ## Man (manual) ```bash= man cat ``` Clavier : - *G* : aller à la fin - *g* : revenir au début - *espace* : de page en page - *q* : quitter Rechercher les occurences du mot "word" dans toutes les pages du manuel ```bash= man -k word ``` --- # Aller plus loin --- ## Introduction à la compression Réduire la quantité d'espace qu'un ensemble de données consomme sur l'ordinateur. 2 catégories : - *Lossless* : possibilité de revenir en arrière et de récupérer les données compressées - *Lossy* : Impossible de revenir en arrière et de récupérer les données compressées - Images, vidéos, audios (diminution de la qualité non perceptible) Il existe pleins d'outils de compression sur linux : - *Lossless* : bzip2, xz, gzip ---- ### Archivage des fichiers <div style="display: flex; justify-align: center; align-items: center; width: 100%;"> <div>  </div> <div>  </div> </div> #### Zip fonctionne aussi avec les commandes *zip* et *unzip* (pas dispo par défaut) ---- ### Exercice - Compression ```bash= # Créons 4 fichiers dans un dossier $HOME/learning/archivage/exercice cd # je reviens à la racine mkdir -p learning/archivage/exercice cd /learning/archivage/exercice pwd $ /home/sam/learning/archivage/exercice touch monfichier1 nano monfichier1 # On va copier du lorem à l'intérieur cp monfichier1 monfichier2 cp monfichier1 monfichier3 cp monfichier1 monfichier4 bzip2 monfichier2 ls gzip monfichier3 ls xz monfichier4 ls -lh ``` ---- ### Exercice - Décompression ```bash= bunzip2 monfichier2.bz2 ls gunzip monfichier3.gz ls unxz monfichier4.xz ls gzip -1 monfichier2 gzip -9 monfichier3 ls # quel est le fichier le plus compressé ? zcat monfichier2 # lire du contenu d'un fichier compressé ``` ---- ### Exercice - Archivage Les fichiers créés à partir de la commande *tar* sont appelés des **tarballs**. ```bash= pwd $ /home/sam/learning/archivage/exercice cd $HOME/learning/archivage tar -cf montarball.tar exercice # j'utilise les chemins relatifs tar -tf montarball.tar # affichage des fichiers à l'intérieur de mon tarball # On peut omettre le - de tf ou cf car toujours obligé de mettre des options tar -xf montarball.tar # extraction de tous les fichiers tar -xf montarball.tar monfichier.gz ``` ---- ### Exercice - Archivage / Compression / Décompression ```bash= tar -czf gzip.tar.gz monfichier # archivage puis compression avec gzip tar -cjf gzip.tar.bz2 monfichier # archivage puis compression avec bzip2 tar -cJf gzip.tar.xz monfichier # archivage puis compression avec xz tar -tf montarball.tar # affichage des fichiers tar -uf montarball.tar monfichier # ajout du fichier "monfichier" dans montarball.tar tar -xzf gzip.tar.gz # décompression du gzip tar -xjf gzip.tar.bz2 # décompression du bzip2 tar -xJf gzip.tar.xz # décompression du xz ``` ---- ### Exercice - Zip / Unzip ```bash= # Installation sudo apt update && sudo apt install zip # Reprenons nos fichiers monfichier$ zip zipfile.zip monfichier1 monfichier2 monfichier3 monfichier4 ls mkdir decompress mv zipfile.zip decompress cd decompress unzip zipfile.zip ls ``` ---- ### Résumé Les systèmes Linux possèdent plusieurs outils de compression et d'archivage : *tar* : l’outil d’archivage le plus utilisé *zip* : outil de création d’archive compressée *unzip* : outil de décompression d’archive zip ---- La commande tar possède de très nombreuses options dont seulement quelques-unes sont à retenir : - *x* : extraction - *c* : création - *t* : visualisation - *u* : ajouter et remplacement de fichier - *v* : afficher les différentes étapes lors de la création d’archive ---- Les outils de compression et de décompression parmi les plus utilisés sont les suivants : *gzip* et *gunzip* pour les archives de type *.tar.gz* ou *.tgz* *bzip2* et *bunzip2* pour les archives de type *bz2* *xz* et *unxz* pour les archives de type *xz* --- # Résumé de commandes | Commande | Description | | --------:|:-------------------------------------------------------------------------------------- | | apropos | Permet de rechercher des pages de manuel par mot-clé. Exemple : % apropos permissions, | | whatis | Affiche la description des pages de manuels. Exemple : % whatis chown | | man | Permet de conslter une page de manuel | | vimtutor | Manuel complet de vim | | ls | Lister un répertoire. | | pwd | Où suis-je ? (print working directory) | | cd | Aller dans un répertoire. (change directory) | | cat | Afficher le contenu d’un fichier. | ---- | Commande | Description | | ------------------:|:---------------------------------------------------------------------------------------- | | grep | Afficher uniquement les lignes d’un fichier qui contiennent une expression particulière. | | less, more et most | Afficher un fichier avec pagination. | | cp | Copier un fichier/répertoire. | | mv | Déplacer un fichier/répertoire. | | vi, vim, nano | Éditer un fichier. | | mkdir | Créer un répertoire. | | rm | Supprimer un fichier. | | rmdir | Supprimer un dossier | | ln | Créer un lien vers un fichier. | | chmod | Changer les droits d’un fichier. | ---- | Commande | Description | | ------------:|:-------------------------------------------------------------------- | | chown | Changer le propriétaire d’un fichier. | | chgrp | Changer le groupe d’un fichier. | | su | Changer d’utilisateur (switch user). | | w | Afficher ce que font les utilisateurs du système. | | tar | Compresse/décompresse les archives aux formats tar, tar.gz, tar.bz2. | | zip, unzip | Compresse/décompresse les archives aux format zip. | | find, locate | Trouver un fichier. | | head | Afficher le début d’un fichier. | | tail | Afficher la fin d’un fichier. | ---- | Commande | Description | | ----------:|:------------------------------------------------- | | mount | Monter (rendre accessible) un système de fichier. | | ssh | Obtenir un terminal distant (secure shell). | | scp | Copier des fichiers à distance(secure copy). | | tail | Imprimer les derniers éléments d'une entrée | | wget, curl | Télécharger un fichier. | --- ## **Pipelines (`|`)** Les **pipelines** permettent de rediriger la sortie d'une commande vers l'entrée d'une autre. C'est un outil puissant pour enchaîner des commandes. ### Exemples : 1. **Compter le nombre de fichiers dans un répertoire** : ```bash ls | wc -l ``` 2. **Filtrer les processus en cours** : ```bash ps aux | grep "nginx" ``` 3. **Trier et afficher les lignes uniques** : ```bash cat fichier.txt | sort | uniq ``` --- # Encore beaucoup de choses existent 🤯 --- ## **Commandes avancées de manipulation de texte** 1. **`tr`** : Translittérer ou supprimer des caractères. - Exemples : ```bash echo "hello" | tr 'a-z' 'A-Z' # Convertit en majuscules echo "hello123" | tr -d '0-9' # Supprime les chiffres ``` 2. **`cut`** : Extraire des colonnes ou des champs d'un fichier. - Exemples : ```bash echo "un:deux:trois" | cut -d ':' -f 2 # Extrait "deux" ``` ---- 3. **`awk`** : Traiter des fichiers texte ligne par ligne. - Exemples : ```bash awk '{print $1}' fichier.txt # Affiche la première colonne awk '/motif/ {print $0}' fichier.txt # Affiche les lignes contenant "motif" ``` 4. **`sed`** : Éditer des flux de texte (remplacement, suppression, etc.). - Exemples : ```bash sed 's/foo/bar/' fichier.txt # Remplace "foo" par "bar" sed '/pattern/d' fichier.txt # Supprime les lignes contenant "pattern" ``` --- ## **Substitutions de commandes** Les **substitutions de commandes** permettent d'exécuter une commande et d'utiliser sa sortie comme argument pour une autre commande. ### Syntaxe : - **`$(commande)`** ou **`` `commande` ``** (obsolète). ### Exemples : 1. **Utiliser la sortie d'une commande dans une autre** : ```bash echo "Aujourd'hui, nous sommes le $(date)" ``` 2. **Compter le nombre de fichiers dans un répertoire** : ```bash echo "Il y a $(ls | wc -l) fichiers dans ce répertoire." ``` --- ## **Expansions** ### 1. **Arithmetic Expansion (`$((...))`)** : Permet d'effectuer des calculs arithmétiques. - Exemple : ```bash echo $((5 + 3 * 2)) # Affiche 11 ``` ### 2. **Filename Expansion (Globbing)** : Permet d'utiliser des motifs pour sélectionner des fichiers. - Exemples : ```bash ls *.txt # Liste tous les fichiers .txt ls fichier{1..5}.txt # Liste fichier1.txt à fichier5.txt ``` --- ### 3. **Brace Expansion (`{...}`)** : Génère des combinaisons de chaînes. - Exemples : ```bash echo {A,B,C}.txt # Affiche A.txt B.txt C.txt mkdir -p dossier/{sous1,sous2} # Crée dossier/sous1 et dossier/sous2 ``` --- ## **Liens symboliques et physiques (`ln`)** 1. **Liens symboliques (symlinks)** : - Crée un pointeur vers un fichier ou un répertoire. - Exemple : ```bash ln -s /chemin/vers/fichier lien_symbolique ``` 2. **Liens physiques (hard links)** : - Crée une copie directe d'un fichier (même inode). - Exemple : ```bash ln fichier.txt lien_physique ``` --- ## **Redirections avancées** 1. **Rediriger la sortie standard et les erreurs** : - Exemple : ```bash commande > fichier.txt 2>&1 # Redirige tout vers fichier.txt ``` 2. **Rediriger vers `/dev/null`** : - Exemple : ```bash commande > /dev/null 2>&1 # Ignore toute sortie ``` 3. **Rediriger vers un processus** : - Exemple : ```bash commande1 | commande2 # Redirige la sortie de commande1 vers commande2 ``` --- ## **Gestion des processus en arrière-plan** 1. **Lancer un processus en arrière-plan** : - Exemple : ```bash sleep 60 & ``` 2. **Ramener un processus au premier plan** : - Exemple : ```bash fg %1 # Ramène le processus avec l'ID 1 ``` 3. **Suspendre un processus** : - Exemple : ```bash Ctrl + Z # Suspend le processus en cours ``` --- ## **Commandes utiles pour les développeurs** 1. **`curl`** : Tester des API ou télécharger des fichiers. - Exemples : ```bash curl https://api.github.com # Tester une API curl -O https://example.com/fichier.txt # Télécharger un fichier ``` 2. **`jq`** : Manipuler des fichiers JSON. - Exemple : ```bash echo '{"name": "John", "age": 30}' | jq '.name' # Affiche "John" ``` ---- 3. **`tmux`** : Gestion de sessions terminal. - Exemples : ```bash tmux new -s session1 # Créer une nouvelle session tmux attach -t session1 # Rejoindre une session existante ``` 4. **`rsync`** : Synchronisation de fichiers. - Exemple : ```bash rsync -avz /source/ /destination/ # Synchroniser des fichiers ``` --- ## **Astuces pour les développeurs** 1. **Utiliser `&&` pour enchaîner des commandes** : - Exemple : ```bash make && make install # Exécute `make install` seulement si `make` réussit ``` 2. **Utiliser `||` pour gérer les erreurs** : - Exemple : ```bash commande1 || commande2 # Exécute `commande2` si `commande1` échoue ``` 3. **Utiliser `xargs` pour traiter des listes** : - Exemple : ```bash ls *.txt | xargs rm # Supprime tous les fichiers .txt ``` ---- 4. **Utiliser `tee` pour rediriger et afficher** : - Exemple : ```bash echo "test" | tee fichier.txt # Écrit dans fichier.txt et affiche à l'écran ``` 5. **Utiliser `watch` pour surveiller des commandes** : - Exemple : ```bash watch -n 1 "ls -l" # Affiche `ls -l` toutes les secondes ``` --- ## **Conclusion** Ces commandes et astuces avancées sont essentielles pour les développeurs travaillant sur Linux. Elles permettent d'automatiser des tâches, de manipuler des données efficacement, et de gérer des processus complexes. En maîtrisant ces outils, vous gagnerez en productivité et en efficacité dans votre travail quotidien. --- # Gestion des processus sous Linux --- ## Introduction aux processus Un **processus** est une instance d'un programme en cours d'exécution. Chaque processus a un identifiant unique appelé **PID** (Process ID). Sous Linux, il existe plusieurs commandes pour surveiller, gérer et interagir avec les processus. --- ## **Commandes de base pour gérer les processus** ### 1. **`ps`** : Afficher les processus en cours La commande `ps` (Process Status) permet de lister les processus en cours d'exécution. #### Options courantes : - **`ps aux`** : Affiche tous les processus avec des détails complets. ```bash ps aux ``` - **`USER`** : Propriétaire du processus. - **`PID`** : Identifiant du processus. - **`%CPU`** : Utilisation du CPU. - **`%MEM`** : Utilisation de la mémoire. - **`COMMAND`** : Commande lancée. - **`ps -ef`** : Affiche les processus avec des informations supplémentaires. ```bash ps -ef ``` --- - **`ps -e`** : Affiche tous les processus. ```bash ps -e ``` - **`ps -u utilisateur`** : Affiche les processus d'un utilisateur spécifique. ```bash ps -u root ``` --- ### 2. **`top`** : Surveiller les processus en temps réel La commande `top` affiche les processus en temps réel, avec des informations sur l'utilisation du CPU, de la mémoire, et plus encore. #### Utilisation : ```bash top ``` #### Commandes dans `top` : - **`k`** : Tuer un processus (saisir le PID). - **`q`** : Quitter `top`. - **`P`** : Trier par utilisation du CPU. - **`M`** : Trier par utilisation de la mémoire. - **`h`** : Afficher l'aide. #### Exemple de sortie : ``` PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 1234 root 20 0 12345 6789 1234 R 50.0 2.0 0:10.00 process_name ``` --- ### 3. **`htop`** : Version améliorée de `top` `htop` est une version interactive et plus conviviale de `top`. Il permet de naviguer et de gérer les processus avec des raccourcis clavier. #### Installation : ```bash sudo apt install htop # Debian/Ubuntu sudo yum install htop # CentOS/RHEL ``` #### Utilisation : ```bash htop ``` #### Commandes dans `htop` : - **`F9`** : Tuer un processus. - **`F6`** : Trier les processus. - **`F3`** : Rechercher un processus. - **`F10`** : Quitter `htop`. --- ### 4. **`kill`** : Terminer un processus La commande `kill` permet d'envoyer un signal à un processus pour le terminer ou le suspendre. #### Syntaxe : ```bash kill [options] PID ``` #### Signaux courants : - **`SIGTERM` (15)** : Termine proprement le processus (par défaut). ```bash kill 1234 ``` - **`SIGKILL` (9)** : Force la terminaison du processus. ```bash kill -9 1234 ``` #### Exemple : ```bash kill 1234 # Termine le processus avec le PID 1234 kill -9 1234 # Force la terminaison du processus ``` --- ### 5. **`pkill`** : Terminer un processus par son nom `pkill` permet de terminer un processus en utilisant son nom plutôt que son PID. #### Exemples : ```bash pkill firefox # Termine tous les processus Firefox pkill -u utilisateur # Termine tous les processus d'un utilisateur ``` --- ### 6. **`killall`** : Terminer tous les processus d'un nom donné `killall` est similaire à `pkill`, mais il termine tous les processus correspondant au nom donné. #### Exemple : ```bash killall firefox # Termine tous les processus Firefox ``` --- ### 7. **`nice` et `renice`** : Gérer la priorité des processus - **`nice`** : Lance un processus avec une priorité spécifique. - La priorité va de **-20** (la plus haute) à **19** (la plus basse). - Exemple : ```bash nice -n 10 commande # Lance la commande avec une priorité de 10 ``` - **`renice`** : Modifie la priorité d'un processus en cours d'exécution. - Exemple : ```bash renice 5 -p 1234 # Change la priorité du processus 1234 à 5 ``` --- ### 8. **`bg` et `fg`** : Gérer les processus en arrière-plan et premier plan - **`bg`** : Met un processus en arrière-plan. - Exemple : ```bash bg # Met le dernier processus suspendu en arrière-plan ``` - **`fg`** : Ramène un processus au premier plan. - Exemple : ```bash fg # Ramène le dernier processus en arrière-plan au premier plan ``` --- ### 9. **`jobs`** : Lister les processus en arrière-plan La commande `jobs` affiche les processus en arrière-plan associés à la session courante. #### Exemple : ```bash jobs # Sortie : [1] + running sleep 100 ``` --- ### 10. **`nohup`** : Exécuter un processus qui continue après la déconnexion `nohup` permet de lancer un processus qui continue à s'exécuter même après la déconnexion de l'utilisateur. #### Exemple : ```bash nohup long_running_command & ``` --- ## **Surveillance avancée des processus** ### 1. **`lsof`** : Lister les fichiers ouverts par les processus `lsof` (List Open Files) affiche les fichiers ouverts par les processus. #### Exemples : ```bash lsof # Liste tous les fichiers ouverts lsof -u utilisateur # Liste les fichiers ouverts par un utilisateur lsof -p 1234 # Liste les fichiers ouverts par un processus spécifique ``` --- ### 2. **`strace`** : Surveiller les appels système d'un processus `strace` permet de suivre les appels système et les signaux d'un processus. #### Exemple : ```bash strace -p 1234 # Surveille les appels système du processus 1234 ``` --- ### 3. **`vmstat`** : Afficher les statistiques système `vmstat` affiche des informations sur la mémoire, les processus, les E/S, et plus encore. #### Exemple : ```bash vmstat 1 # Affiche les statistiques toutes les secondes ``` --- ### 4. **`iotop`** : Surveiller les E/S des processus `iotop` affiche les processus utilisant le plus d'E/S (entrées/sorties). #### Installation : ```bash sudo apt install iotop # Debian/Ubuntu sudo yum install iotop # CentOS/RHEL ``` #### Utilisation : ```bash iotop ``` --- ## **Conclusion** La gestion des processus est une compétence essentielle pour tout utilisateur ou développeur Linux. Avec des commandes comme `ps`, `top`, `htop`, `kill`, et d'autres, vous pouvez surveiller, contrôler et optimiser les ressources de votre système. Ces outils vous permettent de diagnostiquer des problèmes de performance, de terminer des processus bloqués, et de gérer efficacement les tâches en arrière-plan. --- # **`awk`**, **`jq`**, **`sed`** --- ## **1. `awk` : Traitement de texte avancé** `awk` est un langage de script puissant pour traiter et analyser des fichiers texte, en particulier des fichiers structurés (comme les fichiers CSV ou les logs). ### Syntaxe de base : ```bash awk 'pattern { action }' fichier.txt ``` ### Exemples : 1. **Afficher la première colonne d'un fichier** : ```bash awk '{print $1}' fichier.txt ``` 2. **Afficher les lignes contenant un motif** : ```bash awk '/motif/ {print $0}' fichier.txt ``` ---- 3. **Afficher la somme d'une colonne** : ```bash awk '{sum += $1} END {print sum}' fichier.txt ``` 4. **Utiliser un délimiteur personnalisé** : ```bash awk -F':' '{print $1}' /etc/passwd # Utilise ':' comme délimiteur ``` 5. **Filtrer et formater** : ```bash awk '$3 > 100 {print "Utilisateur:", $1, "UID:", $3}' /etc/passwd ``` --- ## **2. `jq` : Manipulation de JSON** `jq` est un outil en ligne de commande pour traiter et manipuler des données JSON. Il est très utile pour interagir avec des API ou analyser des fichiers JSON. ### Installation : ```bash sudo apt install jq # Debian/Ubuntu sudo yum install jq # CentOS/RHEL ``` ### Exemples : 1. **Afficher un champ JSON** : ```bash echo '{"name": "John", "age": 30}' | jq '.name' # Sortie : "John" ``` 2. **Afficher un tableau JSON** : ```bash echo '[{"name": "John"}, {"name": "Jane"}]' | jq '.[].name' # Sortie : "John" "Jane" ``` ---- 3. **Filtrer un tableau JSON** : ```bash echo '[{"name": "John", "age": 30}, {"name": "Jane", "age": 25}]' | jq '.[] | select(.age > 28)' # Sortie : {"name": "John", "age": 30} ``` 4. **Formater la sortie JSON** : ```bash echo '{"name": "John", "age": 30}' | jq '.name, .age' # Sortie : "John" 30 ``` 5. **Manipuler des fichiers JSON** : ```bash jq '.users[] | select(.active == true)' fichier.json ``` --- ## **3. `sed` : Édition de flux de texte** `sed` (Stream Editor) est un outil puissant pour éditer des flux de texte en utilisant des commandes simples ou des expressions régulières (regex). ### Syntaxe de base : ```bash sed 's/motif/remplacement/' fichier.txt ``` ### Exemples : 1. **Remplacer un motif** : ```bash echo "hello world" | sed 's/world/Linux/' # Sortie : hello Linux ``` 2. **Supprimer des lignes** : ```bash sed '/motif/d' fichier.txt # Supprime les lignes contenant "motif" ``` ---- 3. **Ajouter du texte avant ou après une ligne** : ```bash sed '3i\Nouvelle ligne' fichier.txt # Insère une ligne avant la ligne 3 sed '3a\Nouvelle ligne' fichier.txt # Ajoute une ligne après la ligne 3 ``` 4. **Modifier uniquement les lignes correspondant à un motif** : ```bash sed '/motif/s/foo/bar/' fichier.txt # Remplace "foo" par "bar" sur les lignes contenant "motif" ``` 5. **Utiliser des délimiteurs personnalisés** : ```bash echo "hello/world" | sed 's|/| |' # Sortie : hello world ``` --- ## **4. Expressions régulières (regex) avec `sed`** Les **expressions régulières** sont des motifs utilisés pour rechercher et manipuler du texte. Voici quelques exemples de regex avec `sed` : ### Caractères spéciaux courants : - **`.`** : Correspond à n'importe quel caractère. - **`*`** : Correspond à 0 ou plusieurs occurrences du caractère précédent. - **`^`** : Correspond au début d'une ligne. - **`$`** : Correspond à la fin d'une ligne. - **`[abc]`** : Correspond à l'un des caractères `a`, `b`, ou `c`. - **`[^abc]`** : Correspond à tout caractère sauf `a`, `b`, ou `c`. - **`\d`** : Correspond à un chiffre (nécessite `-E` pour activer les regex étendues). :::success Super outils en ligne [regex101](https://regex101.com/) ::: ---- ### Exemples avec `sed` : 1. **Remplacer un motif avec regex** : ```bash echo "123-456-7890" | sed -E 's/[0-9]{3}/XXX/' # Sortie : XXX-456-7890 ``` 2. **Supprimer les lignes vides** : ```bash sed '/^$/d' fichier.txt ``` 3. **Remplacer toutes les occurrences d'un motif** : ```bash echo "foo foo foo" | sed 's/foo/bar/g' # Sortie : bar bar bar ``` ---- 4. **Extraire des lignes correspondant à un motif** : ```bash sed -n '/motif/p' fichier.txt ``` 5. **Utiliser des groupes de capture** : ```bash echo "John Doe" | sed -E 's/(.*) (.*)/\2, \1/' # Sortie : Doe, John ``` 6. **Remplacer uniquement à une position spécifique** : ```bash echo "hello world" | sed 's/o/O/2' # Sortie : hello wOrld (remplace la deuxième occurrence de "o") ``` --- ## **5. Combinaison d'outils** Ces outils peuvent être combinés pour des tâches complexes. Voici quelques exemples : 1. **Extraire et formater des données** : ```bash cat fichier.log | awk '/ERROR/ {print $1, $2}' | sed 's/:/ /' ``` 2. **Manipuler des données JSON et les filtrer** : ```bash curl https://api.example.com/data | jq '.items[] | select(.status == "active")' | awk '{print $1}' ``` 3. **Remplacer des motifs dans un fichier JSON** : ```bash cat fichier.json | jq '.' | sed 's/foo/bar/g' ``` --- ## **Conclusion** - **`awk`** est idéal pour traiter des fichiers structurés et effectuer des calculs. - **`jq`** est indispensable pour manipuler des données JSON. - **`sed`** est un outil puissant pour éditer du texte en utilisant des expressions régulières. En maîtrisant ces outils, vous pouvez automatiser des tâches complexes, analyser des logs, manipuler des données, et bien plus encore. Les expressions régulières ajoutent une couche de flexibilité pour des recherches et remplacements avancés. --- # WSL (Windows Subsystem for Linux) --- ## **Activation de WSL (Windows Subsystem for Linux)** ### **Étape 1 : Vérifier les prérequis** - **Système d'exploitation** : Windows 10 (version 2004 ou ultérieure) ou Windows 11. - **Architecture** : Processeur 64 bits avec support de la virtualisation activé dans le BIOS. --- ### **Étape 2 : Activer WSL** #### **Méthode 1 : Via l'interface graphique** 1. Ouvrez le **Panneau de configuration**. 2. Allez dans **Programmes > Activer ou désactiver des fonctionnalités Windows**. 3. Cochez les cases suivantes : - **Sous-système Windows pour Linux** - **Plateforme de machine virtuelle** (nécessaire pour WSL 2) 4. Cliquez sur **OK** et redémarrez votre ordinateur. #### **Méthode 2 : Via PowerShell (recommandé)** 1. Ouvrez **PowerShell en mode administrateur**. 2. Exécutez la commande suivante pour activer WSL et installer la dernière version (WSL 2) : ```bash wsl --install ``` - Cette commande active automatiquement les fonctionnalités nécessaires et installe la distribution Linux par défaut (Ubuntu). 3. **Redémarrez votre ordinateur** pour appliquer les modifications. --- ### **Étape 3 : Installer une distribution Linux** 1. **Via le Microsoft Store** : - Ouvrez le **Microsoft Store**. - Recherchez la distribution Linux de votre choix (par exemple, **Ubuntu**, **Debian**, **Kali Linux**). - Cliquez sur **Installer**. 2. **Via la ligne de commande** : - Vous pouvez installer une distribution directement depuis PowerShell avec la commande suivante : ```bash wsl --list wsl --install -d <NomDeLaDistribution> ``` - Exemple pour installer Ubuntu : ```bash wsl --install -d Ubuntu ``` --- ### **Étape 4 : Configurer WSL 2 (optionnel mais recommandé)** WSL 2 est la version la plus récente et offre de meilleures performances et une compatibilité accrue avec les applications Linux. 1. Vérifiez la version de WSL installée : ```bash wsl --list --verbose ``` - Si la version est **1**, vous pouvez la mettre à jour vers WSL 2. 2. Mettre à jour une distribution vers WSL 2 : ```bash wsl --set-version <NomDeLaDistribution> 2 ``` - Exemple pour Ubuntu : ```bash wsl --set-version Ubuntu 2 ``` 3. Définir WSL 2 comme version par défaut pour les nouvelles installations : ```bash wsl --set-default-version 2 ``` --- ## **Différences entre WSL 1 et WSL 2** | **Aspect** | **WSL 1** | **WSL 2** | |----------------------|---------------------------------------------------------------------------|---------------------------------------------------------------------------| | **Architecture** | Utilise une couche de compatibilité pour exécuter des binaires Linux. | Utilise un noyau Linux complet virtualisé via Hyper-V. | | **Performance** | Moins performant pour les opérations système (comme les appels système). | Beaucoup plus rapide, surtout pour les opérations système et les E/S. | | **Compatibilité** | Compatible avec la plupart des applications Linux. | Compatibilité presque totale avec les applications Linux. | | **Intégration** | Meilleure intégration avec les fichiers Windows. | Intégration légèrement moins fluide avec les fichiers Windows. | --- Voici un tableau comparatif détaillé entre **WSL (Windows Subsystem for Linux)** et les **Machines Virtuelles (VM)**, suivi d'une explication et d'une image illustrative. --- ## **Tableau comparatif : WSL vs Machines Virtuelles** | **Aspect** | **WSL** | **Machines Virtuelles (VM)** | |--------------------------|-------------------------------------------------------------------------|--------------------------------------------------------------------------| | **Performance** | Léger et rapide, utilise moins de ressources système. | Plus lent en raison de la virtualisation complète. | | **Intégration avec Windows** | Intégration native, accès direct aux fichiers Windows via `/mnt/c/`. | Nécessite des dossiers partagés ou des transferts manuels. | | **Installation** | Simple, en quelques commandes. | Complexe, nécessite un logiciel de virtualisation (VMware, VirtualBox). | | **Ressources** | Utilisation optimisée des ressources (mémoire, CPU). | Consommation élevée de ressources (mémoire, CPU, espace disque). | | **Isolation** | Moins isolé, partage le noyau Windows. | Isolation complète, environnement sécurisé et indépendant. | ---- | **Aspect** | **WSL** | **Machines Virtuelles (VM)** | |--------------------------|-------------------------------------------------------------------------|--------------------------------------------------------------------------| | **Support des OS** | Seulement Linux (WSL 1 : noyau Windows, WSL 2 : noyau Linux). | Supporte tous les systèmes d'exploitation (Linux, Windows, macOS, etc.). | | **Interface graphique** | Support limité (WSLg permet des applications graphiques simples). | Support complet des interfaces graphiques (GNOME, KDE, etc.). | | **Cas d'usage** | Développement, scripts, outils en ligne de commande. | Environnements complets, tests, déploiement multi-OS. | | **Sécurité** | Moins sécurisé, intégré à Windows. | Très sécurisé, isolation totale entre l'hôte et le système invité. | | **Démarrage** | Démarrer WSL est presque instantané. | Le démarrage d'une VM peut prendre plusieurs secondes ou minutes. | --- ## **Explication des différences** ### **1. Performance** - **WSL** : WSL 2 utilise un noyau Linux léger virtualisé via Hyper-V, ce qui permet une meilleure utilisation des ressources système. Il est idéal pour les tâches de développement et les scripts. - **VM** : Les machines virtuelles nécessitent une virtualisation complète, ce qui entraîne une surcharge de performance, surtout si plusieurs VM sont exécutées simultanément . ### **2. Intégration avec Windows** - **WSL** : Les fichiers Windows sont accessibles directement depuis Linux via `/mnt/c/`, ce qui facilite le partage de données entre les deux systèmes. - **VM** : Les fichiers doivent être partagés via des dossiers partagés ou des transferts manuels, ce qui est moins pratique . ---- ### **3. Installation et gestion** - **WSL** : L'installation est simple et rapide, avec des commandes comme `wsl --install`. Aucune configuration complexe n'est nécessaire. - **VM** : Nécessite l'installation d'un logiciel de virtualisation (comme VMware ou VirtualBox), ainsi que la création et la configuration d'une machine virtuelle . ### **4. Cas d'usage** - **WSL** : Idéal pour les développeurs qui ont besoin d'exécuter des outils Linux (comme Bash, Python, Docker) directement sur Windows. - **VM** : Convient mieux pour les scénarios nécessitant une isolation complète ou l'exécution de plusieurs systèmes d'exploitation simultanément . ### **5. Interface graphique** - **WSL** : WSLg permet d'exécuter des applications graphiques Linux, mais le support est limité. - **VM** : Offre un support complet des interfaces graphiques, ce qui est idéal pour tester des environnements de bureau Linux . --- ## **Conclusion** - **WSL** est une solution légère et intégrée pour exécuter des outils Linux sur Windows, idéale pour les développeurs et les utilisateurs occasionnels. - **Les machines virtuelles** offrent une isolation complète et sont mieux adaptées pour des scénarios nécessitant plusieurs systèmes d'exploitation ou des environnements graphiques complets. Choisissez **WSL** si vous avez besoin d'une solution rapide et intégrée pour le développement. Optez pour une **machine virtuelle** si vous avez besoin d'un environnement complet et isolé.