Tutoriel : Créer une connexion sans mot de passe à un service de base de données par le biais de Service Connector

Les connexions sans mot de passe utilisent des identités managées pour accéder aux services Azure. Avec cette approche, vous n’avez pas besoin de suivre et de gérer manuellement les secrets pour les identités managées. Ces tâches sont gérées de manière sécurisée en interne par Azure.

Service Connector active les identités managées dans les services d’hébergement d’applications comme Azure Spring Apps, Azure App Service et Azure Container Apps. Service Connector configure également les services de base de données, tels qu’Azure Database pour PostgreSQL, Azure Database pour MySQL, Azure SQL Database et SQL Database dans Microsoft Fabric, afin d’accepter des identités managées.

Ce tutoriel explique comment utiliser Azure CLI pour effectuer les tâches suivantes :

Vérifier votre environnement initial avec Azure CLI.
Créer une connexion sans mot de passe avec Service Connector.
Utiliser les variables d’environnement ou les configurations générées par Service Connector pour accéder à un service de base de données.

Prérequis

Compte Azure avec un abonnement actif. Créez gratuitement un compte Azure.
Une application déployée dans Azure App Service dans une région prise en charge par Service Connector.
Azure CLI version 2.61.0 ou ultérieure.

Pour commencer à utiliser Azure CLI :

Utilisez l’environnement Bash dans Azure Cloud Shell. Pour obtenir plus d’informations, consultez Démarrage d’Azure Cloud Shell.
Si vous préférez exécuter des commandes de référence CLI localement, installez Azure CLI. Si vous exécutez sur Windows ou macOS, envisagez d’exécuter Azure CLI dans un conteneur Docker. Pour plus d’informations, consultez Guide pratique pour exécuter Azure CLI dans un conteneur Docker.
- Si vous utilisez une installation locale, connectez-vous à Azure CLI à l’aide de la commande az login. Pour terminer le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour obtenir d’autres options de connexion, consultez S’authentifier auprès d’Azure à l’aide d’Azure CLI.
- Lorsque vous y êtes invité, installez l’extension Azure CLI lors de la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser et gérer des extensions avec Azure CLI.
- Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutez az upgrade.

Installer l’extension sans mot de passe Service Connector

Installez l’extension sans mot de passe Connecteur de services pour Azure CLI la plus récente :

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

Remarque

Vérifiez que la version de l’extension « serviceconnector-passwordless » est « 2.0.2 » ou ultérieure en exécutant az version. Vous serez peut-être amené d’abord à mettre à niveau Azure CLI pour mettre à niveau la version de l’extension.

Créer une connexion sans mot de passe

Ensuite, nous utilisons Azure App Service comme exemple pour créer une connexion à l’aide d’une identité managée.

Si vous utilisez :

Azure Spring Apps : utilisez plutôt az spring connection create. Pour plus d’exemples, consultez la section Connecter Azure Spring Apps à la base de données Azure.
Azure Container Apps : utilisez plutôt az containerapp connection create. Pour plus d’exemples, consultez la section Créer et connecter une base de données PostgreSQL avec une connectivité d’identité.

Remarque

Si vous utilisez le portail Azure, accédez au panneau Service Connector d’Azure App Service, Azure Spring Apps ou Azure Container Apps, puis sélectionnez Créer pour créer une connexion. Le portail Azure compose automatiquement la commande à votre place et déclenche l’exécution de la commande sur Cloud Shell.

La commande Azure CLI suivante utilise un paramètre --client-type, il peut s’agir de java, de dotnet, de python, etc. Exécutez le az webapp connection create postgres-flexible -h pour obtenir les types de clients pris en charge, puis choisissez celui qui correspond à votre application.

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

Azure Database pour MySQL : un serveur flexible nécessite une identité managée affectée par l’utilisateur pour activer l’authentification Microsoft Entra. Pour plus d’informations, consultez Configurer l’authentification Microsoft Entra pour Azure Database pour MySQL : Serveur flexible. Vous pouvez utiliser la commande suivante pour créer une identité managée affectée par l’utilisateur :

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)

Important

Après avoir créé l’identité managée affectée par l'utilisateur, demandez à votre administrateur général ou à votre administrateur de rôle privilégié d’accorder les autorisations suivantes pour cette identité :

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

Pour plus d’informations, consultez la section Autorisations d’Authentification Active Directory.

Ensuite, connectez votre application à une base de données MySQL avec une identité managée affectée par le système à l’aide de Service Connector.

La commande Azure CLI suivante utilise un paramètre --client-type. Exécutez az webapp connection create mysql-flexible -h pour obtenir les types de clients pris en charge, puis choisissez celui qui correspond à votre application.

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

La commande Azure CLI suivante utilise un paramètre --client-type. Exécutez az webapp connection create sql -h pour obtenir les types de clients pris en charge, puis choisissez celui qui correspond à votre application.

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

La commande Azure CLI suivante utilise un paramètre --client-type. Exécutez az webapp connection create fabricsql -h pour obtenir les types de clients pris en charge, puis choisissez celui qui correspond à votre application.

Important

Le partage d’accès manuel est actuellement nécessaire pour l’intégration complète. Consultez Partager l’accès à la base de données SQL dans 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

Cette commande Service Connector effectue les tâches suivantes en arrière-plan :

Activez l’identité managée affectée par le système ou affectez une identité utilisateur pour l’application $APPSERVICE_NAME hébergée par Azure App Service/Azure Spring Apps/Azure Container Apps.
Activez l’authentification Microsoft Entra pour le serveur de base de données si elle n’a pas été activée auparavant.
Définissez l’administrateur Microsoft Entra sur l’utilisateur connecté actuel.
Ajoutez un utilisateur de base de données pour l’identité managée affectée par le système, l’identité managée affectée par l’utilisateur ou le principal de service. Accordez tous les privilèges de la base de données $DATABASE_NAME à cet utilisateur. Le nom d’utilisateur se trouve dans la chaîne de connexion dans la sortie de commande précédente.
Définissez les configurations nommées AZURE_MYSQL_CONNECTIONSTRING, , AZURE_POSTGRESQL_CONNECTIONSTRINGAZURE_SQL_CONNECTIONSTRINGou FABRIC_SQL_CONNECTIONSTRING sur la ressource Azure en fonction du type de base de données.
- Pour App Service, les configurations sont définies dans le panneau Paramètres de l’application.
- Pour Spring Apps, les configurations sont définies lors du lancement de l’application.
- Pour Container Apps, les configurations sont définies sur les variables d’environnement. Vous pouvez obtenir toutes les configurations et leurs valeurs dans le panneau Service Connector du portail Azure.

Le connecteur de services affecte les privilèges suivants à l’utilisateur, vous pouvez les révoquer et ajuster les privilèges en fonction de vos besoins.

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"

Se connecter à une base de données avec l’authentification Microsoft Entra

Après avoir créé la connexion, vous pouvez utiliser la chaîne de connexion dans votre application pour vous connecter à la base de données avec l’authentification Microsoft Entra. Par exemple, vous pouvez utiliser les solutions suivantes pour vous connecter à la base de données avec l’authentification Microsoft Entra.

Pour .NET, il n’existe pas de plug-in ou de bibliothèque pour prendre en charge les connexions sans mot de passe. Vous pouvez obtenir un jeton d’accès pour l’identité managée ou le principal de service à l’aide d’une bibliothèque cliente telle que Azure.Identity. Vous pouvez ensuite utiliser le jeton d’accès comme mot de passe pour vous connecter à la base de données. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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();
}

Ajoutez les dépendances suivantes dans votre fichier 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>

Obtenez la chaîne de connexion à partir des variables d’environnement et ajoutez le nom du plug-in pour vous connecter à la base de données :

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);

Pour plus d’informations, consultez les ressources suivantes :

Pour une application Spring, si vous créez une connexion avec l’option --client-type springboot, Service Connector définit les propriétés spring.datasource.azure.passwordless-enabled, spring.datasource.url et spring.datasource.username sur Azure Spring Apps.

Mettez à jour votre application en suivant le tutoriel Lier une instance Azure Database pour PostgreSQL à votre application dans Azure Spring Apps. N’oubliez pas de supprimer la propriété de configuration spring.datasource.password si elle était définie avant et ajoutez les dépendances appropriées à votre application Spring.

Pour obtenir d’autres tutoriels, consultez Utiliser Spring Data JDBC avec Azure Database pour PostgreSQL et Tutoriel : déployer une application Spring sur Azure Spring Apps avec une connexion sans mot de passe à une base de données Azure.

Installez des dépendances.

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

Obtenez un jeton d’accès à l’aide de la bibliothèque azure-identity et utilisez le jeton comme mot de passe. Obtenez des informations de connexion à partir de la variable d’environnement ajoutée par le connecteur de services. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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)

Installez des dépendances.
```
pip install azure-identity
```

Obtenez un jeton d’accès à l’aide de la bibliothèque azure-identity en utilisant les variables d’environnement ajoutées par le connecteur de services. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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')

Dans le fichier de paramètres, obtenez les informations de base de données Azure PostgreSQL à partir de variables d’environnement ajoutées par le connecteur de services. Utilisez accessToken obtenu à l’étape précédente pour accéder à la base de données.

# 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'},
    }
}

Installez des dépendances.

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"

Dans le code, obtenez le jeton d’accès à l’aide de azidentity, puis utilisez-le comme mot de passe pour vous connecter à Azure PostgreSQL, ainsi qu’avec les informations de connexion fournies par le connecteur de services. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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()

Installez des dépendances.

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

Dans le code, obtenez le jeton d’accès à l’aide de @azure/identity et des informations de connexion PostgreSQL à partir de variables d’environnement ajoutées par le connecteur de services. Combinez-les pour établir la connexion. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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();
})();

Pour PHP, il n’existe pas de plug-in ou de bibliothèque pour les connexions sans mot de passe. Vous pouvez obtenir un jeton d’accès pour l’identité managée ou le principal de service et l’utiliser comme mot de passe pour vous connecter à la base de données. Le jeton d’accès peut être obtenu à l’aide de l’API REST Azure.

Dans le code, obtenez le jeton d’accès à l’aide de l’API REST avec votre bibliothèque préférée.

Pour l’identité affectée par l’utilisateur et l’identité affectée par le système, Azure App Service et Azure Container Apps fournissent un point de terminaison REST accessible en interne pour récupérer des jetons pour les identités managées en définissant deux variables d’environnement : IDENTITY_ENDPOINT et IDENTITY_HEADER. Pour plus d’informations, consultez la référence du point de terminaison REST. Obtenez le jeton d’accès en effectuant une requête HTTP GET au point de terminaison d’identité et utilisez https://ossrdbms-aad.database.windows.net comme resource dans la requête. Pour l’identité affectée par l’utilisateur, incluez également l’ID client des variables d’environnement ajoutées par le connecteur de services dans la requête.

Pour le principal de service, reportez-vous à la demande de jeton d’accès de service à service Azure AD pour afficher les détails de l’acquisition du jeton d’accès. Effectuez la requête POST sur l’étendue de https://ossrdbms-aad.database.windows.net/.default avec l’ID locataire, l’ID client et la clé secrète client du principal de service à partir des variables d’environnement ajoutées par le connecteur de services.
Combinez le jeton d’accès et la chaîne de connexion PostgreSQL à partir de variables d’environnement ajoutées par le service Service Connector pour établir la connexion.
```
<?php
$conn_string = sprintf("%s password=", getenv('AZURE_POSTGRESQL_CONNECTIONSTRING'), $access_token);
$dbconn = pg_connect($conn_string);
?>
```

Pour Ruby, il n’existe pas de plug-in ou de bibliothèque pour les connexions sans mot de passe. Vous pouvez obtenir un jeton d’accès pour l’identité managée ou le principal de service et l’utiliser comme mot de passe pour vous connecter à la base de données. Le jeton d’accès peut être obtenu à l’aide de l’API REST Azure.

Installez des dépendances.
```
gem install pg
```

Dans le code, obtenez le jeton d’accès à l’aide de l’API REST et des informations de connexion PostgreSQL à partir de variables d’environnement ajoutées par le connecteur de services. Combinez-les pour établir la connexion. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

Azure App Service et Azure Container Apps fournissent un point de terminaison REST accessible en interne pour récupérer des jetons pour les identités managées. Pour plus d’informations, consultez la référence du point de terminaison 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,
)

Reportez-vous à la demande de jeton d’accès de service à service Azure AD pour voir plus d’informations sur l’acquisition du jeton d’accès pour le principal de service.

Ensuite, si vous avez créé des tables et des séquences dans un serveur flexible PostgreSQL avant d’utiliser le connecteur de services, vous devez vous connecter en tant que propriétaire et accorder à <aad-username> l’autorisation créée par le connecteur de services. Le nom d’utilisateur de la chaîne de connexion ou de la configuration définie par le connecteur de service doit ressembler à aad_<connection name>. Si vous utilisez le Portail Azure, sélectionnez le bouton Développer à côté de la colonne Service Type et obtenez la valeur. Si vous utilisez Azure CLI, cochez configurations dans la sortie de la commande CLI.

Ensuite, exécutez la requête pour accorder l’autorisation

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> et <owner-password> est le propriétaire de la table existante qui peut accorder des autorisations à d’autres personnes. <aad-username> est l’utilisateur créé par Service Connector. Remplacez-les par la valeur réelle.

Validez le résultat avec la commande suivante :

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

Ajoutez les dépendances suivantes dans votre fichier 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>

Obtenez la chaîne de connexion à partir de la variable d’environnement et ajoutez le nom du plug-in pour vous connecter à la base de données :

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);

Pour plus d’informations, consultez l’article Utiliser Java et JDBC avec Azure Database pour MySQL – Serveur flexible.

Mettez à jour votre application en suivant le tutoriel Connecter une instance Azure Database pour MySQL à votre application dans Azure Spring Apps. N’oubliez pas de supprimer la propriété de configuration spring.datasource.password si elle était définie avant et ajoutez les dépendances appropriées à votre application Spring.

Pour obtenir d’autres tutoriels, consultez l’article Utiliser Spring Data JDBC avec Azure Database pour MySQL.

Installer des dépendances

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

Authentifiez-vous avec le jeton d’accès via la bibliothèque azure-identity et obtenez des informations de connexion à partir de la variable d’environnement ajoutée par le connecteur de services. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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()

Installez des dépendances.
```
pip install azure-identity
```

Obtenez le jeton d’accès via la bibliothèque azure-identity avec les variables d’environnement ajoutées par le connecteur de services. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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')

Dans le fichier de paramètres, obtenez les informations de base de données Azure MySQL à partir de variables d’environnement ajoutées par le service Service Connector. Utilisez accessToken obtenu à l’étape précédente pour accéder à la base de données.

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

Installez des dépendances.

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"

Dans le code, obtenez le jeton d’accès via azidentity, puis connectez-vous à Azure MySQL avec le jeton. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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)
}

Installer des dépendances

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

Obtenez un jeton d’accès en utilisant @azure/identity et les informations de base de données Azure MySQL à partir de variables d’environnement ajoutées par le service Service Connector. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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');
});

Pour obtenir d’autres exemples de code, consultez la section Connexion à des bases de données Azure à partir d’App Service sans secrets à l’aide d’une identité managée.

Installez des dépendances.

dotnet add package Microsoft.Data.SqlClient

Obtenez la chaîne de connexion Azure SQL Database à partir de la variable d’environnement ajoutée par le connecteur de services.
```
using Microsoft.Data.SqlClient;

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

using var connection = new SqlConnection(connectionString);
connection.Open();
```
Pour plus d’informations, consultez Utilisation de l’authentification d’identité managée Active Directory.

Ajoutez les dépendances suivantes dans votre fichier 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>

Obtenez la chaîne de connexion Azure SQL Database à partir de la variable d’environnement ajoutée par le connecteur de services.

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();
        }
    }
}

Pour plus d’informations, consultez Se connecter à des bases de données Azure à partir d’App Service sans secrets avec une identité managée.

Pour une application Spring, si vous créez une connexion avec l’option --client-type springboot, Service Connector définit les propriétés spring.datasource.url au format valeur jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; sur Azure Spring Apps.

Mettez à jour votre application en suivant le tutoriel Migrer une application Java pour utiliser des connexions sans mot de passe avec Azure SQL Database. N’oubliez pas de supprimer la propriété de configuration spring.datasource.password si elle était définie avant et ajoutez les dépendances appropriées.

Installez des dépendances.
```
python -m pip install pyodbc
```

Obtenez les configurations de connexion Azure SQL Database à partir de la variable d’environnement ajoutée par le connecteur de services. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser. Si vous utilisez Azure Container Apps comme service de calcul ou que la chaîne de connexion dans l’extrait de code ne fonctionne pas, reportez-vous à Migrer une application Python pour utiliser des connexions sans mot de passe avec Azure SQL Database pour vous connecter à Azure SQL Database à l’aide d’un jeton d’accès.

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)

Installez des dépendances.
```
npm install mssql
```

Obtenez les configurations de connexion Azure SQL Database à partir des variables d’environnement ajoutées par le connecteur de services. Lorsque vous utilisez le code ci-dessous, supprimez les marques de commentaire de la partie de l’extrait de code pour le type d’authentification que vous souhaitez utiliser.

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);

Pour plus d’informations, consultez Page d’accueil pour la programmation client sur Microsoft SQL Server.

Installez des dépendances.

dotnet add package Microsoft.Data.SqlClient

Récupérez la base de données SQL dans la chaîne de connexion Microsoft Fabric à partir de la variable d’environnement ajoutée par Service Connector.
```
using Microsoft.Data.SqlClient;

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

using var connection = new SqlConnection(connectionString);
connection.Open();
```
Pour plus d’informations, consultez Utilisation de l’authentification d’identité managée Active Directory.

Ajoutez les dépendances suivantes dans votre fichier 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>

Récupérez la base de données SQL dans la chaîne de connexion Microsoft Fabric à partir de la variable d’environnement ajoutée par 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();
        }
    }
}

Pour plus d’informations, consultez Se connecter à des bases de données Azure à partir d’App Service sans secrets avec une identité managée.

Pour une application Spring, si vous créez une connexion avec l’option --client-type springboot, Service Connector définit la variable d’environnement FABRIC_SQL_CONNECTIONSTRING avec la valeur formatée jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI; sur Azure Spring Apps.

Pour les identités managées attribuées par l'utilisateur, msiClientId=<msiClientId>; est ajouté.

Mettez à jour votre application en suivant le tutoriel Migrer une application Java pour utiliser des connexions sans mot de passe avec Azure SQL Database. N’oubliez pas de supprimer la spring.datasource.password propriété de configuration si elle a été définie précédemment et d’ajouter les dépendances appropriées.

spring:
  datasource:
    url: ${FABRIC_SQL_CONNECTIONSTRING}

Installez des dépendances.
```
python -m pip install pyodbc
```
Récupérez la base de données SQL dans la chaîne de connexion Microsoft Fabric à partir de la variable d’environnement ajoutée par Service Connector. Si vous utilisez Azure Container Apps comme service de calcul ou que la chaîne de connexion dans l’extrait de code ne fonctionne pas, reportez-vous à Migrer une application Python pour utiliser des connexions sans mot de passe avec Azure SQL Database pour vous connecter à une base de données SQL dans Microsoft Fabric à l’aide d’informations d’identification sans mot de passe. Authentication=ActiveDirectoryMSI; est obligatoire dans la chaîne de connexion lors de la connexion à l’aide d’identités managées. UID=<msiClientId> est également nécessaire dans la chaîne de connexion lors de la connexion à l’aide d’une identité managée affectée par l’utilisateur.
```
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)
```

Installez des dépendances.

go mod init <YourProjectName>
go mod tidy

Récupérez la base de données SQL dans la chaîne de connexion Microsoft Fabric à partir de la variable d’environnement ajoutée par 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")
}

Pour plus d’informations, consultez Utiliser Golang pour interroger une base de données dans Azure SQL Database.

Pour plus d’informations, consultez Se connecter à votre base de données SQL dans Microsoft Fabric.

Déployer l’application sur un service d’hébergement Azure

Déployez votre application sur un service d’hébergement Azure. Reportez-vous éventuellement aux guides ci-dessous pour plus d’informations sur le déploiement de ces ressources.
- Azure App Service : Démarrage rapide : Déployer une application web ASP.NET.
- Azure Container Apps : Démarrage rapide : Déployer votre première application conteneur.
- Azure Spring Apps : Générez et déployez l’application.
  
  Remarque
  
  Les abonnements Basic, Standard et Enterprise sont entrés dans une période de retraite le 17 mars 2025. Pour plus d’informations, consultez l’annonce de mise hors service d’Azure Spring Apps.
Vérifiez le journal ou appelez l’application pour voir si elle peut se connecter à la base de données Azure avec succès.

Résolution des problèmes

Autorisations

Si vous rencontrez des erreurs liées aux autorisations, confirmez l’utilisateur connecté Azure CLI avec la commande az account show. Assurez-vous de vous connecter avec le bon compte. Ensuite, vérifiez que vous disposez des autorisations suivantes qui peuvent être demandées pour créer une connexion sans mot de passe avec le connecteur de services.

Autorisation	Opération
`Microsoft.DBforPostgreSQL/flexibleServers/read`	Requise pour obtenir les informations du serveur de base de données
`Microsoft.DBforPostgreSQL/flexibleServers/write`	Requis pour activer l’authentification Microsoft Entra pour le serveur de base de données
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write`	Requise pour créer une règle de pare-feu en cas de blocage de l’adresse IP
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete`	Requise pour rétablir la règle de pare-feu créée par Service Connector pour éviter un problème de sécurité
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/read`	Requis pour vérifier si l’utilisateur de connexion Azure CLI est un administrateur de serveur de base de données Microsoft Entra
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/write`	Requis pour ajouter l’utilisateur de connexion Azure CLI en tant qu’administrateur Microsoft Entra du serveur de base de données

Autorisation	Opération
`Microsoft.DBforMySQL/flexibleServers/read`	Requise pour obtenir les informations du serveur de base de données
`Microsoft.DBforMySQL/flexibleServers/write`	Requise pour ajouter l’identité managée affectée par l’utilisateur fournie au serveur de base de données
`Microsoft.DBforMySQL/flexibleServers/firewallRules/write`	Requise pour créer une règle de pare-feu en cas de blocage de l’adresse IP
`Microsoft.DBforMySQL/flexibleServers/firewallRules/delete`	Requise pour rétablir la règle de pare-feu créée par Service Connector pour éviter un problème de sécurité
`Microsoft.DBforMySQL/flexibleServers/administrators/read`	Requis pour vérifier si l’utilisateur de connexion Azure CLI est un administrateur de serveur de base de données Microsoft Entra
`Microsoft.DBforMySQL/flexibleServers/administrators/write`	Requis pour ajouter l’utilisateur de connexion Azure CLI en tant qu’administrateur Microsoft Entra du serveur de base de données

Autorisation	Opération
`Microsoft.Sql/servers/read`	Requise pour obtenir les informations du serveur de base de données
`Microsoft.Sql/servers/firewallRules/write`	Requise pour créer une règle de pare-feu en cas de blocage de l’adresse IP
`Microsoft.Sql/servers/firewallRules/delete`	Requise pour rétablir la règle de pare-feu créée par Service Connector pour éviter un problème de sécurité
`Microsoft.Sql/servers/administrators/read`	Requis pour vérifier si l’utilisateur de connexion Azure CLI est un administrateur de serveur de base de données Microsoft Entra
`Microsoft.Sql/servers/administrators/write`	Requis pour ajouter l’utilisateur de connexion Azure CLI en tant qu’administrateur Microsoft Entra du serveur de base de données

Dans certains cas, les autorisations ne sont pas requises. Par exemple, si l’utilisateur authentifié par Azure CLI est déjà administrateur Active Directory sur SQL Server, vous n’avez pas besoin de l’autorisation Microsoft.Sql/servers/administrators/write.

Microsoft Entra ID (système d'identification de Microsoft)

Si vous obtenez une erreur ERROR: AADSTS530003: Your device is required to be managed to access this resource., demandez de l’aide à votre service informatique pour joindre cet appareil à Microsoft Entra ID. Pour plus d’informations, consultez Appareils joints à Microsoft Entra.

Le connecteur de services doit accéder à Microsoft Entra ID pour obtenir les informations de votre compte et l’identité managée du service d’hébergement. Vous pouvez utiliser la commande suivante pour vérifier si votre appareil peut accéder Microsoft Entra ID :

az ad signed-in-user show

Si vous ne vous connectez pas de manière interactive, vous pouvez également obtenir l’erreur et le message Interactive authentication is needed. Pour résoudre l’erreur, connectez-vous avec la commande az login.

Connectivité réseau

Si votre serveur de base de données est dans un réseau virtuel, assurez-vous que votre environnement qui exécute la commande Azure CLI peut accéder au serveur dans le réseau virtuel.

Si votre serveur de base de données interdit l’accès public, assurez-vous que votre environnement qui exécute la commande Azure CLI peut accéder au serveur par le biais du point de terminaison privé.

Étapes suivantes

Pour plus d’informations sur Service Connector et les connexions sans mot de passe, consultez les ressources suivantes :

Documentation Service Connector

Connexions sans mot de passe pour les services Azure

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-09-29

Partager via

Tutoriel : Créer une connexion sans mot de passe à un service de base de données par le biais de Service Connector

Prérequis

Installer l’extension sans mot de passe Service Connector

Créer une connexion sans mot de passe

Se connecter à une base de données avec l’authentification Microsoft Entra

Déployer l’application sur un service d’hébergement Azure

Résolution des problèmes

Autorisations

Microsoft Entra ID (système d'identification de Microsoft)

Connectivité réseau

Étapes suivantes

Commentaires

Ressources supplémentaires