Public cible
- Débutants : Personnes découvrant le domaine ou ayant peu d'expérience.
- Intermédiaires : Personnes ayant déjà une expérience de base dans le domaine.
- Étudiants : Étudiants en formation initiale.
Préparer un poste de développement reproductible, versionné et sûr avec une procédure de démarrage et de diagnostic.
Comprendre les notions essentielles et les appliquer dans un projet vérifiable.
Aucune connaissance préalable n’est strictement obligatoire ; les prérequis détaillés sont précisés dans les ateliers.
Bac+2
Installer un poste de développement et vérifier sa reproductibilité.
Obligatoire ConsulterÉvaluer les outils, la configuration et la sécurisation du poste.
Obligatoire ConsulterLivrer un script d'installation et une documentation de démarrage.
Livrables :
Installer un poste de développement et vérifier sa reproductibilité.
Obligatoire ConsulterÉvaluer les outils, la configuration et la sécurisation du poste.
Obligatoire ConsulterLivrer un script d'installation et une documentation de démarrage.
Livrables :
Préparer un poste reproductible, versionné et sûr afin que chaque intervenant réseau puisse installer, exécuter et diagnostiquer le projet sans dépendre d’un poste invisible.
Le cours suit les prérequis, les couches d’exécution, l’outillage réseau, Git, la configuration, l’automatisation et la vérification finale du poste.
Prérequis : Bases de la ligne de commande et du développement logiciel.
Commencer par identifier la version du système, le langage, le gestionnaire de paquets et les services attendus. Installer seulement les outils nécessaires et conserver leurs versions dans un fichier de configuration.
Créer un dossier de travail stable et un compte utilisateur non privilégié. Les installations système qui demandent des droits doivent être documentées avec leur raison.
git --version; node --version; composer --version; php -v
Un intervenant réseau enchaîne plusieurs couches d’exécution : le poste porte le système et les droits, l’éditeur et le terminal portent la pratique, le navigateur valide les services, le conteneur et la machine virtuelle reproduisent un contexte d’intervention. Chaque couche se juge sur trois critères : la reproductibilité, le versionnage, l’isolation.
La reproductibilité répond à la question : un collègue obtient-il le même résultat sur son poste ? Le versionnage répond à : la description de l’environnement est-elle stockée dans le dépôt ? L’isolation répond à : une manipulation dangereuse reste-t-elle confinée ?
Le bon réflexe n’est pas de chercher la meilleure machine mais de retenir la couche la plus légère qui satisfait les trois critères. On monte en isolation pour tester un comportement destructeur, on redescend en légèreté pour obtenir un retour immédiat.
Un poste doit pouvoir être reconstruit sans lui : la couche la plus lourde du schéma sert alors de référence, tandis que les couches légères servent au travail quotidien.
| Couche | Usage principal | Isolation apportée |
|---|---|---|
| Poste physique | Outillage quotidien et accès d’administration | Aucune : une erreur touche le système |
| Éditeur et terminal | Écriture, exécution et diagnostic rapide | Faible : les processus sont partagés |
| Navigateur | Validation d’un service HTTP et console d’administration | Moyenne : profil et cache séparés |
| Conteneur | Service reproductible et test d’une version | Forte : système de fichiers isolé |
| Machine virtuelle | Réseau complet, image d’usine et restauration | Totale : noyau et réseau dédiés |
Ne jamais tester une configuration risquée directement sur le réseau de production. On la rejoue d’abord dans une couche isolée : la panne provoquée ne coûte alors qu’un redémarrage de la couche, pas une intervention d’urgence.
Le terminal est le point d’entrée unique : il exécute la même commande sur tous les postes, se copie dans un compte rendu et se relit en cas de doute. Tous les autres outils se découvrent dans ce cadre.
Le client SSH donne l’accès distant à un équipement ; l’authentification par clé remplace le mot de passe, qui voyage en clair dans l’historique et les captures. La capture de paquets prouve qu’une trame circule réellement et montre ce qu’elle porte, là où une simple réponse réseau ne prouve rien.
Le testeur de câble vérifie la continuité, l’ordre des paires et situe un défaut à une distance ; il distingue une coupure d’une inversion, deux pannes que l’on confond sans instrument. Les clients DNS, avec dig et nslookup, valident la résolution d’un nom et les enregistrements publiés.
Le client HTTP, curl, interroge un service et affiche le code de retour et les en-têtes : c’est le seul moyen de prouver qu’un service répond correctement, indépendamment du navigateur. L’interpréteur de requêtes réseau complète l’ensemble en construisant une requête à la main, ce qui permet de tester une interface sans dépendre d’une page web.
ssh -i cle_intervenant intervenant@10.10.20.1
dig +short A equipement.test
nslookup equipement.test 10.10.20.10
curl -sS -I https://127.0.0.1:8001/health
| Outil | Ce qu’il prouve | Commande ou manipulation de référence |
|---|---|---|
| Terminal | Que la commande et ses arguments sont exacts | uname -a; ip a |
| Client SSH | Que le service distant répond et que la clé est acceptée | ssh -i cle_intervenant intervenant@10.10.20.1 |
| Capture de paquets | Que la trame circule et ce qu’elle transporte | tcpdump -ni eth0 port 67 or port 68 |
| Testeur de câble | Continuité, ordre des paires et distance du défaut | Test de la liaison, puis du brassage |
| Client DNS | La résolution du nom et l’enregistrement publié | dig +short A equipement.test |
| Client HTTP | Le code de retour et les en-têtes du service | curl -sS -I https://127.0.0.1:8001/health |
| Interpréteur de requêtes | Le comportement de l’interface hors navigateur | Requête GET ou POST, en-têtes et corps |
Capturer le trafic n’autorise pas à en lire librement le contenu : on n’intervient que sur des réseaux dont on a la charge, et une capture partagée est anonymisée. Une capture contient des mots de passe, des jetons et des données personnelles.
Séparer les dépendances figées dans le gestionnaire de paquets des secrets fournis par l’environnement. Un fichier d’exemple décrit les noms de variables sans contenir de valeur sensible.
Un script de bootstrap installe les dépendances, crée la base de test et vérifie les commandes essentielles. Il doit être idempotent et produire un message clair en cas d’échec.
APP_ENV=dev; DB_HOST=127.0.0.1; DB_NAME=app; SECRET=<via un gestionnaire de secrets>
Initialiser ou cloner le dépôt, configurer une identité de développement, puis vérifier la branche courante avant toute modification. Les commits doivent raconter une intention testable.
Ne pas versionner les secrets, les caches, les dépendances ou les fichiers générés. Utiliser un fichier d’exemple et documenter le mécanisme de rotation des secrets.
Un dépôt est un historique partagé : ce qui y entre reste lisible même après une suppression. La règle n’est donc pas de faire attention, c’est de ne jamais laisser entrer.
On versionne tout ce qui décrit l’environnement : scripts d’installation, fichiers de dépendances figées, fichiers d’exemple, documentation, tests et réglages partagés de l’éditeur ou du terminal.
On ne versionne jamais un secret : mot de passe, clé privée, jeton d’accès, chaîne de connexion complète, sauvegarde de base, certificat. Le fichier d’ignorance protège le dépôt, pas ce qui a déjà été validé.
Un secret entré une seule fois reste dans l’historique. La seule parade efficace est la révocation : on change le secret compromis, puis on nettoie la branche si nécessaire.
.gitignore
.env.local
var/cache/
*.pem
*.key
| À versionner | Ne jamais versionner |
|---|---|
| Scripts d’installation et de démarrage | Mots de passe et phrases de passe |
| Fichiers de dépendances figées | Clés privées SSH, PGP ou de certificat |
| Fichier d’exemple des variables | Jetons d’accès et clés d’interface |
| Documentation d’installation et de dépannage | Chaîne de connexion avec identifiants |
| Tests et scénarios de validation | Sauvegardes de base de données |
| Réglages partagés de l’éditeur | Journaux, caches et fichiers générés |
Une clé privée poussée par erreur se recopie avec chaque clone, y compris sur les postes personnels. La vérifier avant la première publication avec la commande git log -p sur les fichiers sensibles, puis purger l’entrée et révoquer la clé.
La configuration change d’un poste à l’autre, le code ne change pas. Tout ce qui varie donc — environnement d’exécution, adresse d’un service, niveau de détail des journaux — passe par une variable d’environnement lue au démarrage.
Un secret n’est jamais écrit dans le code source ni dans un dépôt, même en commentaire, même dans un exemple. Il est fourni par l’environnement, par un fichier local ignoré ou par un gestionnaire de secrets dédié.
Le fichier d’exemple liste les noms des variables et leur rôle, sans aucune valeur sensible. Chaque poste en crée une copie locale, jamais recopiée depuis le poste d’un collègue.
Tout secret doit pouvoir être remplacé sans modifier le code : c’est ce que l’on appelle la rotation, et c’est la contrepartie obligatoire d’un secret partagé.
APP_ENV=dev
DB_HOST=127.0.0.1
DB_NAME=app_test
SECRET=<a renseigner sur chaque poste>
| Variable | Rôle | Où on la définit |
|---|---|---|
| APP_ENV | Environnement d’exécution | Fichier local ignoré ou variable du système |
| DB_HOST | Adresse du service de données | Fichier local ignoré |
| DB_USER et DB_PASSWORD | Identifiants du service de données | Jamais dans le dépôt |
| API_TOKEN | Jeton d’accès à un service distant | Gestionnaire de secrets |
| LOG_LEVEL | Niveau de détail des journaux | Fichier d’exemple avec valeur par défaut |
Un secret en dur finit par apparaître dans les journaux, dans les copies d’écran de diagnostic et dans l’historique du dépôt. Une variable d’environnement n’a aucun de ces défauts : elle ne se lit jamais par accident.
Deux projets sur le même poste n’ont presque jamais les mêmes versions. Un interpréteur global produit des effets de bord : mettre à jour pour un projet casse l’autre, et le diagnostic devient un jeu de devinettes.
On isole donc par projet, et on fige les versions dans un fichier de verrouillage. Figer signifie que l’on connaît la version exacte installée, donc que l’on peut rejouer l’installation à l’identique.
Trois niveaux d’isolement existent, du plus léger au plus lourd : l’environnement virtuel sépare les bibliothèques du langage, le conteneur sépare le système de fichiers et le réseau, la machine virtuelle dédie le noyau entier.
Plus l’isolation est forte, plus le coût monte en ressources, en temps de démarrage et en place disque. Le bon niveau est le plus faible qui garantit la reproductibilité attendue.
python3 -m venv .venv
source .venv/bin/activate
python3 -m pip install -r requirements.txt
composer install --no-interaction
| Niveau d’isolement | Ce qui est isolé | Reproductibilité | Coût |
|---|---|---|---|
| Environnement virtuel | Les bibliothèques du langage | Forte si le verrouillage est respecté | Faible |
| Conteneur | Le système de fichiers et le réseau | Forte, décrite par un fichier | Moyen |
| Machine virtuelle | Le noyau, le réseau et le matériel virtuel | Totale, image complète | Élevé |
Mettre à jour sans figer revient à accepter n’importe quelle version. La mise à jour est une décision : on modifie le fichier de dépendances, on régénère le verrou, on exécute les tests, puis on commite le résultat.
Une tâche réalisée deux fois doit être scriptée : le script remplace la mémoire, se relit, se corrige et se transmet. Un geste manuel qui n’est pas écrit est un geste qui sera oublié ou refait différemment.
La planification rend l’automatisation régulière. Sauvegarde, supervision et remise à jour deviennent des tâches périodiques déclenchées sans intervention, y compris en l’absence de l’intervenant.
Les journaux sont la seule trace exploitable d’une exécution automatique : sans eux, une tâche planifiée qui échoue ne se remarque pas. Ils doivent être horodatés, écrits dans un fichier ou un service de collecte, et conservés assez longtemps pour couvrir un cycle d’exploitation.
#!/bin/sh
set -eu
date -u +"debut sauvegarde"
tar -czf sauvegarde.tar.gz donnees/
date -u +"fin sauvegarde"
Planifier ne dispense pas de vérifier. Une tâche planifiée qui échoue en silence donne un faux sentiment de sécurité : il faut consulter le journal déclenché par la planification, et non supposer qu’elle a abouti.
Porter un environnement, c’est le rejouer depuis une description, pas recopier un dossier. La copie emporte les défauts du poste d’origine, la description les corrige au passage.
La sauvegarde couvre deux objets distincts : les données, c’est-à-dire la base de données et les fichiers déposés, et la description de l’environnement, c’est-à-dire les scripts, les dépendances figées et la documentation.
La documentation d’installation est le test final : poste vierge plus documentation égale environnement fonctionnel. Si une étape manque ou dépend d’une mémoire locale, la documentation est à corriger immédiatement.
On teste la restauration périodiquement, sur un poste qui n’a jamais porté le projet : c’est la seule façon de savoir que la sauvegarde est réellement exploitable.
git clone depot-projet
cd depot-projet
cp .env.example .env.local
./scripts/bootstrap.sh
./scripts/smoke-test.sh
Sauvegarder les données sans sauvegarder la description de l’environnement oblige à tout réinstaller à la main. Sauvegarder la description sans tester la restauration des données donne une couverture partielle, que l’on découvre le jour de la panne.
Lorsque le démarrage échoue, isoler le réseau, la base, les permissions, les ports et les versions. Capturer la commande, le message et la première cause plausible avant de modifier plusieurs éléments à la fois.
Prévoir une procédure de remise à zéro qui ne détruit ni les données utiles ni les secrets. Tester cette procédure régulièrement pour éviter un faux sentiment de sécurité.
docker compose down && docker compose up -d && php bin/console about
Avant de rendre un poste à un intervenant réseau, on le vérifie couche par couche : système, accès, outillage, secrets, journaux, sauvegarde. Chaque ligne de la checklist s’appuie sur une preuve, jamais sur une impression.
La mise en service se termine par une intervention complète sur le réseau de test : connexion distante, résolution de nom, appel d’un service et capture d’une trame. Si l’une de ces étapes échoue, le poste n’est pas livré.
| Vérification | Preuve attendue |
|---|---|
| Système et langages à jour | Version affichée et consignée dans le README |
| Accès distant par clé | Connexion refusée par mot de passe |
| Outils de diagnostic présents | Chaque commande répond avec un résultat exploitable |
| Aucun secret en clair | Recherche dans le poste et l’historique sans résultat |
| Journaux actifs | Une erreur volontaire apparaît dans le journal |
| Sauvegarde testée | Restauration à blanc réussie sur un support neuf |
Le livrable doit montrer une compréhension personnelle, des choix explicités et une vérification par un cas de test ou une procédure reproductible.
Publié le 29/11/2025