Lernprogramm: Herstellen einer Verbindung mit Azure Datenbanken von App Service ohne geheime Schlüssel mithilfe einer verwalteten Identität

1. Installieren Sie Abhängigkeiten.

   dotnet add package Microsoft.Data.SqlClient
   

2. Rufen Sie die Azure SQL Database connection string aus der Umgebungsvariable ab, die von Service Connector hinzugefügt wurde.

   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 Using Active Directory Managed Identity Authentication.

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 Database connection string aus der Umgebungsvariable ab, die von Service Connector hinzugefügt wurde.

   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 Connect using Microsoft Entra authentication.

1. Installieren Sie Abhängigkeiten.

   python -m pip install mssql-python python-dotenv
   

2. Rufen Sie die Azure SQL Database 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
   from mssql_python import connect
   
   server = os.getenv('AZURE_SQL_SERVER')
   port = os.getenv('AZURE_SQL_PORT')
   database = os.getenv('AZURE_SQL_DATABASE')
   
   # Uncomment the following lines according to the authentication type.
   # For system-assigned managed identity.
   # connection_string = f'Server={server},{port};Database={database};Authentication=ActiveDirectoryMSI;Encrypt=yes;'
   
   # For user-assigned managed identity.
   # client_id = os.getenv('AZURE_SQL_USER')
   # connection_string = f'Server={server},{port};Database={database};UID={client_id};Authentication=ActiveDirectoryMSI;Encrypt=yes;'
   
   conn = connect(connection_string)
   

   Für eine alternative Methode können Sie auch mithilfe eines Zugriffstokens eine Verbindung mit Azure SQL Database herstellen, siehe Migrieren einer Python-Anwendung, um kennwortlose Verbindungen mit Azure SQL Database zu verwenden.

1. Installieren Sie Abhängigkeiten.

   npm install mssql
   

2. Rufen Sie die Azure SQL Database Verbindungskonfigurationen aus den Von Service Connector 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 Managed Identity mithilfe einer Client-Bibliothek 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.33</version>
   </dependency>
   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity-extensions</artifactId>
       <version>1.2.0</version>
   </dependency>
   

2. Rufen Sie die connection string aus der Umgebungsvariable 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 Use Java und JDBC with Azure Database for MySQL - Flexible 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 mit @azure/identity und den Azure MySQL-Datenbankinformationen aus den von Service Connector hinzugefügten Umgebungsvariablen ab. 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.7.5</version>
   </dependency>
   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity-extensions</artifactId>
       <version>1.2.0</version>
   </dependency>
   

2. Rufen Sie die connection string 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: Herstellen einer Verbindung mit einer PostgreSQL-Datenbank aus Java Tomcat App Service ohne geheime Schlüssel mithilfe einer verwalteten Identität
• Quickstart: Verwenden Sie 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 bereiten Sie eine Flask-Python-Webanwendung für Azure mit systemzugewiesener verwalteter Identität vor
• Erstellen und Bereitstellen einer Django-Webanwendung auf Azure mit einer benutzerzugewiesenen 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();
   })();