Guide débutant : comprendre les bases (pas à pas)

Ce tutoriel est conçu pour quelqu’un qui débute et qui veut comprendre les bases de l’informatique “pratique” : comment fonctionne un système, comment se repérer dans un terminal, manipuler des fichiers, installer des logiciels, comprendre le réseau, et automatiser des tâches simples. L’objectif n’est pas d’apprendre “par cœur”, mais de comprendre ce que vous faites.

Hypothèse : vous utilisez Linux (Ubuntu/Debian) ou macOS. Sur Windows, beaucoup de concepts sont identiques, mais les commandes changent (PowerShell, CMD). Si vous êtes sur Windows, vous pouvez suivre avec WSL (Windows Subsystem for Linux) pour avoir un environnement Linux.

1) Les notions fondamentales : système, programmes, fichiers

1.1 Système d’exploitation (OS) : le chef d’orchestre

Un ordinateur exécute des programmes, mais ces programmes ont besoin d’un intermédiaire pour accéder au matériel (disque, réseau, écran). Cet intermédiaire, c’est le système d’exploitation (Linux, macOS, Windows).

Le rôle de l’OS :

gérer la mémoire (RAM) et le processeur (CPU) ;
gérer les droits d’accès (qui peut lire/écrire quoi) ;
gérer les processus (programmes en cours d’exécution) ;
fournir un système de fichiers (organisation des données) ;
fournir des outils (shell, commandes, bibliothèques).

1.2 Fichiers et dossiers : une arborescence

Vos données sont organisées en répertoires (dossiers) et fichiers. Sur Linux/macOS, tout part de la racine /.

Quelques répertoires importants (Linux) :

/home/votre_nom : vos fichiers personnels (souvent abrégé ~)
/etc : configuration système
/var : données variables (logs, cache, etc.)
/tmp : fichiers temporaires
/usr/bin : beaucoup de programmes

Comprendre l’arborescence est crucial : quand vous lancez une commande, elle s’exécute dans un répertoire courant.

2) Le terminal : votre outil le plus puissant

2.1 Pourquoi apprendre le terminal ?

Le terminal (ou “shell”) permet :

d’être précis et rapide ;
d’automatiser (scripts) ;
de reproduire exactement une suite d’actions ;
de diagnostiquer des problèmes (réseau, disque, permissions).

Sur Linux/macOS, le shell est souvent bash ou zsh.

2.2 Se repérer : où suis-je ?

Ouvrez un terminal, puis :

pwd

pwd = print working directory : affiche le chemin du répertoire courant.

Listez le contenu :

ls

Liste détaillée :

ls -l

Inclure les fichiers cachés (commencent par .) :

ls -la

Les options (comme -l, -a) modifient le comportement d’une commande. Beaucoup de commandes suivent ce modèle.

2.3 Naviguer

Aller dans un dossier :

cd Documents

Revenir au dossier précédent :

cd ..

Aller directement à votre “home” :

cd ~

Revenir au répertoire précédent (très pratique) :

cd -

3) Manipuler fichiers et dossiers (sans peur)

3.1 Créer dossiers et fichiers

Créer un dossier :

mkdir projet

Créer des dossiers imbriqués d’un coup :

mkdir -p projet/src projet/data

Créer un fichier vide :

touch projet/README.md

touch sert aussi à mettre à jour la date de modification d’un fichier.

3.2 Copier, déplacer, renommer

Copier un fichier :

cp projet/README.md projet/README.copy.md

Copier un dossier (récursif) :

cp -r projet projet_backup

Déplacer / renommer :

mv projet/README.copy.md projet/docs.md

3.3 Supprimer (attention)

Supprimer un fichier :

rm projet/docs.md

Supprimer un dossier et son contenu :

rm -r projet_backup

Supprimer “sans demander” (dangereux) :

rm -rf projet_backup

Compréhension importante : rm supprime réellement (pas de corbeille dans beaucoup de contextes). Avant un rm -r, vérifiez avec ls ce que vous visez.

4) Lire et éditer du texte

4.1 Afficher le contenu

Afficher un fichier :

cat projet/README.md

Afficher page par page :

less /var/log/system.log

Dans less :

q pour quitter
/mot pour chercher
n pour occurrence suivante

Afficher le début / la fin :

head -n 20 projet/README.md
tail -n 20 projet/README.md

Suivre un fichier qui s’actualise (logs) :

tail -f /var/log/syslog

4.2 Éditer : nano (simple) ou vim (puissant)

Éditer avec nano :

nano projet/README.md

Ctrl+O enregistrer
Ctrl+X quitter

vim (si vous voulez apprendre plus tard) :

vim projet/README.md

5) Comprendre permissions et propriété (un pilier)

Sur Linux/macOS, chaque fichier a :

un propriétaire (user)
un groupe
des permissions : lecture (r), écriture (w), exécution (x)

Regardez :

ls -l

Exemple de sortie typique :

-rw-r--r--  1 alice staff  1200 Mar 22 10:00 README.md

Décomposition :

-rw-r--r-- : permissions
alice : propriétaire
staff : groupe

5.1 Modifier les permissions : `chmod`

Ajouter le droit d’exécution à un script :

chmod +x script.sh

Retirer l’écriture pour “others” :

chmod o-w fichier.txt

Notation numérique (souvent vue) :

r=4, w=2, x=1
7 = rwx, 6 = rw-, 5 = r-x

Exemple : propriétaire tout, groupe lecture, autres lecture :

chmod 744 script.sh

5.2 Modifier propriétaire/groupe : `chown`

(En général nécessite sudo)

sudo chown alice:staff fichier.txt

6) Installer des logiciels (gestion de paquets)

6.1 Sur Debian/Ubuntu : `apt`

Mettre à jour la liste des paquets :

sudo apt update

Mettre à jour les paquets installés :

sudo apt upgrade

Installer un paquet :

sudo apt install curl git

Chercher un paquet :

apt search nginx

Afficher des infos :

apt show git

6.2 Sur macOS : Homebrew (si installé)

Installer Homebrew (commande officielle à vérifier sur le site brew.sh), puis :

brew update
brew install git curl

Comprendre l’idée : un gestionnaire de paquets télécharge, vérifie, installe et met à jour des logiciels de manière cohérente.

7) Processus : voir et contrôler ce qui tourne

7.1 Lister les processus

Afficher un aperçu :

ps

Afficher tous les processus :

ps aux

Voir en temps réel :

top

Sur beaucoup de Linux, htop est plus confortable (si installé) :

htop

7.2 Terminer un processus

Supposons qu’un programme se bloque. Trouvez son PID :

ps aux | grep nom_du_programme

Puis :

kill PID

Si ça ne suffit pas (à utiliser avec prudence) :

kill -9 PID

Compréhension :

kill envoie un signal.
-9 (SIGKILL) force l’arrêt sans “nettoyage”. Préférez d’abord un arrêt propre.

8) Entrées/sorties, pipes et redirections (la magie du shell)

C’est l’une des idées les plus puissantes : une commande produit une sortie (stdout) que vous pouvez rediriger ou enchaîner.

8.1 Rediriger vers un fichier

Écraser un fichier :

echo "Bonjour" > message.txt

Ajouter à la fin :

echo "Deuxième ligne" >> message.txt

8.2 Utiliser un pipe `|`

Envoyer la sortie d’une commande vers une autre :

ls -la | less

Chercher dans une sortie :

ps aux | grep ssh

Compter des lignes :

ls -1 | wc -l

8.3 Erreurs (stderr) et redirections

Rediriger les erreurs vers un fichier :

commande_inexistante 2> erreurs.log

Rediriger sortie + erreurs :

commande 1> sortie.log 2> erreurs.log

Ou tout ensemble :

commande > tout.log 2>&1

9) Rechercher : fichiers, contenu, commandes

9.1 Trouver un fichier : `find`

Chercher un fichier par nom dans un dossier :

find . -name "README.md"

Chercher par extension :

find . -type f -name "*.md"

9.2 Chercher du texte : `grep`

Chercher “TODO” dans un fichier :

grep "TODO" projet/README.md

Chercher récursivement dans un dossier :

grep -R "TODO" projet/

Afficher numéros de ligne :

grep -n "TODO" -R projet/

9.3 Trouver où est une commande : `which`, `command -v`

which python
command -v git

10) Réseau : comprendre l’essentiel et diagnostiquer

10.1 Tester la connectivité : `ping`

ping -c 4 8.8.8.8

Si ça répond, vous avez une connectivité IP.
Si ping google.com ne marche pas mais ping 8.8.8.8 marche, le problème est souvent le DNS.

10.2 Voir la configuration IP

Sur Linux (souvent) :

ip a
ip route

Sur macOS :

ifconfig
netstat -rn

10.3 Tester HTTP : `curl`

Récupérer une page :

curl https://example.com

Voir les en-têtes :

curl -I https://example.com

Suivre les redirections :

curl -L https://example.com

10.4 DNS : `dig` (ou `nslookup`)

dig example.com

11) Archives et compression : zip, tar, gzip

Créer une archive .tar.gz :

tar -czf projet.tar.gz projet/

Extraire :

tar -xzf projet.tar.gz

Créer un zip :

zip -r projet.zip projet/

Extraire un zip :

unzip projet.zip

Compréhension :

tar regroupe des fichiers (archive).
gzip compresse.
tar -czf = create + gzip + file.

12) Variables d’environnement et PATH

12.1 Voir une variable

echo $HOME
echo $PATH

PATH est une liste de dossiers où le shell cherche les exécutables. Si vous tapez git, le shell cherche git dans les dossiers de PATH.

Afficher toutes les variables :

printenv

12.2 Définir une variable (session courante)

export NOM="Alice"
echo $NOM

Après fermeture du terminal, la variable disparaît, sauf si vous la mettez dans un fichier de configuration (~/.bashrc, ~/.zshrc).

13) Scripts : automatiser en douceur

13.1 Créer un script bash

Créez bonjour.sh :

nano bonjour.sh

Contenu :

#!/usr/bin/env bash
set -e

echo "Bonjour !"
echo "Nous sommes le : $(date)"
echo "Répertoire courant : $(pwd)"

Rendre exécutable :

chmod +x bonjour.sh

Exécuter :

./bonjour.sh

Explications :

#!/usr/bin/env bash indique quel interpréteur utiliser.
set -e fait échouer le script dès qu’une commande échoue (utile pour éviter des états incohérents).
$(...) exécute une commande et insère son résultat.

13.2 Paramètres

Modifiez le script :

#!/usr/bin/env bash
set -e

echo "Salut, $1"

Exécutez :

./bonjour.sh Alice

$1 = premier argument, $2 = deuxième, etc.

14) Git : bases du versionnage (indispensable)

Git sert à suivre l’historique d’un projet, collaborer, revenir en arrière, comparer des versions.

14.1 Initialiser un dépôt

mkdir demo-git
cd demo-git
git init

Créer un fichier :

echo "# Mon projet" > README.md

Voir l’état :

git status

Ajouter au “staging” :

git add README.md

Créer un commit :

git commit -m "Ajoute un README"

Voir l’historique :

git log --oneline

14.2 Comprendre les 3 zones

Working directory : vos fichiers modifiés
Staging area : ce que vous préparez pour le commit (git add)
Repository : l’historique (git commit)

Cette séparation permet de committer proprement un ensemble cohérent de changements.

15) Déboguer intelligemment : méthode simple

Quand quelque chose ne marche pas, évitez de “cliquer partout” au hasard. Appliquez une méthode :

Lire le message d’erreur (en entier).
Reproduire le problème (mêmes étapes).
Isoler : quel composant ? fichier ? commande ? réseau ? droits ?
Observer : logs, état, configuration.
Tester une hypothèse à la fois.

Commandes utiles :

Voir l’espace disque :

df -h

Voir la taille des dossiers :

du -sh *

Vérifier les droits :

ls -la

Vérifier si un port écoute (Linux, selon outils disponibles) :

ss -lntp

Ou (macOS / parfois Linux) :

lsof -iTCP -sTCP:LISTEN -n -P

16) Mini-projet guidé (pas à pas) : organiser un dossier et produire un rapport

Objectif : créer un dossier de travail, y mettre des fichiers, puis générer un petit “rapport” texte automatiquement.

16.1 Préparer l’espace

mkdir -p atelier/{data,output,scripts}
cd atelier

Vérifiez :

find . -maxdepth 2 -type d

16.2 Créer des fichiers de données

echo "alice,Paris" > data/clients.csv
echo "bob,Lyon" >> data/clients.csv
echo "carol,Toulouse" >> data/clients.csv

Afficher :

cat data/clients.csv

16.3 Générer un rapport avec des commandes

Compter le nombre de lignes (donc de clients) :

wc -l data/clients.csv

Extraire les villes :

cut -d',' -f2 data/clients.csv

Trier et supprimer doublons :

cut -d',' -f2 data/clients.csv | sort | uniq

16.4 Automatiser via script

Créez scripts/rapport.sh :

nano scripts/rapport.sh

Contenu :

#!/usr/bin/env bash
set -e

INPUT="data/clients.csv"
OUT="output/rapport.txt"

echo "Rapport clients" > "$OUT"
echo "Généré le : $(date)" >> "$OUT"
echo "" >> "$OUT"

echo "Nombre de clients :" >> "$OUT"
wc -l "$INPUT" >> "$OUT"
echo "" >> "$OUT"

echo "Villes (uniques) :" >> "$OUT"
cut -d',' -f2 "$INPUT" | sort | uniq >> "$OUT"

Rendre exécutable et lancer :

chmod +x scripts/rapport.sh
./scripts/rapport.sh

Lire le rapport :

cat output/rapport.txt

Ce que vous venez d’apprendre réellement :

structurer un projet (data/, scripts/, output/)
enchaîner des commandes (cut | sort | uniq)
écrire dans des fichiers via redirections
rendre un script exécutable et le réutiliser

17) Bonnes pratiques débutant (qui font gagner des heures)

Travaillez dans un dossier dédié (évitez le bureau en vrac).
Avant une commande destructrice (rm -r), faites un ls et vérifiez le chemin.
Apprenez à lire man (manuel) :

man ls
man find
man grep

Utilisez l’historique :

history | tail

Réutilisez une commande précédente avec la recherche (souvent Ctrl+R).
Quand vous copiez-collez une commande trouvée en ligne, demandez-vous :
- Dans quel dossier suis-je ?
- Qu’est-ce que cette commande modifie ?
- Est-ce qu’elle nécessite sudo ?
- Est-ce qu’elle télécharge/exécute quelque chose ?

18) Prochaines étapes (progression recommandée)

Terminal niveau 2 : awk, sed, expressions régulières.
Git niveau 2 : branches (git branch, git switch), fusion (merge), rebase.
Réseau niveau 2 : ports, HTTP, TLS, reverse proxy.
Scripting : bash avancé ou Python pour automatiser plus proprement.
Sécurité : mots de passe, clés SSH, permissions, mises à jour.

Pour vous entraîner, essayez ces exercices :

Créer un dossier exos/ et y générer 20 fichiers, puis les renommer en masse.
Écrire un script qui sauvegarde un dossier en .tar.gz avec la date du jour.
Cloner un dépôt Git public, lire l’historique, créer une branche et faire un commit.

Conclusion

Vous avez maintenant une base solide : naviguer, manipuler des fichiers, comprendre les permissions, installer des outils, diagnostiquer, et automatiser. Le point le plus important est la logique : chaque commande a une entrée, une sortie, des options, et s’inscrit dans un contexte (répertoire courant, droits, environnement). En avançant pas à pas, vous transformez l’ordinateur d’une “boîte noire” en un système compréhensible et maîtrisable.

Guide débutant : comprendre les bases (pas à pas)

Guide débutant : comprendre les bases (pas à pas)

1) Les notions fondamentales : système, programmes, fichiers

1.1 Système d’exploitation (OS) : le chef d’orchestre

1.2 Fichiers et dossiers : une arborescence

2) Le terminal : votre outil le plus puissant

2.1 Pourquoi apprendre le terminal ?

2.2 Se repérer : où suis-je ?

2.3 Naviguer

3) Manipuler fichiers et dossiers (sans peur)

3.1 Créer dossiers et fichiers

3.2 Copier, déplacer, renommer

3.3 Supprimer (attention)

4) Lire et éditer du texte

4.1 Afficher le contenu

4.2 Éditer : nano (simple) ou vim (puissant)

5) Comprendre permissions et propriété (un pilier)

5.1 Modifier les permissions : chmod

5.2 Modifier propriétaire/groupe : chown

6) Installer des logiciels (gestion de paquets)

6.1 Sur Debian/Ubuntu : apt

6.2 Sur macOS : Homebrew (si installé)

7) Processus : voir et contrôler ce qui tourne

7.1 Lister les processus

7.2 Terminer un processus

8) Entrées/sorties, pipes et redirections (la magie du shell)

8.1 Rediriger vers un fichier

8.2 Utiliser un pipe |

8.3 Erreurs (stderr) et redirections

9) Rechercher : fichiers, contenu, commandes

9.1 Trouver un fichier : find

9.2 Chercher du texte : grep

9.3 Trouver où est une commande : which, command -v

10) Réseau : comprendre l’essentiel et diagnostiquer

10.1 Tester la connectivité : ping

10.2 Voir la configuration IP

10.3 Tester HTTP : curl

10.4 DNS : dig (ou nslookup)

11) Archives et compression : zip, tar, gzip

12) Variables d’environnement et PATH

12.1 Voir une variable

12.2 Définir une variable (session courante)

13) Scripts : automatiser en douceur

13.1 Créer un script bash

13.2 Paramètres

14) Git : bases du versionnage (indispensable)

14.1 Initialiser un dépôt

14.2 Comprendre les 3 zones

15) Déboguer intelligemment : méthode simple

16) Mini-projet guidé (pas à pas) : organiser un dossier et produire un rapport

16.1 Préparer l’espace

16.2 Créer des fichiers de données

16.3 Générer un rapport avec des commandes

16.4 Automatiser via script

17) Bonnes pratiques débutant (qui font gagner des heures)

18) Prochaines étapes (progression recommandée)

Conclusion

Tutoriels associés

5.1 Modifier les permissions : `chmod`

5.2 Modifier propriétaire/groupe : `chown`

6.1 Sur Debian/Ubuntu : `apt`

8.2 Utiliser un pipe `|`

9.1 Trouver un fichier : `find`

9.2 Chercher du texte : `grep`

9.3 Trouver où est une commande : `which`, `command -v`

10.1 Tester la connectivité : `ping`

10.3 Tester HTTP : `curl`

10.4 DNS : `dig` (ou `nslookup`)