> ## 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.

# Guia de onboarding do SSO

> Guia completo para configurar o SSO, entender as considerações sobre SCIM e configurar grupos do IdP com Devin Enterprise.

Este guia orienta administradores do Enterprise em todo o ciclo de vida do SSO com Devin — da configuração inicial à configuração de grupos do IdP — e explica como Devin gerencia o provisionamento de usuários sem SCIM.

Para instruções de configuração específicas de cada provedor, consulte [Okta](/pt-BR/enterprise/security-access/sso/okta), [Microsoft Entra ID](/pt-BR/enterprise/security-access/sso/azure), [SAML](/pt-BR/enterprise/security-access/sso/saml) ou [OIDC genérico](/pt-BR/enterprise/security-access/sso/oidc).

***

<div id="1-setting-up-sso">
  ## 1. Configurando o SSO
</div>

<div id="creating-your-sso-application">
  ### Criando seu aplicativo de SSO
</div>

Crie um aplicativo no seu provedor de identidade (Okta, Microsoft Entra ID ou qualquer IdP compatível com SAML/OIDC) e compartilhe as seguintes credenciais com a sua equipe da Cognition:

| Tipo de conexão        | Protocolo                      | O que fornecer                                                   |
| :--------------------- | :----------------------------- | :--------------------------------------------------------------- |
| **Okta**               | OIDC (Okta Workforce Identity) | domínio do Okta, ID do cliente, segredo do cliente, escopos      |
| **Microsoft Entra ID** | OIDC (Microsoft Entra ID)      | domínio do Microsoft Entra ID, ID do cliente, segredo do cliente |
| **SAML**               | SAML 2.0 (qualquer IdP)        | URL de login, certificado de assinatura X.509                    |
| **OIDC genérico**      | OIDC                           | URL de descoberta, ID do cliente, segredo do cliente, escopos    |

<Note>
  Você também deve fornecer seus domínios de e-mail verificados para que o Devin saiba quais endereços de e-mail do seu IdP considerar confiáveis.
</Note>

<div id="what-happens-after-setup">
  ### O que acontece após a configuração
</div>

Quando sua equipe da Cognition tiver as credenciais, ela configurará a conexão de SSO. Após a conclusão da configuração:

1. A conexão de SSO é vinculada ao seu ambiente Enterprise do Devin
2. **Associação automática ao fazer login** é ativada — qualquer usuário que se autenticar via SSO é adicionado automaticamente ao seu ambiente Enterprise
3. Seu(s) domínio(s) de e-mail são registrados como confiáveis — somente e-mails desses domínios são aceitos
4. **Atribuição de funções com base em grupos (RBAC)** é ativada — grupos do IdP enviados durante o login podem ser mapeados para funções no Devin
5. Os logins sociais padrão (Google, GitHub) são desativados — o SSO passa a ser o método de autenticação obrigatório

<div id="the-user-login-experience">
  ### A experiência de login do usuário
</div>

1. O usuário acessa a URL do seu Devin
2. É redirecionado para o IdP configurado (Okta, Microsoft Entra ID etc.)
3. O usuário se autentica normalmente
4. O IdP envia ao Devin as informações do usuário e as associações a grupos
5. O Devin automaticamente:
   * Cria a conta do usuário se esse for o primeiro login dele (provisionamento just-in-time)
   * Atribui a ele a função padrão Enterprise Member
   * Sincroniza as associações a grupos do IdP — adiciona novos grupos e remove os obsoletos
   * Registra o login no log de auditoria do Enterprise

***

<div id="self-service-administration">
  ## Administração self-service
</div>

Os itens a seguir estão disponíveis diretamente no webapp do Devin para os admins do Enterprise.

<div id="idp-group-management">
  ### Gerenciamento de grupos do IdP
</div>

**Configurações → Enterprise → Grupos do Provedor de Identidade**

* Visualize todos os grupos sincronizados a partir dos logins de usuários
* Atribua um grupo a uma função no nível Enterprise (por exemplo, "Todos em `Engineering-Admins` recebem a função de Enterprise Admin")
* Atribua um grupo a orgs específicas com funções específicas (por exemplo, "`Team-Backend` recebe acesso de Membro na org Backend")
* Adicione/remova grupos em massa em várias orgs
* Visualize em quantas orgs cada grupo está atribuído

<div id="member-management">
  ### Gerenciamento de membros
</div>

**Configurações → Enterprise → Membros**

* Visualize todos os membros do Enterprise, incluindo suas associações com grupos do IdP
* Convide novos membros por e-mail
* Atualize as funções dos membros
* Remova membros

<div id="custom-roles">
  ### Funções personalizadas
</div>

**Configurações → Enterprise → Funções**

* Crie funções personalizadas com permissões granulares
* Atribua funções personalizadas a usuários específicos ou a grupos do IdP

Consulte [Funções personalizadas e RBAC](/pt-BR/enterprise/security-access/custom-roles) para mais detalhes.

<div id="api-for-automation">
  ### API para automação
</div>

A Devin oferece uma API V2 que você pode usar para automatizar o gerenciamento de membros:

| Ação                                    | Endpoint da API                              |
| :-------------------------------------- | :------------------------------------------- |
| Listar todos os membros                 | `GET /v2/enterprise/members`                 |
| Convidar usuários por e-mail (em lote)  | `POST /v2/enterprise/members/invite`         |
| Remover um membro                       | `DELETE /v2/enterprise/members/{user_id}`    |
| Atualizar funções de membros em lote    | `PATCH /v2/enterprise/members/roles`         |
| Migrar membros entre funções            | `PATCH /v2/enterprise/members/migrate-roles` |
| Listar todas as funções                 | `GET /v2/enterprise/roles`                   |
| Listar todos os grupos do IdP           | `GET /v2/enterprise/groups`                  |
| Pré-criar grupos do IdP                 | `PUT /v2/enterprise/groups`                  |
| Obter as atribuições de org de um grupo | `GET /v2/enterprise/groups/{group_name}`     |

***

<div id="2-understanding-devin-without-scim">
  ## 2. Entendendo o Devin sem SCIM
</div>

No momento, o Devin não oferece suporte ao protocolo SCIM. Todo o gerenciamento de usuários e grupos é feito por meio de eventos de login via SSO e pela UI/API do Devin. Veja o que isso significa na prática.

<div id="user-provisioning-login-triggered-only">
  ### Provisionamento de usuário: somente no login
</div>

|                                  | Com SCIM                                                                      | Devin (sem SCIM)                                                                                               |
| :------------------------------- | :---------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------- |
| **Como os usuários são criados** | O IdP cria o usuário no app imediatamente quando o app é atribuído ao usuário | O usuário só passa a existir no Devin após o primeiro login com SSO — ou após um convite manual pela UI ou API |
| **Quando isso acontece**         | O administrador atribui o app ao usuário → o usuário aparece em segundos      | O administrador atribui o app ao usuário → nada acontece no Devin até ele fazer login                          |
| **Pré-provisionamento**          | A conta do usuário fica pronta antes mesmo de ele acessar o app               | Não há pré-provisionamento, a menos que o administrador o convide explicitamente pela UI ou API do Devin       |

Ao integrar novos funcionários, o administrador pode convidá-los com antecedência (**Configurações → Enterprise → Membros → Convidar**, ou pela API) ou simplesmente deixar que sejam provisionados automaticamente no primeiro login.

<div id="user-deprovisioning-manual-only">
  ### Desprovisionamento de usuários: apenas manual
</div>

|                                    | Com SCIM                                                                           | Devin (Sem SCIM)                                                                                   |
| :--------------------------------- | :--------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------- |
| **Como os usuários são removidos** | O IdP desativa/remove o usuário → o app desativa imediatamente o acesso do usuário | Desativar/remover um usuário no IdP não faz nada no Devin                                          |
| **Desligamento**                   | O funcionário desligado perde o acesso em minutos                                  | O funcionário desligado mantém o acesso até ser removido manualmente do Devin e sua sessão expirar |
| **Conformidade**                   | Conformidade automatizada — sem contas órfãs                                       | Risco de contas órfãs, a menos que o administrador mantenha os dois sistemas                       |

<Warning>
  Esta é a maior lacuna operacional. Ao desligar um funcionário, o administrador deve removê-lo separadamente do Devin (**Configurações → Enterprise → Membros → Remover**, ou via API). Sessões ativas continuam funcionando até expirarem naturalmente — não há revogação imediata de sessão acionada pelo IdP.
</Warning>

<div id="group-sync-login-time-only-not-real-time">
  ### Sincronização de grupos: apenas no login, não em tempo real
</div>

|                              | Com SCIM (Group Push)                                                  | Devin (Sem SCIM)                                                                                     |
| :--------------------------- | :--------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------- |
| **Momento da sincronização** | O IdP envia as alterações de associação a grupos em tempo real         | Os grupos só são sincronizados quando o usuário faz login                                            |
| **Adicionar a um grupo**     | O Admin adiciona o usuário ao grupo → o app reflete isso imediatamente | O Admin adiciona o usuário ao grupo → Devin só fica sabendo no próximo login do usuário              |
| **Remover de um grupo**      | O Admin remove o usuário do grupo → o app reflete isso imediatamente   | O Admin remove o usuário do grupo → Devin continua mostrando a associação antiga até o próximo login |
| **Fonte de verdade**         | O IdP é sempre a fonte de verdade                                      | O IdP só é a fonte de verdade no momento do login — pode haver divergências entre logins             |

Se um admin alterar o grupo de alguém no IdP (p. ex., movê-lo de Engenharia para Vendas), Devin não refletirá essa mudança até que o usuário faça login novamente. Enquanto isso, o usuário mantém suas funções baseadas em grupo e o acesso antigo à org.

<div id="built-in-alternatives-to-scim">
  ### Alternativas nativas ao SCIM
</div>

O Devin inclui vários recursos que atendem a casos de uso comuns do SCIM:

1. **Provisionamento just-in-time** — os usuários são criados automaticamente no primeiro login via SSO com a função padrão do Enterprise
2. **Sincronização completa de grupos a cada login** — sempre que um usuário faz login, o Devin faz um diff completo dos grupos do IdP: adiciona os novos e remove os antigos
3. **RBAC baseado em grupos** — é possível mapear grupos do IdP para funções do Enterprise e acesso à org nas Configurações do Devin, com efeito no próximo login
4. **API V2 para automação** — convites, remoções e alterações de função em massa podem ser automatizados por script para fechar a lacuna de provisionamento/desprovisionamento
5. **Logs de auditoria** — todo login é registrado, dando visibilidade sobre quem acessou o Devin

***

<div id="3-configuring-idp-managed-groups">
  ## 3. Configuração de grupos gerenciados pelo IdP
</div>

Se você usa SCIM com outros aplicativos (por exemplo, Slack, Box), esta seção explica como funciona o modelo de grupos do Devin e como configurar corretamente seu IdP.

<div id="context-scim-groups-vs-idp-groups">
  ### Contexto: Grupos SCIM vs. Grupos do IdP
</div>

* **Grupos SCIM:** O app de destino informa ao IdP quais grupos existem (o IdP os "importa"). O app é a fonte de verdade da estrutura dos grupos. O IdP sincroniza os usuários com esses grupos definidos pelo app.
* **Grupos do IdP (o que o Devin usa):** O IdP é a fonte de verdade. Os grupos são definidos no diretório do IdP, e as associações aos grupos são repassadas ao Devin por meio de claims SAML/OIDC no momento do login.

Como o Devin não usa SCIM, você já está operando no modo "grupos do IdP". O principal é garantir que os grupos corretos estejam sendo enviados pelo seu IdP e mapeados corretamente no Devin.

<div id="step-1-define-groups-in-the-idp">
  ### Etapa 1: Definir grupos no IdP
</div>

No console de administração do seu IdP (os exemplos abaixo usam o Okta):

1. Vá para **Directory → Groups**
2. Crie grupos que correspondam aos níveis de acesso do Devin (por exemplo, `Devin-Engineering`, `Devin-Admins`, `Devin-DataScience`)
3. Atribua usuários a esses grupos

Esses são grupos nativos do IdP — seu IdP é a fonte de verdade sobre quem pertence a qual grupo.

<div id="step-2-configure-group-claims-in-the-idp-app">
  ### Etapa 2: Configurar as claim de grupo no app do IdP
</div>

Os grupos devem ser incluídos na resposta de autenticação para que o Devin possa lê-los.

<div id="for-saml-connections">
  #### Para conexões SAML
</div>

1. Vá para **Applications → \[Devin App] → SAML Settings → Edit**
2. Em **Group Attribute Statements**, adicione:
   * **Name:** `groups`
   * **Filter:** "Starts with" → `Devin-` (ou use "Matches regex" para padrões mais complexos)
3. Isso instrui o IdP a incluir os nomes dos grupos correspondentes na asserção SAML

<div id="for-oidc-connections">
  #### Para conexões OIDC
</div>

1. Vá para **Applications → \[Devin App] → Sign On → Edit**
2. Em **OpenID Connect ID Token → Groups claim type**, selecione "Filter"
3. Configure o filtro para corresponder aos grupos do Devin (por exemplo, "Starts with" → `Devin-`)

<Tip>
  Use um prefixo de filtro como `Devin-` para que apenas os grupos relevantes sejam enviados. Não é necessário enviar todos os grupos do IdP da organização.
</Tip>

<div id="step-3-map-groups-to-roles-and-orgs-in-devin">
  ### Etapa 3: Mapear grupos para funções e org no Devin
</div>

Quando os grupos passarem a ser enviados no login, faça o mapeamento deles no Devin.

<div id="in-the-devin-ui">
  #### Na UI do Devin
</div>

1. **Configurações → Enterprise → Grupos do Provedor de Identidade**
2. Os grupos aparecem automaticamente depois que qualquer membro do grupo faz login
3. Clique em um grupo → atribua a ele uma função no nível Enterprise (por exemplo, Enterprise Admin ou uma função personalizada)
4. Clique em um grupo → atribua-o a org específicas com funções específicas no nível da org

<div id="via-the-api-for-pre-setup-or-automation">
  #### Pela API (para pré-configuração ou automação)
</div>

* Crie grupos antecipadamente, antes que qualquer pessoa faça login: `PUT /v2/enterprise/groups`
* Liste os grupos e suas atribuições de org: `GET /v2/enterprise/groups`

<div id="step-4-if-migrating-from-scim-groups-in-other-apps">
  ### Etapa 4: Se estiver migrando de grupos SCIM em outros apps
</div>

Se você estiver mudando sua estratégia geral de IdP de grupos gerenciados por SCIM para grupos gerenciados pelo IdP em todas as suas ferramentas (não apenas no Devin):

1. **Interrompa a importação de grupos via SCIM** nos outros apps:
   * No IdP: vá para a aba **Provisioning → Integration** do app → desmarque "Import Groups"
   * Isso faz com que o app de destino deixe de ser a fonte de verdade para os grupos
2. **Crie grupos correspondentes** no diretório do IdP:
   * Vá para **Directory → Groups** e crie grupos que espelhem o que existia no app de destino
   * Atribua usuários a esses grupos nativos do IdP
3. **Configure o Group Push** (para apps que oferecem suporte):
   * Na configuração de IdP do app: aba **Push Groups** → encontre os grupos pelo nome → vincule-os aos grupos existentes no app de destino
   * Isso faz com que o IdP sobrescreva a associação interna do app — o IdP passa a ser a única fonte de verdade
   * O Devin não precisa de Group Push porque lê os grupos diretamente da asserção de login
4. **Desative a sincronização de grupos via SCIM** nos outros apps:
   * Garanta que "Import Groups" permaneça desativado para impedir que o app de destino volte a se afirmar como fonte de verdade

Para o Devin especificamente, nenhuma migração é necessária. Apenas garanta que as Etapas 1–3 acima tenham sido concluídas (grupos definidos no seu IdP, claims configuradas e mapeamentos definidos no Devin).

***

<div id="key-considerations">
  ## Considerações principais
</div>

<AccordionGroup>
  <Accordion title="Renomeação de grupos no IdP">
    Se um grupo for renomeado, Devin o tratará como um novo grupo. Os mapeamentos de função do grupo antigo não são transferidos automaticamente — será necessário reconfigurar o novo nome do grupo nas Configurações do Devin.
  </Accordion>

  <Accordion title="Adicionar a um grupo não significa acesso imediato ao Devin">
    Um usuário adicionado a um grupo do IdP mapeado no Devin só terá esse acesso quando fizer login.
  </Accordion>

  <Accordion title="Remover de um grupo não significa perda imediata de acesso ao Devin">
    Remover um usuário de um grupo do IdP não revoga imediatamente seu acesso ao Devin. No próximo login, Devin sincroniza e remove a associação ao grupo obsoleta. Qualquer associação direta (atribuída fora dos grupos) não é afetada.
  </Accordion>

  <Accordion title="Os nomes dos grupos devem corresponder exatamente">
    O nome do grupo no IdP deve corresponder exatamente ao que Devin vê. Diferencia letras maiúsculas de minúsculas.
  </Accordion>

  <Accordion title="Sem grupos aninhados">
    Devin não oferece suporte a grupos aninhados/hierárquicos. Se o IdP enviar um grupo pai, os membros dos grupos filhos não serão incluídos automaticamente. Cada grupo deve ser atribuído explicitamente.
  </Accordion>
</AccordionGroup>

***

<div id="recommended-setup-for-scim-like-behavior">
  ## Configuração recomendada para um comportamento "semelhante ao SCIM"
</div>

Para ter o maior controle possível sem SCIM, siga esta abordagem:

<Steps>
  <Step title="Configure seu provedor de identidade (Fonte da verdade)">
    1. Defina grupos: `Devin-Admins`, `Devin-Backend`, `Devin-Frontend`, etc.
    2. Atribua usuários aos grupos
    3. Configure claims de grupo SAML/OIDC filtradas por "Começa com: `Devin-`"
  </Step>

  <Step title="O Devin sincroniza a cada login">
    Quando um usuário faz login via SSO, o Devin automaticamente:

    * Cria o usuário automaticamente, se ele for novo
    * Executa uma sincronização completa dos grupos (adiciona novos grupos e remove os obsoletos)
    * Aplica imediatamente os mapeamentos de grupo para função e de grupo para organização
  </Step>

  <Step title="Opcional: automatize com a API V2">
    Configure uma tarefa agendada para cobrir as lacunas do SCIM:

    1. Leia os usuários ativos da API do seu IdP
    2. Leia os membros do Devin em `GET /v2/enterprise/members`
    3. Convide novos funcionários via `POST /v2/enterprise/members/invite`
    4. Remova funcionários desligados via `DELETE /v2/enterprise/members/{user_id}`

    Isso oferece provisionamento e desprovisionamento no modelo push sem SCIM.
  </Step>
</Steps>

<div id="what-this-gives-you">
  ### O que isso proporciona
</div>

* Seu IdP como fonte única de verdade para a estrutura e a associação de grupos
* Acesso automático baseado em grupos em todos os logins
* Provisionamento/desprovisionamento via API para suprir a lacuna que o SCIM normalmente preencheria
* Trilha de auditoria completa para todos os logins e alterações de associação

<div id="current-limitations">
  ### Limitações atuais
</div>

* **Sincronização de grupos em tempo real entre um login e outro** — os grupos só são atualizados quando os usuários fazem login
* **Revogação instantânea de sessão no desprovisionamento** — as sessões permanecem ativas até expirarem
* **Eventos de ciclo de vida iniciados pelo IdP**, como suspender/reativar, não têm suporte