> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Guida alla configurazione di SSO

> Guida completa alla configurazione di SSO, alle considerazioni su SCIM e alla configurazione dei gruppi IdP con Devin Enterprise.

Questa guida accompagna gli amministratori Enterprise lungo l'intero ciclo di vita di SSO con Devin — dalla configurazione iniziale alla configurazione dei gruppi IdP — e spiega come Devin gestisce il provisioning degli utenti senza SCIM.

Per istruzioni di configurazione specifiche per il provider, consulta [Okta](/it/enterprise/security-access/sso/okta), [Microsoft Entra ID](/it/enterprise/security-access/sso/azure), [SAML](/it/enterprise/security-access/sso/saml) o [OIDC generico](/it/enterprise/security-access/sso/oidc).

***

<div id="1-setting-up-sso">
  ## 1. Configurazione del Single Sign-On (SSO)
</div>

<div id="creating-your-sso-application">
  ### Creazione dell'applicazione SSO
</div>

Crea un'applicazione nel tuo provider di identità (Okta, Microsoft Entra ID o qualsiasi IdP compatibile con SAML/OIDC) e condividi le seguenti credenziali con il team di Cognition:

| Tipo di connessione    | Protocollo                     | Dati da fornire                                         |
| :--------------------- | :----------------------------- | :------------------------------------------------------ |
| **Okta**               | OIDC (Okta Workforce Identity) | Dominio Okta, ID client, Client Secret, ambiti          |
| **Microsoft Entra ID** | OIDC (Microsoft Entra ID)      | Dominio Microsoft Entra ID, ID client, Client Secret    |
| **SAML**               | SAML 2.0 (qualsiasi IdP)       | URL di accesso, certificato di firma X.509              |
| **OIDC generico**      | OIDC                           | URL di individuazione, ID client, Client Secret, ambiti |

<Note>
  Dovresti anche fornire i tuoi domini email verificati, in modo che Devin sappia quali indirizzi email considerare attendibili se provenienti dal tuo IdP.
</Note>

<div id="what-happens-after-setup">
  ### Cosa succede dopo la configurazione
</div>

Una volta che il tuo team di Cognition ha le credenziali, configura la connessione SSO. Al termine della configurazione:

1. La connessione SSO viene collegata al tuo account Enterprise di Devin
2. **Aggiunta automatica dei membri all'accesso** è abilitata: qualsiasi utente che si autentica tramite SSO viene aggiunto automaticamente al tuo account Enterprise
3. I tuoi domini email vengono registrati come attendibili: sono accettati solo gli indirizzi email provenienti da tali domini
4. **Assegnazione dei ruoli basata sui gruppi (RBAC)** è abilitata: i gruppi IdP inviati durante l'accesso possono essere mappati ai ruoli di Devin
5. Gli accessi social predefiniti (Google, GitHub) sono disabilitati: SSO diventa il metodo di autenticazione obbligatorio

<div id="the-user-login-experience">
  ### L'esperienza di accesso dell'utente
</div>

1. L'utente apre il tuo URL di Devin
2. Viene reindirizzato all'IdP configurato (Okta, Microsoft Entra ID, ecc.)
3. L'utente si autentica normalmente
4. L'IdP invia a Devin le informazioni dell'utente e le relative appartenenze ai gruppi
5. Devin automaticamente:
   * Crea l'account dell'utente al primo accesso (provisioning just-in-time)
   * Assegna il ruolo predefinito Enterprise Member
   * Sincronizza le appartenenze ai gruppi dell'IdP: aggiunge i nuovi gruppi e rimuove quelli non più validi
   * Registra l'accesso nel log di audit dell'Enterprise

***

<div id="self-service-administration">
  ## Amministrazione self-service
</div>

Le seguenti funzionalità sono disponibili direttamente nella webapp di Devin per gli amministratori Enterprise.

<div id="idp-group-management">
  ### Gestione dei gruppi IdP
</div>

**Settings → Enterprise → Gruppi del provider di identità**

* Visualizza tutti i gruppi sincronizzati tramite gli accessi degli utenti
* Assegna un gruppo a un ruolo a livello Enterprise (ad es. "Tutti gli utenti in `Engineering-Admins` ricevono il ruolo Enterprise Admin")
* Assegna un gruppo a org specifiche con ruoli specifici (ad es. "`Team-Backend` ottiene l'accesso Member nell'org Backend")
* Aggiungi o rimuovi in blocco gruppi in più org
* Visualizza a quante org è assegnato ciascun gruppo

<div id="member-management">
  ### Gestione dei membri
</div>

**Settings → Enterprise → Membri**

* Visualizza tutti i membri dell'Enterprise, inclusi i gruppi IdP a cui appartengono
* Invita nuovi membri via email
* Aggiorna i ruoli dei membri
* Rimuovi i membri

<div id="custom-roles">
  ### Ruoli personalizzati
</div>

**Settings → Enterprise → Ruoli**

* Crea ruoli personalizzati con autorizzazioni granulari
* Assegna ruoli personalizzati a singoli utenti o a gruppi IdP

Per maggiori dettagli, consulta [Ruoli personalizzati e RBAC](/it/enterprise/security-access/custom-roles).

<div id="api-for-automation">
  ### API per l'automazione
</div>

Devin offre un'API V2 che puoi usare per automatizzare la gestione dei membri:

| Azione                                      | Endpoint API                                 |
| :------------------------------------------ | :------------------------------------------- |
| Elencare tutti i membri                     | `GET /v2/enterprise/members`                 |
| Invitare utenti via email (in blocco)       | `POST /v2/enterprise/members/invite`         |
| Rimuovere un membro                         | `DELETE /v2/enterprise/members/{user_id}`    |
| Aggiornare in blocco i ruoli dei membri     | `PATCH /v2/enterprise/members/roles`         |
| Migrare i membri tra ruoli                  | `PATCH /v2/enterprise/members/migrate-roles` |
| Elencare tutti i ruoli                      | `GET /v2/enterprise/roles`                   |
| Elencare tutti i gruppi IdP                 | `GET /v2/enterprise/groups`                  |
| Creare in anticipo i gruppi IdP             | `PUT /v2/enterprise/groups`                  |
| Recuperare le assegnazioni org di un gruppo | `GET /v2/enterprise/groups/{group_name}`     |

***

<div id="2-understanding-devin-without-scim">
  ## 2. Come funziona Devin senza SCIM
</div>

Devin al momento non supporta il protocollo SCIM. La gestione di utenti e gruppi avviene interamente tramite gli eventi di accesso SSO e l'interfaccia utente/API di Devin. Ecco cosa significa in pratica.

<div id="user-provisioning-login-triggered-only">
  ### Provisioning degli utenti: solo al momento del login
</div>

|                                    | Con SCIM                                                                         | Devin (senza SCIM)                                                                                               |
| :--------------------------------- | :------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------- |
| **Come vengono creati gli utenti** | L'IdP crea immediatamente l'utente nell'app quando gli viene assegnata           | L'utente esiste in Devin solo dopo il primo accesso tramite SSO, oppure dopo un invito manuale tramite UI o API  |
| **Quando avviene**                 | L'amministratore assegna l'app all'utente → l'utente compare entro pochi secondi | L'amministratore assegna l'app all'utente → in Devin non succede nulla finché l'utente non accede                |
| **Pre-provisioning**               | L'account utente è pronto prima ancora che l'utente visiti l'app                 | Nessun pre-provisioning, a meno che l'amministratore non lo inviti esplicitamente tramite la UI o l'API di Devin |

Quando si inseriscono nuovi dipendenti, l'amministratore può invitarli in anticipo (**Settings → Enterprise → Membri → Invita**, oppure tramite l'API) oppure lasciare semplicemente che vengano provisionati automaticamente al primo accesso.

<div id="user-deprovisioning-manual-only">
  ### Deprovisioning degli utenti: solo manuale
</div>

|                                     | Con SCIM                                                                      | Devin (senza SCIM)                                                                                                                |
| :---------------------------------- | :---------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------- |
| **Come vengono rimossi gli utenti** | L'IdP disattiva/rimuove l'utente → l'app lo disabilita immediatamente         | La disattivazione/rimozione di un utente nell'IdP non ha alcun effetto in Devin                                                   |
| **Offboarding**                     | Il dipendente in fase di offboarding perde l'accesso nel giro di pochi minuti | Il dipendente in fase di offboarding mantiene l'accesso finché non viene rimosso manualmente da Devin e la sua sessione non scade |
| **Conformità**                      | Conformità automatizzata — nessun account orfano                              | Rischio di account orfani, a meno che l'amministratore non mantenga entrambi i sistemi                                            |

<Warning>
  Questa è la principale lacuna operativa. Quando un dipendente viene messo in offboarding, l'amministratore deve rimuoverlo separatamente da Devin (**Settings → Enterprise → Membri → Rimuovi**, oppure tramite l'API). Le sessioni attive continuano a funzionare fino alla naturale scadenza: non esiste alcuna revoca immediata della sessione attivata dall'IdP.
</Warning>

<div id="group-sync-login-time-only-not-real-time">
  ### Sincronizzazione dei gruppi: solo al login, non in tempo reale
</div>

|                                    | Con SCIM (Group Push)                                                   | Devin (senza SCIM)                                                                                                  |
| :--------------------------------- | :---------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------ |
| **Tempistica di sincronizzazione** | L'IdP invia in tempo reale le modifiche all'appartenenza ai gruppi      | I gruppi si sincronizzano solo quando l'utente effettua il login                                                    |
| **Aggiunta a un gruppo**           | L'Admin aggiunge l'utente al gruppo → l'app lo recepisce immediatamente | L'Admin aggiunge l'utente al gruppo → Devin non lo rileva fino al login successivo dell'utente                      |
| **Rimozione da un gruppo**         | L'Admin rimuove l'utente dal gruppo → l'app lo recepisce immediatamente | L'Admin rimuove l'utente dal gruppo → Devin continua a mostrare la precedente appartenenza fino al login successivo |
| **Fonte autorevole**               | L'IdP è sempre la fonte autorevole                                      | L'IdP è la fonte autorevole solo al login — tra un login e l'altro possono esserci discrepanze                      |

Se un admin modifica l'IDP group di una persona (ad es. spostandola da Engineering a Sales), Devin non rifletterà questa modifica finché l'utente non effettua di nuovo il login. Nel frattempo, l'utente mantiene i vecchi ruoli basati sul gruppo e l'accesso all'org.

<div id="built-in-alternatives-to-scim">
  ### Alternative integrate a SCIM
</div>

Devin include diverse funzionalità che coprono i casi d'uso SCIM più comuni:

1. **Provisioning just-in-time** — gli utenti vengono creati automaticamente al primo accesso SSO con il ruolo Enterprise predefinito
2. **Sincronizzazione completa dei gruppi a ogni accesso** — ogni volta che un utente accede, Devin esegue un diff completo dei suoi gruppi IdP: aggiunge quelli nuovi e rimuove quelli vecchi
3. **RBAC basato sui gruppi** — puoi mappare i gruppi IdP ai ruoli Enterprise e all'accesso all'org nelle Settings di Devin; le modifiche hanno effetto al successivo accesso
4. **API V2 per l'automazione** — inviti, rimozioni e modifiche di ruolo in blocco possono essere automatizzati tramite script per colmare il divario nel provisioning/deprovisioning
5. **Log di audit** — ogni accesso viene registrato, offrendo visibilità su chi ha avuto accesso a Devin

***

<div id="3-configuring-idp-managed-groups">
  ## 3. Configurazione dei gruppi gestiti dall'IdP
</div>

Se usi SCIM con altre applicazioni (ad es. Slack, Box), questa sezione spiega come funziona il modello dei gruppi in Devin e come configurare correttamente il tuo IdP.

<div id="context-scim-groups-vs-idp-groups">
  ### Contesto: gruppi SCIM vs gruppi IdP
</div>

* **Gruppi SCIM:** L'app downstream comunica all'IdP quali gruppi esistono (l'IdP li "importa"). L'app è la fonte autorevole per la struttura dei gruppi. L'IdP sincronizza gli utenti in quei gruppi definiti dall'app.
* **Gruppi IdP (quelli usati da Devin):** L'IdP è la fonte autorevole. I gruppi sono definiti nella directory dell'IdP e le appartenenze ai gruppi vengono passate a Devin tramite claim SAML/OIDC al momento dell'accesso.

Poiché Devin non usa SCIM, stai già operando in modalità "gruppi IdP". L'aspetto fondamentale è assicurarsi che dal tuo IdP vengano inviati i gruppi corretti e che siano mappati correttamente in Devin.

<div id="step-1-define-groups-in-the-idp">
  ### Passaggio 1: Definire i gruppi nell'IdP
</div>

Nella console di amministrazione del tuo IdP (negli esempi seguenti viene usato Okta):

1. Vai a **Directory → Groups**
2. Crea gruppi che corrispondano ai livelli di accesso di Devin (ad es. `Devin-Engineering`, `Devin-Admins`, `Devin-DataScience`)
3. Assegna gli utenti a questi gruppi

Questi gruppi sono nativi dell'IdP: il tuo IdP è la fonte autorevole per stabilire chi appartiene a quale gruppo.

<div id="step-2-configure-group-claims-in-the-idp-app">
  ### Passaggio 2: configura i claim dei gruppi nell'app IdP
</div>

I gruppi devono essere inclusi nella risposta di autenticazione affinché Devin possa leggerli.

<div id="for-saml-connections">
  #### Per le connessioni SAML
</div>

1. Vai a **Applications → \[Devin App] → SAML Settings → Edit**
2. In **Group Attribute Statements**, aggiungi:
   * **Name:** `groups`
   * **Filter:** "Starts with" → `Devin-` (oppure usa "Matches regex" per pattern più complessi)
3. In questo modo, l'IdP includerà nell'asserzione SAML i nomi dei gruppi corrispondenti

<div id="for-oidc-connections">
  #### Per le connessioni OIDC
</div>

1. Vai a **Applications → \[Devin App] → Sign On → Edit**
2. In **OpenID Connect ID Token → Groups claim type**, seleziona "Filter"
3. Imposta il filtro in modo che corrisponda ai gruppi Devin (ad es. "Starts with" → `Devin-`)

<Tip>
  Usa un prefisso di filtro come `Devin-` in modo che vengano inviati solo i gruppi pertinenti. Non è necessario inviare tutti i gruppi IdP dell'organizzazione.
</Tip>

<div id="step-3-map-groups-to-roles-and-orgs-in-devin">
  ### Passaggio 3: associa i Gruppi ai Ruoli e alle org in Devin
</div>

Una volta che i gruppi vengono passati al login, mappali in Devin.

<div id="in-the-devin-ui">
  #### Nella UI di Devin
</div>

1. **Settings → Enterprise → Gruppi del provider di identità**
2. I gruppi compaiono automaticamente dopo l'accesso di un membro del gruppo
3. Fai clic su un gruppo → assegnagli un ruolo a livello Enterprise (ad es. Enterprise Admin o un ruolo personalizzato)
4. Fai clic su un gruppo → assegnalo a org specifiche con ruoli specifici a livello di org

<div id="via-the-api-for-pre-setup-or-automation">
  #### Tramite l'API (per la configurazione preliminare o l'automazione)
</div>

* Crea i gruppi in anticipo, prima che qualcuno acceda: `PUT /v2/enterprise/groups`
* Elenca i gruppi e le rispettive assegnazioni alle org: `GET /v2/enterprise/groups`

<div id="step-4-if-migrating-from-scim-groups-in-other-apps">
  ### Passaggio 4: se esegui la migrazione dai gruppi SCIM in altre app
</div>

Se stai passando, in tutta la tua suite di strumenti (non solo Devin), da una strategia IdP basata su gruppi gestiti tramite SCIM a una basata su gruppi gestiti direttamente dall'IdP:

1. **Interrompi l'importazione dei gruppi SCIM** nelle altre app:
   * Nell'IdP: vai alla scheda **Provisioning → Integration** dell'app → deseleziona "Import Groups"
   * In questo modo l'app downstream non sarà più la fonte autorevole per i gruppi
2. **Crea gruppi corrispondenti** nella directory dell'IdP:
   * Vai a **Directory → Groups** e crea gruppi che rispecchino quelli presenti nell'app downstream
   * Assegna gli utenti a questi gruppi nativi dell'IdP
3. **Configura il push dei gruppi** (per le app che lo supportano):
   * Nella configurazione IdP dell'app: scheda **Push Groups** → trova i gruppi per nome → collegali ai gruppi downstream esistenti
   * In questo modo l'IdP sovrascrive le appartenenze interne dell'app: l'IdP diventa l'unica fonte autorevole
   * Devin non richiede il push dei gruppi perché legge i gruppi direttamente dall'asserzione di login
4. **Disabilita la sincronizzazione dei gruppi SCIM** nelle altre app:
   * Assicurati che "Import Groups" resti disattivato per evitare che l'app downstream torni a proporsi come fonte autorevole

Per Devin nello specifico, non è necessaria alcuna migrazione. Assicurati solo che i passaggi 1–3 sopra siano completati (gruppi definiti nel tuo IdP, claim configurati, mappature impostate in Devin).

***

<div id="key-considerations">
  ## Considerazioni chiave
</div>

<AccordionGroup>
  <Accordion title="Rinomina dei gruppi nell'IdP">
    Se un gruppo viene rinominato, Devin lo considera un nuovo gruppo. Le mappature dei ruoli del vecchio gruppo non vengono trasferite automaticamente: dovrai riconfigurare il nuovo nome del gruppo nelle Settings di Devin.
  </Accordion>

  <Accordion title="L'aggiunta a un gruppo non implica un accesso immediato a Devin">
    Un utente aggiunto a un gruppo IdP mappato in Devin non otterrà l'accesso finché non avrà effettuato l'accesso.
  </Accordion>

  <Accordion title="La rimozione da un gruppo non implica la rimozione immediata da Devin">
    La rimozione di un utente da un gruppo IdP non revoca immediatamente il suo accesso a Devin. Al successivo accesso, Devin sincronizza e rimuove l'appartenenza al gruppo non più valida. Eventuali appartenenze dirette (assegnate al di fuori dei gruppi) non vengono influenzate.
  </Accordion>

  <Accordion title="I nomi dei gruppi devono corrispondere esattamente">
    Il nome del gruppo nell'IdP deve corrispondere esattamente a quello visto da Devin. Fa distinzione tra maiuscole e minuscole.
  </Accordion>

  <Accordion title="Nessun gruppo nidificato">
    Devin non supporta gruppi nidificati/gerarchici. Se l'IdP invia un gruppo padre, i membri dei gruppi figli non vengono inclusi automaticamente. Ogni gruppo deve essere assegnato esplicitamente.
  </Accordion>
</AccordionGroup>

***

<div id="recommended-setup-for-scim-like-behavior">
  ## Configurazione consigliata per un comportamento "simile a SCIM"
</div>

Per ottenere il massimo livello di controllo possibile senza SCIM, segui questo approccio:

<Steps>
  <Step title="Configura il tuo provider di identità (fonte autorevole)">
    1. Definisci i gruppi: `Devin-Admins`, `Devin-Backend`, `Devin-Frontend`, ecc.
    2. Assegna gli utenti ai gruppi
    3. Configura i claim di gruppo SAML/OIDC filtrati su "Inizia con: `Devin-`"
  </Step>

  <Step title="Devin si sincronizza a ogni accesso">
    Quando un utente accede tramite SSO, Devin:

    * Crea automaticamente l'utente se non esiste ancora
    * Esegue una sincronizzazione completa dei gruppi (aggiunge i nuovi gruppi e rimuove quelli obsoleti)
    * Applica immediatamente le mappature da gruppo a ruolo e da gruppo a org
  </Step>

  <Step title="Facoltativo: automatizza con l'API V2">
    Configura un job pianificato per colmare le limitazioni dovute all'assenza di SCIM:

    1. Leggi gli utenti attivi dalla tua API IdP
    2. Leggi i membri di Devin da `GET /v2/enterprise/members`
    3. Invita i nuovi dipendenti tramite `POST /v2/enterprise/members/invite`
    4. Rimuovi i dipendenti che hanno lasciato l'azienda tramite `DELETE /v2/enterprise/members/{user_id}`

    In questo modo ottieni provisioning e deprovisioning di tipo push senza SCIM.
  </Step>
</Steps>

<div id="what-this-gives-you">
  ### Cosa ottieni
</div>

* Il tuo IdP come fonte autorevole unica per la struttura dei gruppi e l'appartenenza
* Accesso automatico basato sui gruppi a ogni login
* Provisioning/deprovisioning tramite API per colmare il divario che normalmente verrebbe coperto da SCIM
* Audit trail completo di tutti gli accessi e delle modifiche all'appartenenza

<div id="current-limitations">
  ### Limitazioni attuali
</div>

* **Sincronizzazione dei gruppi in tempo reale tra un accesso e l'altro** — i gruppi si aggiornano solo quando gli utenti effettuano l'accesso
* **Revoca immediata delle sessioni in caso di deprovisioning** — le sessioni restano attive fino alla scadenza
* Gli **eventi del ciclo di vita avviati dall'IdP**, come sospensione e riattivazione, non sono supportati