Fondamentaux de la Qualité Code

"La qualité n'est pas un acte, c'est une habitude." — Aristote, reformulé par W. Edwards Deming pour le génie logiciel

Niveau : Débutant Objectif pédagogique : Comprendre les fondamentaux de la qualité logicielle, maîtriser l'architecture de SonarQube, l'installer, et réaliser un premier scan. Fil rouge : Application PetClinic (Spring Boot) — nous l'installerons et l'analyserons dans ce module.

---

Table des matières

1. Objectifs du Module 1
2. Rappel : Pourquoi la Qualité Logicielle ?
3. Panorama des Outils d'Analyse Statique
4. Architecture de SonarQube
5. Les Langages Supportés
6. Installation de SonarQube
7. Configuration Initiale
8. Premier Scan avec Scanner CLI
9. Le Fil Rouge : PetClinic
10. Synthèse du Module
11. Quiz d'Évaluation
12. Exercices Pratiques

---

1. Objectifs du Module 1

1.1 À l'issue de ce module, vous serez capable de

Diagramme en cours de génération...

1.2 Prérequis

1.3 Matériel requis

---

2. Rappel : Pourquoi la Qualité Logicielle ?

2.1 Le coût de la non-qualité

Le coût de la non-qualité logicielle est considérable et croissant. Selon une étude du Consortium for Information & Software Quality (CISQ) en 2022, le coût total de la mauvaise qualité logicielle aux États-Unis seul s'élevait à 2,41 billions de dollars.

Diagramme en cours de génération...

L'exemple Knight Capital (2012)

Le 1er août 2012, Knight Capital Group a déployé du code défectueux sur 8 serveurs de trading. Un bug dans le code de gestion des ordres (un ancien code de test non désactivé) a provoqué des milliers d'ordres erronés en 45 minutes.

Résultat :

• Perte : 440 millions de dollars en 45 minutes
• Cause : Un fichier PowerIncr déployé sur 7 des 8 serveurs (oubli sur 1)
• Évitable par : Analyse statique + revue de code + processus de déploiement

Le ratio de correction

Phase de conception  → x1 (coût de base)
Phase de développement → x5
Phase de test         → x10
Phase de déploiement  → x20
En production         → x100
Post-publication      → x1 000

Ce que ça signifie concrètement : Un bug qui coûterait 10€ à corriger en conception coûtera 1 000€ à corriger une fois en production.

2.2 Les 3 piliers de la qualité logicielle

Diagramme en cours de génération...

2.3 Les 6 caractéristiques ISO 25010

La norme ISO 25010 (remplaçant ISO 9126) définit 8 caractéristiques de qualité logicielle. SonarQube en couvre directement 4 :

---

3. Panorama des Outils d'Analyse Statique

3.1 Qu'est-ce que l'analyse statique ?

L'analyse statique est l'examenautomatique du code source sans l'exécuter. Elle cherche des patterns problématiques, des violations de règles et des vulnérabilités potentielle.

Diagramme en cours de génération...

Exemple concret :

// L'analyse statique détecte ce problème SANS exécuter le code
public String getUserData(String userId) {
    String query = "SELECT * FROM users WHERE id = '" + userId + "'";
    //                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    // SonarQube détecte : SQL Injection vulnerability (rule:S3649)
    return jdbcTemplate.queryForObject(query, ...);
}

3.2 Les 5 catégories d'outils

Diagramme en cours de génération...

3.3 Comparaison détaillée des outils

Outils Java

Outils JavaScript/TypeScript

Outils Python

Outils C/C++

3.4 Pourquoi SonarQube et pas un autre ?

Diagramme en cours de génération...

Les 7 avantages de SonarQube par rapport aux outils isolés :

3.5 L'analyse statique dans la chaîne de DevOps

Diagramme en cours de génération...

---

4. Architecture de SonarQube

4.1 Vue d'ensemble de l'architecture

SonarQube suit une architecture client-serveur avec séparation claire entre l'analyse (côté build) et le stockage/affichage (côté serveur).

Diagramme en cours de génération...

4.2 Les composants en détail

4.2.1 Le Serveur Web (Web Server)

Rôle : Interface utilisateur (UI), API REST, authentification, gestion des projets.

Technologies :

• Java (Spring Boot)
• Port par défaut : 9000
• Interface web : JavaScript (anciennement AngularJS, maintenant web components)

Responsabilités :

• Servir l'interface web
• Exposer les API REST (200+ endpoints)
• Gérer les sessions utilisateur
• Orchestrer les tâches d'analyse
• Gérer les Quality Gates et Profiles

Diagramme en cours de génération...

4.2.2 Le Compute Engine

Rôle : Exécuter les tâches lourdes en arrière-plan (analyse, indexation, calculs).

Technologies :

• Java (async executor)
• Tâches asynchrones via une file d'attente
• Parallelisation possible (Enterprise Edition)

Cycle de vie d'une analyse :

Diagramme en cours de génération...

4.2.3 Elasticsearch

Rôle : Indexation et recherche rapide des données d'analyse.

Utilisé pour :

• Recherche dans les issues
• Filtrage par projet, par auteur, par date
• Dashboard et tendances
• Quick Open (recherche rapide)

Versions supportées :

• SonarQube 10.x : Elasticsearch 8.x intégré
• Pas de configuration externe nécessaire (embedded)

4.2.4 PostgreSQL

Rôle : Stockage persistant de la configuration et des métriques.

Stocké en PostgreSQL :

• Configuration des projets
• Quality Profiles et Gates
• Utilisateurs et groupes
• Métriques agrégées
• Historique des analyses

Versions supportées :

• PostgreSQL 12+ (recommandé : 15+)
• H2 (dev uniquement, ne pas utiliser en production)

4.3 Le flux de données complet

Diagramme en cours de génération...

4.4 Les éditions de SonarQube

4.5 Les Quality Gates

La Quality Gate est le passage obligatoire que chaque analyse doit franchir pour être considérée comme "passée".

Diagramme en cours de génération...

---

5. Les Langages Supportés

5.1 Liste complète des langages

SonarQube Community Edition supporte 29 langages nativement :

5.2 Le support multi-langages

Diagramme en cours de génération...

5.3 Exemple : configuration multi-langages

Dans sonar-project.properties :

# Langage principal
sonar.projectKey=my-project
sonar.projectName=Mon Projet

# Inclure plusieurs langages
sonar.sources=src/main/java,src/main/js,src/main/resources
sonar.tests=src/test/java,src/test/js

# Exclusions
sonar.exclusions=**/node_modules/**,**/vendor/**,**/target/**

# Langages spécifiques
sonar.javascript.lcov.reportPaths=coverage/lcov.info
sonar.java.coveragePlugin=jacoco
sonar.jacoco.reportPaths=target/jacoco.exec

---

6. Installation de SonarQube

6.1 Prérequis système

Diagramme en cours de génération...

Vérification des prérequis

# Vérifier Java
java -version
# Attendu : openjdk version "17.x" ou "21.x"

# Vérifier Docker
docker --version
# Attendu : Docker version 20.10+

# Vérifier Docker Compose
docker-compose --version
# Attendu : docker-compose version 2.x

# Vérifier la mémoire disponible
free -h
# Minimum : 4 Go

# Vérifier l'espace disque
df -h /
# Minimum : 20 Go libres

6.2 Installation Docker (recommandée)

6.2.1 Structure du dossier

sonarqube-training/
├── docker/
│   ├── docker-compose.yml          # CE + PostgreSQL
│   ├── docker-compose.developer.yml # Developer Edition
│   ├── docker-compose.jenkins.yml   # Jenkins + SonarQube
│   └── Dockerfile.scanner          # Scanner custom

6.2.2 docker-compose.yml (Community Edition)

version: '3.8'

services:
  sonarqube:
    image: sonarqube:10.4-community
    container_name: sonarqube
    ports:
      - "9000:9000"
    environment:
      - SONAR_JDBC_URL=jdbc:postgresql://db:5432/sonarqube
      - SONAR_JDBC_USERNAME=sonar
      - SONAR_JDBC_PASSWORD=sonar
      - SONAR_ES_BOOTSTRAP_CHECKS_DISABLE=true
    volumes:
      - sonarqube_data:/opt/sonarqube/data
      - sonarqube_extensions:/opt/sonarqube/extensions
      - sonarqube_logs:/opt/sonarqube/logs
    depends_on:
      - db
    networks:
      - sonarnet

  db:
    image: postgres:15
    container_name: sonarqube-db
    environment:
      - POSTGRES_USER=sonar
      - POSTGRES_PASSWORD=sonar
      - POSTGRES_DB=sonarqube
    volumes:
      - postgresql_data:/var/lib/postgresql/data
    networks:
      - sonarnet

volumes:
  sonarqube_data:
  sonarqube_extensions:
  sonarqube_logs:
  postgresql_data:

networks:
  sonarnet:

6.2.3 Lancer l'installation

# Créer le dossier docker
mkdir -p sonarqube-training/docker
cd sonarqube-training/docker

# Copier le docker-compose.yml (ci-dessus)
# Puis lancer
docker-compose up -d

# Vérifier le démarrage (patienter 2-3 minutes)
docker-compose logs -f sonarqube

# Attendre le message :
# "SonarQube is up and running"

# Accéder à l'interface
# http://localhost:9000
# Login : admin / admin (à changer au 1er login)

6.2.4 Vérification post-installation

# Vérifier les conteneurs
docker-compose ps

# Résultat attendu :
# NAME                 STATUS
# sonarqube            Up (healthy)
# sonarqube-db         Up

# Vérifier les logs
docker-compose logs --tail=20 sonarqube

# Tester l'API
curl http://localhost:9000/api/system/status
# Résultat attendu : {"status":"UP"}

6.3 Installation bare-metal

6.3.1 Téléchargement

# Télécharger SonarQube 10.4
wget https://binaries.sonarsource.com/Distribution/sonarqube/sonarqube-10.4.0.88968.zip

# Décompresser
unzip sonarqube-10.4.0.88968.zip
cd sonarqube-10.4.0.88968

# Structure
ls -la
# bin/          → Scripts de démarrage
# conf/         → Configuration
# lib/          → Bibliothèques Java
# extensions/   → Plugins
# data/         → Données (Elasticsearch)
# logs/         → Logs
# web/          → Interface web

6.3.2 Configuration

# Éditer la configuration principale
vi conf/sonar.properties

# Configuration minimale pour PostgreSQL
sonar.jdbc.username=sonar
sonar.jdbc.password=sonar_password
sonar.jdbc.url=jdbc:postgresql://localhost:5432/sonarqube

# Configuration recommandée
sonar.web.javaAdditionalOpts=-Xmx2g -Xms512m
sonar.ce.javaAdditionalOpts=-Xmx2g -Xms512m
sonar.search.javaAdditionalOpts=-Xmx1g -Xms512m

# Port personnalisé (optionnel)
sonar.web.port=9000

6.3.3 Création de la base PostgreSQL

-- Créer l'utilisateur et la base
CREATE USER sonar WITH PASSWORD 'sonar_password';
CREATE DATABASE sonarqube OWNER sonar;

-- Vérifier
\du sonar
\l sonarqube

6.3.4 Démarrage

# Linux/Mac
./bin/linux-x86-64/sonar.sh start

# Vérifier
./bin/linux-x86-64/sonar.sh status
# Résultat : "SonarQube is running"

# Arrêter
./bin/linux-x86-64/sonar.sh stop

# Logs
tail -f logs/sonar.log

6.4 Configuration des paramètres système (vm.max_map_count)

Problème courant : Elasticsearch nécessite une valeur vm.max_map_count élevée.

# Linux
sudo sysctl -w vm.max_map_count=524288

# Persister au redémarrage
echo "vm.max_map_count=524288" | sudo tee -a /etc/sysctl.conf

# Docker Desktop (Mac/Windows)
# Ajouter dans docker-compose.yml :
# environment:
#   - sonar.search.javaAdditionalOpts=-Xmx512m -Xms256m

6.5 Problèmes courants et résolutions

---

7. Configuration Initiale

7.1 Premier login

Diagramme en cours de génération...

Étapes :

1. Ouvrir http://localhost:9000
2. Login : admin / admin
3. Changer le mot de passe immédiatement
4. Vous êtes sur le Dashboard Global

7.2 Les Quality Gates par défaut

Sonar Way (par défaut)

La Quality Gate Sonar Way est la configuration par défaut. Elle est raisonnable et adaptée à la plupart des projets.

Diagramme en cours de génération...

Pourquoi ces critères ?

7.3 Créer un projet

Via l'interface web

1. Cliquer "Create new project"
2. Projec Key : "petclinic"
3. Display Name : "PetClinic Spring Boot"
4. Main branch : main
5. Cliquer "Set Up"
6. Générer un token d'analyse
7. Copier le token (ne sera plus affiché)

Via l'API

# Créer un projet via l'API
curl -X POST -u admin:ADMIN_PASSWORD \
  "http://localhost:9000/api/projects/create?name=petclinic&project=petclinic&mainBranch=main"

# Générer un token
curl -X POST -u admin:ADMIN_PASSWORD \
  "http://localhost:9000/api/user_tokens/generate?name=scanner-token&projectKey=petclinic"

7.4 Les Quality Profiles

Un Quality Profile définit l'ensemble des règles activées pour un langage donné.

Diagramme en cours de génération...

Pour chaque langage :

• Un Quality Profile par défaut (généralement "Sonar way")
• Possibilité de créer des profils personnalisés
• Possibilité d'activer/désactiver des règles spécifiques
• Possibilité d'importer des profils externes (PMD, ESLint)

---

8. Premier Scan avec Scanner CLI

8.1 Le Scanner CLI

Le Scanner CLI est l'outil d'analyse polyvalent qui fonctionne avec n'importe quel langage, sans build tool spécifique.

Diagramme en cours de génération...

8.2 Téléchargement et installation

# Télécharger le Scanner CLI
# Linux/Mac
wget https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-5.0.1.3006-linux.zip
unzip sonar-scanner-cli-5.0.1.3006-linux.zip

# Windows
# Télécharger le .zip depuis https://docs.sonarqube.org/latest/analysis/scan/sonarscanner/
# Extraire et ajouter au PATH

# Vérifier
./sonar-scanner --version
# INFO: Scanner configuration: ...
# INFO: SonarQube server 10.4.0

8.3 Configuration du scan

Fichier sonar-project.properties

# === Identification du projet ===
sonar.projectKey=petclinic
sonar.projectName=PetClinic Spring Boot
sonar.projectVersion=1.0

# === Sources ===
sonar.sources=src/main/java
sonar.tests=src/test/java
sonar.java.binaries=target/classes
sonar.java.libraries=target/dependency/*.jar

# === Encodage ===
sonar.sourceEncoding=UTF-8

# === Exclusions ===
sonar.exclusions=**/test/**,**/config/**

# === Couverture ===
sonar.java.coveragePlugin=jacoco
sonar.jacoco.reportPaths=target/jacoco.exec

# === Connexion au serveur ===
sonar.host.url=http://localhost:9000
sonar.token=YOUR_TOKEN_HERE

8.4 Lancer le scan

# Étape 1 : Build le projet (nécessaire pour Java)
mvn clean package -DskipTests

# Étape 2 : Lancer le scan
sonar-scanner

# Résultat attendu :
# INFO: Scanner configuration: /path/to/project
# INFO: SonarQube server 10.4.0
# INFO: Default locale: fr_FR
# INFO: Analyze on SonarQube
# INFO: Load global settings
# INFO: Load project settings
# INFO: Load quality profiles
# INFO: Load active rules
# INFO: Indexing files...
# INFO: Indexing 45 files of type MAIN
# INFO: Indexing 12 files of type TEST
# INFO: 45 source files analyzed
# INFO: 12 test files analyzed
# INFO: Analysis report generated
# INFO: Analysis report uploaded
# INFO: SUCCESS
# INFO: More information at http://localhost:9000/dashboard?id=petclinic

8.5 Le scan avec Maven

# Méthode 1 : Plugin Maven direct
mvn clean verify sonar:sonar \
  -Dsonar.projectKey=petclinic \
  -Dsonar.host.url=http://localhost:9000 \
  -Dsonar.token=YOUR_TOKEN

# Méthode 2 : Avec le plugin dans pom.xml
# (voir section suivante)

Configuration Maven (pom.xml)

<project>
    ...
    <properties>
        <sonar.projectKey>petclinic</sonar.projectKey>
        <sonar.host.url>http://localhost:9000</sonar.host.url>
    </properties>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.sonarsource.scanner.maven</groupId>
                <artifactId>sonar-maven-plugin</artifactId>
                <version>4.0.0.4121</version>
            </plugin>
        </plugins>
    </build>
</project>

8.6 Résultats du premier scan

Via l'interface web

http://localhost:9000/dashboard?id=petclinic

Diagramme en cours de génération...

Via l'API

# Récupérer les métriques
curl -u admin:PASSWORD \
  "http://localhost:9000/api/measures/component?component=petclinic&metricKeys=bugs,vulnerabilities,code_smells,coverage,duplicated_lines_density,ncloc,reliability_rating,security_rating,sqale_rating"

# Résultat JSON
{
  "component": {
    "key": "petclinic",
    "name": "PetClinic Spring Boot",
    "measures": [
      {"metric": "bugs", "value": "12"},
      {"metric": "vulnerabilities", "value": "3"},
      {"metric": "code_smells", "value": "89"},
      {"metric": "coverage", "value": "78.2"},
      {"metric": "duplicated_lines_density", "value": "2.1"},
      {"metric": "ncloc", "value": "12450"}
    ]
  }
}

8.7 Interprétation des résultats

Les types d'issues

Diagramme en cours de génération...

Les severités

Lire une issue

Exemple d'issue affichée dans SonarQube :

🔴 Bug — Major

Title: Resources should be closed

Component: src/main/java/org/springframework/samples/petclinic/repository/
           JdbcOwnerRepository.java
Line: 45

Message: Use try-with-resources or close this "PreparedStatement" in a "finally" 
clause.

Rule: java:S2095 (Resources should be closed)

Impact on Maintainability: +2h de dette technique

Que signifie cette issue ?

• Type : Bug (pas juste un smell)
• Sévérité : Major
• Règle : S2095 (resources doivent être fermées)
• Problème : Un PreparedStatement n'est pas fermé
• Conséquence : Fuite de ressources, potentiel memory leak
• Solution : Utiliser try-with-resources

---

9. Le Fil Rouge : PetClinic

9.1 Présentation du projet

PetClinic est une application Spring Boot de démonstration développée par l'équipe Spring de VMware. Elle simule un gestionnaire de cliniques vétérinaires.

Diagramme en cours de génération...

9.2 Installation de PetClinic

# Cloner le projet
git clone https://github.com/spring-projects/spring-petclinic.git
cd spring-petclinic

# Build
./mvnw clean package

# Lancer l'application
./mvnw spring-boot:run

# Vérifier : http://localhost:8080

9.3 Scanner PetClinic

# Build + Analyse
./mvnw clean verify sonar:sonar \
  -Dsonar.projectKey=petclinic \
  -Dsonar.host.url=http://localhost:9000 \
  -Dsonar.token=YOUR_TOKEN

# OU avec Scanner CLI
# Copier sonar-project.properties (voir section 8.3)
sonar-scanner

9.4 Résultats typiques

Project: spring-petclinic
Version: 1.0

📊 Overall Code:
├── Bugs: 12
├── Vulnerabilities: 3
├── Security Hotspots: 5
├── Code Smells: 89
├── Duplicated Lines: 2.1%
├── Coverage: 78.2%
└── Lines of Code: 12,450

📊 New Code (last commit):
├── Bugs: 2
├── Vulnerabilities: 0
├── Coverage: 85.0%
└── Duplicated Lines: 1.5%

✅ Quality Gate: PASSED

9.5 Les premiers problèmes identifiés

Diagramme en cours de génération...

---

10. Synthèse du Module

10.1 Les points clés à retenir

Diagramme en cours de génération...

10.2 Les 10 commandements du module

1. La qualité logicielle a un coût — La non-qualité coûte 1000x plus cher en production
2. L'analyse statique est votre premier rempart — Elle détecte les problèmes avant l'exécution
3. SonarQube centralise tout — Pas besoin de 5 outils différents
4. L'architecture est simple — Scanner → Server → Compute Engine → DB
5. Docker est votre ami — docker-compose up -d en 3 minutes
6. Le premier scan est rapide — sonar-scanner en 30 secondes
7. La Quality Gate est non négociable — Elle protège votre code
8. Le token est secret — Ne jamais le commiter
9. Le dashboard raconte une histoire — Apprenez à la lire
10. La qualité est un marathon — Pas un sprint

10.3 Erreurs courantes à éviter

---

11. Quiz d'Évaluation

Quiz 1.1 — Architecture

Q1 : Quels sont les 4 composants principaux de SonarQube Server ?

• A) Scanner, Maven, Jenkins, Docker
• B) Web Server, Compute Engine, Elasticsearch, PostgreSQL
• C) API, Dashboard, Database, Cache
• D) SonarLint, SonarQube, SonarCloud, Scanner

<details> <summary>Réponse</summary>

B — Web Server, Compute Engine, Elasticsearch, PostgreSQL

Le Web Server gère l'UI et l'API, le Compute Engine exécute les tâches asynchrones, Elasticsearch indexe les données, et PostgreSQL assure la persistance.

</details>

---

Q2 : Quel port utilise SonarQube par défaut ?

• A) 8080
• B) 3000
• C) 9000
• D) 5432

<details> <summary>Réponse</summary>

C — Port 9000 (HTTP)

Le port 9000 est le port par défaut pour l'interface web et l'API REST. Le port 5432 est PostgreSQL, 8080 est typiquement Spring Boot.

</details>

---

Q3 : Quel est le rôle du Compute Engine ?

• A) Servir l'interface web
• B) Exécuter les tâches d'analyse en arrière-plan
• C) Stocker les données
• D) Indexer les fichiers

<details> <summary>Réponse</summary>

B — Exécuter les tâches d'analyse en arrière-plan

Le Compute Engine prend les rapports bruts du Scanner, les traite, calcule les métriques et la Quality Gate.

</details>

Quiz 1.2 — Installation

Q4 : Quel prérequis est OBLIGATOIRE pour SonarQube 10.x ?

• A) Java 8
• B) Java 17 ou 21
• C) Node.js 18
• D) Python 3.10

<details> <summary>Réponse</summary>

B — Java 17 ou 21

SonarQube 10.x nécessite Java 17 ou 21 (LTS). Java 8 n'est plus supporté.

</details>

---

Q5 : Quelle est la commande correcte pour démarrer SonarQube en Docker ?

• A) docker run sonarqube
• B) docker-compose up -d
• C) docker start sonarqube
• D) docker build .

<details> <summary>Réponse</summary>

B — docker-compose up -d

Avec le docker-compose.yml configuré, cette commande lance SonarQube + PostgreSQL en mode détaché.

</details>

Quiz 1.3 — Analyse

Q6 : Pour analyser un projet Maven, quelle est la meilleure approche ?

• A) sonar-scanner seul
• B) mvn sonar:sonar après mvn clean package
• C) mvn install sans sonar-scanner
• D) java -jar sonarqube.jar

<details> <summary>Réponse</summary>

B — mvn sonar:sonar après mvn clean package

Le plugin Maven gère automatiquement la collecte des métriques (couverture, classpath, etc.). Le build préalable est nécessaire pour avoir les .class.

</details>

---

Q7 : Que signifie "Quality Gate PASSED" ?

• A) Aucun bug dans le projet
• B) Tous les critères de qualité sont respectés
• C) Le projet est prêt à être déployé
• D) Toutes les règles sont désactivées

<details> <summary>Réponse</summary>

B — Tous les critères de qualité de la Quality Gate sont respectés

La Quality Gate PASSED signifie que le projet respecte tous les seuils définis (bugs, couverture, duplication, etc.). Ce n'est PAS une garantie de déploiement, c'est un indicateur de qualité.

</details>

---

Q8 : Quel est le premier réflexe après l'installation de SonarQube ?

• A) Lancer un scan immédiatement
• B) Changer le mot de passe admin
• C) Installer des plugins
• D) Créer des projets

<details> <summary>Réponse</summary>

B — Changer le mot de passe admin

La sécurité passe en premier. Le mot de passe par défaut "admin" est public.

</details>

---

12. Exercices Pratiques

Exercice 1.1 — Installation personnalisée

Objectif : Installer SonarQube avec configuration personnalisée.

Énoncé :

1. Créer un docker-compose.yml avec SonarQube CE + PostgreSQL
2. Personnaliser les ports (SonarQube : 9001, PostgreSQL : 5433)
3. Ajouter des volumes nommés
4. Lancer le service et vérifier le démarrage
5. Accéder à l'interface web

Fichier de livraison : docker-compose-custom.yml

Critères de validation :

• SonarQube accessible sur le port 9001
• PostgreSQL accessible sur le port 5433
• Interface web fonctionnelle
• API /api/system/status retourne {"status":"UP"}

---

Exercice 1.2 — Premier scan complet

Objectif : Scanner un projet et interpréter les résultats.

Énoncé :

1. Cloner le projet PetClinic
2. Configurer sonar-project.properties
3. Lancer le build Maven
4. Lancer le scan SonarQube
5. Lire le dashboard et répondre aux questions

Questions :

• Combien de bugs ?
• Quel est le rating de Maintainability ?
• Quel est le pourcentage de duplication ?
• La Quality Gate est-elle passée ?

Fichier de livraison : Capture d'écran du dashboard + réponses aux questions

---

Exercice 1.3 — Comparaison des outils

Objectif : Comprendre les différences entre les outils d'analyse statique.

Énoncé : Installer et exécuter sur le même projet :

1. PMD (rapport XML)
2. Checkstyle (rapport HTML)
3. SonarQube (dashboard web)

Comparer les résultats dans un tableau.

Fichier de livraison : comparaison-outils.md avec tableau comparatif

Critères de validation :

• Les 3 outils ont produit des résultats
• Le tableau compare : nombre d'issues, types, interface, historique
• Conclusion sur les avantages de SonarQube

---

Exercice 1.4 — Exploration de l'API

Objectif : Découvrir l'API REST de SonarQube.

Énoncé : Exécuter les commandes curl suivantes et documenter les résultats :

# Status
curl -u admin:PASSWORD http://localhost:9000/api/system/status

# Projets
curl -u admin:PASSWORD http://localhost:9000/api/projects/search

# Métriques d'un projet
curl -u admin:PASSWORD \
  "http://localhost:9000/api/measures/component?component=petclinic&metricKeys=bugs,vulnerabilities,code_smells"

# Quality Gates
curl -u admin:PASSWORD http://localhost:9000/api/qualitygates/list

# Règles actives
curl -u admin:PASSWORD \
  "http://localhost:9000/api/rules/search?languages=java&ps=10"

Fichier de livraison : Documentation de chaque endpoint testé

---

Exercice 1.5 — Diagnostic de problèmes

Objectif : Diagnostiquer et résoudre les problèmes courants.

Énoncé : Résoudre les scénarios suivants :

1. Scénario : Elasticsearch ne démarre pas

   • Symptôme : docker-compose logs montre "max virtual memory areas"
   • Solution attendue : Modifier vm.max_map_count

2. Scénario : Le scan ne trouve pas de couverture

   • Symptôme : Coverage = 0% alors que les tests passent
   • Solution attendue : Ajouter sonar.java.coveragePlugin=jacoco

3. Scénario : Le scan échoue avec "Not authorized"

   • Symptôme : Error 401
   • Solution attendue : Vérifier le token

Fichier de livraison : diagnostic-solutions.md

---