Zelfstudie: Een verbinding zonder wachtwoord maken met een databaseservice via serviceconnector

Verbindingen zonder wachtwoord maken gebruik van beheerde identiteiten voor toegang tot Azure-services. Met deze aanpak hoeft u geheimen voor beheerde identiteiten niet handmatig bij te houden en te beheren. Deze taken worden veilig intern verwerkt door Azure.

Service Connector maakt beheerde identiteiten mogelijk in app-hostingservices zoals Azure Spring Apps en Azure App Service. Service Connector configureert ook databaseservices, zoals Azure Database for PostgreSQL, Azure Database for MySQL, Azure SQL Database en SQL Database in Microsoft Fabric, om beheerde identiteiten te accepteren.

In deze zelfstudie gebruikt u de Azure CLI om de volgende taken te voltooien:

Controleer uw eerste omgeving met de Azure CLI.
Maak een verbinding zonder wachtwoord met serviceconnector.
Gebruik de omgevingsvariabelen of configuraties die door Service Connector worden gegenereerd voor toegang tot een databaseservice.

Vereisten

Een Azure-account met een actief abonnement. Maak gratis een Azure-account.
Een app die is geïmplementeerd in Azure App Service in een regio die wordt ondersteund door Service Connector.
Azure CLI versie 2.61.0 of hoger.

Ga als volgt te werk om de Azure CLI te gaan gebruiken:

Gebruik de Bash-omgeving in Azure Cloud Shell. Zie Aan de slag met Azure Cloud Shell voor meer informatie.
Als u liever CLI-referentieopdrachten lokaal uitvoert, installeert u de Azure CLI. Als je op Windows of macOS werkt, overweeg dan om Azure CLI in een Docker-container te draaien. Zie De Azure CLI uitvoeren in een Docker-container voor meer informatie.
- Als u een lokale installatie gebruikt, meldt u zich aan bij de Azure CLI met behulp van de opdracht az login . Om het authenticatieproces te voltooien, volgt u de stappen die op uw terminal worden weergegeven. Zie Verifiëren bij Azure met behulp van Azure CLI voor andere aanmeldingsopties.
- Wanneer u daarom wordt gevraagd, installeer de Azure CLI-extensie bij het eerste gebruik. Zie Extensies gebruiken en beheren met de Azure CLI voor meer informatie over extensies.
- Voer az version uit om de versie en afhankelijke bibliotheken te vinden die zijn geïnstalleerd. Voer az upgrade uit om een upgrade uit te voeren naar de nieuwste versie.

De serviceconnector-extensie zonder wachtwoord installeren

Installeer de nieuwste serviceconnector-extensie zonder wachtwoord voor de Azure CLI:

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

Notitie

Controleer of de serviceconnector-passwordless extensieversie 2.0.2 of hoger is door uit te voeren az version. Indien nodig moet u eerst de Azure CLI bijwerken en vervolgens de extensie bijwerken.

Een verbinding zonder wachtwoord maken

De volgende opdrachten gebruiken Azure App Service als voorbeeld om een verbinding te maken met behulp van een beheerde identiteit.

Als u Azure Spring Apps gebruikt, voert u in plaats daarvan de opdracht uitaz spring connection create. Zie Azure Spring Apps verbinden met de Azure-database voor meer voorbeelden.

Notitie

Als u de voorkeur geeft aan de Azure-portal, opent u de blade Serviceconnector in Azure App Service of Azure Spring Apps en selecteert u Maken. In de portal wordt de opdracht automatisch samengesteld en uitgevoerd in Cloud Shell.

De volgende Azure CLI-opdracht maakt gebruik van een --client-type parameter, dit kan java, dotnet, python, enzovoort zijn. Voer de az webapp connection create postgres-flexible -h opdracht uit om de ondersteunde clienttypen op te halen en kies de parameter die overeenkomt met uw toepassing.

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 for MySQL - Flexible Server vereist een door de gebruiker toegewezen beheerde identiteit om Microsoft Entra-verificatie in te schakelen. Zie Microsoft Entra-verificatie instellen voor Azure Database for MySQL - Flexible Server voor meer informatie. U kunt de volgende opdracht gebruiken om een door de gebruiker toegewezen beheerde identiteit te maken:

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)

Belangrijk

Nadat u de door de gebruiker toegewezen beheerde identiteit hebt gemaakt, vraagt u de globale beheerder of bevoorrechte rolbeheerder om de volgende machtigingen voor deze identiteit te verlenen:

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

Zie de sectie Machtigingen van Active Directory-verificatie voor meer informatie.

Verbind vervolgens uw app met een MySQL-database met een door het systeem toegewezen beheerde identiteit met behulp van Service Connector.

De volgende Azure CLI-opdracht maakt gebruik van een --client-type parameter. Voer de az webapp connection create mysql-flexible -h opdracht uit om de ondersteunde clienttypen op te halen en kies de client die overeenkomt met uw toepassing.

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

De volgende Azure CLI-opdracht maakt gebruik van een --client-type parameter. Voer de az webapp connection create sql -h opdracht uit om de ondersteunde clienttypen op te halen en kies de client die overeenkomt met uw toepassing.

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

De volgende Azure CLI-opdracht maakt gebruik van een --client-type parameter. Voer de az webapp connection create fabricsql -h opdracht uit om de ondersteunde clienttypen op te halen en kies de client die overeenkomt met uw toepassing.

Belangrijk

Handmatig delen van toegang is momenteel vereist voor het voltooien van onboarding. Zie Toegang tot SQL-database delen in Fabric.

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

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

Met deze serviceconnectoropdracht worden de volgende taken op de achtergrond uitgevoerd:

Schakel Microsoft Entra-verificatie in voor de databaseserver als deze nog niet is ingeschakeld.
Stel de Microsoft Entra-beheerder in op de huidige aangemelde gebruiker.
Voeg een databasegebruiker toe voor de door het systeem toegewezen beheerde identiteit, door de gebruiker toegewezen beheerde identiteit of service-principal. Verdeel alle bevoegdheden van de database $DATABASE_NAME aan deze gebruiker. De gebruikersnaam vindt u in de verbindingsreeks in de voorgaande opdrachtuitvoer.
Stel configuraties in met de naam AZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRINGof AZURE_SQL_CONNECTIONSTRINGFABRIC_SQL_CONNECTIONSTRING op de Azure-resource op basis van het databasetype.
- Voor App Service worden de configuraties ingesteld op de blade App-instellingen .
- Voor Spring Apps worden de configuraties ingesteld wanneer de toepassing wordt gestart.

ServiceConnector wijst de volgende bevoegdheden toe aan de gebruiker, u kunt deze intrekken en de bevoegdheden aanpassen op basis van uw vereisten.

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"

Verbinding maken met een database met Microsoft Entra-verificatie

Nadat u de verbinding hebt gemaakt, kunt u de verbindingsreeks in uw toepassing gebruiken om verbinding te maken met de database met Microsoft Entra-verificatie. U kunt bijvoorbeeld de volgende oplossingen gebruiken om verbinding te maken met de database met Microsoft Entra-verificatie.

Voor .NET is er geen invoegtoepassing of bibliotheek om wachtwoordloze verbindingen te ondersteunen. U kunt een toegangstoken ophalen voor de beheerde identiteit of service-principal met behulp van de clientbibliotheek, zoals Azure.Identity. Vervolgens kunt u het toegangstoken als wachtwoord gebruiken om verbinding te maken met de database. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

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

Voeg de volgende afhankelijkheden toe aan uw pom.xml-bestand :

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

Haal de verbindingsreeks op uit omgevingsvariabelen en voeg de naam van de invoegtoepassing toe om verbinding te maken met de database:

import java.sql.*;

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

Voor meer informatie raadpleegt u de volgende bronnen:

Voor een Spring-applicatie geldt: als u een verbinding maakt met de optie --client-type springboot, stelt Service Connector de eigenschappen spring.datasource.azure.passwordless-enabled, spring.datasource.url en spring.datasource.username in voor Azure Spring Apps.

Werk uw toepassing bij aan de hand van de tutorial Azure Database voor PostgreSQL aan uw toepassing in Azure Spring Apps koppelen. Vergeet niet om de spring.datasource.password configuratie-eigenschap te verwijderen als deze eerder is ingesteld en de juiste afhankelijkheden aan uw Spring-toepassing toe te voegen.

Zie Spring Data JDBC gebruiken met Azure Database for PostgreSQL en zelfstudie: Een Spring-toepassing implementeren in Azure Spring Apps met een wachtwoordloze verbinding met een Azure-database voor meer zelfstudies.

Installeer afhankelijkheden.

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

Verkrijg toegangstoken met behulp van de azure-identity bibliotheek en gebruik de token als wachtwoord. Haal verbindingsgegevens op uit de omgevingsvariabelen die zijn toegevoegd door Service Connector. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

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)

Installeer afhankelijkheden.
```
pip install azure-identity
```

Toegangstoken ophalen met behulp van azure-identity bibliotheek met behulp van omgevingsvariabelen die zijn toegevoegd door Service Connector. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

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

Haal bij het instellen van het bestand azure PostgreSQL-databasegegevens op uit omgevingsvariabelen die zijn toegevoegd door de Service Connector-service. Gebruik accessToken verkregen in de vorige stap om toegang te krijgen tot de database.

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

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

Installeer afhankelijkheden.

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"

Haal in code het toegangstoken op met behulp van azidentity, en gebruik dit als wachtwoord om verbinding te maken met Azure PostgreSQL, samen met de verbindingsgegevens die door Service Connector worden verstrekt. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

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

Installeer afhankelijkheden.

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

Haal in code het toegangstoken op met behulp van @azure/identity en PostgreSQL-verbindingsgegevens uit omgevingsvariabelen die zijn toegevoegd door de Service Connector-service. Combineer ze om de verbinding tot stand te brengen. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

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

Voor PHP is er geen invoegtoepassing of bibliotheek voor wachtwoordloze verbindingen. U kunt een toegangstoken ophalen voor de beheerde identiteit of service-principal en dit gebruiken als het wachtwoord om verbinding te maken met de database. Het toegangstoken kan worden verkregen met behulp van de Azure REST API.

Haal in code het toegangstoken op met behulp van REST API met uw favoriete bibliotheek.

Voor door de gebruiker toegewezen identiteit en door het systeem toegewezen identiteit biedt Azure App Service een intern toegankelijk REST-eindpunt voor het ophalen van tokens voor beheerde identiteiten door twee omgevingsvariabelen te definiëren: IDENTITY_ENDPOINT en IDENTITY_HEADER. Zie rest-eindpuntreferentie voor meer informatie. Haal het toegangstoken op door een HTTP GET-aanvraag naar het identiteitseindpunt te maken en te gebruiken https://ossrdbms-aad.database.windows.net zoals resource in de query. Voor door de gebruiker toegewezen identiteit moet u ook de client-id van de omgevingsvariabelen opnemen die door Service Connector in de query zijn toegevoegd.

Raadpleeg de Azure AD-toegangstokenaanvraag voor toegang tussen services voor meer informatie over het verkrijgen van toegangstokens voor service-principals. Voer de POST-aanvraag uit voor het bereik van https://ossrdbms-aad.database.windows.net/.default en met de tenant-id, client-id en clientgeheim van de service-principal uit de omgevingsvariabelen die zijn toegevoegd door Service Connector.
Combineer het toegangstoken en de PostgreSQL-verbindingsreeks uit omgevingsvariabelen die zijn toegevoegd door de Service Connector-service om de verbinding tot stand te brengen.
```
<?php
$conn_string = sprintf("%s password=", getenv('AZURE_POSTGRESQL_CONNECTIONSTRING'), $access_token);
$dbconn = pg_connect($conn_string);
?>
```

Voor Ruby is er geen invoegtoepassing of bibliotheek voor wachtwoordloze verbindingen. U kunt een toegangstoken ophalen voor de beheerde identiteit of service-principal en dit gebruiken als het wachtwoord om verbinding te maken met de database. Het toegangstoken kan worden verkregen met behulp van de Azure REST API.

Installeer afhankelijkheden.
```
gem install pg
```

Haal in code het toegangstoken op met behulp van REST API en PostgreSQL-verbindingsgegevens uit omgevingsvariabelen die zijn toegevoegd door de Service Connector-service. Combineer ze om de verbinding tot stand te brengen. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

Azure App Service biedt een intern toegankelijk REST-eindpunt voor het ophalen van tokens voor beheerde identiteiten. Zie rest-eindpuntreferentie voor meer informatie.

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

Raadpleeg de azure AD-service-to-service-toegangstokenaanvraag voor meer informatie over het verkrijgen van toegangstokens voor de service-principal.

Als u vervolgens tabellen en sequenties hebt gemaakt in PostgreSQL Flexible Server voordat u Service Connector gebruikte, maakt u verbinding als de eigenaar en verleent u machtigingen aan <aad-username>, gemaakt door Service Connector. De gebruikersnaam uit de verbindingsreeks of de configuratie die is ingesteld door Service Connector, moet eruitzien als aad_<connection name>. Als u de Azure-portal gebruikt, selecteert u de knop Uitvouwen naast de kolom Servicetype om de waarde op te halen. Als u de Azure CLI gebruikt, controleer dan configurations in de uitvoer van de CLI-opdracht.

Voer vervolgens de volgende query uit om machtigingen te verlenen:

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>\";"

De <owner-username> en <owner-password> behoren tot de eigenaar van de bestaande tabel die machtigingen aan anderen kan verlenen. <aad-username> is de gebruiker die door Service Connector is gemaakt. Vervang ze door werkelijke waarden.

Valideer het resultaat:

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

Voeg de volgende afhankelijkheden toe aan uw pom.xml-bestand :

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

Haal de verbindingsreeks op uit de omgevingsvariabele en voeg de naam van de invoegtoepassing toe om verbinding te maken met de database:

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

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

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

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

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

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

Zie Java en JDBC gebruiken met Azure Database for MySQL - Flexible Server voor meer informatie.

Werk uw toepassing bij volgens de zelfstudie Een Azure Database for MySQL-exemplaar verbinden met uw toepassing in Azure Spring Apps. Vergeet niet om de spring.datasource.password configuratie-eigenschap te verwijderen als deze eerder is ingesteld en de juiste afhankelijkheden aan uw Spring-toepassing toe te voegen.

Zie Spring Data JDBC gebruiken met Azure Database for MySQL voor meer zelfstudies

Afhankelijkheden installeren

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

Verifiëren met een toegangstoken dat is verkregen via de azure-identity-bibliotheek en verbindingsinformatie ophalen uit de omgevingsvariabele die is toegevoegd door Service Connector. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

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

Installeer afhankelijkheden.
```
pip install azure-identity
```

Haal een toegangstoken op via de azure-identity-bibliotheek met behulp van de omgevingsvariabelen die door Service Connector zijn toegevoegd. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

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

Bij het instellen van een bestand haalt u azure MySQL-databasegegevens op uit omgevingsvariabelen die zijn toegevoegd door de Service Connector-service. Gebruik accessToken verkregen in de vorige stap om toegang te krijgen tot de database.

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

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

Installeer afhankelijkheden.

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"

Haal in code het toegangstoken op via azidentityen maak vervolgens verbinding met Azure MySQL met het token. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

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

Afhankelijkheden installeren

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

Haal toegangstokens op met behulp van @azure/identity en Azure MySQL-databasegegevens uit omgevingsvariabelen die zijn toegevoegd door de Service Connector-service. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

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

Zie Verbinding maken met Azure-databases vanuit App Service zonder geheimen met behulp van een beheerde identiteit voor meer codevoorbeelden.

Installeer afhankelijkheden.

dotnet add package Microsoft.Data.SqlClient

Haal de Azure SQL Database-verbindingsreeks op uit de omgevingsvariabele die is toegevoegd door Service Connector.

using Microsoft.Data.SqlClient;

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

using var connection = new SqlConnection(connectionString);
connection.Open();

Zie Active Directory Managed Identity-verificatie gebruiken voor meer informatie.

Voeg de volgende afhankelijkheden toe aan uw pom.xml-bestand :

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

Haal de Azure SQL Database-verbindingsreeks op uit de omgevingsvariabele die is toegevoegd door 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) {
        // 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();
        }
    }
}

Zie Verbinding maken met Azure-databases vanuit App Service zonder geheimen met behulp van een beheerde identiteit voor meer informatie.

Voor een Spring-toepassing geldt: als u een verbinding maakt met de optie --client-type springboot, stelt Service Connector de eigenschappen spring.datasource.url met de waarde-indeling jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; in voor Azure Spring Apps.

Werk uw applicatie bij volgens de handleiding Een Java-toepassing migreren om wachtwoordloze verbindingen met Azure SQL Database te gebruiken. Vergeet niet om de spring.datasource.password configuratie-eigenschap te verwijderen als deze eerder is ingesteld en de juiste afhankelijkheden toe te voegen.

Installeer afhankelijkheden.

python -m pip install mssql-python python-dotenv

Haal de azure SQL Database-verbindingsconfiguraties op uit de omgevingsvariabele die is toegevoegd door Service Connector. Verwijder in de onderstaande code de opmerking in de sectie voor uw verificatietype.

import os
from mssql_python import connect

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

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned managed identity.
# connection_string = f'Server={server},{port};Database={database};Authentication=ActiveDirectoryMSI;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

# For user-assigned managed identity.
# client_id = os.getenv('AZURE_SQL_USER')
# connection_string = f'Server={server},{port};Database={database};UID={client_id};Authentication=ActiveDirectoryMSI;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

# For service principal.
# user = os.getenv('AZURE_SQL_USER')
# password = os.getenv('AZURE_SQL_PASSWORD')
# connection_string = f'Server={server},{port};Database={database};UID={user};PWD={password};Authentication=ActiveDirectoryServicePrincipal;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

conn = connect(connection_string)

Installeer afhankelijkheden.
```
npm install mssql
```

Haal de azure SQL Database-verbindingsconfiguraties op uit de omgevingsvariabelen die zijn toegevoegd door Service Connector. Verwijder in de onderstaande code de opmerking in de sectie voor uw verificatietype.

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

Zie Startpagina voor clientprogrammering naar Microsoft SQL Server voor meer informatie.

Installeer afhankelijkheden.

dotnet add package Microsoft.Data.SqlClient

Haal de SQL-database in Microsoft Fabric-verbindingsreeks op uit de omgevingsvariabele die is toegevoegd door Service Connector.
```
using Microsoft.Data.SqlClient;

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

using var connection = new SqlConnection(connectionString);
connection.Open();
```
Zie Verificatie van beheerde identiteiten in Active Directory gebruiken voor meer informatie.

Voeg de volgende afhankelijkheden toe aan uw pom.xml-bestand :

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

Haal de SQL-database in Microsoft Fabric-verbindingsreeks op uit de omgevingsvariabele die is toegevoegd door 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();
        }
    }
}

Zie Verbinding maken met Azure-databases vanuit App Service zonder geheimen met behulp van een beheerde identiteit voor meer informatie.

Als u voor een Spring-toepassing een verbinding met de optie --client-type springbootmaakt, stelt Service Connector de omgevingsvariabele FABRIC_SQL_CONNECTIONSTRING in met waarde-indeling jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI; in Azure Spring Apps.

Voor door de gebruiker toegewezen beheerde identiteiten wordt msiClientId=<msiClientId>; toegevoegd.

spring:
  datasource:
    url: ${FABRIC_SQL_CONNECTIONSTRING}

Installeer afhankelijkheden.

python -m pip install mssql-python python-dotenv

Haal de SQL-database in Microsoft Fabric-verbindingsreeks op uit de omgevingsvariabele die is toegevoegd door Service Connector. Authentication=ActiveDirectoryMSI; is vereist in de verbindingsreeks bij het maken van verbinding met beheerde identiteiten. UID=<msiClientId> is ook vereist in de verbindingsreeks wanneer u verbinding maakt met een door de gebruiker toegewezen beheerde identiteit.

import os
from mssql_python import connect

connection_string = os.getenv('FABRIC_SQL_CONNECTIONSTRING')

# System-assigned managed identity connection string format
# `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
# `Server=tcp:<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;Database=<SQL-DB-name>-<Fabric-DB-Identifier>;UID=<msiClientId>;Authentication=ActiveDirectoryMSI;`

conn = connect(connection_string)

Installeer afhankelijkheden.

go mod init <YourProjectName>
go mod tidy

Haal de SQL-database in Microsoft Fabric-verbindingsreeks op uit de omgevingsvariabele die is toegevoegd door 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")
}

Zie Golang gebruiken om een query uit te voeren op een database in Azure SQL Database voor meer informatie.

Zie Verbinding maken met uw SQL-database in Microsoft Fabric voor meer informatie.

De toepassing implementeren in een Azure-hostingservice

Implementeer uw toepassing in een Azure-hostingservice. Raadpleeg eventueel de onderstaande handleidingen voor meer informatie over het implementeren van deze resources.
- Azure App Service: Quickstart: Een ASP.NET-web-app implementeren.
- Azure Spring Apps: de app bouwen en implementeren.
  
  Notitie
  
  De Basic-, Standard- en Enterprise-abonnementen hebben op 17 maart 2025 een pensioenperiode ingevoerd. Zie de aankondiging over buitengebruikstelling van Azure Spring Apps voor meer informatie.
Controleer het logboek of roep de toepassing aan om te zien of deze verbinding kan maken met de Azure-database.

Probleemoplossing

Machtigingen

Als er machtigingsfouten optreden, bevestigt u de aangemelde Gebruiker van Azure CLI met de opdracht az account show. Zorg ervoor dat u zich aanmeldt met het juiste account. Controleer vervolgens of u de volgende machtigingen hebt die mogelijk vereist zijn om een verbinding zonder wachtwoord te maken met serviceconnector.

Machtiging	Operatie
`Microsoft.DBforPostgreSQL/flexibleServers/read`	Vereist voor het ophalen van gegevens van de databaseserver
`Microsoft.DBforPostgreSQL/flexibleServers/write`	Vereist voor het inschakelen van Microsoft Entra-verificatie voor databaseserver
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write`	Vereist voor het maken van een firewallregel voor het geval het lokale IP-adres wordt geblokkeerd
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete`	Vereist om de firewallregel die door Service Connector is gemaakt, te herstellen om beveiligingsproblemen te voorkomen
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/read`	Vereist om te controleren of de azure CLI-aanmeldingsgebruiker een databaseserver Microsoft Entra-beheerder is
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/write`	Vereist voor het toevoegen van de aangemelde Azure CLI-gebruiker als Microsoft Entra-beheerder van de databaseserver

Machtiging	Operatie
`Microsoft.DBforMySQL/flexibleServers/read`	Vereist voor het ophalen van gegevens van de databaseserver
`Microsoft.DBforMySQL/flexibleServers/write`	Vereist om de door de gebruiker toegewezen beheerde identiteit toe te voegen aan de databaseserver
`Microsoft.DBforMySQL/flexibleServers/firewallRules/write`	Vereist voor het maken van een firewallregel voor het geval het lokale IP-adres wordt geblokkeerd
`Microsoft.DBforMySQL/flexibleServers/firewallRules/delete`	Vereist om de firewallregel die door Service Connector is gemaakt, te herstellen om beveiligingsproblemen te voorkomen
`Microsoft.DBforMySQL/flexibleServers/administrators/read`	Vereist om te controleren of de azure CLI-aanmeldingsgebruiker een databaseserver Microsoft Entra-beheerder is
`Microsoft.DBforMySQL/flexibleServers/administrators/write`	Vereist voor het toevoegen van de aangemelde Azure CLI-gebruiker als Microsoft Entra-beheerder van de databaseserver

Machtiging	Operatie
`Microsoft.Sql/servers/read`	Vereist voor het ophalen van gegevens van de databaseserver
`Microsoft.Sql/servers/firewallRules/write`	Vereist voor het maken van een firewallregel voor het geval het lokale IP-adres wordt geblokkeerd
`Microsoft.Sql/servers/firewallRules/delete`	Vereist om de firewallregel die door Service Connector is gemaakt, te herstellen om beveiligingsproblemen te voorkomen
`Microsoft.Sql/servers/administrators/read`	Vereist om te controleren of de azure CLI-aanmeldingsgebruiker een databaseserver Microsoft Entra-beheerder is
`Microsoft.Sql/servers/administrators/write`	Vereist voor het toevoegen van de aangemelde Azure CLI-gebruiker als Microsoft Entra-beheerder van de databaseserver

In sommige gevallen zijn de machtigingen niet vereist. Als de door Azure CLI geverifieerde gebruiker bijvoorbeeld al een Active Directory-beheerder op SQL Server is, hoeft u niet over de Microsoft.Sql/servers/administrators/write machtiging te beschikken.

Microsoft Entra ID

Als er een fout ERROR: AADSTS530003: Your device is required to be managed to access this resource.optreedt, vraagt u uw IT-afdeling om hulp bij het toevoegen van dit apparaat aan Microsoft Entra-id. Zie Microsoft Entra-gekoppelde apparaten voor meer informatie.

ServiceConnector moet toegang krijgen tot Microsoft Entra ID om informatie op te halen over uw account en de beheerde identiteit van de hostingservice. U kunt de volgende opdracht gebruiken om te controleren of uw apparaat toegang heeft tot Microsoft Entra ID:

az ad signed-in-user show

Als u niet interactief inlogt, krijgt u mogelijk ook de foutmelding en Interactive authentication is needed. Om de fout op te lossen, meldt u zich aan met de opdracht az login.

Netwerkverbinding

Als uw databaseserver zich in virtual network bevindt, moet u ervoor zorgen dat uw omgeving waarop de Azure CLI-opdracht wordt uitgevoerd, toegang heeft tot de server in het virtuele netwerk.

Als uw databaseserver openbare toegang weigert, moet u ervoor zorgen dat uw omgeving waarop de Azure CLI-opdracht wordt uitgevoerd, toegang heeft tot de server via het privé-eindpunt.

Volgende stappen

Raadpleeg de volgende bronnen voor meer informatie over serviceconnector en verbindingen zonder wachtwoord:

Documentatie voor Service Connector

Verbindingen zonder wachtwoord voor Azure-services

Feedback

Is deze pagina nuttig?

Last updated on 2026-06-18

Zelfstudie: Een verbinding zonder wachtwoord maken met een databaseservice via serviceconnector

Vereisten

De serviceconnector-extensie zonder wachtwoord installeren

Een verbinding zonder wachtwoord maken

Verbinding maken met een database met Microsoft Entra-verificatie

De toepassing implementeren in een Azure-hostingservice

Probleemoplossing

Machtigingen

Microsoft Entra ID

Netwerkverbinding

Volgende stappen

Feedback

Aanvullende resources