Tutorial: Criar uma conexão sem senha para um serviço de banco de dados via Service Connector

Artigo
10/22/2024

As conexões sem senha usam identidades gerenciadas para acessar os serviços do Azure. Com essa abordagem, você não precisa rastrear e gerenciar manualmente segredos para identidades gerenciadas. Essas tarefas são tratadas internamente com segurança pelo Azure.

O Service Connector habilita identidades gerenciadas em serviços de hospedagem de aplicativos, como Azure Spring Apps, Azure App Service e Azure Container Apps. O Service Connector também configura serviços de banco de dados, como o Banco de Dados do Azure para PostgreSQL, o Banco de Dados do Azure para MySQL e o Banco de Dados SQL do Azure, para aceitar identidades gerenciadas.

Neste tutorial, você usa a CLI do Azure para concluir as seguintes tarefas:

Verifique seu ambiente inicial com a CLI do Azure.
Crie uma conexão sem senha com o Service Connector.
Use as variáveis de ambiente ou configurações geradas pelo Service Connector para acessar um serviço de banco de dados.

Pré-requisitos

Azure CLI versão 2.61.0 ou superior.
Uma conta do Azure com uma subscrição ativa. Crie uma conta do Azure gratuitamente.
Um aplicativo implantado no Serviço de Aplicativo do Azure em uma região suportada pelo Service Connector.

Configurar o ambiente

Account

Entre com a CLI do Azure via az login. Se você estiver usando o Azure Cloud Shell ou já estiver conectado, confirme sua conta autenticada com az account show.

Instalar a extensão sem senha do Service Connector

Instale a extensão sem senha mais recente do Service Connector para a CLI do Azure:

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

Nota

Verifique se a extensão "serviceconnector-passwordless" versão é "2.0.2" ou superior executando az version. Talvez seja necessário atualizar a CLI do Azure primeiro para atualizar a versão da extensão.

Criar uma ligação sem palavra-passe

Em seguida, usamos o Serviço de Aplicativo do Azure como exemplo para criar uma conexão usando a identidade gerenciada.

Se utilizar:

Azure Spring Apps: use az spring connection create em vez disso. Para obter mais exemplos, consulte Conectar o Azure Spring Apps ao banco de dados do Azure.
Azure Container Apps: use az containerapp connection create em vez disso. Para obter mais exemplos, consulte Criar e conectar um banco de dados PostgreSQL com conectividade de identidade.

Nota

Se você usar o portal do Azure, vá para a folha Conector de Serviço do Serviço de Aplicativo do Azure, Azure Spring Apps ou Aplicativos de Contêiner do Azure e selecione Criar para criar uma conexão. O portal do Azure comporá automaticamente o comando para você e acionará a execução do comando no Cloud Shell.

O comando CLI do Azure a seguir usa um --client-type parâmetro, pode ser java, dotnet, python, etc. Execute o az webapp connection create postgres-flexible -h para obter os tipos de cliente suportados e escolha o que corresponde ao seu aplicativo.

az webapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $POSTGRESQL_HOST \
    --database $DATABASE_NAME \
    --user-identity client-id=XX subs-id=XX \
    --client-type $CLIENT_TYPE

az webapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $POSTGRESQL_HOST \
    --database $DATABASE_NAME \
    --system-identity \
    --client-type $CLIENT_TYPE

az webapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $POSTGRESQL_HOST \
    --database $DATABASE_NAME \
    --service-principal client-id=XX secret=XX\
    --client-type $CLIENT_TYPE

O Banco de Dados do Azure para MySQL - Servidor Flexível requer uma identidade gerenciada atribuída pelo usuário para habilitar a autenticação do Microsoft Entra. Para obter mais informações, consulte Configurar a autenticação do Microsoft Entra para o Banco de Dados do Azure para MySQL - Servidor Flexível. Você pode usar o seguinte comando para criar uma identidade gerenciada atribuída pelo usuário:

USER_IDENTITY_NAME=<YOUR_USER_ASSIGNED_MANAGEMED_IDENTITY_NAME>
IDENTITY_RESOURCE_ID=$(az identity create \
    --name $USER_IDENTITY_NAME \
    --resource-group $RESOURCE_GROUP \
    --query id \
    --output tsv)

Importante

Depois de criar a identidade gerenciada atribuída pelo usuário, peça ao seu Administrador Global ou Administrador de Função Privilegiada para conceder as seguintes permissões para essa identidade:

User.Read.All
GroupMember.Read.All
Application.Read.All

Para obter mais informações, consulte a seção Permissões da autenticação do Ative Directory.

Em seguida, conecte seu aplicativo a um banco de dados MySQL com uma identidade gerenciada atribuída ao sistema usando o Service Connector.

O comando da CLI do Azure a seguir usa um --client-type parâmetro. Execute o az webapp connection create mysql-flexible -h para obter os tipos de cliente suportados e escolha o que corresponde ao seu aplicativo.

az webapp connection create mysql-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $MYSQL_HOST \
    --database $DATABASE_NAME \
    --user-identity client-id=XX subs-id=XX mysql-identity-id=$IDENTITY_RESOURCE_ID \
    --client-type java

az webapp connection create mysql-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $MYSQL_HOST \
    --database $DATABASE_NAME \
    --system-identity mysql-identity-id=$IDENTITY_RESOURCE_ID \
    --client-type java

az webapp connection create mysql-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $MYSQL_HOST \
    --database $DATABASE_NAME \
    --service-principal client-id=XX secret=XX mysql-identity-id=$IDENTITY_RESOURCE_ID \
    --client-type java

O comando da CLI do Azure a seguir usa um --client-type parâmetro. Execute o az webapp connection create sql -h para obter os tipos de cliente suportados e escolha o que corresponde ao seu aplicativo.

az webapp connection create sql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $SQL_HOST \
    --database $DATABASE_NAME \
    --user-identity client-id=XX subs-id=XX \
    --client-type dotnet

az webapp connection create sql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $SQL_HOST \
    --database $DATABASE_NAME \
    --system-identity \
    --client-type dotnet

az webapp connection create sql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $SQL_HOST \
    --database $DATABASE_NAME \
    --service-principal client-id=XX secret=XX \
    --client-type dotnet

Este comando do Service Connector conclui as seguintes tarefas em segundo plano:

Habilite a identidade gerenciada atribuída ao sistema ou atribua uma identidade de usuário para o aplicativo $APPSERVICE_NAME hospedado pelo Serviço de Aplicativo do Azure/Azure Spring Apps/Azure Container Apps.
Habilite a Autenticação do Microsoft Entra para o servidor de banco de dados se ela não estiver habilitada antes.
Defina o administrador do Microsoft Entra como o usuário conectado atual.
Adicione um usuário de banco de dados para a identidade gerenciada atribuída ao sistema, a identidade gerenciada atribuída pelo usuário ou a entidade de serviço. 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 nomeadas 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.
- Para Spring Apps, as configurações são definidas quando o aplicativo é iniciado.
- Para Aplicativos de Contêiner, as configurações são definidas para as variáveis de ambiente. Você pode obter todas as configurações e seus valores na folha Service Connector no portal do Azure.

O Service Connector atribuirá os seguintes privilégios ao usuário, você poderá revogá-los e ajustar os privilégios com base em suas necessidades.

GRANT ALL PRIVILEGES ON DATABASE "$DATABASE_NAME" TO "username"; 

GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO "username"; 

GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO "username";


GRANT ALL PRIVILEGES ON $DATABASE_NAME.* TO 'username'@'%';

GRANT CONTROL ON DATABASE::"$DATABASE_NAME" TO "username";

Conectar-se a um banco de dados com a autenticação do Microsoft Entra

Depois de criar a conexão, você pode usar a cadeia de conexão em seu aplicativo para se conectar ao banco de dados com a autenticação do Microsoft Entra. Por exemplo, você pode usar as seguintes soluções para se conectar ao banco de dados com a autenticação do Microsoft Entra.

Para o .NET, não há um plug-in ou biblioteca para suportar conexões sem senha. Você pode obter um token de acesso para a identidade gerenciada ou entidade de serviço usando a biblioteca de cliente como Azure.Identity. Em seguida, você pode usar o token de acesso como senha para se conectar ao banco de dados. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

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

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

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

// For service principal.
// var tenantId = Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_TENANTID");
// var clientId = Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_CLIENTID");
// var clientSecret = Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_CLIENTSECRET");
// var sqlServerTokenProvider = new ClientSecretCredential(tenantId, clientId, clientSecret);

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

Adicione as seguintes dependências no 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>

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 obter mais informações, consulte os seguintes recursos:

Para um aplicativo Spring, se você criar uma conexão com a opção --client-type springboot, o Service Connector definirá as propriedades spring.datasource.azure.passwordless-enabled, spring.datasource.urle spring.datasource.username para Azure Spring Apps.

Atualize seu aplicativo seguindo o tutorial Vincular um Banco de Dados do Azure para PostgreSQL ao seu aplicativo no Azure Spring Apps. Lembre-se de remover a spring.datasource.password propriedade de configuração se ela tiver sido definida antes e adicionar as dependências corretas ao seu aplicativo Spring.

Para obter mais tutoriais, consulte Usar o Spring Data JDBC com o Banco de Dados do Azure para PostgreSQL e Tutorial: Implantar um aplicativo Spring no Azure Spring Apps com uma conexão sem senha para um banco de dados do Azure.

Instale dependências.

pip install azure-identity
pip install psycopg2-binary
pip freeze > requirements.txt # Save the dependencies to a file

Obtenha o token de acesso usando azure-identity a biblioteca e use o token como senha. Obtenha informações de conexão das variáveis de ambiente adicionadas pelo Service Connector. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

from azure.identity import DefaultAzureCredential
import psycopg2

# Uncomment the following lines corresponding to the authentication type you want to use.
# 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)   

# For service principal.
# tenant_id = os.getenv('AZURE_POSTGRESQL_TENANTID')
# client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
# client_secret = os.getenv('AZURE_POSTGRESQL_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

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

Instale dependências.
```
pip install azure-identity
```

Obtenha o token de acesso usando azure-identity a biblioteca usando variáveis de ambiente adicionadas pelo Service Connector. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

from azure.identity import DefaultAzureCredential
import psycopg2

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned identity.
# credential = DefaultAzureCredential()

# For user-assigned identity.
# managed_identity_client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
# cred = ManagedIdentityCredential(client_id=managed_identity_client_id)    

# For service principal.
# tenant_id = os.getenv('AZURE_POSTGRESQL_TENANTID')
# client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
# client_secret = os.getenv('AZURE_POSTGRESQL_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

# Acquire the access token.
accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')

No arquivo de configuração, obtenha informações do banco de dados PostgreSQL do Azure de variáveis de ambiente adicionadas pelo serviço Service Connector. Utilização accessToken adquirida no passo anterior para aceder à base de dados.

# In your setting file, eg. settings.py
host = os.getenv('AZURE_POSTGRESQL_HOST')
user = os.getenv('AZURE_POSTGRESQL_USER')
password = accessToken.token # this is accessToken acquired from above step.
database = os.getenv('AZURE_POSTGRESQL_NAME')

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': database,
        'USER': user,
        'PASSWORD': password,
        'HOST': host,
        'PORT': '5432',  # Port is 5432 by default 
        'OPTIONS': {'sslmode': 'require'},
    }
}

Instale dependências.

go get github.com/lib/pq
go get "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
go get "github.com/Azure/azure-sdk-for-go/sdk/azcore"

No código, obtenha o token de acesso usando azidentityo e, em seguida, use-o como senha para se conectar ao Azure PostgreSQL junto com as informações de conexão fornecidas pelo Service Connector. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

import (
"database/sql"
"fmt"
"os"

"context"

"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

 _ "github.com/lib/pq"
)    

// Uncomment the following lines corresponding to the authentication type you want to use.
// For system-assigned identity.
// cred, err := azidentity.NewDefaultAzureCredential(nil)

// For user-assigned identity.
// clientid := os.Getenv("AZURE_POSTGRESQL_CLIENTID")
// azidentity.ManagedIdentityCredentialOptions.ID := clientid
// options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
// cred, err := azidentity.NewManagedIdentityCredential(options)

// For service principal.
// clientid := os.Getenv("AZURE_POSTGRESQL_CLIENTID")
// tenantid := os.Getenv("AZURE_POSTGRESQL_TENANTID")
// clientsecret := os.Getenv("AZURE_POSTGRESQL_CLIENTSECRET")
// cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})

if err != nil {
    // error handling
}

// Acquire the access token
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
    Scopes: []string("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.
connectionString := os.Getenv("AZURE_POSTGRESQL_CONNECTIONSTRING") + " password=" + token.Token

conn, err := sql.Open("postgres", connectionString)
 if err != nil {
 	panic(err)
 }

 conn.Close()

Instale dependências.

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

No código, obtenha o token de acesso usando @azure/identity e informações de conexão PostgreSQL de variáveis de ambiente adicionadas pelo serviço Service Connector. Combine-os para estabelecer a conexão. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

import { DefaultAzureCredential, ClientSecretCredential } from "@azure/identity";
const { Client } = require('pg');

// Uncomment the following lines corresponding to the authentication type you want to use.  
// 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
// });

// For service principal.
// const tenantId = process.env.AZURE_POSTGRESQL_TENANTID;
// const clientId = process.env.AZURE_POSTGRESQL_CLIENTID;
// const clientSecret = process.env.AZURE_POSTGRESQL_CLIENTSECRET;

// 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 PHP, não há um plugin ou biblioteca para conexões sem senha. Você pode obter um token de acesso para a identidade gerenciada ou a entidade de serviço e usá-lo como senha para se conectar ao banco de dados. O token de acesso pode ser adquirido usando a API REST do Azure.

No código, obtenha o token de acesso usando a API REST com sua biblioteca favorita.

Para identidade atribuída pelo usuário e identidade atribuída pelo sistema, o Serviço de Aplicativo e os Aplicativos de Contêiner fornecem um ponto de extremidade REST acessível internamente para recuperar tokens para identidades gerenciadas definindo duas variáveis de ambiente: IDENTITY_ENDPOINT e IDENTITY_HEADER. Para obter mais informações, consulte Referência do ponto de extremidade REST. Obtenha o token de acesso fazendo uma solicitação HTTP GET para o ponto de extremidade de identidade e use https://ossrdbms-aad.database.windows.net como resource na consulta. Para identidade atribuída pelo usuário, inclua também o ID do cliente das variáveis de ambiente adicionadas pelo Service Connector na consulta.

Para entidade de serviço, consulte a solicitação de token de acesso de serviço a serviço do Azure AD para ver os detalhes de como adquirir o token de acesso. Faça da solicitação POST o escopo e com a ID do https://ossrdbms-aad.database.windows.net/.default locatário, a ID do cliente e o segredo do cliente da entidade de serviço a partir das variáveis de ambiente adicionadas pelo Service Connector.
Combine o token de acesso e a picada de conexão PostgreSQL de variáveis de ambiente adicionadas pelo serviço Service Connector para estabelecer a conexão.
```
<?php
$conn_string = sprintf("%s password=", getenv('AZURE_POSTGRESQL_CONNECTIONSTRING'), $access_token);
$dbconn = pg_connect($conn_string);
?>
```

Para Ruby, não há um plugin ou biblioteca para conexões sem senha. Você pode obter um token de acesso para a identidade gerenciada ou a entidade de serviço e usá-lo como senha para se conectar ao banco de dados. O token de acesso pode ser adquirido usando a API REST do Azure.

Instale dependências.
```
gem install pg
```

No código, obtenha o token de acesso usando a API REST e informações de conexão PostgreSQL de variáveis de ambiente adicionadas pelo serviço Service Connector. Combine-os para estabelecer a conexão. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

Serviço de aplicativo e contêiner Aplicativos fornecem um ponto de extremidade REST acessível internamente para recuperar tokens para identidades gerenciadas. Para obter mais informações, consulte Referência do ponto de extremidade REST.

require 'pg'
require 'dotenv/load'
require 'net/http'
require 'json'

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned identity.
# uri = URI(ENV['IDENTITY_ENDPOINT'] + '?resource=https://ossrdbms-aad.database.windows.net&api-version=2019-08-01')
# res = Net::HTTP.get_response(uri, {'X-IDENTITY-HEADER' => ENV['IDENTITY_HEADER'], 'Metadata' => 'true'})  

# For user-assigned identity.
# uri = URI(ENV[IDENTITY_ENDPOINT] + '?resource=https://ossrdbms-aad.database.windows.net&api-version=2019-08-01&client-id=' + ENV['AZURE_POSTGRESQL_CLIENTID'])
# res = Net::HTTP.get_response(uri, {'X-IDENTITY-HEADER' => ENV['IDENTITY_HEADER'], 'Metadata' => 'true'})  

# For service principal
# uri = URI('https://login.microsoftonline.com/' + ENV['AZURE_POSTGRESQL_TENANTID'] + '/oauth2/v2.0/token')
# params = {
#     :grant_type => 'client_credentials',
#     :client_id: => ENV['AZURE_POSTGRESQL_CLIENTID'],
#     :client_secret => ENV['AZURE_POSTGRESQL_CLIENTSECRET'],
#     :scope => 'https://ossrdbms-aad.database.windows.net/.default'
# }
# req = Net::HTTP::POST.new(uri)
# req.set_form_data(params)
# req['Content-Type'] = 'application/x-www-form-urlencoded'
# res = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|
#   http.request(req)

parsed = JSON.parse(res.body)
access_token = parsed["access_token"]

# Use the token and the connection string from the environment variables added by Service Connector to establish the connection.
conn = PG::Connection.new(
    connection_string: ENV['AZURE_POSTGRESQL_CONNECTIONSTRING'] + " password="  + access_token,
)

Consulte a solicitação de token de acesso de serviço a serviço do Azure AD para ver mais detalhes de como adquirir token de acesso para entidade de serviço.

Em seguida, se você criou tabelas e sequências no servidor flexível PostgreSQL antes de usar o Service Connector, precisará se conectar como proprietário e conceder permissão para <aad-username> criar pelo Service Connector. O nome de usuário da cadeia de conexão ou configuração definida pelo Service Connector deve se parecer com aad_<connection name>. Se você usar o portal do Azure, selecione o botão de expansão ao lado da Service Type coluna e obtenha o valor. Se você usar a CLI do Azure, verifique configurations a saída do comando 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 <owner-password> é o proprietário da tabela existente que pode conceder permissões a outras pessoas. <aad-username> é o usuário criado pelo Service Connector. Substitua-os pelo valor real.

Valide 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

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

// Uncomment the following lines corresponding to the authentication type you want to use.
// 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");
//     });

// For service principal.
// var tenantId = Environment.GetEnvironmentVariable("AZURE_MYSQL_TENANTID");
// var clientId = Environment.GetEnvironmentVariable("AZURE_MYSQL_CLIENTID");
// var clientSecret = Environment.GetEnvironmentVariable("AZURE_MYSQL_CLIENTSECRET");
// var credential = new ClientSecretCredential(tenantId, clientId, clientSecret);

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

Adicione as seguintes dependências no 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>

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, consulte Usar Java e JDBC com o Banco de Dados do Azure para MySQL - Servidor flexível.

Atualize seu aplicativo seguindo o tutorial Conectar uma instância do Banco de Dados do Azure para MySQL ao seu aplicativo no Azure Spring Apps. Lembre-se de remover a spring.datasource.password propriedade de configuração se ela tiver sido definida antes e adicionar as dependências corretas ao seu aplicativo Spring.

Para obter mais tutoriais, consulte Usar o Spring Data JDBC com o Banco de Dados do Azure para MySQL

Instalar 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

Autentique-se com token de acesso via azure-identity biblioteca e obtenha informações de conexão da variável de ambiente adicionada pelo Service Connector. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

from azure.identity import ManagedIdentityCredential, ClientSecretCredential
import mysql.connector
import os

# Uncomment the following lines corresponding to the authentication type you want to use.
# 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)

# For service principal
# tenant_id = os.getenv('AZURE_MYSQL_TENANTID')
# client_id = os.getenv('AZURE_MYSQL_CLIENTID')
# client_secret = os.getenv('AZURE_MYSQL_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

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

Instale dependências.
```
pip install azure-identity
```

Obtenha token de acesso via azure-identity biblioteca com as variáveis de ambiente adicionadas pelo Service Connector. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

from azure.identity import ManagedIdentityCredential, ClientSecretCredential
import os

# Uncomment the following lines corresponding to the authentication type you want to use.
# system-assigned managed identity
# cred = ManagedIdentityCredential()

# user-assigned managed identity
# managed_identity_client_id = os.getenv('AZURE_MYSQL_CLIENTID')
# cred = ManagedIdentityCredential(client_id=managed_identity_client_id)

# service principal
# tenant_id = os.getenv('AZURE_MYSQL_TENANTID')
# client_id = os.getenv('AZURE_MYSQL_CLIENTID')
# client_secret = os.getenv('AZURE_MYSQL_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

# acquire token
accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')

No arquivo de configuração, obtenha informações do banco de dados MySQL do Azure a partir de variáveis de ambiente adicionadas pelo serviço Service Connector. Utilização accessToken adquirida no passo anterior para aceder à base de dados.

# in your setting file, eg. settings.py
host = os.getenv('AZURE_MYSQL_HOST')
database = os.getenv('AZURE_MYSQL_NAME')
user = os.getenv('AZURE_MYSQL_USER')
password = accessToken.token # this is accessToken acquired from above step.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': database,
        'USER': user,
        'PASSWORD': password,
        'HOST': host
    }
}

Instale dependências.

go get "github.com/go-sql-driver/mysql"
go get "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
go get "github.com/Azure/azure-sdk-for-go/sdk/azcore"

No código, obtenha o token de acesso via e, em azidentityseguida, conecte-se ao Azure MySQL com o token. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

import (
  "context"

  "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
  "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
  "github.com/go-sql-driver/mysql"
)


func main() {

  // Uncomment the following lines corresponding to the authentication type you want to use.
  // for system-assigned managed identity
  // cred, err := azidentity.NewDefaultAzureCredential(nil)

  // for user-assigned managed identity
  // clientid := os.Getenv("AZURE_MYSQL_CLIENTID")
  // azidentity.ManagedIdentityCredentialOptions.ID := clientid
  // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
  // cred, err := azidentity.NewManagedIdentityCredential(options)

  // for service principal
  // clientid := os.Getenv("AZURE_MYSQL_CLIENTID")
  // tenantid := os.Getenv("AZURE_MYSQL_TENANTID")
  // clientsecret := os.Getenv("AZURE_MYSQL_CLIENTSECRET")
  // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})

  if err != nil {
  }

  ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
  token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
    Scopes: []string("https://ossrdbms-aad.database.windows.net/.default"),
  })

  connectionString := os.Getenv("AZURE_MYSQL_CONNECTIONSTRING") + ";Password=" + token.Token
  db, err := sql.Open("mysql", connectionString)
}

Instalar dependências

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

Obtenha o token de acesso usando @azure/identity as informações do banco de dados MySQL do Azure a partir de variáveis de ambiente adicionadas pelo serviço Service Connector. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar.

import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";

const mysql = require('mysql2');

// Uncomment the following lines corresponding to the authentication type you want to use.
// 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
// });

// for service principal
// const tenantId = process.env.AZURE_MYSQL_TENANTID;
// const clientId = process.env.AZURE_MYSQL_CLIENTID;
// const clientSecret = process.env.AZURE_MYSQL_CLIENTSECRET;
// const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);

// 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 obter mais exemplos de código, consulte Conectar-se a bancos de dados do Azure a partir do Serviço de Aplicativo sem segredos usando uma identidade gerenciada.

Instale dependências.

dotnet add package Microsoft.Data.SqlClient

Obtenha a cadeia de conexão do Banco de Dados SQL do Azure da variável de ambiente adicionada pelo Service Connector.
```
using Microsoft.Data.SqlClient;

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 Ative Directory.

Adicione as seguintes dependências no arquivo pom.xml :

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

Obtenha a cadeia de conexão do Banco de Dados SQL do Azure da variável de ambiente adicionada pelo Service Connector.

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;"
        // For service principal: "jdbc:sqlserver://{SQLName}.database.windows.net:1433;databaseName={SQLDbName};user={ServicePrincipalClientId};password={spSecret};authentication=ActiveDirectoryServicePrincipal;"
        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-se a bancos de dados do Azure a partir do Serviço de Aplicativo sem segredos usando uma identidade gerenciada.

Para um aplicativo Spring, se você criar uma conexão com a opção --client-type springboot, o Service Connector definirá as propriedades spring.datasource.url com formato jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; de valor como Azure Spring Apps.

Atualize seu aplicativo seguindo o tutorial Migrar um aplicativo Java para usar conexões sem senha com o Banco de Dados SQL do Azure. Lembre-se de remover a spring.datasource.password propriedade de configuração se ela tiver sido definida antes e adicionar as dependências corretas.

Instale dependências.
```
python -m pip install pyodbc
```

Obtenha as configurações de conexão do Banco de Dados SQL do Azure da variável de ambiente adicionada pelo Service Connector. Ao usar o código abaixo, descomente a parte do trecho de código para o tipo de autenticação que você deseja usar. Se você estiver usando Aplicativos de Contêiner do Azure como serviço de computação ou se a cadeia de conexão no trecho de código não funcionar, consulte Migrar um aplicativo Python para usar conexões sem senha com o Banco de Dados SQL do Azure para se conectar ao Banco de Dados SQL do Azure usando um token de acesso.

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

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned managed identity.
# connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server=tcp:{server},{port};Database={database};Authentication={authentication};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

# For user-assigned managed identity.
# clientID = os.getenv('AZURE_SQL_USER')
# connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server=tcp:{server},{port};Database={database};UID={clientID};Authentication={authentication};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

# For service principal.
# user = os.getenv('AZURE_SQL_USER')
# password = os.getenv('AZURE_SQL_PASSWORD')
# connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server=tcp:{server},{port};Database={database};UID={user};PWD={password};Authentication={authentication};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

conn = pyodbc.connect(connString)

Instale dependências.
```
npm install mssql
```

Obtenha as configurações de conexão do Banco de Dados SQL do Azure das variáveis de ambiente adicionadas pelo Service Connector. Ao usar o código abaixo, descomente a parte do trecho de código para o 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 corresponding to the authentication type you want to use.
// For system-assigned managed identity.
// const config = {
//     server,
//     port,
//     database,
//     authentication: {
//         type: 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
//     }
// };  

// For service principal.
// const clientId = process.env.AZURE_SQL_CLIENTID;
// const clientSecret = process.env.AZURE_SQL_CLIENTSECRET;
// const tenantId = process.env.AZURE_SQL_TENANTID;
// const config = {
//     server,
//     port,
//     database,
//     authentication: {
//         type: authenticationType
//     },
//     options: {
//         encrypt: true,
//         clientId: clientId,
//         clientSecret: clientSecret,
//         tenantId: tenantId
//     }
// };  

this.poolconnection = await sql.connect(config);

Para obter mais informações, consulte Homepage para programação de cliente para o Microsoft SQL Server.

Implantar o aplicativo em um serviço de hospedagem do Azure

Por fim, implante seu aplicativo em um serviço de hospedagem do Azure. Esse serviço de origem pode usar uma identidade gerenciada para se conectar ao banco de dados de destino no Azure.

Para o Serviço de Aplicativo do Azure, você pode verificar o documento para escolher uma maneira de implantar, consulte Guia de início rápido: implantar um aplicativo Web ASP.NET.

Em seguida, você pode verificar o log ou chamar o aplicativo para ver se ele pode se conectar ao banco de dados do Azure com êxito.

Resolução de Problemas

Permissão

Se você encontrar algum erro relacionado à permissão, confirme o usuário conectado da CLI do Azure com o comando az account show. Certifique-se de que inicia sessão com a conta correta. Em seguida, confirme se você tem as seguintes permissões que podem ser necessárias para criar uma conexão sem senha com o Service Connector.

Permissão	Operação
`Microsoft.DBforPostgreSQL/flexibleServers/read`	Necessário para obter informações do servidor de banco de dados
`Microsoft.DBforPostgreSQL/flexibleServers/write`	Necessário para habilitar a autenticação do Microsoft Entra para o servidor de banco de dados
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write`	Necessário para criar uma regra de firewall caso o endereço IP local seja bloqueado
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete`	Necessário para reverter a regra de firewall criada pelo Service Connector para evitar problemas de segurança
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/read`	Necessário para verificar se o usuário de logon da CLI do Azure é um administrador do Microsoft Entra do servidor de banco de dados
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/write`	Necessário para adicionar o usuário de logon da CLI do Azure como administrador do servidor de banco de dados Microsoft Entra

Permissão	Operação
`Microsoft.DBforMySQL/flexibleServers/read`	Necessário para obter informações do servidor de banco de dados
`Microsoft.DBforMySQL/flexibleServers/write`	Necessário para adicionar a identidade gerenciada atribuída ao usuário fornecida ao servidor de banco de dados
`Microsoft.DBforMySQL/flexibleServers/firewallRules/write`	Necessário para criar uma regra de firewall caso o endereço IP local seja bloqueado
`Microsoft.DBforMySQL/flexibleServers/firewallRules/delete`	Necessário para reverter a regra de firewall criada pelo Service Connector para evitar problemas de segurança
`Microsoft.DBforMySQL/flexibleServers/administrators/read`	Necessário para verificar se o usuário de logon da CLI do Azure é um administrador do Microsoft Entra do servidor de banco de dados
`Microsoft.DBforMySQL/flexibleServers/administrators/write`	Necessário para adicionar o usuário de logon da CLI do Azure como administrador do servidor de banco de dados Microsoft Entra

Permissão	Operação
`Microsoft.Sql/servers/read`	Necessário para obter informações do servidor de banco de dados
`Microsoft.Sql/servers/firewallRules/write`	Necessário para criar uma regra de firewall caso o endereço IP local seja bloqueado
`Microsoft.Sql/servers/firewallRules/delete`	Necessário para reverter a regra de firewall criada pelo Service Connector para evitar problemas de segurança
`Microsoft.Sql/servers/administrators/read`	Necessário para verificar se o usuário de logon da CLI do Azure é um administrador do Microsoft Entra do servidor de banco de dados
`Microsoft.Sql/servers/administrators/write`	Necessário para adicionar o usuário de logon da CLI do Azure como administrador do servidor de banco de dados Microsoft Entra

Em alguns casos, as permissões não são necessárias. Por exemplo, se o usuário autenticado pela CLI do Azure já for um Administrador do Ative Directory no SQL Server, você não precisará ter a Microsoft.Sql/servers/administrators/write permissão.

Microsoft Entra ID

Se você receber um erro ERROR: AADSTS530003: Your device is required to be managed to access this resource., peça ajuda ao seu departamento de TI para ingressar este dispositivo no Microsoft Entra ID. Para obter mais informações, consulte Microsoft Entra joined devices.

O Service Connector precisa acessar o Microsoft Entra ID para obter informações de sua conta e identidade gerenciada do serviço de hospedagem. Você pode usar o seguinte comando para verificar se seu dispositivo pode acessar o Microsoft Entra ID:

az ad signed-in-user show

Se você não fizer login interativamente, também poderá receber o erro e Interactive authentication is neededo . Para resolver o erro, faça login com o az login comando.

Conectividade de rede

Se o servidor de banco de dados estiver na Rede Virtual, verifique se o ambiente que executa o comando CLI do Azure pode acessar o servidor na Rede Virtual.

Se o servidor de banco de dados não permitir acesso público, certifique-se de que seu ambiente que executa o comando da CLI do Azure possa acessar o servidor por meio do ponto de extremidade privado.

Próximos passos

Para obter mais informações sobre o Service Connector e conexões sem senha, consulte os seguintes recursos:

Documentação do Service Connector

Conexões sem senha para serviços do Azure

Partilhar via

Tutorial: Criar uma conexão sem senha para um serviço de banco de dados via Service Connector

Pré-requisitos

Configurar o ambiente

Account

Instalar a extensão sem senha do Service Connector

Criar uma ligação sem palavra-passe

Conectar-se a um banco de dados com a autenticação do Microsoft Entra

Implantar o aplicativo em um serviço de hospedagem do Azure

Resolução de Problemas

Permissão

Microsoft Entra ID

Conectividade de rede

Próximos passos

Comentários

Recursos adicionais