Outils de Build & Gestionnaires de Paquets

Pour déployer une application sur un serveur de production, il faut d'abord la packager en un seul fichier transportable : c'est le rôle des outils de build et de gestion de paquets.

Qu'est-ce que "builder le code" ?

Code source (centaines de fichiers)
        │
        ▼  Build Tool
┌─────────────────────┐
│  1. Compiler        │  → Traduit le code en bytecode exécutable
│  2. Compresser      │  → Réduit la taille des fichiers
│  3. Packager        │  → Regroupe tout en 1 seul fichier
└─────────────────────┘
        │
        ▼
    artifact
  (1 fichier déployable)

Packaging = "building the code" — les deux termes désignent la même opération.

Qu'est-ce qu'un Artifact ?

Un artifact = fichier unique contenant le code de l'application + toutes ses dépendances. C'est ce fichier qui sera déployé sur le serveur de production.

Langage	Format de l'artifact
Java	`.jar` (Java Archive) ou `.war` (Web Application Archive)
JavaScript	`.zip` ou `.tar`
Python	`.whl` (wheel) ou `.tar.gz`

Le format de l'artifact dépend du langage. Chaque langage a ses conventions.

Outils de build par langage

Langage	Outils de build / Package Managers
Java	Maven, Gradle
JavaScript	npm, yarn, webpack
Python	pip
C / C++	conan
C#	NuGet
Golang	dep
Ruby	RubyGems

Les concepts sont identiques dans tous les langages — seuls les noms des outils changent.

Java — Maven & Gradle

Maven

Configuration dans pom.xml (XML) :

<!-- pom.xml -->
<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>3.0.5</version>
  </dependency>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
  </dependency>
</dependencies>

mvn install       # Installer les deps + compiler + tester + packager
mvn package       # Compiler + packager (sans tests)
mvn test          # Exécuter les tests uniquement
mvn clean         # Supprimer le dossier target/

# Artifact généré dans :
target/mon-app-1.0-SNAPSHOT.jar

Gradle

Configuration dans build.gradle (Groovy) :

// build.gradle
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web:3.0.5'
    testImplementation 'junit:junit:4.13.2'
}

gradle build      # Compiler + tester + packager
gradle test       # Tests uniquement
gradle clean      # Nettoyer

# Artifact généré dans :
build/libs/mon-app-1.0-SNAPSHOT.jar

Comparaison Maven vs Gradle

	Maven	Gradle
Fichier config	`pom.xml` (XML)	`build.gradle` (Groovy/Kotlin)
Artifact	`target/*.jar`	`build/libs/*.jar`
Commande build	`mvn install`	`gradle build`
Lisibilité	Verbeux	Plus concis
Performance	Standard	Plus rapide (cache incrémental)

Lancer une application Java

# En local (tests)
java -jar target/mon-app-1.0-SNAPSHOT.jar

# Sur un serveur de déploiement
# 1. Copier le jar sur le serveur
scp target/mon-app.jar user@server:/opt/app/

# 2. Exécuter
java -jar /opt/app/mon-app.jar

Maven Central Repository

Toutes les bibliothèques Java sont disponibles sur mvnrepository.com.

Besoin d'une bibliothèque ElasticSearch ?
1. Chercher sur mvnrepository.com
2. Copier la dépendance XML ou Groovy
3. Ajouter dans pom.xml ou build.gradle
4. Le build tool télécharge automatiquement la bibliothèque

JavaScript — npm & yarn

JavaScript utilise des package managers (et non des build tools comme Java).

package.json — fichier de dépendances

{
  "name": "mon-app",
  "version": "1.0.0",
  "scripts": {
    "start": "node server.js",
    "test": "jest",
    "build": "webpack --mode production"
  },
  "dependencies": {
    "express": "^4.18.2",
    "mongodb": "^5.3.0"
  },
  "devDependencies": {
    "jest": "^29.0.0",
    "webpack": "^5.88.0"
  }
}

Commandes npm essentielles

npm install       # Installer toutes les dépendances (crée node_modules/)
npm install <pkg> # Ajouter une dépendance
npm start         # Démarrer l'application
npm stop          # Arrêter l'application
npm test          # Exécuter les tests
npm run build     # Exécuter le script "build" défini dans package.json
npm publish       # Publier l'artifact sur npm registry

Artifact JavaScript — ce qu'il contient

Artifact ZIP/TAR :
✓ Code de l'application
✗ node_modules/ (dépendances NON incluses)

→ Sur le serveur, il faut faire "npm install" après décompression

# Déployer une application Node.js sur un serveur :
# 1. Copier le zip sur le serveur
# 2. Décompresser : unzip mon-app.zip
# 3. Installer les deps : npm install
# 4. Démarrer : npm start

npm Registry

Les bibliothèques JavaScript sont sur npmjs.com :

# Chercher une bibliothèque
npm search mongodb

# Installer directement
npm install mongodb

Frontend JavaScript — Packaging avec Webpack

Le code frontend (React, Vue...) doit être transformé avant d'être envoyé au navigateur :

Pourquoi ?
- Les navigateurs ne comprennent pas JSX (React), TypeScript, SCSS...
- Le code source doit être "transpilé" en JavaScript standard
- Les fichiers doivent être compressés/minifiés pour la performance

Webpack = outil de bundling frontend :

Fichiers sources :               Résultat :
├── App.jsx                      ├── index.html        (1.99 KB)
├── styles.scss    → webpack →   ├── index.bundle.js   (19.92 KB)
├── utils.ts                     ├── style.bundle.css  (12.64 KB)
└── images/                      └── favicon.ico       (23.24 KB)

Webpack transpile + minifie + bundle + compresse le code en fichiers optimisés pour le navigateur.

Workflow frontend complet

1. Bundle avec webpack          → code transpilé + minifié
2. Gérer les dépendances avec npm/yarn
3. Packager en WAR ou ZIP       → déploiement

Dépôt d'artifacts (Artifact Repository)

Un artifact repository = serveur de stockage des artifacts buildés.

Build Tool
    │
    │ publish (mvn deploy / npm publish)
    ▼
Artifact Repository ──► dev
(Nexus / JFrog)     ──► test
                    ──► production

Outil	Description
Nexus Repository	Solution open source très répandue
JFrog Artifactory	Solution enterprise complète
Maven Central	Repo public pour les libs Java
npm Registry	Repo public pour les packages JS

Publier et télécharger un artifact

# Maven — publier
mvn deploy

# npm — publier
npm publish

# Télécharger sur un serveur (sans package manager)
curl -O https://repo.exemple.com/mon-app-1.0.jar
wget https://repo.exemple.com/mon-app-1.0.jar

Pattern commun à tous les outils

Tous les outils de build suivent le même schéma :

Composant	Java (Maven)	JavaScript (npm)
Fichier de dépendances	`pom.xml`	`package.json`
Dépôt de bibliothèques	Maven Central	npm Registry
Installer les deps	`mvn install`	`npm install`
Lancer les tests	`mvn test`	`npm test`
Builder l'app	`mvn package`	`npm run build`
Publier l'artifact	`mvn deploy`	`npm publish`

À retenir

Artifact = fichier unique déployable (code + dépendances) produit par un build

"Builder le code" = compiler + compresser + packager en 1 fichier

Java : Maven (pom.xml, mvn install → target/*.jar) et Gradle (build.gradle, gradle build → build/libs/*.jar)

JavaScript : npm/yarn (package.json, npm install/test/publish), artifact = ZIP/TAR sans node_modules

Webpack = bundler frontend : transpile JSX/TS, minifie et compresse pour le navigateur

Maven Central = repo de bibliothèques Java ; npm Registry = repo de packages JS

Artifact Repository (Nexus, JFrog) = stockage centralisé des artifacts buildés

Pattern universel : fichier deps + repo + CLI + package manager — identique pour tous les langages