Esercitazione: Creare una connessione senza password a un servizio di database tramite Service Connector

2025-04-30

Le connessioni senza password usano identità gestite per accedere ai servizi di Azure. Con questo approccio non è necessario tenere traccia e gestire manualmente i segreti per le identità gestite. Queste attività vengono gestite internamente da Azure.

Service Connector abilita le identità gestite nei servizi di hosting di app come Azure Spring Apps, servizio app Azure e app contenitore di Azure. Service Connector configura anche i servizi di database, ad esempio Database di Azure per PostgreSQL, Database di Azure per MySQL, database SQL di Azure e database SQL in Microsoft Fabric, per accettare identità gestite.

In questa esercitazione verrà usata l'interfaccia della riga di comando di Azure per completare le attività seguenti:

Controllare l'ambiente iniziale con l'interfaccia della riga di comando di Azure.
Creare una connessione senza password con Service Connector.
Usare le variabili di ambiente o le configurazioni generate da Service Connector per accedere a un servizio di database.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare gratuitamente un account Azure.
Un'app distribuita nel servizio app di Azure in un'area supportata da Service Connector.
Interfaccia della riga di comando di Azure versione 2.61.0 o successiva.

Per iniziare a usare l'interfaccia della riga di comando di Azure:

Usare l'ambiente Bash in Azure Cloud Shell. Per altre informazioni, vedere Introduzione ad Azure Cloud Shell.
Se preferisci eseguire i comandi di riferimento della CLI in locale, installa la CLI di Azure. Se si esegue 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 usando il comando az login . Per completare il processo di autenticazione, seguire i passaggi visualizzati nel terminale. Per altre opzioni di accesso, vedere Eseguire l'autenticazione ad Azure con l'interfaccia della riga di comando di Azure.
- Quando ti viene richiesto, installa l'estensione Azure CLI al primo utilizzo. Per altre informazioni sulle estensioni, vedere Usare e gestire 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.

Installare l'estensione senza password di Service Connector

Installare l'estensione senza password Connettore di servizi più recente per l'interfaccia della riga di comando di Azure:

az extension add --name serviceconnector-passwordless --upgrade

Nota

Verificare che la versione dell'estensione "serviceconnector-passwordless" sia "2.0.2" o successiva eseguendo az version. Potrebbe essere necessario aggiornare prima l'interfaccia della riga di comando di Azure per aggiornare la versione dell'estensione.

Creare una connessione senza password

Si userà quindi app Azure Servizio come esempio per creare una connessione usando l'identità gestita.

Se si usa:

App Spring di Azure: usare az spring connection create invece. Per altri esempi, vedere Connettere Azure Spring Apps al database di Azure.
App contenitore di Azure: usare az containerapp connection create invece. Per altri esempi, vedere Creare e connettere un database PostgreSQL con connettività di identità.

Nota

Se si utilizza il portale di Azure, passare al pannello Service Connector di Azure App Service, Azure Spring Apps o Azure Container Apps e selezionare Crea per creare una connessione. Il portale di Azure comporrà automaticamente il comando e attiverà l'esecuzione del comando in Cloud Shell.

Il comando seguente dell'interfaccia della riga di comando di Azure usa un --client-type parametro, può essere java, dotnet, python e così via. Eseguire az webapp connection create postgres-flexible -h per ottenere i tipi di client supportati e scegliere quello corrispondente all'applicazione.

az webapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $POSTGRESQL_HOST \
    --database $DATABASE_NAME \
    --user-identity client-id=XX subs-id=XX \
    --client-type $CLIENT_TYPE

az webapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $POSTGRESQL_HOST \
    --database $DATABASE_NAME \
    --system-identity \
    --client-type $CLIENT_TYPE

az webapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $POSTGRESQL_HOST \
    --database $DATABASE_NAME \
    --service-principal client-id=XX secret=XX\
    --client-type $CLIENT_TYPE

Database di Azure per MySQL : il server flessibile richiede un'identità gestita assegnata dall'utente per abilitare l'autenticazione di Microsoft Entra. Per altre informazioni, vedere Configurare l'autenticazione di Microsoft Entra per Database di Azure per MySQL - Server Flessibile. È possibile usare il comando seguente per creare un'identità gestita assegnata dall'utente:

USER_IDENTITY_NAME=<YOUR_USER_ASSIGNED_MANAGED_IDENTITY_NAME>
IDENTITY_RESOURCE_ID=$(az identity create \
    --name $USER_IDENTITY_NAME \
    --resource-group $RESOURCE_GROUP \
    --query id \
    --output tsv)

Importante

Dopo aver creato l'identità gestita assegnata dall'utente, chiedere all'amministratore globale o all'amministratore del ruolo con privilegi di concedere le autorizzazioni seguenti per questa identità:

User.Read.All
GroupMember.Read.All
Application.Read.All

Per ulteriori informazioni, vedere la sezione Permessi diautenticazione di Active Directory .

Connettere quindi l'app a un database MySQL con un'identità gestita assegnata dal sistema usando la funzionalità Connettore servizio.

Il comando seguente dell'interfaccia della riga di comando di Azure usa un parametro --client-type. az webapp connection create mysql-flexible -h Eseguire per ottenere i tipi di client supportati e scegliere quello che corrisponde all'applicazione.

az webapp connection create mysql-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $MYSQL_HOST \
    --database $DATABASE_NAME \
    --user-identity client-id=XX subs-id=XX mysql-identity-id=$IDENTITY_RESOURCE_ID \
    --client-type java

az webapp connection create mysql-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $MYSQL_HOST \
    --database $DATABASE_NAME \
    --system-identity mysql-identity-id=$IDENTITY_RESOURCE_ID \
    --client-type java

az webapp connection create mysql-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $MYSQL_HOST \
    --database $DATABASE_NAME \
    --service-principal client-id=XX secret=XX mysql-identity-id=$IDENTITY_RESOURCE_ID \
    --client-type java

Il comando seguente dell'interfaccia della riga di comando di Azure usa un parametro --client-type. az webapp connection create sql -h Eseguire per ottenere i tipi di client supportati e scegliere quello che corrisponde all'applicazione.

az webapp connection create sql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $SQL_HOST \
    --database $DATABASE_NAME \
    --user-identity client-id=XX subs-id=XX \
    --client-type dotnet

az webapp connection create sql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $SQL_HOST \
    --database $DATABASE_NAME \
    --system-identity \
    --client-type dotnet

az webapp connection create sql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $SQL_HOST \
    --database $DATABASE_NAME \
    --service-principal client-id=XX secret=XX \
    --client-type dotnet

Il comando seguente dell'interfaccia della riga di comando di Azure usa un parametro --client-type. az webapp connection create fabricsql -h Eseguire per ottenere i tipi di client supportati e scegliere quello che corrisponde all'applicazione.

Importante

La condivisione dell'accesso manuale è attualmente necessaria per il completamento dell'onboarding. Vedere Condividere l'accesso al database SQL in Fabric.

az webapp connection create fabricsql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --fabric-workspace-uuid $FABRIC_WORKSPACE_UUID \
    --fabric-sql-db-uuid $FABRIC_SQL_DB_UUID \
    --user-identity client-id=XX subs-id=XX \
    --client-type dotnet

az webapp connection create fabricsql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --fabric-workspace-uuid $FABRIC_WORKSPACE_UUID \
    --fabric-sql-db-uuid $FABRIC_SQL_DB_UUID \
    --system-identity \
    --client-type dotnet

Questo comando di Connettore servizio completa le attività seguenti in background:

Abilitare l'identità gestita assegnata dal sistema o assegnare un'identità utente per l'app $APPSERVICE_NAME ospitata da app Azure Servizio/App Spring di Azure/App Azure Container.
Abilitare Microsoft Entra Authentication per il server di database se non è abilitato in precedenza.
Impostare l'amministratore di Microsoft Entra sull'utente connesso corrente.
Aggiungere un utente del database per l'identità gestita assegnata dal sistema, l'identità gestita assegnata dall'utente o l'entità servizio. Concedere a questo utente tutti i privilegi del database $DATABASE_NAME. Il nome utente è disponibile nella stringa di connessione nell'output del comando precedente.
Impostare le configurazioni denominate AZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRINGAZURE_SQL_CONNECTIONSTRING, o FABRIC_SQL_CONNECTIONSTRING sulla risorsa di Azure in base al tipo di database.
- Per il servizio app, le configurazioni vengono impostate nel pannello Impostazioni app .
- Per Spring Apps, le configurazioni vengono impostate all'avvio dell'applicazione.
- Per App contenitore, le configurazioni vengono impostate sulle variabili di ambiente. È possibile ottenere tutte le configurazioni e i relativi valori nel pannello Service Connector nel portale di Azure.

Service Connector assegnerà i privilegi seguenti all'utente, è possibile revocarli e modificare i privilegi in base alle esigenze.

GRANT ALL PRIVILEGES ON DATABASE "$DATABASE_NAME" TO "username"; 

GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO "username"; 

GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO "username";


GRANT ALL PRIVILEGES ON $DATABASE_NAME.* TO 'username'@'%';

GRANT CONTROL ON DATABASE::"$DATABASE_NAME" TO "username";

ALTER ROLE db_datareader ADD MEMBER "username"
ALTER ROLE db_datawriter ADD MEMBER "username"
ALTER ROLE db_ddladmin ADD MEMBER "username"

Connettersi a un database con l'autenticazione di Microsoft Entra

Dopo aver creato la connessione, è possibile usare il stringa di connessione nell'applicazione per connettersi al database con l'autenticazione Microsoft Entra. Ad esempio, è possibile usare le soluzioni seguenti per connettersi al database con l'autenticazione di Microsoft Entra.

Per .NET non è disponibile un plug-in o una libreria per supportare connessioni senza password. È possibile ottenere un token di accesso per l'identità gestita o l'entità servizio utilizzando una libreria client come Azure.Identity. È quindi possibile usare il token di accesso come password per connettersi al database. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

using Azure.Identity;
using Azure.Core;
using Npgsql;

// Uncomment the following lines corresponding to the authentication type you want to use.
// For system-assigned identity.
// var sqlServerTokenProvider = new DefaultAzureCredential();

// For user-assigned identity.
// var sqlServerTokenProvider = new DefaultAzureCredential(
//     new DefaultAzureCredentialOptions
//     {
//         ManagedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_CLIENTID");
//     }
// );

// For service principal.
// var tenantId = Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_TENANTID");
// var clientId = Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_CLIENTID");
// var clientSecret = Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_CLIENTSECRET");
// var sqlServerTokenProvider = new ClientSecretCredential(tenantId, clientId, clientSecret);

// Acquire the access token. 
AccessToken accessToken = await sqlServerTokenProvider.GetTokenAsync(
    new TokenRequestContext(scopes: new string[]
    {
        "https://ossrdbms-aad.database.windows.net/.default"
    }));

// Combine the token with the connection string from the environment variables provided by Service Connector.
string connectionString =
    $"{Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_CONNECTIONSTRING")};Password={accessToken.Token}";

// Establish the connection.
using (var connection = new NpgsqlConnection(connectionString))
{
    Console.WriteLine("Opening connection using access token...");
    connection.Open();
}

Aggiungere le dipendenze seguenti nel file pom.xml :

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.7.5</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-extensions</artifactId>
    <version>1.2.0</version>
</dependency>

Ottenere la stringa di connessione dalle variabili di ambiente e aggiungere il nome del plug-in per connettersi al database:

import java.sql.*;

String url = System.getenv("AZURE_POSTGRESQL_CONNECTIONSTRING");
String pluginName = "com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin";  
Connection connection = DriverManager.getConnection(url + "&authenticationPluginClassName=" + pluginName);

Per ulteriori informazioni, vedi le seguenti risorse:

Per un'applicazione Spring, se si crea una connessione con l'opzione --client-type springboot, Service Connector imposta le proprietà spring.datasource.azure.passwordless-enabled, spring.datasource.url e spring.datasource.username su Azure Spring Apps.

Aggiornare l'applicazione seguendo l'esercitazione Associare un database di Azure per PostgreSQL all'applicazione in Azure Spring Apps. Ricordarsi di rimuovere la proprietà di configurazione spring.datasource.password se è stata impostata in precedenza e aggiungere le dipendenze corrette all'applicazione Spring.

Per altre esercitazioni, vedere Usare Spring Data JDBC con Database di Azure per PostgreSQL e Esercitazione: Distribuire un'applicazione Spring in Azure Spring Apps con una connessione senza password a un database di Azure.

Installare le dipendenze.

pip install azure-identity
pip install psycopg2-binary
pip freeze > requirements.txt # Save the dependencies to a file

Ottenere il token di accesso tramite la libreria azure-identitye usare il token come password. Ottenere informazioni di connessione dalle variabili di ambiente aggiunte da Connettore di servizi. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

from azure.identity import DefaultAzureCredential
import psycopg2

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned identity.
# cred = DefaultAzureCredential()

# For user-assigned identity.
# managed_identity_client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
# cred = ManagedIdentityCredential(client_id=managed_identity_client_id)   

# For service principal.
# tenant_id = os.getenv('AZURE_POSTGRESQL_TENANTID')
# client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
# client_secret = os.getenv('AZURE_POSTGRESQL_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

# Acquire the access token
accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')

# Combine the token with the connection string from the environment variables added by Service Connector to establish the connection.
conn_string = os.getenv('AZURE_POSTGRESQL_CONNECTIONSTRING')
conn = psycopg2.connect(conn_string + ' password=' + accessToken.token)

Installare le dipendenze.
```
pip install azure-identity
```

Ottenere il token di accesso tramite la libreria azure-identity usando le variabili di ambiente aggiunte da Connettore di servizi. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

from azure.identity import DefaultAzureCredential
import psycopg2

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned identity.
# credential = DefaultAzureCredential()

# For user-assigned identity.
# managed_identity_client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
# cred = ManagedIdentityCredential(client_id=managed_identity_client_id)    

# For service principal.
# tenant_id = os.getenv('AZURE_POSTGRESQL_TENANTID')
# client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
# client_secret = os.getenv('AZURE_POSTGRESQL_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

# Acquire the access token.
accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')

Nel file di impostazione, ottenere informazioni sul database PostgreSQL di Azure delle variabili di ambiente aggiunte dal servizio Connettore di servizi. Usare accessToken acquisito nel passaggio precedente per accedere al database.

# In your setting file, eg. settings.py
host = os.getenv('AZURE_POSTGRESQL_HOST')
user = os.getenv('AZURE_POSTGRESQL_USER')
password = accessToken.token # this is accessToken acquired from above step.
database = os.getenv('AZURE_POSTGRESQL_NAME')

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': database,
        'USER': user,
        'PASSWORD': password,
        'HOST': host,
        'PORT': '5432',  # Port is 5432 by default 
        'OPTIONS': {'sslmode': 'require'},
    }
}

Installare le dipendenze.

go get github.com/lib/pq
go get "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
go get "github.com/Azure/azure-sdk-for-go/sdk/azcore"

Nel codice, ottenere il token di accesso tramite azidentity, quindi usarlo come password per connettersi a PostgreSQL di Azure insieme alle informazioni di connessione fornite da Connettore di servizi. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

import (
"database/sql"
"fmt"
"os"

"context"

"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

 _ "github.com/lib/pq"
)    

// Uncomment the following lines corresponding to the authentication type you want to use.
// For system-assigned identity.
// cred, err := azidentity.NewDefaultAzureCredential(nil)

// For user-assigned identity.
// clientid := os.Getenv("AZURE_POSTGRESQL_CLIENTID")
// azidentity.ManagedIdentityCredentialOptions.ID := clientid
// options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
// cred, err := azidentity.NewManagedIdentityCredential(options)

// For service principal.
// clientid := os.Getenv("AZURE_POSTGRESQL_CLIENTID")
// tenantid := os.Getenv("AZURE_POSTGRESQL_TENANTID")
// clientsecret := os.Getenv("AZURE_POSTGRESQL_CLIENTSECRET")
// cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})

if err != nil {
    // error handling
}

// Acquire the access token
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
    Scopes: []string("https://ossrdbms-aad.database.windows.net/.default"),
})

// Combine the token with the connection string from the environment variables added by Service Connector to establish the connection.
connectionString := os.Getenv("AZURE_POSTGRESQL_CONNECTIONSTRING") + " password=" + token.Token

conn, err := sql.Open("postgres", connectionString)
 if err != nil {
 	panic(err)
 }

 conn.Close()

Installare le dipendenze.

npm install --save @azure/identity
npm install --save pg

Nel codice, ottenere il token di accesso tramite @azure/identity e le informazioni sulla connessione PostgreSQL dalle variabili di ambiente aggiunte dal servizio Connettore di servizi. Combinarli per stabilire la connessione. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

import { DefaultAzureCredential, ClientSecretCredential } from "@azure/identity";
import { Client } from 'pg';

// Uncomment the following lines corresponding to the authentication type you want to use.  
// For system-assigned identity.
// const credential = new DefaultAzureCredential();

// For user-assigned identity.
// const clientId = process.env.AZURE_POSTGRESQL_CLIENTID;
// const credential = new DefaultAzureCredential({
//     managedIdentityClientId: clientId
// });

// For service principal.
// const tenantId = process.env.AZURE_POSTGRESQL_TENANTID;
// const clientId = process.env.AZURE_POSTGRESQL_CLIENTID;
// const clientSecret = process.env.AZURE_POSTGRESQL_CLIENTSECRET;
// const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);

// Acquire the access token.
var accessToken = await credential.getToken('https://ossrdbms-aad.database.windows.net/.default');

// Use the token and the connection information from the environment variables added by Service Connector to establish the connection.
(async () => {
const client = new Client({
    host: process.env.AZURE_POSTGRESQL_HOST,
    user: process.env.AZURE_POSTGRESQL_USER,
    password: accesstoken.token,
    database: process.env.AZURE_POSTGRESQL_DATABASE,
    port: Number(process.env.AZURE_POSTGRESQL_PORT) ,
    ssl: process.env.AZURE_POSTGRESQL_SSL
});
await client.connect();

await client.end();
})();

Per PHP, non è disponibile un plug-in o una libreria per le connessioni senza password. È possibile ottenere un token di accesso per l'identità gestita o l'entità servizio e usarlo come password per connettersi al database. Il token di accesso può essere acquisito tramite l'API REST di Azure.

Nel codice, ottenere il token di accesso tramite l'API REST con la libreria preferita.

Per l'identità assegnata dall'utente e l'identità assegnata dal sistema, Servizio app e App contenitore forniscono un endpoint REST accessibile internamente in modo da recuperare i token per le identità gestite definendo due variabili di ambiente: IDENTITY_ENDPOINT e IDENTITY_HEADER. Per altre informazioni, vedere Informazioni di riferimento sull'endpoint REST. Ottenere il token di accesso effettuando una richiesta HTTP GET all'endpoint di identità e usare https://ossrdbms-aad.database.windows.net come resource nella query. Per l'identità assegnata dall'utente, includere anche l'ID client delle variabili di ambiente aggiunte da Connettore di servizi nella query.

Per l'entità servizio, fare riferimento alla richiesta di Azure AD per il token di accesso da servizio a servizio per visualizzare i dettagli su come acquisire il token di accesso. Effettuare la richiesta POST nell’ambito di https://ossrdbms-aad.database.windows.net/.default e con l'ID tenant, l'ID client e il segreto client dell'entità servizio delle variabili di ambiente aggiunte da Connettore di servizi.
Combinare il token di accesso e la stringa di connessione PostgreSQL dalle variabili di ambiente aggiunte dal servizio Service Connector per stabilire la connessione.
```
<?php
$conn_string = sprintf("%s password=", getenv('AZURE_POSTGRESQL_CONNECTIONSTRING'), $access_token);
$dbconn = pg_connect($conn_string);
?>
```

Per Ruby, non è disponibile un plug-in o una libreria per le connessioni senza password. È possibile ottenere un token di accesso per l'identità gestita o l'entità servizio e usarlo come password per connettersi al database. Il token di accesso può essere acquisito tramite l'API REST di Azure.

Installare le dipendenze.
```
gem install pg
```

Nel codice, ottenere il token di accesso tramite l’API REST e le informazioni sulla connessione PostgreSQL dalle variabili di ambiente aggiunte dal servizio Connettore di servizi. Combinarli per stabilire la connessione. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

Servizio app e App contenitore forniscono un endpoint REST accessibile internamente per recuperare i token per le identità gestite. Per altre informazioni, vedere Informazioni di riferimento sull'endpoint REST.

require 'pg'
require 'dotenv/load'
require 'net/http'
require 'json'

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned identity.
# uri = URI(ENV['IDENTITY_ENDPOINT'] + '?resource=https://ossrdbms-aad.database.windows.net&api-version=2019-08-01')
# res = Net::HTTP.get_response(uri, {'X-IDENTITY-HEADER' => ENV['IDENTITY_HEADER'], 'Metadata' => 'true'})  

# For user-assigned identity.
# uri = URI(ENV[IDENTITY_ENDPOINT] + '?resource=https://ossrdbms-aad.database.windows.net&api-version=2019-08-01&client_id=' + ENV['AZURE_POSTGRESQL_CLIENTID'])
# res = Net::HTTP.get_response(uri, {'X-IDENTITY-HEADER' => ENV['IDENTITY_HEADER'], 'Metadata' => 'true'})  

# For service principal
# uri = URI('https://login.microsoftonline.com/' + ENV['AZURE_POSTGRESQL_TENANTID'] + '/oauth2/v2.0/token')
# params = {
#     :grant_type => 'client_credentials',
#     :client_id: => ENV['AZURE_POSTGRESQL_CLIENTID'],
#     :client_secret => ENV['AZURE_POSTGRESQL_CLIENTSECRET'],
#     :scope => 'https://ossrdbms-aad.database.windows.net/.default'
# }
# req = Net::HTTP::POST.new(uri)
# req.set_form_data(params)
# req['Content-Type'] = 'application/x-www-form-urlencoded'
# res = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|
#   http.request(req)

parsed = JSON.parse(res.body)
access_token = parsed["access_token"]

# Use the token and the connection string from the environment variables added by Service Connector to establish the connection.
conn = PG::Connection.new(
    connection_string: ENV['AZURE_POSTGRESQL_CONNECTIONSTRING'] + " password="  + access_token,
)

Fare riferimento alla richiesta di token di accesso da servizio a servizio di Azure AD per vedere altri dettagli su come acquisire il token di accesso per il principale del servizio.

Successivamente, se si sono create tabelle e sequenze nel server flessibile PostgreSQL prima di usare Connettore di servizi, è necessario connettersi come proprietario e concedere l'autorizzazione alle <aad-username> create da Connettore di servizi. Il nome utente della stringa di connessione o della configurazione impostata da Connettore di servizi dovrebbe essere simile a aad_<connection name>. Se si usa il portale di Azure, selezionare il pulsante Espandi accanto alla colonna Service Type e ottenere il valore. Se si usa l'interfaccia della riga di comando di Azure, controllare configurations nell'output del comando dell'interfaccia della riga di comando.

Eseguire quindi la query per concedere l'autorizzazione

az extension add --name rdbms-connect

az postgres flexible-server execute -n <postgres-name> -u <owner-username> -p "<owner-password>" -d <database-name> --querytext "GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO \"<aad-username>\";GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO \"<aad username>\";"

<owner-username> e <owner-password> sono i proprietari della tabella esistente che può concedere autorizzazioni ad altri utenti. <aad-username> è l'utente creato da Connettore di servizi. Sostituirlo con il valore effettivo.

Convalidare il risultato tramite il comando:

az postgres flexible-server execute -n <postgres-name> -u <owner-username> -p "<owner-password>" -d <database-name> --querytext "SELECT distinct(table_name) FROM information_schema.table_privileges WHERE grantee='<aad-username>' AND table_schema='public';" --output table

using Azure.Core;
using Azure.Identity;
using MySqlConnector;

// Uncomment the following lines corresponding to the authentication type you want to use.
// For system-assigned managed identity.
// var credential = new DefaultAzureCredential();

// For user-assigned managed identity.
// var credential = new DefaultAzureCredential(
//     new DefaultAzureCredentialOptions
//     {
//         ManagedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_MYSQL_CLIENTID");
//     });

// For service principal.
// var tenantId = Environment.GetEnvironmentVariable("AZURE_MYSQL_TENANTID");
// var clientId = Environment.GetEnvironmentVariable("AZURE_MYSQL_CLIENTID");
// var clientSecret = Environment.GetEnvironmentVariable("AZURE_MYSQL_CLIENTSECRET");
// var credential = new ClientSecretCredential(tenantId, clientId, clientSecret);

var tokenRequestContext = new TokenRequestContext(
    new[] { "https://ossrdbms-aad.database.windows.net/.default" });
AccessToken accessToken = await credential.GetTokenAsync(tokenRequestContext);
// Open a connection to the MySQL server using the access token.
string connectionString =
    $"{Environment.GetEnvironmentVariable("AZURE_MYSQL_CONNECTIONSTRING")};Password={accessToken.Token}";

using var connection = new MySqlConnection(connectionString);
Console.WriteLine("Opening connection using access token...");
await connection.OpenAsync();

// do something

Aggiungere le dipendenze seguenti nel file pom.xml :

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-extensions</artifactId>
    <version>1.2.0</version>
</dependency>

Ottenere la stringa di connessione dalla variabile di ambiente e aggiungere il nome del plug-in per connettersi al database:

String url = System.getenv("AZURE_MYSQL_CONNECTIONSTRING");
String pluginName = "com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin";

Properties properties = new Properties();
properties.put("defaultAuthenticationPlugin", pluginName);
properties.put("authenticationPlugins", pluginName);

// Uncomment the following lines corresponding to the authentication type you want to use.

// for user-assigned managed identity
// String clientId = System.getenv('AZURE_MYSQL_CLIENTID')
// properties.put("azure.clientId", clientId);

// For service principal
// String tenantId = System.getenv('AZURE_MYSQL_TENANTID')
// String clientId = System.getenv('AZURE_MYSQL_CLIENTID')
// String clientSecret = System.getenv('AZURE_MYSQL_CLIENTSECRET')
// properties.put("azure.clientId", clientId);
// properties.put("azure.clientSecret", clientSecret);
// properties.put("azure.tenantId", tenantId);

Connection connection = DriverManager.getConnection(url, properties);

Per altre informazioni, vedere Usare Java e JDBC con il server flessibile di Database di Azure per MySQL.

Aggiorna l'applicazione seguendo l'esercitazione Connettere un'istanza di Database di Azure per MySQL all'applicazione in Azure Spring Apps. Ricordarsi di rimuovere la proprietà di configurazione spring.datasource.password se è stata impostata in precedenza e aggiungere le dipendenze corrette all'applicazione Spring.

Per altre esercitazioni, vedere Usare Spring Data JDBC con Database di Azure per MySQL

Installare le dipendenze

pip install azure-identity
# install Connector/Python https://dev.mysql.com/doc/connector-python/en/connector-python-installation.html
pip install mysql-connector-python

Eseguire l'autenticazione con il token di accesso tramite la libreria azure-identity e ottenere informazioni di connessione dalla variabile di ambiente aggiunta da Service Connector. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

from azure.identity import ManagedIdentityCredential, ClientSecretCredential
import mysql.connector
import os

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned managed identity.
# cred = ManagedIdentityCredential()    

# For user-assigned managed identity.
# managed_identity_client_id = os.getenv('AZURE_MYSQL_CLIENTID')
# cred = ManagedIdentityCredential(client_id=managed_identity_client_id)

# For service principal
# tenant_id = os.getenv('AZURE_MYSQL_TENANTID')
# client_id = os.getenv('AZURE_MYSQL_CLIENTID')
# client_secret = os.getenv('AZURE_MYSQL_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

# acquire token
accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')

# open connect to Azure MySQL with the access token.
host = os.getenv('AZURE_MYSQL_HOST')
database = os.getenv('AZURE_MYSQL_NAME')
user = os.getenv('AZURE_MYSQL_USER')
password = accessToken.token

cnx = mysql.connector.connect(user=user,
                              password=password,
                              host=host,
                              database=database)
cnx.close()

Installare le dipendenze.
```
pip install azure-identity
```

Ottenere il token di accesso tramite la libreria azure-identity con le variabili di ambiente aggiunte da Service Connector. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

from azure.identity import ManagedIdentityCredential, ClientSecretCredential
import os

# Uncomment the following lines corresponding to the authentication type you want to use.
# system-assigned managed identity
# cred = ManagedIdentityCredential()

# user-assigned managed identity
# managed_identity_client_id = os.getenv('AZURE_MYSQL_CLIENTID')
# cred = ManagedIdentityCredential(client_id=managed_identity_client_id)

# service principal
# tenant_id = os.getenv('AZURE_MYSQL_TENANTID')
# client_id = os.getenv('AZURE_MYSQL_CLIENTID')
# client_secret = os.getenv('AZURE_MYSQL_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

# acquire token
accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')

Nel file di impostazione ottenere informazioni sul database MySQL di Azure dalle variabili di ambiente aggiunte dal servizio Service Connector. Usare accessToken acquisito nel passaggio precedente per accedere al database.

# in your setting file, eg. settings.py
host = os.getenv('AZURE_MYSQL_HOST')
database = os.getenv('AZURE_MYSQL_NAME')
user = os.getenv('AZURE_MYSQL_USER')
password = accessToken.token # this is accessToken acquired from above step.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': database,
        'USER': user,
        'PASSWORD': password,
        'HOST': host
    }
}

Installare le dipendenze.

go get "github.com/go-sql-driver/mysql"
go get "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
go get "github.com/Azure/azure-sdk-for-go/sdk/azcore"

Nel codice ottenere il token di accesso tramite azidentity, quindi connettersi ad Azure MySQL con il token. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

import (
  "context"

  "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
  "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
  "github.com/go-sql-driver/mysql"
)


func main() {

  // Uncomment the following lines corresponding to the authentication type you want to use.
  // for system-assigned managed identity
  // cred, err := azidentity.NewDefaultAzureCredential(nil)

  // for user-assigned managed identity
  // clientid := os.Getenv("AZURE_MYSQL_CLIENTID")
  // azidentity.ManagedIdentityCredentialOptions.ID := clientid
  // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
  // cred, err := azidentity.NewManagedIdentityCredential(options)

  // for service principal
  // clientid := os.Getenv("AZURE_MYSQL_CLIENTID")
  // tenantid := os.Getenv("AZURE_MYSQL_TENANTID")
  // clientsecret := os.Getenv("AZURE_MYSQL_CLIENTSECRET")
  // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})

  if err != nil {
  }

  ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
  token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
    Scopes: []string("https://ossrdbms-aad.database.windows.net/.default"),
  })

  connectionString := os.Getenv("AZURE_MYSQL_CONNECTIONSTRING") + ";Password=" + token.Token
  db, err := sql.Open("mysql", connectionString)
}

Installare le dipendenze

npm install --save @azure/identity
npm install --save mysql2

Ottenere il token di accesso usando @azure/identity e le informazioni sul database MySQL di Azure dalle variabili di ambiente aggiunte dal servizio Service Connector. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";

const mysql = require('mysql2');

// Uncomment the following lines corresponding to the authentication type you want to use.
// for system-assigned managed identity
// const credential = new DefaultAzureCredential();

// for user-assigned managed identity
// const clientId = process.env.AZURE_MYSQL_CLIENTID;
// const credential = new DefaultAzureCredential({
//    managedIdentityClientId: clientId
// });

// for service principal
// const tenantId = process.env.AZURE_MYSQL_TENANTID;
// const clientId = process.env.AZURE_MYSQL_CLIENTID;
// const clientSecret = process.env.AZURE_MYSQL_CLIENTSECRET;
// const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);

// acquire token
var accessToken = await credential.getToken('https://ossrdbms-aad.database.windows.net/.default');

const connection = mysql.createConnection({
  host: process.env.AZURE_MYSQL_HOST,
  user: process.env.AZURE_MYSQL_USER,
  password: accessToken.token,
  database: process.env.AZURE_MYSQL_DATABASE,
  port: process.env.AZURE_MYSQL_PORT,
  ssl: process.env.AZURE_MYSQL_SSL
});

connection.connect((err) => {
  if (err) {
    console.error('Error connecting to MySQL database: ' + err.stack);
    return;
  }
  console.log('Connected to MySQL database');
});

Per altri esempi di codice, vedere Connettersi ai database di Azure dal servizio app senza segreti usando un'identità gestita.

Installare le dipendenze.

dotnet add package Microsoft.Data.SqlClient

Ottenere la stringa di connessione del database SQL di Azure dalla variabile di ambiente aggiunta dal connettore di servizi.
```
using Microsoft.Data.SqlClient;

string connectionString = 
    Environment.GetEnvironmentVariable("AZURE_SQL_CONNECTIONSTRING")!;

using var connection = new SqlConnection(connectionString);
connection.Open();
```
Per altre informazioni, vedere Uso dell'autenticazione dell'identità gestita di Active Directory.

Aggiungere le dipendenze seguenti nel file pom.xml :

<dependency>
    <groupId>com.microsoft.sqlserver</groupId>
    <artifactId>mssql-jdbc</artifactId>
    <version>10.2.0.jre11</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.7.0</version>
</dependency>

Ottenere la stringa di connessione del database SQL di Azure dalla variabile di ambiente aggiunta dal connettore di servizi.

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import com.microsoft.sqlserver.jdbc.SQLServerDataSource;

public class Main {
    public static void main(String[] args) {
        // AZURE_SQL_CONNECTIONSTRING should be one of the following:
        // For system-assigned managed identity: "jdbc:sqlserver://{SQLName}.database.windows.net:1433;databaseName={SQLDbName};authentication=ActiveDirectoryMSI;"
        // For user-assigned managed identity: "jdbc:sqlserver://{SQLName}.database.windows.net:1433;databaseName={SQLDbName};msiClientId={UserAssignedMiClientId};authentication=ActiveDirectoryMSI;"
        // For service principal: "jdbc:sqlserver://{SQLName}.database.windows.net:1433;databaseName={SQLDbName};user={ServicePrincipalClientId};password={spSecret};authentication=ActiveDirectoryServicePrincipal;"
        String connectionString = System.getenv("AZURE_SQL_CONNECTIONSTRING");
        SQLServerDataSource ds = new SQLServerDataSource();
        ds.setURL(connectionString);
        try (Connection connection = ds.getConnection()) {
            System.out.println("Connected successfully.");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Per altre informazioni, vedere Connettersi ai database di Azure dal servizio app senza segreti usando un'identità gestita.

Per un'applicazione Spring, se si crea una connessione con l'opzione --client-type springboot, il connettore di servizi imposta le proprietà spring.datasource.url con il formato valore jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; su Azure Spring Apps.

Aggiornare l'applicazione seguendo l'esercitazione Eseguire la migrazione di un'applicazione Java per usare connessioni senza password con il database SQL di Azure. Ricordarsi di rimuovere la proprietà di configurazione spring.datasource.password se è stata impostata in precedenza e aggiungere le dipendenze corrette.

Installare le dipendenze.
```
python -m pip install pyodbc
```

Ottenere le configurazioni di connessione del database SQL di Azure dalla variabile di ambiente aggiunta dal connettore di servizi. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare. Se si usano app Azure Container come servizio di calcolo o la stringa di connessione nel frammento di codice non funziona, vedere Eseguire la migrazione di un'applicazione Python per usare connessioni senza password con il database SQL di Azure per connettersi al database SQL di Azure usando un token di accesso.

import os
import pyodbc

server = os.getenv('AZURE_SQL_SERVER')
port = os.getenv('AZURE_SQL_PORT')
database = os.getenv('AZURE_SQL_DATABASE')
authentication = os.getenv('AZURE_SQL_AUTHENTICATION')

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned managed identity.
# connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server=tcp:{server},{port};Database={database};Authentication={authentication};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

# For user-assigned managed identity.
# clientID = os.getenv('AZURE_SQL_USER')
# connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server=tcp:{server},{port};Database={database};UID={clientID};Authentication={authentication};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

# For service principal.
# user = os.getenv('AZURE_SQL_USER')
# password = os.getenv('AZURE_SQL_PASSWORD')
# connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server=tcp:{server},{port};Database={database};UID={user};PWD={password};Authentication={authentication};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

conn = pyodbc.connect(connString)

Installare le dipendenze.
```
npm install mssql
```

Ottenere le configurazioni di connessione del database SQL di Azure dalle variabili di ambiente aggiunte dal connettore di servizi. Quando si usa il codice seguente, rimuovere il commento dalla parte del frammento di codice per il tipo di autenticazione che si vuole usare.

import sql from 'mssql';

const server = process.env.AZURE_SQL_SERVER;
const database = process.env.AZURE_SQL_DATABASE;
const port = parseInt(process.env.AZURE_SQL_PORT);
const authenticationType = process.env.AZURE_SQL_AUTHENTICATIONTYPE;

// Uncomment the following lines corresponding to the authentication type you want to use.
// For system-assigned managed identity.
// const config = {
//     server,
//     port,
//     database,
//     authentication: {
//         type: authenticationType
//     },
//     options: {
//        encrypt: true
//     }
// };  

// For user-assigned managed identity.
// const clientId = process.env.AZURE_SQL_CLIENTID;
// const config = {
//     server,
//     port,
//     database,
//     authentication: {
//         type: authenticationType
//     },
//     options: {
//         encrypt: true,
//         clientId: clientId
//     }
// };  

// For service principal.
// const clientId = process.env.AZURE_SQL_CLIENTID;
// const clientSecret = process.env.AZURE_SQL_CLIENTSECRET;
// const tenantId = process.env.AZURE_SQL_TENANTID;
// const config = {
//     server,
//     port,
//     database,
//     authentication: {
//         type: authenticationType
//     },
//     options: {
//         encrypt: true,
//         clientId: clientId,
//         clientSecret: clientSecret,
//         tenantId: tenantId
//     }
// };  

this.poolconnection = await sql.connect(config);

Per altre informazioni, vedere Pagina principale della programmazione client per Microsoft SQL Server.

Installare le dipendenze.

dotnet add package Microsoft.Data.SqlClient

Recuperare il database SQL nella stringa di connessione di Microsoft Fabric dalla variabile di ambiente aggiunta da Service Connector.
```
using Microsoft.Data.SqlClient;

string connectionString = 
    Environment.GetEnvironmentVariable("FABRIC_SQL_CONNECTIONSTRING")!;

using var connection = new SqlConnection(connectionString);
connection.Open();
```
Per altre informazioni, vedere Uso dell'autenticazione dell'identità gestita di Active Directory.

Aggiungere le dipendenze seguenti nel file pom.xml :

<dependency>
    <groupId>com.microsoft.sqlserver</groupId>
    <artifactId>mssql-jdbc</artifactId>
    <version>10.2.0.jre11</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.7.0</version>
</dependency>

Recuperare il database SQL nella stringa di connessione di Microsoft Fabric dalla variabile di ambiente aggiunta da Service Connector.

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import com.microsoft.sqlserver.jdbc.SQLServerDataSource;

public class Main {
    public static void main(String[] args) {
        // FABRIC_SQL_CONNECTIONSTRING should be one of the following:
        // For system-assigned managed identity: "jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI;"
        // For user-assigned managed identity: "jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;msiClientId=<msiClientId>;authentication=ActiveDirectoryMSI;"
        String connectionString = System.getenv("FABRIC_SQL_CONNECTIONSTRING");
        SQLServerDataSource ds = new SQLServerDataSource();
        ds.setURL(connectionString);
        try (Connection connection = ds.getConnection()) {
            System.out.println("Connected successfully.");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Per altre informazioni, vedere Connettersi ai database di Azure dal servizio app senza segreti usando un'identità gestita.

Per un'applicazione Spring, se si crea una connessione con l'opzione --client-type springboot, Service Connector imposta la variabile di ambiente FABRIC_SQL_CONNECTIONSTRING con il valore formattato jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI; su Azure Spring Apps.

Per le identità gestite assegnate dall'utente, msiClientId=<msiClientId>; viene aggiunto .

Aggiornare l'applicazione seguendo l'esercitazione Eseguire la migrazione di un'applicazione Java per usare connessioni senza password con il database SQL di Azure. Ricordarsi di rimuovere la spring.datasource.password proprietà di configurazione se è stata impostata in precedenza e aggiungere le dipendenze corrette.

spring:
  datasource:
    url: ${FABRIC_SQL_CONNECTIONSTRING}

Installare le dipendenze.
```
python -m pip install pyodbc
```
Recuperare il database SQL nella stringa di connessione di Microsoft Fabric dalla variabile di ambiente aggiunta da Service Connector. Se si usano app Azure Container come servizio di calcolo o la stringa di connessione nel frammento di codice non funziona, vedere Eseguire la migrazione di un'applicazione Python per usare connessioni senza password con il database SQL di Azure per connettersi al database SQL in Microsoft Fabric usando credenziali senza password. Authentication=ActiveDirectoryMSI; è obbligatorio nella stringa di connessione durante la connessione tramite identità gestite. UID=<msiClientId> è necessario anche nella stringa di connessione quando ci si connette usando un'identità gestita assegnata dall'utente.
```
import os
import pyodbc, struct
from azure.identity import DefaultAzureCredential

connStr = os.getenv('FABRIC_SQL_CONNECTIONSTRING')

# System-assigned managed identity connection string format
# `Driver={ODBC Driver 17 for SQL Server};Server=tcp:<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;Database=<SQL-DB-name>-<Fabric-DB-Identifier>;Authentication=ActiveDirectoryMSI;`

# User-assigned managed identity connection string format
# `Driver={ODBC Driver 17 for SQL Server};Server=tcp:<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;Database=<SQL-DB-name>-<Fabric-DB-Identifier>;UID=<msiClientId>;Authentication=ActiveDirectoryMSI;`

conn = pyodbc.connect(connString)
```

Installare le dipendenze.

go mod init <YourProjectName>
go mod tidy

Recuperare il database SQL nella stringa di connessione di Microsoft Fabric dalla variabile di ambiente aggiunta da Service Connector.

package main

import (
    "github.com/microsoft/go-mssqldb/azuread"
    "database/sql"
    "context"
    "log"
    "fmt"
    "os"
)

var db *sql.DB

var connectionString = os.Getenv("FABRIC_SQL_CONNECTIONSTRING")

func main() {
    var err error

    // Create connection pool
    db, err = sql.Open(azuread.DriverName, connectionString)
    if err != nil {
        log.Fatal("Error creating connection pool: ", err.Error())
    }
    ctx := context.Background()
    err = db.PingContext(ctx)
    if err != nil {
        log.Fatal(err.Error())
    }
    fmt.Printf("Connected!\n")
}

Per altre informazioni, vedere Usare Golang per eseguire query su un database nel database SQL di Azure.

Per altre informazioni, vedere Connettersi al database SQL in Microsoft Fabric.

Distribuire l'applicazione in un servizio di hosting di Azure

Distribuire l'applicazione in un servizio di hosting di Azure. Facoltativamente, vedere le guide seguenti per altre informazioni sulla distribuzione di queste risorse.
- Servizio app di Azure : Guida introduttiva: Distribuire un'app Web ASP.NET.
- App Azure Container: Guida introduttiva: Distribuire la prima app contenitore.
- App Azure Spring: compilare e distribuire l'app.
  
  Nota
  
  I piani Basic, Standard ed Enterprise sono entrati in un periodo di ritiro il 17 marzo 2025. Per altre informazioni, vedere l'annuncio di ritiro di Azure Spring Apps.
  
  Il piano Standard a consumo e dedicato è entrato in fase di dismissione il 30 settembre 2024, con un arresto completo entro la fine di marzo 2025. Per altre informazioni, vedere Eseguire la migrazione del consumo di Azure Spring Apps Standard e del piano dedicato alle app Azure Container.
Controllare il log o chiamare l'applicazione per verificare se è in grado di connettersi correttamente al database di Azure.

Risoluzione dei problemi

Autorizzazioni

Se si verificano errori correlati alle autorizzazioni, verificare che l'utente connesso all'interfaccia della riga di comando di Azure con il comando az account show. Assicurarsi di accedere con l'account corretto. Verificare quindi di avere le autorizzazioni seguenti che potrebbero essere necessarie per creare una connessione senza password con Service Connector.

Autorizzazione	Operazione
`Microsoft.DBforPostgreSQL/flexibleServers/read`	Obbligatorio per ottenere informazioni sul server di database
`Microsoft.DBforPostgreSQL/flexibleServers/write`	Obbligatorio per abilitare l'autenticazione di Microsoft Entra per il server di database
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write`	Obbligatorio per creare una regola del firewall nel caso in cui l'indirizzo IP locale sia bloccato
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete`	Obbligatorio per ripristinare la regola del firewall creata da Service Connector per evitare problemi di sicurezza
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/read`	Obbligatorio per verificare se l'utente di accesso dell'interfaccia della riga di comando di Azure è un amministratore di Microsoft Entra
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/write`	Obbligatorio per aggiungere l'utente di accesso dell'interfaccia della riga di comando di Azure come amministratore di Microsoft Entra del server di database

Autorizzazione	Operazione
`Microsoft.DBforMySQL/flexibleServers/read`	Obbligatorio per ottenere informazioni sul server di database
`Microsoft.DBforMySQL/flexibleServers/write`	Obbligatorio per aggiungere l'identità gestita assegnata dall'utente al server di database
`Microsoft.DBforMySQL/flexibleServers/firewallRules/write`	Obbligatorio per creare una regola del firewall nel caso in cui l'indirizzo IP locale sia bloccato
`Microsoft.DBforMySQL/flexibleServers/firewallRules/delete`	Obbligatorio per ripristinare la regola del firewall creata da Service Connector per evitare problemi di sicurezza
`Microsoft.DBforMySQL/flexibleServers/administrators/read`	Obbligatorio per verificare se l'utente di accesso dell'interfaccia della riga di comando di Azure è un amministratore di Microsoft Entra
`Microsoft.DBforMySQL/flexibleServers/administrators/write`	Obbligatorio per aggiungere l'utente di accesso dell'interfaccia della riga di comando di Azure come amministratore di Microsoft Entra del server di database

Autorizzazione	Operazione
`Microsoft.Sql/servers/read`	Obbligatorio per ottenere informazioni sul server di database
`Microsoft.Sql/servers/firewallRules/write`	Obbligatorio per creare una regola del firewall nel caso in cui l'indirizzo IP locale sia bloccato
`Microsoft.Sql/servers/firewallRules/delete`	Obbligatorio per ripristinare la regola del firewall creata da Service Connector per evitare problemi di sicurezza
`Microsoft.Sql/servers/administrators/read`	Obbligatorio per verificare se l'utente di accesso dell'interfaccia della riga di comando di Azure è un amministratore di Microsoft Entra
`Microsoft.Sql/servers/administrators/write`	Obbligatorio per aggiungere l'utente di accesso dell'interfaccia della riga di comando di Azure come amministratore di Microsoft Entra del server di database

In alcuni casi, le autorizzazioni non sono necessarie. Ad esempio, se l'utente autenticato dall'interfaccia della riga di comando di Azure è già un amministratore di Active Directory in SQL Server, non è necessario disporre dell'autorizzazione Microsoft.Sql/servers/administrators/write .

Microsoft Entra ID

Se viene visualizzato un errore ERROR: AADSTS530003: Your device is required to be managed to access this resource., chiedere al reparto IT di assistenza per l'aggiunta di questo dispositivo all'ID Microsoft Entra. Per altre informazioni, vedere Dispositivi aggiunti a Microsoft Entra.

Service Connector deve accedere all'ID Microsoft Entra per ottenere informazioni sull'account e sull'identità gestita del servizio di hosting. È possibile usare il comando seguente per verificare se il dispositivo può accedere all'ID Microsoft Entra:

az ad signed-in-user show

Se non si esegue l'accesso in modo interattivo, è anche possibile che venga visualizzato l'errore e Interactive authentication is needed. Per risolvere l'errore, accedere con il az login comando .

Connettività di rete

Se il server di database si trova in Rete virtuale, assicurarsi che l'ambiente che esegue il comando dell'interfaccia della riga di comando di Azure possa accedere al server nel Rete virtuale.

Se il server di database non consente l'accesso pubblico, assicurarsi che l'ambiente che esegue il comando dell'interfaccia della riga di comando di Azure possa accedere al server tramite l'endpoint privato.

Passaggi successivi

Per altre informazioni su Service Connector e connessioni senza password, vedere le risorse seguenti:

Documentazione di Service Connector

Connessioni senza password per i servizi di Azure

Condividi tramite

Esercitazione: Creare una connessione senza password a un servizio di database tramite Service Connector

Prerequisiti

Installare l'estensione senza password di Service Connector

Creare una connessione senza password

Connettersi a un database con l'autenticazione di Microsoft Entra

Distribuire l'applicazione in un servizio di hosting di Azure

Risoluzione dei problemi

Autorizzazioni

Microsoft Entra ID

Connettività di rete

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive