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

Article
11/18/2023

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 et Azure SQL Database, pour accepter les 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

Azure CLI version 2.48.1 ou ultérieure.
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.

Configurer votre environnement

Compte

Connectez-vous avec Azure CLI par le biais de az login. Si vous utilisez Azure Cloud Shell ou si vous êtes déjà connecté, confirmez votre compte authentifié avec az account show.

Installer l’extension sans mot de passe Service Connector

Installez l’extension sans mot de passe Service Connector pour Azure CLI :

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

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

Notes

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. Exécutez 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 java

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 java

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 java

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_MANAGEMED_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

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.
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_CONNECTIONSTRING ou AZURE_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.

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 according to the authentication type.
// 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.3.6</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-extensions</artifactId>
    <version>1.1.5</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

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 according to the authentication type.
# 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 according to the authentication type.
# 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 according to the authentication type.
// 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";
const { Client } = require('pg');

// Uncomment the following lines according to the authentication type.  
// 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;

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

Concernant l’identité affectée par l’utilisateur et l’identité affectée par le système, App Service et Container Apps fournissent un point de terminaison REST accessible en interne afin de 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 des variables d’environnement ajoutées par le connecteur de services 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.

App Service et container Apps fournissent un point de terminaison REST accessible en interne afin de 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 according to the authentication type.
# 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 according to the authentication type.
// 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.30</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-extensions</artifactId>
    <version>1.1.5</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";
Connection connection = DriverManager.getConnection(url + "&defaultAuthenticationPlugin=" +
    pluginName + "&authenticationPlugins=" + pluginName);

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 according to the authentication type.
# 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 according to the authentication type.
# 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 according to the authentication type.
  // 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 according to the authentication type.
// 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 afin de vous connecter à Azure SQL Database avec 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 according to the authentication type.
# 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 according to the authentication type.
// 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.

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

Enfin, déployez votre application sur un service d’hébergement Azure. Ce service source peut utiliser une identité managée pour se connecter à la base de données cible sur Azure.

Par Azure App Service, vous pouvez déployer le code de l’application à l’aide de la commande az webapp deploy. Pour plus d’informations, consultez Démarrage rapide : Déployer une application web ASP.NET.

Vous pouvez ensuite consulter le journal ou appeler l’application pour déterminer si elle peut se connecter à la base de données Azure.

Résolution des problèmes

Autorisation

Si vous rencontrez des erreurs liées aux autorisations, confirmez l’utilisateur connecté Azure CLI avec la commande az account show. Veillez à vous connecter avec le compte correct. 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

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

Share 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

Configurer votre environnement

Compte

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

Autorisation

Microsoft Entra ID

Connectivité réseau

Étapes suivantes

Ressources supplémentaires