lions-user-manager/scripts/setup-keycloak-client.md

Configuration du client Keycloak pour Lions User Manager

Configuration requise

Le serveur attend un client avec les propriétés suivantes :

• Client ID: lions-user-manager
• Realm: master
• Type: Service Account (confidential client)
• Secret: dev-secret-change-me (ou générer un nouveau secret)

Option 1 : Via l'interface web Keycloak

1. Accéder à Keycloak Admin Console

   • URL: http://localhost:8180
   • Se connecter avec admin / admin

2. Sélectionner le realm master

   • Dans le menu déroulant en haut à gauche

3. Créer le client

   • Aller dans Clients → Create client
   • Client type: OpenID Connect
   • Client ID: lions-user-manager
   • Cliquer sur Next

4. Configurer le client

   • Client authentication: ON (confidential client)
   • Authorization: OFF (pour l'instant)
   • Authentication flow: Standard flow: OFF, Direct access grants: OFF, Service accounts roles: ON
   • Cliquer sur Next puis Save

5. Récupérer le secret

   • Dans l'onglet Credentials
   • Copier le Client secret (ou régénérer si nécessaire)
   • Mettre à jour application-dev.properties avec ce secret :

     quarkus.oidc.credentials.secret=VOTRE_SECRET_ICI
     

6. Attribuer les rôles au service account

   • Aller dans Users → Chercher service-account-lions-user-manager
   • Cliquer sur l'utilisateur
   • Aller dans l'onglet Role mapping
   • Cliquer sur Assign role
   • Filtrer par Filter by realm roles
   • Sélectionner le rôle admin (ou les rôles nécessaires)
   • Cliquer sur Assign

Option 2 : Via kcadm.sh (ligne de commande)

# 1. Se connecter à Keycloak
kcadm.sh config credentials \
    --server http://localhost:8180 \
    --realm master \
    --user admin \
    --password admin

# 2. Créer le client
kcadm.sh create clients -r master -s clientId=lions-user-manager \
    -s enabled=true \
    -s serviceAccountsEnabled=true \
    -s standardFlowEnabled=false \
    -s directAccessGrantsEnabled=false \
    -s publicClient=false \
    -s protocol=openid-connect

# 3. Récupérer l'UUID du client
CLIENT_UUID=$(kcadm.sh get clients -r master --fields id,clientId | \
    jq -r '.[] | select(.clientId=="lions-user-manager") | .id')

# 4. Récupérer ou définir le secret
# Option A: Récupérer le secret généré automatiquement
kcadm.sh get "clients/$CLIENT_UUID/client-secret" -r master

# Option B: Définir un secret personnalisé
kcadm.sh update "clients/$CLIENT_UUID/client-secret" -r master \
    -s value=dev-secret-change-me

# 5. Attribuer le rôle admin au service account
kcadm.sh add-roles -r master \
    --uusername "service-account-lions-user-manager" \
    --rolename admin

Option 3 : Script PowerShell (Windows)

Créez un fichier setup-keycloak-client.ps1 :

# Configuration
$KEYCLOAK_URL = "http://localhost:8180"
$ADMIN_USER = "admin"
$ADMIN_PASSWORD = "admin"
$REALM = "master"
$CLIENT_ID = "lions-user-manager"
$CLIENT_SECRET = "dev-secret-change-me"

# Obtenir le token admin
$tokenResponse = Invoke-RestMethod -Uri "$KEYCLOAK_URL/realms/master/protocol/openid-connect/token" `
    -Method Post `
    -ContentType "application/x-www-form-urlencoded" `
    -Body @{
        grant_type = "password"
        client_id = "admin-cli"
        username = $ADMIN_USER
        password = $ADMIN_PASSWORD
    }

$accessToken = $tokenResponse.access_token
$headers = @{
    "Authorization" = "Bearer $accessToken"
    "Content-Type" = "application/json"
}

# Créer le client
$clientBody = @{
    clientId = $CLIENT_ID
    enabled = $true
    serviceAccountsEnabled = $true
    standardFlowEnabled = $false
    directAccessGrantsEnabled = $false
    publicClient = $false
    protocol = "openid-connect"
} | ConvertTo-Json

try {
    $createResponse = Invoke-RestMethod -Uri "$KEYCLOAK_URL/admin/realms/$REALM/clients" `
        -Method Post `
        -Headers $headers `
        -Body $clientBody
    
    Write-Host "Client créé avec succès"
} catch {
    Write-Host "Erreur lors de la création du client: $_"
    exit 1
}

# Récupérer l'UUID du client
$clients = Invoke-RestMethod -Uri "$KEYCLOAK_URL/admin/realms/$REALM/clients?clientId=$CLIENT_ID" `
    -Method Get `
    -Headers $headers

$clientUuid = $clients[0].id
Write-Host "Client UUID: $clientUuid"

# Définir le secret
$secretBody = @{
    value = $CLIENT_SECRET
} | ConvertTo-Json

Invoke-RestMethod -Uri "$KEYCLOAK_URL/admin/realms/$REALM/clients/$clientUuid/client-secret" `
    -Method Put `
    -Headers $headers `
    -Body $secretBody

Write-Host "Secret défini: $CLIENT_SECRET"

# Attribuer le rôle admin au service account
$serviceAccountUsername = "service-account-$CLIENT_ID"
$users = Invoke-RestMethod -Uri "$KEYCLOAK_URL/admin/realms/$REALM/users?username=$serviceAccountUsername" `
    -Method Get `
    -Headers $headers

if ($users.Count -eq 0) {
    Write-Host "Service account non trouvé. Il sera créé automatiquement lors de la première utilisation."
} else {
    $serviceAccountId = $users[0].id
    
    # Récupérer le rôle admin
    $roles = Invoke-RestMethod -Uri "$KEYCLOAK_URL/admin/realms/$REALM/roles/admin" `
        -Method Get `
        -Headers $headers
    
    # Assigner le rôle
    $roleBody = @($roles) | ConvertTo-Json
    
    Invoke-RestMethod -Uri "$KEYCLOAK_URL/admin/realms/$REALM/users/$serviceAccountId/role-mappings/realm" `
        -Method Post `
        -Headers $headers `
        -Body $roleBody
    
    Write-Host "Rôle admin attribué au service account"
}

Write-Host "Configuration terminée!"

Vérification

Après la configuration, vérifiez que :

1. Le client existe dans Keycloak
2. Le secret correspond à celui dans application-dev.properties
3. Le service account a les rôles nécessaires

Redémarrer le serveur

Une fois le client configuré, redémarrez le serveur Quarkus :

mvn quarkus:dev -pl lions-user-manager-server-impl-quarkus

Le serveur devrait maintenant pouvoir s'authentifier auprès de Keycloak.