# Configurar el aprovisionamiento SCIM





## Atributos admitidos

SCIM utiliza atributos (nombre, correo electrónico, etc.) para sincronizar la información del usuario entre tu proveedor de identidad y Docker. Mapear correctamente estos atributos en tu proveedor de identidad garantiza que el aprovisionamiento de usuarios funcione sin problemas y evita problemas como cuentas de usuario duplicadas al usar el inicio de sesión único.

Docker admite los siguientes atributos SCIM:

| Atributo          | Descripción                                                                                                     |
| :---------------- | :-------------------------------------------------------------------------------------------------------------- |
| `userName`        | Dirección de correo electrónico principal del usuario, utilizada como identificador único                       |
| `name.givenName`  | Nombre de pila del usuario                                                                                      |
| `name.familyName` | Apellido del usuario                                                                                            |
| `active`          | Indica si un usuario está habilitado o deshabilitado; se establece en "false" para desaprovisionar a un usuario |

Para obtener detalles adicionales sobre los atributos admitidos y SCIM, consulta la [referencia de la API SCIM de Docker Hub](/reference/api/hub/latest/#tag/scim).

> [!IMPORTANT]
>
> Por defecto, Docker utiliza el aprovisionamiento Just-in-Time (JIT) para SSO. Si SCIM está habilitado, los valores de JIT aún tienen prioridad y sobrescribirán los valores de atributos establecidos por SCIM. Para evitar conflictos, asegúrate de que los valores de tus atributos JIT coincidan con los de SCIM.
>
> Como alternativa, puedes deshabilitar el aprovisionamiento JIT para depender únicamente de SCIM. Para obtener detalles, consulta [Just-in-Time](/enterprise/security/provisioning/just-in-time/).

## Habilitar SCIM en Docker

Para habilitar SCIM:

1. Inicia sesión en [Docker Home](https://app.docker.com).
2. Selecciona **Admin Console** (Consola de administración), luego **SSO and SCIM**.
3. En la tabla **SSO connections** (Conexiones SSO), selecciona el icono de acciones (**Actions**) para tu conexión, y luego selecciona **Setup SCIM** (Configurar SCIM).
4. Copia la **SCIM Base URL** (URL base de SCIM) y el **API Token** (Token de API) y pega estos valores en tu IdP.

## Habilitar SCIM en tu IdP

La interfaz de usuario de tu proveedor de identidad puede diferir ligeramente de los pasos que se muestran a continuación. Puedes consultar la documentación de tu proveedor de identidad para verificar los pasos. Para más detalles, consulta la documentación correspondiente:

- [Okta](https://help.okta.com/en-us/Content/Topics/Apps/Apps_App_Integration_Wizard_SCIM.htm)
- [Entra ID/Azure AD SAML 2.0](https://learn.microsoft.com/en-us/azure/active-directory/app-provisioning/user-provisioning)

> [!NOTE]
>
> Microsoft no admite actualmente SCIM y OIDC en la misma aplicación que no pertenece a la galería en Entra ID. Esta página proporciona una solución alternativa verificada utilizando una aplicación independiente que no pertenece a la galería para el aprovisionamiento SCIM. Aunque Microsoft no documenta oficialmente esta configuración, es ampliamente utilizada y compatible en la práctica.

**Okta**



### Paso uno: Habilitar SCIM

1. Inicia sesión en Okta y selecciona **Admin** para abrir el portal de administración.
2. Abre la aplicación que creaste al configurar tu conexión SSO.
3. En la página de la aplicación, selecciona la pestaña **General** y luego **Edit App Settings** (Editar ajustes de la aplicación).
4. Habilita el aprovisionamiento SCIM y luego selecciona **Save** (Guardar).
5. Navega a **Provisioning** (Aprovisionamiento) y luego selecciona **Edit SCIM Connection** (Editar conexión SCIM).
6. Para configurar SCIM en Okta, establece tu conexión utilizando los siguientes valores y ajustes:
   - SCIM Base URL: URL base del conector SCIM (copiada de Docker Home).
   - Unique identifier field for users (Campo identificador único para usuarios): `email`.
   - Supported provisioning actions (Acciones de aprovisionamiento admitidas): **Push New Users** (Enviar nuevos usuarios) y **Push Profile Updates** (Enviar actualizaciones de perfil).
   - Authentication Mode (Modo de autenticación): HTTP Header.
   - SCIM Bearer Token: Token de portador de autorización de cabecera HTTP (copiado de Docker Home).
7. Selecciona **Test Connector Configuration** (Probar configuración del conector).
8. Revisa los resultados de la prueba y selecciona **Save** (Guardar).

### Paso dos: Habilitar la sincronización

1. En Okta, selecciona **Provisioning** (Aprovisionamiento).
2. Selecciona **To App** (A la aplicación) y luego **Edit** (Editar).
3. Habilita **Create Users** (Crear usuarios), **Update User Attributes** (Actualizar atributos de usuario) y **Deactivate Users** (Desactivar usuarios).
4. Selecciona **Save** (Guardar).
5. Elimina los mapeos innecesarios. Los mapeos necesarios son:
   - Username (Nombre de usuario)
   - Given name (Nombre de pila)
   - Family name (Apellido)
   - Email

A continuación, [configura el mapeo de roles](#configurar-el-mapeo-de-roles).

**Entra ID (OIDC)**



Microsoft no admite SCIM y OIDC en la misma aplicación que no pertenece a la galería. Debes crear una segunda aplicación que no pertenezca a la galería en Entra ID para el aprovisionamiento SCIM.

### Paso uno: Crear una aplicación SCIM independiente

1. En el portal de Azure, ve a **Microsoft Entra ID** > **Enterprise Applications** (Aplicaciones empresariales) > **New application** (Nueva aplicación).
2. Selecciona **Create your own application** (Crear tu propia aplicación).
3. Nombra tu aplicación y elige **Integrate any other application you don't find in the gallery** (Integrar cualquier otra aplicación que no encuentres en la galería).
4. Selecciona **Create** (Crear).

### Paso dos: Configurar el aprovisionamiento SCIM

1. En tu nueva aplicación SCIM, ve a **Provisioning** (Aprovisionamiento) > **Get started** (Comenzar).
2. Establece el **Provisioning Mode** (Modo de aprovisionamiento) en **Automatic** (Automático).
3. En **Admin Credentials** (Credenciales de administrador):
   - **Tenant URL**: Pega la **SCIM Base URL** de Docker Home.
   - **Secret Token**: Pega el **SCIM API token** de Docker Home.
4. Selecciona **Test Connection** (Probar conexión) para verificar.
5. Selecciona **Save** (Guardar) para almacenar las credenciales.

A continuación, [configura el mapeo de roles](#configurar-el-mapeo-de-roles).

**Entra ID (SAML 2.0)**



1. En el portal de Azure, ve a **Microsoft Entra ID** > **Enterprise Applications** (Aplicaciones empresariales) y selecciona tu aplicación SAML de Docker.
2. Selecciona **Provisioning** (Aprovisionamiento) > **Get started** (Comenzar).
3. Establece el **Provisioning Mode** (Modo de aprovisionamiento) en **Automatic** (Automático).
4. En **Admin Credentials** (Credenciales de administrador):
   - **Tenant URL**: Pega la **SCIM Base URL** de Docker Home.
   - **Secret Token**: Pega el **SCIM API token** de Docker Home.
5. Selecciona **Test Connection** (Probar conexión) para verificar.
6. Selecciona **Save** (Guardar) para almacenar las credenciales.

A continuación, [configura el mapeo de roles](#configurar-el-mapeo-de-roles).



## Configurar el mapeo de roles

Puedes asignar [roles de Docker](/enterprise/security/roles-and-permissions/) a los usuarios añadiendo atributos opcionales de SCIM en tu IdP. Estos atributos sobrescriben los valores de rol y equipo predeterminados establecidos en tu configuración de SSO.

> [!NOTE]
>
> Los mapeos de roles son compatibles tanto con SCIM como con el aprovisionamiento Just-in-Time (JIT). Para JIT, el mapeo de roles se aplica solo cuando el usuario se aprovisiona por primera vez.

La siguiente tabla muestra los atributos opcionales admitidos a nivel de usuario:

| Atributo     | Valores posibles                           | Notas                                                                                                                                                                                                                                                                                                   |
| ------------ | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `dockerRole` | `member`, `editor` u `owner`               | Si no se establece, el usuario toma por defecto el rol `member`. Establecer este atributo sobrescribe el valor predeterminado.<br><br>Para las definiciones de roles, consulta [Roles y permisos](/enterprise/security/roles-and-permissions/).                                        |
| `dockerOrg`  | `organizationName` de Docker (ej., `moby`) | Sobrescribe la organización predeterminada configurada en tu conexión SSO.<br><br>Si no se establece, el usuario se aprovisiona en la organización predeterminada. Si se configuran tanto `dockerOrg` como `dockerTeam`, el usuario se aprovisiona en el equipo dentro de la organización especificada. |
| `dockerTeam` | `teamName` de Docker (ej., `developers`)   | Aprovisiona al usuario en el equipo especificado en la organización predeterminada o especificada. Si el equipo no existe, se crea automáticamente.<br><br>Aún puedes usar el [mapeo de grupos](/enterprise/security/provisioning/scim/provision-scim/group-mapping/) para asignar usuarios a varios equipos en distintas organizaciones.                   |

El espacio de nombres externo utilizado para estos atributos es: `urn:ietf:params:scim:schemas:extension:docker:2.0:User`.
Este valor es obligatorio en tu proveedor de identidad al crear atributos SCIM personalizados para Docker.

**Okta**



### Paso uno: Configurar el mapeo de roles en Okta

1. Configura [SSO](/enterprise/security/single-sign-on/connect/) y SCIM primero.
2. In el portal de administración de Okta, ve a **Directory** (Directorio), selecciona **Profile Editor** (Editor de perfiles) y luego **User (Default)** (Usuario por defecto).
3. Selecciona **Add Attribute** (Añadir atributo) y configura los valores para el rol, la organización o el equipo que deseas añadir. No es obligatorio que los nombres sean exactos.
4. Regresa al **Profile Editor** y selecciona tu aplicación.
5. Selecciona **Add Attribute** (Añadir atributo) e introduce los valores requeridos. El **External Name** (Nombre externo) y el **External Namespace** (Espacio de nombres externo) deben ser exactos.
   - Los valores de nombre externo para el mapeo de organización/equipo/rol son `dockerOrg`, `dockerTeam` y `dockerRole` respectivamente, como se muestra en la tabla anterior.
   - El espacio de nombres externo es el mismo para todos ellos: `urn:ietf:params:scim:schemas:extension:docker:2.0:User`.
6. Después de crear los atributos, ve a la parte superior de la página y selecciona **Mappings** (Mapeos), luego **Okta User to YOUR APP** (Usuario de Okta a TU APLICACIÓN).
7. Ve a los atributos recién creados y mapea los nombres de las variables a los nombres externos, luego selecciona **Save Mappings** (Guardar mapeos). Si estás utilizando el aprovisionamiento JIT, continúa con los pasos siguientes.
8. Navega a **Applications** (Aplicaciones) y selecciona **YOUR APP** (TU APLICACIÓN).
9. Selecciona **General**, luego **SAML Settings** (Ajustes de SAML) y **Edit** (Editar).
10. Selecciona **Step 2** (Paso 2) y configura el mapeo desde el atributo de usuario a las variables de Docker.

### Paso dos: Asignar roles por usuario

1. En el portal de administración de Okta, selecciona **Directory** (Directorio) y luego **People** (Personas).
2. Selecciona **Profile** (Perfil) y luego **Edit** (Editar).
3. Selecciona **Attributes** (Atributos) y actualización de atributos a los valores deseados.

### Paso tres: Asignar roles por grupo

1. En el portal de administración de Okta, selecciona **Directory** (Directorio) y luego **People** (Personas).
2. Selecciona **YOUR GROUP** (TU GRUPO) y luego **Applications** (Aplicaciones).
3. Abre **YOUR APPLICATION** (TU APLICACIÓN) y selecciona el icono **Edit** (Editar).
4. Actualiza los atributos con los valores deseados.

Si un usuario no tiene atributos configurados previamente, los usuarios que se añadan al grupo heredarán estos atributos al ser aprovisionados.

**Entra ID/Azure AD (SAML 2.0 y OIDC)**



### Paso uno: Configurar los mapeos de atributos

1. Completa la [configuración del aprovisionamiento SCIM](/enterprise/security/provisioning/scim/provision-scim/#enable-scim-in-docker).
2. En el portal de Azure, abre **Microsoft Entra ID** > **Enterprise Applications** (Aplicaciones empresariales) y selecciona tu aplicación SCIM.
3. Ve a **Provisioning** (Aprovisionamiento) > **Mappings** (Mapeos) > **Provision Azure Active Directory Users** (Aprovisionar usuarios de Azure Active Directory).
4. Añade o actualiza los siguientes mapeos:
   - `userPrincipalName` -> `userName`
   - `mail` -> `emails.value`
   - Opcional. Mapea `dockerRole`, `dockerOrg` o `dockerTeam` utilizando uno de los [métodos de mapeo](/enterprise/security/provisioning/scim/provision-scim/#configurar-el-mapeo-de-roles).
5. Elimina cualquier atributo no admitido para evitar errores de sincronización.
6. Opcional. Ve a **Mappings** (Mapeos) > **Provision Azure Active Directory Groups** (Aprovisionar grupos de Azure Active Directory):
   - Si el aprovisionamiento de grupos causa errores, establece **Enabled** (Habilitado) en **No**.
   - Si lo habilitas, prueba los mapeos de grupos con cuidado.
7. Selecciona **Save** (Guardar) para aplicar los mapeos.

### Paso dos: Elegir un método de mapeo de roles

Puedes mapear `dockerRole`, `dockerOrg` o `dockerTeam` utilizando uno de los siguientes métodos:

#### Mapeo por expresiones

Utiliza este método si solo necesitas asignar roles de Docker como `member`, `editor` u `owner`.

1. En la vista **Edit Attribute** (Editar atributo), establece el tipo de mapeo en **Expression** (Expresión).
2. En el campo **Expression** (Expresión):
   1. Si tus App Roles (roles de aplicación) coinciden exactamente con los roles de Docker, usa: `SingleAppRoleAssignment([appRoleAssignments])`.
   2. Si no coinciden, usa una expresión de tipo switch: `Switch(SingleAppRoleAssignment([appRoleAssignments]), "My Corp Admins", "owner", "My Corp Editors", "editor", "My Corp Users", "member")`.
3. Establece:
   - **Target attribute** (Atributo de destino): `urn:ietf:params:scim:schemas:extension:docker:2.0:User:dockerRole`
   - **Match objects using this attribute** (Hacer coincidir objetos usando este atributo): No
   - **Apply this mapping** (Aplicar este mapeo): Always (Siempre)
4. Guarda tus cambios.

> [!WARNING]
>
> No puedes utilizar `dockerOrg` o `dockerTeam` con este método. El mapeo por expresiones solo es compatible con un atributo.

#### Mapeo directo

Utiliza este método si necesitas mapear varios atributos (`dockerRole` + `dockerTeam`).

1. Para cada atributo de Docker, elige un atributo de extensión de Entra único (`extensionAttribute1`, `extensionAttribute2`, etc.).
2. En la vista **Edit Attribute** (Editar atributo):
   - Establece el tipo de mapeo en **Direct** (Directo).
   - Establece el **Source attribute** (Atributo de origen) en el atributo de extensión que seleccionaste.
   - Establece el **Target attribute** (Atributo de destino) en uno de los siguientes:
     - `dockerRole: urn:ietf:params:scim:schemas:extension:docker:2.0:User:dockerRole`
     - `dockerOrg: urn:ietf:params:scim:schemas:extension:docker:2.0:User:dockerOrg`
     - `dockerTeam: urn:ietf:params:scim:schemas:extension:docker:2.0:User:dockerTeam`
   - Establece **Apply this mapping** (Aplicar este mapeo) en **Always** (Siempre).
3. Guarda tus cambios.

Para asignar valores, necesitarás utilizar la API de Microsoft Graph.

### Paso tres: Asignar usuarios y grupos

Para cualquier método de mapeo:

1. In the SCIM app, go to **Users and Groups** (Usuarios y grupos) > **Add user/group** (Añadir usuario/grupo).
2. Selecciona los usuarios o grupos que deseas aprovisionar en Docker.
3. Selecciona **Assign** (Asignar).

Si utilizas mapeo por expresiones:

1. Ve a **App registrations** (Registros de aplicaciones) > tu aplicación SCIM > **App Roles** (Roles de aplicación).
2. Crea los App Roles que coincidan con los roles de Docker.
3. Asigna usuarios o grupos a los App Roles bajo **Users and Groups** (Usuarios y grupos).

Si utilizas mapeo directo:

1. Ve al [Explorador de Microsoft Graph](https://developer.microsoft.com/en-us/graph/graph-explorer) e inicia sesión como administrador del tenant.
2. Utiliza la API de Microsoft Graph para asignar los valores de los atributos. Ejemplo de solicitud PATCH:

```bash
PATCH https://graph.microsoft.com/v1.0/users/{user-id}
Content-Type: application/json

{
  "extensionAttribute1": "owner",
  "extensionAttribute2": "moby",
  "extensionAttribute3": "developers"
}
```

> [!NOTE]
>
> Debes utilizar un atributo de extensión diferente para cada campo de SCIM.



Consulta la documentación de tu IdP para obtener detalles adicionales:

- [Okta](https://help.okta.com/en-us/Content/Topics/users-groups-profiles/usgp-add-custom-user-attributes.htm)
- [Entra ID/Azure AD](https://learn.microsoft.com/en-us/azure/active-directory/app-provisioning/customize-application-attributes#provisioning-a-custom-extension-attribute-to-a-scim-compliant-application)

## Probar el aprovisionamiento SCIM

Después de completar el mapeo de roles, puedes probar la configuración de forma manual.

**Okta**



1. En el portal de administración de Okta, ve a **Directory > People** (Directorio > Personas).
2. Selecciona un usuario que hayas asignado a tu aplicación SCIM.
3. Selecciona **Provision User** (Aprovisionar usuario).
4. Espera unos segundos y luego verifica la [Admin Console](https://app.docker.com/admin) de Docker bajo **Members** (Miembros).
5. Si el usuario no aparece, revisa los registros en **Reports > System Log** (Informes > Registro del sistema) y confirma los ajustes de SCIM en la aplicación.

**Entra ID/Azure AD (OIDC y SAML 2.0)**



1. En el portal de Azure, ve a **Microsoft Entra ID** > **Enterprise Applications** (Aplicaciones empresariales) y selecciona tu aplicación SCIM.
2. Ve a **Provisioning** (Aprovisionamiento) > **Provision on demand** (Aprovisionar bajo demanda).
3. Selecciona un usuario o grupo y elige **Provision** (Aprovisionar).
4. Confirma que el usuario aparece en la [Admin Console](https://app.docker.com/admin) de Docker bajo **Members** (Miembros).
5. Si es necesario, comprueba los registros de aprovisionamiento (**Provisioning logs**) para ver si hay errores.



## Deshabilitar SCIM

Si SCIM está deshabilitado, cualquier usuario aprovisionado mediante SCIM permanecerá en la organización. Los cambios futuros de tus usuarios no se sincronizarán desde tu IdP. El desaprovisionamiento de usuarios solo será posible eliminándolos manualmente de la organización.

Para deshabilitar SCIM:

1. Inicia sesión en [Docker Home](https://app.docker.com).
2. Selecciona **Admin Console** (Consola de administración) y luego **SSO and SCIM**.
3. En la tabla **SSO connections** (Conexiones SSO), selecciona el icono de acciones.
4. Selecciona **Disable SCIM** (Deshabilitar SCIM).

## Siguientes pasos

- Configura el [mapeo de grupos](/enterprise/security/provisioning/scim/group-mapping/).
- [Resolución de problemas de aprovisionamiento](/enterprise/security/provisioning/troubleshoot-provisioning/).