Installation et configuration de l'environnement

Se connecter pour s'inscrire

Environnement et outils de développement

Préparer un poste de développement reproductible, versionné et sûr avec une procédure de démarrage et de diagnostic.

  1. 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.
  2. Objectifs

    Comprendre les notions essentielles et les appliquer dans un projet vérifiable.

  3. Prérequis

    Aucune connaissance préalable n’est strictement obligatoire ; les prérequis détaillés sont précisés dans les ateliers.

  4. Niveau

    Bac+2

  5. Ressources

    • Documentation officielle et références citées dans les ateliers.
    • Exercices, examens et projet de synthèse du catalogue.
  6. Validation des compétences

    • QCM : QCM comprenant des questions sur les principes fondamentaux étudiés. Les étudiants devront sélectionner la réponse correcte parmi les options proposées.
    • Étude de cas : Proposer une étude de cas dans laquelle les étudiants doivent analyser une situation spécifique liée aux concepts étudiés. Inviter les étudiants à repérer les principes applicables, à recommander des outils et des technologies appropriés, et à expliquer les bénéfices escomptés de l'adoption dans cette situation spécifique.
    • Exercices pratiques : Organisation d’exercices pratiques où les étudiants peuvent mettre en œuvre les concepts étudiés. Évaluation de la capacité des étudiants à mettre en place les solutions proposées.
    • Présentation orale : Demander aux étudiants de préparer une courte présentation orale sur un sujet lié au contenu du cours. Ils devront expliquer le concept, les principes clés, les outils pertinents et les avantages de l'adoption des solutions proposées. Évaluer leur compréhension du sujet, leur capacité à communiquer efficacement et à présenter des informations de manière claire et concise.
    • Projet : <div>La validation des compétences s'effectue à travers un projet professionnel simulé. Les apprenants, répartis en équipes, devront mener à bien une mission data complète incluant :<br><br></div><ul><li>Une répartition des rôles (architecte, data engineer, analyste...)</li><li>Des livrables techniques avec stack imposée</li><li>Des deadlines serrées</li><li>Une soutenance professionnelle (20 min max)</li></ul><div><br></div><div><strong>La présentation devra :<br></strong><br></div><ol><li>Couvrir l'ensemble des concepts clés du module</li><li>Démontrer la maîtrise technique via une démo opérationnelle</li><li>Communiquer de manière claire et convaincante</li></ol><div><br></div>
  7. Besoins techniques

    • Ordinateur fonctionnel : Un ordinateur en bon état de fonctionnement, capable d’exécuter les logiciels nécessaires au cours.
    • Accès à Internet : Connexion Internet stable pour accéder aux ressources en ligne, visioconférences et plateformes pédagogiques.
    • Ordinateur avec 8 Go de RAM : Ordinateur équipé d’au moins 8 Go de mémoire vive pour un usage bureautique avancé ou développement léger.
    • Navigateur web moderne : Google Chrome, Mozilla Firefox, Microsoft Edge, Safari ou autre navigateur à jour.
    • Suite bureautique : Microsoft Office, LibreOffice ou équivalent pour la rédaction de documents, tableurs et présentations.
    • Environnement de développement : IDE ou éditeur de texte adapté (Visual Studio Code, PyCharm, Eclipse, etc.), selon le langage étudié.

Exercices, examens et projets

Système et outils

Exercice

Atelier environnement

Installer un poste de développement et vérifier sa reproductibilité.

Obligatoire Consulter
Examen

Examen environnement

Évaluer les outils, la configuration et la sécurisation du poste.

Obligatoire Consulter
Projet

Projet environnement

Livrer un script d'installation et une documentation de démarrage.

Livrables :

  • Script d'installation
  • README
  • Procédure de dépannage
Obligatoire Consulter

Git et reproductibilité

Exercice

Atelier environnement

Installer un poste de développement et vérifier sa reproductibilité.

Obligatoire Consulter
Examen

Examen environnement

Évaluer les outils, la configuration et la sécurisation du poste.

Obligatoire Consulter
Projet

Projet environnement

Livrer un script d'installation et une documentation de démarrage.

Livrables :

  • Script d'installation
  • README
  • Procédure de dépannage
Obligatoire Consulter

Installation de l’environnement de développement

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.

À la fin du cours

  • Installer les outils de base avec une procédure vérifiable.
  • Choisir la couche d’exécution adaptée : poste, éditeur, terminal, conteneur, machine virtuelle.
  • Maîtriser l’outillage d’un intervenant réseau : terminal, SSH, capture de paquets, DNS, client HTTP.
  • Gérer les dépendances, services locaux et variables d’environnement.
  • Versionner le code et distinguer secrets, configuration et documentation.
  • Réinitialiser un poste, le rejouer sur une autre machine et vérifier sa mise en service.

Organisation

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.

Préparer le poste

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
Point de contrôle : Les versions attendues sont consignées dans le README et vérifiables sur une machine vierge.

Cycle de vie d’une machine

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
graph LR P["Poste"] --> E["Éditeur"] E --> T["Terminal"] T --> N["Navigateur"] T --> C["Conteneur"] T --> V["Machine virtuelle"] C --> S["Service de test"] V --> S N --> 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.

Point de contrôle : Je justifie la couche choisie par les trois critères et je sais nommer ce que coûte une isolation totale.

Outillage d’un intervenant réseau

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
graph TD CA["Câble"] --> TC["Testeur de câble"] P["Poste"] --> SSH["Session SSH"] P --> DNS["Requête dig"] P --> HTTP["Requête curl"] SSH --> S["Équipement distant"] DNS --> S HTTP --> S

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.

Point de contrôle : Pour une panne annoncée, je nomme l’outil qui prouve le maillon fautif et la trace exploitable qu’il produit.

Dépendances et configuration

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>
Point de contrôle : Un nouveau poste peut être configuré sans copier le fichier de configuration d’un collègue.

Git et travail collectif

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.

Méthode

  1. Cloner et installer.
  2. Configurer les variables locales.
  3. Lancer le test de fumée.
  4. Documenter la version de référence.
Point de contrôle : Un clone propre passe le test de démarrage sans fichier caché.

À versionner, ne jamais versionner

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
graph LR A["Scripts et documentation"] --> D["Dépôt Git"] B["Exemples de configuration"] --> D S["Secret local"] -->|fichier ignoré| X["Jamais versionné"] D --> H["Historique partagé"]

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é.

Point de contrôle : Un dépôt cloné sur un poste vierge démarre, et aucune recherche de motifs sensibles ne renvoie de secret.

Variables d’environnement et configuration

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
graph TD CODE["Code source"] --> VAR["Variables d’environnement"] LOCAL["Fichier local ignoré"] --> VAR VAULT["Gestionnaire de secrets"] --> VAR VAR --> APP["Application au démarrage"]

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.

Point de contrôle : Un nouveau poste est configuré depuis le fichier d’exemple, sans copier le fichier local d’un collègue.

Interpréteurs, dépendances et isolement

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é
graph LR A["Projet 1"] --> VE1["Environnement dédié"] B["Projet 2"] --> VE2["Environnement dédié"] VE1 --> V1["Dépendances figées"] VE2 --> V2["Dépendances figées"]

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.

Point de contrôle : Chaque projet dispose de son propre isolement et son installation est rejouable depuis un fichier versionné.

Automatiser, planifier et journaliser

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.

Méthode

  1. Lister les gestes répétés sur le poste.
  2. Écrire un script idempotent et testé.
  3. Planifier son exécution périodique.
  4. Vérifier le journal produit à chaque passage.
Point de contrôle : La sauvegarde et la vérification tournent sans intervention et laissent un journal consultable.

Sauvegarde, portabilité et reprise

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.

Point de contrôle : Le dépôt plus la documentation reconstruisent l’environnement sur un poste vierge, et une restauration complète a été essayée.

Diagnostiquer et réinitialiser

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
Point de contrôle : Le README contient une procédure de dépannage et une procédure de reset testées.

Checklist de mise en service d’un poste

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

Méthode

  1. Vérifier la couche système et les versions installées.
  2. Vérifier l’accès distant par clé et l’absence de mot de passe.
  3. Vérifier l’outillage réseau et la réponse de chaque commande.
  4. Vérifier l’absence de secret en clair sur le poste et dans le dépôt.
  5. Vérifier l’activité des journaux en provoquant une erreur.
  6. Tester une restauration complète sur un support neuf.
Point de contrôle : La checklist est intégralement cochée, signée et conservée avec le dossier d’intervention.

Livrables et validation

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.

  • Un script de bootstrap idempotent.
  • Un README d’installation avec prérequis et versions.
  • Un fichier d’exemple pour les variables d’environnement.
  • Une procédure de diagnostic et de réinitialisation testée.
  • Une checklist de mise en service du poste d’intervenant réseau.
Critère de réussite : L’environnement est validé sur une machine vierge avec un démarrage documenté, un test de fumée réussi, une restauration essayée et aucun secret dans Git.

Publié le 29/11/2025