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 :
     ```properties
     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)

```bash
# 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` :

```powershell
# 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 :

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

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