Contactez-nous

Linux : les bases pour une prise en main rapide et efficace

Apprenez Linux rapidement ! Ce cours pour débutants vous rend opérationnel sur la ligne de commande, la gestion de fichiers et l'administration de base. Idéal pour une prise en main efficace.

Table des matières

  1. Découverte de Linux et première immersion
    1. Qu'est-ce que Linux et pourquoi l'utiliser ?
      1. La philosophie open source et la communauté Linux
      2. Importance de Linux dans l'IT moderne (serveurs, cloud, embarqué, développement)
      3. Les distributions Linux : un écosystème varié (Ubuntu, Debian, Fedora/CentOS en exemples)
    2. Le vocabulaire essentiel de Linux
      1. Noyau (Kernel), Shell, Terminal, Interface graphique (GUI)
      2. Utilisateur (root vs utilisateur standard), Groupe, Permissions (introduction)
      3. Système de fichiers, Répertoire (Dossier), Fichier
    3. Préparer votre environnement Linux
      1. Options pour utiliser Linux : machine virtuelle (recommandé), dual boot, WSL (Windows Subsystem for Linux)
      2. Guide rapide d'installation d'Ubuntu Desktop sur une machine virtuelle (VirtualBox/VMware)
      3. Première connexion et découverte de l'interface graphique et du terminal
  2. Les fondations : la ligne de commande et le système de fichiers
    1. La ligne de commande (Shell) : votre principal outil
      1. Introduction au shell Bash : pourquoi et comment l'utiliser efficacement
      2. Structure d'une commande : commande, options, arguments
      3. Obtenir de l'aide : les commandes `man` et l'option `--help`
    2. Naviguer dans le système de fichiers
      1. Comprendre l'arborescence Linux standard (/, /home, /etc, /var, /usr, /bin, /sbin)
      2. Commandes essentielles de navigation : `pwd`, `ls` (et ses options utiles comme `-l`, `-a`), `cd`
      3. Chemins absolus vs chemins relatifs : comprendre et utiliser les deux
    3. Gérer les fichiers et répertoires
      1. Création : `mkdir` (répertoires), `touch` (fichiers vides ou mise à jour du timestamp)
      2. Copie, déplacement, suppression : `cp`, `mv`, `rm`, `rmdir` (et l'option `-r` avec prudence)
      3. Affichage du contenu : `cat`, `less`, `more`, `head`, `tail`
      4. Exemple concret 1 : Créer une arborescence de projet simple (ex: `mon_projet/src`, `mon_projet/docs`)
    4. Comprendre et gérer les permissions de fichiers
      1. Les droits : lire (r), écrire (w), exécuter (x) pour l'utilisateur (owner), le groupe, et les autres
      2. Visualiser les permissions et le propriétaire avec `ls -l`
      3. Modifier les permissions avec `chmod` (modes octal et symbolique de base)
      4. Changer le propriétaire et le groupe avec `chown` et `chgrp` (introduction)
      5. Exemple concret 2 : Rendre un script personnel exécutable
  3. Processus et outils essentiels pour l'administration de base
    1. Gestion des utilisateurs et des groupes (notions de base)
      1. Le superutilisateur `root` et l'importance de la commande `sudo`
      2. Ajouter et supprimer un utilisateur (commandes `useradd`, `passwd`, `userdel` en bref)
    2. Processus : installer et gérer des logiciels
      1. Les gestionnaires de paquets : rôle et avantages (ex: `apt` pour Debian/Ubuntu, `dnf`/`yum` pour Fedora/RHEL)
      2. Séquence d'actions : mettre à jour la liste des paquets, rechercher, installer, mettre à jour et supprimer un paquet
      3. Exemple concret 3 : Installer un utilitaire pratique (ex: `htop` ou `tree`) et un serveur web simple (ex: Nginx)
    3. Les outils essentiels du quotidien
      1. Le terminal (Bash) : récapitulatif, historique des commandes, auto-complétion (Tab)
      2. Un éditeur de texte en ligne de commande : `nano` (prise en main rapide) et introduction à `vim` (ouvrir, modifier, sauvegarder, quitter)
      3. Visualiser l'utilisation des ressources : `top` ou `htop`, `df`, `du`, `free`
      4. Rechercher des fichiers et du texte : `find` (bases), `grep` (bases)
  4. Gérer les défis, erreurs courantes et bonnes pratiques
    1. Anticiper et résoudre les problèmes fréquents des débutants
      1. Erreur "Commande non trouvée" : vérifier le `PATH` (concept), les erreurs de frappe et l'installation du paquet
      2. Erreur "Permission non accordée" : vérifier les droits du fichier/répertoire et l'utilisation correcte de `sudo`
      3. Problèmes de dépendances lors de l'installation de logiciels (rôle du gestionnaire de paquets)
      4. Où chercher de l'aide ? Logs système de base (ex: `/var/log/apt/history.log`), forums, documentation officielle
    2. Bonnes pratiques fondamentales pour un usage serein et efficace
      1. Utiliser `sudo` avec discernement : ne pas travailler en `root` en permanence
      2. Comprendre l'importance des mises à jour régulières du système (`sudo apt update && sudo apt upgrade`)
      3. Nommer ses fichiers et répertoires de manière claire et cohérente (éviter les espaces et caractères spéciaux)
      4. Organiser ses fichiers personnels et ses projets
      5. Introduction à la redirection et aux tubes (`>`, `>>`, `|`) pour combiner des commandes
  5. Mise en pratique guidée pour consolider les acquis
    1. Exercice 1 : Configuration d'un environnement web local simple
      1. Objectif : Installer un serveur web, créer une page HTML de base et y accéder localement
      2. Etapes guidées : Installation de Nginx, création d'un fichier `index.html` dans `/var/www/html` (ou équivalent), vérification des permissions, test d'accès via un navigateur sur `http://localhost`
    2. Exercice 2 : Manipulation de fichiers et écriture d'un premier script shell simple
      1. Objectif : Créer un script qui sauvegarde quelques fichiers de configuration importants
      2. Etapes guidées : Créer un répertoire `mes_sauvegardes`, écrire un script `sauvegarde.sh` utilisant `cp` pour copier 2-3 fichiers (ex: `/etc/hosts`, un fichier de votre `/home`), rendre le script exécutable et le tester
    3. Prochaines étapes et ressources pour aller plus loin
      1. Introduction à la gestion des services avec `systemctl` (démarrer, arrêter, vérifier le statut)
      2. Les bases du réseau sous Linux (visualiser son IP avec `ip addr`, tester la connectivité avec `ping`)
      3. Pistes pour approfondir : scripting shell avancé, conteneurisation (Docker), administration serveur plus poussée, exploration d'autres distributions