Tutorial: Verbindungsherstellung mit Azure-Datenbanken über App Service ohne Geheimnisse mithilfe einer verwalteten Identität

1. Installieren Sie Abhängigkeiten.

   dotnet add package Microsoft.Data.SqlClient
   

2. Rufen Sie die Azure SQL-Datenbank-Verbindungszeichenfolge aus der Umgebungsvariable ab, die vom Dienstconnector hinzugefügt wird.

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

   Weitere Informationen finden Sie unter Verwenden der Active Directory mit verwalteter Identität-Authentifizierung.

1. Fügen Sie der Datei pom.xml die folgenden Abhängigkeiten hinzu:

   <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. Rufen Sie die Azure SQL-Datenbank-Verbindungszeichenfolge aus der Umgebungsvariable ab, die vom Dienstconnector hinzugefügt wird.

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

Weitere Informationen finden Sie unter Herstellen einer Verbindung mithilfe der Microsoft Entra-Authentifizierung.

1. Installieren Sie Abhängigkeiten.

   python -m pip install pyodbc
   

2. Rufen Sie die Azure SQL-Datenbank-Verbindungskonfigurationen aus der Umgebungsvariable ab, die von Service Connector hinzugefügt wurde. Heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

   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)
   

   Alternativ können Sie auch mithilfe eines Zugriffstokens eine Verbindung mit Azure SQL-Datenbank herstellen. Entsprechende Informationen finden Sie unter Migrieren einer Python-Anwendung zur Verwendung kennwortloser Verbindungen mit Azure SQL-Datenbank.

1. Installieren Sie Abhängigkeiten.

   npm install mssql
   

2. Rufen Sie die Azure SQL-Datenbank-Verbindungskonfigurationen aus den vom Dienstconnector hinzugefügten Umgebungsvariablen ab. Heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

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

Rufen Sie für .NET ein Zugriffstoken für die verwaltete Identität mithilfe einer Clientbibliothek wie Azure.Identity ab. Verwenden Sie dann das Zugriffstoken als Kennwort, um eine Verbindung mit der Datenbank herzustellen. Stellen Sie bei Verwendung des folgenden Codes sicher, dass Sie den Teil des Codeausschnitts aufheben, der dem Authentifizierungstyp entspricht, den Sie verwenden möchten.

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

1. Fügen Sie der Datei pom.xml die folgenden Abhängigkeiten hinzu:

   <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. Rufen Sie die Verbindungszeichenfolge aus den Umgebungsvariablen ab, und fügen Sie den Plug-In-Namen hinzu, um eine Verbindung mit der Datenbank herzustellen:

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

Weitere Informationen finden Sie unter Verwenden von Java und JDBC mit Azure Database for MySQL – Flexibler Server.

1. Installieren Sie Abhängigkeiten.

   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. Authentifizieren sie sich mit einem Zugriffstoken aus der azure-identity-Bibliothek. Rufen Sie die Verbindungsinformationen aus der Umgebungsvariablen ab, die vom Dienstconnector hinzugefügt wurde. Stellen Sie bei Verwendung des folgenden Codes sicher, dass Sie den Teil des Codeausschnitts aufheben, der dem Authentifizierungstyp entspricht, den Sie verwenden möchten.

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

1. Installieren Sie Abhängigkeiten.

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

2. Rufen Sie ein Zugriffstoken mithilfe von @azure/identity und der Azure MySQL-Datenbank aus den Umgebungsvariablen ab, die vom Dienstconnector hinzugefügt wurde. Stellen Sie bei Verwendung des folgenden Codes sicher, dass Sie den Teil des Codeausschnitts aufheben, der dem Authentifizierungstyp entspricht, den Sie verwenden möchten.

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

Rufen Sie für .NET ein Zugriffstoken für die verwaltete Identität mithilfe einer Clientbibliothek wie Azure.Identity ab. Verwenden Sie dann das Zugriffstoken als Kennwort, um eine Verbindung mit der Datenbank herzustellen. Stellen Sie bei Verwendung des folgenden Codes sicher, dass Sie den Teil des Codeausschnitts aufheben, der dem Authentifizierungstyp entspricht, den Sie verwenden möchten.

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

1. Fügen Sie der Datei pom.xml die folgenden Abhängigkeiten hinzu:

   <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. Rufen Sie die Verbindungszeichenfolge aus den Umgebungsvariablen ab und fügen Sie den Plug-In-Namen hinzu, um eine Verbindung mit der Datenbank herzustellen:

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

Weitere Informationen finden Sie in den folgenden Ressourcen:

• Tutorial: Verbindungsherstellung mit einer PostgreSQL-Datenbank aus einem Java Tomcat App Service ohne Geheimnisse mithilfe einer verwalteten Identität
• Schnellstart: Verwenden von Java und JDBC mit Azure Database for PostgreSQL Flexible Server

1. Installieren Sie Abhängigkeiten.

   pip install azure-identity
   pip install psycopg2-binary
   

2. Authentifizieren Sie sich mit einem Zugriffstoken, das über die azure-identity-Bibliothek abgerufen und als Kennwort verwendet wird. Rufen Sie die Verbindungsinformationen aus den Umgebungsvariablen ab, die vom Dienstconnector hinzugefügt wurden. Stellen Sie bei Verwendung des folgenden Codes sicher, dass Sie den Teil des Codeausschnitts aufheben, der dem Authentifizierungstyp entspricht, den Sie verwenden möchten.

   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) 
   

Weitere Informationen finden Sie in den folgenden Ressourcen:

• Erstellen und Bereitstellen einer Flask Python-Web-App in Azure mit einer systemseitig zugewiesenen verwalteten Identität
• Erstellen und Bereitstellen einer Django-Web-App in Azure mit einer benutzerseitig zugewiesenen verwalteten Identität

1. Installieren Sie Abhängigkeiten.

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

2. Rufen Sie im Code das Zugriffstoken über @azure/identity und die PostgreSQL-Verbindungsinformationen aus Umgebungsvariablen ab, die vom Dienstconnector hinzugefügt wurden. Kombinieren Sie sie, um die Verbindung herzustellen. Stellen Sie bei Verwendung des folgenden Codes sicher, dass Sie den Teil des Codeausschnitts aufheben, der dem Authentifizierungstyp entspricht, den Sie verwenden möchten.

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