Compare commits

..

2 commits

Author SHA1 Message Date
Alpinux
ad1f459659 Empêcher le hook des derniers articles de bloquer la publication
Le hook promettait de ne jamais faire échouer le build. En pratique il
journalisait ses échecs en « warning », et le déploiement construit avec
« --strict » : un dépôt sans historique git suffisait à obtenir « Aborted
with 1 warnings in strict mode » — plus aucune publication du wiki, pour
un fichier d'agrément.

Ses messages passent donc en « info », l'écriture des deux fichiers est
protégée à son tour, et un clone superficiel est détecté et signalé : ses
dates seraient toutes identiques.

Vérifié dans les deux cas : avec historique, vingt articles publiés ;
sans dépôt git, build réussi et fichier non écrit.

Documenté au passage que le .htaccess du DocumentRoot est désormais
réécrit à chaque déploiement, rsync --delete recopiant tout le staging.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BE4rvHVETRoWnYNDTGssdo
2026-09-20 00:29:56 +02:00
Alpinux
0166436000 Publier la liste des pages récemment mises à jour
La page d'accueil d'alpinux.org affiche les prochaines dates ; elle n'a aucun moyen de
savoir ce qui bouge dans le wiki. Le build écrit désormais « derniers-articles.json » à
la racine du site : les vingt dernières pages créées ou modifiées, titre, URL et date.

Les dates viennent de git, avec suivi des renommages : déplacer un article ne le fait pas
remonter dans la liste, seule une modification de son texte compte. Les pages absentes de
la navigation — les redirections laissées derrière un article déplacé — sont écartées.

Le hook dépose aussi un .htaccess limité à ce fichier : sans l'en-tête
Access-Control-Allow-Origin, le navigateur refuse à alpinux.org de lire une réponse venue
de wiki.alpinux.org.

En cas de souci — pas d'historique git, git absent — le hook n'écrit rien et le build
continue : le site reste publiable et l'accueil masque simplement sa section wiki.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ae3qPEPRrNkEY5LwcTTKc1
2026-09-20 00:22:00 +02:00
99 changed files with 249 additions and 34785 deletions

2
.obsidian/app.json vendored
View file

@ -8,4 +8,4 @@
"alwaysUpdateLinks": true,
"useMarkdownLinks": true,
"newLinkFormat": "relative"
}
}

View file

@ -1,702 +0,0 @@
#!/bin/bash
# Relève la fiche d'une machine, et l'envoie au serveur de l'install party.
#
# Ce script vit dans le dépôt du wiki, à côté d'install.sh : il est lu et
# versionné comme lui, et c'est de là qu'il faut le prendre.
#
# wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux-wiki/raw/branch/main/code/linux/linux-mint/alpi-fiche.sh
# chmod +x alpi-fiche.sh
# sudo ./alpi-fiche.sh --check # depuis la session live, avant d'installer
# sudo ./alpi-fiche.sh # après l'installation
#
# Sur le réseau de l'install party, plus court :
#
# wget http://10.0.0.1/alpi-fiche.sh && chmod +x alpi-fiche.sh && sudo ./alpi-fiche.sh --check
#
# Pourquoi la garder sur le serveur plutôt que sur le poste : trois semaines
# plus tard, quand quelqu'un rappelle parce que « ça rame », on n'a plus la
# machine sous la main. Savoir qu'elle a huit ans, quatre gigaoctets de
# mémoire et un disque mécanique qui commence à réallouer des secteurs répond
# à la question avant de l'avoir posée.
#
# Ce qui est envoyé : le modèle, le processeur, la mémoire, les disques et
# leur santé, le système installé.
#
# Deux de ces champs touchent à la personne, et il faut le dire plutôt que de
# prétendre le contraire — la première version de cet en-tête annonçait « rien
# qui touche à la personne », ce qui était faux :
#
# · le NOM DE LA MACHINE, choisi pendant l'installation, contient très
# souvent un prénom ;
# · l'ADRESSE MATÉRIELLE de la carte réseau identifie durablement l'appareil.
#
# Les deux servent : le nom pour s'y retrouver, l'adresse pour rapprocher la
# fiche du bail DHCP. Mais ils appartiennent à la personne dont on installe
# l'ordinateur — il faut le lui dire. Ne sont en revanche jamais envoyés : son
# nom d'utilisateur, ses fichiers, son historique, ni rien de ce qu'elle a
# installé. Le numéro de série est tronqué à quatre caractères.
#
# alpi-fiche relève et envoie
# alpi-fiche --montrer relève et affiche, sans rien envoyer
# alpi-fiche --check relève, envoie, et rend un verdict
#
# Le mode « --check » est fait pour tourner **depuis la clé USB, avant
# d'installer** : c'est le seul moment où l'on peut encore renoncer. Un disque
# qui se déclare défaillant, on ne passe pas une heure à installer dessus — on
# le dit à son propriétaire et on cherche une autre solution.
set -u
# Bash ne compte les caractères — et non les octets — que si la locale le dit.
# C'est ce qui aligne les colonnes du tableau des disques.
export LC_ALL="${LC_ALL:-C.UTF-8}"
# Le temps que met la collecte, en millisecondes.
#
# Une machine n'est relevée qu'une fois quand elle n'a pas connu de session
# live : il n'y a alors pas d'écart entre deux passages à mesurer. Cette durée-
# ci existe toujours, et elle se compare — elle dit ce que la machine met à
# s'interroger elle-même : lire le SMART de ses disques, réveiller ceux qui
# dorment, énumérer ses barrettes. Un plateau qui rame se voit là.
#
# On arrête le chronomètre à la fin de la collecte, avant le verdict : celui-ci
# attend une touche, et l'on mesurerait la personne devant l'écran.
DEBUT_NS="$(date +%s%N 2>/dev/null || echo 0)"
# smartctl et dmidecode vivent dans /usr/sbin, que le PATH d'un shell ordinaire
# ne contient pas toujours — un « command -v » y échouait alors que le binaire
# était là.
PATH="$PATH:/usr/sbin:/sbin"
SERVEUR="${ALPI_SERVEUR:-http://alpicache.lan}"
MONTRER=0
CHECK=0
case "${1:-}" in
--montrer) MONTRER=1 ;;
--check) CHECK=1 ;;
esac
if [ -t 1 ]; then
V=$'\e[32m'; O=$'\e[33m'; R=$'\e[31m'; B=$'\e[1m'; D=$'\e[2m'; Z=$'\e[0m'
else
V=""; O=""; R=""; B=""; D=""; Z=""
fi
# Ce dont le relevé a besoin, et qu'il installe lui-même plutôt que de rendre
# un verdict à trous.
#
# « état des disques inconnu » n'aide personne : c'est précisément la réponse
# qu'on était venu chercher. Les deux paquets pèsent moins de deux mégaoctets,
# ils sont dans le cache, et l'installation prend deux secondes sur le réseau
# de l'install party. On ne le fait qu'en root, qu'avec apt, et sans rien
# demander d'autre.
completer_outils() {
[ "$(id -u)" = "0" ] || return 0
command -v apt-get >/dev/null 2>&1 || return 0
local manquants=""
command -v smartctl >/dev/null 2>&1 || manquants="$manquants smartmontools"
command -v dmidecode >/dev/null 2>&1 || manquants="$manquants dmidecode"
[ -z "$manquants" ] && return 0
echo "==> Installation de ce qui manque au relevé :$manquants"
# Par le cache s'il répond, directement sinon. « -qq » pour ne pas noyer
# l'écran : ce n'est pas l'objet de la manœuvre.
local proxy=""
if command -v wget >/dev/null 2>&1 \
&& wget -q --spider --timeout=3 "$SERVEUR/" 2>/dev/null; then
proxy="-o Acquire::http::Proxy=http://apt-proxy:3142"
fi
DEBIAN_FRONTEND=noninteractive apt-get $proxy -qq -y install $manquants \
>/dev/null 2>&1 \
|| echo " (échec — le relevé se fera sans)"
# Ce qui vient d'arriver est dans /usr/sbin, que le PATH d'un shell
# ordinaire ne contient pas toujours.
PATH="$PATH:/usr/sbin:/sbin"
}
completer_outils
lire_dmi() {
cat "/sys/class/dmi/id/$1" 2>/dev/null | tr -d '\n' | sed 's/^ *//; s/ *$//'
}
echapper() {
# De quoi écrire du JSON sans rien installer : guillemets, antislashs et
# sauts de ligne, et c'est tout ce qui peut nous arriver ici.
printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g' | tr -d '\n\r'
}
champ() { printf '"%s":"%s"' "$1" "$(echapper "${2:-}")"; }
# --- La machine ------------------------------------------------------------
MODELE="$(lire_dmi product_name)"
MARQUE="$(lire_dmi sys_vendor)"
SERIE="$(lire_dmi product_serial)"
# Le numéro de série identifie un objet, pas une personne, mais il n'a rien à
# faire dans un fichier qu'on partage : on n'en garde que les quatre derniers
# caractères, assez pour distinguer deux machines du même modèle.
SERIE="${SERIE: -4}"
BIOS="$(lire_dmi bios_date)"
PROCESSEUR="$(awk -F': ' '/^model name/{print $2; exit}' /proc/cpuinfo)"
COEURS="$(nproc 2>/dev/null || echo '?')"
MEMOIRE_KO="$(awk '/^MemTotal/{print $2}' /proc/meminfo)"
SYSTEME=""
if [ -r /etc/os-release ]; then
SYSTEME="$(. /etc/os-release; echo "${PRETTY_NAME:-$NAME $VERSION}")"
fi
NOYAU="$(uname -r)"
ARCHITECTURE="$(uname -m)"
# Sommes-nous sur la clé USB, ou sur le système installé ?
#
# La distinction n'est pas cosmétique : les deux relevés répondent à deux
# questions différentes. Celui de la session live dit « peut-on installer sur
# cette machine ? » et se fait avant d'effacer quoi que ce soit. Celui d'après
# dit « qu'avons-nous installé, et sur quoi ». Les garder séparés permet de
# comparer — un disque qui allait bien le matin et qui se plaint le soir, cela
# se voit.
#
# Le signe qui ne trompe pas est la racine : une session live la monte en
# overlay au-dessus d'un squashfs, ce qu'aucun système installé ne fait. S'y
# ajoute « boot=casper » ou « boot=live » sur la ligne de commande du noyau.
#
# L'existence de /cdrom ou de /rofs, elle, ne prouve rien : l'installateur de
# Mint laisse un /cdrom vide derrière lui, et la première version de ce script
# a donc déclaré « session live » une machine parfaitement installée. On ne les
# retient que s'ils sont réellement montés.
MOMENT="post-installation"
if findmnt -n -o FSTYPE / 2>/dev/null | grep -qE '^(overlay|aufs|squashfs)$' \
|| grep -qE '(^| )boot=(casper|live)( |$)' /proc/cmdline 2>/dev/null \
|| mountpoint -q /rofs 2>/dev/null \
|| { mountpoint -q /cdrom 2>/dev/null \
&& findmnt -n -o FSTYPE /cdrom 2>/dev/null | grep -qE '^(iso9660|squashfs)$'; }; then
MOMENT="live"
fi
# --- La mémoire, barrette par barrette ------------------------------------
#
# La question qu'on pose vraiment devant une machine lente : peut-on en
# ajouter ? Elle demande trois réponses — combien de connecteurs, combien
# d'occupés, et de quel type. Un slot libre en DDR3 ne se remplit pas avec ce
# qu'on a dans le tiroir.
#
# dmidecode lit cela dans la table du BIOS. Il est présent par défaut sur
# Debian, Ubuntu et Mint ; s'il manque, on ne prétend rien plutôt que de
# deviner.
BARRETTES="["
SLOTS_TOTAL=0
SLOTS_PRIS=0
TYPE_MEMOIRE=""
VITESSE_MEMOIRE=""
if command -v dmidecode >/dev/null 2>&1 && [ "$(id -u)" = "0" ]; then
premier=1
# Chaque bloc « Memory Device » décrit un connecteur, occupé ou non.
while IFS= read -r bloc; do
emplacement="$(printf '%s' "$bloc" | sed -n 's/.*|Locator:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
taille="$(printf '%s' "$bloc" | sed -n 's/.*|Size:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
type_="$(printf '%s' "$bloc" | sed -n 's/.*|Type:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
vitesse="$(printf '%s' "$bloc" | sed -n 's/.*|Speed:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
forme="$(printf '%s' "$bloc" | sed -n 's/.*|Form Factor:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
reference="$(printf '%s' "$bloc" | sed -n 's/.*|Part Number:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
# La vitesse configurée est celle à laquelle la barrette travaille
# vraiment ; « Speed » n'est que ce dont elle serait capable. L'écart
# entre les deux explique bien des machines qui « rament » sans raison
# apparente : une DDR4-3200 bridée à 2133 par la carte mère, ou deux
# barrettes dépareillées qui s'alignent sur la plus lente.
vitesse_reelle="$(printf '%s' "$bloc" | sed -n 's/.*|Configured Memory Speed:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
fabricant="$(printf '%s' "$bloc" | sed -n 's/.*|Manufacturer:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
rang="$(printf '%s' "$bloc" | sed -n 's/.*|Rank:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
tension="$(printf '%s' "$bloc" | sed -n 's/.*|Configured Voltage:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
largeur="$(printf '%s' "$bloc" | sed -n 's/.*|Data Width:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
detail="$(printf '%s' "$bloc" | sed -n 's/.*|Type Detail:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
[ -z "$emplacement" ] && continue
SLOTS_TOTAL=$(( SLOTS_TOTAL + 1 ))
case "$taille" in
*"No Module"*|""|"Unknown") taille="" ;;
*) SLOTS_PRIS=$(( SLOTS_PRIS + 1 ))
[ -z "$TYPE_MEMOIRE" ] && [ "$type_" != "Unknown" ] && TYPE_MEMOIRE="$type_"
# Deux barrettes de vitesses différentes s'alignent sur la plus
# lente : c'est celle-là qu'il faut retenir pour la machine.
if [ -n "$vitesse_reelle" ] && [ "$vitesse_reelle" != "Unknown" ]; then
nombre="${vitesse_reelle%% *}"
case "$nombre" in
''|*[!0-9]*) ;;
*) if [ -z "$VITESSE_MEMOIRE" ] || [ "$nombre" -lt "$VITESSE_MEMOIRE" ]; then
VITESSE_MEMOIRE="$nombre"
fi ;;
esac
fi ;;
esac
[ "$premier" = 0 ] && BARRETTES="$BARRETTES,"
premier=0
BARRETTES="$BARRETTES{$(champ emplacement "$emplacement"),$(champ taille "$taille"),\
$(champ type "$type_"),$(champ vitesse "$vitesse"),$(champ vitesse_reelle "$vitesse_reelle"),\
$(champ forme "$forme"),$(champ reference "$reference"),$(champ fabricant "$fabricant"),\
$(champ rang "$rang"),$(champ tension "$tension"),$(champ largeur "$largeur"),\
$(champ detail "$detail")}"
done < <(dmidecode -t memory 2>/dev/null \
| awk '/^Memory Device$/{bloc=""; dedans=1; next}
/^$/{if (dedans && bloc != "") print bloc; dedans=0; bloc=""}
dedans {gsub(/^[ \t]+/, ""); bloc = bloc "|" $0}
END{if (dedans && bloc != "") print bloc}')
fi
BARRETTES="$BARRETTES]"
TABLE_DISQUES=""
# Remplir une colonne à la bonne largeur.
#
# « printf %-10s » compte les octets, pas les caractères : « mécanique » en
# pèse dix pour neuf signes, et la colonne suivante glisse d'un cran. Bash,
# lui, sait compter les caractères quand la locale est en UTF-8 — on lui
# laisse ce travail, et l'on force la locale plutôt que d'espérer.
colonne() {
local texte="$1" largeur="$2" cote="${3:-gauche}" n
n=${#texte}
if [ "$n" -gt "$largeur" ]; then
printf '%s' "${texte:0:$largeur}"
return
fi
local blancs=""
while [ "$n" -lt "$largeur" ]; do blancs="$blancs "; n=$((n + 1)); done
if [ "$cote" = droite ]; then printf '%s%s' "$blancs" "$texte"
else printf '%s%s' "$texte" "$blancs"; fi
}
# --- Les disques -----------------------------------------------------------
#
# lsblk donne la taille et le type ; le drapeau « rotational » du noyau
# distingue un disque mécanique d'un SSD sans rien installer. C'est la
# distinction qui compte : une machine lente avec un disque mécanique de dix
# ans ne s'arrangera pas avec un système plus léger.
DISQUES="["
premier=1
for chemin in /sys/block/*; do
nom="$(basename "$chemin")"
case "$nom" in loop*|ram*|sr*|zram*|dm-*) continue ;; esac
[ -r "$chemin/size" ] || continue
taille=$(( $(cat "$chemin/size") * 512 ))
[ "$taille" -lt 1000000000 ] && continue # moins d'un Go : pas un disque
rotatif="$(cat "$chemin/queue/rotational" 2>/dev/null || echo '?')"
modele="$(cat "$chemin/device/model" 2>/dev/null | sed 's/ *$//')"
# L'état SMART, s'il est lisible. Sans smartctl on ne prétend rien.
sante=""
reallocations=""
pending=""
illisibles=""
heures=""
usure=""
ecrit=""
if command -v smartctl >/dev/null 2>&1; then
sortie="$(smartctl -H -A "/dev/$nom" 2>/dev/null)"
sante="$(printf '%s' "$sortie" | grep -iE 'overall-health|SMART Health' \
| sed 's/.*: *//' | head -1)"
reallocations="$(printf '%s' "$sortie" \
| awk '/Reallocated_Sector_Ct|Reallocated_Event/{print $10; exit}')"
# Les secteurs que le disque n'arrive plus à lire. Ils manquaient à la
# fiche, et c'est ce qui a fait qu'alpicache annonçait « sain » un
# disque déclaré à remplacer : il ne les avait jamais reçus.
pending="$(printf '%s' "$sortie" | awk '$2 == "Current_Pending_Sector"{print $10; exit}')"
illisibles="$(printf '%s' "$sortie" | awk '$2 == "Offline_Uncorrectable"{print $10; exit}')"
heures="$(printf '%s' "$sortie" | awk '/Power_On_Hours/{print $10; exit}')"
# L'usure d'un SSD, en pour cent de vie consommée.
#
# Un disque mécanique s'use en tournant, un SSD en écrivant : les
# heures de marche ne disent rien de son état. Chaque constructeur a
# son attribut, et deux conventions coexistent — les uns comptent ce
# qui est consommé, les autres ce qui reste. On ramène tout à
# « consommé », qui est le sens qu'on veut lire. NVMe donne directement
# « Percentage Used » ; pour les SATA, la colonne VALUE part de 100 et
# descend.
usure="$(printf '%s' "$sortie" | awk '/Percentage Used:/{gsub(/[^0-9]/,"",$3); print $3; exit}')"
if [ -z "$usure" ]; then
usure="$(printf '%s' "$sortie" | awk '
/Media_Wearout_Indicator|Wear_Leveling_Count|SSD_Life_Left|Percent_Lifetime_Remain/ {
if ($4 ~ /^[0-9]+$/ && $4 <= 100) { print 100 - $4; exit }
}')"
fi
# Ce que le disque a écrit depuis sa mise en service : l'autre façon de
# juger un SSD, dont les modèles courants tiennent 100 à 600 To.
ecrit="$(printf '%s' "$sortie" | awk '
/Total_LBAs_Written|Host_Writes_32MiB|Total_Host_Writes/ {
if ($10 ~ /^[0-9]+$/) { print $10; exit }
}
/Data Units Written:/ { gsub(/[^0-9]/,"",$4); print $4; exit }')"
fi
# Les mêmes chiffres, mis en table pour être lus par quelqu'un. Le verdict
# ne dit que ce qui cloche ; on veut aussi voir ce qui va, et sur quoi le
# verdict se fonde.
taille_go="$(awk -v o="$taille" 'BEGIN{printf "%.1f", o/1000000000}' | tr . ,)"
secteurs="—"
for valeur in "${pending:-0}" "${illisibles:-0}" "${reallocations:-0}"; do
case "$valeur" in ''|*[!0-9]*) continue ;; esac
[ "$valeur" -gt 0 ] && secteurs="!"
done
[ "$secteurs" = "!" ] && secteurs="$(printf '%s/%s/%s' \
"${reallocations:-0}" "${pending:-0}" "${illisibles:-0}")"
usure_dite="—"
if [ "$rotatif" = 1 ]; then
case "$heures" in ''|*[!0-9]*) ;; *)
usure_dite="$heures h"
[ "$heures" -ge 8760 ] && usure_dite="$usure_dite ($(( heures / 8760 )),$(( (heures % 8760) * 10 / 8760 )) an)" ;;
esac
else
case "$usure" in ''|*[!0-9]*) ;; *) usure_dite="usé à $usure %" ;; esac
fi
TABLE_DISQUES="$TABLE_DISQUES$(
colonne "$nom" 7; printf ' '
colonne "${modele:-—}" 20; printf ' '
colonne "$([ "$rotatif" = 1 ] && echo mécanique || echo SSD)" 10; printf ' '
colonne "$taille_go Go" 10 droite; printf ' '
colonne "${sante:-—}" 8; printf ' '
colonne "$usure_dite" 16; printf ' '
printf '%s' "$secteurs")"$'\n'
[ "$premier" = 0 ] && DISQUES="$DISQUES,"
premier=0
DISQUES="$DISQUES{$(champ nom "$nom"),$(champ modele "$modele"),\
\"octets\":$taille,$(champ type "$([ "$rotatif" = 1 ] && echo mécanique || echo SSD)"),\
$(champ sante "$sante"),$(champ reallocations "$reallocations"),\
$(champ pending "$pending"),$(champ illisibles "$illisibles"),$(champ heures "$heures"),\
$(champ usure "$usure"),$(champ ecrit "$ecrit")}"
done
DISQUES="$DISQUES]"
# L'occupation, telle qu'elle est maintenant.
OCCUPATION="["
premier=1
while read -r point taille utilise dispo pourcent; do
[ "$premier" = 0 ] && OCCUPATION="$OCCUPATION,"
premier=0
OCCUPATION="$OCCUPATION{$(champ point "$point"),\"taille\":$taille,\
\"utilise\":$utilise,$(champ pourcent "$pourcent")}"
done < <(df -B1 --output=target,size,used,avail,pcent 2>/dev/null \
| awk 'NR>1 && $2+0 > 1000000000 {print $1, $2, $3, $4, $5}')
OCCUPATION="$OCCUPATION]"
# --- Le rapport ------------------------------------------------------------
# L'adresse matérielle de l'interface par laquelle on sort — celle que le
# serveur a vue en donnant le bail, donc celle qui permettra de rapprocher
# cette fiche de la machine servie. « ip -o link » a failli nous donner
# l'adresse de diffusion, qui est la même pour tout le monde.
INTERFACE="$(ip -o -4 route show default 2>/dev/null | awk '{print $5; exit}')"
[ -z "$INTERFACE" ] && INTERFACE="$(ls /sys/class/net 2>/dev/null \
| grep -v '^lo$' | head -1)"
MAC="$(cat "/sys/class/net/$INTERFACE/address" 2>/dev/null)"
RAPPORT="{$(champ machine "$(hostname)"),$(champ mac "$MAC"),\
$(champ marque "$MARQUE"),$(champ modele "$MODELE"),$(champ serie "$SERIE"),\
$(champ bios "$BIOS"),$(champ processeur "$PROCESSEUR"),\"coeurs\":${COEURS:-0},\
\"memoire_ko\":${MEMOIRE_KO:-0},$(champ systeme "$SYSTEME"),$(champ noyau "$NOYAU"),\
$(champ architecture "$ARCHITECTURE"),$(champ moment "$MOMENT"),\
$(champ type_memoire "$TYPE_MEMOIRE"),\
$(champ vitesse_memoire "$VITESSE_MEMOIRE"),\
\"slots_total\":$SLOTS_TOTAL,\"slots_pris\":$SLOTS_PRIS,\"barrettes\":$BARRETTES,\
\"disques\":$DISQUES,\"occupation\":$OCCUPATION}"
DUREE_MS=0
case "$DEBUT_NS" in
''|*[!0-9]*) ;;
0) ;;
*) FIN_NS="$(date +%s%N 2>/dev/null || echo 0)"
case "$FIN_NS" in
''|*[!0-9]*|0) ;;
*) DUREE_MS=$(( (FIN_NS - DEBUT_NS) / 1000000 )) ;;
esac ;;
esac
[ "$DUREE_MS" -lt 0 ] && DUREE_MS=0
RAPPORT="${RAPPORT%\}},\"duree_releve_ms\":$DUREE_MS}"
if [ "$MONTRER" = 1 ]; then
if command -v python3 >/dev/null 2>&1; then
printf '%s' "$RAPPORT" | python3 -m json.tool 2>/dev/null || printf '%s\n' "$RAPPORT"
else
printf '%s\n' "$RAPPORT"
fi
exit 0
fi
[ "$CHECK" = 1 ] && printf " %sLa fiche est envoyée à alpicache…%s\n\n" "$D" "$Z"
echo "Relevé : $([ "$MOMENT" = live ] && echo "session live, avant installation" \
|| echo "système installé")"
echo "Machine : $MARQUE $MODELE"
echo "Processeur : $PROCESSEUR ($COEURS cœurs)"
if [ "$SLOTS_TOTAL" -gt 0 ]; then
echo "Mémoire : $(( MEMOIRE_KO / 1024 )) Mo ${TYPE_MEMOIRE:+$TYPE_MEMOIRE }\
${VITESSE_MEMOIRE:+à $VITESSE_MEMOIRE MT/s }· \
$SLOTS_PRIS connecteur(s) occupé(s) sur $SLOTS_TOTAL"
else
echo "Mémoire : $(( MEMOIRE_KO / 1024 )) Mo"
fi
echo "Système : $SYSTEME"
echo
MOTIFS=""
# --- Le verdict ------------------------------------------------------------
#
# Trois réponses possibles, et une seule question : peut-on installer sur cette
# machine ? Les seuils viennent de ce qu'on rencontre en install party, pas
# d'un idéal — une machine de dix ans avec 4 Go et un disque sain fait très
# bien l'affaire, et c'est souvent celle qu'on nous apporte.
# Le verdict sort toujours, live ou non. C'est l'information qu'on est venu
# chercher : la première version ne le rendait qu'en session live, et le
# relevé d'après installation défilait sans rien dire de l'état des disques —
# précisément ce dont on voulait parler au propriétaire.
[ "$MONTRER" = 1 ] || CHECK=1
if [ "$CHECK" = 1 ]; then
GRAVITE=0 # 0 rien à signaler · 1 à surveiller · 2 ne pas installer
REMARQUES=""
note() {
[ "$1" -gt "$GRAVITE" ] && GRAVITE="$1"
REMARQUES="$REMARQUES$2"$'\n'
# Le même motif, débarrassé de ses couleurs et de ses retours à la
# ligne, pour qu'alpicache dise exactement ce qui a été dit ici.
if [ "$1" -ge 1 ]; then
# Une note tient sur plusieurs lignes à l'écran ; le motif, lui,
# est d'un seul tenant — il ira dans une case de tableau.
nu="$(printf '%s' "$2" | tr '\n' ' ' | sed -e 's/\x1b\[[0-9;]*m//g' \
-e 's/[[:space:]]\{1,\}/ /g' \
-e 's/^ *[!?✗·] *//' \
-e 's/^ *//' -e 's/ *$//')"
[ -n "$nu" ] && MOTIFS="$MOTIFS$nu"$'\n'
fi
}
# Les disques. C'est pour eux qu'on fait ce contrôle.
for chemin in /sys/block/*; do
nom="$(basename "$chemin")"
case "$nom" in loop*|ram*|sr*|zram*|dm-*) continue ;; esac
[ -r "$chemin/size" ] || continue
taille=$(( $(cat "$chemin/size") * 512 ))
[ "$taille" -lt 1000000000 ] && continue
if ! command -v smartctl >/dev/null 2>&1; then
note 1 " ${O}?${Z} état des disques inconnu — smartmontools n'est pas installé.
${D}sudo apt install -y smartmontools${Z} ${D}(il passera par le cache)${Z}"
break
fi
sortie="$(smartctl -H -A "/dev/$nom" 2>/dev/null)"
if printf '%s' "$sortie" | grep -qiE 'overall-health.*(FAILED|FAILING)'; then
note 2 " ${R}✗${Z} ${B}/dev/$nom se déclare défaillant${Z} — ne pas installer dessus."
fi
# Les trois attributs ne disent pas la même chose, et les confondre
# revient à sous-estimer les deux qui comptent.
#
# Reallocated_Sector_Ct des secteurs déjà remplacés par la réserve
# du disque. Quelques-uns sont de l'usure
# ordinaire ; c'est leur nombre qui parle.
# Current_Pending_Sector des secteurs que le disque n'arrive plus à
# lire et n'a pas encore pu déplacer. Ce
# qu'ils contenaient est en train d'être
# perdu. Un seul suffit à s'inquiéter.
# Offline_Uncorrectable des secteurs définitivement illisibles.
#
# Les deux derniers ne sont pas de l'usure mais une panne en cours :
# on ne les mesure pas à la même aune que le premier.
for attribut in Reallocated_Sector_Ct Current_Pending_Sector Offline_Uncorrectable; do
valeur="$(printf '%s' "$sortie" | awk -v a="$attribut" '$2 == a {print $10; exit}')"
case "$valeur" in ''|*[!0-9]*) continue ;; esac
[ "$valeur" = "0" ] && continue
case "$attribut" in
Reallocated_Sector_Ct)
libelle="secteur(s) déjà remplacé(s)"
if [ "$valeur" -ge 50 ]; then
note 2 " ${R}✗${Z} /dev/$nom : ${B}$valeur $libelle${Z} — disque à remplacer."
else
note 1 " ${O}!${Z} /dev/$nom : $valeur $libelle — à surveiller."
fi ;;
Current_Pending_Sector)
note 2 " ${R}✗${Z} /dev/$nom : ${B}$valeur secteur(s) illisible(s)${Z} en attente.
${R}Ce ne sont pas des secteurs usés mais des données que le disque
n'arrive plus à relire : le disque est en train de lâcher.${Z}
${D}Sauvegarder ce qui doit l'être avant toute autre chose, et
ne rien installer dessus — l'installation ne tiendrait pas.${Z}" ;;
Offline_Uncorrectable)
note 2 " ${R}✗${Z} /dev/$nom : ${B}$valeur secteur(s) définitivement perdu(s)${Z}.
${R}Le disque a renoncé à les relire. À remplacer.${Z}" ;;
esac
done
heures="$(printf '%s' "$sortie" | awk '/Power_On_Hours/{print $10; exit}')"
rotatif="$(cat "$chemin/queue/rotational" 2>/dev/null)"
# L'usure, recalculée ici : cette boucle est distincte de celle du
# relevé et ne voit pas ses variables.
usure="$(printf '%s' "$sortie" | awk '/Percentage Used:/{gsub(/[^0-9]/,"",$3); print $3; exit}')"
if [ -z "$usure" ]; then
usure="$(printf '%s' "$sortie" | awk '
/Media_Wearout_Indicator|Wear_Leveling_Count|SSD_Life_Left|Percent_Lifetime_Remain/ {
if ($4 ~ /^[0-9]+$/ && $4 <= 100) { print 100 - $4; exit }
}')"
fi
# Un disque mécanique se signale toujours, et pas seulement quand il
# est vieux. C'est le premier frein d'une machine par ailleurs
# correcte : remplacer un plateau par un SSD fait plus pour elle que
# n'importe quel réglage, et c'est le genre de conseil qu'on donne
# pendant qu'on a la machine ouverte devant soi.
# Les heures de marche, dites en heures et en années de fonctionnement.
# « 477 j 15 h » se lit mal : on croit à un disque épuisé alors que
# c'est une année et quelques mois de marche, ce qui est peu.
marche=""
case "$heures" in
''|*[!0-9]*) ;;
*) marche="$heures h"
if [ "$heures" -ge 8760 ]; then
marche="$marche, soit $(( heures / 8760 )),$(( (heures % 8760) * 10 / 8760 )) an de marche"
fi ;;
esac
if [ "$rotatif" = "1" ]; then
# Un disque mécanique se fatigue en tournant. Les constructeurs
# annoncent 300 000 à 600 000 heures de MTBF, mais le retour du
# terrain est plus sobre : au-delà de 30 000 heures — trois ans et
# demi de marche continue — les pannes deviennent sensiblement plus
# fréquentes, et à 45 000 on est dans le sursis.
gravite_disque=1
supplement=""
case "$heures" in
''|*[!0-9]*) ;;
*) if [ "$heures" -ge 45000 ]; then
gravite_disque=2
supplement="
${R}Au-delà de 45 000 heures : sauvegarder avant toute chose.${Z}"
elif [ "$heures" -ge 30000 ]; then
supplement="
${O}Plus de 30 000 heures de marche : il a fait son temps.${Z}"
fi ;;
esac
note "$gravite_disque" " ${O}!${Z} /dev/$nom est un ${B}disque mécanique${Z}${marche:+ · $marche}.
${D}Le remplacer par un SSD ferait plus pour cette machine que
tout le reste réuni — démarrage, ouverture des programmes, réactivité.${Z}$supplement"
else
# Un SSD ne s'use pas en tournant mais en écrivant. Les heures de
# marche ne disent rien de son état : c'est l'usure qu'on regarde.
case "$usure" in
''|*[!0-9]*)
[ -n "$marche" ] && note 0 " ${V}·${Z} /dev/$nom est un SSD · $marche.
${D}Usure non déclarée par ce modèle.${Z}" ;;
*) if [ "$usure" -ge 90 ]; then
note 2 " ${R}✗${Z} /dev/$nom : SSD usé à ${B}${usure} %${Z} — il approche de sa fin.
${R}Sauvegarder, et prévoir son remplacement.${Z}"
elif [ "$usure" -ge 70 ]; then
note 1 " ${O}!${Z} /dev/$nom : SSD usé à ${usure} %${marche:+ · $marche}.
${D}Encore utilisable, mais il faudra y penser.${Z}"
else
note 0 " ${V}·${Z} /dev/$nom : SSD usé à ${usure} % seulement${marche:+ · $marche}."
fi ;;
esac
fi
if [ "$taille" -lt 32000000000 ]; then
note 1 " ${O}!${Z} /dev/$nom ne fait que $(( taille / 1000000000 )) Go — c'est juste."
fi
done
# La mémoire, le processeur.
MEMOIRE_MO=$(( MEMOIRE_KO / 1024 ))
if [ "$MEMOIRE_MO" -lt 2048 ]; then
note 2 " ${R}✗${Z} ${B}${MEMOIRE_MO} Mo de mémoire${Z} — trop peu pour Mint.
${D}Envisager une version légère, ou ajouter de la mémoire.${Z}"
elif [ "$MEMOIRE_MO" -lt 4096 ]; then
libres=$(( SLOTS_TOTAL - SLOTS_PRIS ))
note 1 " ${O}!${Z} ${MEMOIRE_MO} Mo de mémoire — Mint tournera, mais sans aisance.$(
[ "$libres" -gt 0 ] && printf '\n %s' "${D}$libres connecteur(s) ${TYPE_MEMOIRE} libre(s) : la machine est extensible.${Z}")"
fi
if [ "$ARCHITECTURE" != "x86_64" ] && [ "$ARCHITECTURE" != "aarch64" ]; then
note 2 " ${R}✗${Z} processeur ${ARCHITECTURE} — les versions 64 bits ne s'installeront pas."
fi
echo
case "$GRAVITE" in
0) printf " %s%s BON POUR L'INSTALLATION %s\n" "$B$V" "✓" "$Z" ;;
1) printf " %s%s INSTALLATION POSSIBLE, AVEC DES RÉSERVES %s\n" "$B$O" "!" "$Z" ;;
2) printf " %s%s NE PAS INSTALLER EN L'ÉTAT %s\n" "$B$R" "✗" "$Z" ;;
esac
echo
if [ -n "$TABLE_DISQUES" ]; then
printf ' %s' "$D"
colonne "Disque" 7; printf ' '
colonne "Modèle" 20; printf ' '
colonne "Type" 10; printf ' '
colonne "Taille" 10 droite; printf ' '
colonne "SMART" 8; printf ' '
colonne "Marche / usure" 16; printf ' '
printf 'Secteurs R/P/I%s\n' "$Z"
printf '%s' "$TABLE_DISQUES" | sed "s/^/ /"
printf " %sR : remplacés · P : illisibles en attente · I : perdus%s\n" "$D" "$Z"
echo
fi
[ -n "$REMARQUES" ] && printf "%s\n" "$REMARQUES"
# Une pause, sans quoi tout cela défile et personne ne le lit. Sa durée
# suit la gravité, et l'on n'attend jamais indéfiniment : le script tourne
# aussi sans personne devant l'écran, appelé par install.sh.
if [ -t 0 ]; then
case "$GRAVITE" in
2) printf " %sEn parler au propriétaire AVANT de toucher à quoi que ce soit.%s\n" "$D" "$Z"
printf " %sEntrée pour continuer malgré tout%s " "$B" "$Z"
read -r -t "${ALPI_PAUSE_ALERTE:-120}" _ || echo ;;
1) printf " %sEntrée pour continuer (reprise automatique dans %ss)%s " \
"$D" "${ALPI_PAUSE:-20}" "$Z"
read -r -t "${ALPI_PAUSE:-20}" _ || echo ;;
*) sleep "${ALPI_PAUSE_OK:-3}" ;;
esac
echo
fi
fi
# Ce que l'on vient de dire à la personne part avec la fiche.
#
# Sans cela, alpicache rejugeait à partir des seuls champs reçus — et ne voyait
# pas les secteurs en attente, qui ne lui étaient pas envoyés. Il affichait
# « sain » un disque que ce script venait de déclarer à remplacer. Deux juges,
# deux verdicts : il n'y en a plus qu'un, et c'est celui-ci.
VERDICT="ok"
case "${GRAVITE:-0}" in
2) VERDICT="alerte" ;;
1) VERDICT="attention" ;;
esac
MOTIFS_JSON="["
premier=1
while IFS= read -r ligne; do
[ -n "$ligne" ] || continue
[ "$premier" = 0 ] && MOTIFS_JSON="$MOTIFS_JSON,"
premier=0
MOTIFS_JSON="$MOTIFS_JSON$(printf '%s' "$ligne" \
| sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' -e 's/^/"/' -e 's/$/"/')"
done <<< "${MOTIFS:-}"
MOTIFS_JSON="$MOTIFS_JSON]"
RAPPORT="${RAPPORT%\}},$(champ verdict "$VERDICT"),\"motifs\":$MOTIFS_JSON}"
if command -v curl >/dev/null 2>&1; then
reponse="$(printf '%s' "$RAPPORT" | curl -s --max-time 15 \
-H 'Content-Type: application/json' --data-binary @- "$SERVEUR/fiche")"
elif command -v wget >/dev/null 2>&1; then
reponse="$(printf '%s' "$RAPPORT" | wget -qO- --timeout=15 \
--header='Content-Type: application/json' --post-file=- "$SERVEUR/fiche")"
else
echo "Ni curl ni wget : la fiche n'a pas pu être envoyée." >&2
exit 1
fi
if [ -n "$reponse" ]; then
echo "$reponse"
else
echo "Le serveur n'a pas répondu — la fiche n'est pas enregistrée." >&2
exit 1
fi

View file

@ -1,39 +1,14 @@
#!/bin/bash
##################################################
# Fiche matérielle pour le serveur de l'install party
#
# Placée au début, et non à la fin : si un disque faiblit, autant le savoir
# avant d'avoir passé une heure à installer dessus — c'est le moment où l'on
# peut encore en parler à son propriétaire. Et si l'installation s'arrête en
# route, on a tout de même la fiche.
#
# Le relevé est le script voisin du dépôt, lu et versionné comme celui-ci :
# rien n'est téléchargé ni exécuté depuis le réseau. S'il n'est pas là, on
# passe — la machine d'un particulier qui rejoue ce script chez elle ne doit
# rien avoir à faire de tout ceci.
#
# C'est la seconde passe, celle que « sudo » relance, qui l'exécute :
# dmidecode et smartctl demandent les droits d'administration.
##################################################
if [ "$(id -u)" = "0" ] && [ -x "$(dirname "$0")/alpi-fiche.sh" ]; then
"$(dirname "$0")/alpi-fiche.sh" || true
fi
# Script de post-installation pour Linux Mint 22.3
# testé le 25/03/2026
#
# utilisation
# wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux-wiki/raw/branch/main/code/linux/linux-mint/install.sh
# wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.site.2026/raw/branch/main/code/linux/linux-mint/install.sh
# && chmod +x install.sh
# && ./install.sh
GREEN=$'\e[32m'
NC=$'\e[0m'
abort() {
echo ""
echo ""
@ -123,14 +98,7 @@ opti_journald() {
opti_fstab () {
echo -e "==> Optimisation du montage des disques (noatime)\n"
# Remplace relatime par noatime partout dans le fichier.
#
# ATTENTION : sans effet sur une installation Mint 22.3. Le fstab qu'écrit
# l'installateur ne mentionne ni « relatime » ni « noatime » — il s'en remet
# à « defaults », et relatime est le comportement par défaut du noyau. Il n'y
# a donc rien à substituer. Vérifié le 20/09/2026 sur une installation neuve.
# Pour poser réellement noatime, il faudrait ajouter l'option aux lignes
# concernées plutôt que d'en remplacer une qui n'y est pas.
# Replaces relatime with noatime everywhere in the file
sudo sed -i 's/relatime/noatime/g' /etc/fstab
}
@ -176,7 +144,6 @@ modif_systeme() {
microcode
opti_journald
opti_fstab
modif_grub
mises_a_jour
@ -249,7 +216,7 @@ install_logiciels() {
DEBIAN_FRONTEND=noninteractive apt install -y ttf-mscorefonts-installer || abort "problème lors de l'installation des polices"
# mise à jour du système
echo -e "==> Mise à jour du système\n"
echo "==> Mise à jour du système\n"
apt update || abort "impossible de récupérer les informations des dépôts"
apt full-upgrade -y || abort "erreur lors de la mise à jour des paquets"
@ -311,7 +278,7 @@ install_logiciels() {
# Mises à jour #
################
mises_a_jour() {
echo -e "==> Configuration de dconf\n"
echo -e "Configuraiton de dconf\n"
# Configuration de dconf pour permettre de modifier certaines configurations
# par défaut
mkdir -p /etc/dconf/profile
@ -359,32 +326,11 @@ configuration_apt() {
# GRUB : sélection automatique de la dernière entrée utilisée #
###############################################################
modif_grub() {
# Rien à faire si c'est déjà en place.
#
# update-grub lance os-prober, qui part sonder toutes les partitions de la
# machine à la recherche d'autres systèmes, puis régénère la configuration
# entière : vingt à trente secondes qu'on ne rattrape pas, et qu'on payait
# jusqu'ici à chaque exécution, y compris quand il n'y avait rien à
# changer. Sur une install party de quinze machines, cela se voit.
if grep -q '^GRUB_DEFAULT=saved' /etc/default/grub \
&& grep -q '^GRUB_SAVEDEFAULT=true' /etc/default/grub; then
echo -e "==> GRUB est déjà configuré, rien à changer\n"
return 0
fi
echo -e "==> Modification de GRUB\n"
# On commente la ligne d'origine, puis on ajoute les nôtres si elles
# manquent. Les ajouter plutôt que les insérer règle deux choses : le
# fichier ne se retrouve plus avec des lignes indentées — GRUB les accepte,
# mais elles trompent la lecture quand on vient déboguer —, et la fonction
# fait toujours son travail lorsque « GRUB_DEFAULT=0 » a disparu, ce qui
# arrive dès qu'un autre outil est passé avant nous.
sed -i 's/^GRUB_DEFAULT=0/#&/' /etc/default/grub
grep -q '^GRUB_DEFAULT=saved' /etc/default/grub \
|| echo 'GRUB_DEFAULT=saved' >> /etc/default/grub
grep -q '^GRUB_SAVEDEFAULT=true' /etc/default/grub \
|| echo 'GRUB_SAVEDEFAULT=true' >> /etc/default/grub
# On comment la ligne "GRUB_DEFAULT=0" et on ajoute les "bonnes" options
sed -i '/^GRUB_DEFAULT=0/ i#GRUB_DEFAULT=0\
GRUB_DEFAULT=saved\
GRUB_SAVEDEFAULT=true' /etc/default/grub
# On met à jour GRUB
update-grub
}

View file

@ -1,236 +0,0 @@
#!/bin/bash
#
# Alpinux — état des lieux d'une machine avant d'installer Linux Mint
#
# À lancer depuis la session live, AVANT de toucher au disque :
# wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux-wiki/raw/branch/main/code/linux/linux-mint/verif-disque.sh
# chmod +x verif-disque.sh
# ./verif-disque.sh
#
# Ou, sur le réseau de l'install party :
# wget http://10.0.0.1/verif-disque.sh && chmod +x verif-disque.sh && ./verif-disque.sh
#
# Le script ne modifie RIEN : il lit, il affiche, il conseille. Il peut s'exécuter
# sans droits d'administration, mais plusieurs vérifications les demandent : il
# relance alors sudo de lui-même.
#
# testé le 20/09/2026 sur Linux Mint 22.3 Cinnamon
set -u
VERT=$'\e[32m'; ROUGE=$'\e[31m'; ORANGE=$'\e[33m'; GRAS=$'\e[1m'; RAZ=$'\e[0m'
titre() { printf '\n%s%s%s\n' "$GRAS" "$1" "$RAZ"; printf '%s\n' "${1//?/─}"; }
ok() { printf ' %s✓%s %s\n' "$VERT" "$RAZ" "$1"; }
attention(){ printf ' %s!%s %s\n' "$ORANGE" "$RAZ" "$1"; }
probleme(){ printf ' %s✗%s %s\n' "$ROUGE" "$RAZ" "$1"; }
info() { printf ' %s\n' "$1"; }
# Les alertes collectées en chemin, résumées à la fin.
AVERTISSEMENTS=()
BLOQUANTS=()
if [ "$(id -u)" != "0" ]; then
echo "Certaines vérifications demandent les droits d'administration."
exec sudo -- "$0" "$@"
fi
printf '%s\n' "════════════════════════════════════════════════════════════"
printf '%s\n' " Alpinux — état des lieux avant installation"
printf '%s\n' " $(date '+%d/%m/%Y %H:%M')"
printf '%s\n' "════════════════════════════════════════════════════════════"
# ─────────────────────────────────────────────────────────────────────
titre "La machine"
MODELE="$(cat /sys/devices/virtual/dmi/id/sys_vendor 2>/dev/null) $(cat /sys/devices/virtual/dmi/id/product_name 2>/dev/null)"
info "Modèle : ${MODELE:-inconnu}"
info "Processeur : $(grep -m1 'model name' /proc/cpuinfo | cut -d: -f2- | sed 's/^ //')"
if grep -qw lm /proc/cpuinfo; then
ok "Processeur 64 bits"
else
probleme "Processeur 32 bits : Linux Mint ne s'installera pas"
BLOQUANTS+=("Processeur 32 bits — voir Debian ou LMDE")
fi
RAM_MO=$(( $(grep MemTotal /proc/meminfo | tr -dc '0-9') / 1024 ))
info "Mémoire vive : ${RAM_MO} Mo"
if [ "$RAM_MO" -lt 2000 ]; then
probleme "Moins de 2 Go : en dessous du minimum de Linux Mint"
BLOQUANTS+=("RAM insuffisante (${RAM_MO} Mo)")
elif [ "$RAM_MO" -lt 4000 ]; then
attention "Moins de 4 Go : conseillez l'édition Xfce plutôt que Cinnamon"
AVERTISSEMENTS+=("RAM de ${RAM_MO} Mo — édition Xfce conseillée")
else
ok "Mémoire suffisante pour l'édition Cinnamon"
fi
# ─────────────────────────────────────────────────────────────────────
titre "Le mode de démarrage"
if [ -d /sys/firmware/efi ]; then
ok "Démarrage en UEFI — le disque sera en GPT, avec une partition EFI"
MODE=UEFI
SB=/sys/firmware/efi/efivars/SecureBoot-8be4df61-93ca-11d2-aa0d-00e098032b8c
if [ -r "$SB" ]; then
if [ "$(od -An -t u1 "$SB" 2>/dev/null | awk '{print $5}')" = "1" ]; then
attention "Secure Boot actif : à désactiver si un pilote propriétaire est nécessaire"
AVERTISSEMENTS+=("Secure Boot actif")
else
ok "Secure Boot désactivé"
fi
fi
else
attention "Démarrage en BIOS hérité — le disque sera en MBR, sans partition EFI"
MODE=BIOS
AVERTISSEMENTS+=("Machine démarrée en mode BIOS hérité")
fi
# ─────────────────────────────────────────────────────────────────────
titre "Les disques"
mapfile -t DISQUES < <(lsblk -dn -o NAME,TYPE | awk '$2=="disk"{print $1}')
NB_DISQUES=${#DISQUES[@]}
if [ "$NB_DISQUES" -eq 0 ]; then
probleme "Aucun disque détecté"
BLOQUANTS+=("Aucun disque vu par le système — contrôleur SATA en RAID/Intel RST ?")
elif [ "$NB_DISQUES" -gt 1 ]; then
attention "$NB_DISQUES disques présents : identifiez le bon avant de partitionner"
AVERTISSEMENTS+=("$NB_DISQUES disques — risque d'effacer le mauvais")
fi
for d in "${DISQUES[@]}"; do
TAILLE=$(lsblk -dn -o SIZE "/dev/$d" | tr -d ' ')
ROT=$(cat "/sys/block/$d/queue/rotational" 2>/dev/null)
TYPE=$([ "$ROT" = "0" ] && echo "SSD/NVMe" || echo "disque mécanique")
TABLE=$(blkid -p -s PTTYPE -o value "/dev/$d" 2>/dev/null || echo "aucune")
printf '\n %s/dev/%s%s — %s, %s, table %s\n' "$GRAS" "$d" "$RAZ" "$TAILLE" "$TYPE" "${TABLE:-aucune}"
lsblk -o NAME,SIZE,FSTYPE,LABEL,FSUSE%,MOUNTPOINT "/dev/$d" | sed '1d;s/^/ /'
TAILLE_GO=$(( $(lsblk -dbn -o SIZE "/dev/$d") / 1000000000 ))
if [ "$TAILLE_GO" -lt 11 ]; then
probleme " Moins de 11 Go : l'installateur refusera de démarrer"
BLOQUANTS+=("/dev/$d trop petit (${TAILLE_GO} Go)")
elif [ "$TAILLE_GO" -lt 30 ]; then
attention " ${TAILLE_GO} Go : installable, mais en dessous des 30 Go conseillés"
AVERTISSEMENTS+=("/dev/$d de ${TAILLE_GO} Go seulement")
fi
if [ "$MODE" = "UEFI" ] && [ "$TABLE" = "dos" ]; then
attention " Machine en UEFI mais disque en MBR : table à refaire en GPT"
AVERTISSEMENTS+=("/dev/$d en MBR alors que la machine démarre en UEFI")
fi
done
# ─────────────────────────────────────────────────────────────────────
titre "Ce qui est déjà installé"
TROUVE_WINDOWS=0
TROUVE_LINUX=0
while read -r part type; do
[ -z "$part" ] && continue
case "$type" in
BitLocker)
probleme "$part : partition chiffrée par BitLocker"
BLOQUANTS+=("$part chiffrée BitLocker — suspendre le chiffrement depuis Windows AVANT de toucher au disque")
TROUVE_WINDOWS=1
;;
ntfs)
TROUVE_WINDOWS=1
ETIQUETTE=$(blkid -s LABEL -o value "$part" 2>/dev/null)
ok "$part : partition Windows (NTFS)${ETIQUETTE:+ — « $ETIQUETTE »}"
POINT=$(mktemp -d)
if mount -o ro,noexec,nosuid "$part" "$POINT" 2>/dev/null; then
[ -f "$POINT/hiberfil.sys" ] && {
attention " hiberfil.sys présent : Windows est en veille prolongée ou en démarrage rapide"
AVERTISSEMENTS+=("$part : désactiver le démarrage rapide de Windows, puis arrêt complet")
}
[ -d "$POINT/Windows" ] && info " Windows installé sur cette partition"
umount "$POINT" 2>/dev/null
else
attention " Montage impossible en lecture seule : partition sale, chiffrée, ou mal démontée"
AVERTISSEMENTS+=("$part illisible — Windows mal arrêté ?")
fi
rmdir "$POINT" 2>/dev/null
;;
ext4|ext3|btrfs|xfs)
ETIQUETTE=$(blkid -s LABEL -o value "$part" 2>/dev/null)
ok "$part : partition Linux ($type)${ETIQUETTE:+ — « $ETIQUETTE »}"
TROUVE_LINUX=1
;;
vfat)
if [ "$(blkid -s PARTLABEL -o value "$part" 2>/dev/null)" = "EFI system partition" ] \
|| [ "$(lsblk -no PARTTYPENAME "$part" 2>/dev/null)" = "EFI System" ]; then
ok "$part : partition EFI existante — à réutiliser, pas à recréer"
fi
;;
crypto_LUKS)
attention "$part : partition chiffrée LUKS"
AVERTISSEMENTS+=("$part chiffrée (LUKS) — récupérer la phrase de passe avant d'effacer")
;;
esac
done < <(lsblk -pnl -o NAME,FSTYPE | awk 'NF==2 && $1 ~ /[0-9]$/')
[ "$TROUVE_WINDOWS" = "0" ] && info "Aucune partition Windows détectée."
if [ "$TROUVE_LINUX" = "1" ]; then
attention "Un système Linux occupe déjà ce disque"
AVERTISSEMENTS+=("Linux déjà installé — sauvegarder /home avant de réinstaller")
fi
# ─────────────────────────────────────────────────────────────────────
titre "Santé des disques"
if command -v smartctl >/dev/null; then
for d in "${DISQUES[@]}"; do
SANTE=$(smartctl -H "/dev/$d" 2>/dev/null | grep -Ei 'overall-health|SMART Health' | cut -d: -f2- | sed 's/^ *//')
case "$SANTE" in
*PASSED*|*OK*) ok "/dev/$d : $SANTE" ;;
"") info "/dev/$d : pas d'information SMART (disque virtuel, USB, ou contrôleur muet)" ;;
*) probleme "/dev/$d : $SANTE"
BLOQUANTS+=("/dev/$d signalé défaillant par SMART — ne pas installer dessus") ;;
esac
REALLOC=$(smartctl -A "/dev/$d" 2>/dev/null | awk '/Reallocated_Sector_Ct/{print $10}')
if [ -n "${REALLOC:-}" ] && [ "$REALLOC" -gt 0 ] 2>/dev/null; then
attention "/dev/$d : $REALLOC secteurs réalloués — disque fatigué"
AVERTISSEMENTS+=("/dev/$d : $REALLOC secteurs réalloués")
fi
done
else
info "smartmontools absent de la session live."
info "Pour l'ajouter : sudo apt update && sudo apt install -y smartmontools"
fi
# ─────────────────────────────────────────────────────────────────────
titre "Réseau"
if ping -c1 -W3 archive.ubuntu.com >/dev/null 2>&1; then
ok "Connexion à Internet fonctionnelle (mises à jour et codecs téléchargeables)"
else
attention "Pas d'accès à Internet : branchez le câble réseau avant d'installer"
AVERTISSEMENTS+=("Pas de réseau — codecs et mises à jour ne s'installeront pas")
fi
# ─────────────────────────────────────────────────────────────────────
titre "Conclusion"
if [ ${#BLOQUANTS[@]} -gt 0 ]; then
printf ' %s%sÀ RÉGLER AVANT D'"'"'INSTALLER%s\n' "$GRAS" "$ROUGE" "$RAZ"
for b in "${BLOQUANTS[@]}"; do printf ' %s✗%s %s\n' "$ROUGE" "$RAZ" "$b"; done
echo
fi
if [ ${#AVERTISSEMENTS[@]} -gt 0 ]; then
printf ' %s%sÀ SAVOIR%s\n' "$GRAS" "$ORANGE" "$RAZ"
for a in "${AVERTISSEMENTS[@]}"; do printf ' %s!%s %s\n' "$ORANGE" "$RAZ" "$a"; done
echo
fi
if [ ${#BLOQUANTS[@]} -eq 0 ] && [ ${#AVERTISSEMENTS[@]} -eq 0 ]; then
printf ' %s✓%s Rien ne s'"'"'oppose à l'"'"'installation.\n\n' "$VERT" "$RAZ"
fi
printf ' Dans le doute, montrez cet écran à un bénévole avant de continuer.\n'
printf ' Guide complet : https://wiki.alpinux.org/guides/linux-mint-depuis-windows/\n\n'

View file

@ -1,134 +0,0 @@
---
description: Comment Alpinux recueille les adresses e-mail, quels messages l'association envoie, combien de temps elle conserve vos données et comment exercer vos droits.
---
# ✉️ Vos données, vos adresses, nos envois
Alpinux recueille des adresses e-mail pour faire fonctionner ses activités : vous
inscrire à une install party, vous prévenir qu'un rendez-vous a bougé, vous envoyer
la lettre d'information, tenir à jour la liste des adhérents. Cette page dit lesquelles, pourquoi, pour combien de temps,
et ce que vous pouvez exiger de nous.
**En une phrase :** une adresse donnée à Alpinux ne sert qu'à ce pour quoi elle a été
donnée. Nous ne la revendons pas, ne la partageons pas, et nous ne vous écrivons que
pour ce que vous avez demandé.
---
## Où nous recueillons une adresse
| Occasion | Ce que nous recueillons |
|---|---|
| **Inscription à une install party** | Nom, adresse e-mail, téléphone (facultatif), description de la machine et de ses périphériques, et ce que vous voulez bien nous en dire |
| **Inscription comme installateur ou installatrice** | Prénom, nom, adresse e-mail, heures de présence annoncées |
| **Organisation d'une install party** | L'adresse e-mail des personnes à qui l'on confie l'organisation ou l'administration de l'événement |
| **Adhésion à l'association** | Recueillie par **HelloAsso** au moment de l'adhésion ; les coordonnées des adhérents sont ensuite tenues dans **Dolibarr**, sur le serveur de l'association |
| **Compte AlpID** | Votre identifiant, votre nom et votre adresse e-mail, conservés par notre service d'authentification |
| **Un message que vous nous envoyez** | Ce que contient votre message, et l'adresse qui l'a envoyé |
Aucun de nos sites ne collecte d'adresse à votre insu : il faut toujours l'avoir
saisie dans un formulaire, ou nous avoir écrit.
---
## Ce que nous envoyons
Tous nos messages automatiques viennent de l'application **Install Party**, et partent
de l'adresse **Alpinux &lt;alpinux@alpinux.org&gt;**. Ce sont des messages en texte
simple, sans image ni traceur : rien ne nous dit si vous les avez ouverts.
### Si vous vous êtes inscrit à une install party
| Message | Quand il part |
|---|---|
| Confirmation d'inscription | Dès l'inscription enregistrée — il porte le lieu, l'horaire et le lien vers votre fiche |
| Lien vers votre espace | Quand vous demandez à retrouver votre inscription |
| Votre rendez-vous passe à telle heure | Quand l'organisation déplace votre créneau |
| Votre fiche d'installation | Le soir (19 h 30) du jour où un bénévole a noté quelque chose sur votre installation — un seul message, même s'il y a eu plusieurs notes |
### Si vous êtes bénévole sur une install party
| Message | Quand il part |
|---|---|
| Votre code installateur | À votre inscription comme installateur |
| Vos heures de présence | Relance quand vos disponibilités manquent encore |
| Les fiches d'installation sont prêtes | Quand l'organisation ouvre les fiches avant l'événement |
| Note sur l'installation de telle heure | Quand une note est ajoutée sur une machine dont vous vous occupez |
| Rendez-vous déplacé | Quand un créneau que vous teniez change d'heure |
| Nouvel installateur | À l'organisation, quand quelqu'un rejoint l'équipe |
Chacun de ces messages répond à quelque chose que vous avez fait, ou à un changement
qui vous concerne directement.
---
## La lettre d'information
C'est notre seul envoi régulier : **deux à quatre fois par mois**, un message qui
annonce les prochains rendez-vous, les install parties, les présentations et ce qui
occupe l'association. Il part du serveur de l'association.
**Qui la reçoit.** Les adhérents, et toute personne qui a demandé à la recevoir. Une
inscription à une install party ne vous y abonne pas : il faut l'avoir demandé. Pour
la recevoir sans être adhérent, abonnez-vous vous-même sur
**[messagerie.alpinux.org](https://messagerie.alpinux.org)** — la marche à suivre est
décrite dans [S'abonner et se désabonner](messagerie-abonnement.md#inscription).
**Comment s'en aller.** Chaque envoi porte un lien de désinscription, en pied de page
et dans ses en-têtes. Un clic suffit, il n'y a rien à justifier, et le retrait est
immédiat. Vous continuerez à recevoir les
messages liés à vos inscriptions en cours — ce sont deux choses distinctes.
---
## Ce que nous n'envoyons pas
- **Pas de démarchage**, ni pour nous, ni pour personne d'autre.
- **Pas de transmission à des tiers.** Vos coordonnées ne sortent pas de l'association,
sauf obligation légale.
- **Pas de revente.** Jamais, à personne, à aucun prix.
---
## Qui voit votre adresse
- **Pour une install party** : les personnes qui organisent cet événement-là, et les
bénévoles qui s'occupent de votre machine. Pas les autres install parties.
- **Pour une adhésion** : les membres du bureau qui tiennent le registre dans Dolibarr.
- **Pour un compte AlpID** : nos applications (quiz, administration) voient votre
adresse le temps de votre session ; elles ne la conservent pas dans leur base.
---
## Combien de temps nous les gardons
- **Les données d'une install party** sont conservées **13 mois**, puis supprimées.
Elles servent à nos statistiques d'activité et à nos obligations d'association
loi 1901. Vous pouvez demander à les conserver plus longtemps, par exemple pour
qu'on retrouve l'historique de votre machine à la prochaine install party.
- **Si vous annulez votre inscription**, tout part immédiatement : votre fiche, vos
coordonnées, et les photos qui auraient été jointes.
- **Les données d'adhésion** sont conservées le temps requis pour la tenue des
comptes et du registre des membres.
---
## Vos droits
Vous pouvez à tout moment demander à **accéder** à vos données, à les faire
**corriger**, ou à les faire **supprimer**.
- Pour vos données personnelles : **dpo@alpinux.org**
- Pour toute autre question : **secretaire@alpinux.org**
Une demande de suppression est traitée dès réception. Si nous devons garder une trace
pour une obligation légale, nous vous le disons et nous vous disons laquelle.
---
## Qui traite ces données
**Alpinux**, association loi 1901, Chambéry (Savoie). Les inscriptions, le registre
des membres et les envois sont gérés par nos propres applications — Install Party et
Dolibarr — hébergées sur le serveur de l'association. Seules les adhésions passent par
**HelloAsso**, qui applique sa propre politique de confidentialité.

View file

@ -8,18 +8,10 @@ N'hésitez pas à vous abonner au calendrier des évènements Alpinux. Vous pouv
- **Google Agenda :** [Ajouter à Google Agenda](https://calendar.google.com/calendar/render?cid=webcal://alpinux.org/public-calendars/n5BWPYsxw7FCYozM)
- **Outlook Live :** [Ajouter à Outlook Live](https://outlook.live.com/owa/?path=/calendar/action/compose&rru=addsubscription&url=webcal://alpinux.org/public-calendars/n5BWPYsxw7FCYozM)
- **Outlook 365 :** [Ajouter à Outlook 365](https://outlook.office.com/owa?path=/calendar/action/compose&rru=addsubscription&url=webcal://alpinux.org/public-calendars/n5BWPYsxw7FCYozM)
- **Thunderbird :** menu **Fichier › Nouveau › Agenda…**, choisir **Sur le réseau**, laisser le nom d'utilisateur vide, cocher « Cette adresse ne demande pas d'identifiants de connexion » et coller l'adresse **HTTPS** ci-dessous. L'agenda apparaît sous le nom « Alpinux évènements ».
Attention : ces liens d'abonnement fonctionnent depuis un PC, mais pas forcément depuis un smartphone ou une tablette.
Adresse **HTTPS**, à coller dans Thunderbird et dans tout logiciel qui demande l'adresse d'un agenda iCalendar :
```
https://alpinux.org/public-calendars/n5BWPYsxw7FCYozM/Alpinux%20%C3%A9v%C3%A8nements.ics
```
Adresse **Webcal** :
```
webcal://alpinux.org/public-calendars/n5BWPYsxw7FCYozM
```
Avec l'adresse en `webcal://`, Thunderbird répond « Aucun agenda à cette adresse » : il la traduit en `http://`, et la bascule du site vers `https://` le fait rejeter la réponse. Utilisez l'adresse HTTPS.

View file

@ -13,13 +13,6 @@ L'association propose également des **services numériques** à ses membres.
[Gérer son adhésion](https://www.helloasso.com/associations/alpinux-le-lug-de-savoie){ .md-button }
[Install Party](install-party.md){ .md-button }
## Vos données
Ce que nous faisons de votre adresse e-mail, ce que nous vous envoyons, et ce que
nous ne vous enverrons jamais.
[Vos données, vos adresses, nos envois](donnees-personnelles.md){ .md-button }
## Événements
[Tous les événements et rendez-vous](evenements.md){ .md-button .md-button--primary }

View file

@ -58,7 +58,6 @@ Lors de nos **Install Party**, les bénévoles d'**Alpinux** installent Linux av
## 🧰 Après l'installation
- 🩹 [**Trousse de premiers secours Linux Mint**](../guides/linux-mint-trousse.md) — les réflexes utiles des premiers jours.
- 🖧 [**Le serveur qu'on emporte**](../technique/serveur-install-party.md) — le réseau de la salle, le cache de paquets, et ce qu'un bénévole doit en savoir.
- 🗣️ [**Ateliers et rencontres**](evenements.md) — pour progresser et échanger avec la communauté.
---

View file

@ -1,113 +0,0 @@
---
description: Pour les bénévoles installateurs d'Alpinux : retrouver ses accès, annoncer ses heures de présence, préparer les machines et répondre aux participants.
---
# 🔧 J'aide comme bénévole installateur
Cette page est pour l'équipe qui installe. Les autres usages du site ont
[leur propre page](installparty-mode-emploi.md).
---
## Retrouver ses accès
![L'écran où l'on donne son adresse](../assets/installparty/03-espace-connexion.png)
[installparty.alpinux.org/party/moi](https://installparty.alpinux.org/party/moi)
est le seul endroit où l'on saisit son adresse. Vous y recevez un lien — valable
une demi-heure — qui ouvre tout ce que cette adresse ouvre.
![L'espace personnel : ce que votre adresse ouvre](../assets/installparty/04-espace-personnel.png)
On y trouve son **code installateur**, les machines dont on s'occupe, et le lien
vers sa grille.
## Entrer dans son espace : deux codes
![L'écran qui demande le code à quatre chiffres](../assets/installparty/07-deux-codes.png)
- **Le code installateur**, quatre caractères, donné par l'organisation ;
- **un code à quatre chiffres**, que vous choisissez.
Le premier se dicte au téléphone, donc il se devine ; le second le protège.
### À votre première venue
Saisissez votre code installateur et laissez le second champ vide : un lien part
vers votre boîte et vous fait choisir vos quatre chiffres.
![Le choix du code à quatre chiffres](../assets/installparty/08-choisir-son-code.png)
Le lien vaut une demi-heure. Oublié votre code ? Demandez-en un autre depuis la
page de connexion — le nouveau remplace l'ancien.
!!! tip "Faites-le avant le jour J"
Le choix du code passe par votre boîte aux lettres. Le faire tranquillement
chez soi vaut mieux que de s'y prendre en salle, un samedi matin.
## Annoncer ses heures
![La grille des heures de présence et les rendez-vous du jour](../assets/installparty/05-espace-installateur.png)
!!! warning "Vos heures ouvrent les places"
Le nombre de créneaux proposés au public **se calcule à partir des heures
annoncées**. Une grille vide n'ouvre aucune place : ce n'est pas une
formalité, c'est ce qui décide du nombre de personnes qu'on pourra recevoir.
Cochez les heures où vous serez là. L'enregistrement est automatique, et vous
pouvez y revenir autant de fois que votre journée change — l'organisation le
voit aussitôt.
Le tableau **« Où en est la journée ? »** montre, heure par heure, combien
d'installateurs sont annoncés, combien seront occupés et combien restent
disponibles. Une colonne dégarnie se comble en cochant une heure de plus.
## Préparer les installations
Sous les rendez-vous du jour, vous voyez qui vient, avec quelle machine et ce que
la personne a signalé — **sans ses coordonnées** : s'il faut joindre quelqu'un,
c'est l'organisation qui s'en charge.
Vous pouvez :
- **écrire ce qu'il y a à prévoir** dans la note « À prévoir avant
l'installation » : un dongle, un pilote, un point à vérifier ;
- **vous charger d'une machine**, pour que l'équipe sache qui s'en occupe. Votre
nom s'affiche alors à côté du rendez-vous ;
- **répondre** aux questions du participant, et joindre un document ou une photo.
!!! danger "La personne inscrite lit cette note"
« À prévoir avant l'installation » s'affiche sur sa fiche, sous le titre
« Informations importantes », et un message l'avertit le soir même.
Écrivez-la comme si elle la lisait, parce qu'elle la lira.
Les versions précédentes de la note restent consultables, avec leur auteur : on
peut voir ce qui a été modifié, et reprendre une version antérieure si besoin.
## Le jour de l'install party
La **fiche d'installation** — les points à cocher — s'ouvre le jour même. D'ici
là, il n'y a rien à y noter.
Pour l'ouvrir, deux chemins : depuis votre espace si vous vous êtes déjà chargé
de la machine, ou en donnant le **numéro de réservation** que la personne annonce
à l'accueil.
---
## Questions courantes
??? question "Je me suis inscrit par un lien, et je ne vois aucun rendez-vous"
Votre inscription attend d'être confirmée par l'équipe. En attendant, vous
pouvez cocher vos heures — c'est même le plus utile. Vous recevrez un message
quand ce sera fait.
??? question "Je me suis trompé plusieurs fois de code"
Au bout de quelques essais, l'accès se ferme quelques minutes. Cela ne
concerne que vous : vos collègues, même sur le même réseau, ne sont pas
gênés.
??? question "Puis-je laisser une machine à quelqu'un d'autre ?"
Oui, tant que vous n'avez rien écrit sur sa fiche : le bouton « Je ne m'en
occupe plus » la rend disponible. Une fois que vous y avez noté quelque
chose, votre nom y reste — une fiche doit pouvoir dire qui l'a remplie.

View file

@ -1,47 +0,0 @@
---
description: Le mode d'emploi du site des install parties d'Alpinux, selon que vous venez faire installer Linux, que vous aidez comme bénévole ou que vous organisez la journée.
---
# 🐧 Le site des install parties
Les install parties d'<span class="alpinux-brand">A<strong>l</strong>p<strong>inux</strong></span>
se tiennent avec un outil à nous : **[installparty.alpinux.org](https://installparty.alpinux.org)**.
On y réserve son créneau, on y suit ce qui a été fait sur sa machine, et les
bénévoles y préparent leur journée.
!!! info "Pas de compte, pas de mot de passe"
Il n'y a rien à créer et rien à retenir. Tout passe par des liens reçus par
courriel et, pour les bénévoles, par un code personnel. Une adresse donnée
ici ne sert qu'à l'install party.
---
## Trois façons d'utiliser le site
### 💻 [Je viens faire installer Linux](installparty-participant.md)
Choisir son créneau, s'inscrire, et suivre la fiche de sa machine avant, pendant
et après l'install party. Vous pouvez aussi y écrire aux bénévoles.
### 🔧 [J'aide comme bénévole installateur](installparty-benevole.md)
Retrouver ses accès, annoncer ses heures de présence — ce sont elles qui ouvrent
les places —, préparer les machines qu'on prendra et répondre aux questions.
### 📋 [J'organise une install party](installparty-organisateur.md)
Tenir la journée : horaires, places, équipe, fiches. Et ce qu'il faut savoir sur
les liens d'accès, qui valent mot de passe.
---
## Où trouver quoi
| Vous cherchez | Adresse |
|---|---|
| La prochaine install party, et s'y inscrire | [installparty.alpinux.org](https://installparty.alpinux.org) |
| Vos accès : code installateur, liens, inscriptions | [/party/moi](https://installparty.alpinux.org/party/moi) |
| La fiche de votre machine | le lien personnel reçu à l'inscription |
Une question à laquelle ces pages ne répondent pas ? Écrivez-nous — l'adresse
figure au bas des messages que vous recevez.

View file

@ -1,107 +0,0 @@
---
description: Pour les organisateurs d'une install party Alpinux : tenir la journée, gérer l'équipe et les créneaux, et les règles à connaître sur les liens d'accès.
---
# 📋 J'organise une install party
Cette page est pour qui tient une install party de bout en bout. Les autres
usages du site ont [leur propre page](installparty-mode-emploi.md).
---
## L'espace d'organisation
![L'espace d'organisation : horaires, places, équipe](../assets/installparty/09-organisation.png)
Tout s'y tient : les horaires et leurs places, l'équipe et ses heures, les
inscrits et leurs fiches, la check-list.
!!! danger "Le lien vaut mot de passe"
L'adresse de cette page contient une clé. Quiconque l'a peut voir les
inscrits, les modifier et les supprimer.
- Ne la publiez **jamais** : ni sur une affiche, ni dans un code QR, ni dans
un message à plusieurs. Voir
[Liens et codes QR](../communication/liens-et-codes-qr.md).
- Elle **cesse de valoir trente minutes** après votre dernière action. On en
redemande une depuis [/party/moi](https://installparty.alpinux.org/party/moi),
ce qui remplace l'ancienne.
## Les places se calculent
Le nombre de places d'un créneau n'est pas saisi : il se **déduit** des
installateurs annoncés présents pendant toute la durée d'une installation,
pondérés par la charge que vous fixez.
- Huit installateurs présents, charge à 90 % : sept places.
- Baisser la charge garde de la marge — le temps d'accueillir, de dépanner un
voisin, de souffler.
- Vous pouvez ajouter ou retirer une place à la main ; l'écart est conservé même
si l'équipe change.
Une conséquence : **relancer les installateurs qui n'ont pas coché leurs heures
ouvre des places**. Le bouton est sur la page, à côté de ceux qui manquent.
## L'équipe
Deux façons d'entrer dans l'équipe :
- **vous ajoutez quelqu'un** : il reçoit son code, et voit tout aussitôt ;
- **quelqu'un s'inscrit** par le lien d'inscription des installateurs : il
attend votre confirmation avant de voir les rendez-vous, et ses heures
n'ouvrent pas de place d'ici là. La page le signale par « inscrit lui-même ·
à confirmer ».
Cette différence est voulue : le lien d'inscription circule sur les listes de
diffusion, et s'inscrire ne doit pas suffire à voir chez qui l'on va installer.
## Les coordonnées ne s'affichent pas
L'adresse et le téléphone de chaque inscrit sont masqués. Un bouton les demande,
et **chaque demande est inscrite au journal**.
![L'historique : ce qui a été fait, et depuis où](../assets/installparty/10-historique.png)
La page **Historique** montre, pour votre install party : quand, quoi, sur qui,
depuis quelle adresse et avec quel navigateur. Elle sert à une chose — savoir ce
qui a été consulté si un accès venait à fuiter.
Les adresses IP s'effacent d'elles-mêmes au bout de six mois.
## Avant la journée
- **Composer la check-list** que suivront les installateurs : un modèle existe,
à adapter.
- **Annoncer que les fiches sont prêtes** : un bouton prévient toute l'équipe
qu'elle peut préparer les machines.
- **Écrire ce qu'il y a à prévoir** sur les fiches que vous connaissez déjà —
ce que la personne a dit au téléphone, par exemple.
- **Vérifier l'écran de salle** : il affiche les rendez-vous à l'accueil, sans
aucune coordonnée. Sa clé est distincte de la vôtre, parce qu'un écran se
photographie.
## Le jour même
- Les participants annoncent leur **numéro de réservation** à l'accueil.
- Un rendez-vous peut être **déplacé** d'un créneau à l'autre : la personne et
les installateurs concernés en sont prévenus, et la fiche suit.
- Les fiches se remplissent ; vous pouvez les relire et les corriger.
---
## Questions courantes
??? question "J'ai perdu le lien de mon install party"
[/party/moi](https://installparty.alpinux.org/party/moi), avec l'adresse
enregistrée pour cette install party. Si personne ne l'a plus, écrivez à
l'association.
??? question "Une clé a été publiée par erreur"
Renouvelez-la immédiatement en redemandant votre lien, puis regardez
l'Historique pour savoir ce qui a été consulté. La marche à suivre complète
est dans [Liens et codes QR](../communication/liens-et-codes-qr.md).
??? question "Comment ouvrir une nouvelle install party ?"
Votre adresse doit y être autorisée. Depuis
[/party/moi](https://installparty.alpinux.org/party/moi), un bouton
« Ouvrir une install party » apparaît si c'est le cas.

View file

@ -1,130 +0,0 @@
---
description: S'inscrire à une install party Alpinux, comprendre ce qu'on vous demande, et suivre la fiche de votre machine avant, pendant et après la journée.
---
# 💻 Je viens faire installer Linux
Cette page suit votre parcours, de l'inscription au compte rendu de
l'installation. Les autres usages du site ont
[leur propre page](installparty-mode-emploi.md).
---
## 1. Choisir son créneau
Depuis [installparty.alpinux.org](https://installparty.alpinux.org), vous arrivez
sur la liste des install parties à venir.
![La liste des install parties ouvertes aux inscriptions](../assets/installparty/01-liste-publique.png)
Chaque carte indique la date, le lieu et s'il reste de la place. Un clic sur
**S'inscrire** ouvre le formulaire.
## 2. S'inscrire
![Le formulaire d'inscription, avec le choix de l'heure](../assets/installparty/02-inscription.png)
Ce qu'on vous demande, et pourquoi :
| Ce qu'on demande | À quoi cela sert |
|---|---|
| Votre nom | vous accueillir, et retrouver votre machine dans la journée |
| Votre adresse électronique | vous envoyer votre confirmation et le suivi |
| Votre téléphone | vous joindre le jour même si besoin — facultatif |
| La machine et son âge | préparer ce qu'il faut : une clé, un pilote, un adaptateur |
| Ce que vous signalez | tout ce que vous jugez utile : un bruit, une lenteur, un doute |
| L'heure de passage | les créneaux restants s'affichent seuls |
Deux cases sont à cocher : **vos sauvegardes sont faites** et vous avez lu la
décharge.
!!! danger "Les sauvegardes ne sont pas une formalité"
Une installation efface le disque. Copiez vos documents, vos photos et vos
mots de passe sur un disque externe ou une clé **avant** de venir. Les
bénévoles vous aideront volontiers à le faire, mais cela prend du temps —
autant arriver prêt.
## 3. Après l'inscription
Vous recevez un courriel avec :
- **votre numéro de réservation**, à annoncer à l'accueil le jour J ;
- **un lien personnel** vers la fiche de votre machine. Gardez-le : c'est par
lui qu'on la retrouve, pendant **douze mois après l'install party**.
## 4. Suivre la fiche de sa machine
![La fiche d'installation vue par le participant](../assets/installparty/06-fiche-participant.png)
Cette page vit avant, pendant et après l'install party.
Pour l'ouvrir, cliquez sur votre lien : la page vous propose de vous envoyer
une clé, et un message arrive aussitôt.
**Avant**, les bénévoles y notent ce qu'il faudra prévoir pour votre machine —
sous « Informations importantes ». Lisez-le : on vous y demande parfois
d'apporter un câble, de retrouver un mot de passe ou de préciser un détail.
**Pendant**, elle se remplit au fur et à mesure : ce qui a été vérifié, ce qui a
été installé, ce qui reste à faire.
**Après**, elle reste consultable pendant douze mois. C'est le compte rendu de
ce qui a été fait sur votre machine : si vous y tenez, imprimez-la ou
enregistrez-la avant la fin de ce délai.
Un message vous prévient le soir quand quelque chose a changé.
## 5. Écrire aux bénévoles
Le bloc **« Répondre »**, en bas de votre fiche, envoie votre message aux
bénévoles qui préparent votre passage : un doute sur ce qu'on vous demande
d'apporter, une machine de plus, un empêchement.
Vous pouvez y joindre une **photo ou une capture d'écran** — un message d'erreur
se montre mieux qu'il ne se décrit.
!!! info "Une clé vous est envoyée à chaque visite"
Votre lien dit **quelle** fiche vous demandez ; il ne l'ouvre pas. Nous
envoyons une clé à l'adresse de votre inscription : elle ouvre la fiche pour
une demi-heure, le temps de la lire et de répondre. Tant que vous y êtes,
rien ne vous est redemandé.
Pourquoi : un lien qu'on garde finit par traîner — dans une archive, une
boîte partagée, un téléphone changé. Ce qu'on a noté sur votre machine ne
regarde que vous.
!!! warning "Ne répondez pas au courriel"
Les messages que le site vous envoie partent d'une adresse automatique.
Une réponse n'atteindrait pas les bénévoles et se perdrait : utilisez le bloc
« Répondre » de votre fiche.
---
## Questions courantes
??? question "J'ai perdu le lien de ma fiche"
Rendez-vous sur [installparty.alpinux.org/party/moi](https://installparty.alpinux.org/party/moi),
donnez l'adresse avec laquelle vous vous êtes inscrit, et tout ce que cette
adresse ouvre vous est renvoyé — la fiche comprise.
??? question "Ma clé ne fonctionne plus"
Une clé reçue par courriel vaut une demi-heure — comme toutes celles que
nous envoyons. Redemandez-en une depuis votre lien : elle repart aussitôt.
??? question "Mon lien ne fonctionne plus"
Les fiches se ferment douze mois après l'install party. Passé ce délai, le
lien ne mène plus à rien : ce qui a été fait sur votre machine ne nous
regarde plus, et nous n'avons pas de raison de le garder consultable
indéfiniment.
??? question "Je ne peux plus venir"
Dites-le nous : votre place sera rendue à quelqu'un d'autre, et vos
informations effacées si vous le souhaitez. L'adresse figure au bas des
messages que vous avez reçus.
??? question "Qui voit mes coordonnées ?"
L'organisation, et seulement en les demandant — chaque consultation est
inscrite au journal de l'install party. Les bénévoles installateurs, eux,
voient votre nom, votre machine et ce que vous avez signalé, mais **ni votre
adresse ni votre téléphone**. Voir
[Vos données, vos adresses, nos envois](donnees-personnelles.md).

View file

@ -1,130 +0,0 @@
---
description: Comment s'abonner à une liste de diffusion d'Alpinux, confirmer son adresse, se désabonner, et lire les messages déjà envoyés.
---
# ✉️ S'abonner et se désabonner
Ce guide s'adresse à toute personne qui veut **recevoir les annonces de
l'association**, ou cesser de les recevoir. Aucun compte n'est nécessaire.
**En une phrase :** vous vous abonnez et vous vous désabonnez vous-même, personne ne
peut le faire à votre place, et rien ne part vers une adresse qui ne l'a pas
demandé.
---
## S'abonner { #inscription }
Rendez-vous sur la page d'accueil de la messagerie de l'association.
![La page d'accueil : votre adresse, la liste, et c'est tout](../assets/messagerie/abonnement-01-accueil.png)
Indiquez votre adresse de courriel, choisissez la liste qui vous intéresse, puis
**Continuer**.
L'écran suivant affiche un **code** — de la forme `ALPX-7K3M9Q` — et vous demande de
faire une chose, une seule :
!!! tip "Envoyez-nous un message depuis l'adresse que vous venez de saisir"
Destinataire : **messagerie@alpinux.org**
Objet : **le code affiché**, recopié tel quel
Corps du message : ce que vous voulez, il n'est pas lu
![Le code à recopier, l'adresse où écrire, et l'heure limite](../assets/messagerie/abonnement-02-code.png)
Un bouton **Ouvrir mon logiciel de messagerie** prépare le message pour vous. Il ne
l'envoie pas : c'est à vous de le faire.
Vous avez **trente minutes**. Passé ce délai, le code ne vaut plus rien et la demande
s'efface d'elle-même — sans aucune conséquence, vous pouvez recommencer.
Dans la minute qui suit votre envoi, vous recevez une réponse qui confirme
l'inscription, rappelle la liste, et porte déjà le lien pour partir.
![La réponse reçue une fois le code envoyé](../assets/messagerie/abonnement-03-confirmation.png)
### Pourquoi est-ce à moi d'écrire ?
D'habitude, un site vous envoie un courriel de confirmation. Ici, c'est l'inverse.
Trois raisons.
- **Rien ne part vers une adresse non vérifiée.** Écrire à des adresses non
confirmées est ce qui abîme le plus la réputation d'un expéditeur — et quand elle
est abîmée, ce sont les messages de toute l'association qui finissent en
indésirable, chez tout le monde.
- **Inscrire l'adresse de quelqu'un d'autre ne lui envoie rien.** La demande reste en
attente puis s'efface. Personne ne peut vous abonner à votre insu, ni se servir de
ce formulaire pour vous faire parvenir un message.
- **Un message venu de votre boîte prouve mieux que vous la possédez** qu'un clic sur
un lien : certains antivirus d'entreprise cliquent les liens tout seuls.
La contrepartie, c'est une manipulation à faire. Elle est assumée.
### Je me suis déjà abonné, ou désabonné, par le passé
Le parcours est le même. C'est d'ailleurs **le seul moyen de revenir** : l'association
ne réinscrit jamais personne de sa propre initiative.
### Je n'ai pas reçu la confirmation
Trois choses à vérifier, dans cet ordre :
1. **Avez-vous écrit depuis l'adresse que vous aviez saisie ?** Le code ne vaut que
présenté depuis celle-ci. Un message envoyé depuis une autre boîte est refusé.
2. **Les trente minutes sont-elles passées ?** Recommencez, c'est sans conséquence.
3. **Le code était-il bien dans l'objet ?** Il est aussi reconnu dans le corps du
message, mais l'objet est le plus sûr.
---
## Se désabonner { #desabonnement }
**Chaque message reçu porte un lien de désabonnement**, à deux endroits : en pied de
page, et dans les en-têtes techniques du message.
C'est ce second emplacement qui fait apparaître un bouton **Se désabonner** en haut
du message dans les logiciels modernes — Gmail, Outlook, Thunderbird, Apple Mail. Un
clic suffit.
![Le bouton « Se désabonner » qu'affiche votre logiciel de messagerie](../assets/messagerie/abonnement-04-bouton-desabonner.png)
La page qui s'ouvre vous laisse choisir :
- quitter **cette liste seulement** ;
- ou quitter **toutes les listes** de l'association d'un coup.
![Quitter cette liste, ou toutes](../assets/messagerie/abonnement-05-desabonnement.png)
Aucune justification n'est demandée. Le retrait est immédiat, et il n'y a personne à
qui écrire.
!!! note "Vous n'avez plus aucun message sous la main ?"
Reprenez simplement le parcours d'inscription : il vous renverra un message, qui
portera le lien.
---
## Lire ce qui a déjà été envoyé { #archives }
Les listes ouvertes au public ont des **archives** consultables sans compte. C'est
utile avant de s'abonner, pour voir à quoi on s'engage.
![Les envois passés d'une liste publique](../assets/messagerie/abonnement-06-archives.png)
Seuls y figurent les messages **réellement envoyés** : ni les brouillons, ni les
envois annulés.
!!! info "Aucune adresse de courriel n'apparaît dans les archives"
Les adresses citées dans le corps d'un message — signature, contact d'un
événement, adresse d'un partenaire — y sont masquées : `s****@a****.xxx`. On voit
qu'un contact existait, sans pouvoir le reconstituer ni même savoir chez quel
fournisseur il est hébergé. Leurs titulaires n'ont pas consenti à une publication
sur le web, où un robot les ramasserait pour en faire du spam.
---
## Voir aussi
- [Vos données, vos adresses, nos envois](donnees-personnelles.md)
- [Écrire et recevoir des messages](messagerie-membre.md) — la messagerie entre
membres, qui est autre chose que les listes.

View file

@ -1,300 +0,0 @@
---
description: Guide du gestionnaire de listes Alpinux — créer une liste, préparer et envoyer un message, gérer les abonnés, comprendre les adresses désactivées et surveiller la réputation d'envoi.
---
# 📣 Gérer une liste de diffusion
Ce guide s'adresse aux personnes qui **écrivent à toute une liste** : le bureau, et
les administrateurs de l'outil.
**En une phrase :** vous rédigez un brouillon, vous le mettez en file d'envoi, et un
automate le distribue en lissant le débit pendant que vous faites autre chose.
!!! warning "N'envoyez plus de message en copie cachée depuis votre logiciel de messagerie"
Les deux méthodes ne se coordonnent pas : l'outil ne saurait rien de ce qui est
parti par l'autre chemin, ni des rebonds que cela aurait provoqués. Et c'est
précisément ce mode d'envoi qui saturait le serveur — au-delà d'un certain
nombre de messages par heure, il refuse les suivants et une partie de l'envoi
est perdue sans que personne le voie.
---
## Envoyer un message à une liste { #envoyer }
### 1. Rédiger
Menu **Listes → Campagnes**, puis **Nouvelle campagne**.
![La rédaction, avec l'aperçu de ce qui partira](../assets/messagerie/gestionnaire-01-redaction.png)
Choisissez la liste destinataire, écrivez l'objet et le corps.
Le corps s'écrit en **Markdown** — la même syntaxe que ce wiki, voir
[Écrire en Markdown](../contribuer/markdown.md). Un aperçu s'affiche à côté ; le
bouton **Enregistrer et actualiser l'aperçu** le rafraîchit.
Trois variables sont remplacées à l'envoi, pour chaque destinataire :
| Variable | Remplacée par |
|---|---|
| `{{nom}}` | le nom de l'abonné, s'il est connu |
| `{{email}}` | son adresse |
| `{{desabonnement}}` | le lien de désabonnement qui lui est propre |
**Enregistrer le brouillon** vous permet de revenir plus tard : rien ne part tant que
vous n'avez rien demandé.
!!! danger "Le lien de désabonnement n'est pas optionnel"
Si vous ne placez pas `{{desabonnement}}` vous-même, un lien est ajouté
automatiquement en pied de message. Ce comportement ne se désactive pas : un
envoi de masse sans lien de désabonnement est signalé comme spam, et c'est
ensuite toute l'association qui n'arrive plus à écrire à personne.
### 2. Vérifier avant d'envoyer
Relisez l'aperçu. C'est le dernier moment confortable : une fois la file remplie, ce
qui est parti est parti.
Deux choses valent le coup d'œil :
- **les liens** — un lien faux dans un message envoyé à toute la liste ne se
rattrape pas ;
- **le nombre de destinataires**, affiché sur la fiche de la liste.
### 3. Envoyer
Bouton **Mettre en file d'envoi…**. Une confirmation vous est demandée, avec le
nombre de destinataires.
![Le dernier écran avant que la file se remplisse](../assets/messagerie/gestionnaire-02-confirmation.png)
L'envoi se fait ensuite tout seul, une minute sur l'autre, **sous un plafond horaire**
fixé pour ne pas saturer le serveur. Une liste de quelques centaines de personnes
part en une heure environ.
Vous pouvez fermer la page : l'envoi continue.
### 4. Suivre
La fiche de la campagne affiche la progression : envoyés, en attente, échecs.
![L'envoi en cours : remis, en attente, échecs](../assets/messagerie/gestionnaire-03-progression.png)
Si le compteur semble figé, c'est probablement le plafond horaire : l'envoi reprend
de lui-même à l'heure suivante.
### Arrêter, recommencer
- **Annuler les envois restants…** abandonne ce qui n'est pas encore parti. Ce qui
est déjà distribué ne revient pas.
- **Dupliquer en brouillon** recrée une copie modifiable d'un envoi passé — pratique
pour une lettre dont la structure ne change pas d'un mois sur l'autre.
- **Supprimer ce brouillon…** efface un brouillon abandonné. Une confirmation est
demandée, et il n'y a pas de corbeille. Seul un brouillon se supprime : une
campagne partie reste, puisque des gens l'ont reçue et qu'elle figure dans les
archives.
---
## Créer une liste { #creer }
Menu **Listes → Listes de diffusion**, puis le formulaire de création.
![Créer une liste : le nom et la description suffisent](../assets/messagerie/gestionnaire-04-creer-liste.png)
Seuls **le nom** et **la description** sont demandés. Le reste est automatique :
- l'**identifiant technique** se déduit du nom ;
- l'**expéditeur** est celui de l'association, suivi du nom de l'auteur à
l'envoi — « Alpinux (de la part de Prénom Nom) » ;
- les **réponses** reviennent à l'adresse d'expédition, qui est relevée.
Rien de cela ne se règle liste par liste : l'association écrit sous une seule
identité. Multiplier les expéditeurs éparpille la réputation du domaine autant que
cela désoriente les destinataires.
!!! note "Le nom d'une liste n'est pas modifiable après création"
Relisez-le avant de valider.
---
## Gérer les abonnés { #abonnes }
Menu **Listes → Listes de diffusion**, puis la liste voulue.
![La fiche d'une liste, adresses masquées par défaut](../assets/messagerie/gestionnaire-05-fiche-liste.png)
Quatre compteurs résument l'état : destinataires joignables, inscrits au total,
désabonnés, adresses mortes.
### Les adresses sont masquées
Elles s'affichent sous la forme `c••••••e@exemple.fr`. Le domaine reste lisible — il
suffit au diagnostic — sans étaler à l'écran un carnet d'adresses exploitable.
Un lien **Afficher les adresses en clair** lève le masque quand c'est nécessaire.
### Ajouter des abonnés
Deux moyens, dans le volet **Ajouter des abonnés** :
- **coller une liste d'adresses**, une par ligne. Les formes `nom@exemple.fr`,
`nom@exemple.fr;Prénom Nom` et `Prénom Nom <nom@exemple.fr>` sont acceptées ;
- **importer depuis Dolibarr** les adhérents à jour de cotisation.
!!! danger "Un import ne réactive jamais une adresse partie"
Désabonnée, morte, ou ayant signalé un spam : l'outil refuse de la remettre en
service, même si elle figure dans le fichier importé. Seule la personne
concernée peut revenir, par le parcours d'inscription.
Réinscrire quelqu'un qui est parti est le meilleur moyen de se faire signaler
comme spam — et cette fois définitivement.
---
## Ouvrir une liste au public { #publique }
*Réservé aux administrateurs.*
Sur la fiche de la liste, cochez **Liste publique** et enregistrez.
![Ouvrir une liste à l'inscription libre](../assets/messagerie/gestionnaire-06-liste-publique.png)
Trois conséquences, à peser avant de cocher :
- n'importe qui peut **demander à s'abonner** depuis la page d'accueil ;
- les envois passés deviennent **lisibles publiquement** dans les archives ;
- le **nom et la description** de la liste sont visibles de tout visiteur.
Ce dernier point n'est pas anodin pour une liste interne. Le geste est enregistré
dans le journal de l'outil.
### Les demandes en attente
Quand une liste est publique, la fiche affiche les **demandes d'inscription en
attente de confirmation**, avec leur heure d'expiration.
![Les demandes en attente de confirmation](../assets/messagerie/gestionnaire-07-demandes.png)
Ces adresses **ne sont pas inscrites** et ne le seront que si leurs titulaires
confirment depuis leur propre boîte. Il n'y a rien à faire : celles qui restent
s'effacent seules.
---
## Les adresses désactivées { #desactivees }
Menu **Listes → Adresses désactivées**.
L'écran comporte deux tableaux, et la différence entre les deux est importante.
### Rejets définitifs et plaintes
Ces adresses ont été retirées de **toutes** les listes : le serveur d'en face a
répondu que la boîte n'existait pas, ou la personne nous a signalés comme spam.
![Les rejets définitifs, avec le texte exact du refus](../assets/messagerie/gestionnaire-08-rejets.png)
La colonne de droite affiche **le texte exact du refus**, extrait du rapport reçu —
« utilisateur inconnu », « boîte pleine », le nom d'une liste noire. Le rapport
complet est dépliable si vous voulez tout lire.
Continuer à écrire à ces adresses abîmerait la réputation du serveur pour tous les
autres envois. C'est pourquoi l'outil les écarte sans demander.
### Blocages d'opérateur
**Ces adresses-là sont conservées**, et c'est délibéré.
Le message a été refusé non pas parce que la boîte a disparu, mais parce qu'un
opérateur refuse *notre* serveur — un grand fournisseur de messagerie qui nous a mis
sur une liste d'attente, ou un serveur qui interroge une liste noire.
![Les blocages d'opérateur : ces adresses restent inscrites](../assets/messagerie/gestionnaire-09-blocages.png)
La distinction est vitale. Une part notable des abonnés d'une association tient ses
adresses chez deux ou trois grands fournisseurs : les traiter comme mortes parce que
l'un d'eux nous bloque un jour ferait perdre d'un coup une fraction de la liste, en
silence, pour une faute qui n'est pas la leur.
Quand cette section se remplit, ce n'est donc pas un problème d'abonnés mais de
réputation d'envoi. Le délistage se demande auprès de l'opérateur concerné.
---
## Surveiller la réputation d'envoi { #postmaster }
*Réservé aux administrateurs.* Menu **Configuration → Postmaster**.
Les grands opérateurs de messagerie envoient chaque jour un rapport disant **quelles
adresses IP ont émis du courrier au nom du domaine de l'association**, et si ces
envois étaient correctement signés. L'outil les dépouille tout seul.
![Qui émet au nom du domaine, et si c'est aligné](../assets/messagerie/gestionnaire-10-postmaster.png)
Deux lectures valent le détour :
- **une adresse IP inconnue dans la liste** : quelqu'un émet en notre nom. Usurpation,
ou service de l'association qu'on avait oublié ;
- **une adresse IP connue mais jamais alignée** : elle émet sans être autorisée par
nos enregistrements, et ses messages tombent en indésirable chez tout le monde.
Le second tableau liste le courrier reçu à l'adresse *postmaster* que l'automate n'a
pas su traiter — avis d'opérateur, signalement — et qui attend une lecture humaine.
Le bouton **Marquer comme lu** le retire de la liste une fois traité.
---
## Attribuer les rôles { #droits }
*Réservé aux administrateurs.* Menu **Configuration → Droits**.
![Les trois rôles, cumulables](../assets/messagerie/gestionnaire-11-droits.png)
Trois rôles indépendants, cumulables :
| Rôle | Donne accès à |
|---|---|
| Rédacteur | la section **Listes** : campagnes et abonnés |
| Administrateur | les listes publiques, les imports, **Droits** et **Postmaster** |
| Messagerie interne | la section **Messagerie** |
Un administrateur ne peut pas se retirer lui-même l'administration : l'outil refuse
de se retrouver sans personne pour le gérer. Demandez-le à un autre administrateur.
---
## Questions fréquentes
??? question "Mon envoi semble arrêté à mi-parcours"
C'est le plafond horaire. L'envoi reprend de lui-même à l'heure suivante, et la
fiche de la campagne affiche ce qui reste en attente.
??? question "Une adresse apparaît comme désactivée alors qu'elle fonctionne"
Regardez dans quel tableau elle se trouve. Dans **Blocages d'opérateur**, elle
n'est pas désactivée et il n'y a rien à faire de ce côté. Dans **Rejets
définitifs**, lisez le texte du refus : il dit précisément ce que le serveur
distant a répondu.
??? question "Quelqu'un veut revenir après s'être désabonné"
Il doit refaire le parcours d'inscription lui-même. Ne le réinscrivez pas à la
main : l'outil l'interdit, et pour de bonnes raisons.
??? question "Puis-je renvoyer exactement le même message plus tard ?"
Oui, **Dupliquer en brouillon** sur la campagne passée. Vérifiez les dates et les
liens avant de renvoyer : ce qui était vrai il y a un mois ne l'est plus
forcément.
??? question "Comment savoir qui a ouvert le message ?"
On ne le sait pas, et c'est voulu. Les messages ne contiennent ni image de suivi
ni lien piégé. Ce que l'on sait, c'est ce qui a été **remis** et ce qui a
**rebondi**.
---
## Voir aussi
- [S'abonner et se désabonner](messagerie-abonnement.md) — ce que voient les
personnes à qui vous écrivez.
- [Vos données, vos adresses, nos envois](donnees-personnelles.md)
- [Écrire en Markdown](../contribuer/markdown.md)

View file

@ -1,120 +0,0 @@
---
description: La messagerie interne d'Alpinux — écrire à un autre membre sans connaître son adresse, lire ses messages, régler ses avis par courriel.
---
# 💬 Écrire et recevoir des messages
Ce guide s'adresse aux **membres** de l'association qui veulent s'écrire entre eux.
C'est autre chose que les listes de diffusion : ici, personne ne diffuse à tout le
monde. On écrit à une personne, et elle seule.
**En une phrase :** vous écrivez à quelqu'un sans connaître son adresse, et il vous
répond sans connaître la vôtre.
!!! info "Il faut être connecté"
La messagerie interne demande le **compte de l'association**, le même que pour
le portail. Le rôle correspondant est attribué par un administrateur.
---
## Lire mes messages { #boite }
Menu **Messagerie → Mes messages**.
![La boîte de réception ; les messages non lus sont en gras](../assets/messagerie/membre-01-boite.png)
Le nombre de messages non lus apparaît à côté du mot **Messagerie** dans le menu :
vous le voyez donc depuis n'importe quel écran, sans avoir à aller voir.
Un message s'ouvre d'un clic sur son objet. Il est marqué lu à ce moment-là.
---
## Écrire à quelqu'un { #ecrire }
Menu **Messagerie → Écrire**.
![Le destinataire se choisit dans l'annuaire, sans connaître son adresse](../assets/messagerie/membre-02-ecrire.png)
Choisissez le destinataire dans la liste proposée : c'est l'annuaire des membres.
**Vous n'avez pas besoin de son adresse** — vous ne la verrez pas, et il ne verra pas
la vôtre.
Écrivez l'objet et le message, puis envoyez.
### Ce que reçoit votre destinataire
Un **avis** par courriel, qui dit qu'un message l'attend, de la part de qui, et sur
quel sujet. **Le texte du message n'est pas recopié dans cet avis** : il faut se
connecter pour le lire.
C'est volontaire. Un avis qui recopierait le message rendrait la messagerie interne
inutile — autant s'écrire directement.
---
## Régler mes avis par courriel { #avis }
Menu **Configuration → Mon profil**.
![Les avis par courriel et le résumé quotidien se règlent ici](../assets/messagerie/membre-03-profil.png)
Vous y choisissez :
- **si** vous voulez être prévenu par courriel quand un message arrive ;
- **à quelle adresse** ces avis doivent partir.
### Le résumé quotidien
Si des messages restent non lus, un **résumé** part une fois par jour — et seulement
les jours où quelque chose est arrivé. Il dit qui vous a écrit et sur quels sujets.
Ni le corps des messages, ni les adresses des auteurs n'y figurent.
Il se coupe depuis le même écran que les avis.
---
## Emporter mes messages { #export }
Menu **Messagerie → Copie de mes messages**.
Vous téléchargez l'ensemble de vos messages — reçus et envoyés — dans une archive.
Chaque message y est au format standard des courriels, lisible par n'importe quel
logiciel de messagerie.
C'est ce qu'il faut utiliser pour garder une trace hors de l'outil, ou pour exercer
votre droit d'accès à vos données.
---
## Questions fréquentes
??? question "Mon correspondant verra-t-il mon adresse ?"
Non. Les messages ne circulent pas par courriel entre vous : ils restent dans
l'outil. Seuls les **avis** partent par courriel, et chacun part vers l'adresse
de son propre destinataire.
??? question "Puis-je répondre depuis mon logiciel de messagerie ?"
Non. L'avis est une notification, pas le message. Il faut se connecter pour lire
et répondre — c'est la contrepartie de ne pas divulguer les adresses.
??? question "Je ne reçois plus d'avis"
Vérifiez d'abord **Configuration → Mon profil** : les avis y sont peut-être
coupés. S'ils sont actifs et que rien n'arrive, c'est probablement que votre
adresse a rebondi ; l'outil suspend alors les avis pour ne pas s'acharner.
Signalez-le à un administrateur, qui le verra dans ses écrans.
??? question "Puis-je écrire à quelqu'un qui n'est pas dans l'annuaire ?"
Non. L'annuaire ne contient que les membres à qui un rôle a été attribué. Pour
écrire à quelqu'un d'autre, il faut son adresse et un logiciel de messagerie
ordinaire.
---
## Voir aussi
- [S'abonner et se désabonner](messagerie-abonnement.md) — les listes de diffusion,
qui sont autre chose.
- [Vos données, vos adresses, nos envois](donnees-personnelles.md)

View file

@ -1,50 +0,0 @@
---
description: La messagerie d'Alpinux — trois guides selon que vous voulez vous abonner, écrire aux membres, ou gérer une liste de diffusion.
---
# 📬 La messagerie d'Alpinux
La messagerie de l'association sert à deux choses qu'il ne faut pas confondre :
- **les listes de diffusion**, par lesquelles le bureau écrit à tout le monde ;
- **la messagerie interne**, par laquelle les membres s'écrivent entre eux sans se
communiquer leurs adresses.
Selon ce que vous voulez faire, la suite n'est pas la même.
---
## Je veux…
| Ce que vous voulez faire | Le guide qu'il vous faut |
|---|---|
| Recevoir les annonces de l'association, ou arrêter de les recevoir | [S'abonner et se désabonner](messagerie-abonnement.md) |
| Lire ce qui a déjà été envoyé | [S'abonner et se désabonner](messagerie-abonnement.md#archives) |
| Écrire à un autre membre, ou lire mes messages | [Écrire et recevoir des messages](messagerie-membre.md) |
| Envoyer un message à toute une liste | [Gérer une liste de diffusion](messagerie-gestionnaire.md) |
| Ajouter des abonnés, ouvrir une liste au public | [Gérer une liste de diffusion](messagerie-gestionnaire.md) |
| Comprendre pourquoi une adresse ne reçoit plus rien | [Gérer une liste de diffusion](messagerie-gestionnaire.md#desactivees) |
---
## Qui peut quoi
L'accès aux écrans dépend d'un rôle, attribué par un administrateur dans
**Configuration → Droits**.
| Vous êtes… | Vous voyez… |
|---|---|
| Une personne sans compte | l'inscription et les archives des listes publiques |
| Membre | la section **Messagerie** |
| Rédacteur | la section **Listes** |
| Administrateur | tout, plus **Configuration → Droits** et **Configuration → Postmaster** |
Une même personne peut cumuler les trois.
---
## Voir aussi
- [Vos données, vos adresses, nos envois](donnees-personnelles.md) — ce que
l'association recueille, combien de temps elle le garde, et ce que vous pouvez
exiger.

View file

@ -1,40 +0,0 @@
---
description: Apprendre Linux en jouant — le site de jeux et de cours d'Alpinux, ses fiches de référence, et des programmes prêts à l'emploi pour animer une initiation.
---
# Apprendre Linux en jouant
Alpinux propose un site pour apprendre Linux par le jeu :
**[dynamic.alpinux.org](https://dynamic.alpinux.org)**. On y trouve des cours courts avec un
terminal d'essai intégré, des jeux (missions dans un terminal simulé, associations,
permissions) et des quiz. Rien à installer, et rien ne peut casser.
Cette rubrique du wiki en est le complément : les **fiches de référence**, à garder sous la
main ou à imprimer, et les **programmes** pour animer une initiation.
---
## Le parcours « Linux pour le DevOps »
| Étape | Cours | Jeu | Fiche |
|---|---|---|---|
| 1. L'arborescence | — | [Où range-t-on quoi ?](https://dynamic.alpinux.org/jeux/arborescence/) | — |
| 2. Le terminal | [Se repérer et se déplacer](https://dynamic.alpinux.org/cours/terminal-premiers-pas/) | [Premier jour sur le serveur](https://dynamic.alpinux.org/jeux/terminal-premiers-pas/) | [Le terminal](terminal-se-reperer.md) |
| 3. Les fichiers | — | [Préparer un déploiement](https://dynamic.alpinux.org/jeux/terminal-fichiers/) | — |
| 4. Les permissions | — | [rwx : le jeu des permissions](https://dynamic.alpinux.org/jeux/permissions/) | — |
| 5. Processus et système | — | [Sous le capot](https://dynamic.alpinux.org/jeux/noyau-processus/) | — |
| 6. Diagnostiquer | — | [Incident à 3 h du matin](https://dynamic.alpinux.org/jeux/terminal-incident/) | — |
Les cours et fiches manquants sont en cours de rédaction.
## Animer une initiation
- [Une semaine pour découvrir Linux — 3e et terminale](semaine-college-lycee.md) : cinq
journées sur Linux, le terminal, Bash, Python, Git et Forgejo, avec une enquête en fil rouge.
## Voir aussi
- [Apprendre à programmer en Python](../presentations/Python/README.md), le cours complet
pour débutants.
- [Le Git d'Alpinux](../guides/git-alpinux.md) : créer son compte sur la forge et y publier
son travail.

View file

@ -1,300 +0,0 @@
---
description: Programme d'une semaine d'initiation (5 jours de 6 h) pour des élèves de 3e et de terminale — Linux, terminal, Bash, Python, Git et Forgejo, avec une enquête en fil rouge.
---
# Une semaine pour découvrir Linux — 3e et terminale
Cinq journées de six heures pour faire découvrir à des élèves ce qui se cache derrière les
serveurs, les sites web et le code : **Linux, le terminal, Bash, Python, Git et la forge
Forgejo**. Le même déroulé sert pour les deux niveaux ; ce qui change, c'est la profondeur.
!!! warning "Brouillon à valider"
Ce programme est une première proposition. Les points encore ouverts sont listés en fin
de page, dans [À décider avant la semaine](#a-decider).
---
## Les principes
**Toujours dire pourquoi.** Chaque journée commence par la question à laquelle elle répond :
à quoi sert ce qu'on va apprendre, et quel problème cela règle. Une commande dont on ne
comprend pas l'utilité s'oublie dès le lendemain. Les encadrés **Pourquoi** de chaque journée
donnent ces réponses, à reformuler devant la classe.
**Alterner toutes les 45 minutes.** Une journée de 6 h devant un écran ne tient pas sans
changer de forme. Chaque demi-journée enchaîne un **cours court** (sur le site), un **jeu**,
de la **pratique sur un vrai terminal**, et si possible une **activité débranchée**.
**Un fil rouge : l'enquête.** Lundi matin, on découvre que le site du club informatique d'un
lycée imaginaire a été modifié pendant la nuit. Chaque après-midi, les élèves avancent dans
l'enquête **sur les vrais postes Linux de la salle**, avec les commandes apprises le matin.
Vendredi, une épreuve finale en équipes désigne le coupable et remet le site en état.
**Les outils :**
| Outil | Rôle |
|---|---|
| [dynamic.alpinux.org](https://dynamic.alpinux.org/jeux/) | Cours avec terminal d'essai intégré, jeux, quiz. Rien à installer. |
| Les postes Linux de la salle | La pratique pour de vrai, et l'enquête. |
| Ce wiki | Les fiches de référence, et ce programme. |
| [La forge d'Alpinux](../guides/git-alpinux.md) | Vendredi : publier son travail et collaborer. |
| Un carnet de bord papier | Une page par jour : ce que j'ai appris, une commande à retenir, une question. |
---
## Le déroulé type d'une journée
| Horaire | Durée | Activité |
|---|---|---|
| 9 h 00 | 15 min | Rappel de la veille : quiz éclair au tableau, ou une commande « mystère » à deviner |
| 9 h 15 | 45 min | Le pourquoi du jour, puis le cours sur le site, avec le terminal d'essai |
| 10 h 00 | 30 min | Jeu sur le site |
| 10 h 30 | 15 min | Pause |
| 10 h 45 | 75 min | Pratique sur le vrai terminal, en binômes |
| 12 h 00 | | Repas |
| 13 h 30 | 15 min | Activité débranchée, pour se remettre en route |
| 13 h 45 | 90 min | Enquête : le chapitre du jour |
| 15 h 15 | 15 min | Pause |
| 15 h 30 | 45 min | Approfondissement, différent selon le niveau |
| 16 h 15 | 15 min | Bilan et carnet de bord |
---
## Lundi — Linux et le terminal
**Objectif du jour :** savoir ce qu'est Linux, se repérer dans l'arborescence et s'y déplacer
au clavier.
!!! question "Pourquoi le terminal, alors qu'on a une souris ?"
- **Les serveurs n'ont pas d'écran.** Les machines qui font tourner les sites web, les
jeux en ligne ou les réseaux sociaux sont presque toutes sous Linux, dans des salles
sans écran ni souris. On les pilote à distance, en tapant des commandes.
- **Une commande se note, se copie, se répète.** Un clic ne s'écrit pas dans un tuto ; une
commande, si. On peut l'envoyer à quelqu'un, la relancer demain, ou la confier à un
script mercredi.
- **C'est la porte d'entrée de toute la semaine** : Bash, Python et Git s'utilisent depuis
le terminal.
- **Accueil (30 min)** : qui est Alpinux, ce qu'est un logiciel libre, où se trouve Linux
sans qu'on le voie : téléphones Android, box Internet, téléviseurs, serveurs, et les 500
supercalculateurs les plus puissants du monde.
- **Débranché — l'arbre humain** : chaque élève porte une étiquette de dossier (`/`, `home`,
`alex`, `etc`…) et tient l'épaule de son « parent ». Un élève-curseur se déplace selon les
commandes `cd` lancées par la classe. Chemins absolus et relatifs se comprennent dans
l'espace avant de se comprendre à l'écran.
- **Site** : jeu [Où range-t-on quoi ?](https://dynamic.alpinux.org/jeux/arborescence/), puis
cours [Le terminal : se repérer et se déplacer](https://dynamic.alpinux.org/cours/terminal-premiers-pas/)
et jeu [Premier jour sur le serveur](https://dynamic.alpinux.org/jeux/terminal-premiers-pas/).
- **Vrai terminal** : ouvrir un terminal (Ctrl + Alt + T), les trois défis de fin de cours,
explorer son dossier personnel. Fiche : [Le terminal](terminal-se-reperer.md).
- **Enquête, chapitre 1 — L'alerte** : le dossier de l'enquête apparaît sur les postes. Le
premier message est caché quelque part : `ls -a`, `cd`, `cat`.
| | 3e | Terminale |
|---|---|---|
| Approfondissement | Course d'orientation dans l'arborescence : trouver des fichiers à partir d'indices (« je suis un réglage du réseau… ») | Comment Linux démarre : noyau, `/boot`, `/proc`, PID 1 ; explorer `/proc/cpuinfo` et `/proc/meminfo` |
---
## Mardi — Fichiers, droits et recherche
**Objectif du jour :** créer, déplacer et supprimer des fichiers, comprendre les droits, et
retrouver une information dans une montagne de texte.
!!! question "Pourquoi des droits sur les fichiers ? Pourquoi chercher avec des commandes ?"
- **Linux est partagé.** Plusieurs personnes et plusieurs services utilisent la même
machine. Les droits empêchent un utilisateur de lire le courrier d'un autre, un site web
piraté de toucher au reste du système, et vous-même d'effacer par erreur un fichier
important.
- **On ne lit pas un journal de 50 000 lignes, on le filtre.** `grep` trouve en une
seconde la ligne qui compte. Enchaînées avec `|`, de petites commandes répondent à des
questions précises : combien d'erreurs ? quand ? venant d'où ?
- **Site** : jeu [Préparer un déploiement](https://dynamic.alpinux.org/jeux/terminal-fichiers/),
puis [rwx : le jeu des permissions](https://dynamic.alpinux.org/jeux/permissions/).
- **Vrai terminal** : `mkdir`, `cp`, `mv`, `rm`, les redirections `>` et `>>`, et un premier
éditeur de texte dans le terminal, **nano**.
- **Débranché — le pipe humain** : une file d'élèves se passe un paquet de cartes. Le premier
ne garde que les cartes rouges (`grep`), le suivant les trie (`sort`), le dernier les compte
(`wc -l`). C'est exactement ce que fait `|`.
- **Enquête, chapitre 2 — Les morceaux** : le message du pirate est découpé en plusieurs
fichiers à rassembler (`cat`, `>`), l'un d'eux est verrouillé (`chmod`), et un indice se
cache dans un long journal (`grep`).
| | 3e | Terminale |
|---|---|---|
| Approfondissement | Défi « ménage » : ranger un dossier en désordre dans des sous-dossiers par type de fichier | `find`, et les enchaînements `grep … \| sort \| uniq -c \| sort -n` sur un vrai journal |
---
## Mercredi — Bash : faire travailler l'ordinateur à sa place
**Objectif du jour :** écrire un script, c'est-à-dire une suite de commandes que l'on peut
relancer à volonté.
!!! question "Pourquoi écrire des scripts ?"
- **Ce qu'on tape deux fois, on l'écrit une fois.** Un script refait le même travail, dans
le même ordre, sans oubli ni faute de frappe, autant de fois qu'il le faut.
- **L'ordinateur travaille sans vous** : une sauvegarde à 3 h du matin, la vérification de
cent fichiers, la préparation de trente postes identiques.
- **Un script est une procédure écrite.** Il se relit, se corrige, se partage, et il dit
exactement ce qui a été fait.
- **Cours** : la ligne `#!/bin/bash`, `chmod +x`, les variables, `echo`, `read`, `if`, `for`.
- **Site** : jeu [Sous le capot](https://dynamic.alpinux.org/jeux/noyau-processus/) (ce qui
se passe quand on lance une commande) et, pour les terminales,
[Incident à 3 h du matin](https://dynamic.alpinux.org/jeux/terminal-incident/).
- **Débranché — le robot idiot** : un élève joue le robot qui exécute à la lettre un
« script » écrit par un autre groupe pour, par exemple, faire un sandwich. Les bugs
apparaissent tout seuls, et l'on comprend pourquoi un programme doit être précis.
- **Enquête, chapitre 3 — Le script du pirate** : un script laissé sur le serveur. Il faut
le lire sans le lancer, comprendre ce qu'il fait, puis décoder le message qu'il a chiffré.
En 3e, le décodage tient en une commande donnée par étapes ; en terminale, les élèves
écrivent le script de décodage eux-mêmes.
| | 3e | Terminale |
|---|---|---|
| Script du jour | Un quiz interactif en Bash avec `read` et `if`, à faire passer au voisin | Un script de sauvegarde qui prend des arguments (`$1`), vérifie les erreurs (`$?`) et date ses archives |
| Approfondissement | Commandes « pour le plaisir » si elles sont installées : `figlet`, `cowsay`, `sl` | Processus et signaux : `ps`, `kill`, `top` ; lien avec le thème « processus » de NSI |
---
## Jeudi — Python
**Objectif du jour :** écrire et lancer un programme Python depuis le terminal, puis s'en
servir comme outil.
!!! question "Pourquoi Python, puisqu'on a Bash ?"
- **Chaque outil a son terrain.** Bash est imbattable pour enchaîner des commandes et
manipuler des fichiers. Dès qu'il faut calculer, mémoriser des données, les trier
finement ou écrire un vrai programme, il devient pénible : Python est fait pour ça.
- **Python est partout** : l'analyse de données, l'intelligence artificielle, les sites
web, l'automatisation, les cartes électroniques. Et c'est le langage de la spécialité
NSI au lycée.
- **Le même problème, deux outils** : l'après-midi, on compte les connexions d'un journal
en Python, comme on l'a fait en Bash mardi. Comparer les deux, c'est apprendre à choisir.
Le wiki contient déjà un [cours complet de Python pour débutants](../presentations/Python/README.md) :
la journée s'appuie sur ses chapitres plutôt que de tout réécrire. Ce cours tutoie son
lecteur, à la différence du reste de ce programme.
- **Lancer Python** : l'interpréteur interactif `python3`, puis un fichier `.py` écrit avec
nano et lancé avec `python3 mon_programme.py`.
- **Enquête, chapitre 4 — Les traces** : un journal de connexions de plusieurs milliers de
lignes. Écrire un programme Python qui compte les connexions par adresse et par heure,
pour trouver quand le pirate est entré.
| | 3e | Terminale |
|---|---|---|
| Notions | Variables, `input`, conditions, boucles : chapitres [01](../presentations/Python/01-variables-types-operateurs.md), [02](../presentations/Python/02-conditions.md) et [03](../presentations/Python/03-boucles.md) | Fichiers, dictionnaires, CSV : chapitres [04](../presentations/Python/04-structures-de-donnees.md) et [07](../presentations/Python/07-fichiers-csv-json.md) |
| Projet | Le jeu « devine le nombre », puis des dessins avec `turtle` | Le comptage de mardi, réécrit en Python : comparer les deux approches |
!!! tip "Pour les élèves de terminale NSI"
Python est déjà leur langage. L'intérêt de la journée n'est pas d'apprendre la syntaxe,
mais de l'utiliser **hors de l'éditeur de l'école** : depuis le terminal, sur de vraies
données, avec la bibliothèque standard (`pathlib`, `csv`, `collections`).
---
## Vendredi — Git, Forgejo, et le dénouement
**Objectif du jour :** garder l'historique de son travail avec Git, le publier sur une forge,
et travailler à plusieurs sur le même code.
!!! question "Pourquoi Git en local, sur sa propre machine ?"
Git enregistre des **photos successives** d'un projet, appelées *commits*, chacune avec
sa date, son auteur et un message qui dit ce qui a changé et pourquoi. Tout se passe sur
votre ordinateur, sans réseau ni compte.
- **Fini `rapport_final_v3_vraiment_final.txt`.** Un seul fichier, et toutes ses versions
rangées dans l'historique.
- **On peut revenir en arrière.** Une modification a tout cassé ? On retrouve la dernière
version qui marchait, en une commande.
- **On sait ce qui a changé** entre deux versions (`git diff`), ligne par ligne, et
**pourquoi** grâce au message du commit.
- **On essaie sans risque.** Une idée hasardeuse se développe sur une *branche* à part ;
si elle ne donne rien, on l'abandonne sans avoir abîmé le reste.
!!! question "Pourquoi Git à distance, sur une forge ?"
Une forge comme Forgejo garde une copie du projet sur un serveur. On y **envoie** ses
commits (`git push`) et on **récupère** ceux des autres (`git pull`).
- **Une sauvegarde hors de sa machine.** Un disque qui lâche, un ordinateur perdu, un
poste de salle réinitialisé : le travail reste sur la forge.
- **Travailler à plusieurs sur le même projet.** Chacun travaille sur sa copie, puis Git
assemble les modifications, et signale quand deux personnes ont touché à la même ligne.
- **Faire relire avant d'intégrer.** Une *pull request* propose une modification : les
autres la lisent, la commentent, et ne l'acceptent qu'une fois convaincus. C'est ainsi
que se fait ce wiki.
- **Partager et publier.** Un dépôt public, c'est un projet que tout le monde peut lire,
réutiliser et améliorer : c'est le fonctionnement même du logiciel libre.
**Dans quel ordre ?** D'abord en local : on travaille, on fait des commits, on se trompe
et on corrige, sans rien montrer à personne. Ensuite seulement, on envoie sur la forge un
travail propre. Le local, c'est le brouillon daté ; la forge, c'est le classeur partagé.
- **Débranché — la machine à remonter le temps** : un texte écrit à plusieurs sur une feuille,
avec une photo prise à chaque étape. Revenir à la photo d'hier, c'est un `git checkout` ;
la pile de photos, c'est `git log`. Puis deux groupes modifient chacun leur copie de la
même phrase : c'est un conflit, qu'il faut régler en se parlant.
- **Git en local** : `git init`, `git add`, `git commit`, `git log`, `git diff`. Chacun
versionne les scripts et programmes écrits pendant la semaine.
- **Forgejo** : déposer ce travail sur la [forge d'Alpinux](../guides/git-alpinux.md), en
explorer l'interface web, et proposer une modification sur le dépôt d'un camarade.
- **Enquête, chapitre 5 — Le dénouement** : épreuve en équipes, chronométrée. Le site du club
est versionné avec Git, et c'est ce qui va trahir le coupable : chaque commit dit **qui** a
modifié **quoi** et **quand**. Il faut identifier le coupable, croiser avec les indices des
jours précédents, puis remettre le site en état en revenant à une version saine.
- **Clôture (45 min, à la place de l'approfondissement)** : remise des diplômes, ce qu'on
retient de la semaine, et la suite (réunions Alpinux, install parties, spécialité NSI).
| | 3e | Terminale |
|---|---|---|
| Forgejo | Modifier un fichier depuis l'interface web et ouvrir une pull request | Branches, pull request depuis le terminal, résolution d'un conflit provoqué exprès |
---
## Où en est la préparation
| Jour | Cours sur le site | Jeux sur le site | Enquête |
|---|---|---|---|
| Lundi | ✅ Le terminal | ✅ Où range-t-on quoi ?, Premier jour sur le serveur | à écrire |
| Mardi | à écrire : fichiers et droits, chercher et filtrer | ✅ Préparer un déploiement, rwx | à écrire |
| Mercredi | à écrire : Bash | ✅ Sous le capot, Incident à 3 h du matin | à écrire |
| Jeudi | le cours Python du wiki | à prévoir | à écrire |
| Vendredi | à écrire : Git local et Forgejo | à prévoir | à écrire |
L'enquête sera installée sur chaque poste par un script : un dossier par élève, avec les
fichiers, les journaux et le dépôt Git du site du club.
---
## Ce qu'il faut préparer
**Sur les postes**, à vérifier en amont :
- [ ] un terminal accessible aux élèves, et les commandes `git`, `python3`, `nano`, `tree` ;
- [ ] le paquet `python3-tk`, sans lequel le module `turtle` de Python ne fonctionne pas ;
- [ ] Git configuré avec un nom et une adresse pour chaque session
(`git config --global user.name` et `user.email`), sans quoi `git commit` refuse de
fonctionner. Pour des mineurs, un pseudonyme et une adresse fictive suffisent en local ;
- [ ] facultatif, pour le plaisir : `figlet`, `cowsay`, `sl` ;
- [ ] l'accès à `dynamic.alpinux.org` et à `gitea.alpinux.org` depuis le réseau de
l'établissement (certains filtres bloquent les forges) ;
- [ ] le dossier de l'enquête, installé par un script à lancer sur chaque poste.
**Pour la salle** : un vidéoprojecteur, des étiquettes et des cartes pour les activités
débranchées, un carnet de bord par élève, des diplômes à imprimer.
---
## À décider avant la semaine {#a-decider}
| Question | Pourquoi c'est important |
|---|---|
| **Les comptes Forgejo des élèves.** Comptes AlpID nominatifs, comptes anonymes de classe (`eleve01`, `eleve02`…), ou forge installée localement pour la semaine ? | Les élèves sont mineurs : la solution la plus simple côté données personnelles est celle des comptes anonymes, créés à l'avance et supprimés après la semaine. |
| **Les sessions sont-elles conservées d'un jour à l'autre ?** | Beaucoup de postes d'établissement effacent tout à la déconnexion. L'enquête et le travail de la semaine doivent survivre jusqu'au vendredi : sinon, prévoir une clé USB par binôme, ou s'appuyer plus tôt sur la forge. |
| **Le nombre d'élèves et de postes.** | Le travail en binômes demande un poste pour deux au minimum. |
| **La distribution installée et les droits.** Peut-on installer des paquets ? Les élèves ont-ils `sudo` ? | Sans droits d'installation, il faut vérifier toute la liste ci-dessus avant le lundi. |
| **Les horaires exacts** de l'établissement. | Le déroulé type se décale facilement, mais les pauses et le repas sont imposés. |
| **Les scores sur le site.** | Ils ne s'enregistrent qu'avec un compte AlpID. Sans compte, on peut faire un classement par équipe à la main, à partir des écrans de fin de partie. |

View file

@ -1,110 +0,0 @@
---
description: Fiche de référence du terminal Linux — l'invite, la forme d'une commande, l'arborescence, les chemins, et les commandes pwd, ls, cd et cat.
---
# Le terminal : se repérer et se déplacer
Fiche de référence. Pour apprendre pas à pas, avec un terminal d'essai intégré, suivre le
**[cours interactif](https://dynamic.alpinux.org/cours/terminal-premiers-pas/)**, puis le jeu
**[Premier jour sur le serveur](https://dynamic.alpinux.org/jeux/terminal-premiers-pas/)**.
---
## Ouvrir un terminal
| Système | Comment |
|---|---|
| Linux Mint, Ubuntu | **Ctrl + Alt + T**, ou « Terminal » dans le menu |
| Debian (GNOME) | Touche **Super**, puis taper « Terminal » |
Dans le terminal, **Ctrl + C n'est pas « copier »** : cette combinaison interrompt la
commande en cours. On copie avec **Ctrl + Maj + C** et on colle avec **Ctrl + Maj + V**.
## Lire l'invite
```
alex@srv-web01:~/projets$
```
| Morceau | Signification |
|---|---|
| `alex` | l'utilisateur connecté |
| `srv-web01` | le nom de la machine |
| `~/projets` | le dossier courant (`~` = dossier personnel) |
| `$` | utilisateur ordinaire — `#` signale l'administrateur (*root*) |
## La forme d'une commande
```
ls -l /etc
```
**Commande** (`ls`), puis **options** (`-l`), puis **arguments** (`/etc`), séparés par des
espaces. Les majuscules comptent. Les options courtes se combinent : `ls -l -a` = `ls -la`.
Une commande qui réussit n'affiche souvent rien. Une commande qui échoue affiche un message :
il faut le lire, il indique presque toujours la cause.
## L'arborescence
Tout part de la racine `/`. Les dossiers à connaître :
| Dossier | Contenu |
|---|---|
| `/home/<nom>` | les dossiers personnels |
| `/etc` | la configuration du système et des services |
| `/var/log` | les journaux |
| `/tmp` | les fichiers temporaires |
| `/usr/bin` | les programmes |
## Les chemins
| Chemin | Type | Part de… |
|---|---|---|
| `/home/alex/projets` | absolu | la racine : fonctionne de partout |
| `projets/site-web` | relatif | le dossier courant |
| Raccourci | Signification |
|---|---|
| `~` | dossier personnel |
| `.` | dossier courant |
| `..` | dossier parent |
| `-` | (avec `cd`) dossier précédent |
## Les commandes
| Commande | Effet |
|---|---|
| `pwd` | affiche le dossier courant |
| `ls` | liste le contenu du dossier courant |
| `ls dossier` | liste le contenu d'un autre dossier |
| `ls -a` | inclut les fichiers cachés (nom commençant par `.`) |
| `ls -l` | format détaillé : droits, propriétaire, groupe, taille, date |
| `cd dossier` | entre dans un dossier |
| `cd ..` | remonte d'un niveau |
| `cd` ou `cd ~` | revient au dossier personnel |
| `cd -` | revient au dossier précédent |
| `cat fichier` | affiche un fichier en entier |
| `less fichier` | parcourt un fichier page par page (`q` pour quitter) |
| `head fichier` / `tail fichier` | les 10 premières / dernières lignes |
| `man commande` | le manuel d'une commande (`q` pour quitter) |
| `history` | les commandes déjà tapées |
## Les raccourcis clavier
| Touche | Effet |
|---|---|
| **Tab** | complète un nom ; deux fois, liste les possibilités |
| **↑** / **↓** | parcourent l'historique |
| **Ctrl + C** | annule la commande ou la ligne en cours |
| **Ctrl + L** | efface l'écran |
| **Ctrl + R** | recherche dans l'historique |
## Les erreurs fréquentes
| Message | Cause probable | Réflexe |
|---|---|---|
| `Aucun fichier ou dossier de ce type` | ce nom n'existe pas ici : mauvais dossier courant, ou nom mal écrit | `pwd`, `ls`, puis **Tab** pour compléter |
| `commande introuvable` | faute de frappe, majuscule, ou programme non installé | relire ; `type commande` dit si elle existe |
| `Permission non accordée` | les droits ne le permettent pas | `ls -l` pour voir les droits |
| un nom avec espace « coupé en deux » | l'espace sépare les arguments | entourer de guillemets : `cat "mon fichier.txt"` |

Binary file not shown.

Before

Width:  |  Height:  |  Size: 82 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 107 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 78 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 87 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 131 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 158 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 68 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 57 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 330 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 200 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 56 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 73 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 88 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 54 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 44 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 64 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 104 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 52 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 55 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 63 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 92 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 52 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 59 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 88 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 88 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 83 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 48 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 58 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 65 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 55 KiB

View file

@ -1,109 +0,0 @@
---
description: Quelles adresses de l'outil d'install party se publient sur une affiche, un article ou un code QR, lesquelles ne se publient jamais, et comment le vérifier avant impression.
---
# 🔗 Liens et codes QR : ce qui se publie
Affiche, flyer, article de presse, message sur une liste de diffusion,
publication d'une commune : dès qu'une adresse sort de l'équipe, elle est
publique pour de bon. Une affiche s'imprime, un article se reprend, un code QR
se scanne des semaines plus tard.
Cette page existe parce qu'un code QR a déjà mené à la page d'organisation d'une
install party au lieu de la page d'inscription — et que rien ne distingue les
deux à l'œil nu.
---
## La règle, en une phrase
!!! danger "À retenir"
**Une adresse qui contient `key=` ou `jeton=` ne se publie jamais.**
Ces deux mots signalent une clé d'accès. Elles valent mot de passe et sont
faites pour une seule personne.
---
## Les adresses qui se publient
| Pour | Adresse |
|---|---|
| **Le public** — affiches, articles, codes QR | `https://installparty.alpinux.org` |
| **S'inscrire** directement à une install party | `https://installparty.alpinux.org/party/<uid>/register` |
| Voir les **install parties à venir** | `https://installparty.alpinux.org/party/` |
| **Retrouver ses accès** (organisateur, installateur, inscrit) | `https://installparty.alpinux.org/party/moi` |
Aucune ne contient de clé : ce sont les seules à faire figurer sur un support.
!!! tip "Sur une affiche, c'est la première qu'il faut"
`https://installparty.alpinux.org` est courte, se retient, se lit à voix
haute et ne vieillit pas : elle mène à la page qui annonce la prochaine
install party et porte le bouton d'inscription. Une adresse qui contient
l'identifiant d'une install party, elle, ne vaudra plus rien à la
suivante — et une affiche dure plus longtemps qu'un événement.
## Les adresses qui ne se publient pas
| Ce que c'est | À quoi on la reconnaît | Ce qu'elle ouvre |
|---|---|---|
| Espace d'organisation | `/status/?key=…` | les inscrits et leurs coordonnées, avec de quoi les modifier |
| Écran de salle | `/accueil?key=…` | prénoms, machines et heures de la journée |
| Inscription des installateurs | `/benevole/inscription?key=…` | le formulaire par lequel on rejoint l'équipe |
| Fiche d'un participant | `/fiche/…?jeton=…` | ses données et la conversation le concernant |
---
## Avant d'envoyer un support à l'impression
1. **Relire l'adresse en entier** — pas son début : la clé est à la fin.
2. **Scanner soi-même le code QR** avec son téléphone et regarder où il mène.
C'est la seule vérification qui porte sur ce qui sera réellement diffusé,
et non sur ce qu'on croit y avoir mis.
3. **Faire regarder par quelqu'un d'autre.** Celui qui a fabriqué le code voit
ce qu'il voulait faire, pas ce qu'il a fait.
4. **Demander le fichier final** à qui publie — commune, imprimeur, journal —
et le vérifier avant parution, pas après.
### Décoder un code QR depuis une image
```sh
zbarimg affiche.png
```
La commande affiche l'adresse encodée. `sudo apt install zbar-tools` si elle
manque.
### Fabriquer le bon code
```sh
qrencode -o installparty.png -s 12 -m 3 "https://installparty.alpinux.org"
```
En SVG pour l'impression, où le code doit rester net à toute taille :
```sh
qrencode -t SVG -o installparty.svg -s 12 -m 3 "https://installparty.alpinux.org"
```
`sudo apt install qrencode` si la commande manque.
---
## Si une clé a été publiée malgré tout
!!! warning "Agir le jour même"
1. **Renouveler la clé.** Pour l'espace d'organisation, il suffit de
redemander son lien depuis `/party/moi` : la clé publiée est remplacée.
Pour l'écran de salle et l'inscription des installateurs, un bouton
existe sur la page d'organisation.
2. **Regarder les journaux du serveur** pour savoir qui a consulté, et
depuis quand.
3. **Prévenir les personnes concernées** si leurs données ont été
exposées, et notifier la CNIL — le délai est de 72 heures à compter de
la découverte.
Une clé d'organisation cesse de valoir trente minutes après la dernière action
de son détenteur : une clé publiée ne reste donc pas utilisable indéfiniment.
Ce n'est pas une raison d'en publier une — quelques jours d'exposition
suffisent à ce qu'elle serve.

View file

@ -1,23 +0,0 @@
# wiki.alpinux.org
Documentation publique Alpinux — MkDocs Material.
## Déploiement
```bash
cd org.alpinux.owni/wiki
mkdocs build --strict
rsync -rlcz --delete site/ alpinux.org:/var/www/wiki.alpinux.org/web/
```
## Développement local
```bash
pip install mkdocs-material
mkdocs serve # http://localhost:8000
```
## Notes
- Pas de service systemd — site statique servi directement par Apache
- Les docs publiques sont dans `wiki/docs/technique/`

View file

@ -9,22 +9,12 @@ l'ordinateur rendu à son propriétaire. Il sert aussi bien au bénévole qui in
personne qui veut recommencer chez elle.
!!! info "État du document"
Procédure **rejouée de bout en bout le 20/09/2026 sur Linux Mint 22.3 Cinnamon**, de
la clé USB au premier démarrage : les libellés et les captures de l'installation sont
ceux de la 22.3. Restent d'anciennes captures pour les écrans Windows — qui n'ont pas
changé — et pour la post-installation.
Vérifié le **19/09/2026** par alpinux.cedrica5l, sur **Linux Mint 22.3 Cinnamon**.
Pendant une Install Party, la checklist de suivi est le document numérique
[installparty.alpinux.org/party/moi](https://installparty.alpinux.org/party/moi).
Vos [remarques et suggestions](../alpinux/evenements.md) sont bienvenues pour
l'améliorer.
!!! tip "Quatre pages, quatre moments"
- **Cette page** — l'installation elle-même, de la clé USB à l'ordinateur rendu.
- [Régler Linux Mint après l'installation](linux-mint-parametres.md) — le premier démarrage : mises à jour, langue, pilotes.
- [Trousse de premiers secours](linux-mint-trousse.md) — les gestes de base, en format court et imprimable.
- [Utiliser Linux Mint](utiliser-linux-mint.md) — la vie courante : paramètres, matériel, logiciels, entretien.
---
## 1. Préparer Windows
@ -104,6 +94,10 @@ Clic droit sur **Démarrer** → *Terminal (administrateur)*, puis :
powercfg /hibernate off
```
!!! tip "Le dernier arrêt de Windows"
Au moment d'éteindre Windows pour insérer la clé USB, maintenez **Maj (Shift)**
enfoncée en cliquant sur *Démarrer → Arrêter*. Cela force un arrêt complet.
### Gestion de l'alimentation de la carte Wi-Fi
Certaines cartes Wi-Fi (puces Realtek ou Broadcom notamment) restent dans l'état de basse
@ -184,8 +178,6 @@ Linux. Il faut le basculer sur **AHCI**, dans la section *Storage*, *SATA Config
conserver Windows, faites le changement avec un bénévole. Si Windows est de toute
façon remplacé, la bascule est sans conséquence.
---
## 2. Préparer son support d'installation
@ -244,11 +236,8 @@ Avec [Ventoy](ventoy.md), la préparation tient en un copier-coller :
### Branchements
- Insérez la clé Ventoy dans un **port USB de la machine**, en évitant les hubs.
- **Branchez un câble Ethernet.** Le script install.sh de Alpinux effectue des tests.
!!! tip "Le dernier arrêt de Windows - Comment arrêter Windows pour démarrer sur la clé USB"
Au moment d'éteindre Windows pour insérer la clé USB, maintenez **Maj (Shift)**
enfoncée en cliquant sur *Démarrer → Arrêter*. Cela force un arrêt complet.
- **Branchez un câble Ethernet.** Mint pourra télécharger mises à jour, codecs et paquets
de langue pendant l'installation — cela évite beaucoup de réglages ensuite.
### Accéder au menu de démarrage
@ -268,7 +257,7 @@ constructeur :
### Le menu Ventoy
![Le menu isolinux, en mode BIOS](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/01-menu-demarrage-ventoy-grub.png)
![Le menu isolinux, en mode BIOS](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-011009.png)
Sur l'écran de Ventoy, sélectionnez l'ISO de Linux Mint avec les flèches, **Entrée**, puis
**Boot in normal mode**.
@ -281,11 +270,10 @@ machines d'avant 2012.
![L'écran de démarrage de Linux Mint](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-011515.png)
Un second menu apparaît, le GRUB de Mint : choisissez
**Start Linux Mint 22.3 Cinnamon 64-bit**. Le
Un second menu apparaît, le GRUB de Mint : choisissez **Start Linux Mint (64-bit)**. Le
logo « LM » s'affiche en blanc sur fond vert, puis le bureau.
![Le bureau de la session live](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/02-bureau-session-live.png)
![Le bureau de la session live](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-011723.png)
Une notification confirme la connexion : *« Vous êtes maintenant connecté au réseau filaire
1 »*. Vous êtes dans une session **live**, qui tourne entièrement en mémoire vive :
@ -332,123 +320,29 @@ Si un élément important — le Wi-Fi par exemple — ne fonctionne pas du tout
demandez l'aide d'un bénévole avant de lancer l'installation. Dans la grande majorité des
cas il s'agit d'un pilote propriétaire à activer, mais mieux vaut le savoir maintenant.
### Faire l'état des lieux du disque
**C'est l'étape qu'on oublie, et c'est celle qui coûte le plus cher.** Avant de toucher au
partitionnement, il faut savoir ce qu'il y a dans la machine : un seul disque ou deux, un
Windows chiffré par BitLocker, une partition de récupération du constructeur, un disque
fatigué. On ne le découvre pas au milieu du partitionnement.
En session live, taper les commandes une à une est fastidieux. Un script d'Alpinux fait
l'inventaire et rend un verdict :
**Sur le réseau de l'install party**, où les scripts sont servis par
[le serveur qu'Alpinux emporte](../technique/serveur-install-party.md) :
```bash
wget http://alpicache.lan/verif-disque.sh && chmod +x verif-disque.sh && ./verif-disque.sh
```
!!! tip "Si le nom ne répond pas"
Le serveur répond aussi à `alpicache`, `apt-proxy` et `10.0.0.1` — cette
dernière adresse fonctionne même quand la résolution de noms n'est pas encore
en place :
`wget http://10.0.0.1/verif-disque.sh`
**Ailleurs, depuis Internet :**
```bash
wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.scripts/raw/branch/stable/poste/verif-disque.sh
chmod +x verif-disque.sh
./verif-disque.sh
```
Il **ne modifie rien** — il lit, il affiche, il conseille. Il demande le mot de passe pour
les vérifications qui le nécessitent, puis passe en revue :
- la **machine** : processeur 64 bits, mémoire vive, et l'édition à conseiller en dessous
de 4 Go ;
- le **mode de démarrage** réel (UEFI ou BIOS hérité) et l'état du **Secure Boot** ;
- les **disques** : nombre, taille, SSD ou mécanique, table de partition, et l'alerte si
la machine démarre en UEFI alors que le disque est en MBR ;
- ce qui est **déjà installé** : Windows, Linux, partition EFI existante à réutiliser ;
- les **pièges** : BitLocker, chiffrement LUKS, `hiberfil.sys` laissé par le démarrage
rapide de Windows ;
- la **santé SMART** des disques, et l'**accès à Internet**.
Il finit par deux listes : *à régler avant d'installer*, et *à savoir*.
### Relever la fiche de la machine
En install party, un second script complète l'état des lieux : il relève la **fiche
matérielle** — modèle, processeur, mémoire et ses connecteurs, disques et leur santé —
et l'envoie au serveur de l'association.
```bash
wget http://alpicache.lan/alpi-fiche.sh && chmod +x alpi-fiche.sh && sudo ./alpi-fiche.sh --check
```
Hors réseau de l'install party, il se prend sur Internet :
```bash
wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.scripts/raw/branch/stable/poste/alpi-fiche.sh
```
Il n'aura alors aucun serveur à qui remettre la fiche : il l'affiche, et c'est tout.
Lancé depuis la session live, il rend en plus un verdict en trois états : **bon pour
l'installation**, **possible avec des réserves**, ou **ne pas installer en l'état** — un
disque qui se déclare défaillant, des secteurs réalloués, moins de 2 Go de mémoire, un
processeur 32 bits. C'est le dernier moment où l'on peut encore renoncer et en parler au
propriétaire.
Le même script, relancé après l'installation (sans `--check`), enregistre ce qui a
finalement été installé. Les deux relevés se comparent : un disque qui allait bien le
matin et se plaint le soir, cela se voit.
!!! warning "Dites-le à la personne dont vous installez la machine"
La fiche part sur le réseau local, vers le serveur de l'association, et n'en sort
pas. Elle ne contient ni fichiers, ni historique, ni nom d'utilisateur — mais elle
contient le **nom de la machine**, souvent un prénom, et l'**adresse matérielle** de
la carte réseau. C'est son ordinateur : cela se demande, cela ne se suppose pas.
!!! danger "BitLocker : ne touchez à rien"
Si le script annonce une partition chiffrée par BitLocker, **arrêtez-vous là**. Le
chiffrement doit être suspendu depuis Windows — *Paramètres → Confidentialité et
sécurité → Chiffrement de l'appareil* — et la clé de récupération mise à l'abri.
Redimensionner ou effacer une partition BitLocker sans cette précaution rend les
données définitivement illisibles.
---
## 5. Installer le système
![L'icône « Install Linux Mint » sur le bureau](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/02-bureau-session-live.png)
![L'icône « Install Linux Mint » sur le bureau](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-012911.png)
Double-cliquez sur **Install Linux Mint**.
![Le choix de la langue](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/03-choix-de-la-langue.png)
![Le choix de la langue](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-013009.png)
**Langue** : sélectionnez **Français** dans la colonne de gauche, puis **Continuer**.
![La disposition du clavier](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/04-disposition-du-clavier.png)
![La disposition du clavier](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-013133.png)
**Disposition du clavier** : choisissez **French** dans la colonne de gauche. La colonne de
droite liste les variantes, en anglais elles aussi : **French - French (legacy, alt.)** est
proposée par défaut et convient à un clavier AZERTY français ordinaire. Les autres entrées
couvrent les cas particuliers — *(BEPO, AFNOR)*, *(Dvorak)*, *(Macintosh)*, *(no dead
keys)* pour un clavier sans touches mortes.
**Disposition du clavier** : choisissez **Français** à gauche, et à droite **Français
(variante)** ou **Français (variante, AltGr morte)**. Étape à ne pas bâcler — un clavier mal
choisi se paie au premier mot de passe. Testez dans la zone de saisie en bas : le `²`, le
`@`, les accents.
Étape à ne pas bâcler — un clavier mal choisi se paie au premier mot de passe. Testez dans
le champ **« Saisissez du texte ici pour tester votre clavier »** : le `²`, le `@`, les
accents. Le bouton **Détecter la disposition du clavier** fait deviner la disposition en
demandant d'appuyer sur quelques touches.
![Les codecs multimédia](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-013250.png)
![Les codecs multimédia](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/05-codecs-multimedia.png)
**Codecs multimédia** : cochez **Installer les codecs multimédias**, décochée par défaut.
Ces composants, parfois propriétaires, sont indispensables pour lire du MP3, du MP4 ou les
vidéos de nombreux sites.
**Codecs multimédia** : cochez la case. Ces composants, parfois propriétaires, sont
indispensables pour lire du MP3, du MP4 ou les vidéos de nombreux sites.
!!! info "Pourquoi ces codecs ne sont-ils pas installés d'office ?"
Certains formats, comme le MP3 ou le H.264, sont couverts par des brevets. Linux Mint
@ -459,13 +353,9 @@ vidéos de nombreux sites.
## 6. Créer les partitions
![Le type d'installation](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/06-type-installation.png)
![Le type d'installation](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-013612.png)
![L'écran de partitionnement, disque vierge](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/07-partitionnement-disque-vierge.png)
À l'écran *Type d'installation*, choisissez **Autre chose** — la première option,
*Effacer le disque et installer Linux Mint*, est sélectionnée par défaut — puis cliquez sur
**Installer maintenant** (et non « Continuer », comme aux écrans précédents).
À l'écran *Type d'installation*, choisissez **Autre chose**, puis **Continuer**.
!!! danger "Plusieurs disques ?"
Si la fenêtre montre plusieurs disques (`sda`, `sdb`, `nvme0n1`), ne prenez aucun
@ -474,26 +364,16 @@ vidéos de nombreux sites.
### Préparer le disque
![La table de partition](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/08-nouvelle-table-de-partition.png)
![La table de partition](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-013806.png)
- **Disque vierge** : cliquez sur **Nouvelle table de partition…**, puis **Continuer** dans
le message d'avertissement. L'installateur choisit seul le format adapté au mode de
démarrage — GPT en UEFI, MBR en BIOS hérité — sans rien demander.
- **Disque vierge** : cliquez sur **Nouvelle table de partition…** — **GPT** en UEFI,
**MBR** en BIOS hérité.
- **Anciennes partitions Windows** : supprimez-les une à une avec le bouton **-** pour
obtenir un grand *espace libre*, ou repartez d'une nouvelle table de partition.
### Les partitions à créer
Cliquez sur l'espace libre, puis sur **+** pour chacune. La fenêtre **Créer une
partition** demande la taille, le type, l'emplacement, l'usage et le point de montage :
![La fenêtre « Créer une partition »](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/09-creer-une-partition.png)
La liste **Utiliser comme** contient tout ce dont vous aurez besoin — *système de fichiers
journalisé ext4*, *espace d'échange (« swap »)*, *Partition système EFI*, et *Zone
réservée pour le chargeur d'amorçage BIOS* :
![La liste des systèmes de fichiers](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/10-utiliser-comme-partition-efi.png)
Cliquez sur l'espace libre, puis sur **+** pour chacune.
**Selon le mode de démarrage :**
@ -509,7 +389,7 @@ réservée pour le chargeur d'amorçage BIOS* :
1. **Le swap** (espace d'échange) — environ 1,5 fois la mémoire vive : pour 4 ou 8 Go de
RAM, indiquez 8000 Mo, et *Utiliser comme* → **espace d'échange (« swap »)**.
![La création du swap](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/12-creation-du-swap.png)
![La création du swap](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-013914.png)
2. **La racine `/`** — 30 à 150 Go selon le disque, *Utiliser comme* → **système de
fichiers journalisé ext4**, point de montage `/`.
@ -523,18 +403,16 @@ réservée pour le chargeur d'amorçage BIOS* :
### Lancer l'écriture
![Le tableau des partitions](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/13-table-de-partitions-complete.png)
![Le tableau des partitions](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-014316.png)
Vérifiez que le **Périphérique où sera installé le programme de démarrage** est bien le
disque principal (`/dev/sda`, `/dev/nvme0n1`…), puis **Installer maintenant**. Un dialogue
récapitule alors les partitions qui seront formatées : c'est le dernier écran avant
écriture.
Vérifiez que le *périphérique où sera installé le chargeur d'amorçage* est bien le disque
principal (`/dev/sda`, `/dev/nvme0n1`…), puis **Installer maintenant**.
![L'avertissement EFI](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-014445.png)
Un message peut signaler une particularité EFI : lisez-le, puis **Continuer**.
![Le dernier avertissement](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/14-appliquer-les-changements.png)
![Le dernier avertissement](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-014709.png)
Le dernier écran récapitule les changements. **Après ce clic, les données des partitions
concernées sont définitivement effacées.**
@ -543,11 +421,11 @@ concernées sont définitivement effacées.**
## 7. Compte utilisateur et fin de l'installation
![Le choix du fuseau horaire](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/15-fuseau-horaire.png)
![Le choix du fuseau horaire](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-014835.png)
**Où êtes-vous ?** — choisissez le fuseau horaire.
![La création du compte](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/16-compte-utilisateur.png)
![La création du compte](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-015439.png)
Pendant que les fichiers se copient, créez le compte principal :
@ -558,24 +436,20 @@ Pendant que les fichiers se copient, créez le compte principal :
(*jean*).
- **Mot de passe** : en Install Party, nous utilisons le mot de passe temporaire
`alpinux73`, remplacé avant de rendre la machine.
- Laissez **Demander mon mot de passe pour ouvrir une session**, sélectionné par défaut :
l'autre choix, *Ouvrir la session automatiquement*, laisse l'ordinateur accessible à qui
l'allume. L'option *Chiffrer mon dossier personnel* existe, mais un mot de passe oublié
rend alors les données définitivement irrécupérables.
- Le nom d'ordinateur et le nom d'utilisateur se remplissent tout seuls dès que vous
saisissez votre nom : le nom proposé pour la machine est souvent long et technique, il
gagne à être remplacé par quelque chose de court.
- Cochez **Demander mon mot de passe pour ouvrir une session**. L'option *Chiffrer mon
dossier personnel* existe, mais un mot de passe oublié rend alors les données
définitivement irrécupérables.
![L'installation en cours](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/17-installation-en-cours.png)
![L'installation en cours](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-015337.png)
Comptez **10 à 30 minutes** selon le disque et la connexion : Mint en profite pour
récupérer les mises à jour de sécurité et les paquets de langue française.
![Installation terminée](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/18-installation-terminee.png)
![Installation terminée](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-015957.png)
À la fin, la fenêtre **Installation terminée** propose **Redémarrer maintenant**.
![Retirer le support d'installation](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/19-retirer-le-support.png)
![Retirer le support d'installation](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-020022.png)
!!! warning "Ne retirez pas la clé trop tôt"
L'écran devient noir, puis affiche *« Please remove the installation medium, then press
@ -585,85 +459,42 @@ récupérer les mises à jour de sécurité et les paquets de langue française.
---
## 8. Le premier démarrage
![L'écran de connexion](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/20-ecran-de-connexion.png)
L'écran de connexion s'affiche en français, avec le nom saisi pendant l'installation. La
disposition du clavier retenue est rappelée en haut à droite — `fr` et `latin9` pour un
clavier français ordinaire : vérifiez-la avant de taper le mot de passe.
![L'écran de bienvenue](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/21-ecran-de-bienvenue.png)
La session s'ouvre sur l'écran **Bienvenue**. Sa rubrique **Premiers pas** enchaîne les
réglages que Mint juge prioritaires, chacun avec son bouton *Lancer* : couleurs du bureau,
**instantanés du système**, gestionnaire de pilotes, gestionnaire de mises à jour. C'est un
bon fil à suivre — et il recoupe ce qui suit.
La case *Afficher cette fenêtre au démarrage*, en bas, permet de ne plus la revoir une fois
le tour fait.
---
## 9. Opérations de post-installation
## 8. Opérations de post-installation
Le système est installé ; quelques réglages le rendent réellement utilisable.
### Le script de post-installation Alpinux
Il automatise ce qui manque presque toujours après une installation standard. Ouvrez un
terminal (`Ctrl + Alt + T`) et récupérez-le — **sur le réseau local de l'Install Party**,
où [le serveur d'Alpinux](../technique/serveur-install-party.md) le sert et met en cache
tout ce que la machine téléchargera ensuite :
terminal (`Ctrl + Alt + T`) et récupérez-le — **sur le réseau local de l'Install Party** :
```bash
wget http://alpicache.lan/install.sh http://alpicache.lan/alpi-fiche.sh
wget http://10.0.0.1/install.sh
```
**ou depuis Internet :**
```bash
wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.scripts/raw/branch/stable/poste/install.sh \
https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.scripts/raw/branch/stable/poste/alpi-fiche.sh
wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux-wiki/raw/branch/main/code/linux/linux-mint/install.sh
```
Puis, dans les deux cas :
```bash
chmod +x install.sh alpi-fiche.sh
chmod +x install.sh
./install.sh
```
!!! note "Pourquoi deux fichiers"
`install.sh` commence par relever la fiche matérielle, et il ne le fait **que s'il
trouve `alpi-fiche.sh` à côté de lui** — il ne va rien chercher sur le réseau de
lui-même. Téléchargé seul, il s'installera très bien, simplement sans relevé. En
install party, prenez les deux.
Le mot de passe est demandé au passage (`alpinux73` en Install Party) : les caractères ne
s'affichent pas, c'est normal.
Ce que le script met en place :
- **Le français partout** : paquets de langue manquants, dictionnaires LibreOffice
(`hunspell-fr`, `mythes-fr`, `hyphen-fr`) et préférences Firefox globales — interface,
correcteur, langue demandée aux sites, et lecture des contenus protégés (Netflix,
Prime).
- **Une logithèque prête à l'emploi** : polices Microsoft, VLC, GParted, Shotwell, Cheese,
pdfarranger, tesseract-ocr en français, backintime, stacer, `numlockx` pour le pavé
numérique — plus Flathub, avec KeePassXC et Flatseal en Flatpak.
- **Des réglages système** : microcode processeur Intel ou AMD, journaux plafonnés, cache
APT allégé, proxy APT détecté automatiquement sur le réseau de l'install party, Timeshift
désactivé, et GRUB qui redémarre sur la dernière entrée utilisée.
- **Les mises à jour** appliquées dans la foulée.
Le script s'efface lui-même une fois terminé.
!!! note "Comptez vingt minutes, et une connexion qui tient"
Le script installe les polices Microsoft (leur licence est acceptée automatiquement),
puis applique la mise à jour complète du système — plusieurs centaines de paquets sur
une installation neuve. Il demande le mot de passe au début, pour se relancer avec les
droits d'administration, puis se déroule seul.
- **Logithèque enrichie** : polices Microsoft, outils de gravure, application de webcam,
gestionnaire de mots de passe, utilitaires de sauvegarde.
- **Confort matériel** : `numlockx`, pour le pavé numérique dès le démarrage.
- **Mises à jour automatiques** : les correctifs de sécurité s'installent sans intervention.
- **Paquets de langue** : les traductions manquantes de LibreOffice, Firefox et consorts.
!!! info "Pourquoi installer les polices Microsoft ?"
Linux utilise des polices libres. Un document reçu en *Arial* ou *Times New Roman*
@ -786,7 +617,7 @@ Video.
---
## 10. Tests matériels finaux
## 9. Tests matériels finaux
Avant de considérer l'installation comme terminée, éprouvez chaque composant : c'est ainsi
qu'on détecte un pilote manquant pendant que les bénévoles sont encore là.
@ -818,7 +649,7 @@ qu'on détecte un pilote manquant pendant que les bénévoles sont encore là.
---
## 11. Rendre l'ordinateur
## 10. Rendre l'ordinateur
Une **vérification par une autre personne** que celle qui a installé conclut la séance :
un regard neuf repère ce que l'habitude a fait oublier.

View file

@ -14,13 +14,7 @@ son bureau pour la première fois.
21 : les fenêtres ont pu changer d'allure, les chemins et les boutons décrits restent
ceux de la 22.3.
!!! tip "Quatre pages, quatre moments"
- [Installer Linux Mint depuis Windows](linux-mint-depuis-windows.md) — l'installation elle-même, de la clé USB à l'ordinateur rendu.
- **Cette page** — le premier démarrage : mises à jour, langue, pilotes.
- [Trousse de premiers secours](linux-mint-trousse.md) — les gestes de base, en format court et imprimable.
- [Utiliser Linux Mint](utiliser-linux-mint.md) — la vie courante : paramètres, matériel, logiciels, entretien.
!!! note "Vous sortez d'une Install Party ?"
!!! tip "Vous sortez d'une Install Party ?"
Le [guide d'installation](linux-mint-depuis-windows.md) couvre déjà ces réglages dans
le fil de l'installation, avec le script de post-installation d'Alpinux qui en
automatise une partie. Cette page reprend les mêmes points, en détail et dans l'ordre
@ -73,8 +67,7 @@ Thunderbird ont leurs propres paquets, téléchargés après coup.
Dans la même fenêtre, le bouton **Installer / Supprimer des langues** signale par un
avertissement les paquets qui manquent pour le français.
Le même constat remonte dans **Renseignements sur le système**, l'outil de diagnostic de
Mint, à sa rubrique *Relevés du système* :
Le même constat remonte dans **Relevés du système**, l'outil de diagnostic de Mint :
![Relevés du système — installer des paquets de langue](https://static.alpinux.org/wiki/technique/pratique/pasted/20221213-230255.png)
@ -93,31 +86,22 @@ Si des mises à jour complémentaires sont proposées au passage, acceptez-les.
---
## 3. Lire ce que le système signale
## 3. Lire ce que « Relevés du système » signale
![Relevés du système](https://static.alpinux.org/wiki/technique/pratique/pasted/20221213-230516.png)
**Menu → Renseignements sur le système** centralise ce que Mint a remarqué sur votre
machine. Son menu latéral donne, dans l'ordre : l'identité de la machine (modèle, version
de Mint, noyau, processeur, carte graphique, mémoire, disques, environnement de bureau),
puis *USB*, *Processeur graphique*, *PCI*, *BIOS*, et enfin les deux rubriques qui
signalent quelque chose — **Relevés du système** (paquets de langue incomplets, pilotes
disponibles) et **Relevés de plantage**.
!!! tip "Le bouton qui fait gagner un quart d'heure"
La page d'accueil porte un bouton **Copier** : il met tout le résumé matériel dans le
presse-papiers, prêt à coller dans un message au LUG ou sur le forum. C'est la
première chose qu'un bénévole vous demandera.
**Menu → Relevés du système** est l'outil qui centralise ce que Mint a remarqué sur votre
machine : paquets de langue incomplets, pilotes propriétaires disponibles, rapports de
plantage, et informations système utiles quand on demande de l'aide.
Prenez l'habitude d'y passer après une installation, puis à chaque fois que quelque chose
se comporte bizarrement.
se comporte bizarrement : c'est la première chose qu'un bénévole vous demandera d'ouvrir.
---
## 4. Activer les pilotes du matériel
Toujours dans **Renseignements sur le système**, la rubrique *Installer des pilotes de
périphériques*
Toujours dans **Relevés du système**, la rubrique *Installer des pilotes de périphériques*
ouvre le **Gestionnaire de pilotes** — accessible aussi par **Menu → Gestionnaire de
pilotes**.
@ -169,7 +153,7 @@ contrôler ce que votre navigateur annonce réellement aux sites.
- [ ] *Langues* indique **Français, France UTF-8** pour la langue, la région et l'heure
- [ ] **Appliquer à tout le système** a été cliqué, et l'écran de connexion est en français
- [ ] Les paquets de langue manquants sont installés
- [ ] *Renseignements sur le système* ne signale plus rien d'urgent
- [ ] *Relevés du système* ne signale plus rien d'urgent
- [ ] Le pilote recommandé est activé, la machine a redémarré derrière
- [ ] Firefox est en français et souligne les fautes de frappe
- [ ] Le son, le Wi-Fi et le Bluetooth ont été essayés au moins une fois
@ -178,7 +162,8 @@ contrôler ce que votre navigateur annonce réellement aux sites.
## Et ensuite
- [Utiliser Linux Mint](utiliser-linux-mint.md) — la suite directe de cette page : les
Paramètres système, le confort du bureau, le matériel qui résiste, l'entretien.
- [Trousse de premiers secours](linux-mint-trousse.md) — les mêmes gestes en images, à
imprimer pour une install party.
- [Installer Linux Mint depuis Windows](linux-mint-depuis-windows.md) — le parcours
complet, y compris la restauration du profil Firefox et les tests matériels.
- [Trousse de premiers secours](linux-mint-trousse.md) — les gestes des premiers jours,
en format court et imprimable.
- [Utiliser Linux Mint](utiliser-linux-mint.md) — la prise en main au quotidien.

View file

@ -1,23 +1,6 @@
---
description: Trousse de premiers secours Linux Mint — les gestes des premiers jours en images : wifi, bluetooth, mises à jour, clé USB, installer et désinstaller un logiciel.
---
# Linux Mint 21 (Vanessa), Trousse de premiers secours
# Trousse de premiers secours
Les gestes des tout premiers jours, en images, pour qui découvre Linux Mint. Rien de plus :
chaque sujet est traité en détail ailleurs, et les liens y mènent.
!!! tip "Quatre pages, quatre moments"
- [Installer Linux Mint depuis Windows](linux-mint-depuis-windows.md) — l'installation elle-même, de la clé USB à l'ordinateur rendu.
- [Régler Linux Mint après l'installation](linux-mint-parametres.md) — le premier démarrage : mises à jour, langue, pilotes.
- **Cette page** — les gestes de base, en format court et imprimable.
- [Utiliser Linux Mint](utiliser-linux-mint.md) — la vie courante : paramètres, matériel, logiciels, entretien.
!!! info "État du document"
Captures et PDF réalisés sous **Linux Mint 21 (Vanessa)**. Les fenêtres ont changé
d'allure depuis, les gestes décrits restent les mêmes en 22.3.
[Télécharger la trousse de premiers secours (PDF, Mint 21)](https://static.alpinux.org/wiki/technique/pratique/premiers_secours.pdf){ .md-button }
[Télécharger la trousse de premiers secours Linux Mint 21 (PDF)](https://static.alpinux.org/wiki/technique/pratique/premiers_secours.pdf){ .md-button }
## Modifier l'arrière plan du bureau
![](https://static.alpinux.org/wiki/technique/pratique/pasted/20221112-070510.png)
@ -38,9 +21,6 @@ Choisir votre box et entrer la clé wifi. Elle est généralement inscrite sur l
## Faire les mises à jour
Les mises à jour sont importantes parce qu'elles protègent votre ordinateur, éliminent les bogues et peuvent même ajouter de nouvelles fonctions à votre système d'exploitation. L'icône des mises à jour se trouve en bas à droite de votre écran.
Le fonctionnement du gestionnaire, les notifications et les réglages utiles sont expliqués
dans [Utiliser Linux Mint](utiliser-linux-mint.md#le-gestionnaire-de-mises-a-jour).
![](https://static.alpinux.org/wiki/technique/pratique/pasted/20221112-071144.png)
## Enlever proprement une clé USB ou un disque dur externe
@ -52,8 +32,7 @@ Clic droit sur le volume que l'on veut enlever **Ejecter** pour une clé USB ou
![](https://static.alpinux.org/wiki/technique/pratique/pasted/20221112-071411.png)
## Installer des logiciels
Pour être sûr d'installer un logiciel compatible avec votre système, il faut utiliser le gestionnaire de logiciels. La différence entre les logiciels des dépôts et les Flatpak est
expliquée dans [Utiliser Linux Mint](utiliser-linux-mint.md#installer-des-logiciels).
Pour être sûr d'installer un logiciel compatible avec votre système, il faut utiliser le gestionnaire de logiciels.
![](https://static.alpinux.org/wiki/technique/pratique/pasted/20221112-071503.png)

View file

@ -1,313 +1,53 @@
---
description: Utiliser Linux Mint au quotidien — les Paramètres système, les réglages à faire une fois, le confort du bureau, le matériel qui résiste, l'installation de logiciels et les mises à jour.
---
# Utiliser Linux Mint
Le système est installé et réglé : cette page est celle de la vie courante. Où changer
quoi, quoi installer, comment tenir la machine à jour, et quoi faire quand un périphérique
refuse de coopérer.
!!! tip "Quatre pages, quatre moments"
- [Installer Linux Mint depuis Windows](linux-mint-depuis-windows.md) — l'installation
elle-même, de la clé USB à l'ordinateur rendu.
- [Régler Linux Mint après l'installation](linux-mint-parametres.md) — le premier
démarrage : mises à jour, langue, pilotes.
- [Trousse de premiers secours](linux-mint-trousse.md) — les gestes de base, en format
court et imprimable.
- **Cette page** — tout ce qui vient ensuite.
---
## Les Paramètres système
Tout se règle au même endroit : **Menu → Paramètres système**, dont la fenêtre s'intitule
**Paramètres du système**. Une quarantaine de rubriques, rangées en quatre familles :
| Famille | Ce qu'on y trouve |
| --- | --- |
| **Apparence** | Choix des polices, Effets, Fonds d'écran, Thèmes |
| **Préférences** | Accessibilité, Applets, Applications lancées au démarrage, Applications par défaut, Comptes en ligne, Date et heure, Détails du compte, Économiseur d'écran, Espaces de travail, Fenêtres, Gestes, Langues… |
| **Matériel** | Affichage, Bluetooth, Clavier, Disques, Gestion de l'alimentation, Imprimantes, Réseau, Son, Souris et pavé tactile, Renseignements sur le système |
| **Administration** | Fenêtre de connexion, Gestionnaire de pilotes, Pare-feu, Sources des logiciels, Administration du système |
Deux réflexes font gagner beaucoup de temps :
- **la barre de recherche en haut** de cette fenêtre : tapez « écran », « son », « heure »
plutôt que de chercher l'icône ;
- **la recherche du menu** : la même chose depuis le menu principal, sans ouvrir les
paramètres.
!!! note "Paramètres système ou Gestionnaire de logiciels ?"
Les **Paramètres système** règlent le comportement de l'ordinateur — ce qui est déjà
là. Le **Gestionnaire de logiciels** installe et retire des applications. Deux outils
différents, deux icônes différentes : la confusion entre les deux est la première
source d'égarement.
---
## Les réglages à faire une fois
### Le gestionnaire de mises à jour
Les mises à jour ajoutent des fonctions, corrigent des bogues et bouchent des failles de
sécurité. Sous Linux elles ne concernent pas que le système : les logiciels et les pilotes
installés avec la distribution passent par le même canal.
Linux Mint repose sur des **paquets** — des archives contenant un logiciel et les
informations nécessaires à son installation — gérés par un **gestionnaire de paquets**,
qui automatise l'ensemble.
Une mise à jour peut aussi provoquer une régression : logiciel instable, fonction perdue,
matériel qui cesse d'être reconnu (Wi-Fi, webcam).
!!! warning "Les « niveaux » de mise à jour n'existent plus"
Jusqu'à Mint 19, le gestionnaire classait les mises à jour en quatre niveaux, et l'on
conseillait aux débutants de s'en tenir au niveau 2. **Ce système a disparu** : sur
Mint 22.3, il n'y a plus ni menu *Édition → Niveaux*, ni réglage correspondant.
Vérifié sur une installation 22.3 en septembre 2026 — si vous trouvez un tutoriel qui
en parle, il décrit une version ancienne.
La réponse de Mint au risque de régression est ailleurs : **les instantanés système**,
que le gestionnaire met en avant dès son premier lancement (voir *Prendre des
instantanés avec Timeshift*, plus bas).
**Au premier lancement**
Le gestionnaire commence par un écran d'accueil qui distingue trois choses : les **mises à
jour de sécurité**, les **mises à jour logicielles** et les **instantanés système**. Il
propose ensuite d'utiliser un **miroir de dépôts local**, plus rapide que le serveur par
défaut : acceptez. Il peut enfin se mettre à jour lui-même avant d'afficher le reste.
**Quand mettre à jour ?**
L'applet en forme de bouclier, à droite de la barre des tâches, change d'aspect selon
l'état du système :
| Bouclier | Signification |
| --- | --- |
| **V vert** | Le système est à jour |
| **! bleu** | Des mises à jour sont disponibles — cliquez pour les installer |
| **Gris, vide** | Le système cherche les mises à jour, ou n'arrive pas à joindre le réseau |
| **X rouge** | Une erreur est survenue ; réessayez plus tard, et voyez avec le LUG si elle persiste |
**Comment ?** Cliquez sur l'applet, puis sur **Installer les mises à jour**, saisissez
votre mot de passe, et laissez faire. Le gestionnaire annonce à la fin que le système est
à jour.
**Ce que contient le menu Édition** : *Préférences*, *Instantanés système* et *Sources de
logiciels* — rien d'autre.
Les **Préférences** s'organisent en trois onglets :
| Onglet | Ce qu'on y règle |
| --- | --- |
| **Options** | L'interface (cacher la fenêtre après installation, afficher une icône de notification), l'actualisation automatique de la liste, et les notifications — dont *N'afficher que les notifications des mises à jour de sécurité et des noyaux* |
| **Paquets** | Ce qui apparaît dans la liste : mises à jour de Cinnamon, paquets Flatpak, noyaux |
| **Automatisation** | Les mises à jour appliquées sans intervention |
!!! tip "Le piège du `/boot` plein"
Les anciens noyaux s'accumulent et finissent par saturer la partition de démarrage,
ce qui bloque toute nouvelle mise à jour. L'onglet *Automatisation* permet de
programmer leur suppression ; à défaut, passez de temps en temps par
**Affichage → Noyaux Linux**, qui les liste et permet de retirer les plus anciens.
!!! warning "Changer de noyau n'est pas anodin"
La même fenêtre *Noyaux Linux* s'ouvre sur un avertissement qu'il vaut la peine de
lire : un noyau plus récent peut faire disparaître le Wi-Fi, l'accélération graphique,
ou donner un écran noir au démarrage — surtout avec des pilotes propriétaires.
La sortie de secours tient en quatre gestes, à connaître **avant** d'en installer un :
redémarrer, maintenir **Maj** pour afficher le menu GRUB, choisir *Advanced options*
puis un noyau antérieur, et désinstaller le plus récent une fois revenu.
### Activer le pare-feu
Le pare-feu est installé, mais **désactivé par défaut**. Pour un ordinateur portable qui
se connecte à des réseaux publics, il vaut mieux l'allumer :
**Paramètres du système → Pare-feu** (famille *Administration*). L'ouverture demande votre
mot de passe, puis il suffit de basculer **État** sur *Activé*.
Le profil proposé par défaut, **Domestique**, convient : les deux lignes en dessous
annoncent la règle appliquée — *Entrant : Refuser*, *Sortant : Autoriser*. Autrement dit,
rien ne rentre sans y avoir été invité, tout ce que vous lancez sort normalement. Les
profils *Bureau* et *Public* servent à mémoriser d'autres jeux de règles ; sans besoin
précis, n'y touchez pas.
### Vérifier ses pilotes
**Paramètres du système → Gestionnaire de pilotes** (famille *Administration*) liste le
matériel pour lequel un pilote propriétaire existe. Si la case cochée est celle d'un pilote libre alors qu'un pilote recommandé est
proposé, essayez ce dernier, puis redémarrez.
!!! warning "Prudence avec la carte graphique"
Changer un pilote graphique peut mener à un écran noir au redémarrage. Faites-le quand
vous avez le temps de revenir en arrière — et de préférence après avoir pris un
instantané Timeshift.
### Alléger le démarrage
**Paramètres du système → Applications lancées au démarrage** montre ce qui se lance à
l'ouverture de session. Désactivez ce que vous n'utilisez pas : chaque entrée retarde l'arrivée du
bureau. Dans le doute, désactivez plutôt que de supprimer.
### Prendre des instantanés avec Timeshift
**Menu → Timeshift** photographie le système à intervalles réguliers et permet de revenir
en arrière après une mise à jour malheureuse ou une fausse manœuvre.
- Choisissez **RSYNC** à la première ouverture.
- Gardez peu d'instantanés — deux ou trois — sur un petit disque.
- Timeshift sauvegarde le **système**, pas vos documents : pour ces derniers, voyez
*Menu → Sauvegarde*, ou une copie sur disque externe.
!!! tip "Des instantanés qui grossissent trop"
Les applications Flatpak sont volumineuses et changent souvent : elles peuvent faire
gonfler les instantanés hors de proportion. Dans *Timeshift → Paramètres → Filtres*,
excluez `/var/lib/flatpak` si l'espace disque devient un souci.
---
## Le confort du bureau
### Écrans
**Paramètres du système → Affichage** gère la disposition d'un deuxième écran (à gauche, à
droite, en miroir), la résolution et la fréquence.
Sur un portable récent à écran très fin — 13 ou 14 pouces en haute définition — tout
paraît minuscule. C'est le réglage d'**échelle de l'interface** qu'il faut modifier, dans
la même fenêtre, et non la résolution : baisser la résolution rend l'image floue, alors
que l'échelle agrandit proprement.
### Apparence
**Paramètres du système → Thèmes** change l'aspect général, y compris le mode sombre —
Mint 22.3 démarre d'ailleurs en thème sombre. **Choix des polices** règle la taille du
texte partout à la fois, plus efficace que d'agrandir chaque application séparément.
### Panneau et menu
Clic droit sur la barre des tâches → **Configurer** : hauteur, position (en haut plutôt
qu'en bas, par exemple), et **Ajouter des applets** pour la météo, la charge, ou un
sélecteur de fenêtres.
Clic droit sur une application dans le menu → **Ajouter aux favoris** pour l'épingler.
### Énergie et veille
**Paramètres du système → Gestion de l'alimentation** décide de ce qui se passe quand on
ferme le capot, au bout de combien de temps l'écran s'éteint, et si la machine se met en
veille. Sur un ordinateur de bureau, mettre la veille sur *Jamais* évite bien des retours
d'écran capricieux.
### Clavier
**Paramètres du système → Clavier** contient deux réglages qui rendent service :
- la **touche compose**, dans *Options*, qui donne accès aux caractères absents du clavier
(œ, æ, ©, majuscules accentuées) ;
- les **raccourcis**, pour ouvrir un terminal ou changer de bureau sans la souris.
Pour que le **pavé numérique** soit actif dès l'écran de connexion :
*Paramètres du système → Fenêtre de connexion → Paramètres → Activer le verrouillage
numérique*.
### Pavé tactile
**Paramètres du système → Souris et pavé tactile** : défilement à deux doigts, clic par
tapotement, désactivation pendant la frappe — le réglage qui évite le curseur qui saute
au milieu d'une phrase.
---
## Quand le matériel résiste
Trois sujets reviennent sans cesse sur les forums francophones, et valent d'être connus
avant de chercher.
### Imprimante
**Paramètres du système → Imprimantes → Ajouter**. La plupart des imprimantes réseau sont
détectées seules ; les modèles USB aussi, une fois allumés et branchés.
Si l'imprimante apparaît mais imprime de travers, ou se présente comme « imprimante
générique », le pilote générique ne suffit pas : certains constructeurs — **Canon** en
particulier — publient des pilotes Linux à télécharger sur leur site et à installer à la
main. Un passage par le [forum
francophone](https://forum-francophone-linuxmint.fr/) évite souvent une heure de
tâtonnement : le modèle a généralement déjà été traité.
### Bluetooth
L'adaptateur peut être éteint au démarrage : l'applet Bluetooth de la barre des tâches
permet de l'allumer, et *Paramètres du système → Bluetooth* de gérer les appareils
appairés.
Un casque qui ne se reconnecte pas tout seul se règle le plus souvent en le supprimant de
la liste puis en le réappairant. Si l'adaptateur n'apparaît pas du tout, c'est un pilote
manquant : voyez le gestionnaire de pilotes, puis demandez de l'aide avec le modèle exact
de la machine.
### Son
**Paramètres du système → Son** liste les sorties disponibles. Le cas classique : le son
reste dans les haut-parleurs alors qu'un casque est branché — il suffit de choisir la
bonne sortie dans cette fenêtre. Même chose pour le micro, dans l'onglet *Entrée*, où le
niveau peut être à zéro.
---
## Installer des logiciels
Le **Gestionnaire de logiciels** (*Menu → Gestionnaire de logiciels*) est la bonne porte
d'entrée : il cherche, installe et désinstalle proprement. La
[trousse de premiers secours](linux-mint-trousse.md) en montre les écrans pas à pas.
Deux origines coexistent, et le gestionnaire indique laquelle il propose :
| Origine | Ce que c'est |
| --- | --- |
| **Dépôts système** (apt) | Les paquets intégrés à Mint, testés avec votre version. À préférer par défaut. |
| **Flatpak** | Des applications autonomes, souvent plus récentes, qui embarquent ce dont elles ont besoin. Utile quand la version des dépôts est trop ancienne. |
!!! note "Et Snap ?"
Mint **bloque volontairement** l'installation de `snapd`, le format concurrent poussé
par Ubuntu. Ce n'est pas un bogue : un équivalent Flatpak existe pour à peu près tout.
N'essayez pas de le contourner sans raison précise.
Quelques logiciels installés d'office, pour situer : **LibreOffice** (traitement de texte,
tableur, présentation), **Firefox** (navigateur), **Thunderbird** (courriel), **VLC**
(vidéo et audio), **GIMP** (retouche d'images), **Timeshift** (instantanés système).
---
## Entretenir la machine
Quelques gestes, quelques minutes par mois :
- [ ] Installer les mises à jour proposées par l'applet bouclier
- [ ] Redémarrer après une mise à jour du noyau (l'applet le signale)
- [ ] Vérifier l'espace disque restant (*Menu → Analyseur d'utilisation des disques*)
- [ ] Vider la corbeille et le dossier des téléchargements
- [ ] Contrôler que les instantanés Timeshift sont récents — et qu'ils ne saturent pas le
disque
- [ ] Sauvegarder ses documents ailleurs que sur la machine
!!! tip "Une question sans réponse ici ?"
Les réunions Alpinux ont lieu les 1er et 3e jeudis du mois, et le
[forum francophone Linux Mint](https://forum-francophone-linuxmint.fr/) traite déjà la
plupart des cas. Donnez toujours votre version de Mint — *Menu → Renseignements sur le
système*, bouton **Copier** —,
le modèle de la machine, et le message d'erreur exact.
---
## Références
- [Paramétrer Linux Mint — InfoLibre](https://infolib.re/Parametrer_Linux_Mint)
- [Le panneau de paramètres système — TuxLibre](https://lewinux.over-blog.fr/2020/12/linux-mint-le-panneau-de-parametres-systeme.html)
- [Instantanés système — guide d'installation officiel de Linux Mint](https://linuxmint-installation-guide.readthedocs.io/en/latest/timeshift.html)
- [Gestionnaire de mises à jour — Link-Zilla](https://link-zilla.blogspot.com/2020/05/linux-mint-gestionnaire-mises-a-jour.html)
- [Forum francophone Linux Mint](https://forum-francophone-linuxmint.fr/)
## Logiciels
Libre Office - suite bureautique : tableur, traitement de texte...
VLC - lecteur de vidéo
Firefox - navigateur Internet
Chromium - navigateur Internet
## Maintenir son système à jour
Les mises à jour du système d'exploitation sont destinées à ajouter de nouvelles fonctionnalités, à corriger des bugues de fonctionnement et/ou des failles de sécurité. Votre système doit donc impérativement être mis à jour. Sous Linux, les mises à jour ne concernent pas uniquement le système d'exploitation, mais également les logiciels et pilotes installés avec la distribution.
Pour votre information, le système d’exploitation Linux Mint reposent sur l’utilisation de paquets logiciels via un gestionnaire de paquets.
Un paquet Archives (fichier compressé) contenant les données et informations nécessaires à l’installation d’un logiciel.
Un gestionnaire de paquets est un ensemble d’outils logiciels permettant d’automatiser l’installation et la gestion de paquets logiciels.
Les mises à jour peuvent cependant entraîner des régressions, c’est-à-dire qu’elles peuvent rendre certains logiciels instables, entraîner la perte de certaines fonctions, perturber le bon fonctionnement d’autres logiciels, perdre la compatibilité avec certains matériels (Wifi, webcam…), etc.
Pour certains logiciels isolés, ces régressions seront sans conséquences sur l’ensemble du système d’exploitation, mais pour d’autres paquets plus sensibles, les perturbations peuvent être très handicapantes pour l’utilisation du système. Nous appelons les mises à jour concernant ces derniers paquets « Mises à jour sensibles ».
Afin d’aider à identifier les différents types de mise à jour (fonctionnelle ou de sécurité) et quel est le niveau de risques concernant les possibles régressions, Linux Mint propose un gestionnaire de mise à jour permettant de gérer au mieux son système d’exploitation et ses paquets.
Son utilisation est donc recommandée pour les utilisateurs non experts ainsi que pour ceux souhaitant disposer d’un récapitulatif graphique des informations essentielles concernant les mises à jour disponibles avant de les appliquer.
****Paramétrage du gestionnaire de mises à jour****
Lors de la première installation de Linux Mint, il vous sera demandé de choisir quel degré de mises à jour vous entendez appliquer.
Pour les novices, il est plus prudent de ne cocher que le niveau 2 ( Niveau par défaut - Faible impact sur le système ).
Il vous sera possible de modifier ces choix plus tard en allant sur le gestionnaire de mises à jour / Menu Édition / Niveaux /
Les quatre possibilités de niveau d'impact des mises à jour sur votre système sont les suivants :
- **Niveau 1** : Minimal - Aucun impact sur le système ou sur d'autres programmes.
- **Niveau 2** : Normal - Habituellement faible impact sur le système.
- **Niveau 3** : Grand - Impact sur plusieurs applications.
- **Niveau 4** : Sensible - Impact sur les parties sensibles du système.
****Procédure de mise à jour Linux Mint par le gestionnaire de mises à jour****
****QUAND ?****
Votre système Linux Mint est conçu pour vous prévenir de la présence de nouvelles mises à jour. L'applet des mises à jour modifie automatiquement son apparence pour mettre en évidence l'état du système. Il se trouve à droite de votre barre de tâches et représente un bouclier.
- ****Bouclier avec un V vert**** : Votre système est à jour.
- ****Bouclier avec un ! bleu**** : Des mises à jour sont disponibles. Cliquez sur l'applet pour les installer.
- ****Bouclier vide et gris**** : Le système est occupé. Soit il effectue une recherche de mises à jour, soit il ne parvient pas à se connecter au réseau pour vérifier les mises à jour.
- ****Bouclier avec une X rouge**** : Une erreur est survenue. Veuillez réessayer plus tard. Si vous ne parvenez pas à installer les mises à jour après plusieurs tentatives, mettez-vous en contact avec le LUG ( Groupe d'Utilisateurs Linux - En anglais **L**inux **U**ser **G**roup ) près de chez vous.
****COMMENT ?****
- En cliquant sur l'applet, la liste des mises à jour apparaît.
- Cliquez sur le bouton Installer les mises à jour.
- Entrez votre mot de passe.
- Les mises à jour se téléchargent et s'installent automatiquement.
- A la fin du processus, le gestionnaire des mises à jour vous indique que votre système est à jour.
- Vous pouvez alors fermer la fenêtre du gestionnaire.
### Références
- https://link-zilla.blogspot.com/2020/05/linux-mint-gestionnaire-mises-a-jour.html
- https://forum-francophone-linuxmint.fr/viewtopic.php?t=8953

View file

@ -1,110 +0,0 @@
**Format** : Court (20 min)
**Objectif :** ne plus imprimer un formulaire pour le signer puis le scanner.
**Déroulé**
1. Le lecteur de Linux Mint (Xreader) : lire, chercher, surligner.
2. Okular : annoter et remplir un formulaire.
3. Xournal++ : apposer une signature manuscrite.
4. PDF Arranger : fusionner, découper, réordonner des pages.
5. Exporter en PDF depuis LibreOffice, réduire le poids pour un envoi par mail.
**Démo :** remplir et signer un vrai formulaire, le fusionner avec une pièce justificative.
--
Voilà ce que nous voulons faire : Un dossier d’inscription à envoyer par mail. C'est un formulaire à remplir et signer, une pièce justificative à joindre, le tout en un seul PDF léger. Chaque outil résout une étape.
### Avant la séance
**Fichiers à préparer**
- Un formulaire PDF avec champs modifiables (un CERFA convient).
- Un formulaire sans champs, par exemple un document scanné.
- Un justificatif en image (photo d’une facture fictive).
- Une signature sur papier blanc, photographiée et enregistrée en PNG.
**Installation** (Xreader et LibreOffice sont déjà dans Linux Mint) :
```
sudo apt install okular xournalpp pdfarranger
```
Les trois sont aussi dans la Logithèque, à utiliser si vous ne vous sentez pas à l'aise avec le terminal.
### 1. Xreader, le lecteur déjà installé
- Ouvrir le formulaire par double-clic.
- Le panneau latéral : vignettes des pages et sommaire.
- Chercher un mot avec Ctrl+F.
- Surligner un passage et ajouter une note depuis le panneau des annotations.
- Remplir directement un champ du formulaire.
**À noter :** pour lire et pour un formulaire simple, il n’y a rien à installer.
**Piège :** utiliser « Enregistrer une copie », sinon les annotations et la saisie sont perdues à la fermeture.
### 2. Okular, pour annoter et remplir
- La barre d’annotations (F6) : surligneur, note, trait à main levée.
- Le bouton « Afficher les formulaires », puis la saisie des champs et des cases à cocher.
- L’outil « machine à écrire » : il permet d’écrire sur un PDF qui n’a pas de champs, cas très fréquent avec les documents scannés.
- Enregistrer avec Ctrl+S, puis rouvrir le fichier dans Xreader pour prouver que le texte est bien dedans.
**À retenir :** Okular vient de l’environnement KDE mais fonctionne très bien sous Mint. C’est l’outil à retenir si l’on ne devait en installer qu’un.
**Piège :** un PDF protégé peut refuser la saisie. Dans ce cas, passer à Xournal++.
### 3. Xournal++, pour signer
- Fichier > Annoter un PDF, puis ouvrir le formulaire rempli.
- Méthode 1 : signer au stylet ou à la souris avec l’outil stylo (résultat médiocre à la souris, le montrer avec humour).
- Méthode 2, la bonne : insérer l’image de sa signature, la redimensionner et la placer.
- Ajouter la date avec l’outil texte.
- Fichier > Exporter en PDF.
**À noter :** une signature collée en image est acceptée pour beaucoup de démarches courantes, mais ce n’est pas une signature électronique qualifiée. Pour un acte important, l’organisme impose généralement son propre service.
**Piège :** « Enregistrer » produit un fichier .xopp, illisible pour le destinataire. Il faut exporter en PDF. C’est l’erreur numéro un.
**Conseil de sécurité :** ranger le PNG de sa signature dans un dossier discret, et ne pas le laisser traîner sur une clé USB.
### 4. PDF Arranger, pour assembler
- Glisser le formulaire signé et le justificatif dans la fenêtre.
- Réordonner les pages à la souris.
- Faire pivoter une page scannée de travers.
- Supprimer une page blanche.
- Extraire une seule page d’un long document : sélectionner, puis exporter la sélection.
- Enregistrer sous un nouveau nom.
**À noter :** le logiciel accepte aussi les images, donc une photo de justificatif devient une page PDF sans étape intermédiaire.
**Piège :** enregistrer sous un nouveau nom pour ne pas écraser l’original.
### 5. Exporter et alléger
- Dans LibreOffice Writer : Fichier > Exporter vers PDF.
- Dans les options : compression JPEG et réduction de la résolution des images à 150 DPI. Comparer le poids avant et après dans le gestionnaire de fichiers.
- Mentionner l’option PDF hybride, qui embarque le fichier d’origine et permet de le remodifier plus tard.
**Pour un PDF déjà existant et trop lourd**, typiquement un scan, une commande suffit :
```
gs -sDEVICE=pdfwrite -dPDFSETTINGS=/ebook -dNOPAUSE -dBATCH -sOutputFile=leger.pdf lourd.pdf
```
**À noter :** les sites de compression en ligne fonctionnent, mais on y envoie sa pièce d’identité ou son avis d’imposition à un inconnu. Tout ce qui a été montré ce soir reste sur l’ordinateur.
### Conclusion
Rappeler le parcours : remplir (Okular), signer (Xournal++), assembler (PDF Arranger), alléger, envoyer. Pas d’imprimante, pas de scanner, pas de service en ligne.
|Je veux|J’utilise|
|---|---|
|Lire, chercher, surligner|Xreader|
|Remplir un formulaire, écrire sur un PDF|Okular|
|Signer|Xournal++|
|Fusionner, découper, pivoter|PDF Arranger|
|Créer un PDF léger|LibreOffice|

View file

@ -1,16 +0,0 @@
**Format** : Court (20 min)
**Objectif :** savoir quoi sauvegarder et où, avant de parler d’outil.
**Déroulé**
1. Où sont mes fichiers : le dossier personnel, Documents, Images (rappel de la présentation existante).
2. Ce qui est irremplaçable (photos, papiers) et ce qui ne l’est pas (logiciels, système).
3. La règle 3-2-1 expliquée simplement : trois copies, deux supports, une ailleurs.
4. Choisir son support : disque externe, clé USB, [[NAS]], [[Nextcloud]].
5. Synchronisation et sauvegarde ne sont pas la même chose : une suppression par erreur se propage.
**Démo :** copier son dossier Documents sur un disque externe, puis vérifier que la copie s’ouvre.
**Remarque :** « Les sauvegardes » figure déjà dans les présentations passées et un guide existe sur le wiki. Cette séance peut en être la version actualisée, centrée sur les documents personnels.
[sauvegardes](../guides/sauvegardes.md)

View file

@ -1,16 +0,0 @@
**Format** : Long (45 min)
**Objectif :** que chacun reparte avec une sauvegarde configurée sur sa machine.
**Déroulé**
1. Deux outils, deux rôles : Timeshift pour le système, l’Outil de sauvegarde pour les fichiers personnels.
2. Timeshift : choisir le disque, la fréquence, le nombre d’instantanés conservés, puis restaurer après une mise à jour ratée.
3. Outil de sauvegarde : sauvegarder son dossier personnel, exclure des dossiers, restaurer.
4. Sauvegarder la liste de ses logiciels, pratique pour une réinstallation.
5. Pour aller plus loin : Déjà Dup ou Pika Backup, avec planification et chiffrement.
6. Tester une restauration, l’étape que tout le monde oublie.
**Démo :** supprimer volontairement un fichier, puis le restaurer.
**À prévoir :** demander aux participants d’apporter leur portable et un disque externe.

View file

@ -1,18 +0,0 @@
**Format :** long, 45 min
**Objectif :** utiliser [[Nextcloud]] côté utilisateur, sans parler d’installation de serveur.
**Déroulé**
1. À quoi ça sert : ses fichiers accessibles partout, sans Google Drive ni OneDrive.
2. L’interface web : déposer, ranger, retrouver une version précédente, corbeille.
3. Le client de synchronisation sous Linux Mint : choisir les dossiers.
4. L’application mobile : envoi automatique des photos.
5. Partager : lien public, mot de passe, date d’expiration.
6. Agenda et contacts, reliés à Thunderbird.
7. Les limites : quota, et toujours pas une sauvegarde à lui seul.
**Démo :** partager un dossier avec la salle par un code QR, chacun y dépose une photo.
**Atout :** le portail membres d’Alpinux donne déjà accès à un Nextcloud, donc les adhérents peuvent pratiquer tout de suite, et c’est un argument d’adhésion. [alpinux](https://alpinux.org/)

View file

@ -1,44 +0,0 @@
Le référentiel Pix (aligné sur le CRCN, le Cadre de référence des compétences numériques) compte 16 compétences rassemblées en 5 grands domaines, décliné du cadre commun de référence européen DIGCOMP 2.1. Les voici :
**1. Information et données**
- 1.1 [[Mener une recherche et une veille d'information]]
- 1.2 [[Gérer des données]]
- 1.3 [[Traiter des données]]
**2. Communication et collaboration**
- 2.1 [[Interagir]]
- 2.2 [[Partager et publier]]
- 2.3 [[Collaborer]]
- 2.4 [[S'insérer dans le monde numérique]]
**3. Création de contenu**
- 3.1 [[Développer des documents textuels]]
- 3.2 [[Développer des documents multimédia]]
- 3.3 [[Adapter les documents à leur finalité]]
- 3.4 [[Programmer]]
**4. Protection et sécurité**
- 4.1 [[Sécuriser l'environnement numérique]]
- 4.2 [[Protéger les données personnelles et la vie privée]]
- 4.3 [[Protéger la santé, le bien-être et l'environnement]]
**5. Environnement numérique**
- 5.1 [[Résoudre des problèmes techniques]]
- 5.2 [[Construire un environnement numérique]]
Quelques repères utiles : le cadre prévoit 8 niveaux de maîtrise progressive, les niveaux 1 à 5 concernant les élèves de collège et de lycée. Chaque compétence est décomposée en sous-compétences, elles-mêmes déclinées en acquis par niveau, et côté score, une compétence validée au niveau le plus élevé « rapporte » 64 Pix (8 Pix par niveau). Enfin, la certification doit être renouvelée tous les 3 ans.
Le détail de chaque compétence est consultable sur pix.fr/competences.
Sources :
- [France Compétences – Certificat Pix](https://www.francecompetences.fr/recherche/rs/3807)
- [France Compétences – fiche Pix](https://certifpro.francecompetences.fr/api/fiches/downloadAncFormat/18995)
- [Collège Alfred Kastler – Parcours Pix 3e](https://alfred-kastler.college.ac-normandie.fr/IMG/pdf/parcours_de_formation_pix_3e.pdf)
- [Collège Anna Marly – Pix et continuité pédagogique](https://www.college-anna-marly-brest.ac-rennes.fr/sites/college-anna-marly-brest.ac-rennes.fr/IMG/pdf/pix_et_continuite_pedagogique.pdf)

View file

@ -1,74 +0,0 @@
## 3.3 Adapter les documents à leur finalité
**Ce que recouvre la compétence** : transformer un document selon son usage (impression, mise en ligne, projection, mises à jour fréquentes, diffusion sur plusieurs supports) et maîtriser les licences qui encadrent sa réutilisation. Thématiques Pix : choix et conversion de formats, poids et qualité des fichiers, interopérabilité, accessibilité, licences.
### Progression par niveaux (résumé)
- **N1-N2** : enregistrer un document dans un autre format, exporter en PDF.
- **N3** : choisir le format selon l'usage (modifiable ou figé), réduire le poids d'une image avant envoi.
- **N4-N5** : préparer un document pour l'impression ou la projection, appliquer une licence à sa production, respecter celles des ressources réutilisées.
- **N6+** : organiser une production multisupport à partir d'une source unique, automatiser les conversions, gérer la compatibilité des licences.
### Version Linux et libre
**Choisir le bon format selon l'usage**
- À modifier : ODT, ODS, ODP, Markdown
- À diffuser figé ou imprimer : PDF ; à archiver : PDF/A
- Pour le web : HTML ; pour une liseuse : EPUB
- Images : PNG (schémas), JPEG ou WebP (photos), SVG (vectoriel)
- Audio et vidéo : Opus, FLAC, WebM (formats ouverts) ; MP3 et MP4 pour la compatibilité
**Convertir**
- LibreOffice en ligne de commande : `soffice --headless --convert-to pdf *.odt` pour tout un dossier
- **Pandoc** : une source Markdown, plusieurs sorties (principe de la diffusion multicanale)
- Images : **ImageMagick**, Converseen (par lots), Switcheroo (GNOME)
- Audio et vidéo : **FFmpeg**, HandBrake
**Alléger et optimiser**
- Compression avec ou sans perte : comprendre le compromis
- Images : Curtail, ou `magick photo.jpg -resize 1200x photo-web.jpg`
- PDF trop lourd : Ghostscript, réglages d'export de LibreOffice
- Assembler, découper, réordonner des PDF : PDF Arranger, `qpdf`
**Préparer pour l'impression**
- Résolution (300 ppp), marges, fonds perdus
- Couleurs CMJN avec Scribus
- Impression en livret depuis LibreOffice, gestion des imprimantes avec CUPS
**Préparer pour la projection**
- Format 16:9, gros caractères, contrastes forts
- PDF avec polices incorporées pour éviter les surprises sur un autre poste
**Documents mis à jour souvent**
- Garder la source modifiable, versionner (lien 2.3)
- Champs automatiques (dates, numéros), modèles, publipostage
**Accessibilité**
- PDF balisé, texte alternatif
- **OCRmyPDF** : rendre un PDF scanné lisible et cherchable
**Avant diffusion**
- Retirer métadonnées et traces de révisions : option de LibreOffice pour supprimer les informations personnelles à l'enregistrement, **mat2**
**Licences**
- Creative Commons : choisir, afficher la mention dans le document et ses propriétés
- Compatibilité : on ne peut pas mélanger librement BY-SA et BY-NC dans une même œuvre
- **CC0** pour le domaine public, **Licence Ouverte (Etalab)** pour les données publiques, **GPL** pour le code
- Vérifier la licence de chaque ressource réutilisée et la créditer
### Idées d'activités
- Partir d'un même contenu et produire trois versions : une affiche imprimable, une page web légère, un diaporama à projeter
- Convertir tout un dossier de documents en PDF en une seule commande
- Défi poids : envoyer un document illustré de 25 Mo en moins de 2 Mo sans perte visible de qualité
- Rendre un PDF scanné accessible avec OCRmyPDF, puis tester avec un lecteur d'écran (Orca)
- Construire un document à partir de ressources sous différentes licences et vérifier si la combinaison est autorisée

View file

@ -1,65 +0,0 @@
## 2.3 Collaborer
**Ce que recouvre la compétence** : travailler à plusieurs pour réaliser un projet, coproduire des documents, des données ou des connaissances, et apprendre ensemble. Thématiques Pix : outils d'édition partagée, suivi des modifications et gestion de versions, droits d'accès, organisation du travail en groupe, production de communs.
### Progression par niveaux (résumé)
- **N1-N2** : modifier un document partagé, laisser un commentaire.
- **N3** : utiliser le suivi des modifications et l'historique des versions, respecter le travail des autres.
- **N4-N5** : organiser un projet de groupe (répartition des tâches, échéances), gérer les droits d'accès d'un espace partagé.
- **N6+** : choisir et mettre en place un environnement collaboratif adapté, gérer les versions et les conflits, coordonner une production à grande échelle.
### Version Linux et libre
**Édition simultanée**
- **CryptPad** : texte, tableur, présentation, kanban, formulaires, tableau blanc, le tout chiffré de bout en bout
- **Etherpad** : texte en temps réel avec une couleur par auteur, très lisible pour voir qui a écrit quoi
- **HedgeDoc** : Markdown collaboratif
- Nextcloud avec **Collabora Online** ou **OnlyOffice** : bureautique complète dans le navigateur
**Travailler hors ligne, à plusieurs**
- LibreOffice : suivi des modifications (accepter/refuser), commentaires, comparaison de deux versions d'un document
**Gestion de versions**
- Historique des versions dans Nextcloud et CryptPad : revenir en arrière
- **Git** : `clone`, `commit`, `pull`, `push`, branches, résolution de conflits
- Forges libres : **Codeberg**, GitLab, Forgejo (auto-hébergeable)
- Tickets (issues) et demandes de fusion : le modèle de collaboration du logiciel libre
**Organisation et suivi de projet**
- Kanban : Nextcloud Deck, Kanboard, Wekan, Vikunja
- Gestion de projet plus poussée : OpenProject, Taiga
- Tableaux blancs : Excalidraw, draw.io, tableau blanc de BigBlueButton
**Bases de connaissances**
- Wikis d'équipe : BookStack, Wiki.js, DokuWiki
**Espaces de travail complets**
- **Nextcloud** : fichiers, agenda, discussions, tâches au même endroit
- Framaspace (Nextcloud pour associations et collectifs)
- apps.education.fr pour les personnels de l'Éducation nationale
- Discussions d'équipe : Matrix/Element, Mattermost
**Droits d'accès**
- Lecture, commentaire, édition, administration : qui peut faire quoi
- Liens publics vs accès nominatif
**Méthodes de travail**
- Définir des rôles, des conventions de nommage, un calendrier
- Décider ensemble des règles (gouvernance), comme dans les projets libres
### Idées d'activités
- Rédaction à plusieurs sur Etherpad, puis analyse des couleurs : la contribution est-elle équilibrée ?
- Relecture croisée d'un texte dans LibreOffice avec suivi des modifications
- Gérer un projet de groupe de bout en bout avec un tableau Deck ou Kanboard
- Premier pas avec Git sur Codeberg : chacun modifie un fichier, on provoque puis on résout un conflit
- Observer un vrai projet libre (tickets, discussions, contributions) pour comprendre comment des milliers de personnes collaborent sans se connaître

View file

@ -1,79 +0,0 @@
## 5.2 Construire un environnement numérique
**Ce que recouvre la compétence** : installer, configurer et enrichir un environnement (matériel, système, logiciels, services) adapté à ses activités, à son contexte et à ses valeurs. C'est la compétence où le choix de Linux et du libre devient lui-même l'objet d'apprentissage. Thématiques Pix : composants matériels, systèmes d'exploitation, installation de logiciels, configuration et personnalisation, périphériques et réseau, choix de services.
### Progression par niveaux (résumé)
- **N1-N2** : allumer et prendre en main un appareil, connecter un périphérique, personnaliser le fond d'écran ou la langue.
- **N3** : installer et désinstaller une application, connecter un appareil au réseau, choisir ses applications par défaut.
- **N4-N5** : configurer un système (comptes, partage, périphériques), choisir des logiciels et services selon des critères explicites.
- **N6+** : installer un système d'exploitation, concevoir un environnement complet pour un usage ou un groupe, auto-héberger des services.
### Version Linux et libre
**Comprendre les couches**
- Matériel (processeur, mémoire, stockage, carte graphique), micrologiciel UEFI
- Noyau Linux, pilotes, système GNU, environnement de bureau, applications
- Une même base, de nombreuses combinaisons : c'est ce qui rend les choix visibles et compréhensibles
**Choisir sa distribution et son bureau**
- Pour débuter : **Linux Mint**, Ubuntu, Zorin OS
- Stables et communautaires : **Debian**, Fedora, openSUSE
- Pour apprendre en profondeur : Arch Linux
- Contextes particuliers : **PrimTux** (écoles primaires, projet français), Emmabuntüs (réemploi)
- Environnements de bureau : GNOME, KDE Plasma, Xfce, Cinnamon, MATE, LXQt (du plus riche au plus léger)
**Installer le système**
- Tester sans rien modifier grâce au mode live
- Créer une clé d'installation : Impression d'image disque (GNOME), balenaEtcher, Ventoy
- Choix d'installation : remplacer l'ancien système ou cohabiter (double démarrage), partitionnement, chiffrement LUKS (lien 4.1), Secure Boot
- S'entraîner d'abord en machine virtuelle avec GNOME Boxes
**Installer des logiciels**
- Gestionnaire de paquets : `apt`, `dnf`, `pacman`
- Logithèques graphiques : Logiciels (GNOME), Discover (KDE)
- **Flatpak et Flathub**, Snap, AppImage : comprendre leurs différences, avantages et limites
- Règle d'or : privilégier les sources officielles plutôt que des fichiers téléchargés au hasard
**Configurer et personnaliser**
- Comptes utilisateurs et groupes, droits d'administration
- Langue, disposition du clavier, raccourcis, applications par défaut, lancement au démarrage
- Extensions GNOME, widgets KDE, thèmes
- Les réglages sont stockés dans `~/.config` : sauvegarder et transporter son environnement (_dotfiles_)
**Périphériques et réseau**
- Imprimantes et scanners (lien 5.1)
- Partage de dossiers en réseau local avec Samba
- **KDE Connect** ou GSConnect (GNOME) : relier son téléphone à son ordinateur (fichiers, notifications, presse-papiers)
**Choisir ses services selon ses valeurs**
- Hébergeurs du collectif CHATONS, Framaspace, Nextcloud (lien 1.2 et 2.3)
- Téléphone : F-Droid, /e/OS (lien 4.2)
- Critères à expliciter : liberté du logiciel, formats ouverts, vie privée, localisation des données, sobriété, coût
**Auto-héberger**
- **YunoHost** (projet français) : installer Nextcloud, FreshRSS, Wallabag et d'autres en quelques clics sur un serveur ou un Raspberry Pi
- Pour aller plus loin : conteneurs avec Podman ou Docker
**Penser l'environnement comme un tout**
- Mises à jour, sauvegardes, sécurité : un plan de maintenance (liens 1.2, 4.1, 5.1)
- Interopérabilité avec les utilisateurs d'autres systèmes : formats ouverts, services web
- Exemple de déploiement à grande échelle : la Gendarmerie nationale et ses dizaines de milliers de postes sous GendBuntu
### Idées d'activités
- Tester trois distributions en machine virtuelle et justifier son choix selon un profil d'utilisateur donné
- Installer Linux sur un vrai ordinateur, de la création de la clé à la configuration finale
- Concevoir un environnement « clé en main » pour un public précis (élève, association, personne âgée) et le documenter
- Monter un petit serveur YunoHost sur un Raspberry Pi avec deux ou trois services utiles au groupe
- Relier son téléphone à son PC avec KDE Connect
- Rédiger une charte de choix numériques pour une classe ou une association, argumentée par des valeurs

View file

@ -1,81 +0,0 @@
## 3.2 Développer des documents multimédia
**Ce que recouvre la compétence** : créer ses propres productions mêlant image, son, vidéo ou animation, enrichir un document textuel, ou réaliser une œuvre transformative (remix, détournement). Thématiques Pix : capture et édition d'images, de sons et de vidéos, image matricielle et vectorielle, formats et codecs, montage, droit d'auteur et droit à l'image.
### Progression par niveaux (résumé)
- **N1-N2** : faire une capture d'écran, recadrer une photo, enregistrer un son.
- **N3** : retoucher une image, couper et assembler des séquences audio ou vidéo, distinguer image matricielle et vectorielle.
- **N4-N5** : réaliser un montage complet (titres, transitions, musique, sous-titres), travailler avec des calques, choisir formats et réglages d'export.
- **N6+** : mener une production multimédia de bout en bout, créer des animations, réaliser des remix en respectant les licences.
### Version Linux et libre
**Notions de base à faire comprendre**
- Pixels (matriciel) vs formes mathématiques (vectoriel) : effet d'un agrandissement
- Calques, résolution, profondeur de couleur
- Conteneur (MKV, WebM, MP4) vs codec (AV1, VP9, H.264 pour la vidéo ; Opus, AAC pour le son)
- Débit, images par seconde, fréquence d'échantillonnage
**Captures**
- Captures d'écran : outil intégré de GNOME (touche Impr. écran), Spectacle (KDE), **Flameshot** pour annoter
- Enregistrement d'écran : outil intégré de GNOME, Kooha, **OBS Studio** pour des tutoriels plus élaborés
**Image matricielle**
- **GIMP** : retouche, calques, masques
- **Krita** : dessin et peinture numérique
- Pinta : simple, pour débuter
- darktable ou RawTherapee : développement de photos RAW
**Image vectorielle et schémas**
- **Inkscape** : logos, affiches, illustrations, format SVG
- draw.io, Dia : schémas et organigrammes
**Son**
- **Audacity** : enregistrement, découpe, réduction de bruit, effets (idéal pour un podcast)
- Ardour : enregistrement multipiste
- LMMS : composition, MuseScore : partitions
**Vidéo**
- **Kdenlive** : montage complet, le plus abouti
- Shotcut, OpenShot : plus simples pour démarrer
- Sous-titres : Aegisub, Gaupol ; transcription automatique hors ligne avec des outils basés sur Whisper (par exemple Speech Note)
**Animation et 3D**
- Pencil2D : animation 2D image par image, accessible aux débutants
- Synfig Studio : animation 2D vectorielle
- **Blender** : 3D, animation, et même montage vidéo
- Sweet Home 3D : aménagement intérieur
**Installation sous Linux**
- **Flathub** pour obtenir les versions récentes de ces logiciels
- Codecs : certaines distributions demandent d'installer à part les codecs non libres (paquet « restricted extras » sur Ubuntu, par exemple)
**Ressources libres pour enrichir et remixer**
- **Wikimedia Commons**, **Openverse** (moteur de recherche de médias sous Creative Commons)
- **Freesound** pour les sons, ccMixter et Free Music Archive pour la musique
- Toujours vérifier la licence : une ressource en ND (pas de modification) ne peut pas être remixée
**Droits**
- Droit à l'image : autorisation des personnes filmées ou photographiées
- Droit d'auteur, courte citation, exception pédagogique
- Créditer les ressources utilisées dans le générique
### Idées d'activités
- Comparer l'agrandissement d'un logo en PNG dans GIMP et en SVG dans Inkscape
- Réaliser un podcast de 3 minutes avec Audacity, avec un générique musical sous licence libre
- Tourner et monter une courte vidéo dans Kdenlive, sous-titres et crédits compris
- Enregistrer un tutoriel vidéo avec OBS pour expliquer une manipulation sous Linux
- Créer un remix à partir de ressources trouvées sur Openverse, en documentant chaque licence
- Animation image par image avec Pencil2D

View file

@ -1,73 +0,0 @@
## 3.1 Développer des documents textuels
**Ce que recouvre la compétence** : produire des documents principalement textuels pour communiquer des idées, rendre compte d'un travail ou le valoriser (traitement de texte, présentation, page web, carte mentale). Thématiques Pix : structuration et séparation fond/forme, mise en page, intégration d'illustrations, formats et diffusion, accessibilité, droit d'auteur.
### Progression par niveaux (résumé)
- **N1-N2** : saisir et mettre en forme un texte simple (gras, taille, alignement), insérer une image.
- **N3** : structurer un document avec des titres, insérer tableaux et listes, exporter en PDF.
- **N4-N5** : utiliser les **styles**, générer une table des matières, gérer en-têtes, pieds de page et notes, créer un modèle.
- **N6+** : séparer complètement fond et forme, automatiser (publipostage, conversion), produire des documents accessibles et interopérables.
### Version Linux et libre
**Traitement de texte : LibreOffice Writer**
- **Styles** de paragraphe, de caractère, de page : le cœur de la compétence
- Numérotation automatique des titres, table des matières, index, notes de bas de page
- Ancrage et habillage des images, tableaux, sections en colonnes
- Modèles (`.ott`), publipostage
- Export PDF, PDF/A pour l'archivage, PDF balisé pour l'accessibilité
- **Vérificateur d'accessibilité** intégré
**Correction de la langue**
- **Grammalecte** : correcteur grammatical français libre, pour LibreOffice et Firefox
**Présentations**
- LibreOffice Impress : masques de diapositives, mode présentateur, export PDF
**Écrire en Markdown**
- Éditeurs : Apostrophe (GNOME), Ghostwriter (KDE), Zettlr, ou simplement Kate / Éditeur de texte
- **Pandoc** : convertir un même texte en ODT, DOCX, PDF, HTML ou EPUB, démonstration parfaite de la séparation fond/forme
**Composition avancée**
- LaTeX avec TeXstudio, pour les documents scientifiques
- **Typst** : alternative récente, libre, plus simple à apprendre
- Scribus pour la mise en page de type affiche, journal ou brochure
**Cartes mentales et conceptuelles**
- Freeplane, VYM, Heimer
**Pages web et livres numériques**
- HTML et CSS avec un simple éditeur de texte et le navigateur
- Sigil pour créer un EPUB, Calibre pour le convertir et le gérer
**Formats et interopérabilité**
- ODF (`.odt`) : format ouvert, normalisé ISO, recommandé par le Référentiel général d'interopérabilité de l'administration
- Échanges avec des utilisateurs de Word : polices aux métriques compatibles (Carlito pour Calibri, Caladea pour Cambria) pour éviter les décalages de mise en page
**Typographie et polices libres**
- Liberation, DejaVu, Noto
- **Luciole** : police libre conçue pour les personnes malvoyantes
- Installer une police dans `~/.local/share/fonts`
**Accessibilité**
- Titres structurés par styles (et non par mise en forme manuelle)
- Texte alternatif pour les images, contrastes suffisants, écriture FALC (Facile à lire et à comprendre)
### Idées d'activités
- Partir d'un document mis en forme « à la main » et le refaire entièrement avec les styles, puis changer tout son aspect en modifiant un seul style
- Rédiger un compte rendu en Markdown, puis le convertir avec Pandoc en ODT, PDF et page web
- Faire passer le vérificateur d'accessibilité sur un document et corriger toutes les alertes
- Échanger un fichier ODT et DOCX avec un utilisateur de Word et analyser ce qui change
- Créer un modèle de lettre réutilisable avec publipostage à partir d'un fichier Calc

View file

@ -1,75 +0,0 @@
## 1.2 Gérer des données
**Ce que recouvre la compétence** : stocker et organiser ses fichiers pour les retrouver, les conserver et y accéder facilement, en local comme en ligne. Les thématiques Pix : fichiers et dossiers, stockage et compression, transfert et synchronisation, recherche et métadonnées, sauvegarde.
### Progression par niveaux (résumé)
- **N1-N2** : enregistrer un fichier, le retrouver, le nommer et le ranger dans un dossier.
- **N3** : construire une arborescence cohérente, utiliser un espace de stockage en ligne, compresser/décompresser.
- **N4-N5** : synchroniser plusieurs appareils, mettre en place des sauvegardes, choisir un format adapté, exploiter les métadonnées.
- **N6+** : définir une stratégie de stockage et de sauvegarde pour un groupe, gérer les droits d'accès.
### Version Linux et libre
**Comprendre l'arborescence**
- Une seule racine `/`, le dossier personnel `/home/utilisateur`, les supports amovibles dans `/media`
- Chemins absolus et relatifs, fichiers cachés (commençant par un point)
- La casse compte : `Rapport.odt` ≠ `rapport.odt`
- Le type d'un fichier ne dépend pas de son extension : la commande `file` le révèle
**Gestionnaires de fichiers**
- Graphiques : Fichiers (GNOME), Dolphin (KDE), Thunar (XFCE), Nemo
- Terminal : `ls`, `cd`, `mkdir`, `cp`, `mv`, `rm`, `tree` ; Midnight Commander (`mc`) en intermédiaire
- Bonnes pratiques de nommage : dates au format `AAAA-MM-JJ`, pas d'espaces ni d'accents si les fichiers circulent
**Retrouver ses fichiers**
- `find`, `locate`, `grep -r` pour chercher dans le contenu
- Recherche intégrée au bureau : Tracker/LocalSearch (GNOME), Baloo (KDE)
- Doublons : Czkawka (graphique), `fdupes`
**Métadonnées**
- Étiquettes dans Dolphin, gestion de photothèque avec digiKam
- Lire : `exiftool` ; nettoyer avant partage : **mat2** (lien direct avec la compétence 4.2 sur la vie privée)
**Compression et archives**
- `tar`, `gzip`, `xz`, `zip`, `7z`
- Graphiques : Archives (File Roller), Ark
**Supports et systèmes de fichiers**
- Voir l'espace : `df -h`, `du`, `ncdu`, `lsblk`
- GNOME Disques, GParted pour formater
- Choisir le bon format : ext4 pour Linux, exFAT pour une clé partagée avec Windows/macOS
**Stockage en ligne et synchronisation**
- **Nextcloud** (auto-hébergé ou chez un CHATON), Seafile
- **Syncthing** : synchronisation pair à pair, sans serveur central
- `rsync` en ligne de commande
- Transfert ponctuel : LocalSend (réseau local), Lufi (partage chiffré temporaire, Framasoft), `scp`/`sftp`, FileZilla
**Sauvegarde**
- Règle 3-2-1 : 3 copies, 2 supports différents, 1 hors site
- Déjà Dup (simple, intégré à GNOME), Back In Time, BorgBackup avec son interface Vorta, restic
- Timeshift pour des instantanés du système (à distinguer de la sauvegarde des données personnelles)
**Droits et partage**
- `ls -l`, `chmod`, `chown` : lire et modifier les permissions, comprendre propriétaire/groupe/autres
**Formats ouverts** (pour la conservation à long terme)
- ODF (LibreOffice), CSV, Markdown, PNG, FLAC, PDF/A
### Idées d'activités
- Ranger un dossier « fourre-tout » en arborescence logique, d'abord graphiquement puis en ligne de commande
- Mettre en place une synchronisation Syncthing entre un PC et un téléphone
- Retirer les métadonnées GPS d'une photo avec mat2 et vérifier avec exiftool
- Simuler une panne : sauvegarder avec Déjà Dup, supprimer un fichier, le restaurer

View file

@ -1,55 +0,0 @@
## 2.1 Interagir
**Ce que recouvre la compétence** : échanger avec des personnes ou de petits groupes, de façon ponctuelle ou régulière, dans un cadre privé ou professionnel, par courriel, messagerie instantanée ou visioconférence. Thématiques Pix : protocoles et services de communication, usages adaptés au contexte, savoir-vivre en ligne (nétiquette), confidentialité, prévention du cyberharcèlement.
### Progression par niveaux (résumé)
- **N1-N2** : envoyer et recevoir un message, répondre, joindre un fichier.
- **N3** : choisir l'outil adapté à la situation, utiliser À / Cc / Cci à bon escient, adopter un ton approprié.
- **N4-N5** : organiser des échanges de groupe, animer une visioconférence, gérer plusieurs comptes et identités.
- **N6+** : comprendre les protocoles et le chiffrement, choisir des services selon des critères de confidentialité, réagir face à des comportements inappropriés.
### Version Linux et libre
**Courriel**
- **Thunderbird** (avec chiffrement OpenPGP intégré), Evolution, KMail, Geary
- En terminal : NeoMutt, aerc
- Webmails libres : Roundcube, SnappyMail
- Notions à faire comprendre : IMAP vs POP, SMTP, Cci pour protéger les adresses d'un groupe, taille des pièces jointes
- Fournisseurs soucieux de la vie privée : Disroot, Posteo, mailbox.org, Tuta et Proton (applications open source)
**Messagerie instantanée**
- **Matrix** avec le client Element : décentralisé, fédéré, chiffré de bout en bout
- **XMPP** : Gajim, Dino (bureau), Conversations (Android), Movim (web)
- Signal : application libre et chiffrée, mais serveur centralisé
- Delta Chat : messagerie instantanée qui s'appuie sur le courriel
- IRC (HexChat, WeeChat) pour découvrir l'historique des communautés libres
- Notion clé à travailler : centralisé, fédéré, pair à pair
**Visioconférence et audio**
- **Jitsi Meet** : sans compte, dans le navigateur
- **BigBlueButton** : classes virtuelles (proposé sur apps.education.fr pour les personnels de l'Éducation nationale)
- Nextcloud Talk, Mumble pour l'audio de groupe
- Côté Linux : tester webcam et micro (Snapshot, `pavucontrol`), comprendre le partage d'écran sous Wayland
**Planifier les échanges**
- Framadate pour trouver une date commune
- Agendas partagés via CalDAV : Nextcloud, agenda de Thunderbird
**Savoir-vivre et sécurité**
- Nétiquette : objet clair, pas de « répondre à tous » inutile, majuscules perçues comme des cris
- Cyberharcèlement : repérer, conserver des preuves, signaler (numéro 3018 pour les jeunes)
- Hameçonnage : vérifier l'expéditeur réel (lien avec le domaine 4)
### Idées d'activités
- Configurer un compte dans Thunderbird en IMAP, puis envoyer un message à un groupe en Cci
- Créer un salon Matrix pour la classe ou le groupe, et comparer avec un groupe WhatsApp (qui détient les données, qui peut lire)
- Organiser une réunion : sondage Framadate, puis séance sur Jitsi ou BigBlueButton avec partage d'écran
- Échanger un message chiffré OpenPGP entre deux participants dans Thunderbird
- Analyser des cas de messages problématiques (ton, destinataires, harcèlement) et proposer une réaction adaptée

View file

@ -1,66 +0,0 @@
## 1.1 Mener une recherche et une veille d'information
**Ce que recouvre la compétence** : trouver une information pour répondre à un besoin (moteur de recherche, sites, bases documentaires), évaluer sa fiabilité, et se tenir au courant d'un sujet dans la durée (abonnements, flux, réseaux).
Pix la découpe en grandes thématiques : navigation web, moteurs de recherche, évaluation de l'information, source et citation, veille et curation, filtrage/personnalisation (bulles de filtre), gouvernance et ouverture du web.
### Progression par niveaux (résumé)
- **N1-N2** : faire une recherche simple, reformuler ses mots-clés, repérer l'auteur et la date d'une page.
- **N3** : utiliser les fonctions avancées des moteurs, croiser les sources, distinguer information, opinion et publicité.
- **N4-N5** : construire une stratégie de recherche, mettre en place une veille outillée (flux, alertes).
- **N6+** : organiser, trier et partager une veille (curation), comprendre les mécanismes des algorithmes de recommandation.
### Version Linux et libre
**Navigation**
- Firefox (ou LibreWolf, sa variante orientée vie privée), Chromium
- Extensions : uBlock Origin (bloqueur), Privacy Badger
- En terminal : `lynx` ou `w3m` pour naviguer en texte, `curl`/`wget` pour récupérer une page
**Moteurs de recherche**
- **SearXNG** : métamoteur libre, auto-hébergeable, sans pistage (instances publiques disponibles)
- Alternatives respectueuses mais non libres : DuckDuckGo, Qwant, Mojeek, Startpage
- Bases ouvertes : Wikipédia, Wikidata, OpenStreetMap, Internet Archive, HAL (archive ouverte de la recherche française)
- Opérateurs à maîtriser : `"expression exacte"`, `-exclure`, `site:debian.org`, `filetype:pdf`, `OR`
**Chercher dans la documentation Linux** (spécifique et très formateur)
- `man`, `apropos`, `--help`, `tldr`
- Wikis communautaires : doc.ubuntu-fr.org, wiki Arch Linux, wiki Debian
- Forums et suivis de bugs comme sources de solutions (et leur fiabilité variable)
**Veille par flux RSS/Atom**
- Lecteurs locaux : Thunderbird, Liferea, Akregator (KDE), NewsFlash (GNOME), Newsboat (terminal)
- Auto-hébergés : **FreshRSS** (projet français), Miniflux, Tiny Tiny RSS
- Surveillance de pages sans flux : changedetection.io
- Réseaux décentralisés : Mastodon (fédivers), Lemmy, PeerTube, avec abonnement par hashtags
**Curation et conservation**
- **Wallabag** (lire plus tard, français), **Shaarli** (partage de liens, français), Linkding
- **Zotero** : collecte de références et génération de citations, idéal pour le volet « source et citation »
- **Joplin** (libre, AGPL) : notes Markdown, Web Clipper pour Firefox (page entière, sélection ou URL avec sa source), synchronisation Nextcloud/WebDAV chiffrée de bout en bout
- **Obsidian** : gratuit mais **pas libre** ; stocke tout en fichiers Markdown ordinaires, donc les données restent dans un format ouvert. Bon support pour distinguer _logiciel libre_ et _format ouvert_. Web Clipper pour Firefox, synchronisation possible avec Syncthing
- Alternatives 100 % libres à Obsidian (notes liées, graphe) : **Logseq** (AGPL), **Zettlr** (GPL, intégré à Zotero), **Trilium Notes** (auto-hébergeable)
- Côté pédagogie : ces outils couvrent les niveaux 5 et plus (organiser sa veille avec étiquettes et liens entre notes, garder la trace des sources)
**Évaluer l'information**
- Wayback Machine pour vérifier l'historique d'une page
- `whois` et `dig` pour savoir qui est derrière un domaine
- Métadonnées d'images : `exiftool`
**Droit et ouverture du web**
- Licences Creative Commons, GPL, et Wikimedia Commons pour des ressources réutilisables
- Repères militants et pédagogiques : Framasoft (et le collectif CHATONS d'hébergeurs alternatifs), La Quadrature du Net, l'April
### Idées d'activités
- Comparer les résultats d'une même requête sur SearXNG, DuckDuckGo et Google pour illustrer la bulle de filtre
- Résoudre un problème Linux réel uniquement avec `man` et le wiki ubuntu-fr
- Monter une veille sur un sujet avec FreshRSS ou Newsboat, puis en publier une sélection via Shaarli

View file

@ -1,63 +0,0 @@
## 2.2 Partager et publier
**Ce que recouvre la compétence** : diffuser ses productions ou ses opinions et relayer celles des autres dans un espace public (réseaux sociaux, blogs, forums, plateformes de partage). Thématiques Pix : règles de visibilité, identité numérique et e-réputation, droit d'auteur et licences, liberté d'expression et ses limites, écriture pour le web, participation citoyenne.
### Progression par niveaux (résumé)
- **N1-N2** : partager un fichier ou un lien, publier un message simple.
- **N3** : régler la visibilité d'une publication (public, restreint, privé), respecter le droit à l'image et le droit d'auteur.
- **N4-N5** : publier sur un blog ou un site, choisir une licence pour ses productions, maîtriser son identité numérique.
- **N6+** : animer un espace de publication, comprendre les mécanismes de diffusion et d'influence, contribuer à des communs.
### Version Linux et libre
**Le fédivers** (réseaux sociaux décentralisés, notion centrale à faire comprendre)
- **Mastodon** : microblog, avec visibilité réglable (publique, non listée, abonnés, mention privée)
- **PeerTube** (vidéo, développé par Framasoft), **Pixelfed** (photo), **Lemmy** (forums thématiques), Funkwhale (audio)
- **WriteFreely** : blog minimaliste qui se suit depuis Mastodon
- Principe clé : choisir son instance, ses règles de modération, pouvoir déménager son compte
**Blogs et sites**
- **WordPress** (libre), Dotclear, PluXml (français, sans base de données)
- Sites statiques : Hugo, Jekyll, Zola, hébergés gratuitement via Codeberg Pages ou GitLab Pages
- Wikis : DokuWiki, MediaWiki
- Forums : Discourse, Flarum
**Partage de fichiers et de contenus**
- Liens de partage **Nextcloud** avec mot de passe et date d'expiration
- **CryptPad** : documents partagés chiffrés de bout en bout
- PrivateBin pour partager un texte de façon chiffrée et éphémère, Lufi pour les fichiers
**Contribuer aux communs** (participation citoyenne)
- Wikipédia, Wikimedia Commons, OpenStreetMap
- Signaler un bug ou traduire un logiciel libre
**Droit et licences**
- Droit d'auteur et droit à l'image : ce qu'on peut publier, ce qu'il faut demander
- Licences **Creative Commons** (BY, SA, NC, ND) : comprendre et choisir celle de sa propre production
- Citer correctement ce qu'on relaie
- Limites de la liberté d'expression : diffamation, injure, incitation à la haine
**Identité numérique et e-réputation**
- Faire sa « recherche de soi-même » sur plusieurs moteurs (lien avec 1.1)
- Droit au déréférencement et droit à l'effacement (RGPD, CNIL)
- Séparer identités personnelle et professionnelle
**Écrire pour le web**
- Markdown, titres clairs, liens explicites
- Accessibilité : texte alternatif pour les images (pratique très ancrée sur Mastodon), hashtags en `#CamelCase` pour les lecteurs d'écran
### Idées d'activités
- Créer un compte Mastodon, régler la visibilité de trois publications différentes et comparer qui peut les voir
- Publier un mini-site avec Hugo sur Codeberg Pages, sous licence Creative Commons choisie et justifiée
- Ajouter une photo personnelle à Wikimedia Commons ou corriger une rue dans OpenStreetMap
- Audit d'identité numérique : chercher son nom, repérer ce qui est public, faire le ménage
- Comparer les conditions d'utilisation d'Instagram et d'une instance Pixelfed : à qui appartiennent les contenus publiés ?

View file

@ -1,74 +0,0 @@
## 3.4 Programmer
**Ce que recouvre la compétence** : écrire des programmes et des algorithmes pour répondre à un besoin (automatiser une tâche répétitive, résoudre un problème, traiter un volume important) ou pour créer un contenu riche comme un jeu ou un site. Thématiques Pix : algorithmique (séquences, boucles, conditions, variables, fonctions), langages, automatisation, débogage, programmation web.
### Progression par niveaux (résumé)
- **N1-N2** : lire et comprendre un algorithme simple, programmer des séquences d'instructions par blocs.
- **N3** : utiliser boucles, conditions et variables, corriger un programme qui ne fonctionne pas.
- **N4-N5** : passer à un langage textuel, structurer avec des fonctions, automatiser une tâche réelle.
- **N6+** : concevoir un programme complet, gérer les erreurs, réutiliser des bibliothèques, planifier l'exécution automatique de tâches.
### Version Linux et libre
**Programmation par blocs**
- **Snap!** : libre, dans le navigateur, plus puissant que Scratch
- **TurboWarp** : version libre et rapide compatible Scratch, avec application de bureau Linux
- Blockly Games : progression ludique vers la logique de programmation
**Python, le passage naturel au code textuel**
- **Thonny** : conçu pour débuter, avec exécution pas à pas pour visualiser les variables
- **Basthon** : Python et notebooks dans le navigateur, pensé pour l'enseignement en France
- JupyterLab pour mêler code, texte et graphiques
- Module `turtle` pour dessiner, Pyxel ou Pygame pour créer des jeux
**Automatiser sous Linux** (l'atout majeur de l'environnement)
- Scripts **Bash** : boucles sur des fichiers, renommage par lots, sauvegardes
- Exemple parlant : `for f in *.jpg; do magick "$f" -resize 800x "petit-$f"; done`
- Planifier des tâches : **cron** ou les minuteurs systemd, ce qui répond directement à la mention des « logiciels de planification de tâches » dans le référentiel
- Alias et petits scripts dans `~/bin` pour se créer ses propres commandes
- Macros LibreOffice en Basic ou en Python
**Éditeurs et environnements**
- Geany, Kate : simples et légers
- **VSCodium** : version libre de VS Code, sans télémétrie
- nano pour débuter en terminal, Vim ou Emacs pour aller loin
**Web**
- HTML, CSS, JavaScript avec un éditeur et Firefox
- Outils de développement de Firefox (F12) : inspecter, modifier une page en direct, lire les erreurs
- **p5.js** : programmation créative et visuelle
**Jeux**
- **Godot** : moteur de jeu libre complet, 2D et 3D
- GDevelop : création de jeux sans coder ou presque
**Robotique et électronique**
- **Raspberry Pi** : ordinateur sous Linux pour piloter capteurs et moteurs
- Arduino IDE, MicroPython, micro:bit
- Thymio : petit robot éducatif avec environnement libre
**La culture du libre**
- Lire le code source d'un logiciel qu'on utilise
- Versionner son travail avec Git et le publier sur Codeberg (lien 2.3)
**Débogage**
- Lire un message d'erreur, afficher des valeurs intermédiaires, exécuter pas à pas, tester avec des cas limites
### Idées d'activités
- Débuter avec Snap!, puis réécrire le même programme en Python dans Thonny
- Écrire un script Bash qui trie un dossier de téléchargements par type de fichier, puis le planifier chaque soir avec cron
- Programmer un petit jeu avec Pyxel ou Godot
- Modifier une page web en direct avec les outils de développement de Firefox, puis créer la sienne
- Piloter une LED ou un capteur avec un Raspberry Pi
- Modifier un petit logiciel libre existant (changer un texte, une couleur) pour comprendre ce que signifie avoir accès au code

View file

@ -1,57 +0,0 @@
## 4.3 Protéger la santé, le bien-être et l'environnement
**Ce que recouvre la compétence** : prévenir les effets négatifs du numérique sur la santé physique et psychique et sur l'environnement, mais aussi tirer parti du numérique pour le bien-être, l'inclusion et l'accessibilité. Thématiques Pix : ergonomie et santé physique, sommeil et attention, dépendance et harcèlement, impact environnemental, accessibilité.
### Progression par niveaux (résumé)
- **N1-N2** : adopter une bonne posture, faire des pauses, limiter les écrans le soir.
- **N3** : régler son poste pour son confort, gérer ses notifications, connaître les gestes de base pour l'environnement (recyclage).
- **N4-N5** : maîtriser son temps d'écran, utiliser les outils d'accessibilité, comprendre que l'essentiel de l'impact environnemental vient de la fabrication des appareils.
- **N6+** : adopter une démarche de sobriété numérique argumentée, concevoir des contenus accessibles et peu gourmands, accompagner les autres.
### Version Linux et libre
**Santé physique et ergonomie**
- Éclairage nocturne intégré à GNOME et KDE (réduction de la lumière bleue le soir)
- Rappels de pause : **Safe Eyes**, Workrave, Stretchly ; règle 20-20-20 pour les yeux
- Raccourcis clavier pour limiter l'usage de la souris et les troubles musculo-squelettiques
- Réglages de la taille du texte, du zoom, de la vitesse du pointeur
**Attention et bien-être psychique**
- Mode « Ne pas déranger » et réglage fin des notifications
- Les versions récentes de GNOME intègrent un suivi du temps d'écran, des limites et des rappels de pause
- **LeechBlock NG** (Firefox) : bloquer les sites chronophages à certaines heures
- **FreeTube** (bureau) et NewPipe (Android) : regarder des vidéos sans recommandations algorithmiques ni publicité
- Fils chronologiques sans algorithme (Mastodon) vs fils conçus pour retenir l'attention
- Contrôle parental : Malcontent (GNOME), **CTparental** (libre, français)
- Cyberharcèlement et mal-être : 3018, Fil Santé Jeunes (lien 2.1)
**Impact environnemental**
- Ordre de grandeur essentiel : la fabrication des appareils pèse bien plus que leur usage, d'où l'enjeu de les garder longtemps
- **Linux pour prolonger la vie du matériel** : distributions légères (Xubuntu, Lubuntu, Linux Mint XFCE, antiX), Emmabuntüs pour le réemploi, campagne _End of 10_
- Réparabilité : indice de réparabilité/durabilité, appareils reconditionnés, recyclage des équipements électriques (DEEE)
- Consommation : TLP et les profils d'énergie pour l'autonomie des portables, `powertop` pour repérer ce qui consomme
- Mesurer l'empreinte d'une page web : extension **GreenIT-Analysis**, EcoIndex (outils libres français)
- Sobriété des usages : résolution vidéo adaptée, téléchargement plutôt que streaming répété, en gardant le sens des proportions (trier ses courriels a un effet très faible comparé au fait de garder son ordinateur deux ans de plus)
- Référentiel général d'écoconception de services numériques (RGESN)
**Accessibilité et inclusion**
- **Orca** : lecteur d'écran
- Loupe, contraste élevé, grands caractères, curseur agrandi dans les paramètres d'accessibilité
- Clavier visuel (Onboard), Dasher pour écrire sans clavier
- Synthèse vocale : espeak-ng, Piper (voix plus naturelles)
- Dictée vocale hors ligne avec des outils basés sur Whisper (Speech Note)
- Police Luciole, écriture FALC, documents accessibles (lien 3.1)
- RGAA : référentiel d'accessibilité des services publics en ligne
### Idées d'activités
- Installer une distribution légère sur un vieil ordinateur et comparer son usage avant et après
- Mesurer avec GreenIT-Analysis plusieurs sites d'information et classer leur sobriété
- Tenir pendant une semaine un journal de son temps d'écran, puis mettre en place une règle avec LeechBlock ou les outils de GNOME
- Utiliser l'ordinateur pendant 15 minutes uniquement avec Orca, écran éteint, pour comprendre les enjeux de l'accessibilité
- Calculer l'empreinte de son équipement avec le simulateur Impact CO2 de l'ADEME et discuter des leviers réels

View file

@ -1,75 +0,0 @@
## 4.2 Protéger les données personnelles et la vie privée
**Ce que recouvre la compétence** : maîtriser ses traces numériques, gérer ses données personnelles et respecter celles des autres, en adoptant des pratiques éclairées. Là où la 4.1 protège contre les attaques, la 4.2 protège contre la collecte et l'exploitation des données, souvent parfaitement légales. Thématiques Pix : données personnelles et sensibles, traces (cookies, historique, métadonnées, géolocalisation), pistage et profilage, paramètres de confidentialité, RGPD, respect de la vie privée d'autrui.
### Progression par niveaux (résumé)
- **N1-N2** : savoir ce qu'est une donnée personnelle, ne pas diffuser d'informations sur les autres sans accord.
- **N3** : effacer son historique, régler les paramètres de confidentialité d'un service, comprendre les cookies.
- **N4-N5** : limiter le pistage, contrôler ses traces (métadonnées, géolocalisation), exercer ses droits RGPD.
- **N6+** : comprendre le profilage et l'économie des données, choisir des services selon leurs pratiques, conseiller les autres.
### Version Linux et libre
**Comprendre les traces**
- Cookies, pixels espions, empreinte du navigateur (_fingerprinting_)
- **CookieViz** : outil libre de la CNIL qui montre en direct les échanges avec les pisteurs pendant la navigation
- Firefox : page `about:protections` qui récapitule les pisteurs bloqués
- Navigation privée : ce qu'elle efface localement, et ce qu'elle ne cache pas (fournisseur d'accès, sites visités)
**Navigateur protecteur**
- Firefox en protection renforcée (mode strict)
- **Conteneurs** (Firefox Multi-Account Containers) : isoler ses comptes les uns des autres
- uBlock Origin, Privacy Badger
- LibreWolf, Mullvad Browser, Tor Browser selon le niveau de protection voulu
- Moteurs de recherche sans profilage (lien 1.1)
**Les traces sur son propre poste**
- Paramètres de confidentialité de GNOME ou KDE : localisation, historique des fichiers récents, accès caméra et micro
- Historique du terminal (`~/.bash_history`)
- Télémétrie : la plupart des distributions n'en ont pas ou la proposent en option, un point de comparaison intéressant avec les systèmes commerciaux
**Métadonnées**
- Coordonnées GPS dans les photos, auteur dans les documents
- `exiftool` pour les voir, **mat2** pour les nettoyer (lien 1.2 et 3.3)
**Téléphone**
- **Exodus Privacy** (association française) : liste les pisteurs présents dans les applications Android
- **F-Droid** : magasin d'applications libres
- Systèmes alternatifs : /e/OS, LineageOS, GrapheneOS
- Revoir les permissions des applications (localisation, contacts, micro)
**Limiter les données transmises**
- Principe de minimisation : ne donner que le nécessaire
- Alias de courriel pour les inscriptions : addy.io, SimpleLogin
- Fermer les comptes inutilisés
- Préférer des services hébergés chez un CHATON ou auto-hébergés
**RGPD et droits**
- Droits d'accès, de rectification, d'effacement, d'opposition, de portabilité
- Modèles de courriers sur le site de la **CNIL**, plainte en cas de refus
- Exporter ses données (par exemple Google Takeout) pour constater ce qui est conservé
- Données sensibles : santé, opinions, religion, orientation sexuelle
**Respecter la vie privée des autres**
- Droit à l'image, ne pas publier d'informations sur un tiers
- Ne pas diffuser de captures de conversations privées
- Applications qui aspirent tout le carnet d'adresses
- Cci pour les envois groupés (lien 2.1)
### Idées d'activités
- Naviguer 10 minutes sur des sites d'actualité avec CookieViz et analyser vers où partent les données
- Passer ses applications Android dans Exodus Privacy et en remplacer une par une alternative de F-Droid
- Exercer réellement son droit d'accès auprès d'un service et analyser la réponse
- Télécharger son export Google ou Facebook et découvrir ce qui est conservé
- Configurer Firefox avec des conteneurs séparés pour les réseaux sociaux, les achats et le reste
- Retirer la localisation de photos avant de les publier

View file

@ -1,91 +0,0 @@
## 5.1 Résoudre des problèmes techniques
**Ce que recouvre la compétence** : diagnostiquer et résoudre des problèmes pour garantir ou rétablir le bon fonctionnement d'un environnement informatique, en utilisant les outils de configuration et de maintenance, et en sachant mobiliser de l'aide. Thématiques Pix : composants matériels et logiciels, diagnostic, maintenance, configuration, réseau, assistance.
### Progression par niveaux (résumé)
- **N1-N2** : redémarrer un appareil ou une application, vérifier les branchements et la connexion.
- **N3** : identifier l'origine probable d'une panne (matériel, logiciel, réseau), consulter une aide en ligne, faire les mises à jour.
- **N4-N5** : diagnostiquer avec les outils du système, installer ou réinstaller un logiciel ou un pilote, décrire précisément un problème pour obtenir de l'aide.
- **N6+** : analyser des journaux système, dépanner un système qui ne démarre plus, récupérer des données, assister d'autres personnes.
### Version Linux et libre
**Une méthode avant les outils**
- Décrire précisément le symptôme, le reproduire
- Noter ce qui a changé récemment (mise à jour, installation, nouveau matériel)
- Isoler la cause, ne modifier qu'une chose à la fois, garder trace de ce qu'on a essayé
- Chercher le message d'erreur exact (lien 1.1)
**Connaître sa machine**
- `inxi -Fxz` : résumé complet du matériel, idéal à coller dans un forum
- `cat /etc/os-release`, `uname -r` : distribution et noyau
- `lspci`, `lsusb`, `lsblk`, `free -h`, `df -h`
- Interfaces graphiques : À propos (GNOME), Centre d'informations (KDE), Hardinfo2
**Programmes et ressources**
- Moniteur système, `htop` ou `btop` : qui consomme le processeur ou la mémoire
- Arrêter un programme bloqué : `kill`, `xkill`
- Interface graphique figée : basculer vers une console avec Ctrl+Alt+F3
**Lire les journaux**
- `journalctl -b -p err` : erreurs depuis le dernier démarrage
- `dmesg` : messages du noyau (matériel, pilotes)
- Application Journaux (GNOME) pour une lecture graphique
**Réseau**
- `ping`, `ip a`, `nmcli`, `mtr` : distinguer un problème de câble, de Wi-Fi, de box ou de DNS
- Pilotes Wi-Fi propriétaires (outil « Pilotes additionnels » sur Ubuntu)
**Logiciels et mises à jour**
- `sudo apt update && sudo apt upgrade`, ou `dnf upgrade`
- Réparer une installation interrompue : `sudo dpkg --configure -a`, `sudo apt --fix-broken install`
- Disque plein : `ncdu`, nettoyage du cache des paquets, `flatpak uninstall --unused`
**Périphériques**
- Imprimantes : CUPS (interface sur `localhost:631`)
- Scanner : Numériseur de documents (Simple Scan), SANE
- Son : `pavucontrol`, `wpctl status` (PipeWire)
- Bluetooth : `bluetoothctl`
- Vérifier la compatibilité d'un matériel avant achat : base linux-hardware.org
**Quand le système ne démarre plus**
- Menu GRUB : démarrer sur un ancien noyau ou en mode de récupération
- **Clé USB live** (Ventoy pour en avoir plusieurs sur une seule clé) pour accéder aux fichiers et réparer
- Boot-Repair pour réparer le chargeur de démarrage
- Timeshift pour revenir à un état antérieur du système
**Matériel et données**
- Santé des disques : GNOME Disques (SMART), `smartctl`
- Test de la mémoire vive : Memtest86+
- **TestDisk** et **PhotoRec** : récupérer des partitions ou des fichiers supprimés
**Applications Windows indispensables**
- Wine et Bottles pour certaines applications
- Machine virtuelle avec GNOME Boxes ou virt-manager
**Demander et donner de l'aide**
- Forums : ubuntu-fr, forums de sa distribution, LinuxFr.org, salons Matrix ou IRC, groupes d'utilisateurs locaux
- Bien poser une question : distribution et version, matériel, message d'erreur exact, ce qui a déjà été tenté
- Prudence avec les commandes copiées sans les comprendre (lien 4.1)
- Assistance à distance : **RustDesk**, SSH
- Signaler un bug au projet concerné
### Idées d'activités
- Pannes simulées : imprimante en pause, Wi-Fi désactivé, DNS mal configuré, disque plein ; chacun diagnostique et documente
- Rédiger une demande d'aide modèle sur un forum à partir d'un problème réel, avec la sortie d'`inxi`
- Récupérer des photos « effacées » d'une clé USB avec PhotoRec
- Démarrer un ordinateur depuis une clé live et sauver des fichiers d'un système qui ne démarre plus
- Lire `journalctl` après avoir débranché un périphérique pour apprendre à repérer l'information utile

View file

@ -1,63 +0,0 @@
## 2.4 S'insérer dans le monde numérique
**Ce que recouvre la compétence** : comprendre les enjeux de sa présence en ligne et choisir ses pratiques pour agir en tant que citoyen, acteur économique et professionnel dans le monde numérique. C'est la compétence la plus « culture générale » du référentiel. Thématiques Pix : identité et présence en ligne, modèles économiques du numérique, démarches administratives, vie professionnelle, participation citoyenne, questions éthiques et sociétales.
### Progression par niveaux (résumé)
- **N1-N2** : réaliser une démarche en ligne simple, savoir que ses actions laissent des traces.
- **N3** : comprendre qu'un service gratuit a un modèle économique, gérer sa présence sur quelques services.
- **N4-N5** : construire une présence en ligne cohérente avec ses objectifs (emploi, engagement), effectuer des démarches administratives complexes.
- **N6+** : analyser les enjeux économiques, politiques et éthiques du numérique, faire des choix argumentés et s'engager.
### Version Linux et libre
**Comprendre les modèles économiques**
- « Si c'est gratuit, c'est vous le produit » : publicité ciblée, revente de données, économie de l'attention
- Freemium, abonnement, achats intégrés
- Le modèle du libre : dons, services, contributions d'entreprises, financements publics
- Les **4 libertés** du logiciel libre : utiliser, étudier, modifier, redistribuer
**Enjeux de société**
- Dépendance aux grandes plateformes, souveraineté numérique, interopérabilité
- Les communs numériques : Wikipédia, OpenStreetMap, logiciels libres
- Algorithmes de recommandation vs fils chronologiques (comme sur Mastodon)
- Interfaces trompeuses (_dark patterns_), notifications et captation de l'attention
**Démarches en ligne depuis Linux**
- FranceConnect, impots.gouv, ameli, ANTS fonctionnent dans Firefox
- Repérer les rares cas où un service impose un logiciel ou un système propriétaire, et savoir le signaler
**Obsolescence et inclusion**
- Redonner vie à un ancien ordinateur sous Linux (distributions légères, Emmabuntüs conçue pour le réemploi)
- Fin de support de Windows 10 en 2025 : la campagne _End of 10_ propose de passer à Linux plutôt que de jeter son PC
- Illectronisme : lieux de médiation numérique, conseillers numériques
**Vie professionnelle**
- CV et lettres avec LibreOffice, export PDF
- Contributions à des projets libres (code, traduction, documentation) comme vitrine de compétences
- Séparer présence professionnelle et vie privée
**Participation citoyenne**
- Plateformes participatives libres comme **Decidim**, utilisées par des collectivités pour les budgets participatifs et consultations
- Consultations publiques en ligne, pétitions
- Contributions aux communs (lien avec 2.2)
**S'engager dans le libre**
- Associations : **April**, **Framasoft**, **La Quadrature du Net**, FSFE, Wikimédia France, OpenStreetMap France
- Collectif **CHATONS** : hébergeurs alternatifs, éthiques et locaux
- Groupes d'utilisateurs Linux (GUL), _install parties_, événements comme les JDLL ou le Capitole du Libre
### Idées d'activités
- Lire ensemble les conditions d'utilisation d'un réseau social et identifier comment il gagne de l'argent
- Débat argumenté : « Une administration devrait-elle utiliser exclusivement des logiciels libres ? »
- Organiser une mini _install party_ : installer Linux sur un ordinateur destiné à être jeté
- Réaliser une démarche administrative complète sous Linux et noter les éventuels obstacles
- Explorer une consultation Decidim d'une collectivité et y analyser la participation

View file

@ -1,73 +0,0 @@
## 4.1 Sécuriser l'environnement numérique
**Ce que recouvre la compétence** : protéger ses équipements, ses communications et ses données contre les attaques, pièges et incidents (logiciels malveillants, hameçonnage, vol de compte, perte de données). Thématiques Pix : menaces et ingénierie sociale, authentification, chiffrement, mises à jour et logiciels de protection, sécurité des réseaux, paiements en ligne.
### Progression par niveaux (résumé)
- **N1-N2** : verrouiller son poste, ne pas partager ses mots de passe, reconnaître un message suspect évident.
- **N3** : créer des mots de passe robustes, faire les mises à jour, repérer une connexion sécurisée (HTTPS).
- **N4-N5** : utiliser un gestionnaire de mots de passe et la double authentification, chiffrer des données, sécuriser son réseau.
- **N6+** : comprendre les mécanismes d'attaque et de chiffrement, appliquer une politique de sécurité pour un groupe, réagir à un incident.
### Version Linux et libre
**Le modèle de sécurité de Linux**
- Compte utilisateur sans privilèges, `sudo` pour les actions d'administration
- Logiciels installés depuis des dépôts officiels signés plutôt que téléchargés au hasard
- Mises à jour centralisées pour tout le système (gestionnaire de logiciels, `apt`, `dnf`), automatisables
- Flatpak : applications isolées, permissions réglables avec **Flatseal**
- AppArmor ou SELinux en arrière-plan
- À démystifier : Linux n'est pas invulnérable. L'hameçonnage, les extensions de navigateur malveillantes, un `curl … | bash` aveugle ou un dépôt tiers douteux restent des risques réels
**Mots de passe et authentification**
- **KeePassXC** : gestionnaire libre, certifié par l'ANSSI
- Bitwarden (serveur auto-hébergeable avec Vaultwarden)
- Phrases de passe (méthode Diceware) plutôt que mots de passe complexes impossibles à retenir
- Vérifier si ses comptes ont fuité : Have I Been Pwned, Mozilla Monitor
- Double authentification (TOTP) : KeePassXC lui-même, **Aegis** (Android), Authenticator (GNOME)
- Clés de sécurité physiques FIDO2, dont **Nitrokey** au matériel ouvert ; passkeys
**Chiffrement**
- **LUKS** : chiffrement complet du disque proposé à l'installation de la plupart des distributions
- VeraCrypt : conteneurs chiffrés, lisibles aussi sous Windows et macOS
- **Cryptomator** : chiffrer ses fichiers avant de les mettre dans le nuage
- GnuPG pour les fichiers et courriels (Kleopatra, ou Mots de passe et clés sous GNOME)
- Clés SSH pour se connecter à un serveur
- HTTPS et certificats : ce que garantit vraiment le cadenas, et ce qu'il ne garantit pas
**Réseau**
- Pare-feu : `ufw` et son interface **Gufw**, ou firewalld
- Wi-Fi : WPA2/WPA3, prudence sur les réseaux publics
- VPN : **WireGuard**, OpenVPN ; ce qu'un VPN protège et ses limites
- **Tor Browser** pour l'anonymat
- Firefox : mode HTTPS uniquement, DNS chiffré
**Logiciels de protection**
- ClamAV avec l'interface ClamTk : utile surtout pour analyser des fichiers destinés à des postes Windows ou des clés USB partagées
- uBlock Origin contre les publicités piégées
**Hameçonnage et ingénierie sociale**
- Vérifier l'adresse réelle d'un lien et l'expéditeur réel (en-têtes dans Thunderbird)
- Signaler : Signal Spam, **cybermalveillance.gouv.fr**, 17Cyber pour les victimes
- Rançongiciels : la meilleure protection reste la sauvegarde hors ligne (lien 1.2)
**Bonnes pratiques matérielles**
- Verrouiller sa session (Super + L), mot de passe du BIOS/UEFI
- Ne pas brancher une clé USB inconnue
- Référence : guide d'hygiène informatique de l'ANSSI
### Idées d'activités
- Migrer tous ses mots de passe vers KeePassXC et activer la double authentification sur un compte important
- Créer un conteneur VeraCrypt sur une clé USB et l'ouvrir sous un autre système
- Atelier hameçonnage : trier une série de vrais et faux messages en justifiant chaque choix
- Configurer Gufw et vérifier les ports ouverts avec `ss -tulpn`
- Examiner les permissions de ses applications Flatpak avec Flatseal et en restreindre une
- Échanger des fichiers chiffrés avec GnuPG entre deux participants

View file

@ -1,66 +0,0 @@
## 1.3 Traiter des données
**Ce que recouvre la compétence** : appliquer des traitements à des données pour les analyser et les interpréter, avec un tableur, une base de données, un programme ou un outil d'enquête. Thématiques Pix : structure des données, formules et calculs, tri et filtrage, représentation graphique, interprétation critique, formats de données.
### Progression par niveaux (résumé)
- **N1-N2** : saisir des données dans un tableau, faire une somme ou une moyenne simple, trier une colonne.
- **N3** : écrire des formules, utiliser références relatives et absolues, filtrer, produire un graphique adapté.
- **N4-N5** : croiser des données (tableaux croisés dynamiques), importer/exporter des formats comme le CSV, mener une enquête et en analyser les résultats.
- **N6+** : interroger une base de données, automatiser un traitement, détecter un biais ou une représentation trompeuse.
### Version Linux et libre
**Tableur**
- **LibreOffice Calc** : formules, `$A$1` vs `A1`, tri, filtre automatique, validation de données, tableaux croisés dynamiques, graphiques
- Gnumeric : plus léger, réputé pour la justesse de ses fonctions statistiques
- **Grist** : entre tableur et base de données, libre, utilisé par l'administration française (auto-hébergeable)
**Formats de données**
- CSV : le piège classique de l'encodage (UTF-8) et du séparateur (`;` en France à cause de la virgule décimale)
- JSON, XML, ODS ; comprendre qu'un même jeu de données peut circuler sous plusieurs formes
**Bases de données**
- **LibreOffice Base** : tables, relations, formulaires, requêtes
- **SQLite** avec DB Browser for SQLite : idéal pour découvrir le SQL (`SELECT`, `WHERE`, `GROUP BY`)
- PostgreSQL ou MariaDB pour aller plus loin
**Nettoyage de données**
- **OpenRefine** : dédoublonner, harmoniser des valeurs, corriger des incohérences
**En ligne de commande** (spécificité Linux très parlante)
- `wc`, `sort`, `uniq -c`, `cut`, `grep`, `awk` : compter et agréger un fichier texte en une ligne
- `jq` pour le JSON, csvkit ou Miller (`mlr`) pour le CSV
**Programmation et analyse**
- Python avec pandas et matplotlib, dans **JupyterLab**
- R pour les statistiques
- gnuplot pour des graphiques scriptés
**Enquêtes**
- **LimeSurvey** : questionnaires et export des résultats vers Calc ou CSV
**Données ouvertes et cartographie**
- data.gouv.fr, INSEE, OpenStreetMap comme sources réelles
- **QGIS** pour traiter des données géographiques
**Interprétation critique**
- Moyenne vs médiane, corrélation vs causalité
- Repérer un graphique trompeur : axe tronqué, échelle inadaptée, camembert surchargé
### Idées d'activités
- Télécharger un jeu de données sur data.gouv.fr, résoudre le problème d'import CSV dans Calc, puis produire un graphique
- Comparer le même calcul fait dans Calc, en SQL sur SQLite et en une ligne de shell
- Nettoyer un fichier volontairement « sale » avec OpenRefine
- Créer un questionnaire LimeSurvey dans le groupe, puis analyser les réponses avec un tableau croisé dynamique
- Corriger un graphique trompeur trouvé dans la presse

View file

@ -1,932 +0,0 @@
# Chapitre 00 — Installer Python et son environnement de travail
> **⏱️ Durée estimée :** 2 à 3 heures (installation comprise)
>
> **📋 Prérequis :** aucun ! Savoir allumer un ordinateur, télécharger un fichier et taper au clavier suffit. Pense à jeter un œil au [sommaire](README.md) pour avoir une vue d'ensemble du cours.
>
> **🎯 Objectifs — À la fin de ce chapitre, tu sauras :**
> - installer la dernière version stable de Python 3 sur Windows, macOS ou Linux, et vérifier qu'elle fonctionne ;
> - installer et configurer VS Code avec l'extension Python ;
> - te déplacer dans tes dossiers avec le terminal (`cd`, `ls`, `dir`) ;
> - utiliser l'interpréteur interactif de Python comme une calculatrice améliorée ;
> - écrire, enregistrer et exécuter ton premier script, avec des commentaires ;
> - lire un message d'erreur de Python sans paniquer et trouver la ligne fautive.
---
## Cours
### 1. Python, c'est quoi exactement ?
Un ordinateur est très rapide mais complètement bête : il ne fait que ce qu'on lui dit, à la lettre. Pour lui donner des ordres, on écrit des **programmes** dans un **langage de programmation**. Python est l'un de ces langages, et c'est sans doute le plus apprécié des débutants, parce qu'il se lit presque comme de l'anglais simplifié.
Voici un programme Python complet :
```python
print("Bonjour, le monde !")
```
Sortie :
```text
Bonjour, le monde !
```
Une seule ligne, et c'est tout. Dans d'autres langages, il faudrait plusieurs lignes de « cérémonie » pour obtenir le même résultat.
Python est utilisé partout : automatisation de tâches répétitives, sites web, analyse de données, intelligence artificielle, jeux, robotique… Tu découvriras ces domaines au [chapitre 14](14-specialisations.md).
**Comment ça marche ?** Le texte que tu écris (le **code source**) est lu par un programme appelé **l'interpréteur Python**. L'interpréteur lit ton code ligne par ligne, de haut en bas, et exécute chaque instruction. Pense à un cuisinier (l'interpréteur) qui lit une recette (ton code) : il suit les étapes dans l'ordre, et s'il tombe sur une phrase incompréhensible, il s'arrête et te le dit.
Installer Python, c'est donc installer cet interpréteur sur ton ordinateur.
### 2. Installer Python
> 💡 Installe toujours **la dernière version stable de Python 3**, disponible sur le site officiel [python.org](https://www.python.org/downloads/). Ce cours demande au minimum Python 3.12. N'installe jamais « Python 2 » : il est abandonné depuis 2020.
Choisis la section qui correspond à ton système.
#### 2.1. Sous Windows
Il existe aujourd'hui deux façons officielles d'installer Python sous Windows. Les deux fonctionnent ; choisis-en **une seule**.
**Méthode A — L'installateur classique (le plus courant dans les tutoriels)**
1. Va sur [python.org/downloads](https://www.python.org/downloads/) et clique sur le gros bouton jaune *Download Python 3.x.x*. Si le site te propose plutôt le « Python install manager », regarde la méthode B.
2. Lance le fichier `.exe` téléchargé.
3. ⚠️ **ÉTAPE CRUCIALE** : tout en bas de la première fenêtre, **coche la case « Add python.exe to PATH »**. Si tu l'oublies, la commande `python` ne sera pas reconnue dans le terminal.
4. Clique sur *Install Now* et attends la fin de l'installation.
5. Si un message *Disable path length limit* apparaît à la fin, clique dessus (c'est sans risque et ça évite des soucis plus tard).
> 🤔 **Le PATH, c'est quoi ?** C'est une liste de dossiers dans lesquels Windows cherche les programmes quand tu tapes une commande. Cocher la case ajoute le dossier de Python à cette liste. Sans ça, Windows te répond qu'il ne connaît pas `python`, un peu comme si tu cherchais un livre dans une bibliothèque qui n'a pas de fiche à son nom.
**Méthode B — Le « Python install manager »**
Les versions récentes de Python proposent sous Windows un **gestionnaire d'installation** (Python install manager). Il est disponible dans le **Microsoft Store** (cherche « Python install manager ») ou sur python.org. Une fois installé, il fournit les commandes `python` et `py` : la première fois que tu tapes `python` dans un terminal, il télécharge et installe automatiquement la dernière version stable. Si on te propose d'ajouter un dossier au PATH pendant la configuration, accepte.
> ⚠️ Ne mélange pas les deux méthodes, et si tu tapes `python` et que **le Microsoft Store s'ouvre** tout seul, c'est que Python n'est pas (bien) installé : Windows te propose de l'installer. Dans ce cas, reprends l'une des deux méthodes ci-dessus.
**La commande `py` sous Windows.** Windows propose aussi un petit programme appelé `py` (le « lanceur Python »). Il fonctionne même quand le PATH est mal configuré. Si `python` ne marche pas, essaie `py` :
```text
C:\Users\camille> py --version
Python 3.x.y
```
#### 2.2. Sous macOS
macOS contient parfois un vieux Python, ou un Python installé par les outils de développement d'Apple. Ne t'en sers pas et installe la version officielle :
1. Va sur [python.org/downloads](https://www.python.org/downloads/) et télécharge l'installateur macOS (fichier `.pkg`).
2. Lance-le et clique sur *Continuer* jusqu'à la fin.
3. À la fin, une fenêtre du Finder s'ouvre : double-clique sur **`Install Certificates.command`**. Cela permettra à Python de télécharger des choses sur Internet de façon sécurisée (utile au [chapitre 12](12-outils-venv-pip-git.md)).
> 💡 Si tu connais déjà **Homebrew**, `brew install python` fonctionne aussi très bien.
Sous macOS, la commande s'appelle **`python3`** (et pas `python`).
#### 2.3. Sous Linux
La plupart des distributions Linux (Ubuntu, Debian, Fedora…) ont **déjà Python 3** installé, car le système lui-même s'en sert. Vérifie la version (voir section suivante). Si elle est trop ancienne ou absente, utilise le gestionnaire de paquets :
```text
# Ubuntu / Debian
sudo apt update
sudo apt install python3 python3-venv python3-pip
# Fedora
sudo dnf install python3
```
> ⚠️ Ne désinstalle **jamais** le Python fourni avec Linux : ton système en a besoin pour fonctionner.
Sous Linux aussi, la commande s'appelle **`python3`**.
#### 2.4. `python`, `python3` ou `py` : qui fait quoi ?
| Système | Commande à utiliser | Remarque |
|---|---|---|
| Windows | `python` (ou `py`) | `python3` peut ouvrir le Microsoft Store : évite-la |
| macOS | `python3` | `python` n'existe souvent pas |
| Linux | `python3` | `python` peut ne pas exister, ou pointer vers autre chose |
Dans la suite du cours, on écrira `python` dans les exemples de terminal. **Si tu es sous macOS ou Linux, remplace mentalement `python` par `python3`.**
### 3. Le terminal : parler à l'ordinateur en texte
Le **terminal** (on dit aussi « console » ou « ligne de commande ») est une fenêtre où tu tapes des commandes au lieu de cliquer. Ça fait un peu « film de hackers », mais tu n'as besoin que de trois ou quatre commandes.
**Ouvrir un terminal :**
- **Windows** : touche Windows, tape « Terminal » (ou « PowerShell »), puis Entrée.
- **macOS** : `Cmd` + `Espace`, tape « Terminal », puis Entrée.
- **Linux** : souvent `Ctrl` + `Alt` + `T`.
Tu vois alors une ligne qui se termine par `>` (Windows) ou `$` / `%` (macOS, Linux) : c'est l'**invite de commande** (le *prompt*). Elle t'indique aussi **le dossier dans lequel tu te trouves**, appelé **dossier courant**.
#### 3.1. Vérifier que Python est installé
Tape la commande suivante, puis Entrée :
```text
python --version
```
(ou `python3 --version` sous macOS/Linux, ou `py --version` sous Windows)
Tu dois voir quelque chose comme `Python 3.x.y`, avec un numéro au moins égal à 3.12. 🎉 Si tu obtiens une erreur, va voir la section [Pièges fréquents](#pièges-fréquents).
#### 3.2. Les commandes indispensables
| Action | Windows (PowerShell) | macOS / Linux |
|---|---|---|
| Afficher le dossier courant | `pwd` (ou `cd` seul dans l'ancien `cmd`) | `pwd` |
| Lister le contenu du dossier | `dir` (ou `ls` dans PowerShell) | `ls` |
| Entrer dans un dossier | `cd nom_du_dossier` | `cd nom_du_dossier` |
| Remonter d'un niveau | `cd ..` | `cd ..` |
| Revenir au dossier personnel | `cd ~` | `cd ~` |
| Créer un dossier | `mkdir nom_du_dossier` | `mkdir nom_du_dossier` |
| Effacer l'écran | `cls` (ou `clear`) | `clear` |
Imagine que tes dossiers sont des pièces d'une maison. `ls`/`dir` revient à regarder autour de toi, `cd cuisine` à entrer dans la cuisine, `cd ..` à revenir dans le couloir.
Exemple de session (macOS/Linux) :
```text
$ pwd
/home/camille
$ mkdir cours-python
$ cd cours-python
$ pwd
/home/camille/cours-python
$ ls
$ cd ..
$ pwd
/home/camille
```
> 💡 **Astuces qui font gagner un temps fou :**
> - La touche **Tab** complète automatiquement les noms de dossiers et de fichiers : tape `cd cou` puis Tab.
> - La **flèche du haut** rappelle les commandes précédentes.
> - Si un nom de dossier contient des espaces, mets-le entre guillemets : `cd "Mes documents"`. Mieux encore : évite les espaces et les accents dans les noms de dossiers de programmation (`cours-python` plutôt que `Cours Python élémentaire`).
**Crée maintenant ton dossier de travail** pour tout le cours, par exemple `cours-python` dans ton dossier personnel, avec `mkdir cours-python`.
### 4. L'interpréteur interactif : Python en direct
Tape simplement `python` (ou `python3`) dans le terminal, sans rien d'autre :
```text
$ python3
Python 3.x.y (...)
Type "help", "copyright", "credits" or "license" for more information.
>>>
```
Les trois chevrons `>>>` signifient : « Python t'écoute ». Tu es dans l'**interpréteur interactif** (on dit aussi **REPL** : *Read, Evaluate, Print, Loop* — lire, évaluer, afficher, recommencer). Chaque ligne que tu tapes est exécutée immédiatement.
Essaie-le comme une calculatrice :
```pycon
>>> 2 + 3
5
>>> 10 - 4 * 2
2
>>> (10 - 4) * 2
12
>>> 7 / 2
3.5
>>> 2 ** 10
1024
```
Remarques :
- `*` est la multiplication, `/` la division, `**` la puissance (`2 ** 10` = 2 à la puissance 10).
- Les priorités sont celles des maths : la multiplication passe avant l'addition, sauf si tu mets des parenthèses.
- Les nombres à virgule s'écrivent avec un **point** : `3.5`, pas `3,5`.
Tu peux aussi manipuler du texte, à condition de le mettre entre guillemets :
```pycon
>>> "Bonjour"
'Bonjour'
>>> "Bon" + "jour"
'Bonjour'
>>> "Ha" * 3
'HaHaHa'
>>> print("Salut !")
Salut !
```
Tous ces détails (types de valeurs, opérateurs) seront approfondis au [chapitre 01](01-variables-types-operateurs.md).
**Pour quitter l'interpréteur**, tape `exit()` puis Entrée (ou `Ctrl` + `D` sous macOS/Linux, `Ctrl` + `Z` puis Entrée sous Windows). Tu reviens alors au terminal normal.
> ⚠️ **Ne confonds pas les deux mondes !**
> - Après `$` ou `>` : tu parles au **terminal** (commandes `cd`, `ls`, `python`…).
> - Après `>>>` : tu parles à **Python** (code Python).
>
> Taper `cd Documents` après `>>>`, ou `print("Bonjour")` dans le terminal, provoque une erreur.
L'interpréteur interactif est parfait pour tester une petite idée, mais tout ce que tu y tapes disparaît quand tu le fermes. Pour écrire de vrais programmes, on utilise des **scripts** enregistrés dans des fichiers, et un éditeur de code.
### 5. Installer VS Code, ton éditeur de code
Tu pourrais écrire du Python dans le Bloc-notes, mais ce serait comme écrire un roman sans correcteur d'orthographe. Un **éditeur de code** colore ton code, détecte des erreurs à la volée, complète automatiquement ce que tu tapes, et permet d'exécuter ton programme en un clic.
Nous utiliserons **Visual Studio Code** (VS Code), gratuit et disponible sur les trois systèmes.
1. Télécharge-le sur [code.visualstudio.com](https://code.visualstudio.com/) et installe-le.
- **Windows** : pendant l'installation, coche « Ajouter à PATH » et « Ajouter l'action *Ouvrir avec Code* », c'est pratique.
- **macOS** : glisse l'application dans le dossier *Applications*.
- **Linux** : utilise le paquet `.deb` / `.rpm` proposé, ou la logithèque de ta distribution.
2. Lance VS Code.
3. Clique sur l'icône **Extensions** dans la barre de gauche (quatre petits carrés), ou fais `Ctrl` + `Shift` + `X` (`Cmd` + `Shift` + `X` sur macOS).
4. Cherche **« Python »** et installe l'extension publiée par **Microsoft** (c'est la première, avec des millions de téléchargements). Elle installe automatiquement ses compagnons (Pylance, le débogueur…).
5. (Facultatif) Si tu préfères l'interface en français, installe aussi l'extension **« French Language Pack for Visual Studio Code »** puis redémarre VS Code.
**Ouvrir ton dossier de travail.** Dans VS Code : *Fichier* → *Ouvrir le dossier…* (*File* → *Open Folder…*), puis choisis ton dossier `cours-python`. VS Code peut te demander si tu fais confiance aux auteurs des fichiers : réponds oui, c'est ton dossier.
**Choisir l'interpréteur.** Ouvre la palette de commandes avec `Ctrl` + `Shift` + `P` (`Cmd` + `Shift` + `P` sur macOS), tape « Python: Select Interpreter » et choisis la version de Python que tu viens d'installer. En général VS Code la trouve tout seul.
**Le terminal intégré.** VS Code contient son propre terminal : menu *Terminal* → *Nouveau terminal* (ou ``Ctrl`` + ``ù`` sur un clavier français, ``Ctrl`` + `` ` `` sur un clavier anglais). Il s'ouvre directement dans ton dossier de travail. C'est celui-là que tu utiliseras le plus souvent.
### 6. Ton premier script
Un **script** est simplement un fichier texte qui contient du code Python et dont le nom se termine par **`.py`**.
1. Dans VS Code, crée un nouveau fichier (*Fichier* → *Nouveau fichier*, ou l'icône 📄+ à côté du nom du dossier) et nomme-le **`bonjour.py`**.
2. Tape ce code :
```python
print("Bonjour !")
print("Je m'appelle Python.")
print("Je sais calculer : 6 x 7 =", 6 * 7)
```
3. **Enregistre** (`Ctrl` + `S` / `Cmd` + `S`). Un rond blanc à côté du nom de l'onglet signifie « fichier non enregistré » : Python exécute ce qui est **sur le disque**, pas ce qui est à l'écran !
4. Exécute-le, au choix :
- clique sur le bouton ▶ (*Run Python File*) en haut à droite de l'éditeur ;
- ou, dans le terminal intégré, tape `python bonjour.py` (ou `python3 bonjour.py`).
Sortie :
```text
Bonjour !
Je m'appelle Python.
Je sais calculer : 6 x 7 = 42
```
Félicitations, tu es officiellement programmeur ou programmeuse ! 🎉
**Ce qu'il faut remarquer :**
- `print(...)` affiche ce qu'on lui donne entre parenthèses. C'est une **fonction** : un outil prêt à l'emploi fourni par Python. (Tu apprendras à créer tes propres fonctions au [chapitre 05](05-fonctions.md).)
- Le texte est entre guillemets : `"Bonjour !"`. On appelle ça une **chaîne de caractères**. Sans guillemets, Python croirait que c'est du code.
- On peut donner plusieurs choses à `print`, séparées par des virgules : Python les affiche séparées par une espace.
- `6 * 7` n'est pas entre guillemets : Python le calcule et affiche `42`.
- Les lignes sont exécutées **dans l'ordre**, de haut en bas.
Encore un exemple, pour voir que `print()` sans rien affiche une ligne vide :
```python
print("Ligne 1")
print()
print("Ligne 3, après une ligne vide")
print("Le résultat de 100 / 8 est", 100 / 8)
```
Sortie :
```text
Ligne 1
Ligne 3, après une ligne vide
Le résultat de 100 / 8 est 12.5
```
> 💡 **Guillemets simples ou doubles ?** Les deux marchent : `'Bonjour'` et `"Bonjour"` sont identiques. Mais si ton texte contient une apostrophe (très fréquent en français !), utilise des guillemets doubles : `"J'adore Python"`.
### 7. Les commentaires
Un **commentaire** est une note pour les humains, que Python ignore complètement. Il commence par le caractère `#` et s'étend jusqu'à la fin de la ligne.
```python
# Ce programme affiche un message de bienvenue.
# Auteur : Camille
print("Bienvenue !") # un commentaire peut aussi suivre du code
# print("Cette ligne ne sera pas exécutée")
print("Fin du programme")
```
Sortie :
```text
Bienvenue !
Fin du programme
```
**À quoi servent les commentaires ?**
- **Expliquer le pourquoi** d'un morceau de code (« on arrondit ici parce que la banque n'accepte pas les centimes de centimes »).
- **Désactiver temporairement** une ligne sans l'effacer, pour tester quelque chose. Dans VS Code, `Ctrl` + `/` (`Cmd` + `/`) commente ou décommente les lignes sélectionnées.
- **Structurer** un long script en sections.
> 💡 Un bon commentaire explique **pourquoi**, pas **quoi**. `print("Bonjour") # affiche Bonjour` n'apporte rien : le code le dit déjà.
### 8. Lire ta première erreur
Tu vas faire des erreurs. Beaucoup. Tout le monde en fait, même les experts avec 20 ans d'expérience. La différence, c'est qu'ils savent **lire les messages d'erreur**. Bonne nouvelle : les messages de Python sont parmi les plus clairs qui existent.
Crée un fichier `erreur.py` avec ce code (il y a une faute volontaire à la ligne 2) :
```python
print("Bonjour")
print(Bonjour)
```
En l'exécutant, tu obtiens :
```text
Bonjour
Traceback (most recent call last):
File "C:\Users\camille\cours-python\erreur.py", line 2, in <module>
print(Bonjour)
^^^^^^^
NameError: name 'Bonjour' is not defined
```
Comment lire ce message (on l'appelle un **traceback**) :
1. **Commence par la dernière ligne** : c'est la plus importante. Elle donne le **type d'erreur** (`NameError`) et une explication (`name 'Bonjour' is not defined` : « le nom 'Bonjour' n'est pas défini »).
2. **Remonte d'une ou deux lignes** pour trouver **où** : le fichier (`erreur.py`) et le numéro de ligne (`line 2`). Python recopie même la ligne fautive et met des `^^^^` sous le morceau problématique.
3. **Remarque** que la ligne 1 a bien été exécutée (`Bonjour` s'est affiché) : Python s'arrête **à la première erreur rencontrée**.
Ici, on a oublié les guillemets : Python croit que `Bonjour` est un nom de quelque chose qu'il devrait connaître. La correction : `print("Bonjour")`.
Il existe aussi des erreurs détectées **avant même l'exécution**, quand Python relit ton code : les **erreurs de syntaxe** (`SyntaxError`). C'est l'équivalent d'une faute de grammaire.
```python
print("Bonjour"
```
```text
File "C:\Users\camille\cours-python\erreur.py", line 1
print("Bonjour"
^
SyntaxError: '(' was never closed
```
Traduction : « la parenthèse ouverte n'a jamais été fermée ». Dans ce cas, **rien** n'est exécuté, même pas les lignes correctes situées avant.
**Petit dictionnaire des erreurs que tu croiseras au début :**
| Message | Signification | Cause probable |
|---|---|---|
| `SyntaxError: invalid syntax` | Syntaxe invalide | Faute de frappe, symbole manquant ou en trop |
| `SyntaxError: '(' was never closed` | Parenthèse jamais fermée | Il manque `)` |
| `SyntaxError: unterminated string literal` | Chaîne non terminée | Il manque un guillemet fermant |
| `IndentationError: unexpected indent` | Décalage inattendu | Espaces en trop en début de ligne |
| `NameError: name '...' is not defined` | Nom inconnu | Faute de frappe, ou guillemets oubliés |
| `ZeroDivisionError: division by zero` | Division par zéro | On a divisé par 0 |
> 💡 **Le réflexe à prendre :** dernière ligne → numéro de ligne → regarder la ligne en question **et celle d'avant** (une parenthèse oubliée à la ligne 3 est parfois signalée à la ligne 4). Et si tu ne comprends pas, copie la dernière ligne du message dans un moteur de recherche : quelqu'un a déjà eu le même problème. Les erreurs et le débogage seront approfondis au [chapitre 08](08-erreurs-et-debogage.md).
---
## Pièges fréquents
### Piège 1 — « python n'est pas reconnu » (Windows)
```text
PS C:\Users\camille> python --version
python : Le terme «python» n'est pas reconnu comme nom d'applet de commande, fonction, fichier de script ou programme exécutable.
```
**Cause :** la case « Add python.exe to PATH » n'a pas été cochée pendant l'installation.
**Correction :** essaie d'abord `py --version`. Si ça marche, tu peux utiliser `py` à la place de `python`. Sinon, relance l'installateur de Python, choisis *Modify* (ou désinstalle puis réinstalle) et coche bien la case. **Ferme et rouvre ensuite le terminal (et VS Code)** : un terminal déjà ouvert ne voit pas les changements du PATH.
### Piège 2 — « command not found: python » (macOS / Linux)
```text
$ python --version
zsh: command not found: python
```
**Cause :** sur macOS et Linux, la commande s'appelle `python3`.
**Correction :**
```text
$ python3 --version
Python 3.x.y
```
### Piège 3 — Taper du Python dans le terminal, ou une commande de terminal dans Python
Dans le terminal (pas dans Python) :
```text
$ print("Bonjour")
bash: syntax error near unexpected token `"Bonjour"'
```
Dans l'interpréteur Python :
```text
>>> python bonjour.py
File "<stdin>", line 1
python bonjour.py
^^^^^^^
SyntaxError: invalid syntax
```
**Correction :** regarde l'invite. `>>>` = Python ; `$`, `%` ou `>` = terminal. Pour lancer un script, quitte d'abord l'interpréteur avec `exit()`, puis tape `python bonjour.py` dans le terminal.
### Piège 4 — « No such file or directory »
```text
$ python3 bonjour.py
python3: can't open file '/home/camille/bonjour.py': [Errno 2] No such file or directory
```
**Cause :** tu n'es pas dans le dossier qui contient le fichier (ici, on est dans `/home/camille` alors que le fichier est dans `/home/camille/cours-python`), ou le fichier n'a pas le nom que tu crois (par exemple `bonjour.py.txt` sous Windows).
**Correction :** vérifie où tu es (`pwd`) et ce qu'il y a dans le dossier (`ls` ou `dir`), puis déplace-toi avec `cd cours-python`. Utiliser le terminal intégré de VS Code, qui s'ouvre directement dans le bon dossier, évite souvent ce problème.
### Piège 5 — Oublier d'enregistrer
Tu modifies ton code, tu l'exécutes… et rien ne change. Le rond blanc sur l'onglet de VS Code te dit que le fichier n'est **pas enregistré**.
**Correction :** `Ctrl` + `S` (`Cmd` + `S`) avant chaque exécution. Mieux : active *Fichier* → *Enregistrement automatique* (*Auto Save*).
### Piège 6 — Les guillemets « typographiques »
Si tu copies du code depuis un traitement de texte (Word, un PDF…), les guillemets droits `"` sont parfois remplacés par des guillemets courbes `“ ”` :
```python
print(“Bonjour”)
```
```text
File "bonjour.py", line 1
print(“Bonjour”)
^
SyntaxError: invalid character '“' (U+201C)
```
**Correction :** retape les guillemets directement dans VS Code : `print("Bonjour")`. Les guillemets français `« »` provoquent la même erreur.
### Piège 7 — Les majuscules comptent
```python
Print("Bonjour")
```
```text
Traceback (most recent call last):
File "bonjour.py", line 1, in <module>
Print("Bonjour")
^^^^^
NameError: name 'Print' is not defined. Did you mean: 'print'?
```
**Correction :** Python est **sensible à la casse** : `print`, `Print` et `PRINT` sont trois noms différents. Remarque que Python te suggère même la bonne réponse : *Did you mean: 'print'?*
### Piège 8 — Des espaces en trop en début de ligne
```python
print("Bonjour")
print("Au revoir")
```
```text
File "bonjour.py", line 2
print("Au revoir")
IndentationError: unexpected indent
```
**Correction :** en Python, les espaces en **début** de ligne (l'**indentation**) ont un sens précis, que tu découvriras au [chapitre 02](02-conditions.md). Pour l'instant, toutes tes lignes doivent commencer tout à gauche.
---
## Exercices
### Exercice 1 ⭐ — Vérification de l'installation
Ouvre un terminal et :
1. affiche la version de Python installée ;
2. crée un dossier `chapitre00` dans ton dossier de travail et entre dedans ;
3. affiche le chemin du dossier courant pour vérifier que tu es au bon endroit ;
4. lance l'interpréteur interactif, calcule `2 ** 100`, puis quitte-le.
Résultat attendu pour le calcul : `1267650600228229401496703205376`.
### Exercice 2 ⭐ — Calculatrice interactive
Dans l'interpréteur interactif, calcule :
1. le nombre de secondes dans une journée ;
2. le nombre de minutes dans une année de 365 jours ;
3. le prix de 3 croissants à 1,20 € et 2 baguettes à 1,10 € ;
4. la moyenne de 12, 15 et 17.
Attention aux priorités de calcul et à la virgule !
### Exercice 3 ⭐ — Présente-toi
Écris un script `presentation.py` qui affiche exactement (en mettant tes propres informations) :
```text
Bonjour !
Je m'appelle Camille.
J'apprends Python.
À bientôt !
```
Note la ligne vide avant la dernière ligne.
### Exercice 4 ⭐⭐ — Chasse aux erreurs
Le script suivant contient **quatre** erreurs. Exécute-le, lis chaque message d'erreur, corrige la ligne fautive et recommence jusqu'à ce que tout fonctionne.
```text
print("Début du programme")
print("Le double de 21 est", 21 * 2
Print("Python est sensible à la casse")
print("Il manque un guillemet)
print(Fin du programme)
```
Sortie attendue une fois corrigé :
```text
Début du programme
Le double de 21 est 42
Python est sensible à la casse
Il manque un guillemet
Fin du programme
```
### Exercice 5 ⭐⭐ — Le commentateur
Écris un script `recette.py` qui affiche une petite recette de crêpes (titre, ingrédients, étapes) sur une dizaine de lignes. Ajoute :
- un commentaire en tête avec ton nom et la date ;
- un commentaire avant chaque section (titre, ingrédients, étapes) ;
- une ligne d'étape « désactivée » par un commentaire, qui ne doit pas s'afficher.
### Exercice 6 ⭐⭐ — Facture rapide
Écris un script `facture.py` qui affiche une facture et laisse Python faire **tous** les calculs (n'écris pas les résultats toi-même). Un client achète 4 cahiers à 2.5 € et 3 stylos à 1.2 €.
Sortie attendue :
```text
=== FACTURE ===
Cahiers : 4 x 2.5 = 10.0 €
Stylos : 3 x 1.2 = 3.5999999999999996 €
TOTAL : 13.6 €
```
Ne t'inquiète pas du `3.5999999999999996` : c'est normal, et tu sauras pourquoi (et comment l'arrondir) au chapitre 01.
### Exercice 7 ⭐⭐⭐ — Art ASCII
Écris un script `chat.py` qui dessine ce chat (attention : la barre oblique inversée `\` est un caractère spécial en Python ; pour l'afficher, il faut l'écrire en double `\\` dans une chaîne).
```text
/\_/\
( o.o )
> ^ <
```
Puis ajoute un cadre de 20 étoiles au-dessus et au-dessous, **sans taper les 20 étoiles à la main** (indice : tu as vu ce que fait `"Ha" * 3`).
---
## Mini-projet
### Ma carte de visite dans le terminal
**Objectif :** créer un script `carte_visite.py` qui affiche une jolie carte de visite à ton nom, encadrée, et qui calcule une ou deux informations « amusantes ».
**Cahier des charges :**
1. Le fichier commence par un commentaire d'en-tête : nom du programme, auteur, date, description en une phrase.
2. La carte est encadrée par une ligne de 40 caractères `=` en haut et en bas, générée avec l'opérateur `*` sur une chaîne.
3. Elle contient au moins : ton prénom, ta ville, un loisir, et la phrase « Apprenti·e Pythoniste ».
4. Une section « Le saviez-vous ? » affiche au moins deux calculs faits par Python, par exemple ton âge approximatif en jours (âge × 365) et le nombre d'heures de sommeil par an (8 × 365).
5. Les sections sont séparées par des lignes vides et commentées dans le code.
6. Le script s'exécute sans aucune erreur depuis le terminal **et** depuis le bouton ▶ de VS Code.
**Étapes suggérées :**
1. Crée le fichier dans ton dossier de travail et écris le commentaire d'en-tête.
2. Affiche le cadre du haut, puis teste.
3. Ajoute les lignes d'information une par une, en testant à chaque fois.
4. Ajoute la section des calculs.
5. Termine par le cadre du bas et relis les commentaires.
**Pistes d'amélioration :**
- Ajoute un petit dessin ASCII (un chat, une tasse de café…).
- Centre visuellement les textes en ajoutant des espaces.
- Ajoute le nombre de battements de cœur approximatif depuis ta naissance (environ 70 par minute).
- Quand tu auras lu le chapitre 01, reviens améliorer ce script avec des variables et une saisie au clavier !
---
## Corrigés
<details>
<summary>Corrigé de l'exercice 1</summary>
Sous macOS / Linux (sous Windows, remplace `python3` par `python` ou `py`, et `pwd` fonctionne dans PowerShell) :
```text
$ python3 --version
Python 3.x.y
$ mkdir chapitre00
$ cd chapitre00
$ pwd
/home/camille/cours-python/chapitre00
$ python3
>>> 2 ** 100
1267650600228229401496703205376
>>> exit()
$
```
Remarque : Python calcule sans problème des nombres entiers gigantesques, contrairement à une calculatrice de poche qui afficherait `1.2676506e+30`.
</details>
<details>
<summary>Corrigé de l'exercice 2</summary>
```pycon
>>> 24 * 60 * 60
86400
>>> 365 * 24 * 60
525600
>>> 3 * 1.20 + 2 * 1.10
5.8
>>> (12 + 15 + 17) / 3
14.666666666666666
```
- Pour les prix, on écrit `1.20` avec un point, jamais une virgule. (Parfois, un calcul avec des nombres à virgule donne un résultat comme `3.5999999999999996` au lieu de `3.6` : c'est une petite imprécision normale en informatique, expliquée au chapitre 01.)
- Pour la moyenne, les **parenthèses sont indispensables** : `12 + 15 + 17 / 3` calculerait d'abord `17 / 3` et donnerait `32.666666666666664`.
</details>
<details>
<summary>Corrigé de l'exercice 3</summary>
```python
print("Bonjour !")
print("Je m'appelle Camille.")
print("J'apprends Python.")
print()
print("À bientôt !")
```
Sortie :
```text
Bonjour !
Je m'appelle Camille.
J'apprends Python.
À bientôt !
```
On utilise des guillemets doubles car le texte contient des apostrophes. `print()` sans argument affiche une ligne vide.
</details>
<details>
<summary>Corrigé de l'exercice 4</summary>
Les quatre erreurs, dans l'ordre où Python les signale :
1. Ligne 4 : `SyntaxError: unterminated string literal (detected at line 4)` → il manque le guillemet fermant. Surprise : ce n'est pas la ligne 2 qui est signalée en premier ! Python découpe d'abord tout le fichier en « mots », et une chaîne non terminée bloque ce découpage dès le départ.
2. Ligne 2 : `SyntaxError: '(' was never closed` → il manque la parenthèse fermante.
3. Ligne 5 : `SyntaxError: invalid syntax. Perhaps you forgot a comma?` → Python lit `Fin du programme` comme trois noms de code à la suite, ce qui n'a pas de sens. La vraie cause : les guillemets oubliés.
4. Ligne 3 : `NameError: name 'Print' is not defined. Did you mean: 'print'?` → majuscule en trop. Cette erreur n'apparaît qu'en dernier, **pendant l'exécution** : les deux premières lignes s'affichent avant que Python ne plante.
À retenir : tant qu'il reste une erreur de syntaxe (`SyntaxError`), **rien** ne s'exécute. Les autres erreurs (`NameError`…) n'apparaissent qu'au moment où Python atteint la ligne fautive.
Version corrigée :
```python
print("Début du programme")
print("Le double de 21 est", 21 * 2)
print("Python est sensible à la casse")
print("Il manque un guillemet")
print("Fin du programme")
```
Sortie :
```text
Début du programme
Le double de 21 est 42
Python est sensible à la casse
Il manque un guillemet
Fin du programme
```
</details>
<details>
<summary>Corrigé de l'exercice 5</summary>
```python
# Recette de crêpes
# Auteur : Camille — 14 octobre
# --- Titre ---
print("=== Crêpes pour 4 personnes ===")
print()
# --- Ingrédients ---
print("Ingrédients :")
print("- 250 g de farine")
print("- 4 œufs")
print("- 50 cl de lait")
print("- 1 pincée de sel")
print()
# --- Étapes ---
print("Étapes :")
print("1. Mélanger la farine et les œufs.")
print("2. Ajouter le lait petit à petit.")
# print("2bis. Ajouter un verre de rhum.") # étape désactivée
print("3. Laisser reposer 1 heure.")
print("4. Cuire dans une poêle chaude.")
```
Sortie :
```text
=== Crêpes pour 4 personnes ===
Ingrédients :
- 250 g de farine
- 4 œufs
- 50 cl de lait
- 1 pincée de sel
Étapes :
1. Mélanger la farine et les œufs.
2. Ajouter le lait petit à petit.
3. Laisser reposer 1 heure.
4. Cuire dans une poêle chaude.
```
La ligne « 2bis » est commentée : Python l'ignore.
</details>
<details>
<summary>Corrigé de l'exercice 6</summary>
```python
# Facture : Python fait tous les calculs
print("=== FACTURE ===")
print("Cahiers : 4 x 2.5 =", 4 * 2.5, "€")
print("Stylos : 3 x 1.2 =", 3 * 1.2, "€")
print("TOTAL :", 4 * 2.5 + 3 * 1.2, "€")
```
Sortie :
```text
=== FACTURE ===
Cahiers : 4 x 2.5 = 10.0 €
Stylos : 3 x 1.2 = 3.5999999999999996 €
TOTAL : 13.6 €
```
Dans `"4 x 2.5 ="`, le calcul est entre guillemets : c'est du texte, affiché tel quel. Juste après, `4 * 2.5` est hors guillemets : Python le calcule. Remarque qu'on recopie les mêmes nombres plusieurs fois : au chapitre 01, les **variables** permettront d'éviter ça.
</details>
<details>
<summary>Corrigé de l'exercice 7</summary>
```python
# Un chat en art ASCII, encadré d'étoiles
print("*" * 20)
print(" /\\_/\\")
print("( o.o )")
print(" > ^ <")
print("*" * 20)
```
Sortie :
```text
********************
/\_/\
( o.o )
> ^ <
********************
```
Chaque `\\` dans le code produit **un seul** `\` à l'écran. `"*" * 20` répète la chaîne `"*"` vingt fois.
</details>
<details>
<summary>Corrigé du mini-projet</summary>
```python
# ------------------------------------------------------------
# carte_visite.py
# Auteur : Camille
# Date : 14 octobre
# Description : affiche ma carte de visite dans le terminal.
# ------------------------------------------------------------
# --- Cadre du haut ---
print("=" * 40)
# --- Identité ---
print(" Camille")
print(" Apprentie Pythoniste")
print()
# --- Informations ---
print(" Ville : Lyon")
print(" Loisir : l'escalade")
print()
# --- Le saviez-vous ? (calculs faits par Python) ---
print(" Le saviez-vous ?")
print(" J'ai vécu environ", 28 * 365, "jours.")
print(" Je dors environ", 8 * 365, "heures par an.")
print(" Mon cœur a battu environ", 70 * 60 * 24 * 365 * 28, "fois.")
# --- Cadre du bas ---
print("=" * 40)
```
Sortie :
```text
========================================
Camille
Apprentie Pythoniste
Ville : Lyon
Loisir : l'escalade
Le saviez-vous ?
J'ai vécu environ 10220 jours.
Je dors environ 2920 heures par an.
Mon cœur a battu environ 1030176000 fois.
========================================
```
Points à vérifier : le commentaire d'en-tête est présent, chaque section est commentée, les cadres sont générés avec `"=" * 40`, et tous les nombres sont calculés par Python. Le nombre de battements de cœur correspond à l'une des pistes d'amélioration.
</details>
---
## Récapitulatif
**Points clés :**
- Python est un langage **interprété** : l'interpréteur lit ton code de haut en bas et l'exécute ligne par ligne.
- Installe **la dernière version stable de Python 3** depuis python.org. Sous Windows, **coche « Add python.exe to PATH »** (ou utilise le Python install manager).
- La commande est `python` (ou `py`) sous Windows, `python3` sous macOS et Linux.
- Dans le terminal : `cd` pour te déplacer, `cd ..` pour remonter, `ls` / `dir` pour lister, `pwd` pour savoir où tu es, `mkdir` pour créer un dossier.
- `>>>` = interpréteur interactif (tests rapides) ; un fichier `.py` = script (programme durable). On lance un script avec `python nom_du_fichier.py`.
- VS Code + l'extension Python de Microsoft : ton atelier de travail. N'oublie pas d'enregistrer avant d'exécuter.
- `print(...)` affiche des valeurs ; le texte se met entre guillemets.
- `#` commence un commentaire, ignoré par Python.
- Un message d'erreur se lit **de bas en haut** : type d'erreur, explication, puis numéro de ligne.
**Checklist de validation :**
- [ ] `python --version` (ou `python3 --version`) affiche une version 3.12 ou plus récente.
- [ ] Je sais ouvrir un terminal, savoir où je suis et me déplacer dans mes dossiers.
- [ ] Je sais lancer l'interpréteur interactif, y faire un calcul et le quitter.
- [ ] VS Code est installé avec l'extension Python, et mon dossier de travail est ouvert dedans.
- [ ] J'ai écrit, enregistré et exécuté un script `.py` de deux façons (bouton ▶ et terminal).
- [ ] Je sais écrire un commentaire et désactiver une ligne.
- [ ] Face à une erreur, je sais trouver son type et le numéro de la ligne fautive.
---
[← Chapitre précédent (sommaire)](README.md) | [Sommaire](README.md) | [Chapitre suivant →](01-variables-types-operateurs.md)

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

View file

@ -1,130 +0,0 @@
# Apprendre à programmer en Python
Un parcours complet, du tout premier `print()` jusqu'à un projet personnel publié sur GitHub.
Ce dossier s'adresse aux **grands débutants** : aucune connaissance préalable en programmation n'est nécessaire. Chaque chapitre explique les notions pas à pas, avec des exemples que tu peux exécuter, les erreurs que tout le monde fait au début, des exercices corrigés et un mini-projet.
---
## Comment utiliser ce cours
1. **Suis les chapitres dans l'ordre.** Chacun s'appuie sur les précédents.
2. **Tape les exemples toi-même** au lieu de les copier-coller. C'est en tapant (et en se trompant) qu'on retient.
3. **Fais les exercices avant de regarder les corrigés.** Les corrigés sont repliés : clique sur « Corrigé de l'exercice N » seulement après avoir vraiment cherché (au moins 15 à 20 minutes).
4. **Ne saute pas les mini-projets.** Ce sont eux qui transforment des notions isolées en vraie compétence.
5. **Coche la checklist** à la fin de chaque chapitre. Si une case reste vide, relis la partie concernée avant d'avancer.
6. **Garde l'[aide-mémoire](aide-memoire.md) ouvert** pendant que tu codes.
> **Conseil de rythme** : 30 à 60 minutes par jour valent mieux qu'une seule longue séance par semaine. Le cerveau consolide pendant les pauses.
---
## Sommaire
### Partie 1 — Les fondamentaux
| # | Chapitre | Ce que tu apprends | Travail |
|---|---|---|---|
| 00 | [Installation et environnement](00-installation-environnement.md) | Installer Python et VS Code, utiliser le terminal, écrire et lancer ton premier script | 2-3 h |
| 01 | [Variables, types et opérateurs](01-variables-types-operateurs.md) | Stocker des données, nombres et textes, calculs, `input()` / `print()`, f-strings | 4-5 h |
| 02 | [Conditions](02-conditions.md) | Prendre des décisions avec `if` / `elif` / `else`, opérateurs logiques, `match` | 4 h |
| 03 | [Boucles](03-boucles.md) | Répéter des actions avec `for` et `while`, `range()`, `break`, `continue` | 5 h |
### Partie 2 — Organiser ses données et son code
| # | Chapitre | Ce que tu apprends | Travail |
|---|---|---|---|
| 04 | [Structures de données](04-structures-de-donnees.md) | Listes, tuples, dictionnaires, ensembles | 5-6 h |
| 05 | [Fonctions](05-fonctions.md) | Découper son code en blocs réutilisables, paramètres, retour, portée | 5-6 h |
| 06 | [Chaînes et compréhensions](06-chaines-et-comprehensions.md) | Manipuler du texte, slicing, compréhensions, `enumerate`, `zip`, `sorted` | 5-6 h |
| 07 | [Fichiers, CSV et JSON](07-fichiers-csv-json.md) | Lire et écrire des fichiers, sauvegarder des données durablement | 5-6 h |
### Partie 3 — Écrire du code solide
| # | Chapitre | Ce que tu apprends | Travail |
|---|---|---|---|
| 08 | [Erreurs et débogage](08-erreurs-et-debogage.md) | Lire un traceback, gérer les exceptions, utiliser le débogueur | 4-5 h |
| 09 | [Modules et bibliothèque standard](09-modules-bibliotheque-standard.md) | Importer, créer ses propres modules, `random`, `datetime`, `collections`… | 4-5 h |
### Partie 4 — Programmation orientée objet
| # | Chapitre | Ce que tu apprends | Travail |
|---|---|---|---|
| 10 | [Classes et objets](10-poo-classes-objets.md) | Créer ses propres types, attributs, méthodes, `self` | 5-6 h |
| 11 | [POO avancée et typage](11-poo-avancee-heritage-typage.md) | Héritage, composition, `@property`, dataclasses, annotations de type | 6-7 h |
### Partie 5 — Travailler comme un développeur
| # | Chapitre | Ce que tu apprends | Travail |
|---|---|---|---|
| 12 | [Outils : venv, pip, Git](12-outils-venv-pip-git.md) | Environnements virtuels, installer des paquets, versionner et publier son code | 5-7 h |
| 13 | [Tests et bonnes pratiques](13-tests-pytest-bonnes-pratiques.md) | Tester avec `pytest`, PEP 8, `ruff`, structurer un projet | 5-7 h |
### Partie 6 — Aller plus loin
| # | Chapitre | Ce que tu apprends | Travail |
|---|---|---|---|
| 14 | [Spécialisations](14-specialisations.md) | Automatisation, web, data, IA, jeux : un aperçu concret de chaque voie | 8-12 h |
| 15 | [Projet final](15-projet-final.md) | Mener un projet de A à Z, idées de projets, projet fil rouge guidé | 15-30 h |
### Annexes
- [Aide-mémoire Python](aide-memoire.md) — toute la syntaxe essentielle sur une page
- [Ressources](ressources.md) — livres, sites, plateformes d'exercices, communautés
---
## Planning type
La colonne « Travail » du sommaire indique le temps pour le cours, les exercices et le mini-projet d'un chapitre. Ajoute-y de la pratique libre (exercices sur France-IOI ou Codewars, petits scripts personnels, révisions) : c'est elle qui ancre les notions. En pratique, compte **environ une semaine par chapitre**.
Avec **5 à 7 heures par semaine**, compte environ **6 mois** pour le parcours complet :
```
Mois 1 ██████████ Ch. 00 → 03 Fondamentaux
Mois 2 ██████████ Ch. 04 → 07 Données, fonctions, fichiers
Mois 3 ██████████ Ch. 08 → 09 Code solide + révisions
Mois 4 ██████████ Ch. 10 → 13 POO et outils du développeur
Mois 5 ██████████ Ch. 14 Spécialisation choisie
Mois 6 ██████████ Ch. 15 Projet personnel
```
Avec **10 à 15 heures par semaine**, le parcours se fait en 3 mois environ. Avec moins de temps, étale-le : la régularité compte plus que la vitesse.
---
## Suivi de progression
Coche au fur et à mesure :
- [ ] 00 — Installation et environnement
- [ ] 01 — Variables, types et opérateurs
- [ ] 02 — Conditions
- [ ] 03 — Boucles
- [ ] 04 — Structures de données
- [ ] 05 — Fonctions
- [ ] 06 — Chaînes et compréhensions
- [ ] 07 — Fichiers, CSV et JSON
- [ ] 08 — Erreurs et débogage
- [ ] 09 — Modules et bibliothèque standard
- [ ] 10 — Classes et objets
- [ ] 11 — POO avancée et typage
- [ ] 12 — Outils : venv, pip, Git
- [ ] 13 — Tests et bonnes pratiques
- [ ] 14 — Spécialisation choisie : ____________
- [ ] 15 — Projet final publié sur GitHub
---
## Quand tu es bloqué
1. **Relis le message d'erreur**, en partant de la dernière ligne (le chapitre 08 t'apprend à le faire méthodiquement).
2. **Ajoute des `print()`** pour voir ce que contiennent tes variables à chaque étape.
3. **Réduis le problème** : isole les quelques lignes qui posent souci dans un petit fichier à part.
4. **Cherche le message d'erreur** sur un moteur de recherche (souvent en anglais).
5. **Fais une pause.** Beaucoup de bugs se résolvent tout seuls après dix minutes loin de l'écran.
6. **Demande de l'aide** en expliquant ce que tu voulais faire, ce que tu as essayé et le message d'erreur complet (voir [Ressources](ressources.md) pour les communautés).
Bon apprentissage !
[Commencer le chapitre 00 →](00-installation-environnement.md)

View file

@ -1,526 +0,0 @@
# Aide-mémoire Python
Toute la syntaxe essentielle du cours, regroupée pour la retrouver vite. Les numéros entre parenthèses renvoient au chapitre où la notion est expliquée en détail.
---
## Sommaire
1. [Bases](#1-bases-ch-01)
2. [Conditions](#2-conditions-ch-02)
3. [Boucles](#3-boucles-ch-03)
4. [Listes](#4-listes-ch-04)
5. [Tuples et ensembles](#5-tuples-et-ensembles-ch-04)
6. [Dictionnaires](#6-dictionnaires-ch-04)
7. [Fonctions](#7-fonctions-ch-05)
8. [Chaînes de caractères](#8-chaînes-de-caractères-ch-06)
9. [Compréhensions et outils d'itération](#9-compréhensions-et-outils-ditération-ch-06)
10. [Fichiers, CSV, JSON](#10-fichiers-csv-json-ch-07)
11. [Exceptions](#11-exceptions-ch-08)
12. [Modules utiles](#12-modules-utiles-ch-09)
13. [Classes](#13-classes-ch-10-et-11)
14. [Annotations de type](#14-annotations-de-type-ch-11)
15. [Commandes du terminal](#15-commandes-du-terminal-ch-00-12-13)
16. [Erreurs courantes et leur sens](#16-erreurs-courantes-et-leur-sens)
---
## 1. Bases (ch. 01)
```python
# Commentaire sur une ligne
nom = "Alice" # str : texte
age = 30 # int : entier
taille = 1.68 # float: nombre à virgule
majeur = True # bool : True / False
rien = None # absence de valeur
type(age) # <class 'int'>
```
**Conversions**
```python
int("42") # 42
float("3.5") # 3.5
str(42) # "42"
bool(0) # False (0, "", [], {}, None sont « faux »)
int(3.9) # 3 (tronque, n'arrondit pas)
round(3.9) # 4
```
**Opérateurs**
| Opérateur | Sens | Exemple | Résultat |
|---|---|---|---|
| `+ - *` | addition, soustraction, multiplication | `7 * 2` | `14` |
| `/` | division (toujours un float) | `7 / 2` | `3.5` |
| `//` | division entière | `7 // 2` | `3` |
| `%` | reste (modulo) | `7 % 2` | `1` |
| `**` | puissance | `2 ** 10` | `1024` |
| `+=`, `-=`… | raccourcis | `x += 1` | `x = x + 1` |
**Entrées / sorties**
```python
prenom = input("Ton prénom ? ") # renvoie toujours un str
age = int(input("Ton âge ? ")) # convertir pour calculer
print("Bonjour", prenom) # Bonjour Alice
print(f"{prenom} a {age} ans") # f-string
print(f"Prix : {12.5:.2f} €") # Prix : 12.50 €
print(f"{42:>6}") # ' 42' (aligné à droite sur 6)
print("a", "b", sep="-", end="!\n") # a-b!
```
---
## 2. Conditions (ch. 02)
```python
if note >= 16:
print("Très bien")
elif note >= 10:
print("Admis")
else:
print("Recalé")
```
| Comparaison | Logique |
|---|---|
| `==` égal, `!=` différent | `and` : les deux vrais |
| `<`, `<=`, `>`, `>=` | `or` : au moins un vrai |
| `in`, `not in` (appartenance) | `not` : inverse |
| `is None`, `is not None` | |
```python
if 0 <= age < 18: # comparaisons enchaînées
...
statut = "majeur" if age >= 18 else "mineur" # condition sur une ligne
match commande: # Python 3.10+
case "q" | "quitter":
print("Au revoir")
case "aide":
print("Commandes : ...")
case _:
print("Commande inconnue")
```
---
## 3. Boucles (ch. 03)
```python
for i in range(5): # 0, 1, 2, 3, 4
print(i)
range(2, 10) # 2 à 9
range(10, 0, -2) # 10, 8, 6, 4, 2
for lettre in "abc": # parcourt n'importe quel itérable
print(lettre)
compteur = 0
while compteur < 3:
compteur += 1
while True: # boucle infinie + sortie contrôlée
reponse = input("> ")
if reponse == "q":
break # sort de la boucle
if reponse == "":
continue # passe au tour suivant
print(reponse)
```
> `Ctrl + C` dans le terminal arrête un programme coincé dans une boucle infinie.
---
## 4. Listes (ch. 04)
```python
fruits = ["pomme", "banane", "kiwi"]
fruits[0] # "pomme" (premier)
fruits[-1] # "kiwi" (dernier)
fruits[1:3] # ["banane", "kiwi"]
len(fruits) # 3
"kiwi" in fruits # True
fruits.append("poire") # ajoute à la fin
fruits.insert(0, "fraise") # insère à l'indice 0
fruits.remove("banane") # retire la première occurrence
dernier = fruits.pop() # retire et renvoie le dernier
fruits.sort() # trie sur place
fruits.reverse() # inverse sur place
fruits.index("kiwi") # position d'un élément
fruits.count("pomme") # nombre d'occurrences
copie = fruits.copy() # vraie copie (ou fruits[:])
sum([1, 2, 3]), min([4, 2]), max([4, 2]) # 6, 2, 4
```
> **Attention** : `b = a` ne copie pas la liste, les deux noms désignent la même liste.
---
## 5. Tuples et ensembles (ch. 04)
```python
point = (3, 4) # tuple : non modifiable
x, y = point # déballage
a, b = b, a # échanger deux variables
couleurs = {"rouge", "vert"} # set : pas de doublons, pas d'ordre
couleurs.add("bleu")
couleurs.discard("vert")
set([1, 1, 2]) # {1, 2}
a, b = {1, 2, 3}, {2, 3, 4}
a | b # {1, 2, 3, 4} union
a & b # {2, 3} intersection
a - b # {1} différence
```
---
## 6. Dictionnaires (ch. 04)
```python
eleve = {"nom": "Alice", "age": 17}
eleve["nom"] # "Alice" (KeyError si absent)
eleve.get("ville") # None (pas d'erreur)
eleve.get("ville", "?") # "?" (valeur par défaut)
eleve["ville"] = "Lyon" # ajoute ou modifie
del eleve["age"] # supprime
"nom" in eleve # True (teste les clés)
for cle, valeur in eleve.items():
print(cle, valeur)
eleve.keys(), eleve.values()
compte = {}
compte["a"] = compte.get("a", 0) + 1 # compter des occurrences
```
---
## 7. Fonctions (ch. 05)
```python
def aire_rectangle(largeur, hauteur=1):
"""Renvoie l'aire d'un rectangle."""
return largeur * hauteur
aire_rectangle(3, 4) # 12
aire_rectangle(3) # 3 (hauteur par défaut)
aire_rectangle(hauteur=2, largeur=5) # 10 (arguments nommés)
def stats(*nombres, **options): # nombre variable d'arguments
print(nombres, options) # tuple, dict
stats(1, 2, 3, arrondi=2) # (1, 2, 3) {'arrondi': 2}
def min_max(valeurs):
return min(valeurs), max(valeurs) # renvoie un tuple
petit, grand = min_max([4, 1, 9])
```
> **Piège** : ne jamais mettre une liste ou un dict comme valeur par défaut (`def f(x=[])`). Utilise `None` puis crée la liste dans la fonction.
---
## 8. Chaînes de caractères (ch. 06)
```python
s = " Bonjour le Monde "
s.strip() # "Bonjour le Monde"
s.lower(), s.upper() # minuscules, majuscules
s.title() # " Bonjour Le Monde "
s.replace("Monde", "monde")
s.split() # ["Bonjour", "le", "Monde"]
"a,b,c".split(",") # ["a", "b", "c"]
"-".join(["a", "b", "c"]) # "a-b-c"
s.strip().startswith("Bon") # True
"monde" in s.lower() # True
s.count("o") # 3
s.find("le") # indice, ou -1 si absent
"42".isdigit() # True
mot = "Python"
mot[0], mot[-1] # "P", "n"
mot[1:4] # "yth"
mot[::-1] # "nohtyP" (inversé)
```
---
## 9. Compréhensions et outils d'itération (ch. 06)
```python
carres = [x ** 2 for x in range(5)] # [0, 1, 4, 9, 16]
pairs = [x for x in range(10) if x % 2 == 0] # [0, 2, 4, 6, 8]
longueurs = {mot: len(mot) for mot in ["a", "abc"]} # {'a': 1, 'abc': 3}
uniques = {x % 3 for x in range(10)} # {0, 1, 2}
for i, fruit in enumerate(["a", "b"], start=1): # 1 a / 2 b
print(i, fruit)
for nom, note in zip(["Ana", "Léo"], [14, 12]): # parcourt en parallèle
print(nom, note)
sorted([3, 1, 2]) # [1, 2, 3] (nouvelle liste)
sorted(mots, key=len, reverse=True) # trié par longueur décroissante
sorted(eleves, key=lambda e: e["note"]) # trié selon une clé
any(x > 5 for x in valeurs) # au moins un ?
all(x > 0 for x in valeurs) # tous ?
```
---
## 10. Fichiers, CSV, JSON (ch. 07)
```python
from pathlib import Path
# Texte
with open("notes.txt", "w", encoding="utf-8") as f: # w = écrase
f.write("Première ligne\n")
with open("notes.txt", "a", encoding="utf-8") as f: # a = ajoute
f.write("Suite\n")
with open("notes.txt", encoding="utf-8") as f: # r par défaut
for ligne in f:
print(ligne.strip())
chemin = Path("donnees") / "fichier.txt"
chemin.parent.mkdir(exist_ok=True)
chemin.write_text("bonjour", encoding="utf-8")
chemin.read_text(encoding="utf-8")
chemin.exists(), chemin.suffix, chemin.stem # True, ".txt", "fichier"
# CSV
import csv
with open("eleves.csv", "w", newline="", encoding="utf-8") as f:
ecrivain = csv.DictWriter(f, fieldnames=["nom", "note"])
ecrivain.writeheader()
ecrivain.writerow({"nom": "Ana", "note": 15})
with open("eleves.csv", newline="", encoding="utf-8") as f:
for ligne in csv.DictReader(f):
print(ligne["nom"], int(ligne["note"]))
# JSON
import json
donnees = {"nom": "Ana", "notes": [15, 12]}
with open("data.json", "w", encoding="utf-8") as f:
json.dump(donnees, f, ensure_ascii=False, indent=2)
with open("data.json", encoding="utf-8") as f:
donnees = json.load(f)
```
---
## 11. Exceptions (ch. 08)
```python
try:
nombre = int(input("Nombre : "))
resultat = 100 / nombre
except ValueError:
print("Ce n'est pas un nombre.")
except ZeroDivisionError:
print("Division par zéro impossible.")
else:
print(f"Résultat : {resultat}") # si aucune erreur
finally:
print("Toujours exécuté")
if age < 0:
raise ValueError("L'âge ne peut pas être négatif")
class SoldeInsuffisant(Exception): # exception personnalisée
pass
breakpoint() # met le programme en pause (débogueur)
```
---
## 12. Modules utiles (ch. 09)
```python
import random
random.randint(1, 6) # entier entre 1 et 6 inclus
random.choice(["a", "b"]) # élément au hasard
random.shuffle(liste) # mélange sur place
import math
math.sqrt(16), math.pi, math.ceil(2.1), math.floor(2.9) # 4.0, 3.14…, 3, 2
from datetime import date, datetime, timedelta
date.today()
datetime.now().strftime("%d/%m/%Y %H:%M")
date(2026, 12, 25) - date.today() # timedelta
date.today() + timedelta(days=7)
from collections import Counter, defaultdict
Counter("abracadabra").most_common(2) # [('a', 5), ('b', 2)]
groupes = defaultdict(list)
import os, sys
os.getcwd() # dossier courant
sys.argv # arguments de la ligne de commande
# Dans ses propres modules :
if __name__ == "__main__":
main() # exécuté seulement si on lance ce fichier directement
```
---
## 13. Classes (ch. 10 et 11)
```python
class Compte:
taux = 0.02 # attribut de classe (partagé)
def __init__(self, titulaire, solde=0):
self.titulaire = titulaire # attributs d'instance
self.solde = solde
def deposer(self, montant):
if montant <= 0:
raise ValueError("Montant invalide")
self.solde += montant
def __str__(self): # affichage pour l'utilisateur
return f"{self.titulaire} : {self.solde} €"
def __repr__(self): # affichage pour le développeur
return f"Compte({self.titulaire!r}, {self.solde})"
class CompteEpargne(Compte): # héritage
def __init__(self, titulaire, solde=0, plafond=10_000):
super().__init__(titulaire, solde)
self.plafond = plafond
c = CompteEpargne("Ana", 100)
c.deposer(50)
print(c) # Ana : 150 €
isinstance(c, Compte) # True
```
**Dataclass et propriété**
```python
from dataclasses import dataclass, field
@dataclass
class Produit:
nom: str
prix: float
tags: list[str] = field(default_factory=list)
@property
def prix_ttc(self) -> float: # s'utilise comme un attribut
return round(self.prix * 1.2, 2)
p = Produit("Stylo", 2.5)
p.prix_ttc # 3.0
```
---
## 14. Annotations de type (ch. 11)
```python
def moyenne(notes: list[float]) -> float:
return sum(notes) / len(notes)
def trouver(nom: str, annuaire: dict[str, str]) -> str | None:
return annuaire.get(nom)
age: int = 30
coordonnees: tuple[float, float] = (45.19, 5.72)
```
> Les annotations ne changent pas l'exécution : elles documentent le code et permettent à l'éditeur et à `mypy` de détecter des erreurs.
---
## 15. Commandes du terminal (ch. 00, 12, 13)
**Python et paquets**
| Action | macOS / Linux | Windows |
|---|---|---|
| Lancer un script | `python3 script.py` | `py script.py` ou `python script.py` |
| Version | `python3 --version` | `py --version` |
| Créer un venv | `python3 -m venv .venv` | `py -m venv .venv` |
| Activer le venv | `source .venv/bin/activate` | `.venv\Scripts\Activate.ps1` |
| Désactiver | `deactivate` | `deactivate` |
| Installer un paquet | `pip install requests` | `pip install requests` |
| Figer les dépendances | `pip freeze > requirements.txt` | idem |
| Réinstaller | `pip install -r requirements.txt` | idem |
| Lancer les tests | `pytest` | `pytest` |
| Vérifier / formater | `ruff check .` / `ruff format .` | idem |
**Navigation**
| Action | macOS / Linux | Windows (PowerShell) |
|---|---|---|
| Où suis-je ? | `pwd` | `pwd` |
| Lister | `ls` | `ls` ou `dir` |
| Changer de dossier | `cd dossier` / `cd ..` | idem |
| Créer un dossier | `mkdir nom` | idem |
**Git**
```bash
git init # créer un dépôt
git status # état des fichiers
git add fichier.py # préparer (ou git add .)
git commit -m "Message clair" # enregistrer une version
git log --oneline # historique
git diff # voir les modifications
git switch -c nouvelle-branche # créer une branche et y aller
git switch main # revenir sur main
git merge nouvelle-branche # fusionner
git remote add origin URL # lier à GitHub
git push -u origin main # envoyer
git pull # récupérer
git clone URL # copier un dépôt existant
```
---
## 16. Erreurs courantes et leur sens
| Erreur | Signification | Cause typique |
|---|---|---|
| `SyntaxError` | Python ne comprend pas la ligne | `:` oublié, parenthèse non fermée, guillemet manquant |
| `IndentationError` | Indentation incorrecte | Mélange tabulations/espaces, bloc mal aligné |
| `NameError: name 'x' is not defined` | Nom inconnu | Faute de frappe, variable utilisée avant d'être créée |
| `TypeError` | Opération impossible sur ce type | `"âge : " + 30`, mauvais nombre d'arguments |
| `ValueError` | Bon type, mauvaise valeur | `int("abc")` |
| `IndexError: list index out of range` | Indice trop grand | `liste[len(liste)]` |
| `KeyError` | Clé absente du dictionnaire | `d["cle"]` au lieu de `d.get("cle")` |
| `AttributeError` | Attribut ou méthode inexistant | `liste.push()` au lieu de `append()`, variable à `None` |
| `ZeroDivisionError` | Division par zéro | Diviseur non vérifié |
| `FileNotFoundError` | Fichier introuvable | Mauvais chemin, script lancé depuis un autre dossier |
| `ModuleNotFoundError` | Module introuvable | Paquet non installé, venv non activé |
| `RecursionError` | Trop d'appels récursifs | Cas de base manquant |
> **Règle d'or** : lis toujours un traceback **de bas en haut**. La dernière ligne dit *quoi*, les lignes au-dessus disent *où*.
---
[← Projet final](15-projet-final.md) | [Sommaire](README.md) | [Ressources →](ressources.md)

View file

@ -1,104 +0,0 @@
# Ressources pour continuer à apprendre
Une sélection de ressources fiables, classées par usage. Les ressources en français sont signalées par 🇫🇷 ; les autres sont en anglais, mais souvent faciles à suivre avec un traducteur.
> **Conseil** : ne cherche pas à tout consulter. Choisis **une** ressource principale par étape et complète avec de la pratique. Accumuler les tutoriels sans coder est le piège le plus courant.
---
## Documentation officielle
| Ressource | Pour quoi faire |
|---|---|
| 🇫🇷 [Tutoriel officiel Python](https://docs.python.org/fr/3/tutorial/) | La référence, traduite en français. Idéal pour revoir une notion après le chapitre correspondant. |
| 🇫🇷 [Bibliothèque standard](https://docs.python.org/fr/3/library/) | Tous les modules fournis avec Python (`random`, `datetime`, `pathlib`…). |
| 🇫🇷 [Glossaire Python](https://docs.python.org/fr/3/glossary.html) | Quand un terme technique t'échappe. |
| [PEP 8](https://peps.python.org/pep-0008/) | Les conventions d'écriture du code Python (vues au chapitre 13). |
---
## Outils pour comprendre son code
| Outil | Pour quoi faire |
|---|---|
| [Python Tutor](https://pythontutor.com/) | Visualise l'exécution ligne par ligne : variables, listes, appels de fonctions. Excellent pour les chapitres 03 à 05. |
| Le débogueur de VS Code | Points d'arrêt et exécution pas à pas (chapitre 08). |
---
## Cours et livres
### Pour débuter
- 🇫🇷 **Apprendre à programmer avec Python 3**, Gérard Swinnen — un classique, disponible gratuitement en PDF sur [le site de l'auteur](https://inforef.be/swi/python.htm) et en version papier chez Eyrolles.
- 🇫🇷 **OpenClassrooms** — cours d'initiation à Python, gratuits en ligne.
- 🇫🇷 **Zeste de Savoir** — tutoriels Python rédigés par la communauté, et un forum d'entraide.
- **Python Crash Course**, Eric Matthes — progression très claire, avec trois projets (jeu, data, web) en seconde partie.
- **Automate the Boring Stuff with Python**, Al Sweigart — gratuit en ligne sur [automatetheboringstuff.com](https://automatetheboringstuff.com/). Parfait pour l'automatisation (chapitre 14).
- **Think Python**, Allen Downey — gratuit en ligne, plus orienté « penser comme un programmeur ».
### Pour progresser
- **Real Python** ([realpython.com](https://realpython.com/)) — articles et tutoriels de qualité sur à peu près tous les sujets.
- **Fluent Python**, Luciano Ramalho — pour comprendre Python en profondeur une fois les bases solides (à garder pour après le cours).
- **Effective Python**, Brett Slatkin — des dizaines de bonnes pratiques concrètes.
---
## Plateformes d'exercices
| Plateforme | Niveau | Particularité |
|---|---|---|
| 🇫🇷 [France-IOI](https://www.france-ioi.org/) | Débutant → avancé | Exercices très progressifs, en français, avec correction automatique |
| [Exercism](https://exercism.org/tracks/python) | Débutant → intermédiaire | Exercices gratuits avec possibilité de retours de mentors bénévoles |
| [Codewars](https://www.codewars.com/) | Tous niveaux | Petits défis (« kata ») classés par difficulté ; on voit ensuite les solutions des autres |
| [CodinGame](https://www.codingame.com/) | Tous niveaux | Puzzles et jeux de programmation, ludique |
| [Advent of Code](https://adventofcode.com/) | Intermédiaire | 25 problèmes chaque décembre ; les archives des années passées restent disponibles |
| [Project Euler](https://projecteuler.net/) | Intermédiaire → avancé | Problèmes mathématiques à résoudre par le code |
> **Méthode** : après avoir résolu un exercice, lis deux ou trois solutions d'autres personnes. C'est l'un des meilleurs moyens d'apprendre de nouvelles façons d'écrire du code.
---
## Par spécialisation (chapitre 14)
| Domaine | Point de départ |
|---|---|
| Automatisation | *Automate the Boring Stuff with Python* ; documentation de `pathlib`, `requests`, `openpyxl` |
| Web | Tutoriel officiel de Flask, tutoriel de Django (« Écrire sa première application Django », traduit en français), documentation de FastAPI |
| Data | Guide « 10 minutes to pandas » dans la documentation de pandas ; cours gratuits de Kaggle Learn |
| IA / Machine learning | Tutoriels de scikit-learn ; Kaggle Learn ; cours gratuits de fast.ai pour le deep learning |
| Jeux | Documentation et tutoriels de pygame ; Arcade, une autre bibliothèque de jeux 2D |
---
## Communautés et entraide
- 🇫🇷 **AFPy** ([afpy.org](https://www.afpy.org/)) — l'Association Francophone Python, avec un forum, des offres d'emploi et l'organisation de la PyConFR.
- 🇫🇷 **Forum de Zeste de Savoir** — section programmation, bienveillante avec les débutants.
- **r/learnpython** sur Reddit — très actif, questions de débutants bienvenues.
- **Stack Overflow** — l'immense majorité des messages d'erreur y a déjà une réponse ; cherche avant de poster.
- **Meetups Python locaux** — beaucoup de grandes villes ont des rencontres régulières ; regarde sur Meetup ou sur le site de l'AFPy.
### Bien poser une question
Une bonne question obtient une réponse rapide. Elle contient :
1. **Ce que tu veux faire** (le but, pas seulement le problème technique).
2. **Le code minimal** qui reproduit le problème, formaté comme du code.
3. **Le message d'erreur complet**, copié-collé (pas une capture d'écran).
4. **Ce que tu as déjà essayé.**
5. Ta version de Python et ton système d'exploitation si c'est pertinent.
---
## Rester motivé
- **Code sur des sujets qui t'intéressent** : un script pour ta passion, ton travail, tes jeux. La motivation intrinsèque est le meilleur carburant.
- **Garde une trace de tes progrès** : un dépôt GitHub qui se remplit est très encourageant à regarder après quelques mois.
- **Accepte d'être bloqué** : c'est l'état normal d'un programmeur, même expérimenté. Chaque bug résolu est une compétence acquise.
- **Explique ce que tu apprends** à quelqu'un d'autre (ou à un canard en plastique). Si tu peux l'expliquer simplement, tu l'as compris.
---
[← Aide-mémoire](aide-memoire.md) | [Sommaire](README.md)

View file

@ -181,53 +181,45 @@ Une exécution réussie encadre le build par une ligne `Deploy started` et une l
---
## Ce que le build publie pour alpinux.org
## Ce que le build publie pour la page d'accueil
Chaque build écrit deux fichiers à la racine du site, avec pour chaque page son titre,
son adresse et la date du commit qui a touché son contenu :
Chaque build écrit, à la racine du site, un fichier
**[`derniers-articles.json`](https://wiki.alpinux.org/derniers-articles.json)** : les
vingt dernières pages créées ou modifiées, avec leur titre, leur URL et la date du commit
qui a touché leur contenu. C'est ce fichier que lit la page d'accueil
[alpinux.org](https://alpinux.org) pour afficher « Le wiki, fraîchement mis à jour ».
| Fichier | Ce qu'il porte | Qui le lit |
|---|---|---|
| `derniers-articles.json` | Les vingt dernières pages créées ou modifiées | L'accueil d'alpinux.org, section « Le wiki, fraîchement mis à jour » |
| `toutes-les-pages.json` | Toutes les pages, sans limite, avec leur rubrique | La page des mises à jour d'alpinux.org |
Il est produit par le hook `hooks/derniers_articles.py`, déclaré dans `mkdocs.yml`. Trois
choses à savoir :
Le second est la liste entière, le premier son début : un seul parcours de l'historique
git les produit tous les deux, et ils portent la même date de génération.
- **Un déplacement n'est pas une mise à jour.** Les dates viennent de `git log` avec suivi
des renommages : déplacer `guides/truc.md` ne fait pas remonter l'article en tête de
liste, seule une modification de son texte le fait.
- **Seules les pages de la navigation sont annoncées.** Une page hors `nav` — typiquement
la redirection laissée derrière un article déplacé — n'apparaît jamais dans la liste.
- **Le hook n'échoue jamais.** Sans historique git, il n'écrit rien et le build continue ;
l'accueil d'alpinux.org masque alors simplement sa section wiki. Ses messages sont pour
cela de niveau *info* et jamais *warning* : le déploiement construit avec `--strict`, où
un seul avertissement suffit à interrompre le build et donc la publication.
Ils sont produits par le hook `hooks/derniers_articles.py`, déclaré dans `mkdocs.yml`.
Trois choses à savoir :
!!! warning "Deux conditions côté serveur"
**Le clone doit avoir son historique.** Un clone `--depth 1` ne porte qu'un commit :
toutes les pages sembleraient modifiées le même jour. Le hook le détecte et le
signale dans le journal du build, sans rien casser.
- **Un déplacement n'est pas une mise à jour.** Les dates viennent de `git log` avec
suivi des renommages : déplacer `guides/truc.md` ne fait pas remonter l'article en
tête de liste, seule une modification de son texte le fait.
- **Seules les pages de la navigation sont annoncées.** Une page absente de `nav` —
typiquement la redirection laissée derrière un article déplacé — n'apparaît jamais
dans la liste.
- **Le hook n'échoue jamais.** Sans historique git, il n'écrit rien et le build
continue ; alpinux.org masque alors simplement ce qu'il ne peut pas remplir. Ses
messages sont pour cela de niveau *info* et jamais *warning* : le déploiement
construit avec `--strict`, où un seul avertissement suffit à interrompre le build,
et donc la publication.
**Le `.htaccess` du DocumentRoot est réécrit à chaque déploiement.** Le hook le
dépose dans le staging, que `rsync --delete` recopie intégralement : un `.htaccess`
qui aurait été posé à la main sur le serveur serait effacé au premier build. S'il
faut d'autres règles Apache, ajoutez-les dans le hook — c'est désormais lui qui fait
foi.
Le même hook pose l'en-tête `Access-Control-Allow-Origin` sur ces deux fichiers, et
sur eux seuls, au moyen d'un `.htaccess` déposé à la racine du site construit. Sans
lui, le navigateur refuserait à alpinux.org le droit de lire une réponse venue de
wiki.alpinux.org.
!!! warning "Deux conditions"
**Le clone doit avoir son historique.** Un clone `--depth 1` ne porte qu'un
commit : toutes les pages sembleraient modifiées le même jour. Le hook le détecte
et le signale dans le journal du build, sans rien casser.
**Un `.htaccess` posé à la main sur le serveur est effacé au déploiement suivant**,
puisque le staging est recopié avec `rsync --delete`. Pour ajouter des règles
Apache durables, placez-les dans `docs/.htaccess` : MkDocs le recopie dans le site
construit, et le hook **ajoute** son bloc à la suite au lieu de le remplacer.
Le même hook dépose un `.htaccess` d'une ligne utile : il autorise les autres sous-domaines
à lire ce seul fichier JSON (`Access-Control-Allow-Origin`). Sans lui, le navigateur
refuserait à alpinux.org le droit de lire une réponse venue de wiki.alpinux.org.
```bash
# vérifier ce que le dernier build a publié
curl -s https://wiki.alpinux.org/derniers-articles.json | head -20
curl -s https://wiki.alpinux.org/toutes-les-pages.json | head -20
```
---
@ -264,5 +256,4 @@ Ouvrez [http://localhost:8000](http://localhost:8000) — MkDocs recharge automa
| Déployer à la main (webhook en panne) | `deploy-wiki.sh`, sur le serveur |
| Voir le journal des déploiements | `tail -20 /var/log/wiki-deploy.log` |
| Vérifier la liste envoyée à l'accueil | `curl -s https://wiki.alpinux.org/derniers-articles.json` |
| Vérifier l'inventaire complet publié | `curl -s https://wiki.alpinux.org/toutes-les-pages.json` |
| Régénérer les fichiers du logo (poste local) | `python3 scripts/build-assets.py` |

View file

@ -1,169 +0,0 @@
---
description: Le serveur qu'Alpinux emporte en install party — partage de connexion, réseau local, cache de paquets APT, page de santé, et ce qu'un bénévole doit en savoir sur place.
---
# Le serveur qu'on emporte en install party
Quinze ordinateurs qui s'installent le même matin, c'est quinze fois les mêmes
cinq cents mégaoctets tirés par la ligne de la salle — quand il y en a une. Alpinux
apporte donc sa propre machine, **alpicache**, qui partage l'accès à Internet, sert un
réseau local aux postes en cours d'installation, et **garde en cache les paquets déjà
téléchargés**.
!!! note "Pour qui est cette page"
Pour les bénévoles qui installent, et pour qui prépare la salle. La configuration
complète de la machine — interfaces, services, dépannage détaillé — vit dans son
propre dépôt, `alpinux.alpicache`, et non ici.
---
## Le réseau de la salle
```mermaid
flowchart LR
A[Prise murale<br/>ou box de la salle] --> B[alpicache<br/>10.0.0.1]
B --> C[Switch]
C --> D[Poste 1]
C --> E[Poste 2]
C --> F[Poste n]
```
La machine tient les deux bouts : d'un côté elle demande un accès à la salle, de l'autre
elle distribue un réseau en **10.0.0.x** aux postes branchés sur le switch. Les rôles ne
sont pas figés à l'avance : elle désigne comme sortie la première prise où on lui répond,
et sert le réseau local sur l'autre.
!!! warning "Les postes se branchent sur le switch, jamais sur la box"
Un poste branché directement sur la box de la salle reçoit une adresse de la salle :
il ne voit plus le cache, ne trouve plus les scripts, et fait tomber les compteurs à
zéro. C'est l'erreur la plus fréquente, et elle ne se voit pas tout de suite.
---
## Ce que la machine offre, une fois branchée
| Adresse | À quoi ça sert |
| --- | --- |
| **<http://alpicache.lan/>** | La page de santé : réseau, disques, machines servies, cache |
| **`http://apt-proxy:3142`** | Le cache de paquets, à déclarer comme mandataire |
| **`http://10.0.0.1/`** | Les scripts d'Alpinux, servis sur place — dont `verif-disque.sh` et `install.sh` |
La page de santé se rafraîchit seule ; c'est le tableau de bord de la journée. Quatre
cartes à surveiller :
| Carte | Ce qu'on veut y voir |
| --- | --- |
| **Réseau** | une sortie *et* un réseau local nommés, « Internet joignable » |
| **Disques** | le disque du cache présent, avec de la place |
| **Machines servies** | le nombre grandit à mesure que les postes arrivent |
| **Cache de paquets** | « Économisé » qui monte au fil de la matinée |
**« Machines servies » qui reste à zéro** alors que des postes sont branchés, c'est le
signe que le réseau local ne distribue pas d'adresses : prévenez la personne qui tient la
machine plutôt que de chercher sur le poste du participant.
---
## Faire passer une installation par le cache
C'est là que tout se joue, et le geste n'est pas le même selon le système.
### Debian
L'installateur demande un mandataire à l'écran **« Configurer le miroir de l'archive
Debian »**. Saisissez-y :
```
http://apt-proxy:3142
```
C'est **le seul moment** où on peut le faire, et c'est celui qui compte : toute
l'installation passe alors par le cache.
### Linux Mint et Ubuntu
Leur installateur ne demande pas de mandataire : l'installation elle-même sortira sur
Internet. Le gain arrive juste après — sur les mises à jour et les logiciels ajoutés,
c'est-à-dire sur l'essentiel du volume.
Une fois la machine redémarrée sur son nouveau système :
```bash
sudo apt install auto-apt-proxy
```
Ce paquet cherche un cache sur le réseau local et s'en sert quand il en trouve un — sans
rien à configurer, et sans gêner la machine une fois rentrée chez son propriétaire.
!!! tip "Le script de post-installation le fait déjà"
Le [script d'Alpinux](../guides/linux-mint-depuis-windows.md#le-script-de-post-installation-alpinux)
installe `auto-apt-proxy` parmi ses réglages : si vous le lancez, c'est fait.
---
## Ce qui coince, et la parade
**La salle n'a pas de réseau.** Un téléphone Android en partage de connexion USB fait
l'affaire : branché sur la machine, il devient la sortie. Prévoyez le câble.
**Le disque du cache n'est pas vu.** Il doit être branché **avant** d'allumer la machine.
Après coup, le cache démarre sans rien dire et ne garde rien — la carte *Disques* de la
page de santé le montre tout de suite.
**Un poste n'obtient pas d'adresse.** Vérifiez d'abord le câble et le switch, puis la
carte *Machines servies*. Une adresse en `169.254.x.x` signifie que le poste n'a reçu
aucune réponse : il s'en est inventé une.
**`apt` renvoie des « 503 Connection closed » en série.** Le cache accepte la requête mais
ne sait pas où aller la chercher — c'est arrivé le 24/09/2026, et une installation Mint
s'y est arrêtée. Le piège est qu'**interroger le cache directement répond parfaitement** :
les deux chemins ne suivent pas la même route à l'intérieur du serveur. Ne cherchez donc
pas sur la machine du participant : prévenez la personne qui tient le serveur.
---
## Pour préparer une install party
La veille, la machine s'allume chez quelqu'un, sur une ligne rapide, et l'on garnit le
cache avec ce qu'on va installer — si la version de Mint a changé depuis la dernière
sortie, autant la tirer maintenant.
!!! warning "Le cache ne sert que ce qu'il connaît"
Le pré-chargement vise des versions nommées, et une version absente de la liste ne
profite à personne. Le 24/09/2026, la première Mint 22.3 de la soirée a tiré **1,3 Go
d'Internet pour 82 Mo servis par le cache** : le pré-chargeur couvrait encore les
versions précédentes.
Avant chaque sortie, vérifiez donc que la liste des versions pré-chargées correspond à
celle que vous allez réellement installer. C'est par le **nom de code** que le
pré-chargement les désigne, et un décalage d'un cran suffit à garnir le cache de la
mauvaise version :
| Version | Nom de code |
|---|---|
| Mint 22 | `wilma` |
| Mint 22.1 | `xia` |
| Mint 22.2 | `zara` |
| Mint 22.3 | `zena` |
Pour mémoire, la série précédente : `vanessa` (21), `vera` (21.1), `victoria` (21.2),
`virginia` (21.3).
Sur place, l'ordre de branchement n'est pas une superstition : le disque externe d'abord,
puis le câble Internet **seul**, puis la machine, et seulement ensuite le switch et les
postes. Brancher la sortie seule d'abord, c'est ôter à la machine toute occasion de se
tromper de rôle.
La procédure complète — ce qu'on emporte, les vérifications, le dépannage, la fiche à
cocher pour chaque participant et l'affiche à scotcher près du switch — est dans le dépôt
`alpinux.alpicache`. Demandez-la à un membre du bureau avant une sortie.
---
## Voir aussi
- [Install Party](../alpinux/install-party.md) — les dates, et comment y participer
- [Installer Linux Mint depuis Windows](../guides/linux-mint-depuis-windows.md) — le guide
suivi sur place
- [Préparation d'un serveur Debian 13](serveur-debian-13.md) — pour la machine, la base
système est la même

View file

@ -1,88 +1,68 @@
"""Publie ce que le wiki a écrit ou repris, pour qui l'affiche ailleurs.
"""Publie « derniers-articles.json » : les pages récemment créées ou modifiées.
Deux fichiers, écrits à chaque build à côté des pages et servis avec l'en-tête CORS
sans lequel un autre domaine ne peut pas les lire :
Le fichier est écrit à la racine du site construit, à côté de `sitemap.xml`, et sert
la page d'accueil de https://www.alpinux.org — d'où le petit `.htaccess` qui l'ouvre
aux requêtes venues d'un autre sous-domaine.
- `derniers-articles.json` — les vingt dernières pages touchées, que la page d'accueil
d'alpinux.org lit pour sa section « Le wiki, fraîchement mis à jour » ;
- `toutes-les-pages.json` — le même inventaire, sans limite de nombre et avec la
rubrique de chaque page, pour la page des mises à jour d'alpinux.org.
Les dates viennent de git, pas du système de fichiers : c'est la date du commit qui a
touché le contenu de la page. **Un déplacement n'est pas une mise à jour** — renommer
`guides/truc.md` ne fait pas remonter l'article ; seule une modification de son texte
le fait.
Les deux sortent du même calcul : le second est la liste entière, le premier son
début.
Le hook n'échoue jamais : sans git, ou en cas d'erreur, il n'écrit simplement rien et
le build continue (le site reste valide, la page d'accueil garde ses tuiles statiques).
Les dates viennent de git, pas du système de fichiers : un `git clone` repose tous les
fichiers à la même seconde, et une page recopiée depuis Obsidian aurait l'air neuve.
Les renommages sont ignorés (`-M`, statut `R` écarté) — déplacer un article ne le rend
pas nouveau.
Ses messages sont volontairement de niveau *info* et jamais *warning* : le déploiement
construit le site avec `--strict`, où le moindre avertissement interrompt le build. Un
hook d'agrément ne doit pas pouvoir empêcher la publication du wiki.
"""
from __future__ import annotations
import json
import logging
import subprocess
from datetime import datetime, timedelta, timezone
from pathlib import Path
from urllib.parse import urljoin
from mkdocs.plugins import log
log = logging.getLogger("mkdocs.hooks.derniers_articles")
FICHIER_RECENTS = "derniers-articles.json"
FICHIER_TOUTES = "toutes-les-pages.json"
# Ce que le premier fichier porte au plus. L'accueil n'en affiche que six, mais le
# fichier sert aussi à qui voudrait en faire autre chose. Le second ne plafonne pas.
NB_MAX = 20
# En deçà, un article est annoncé comme « publié » plutôt que « mis à jour ».
JOURS_NOUVEAU = 45
# Les pages d'accueil de section n'annoncent rien : elles listent ce qu'il y a dessous.
EXCLUS = {"index.md"}
FICHIER = "derniers-articles.json"
NB_MAX = 20 # articles retenus dans le JSON
JOURS_NOUVEAU = 45 # en deçà, l'article est signalé comme nouveau
EXCLUS = {"index.md"} # l'accueil du wiki n'est pas un article
# Pages construites, remplies au fil du build : chemin source -> titre et URL.
_pages: dict[str, dict[str, str]] = {}
# Pages réellement présentes dans la navigation : les seules annoncées.
_dans_la_nav: set[str] = set()
_rubriques: dict[str, str] = {}
def _rubrique_par_page(items, rubrique=""):
"""Associe chaque page de la navigation au titre de la section qui la porte.
On garde la section de premier niveau — « Guides », « Contribuer » — plutôt que la
plus proche : c'est l'échelle à laquelle un lecteur range les pages.
"""
for item in items:
if item.is_section:
yield from _rubrique_par_page(item.children, rubrique or item.title)
elif item.is_page:
yield item.file.src_uri, rubrique
def on_nav(nav, config, files):
"""Retient les pages de la navigation, et sous quelle rubrique elles vivent.
"""Retient les pages de la navigation.
Ce qui en est absent — les redirections laissées derrière un article déplacé, par
exemple — n'a pas à être annoncé comme une nouveauté.
"""
_dans_la_nav.clear()
_dans_la_nav.update(page.file.src_uri for page in nav.pages)
_rubriques.clear()
_rubriques.update(_rubrique_par_page(nav.items))
return nav
def on_page_context(context, page, config, nav):
"""Retient le titre et l'URL de chaque page rendue."""
_pages[page.file.src_uri] = {
"titre": page.title,
"titre": page.title or page.file.src_uri,
"url": urljoin(config["site_url"] or "", page.url),
}
return context
def _git(depot: Path, *args: str) -> str:
return subprocess.run(
["git", "-C", str(depot), *args],
capture_output=True, text=True, check=True,
capture_output=True, text=True, check=True, timeout=30,
).stdout
@ -95,141 +75,115 @@ def _est_superficiel(depot: Path) -> bool:
def _historique(depot: Path, dossier: str) -> tuple[dict, dict]:
"""Rend deux tables chemin → date ISO : dernière écriture, et première.
"""Retourne (dernière modification, date de création) par chemin actuel.
`git log` remonte le temps : la première date vue pour un fichier est la plus
récente, la dernière est celle de sa création.
Le journal est parcouru du plus récent au plus ancien. Les renommages sont suivis
— pour rattacher l'histoire d'un article déplacé à son chemin actuel — mais ne
comptent pas comme une modification.
"""
sortie = _git(
depot, "log", "--no-merges", "-M", "--name-status", "--format=%x01%aI",
"--", dossier,
depot, "log", "--no-merges", "-M", "--name-status",
"--format=%x01%aI", "--", dossier,
)
modifiees: dict[str, str] = {}
creees: dict[str, str] = {}
alias: dict[str, str] = {} # chemin d'alors -> chemin actuel
modifiees: dict[str, str] = {} # chemin actuel -> date de la dernière modification
creees: dict[str, str] = {} # chemin actuel -> date de création
date = ""
for ligne in sortie.splitlines():
if ligne.startswith("\x01"):
date = ligne[1:].strip()
continue
if not ligne or not date:
if not ligne.strip() or not date:
continue
champs = ligne.split("\t")
statut = champs[0]
if statut.startswith("R"): # renommage : le contenu n'a pas bougé
if statut.startswith("R") and len(champs) >= 3:
ancien, nouveau = champs[1], champs[2]
alias[ancien] = alias.pop(nouveau, nouveau)
continue
chemin = champs.pop()
chemin = alias.get(champs[-1], champs[-1])
if not chemin.endswith(".md"):
continue
modifiees.setdefault(chemin, date)
if statut == "A":
creees[chemin] = date # on remonte le temps : le dernier vu est le bon
if statut.startswith("A"):
creees[chemin] = date
if statut.startswith(("A", "M")):
modifiees.setdefault(chemin, date)
return modifiees, creees
def _autoriser_la_lecture_croisee(site_dir: Path, fichiers: list[str]) -> None:
"""Pose l'en-tête CORS sur les seuls fichiers qui en ont besoin.
Ils sont lus depuis alpinux.org : sans cet en-tête, le navigateur refuse la
réponse et la section reste masquée. Le bloc s'ajoute à un `.htaccess` déjà là
plutôt que de le remplacer — on ne sait pas ce qu'il porte d'autre — et n'est
écrit que pour les fichiers qui n'y figurent pas encore.
"""
fichier = site_dir / ".htaccess"
existant = fichier.read_text(encoding="utf-8") if fichier.exists() else ""
manquants = [nom for nom in fichiers if nom not in existant]
if not manquants:
return
bloc = "<IfModule mod_headers.c>\n"
for nom in manquants:
bloc += (
f' <Files "{nom}">\n'
' Header set Access-Control-Allow-Origin "*"\n'
" </Files>\n"
)
bloc += "</IfModule>\n"
separateur = "\n" if existant and not existant.endswith("\n") else ""
fichier.write_text(existant + separateur + bloc, encoding="utf-8")
def on_post_build(config):
site_dir = Path(config["site_dir"])
docs_dir = Path(config["docs_dir"])
depot = docs_dir.parent
dossier = docs_dir.name
try:
modifiees, creees = _historique(depot, docs_dir.name)
modifiees, creees = _historique(depot, dossier)
except (OSError, subprocess.SubprocessError) as erreur:
log.info("derniers-articles : historique git illisible (%s), fichier non écrit",
erreur)
log.info("derniers-articles : historique git illisible (%s), fichier non écrit", erreur)
return
if _est_superficiel(depot):
log.info("derniers-articles : clone superficiel, les dates ne sont pas fiables")
seuil = datetime.now(timezone.utc) - timedelta(days=JOURS_NOUVEAU)
pages = []
limite = datetime.now(timezone.utc) - timedelta(days=JOURS_NOUVEAU)
articles = []
for chemin, modifiee in modifiees.items():
prefixe = docs_dir.name + "/"
if not chemin.startswith(prefixe):
continue
src_uri = chemin[len(prefixe):]
for chemin, date in modifiees.items():
source = chemin[len(dossier) + 1:] if chemin.startswith(dossier + "/") else chemin
page = _pages.get(source)
if page is None or source in EXCLUS or source not in _dans_la_nav:
continue # page supprimée, hors navigation, ou volontairement écartée
page = _pages.get(src_uri)
if page is None or Path(src_uri).name in EXCLUS or src_uri not in _dans_la_nav:
continue
creee = creees.get(chemin, modifiee)
creation = creees.get(chemin, date)
try:
nouveau = datetime.fromisoformat(creee) >= seuil
nouveau = datetime.fromisoformat(creation) >= limite
except ValueError:
nouveau = False
pages.append({
"titre": page["titre"],
"url": page["url"],
"date": creee if nouveau else modifiee,
"nouveau": nouveau,
"rubrique": _rubriques.get(src_uri, ""),
articles.append({
"titre": page["titre"],
"url": page["url"],
"date": date,
"nouveau": nouveau,
})
if not pages:
if not articles:
log.info("derniers-articles : aucune page datée, fichier non écrit")
return
pages.sort(key=lambda page: page["date"], reverse=True)
genere = datetime.now(timezone.utc).replace(microsecond=0).isoformat()
# L'accueil lit ce fichier depuis longtemps : il garde ses quatre clés, sans la
# rubrique dont il n'a que faire.
recents = [
{clef: page[clef] for clef in ("titre", "url", "date", "nouveau")}
for page in pages[:NB_MAX]
]
ecrits = {
FICHIER_RECENTS: {"genere": genere, "articles": recents},
FICHIER_TOUTES: {"genere": genere, "pages": pages},
}
articles.sort(key=lambda a: a["date"], reverse=True)
articles = articles[:NB_MAX]
try:
for nom, contenu in ecrits.items():
texte = json.dumps(contenu, ensure_ascii=False, indent=2) + "\n"
(site_dir / nom).write_text(texte, encoding="utf-8")
_autoriser_la_lecture_croisee(site_dir, list(ecrits))
(site_dir / FICHIER).write_text(
json.dumps(
{"genere": datetime.now(timezone.utc).isoformat(timespec="seconds"),
"articles": articles},
ensure_ascii=False, indent=2,
) + "\n",
encoding="utf-8",
)
# La page d'accueil est sur un autre sous-domaine : sans cet en-tête, le
# navigateur refuse de lui laisser lire le fichier.
(site_dir / ".htaccess").write_text(
"<IfModule mod_headers.c>\n"
f' <Files "{FICHIER}">\n'
' Header set Access-Control-Allow-Origin "*"\n'
" </Files>\n"
"</IfModule>\n",
encoding="utf-8",
)
except OSError as erreur:
log.info("derniers-articles : écriture impossible (%s), fichier non écrit",
erreur)
log.info("derniers-articles : écriture impossible (%s), fichier non écrit", erreur)
return
log.info("derniers-articles : %d page(s) publiée(s) dans %s, %d dans %s",
len(pages), FICHIER_TOUTES, len(recents), FICHIER_RECENTS)
log.info("derniers-articles : %d article(s) publié(s) dans %s", len(articles), FICHIER)

View file

@ -29,6 +29,9 @@ theme:
icon:
repo: fontawesome/brands/git-alt
hooks:
- hooks/derniers_articles.py
extra_css:
- stylesheets/alpinux.css
@ -66,10 +69,6 @@ extra:
copyright: "© Alpinux — LUG de Savoie | <a href='https://portail.alpinux.org'>Portail</a>"
hooks:
# Écrit derniers-articles.json, que lit la page d'accueil d'alpinux.org.
- hooks/derniers_articles.py
nav:
- Accueil: index.md
- Contribuer:
@ -82,19 +81,8 @@ nav:
- alpinux/index.md
- FAQ: alpinux/faq.md
- Install Party: alpinux/install-party.md
- Le site des install parties:
- alpinux/installparty-mode-emploi.md
- Je viens faire installer Linux: alpinux/installparty-participant.md
- J'aide comme bénévole: alpinux/installparty-benevole.md
- J'organise une install party: alpinux/installparty-organisateur.md
- Présentations passées: alpinux/presentations.md
- Événements & RDV: alpinux/evenements.md
- Messagerie et listes:
- alpinux/messagerie.md
- S'abonner et se désabonner: alpinux/messagerie-abonnement.md
- Écrire et recevoir des messages: alpinux/messagerie-membre.md
- Gérer une liste de diffusion: alpinux/messagerie-gestionnaire.md
- Vos données, vos adresses, nos envois: alpinux/donnees-personnelles.md
- Présentations:
- presentations/libreoffice.md
- presentations/kicad.md
@ -111,10 +99,6 @@ nav:
- guides/sauvegardes.md
- guides/tesseract.md
- guides/ventoy.md
- Apprendre:
- apprendre/index.md
- Une semaine pour découvrir Linux: apprendre/semaine-college-lycee.md
- "Fiche : le terminal": apprendre/terminal-se-reperer.md
- Technique:
- technique/deploiement-wiki.md
- technique/deploiement-dynamic.md
@ -123,9 +107,6 @@ nav:
- technique/matrix.md
- technique/arduino-ide.md
- technique/serveur-debian-13.md
- technique/serveur-install-party.md
- technique/bigbluebutton.md
- technique/ateliers.md
- Communication:
- communication/index.md
- Liens et codes QR: communication/liens-et-codes-qr.md
- Communication: communication/index.md