Tutorial: Conectar-se aos bancos de dados do Azure do Serviço de Aplicativo sem segredos usando uma identidade gerenciada

O Serviço de Aplicativo fornece um serviço de hospedagem na Web altamente escalonável e com aplicação automática de patches no Azure. Ele também fornece uma identidade gerenciada para seu aplicativo, que é uma solução perfeita para proteger o acesso aos bancos de dados do Azure, incluindo:

• Banco de Dados SQL do Azure
• Banco de Dados do Azure para MySQL
• Banco de Dados do Azure para PostgreSQL

Observação

Esse tutorial não inclui diretrizes para o Azure Cosmos DB, que dá suporte à autenticação do Microsoft Entra de forma diferente. Para obter mais informações, consulte a documentação do Azure Cosmos DB, como Usar identidades gerenciadas atribuídas pelo sistema para acessar dados do Azure Cosmos DB.

As identidades gerenciadas no Serviço de Aplicativo tornam seu aplicativo mais seguro, eliminando os segredos do aplicativo, como as credenciais nas cadeias de conexão. Este tutorial mostra como se conectar aos bancos de dados mencionados acima do Serviço de Aplicativo usando identidades gerenciadas.

O que você aprenderá:

• Configurar um usuário do Microsoft Entra como administrador do banco de dados do Azure.
• Conectar-se ao seu banco de dados como o usuário do Microsoft Entra.
• Configure uma identidade gerenciada atribuída pelo sistema ou pelo usuário aplicativo do Serviço de Aplicativo.
• Conceder ao banco de dados acesso à identidade gerenciada.
• Conecte-se ao banco de dados do Azure do código (.NET Framework 4.8, .NET 6, Node.js, Python, Java) usando uma identidade gerenciada.
• Conectar-se ao banco de dados do Azure do ambiente de desenvolvimento com o usuário do Microsoft Entra.

Caso você não tenha uma assinatura do Azure, crie uma conta gratuita do Azure antes de começar.

Pré-requisitos

• Crie um aplicativo no Serviço de Aplicativo com base em .NET, Node.js, Python ou Java.
• Crie um servidor de banco de dados com o Banco de Dados SQL do Azure, Banco de Dados do Azure para MySQL ou Banco de Dados do Azure para PostgreSQL.
• Você deve estar familiarizado com o padrão de conectividade padrão (com nome de usuário e senha) e ser capaz de se conectar com êxito do aplicativo do Serviço de Aplicativo ao banco de dados de sua escolha.

Prepare seu ambiente para a CLI do Azure.

• Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, confira Início Rápido para Bash no Azure Cloud Shell.

  

• Se preferir executar os comandos de referência da CLI localmente, instale a CLI do Azure. Para execuções no Windows ou no macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, confira Como executar a CLI do Azure em um contêiner do Docker.

  • Se estiver usando uma instalação local, entre com a CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga as etapas exibidas no terminal. Para ver outras opções de entrada, confira Conectar-se com a CLI do Azure.

  • Quando solicitado, instale a extensão da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar extensões com a CLI do Azure.

  • Execute az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para fazer a atualização para a versão mais recente, execute az upgrade.

1. Instalar a extensão sem senha do Conector de Serviço

Instale a extensão sem senha do Conector de Serviço para a CLI do Azure:

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

2. Criar a conexão sem senha

Depois, crie uma conexão sem senha com o Conector de Serviço.

Dica

O portal do Azure pode ajudar você a redigir os comandos abaixo. Na portal do Azure, acesse o recurso Serviço de Aplicativo do Azure, selecione Conector de Serviço no menu à esquerda e, em seguida, selecione Criar. Preencha o formulário com os parâmetros obrigatórios. O Azure gera automaticamente o comando de criação de conexão, que você pode copiar para usar na CLI ou executar no Azure Cloud Shell.

Banco de Dados SQL do Azure

O comando da CLI do Azure a seguir usa um parâmetro --client-type.

1. Opcionalmente, execute o az webapp connection create sql -h para obter os tipos de cliente com suporte.

2. Escolha um tipo de cliente e execute o comando correspondente. Substitua os espaços reservados abaixo pelas suas próprias informações.

   Identidade gerenciada atribuída pelo usuário

   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>
   

   Identidade gerenciada atribuída pelo sistema

   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>
   

Banco de Dados do Azure para MySQL

Observação

Para o Banco de Dados do Azure para MySQL – Servidor Flexível, primeiro você deve configurar manualmente a autenticação do Microsoft Entra, que requer uma identidade gerenciada atribuída pelo usuário separada e permissões específicas do Microsoft Graph. Esta etapa não pode ser automatizada.

1. Configure manualmente a autenticação do Microsoft Entra para o Banco de Dados do Azure para MySQL – Servidor Flexível.

2. Opcionalmente, execute o comando az webapp connection create mysql-flexible -h para obter os tipos de cliente com suporte.

3. Escolha um tipo de cliente e execute o comando correspondente. O comando da CLI do Azure a seguir usa um parâmetro --client-type.

   Identidade gerenciada atribuída pelo usuário

   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>
   

   Identidade gerenciada atribuída pelo sistema

   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>
   

Banco de Dados do Azure para PostgreSQL

O comando da CLI do Azure a seguir usa um parâmetro --client-type.

1. Opcionalmente, execute o comando az webapp connection create postgres-flexible -h para obter uma lista de todos os clientes com suporte.

2. Escolha um tipo de cliente e execute o comando correspondente.

   Identidade gerenciada atribuída pelo usuário

   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
   

   Identidade gerenciada atribuída pelo sistema

   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. Conceder permissão a tabelas criadas previamente

Em seguida, se você tiver criado tabelas e sequências no servidor flexível PostgreSQL, precisará se conectar como proprietário do banco de dados e conceder permissão a <aad-username> criado pelo Conector do Serviço. O nome de usuário da cadeia de conexão ou da configuração definida pelo Conector de Serviço deve ser semelhante a aad_<connection name>. Se você usar o portal do Azure, selecione o botão expandir ao lado da coluna Service Type e obtenha o valor. Se você usar a CLI do Azure, verifique configurations na saída do comando da CLI.

Em seguida, execute a consulta para conceder permissão

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

O <owner-username> e a <owner-password> são os proprietários da tabela existente que pode conceder permissão a outras pessoas. O <aad-username> é o usuário criado pelo Conector de Serviço. Substitua-os pelo valor real.

Você pode validar o resultado com o comando:

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

Esse comando do Conector de Serviço executa as seguintes tarefas em segundo plano:

• Habilite a identidade gerenciada atribuída pelo sistema ou atribua a identidade de usuário para o <server-name> do aplicativo hospedado pelo Serviço de Aplicativo do Azure.
• Defina o administrador do Microsoft Entra como o usuário conectado atual.
• Adicione um usuário do banco de dados para a identidade gerenciada atribuída pelo sistema ou identidade gerenciada atribuída pelo usuário. Conceda todos os privilégios do banco de dados <database-name> a esse usuário. O nome de usuário pode ser encontrado na cadeia de conexão na saída do comando anterior.
• Defina configurações chamadas AZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRINGou AZURE_SQL_CONNECTIONSTRING para o recurso do Azure com base no tipo de banco de dados.
• Para o Serviço de Aplicativo, as configurações são definidas na folha Configurações do Aplicativo.

Se ocorrer algum problema ao criar uma conexão, consulte Solução de problemas para obter ajuda.

3. Modificar seu código

Banco de Dados SQL do Azure

.NET

1. Instale as dependências.

   dotnet add package Microsoft.Data.SqlClient
   

2. Obtenha a cadeia de conexão do Banco de Dados SQL do Azure da variável de ambiente adicionada pelo Conector do Serviço.

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

   Para obter mais informações, consulte Usando a autenticação de Identidade Gerenciada do Active Directory.

Java

1. Adicione as dependências a seguir no seu arquivo 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. Obtenha a cadeia de conexão do Banco de Dados SQL do Azure da variável de ambiente adicionada pelo Conector do Serviço.

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

Para obter mais informações, consulte Conectar usando a autenticação do Microsoft Entra.

Python

1. Instale as dependências.

   python -m pip install pyodbc
   

2. Obtenha as configurações de conexão do Banco de Dados SQL do Azure da variável de ambiente adicionada pelo Conector de Serviço. Remova o comentário da parte do snippet de código referente ao tipo de autenticação que você deseja usar.

   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)
   

   Para obter um método alternativo, você também pode se conectar ao Banco de Dados SQL do Azure usando um token de acesso. Consulte Migrar um aplicativo Python para usar conexões sem senha com o Banco de Dados SQL do Azure.

NodeJS

1. Instale as dependências.

   npm install mssql
   

2. Obtenha as configurações de conexão do Banco de Dados SQL do Azure das variáveis de ambiente adicionadas pelo Conector de Serviço. Remova o comentário da parte do snippet de código referente ao tipo de autenticação que você deseja usar.

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

Para obter mais informações, confira Página inicial para a programação de cliente para o Microsoft SQL Server. Para mais exemplos de código, consulte Criar uma conexão sem senha para um serviço de banco de dados por meio do Conector de Serviço.

Banco de Dados do Azure para MySQL

A conectividade com a Banco de Dados do Azure para MySQL no seu código segue o padrão DefaultAzureCredential para todas as pilhas de idiomas. DefaultAzureCredential é flexível o suficiente para se adaptar ao ambiente de desenvolvimento e ao ambiente do Azure. Ao executar localmente, ele pode recuperar o usuário conectado do Azure do ambiente de sua escolha (Visual Studio, Visual Studio Code, CLI do Azure ou Azure PowerShell). Ao executar no Azure, ele recupera a identidade gerenciada. Portanto, é possível ter conectividade com o banco de dados no tempo de desenvolvimento e em produção. O padrão é o seguinte:

1. Crie uma instância DefaultAzureCredential da biblioteca de clientes da Identidade do Azure. Se você estiver usando uma identidade atribuída pelo usuário, especifique a ID do cliente da identidade.
2. Obtenha um token de acesso para o Banco de Dados do Azure para MySQL: https://ossrdbms-aad.database.windows.net/.default.
3. Adicione o token à cadeia de conexão.
4. Abra a conexão.

.NET

Para .NET, você pode obter um token de acesso para a identidade gerenciada utilizando uma biblioteca de clientes como Azure.Identity. Depois, utilize o token de acesso como uma senha para se conectar ao banco de dados. Ao usar o código abaixo, remova a marca de comentário da parte do snippet de código que corresponde ao tipo de autenticação que você quer usar.

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. Adicione as dependências a seguir no seu arquivo pom.xml:

   <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. Obtenha a cadeia de conexão da variável de ambiente e adicione o nome do plug-in para se conectar ao banco de dados:

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

Para obter mais informações, confira Usar o Java e o JDBC com o Banco de Dados do Azure para MySQL com Servidor Flexível.

Python

1. Instale as dependências.

   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. Autentique-se com um token de acesso da biblioteca azure-identity. Obtenha informações de conexão da variável de ambiente adicionada pelo Conector de Serviço. Ao usar o código abaixo, remova a marca de comentário da parte do snippet de código que corresponde ao tipo de autenticação que você quer usar.

   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. Instale as dependências.

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

2. Obtenha um token de acesso usando @azure/identity e as informações do banco de dados MySQL do Azure de variáveis de ambiente adicionadas pelo Conector de Serviço. Ao usar o código abaixo, remova a marca de comentário da parte do snippet de código que corresponde ao tipo de autenticação que você quer usar.

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

Para mais exemplos de código, consulte Criar uma conexão sem senha para um serviço de banco de dados por meio do Conector de Serviço.

Banco de Dados do Azure para PostgreSQL

A conectividade com a Base de Dados Azure para PostgreSQL no seu código segue o padrão DefaultAzureCredential para todas as pilhas de idiomas. DefaultAzureCredential é flexível o suficiente para se adaptar ao ambiente de desenvolvimento e ao ambiente do Azure. Ao executar localmente, ele pode recuperar o usuário conectado do Azure do ambiente de sua escolha (Visual Studio, Visual Studio Code, CLI do Azure ou Azure PowerShell). Ao executar no Azure, ele recupera a identidade gerenciada. Portanto, é possível ter conectividade com o banco de dados no tempo de desenvolvimento e em produção. O padrão é o seguinte:

1. Crie uma instância DefaultAzureCredential da biblioteca de clientes da Identidade do Azure. Se você estiver usando uma identidade atribuída pelo usuário, especifique a ID do cliente da identidade.
2. Obtenha um token de acesso para o Banco de Dados do Azure para PostgreSQL: https://ossrdbms-aad.database.windows.net/.default.
3. Adicione o token à cadeia de conexão.
4. Abra a conexão.

.NET

Para .NET, você pode obter um token de acesso para a identidade gerenciada utilizando uma biblioteca de clientes como Azure.Identity. Depois, utilize o token de acesso como uma senha para se conectar ao banco de dados. Ao usar o código abaixo, remova a marca de comentário da parte do snippet de código que corresponde ao tipo de autenticação que você quer usar.

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. Adicione as dependências a seguir no seu arquivo pom.xml:

   <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. Obtenha a cadeia de conexão das variáveis de ambiente e adicione o nome do plug-in para se conectar ao banco de dados:

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

Para saber mais, consulte os recursos a seguir:

• Tutorial: Conectar-se ao Banco de Dados PostgreSQL do Serviço de Aplicativo Java Tomcat sem segredos usando uma identidade gerenciada
• Início rápido: Usar o Java e o JDBC com o Servidor Flexível do Banco de Dados do Azure para PostgreSQL

Python

1. Instale as dependências.

   pip install azure-identity
   pip install psycopg2-binary
   

2. Autentique-se com um token de acesso da biblioteca azure-identity e utilize o token como senha. Obtenha as informações de conexão das variáveis de ambiente adicionadas pelo Conector de Serviço. Ao usar o código abaixo, remova a marca de comentário da parte do snippet de código que corresponde ao tipo de autenticação que você quer usar.

   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. Instale as dependências.

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

2. No código, obtenha o token de acesso via @azure/identity e as informações de conexão do PostgreSQL das variáveis de ambiente adicionadas pelo serviço Conector de Serviço. Conectar-se a eles para estabelecer a conexão. Ao usar o código abaixo, remova a marca de comentário da parte do snippet de código que corresponde ao tipo de autenticação que você quer usar.

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

Para mais exemplos de código, consulte Criar uma conexão sem senha para um serviço de banco de dados por meio do Conector de Serviço.

4. Configurar o ambiente de desenvolvimento

Esse código de exemplo usa DefaultAzureCredential para obter um token que pode ser usado para seu banco de dados do Microsoft Entra ID e, em seguida, adiciona-o à conexão de banco de dados. Embora você possa personalizar DefaultAzureCredential, por padrão, ele já é versátil. Ele obtém um token do usuário conectado do Microsoft Entra ou de uma identidade gerenciada, dependendo se você o executa localmente em seu ambiente de desenvolvimento ou no Serviço de Aplicativo.

Sem alterações adicionais, o código está pronto para ser executado no Azure. Para depurar seu código localmente, no entanto, seu ambiente de desenvolvimento precisa de um usuário conectado do Microsoft Entra. Nessa etapa, você configurará seu ambiente de escolha se conectando com seu usuário do Microsoft Entra.

Visual Studio para Windows

1. O Visual Studio para Windows é integrado à autenticação do Microsoft Entra. Para habilitar o desenvolvimento e a depuração no Visual Studio, adicione seu usuário do Microsoft Entra no Visual Studio selecionando Arquivo>Configurações de Conta no menu e, a seguir, selecione Entrar ou Adicionar.

2. Para configurar o usuário do Microsoft Entra para a autenticação do serviço do Azure, selecione Ferramentas>Opções no menu e, em seguida, selecione Autenticação do Serviço do Azure>Seleção de Conta. Selecione o usuário do Microsoft Entra que você adicionou e selecione OK.

Visual Studio para macOS

1. O Visual Studio para Mac não é integrado à autenticação do Microsoft Entra. No entanto, a biblioteca de clientes da Identidade do Azure que você usará posteriormente também pode recuperar tokens da CLI do Azure. Para permitir o desenvolvimento e a depuração no Visual Studio, instale a CLI do Azure no computador local.

2. Entre na CLI do Azure com o comando a seguir usando seu usuário do Microsoft Entra:

   az login --allow-no-subscriptions
   

Visual Studio Code

1. O Visual Studio Code é integrado com a autenticação do Microsoft Entra por meio da extensão do Azure. Instale a extensão Ferramentas do Azure no Visual Studio Code.

2. No Visual Studio Code, na Barra de Atividade, clique no logotipo Azure.

3. No explorador Serviço de Aplicativo, clique em Entrar no Azure... e siga as instruções.

CLI do Azure

1. A biblioteca de clientes da Identidade do Azure que você usará posteriormente pode usar tokens da CLI do Azure. Para habilitar o desenvolvimento baseado em linha de comando, instale a CLI do Azure em seu computador local.

2. Entre no Azure com o seguinte comando, usando seu usuário do Microsoft Entra:

   az login --allow-no-subscriptions
   

PowerShell do Azure

1. No entanto, a biblioteca de clientes da Identidade do Azure que você usará posteriormente pode usar tokens do Azure PowerShell. Para habilitar o desenvolvimento baseado em linha de comando, instale o Azure PowerShell em seu computador local.

2. Entre na CLI do Azure com o seguinte cmdlet por meio do seu usuário do Microsoft Entra:

   Connect-AzAccount
   

Para obter mais informações sobre como configurar seu ambiente de desenvolvimento para a autenticação do Microsoft Entra, confira Biblioteca de clientes da Identidade do Azure para .NET.

Agora você está pronto para desenvolver e depurar seu aplicativo com o banco de dados SQL como back-end, usando a autenticação do Microsoft Entra.

5. Testar e publicar

1. Execute seu código em seu ambiente de desenvolvimento. Seu código usa o usuário conectado do Microsoft Entra em seu ambiente para se conectar ao banco de dados de back-end. O usuário pode acessar o banco de dados porque ele está configurado como um administrador do Microsoft Entra para o banco de dados.

2. Publique seu código no Azure usando o método de publicação preferencial. No Serviço de Aplicativo, o código usa a identidade gerenciada do aplicativo para se conectar ao banco de dados de back-end.

Perguntas frequentes

• A identidade gerenciada dá suporte ao SQL Server?
• Eu recebo o erro Login failed for user '<token-identified principal>'.
• Fiz alterações na autenticação do Serviço de Aplicativo ou no registro de aplicativo associado. Por que ainda recebo o token antigo?
• Como adicionar a identidade gerenciada a um grupo do Microsoft Entra?
• Eu recebo o erro SSL connection is required. Please specify SSL options and retry.

A identidade gerenciada dá suporte ao SQL Server?

Não há suporte para o Microsoft Entra ID nem para identidades gerenciadas no SQL Server local.

Eu recebo o erro Login failed for user '<token-identified principal>'.

A identidade gerenciada para a qual você está tentando solicitar um token não está autorizada a acessar o banco de dados do Azure.

Fiz alterações na autenticação do Serviço de Aplicativo ou no registro de aplicativo associado. Por que ainda recebo o token antigo?

Os serviços de back-end das identidades gerenciadas também mantêm um cache de token que atualiza o token para um recurso de destino somente quando ele expira. Se você modificar a configuração depois de tentar obter um token com o seu aplicativo, você não obterá um novo token com as permissões atualizadas até que o token armazenado em cache expire. A melhor maneira de contornar isso é testar suas alterações com uma nova janela InPrivate (Edge)/private (Safari)/Incognito (Chrome). Dessa forma, você certamente começará a partir de uma nova sessão autenticada.

Como adicionar a identidade gerenciada a um grupo do Microsoft Entra?

Se quiser, você pode adicionar a identidade a um grupo do Microsoft Entra e conceder acesso ao grupo do Microsoft Entra em vez da identidade. Por exemplo, os comandos a seguir adicionam a identidade gerenciada da etapa anterior a um novo grupo chamado 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

Para conceder permissões de banco de dados para um grupo do Microsoft Entra, consulte a documentação do respectivo tipo de banco de dados.

Eu recebo o erro SSL connection is required. Please specify SSL options and retry.

A conexão ao banco de dados do Azure requer configurações adicionais e está fora do escopo deste tutorial. Para obter mais informações, consulte um dos seguintes links:

Configurar a conectividade TLS no Banco de Dados do Azure para PostgreSQL – Servidor ÚnicoConfigurar a conectividade SSL em seu aplicativo para se conectar com segurança ao Banco de Dados do Azure para MySQL

Próximas etapas

O que você aprendeu:

• Configurar um usuário do Microsoft Entra como administrador do banco de dados do Azure.
• Conectar-se ao seu banco de dados como o usuário do Microsoft Entra.
• Configure uma identidade gerenciada atribuída pelo sistema ou pelo usuário aplicativo do Serviço de Aplicativo.
• Conceder ao banco de dados acesso à identidade gerenciada.
• Conecte-se ao banco de dados do Azure do código (.NET Framework 4.8, .NET 6, Node.js, Python, Java) usando uma identidade gerenciada.
• Conectar-se ao banco de dados do Azure do ambiente de desenvolvimento com o usuário do Microsoft Entra.

Como usar identidades gerenciadas para o Serviço de Aplicativo e o Azure Functions

Tutorial: Conectar-se ao Banco de Dados SQL do Serviço de Aplicativo .NET sem segredos usando uma identidade gerenciada

Tutorial: Conexão aos serviços do Azure que não dão suporte a identidades gerenciadas (usando Key Vault)

Tutorial: Isolar a comunicação de back-end com a integração da Rede Virtual