Come usare le identità gestite con i servizi di Azure per connettersi ad Azure Cosmos DB per NoSQL

Articolo
10/01/2024

SI APPLICA A: NoSQL

Diagramma della posizione corrente ('Prepare') nella sequenza della guida alla distribuzione.

Questo articolo esamina i passaggi necessari per creare identità gestite da usare con un'applicazione implementata connessa ad Azure Cosmos DB for NoSQL.

Le identità gestite sono uno dei molti tipi di risorse per l’identità di Microsoft Entra ID per le app, da usare per la connessione ai servizi che supportano l'autenticazione di Microsoft Entra. Le identità gestite possono essere usate al posto delle credenziali tradizionali di proprietà delle risorse, ad esempio le chiavi. In Azure, le identità gestite consentono alle applicazioni di ottenere un token Microsoft Entra per l'autenticazione ai servizi di Azure senza dover scrivere una grande quantità di codice di autenticazione.

È possibile usare Microsoft Entra per eseguire l'autenticazione ai servizi di Azure, tra cui:

Azure SQL
Azure per intelligenza artificiale
Azure Cosmos DB
Archiviazione di Azure
Hub eventi di Azure
Registro Azure Container

È possibile usare le identità gestite per rappresentare l'entità di sicurezza che esegue l'autenticazione a un servizio di Azure da altri servizi di Azure, tra cui, ad esempio:

Servizio Azure Kubernetes
App contenitore di Azure
Macchine virtuali di Azure
Funzioni di Azure
Servizio app di Azure
Azure Spring Apps
Azure Service Fabric

Le identità gestite consentono più scenari sicuri in cui vari servizi di Azure possono connettersi tra loro. Alcuni esempi includono:

Creazione di un'identità gestita assegnata dal sistema per un'applicazione in Azure Spring Apps per connettersi ed eseguire query su un account Azure SQL
Uso di una singola identità gestita assegnata dall'utente con servizio Azure Kubernetes e Funzioni di Azure per inviare richieste a un account azure per intelligenza artificiale
Uso di un'identità gestita per un account Azure Cosmos DB per archiviare le chiavi in Azure Key Vault

Per altre informazioni, vedere Identità gestite per le risorse di Azure.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.

Usare l'ambiente Bash in Azure Cloud Shell. Per altre informazioni, vedere Avvio rapido su Bash in Azure Cloud Shell.
Se si preferisce eseguire i comandi di riferimento dell'interfaccia della riga di comando in locale, installare l'interfaccia della riga di comando di Azure. Per l'esecuzione in Windows o macOS, è consigliabile eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker. Per altre informazioni, vedere Come eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker.
- Se si usa un'installazione locale, accedere all'interfaccia della riga di comando di Azure con il comando az login. Per completare il processo di autenticazione, seguire la procedura visualizzata nel terminale. Per altre opzioni di accesso, vedere Accedere tramite l'interfaccia della riga di comando di Azure.
- Quando richiesto, al primo utilizzo installare l'estensione dell'interfaccia della riga di comando di Azure. Per altre informazioni sulle estensioni, vedere Usare le estensioni con l'interfaccia della riga di comando di Azure.
- Eseguire az version per trovare la versione e le librerie dipendenti installate. Per eseguire l'aggiornamento alla versione più recente, eseguire az upgrade.

Se si sceglie di usare Azure PowerShell in locale:
- Installare la versione più recente del modulo Az di PowerShell.
- Connettersi all'account Azure con il cmdlet Connect-AzAccount.
Se si sceglie di usare Azure Cloud Shell:
- Vedere Panoramica di Azure Cloud Shell per altre informazioni.

Creare un servizio Azure con un'identità gestita assegnata dal sistema

Creare un nuovo servizio Azure con un'identità gestita assegnata dal sistema. Questa sezione crea una risorsa Istanze di Azure Container.

Usare az container create per creare una nuova istanza di Container. Configurare l'account per l'uso di un'identità gestita assegnata dal sistema usando il parametro assign-identity.

az container create \
    --resource-group "<name-of-existing-resource-group>" \
    --name "<name-of-new-container>" \
    --image mcr.microsoft.com/dotnet/samples:aspnetapp-chiseled \
    --cpu 1 \
    --memory 2 \
    --assign-identity

Ottenere i dettagli per l'identità gestita assegnata dal sistema usando az container show e una query JMESPath.

az container show \
    --resource-group "<name-of-existing-resource-group>" \
    --name "<name-of-existing-container>" \
    --query "identity"

Esaminare l'output del comando. Deve includere gli identificatori univoci per l'identità e il tenant.

{
  "principalId": "aaaaaaaa-bbbb-cccc-1111-222222222222",
  "tenantId": "aaaabbbb-0000-cccc-1111-dddd2222eeee",
  "type": "SystemAssigned",
  "userAssignedIdentities": null
}

Creare un nuovo file Bicep per definire una nuova istanza di Container. Assegnare al file il nome container-instance.bicep. Impostare queste proprietà per l'istanza di Container:

	Valore
`name`	Usare un parametro denominato `instanceName`
`location`	Impostare sulla posizione del gruppo di risorse
`identity.type`	`SystemAssigned`
`properties.osType`	`Linux`
`properties.containers[0].name`	`aspnet-sample`
`properties.containers[0].properties.image`	`mcr.microsoft.com/dotnet/samples:aspnetapp-chiseled`
`properties.containers[0].properties.resources.requests.cpu`	`1`
`properties.containers[0].properties.resources.requests.memoryInGB`	`2`

metadata description = 'Create Azure Container Instance resource with system-assigned managed identity.'

@description('Name of the Azure Container Instances resource.')
param instanceName string

resource instance 'Microsoft.ContainerInstance/containerGroups@2023-05-01' = {
  name: instanceName
  location: resourceGroup().location
  identity: {
    type: 'SystemAssigned'
  }
  properties: {
    osType: 'Linux'
    containers: [
      {
        name: 'aspnet-sample'
        properties: {
          image: 'mcr.microsoft.com/dotnet/samples:aspnetapp-chiseled'
          resources: {
            requests: {
              cpu: 1
              memoryInGB: 2
            }
          }
        }
      }
    ]
  }
}

output systemAssignedIdentity object = instance.identity

Creare un nuovo file di parametri Bicep denominato container-instance.bicepparam. In questo file di parametri, creare un nome univoco per l'istanza di Container usando il parametro instanceName.
```
using './container-instance.bicep'

param instanceName = '<name-of-new-container-instance>'
```

Distribuire il modello Bicep usando az deployment group create. Specificare il nome del modello Bicep, del file dei parametri e del gruppo di risorse di Azure.

az deployment group create \
    --resource-group "<name-of-existing-resource-group>" \
    --parameters "container-instance.bicepparam" \
    --template-file "container-instance.bicep"

Esaminare l'output della distribuzione. L'output contiene l'oggetto identità dell'istanza di Container nella proprietà properties.outputs.systemAssignedIdentity.value.
```
{
  "principalId": "aaaaaaaa-bbbb-cccc-1111-222222222222",
  "tenantId": "aaaabbbb-0000-cccc-1111-dddd2222eeee",
  "type": "SystemAssigned"
}
```

Accedere al portale di Azure (https://portal.azure.com).
Immettere Istanze di Azure Container nella barra di ricerca globale.
In Servizi, selezionare Istanze di Container.
Nel riquadro Istanze di Container, selezionare Crea.

Nel riquadro Dati principali, configurare le opzioni seguenti e quindi selezionare Rivedi e crea:

	Valore
Abbonamento	Selezionare la sottoscrizione di Azure
Gruppo di risorse	Creare un nuovo gruppo di risorse o selezionarne uno esistente
Nome contenitore	Specificare un nome globalmente univoco
Area	Selezionare un'area di Azure supportata per la sottoscrizione

Screenshot del riquadro

Suggerimento

È possibile lasciare le opzioni non specificate sui loro valori predefiniti.

Nel riquadro Rivedi e crea attendere il completamento della convalida dell'account e quindi selezionare Crea.
Il portale si sposta automaticamente al riquadro Distribuzione. Attendere il completamento della distribuzione.
Al termine della distribuzione, selezionare Vai alla risorsa per spostarsi alla nuova risorsa Istanze di Azure Container.
Nel riquadro della nuova istanza di Container, selezionare Identità nella sezione Impostazioni del menu del servizio.
Nel riquadro Identità, abilitare l'identità gestita assegnata dal sistema impostando l'opzione Stato su Attivo. Quindi, selezionare Salva e risolvere eventuali richieste per eseguire il commit della modifica.
Quando l'identità gestita assegnata dal sistema è pronta, esaminare il valore della proprietà ID oggetto (principale). Il valore della proprietà è un identificatore univoco per l'identità.

Suggerimento

In questo screenshot di esempio, l'identificatore univoco per l'identità gestita assegnata dal sistema è bbbbbbbb-1111-2222-3333-cccccccccccc.

Creare un oggetto che rappresenta un contenitore usando New-AzContainerInstanceObject e archiviarlo in una variabile denominata $container. Usare quindi l'oggetto contenitore per creare una nuova istanza di Container con New-AzContainerGroup. Configurare l'account per l'uso di un'identità gestita assegnata dal sistema impostando il parametro IdentityType su SystemAssigned.

$parameters = @{
    Name = "aspnet-sample"
    Image = "mcr.microsoft.com/dotnet/samples:aspnetapp-chiseled"
    RequestCpu = 1 
    RequestMemoryInGb = 2
}
$container = New-AzContainerInstanceObject @parameters

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    Name = "<name-of-new-container>"
    Container = $container
    OsType = "Linux"
    Location = "<azure-region>"
    IdentityType = "SystemAssigned"
}
New-AzContainerGroup @parameters

Ottenere i dettagli per l'identità gestita assegnata dal sistema usando Get-AzContainerGroup e Format-List selezionando solo la proprietà Identity.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    Name = "<name-of-existing-container>"
}
Get-AzContainerGroup @parameters | Format-List Identity

Esaminare l'output del comando. Deve includere gli identificatori univoci per l'identità e il tenant.

Identity : {
             "principalId": "aaaaaaaa-bbbb-cccc-1111-222222222222",
             "tenantId": "aaaabbbb-0000-cccc-1111-dddd2222eeee",
             "type": "SystemAssigned"
           }

Creare un'identità gestita assegnata dall'utente

Creare un'identità gestita assegnata dall'utente che può essere usata con uno o più servizi di Azure in modo portabile.

Usare az identity create per creare una nuova identità gestita assegnata dall'utente nel gruppo di risorse di Azure.

az identity create \
    --resource-group "<name-of-existing-resource-group>" \
    --name "<name-of-new-managed-identity>"

Ottenere l'elenco delle identità gestite assegnate dall'utente nel gruppo di risorse usando az identity list
```
az identity list \
    --resource-group "<name-of-existing-resource-group>"    
```

Esaminare l'output del comando. Registrare il valore del campo id, in quanto questo identificatore di risorsa completo viene usato per assegnare l'identità gestita assegnata dall'utente alla risorsa di Azure.

{
  "clientId": "11112222-bbbb-3333-cccc-4444dddd5555",
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.ManagedIdentity/userAssignedIdentities/msdocs-identity-example-user-assigned",
  "location": "<azure-location>",
  "name": "msdocs-identity-example-user-assigned",
  "principalId": "cccccccc-dddd-eeee-3333-444444444444",
  "resourceGroup": "msdocs-identity-example",
  "systemData": null,
  "tags": {},
  "tenantId": "aaaabbbb-0000-cccc-1111-dddd2222eeee",
  "type": "Microsoft.ManagedIdentity/userAssignedIdentities"
}

Nota

Per questo esempio, il valore id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.ManagedIdentity/userAssignedIdentities/msdocs-identity-example-user-assigned. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio.

Creare un file Bicep per definire un'identità gestita assegnata dall'utente e denominare il file user-assigned-managed-identity.bicep. Impostare queste proprietà minime:

	Valore
`name`	Usare un parametro facoltativo denominato `identityName` e generare un valore predefinito univoco
`location`	Impostare sulla posizione del gruppo di risorse

metadata description = 'Create a user-assigned managed identity.'

param identityName string = uniqueString(subscription().id, resourceGroup().id)

resource identity 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: identityName
  location: resourceGroup().location
}

output id string = identity.id
output name string = identity.name

Distribuire il modello Bicep usando az deployment group create. Specificare il nome del modello Bicep e del gruppo di risorse di Azure.

az deployment group create \
    --resource-group "<name-of-existing-resource-group>" \
    --template-file "user-assigned-managed-identity.bicep"

Esaminare l'output della distribuzione. L'output contiene l'identificatore univoco dell'identità gestita nella proprietà properties.outputs.name.value. Registrare questo valore, sarà necessario usarlo quando si crea una nuova risorsa di Azure più avanti in questa guida.
```
{
  "type": "String",
  "value": "msdocs-identity-example-user-assigned"
}
```
Nota

In questo esempio, name.value sarà msdocs-identity-example-user-assigned. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio.

Immettere Identità gestitanella barra di ricerca globale.
In Servizi, selezionare Identità gestite.
Nel riquadro Istanze di Container, selezionare Crea.

Nel riquadro Dati principali, configurare le opzioni seguenti e quindi selezionare Rivedi e crea:

	Valore
Abbonamento	Selezionare la sottoscrizione di Azure
Gruppo di risorse	Creare un nuovo gruppo di risorse o selezionarne uno esistente
Area	Selezionare un'area di Azure supportata per la sottoscrizione
Nome	Specificare un nome globalmente univoco

Screenshot del riquadro

Nel riquadro Rivedi e crea attendere il completamento della convalida dell'account e quindi selezionare Crea.
Il portale si sposta automaticamente al riquadro Distribuzione. Attendere il completamento della distribuzione.
Attendere il completamento della distribuzione dell'identità gestita.

Creare una nuova identità gestita assegnata dall'utente usando New-AzUserAssignedIdentity nel gruppo di risorse di Azure.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    Name = "<name-of-new-managed-identity>"
    Location = "<azure-region>"
}
New-AzUserAssignedIdentity @parameters

Usare Get-AzUserAssignedIdentity per ottenere un elenco di identità gestite assegnate dall'utente nel gruppo di risorse.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
}
Get-AzUserAssignedIdentity @parameters | Format-List Name, Id

Esaminare l'output del comando. Registrare il valore del campo Id, in quanto questo identificatore di risorsa completo viene usato per assegnare l'identità gestita assegnata dall'utente alla risorsa di Azure.
```
Name : msdocs-identity-example-user-assigned
Id   : /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.ManagedIdentity/userAssignedIdentities/msdocs-identity-example-user-assigned
```
Nota

Per questo esempio, il valore Id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.ManagedIdentity/userAssignedIdentities/msdocs-identity-example-user-assigned. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio.

Creare un servizio di Azure mediante un'identità gestita assegnata dall'utente

Assegnare un'identità gestita assegnata dall'utente creata in precedenza a un nuovo servizio ospitato di Azure. Questa sezione crea una risorsa dell’app Web Servizi app di Azure.

Creare un nuovo piano di servizio app usando az appservice plan create.

az appservice plan create \
    --resource-group "<name-of-existing-resource-group>" \
    --name "<name-of-new-plan>"

Assegnare l'identità gestita assegnata dall'utente a una nuova app Web con az webapp create. Usare il campo id registrato in precedenza in questa guida come valore del parametro ssign-identity.

az webapp create \
    --resource-group "<name-of-existing-resource-group>" \
    --name "<name-of-existing-web-app>" \
    --plan "<name-of-existing-plan>" \
    --assign-identity "<resource-id-recorded-earlier>"

Ottenere i dettagli per tutte le identità assegnate a questo account usando az webapp show e una query JMESPath.

az webapp show \
    --resource-group "<name-of-existing-resource-group>" \
    --name "<name-of-existing-account>" \
    --query "identity"

Esaminare l'output del comando. Deve includere l'identità gestita assegnata dall'utente.

{
  "principalId": null,
  "tenantId": null,
  "type": "UserAssigned",
  "userAssignedIdentities": {
    "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.ManagedIdentity/userAssignedIdentities/msdocs-identity-example-user-assigned": {
      "clientId": "11112222-bbbb-3333-cccc-4444dddd5555",
      "principalId": "cccccccc-dddd-eeee-3333-444444444444"
    }
  }
}

Creare un altro file Bicep denominato app-service-web-app.bicep e definire un piano e un’app Web del Servizio app di Azure. Impostare queste proprietà per tali risorse:

	Conto risorse	Valore
`name`	Identità gestita esistente	Usare un parametro denominato `identityName`
`name`	Piano di servizio app	Usare un parametro denominato `planName`
`location`	Piano di servizio app	Impostare sulla posizione del gruppo di risorse
`name`	App Web	Usare un parametro denominato `webAppName`
`location`	App Web	Impostare sulla posizione del gruppo di risorse
`identity.type`	`UserAssigned`
`identity.userAssignedIdentities.{identity.id}`	`{}`
`properties.serverFarmId`	`plan.id`

metadata description = 'Creates an Azure App Service plan and web app with a user-assigned managed identity.'

@description('The name of the app service plan.')
param planName string

@description('The name of the web app.')
param webAppName string

@description('The name of the user-assigned managed identity.')
param identityName string

resource identity 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' existing = {
  name: identityName
}

resource plan 'Microsoft.Web/serverfarms@2023-12-01' = {
  name: planName
  location: resourceGroup().location
}

resource webApp 'Microsoft.Web/sites@2023-12-01' = {
  name: webAppName
  location: resourceGroup().location
  identity: {
    type: 'UserAssigned'
    userAssignedIdentities: {
      '${identity.id}': {}
    }
  }
  properties: {
    serverFarmId: plan.id
  }
}

output userAssignedIdentity object = webApp.identity

Creare un file di parametri Bicep denominato app-service-web-app.bicepparam. In questo file di parametri, creare un nome univoco per l'app Web e pianificare rispettivamente usando i parametri planName e webAppName. Specificare quindi il nome dell'identità gestita assegnata dall'utente come valore del parametro identityName.
```
using './app-service-web-app.bicep'

param planName = '<name-of-new-app-service-plan>'
param webAppName = '<name-of-new-web-app>'
param identityName = '<name-of-existing-managed-identity>'
```

Distribuire il modello Bicep usando az deployment group create. Specificare il nome del modello Bicep, del file dei parametri e del gruppo di risorse di Azure.

az deployment group create \
    --resource-group "<name-of-existing-resource-group>" \
    --parameters "app-service-web-app.bicepparam" \
    --template-file "app-service-web-app.bicep"

Esaminare l'output della distribuzione. L'output contiene l'oggetto identità dell'istanza di Container nella proprietà properties.outputs.userAssignedIdentity.value.

{
  "type": "UserAssigned",
  "userAssignedIdentities": {
    "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.ManagedIdentity/userAssignedIdentities/msdocs-identity-example-user-assigned": {
      "clientId": "11112222-bbbb-3333-cccc-4444dddd5555",
      "principalId": "cccccccc-dddd-eeee-3333-444444444444"
    }
  }
}

Immettere l’app Web nella barra di ricerca globale.
In Servizi, selezionare Servizi app.
Nel riquadro Servizi app, selezionare Crea e quindi App Web.

Nel riquadro Dati principali, configurare le opzioni seguenti e quindi selezionare Rivedi e crea:

	Valore
Abbonamento	Selezionare la sottoscrizione di Azure
Gruppo di risorse	Creare un nuovo gruppo di risorse o selezionarne uno esistente
Nome	Specificare un nome globalmente univoco
Piano	Creare un nuovo piano o selezionarne uno esistente

Screenshot del riquadro

Nel riquadro Rivedi e crea attendere il completamento della convalida dell'account e quindi selezionare Crea.
Il portale si sposta automaticamente al riquadro Distribuzione. Attendere il completamento della distribuzione.
Al termine della distribuzione, selezionare Vai alla risorsa per spostarsi alla nuova risorsa Istanze di Azure Container.
Nel riquadro della nuova istanza di Container, selezionare Identità nella sezione Impostazioni del menu del servizio.
Nel riquadro Identità, selezionare l'opzione Assegnata dall'utente.
Selezionare Aggiungi per aprire una finestra di dialogo per assegnare identità gestite assegnate dall'utente esistenti. Nella finestra di dialogo, selezionare l'identità gestita assegnata dall'utente esistente e quindi selezionare Aggiungi.
Esaminare infine l'elenco delle identità gestite assegnate dall'utente associate all'app Web. Deve includere il nome dell'identità, il nome del gruppo di risorse e l'identificatore della sottoscrizione.

Usare New-AzWebApp per creare una nuova app Web del Servizio app di Azure.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    Name = "<name-of-new-web-app>"
    Location = "<azure-region>"
}
New-AzWebApp @parameters

Applicare patch all'app Web appena creata per impostare la proprietà identity.type su UserAssigned e aggiungere l'identità gestita assegnata dall'utente esistente alla proprietà identity.userAssignedIdentities. Per eseguire questa attività, specificare prima di tutto il campo id registrato in precedenza in questa guida come valore della variabile identityId shell. Creare quindi un oggetto payload e convertirlo in JSON. Usare infine Invoke-AzRestMethod con il verbo HTTP PATCH per aggiornare l'app Web esistente.

$identityId = "<resource-id-recorded-earlier>"

$payload = @{
    identity = @{
        type = "UserAssigned"
        userAssignedIdentities = @{
            "$identityId" = @{}
        }
    }
} | ConvertTo-Json -Depth 3

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    Name = "<name-of-existing-web-app>"
    ResourceProviderName = 'Microsoft.Web'
    ResourceType = 'sites'
    ApiVersion = '2023-12-01'
    Method = 'PATCH'
    Payload = $payload
}
Invoke-AzRestMethod @parameters

Ottenere i dettagli per tutte le identità assegnate all'app Web usando Get-AzWebApp, Select-Object e ConvertTo-Json selezionando solo la proprietà Identity.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    Name = "<name-of-existing-web-app>"
}
Get-AzWebApp @parameters | Select-Object Identity | ConvertTo-Json -Depth 3

Esaminare l'output del comando. Deve includere gli identificatori univoci per l'identità e il tenant.

{
  "Identity": {
    "Type": "UserAssigned",
    "TenantId": null,
    "PrincipalId": null,
    "UserAssignedIdentities": {
      "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.ManagedIdentity/userAssignedIdentities/msdocs-identity-example-user-assigned": {
        "PrincipalId": "cccccccc-dddd-eeee-3333-444444444444",
        "ClientId": "11112222-bbbb-3333-cccc-4444dddd5555"
      }
    }
  }
}

Passaggio successivo

Disabilitare l'autenticazione basata su chiave con Azure Cosmos DB per NoSQL

Condividi tramite

Come usare le identità gestite con i servizi di Azure per connettersi ad Azure Cosmos DB per NoSQL

Prerequisiti

Creare un servizio Azure con un'identità gestita assegnata dal sistema

Creare un'identità gestita assegnata dall'utente

Creare un servizio di Azure mediante un'identità gestita assegnata dall'utente

Passaggio successivo

Commenti e suggerimenti

Risorse aggiuntive