Poradnik: Połączenie się z bazami danych platformy Azure z usługi App Service bez tajemnic z użyciem tożsamości zarządzanej

1. Instalowanie zależności.

   dotnet add package Microsoft.Data.SqlClient
   

2. Pobierz parametry połączenia usługi Azure SQL Database ze zmiennej środowiskowej dodanej przez łącznik usługi.

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

   Aby uzyskać więcej informacji, zobacz Używanie uwierzytelniania tożsamości zarządzanej w usłudze Active Directory.

1. Dodaj następujące zależności w pliku pom.xml :

   <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. Pobierz parametry połączenia usługi Azure SQL Database ze zmiennej środowiskowej dodanej przez łącznik usługi.

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

Aby uzyskać więcej informacji, zobacz Connect using Microsoft Entra authentication (Łączenie przy użyciu uwierzytelniania firmy Microsoft Entra).

1. Instalowanie zależności.

   python -m pip install pyodbc
   

2. Pobierz konfiguracje połączeń usługi Azure SQL Database ze zmiennej środowiskowej dodanej przez łącznik usługi. Usuń komentarz ze fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

   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)
   

   Alternatywną metodą można również nawiązać połączenie z usługą Azure SQL Database przy użyciu tokenu dostępu, zobacz Migrowanie aplikacji języka Python w celu używania połączeń bez hasła z usługą Azure SQL Database.

1. Instalowanie zależności.

   npm install mssql
   

2. Pobierz konfiguracje połączeń usługi Azure SQL Database ze zmiennych środowiskowych dodanych przez łącznik usługi. Usuń komentarz ze fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.

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

W przypadku platformy .NET uzyskaj token dostępu dla tożsamości zarządzanej przy użyciu biblioteki klienta, takiej jak Azure.Identity. Następnie użyj tokenu dostępu jako hasła, aby nawiązać połączenie z bazą danych. Korzystając z poniższego kodu, upewnij się, że usuniesz komentarz z tej części kodu, która odpowiada typowi uwierzytelniania, którego chcesz użyć.

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. Dodaj następujące zależności w pliku pom.xml :

   <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. Pobierz parametry połączenia ze zmiennej środowiskowej i dodaj nazwę wtyczki, aby nawiązać połączenie z bazą danych:

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

Aby uzyskać więcej informacji, zobacz Używanie języków Java i JDBC z usługą Azure Database for MySQL — serwer elastyczny.

1. Instalowanie zależności.

   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. Uwierzytelnij się za pomocą tokenu dostępu z biblioteki azure-identity. Pobierz informacje o połączeniu ze zmiennej środowiskowej dodanej przez łącznik usługi. Korzystając z poniższego kodu, upewnij się, że usuniesz komentarz z tej części kodu, która odpowiada typowi uwierzytelniania, którego chcesz użyć.

   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. Instalowanie zależności.

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

2. Uzyskaj token dostępu, korzystając z @azure/identity oraz z informacji o bazie danych Azure MySQL pochodzących ze zmiennych środowiskowych dodanych przez Service Connector. Korzystając z poniższego kodu, upewnij się, że usuniesz komentarz z tej części kodu, która odpowiada typowi uwierzytelniania, którego chcesz użyć.

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

W przypadku platformy .NET uzyskaj token dostępu dla tożsamości zarządzanej przy użyciu biblioteki klienta, takiej jak Azure.Identity. Następnie użyj tokenu dostępu jako hasła, aby nawiązać połączenie z bazą danych. Korzystając z poniższego kodu, upewnij się, że usuniesz komentarz z tej części kodu, która odpowiada typowi uwierzytelniania, którego chcesz użyć.

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. Dodaj następujące zależności w pliku pom.xml :

   <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. Pobierz parametry połączenia ze zmiennych środowiskowych i dodaj nazwę wtyczki, aby nawiązać połączenie z bazą danych:

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

Aby uzyskać więcej informacji, zobacz następujące zasoby:

• Samouczek: nawiązanie połączenia z bazą danych PostgreSQL z usługi Tomcat App Service w języku Java bez użycia informacji poufnych przy użyciu tożsamości zarządzanej
• Szybki start: używanie języków Java i JDBC z usługą Azure Database for PostgreSQL — serwer elastyczny

1. Instalowanie zależności.

   pip install azure-identity
   pip install psycopg2-binary
   

2. Uwierzytelnij się przy użyciu tokenu dostępu z azure-identity biblioteki i użyj tokenu jako hasła. Pobierz informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi. Korzystając z poniższego kodu, upewnij się, że usuniesz komentarz z tej części kodu, która odpowiada typowi uwierzytelniania, którego chcesz użyć.

   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) 
   

Aby uzyskać więcej informacji, zobacz następujące zasoby:

• Tworzenie i wdrażanie aplikacji internetowej platformy Flask Python na platformie Azure przy użyciu tożsamości zarządzanej przypisanej przez system
• Tworzenie i wdrażanie aplikacji internetowej Django na platformie Azure przy użyciu tożsamości zarządzanej przypisanej przez użytkownika

1. Instalowanie zależności.

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

2. W kodzie uzyskaj token dostępu za pomocą @azure/identity oraz informacje o połączeniu PostgreSQL ze zmiennych środowiskowych dodanych przez usługę Service Connector. Połącz je, aby nawiązać połączenie. Korzystając z poniższego kodu, upewnij się, że usuniesz komentarz z tej części kodu, która odpowiada typowi uwierzytelniania, którego chcesz użyć.

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