Självstudie: Anslut till Azure-databaser från App Service utan hemligheter med hjälp av en hanterad identitet

Med App Service får du en automatiskt uppdaterad webbvärdtjänst i Azure med hög skalbarhet. Den tillhandahåller också en hanterad identitet för din app, vilket är en nyckelfärdig lösning för att skydda åtkomsten till Azure-databaser, inklusive:

• Azure SQL Database
• Azure Database for MySQL
• Azure Database for PostgreSQL

Kommentar

Den här självstudien innehåller inte vägledning för Azure Cosmos DB, som stöder Microsoft Entra-autentisering på olika sätt. Mer information finns i Azure Cosmos DB-dokumentationen, till exempel Använda systemtilldelade hanterade identiteter för att komma åt Azure Cosmos DB-data.

Med hanterade identiteter i App Service blir dina appar säkrare eftersom du inte har några hemligheter i dina appar. Du har till exempel inga inloggningsuppgifter i anslutningssträngarna. Den här självstudien visar hur du ansluter till ovan nämnda databaser från App Service med hjälp av hanterade identiteter.

Vad du kommer att lära dig:

• Konfigurera en Microsoft Entra-användare som administratör för din Azure-databas.
• Anslut till databasen som Microsoft Entra-användare.
• Konfigurera en systemtilldelad eller användartilldelad hanterad identitet för en App Service-app.
• Bevilja databasåtkomst till den hanterade identiteten.
• Anslut till Azure-databasen från din kod (.NET Framework 4.8, .NET 6, Node.js, Python, Java) med hjälp av en hanterad identitet.
• Anslut till Azure-databasen från utvecklingsmiljön med hjälp av Microsoft Entra-användaren.

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-konto innan du börjar.

Förutsättningar

• Skapa en app i App Service baserat på .NET, Node.js, Python eller Java.
• Skapa en databasserver med Azure SQL Database, Azure Database for MySQL eller Azure Database for PostgreSQL.
• Du bör känna till standardanslutningsmönstret (med användarnamn och lösenord) och kunna ansluta från din App Service-app till valfri databas.

Förbered din miljö för Azure CLI.

• Använd Bash-miljön i Azure Cloud Shell. Mer information finns i Snabbstart för Bash i Azure Cloud Shell.

  

• Om du föredrar att köra CLI-referenskommandon lokalt installerar du Azure CLI. Om du kör i Windows eller macOS kan du 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 hjälp av kommandot az login. Slutför autentiseringsprocessen genom att följa stegen som visas i terminalen. Andra inloggningsalternativ finns i Logga in med Azure CLI.

  • När du uppmanas att installera Azure CLI-tillägget vid första användningen. Mer information om tillägg finns i Använda tillägg med Azure CLI.

  • Kör az version om du vill hitta versionen och de beroende bibliotek som är installerade. Om du vill uppgradera till den senaste versionen kör du az upgrade.

1. Installera tjänsttillägget Anslut eller lösenordslöst tillägg

Installera tillägget Service Anslut eller passwordless för Azure CLI:

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

2. Skapa en lösenordslös anslutning

Skapa sedan en lösenordslös anslutning med Service Anslut or.

Dricks

Azure-portalen kan hjälpa dig att skriva kommandona nedan. I Azure-portalen går du till din Azure App Service-resurs, väljer Tjänst Anslut eller på den vänstra menyn och väljer Skapa. Fyll i formuläret med alla obligatoriska parametrar. Azure genererar automatiskt kommandot för att skapa anslutningar, som du kan kopiera för att använda i CLI eller köra i Azure Cloud Shell.

Azure SQL Database

Följande Azure CLI-kommando använder en --client-type parameter.

1. Du kan också köra az webapp connection create sql -h för att hämta klienttyper som stöds.

2. Välj en klienttyp och kör motsvarande kommando. Ersätt platshållarna nedan med din egen information.

   Användartilldelad hanterad identitet

   az webapp connection create sql \
       --resource-group <group-name> \
       --name <server-name> \
       --target-resource-group <sql-group-name> \
       --server <sql-name> \
       --database <database-name> \
       --user-identity client-id=<client-id> subs-id=<subscription-id> \
       --client-type <client-type>
   

   Systemtilldelad hanterad identitet

   az webapp connection create sql \
       --resource-group <group-name> \
       --name <server-name> \
       --target-resource-group <group-name> \
       --server <sql-name> \
       --database <database-name> \
       --system-identity \
       --client-type <client-type>
   

Azure Database for MySQL

Kommentar

För Azure Database for MySQL – flexibel server måste du först konfigurera Microsoft Entra-autentisering manuellt, vilket kräver en separat användartilldelad hanterad identitet och specifika Microsoft Graph-behörigheter. Det här steget kan inte automatiseras.

1. Konfigurera Microsoft Entra-autentisering manuellt för Azure Database for MySQL – flexibel server.

2. Du kan också köra kommandot az webapp connection create mysql-flexible -h för att hämta de klienttyper som stöds.

3. Välj en klienttyp och kör motsvarande kommando. Följande Azure CLI-kommando använder en --client-type parameter.

   Användartilldelad hanterad identitet

   az webapp connection create mysql-flexible \
       --resource-group <group-name> \
       --name <server-name> \
       --target-resource-group <group-name> \
       --server <mysql-name> \
       --database <database-name> \
       --user-identity client-id=XX subs-id=XX mysql-identity-id=$IDENTITY_RESOURCE_ID \
       --client-type <client-type>
   

   Systemtilldelad hanterad identitet

   az webapp connection create mysql-flexible \
   --resource-group <group-name> \
   --name <server-name> \
   --target-resource-group <group-name> \
   --server <mysql-name> \
   --database <database-name> \
   --system-identity mysql-identity-id=$IDENTITY_RESOURCE_ID \
   --client-type <client-type>
   

Azure Database for PostgreSQL

Följande Azure CLI-kommando använder en --client-type parameter.

1. Du kan också köra kommandot az webapp connection create postgres-flexible -h för att hämta en lista över alla klienttyper som stöds.

2. Välj en klienttyp och kör motsvarande kommando.

   Användartilldelad hanterad identitet

   az webapp connection create postgres-flexible \
       --resource-group <group-name> \
       --name <server-name> \
       --target-resource-group <group-name> \
       --server <postgresql-name> \
       --database <database-name> \
       --user-identity client-id=XX subs-id=XX \
       --client-type java
   

   Systemtilldelad hanterad identitet

   az webapp connection create postgres-flexible \
       --resource-group <group-name> \
       --name <server-name> \
       --target-resource-group <group-name> \
       --server <postgresql-name> \
       --database <database-name> \
       --system-identity \
       --client-type <client-type>
   

3. Bevilja behörighet till förskapade tabeller

Om du sedan har skapat tabeller och sekvenser i En flexibel PostgreSQL-server innan du använder Service Anslut or måste du ansluta som ägare och bevilja behörighet till skapad <aad-username> av Service Anslut or. Användarnamnet från anslutningssträng eller konfigurationen som anges av Service Anslut eller bör se ut som aad_<connection name>. Om du använder Azure-portalen 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 Anslut or. 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

Det här Anslut eller-kommandot för tjänsten slutför följande uppgifter i bakgrunden:

• Aktivera systemtilldelad hanterad identitet eller tilldela en användaridentitet för appen <server-name> som hanteras av Azure App Service.
• Ange Microsoft Entra-administratören till den aktuella inloggade användaren.
• Lägg till en databasanvändare för den systemtilldelade hanterade identiteten eller den användartilldelade hanterade identiteten. 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_CONNECTIONSTRINGeller AZURE_SQL_CONNECTIONSTRING till Azure-resursen baserat på databastypen.
• För App Service anges konfigurationerna på bladet App Inställningar.

Om du stöter på problem när du skapar en anslutning kan du läsa Felsökning för hjälp.

3. Ändra koden

Azure SQL Database

.NET

1. Installera beroenden.

   dotnet add package Microsoft.Data.SqlClient
   

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

   using Microsoft.Data.SqlClient;
   
   // AZURE_SQL_CONNECTIONSTRING should be one of the following:
   // For system-assigned managed identity:"Server=tcp:<server-name>.database.windows.net;Database=<database-name>;Authentication=Active Directory Default;TrustServerCertificate=True"
   // For user-assigned managed identity: "Server=tcp:<server-name>.database.windows.net;Database=<database-name>;Authentication=Active Directory Default;User Id=<client-id-of-user-assigned-identity>;TrustServerCertificate=True"
   
   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.

Java

1. Lägg till följande beroenden i din pom.xml-fil :

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

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

   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;"
           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 Anslut med Microsoft Entra-autentisering.

Python

1. Installera beroenden.

   python -m pip install pyodbc
   

2. Hämta Azure SQL Database-anslutningskonfigurationerna från miljövariabeln som lagts till av Service Anslut eller. Ta bort kommentaren till den del av kodfragmentet för den autentiseringstyp som du vill använda.

   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')  # The value should be 'ActiveDirectoryMsi'
   
   # Uncomment the following lines according to the authentication type.
   # For system-assigned managed identity.
   # connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server={server},{port};Database={database};Authentication={authentication};Encrypt=yes;'
   
   # For user-assigned managed identity.
   # client_id = os.getenv('AZURE_SQL_USER')
   # connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server={server},{port};Database={database};UID={client_id};Authentication={authentication};Encrypt=yes;'
   
   conn = pyodbc.connect(connString)
   

   En alternativ metod är att ansluta till Azure SQL Database med hjälp av en åtkomsttoken. Mer information finns i Migrera ett Python-program för att använda lösenordslösa anslutningar med Azure SQL Database.

NodeJS

1. Installera beroenden.

   npm install mssql
   

2. Hämta Azure SQL Database-anslutningskonfigurationerna från miljövariablerna som lagts till av Service Anslut eller. Ta bort kommentaren till den del 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 according to the authentication type.
   // For system-assigned managed identity.
   // const config = {
   //     server,
   //     port,
   //     database,
   //     authentication: {
   //         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
   //     }
   // };  
   
   this.poolconnection = await sql.connect(config);
   

Mer information finns på startsidan för klientprogrammering till Microsoft SQL Server. Fler kodexempel finns i Skapa en lösenordslös anslutning till en databastjänst via Service Anslut or.

Azure Database for MySQL

Anslut ivitet för Azure Database for MySQL i koden följer DefaultAzureCredential mönstret för alla språkstackar. DefaultAzureCredential är tillräckligt flexibel för att anpassas till både utvecklingsmiljön och Azure-miljön. När den körs lokalt kan den hämta den inloggade Azure-användaren från valfri miljö (Visual Studio, Visual Studio Code, Azure CLI eller Azure PowerShell). När den körs i Azure hämtas den hanterade identiteten. Därför är det möjligt att ha anslutning till databasen både vid utvecklingstillfället och i produktion. Mönstret är följande:

1. Instansiera en DefaultAzureCredential från Azure Identity-klientbiblioteket. Om du använder en användartilldelad identitet anger du identitetens klient-ID.
2. Hämta en åtkomsttoken för Azure Database for MySQL: https://ossrdbms-aad.database.windows.net/.default.
3. Lägg till token i din anslutningssträng.
4. Öppna anslutningen.

.NET

För .NET hämtar du en åtkomsttoken för den hanterade identiteten med hjälp av ett klientbibliotek som Azure.Identity. Använd sedan åtkomsttoken som ett lösenord för att ansluta till databasen. När du använder koden nedan ser du till att du avkommenterar den del av kodfragmentet som motsvarar den autentiseringstyp som du vill använda.

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

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

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

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

Java

1. Lägg till följande beroenden i din pom.xml-fil :

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

2. 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";
   Connection connection = DriverManager.getConnection(url + "&defaultAuthenticationPlugin=" +
       pluginName + "&authenticationPlugins=" + pluginName);
   

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

Python

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

2. Autentisera azure-identity med en åtkomsttoken från biblioteket. Hämta anslutningsinformationen från miljövariabeln som lagts till av Service Anslut or. När du använder koden nedan ser du till att du avkommenterar den del av kodfragmentet som motsvarar den autentiseringstyp som du vill använda.

   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   import mysql.connector
   import os
   
   # Uncomment the following lines according to the authentication type.
   # For system-assigned managed identity.
   # cred = ManagedIdentityCredential()    
   
   # For user-assigned managed identity.
   # managed_identity_client_id = os.getenv('AZURE_MYSQL_CLIENTID')
   # cred = ManagedIdentityCredential(client_id=managed_identity_client_id)
   
   # 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()
   
   

NodeJS

1. Installera beroenden.

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

2. Hämta en åtkomsttoken med hjälp av @azure/identity och Azure MySQL-databasinformationen från miljövariablerna som lagts till av Service Anslut or. När du använder koden nedan ser du till att du avkommenterar den del av kodfragmentet som motsvarar den autentiseringstyp som du vill använda.

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   
   const mysql = require('mysql2');
   
   // Uncomment the following lines according to the authentication type.
   // for system-assigned managed identity
   // const credential = new DefaultAzureCredential();
   
   // for user-assigned managed identity
   // const clientId = process.env.AZURE_MYSQL_CLIENTID;
   // const credential = new DefaultAzureCredential({
   //    managedIdentityClientId: clientId
   // });
   
   // 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 Skapa en lösenordslös anslutning till en databastjänst via Service Anslut or.

Azure Database for PostgreSQL

Anslut ivity to the Azure Database for PostgreSQL in your code (Azure Database for PostgreSQL) i koden följer DefaultAzureCredential mönstret för alla språkstackar. DefaultAzureCredential är tillräckligt flexibel för att anpassas till både utvecklingsmiljön och Azure-miljön. När den körs lokalt kan den hämta den inloggade Azure-användaren från valfri miljö (Visual Studio, Visual Studio Code, Azure CLI eller Azure PowerShell). När den körs i Azure hämtas den hanterade identiteten. Därför är det möjligt att ha anslutning till databasen både vid utvecklingstillfället och i produktion. Mönstret är följande:

1. Instansiera en DefaultAzureCredential från Azure Identity-klientbiblioteket. Om du använder en användartilldelad identitet anger du identitetens klient-ID.
2. Hämta en åtkomsttoken för Azure Database for PostgreSQL: https://ossrdbms-aad.database.windows.net/.default.
3. Lägg till token i din anslutningssträng.
4. Öppna anslutningen.

.NET

För .NET hämtar du en åtkomsttoken för den hanterade identiteten med hjälp av ett klientbibliotek som Azure.Identity. Använd sedan åtkomsttoken som ett lösenord för att ansluta till databasen. När du använder koden nedan ser du till att du avkommenterar den del av kodfragmentet som motsvarar den autentiseringstyp som du vill använda.

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

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

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

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

Java

1. Lägg till följande beroenden i din pom.xml-fil :

   <dependency>
       <groupId>org.postgresql</groupId>
       <artifactId>postgresql</artifactId>
       <version>42.3.6</version>
   </dependency>
   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity-extensions</artifactId>
       <version>1.1.5</version>
   </dependency>
   

2. Hämta anslutningssträng från miljövariablerna 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:

• Självstudie: Anslut till en PostgreSQL-databas från Java Tomcat App Service utan hemligheter med hjälp av en hanterad identitet
• Snabbstart: Använda Java och JDBC med Azure Database for PostgreSQL – flexibel server

Python

1. Installera beroenden.

   pip install azure-identity
   pip install psycopg2-binary
   

2. Autentisera azure-identity med en åtkomsttoken från biblioteket och använd token som lösenord. Hämta anslutningsinformationen från miljövariablerna som lagts till av Service Anslut eller. När du använder koden nedan ser du till att du avkommenterar den del av kodfragmentet som motsvarar den autentiseringstyp som du vill använda.

   from azure.identity import DefaultAzureCredential
   import psycopg2
   
   # Uncomment the following lines according to the authentication type.
   # For system-assigned identity.
   # cred = DefaultAzureCredential()
   
   # For user-assigned identity.
   # managed_identity_client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
   # cred = ManagedIdentityCredential(client_id=managed_identity_client_id)   
   
   # 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) 
   

NodeJS

1. Installera beroenden.

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

2. I kod hämtar du åtkomsttoken via @azure/identity och PostgreSQL-anslutningsinformation från miljövariabler som lagts till av Service Anslut eller-tjänsten. Kombinera dem för att upprätta anslutningen. När du använder koden nedan ser du till att du avkommenterar den del av kodfragmentet som motsvarar den autentiseringstyp som du vill använda.

   import { DefaultAzureCredential, ClientSecretCredential } from "@azure/identity";
   const { Client } = require('pg');
   
   // Uncomment the following lines according to the authentication type.  
   // For system-assigned identity.
   // const credential = new DefaultAzureCredential();
   
   // For user-assigned identity.
   // const clientId = process.env.AZURE_POSTGRESQL_CLIENTID;
   // const credential = new DefaultAzureCredential({
   //     managedIdentityClientId: clientId
   // });
   
   // 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();
   })();
   

Fler kodexempel finns i Skapa en lösenordslös anslutning till en databastjänst via Service Anslut or.

4. Konfigurera utvecklingsmiljön

Den här exempelkoden använder DefaultAzureCredential för att hämta en användbar token för din Azure-databas från Microsoft Entra-ID och lägger sedan till den i databasanslutningen. Även om du kan anpassa DefaultAzureCredentialär det redan mångsidigt som standard. Den hämtar en token från den inloggade Microsoft Entra-användaren eller från en hanterad identitet, beroende på om du kör den lokalt i utvecklingsmiljön eller i App Service.

Utan ytterligare ändringar är koden redo att köras i Azure. För att felsöka koden lokalt behöver dock utvecklingsmiljön en inloggad Microsoft Entra-användare. I det här steget konfigurerar du valfri miljö genom att logga in med din Microsoft Entra-användare.

Visual Studio Windows

1. Visual Studio för Windows är integrerat med Microsoft Entra-autentisering. Om du vill aktivera utveckling och felsökning i Visual Studio lägger du till din Microsoft Entra-användare i Visual Studio genom att välja Filkonto>Inställningar på menyn och välja Logga in eller Lägg till.

2. Om du vill ange Microsoft Entra-användaren för Azure-tjänstautentisering väljer du Verktygsalternativ> på menyn och väljer sedan Kontoval för Azure-tjänstautentisering.> Välj den Microsoft Entra-användare som du lade till och välj OK.

Visual Studio för macOS

1. Visual Studio för Mac är inte integrerat med Microsoft Entra-autentisering. Det Azure Identity-klientbibliotek som du ska använda senare kan dock också hämta token från Azure CLI. Om du vill aktivera utveckling och felsökning i Visual Studio installerar du Azure CLI på den lokala datorn.

2. Logga in på Azure CLI med följande kommando med din Microsoft Entra-användare:

   az login --allow-no-subscriptions
   

Visual Studio Code

1. Visual Studio Code är integrerat med Microsoft Entra-autentisering via Azure-tillägget. Installera Azure Tools-tillägget i Visual Studio Code.

2. I Visual Studio Code går du till aktivitetsfältet och väljer Azure-logotypen.

3. I App Service-utforskaren väljer du Logga in på Azure... och följer anvisningarna.

Azure CLI

1. Azure Identity-klientbiblioteket som du ska använda senare kan använda token från Azure CLI. Om du vill aktivera kommandoradsbaserad utveckling installerar du Azure CLI på den lokala datorn.

2. Logga in på Azure med följande kommando med din Microsoft Entra-användare:

   az login --allow-no-subscriptions
   

Azure PowerShell

1. Azure Identity-klientbiblioteket som du ska använda senare kan använda token från Azure PowerShell. Om du vill aktivera kommandoradsbaserad utveckling installerar du Azure PowerShell på den lokala datorn.

2. Logga in på Azure CLI med följande cmdlet med din Microsoft Entra-användare:

   Connect-AzAccount
   

Mer information om hur du konfigurerar utvecklingsmiljön för Microsoft Entra-autentisering finns i Azure Identity-klientbiblioteket för .NET.

Nu är du redo att utveckla och felsöka din app med SQL Database som serverdel med hjälp av Microsoft Entra-autentisering.

5. Testa och publicera

1. Kör koden i utvecklingsmiljön. Koden använder den inloggade Microsoft Entra-användaren i din miljö för att ansluta till serverdelsdatabasen. Användaren kan komma åt databasen eftersom den är konfigurerad som Microsoft Entra-administratör för databasen.

2. Publicera din kod till Azure med den föredragna publiceringsmetoden. I App Service använder koden appens hanterade identitet för att ansluta till serverdelsdatabasen.

Vanliga frågor och svar

• Stöder hanterad identitet SQL Server?
• Jag får felet Login failed for user '<token-identified principal>'.
• Jag har gjort ändringar i App Service-autentiseringen eller den associerade appregistreringen. Varför får jag fortfarande den gamla token?
• Hur gör jag för att lägga till den hanterade identiteten i en Microsoft Entra-grupp?
• Jag får felet SSL connection is required. Please specify SSL options and retry.

Stöder hanterad identitet SQL Server?

Microsoft Entra-ID och hanterade identiteter stöds inte för lokal SQL Server.

Jag får felet Login failed for user '<token-identified principal>'.

Den hanterade identitet som du försöker begära en token för har inte behörighet att komma åt Azure-databasen.

Jag har gjort ändringar i App Service-autentiseringen eller den associerade appregistreringen. Varför får jag fortfarande den gamla token?

Serverdelstjänsterna för hanterade identiteter har också en tokencache som uppdaterar token för en målresurs endast när den upphör att gälla. Om du ändrar konfigurationen efter att ha försökt hämta en token med din app får du inte någon ny token med de uppdaterade behörigheterna förrän den cachelagrade token upphör att gälla. Det bästa sättet att kringgå detta är att testa dina ändringar med ett nytt InPrivate-fönster (Edge)/privat (Safari)/Incognito (Chrome). På så sätt kommer du säkert att börja från en ny autentiserad session.

Hur gör jag för att lägga till den hanterade identiteten i en Microsoft Entra-grupp?

Om du vill kan du lägga till identiteten i en Microsoft Entra-grupp och sedan bevilja åtkomst till Microsoft Entra-gruppen i stället för identiteten. Följande kommandon lägger till den hanterade identiteten från föregående steg till en ny grupp med namnet myAzureSQLDBAccessGroup:

groupid=$(az ad group create --display-name myAzureSQLDBAccessGroup --mail-nickname myAzureSQLDBAccessGroup --query objectId --output tsv)
msiobjectid=$(az webapp identity show --resource-group <group-name> --name <app-name> --query principalId --output tsv)
az ad group member add --group $groupid --member-id $msiobjectid
az ad group member list -g $groupid

Information om hur du beviljar databasbehörigheter för en Microsoft Entra-grupp finns i dokumentationen för respektive databastyp.

Jag får felet SSL connection is required. Please specify SSL options and retry.

Anslut till Azure-databasen kräver ytterligare inställningar och ligger utanför omfånget för den här självstudien. Mer information finns i någon av följande länkar:

Konfigurera TLS-anslutning i Azure Database for PostgreSQL – KonfigureraSSL-anslutning i ditt program för säker anslutning till Azure Database for MySQL

Nästa steg

Vad du lärt dig:

• Konfigurera en Microsoft Entra-användare som administratör för din Azure-databas.
• Anslut till databasen som Microsoft Entra-användare.
• Konfigurera en systemtilldelad eller användartilldelad hanterad identitet för en App Service-app.
• Bevilja databasåtkomst till den hanterade identiteten.
• Anslut till Azure-databasen från din kod (.NET Framework 4.8, .NET 6, Node.js, Python, Java) med hjälp av en hanterad identitet.
• Anslut till Azure-databasen från utvecklingsmiljön med hjälp av Microsoft Entra-användaren.

Så här använder du hanterade identiteter för App Service och Azure Functions

Självstudie: Anslut till SQL Database från .NET App Service utan hemligheter med hjälp av en hanterad identitet

Självstudie: Anslut till Azure-tjänster som inte stöder hanterade identiteter (med Key Vault)

Självstudie: Isolera serverdelskommunikation med integrering av virtuellt nätverk