Permissions & RBAC

L'API Products Manager utilise un systeme RBAC (Role-Based Access Control) pour gerer les autorisations de maniere granulaire et securisee.

Vue d'Ensemble

Le systeme de permissions offre :

• Controle d'acces base sur les roles (RBAC)
• Permissions granulaires par ressource et action
• Support des permissions personnalisees par utilisateur
• Priorite : Superuser > Permissions JSON > Role

Hierarchie des Roles

Products Manager definit 4 roles avec des niveaux de privileges croissants :

Format des Permissions

Les permissions suivent le format action:resource :

read:products      # Lecture des produits
write:suppliers    # Creation/modification des fournisseurs
delete:imports     # Suppression des imports
manage:cache       # Gestion complete du cache

Actions Disponibles

Permissions par Ressource

Products (Produits)

Suppliers (Fournisseurs)

Imports

Exports

Analytics

Media (Images)

Cache

Code2ASIN

Templates (Mapping Templates)

System & Monitoring

Files

Prices (Prix)

Environmental Data

AI Metadata

Workflows

Tags

Integrations

Enrichment

Reports

Administration

Utilisation des Decorateurs de Permission

require_permission

Exige une permission specifique pour acceder a un endpoint :

from core.permissions import Permission, require_permission

@router.get("/products")
async def list_products(
    current_user: User = Depends(require_permission(Permission.READ_PRODUCTS))
):
    # L'utilisateur a la permission read:products
    return await get_products()

require_any_permission

Exige au moins une des permissions specifiees :

from core.permissions import Permission, require_any_permission

@router.get("/dashboard")
async def get_dashboard(
    current_user: User = Depends(
        require_any_permission(Permission.READ_PRODUCTS, Permission.READ_ANALYTICS)
    )
):
    # L'utilisateur a au moins une des deux permissions
    return await get_dashboard_data()

require_all_permissions

Exige toutes les permissions specifiees :

from core.permissions import Permission, require_all_permissions

@router.delete("/critical-operation")
async def critical_operation(
    current_user: User = Depends(
        require_all_permissions(Permission.DELETE_PRODUCTS, Permission.ADMIN_ACCESS)
    )
):
    # L'utilisateur a les DEUX permissions requises
    return await perform_critical_operation()

require_role

Exige un role specifique :

from core.permissions import Role, require_role

@router.get("/admin/settings")
async def admin_settings(
    current_user: User = Depends(require_role(Role.ADMIN))
):
    # Seuls les ADMIN peuvent acceder
    return await get_settings()

Gestion des Erreurs 403

Quand un utilisateur n'a pas les permissions requises, l'API retourne une erreur 403 Forbidden :

Reponse d'Erreur

{
  "detail": "Insufficient permissions. Required: read:products"
}

Erreur pour Permissions Multiples

{
  "detail": "Insufficient permissions. Required one of: read:products, read:analytics"
}

{
  "detail": "Insufficient permissions. Required all of: delete:products, admin:access"
}

Erreur de Role

{
  "detail": "Insufficient role. Required: admin, you have: user"
}

Permissions Personnalisees (JSON)

Les utilisateurs peuvent avoir des permissions granulaires stockees dans un champ JSON, qui prennent priorite sur les permissions basees sur le role :

{
  "read:products": true,
  "write:suppliers": true,
  "delete:products": false,
  "manage:imports": true
}

Priorite de Resolution

L'ordre de priorite pour determiner les permissions d'un utilisateur :

1. Superuser : A toutes les permissions (bypass complet)
2. Permissions JSON : Si definies, utilisees exclusivement
3. Role : Fallback vers les permissions du role assigne

def get_user_permissions(user: User) -> list[Permission]:
    # 1. Superuser = toutes les permissions
    if user.is_superuser:
        return list(Permission)

    # 2. Permissions JSON si definies
    if user.permissions:
        return parse_json_permissions(user.permissions)

    # 3. Permissions basees sur le role
    return ROLE_PERMISSIONS.get(user.role, [])

Bonnes Pratiques

1. Principe du moindre privilege : Attribuez uniquement les permissions necessaires
2. Utilisez les roles : Preferez les roles aux permissions individuelles pour la maintenabilite
3. Auditez regulierement : Verifiez periodiquement les permissions des utilisateurs
4. Superusers limites : Restreignez le nombre de superusers au strict minimum

Ressources Associees

• Authentification API
• Endpoints API
• Securite