Skip to content
Learni
View all tutorials
Authentification

Comment implémenter un SSO avec Keycloak en 2026

18 minEXPERT
SécuritéSSOKeycloak

Introduction

Le Single Sign-On (SSO) est devenu indispensable pour les architectures modernes. Il permet à un utilisateur de s'authentifier une seule fois et d'accéder à plusieurs applications sans ressaisir ses identifiants. En 2026, les exigences de sécurité imposent l'utilisation de protocoles standards comme OpenID Connect (OIDC) et SAML. Ce tutoriel vous guide pas à pas dans l'implémentation d'un SSO production-ready avec Keycloak. Vous apprendrez à configurer un realm sécurisé, à gérer les clients et à intégrer la validation des tokens dans une application Next.js. Chaque étape inclut du code complet et fonctionnel.

Prérequis

  • Keycloak 26+ installé (Docker ou standalone)
  • Node.js 20+ et TypeScript
  • Connaissances avancées en JWT et OAuth2
  • Accès à un terminal et éditeur de code

Démarrage de Keycloak

docker-compose.yml
version: '3.8'
services:
  keycloak:
    image: quay.io/keycloak/keycloak:26.0
    command: start-dev
    environment:
      KEYCLOAK_ADMIN: admin
      KEYCLOAK_ADMIN_PASSWORD: StrongPass2026!
    ports:
      - "8080:8080"

Ce fichier Docker Compose lance Keycloak en mode développement avec un compte admin sécurisé. Utilisez un mot de passe fort en production.

Création du realm via CLI

setup-realm.sh
#!/bin/bash
kcadm.sh config credentials --server http://localhost:8080 --realm master --user admin --password StrongPass2026!
kcadm.sh create realms -s realm=entreprise-sso -s enabled=true -s displayName="SSO Entreprise 2026"

Ce script configure le realm principal. Le realm est l'espace de gestion isolé pour votre SSO.

Configuration du client OIDC

client-config.json
{
  "clientId": "nextjs-app",
  "enabled": true,
  "clientAuthenticatorType": "client-secret",
  "secret": "super-secret-2026",
  "redirectUris": ["http://localhost:3000/api/auth/callback"],
  "webOrigins": ["http://localhost:3000"],
  "standardFlowEnabled": true,
  "directAccessGrantsEnabled": false
}

Configuration JSON du client OIDC. Désactivez les flux directs pour renforcer la sécurité en production.

Middleware d'authentification

middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import jwt from 'jsonwebtoken';

export function middleware(request: NextRequest) {
  const token = request.cookies.get('kc-token')?.value;
  if (!token) return NextResponse.redirect(new URL('/login', request.url));
  try {
    jwt.verify(token, process.env.KEYCLOAK_PUBLIC_KEY!);
    return NextResponse.next();
  } catch {
    return NextResponse.redirect(new URL('/login', request.url));
  }
}
export const config = { matcher: ['/dashboard/:path*'] };

Middleware Next.js qui valide le token JWT Keycloak sur chaque requête protégée. Évite les appels réseau inutiles.

Route de callback OIDC

app/api/auth/callback/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { jwtVerify } from 'jose';

export async function GET(request: NextRequest) {
  const code = request.nextUrl.searchParams.get('code');
  const tokenRes = await fetch('http://localhost:8080/realms/entreprise-sso/protocol/openid-connect/token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'authorization_code',
      client_id: 'nextjs-app',
      client_secret: 'super-secret-2026',
      code,
      redirect_uri: 'http://localhost:3000/api/auth/callback'
    })
  });
  const { access_token } = await tokenRes.json();
  const response = NextResponse.redirect(new URL('/dashboard', request.url));
  response.cookies.set('kc-token', access_token, { httpOnly: true, secure: true });
  return response;
}

Cette route échange le code d'autorisation contre un token JWT et le stocke dans un cookie sécurisé.

Bonnes pratiques

  • Toujours utiliser HTTPS et cookies HttpOnly Secure
  • Configurer des audiences et scopes minimaux
  • Implémenter la rotation des clés publiques Keycloak
  • Logger les événements d'authentification sans données sensibles
  • Tester régulièrement les flux avec des outils comme Postman

Erreurs courantes

  • Oublier de configurer les redirect URIs exacts (erreur CORS ou invalid redirect)
  • Stocker les secrets clients côté frontend
  • Ignorer la validation de l'audience (aud) dans le token
  • Ne pas gérer le refresh token avant expiration

Pour aller plus loin

Approfondissez vos compétences avec nos formations avancées sur l'authentification et la sécurité.