> ## Documentation Index > Fetch the complete documentation index at: https://wb-21fd5541-docs-1917.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Gérer les Users, groupes et rôles avec SCIM > Utilisez l'API SCIM pour gérer les Users, les groupes et les rôles personnalisés dans une organisation W&B grâce au provisionnement automatisé. Regardez une [vidéo de démonstration de SCIM en action](https://www.youtube.com/watch?v=Nw3QBqV0I-o) (12 min)
## Aperçu
L’API System for Cross-domain Identity Management (SCIM) permet aux administrateurs de l’instance ou de l’organisation de gérer les utilisateurs, les groupes et les rôles personnalisés dans leur organisation W\&B. Les groupes SCIM correspondent aux Teams W\&B. L’API SCIM de W\&B est compatible avec les principaux fournisseurs d’identité, notamment Okta, ce qui permet le provisionnement et le déprovisionnement automatisés des utilisateurs. Pour configurer le SSO avec Okta et d’autres fournisseurs d’identité, voir la [documentation SSO](/fr/platform/hosting/iam/sso/). Pour obtenir des exemples pratiques en Python montrant comment interagir avec l’API SCIM, consultez notre dépôt [`wandb-scim`](https://github.com/wandb/examples/tree/master/wandb-scim).
### Fonctionnalités prises en charge
* **Filtrage** : l’API prend en charge le filtrage pour les points de terminaison `/Users` et `/Groups` * **Opérations PATCH** : prise en charge de PATCH pour les mises à jour partielles des ressources * **Prise en charge des ETags** : mises à jour conditionnelles à l’aide d’ETags pour détecter les conflits * **Authentification par compte de service** : les comptes de service d’organisation peuvent accéder à l’API Si vous êtes administrateur de plusieurs organisations Enterprise [Cloud mutualisé](/fr/platform/hosting/hosting-options/multi_tenant_cloud), vous devez configurer l’organisation cible des requêtes de l’API SCIM afin de vous assurer que les requêtes de l’API SCIM envoyées avec votre clé API s’appliquent à la bonne organisation. Cliquez sur votre image de profil, puis sur **Paramètres utilisateur**, puis vérifiez le paramètre **Organisation API par défaut**. L’option d’hébergement choisie détermine la valeur de l’espace réservé `` utilisé dans les exemples de cette page. De plus, les exemples utilisent des ID utilisateur comme `abc` et `def`. Dans les requêtes et réponses réelles, les ID utilisateur ont des valeurs hachées.
## Authentification
Les Administrateurs de l’organisation peuvent s’authentifier avec un **jeton Bearer** ou des identifiants **HTTP Basic**. Les deux méthodes utilisent la *même clé API* lorsqu’une clé est utilisée. Choisissez une identité utilisateur ou un compte de service limité à l’organisation après avoir pris connaissance des principales différences.
### Principales différences
* Qui devrait l’utiliser : les utilisateurs conviennent mieux aux actions d’administration interactives et ponctuelles ; les comptes de service conviennent mieux à l’automatisation et aux intégrations (CI/CD, outils de provisionnement). * Identifiants : les utilisateurs envoient un nom d’utilisateur et une clé API pour l’authentification Basic ; les comptes de service envoient uniquement une clé API (sans nom d’utilisateur) pour l’authentification Basic. Pour l’authentification Bearer, envoyez uniquement la clé API dans l’en-tête (sans nom d’utilisateur). * Bearer versus Basic : Bearer utilise `Authorization: Bearer ` avec la clé telle quelle. Basic utilise `Authorization: Basic ` (les utilisateurs encodent `username:API-KEY` ; les comptes de service encodent `:API-KEY` avec un deux-points au début et un nom d’utilisateur vide). * Portée et autorisations : utilisez une clé API d’un utilisateur administrateur de l’instance ou de l’organisation, ou d’un [compte de service limité à l’organisation](/fr/platform/hosting/iam/service-accounts/#organization-scoped-service-accounts). Les clés des [comptes de service à portée d'équipe](/fr/platform/hosting/iam/service-accounts/#team-scoped-service-accounts) ne peuvent pas s’authentifier auprès de l’API SCIM. Les comptes de service qui utilisent SCIM sont limités à l’organisation et non interactifs, ce qui offre des pistes d’audit plus claires pour l’automatisation. * Où obtenir les identifiants : les utilisateurs copient leur clé API depuis les Paramètres utilisateur ; les clés des comptes de service limités à l’organisation se trouvent dans le tableau de bord de l’organisation, sous l’onglet **Compte de service**. * Cloud mutualisé : si vous avez accès à plusieurs organisations dans le Cloud mutualisé, vous devez définir l’organisation API par défaut afin de garantir que les appels à l’API SCIM sont acheminés vers l’organisation prévue.
### Jeton Bearer
Envoyez la clé API sous la forme d’un jeton Bearer : ```bash theme={null} Authorization: Bearer ``` La valeur `` est la même chaîne que celle que vous utiliseriez comme mot de passe pour l’authentification HTTP Basic de ce principal. N’encodez pas la clé en Base64 pour les requêtes Bearer. L’authentification Bearer pour l’API SCIM est disponible dans W\&B Cloud mutualisé, ainsi que dans Cloud dédié et Autogéré à partir de la version v0.79.0. Les exemples suivants utilisent `` comme espace réservé. Remplacez-le par une clé réelle provenant d’un utilisateur administrateur ou d’un compte de service limité à l’organisation. **Lister les utilisateurs** ```bash theme={null} curl -s -S \ -H "Authorization: Bearer " \ -H "Content-Type: application/scim+json" \ "/scim/Users" ``` **Créer un utilisateur** ```bash theme={null} curl -s -S -X POST \ -H "Authorization: Bearer " \ -H "Content-Type: application/scim+json" \ "/scim/Users" \ -d '{ "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"], "userName": "dev-user2", "emails": [{"primary": true, "value": "dev-user2@example.com"}] }' ``` Pour plus de détails, voir [Créer un utilisateur](#create-user).
### Users
Utilisez vos identifiants personnels d’administrateur lorsque vous effectuez des tâches d’administration interactives. Construisez l’en-tête HTTP `Authorization` de la manière suivante : `Basic `. Par exemple, authentifiez-vous avec `demo:p@55w0rd` : ```bash theme={null} Authorization: Basic ZGVtbzpwQDU1dzByZA== ```
### Comptes de service
Utilisez un compte de service limité à l’organisation pour l’automatisation ou les intégrations. Formatez l’en-tête HTTP `Authorization` comme suit : `Basic ` (notez les deux-points initiaux et le nom d’utilisateur vide). Vous trouverez les clés API des comptes de service dans le tableau de bord de l’organisation, sous l’onglet **Compte de service**. Consultez [Comptes de service limités à l’organisation](/fr/platform/hosting/iam/service-accounts/#organization-scoped-service-accounts). Par exemple, authentifiez-vous avec la clé API `sa-p@55w0rd` : ```bash theme={null} Authorization: Basic OnNhLXBANTV3MHJk ```
## Gestion des utilisateurs
La ressource utilisateur SCIM correspond aux utilisateurs W\&B. Utilisez ces points de terminaison pour gérer les utilisateurs de votre organisation. **Modification incompatible pour les intégrations qui analysent le JSON de l’objet User SCIM** * Dans Cloud dédié et Autogéré v0.80.1+, ainsi que dans les déploiements Cloud mutualisé après le 30 avril 2026, les réponses de `/scim/Users` (y compris `GET` user, `GET` users et les réponses `PATCH` qui renvoient un User) sérialisent `emails` sous forme de tableau JSON d’objets avec des noms de champs en minuscules (`value`, `primary`, et `type` ou `display` facultatifs), conformément à SCIM 2.0. * Les déploiements sur des versions antérieures renvoient `emails` sous la forme d’un unique objet JSON avec des clés en PascalCase (`Value`, `Primary` et similaires). Si votre code lit `emails` dans les *réponses* SCIM, traitez `emails` comme un tableau et lisez l’entrée principale (ou le premier élément). Les corps de requête utilisés pour créer ou mettre à jour des utilisateurs sont déjà au format tableau et ne changent pas. Le filtre `list-users` `emails.value eq "..."` reste lui aussi inchangé.
### Obtenir un utilisateur
Récupère les informations d’un utilisateur précis de votre organisation. Cette opération ne récupère pas les comptes de service.
#### Endpoint
* **URL**: `/scim/Users/{id}` * **Méthode**: GET
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | ---------------------------- | | `id` | string | Oui | L’ID unique de l’utilisateur | #### Exemple ```bash theme={null} GET /scim/Users/abc ``` ```bash theme={null} (Status 200) ``` ```json theme={null} { "active": true, "daysActive": 42, "displayName": "Dev User 1", "emails": [ { "primary": true, "value": "dev-user1@example.com" } ], "id": "abc", "lastActiveAt": "2023-10-15T14:32:10Z", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Users/abc" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User" ], "userName": "dev-user1" } ``` La réponse inclut des informations sur l’activité de l’utilisateur dans l’organisation : * **`daysActive`** : nombre total de jours pendant lesquels l’utilisateur a été actif dans l’organisation. * **`lastActiveAt`** : horodatage ISO 8601 de l’activité la plus récente de l’utilisateur. Renvoie `null` si l’utilisateur n’a jamais été actif. La définition d’un utilisateur « actif » varie selon le type de déploiement : * **Cloud dédié / Autogéré** : un utilisateur est considéré comme actif s’il se connecte, ouvre une page dans la W\&B App, enregistre des runs, utilise le SDK ou interagit de quelque manière que ce soit avec le serveur W\&B. * **Cloud mutualisé** : un utilisateur est considéré comme actif s’il effectue, après le 8 mai 2025, une action auditable dans le périmètre de l’organisation. Voir [Actions de journalisation d’audit](/fr/platform/hosting/monitoring-usage/audit-logging#actions) pour la liste complète.
### Lister les Users
Récupère la liste de tous les Users de votre organisation. Cette opération ne récupère pas les comptes de service.
#### Filtrer les Users
Le point de terminaison `/Users` permet de filtrer les Users par nom d’utilisateur ou adresse e-mail : * `userName eq "value"` - Filtrer par nom d’utilisateur * `emails.value eq "value"` - Filtrer par adresse e-mail
##### Exemple
```bash theme={null} GET /scim/Users?filter=userName eq "john.doe" GET /scim/Users?filter=emails.value eq "john@example.com" ```
#### Endpoint
* **URL**: `/scim/Users` * **Méthode**: GET #### Exemple ```bash theme={null} GET /scim/Users ``` ```bash theme={null} (Status 200) ``` ```json theme={null} { "Resources": [ { "active": true, "daysActive": 42, "displayName": "Dev User 1", "emails": [ { "primary": true, "value": "dev-user1@example.com" } ], "id": "abc", "lastActiveAt": "2023-10-15T14:32:10Z", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Users/abc" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User" ], "userName": "dev-user1" } ], "itemsPerPage": 9999, "schemas": [ "urn:ietf:params:scim:api:messages:2.0:ListResponse" ], "startIndex": 1, "totalResults": 1 } ``` La réponse comprend des détails sur l’activité de chaque utilisateur dans l’organisation : * **`daysActive`** : nombre total de jours pendant lesquels l’utilisateur a été actif dans l’organisation. * **`lastActiveAt`** : horodatage ISO 8601 de l’activité la plus récente de l’utilisateur. Renvoie `null` si l’utilisateur n’a jamais été actif. La définition de « active » varie selon le type de déploiement : * **Cloud dédié / Autogéré** : un utilisateur est actif s’il se connecte, ouvre une page dans la W\&B App, enregistre des runs, utilise le SDK ou interagit de quelque manière que ce soit avec le serveur W\&B. * **Cloud mutualisé** : un utilisateur est actif s’il effectue une action auditable dans le périmètre de l’organisation après le 8 mai 2025. Voir [Actions de journalisation d’audit](/fr/platform/hosting/monitoring-usage/audit-logging#actions) pour la liste complète.
### Créer un utilisateur
Crée un nouvel utilisateur au sein de votre organisation.
#### Endpoint
* **URL**: `/scim/Users` * **Méthode**: POST
#### Paramètres
| Paramètre | Type | Requis | Description | | ------------ | ------ | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `emails` | array | Oui | Tableau d’objets e-mail. Doit inclure une adresse e-mail principale | | `userName` | string | Oui | Nom d’utilisateur du nouvel utilisateur | | `modelsSeat` | string | Non | Niveau de licence Models. L’une des valeurs suivantes : `full`, `viewer` ou `none`. La valeur par défaut est `full`. **Uniquement pour Cloud dédié et Autogéré.** | | `weaveRole` | string | Non | Niveau de rôle Weave. L’une des valeurs suivantes : `full`, `viewer` ou `none`. La valeur par défaut est `full`. **Uniquement pour Cloud dédié et Autogéré.** | #### Exemple ```bash theme={null} POST /scim/Users ``` ```json theme={null} { "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User" ], "emails": [ { "primary": true, "value": "dev-user2@example.com" } ], "userName": "dev-user2", "modelsSeat": "full", "weaveRole": "full" } ``` ```bash theme={null} POST /scim/Users ``` ```json theme={null} { "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User", "urn:ietf:params:scim:schemas:extension:teams:2.0:User" ], "emails": [ { "primary": true, "value": "dev-user2@example.com" } ], "userName": "dev-user2", "urn:ietf:params:scim:schemas:extension:teams:2.0:User": { "teams": ["my-team"] } } ```
#### Réponse
```bash theme={null} (Status 201) ``` ```json theme={null} { "active": true, "displayName": "Dev User 2", "emails": [ { "primary": true, "value": "dev-user2@example.com" } ], "id": "def", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "location": "Users/def" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User" ], "modelsSeat": "full", "weaveRole": "full", "userName": "dev-user2" } ``` ```bash theme={null} (Status 201) ``` ```json theme={null} { "active": true, "displayName": "Dev User 2", "emails": [ { "primary": true, "value": "dev-user2@example.com" } ], "id": "def", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "location": "Users/def" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User", "urn:ietf:params:scim:schemas:extension:teams:2.0:User" ], "userName": "dev-user2", "organizationRole": "member", "teamRoles": [ { "teamName": "my-team", "roleName": "member" } ], "groups": [ { "value": "my-team-id" } ] } ```
### Supprimer un utilisateur
**Conservez l’accès administrateur** Vous devez vous assurer qu’au moins un utilisateur administrateur existe en permanence dans votre instance ou votre organisation. Sinon, aucun utilisateur ne pourra configurer ni gérer le compte W\&B de votre organisation. Si une organisation utilise SCIM ou un autre processus automatisé pour retirer des utilisateurs de W\&B, une opération de déprovisionnement pourrait supprimer par inadvertance le dernier administrateur de l’instance ou de l’organisation. Pour obtenir de l’assistance concernant la mise en place de procédures opérationnelles, ou pour rétablir l’accès administrateur, contactez [l’assistance](mailto:support@wandb.com). Supprime définitivement un utilisateur de votre organisation. Cette opération s’applique uniquement aux utilisateurs, pas aux comptes de service. Supprimez un compte de service dans les paramètres du W\&B Team.
#### Endpoint
* **URL**: `/scim/Users/{id}` * **Méthode**: DELETE
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | ---------------------------------------- | | `id` | string | Oui | L’ID unique de l’utilisateur à supprimer | #### Exemple ```bash theme={null} DELETE /scim/Users/abc ``` ```bash theme={null} (Statut 204) ``` Pour désactiver temporairement l’utilisateur, référez-vous à l’API [Désactiver l’utilisateur](#deactivate-user), qui utilise l’endpoint `PATCH`.
### Mettre à jour l’adresse e-mail d’un utilisateur
Met à jour l’adresse e-mail principale d’un utilisateur. **Non pris en charge dans le Cloud mutualisé**, où le compte d’un utilisateur n’est pas géré par l’organisation.
#### Endpoint
* **URL**: `/scim/Users/{id}` * **Méthode**: PATCH
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | -------------------------------------------------- | | `id` | string | Oui | L’ID unique de l’utilisateur | | `op` | string | Oui | `replace` | | `path` | string | Oui | `emails` | | `value` | array | Oui | Tableau contenant le nouvel objet d’adresse e-mail | #### Exemple ```bash theme={null} PATCH /scim/Users/abc ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "path": "emails", "value": [ { "value": "newemail@example.com", "primary": true } ] } ] } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "active": true, "displayName": "Dev User 1", "emails": [ { "primary": true, "value": "newemail@example.com" } ], "id": "abc", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Users/abc" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User" ], "userName": "dev-user1" } ```
### Mettre à jour le nom d’affichage de l’utilisateur
Met à jour le nom d’affichage d’un utilisateur. **Non pris en charge dans le Cloud mutualisé**, où le compte d’un utilisateur n’est pas géré par l’organisation.
#### Endpoint
* **URL**: `/scim/Users/{id}` * **Méthode**: PATCH
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | ---------------------------- | | `id` | string | Oui | L’ID unique de l’utilisateur | | `op` | string | Oui | `replace` | | `path` | string | Oui | `displayName` | | `value` | string | Oui | Nouveau nom d’affichage | #### Exemple ```bash theme={null} PATCH /scim/Users/abc ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "path": "displayName", "value": "John Doe" } ] } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "active": true, "displayName": "John Doe", "emails": [ { "primary": true, "value": "dev-user1@example.com" } ], "id": "abc", "meta": { "resourceType": "User", "created": "2025-7-01T00:00:00Z", "lastModified": "2025-7-01T00:00:00Z", "location": "users/dev-user1" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User" ], "userName": "dev-user1" } ```
### Désactiver un utilisateur
Désactive un utilisateur dans votre organisation. Le résultat varie selon le type de déploiement : * **Cloud dédié** / **Autogéré** : définit le champ `active` de l’utilisateur sur `false`. Pour rétablir l’accès d’un utilisateur désactivé à votre organisation, voir [Réactiver un utilisateur](#reactivate-user). * **Cloud mutualisé** : supprime l’utilisateur de l’organisation. Pour rétablir l’accès de l’utilisateur, ajoutez-le de nouveau à votre organisation. Voir [Créer un utilisateur](#create-user-request-multi-tenant). Dans le Cloud mutualisé, le compte d’un utilisateur n’est pas géré par l’organisation. Cette opération fonctionne uniquement pour les utilisateurs, pas pour les comptes de service. La désactivation d’un compte de service n’est pas prise en charge. Gérez les comptes de service d’équipe dans les Settings de la W\&B Team.
#### Endpoint
* **URL**: `/scim/Users/{id}` * **Méthode**: PATCH
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | ----------------------------------------- | | `id` | string | Oui | L’ID unique de l’utilisateur à désactiver | | `op` | string | Oui | `replace` | | `value` | objet | Oui | Objet contenant `{"active": false}` | #### Exemple ```bash theme={null} PATCH /scim/Users/abc ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "value": {"active": false} } ] } ``` ```bash theme={null} PATCH /scim/Users ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "value": {"active": false} } ] } ```
#### Réponse
```bash theme={null} (Statut 200) ``` ```json theme={null} { "active": false, "displayName": "Dev User 1", "emails": [ { "primary": true, "value": "dev-user1@example.com" } ], "id": "abc", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Users/abc" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User" ], "userName": "dev-user1" } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "value": {"active": true} } ] } ```
### Réactiver un utilisateur
Réactive un utilisateur précédemment désactivé dans votre organisation. * La réactivation ne fonctionne que pour les utilisateurs, pas pour les comptes de service. Elle n'est pas prise en charge pour les comptes de service. Gérez les comptes de service dans les paramètres de l'équipe W\&B. * La réactivation des utilisateurs n'est pas prise en charge dans le [Cloud mutualisé](/fr/platform/hosting/hosting-options/multi_tenant_cloud). Pour restaurer l'accès de l'utilisateur, ajoutez-le à nouveau à votre organisation. Voir [Créer un utilisateur](#create-user-request-multi-tenant). Dans le Cloud mutualisé, le compte d'un utilisateur n'est pas géré par l'organisation. Toute tentative de réactivation d'un utilisateur entraîne une erreur HTTP `400`. Le champ `detail` dans le corps de la réponse est renvoyé tel quel par l'API et peut encore utiliser l'ancienne terminologie du produit : ```json theme={null} { "schemas": [ "urn:ietf:params:scim:api:messages:2.0:Error" ], "detail": "User reactivation operations are not supported in SaaS Cloud", "status": "400" } ```
#### Endpoint
* **URL**: `/scim/Users/{id}` * **Méthode**: PATCH
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | ---------------------------------------- | | `id` | string | Oui | L’ID unique de l’utilisateur à réactiver | | `op` | string | Oui | `replace` | | `value` | objet | Oui | Objet contenant `{"active": true}` | #### Exemple ```bash theme={null} PATCH /scim/Users/abc ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "value": {"active": true} } ] } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "active": true, "displayName": "Dev User 1", "emails": [ { "primary": true, "value": "dev-user1@example.com" } ], "id": "abc", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Users/abc" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User" ], "userName": "dev-user1" } ```
### Attribuer un rôle au niveau de l’organisation
Attribue à un utilisateur un rôle au niveau de l’organisation. Cette opération fonctionne uniquement pour les utilisateurs, pas pour les comptes de service. Les rôles personnalisés ne sont pas pris en charge pour les comptes de service.
#### Endpoint
* **URL**: `/scim/Users/{id}` * **Méthode**: PATCH
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | --------------------------------- | | `id` | string | Oui | L'ID unique de l'utilisateur | | `op` | string | Oui | `replace` | | `path` | string | Oui | `organizationRole` | | `value` | string | Oui | Nom du rôle (`admin` ou `member`) | Le rôle `viewer` au niveau de l'organisation est obsolète et ne peut plus être attribué dans l'interface utilisateur. Si vous utilisez SCIM pour attribuer le rôle `viewer` à un utilisateur : * Le rôle `member` lui est attribué dans l'organisation. * Son `modelsSeat` est défini sur `viewer` au lieu de `full`. Cela permet un accès en lecture seule à Models et un accès complet au registre. Si aucune licence Models n'est disponible, une erreur `Seat limit reached` est renvoyée. Cela pourra être mis à jour plus tard si une licence devient disponible. * Son `weaveRole` est défini sur `viewer` au lieu de `full`. Cela permet un accès en lecture seule à Weave. * Tous ses rôles d'équipe et de projet existants sont définis sur `viewer`. * Le rôle `viewer` du registre lui est attribué dans les registres visibles au niveau de l'organisation. L'attribution du rôle d'organisation `member` ou `admin` ne modifie pas le `modelsSeat` ni le `weaveRole` de l'utilisateur. #### Exemple ```bash theme={null} PATCH /scim/Users/abc ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "path": "organizationRole", "value": "admin" } ] } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "active": true, "displayName": "Dev User 1", "emails": [ { "primary": true, "value": "dev-user1@example.com" } ], "id": "abc", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Users/abc" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User" ], "userName": "dev-user1", "teamRoles": [ { "teamName": "team1", "roleName": "admin" } ], "organizationRole": "admin" } ```
### Mettre à jour la licence Models
Met à jour la licence Models attribuée à un utilisateur. **Cloud dédié** et **Autogéré** uniquement.
#### Endpoint
* **URL**: `/scim/Users/{id}` * **Méthode**: PATCH
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | ---------------------------------------------- | | `id` | string | Oui | L'ID unique de l'utilisateur | | `op` | string | Oui | `replace` | | `path` | string | Oui | `modelsSeat` | | `value` | string | Oui | Niveau de licence (`full`, `viewer` ou `none`) | #### Exemple ```bash theme={null} PATCH /scim/Users/abc ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "path": "modelsSeat", "value": "full" } ] } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "active": true, "displayName": "Dev User 1", "emails": [ { "primary": true, "value": "dev-user1@example.com" } ], "id": "abc", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Users/abc" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User" ], "userName": "dev-user1", "organizationRole": "member", "modelsSeat": "full", "weaveRole": "full" } ```
### Mettre à jour le rôle Weave
Met à jour le rôle d'un utilisateur dans Weave. **Cloud dédié** et **Autogéré** uniquement.
#### Endpoint
* **URL**: `/scim/Users/{id}` * **Méthode**: PATCH
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | ------------------------------------------- | | `id` | string | Oui | L'ID unique de l'utilisateur | | `op` | string | Oui | `replace` | | `path` | string | Oui | `weaveRole` | | `value` | string | Oui | Niveau de rôle (`full`, `viewer` ou `none`) | #### Exemple ```bash theme={null} PATCH /scim/Users/abc ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "path": "weaveRole", "value": "full" } ] } ``` ```bash theme={null} (statut 200) ``` ```json theme={null} { "active": true, "displayName": "Dev User 1", "emails": [ { "primary": true, "value": "dev-user1@example.com" } ], "id": "abc", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Users/abc" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User" ], "userName": "dev-user1", "organizationRole": "member", "modelsSeat": "full", "weaveRole": "full" } ```
### Attribuer un rôle d’équipe
Attribue à un utilisateur un rôle d’équipe. Cette opération s’applique uniquement aux utilisateurs, et non aux comptes de service. Les rôles personnalisés ne sont pas pris en charge pour les comptes de service.
#### Endpoint
* **URL**: `/scim/Users/{id}` * **Méthode**: PATCH
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | --------------------------------------------------- | | `id` | string | Oui | L’ID unique de l’utilisateur | | `op` | string | Oui | `replace` | | `path` | string | Oui | `teamRoles` | | `value` | array | Oui | Tableau d’objets contenant `teamName` et `roleName` | #### Exemple ```bash theme={null} PATCH /scim/Users/abc ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "path": "teamRoles", "value": [ { "roleName": "admin", "teamName": "team1" } ] } ] } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "active": true, "displayName": "Dev User 1", "emails": [ { "primary": true, "value": "dev-user1@example.com" } ], "id": "abc", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Users/abc" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User" ], "userName": "dev-user1", "teamRoles": [ { "teamName": "team1", "roleName": "admin" } ], "organizationRole": "admin" } ```
### Ajouter au registre
Ajoute un utilisateur à un registre en lui attribuant un rôle au niveau du registre. Cette opération fonctionne uniquement pour les utilisateurs, et non pour les comptes de service. Les rôles personnalisés ne sont pas pris en charge pour les comptes de service.
#### Endpoint
* **URL**: `/scim/Users/{id}` * **Méthode**: PATCH
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | ------------------------------------------------------- | | `id` | string | Oui | L’ID unique de l’utilisateur | | `op` | string | Oui | `add` | | `path` | string | Oui | `registryRoles` | | `value` | array | Oui | Tableau d’objets contenant `registryName` et `roleName` | #### Exemple ```bash theme={null} PATCH /scim/Users/abc ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "path": "registryRoles", "value": [ { "roleName": "admin", "registryName": "hello-registry" } ] } ] } ``` ```bash theme={null} (Status 200) ``` ```json theme={null} { "active": true, "displayName": "Dev User 1", "emails": [ { "primary": true, "value": "dev-user1@example.com" } ], "id": "abc", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Users/abc" }, "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"], "userName": "dev-user1", "registryRoles": [ { "registryName": "hello-registry", "roleName": "admin" } ], "organizationRole": "admin" } ```
### Retirer du registre
Retire un utilisateur d’un registre. * Les opérations de suppression suivent les spécifications du protocole SCIM RFC 7644. Utilisez la syntaxe de filtre `"registryRoles[registryName eq \"{registry_name}\"]"` pour retirer un utilisateur d’un registre spécifique, ou `"registryRoles"` pour retirer l’utilisateur de tous les registres. * Cette opération fonctionne uniquement pour les utilisateurs, pas pour les comptes de service. Retirez les comptes de service d’un registre dans les paramètres de la Team W\&B.
#### Endpoint
* **URL**: `/scim/Users/{id}` * **Méthode**: PATCH
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | --------------------------------------------------------------------------- | | `id` | string | Yes | L’ID unique de l’utilisateur | | `op` | string | Yes | `remove` | | `path` | string | Yes | `"registryRoles[registryName eq \"{registry_name}\"]"` ou `"registryRoles"` | #### Exemple ```bash theme={null} PATCH /scim/Users/abc ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "path": "registryRoles[registryName eq \"goodbye-registry\"]" } ] } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "active": true, "displayName": "Dev User 1", "emails": [ { "primary": true, "value": "dev-user1@example.com" } ], "id": "abc", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Users/abc" }, "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"], "userName": "dev-user1", "registryRoles": [ { "registryName": "hello-registry", "roleName": "admin" } ], "organizationRole": "admin" } ``` ```bash theme={null} PATCH /scim/Users/abc ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "path": "registryRoles" } ] } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "active": true, "displayName": "Dev User 1", "emails": [ { "primary": true, "value": "dev-user1@example.com" } ], "id": "abc", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Users/abc" }, "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"], "userName": "dev-user1", "organizationRole": "admin" } ```
## Ressource de groupe
Lorsque vous créez un groupe SCIM dans votre IAM, cela crée un mappage vers une équipe W\&B, et les autres opérations sur les groupes SCIM s’appliquent à cette équipe. Pour configurer un stockage personnalisé lors de la création de l’équipe, incluez `storageBucket` dans la requête.
### Comptes de service
Lorsqu’une équipe W\&B est créée à l’aide de SCIM, tous les comptes de service au niveau de l’organisation y sont automatiquement ajoutés afin de préserver leur accès aux ressources de l’équipe.
### Filtrage des groupes
Le point de terminaison `/Groups` permet de filtrer les résultats pour rechercher des Teams spécifiques :
#### Filtres pris en charge
* `displayName eq "value"` - Filtrer par nom d’affichage de l’équipe #### Exemple ```bash theme={null} GET /scim/Groups?filter=displayName eq "engineering-team" ```
### Obtenir l’équipe
Récupérez les informations d’une équipe à l’aide de son ID unique.
#### Endpoint
* **URL**: `/scim/Groups/{id}` * **Méthode**: GET #### Exemple ```bash theme={null} GET /scim/Groups/ghi ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "displayName": "acme-devs", "id": "ghi", "members": [ { "Value": "abc", "Ref": "", "Type": "", "Display": "dev-user1" } ], "meta": { "resourceType": "Group", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Groups/ghi" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:Group" ] } ```
### Liste des équipes
Récupérez la liste des équipes.
#### Endpoint
* **URL**: `/scim/Groups` * **Méthode**: GET #### Exemple ```bash theme={null} GET /scim/Groups ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "Resources": [ { "displayName": "acme-devs", "id": "ghi", "members": [ { "Value": "abc", "Ref": "", "Type": "", "Display": "dev-user1" } ], "meta": { "resourceType": "Group", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Groups/ghi" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:Group" ] } ], "itemsPerPage": 9999, "schemas": [ "urn:ietf:params:scim:api:messages:2.0:ListResponse" ], "startIndex": 1, "totalResults": 1 } ```
### Créer une équipe
* **Endpoint**: **`/scim/Groups`** * **Méthode**: POST * **Description**: Crée une nouvelle ressource d’équipe. * **Champs pris en charge**: | Champ | Type | Requis | | --------------- | ------------------- | -------------------------------------------------------------------------- | | `displayName` | Chaîne | Oui | | `members` | Tableau multivaleur | Oui (le sous-champ `value` est requis et correspond à un ID d'utilisateur) | | `storageBucket` | Objet | Non | Vous pouvez configurer [Bring your own bucket (BYOB)](/fr/platform/hosting/data-security/secure-storage-connector) au niveau de l’équipe lors de sa création en incluant un objet `storageBucket`. S'il est omis, l’équipe utilise le stockage par défaut ou le stockage au niveau de l'instance. Provisionnez le bucket (stratégie, CORS, identifiants) et déterminez, à l'aide du guide BYOB, le format d'adresse de stockage selon le fournisseur. L'objet `storageBucket` comporte les sous-champs suivants : * **Requis**: `name` (nom du bucket), `provider` (l'une des valeurs suivantes : `COREWEAVE`, `AWS`, `AZURE`, `GCP` ou `MINIO`). La valeur est sensible à la casse ; utilisez les majuscules comme indiqué. * **Facultatif**: `path` (préfixe de chemin dans le bucket), `kmsKeyId` (clé KMS pour le chiffrement, par exemple pour AWS), `awsExternalId` (accès AWS inter-comptes), `azureTenantId` (ID du locataire Azure), `azureClientId` (ID client de l'identité managée Azure). W\&B valide que le bucket existe et est accessible avant de créer l’équipe. Si la validation échoue, la requête SCIM échoue et l’équipe n'est pas créée. Une valeur `provider` invalide renvoie `400 Bad Request` avec une erreur SCIM qui répertorie les valeurs autorisées.
#### Exemples
Ces exemples montrent comment créer une équipe sans stockage personnalisé et avec un stockage BYOB chez un fournisseur donné. Sélectionnez un onglet correspondant à la configuration de stockage souhaitée pour afficher un exemple de requête, puis sélectionnez l’onglet **Réponse** pour voir un exemple de réponse. ```bash theme={null} POST /scim/Groups ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"], "displayName": "wandb-support", "members": [ { "value": "def" } ] } ``` ```bash theme={null} POST /scim/Groups Content-Type: application/scim+json ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"], "displayName": "ml-training-team", "members": [ { "value": "user@example.com", "display": "user@example.com" } ], "storageBucket": { "name": "wandb-coreweave-bucket", "provider": "COREWEAVE", "path": "ml-training/experiments" } } ``` ```bash theme={null} POST /scim/Groups Content-Type: application/scim+json ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"], "displayName": "ml-team", "members": [ { "value": "user@example.com", "display": "user@example.com" } ], "storageBucket": { "name": "my-company-wandb-data", "provider": "AWS", "path": "ml-team/experiments", "kmsKeyId": "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012", "awsExternalId": "wandb-external-id-abc123" } } ``` ```bash theme={null} POST /scim/Groups Content-Type: application/scim+json ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"], "displayName": "research-team", "members": [], "storageBucket": { "name": "wandbstorage", "provider": "AZURE", "path": "research/artifacts", "azureTenantId": "12345678-1234-1234-1234-123456789012", "azureClientId": "87654321-4321-4321-4321-210987654321" } } ``` ```bash theme={null} POST /scim/Groups Content-Type: application/scim+json ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"], "displayName": "data-science-team", "members": [ { "value": "VXNlcjox", "display": "jane.doe@example.com" }, { "value": "VXNlcjoy", "display": "john.smith@example.com" } ], "storageBucket": { "name": "my-gcs-bucket", "provider": "GCP", "path": "data-science/runs" } } ``` ```bash theme={null} (Statut 201) ``` ```json theme={null} { "displayName": "wandb-support", "id": "jkl", "members": [ { "Value": "def", "Ref": "", "Type": "", "Display": "dev-user2" } ], "meta": { "resourceType": "Group", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:00:00Z", "location": "Groups/jkl" }, "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"] } ```
### Mettre à jour l’équipe
* **Endpoint** : **`/scim/Groups/{id}`** * **Méthode** : PATCH * **Description** : Mettre à jour la liste des membres d’une équipe existante. * **Opérations prises en charge** : `add` un membre, `remove` un membre, `replace` les membres - Les opérations de suppression suivent les spécifications du protocole SCIM RFC 7644. Utilisez la syntaxe de filtre `members[value eq "{user_id}"]` pour supprimer un utilisateur spécifique, ou `members` pour supprimer tous les utilisateurs de l’équipe. **Identification de l’utilisateur** : le `{user_id}` dans les opérations sur les membres peut être : * Un ID utilisateur W\&B * Une adresse e-mail (par exemple, "[user@example.com](mailto:user@example.com)") - Ces opérations fonctionnent uniquement pour les utilisateurs, pas pour les comptes de service. Mettez à jour les comptes de service d’une équipe dans les Settings de l’équipe W\&B. Remplacez `{team_id}` par l’ID réel de l’équipe et `{user_id}` par l’ID utilisateur réel ou l’adresse e-mail réelle dans vos requêtes.
### Remplacer les membres de l’équipe
Remplace tous les membres d’une équipe par une nouvelle liste. Cette opération s’applique uniquement aux utilisateurs, pas aux comptes de service. Gérez les comptes de service dans les Settings de l’équipe W\&B. * **Endpoint** : **`/scim/Groups/{id}`** * **Méthode** : PUT * **Description** : Remplacer l’intégralité de la liste des membres de l’équipe. ```bash theme={null} PUT /scim/Groups/{team_id} ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"], "displayName": "acme-devs", "members": [ { "value": "{user_id_1}" }, { "value": "{user_id_2}" } ] } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "displayName": "acme-devs", "id": "ghi", "members": [ { "Value": "user_id_1", "Ref": "", "Type": "", "Display": "user1" }, { "Value": "user_id_2", "Ref": "", "Type": "", "Display": "user2" } ], "meta": { "resourceType": "Group", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:01:00Z", "location": "Groups/ghi" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:Group" ] } ``` **Ajouter un utilisateur à une équipe** Ajout de `dev-user2` à `acme-devs` : Cette opération s’applique uniquement aux utilisateurs, pas aux comptes de service. Gérez les comptes de service dans les Settings de l’équipe W\&B. ```bash theme={null} PATCH /scim/Groups/{team_id} ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "add", "path": "members", "value": [ { "value": "{user_id}" } ] } ] } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "displayName": "acme-devs", "id": "ghi", "members": [ { "Value": "abc", "Ref": "", "Type": "", "Display": "dev-user1" }, { "Value": "def", "Ref": "", "Type": "", "Display": "dev-user2" } ], "meta": { "resourceType": "Group", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:01:00Z", "location": "Groups/ghi" }, "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:Group" ] } ``` **Supprimer un utilisateur spécifique d’une équipe** Suppression de `dev-user2` de `acme-devs` : Cette opération s’applique uniquement aux utilisateurs, pas aux comptes de service. Gérez les comptes de service dans les Settings de l’équipe W\&B. ```bash theme={null} PATCH /scim/Groups/{team_id} ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "remove", "path": "members[value eq \"{user_id}\"]" } ] } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "displayName": "acme-devs", "id": "ghi", "members": [ { "Value": "abc", "Display": "dev-user1" } ], "meta": { "resourceType": "Group", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:01:00Z", "location": "Groups/ghi" }, "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"] } ``` **Suppression de tous les Users d'une équipe** Suppression de tous les Users de `acme-devs` : Cette opération fonctionne uniquement pour les Users, pas pour les comptes de service. Gérez les comptes de service dans les Settings de l’équipe W\&B. ```bash theme={null} PATCH /scim/Groups/{team_id} ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "remove", "path": "members" } ] } ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "displayName": "acme-devs", "id": "ghi", "members": null, "meta": { "resourceType": "Group", "created": "2023-10-01T00:00:00Z", "lastModified": "2023-10-01T00:01:00Z", "location": "Groups/ghi" }, "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"] } ```
### Supprimer une équipe
* La suppression des équipes n’est actuellement pas prise en charge par l’API SCIM, car des données supplémentaires y sont associées. Supprimez les équipes depuis l’application pour confirmer que vous souhaitez tout supprimer.
## Ressource de rôle
La ressource de rôle SCIM correspond aux rôles personnalisés de W\&B. Comme indiqué précédemment, les endpoints `/Roles` ne font pas partie du schéma SCIM officiel. W\&B ajoute ces endpoints `/Roles` pour permettre la gestion automatisée des rôles personnalisés dans les organisations W\&B.
### Obtenir un rôle personnalisé
Récupérez les informations d’un rôle personnalisé en indiquant son ID unique.
#### Endpoint
* **URL**: `/scim/Roles/{id}` * **Méthode**: GET #### Exemple ```bash theme={null} GET /scim/Roles/abc ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "description": "Exemple de rôle personnalisé", "id": "Um9sZTo3", "inheritedFrom": "member", // indique le rôle prédéfini "meta": { "resourceType": "Role", "created": "2023-11-20T23:10:14Z", "lastModified": "2023-11-20T23:31:23Z", "location": "Roles/Um9sZTo3" }, "name": "Rôle personnalisé d’exemple", "organizationID": "T3JnYW5pemF0aW9uOjE0ODQ1OA==", "permissions": [ { "name": "artifact:read", "isInherited": true // hérité du rôle prédéfini member }, ... ... { "name": "project:update", "isInherited": false // autorisation personnalisée ajoutée par l’administrateur } ], "schemas": [ "" ] } ```
### Lister les rôles personnalisés
Récupérez les informations sur tous les rôles personnalisés de l’organisation W\&B.
#### Endpoint
* **URL**: `/scim/Roles` * **Méthode**: GET #### Exemple ```bash theme={null} GET /scim/Roles ``` ```bash theme={null} (Statut 200) ``` ```json theme={null} { "Resources": [ { "description": "Exemple de rôle personnalisé", "id": "Um9sZTo3", "inheritedFrom": "member", // indique le rôle prédéfini dont hérite le rôle personnalisé "meta": { "resourceType": "Role", "created": "2023-11-20T23:10:14Z", "lastModified": "2023-11-20T23:31:23Z", "location": "Roles/Um9sZTo3" }, "name": "Rôle personnalisé d’exemple", "organizationID": "T3JnYW5pemF0aW9uOjE0ODQ1OA==", "permissions": [ { "name": "artifact:read", "isInherited": true // hérité du rôle prédéfini member }, ... ... { "name": "project:update", "isInherited": false // autorisation personnalisée ajoutée par l’administrateur } ], "schemas": [ "" ] }, { "description": "Autre exemple de rôle personnalisé", "id": "Um9sZToxMg==", "inheritedFrom": "viewer", // indique le rôle prédéfini dont hérite le rôle personnalisé "meta": { "resourceType": "Role", "created": "2023-11-21T01:07:50Z", "location": "Roles/Um9sZToxMg==" }, "name": "Rôle personnalisé d’exemple 2", "organizationID": "T3JnYW5pemF0aW9uOjE0ODQ1OA==", "permissions": [ { "name": "launchagent:read", "isInherited": true // hérité du rôle prédéfini viewer }, ... ... { "name": "run:stop", "isInherited": false // autorisation personnalisée ajoutée par l’administrateur } ], "schemas": [ "" ] } ], "itemsPerPage": 9999, "schemas": [ "urn:ietf:params:scim:api:messages:2.0:ListResponse" ], "startIndex": 1, "totalResults": 2 } ```
### Créer un rôle personnalisé
* **Endpoint**: **`/scim/Roles`** * **Méthode**: POST * **Description**: Crée un nouveau rôle personnalisé dans l’organisation W\&B. * **Champs pris en charge**: | Champ | Type | Requis | | --------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `name` | String | Nom du rôle personnalisé | | `description` | String | Description du rôle personnalisé | | `permissions` | Object array | Tableau d’objets d’autorisation, où chaque objet contient un champ de type chaîne `name` dont la valeur est de la forme `w&bobject:operation`. Par exemple, pour une opération de suppression sur des runs W\&B, un objet d’autorisation aurait `name` défini sur `run:delete`. | | `inheritedFrom` | String | Le rôle prédéfini dont hérite le rôle personnalisé. Il peut s’agir de `member` ou de `viewer`. | #### Exemple ```bash theme={null} POST /scim/Roles ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Role"], "name": "Sample custom role", "description": "A sample custom role for example", "permissions": [ { "name": "project:update" } ], "inheritedFrom": "member" } ``` ```bash theme={null} (statut 201) ``` ```json theme={null} { "description": "A sample custom role for example", "id": "Um9sZTo3", "inheritedFrom": "member", // indique le rôle prédéfini "meta": { "resourceType": "Role", "created": "2023-11-20T23:10:14Z", "lastModified": "2023-11-20T23:31:23Z", "location": "Roles/Um9sZTo3" }, "name": "Sample custom role", "organizationID": "T3JnYW5pemF0aW9uOjE0ODQ1OA==", "permissions": [ { "name": "artifact:read", "isInherited": true // hérité du rôle prédéfini member }, ... ... { "name": "project:update", "isInherited": false // autorisation personnalisée ajoutée par l’administrateur } ], "schemas": [ "" ] } ```
### Mettre à jour un rôle personnalisé
#### Ajouter des autorisations à un rôle
* **Endpoint** : **`/scim/Roles/{id}`** * **Méthode** : PATCH * **Description** : Ajouter des autorisations à un rôle personnalisé existant. ```bash theme={null} PATCH /scim/Roles/{role_id} ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "add", "path": "permissions", "value": [ { "name": "project:delete" }, { "name": "run:stop" } ] } ] } ``` ```bash theme={null} (Status 200) ``` Renvoie le rôle mis à jour, avec les nouvelles autorisations ajoutées.
#### Supprimer une autorisation d’un rôle
* **Endpoint**: **`/scim/Roles/{id}`** * **Méthode**: PATCH * **Description**: Supprime des autorisations d’un rôle personnalisé existant. ```bash theme={null} PATCH /scim/Roles/{role_id} ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "remove", "path": "permissions", "value": [ { "name": "project:update" } ] } ] } ``` ```bash theme={null} (Status 200) ``` Renvoie le rôle mis à jour, avec les autorisations spécifiées supprimées.
### Remplacer le rôle personnalisé
* **Endpoint**: **`/scim/Roles/{id}`** * **Méthode**: PUT * **Description**: Remplace intégralement la définition d’un rôle personnalisé. ```bash theme={null} PUT /scim/Roles/{role_id} ``` ```json theme={null} { "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Role"], "name": "Updated custom role", "description": "Updated description for the custom role", "permissions": [ { "name": "project:read" }, { "name": "run:read" }, { "name": "artifact:read" } ], "inheritedFrom": "viewer" } ``` ```bash theme={null} (Status 200) ``` Renvoie la définition du rôle après son remplacement complet.
### Supprimer un rôle personnalisé
Supprimez un rôle personnalisé dans l’organisation W\&B. **À utiliser avec prudence**. Le rôle prédéfini dont héritait le rôle personnalisé est désormais attribué à tous les utilisateurs auxquels ce rôle personnalisé était attribué avant l’opération.
#### Endpoint
* **URL** : `/scim/Roles/{id}` * **Méthode** : DELETE #### Exemple ```bash theme={null} DELETE /scim/Roles/abc ``` ```bash theme={null} (Statut 204 No Content) ```
## Fonctionnalités avancées
### Prise en charge des ETags
L’API SCIM prend en charge les ETags pour les mises à jour conditionnelles afin d’éviter les conflits liés aux modifications simultanées. Les ETags sont renvoyés dans l’en-tête de réponse `ETag` et dans le champ `meta.version`.
#### ETags
Pour utiliser les ETags : 1. **Obtenir l’ETag actuel** : lorsque vous envoyez une requête GET sur une ressource, relevez l’en-tête ETag dans la réponse 2. **Mise à jour conditionnelle** : incluez l’ETag dans l’en-tête `If-Match` lors de la mise à jour #### Exemple ``` # Obtenir l'utilisateur et noter l'ETag GET /scim/Users/abc # La réponse inclut : ETag: W/"xyz123" # Mettre à jour avec l'ETag PATCH /scim/Users/abc If-Match: W/"xyz123" { "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [ { "op": "replace", "path": "organizationRole", "value": "admin" } ] } ``` Une réponse d’erreur `412 Precondition Failed` indique que la ressource a été modifiée depuis que vous l’avez récupérée.
### Gestion des erreurs
L’API SCIM renvoie des réponses d’erreur SCIM standard : | Code de statut | Description | | -------------- | ------------------------------------------------------------------------- | | `200` | Succès | | `201` | Création réussie | | `204` | No Content (suppression réussie) | | `400` | Requête incorrecte - paramètres invalides ou corps de la requête invalide | | `401` | Non autorisé - Échec de l’authentification | | `403` | Interdit - Permissions insuffisantes | | `404` | Introuvable - La ressource n’existe pas | | `409` | Conflit - La ressource existe déjà | | `412` | Échec de la précondition - ETag non correspondant | | `500` | Erreur interne du serveur |
### Différences d’implémentation selon le type de déploiement
W\&B propose deux implémentations distinctes de l’API SCIM, dont les fonctionnalités diffèrent : | Fonctionnalité | Cloud mutualisé | Cloud dédié et Autogéré | | ---------------------------------------------------- | --------------- | ----------------------- | | Mettre à jour l’adresse e-mail de l’utilisateur | - | ✓ | | Mettre à jour le nom d’affichage de l’utilisateur | - | ✓ | | Désactivation de l’utilisateur | ✓ | ✓ | | Réactivation de l’utilisateur | - | ✓ | | Plusieurs adresses e-mail par utilisateur | ✓ | - | | Définir `modelsSeat` lors de la création/mise à jour | - | ✓ | | Définir `weaveRole` lors de la création/mise à jour | - | ✓ |
## Limitations
* **Nombre maximal de résultats** : 9999 éléments par requête. * **Cloud dédié et Autogéré** : ne prennent en charge qu’une seule adresse e-mail par utilisateur. * **Suppression de Teams** : non prise en charge via SCIM (utilisez l'interface web W\&B). * **Réactivation des utilisateurs** : non prise en charge dans les environnements de Cloud mutualisé. * **Limites de licences** : les opérations peuvent échouer si les limites de licences de l'organisation sont atteintes.