Självstudie: Skapa en lösenordslös anslutning till en databastjänst via Service Connector

2025-09-29

Lösenordslösa anslutningar använder hanterade identiteter för att få åtkomst till Azure-tjänster. Med den här metoden behöver du inte spåra och hantera hemligheter för hanterade identiteter manuellt. Dessa uppgifter hanteras på ett säkert sätt internt av Azure.

Service Connector möjliggör hanterade identiteter i appvärdtjänster som Azure Spring Apps, Azure App Service och Azure Container Apps. Service Connector konfigurerar även databastjänster, till exempel Azure Database for PostgreSQL, Azure Database for MySQL, Azure SQL Database och SQL Database i Microsoft Fabric, för att acceptera hanterade identiteter.

I den här självstudien använder du Azure CLI för att utföra följande uppgifter:

Kontrollera din första miljö med Azure CLI.
Skapa en lösenordslös anslutning med Service Connector.
Använd miljövariabler eller konfigurationer som genereras av Service Connector för att få åtkomst till en databastjänst.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Skapa ett Azure-konto kostnadsfritt.
En app som distribueras till Azure App Service i en region som stöds av Service Connector.
Azure CLI version 2.61.0 eller senare.

Så här börjar du använda Azure CLI:

Använd Bash-miljön i Azure Cloud Shell. Mer information finns i Komma igång med Azure Cloud Shell.
Om du föredrar att köra CLI-referenskommandon lokalt installerar du Azure CLI. Om du kör på Windows eller macOS, överväg att köra Azure CLI i en Docker-container. Mer information finns i Så här kör du Azure CLI i en Docker-container.
- Om du använder en lokal installation loggar du in på Azure CLI med kommandot az login . För att slutföra autentiseringsprocessen, följ stegen som visas i din terminal. Andra inloggningsalternativ finns i Autentisera till Azure med Azure CLI.
- När du blir uppmanad, installera Azure CLI-tillägget vid första användning. Mer information om tillägg finns i Använda och hantera tillägg med Azure CLI.
- Kör az version för att hitta den version och beroende bibliotek som är installerade. För att uppgradera till den senaste versionen, kör az upgrade.

Installera det lösenordslösa tillägget för Service Connector

Installera det senaste lösenordslösa tillägget för Service Connector för Azure CLI:

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

Kommentar

Kontrollera att tillägget "serviceconnector-passwordless" är "2.0.2" eller senare genom att köra az version. Du kan behöva uppgradera Azure CLI först för att uppgradera tilläggsversionen.

Skapa en lösenordslös anslutning

Sedan använder vi Azure App Service som exempel för att skapa en anslutning med hjälp av hanterad identitet.

Om du använder:

Azure Spring Apps: använd az spring connection create i stället. Fler exempel finns i Ansluta Azure Spring Apps till Azure-databasen.
Azure Container Apps: använd az containerapp connection create i stället. Fler exempel finns i Skapa och ansluta en PostgreSQL-databas med identitetsanslutning.

Kommentar

Om du använder Azure-portalen går du till bladet Service Connector i Azure App Service, Azure Spring Apps eller Azure Container Apps och väljer Skapa för att skapa en anslutning. Azure Portal skapar automatiskt kommandot åt dig och utlöser kommandokörningen på Cloud Shell.

Följande Azure CLI-kommando använder en --client-type parameter, det kan vara java, dotnet, python osv. Kör az webapp connection create postgres-flexible -h för att hämta de klienttyper som stöds och välj den som matchar ditt program.

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 – Flexibel server kräver en användartilldelad hanterad identitet för att aktivera Microsoft Entra-autentisering. Mer information finns i Konfigurera Microsoft Entra-autentisering för Azure Database for MySQL – flexibel server. Du kan använda följande kommando för att skapa en användartilldelad hanterad identitet:

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)

Viktigt!

När du har skapat den användartilldelade hanterade identiteten ber du din globala administratör eller privilegierade rolladministratör att bevilja följande behörigheter för den här identiteten:

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

Mer information finns i avsnittet Behörigheter i Active Directory-autentisering.

Anslut sedan din app till en MySQL-databas med en systemtilldelad hanterad identitet med hjälp av Service Connector.

Följande Azure CLI-kommando använder en --client-type parameter. az webapp connection create mysql-flexible -h Kör för att hämta de klienttyper som stöds och välj den som matchar ditt program.

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

Följande Azure CLI-kommando använder en --client-type parameter. az webapp connection create sql -h Kör för att hämta de klienttyper som stöds och välj den som matchar ditt program.

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

Följande Azure CLI-kommando använder en --client-type parameter. az webapp connection create fabricsql -h Kör för att hämta de klienttyper som stöds och välj den som matchar ditt program.

Viktigt!

Manuell åtkomstdelning krävs för närvarande för fullständig registrering. Se Dela åtkomst till SQL-databas i 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

Det här service connector-kommandot slutför följande uppgifter i bakgrunden:

Aktivera systemtilldelad hanterad identitet eller tilldela en användaridentitet för appen $APPSERVICE_NAME som hanteras av Azure App Service/Azure Spring Apps/Azure Container Apps.
Aktivera Microsoft Entra-autentisering för databasservern om den inte är aktiverad tidigare.
Ange Microsoft Entra-administratören till den aktuella inloggade användaren.
Lägg till en databasanvändare för den systemtilldelade hanterade identiteten, användartilldelad hanterad identitet eller tjänstens huvudnamn. Bevilja alla behörigheter för databasen $DATABASE_NAME till den här användaren. Användarnamnet finns i anslutningssträng i föregående kommandoutdata.
Ange konfigurationer med namnet AZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRING, AZURE_SQL_CONNECTIONSTRINGeller FABRIC_SQL_CONNECTIONSTRING till Azure-resursen baserat på databastypen.
- För App Service anges konfigurationerna på bladet Appinställningar .
- För Spring Apps anges konfigurationerna när programmet startas.
- För Container Apps är konfigurationerna inställda på miljövariablerna. Du kan hämta alla konfigurationer och deras värden på bladet Tjänstanslutning i Azure-portalen.

Service Connector tilldelar följande behörigheter till användaren. Du kan återkalla dem och justera behörigheterna baserat på dina krav.

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"

Ansluta till en databas med Microsoft Entra-autentisering

När du har skapat anslutningen kan du använda anslutningssträng i ditt program för att ansluta till databasen med Microsoft Entra-autentisering. Du kan till exempel använda följande lösningar för att ansluta till databasen med Microsoft Entra-autentisering.

För .NET finns det inget plugin-program eller bibliotek som stöder lösenordslösa anslutningar. Du kan hämta en åtkomsttoken för den hanterade identiteten eller tjänstens huvudnamn med hjälp av klientbibliotek som Azure.Identity. Sedan kan du använda åtkomsttoken som lösenord för att ansluta till databasen. När du använder koden nedan avkommentarer du delen av kodfragmentet för den autentiseringstyp som du vill använda.

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

Lägg till följande beroenden i dinpom.xml-fil :

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

Hämta anslutningssträng från miljövariabler och lägg till plugin-namnet för att ansluta till databasen:

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

Mer information finns i följande resurser:

För ett Spring-program anger Service Connector egenskaperna --client-type springboot, spring.datasource.azure.passwordless-enabledoch spring.datasource.url till Azure Spring Apps om du skapar en anslutning med alternativet spring.datasource.username.

Uppdatera ditt program enligt handledningen Anslut en Azure Database for PostgreSQL till ditt program i Azure Spring Apps. Kom ihåg att ta bort konfigurationsegenskapen spring.datasource.password om den har angetts tidigare och lägga till rätt beroenden i Spring-programmet.

Fler självstudier finns i Använda Spring Data JDBC med Azure Database for PostgreSQL och Självstudie: Distribuera ett Spring-program till Azure Spring Apps med en lösenordslös anslutning till en Azure-databas.

Installera beroenden.

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

Hämta åtkomsttoken med hjälp av azure-identity biblioteket och använd token som lösenord. Hämta anslutningsinformation från miljövariablerna som lagts till av Service Connector. När du använder koden nedan avkommentarer du delen av kodfragmentet för den autentiseringstyp som du vill använda.

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)

Installera beroenden.
```
pip install azure-identity
```

Hämta åtkomsttoken med hjälp av azure-identity biblioteket med hjälp av miljövariabler som lagts till av Service Connector. När du använder koden nedan avkommentarer du delen av kodfragmentet för den autentiseringstyp som du vill använda.

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

I inställningsfilen hämtar du Azure PostgreSQL-databasinformation från miljövariabler som lagts till av Service Connector-tjänsten. Använd accessToken hämtad i föregående steg för att komma åt databasen.

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

Installera beroenden.

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"

I kod hämtar du åtkomsttoken med och azidentityanvänder den sedan som lösenord för att ansluta till Azure PostgreSQL tillsammans med anslutningsinformation som tillhandahålls av Service Connector. När du använder koden nedan avkommentarer du delen av kodfragmentet för den autentiseringstyp som du vill använda.

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

Installera beroenden.

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

I kod hämtar du åtkomsttoken med hjälp av @azure/identity och PostgreSQL-anslutningsinformation från miljövariabler som lagts till av Service Connector-tjänsten. Kombinera dem för att upprätta anslutningen. När du använder koden nedan avkommentarer du delen av kodfragmentet för den autentiseringstyp som du vill använda.

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

För PHP finns det inget plugin-program eller bibliotek för lösenordslösa anslutningar. Du kan hämta en åtkomsttoken för den hanterade identiteten eller tjänstens huvudnamn och använda den som lösenord för att ansluta till databasen. Åtkomsttoken kan hämtas med hjälp av Azure REST API.

I kod hämtar du åtkomsttoken med hjälp av REST API med ditt favoritbibliotek.

För användartilldelad identitet och systemtilldelad identitet tillhandahåller App Service och Container Apps en internt tillgänglig REST-slutpunkt för att hämta token för hanterade identiteter genom att definiera två miljövariabler: IDENTITY_ENDPOINT och IDENTITY_HEADER. Mer information finns i REST-slutpunktsreferens. Hämta åtkomsttoken genom att göra en HTTP GET-begäran till identitetsslutpunkten och använda https://ossrdbms-aad.database.windows.net som resource i frågan. För användartilldelad identitet ska du även inkludera klient-ID:t från miljövariablerna som lagts till av Service Connector i frågan.

För tjänstens huvudnamn, se azure AD-begäran om tjänst-till-tjänst-åtkomsttoken för att se information om hur du hämtar åtkomsttoken. Gör POST-begäran till omfånget https://ossrdbms-aad.database.windows.net/.default för och med klient-ID, klient-ID och klienthemlighet för tjänstens huvudnamn från miljövariablerna som lagts till av Service Connector.
Kombinera åtkomsttoken och PostgreSQL-anslutningssträngen från miljövariabler som lagts till av Service Connector-tjänsten för att upprätta anslutningen.
```
<?php
$conn_string = sprintf("%s password=", getenv('AZURE_POSTGRESQL_CONNECTIONSTRING'), $access_token);
$dbconn = pg_connect($conn_string);
?>
```

För Ruby finns det inget plugin-program eller bibliotek för lösenordslösa anslutningar. Du kan hämta en åtkomsttoken för den hanterade identiteten eller tjänstens huvudnamn och använda den som lösenord för att ansluta till databasen. Åtkomsttoken kan hämtas med hjälp av Azure REST API.

Installera beroenden.
```
gem install pg
```

I kod hämtar du åtkomsttoken med hjälp av REST API och PostgreSQL-anslutningsinformation från miljövariabler som lagts till av Service Connector-tjänsten. Kombinera dem för att upprätta anslutningen. När du använder koden nedan avkommentarer du delen av kodfragmentet för den autentiseringstyp som du vill använda.

App Service och containerAppar tillhandahåller en internt tillgänglig REST-slutpunkt för att hämta token för hanterade identiteter. Mer information finns i REST-slutpunktsreferens.

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

Mer information om hur du hämtar åtkomsttoken för tjänsthuvudnamn finns i begäran om tjänst-till-tjänst-åtkomsttoken i Azure AD.

Om du sedan har skapat tabeller och sekvenser i En flexibel PostgreSQL-server innan du använder Service Connector, måste du ansluta som ägare och bevilja behörighet till skapad <aad-username> av Service Connector. Användarnamnet från anslutningssträng eller konfigurationsuppsättningen i Service Connector bör se ut som aad_<connection name>. Om du använder Azure Portal väljer du knappen expandera bredvid Service Type kolumnen och hämtar värdet. Om du använder Azure CLI kontrollerar configurations du CLI-kommandoutdata.

Kör sedan frågan för att bevilja behörighet

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

Och <owner-username><owner-password> är ägare till den befintliga tabellen som kan bevilja behörigheter till andra. <aad-username> är användaren som skapats av Service Connector. Ersätt dem med det faktiska värdet.

Verifiera resultatet med kommandot :

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

Lägg till följande beroenden i dinpom.xml-fil :

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

Hämta anslutningssträng från miljövariabeln och lägg till plugin-namnet för att ansluta till databasen:

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

Mer information finns i Använda Java och JDBC med Azure Database for MySQL – flexibel server.

Uppdatera ditt program med hjälp av självstudien Koppla en Azure Database for MySQL-instans till ditt program i Azure Spring Apps. Kom ihåg att ta bort konfigurationsegenskapen spring.datasource.password om den har angetts tidigare och lägga till rätt beroenden i Spring-programmet.

Fler självstudier finns i Använda Spring Data JDBC med Azure Database for MySQL

Installera beroenden

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

Autentisera med åtkomsttoken hämta via azure-identity biblioteket och hämta anslutningsinformation från miljövariabeln som lagts till av Service Connector. När du använder koden nedan avkommentarer du delen av kodfragmentet för den autentiseringstyp som du vill använda.

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

Installera beroenden.
```
pip install azure-identity
```

Hämta åtkomsttoken via azure-identity biblioteket med miljövariablerna som lagts till av Service Connector. När du använder koden nedan avkommentarer du delen av kodfragmentet för den autentiseringstyp som du vill använda.

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

I inställningsfilen hämtar du Azure MySQL-databasinformation från miljövariabler som lagts till av Service Connector-tjänsten. Använd accessToken hämtad i föregående steg för att komma åt databasen.

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

Installera beroenden.

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"

I kod hämtar du åtkomsttoken via azidentityoch ansluter sedan till Azure MySQL med token. När du använder koden nedan avkommentarer du delen av kodfragmentet för den autentiseringstyp som du vill använda.

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

Installera beroenden

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

Hämta åtkomsttoken med hjälp av @azure/identity och Azure MySQL-databasinformation från miljövariabler som lagts till av Service Connector-tjänsten. När du använder koden nedan avkommentarer du delen av kodfragmentet för den autentiseringstyp som du vill använda.

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

Fler kodexempel finns i Ansluta till Azure-databaser från App Service utan hemligheter med hjälp av en hanterad identitet.

Installera beroenden.

dotnet add package Microsoft.Data.SqlClient

Hämta Azure SQL Database-anslutningssträng från miljövariabeln som lagts till av Service Connector.

using Microsoft.Data.SqlClient;

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

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

Mer information finns i Använda Active Directory-hanterad identitetsautentisering.

Lägg till följande beroenden i dinpom.xml-fil :

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

Hämta Azure SQL Database-anslutningssträng från miljövariabeln som lagts till av 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();
        }
    }
}

Mer information finns i Ansluta till Azure-databaser från App Service utan hemligheter med hjälp av en hanterad identitet.

För ett Spring-program anger Service Connector egenskaperna --client-type springboot med värdeformatet spring.datasource.url till Azure Spring Apps om du skapar en anslutning med alternativet jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI;.

Uppdatera ditt program genom att följa handledningen Migrera ett Java-program för att använda lösenordslösa anslutningar med Azure SQL Database. Kom ihåg att ta bort konfigurationsegenskapen spring.datasource.password om den angavs tidigare och lägga till rätt beroenden.

Installera beroenden.
```
python -m pip install pyodbc
```

Hämta Azure SQL Database-anslutningskonfigurationerna från miljövariabeln som lagts till av Service Connector. När du använder koden nedan avkommentarer du delen av kodfragmentet för den autentiseringstyp som du vill använda. Om du använder Azure Container Apps som beräkningstjänst eller om anslutningssträngen i kodfragmentet inte fungerar läser du Migrera ett Python-program för att använda lösenordslösa anslutningar med Azure SQL Database för att ansluta till Azure SQL Database med hjälp av en åtkomsttoken.

import os
import pyodbc

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

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

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

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

conn = pyodbc.connect(connString)

Installera beroenden.
```
npm install mssql
```

Hämta Azure SQL Database-anslutningskonfigurationerna från miljövariablerna som lagts till av Service Connector. När du använder koden nedan avkommentarer du delen av kodfragmentet för den autentiseringstyp som du vill använda.

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

Mer information finns på startsidan för klientprogrammering till Microsoft SQL Server.

Installera beroenden.

dotnet add package Microsoft.Data.SqlClient

Hämta SQL-databasen i Microsoft Fabric-anslutningssträngen från miljövariabeln som lagts till av Service Connector.

using Microsoft.Data.SqlClient;

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

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

Mer information finns i Använda Active Directory-hanterad identitetsautentisering.

Lägg till följande beroenden i dinpom.xml-fil :

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

Hämta SQL-databasen i Microsoft Fabric-anslutningssträngen från miljövariabeln som lagts till av 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();
        }
    }
}

Mer information finns i Ansluta till Azure-databaser från App Service utan hemligheter med hjälp av en hanterad identitet.

För ett Spring-program anger Service Connector miljövariabeln --client-type springboot med värdeformatet FABRIC_SQL_CONNECTIONSTRING till Azure Spring Apps om du skapar en anslutning med alternativet jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI;.

För användartilldelade hanterade identiteter msiClientId=<msiClientId>; läggs till.

spring:
  datasource:
    url: ${FABRIC_SQL_CONNECTIONSTRING}

Installera beroenden.
```
python -m pip install pyodbc
```

Hämta SQL-databasen i Microsoft Fabric-anslutningssträngen från miljövariabeln som lagts till av Service Connector. Om du använder Azure Container Apps som beräkningstjänst eller om anslutningssträngen i kodfragmentet inte fungerar kan du läsa Migrera ett Python-program för att använda lösenordslösa anslutningar med Azure SQL Database för att ansluta till SQL-databasen i Microsoft Fabric med lösenordslösa autentiseringsuppgifter. Authentication=ActiveDirectoryMSI; krävs i anslutningssträngen när du ansluter med hanterade identiteter. UID=<msiClientId> krävs också i anslutningssträngen när du ansluter med hjälp av en användartilldelad hanterad identitet.

import os
import pyodbc, struct
from azure.identity import DefaultAzureCredential

connStr = os.getenv('FABRIC_SQL_CONNECTIONSTRING')

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

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

conn = pyodbc.connect(connString)

Installera beroenden.

go mod init <YourProjectName>
go mod tidy

Hämta SQL-databasen i Microsoft Fabric-anslutningssträngen från miljövariabeln som lagts till av 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")
}

Mer information finns i Använda Golang för att fråga en databas i Azure SQL Database.

Mer information finns i Ansluta till din SQL-databas i Microsoft Fabric.

Distribuera programmet till en Azure-värdtjänst

Distribuera ditt program till en Azure-värdtjänst. Du kan också läsa guiderna nedan för mer information om hur du distribuerar dessa resurser.
- Azure App Service: Snabbstart: Utrulla en ASP.NET webbapplikation.
- Azure Container Apps: Snabbstart: Distribuera din första containerapp.
- Azure Spring Apps: Skapa och distribuera appen.
  
  Kommentar
  
  Basic-, Standard- och Enterprise-planerna gick in i en pensionsperiod den 17 mars 2025. Mer information finns i meddelandet om azure Spring Apps-pensionering.
Kontrollera loggen eller anropa programmet för att se om det kan ansluta till Azure-databasen.

Felsökning

Behörigheter

Om du stöter på behörighetsrelaterade fel bekräftar du den inloggade Azure CLI-användaren med kommandot az account show. Kontrollera att du loggar in med rätt konto. Bekräfta sedan att du har följande behörigheter som kan krävas för att skapa en lösenordslös anslutning med Service Connector.

Behörighet	Åtgärd
`Microsoft.DBforPostgreSQL/flexibleServers/read`	Krävs för att hämta information om databasservern
`Microsoft.DBforPostgreSQL/flexibleServers/write`	Krävs för att aktivera Microsoft Entra-autentisering för databasserver
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write`	Krävs för att skapa brandväggsregeln om den lokala IP-adressen blockeras
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete`	Krävs för att återställa brandväggsregeln som skapats av Service Connector för att undvika säkerhetsproblem
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/read`	Krävs för att kontrollera om Azure CLI-inloggningsanvändare är en Microsoft Entra-administratör för databasservern
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/write`	Krävs för att lägga till Azure CLI-inloggningsanvändare som databasservern Microsoft Entra-administratör

Behörighet	Åtgärd
`Microsoft.DBforMySQL/flexibleServers/read`	Krävs för att hämta information om databasservern
`Microsoft.DBforMySQL/flexibleServers/write`	Krävs för att lägga till den angivna användartilldelade hanterade identiteten till databasservern
`Microsoft.DBforMySQL/flexibleServers/firewallRules/write`	Krävs för att skapa brandväggsregeln om den lokala IP-adressen blockeras
`Microsoft.DBforMySQL/flexibleServers/firewallRules/delete`	Krävs för att återställa brandväggsregeln som skapats av Service Connector för att undvika säkerhetsproblem
`Microsoft.DBforMySQL/flexibleServers/administrators/read`	Krävs för att kontrollera om Azure CLI-inloggningsanvändare är en Microsoft Entra-administratör för databasservern
`Microsoft.DBforMySQL/flexibleServers/administrators/write`	Krävs för att lägga till Azure CLI-inloggningsanvändare som databasservern Microsoft Entra-administratör

Behörighet	Åtgärd
`Microsoft.Sql/servers/read`	Krävs för att hämta information om databasservern
`Microsoft.Sql/servers/firewallRules/write`	Krävs för att skapa brandväggsregeln om den lokala IP-adressen blockeras
`Microsoft.Sql/servers/firewallRules/delete`	Krävs för att återställa brandväggsregeln som skapats av Service Connector för att undvika säkerhetsproblem
`Microsoft.Sql/servers/administrators/read`	Krävs för att kontrollera om Azure CLI-inloggningsanvändare är en Microsoft Entra-administratör för databasservern
`Microsoft.Sql/servers/administrators/write`	Krävs för att lägga till Azure CLI-inloggningsanvändare som databasservern Microsoft Entra-administratör

I vissa fall krävs inte behörigheterna. Om den Azure CLI-autentiserade användaren till exempel redan är Active Directory-administratör på SQL-servern behöver du inte ha behörigheten Microsoft.Sql/servers/administrators/write .

Microsoft Entra-ID

Om du får ett fel ERROR: AADSTS530003: Your device is required to be managed to access this resource.ber du IT-avdelningen om hjälp med att ansluta den här enheten till Microsoft Entra-ID. Mer information finns i Microsoft Entra-anslutna enheter.

Service Connector måste ha åtkomst till Microsoft Entra-ID för att få information om ditt konto och din hanterade identitet för värdtjänsten. Du kan använda följande kommando för att kontrollera om enheten har åtkomst till Microsoft Entra-ID:

az ad signed-in-user show

Om du inte loggar in interaktivt kan du också få felet och Interactive authentication is needed. Lös felet genom att logga in med az login kommandot .

Nätverksanslutningar

Om databasservern finns i virtuellt nätverk kontrollerar du att din miljö som kör Azure CLI-kommandot kan komma åt servern i det virtuella nätverket.

Om databasservern inte tillåter offentlig åtkomst kontrollerar du att din miljö som kör Azure CLI-kommandot kan komma åt servern via den privata slutpunkten.

Nästa steg

Mer information om Service Connector och lösenordslösa anslutningar finns i följande resurser:

Dokumentation om Service Connector

Lösenordslösa anslutningar för Azure-tjänster

Feedback

Var den här sidan till hjälp?

Dela via

Självstudie: Skapa en lösenordslös anslutning till en databastjänst via Service Connector

Förutsättningar

Installera det lösenordslösa tillägget för Service Connector

Skapa en lösenordslös anslutning

Ansluta till en databas med Microsoft Entra-autentisering

Distribuera programmet till en Azure-värdtjänst

Felsökning

Behörigheter

Microsoft Entra-ID

Nätverksanslutningar

Nästa steg

Feedback

Ytterligare resurser