> ## Documentation Index > Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt > Use this file to discover all available pages before exploring further. # Gérer les utilisateurs, groupes et rôles avec SCIM > Utilisez l'API SCIM pour gérer les utilisateurs, 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
Cette page décrit comment les administrateurs d’instance et de l’organisation utilisent l’API System for Cross-domain Identity Management (SCIM) pour automatiser la gestion des identités dans W\&B. Avec l’API SCIM, vous pouvez provisionner et déprovisionner des utilisateurs, gérer l’appartenance des utilisateurs aux équipes et définir des rôles personnalisés par programmation via un fournisseur d’identité ou un pipeline CI/CD, plutôt que de passer par la W\&B App. Les groupes SCIM correspondent aux équipes W\&B. L’API SCIM de W\&B est compatible avec des fournisseurs d’identité tels qu’Okta et Microsoft Entra. Pour la configuration du SSO avec Okta, Microsoft Entra et d’autres fournisseurs d’identité, voir la [documentation SSO](/fr/platform/hosting/iam/sso). Pour des exemples pratiques en Python montrant comment interagir avec l’API SCIM, consultez le dépôt [`wandb-scim`](https://github.com/wandb/examples/tree/master/wandb-scim).
### Fonctionnalités prises en charge
L’API SCIM prend en charge les fonctionnalités suivantes : * **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. * **Cycle de vie des comptes de service** : provisionnez et déprovisionnez les [comptes de service à portée d'équipe et à l’organisation](/fr/platform/hosting/iam/service-accounts). Pris en charge sur **Cloud mutualisé**, ainsi que sur **Cloud dédié** et **Autogéré** v0.81.0+. Si vous êtes administrateur de plusieurs organisations Enterprise [Cloud mutualisé](/fr/platform/hosting/hosting-options/multi_tenant_cloud), configurez l’organisation qui reçoit les requêtes de l’API SCIM afin que les requêtes effectué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é `[HOST-URL]` utilisé dans les exemples de cette page. 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
Chaque requête SCIM doit être authentifiée en tant que principal administrateur. 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 dans la section suivante.
### Principales différences
La liste suivante compare les identifiants utilisateur et les identifiants de compte de service pour l’authentification SCIM : * 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 [API-KEY]` avec la clé telle quelle. Basic utilise `Authorization: Basic ` (les utilisateurs encodent `username:API-KEY`, et 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 à plus d’une organisation 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.
### Bearer token
Envoyez la clé API sous forme de Bearer token : ```bash theme={null} Authorization: Bearer [API-KEY] ``` La valeur `[API-KEY]` correspond à la même chaîne que vous utiliseriez comme mot de passe dans l’authentification HTTP Basic pour 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é v0.79.0 et versions ultérieures. Les exemples suivants utilisent `[API-KEY]` comme espace réservé. Remplacez-le par une clé réelle issue 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 [API-KEY]" \ -H "Content-Type: application/scim+json" \ "[HOST-URL]/scim/Users" ``` **Créer un utilisateur** ```bash theme={null} curl -s -S -X POST \ -H "Authorization: Bearer [API-KEY]" \ -H "Content-Type: application/scim+json" \ "[HOST-URL]/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 d'informations, voir [Create user](#create-user).
### Utilisateurs
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 ```
## Configuration de Microsoft Entra ID
Utilisez cette section pour configurer le provisionnement automatique des utilisateurs et des groupes de Microsoft Entra ID vers W\&B via l’API SCIM. Pour configurer l’authentification unique avec Entra, voir [Configurer l’authentification unique avec Entra](/fr/platform/hosting/iam/sso).
### Tenant URL
Dans les paramètres de provisionnement de votre application d’entreprise Entra, définissez **Tenant URL** sur l’URL de base SCIM de W\&B, en y ajoutant le paramètre de requête d’indicateur de fonctionnalité Entra `aadOptscim062020` : ```text theme={null} [HOST-URL]/scim?aadOptscim062020 ``` Par exemple, si votre instance est à l’adresse `https://wandb.example.com`, définissez l’URL du locataire sur `https://wandb.example.com/scim?aadOptscim062020`. Le paramètre `aadOptscim062020` active une gestion spécifique à Entra dans l’API SCIM de W\&B. Sans ce paramètre, Entra peut envoyer des requêtes de désactivation d’utilisateur avec des valeurs booléennes sous forme de chaînes (`"False"` ou `"True"`) au lieu de booléens JSON (`false` ou `true`), ce qui peut entraîner l’échec de la désactivation. Définissez **Secret Token** sur la clé API d’un administrateur de l’organisation ou d’un compte de service limité à l’organisation. Voir [Authentification](#authentication). Lorsque vous ajoutez `aadOptscim062020` à l’URL du locataire, la désactivation d’utilisateur depuis l’interface utilisateur **Provision on demand** d’Entra dans le centre d’administration Microsoft Entra risque de ne pas fonctionner, car cette interface utilisateur envoie toujours des valeurs booléennes sous forme de chaînes. Pour tester la désactivation manuellement, envoyez une requête SCIM `PATCH` au format `PatchOp` `Operations` qui remplace `active` par `false` (voir [Deactivate user](#deactivate-user)).
### Noms des équipes
Nommez les groupes Entra qui correspondent à des équipes W\&B en utilisant des lettres minuscules et des traits d’union, par exemple `ml-platform` ou `data-science`. Évitez les espaces, les caractères de soulignement et les autres caractères spéciaux dans les noms d’affichage des groupes que vous synchronisez avec W\&B.
### Mappages des attributs utilisateur
Configurez les mappages d’attributs suivants dans Entra pour le provisionnement SCIM des utilisateurs : | Attribut de l’application personnalisée W\&B | Attribut source (Entra) | Appliquer ce mappage | Faire correspondre les objets avec cet attribut | | -------------------------------------------- | ----------------------- | ----------------------------------------- | ----------------------------------------------- | | `emails[type eq "work"].value` | `mail` | Toujours | Oui | | `active` | `Not([IsSoftDeleted])` | Toujours | | | `displayName` | `displayName` | Toujours | | | `userName` | `displayName` | Uniquement lors de la création de l’objet | | Dans **Cloud mutualisé**, le compte d’un utilisateur n’est pas géré par l’organisation. W\&B ne prend pas en charge la mise à jour de `displayName` via SCIM dans le Cloud mutualisé. Voir [Mettre à jour le nom d’affichage de l’utilisateur](#update-user-display-name).
### Mappages des attributs de groupe
Configurez les mappages d’attributs suivants dans Entra pour le provisionnement SCIM des groupes (équipes) : | Attribut de l’application personnalisée W\&B | Attribut source (Entra) | Appliquer ce mappage | Faire correspondre les objets à l’aide de cet attribut | | -------------------------------------------- | ----------------------- | ----------------------------------------- | ------------------------------------------------------ | | `displayName` | `displayName` | Uniquement lors de la création de l’objet | oui | | `members` | `members` | Toujours | |
## Gestion des utilisateurs
La ressource utilisateur SCIM correspond aux utilisateurs W\&B et aux comptes de service. Utilisez les points de terminaison de cette section pour provisionner, mettre à jour et supprimer les utilisateurs et les comptes de service dans votre organisation, par exemple lorsque vous intégrez de nouveaux employés, renouvelez des identifiants de service ou retirez l’accès aux utilisateurs quittant l’organisation. Pour les concepts liés aux comptes de service et aux flux de travail de l’interface utilisateur, voir [Utiliser des comptes de service pour automatiser les flux de travail](/fr/platform/hosting/iam/service-accounts). **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 spécifique ou d’un compte de service de votre organisation à partir de l’ID utilisateur, ou celles d’un utilisateur à partir de son adresse e-mail. Les réponses des comptes de service incluent `accountType` (`SERVICE` pour les comptes de service à portée d'équipe, `ORG_SERVICE` pour les comptes de service limités à l’organisation). Les comptes de service n’incluent pas `emails`. #### Endpoint * **URL**: `[HOST-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 ``` ```text 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 pas é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 utilisateurs
Récupère la liste de tous les utilisateurs et comptes de service de votre organisation. Chaque ressource comprend `accountType` (`USER`, `SERVICE` ou `ORG_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**: `[HOST-URL]/scim/Users` * **Méthode**: `GET` #### Exemple ```bash theme={null} GET /scim/Users ``` ```text 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 pas é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**: `[HOST-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`. | | `weaveRole` | string | Non | Niveau de rôle Weave. L’une des valeurs suivantes : `full`, `viewer` ou `none`. La valeur par défaut est `full`. | #### 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", "modelsSeat": "full", "weaveRole": "full", "urn:ietf:params:scim:schemas:extension:teams:2.0:User": { "teams": ["my-team"] } } ```
#### Réponse
```text 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" } ``` ```text 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", "modelsSeat": "full", "weaveRole": "full", "teamRoles": [ { "teamName": "my-team", "roleName": "member" } ], "groups": [ { "value": "my-team-id" } ] } ```
### Créer un compte de service
Crée un compte de service limité à une équipe ou à l’organisation dans votre organisation. Utilisez ce point de terminaison pour créer des identités non interactives pour l’automatisation, le CI/CD ou des intégrations qui ne doivent pas être liées à un utilisateur humain. Omettez `accountType` pour créer à la place un utilisateur standard. Voir [Create user](#create-user). Disponible dans **Cloud dédié**, **Autogéré** v0.81.0+ et **Cloud mutualisé**. * Définissez `userName` sur le nom du compte de service. L’API utilise `userName` comme nom d’affichage du compte. Le champ `displayName` dans le corps de la requête est ignoré. * `emails` n’est pas requis pour les comptes de service. * `modelsSeat` et `weaveRole` ne sont pas pris en charge à la création et renvoient `400 Bad Request` s’ils sont présents. * Les comptes de service ne peuvent pas être mis à jour avec `PATCH` ou `PUT`, ne peuvent pas être désactivés et ne peuvent pas se voir attribuer de rôles d’organisation, d’équipe ou de registre via SCIM. Créez des clés API dans la W\&B App après le provisionnement. #### Endpoint * **URL**: `[HOST-URL]/scim/Users` * **Méthode**: `POST`
#### Paramètres
| Paramètre | Type | Requis | Description | | ------------------------------------------------------- | ------ | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `userName` | string | oui | Nom unique du compte de service. | | `accountType` | string | oui | `SERVICE` pour un [compte de service à portée d'équipe](/fr/platform/hosting/iam/service-accounts/#team-scoped-service-accounts), ou `ORG_SERVICE` pour un [compte de service limité à l’organisation](/fr/platform/hosting/iam/service-accounts/#organization-scoped-service-accounts). | | `urn:ietf:params:scim:schemas:extension:teams:2.0:User` | objet | oui | Objet d’extension Teams. | | `defaultTeam` | string | oui | Sous-champ de l’extension Teams. Nom d’une équipe W\&B existante. Le compte de service est créé en tant que membre de cette équipe. Pour les comptes de service à portée d'équipe, c’est la seule équipe qu’ils rejoignent. Les comptes de service limités à l’organisation sont également ajoutés automatiquement aux équipes créées ultérieurement via SCIM. | | `teams` | array | Non | **Cloud mutualisé uniquement.** Noms des équipes auxquelles ajouter le compte. Incluez la même équipe que `defaultTeam` lorsque vous utilisez ce champ. | #### Exemple ```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" ], "userName": "sa-deploy-bot", "accountType": "SERVICE", "urn:ietf:params:scim:schemas:extension:teams:2.0:User": { "defaultTeam": "ml-platform" } } ``` ```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" ], "userName": "sa-ci-runner", "accountType": "ORG_SERVICE", "urn:ietf:params:scim:schemas:extension:teams:2.0:User": { "defaultTeam": "ml-platform" } } ```
#### Réponse
```text theme={null} (Status 201) ``` ```json theme={null} { "accountType": "SERVICE", "active": true, "displayName": "sa-deploy-bot", "id": "xyz", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "location": "Users/xyz" }, "organizationRole": "member", "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User", "urn:ietf:params:scim:schemas:extension:wandb:2.0:User" ], "teamRoles": [ { "teamName": "ml-platform", "roleName": "member" } ], "urn:ietf:params:scim:schemas:extension:wandb:2.0:User": { "organizationRole": "member" }, "userName": "sa-deploy-bot" } ``` ```text theme={null} (Status 201) ``` ```json theme={null} { "accountType": "ORG_SERVICE", "active": true, "displayName": "sa-ci-runner", "id": "xyz", "meta": { "resourceType": "User", "created": "2023-10-01T00:00:00Z", "location": "Users/xyz" }, "organizationRole": "member", "schemas": [ "urn:ietf:params:scim:schemas:core:2.0:User", "urn:ietf:params:scim:schemas:extension:wandb:2.0:User" ], "teamRoles": [ { "teamName": "ml-platform", "roleName": "member" } ], "urn:ietf:params:scim:schemas:extension:wandb:2.0:User": { "organizationRole": "member" }, "userName": "sa-ci-runner" } ``` Pour un compte de service limité à l’organisation, `accountType` est `ORG_SERVICE`. Dans les déploiements **Autogérés**, `organizationRole` vaut `service` ou `org_service` au lieu de `member`, selon le type de compte. Si la réponse renvoie l’une des erreurs suivantes, vérifiez la requête pour repérer ces problèmes courants : * `409 Conflict` : la requête inclut des clés `userName` en double pour le même compte de service. * `400 Bad Request` : la requête ne contient pas `defaultTeam` ou lui attribue une valeur non valide.
### Déprovisionner un compte de service
Supprime définitivement un compte de service ainsi que son appartenance à l’organisation. Utilisez ce point de terminaison lorsqu’un compte de service n’est plus nécessaire (par exemple, après la mise hors service d’un pipeline d’automatisation). Il s’agit d’une suppression définitive ; le compte ne peut pas être réactivé via SCIM. Disponible dans **Cloud dédié** et **Autogéré** v0.81.0+, ainsi que dans **Cloud mutualisé**. Utilisez l’`id` utilisateur SCIM du compte de service figurant dans la réponse de provisionnement ou dans [Obtenir un utilisateur](#get-user). Le déprovisionnement ne supprime pas les clés API déjà émises ; révoquez-les séparément dans la W\&B App si nécessaire. #### Endpoint * **URL**: `[HOST-URL]/scim/Users/{id}` * **Méthode**: `DELETE`
#### Paramètres
| Paramètre | Type | Requis | Description | | --------- | ------ | ------ | ------------------------------- | | `id` | string | oui | ID unique du compte de service. | #### Exemple ```bash theme={null} DELETE /scim/Users/xyz ``` ```text theme={null} (Statut 204) ```
### Supprimer un utilisateur
**Conservez l’accès administrateur** Assurez-vous 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. Pour supprimer un compte de service, voir [Déprovisionner un compte de service](#deprovision-service-account). #### Endpoint * **URL**: `[HOST-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 ``` ```text 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. #### Point de terminaison * **URL**: `[HOST-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 } ] } ] } ``` ```text 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. #### Point de terminaison * **URL**: `[HOST-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" } ] } ``` ```text 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 l’équipe W\&B. #### Point de terminaison * **URL**: `[HOST-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
```text 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" } ``` ```text 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" } ``` #### Point de terminaison * **URL**: `[HOST-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} } ] } ``` ```text 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. #### Point de terminaison * **URL**: `[HOST-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" } ] } ``` ```text 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. #### Point de terminaison * **URL**: `[HOST-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" } ] } ``` ```text 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. #### Point de terminaison * **URL**: `[HOST-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" } ] } ``` ```text 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. #### Point de terminaison * **URL**: `[HOST-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" } ] } ] } ``` ```text 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. #### Point de terminaison * **URL**: `[HOST-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" } ] } ] } ``` ```text 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. #### Point de terminaison * **URL**: `[HOST-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\"]" } ] } ``` ```text 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" } ] } ``` ```text 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
La ressource de groupe SCIM correspond à une équipe W\&B. Utilisez les points de terminaison de cette section pour créer des équipes, gérer les membres de l’équipe et, éventuellement, configurer le stockage au niveau de l’équipe depuis votre fournisseur d’identité ou votre automatisation. 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
Lorsque vous créez une équipe W\&B à 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.
### Filtrer les groupes
Le point de terminaison `/Groups` permet de filtrer les résultats pour rechercher des Teams spécifiques.
#### Filtres pris en charge
Le point de terminaison `/Groups` prend en charge le filtre suivant : * `displayName eq "value"`: Filtrer par le 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. #### Point de terminaison * **URL**: `[HOST-URL]/scim/Groups/{id}` * **Méthode**: `GET` #### Exemple ```bash theme={null} GET /scim/Groups/ghi ``` ```text 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. #### Point de terminaison * **URL**: `[HOST-URL]/scim/Groups` * **Méthode**: `GET` #### Exemple ```bash theme={null} GET /scim/Groups ``` ```text 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
Crée une nouvelle ressource d’équipe. #### Point de terminaison * **URL**: `[HOST-URL]/scim/Groups` * **Méthode**: `POST`
#### Champs pris en charge
| Champ | Type | Requis | | --------------- | ------------------- | --------------------------------------------------------- | | `displayName` | Chaîne | Oui | | `members` | Tableau multivaleur | Oui (`value` sub-field is required and maps to a user ID) | | `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 voir 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" } } ``` ```text 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
Met à jour la liste des membres d’une équipe existante. #### Point de terminaison * **URL**: `[HOST-URL]/scim/Groups/{id}` * **Méthode**: `PATCH` * **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 l’un des éléments suivants : * 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. #### Point de terminaison * **URL**: `[HOST-URL]/scim/Groups/{id}` * **Méthode**: `PUT` ```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}" } ] } ``` ```text 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}" } ] } ] } ``` ```text 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 User spécifique d’une équipe
Suppression de `dev-user2` 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[value eq \"{user_id}\"]" } ] } ``` ```text 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" } ] } ``` ```text 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
L’API SCIM ne prend pas en charge la suppression des équipes, car des données supplémentaires leur sont liées. Supprimez les équipes depuis la W\&B App 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. Utilisez les endpoints de cette section pour créer et gérer des rôles personnalisés par programmation (par exemple, pour maintenir les définitions de rôles synchronisées avec vos politiques d'accès). 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. #### point de terminaison * **URL** : `[HOST-URL]/scim/Roles/{id}` * **Méthode** : `GET` #### Exemple ```bash theme={null} GET /scim/Roles/abc ``` ```text 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. #### point de terminaison * **URL**: `[HOST-URL]/scim/Roles` * **Méthode**: `GET` #### Exemple ```bash theme={null} GET /scim/Roles ``` ```text 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é
Crée un nouveau rôle personnalisé dans l’organisation W\&B. #### point de terminaison * **URL**: `[HOST-URL]/scim/Roles` * **Méthode**: `POST`
#### 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" } ``` ```text 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é
Les sections suivantes décrivent comment ajouter ou supprimer des autorisations dans un rôle personnalisé existant.
#### Ajouter des autorisations à un rôle
Ajouter des autorisations à un rôle personnalisé existant.
##### Point de terminaison
* **URL**: `[HOST-URL]/scim/Roles/{id}` * **Méthode**: `PATCH` ```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" } ] } ] } ``` ```text theme={null} (statut 200) ``` Renvoie le rôle mis à jour, avec les nouvelles autorisations ajoutées.
#### Supprimer une autorisation d’un rôle
Supprime des autorisations d’un rôle personnalisé existant.
##### Point de terminaison
* **URL**: `[HOST-URL]/scim/Roles/{id}` * **Méthode**: `PATCH` ```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" } ] } ] } ``` ```text theme={null} (statut 200) ``` Renvoie le rôle mis à jour, avec les autorisations spécifiées supprimées.
### Remplacer le rôle personnalisé
Remplace intégralement la définition d’un rôle personnalisé. #### Point de terminaison * **URL**: `[HOST-URL]/scim/Roles/{id}` * **Méthode**: `PUT` ```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" } ``` ```text theme={null} (statut 200) ``` Renvoie la définition du rôle après son remplacement.
### Supprimer un rôle personnalisé
Supprimez un rôle personnalisé dans l’organisation W\&B. **Utilisez cette opération avec prudence**. Le rôle prédéfini dont héritait le rôle personnalisé est réattribué à tous les utilisateurs auxquels ce rôle personnalisé était attribué avant la suppression. #### point de terminaison * **URL**: `[HOST-URL]/scim/Roles/{id}` * **Méthode**: `DELETE` #### Exemple ```bash theme={null} DELETE /scim/Roles/abc ``` ```text theme={null} (Statut 204 No Content) ```
## Fonctionnalités avancées
Les sections suivantes décrivent des fonctionnalités facultatives (contrôle de la concurrence basé sur les ETag et réponses d’erreur standard) qui permettent aux intégrations SCIM de fonctionner de manière sûre en production.
### 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. Cela est important lorsque plusieurs administrateurs ou systèmes automatisés mettent à jour la même ressource, car cela garantit qu’une mise à jour n’en écrase pas une autre sans avertissement. 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, suivez ces étapes : 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 ```text theme={null} # 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 : consultez le tableau suivant avant d’intégrer SCIM afin de vérifier que les opérations sur lesquelles vous vous appuyez sont disponibles pour votre type de déploiement. | 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
Gardez à l’esprit les contraintes suivantes lorsque vous concevez des intégrations SCIM : * **Nombre maximal de résultats** : 9 999 éléments par requête. * **Cloud dédié et Autogéré** : ne prennent en charge qu’une seule adresse e-mail par utilisateur. * **Suppression d’équipe** : 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.