

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Configurar a App-Only autenticação Microsoft Entra ID para SharePoint
<a name="kb-managed-sharepoint-entra-setup"></a>

A App-Only autenticação Microsoft Entra ID (`ENTRA_ID_APP_ONLY`) é o método de autenticação recomendado para uma fonte SharePoint de dados. Ele usa o fluxo de credenciais do cliente do OAuth 2.0 (somente aplicativo): um aplicativo Microsoft Entra se autentica com um certificado, portanto, nenhum login de usuário está envolvido no momento do rastreamento ou da consulta. Esse é o único método de autenticação que oferece suporte ao controle de acesso (ACLs) em nível de documento. Para uma comparação com o `OAUTH2_APP` método alternativo, consulte[Métodos de autenticação](kb-managed-ds-sharepoint.md#kb-managed-sharepoint-auth-methods).

Essa configuração abrange dois sistemas — Microsoft Entra ID e sua AWS conta — e o certificado é a credencial que os une. O conector armazena o certificado (chave privada incluída) como um arquivo PKCS \#12 (`.p12`) no Amazon S3 e o usa para assinar declarações de autenticação para a Microsoft; o certificado público correspondente é carregado no registro do aplicativo Entra para que a Microsoft possa validar essas afirmações.

**Acesso administrativo necessário**  
Essa configuração requer que um administrador do Microsoft Entra ID (administrador global ou administrador de função privilegiada) registre o aplicativo, configure as permissões e conceda o consentimento do administrador. Se você usar o escopo da `Sites.Selected` permissão, também precisará de um SharePoint administrador para conceder acesso por site. A tabela **de etapas e funções de configuração** abaixo identifica o acesso necessário para cada etapa.

## Etapas e funções de configuração
<a name="kb-managed-sharepoint-entra-roles"></a>

Esse procedimento envolve um administrador do Microsoft Entra ID e um AWS administrador. Dependendo de como as responsabilidades são divididas em sua organização, uma pessoa ou várias pessoas podem concluir essas etapas. Use a tabela a seguir para identificar o acesso que cada etapa exige.


**Etapas de configuração e o acesso que cada uma requer**  

| Etapa | O que você faz | Acesso necessário | 
| --- | --- | --- | 
| 1. Registre o aplicativo | Crie o registro do aplicativo Entra e registre seus IDs de cliente e inquilino. | Administrador do Microsoft Entra ID (administrador global ou administrador de função privilegiada) | 
| 2. Adicione permissões e conceda consentimento | Atribua as permissões do aplicativo para sua configuração e conceda o consentimento do administrador. | Administrador Microsoft Entra ID | 
| 3. Gere o certificado | Crie um certificado autoassinado e um pacote PKCS \#12 (.p12) com o OpenSSL. | Qualquer pessoa com um terminal local (é necessário o OpenSSL) | 
| 4. Faça o upload do certificado público para a Entra | Adicione o certificado público às chaves de registro do aplicativo. | Administrador Microsoft Entra ID | 
| 5. Conceder acesso por site (Sites.Selectedsomente) | Conceda ao aplicativo acesso a cada SharePoint site por meio da API do Microsoft Graph. | Administrador Microsoft Entra ID | 
| 6. Faça o upload do certificado para o Amazon S3 | Armazene o .p12 pacote em um bucket do Amazon S3. | AWS administrador (Amazon S3) | 
| 7. Criar o segredo | Armazene as credenciais em AWS Secrets Manager segredo. | AWS administrador (Secrets Manager) | 
| 8. Conceda à função de serviço acesso ao certificado | Adicione permissões de leitura do Amazon S3 à sua função de serviço da base de conhecimento. | AWS administrador (IAM) | 

## Escolha sua configuração
<a name="kb-managed-sharepoint-entra-choose"></a>

Antes de começar, tome duas decisões. Eles determinam quais permissões você atribui na Etapa 2 e como você concede acesso ao site.
+ **Document-level controle de acesso (ACLs)** — Decida se a fonte de dados filtra os resultados da consulta de acordo com SharePoint as permissões de cada usuário. O rastreamento de ACL requer permissões e Microsoft Graph adicionais. SharePoint Você não pode alterar essa configuração depois de criar a fonte de dados. Para obter detalhes, consulte [Document-level controles de acesso](kb-managed-ds-sharepoint-acl.md).
+ **Escopo da permissão** — Decida se o aplicativo pode ler todos os SharePoint sites do seu locatário (**todos os sites**, a opção mais simples) ou somente os sites que você concede explicitamente (**`Sites.Selected`**, a opção de menor privilégio). Com `Sites.Selected` você conclui uma concessão extra por site na Etapa 5, e todos os sites que você adicionar posteriormente precisarão de sua própria concessão.

A combinação dessas duas opções seleciona um dos conjuntos de permissões na seção a seguir.

## Referência de permissões
<a name="kb-managed-sharepoint-entra-permissions"></a>

Atribua as permissões do aplicativo que correspondem à sua configuração. Todas as permissões são permissões de **aplicativos** (não delegadas) e todas exigem o consentimento do administrador. O conector se autentica em dois recursos da Microsoft: **Microsoft Graph** (para enumerar sites e, para ACLs, para resolver usuários e grupos) e a API **SharePoint**REST (para ler o conteúdo do site e, para ACLs, permissões em nível de item).

**Importante**  
Ao adicionar essas permissões no portal Entra, escolha a guia **Permissões do aplicativo**, não **Permissões delegadas**. App-only a autenticação usa permissões do aplicativo.

Selecione a guia da sua configuração para ver o Microsoft Graph exato e SharePoint as permissões a serem atribuídas.

------
#### [ All sites, no ACLs ]


**Todos os sites, somente conteúdo**  

| solicitações de | Permissão | Finalidade | 
| --- | --- | --- | 
| Microsoft Graph | Sites.Read.All | Enumere e leia todos os sites. SharePoint  | 
| SharePoint | Sites.Read.All | Leia o conteúdo do site por meio da API SharePoint REST. | 

------
#### [ All sites, with ACLs ]


**Todos os sites, com ACLs**  

| solicitações de | Permissão | Finalidade | 
| --- | --- | --- | 
| Microsoft Graph | Sites.Read.All | Enumere e leia todos os sites. SharePoint  | 
| Microsoft Graph | User.Read.All | Resolva usuários para ACLs em nível de documento. | 
| Microsoft Graph | GroupMember.Read.All | Resolva a associação ao grupo para ACLs em nível de documento. | 
| SharePoint | Sites.FullControl.All | Leia as permissões em nível de item para rastreamento de ACL e verifique o acesso no momento da consulta. Sites.Read.Allnão é suficiente para essa verificação. | 

------
#### [ Sites.Selected, no ACLs ]


**Sites.Selected, somente conteúdo**  

| solicitações de | Permissão | Finalidade | 
| --- | --- | --- | 
| Microsoft Graph | Sites.Selected | Acesse somente os sites que você concede explicitamente (Microsoft Graph). | 
| SharePoint | Sites.Selected | Acesse somente os sites que você concede explicitamente (SharePoint REST). Conceda a read função por site na Etapa 5. | 

------
#### [ Sites.Selected, with ACLs ]


**Sites.Selected, com ACLs**  

| solicitações de | Permissão | Finalidade | 
| --- | --- | --- | 
| Microsoft Graph | Sites.Selected | Acesse somente os sites que você concede explicitamente (Microsoft Graph). | 
| Microsoft Graph | User.Read.All | Resolva usuários para ACLs em nível de documento. | 
| Microsoft Graph | GroupMember.Read.All | Resolva a associação ao grupo para ACLs em nível de documento. | 
| SharePoint | Sites.Selected | Acesse somente os sites que você concede explicitamente. Conceda a fullcontrol função por site na Etapa 5 (necessária para ler as permissões em nível de item para ACLs). | 

------

**nota**  
`Sites.FullControl.All`concede amplo acesso a todos os sites do inquilino. Se sua organização exigir menos privilégios, use `Sites.Selected` e conceda acesso por site na Etapa 5.

## Valores que você coleta durante a configuração
<a name="kb-managed-sharepoint-entra-values"></a>

Você cria ou coleta os seguintes valores à medida que avança nas etapas. Você os usa ao criar a fonte de dados. Para obter detalhes, consulte [Conectar uma fonte SharePoint de dados](kb-managed-ds-sharepoint-connect.md).


**Referência de valores**  

| Valor | Criado em | Usado para | 
| --- | --- | --- | 
| ID da aplicação (cliente) | Etapa 1 | O segredo (clientId). | 
| ID do diretório (locatário) | Etapa 1 | A fonte de dadostenantId. | 
| Certificado — PKCS \#12 bundle (.p12) e sua senha | Etapa 3 | O pacote (certificado mais chave privada) é carregado no Amazon S3 (Etapa 6); a senha é armazenada no segredo certificatePassword (). | 
| Certificado — certificado público (.cer) | Etapa 3 | A metade pública do mesmo certificado, enviada para o registro do aplicativo Entra (Etapa 4). | 
| Nome e chave do bucket Amazon S3 | Etapa 6 | A fonte de dadoscertificateS3Path. | 
| ARN do segredo | Etapa 7 | A fonte de dadossecretArn. | 

## Etapa 1: registrar o aplicativo no Microsoft Entra ID
<a name="kb-managed-sharepoint-entra-step1"></a>

1. Faça login no [centro de administração do Microsoft Entra](https://entra.microsoft.com/).

1. No painel de navegação à esquerda, expanda **Entra ID** e escolha **Registros de aplicativos.**

1. Escolha **Novo registro**.

1. Em **Nome**, insira um nome descritivo, como`bedrock-sharepoint-connector`.

1. Para **Tipos de conta compatíveis**, selecione **Contas somente neste diretório organizacional (inquilino único)**.

1. Deixe o **URI de redirecionamento** em branco. Um URI de redirecionamento não é necessário porque o aplicativo usa o fluxo de credenciais do cliente, não um fluxo de login interativo.

1. Escolha **Registrar**.

1. Na página **Visão geral** do aplicativo, registre o ID do **aplicativo (cliente) e o ID** do **diretório (inquilino)**. Você precisa dos dois mais tarde.

## Etapa 2: adicionar permissões de API e conceder o consentimento do administrador
<a name="kb-managed-sharepoint-entra-step2"></a>

Adicione as permissões para sua configuração de[Referência de permissões](#kb-managed-sharepoint-entra-permissions).

1. No registro do seu aplicativo, escolha **Permissões de API** e, em seguida, **Adicionar uma permissão**.

1. Escolha **Microsoft Graph** e, em seguida, **Permissões do aplicativo**. Pesquise e selecione cada permissão do Microsoft Graph para sua configuração e escolha **Adicionar permissões**.

1. Escolha **Adicionar uma permissão** novamente. Escolha **SharePoint**(em **APIs da Microsoft**) e, em seguida, **Permissões do aplicativo**. Selecione cada SharePoint permissão para sua configuração e escolha **Adicionar permissões**.

1. Na página de **permissões da API**, escolha **Conceder consentimento do administrador para [sua organização]** e confirme. Sem o consentimento do administrador, o aplicativo não pode acessar SharePoint os dados.

**nota**  
A App-Only autenticação Microsoft Entra ID usa o certificado (da Etapa 3) como credencial, para que você não crie um segredo de cliente para esse aplicativo.

## Etapa 3: gerar o certificado de autenticação
<a name="kb-managed-sharepoint-entra-step3"></a>

Gere um certificado autoassinado e empacote-o como um pacote PKCS \#12 (`.p12`). O pacote contém o certificado e sua chave privada, protegidos por uma senha. Você carrega o certificado público para o Entra (Etapa 4) e o `.p12` pacote para o Amazon S3 (Etapa 6). Selecione a guia do seu sistema operacional para ver os comandos.

**nota**  
O Amazon Bedrock lê a chave privada do `.p12` pacote para assinar declarações de autenticação, portanto, o pacote deve ser protegido por senha e armazenado com segurança. Escolha uma senha forte e aleatória — você a armazena em segredo, como `certificatePassword` na Etapa 7.

------
#### [ Linux or macOS (OpenSSL) ]

**Gere uma chave privada e um certificado autoassinado**

```
openssl req -x509 -newkey rsa:2048 -keyout private_key.pem -out certificate.cer \
    -days 365 -nodes \
    -subj "/CN={{bedrock-sharepoint-connector}}"
```

**Package o certificado e a chave como um pacote PKCS \#12 (`.p12`)**

Insira uma senha de exportação forte quando solicitado. Grave-o para a Etapa 7.

```
openssl pkcs12 -export -out certificate.p12 \
    -inkey private_key.pem -in certificate.cer
```

Agora você tem três arquivos: a chave privada (`private_key.pem`), o certificado público (`certificate.cer`) e o pacote (`certificate.p12`). Você carrega o certificado público para a Entra na Etapa 4 e o `.p12` pacote para o Amazon S3 na Etapa 6.

------
#### [ Windows (PowerShell) ]

**Gere um certificado autoassinado**

Os PowerShell comandos a seguir geram um certificado autoassinado RSA de 2048 bits com um período de validade de um ano e o armazenam no repositório de certificados do usuário atual. {{your-password}}Substitua por uma senha forte e aleatória — você a armazena em segredo, como `certificatePassword` na Etapa 7.

```
$cert = New-SelfSignedCertificate `
    -Subject "CN={{bedrock-sharepoint-connector}}" `
    -CertStoreLocation "Cert:\CurrentUser\My" `
    -KeyAlgorithm RSA `
    -KeyLength 2048 `
    -KeyExportPolicy Exportable `
    -NotAfter (Get-Date).AddYears(1)
```

**Exportar o certificado público**

```
Export-Certificate -Cert $cert -FilePath certificate.cer -Type CERT
```

**Exportar o pacote PKCS \#12 (`.p12`)**

```
$password = ConvertTo-SecureString -String "{{your-password}}" -Force -AsPlainText
Export-PfxCertificate -Cert $cert -FilePath certificate.p12 -Password $password
```

Agora você tem dois arquivos: o certificado público (`certificate.cer`) e o pacote (`certificate.p12`). Você carrega o certificado público para a Entra na Etapa 4 e o `.p12` pacote para o Amazon S3 na Etapa 6.

------

**Importante**  
Armazene o `.p12` pacote no Amazon S3 (não `.pem` no arquivo `.cer` or). O pacote contém a chave privada que o Amazon Bedrock usa para autenticar. Document-level o controle de acesso (ACLs) requer o `.p12` formato. Para rastreamento somente de conteúdo sem ACLs, você pode armazenar um PEM-encoded certificado em vez disso; como `.p12` funciona para todas as configurações, este guia é usado por toda parte. `.p12`

**nota**  
Por padrão, o certificado é válido por um ano. Um certificado expirado faz com que todas as sincronizações falhem, então alterne o certificado antes que ele expire. Para alterar o período de validade, ajuste a `-days` opção (OpenSSL) ou `-NotAfter` o argumento (). PowerShell Para as etapas de rotação, consulte[Gire o certificado](kb-managed-ds-sharepoint-troubleshooting.md#kb-managed-ds-sharepoint-rotate-cert).

## Etapa 4: Carregar o certificado público para o Entra
<a name="kb-managed-sharepoint-entra-step4"></a>

1. No registro do seu aplicativo, escolha **Certificados e segredos e**, em seguida, a guia **Certificados**.

1. Escolha **Carregar certificado** e selecione o `certificate.cer` arquivo que você gerou na Etapa 3 (somente o certificado público — nunca carregue o `.p12` pacote ou a chave privada para o Entra).

1. Escolha **Adicionar**.

## Etapa 5 (Sites.Selected somente): conceder acesso por site
<a name="kb-managed-sharepoint-entra-step5"></a>

**nota**  
Essa etapa se aplica somente se você escolher o escopo da `Sites.Selected` permissão na Etapa 2. Se você usou o escopo para todos os sites (`Sites.Read.All`ou`Sites.FullControl.All`), vá para. [Etapa 6: Faça o upload do certificado para o Amazon S3](#kb-managed-sharepoint-entra-step6)

Com`Sites.Selected`, você concede ao seu aplicativo conector acesso a cada SharePoint site individualmente por meio da API do Microsoft Graph. Isso requer uma inscrição separada e temporária que seja válida `Sites.FullControl.All` e usada apenas para realizar os subsídios. O Amazon Bedrock nunca vê esse aplicativo temporário ou suas credenciais.

1. **Crie um aplicativo de concessão temporário.** No centro de administração da Entra, registre um segundo aplicativo (por exemplo,`bedrock-sharepoint-granter`) como inquilino único sem URI de redirecionamento. Adicione a permissão do `Sites.FullControl.All` aplicativo Microsoft Graph, conceda o consentimento do administrador e crie um segredo de cliente. Registre seu ID de cliente e valor secreto.

1. **Obtenha um token de acesso para o aplicativo concedente.** Substitua os espaços reservados pelo ID do cliente e pelo segredo do aplicativo concedente e pelo seu ID de inquilino.

   ```
   curl -s -X POST \
     "https://login.microsoftonline.com/{{TENANT_ID}}/oauth2/v2.0/token" \
     -H "Content-Type: application/x-www-form-urlencoded" \
     -d "grant_type=client_credentials" \
     -d "client_id={{GRANTER_CLIENT_ID}}" \
     -d "client_secret={{GRANTER_CLIENT_SECRET}}" \
     -d "scope=https://graph.microsoft.com/.default"
   ```

   A resposta contém um`access_token`. Use-o como símbolo portador nos próximos comandos.

1. **Resolva cada URL do site para um ID do site.** Use o nome do host e o caminho relativo ao servidor do site.

   ```
   curl -s \
     "https://graph.microsoft.com/v1.0/sites/{{contoso}}.sharepoint.com:/sites/{{engineering}}" \
     -H "Authorization: Bearer {{ACCESS_TOKEN}}"
   ```

   O `id` campo na resposta é o ID do site.

1. **Conceda ao aplicativo conector acesso ao site.** Use `read` para rastreamento somente de conteúdo ou `fullcontrol` para rastreamento de ACL. {{CONNECTOR\_CLIENT\_ID}}Substitua pela ID do aplicativo (cliente) da Etapa 1.

   ```
   curl -s -X POST \
     "https://graph.microsoft.com/v1.0/sites/{{SITE_ID}}/permissions" \
     -H "Authorization: Bearer {{ACCESS_TOKEN}}" \
     -H "Content-Type: application/json" \
     -d '{
       "roles": ["{{fullcontrol}}"],
       "grantedToIdentities": [{
         "application": {
           "id": "{{CONNECTOR_CLIENT_ID}}",
           "displayName": "{{bedrock-sharepoint-connector}}"
         }
       }]
     }'
   ```

1. Repita os comandos resolve-and-grant para cada site incluído na fonte de dados. Depois de terminar, você pode excluir o pedido de concessão temporária; as concessões por site permanecem em vigor.

**Importante**  
Per-site os subsídios não são retroativos. Se você adicionar um site à fonte de dados posteriormente, conceda ao aplicativo conector acesso a esse site antes da próxima sincronização, ou seu conteúdo não será rastreado.

## Etapa 6: Faça o upload do certificado para o Amazon S3
<a name="kb-managed-sharepoint-entra-step6"></a>

Faça o upload do `.p12` pacote da Etapa 3 para um bucket do Amazon S3 na AWS mesma região da sua base de conhecimento. Registre o nome e a chave do bucket — você os usa como fonte de dados`certificateS3Path`.

```
aws s3api put-object \
  --bucket {{your-certificate-bucket}} \
  --key {{certs/certificate.p12}} \
  --body certificate.p12 \
  --server-side-encryption AES256
```

**nota**  
Recomendamos que você habilite a criptografia do lado do servidor no objeto certificado e restrinja o bucket às entidades principais que precisam dele. O pacote contém a chave privada.

## Etapa 7: Criar o segredo do Secrets Manager
<a name="kb-managed-sharepoint-entra-step7"></a>

Armazene as credenciais em AWS Secrets Manager segredo. Para a App-Only autenticação do Entra ID, inclua os seguintes pares de valores-chave:
+ `clientId`(obrigatório) — o ID do aplicativo (cliente) da Etapa 1.
+ `certificatePassword`(recomendado) — a senha que você definiu no `.p12` pacote na Etapa 3. Veja a nota a seguir.

```
{
    "clientId": "{{your-client-id}}",
    "certificatePassword": "{{your-certificate-password}}"
}
```

Crie o segredo com AWS Command Line Interface:

```
aws secretsmanager create-secret \
  --name {{bedrock-sharepoint-creds}} \
  --secret-string file://secret.json
```

Registre o ARN secreto da resposta. Você o usa como fonte de dados`secretArn`.

**nota**  
`certificatePassword`Defina a senha que você usou ao criar o `.p12` pacote na Etapa 3. Se você omitir esse campo, o Amazon Bedrock abrirá o pacote usando o ID do cliente do seu aplicativo como senha, portanto, o pacote deve ter sido criado com o ID do cliente como senha. Em vez disso, recomendamos que você sempre defina uma senha explícita de alta entropia e armazene a chave privada com segurança.

**nota**  
**Em vez disso, use um certificado PEM.** Este guia usa um `.p12` pacote que funciona para todas as configurações. Se você rastrear somente o conteúdo (sem controle de acesso em nível de documento), poderá usar um certificado PEM em vez disso. Nesse caso, faça o upload somente do certificado *público* para o Amazon S3 (não um `.p12` pacote) e armazene a chave privada no segredo como `privateKey` (PKCS \#8 não criptografado e codificado em base64, sem linhas de cabeçalho) no lugar de: `certificatePassword`  

```
{
    "clientId": "{{your-client-id}}",
    "privateKey": "{{your-base64-pkcs8-private-key}}"
}
```

## Etapa 8: Conceder à função de serviço acesso ao certificado
<a name="kb-managed-sharepoint-entra-step8"></a>

Sua função de serviço da base de conhecimento deve ser capaz de ler o objeto certificado do Amazon S3. Adicione a seguinte declaração à política de permissões da função, substituindo o nome e a chave do bucket pelos seus valores.

```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "S3ListCertificateBucket",
            "Effect": "Allow",
            "Action": ["s3:ListBucket"],
            "Resource": ["arn:aws:s3:::{{your-certificate-bucket}}"],
            "Condition": {
                "StringEquals": { "aws:ResourceAccount": ["{{123456789012}}"] }
            }
        },
        {
            "Sid": "S3GetCertificate",
            "Effect": "Allow",
            "Action": ["s3:GetObject"],
            "Resource": [
                "arn:aws:s3:::{{your-certificate-bucket}}/{{certs/certificate.p12}}",
                "arn:aws:s3:::{{your-certificate-bucket}}/{{certs/certificate.p12}}.metadata.json"
            ],
            "Condition": {
                "StringEquals": { "aws:ResourceAccount": ["{{123456789012}}"] }
            }
        }
    ]
}
```

**nota**  
A política também permite acesso de leitura a um `.metadata.json` arquivo opcional junto com o certificado. O Amazon Bedrock não exige esse arquivo; incluir a permissão evita erros de acesso se houver um.

**Se o objeto certificado estiver criptografado com uma chave AWS KMS**

O comando de upload [Etapa 6: Faça o upload do certificado para o Amazon S3](#kb-managed-sharepoint-entra-step6) usa a S3-managed criptografia da Amazon (`AES256`), que não precisa de permissões adicionais. Se, em vez disso, você criptografar o objeto certificado com a criptografia do lado do servidor Amazon S3 usando uma chave KMS gerenciada pelo cliente SSE-KMS (), a função de serviço também `kms:Decrypt` precisará de permissão para essa chave, e a política da chave deve permitir que a função a use. Objetos criptografados com a `aws/s3` chave AWS gerenciada não exigem essa concessão adicional.

```
{
    "Sid": "KmsDecryptCertificate",
    "Effect": "Allow",
    "Action": ["kms:Decrypt"],
    "Resource": ["arn:aws:kms:{{us-west-2}}:{{123456789012}}:key/{{your-key-id}}"]
}
```

É necessário apenas o acesso de leitura`kms:Decrypt`. Para obter mais informações, consulte [Uso da criptografia do lado do servidor com chaves AWS KMS (). SSE-KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html)

Para obter o conjunto completo de permissões de função de serviço da base de conhecimento, consulte[Permissões para acessar as fontes de dados](kb-permissions.md#kb-permissions-access-ds).

## Próximas etapas
<a name="kb-managed-sharepoint-entra-next"></a>

Agora você tem tudo o que precisa para criar a fonte de dados: o ARN secreto, seu ID de inquilino e a localização do certificado no Amazon S3. Para criar a fonte de SharePoint dados com a Console de gerenciamento da AWS ou a API, consulte[Conectar uma fonte SharePoint de dados](kb-managed-ds-sharepoint-connect.md).

**Importante**  
Para `ENTRA_ID_APP_ONLY` autenticação, você deve fornecer `certificateS3Path` ao criar a fonte de dados, mesmo quando as ACLs estão desativadas. Uma fonte de SharePoint dados criada com esse tipo de autenticação e nenhum certificado falha.