Les applications modernes nécessitent des mécanismes d’authentification et d’autorisation robustes afin de protéger les APIs, les données utilisateurs et les systèmes métiers. Les architectures cloud-native et microservices utilisent aujourd’hui majoritairement l’authentification basée sur JWT (JSON Web Token).

Spring Boot associé à Spring Security et JWT permet de créer des APIs sécurisées, évolutives et prêtes pour la production.

Dans ce guide complet, nous allons voir comment construire un système d’authentification sécurisé avec Spring Boot et JWT.

Pourquoi Utiliser JWT ?

JWT est largement utilisé dans :

APIs REST
Applications mobiles
Microservices
Applications cloud-native
Applications SPA (Single Page Application)

Principaux avantages :

Authentification stateless
Scalabilité élevée
Réduction de la charge serveur
Sécurisation des APIs
Intégration simple avec les microservices

Architecture de l’Authentification JWT

Flux classique :

L’utilisateur se connecte
Le serveur valide les identifiants
Un token JWT est généré
Le client stocke le token
Le token est envoyé dans les requêtes API
Le serveur valide le JWT
Accès accordé aux ressources protégées

Technologies Utilisées

Technologie	Rôle
Spring Boot	Framework backend
Spring Security	Gestion sécurité
JWT	Authentification stateless
Maven	Gestion dépendances
PostgreSQL / MySQL	Base de données
BCrypt	Chiffrement mot de passe

Dépendances Maven


<dependencies>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>

    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-api</artifactId>
        <version>0.11.5</version>
    </dependency>

    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-impl</artifactId>
        <version>0.11.5</version>
        <scope>runtime</scope>
    </dependency>

</dependencies>

Exemple d’Entité Utilisateur


@Entity
public class Utilisateur {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String username;

    private String password;

    private String role;
}

Chiffrement des Mots de Passe avec BCrypt

Ne jamais stocker les mots de passe en clair.


@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

BCrypt offre :

Hachage sécurisé
Salt automatique
Résistance aux attaques bruteforce

Génération du Token JWT

Classe utilitaire JWT :


@Component
public class JwtUtil {

    private final String SECRET_KEY = "secret-key";

    public String generateToken(String username) {

        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(
                    new Date(System.currentTimeMillis() + 3600000)
                )
                .signWith(
                    Keys.hmacShaKeyFor(
                        SECRET_KEY.getBytes()
                    ),
                    SignatureAlgorithm.HS256
                )
                .compact();
    }
}

Filtre JWT

Le filtre vérifie les tokens entrants.


@Component
public class JwtFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain chain)
            throws ServletException, IOException {

        String authHeader =
                request.getHeader("Authorization");

        if(authHeader != null &&
                authHeader.startsWith("Bearer ")) {

            String token =
                    authHeader.substring(7);

            // Validation du token
        }

        chain.doFilter(request, response);
    }
}

Configuration Spring Security

Configuration des endpoints sécurisés :


@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(
            HttpSecurity http) throws Exception {

        http
            .csrf().disable()
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/auth/**")
                .permitAll()
                .anyRequest()
                .authenticated()
            );

        return http.build();
    }
}

Contrôleur d’Authentification

Exemple de login :


@RestController
@RequestMapping("/auth")
public class AuthController {

    @PostMapping("/login")
    public String login(
            @RequestBody LoginRequest request) {

        // Validation utilisateur

        return jwtUtil.generateToken(
                request.getUsername()
        );
    }
}

Exemple de Requête API

Requête Login


{
   "username":"admin",
   "password":"password"
}

Réponse


{
   "token":"eyJhbGciOiJIUzI1NiJ9..."
}

Sécurisation des APIs REST

Les APIs protégées nécessitent :


Authorization: Bearer JWT_TOKEN

Cela garantit que seuls les utilisateurs authentifiés accèdent aux services.

Gestion des Rôles et Autorisations

Spring Security permet le contrôle d’accès par rôles.


@PreAuthorize("hasRole('ADMIN')")
@GetMapping("/admin")
public String adminApi() {
    return "Admin Access";
}

Rôles courants :

ADMIN
USER
MANAGER
SUPER_ADMIN

Bonnes Pratiques JWT

Utiliser HTTPS

Toujours sécuriser les APIs avec SSL/TLS.

Définir une Expiration des Tokens

Éviter les tokens permanents.

Utiliser des Refresh Tokens

Améliorer la sécurité et l’expérience utilisateur.

Sécuriser les Secrets

Stocker les clés dans Vault ou variables d’environnement.

Limiter les Données Sensibles

Ne jamais mettre d’informations critiques dans le payload JWT.

Recommandations Production

API Gateway

Solutions populaires :

Kong
NGINX
Spring Cloud Gateway

Fournisseurs OAuth2

Keycloak
Okta
Auth0

Monitoring

Surveiller :

Tentatives de connexion échouées
Activités suspectes
Mauvaise utilisation des tokens

Cas d’Usage Réel

Une entreprise fintech a migré vers une architecture JWT avec Spring Boot.

Résultats :

APIs plus scalables
Réduction de la consommation mémoire
Meilleure compatibilité cloud-native
Authentification centralisée
Réduction des temps de réponse

Erreurs JWT Courantes

Problème	Solution
Token invalide	Vérifier la clé secrète
Token expiré	Ajouter refresh token
Accès refusé	Vérifier les rôles
Mot de passe faible	Utiliser BCrypt
Problèmes CORS	Configurer CORS correctement

Architecture Recommandée

Couche	Technologie
Backend	Spring Boot
Sécurité	Spring Security
Authentification	JWT
API Gateway	Kong / NGINX
OAuth2	Keycloak
Base de données	PostgreSQL
Monitoring	Prometheus + Grafana

Conclusion

Construire un système d’authentification sécurisé avec Spring Boot et JWT permet de créer des applications Java modernes, sécurisées et évolutives.

En combinant Spring Security, JWT, BCrypt et les bonnes pratiques de sécurité, les entreprises peuvent protéger efficacement leurs APIs et microservices.

JWT reste aujourd’hui l’une des solutions les plus utilisées pour sécuriser les applications cloud-native et les architectures microservices.

Construire un Système d’Authentification Sécurisé avec Spring Boot & JWT