Tutorial: Criar uma conexão sem senha com um serviço de banco de dados por meio do Conector de Serviço

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 os segredos de identidades gerenciadas. O Azure lida com essas tarefas internamente com segurança.

O Service Connector permite identidades gerenciadas em serviços de hospedagem de aplicativos, como Aplicativos Spring do Azure e Serviço de Aplicativo do Azure. 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, o Banco de Dados SQL do Azure e o Banco de Dados SQL no Microsoft Fabric, para aceitar identidades gerenciadas.

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

Verificar seu ambiente inicial com a CLI do Azure.
Criar uma conexão sem senha com o Conector de Serviço.
Usar as variáveis de ambiente ou as configurações geradas pelo Conector de Serviço para acessar um serviço de banco de dados.

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Criar uma conta do Azure gratuitamente.
Um aplicativo implantado no Serviço de Aplicativo do Azure em uma região com suporte do Conector de Serviço.
CLI do Azure versão 2.61.0 ou posterior.

Para começar a usar a CLI do Azure:

Utilize o ambiente Bash no Azure Cloud Shell. Para obter mais informações, confira Introdução ao Azure Cloud Shell.
Se preferir executar os comandos de referência da CLI localmente, instale a CLI do Azure. Se você estiver executando 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 você estiver usando uma instalação local, entre na CLI do Azure usando o comando az login . Para concluir o processo de autenticação, siga as etapas exibidas em seu terminal. Para obter outras opções de entrada, consulte Autenticar no Azure usando 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 e gerenciar extensões com a CLI do Azure.
- Execute o comando az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.

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

Instale a extensão sem senha do conector de serviço mais recente para a CLI do Azure:

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

Observação

Verifique se a versão da serviceconnector-passwordless extensão é 2.0.2 ou posterior executando az version. Se necessário, atualize o CLI do Azure primeiro e atualize a extensão.

Criar a conexão sem senha

Os comandos a seguir usam Serviço de Aplicativo do Azure como exemplo para criar uma conexão usando uma identidade gerenciada.

Se você usar Aplicativos Spring do Azure, execute az spring connection create em vez disso. Para obter mais exemplos, confira Conectar os Aplicativos Spring do Azure ao banco de dados do Azure.

Observação

Se preferir o portal Azure, abra a folha Conector de Serviço em Serviço de Aplicativo do Azure ou Aplicativos Spring do Azure e selecione Criar. O portal compõe automaticamente o comando e o executa em Cloud Shell.

O comando da CLI do Azure a seguir usa um parâmetro --client-type, que pode ser java, dotnet, python etc. Execute o az webapp connection create postgres-flexible -h para obter os tipos de cliente com suporte e escolha aquele 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 exige 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 comando a seguir para criar uma identidade gerenciada atribuída pelo usuário:

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

Importante

Após criar a identidade gerenciada atribuída pelo usuário, peça ao Administrador Global ou ao Administrador de Função com Privilégios 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 Active Directory.

Em seguida, conecte seu aplicativo a um banco de dados MySQL com uma identidade gerenciada atribuída pelo sistema usando o Conector de Serviço.

O comando da CLI do Azure a seguir usa um parâmetro --client-type. Execute o az webapp connection create mysql-flexible -h para obter os tipos de cliente com suporte e escolha aquele 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 parâmetro --client-type. Execute o az webapp connection create sql -h para obter os tipos de cliente com suporte e escolha aquele 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

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

Importante

Atualmente, o compartilhamento manual de acesso é necessário para integração completa. Consulte compartilhar acesso ao banco de dados SQL no Fabric.

az webapp connection create fabricsql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --fabric-workspace-uuid $FABRIC_WORKSPACE_UUID \
    --fabric-sql-db-uuid $FABRIC_SQL_DB_UUID \
    --user-identity client-id=XX subs-id=XX \
    --client-type dotnet

az webapp connection create fabricsql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --fabric-workspace-uuid $FABRIC_WORKSPACE_UUID \
    --fabric-sql-db-uuid $FABRIC_SQL_DB_UUID \
    --system-identity \
    --client-type dotnet

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

Habilite a Autenticação do Microsoft Entra para o servidor de banco de dados se ele não estiver habilitado 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 pelo 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 nomeadasAZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRINGou AZURE_SQL_CONNECTIONSTRINGFABRIC_SQL_CONNECTIONSTRINGpara 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 os Aplicativos Spring, as configurações são definidas quando o aplicativo é iniciado.

O Conector do Serviço atribuirá os privilégios a seguir ao usuário, você poderá revogá-los e ajustar os privilégios de acordo com seus requisitos.

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

ALTER ROLE db_datareader ADD MEMBER "username"
ALTER ROLE db_datawriter ADD MEMBER "username"
ALTER ROLE db_ddladmin ADD MEMBER "username"

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

Após criar a conexão, você pode utilizar a cadeia de conexão no seu aplicativo para conectar-se ao banco de dados com a autenticação do Microsoft Entra. Por exemplo, você pode utilizar as seguintes soluções para conectar-se ao banco de dados com a conectividade do Microsoft Entra.

Para o .NET, não existe um plug-in ou biblioteca que dê suporte a conexões sem senha. Você pode obter um token de acesso para a identidade gerenciada ou entidade de serviço usando a biblioteca de clientes como Azure.Identity. Em seguida, você pode utilizar o token de acesso como senha para se conectar ao banco de dados. Ao usar o código abaixo, remova a marca de comentário da parte do trecho de código referente ao tipo de autenticação que você quer 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 seu arquivo 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>

Obtenha a cadeia de conexão de 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:

Para um aplicativo Spring, se você criar uma conexão com a opção --client-type springboot, o Conector de Serviço definirá as propriedades spring.datasource.azure.passwordless-enabled, spring.datasource.url e spring.datasource.username para os Aplicativos Spring do Azure.

Atualize seu aplicativo seguindo o tutorial Associar um Banco de Dados do Azure para PostgreSQL ao seu aplicativo nos Aplicativos Spring do Azure. Lembre-se de remover a propriedade de configuração spring.datasource.password se tiver sido configurada 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 Aplicativos Spring do Azure com uma conexão sem senha a um banco de dados do Azure.

Instale as 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 a biblioteca azure-identity e use o token como senha. Obtenha 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 trecho de código referente ao tipo de autenticação que você quer 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 as dependências.
```
pip install azure-identity
```

Obtenha o token de acesso usando a biblioteca azure-identity usando 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 trecho de código referente ao tipo de autenticação que você quer 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 as informações do banco de dados PostgreSQL do Azure das variáveis de ambiente adicionadas pelo serviço do Conector de Serviço. Use accessToken adquirido na etapa anterior para acessar o banco 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 as 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 azidentity e use-o como senha para se conectar ao PostgreSQL do Azure, juntamente com as informações de conexão fornecidas pelo conector de serviço. Ao usar o código abaixo, remova a marca de comentário da parte do trecho de código referente ao tipo de autenticação que você quer 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 as dependências.

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

No código, obtenha o token de acesso usando @azure/identity e as informações de conexão do PostgreSQL de variáveis de ambiente adicionadas pelo serviço do 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 trecho de código referente ao tipo de autenticação que você quer usar.

import { DefaultAzureCredential, ClientSecretCredential } from "@azure/identity";
import { Client } from '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;
// const credential = new ClientSecretCredential(tenantId, clientId, 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 o PHP, não existe um plug-in ou uma 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 utilizando 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, Serviço de Aplicativo do Azure fornece 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 a 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 utilize https://ossrdbms-aad.database.windows.net como resource na consulta. Para a identidade atribuída pelo usuário, inclua também na consulta a ID do cliente das variáveis de ambiente adicionadas pelo Conector de Serviço.

Para entidades de serviço, consulte a solicitação de token de acesso de serviço para o serviço do Microsoft Azure AD para ver os detalhes de como adquirir o token de acesso. Faça a solicitação POST no escopo de https://ossrdbms-aad.database.windows.net/.default e com a ID de Locatário, a ID de Cliente e o segredo do cliente da entidade de serviço das variáveis de ambiente adicionadas pelo Conector de Serviço.
Combine o token de acesso e a cadeia 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 o Ruby, não existe um plug-in ou uma 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 utilizando a API REST do Azure.

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

No código, obtenha o token de acesso usando a API REST e as informações de conexão do PostgreSQL de variáveis de ambiente adicionadas pelo serviço do 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 trecho de código referente ao tipo de autenticação que você quer usar.

O Serviço de Aplicativo do Azure disponibiliza um endpoint REST acessível internamente para obter tokens para identidades gerenciadas. Para obter mais informações, consulte a 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 serviço a serviço do Azure AD para ver mais detalhes sobre como adquirir o token de acesso para a entidade de serviço.

Em seguida, se você criou tabelas e sequências no servidor flexível do PostgreSQL antes de usar o Service Connector, conecte-se como o proprietário e conceda permissão ao <aad-username> criado pelo Service Connector. 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 Azure, selecione o botão expandir ao lado da coluna Tipo de Serviço para obter o valor. Se você usar o CLI do Azure, verifique configurations na saída do comando da CLI.

Em seguida, execute a seguinte consulta para conceder permissões:

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

<owner-username> e <owner-password> pertencem ao proprietário da tabela existente, que pode conceder permissões a outros. O <aad-username> é o usuário criado pelo Conector de Serviço. Substitua-os por valores reais.

Valide o resultado:

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 seu arquivo 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>

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

Properties properties = new Properties();
properties.put("defaultAuthenticationPlugin", pluginName);
properties.put("authenticationPlugins", pluginName);

// Uncomment the following lines corresponding to the authentication type you want to use.

// for user-assigned managed identity
// String clientId = System.getenv('AZURE_MYSQL_CLIENTID')
// properties.put("azure.clientId", clientId);

// For service principal
// String tenantId = System.getenv('AZURE_MYSQL_TENANTID')
// String clientId = System.getenv('AZURE_MYSQL_CLIENTID')
// String clientSecret = System.getenv('AZURE_MYSQL_CLIENTSECRET')
// properties.put("azure.clientId", clientId);
// properties.put("azure.clientSecret", clientSecret);
// properties.put("azure.tenantId", tenantId);

Connection connection = DriverManager.getConnection(url, properties);

Para obter mais informações, confira Usar o Java e o 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 nos Aplicativos Spring do Azure. Lembre-se de remover a propriedade de configuração spring.datasource.password se tiver sido configurada antes e adicionar as dependências corretas ao seu aplicativo Spring.

Para obter mais tutoriais, confira Usar o JDBC do Spring Data 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 com a obtenção de token de acesso por meio da biblioteca azure-identity e 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 trecho de código referente ao tipo de autenticação que você quer 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 as dependências.
```
pip install azure-identity
```

Obtenha o token de acesso por meio da biblioteca azure-identity com as 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 trecho de código referente ao tipo de autenticação que você quer 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 do Azure para MySQL de variáveis de ambiente adicionadas pelo serviço conector de serviço. Use accessToken adquirido na etapa anterior para acessar o banco 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 as 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 por meio de azidentity e conecte-se ao MySQL do Azure com o token. Ao usar o código abaixo, remova a marca de comentário da parte do trecho de código referente ao tipo de autenticação que você quer 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 e as informações do Banco de Dados MySQL do Azure de variáveis de ambiente adicionadas pelo serviço do conector de serviço. Ao usar o código abaixo, remova a marca de comentário da parte do trecho de código referente ao tipo de autenticação que você quer 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 amostras de código, confira Conectar-se aos bancos de dados do Azure a partir do Serviço de Aplicativo sem segredos usando uma identidade gerenciada.

Instale as 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 Conector do Serviço.
```
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 Active Directory.

Adicione as seguintes dependências no seu 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 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;"
        // 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, confira Conectar-se aos 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 Conector de Serviço definirá as propriedades spring.datasource.url com o formato de valor jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; nos Aplicativos Spring do Azure.

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 propriedade de configuração spring.datasource.password se ela tiver sido configurada antes e adicionar as dependências corretas.

Instale as dependências.

python -m pip install mssql-python python-dotenv

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. No código abaixo, descomente a seção correspondente ao seu tipo de autenticação.

import os
from mssql_python import connect

server = os.getenv('AZURE_SQL_SERVER')
port = os.getenv('AZURE_SQL_PORT')
database = os.getenv('AZURE_SQL_DATABASE')

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned managed identity.
# connection_string = f'Server={server},{port};Database={database};Authentication=ActiveDirectoryMSI;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

# For user-assigned managed identity.
# client_id = os.getenv('AZURE_SQL_USER')
# connection_string = f'Server={server},{port};Database={database};UID={client_id};Authentication=ActiveDirectoryMSI;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

# For service principal.
# user = os.getenv('AZURE_SQL_USER')
# password = os.getenv('AZURE_SQL_PASSWORD')
# connection_string = f'Server={server},{port};Database={database};UID={user};PWD={password};Authentication=ActiveDirectoryServicePrincipal;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

conn = connect(connection_string)

Instale as 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 Conector de Serviço. No código abaixo, descomente a seção correspondente ao seu tipo de autenticação.

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, confira Página inicial para a programação de cliente para interagir com o Microsoft SQL Server.

Instale as dependências.

dotnet add package Microsoft.Data.SqlClient

Recupere a string de conexão do banco de dados SQL no Microsoft Fabric a partir da variável de ambiente adicionada pelo Service Connector.
```
using Microsoft.Data.SqlClient;

string connectionString = 
    Environment.GetEnvironmentVariable("FABRIC_SQL_CONNECTIONSTRING")!;

using var connection = new SqlConnection(connectionString);
connection.Open();
```
Para obter mais informações, consulte Como usar a autenticação de identidade gerenciada do Active Directory.

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

Recupere a string de conexão do banco de dados SQL no Microsoft Fabric a partir 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) {
        // FABRIC_SQL_CONNECTIONSTRING should be one of the following:
        // For system-assigned managed identity: "jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI;"
        // For user-assigned managed identity: "jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;msiClientId=<msiClientId>;authentication=ActiveDirectoryMSI;"
        String connectionString = System.getenv("FABRIC_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, confira Conectar-se aos bancos de dados do Azure a partir do Serviço de Aplicativo sem segredos usando uma identidade gerenciada.

Para uma aplicação Spring, se você criar uma conexão com a opção --client-type springboot, o Service Connector definirá a variável de ambiente FABRIC_SQL_CONNECTIONSTRING com o valor no formato jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI; para o Aplicativos Spring do Azure.

Para identidades gerenciadas atribuídas pelo usuário, msiClientId=<msiClientId>; é adicionado.

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 foi definida anteriormente e adicionar as dependências corretas.

spring:
  datasource:
    url: ${FABRIC_SQL_CONNECTIONSTRING}

Instale as dependências.

python -m pip install mssql-python python-dotenv

Recupere a string de conexão do banco de dados SQL no Microsoft Fabric a partir da variável de ambiente adicionada pelo Service Connector. Authentication=ActiveDirectoryMSI; é necessário na cadeia de conexão ao se conectar usando identidades gerenciadas. UID=<msiClientId> também é necessário na cadeia de conexão ao se conectar usando uma identidade gerenciada atribuída pelo usuário.

import os
from mssql_python import connect

connection_string = os.getenv('FABRIC_SQL_CONNECTIONSTRING')

# System-assigned managed identity connection string format
# `Server=tcp:<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;Database=<SQL-DB-name>-<Fabric-DB-Identifier>;Authentication=ActiveDirectoryMSI;`

# User-assigned managed identity connection string format
# `Server=tcp:<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;Database=<SQL-DB-name>-<Fabric-DB-Identifier>;UID=<msiClientId>;Authentication=ActiveDirectoryMSI;`

conn = connect(connection_string)

Instale as dependências.

go mod init <YourProjectName>
go mod tidy

Recupere a string de conexão do banco de dados SQL no Microsoft Fabric a partir da variável de ambiente adicionada pelo Service Connector.

package main

import (
    "github.com/microsoft/go-mssqldb/azuread"
    "database/sql"
    "context"
    "log"
    "fmt"
    "os"
)

var db *sql.DB

var connectionString = os.Getenv("FABRIC_SQL_CONNECTIONSTRING")

func main() {
    var err error

    // Create connection pool
    db, err = sql.Open(azuread.DriverName, connectionString)
    if err != nil {
        log.Fatal("Error creating connection pool: ", err.Error())
    }
    ctx := context.Background()
    err = db.PingContext(ctx)
    if err != nil {
        log.Fatal(err.Error())
    }
    fmt.Printf("Connected!\n")
}

Para obter mais informações, consulte Usar o Golang para consultar um banco de dados no Banco de Dados SQL do Azure.

Para obter mais informações, consulte Conectar-se ao banco de dados SQL no Microsoft Fabric.

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

Implante seu aplicativo em um serviço de hospedagem do Azure. Opcionalmente, consulte os guias abaixo para obter mais informações sobre como implantar esses recursos.
- Serviço de Aplicativo do Azure: Início Rápido: Implantar um aplicativo Web ASP.NET.
- Aplicativos Spring do Azure: compilar e implantar o aplicativo.
  
  Observação
  
  Os planos Basic, Standard e Enterprise entraram em um período de aposentadoria em 17 de março de 2025. Para mais informações, confira o anúncio de desativação dos Aplicativos Spring do Azure.
Verifique o log ou chame o aplicativo para ver se ele pode se conectar ao banco de dados do Azure com êxito.

Solução de problemas

Permissões

Se você se deparar com quaisquer erros relacionados a permissões, confirme o usuário da CLI do Azure conectado com o comando az account show. Certifique-se de entrar com a conta correta. A seguir, confirme que você tem as permissões a seguir que podem ser necessárias para criar uma conexão sem senha com o Conector de Serviço.

Permissão	Operação
`Microsoft.DBforPostgreSQL/flexibleServers/read`	Obrigatória para obter informações do servidor de banco de dados
`Microsoft.DBforPostgreSQL/flexibleServers/write`	Necessário para habilitar a autenticação do Microsoft Entra com o servidor de banco de dados
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write`	Obrigatória para criar uma regra de firewall para o caso de o endereço IP local ser bloqueado
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete`	Obrigatória para reverter a regra de firewall criada pelo Conector de Serviço para evitar um problema 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`	Exigido para adicionar o usuário de logon da CLI do Azure como administrador do Microsoft Entra do servidor de banco de dados

Permissão	Operação
`Microsoft.DBforMySQL/flexibleServers/read`	Obrigatória para obter informações do servidor de banco de dados
`Microsoft.DBforMySQL/flexibleServers/write`	Obrigatória para adicionar a identidade gerenciada atribuída pelo usuário fornecida ao servidor de banco de dados
`Microsoft.DBforMySQL/flexibleServers/firewallRules/write`	Obrigatória para criar uma regra de firewall para o caso de o endereço IP local ser bloqueado
`Microsoft.DBforMySQL/flexibleServers/firewallRules/delete`	Obrigatória para reverter a regra de firewall criada pelo Conector de Serviço para evitar um problema 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`	Exigido para adicionar o usuário de logon da CLI do Azure como administrador do Microsoft Entra do servidor de banco de dados

Permissão	Operação
`Microsoft.Sql/servers/read`	Obrigatória para obter informações do servidor de banco de dados
`Microsoft.Sql/servers/firewallRules/write`	Obrigatória para criar uma regra de firewall para o caso de o endereço IP local ser bloqueado
`Microsoft.Sql/servers/firewallRules/delete`	Obrigatória para reverter a regra de firewall criada pelo Conector de Serviço para evitar um problema 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`	Exigido para adicionar o usuário de logon da CLI do Azure como administrador do Microsoft Entra do servidor de banco de dados

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

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 esse dispositivo no Microsoft Entra ID. Para obter mais informações, consulte Dispositivos ingressados no Microsoft Entra.

O Conector de Serviço precisa acessar o Microsoft Entra ID para obter informações da sua conta Microsoft e a 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 não fizer o login interativamente, você também poderá receber o erro e Interactive authentication is needed. Para resolver o erro, faça login com o comando az login.

Conectividade de rede

Se o seu servidor de banco de dados estiver em uma Rede Virtual, certifique-se de que o seu ambiente que executa o comando da CLI do Azure possa acessar o servidor no Rede Virtual.

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

Próximas etapas

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

Documentação do Conector de Serviço

Conexões sem senha para serviços do Azure

Comentários

Esta página foi útil?

Last updated on 2025-10-31

Tutorial: Criar uma conexão sem senha com um serviço de banco de dados por meio do Conector de Serviço

Pré-requisitos

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

Criar a conexão sem senha

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

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

Solução de problemas

Permissões

Microsoft Entra ID

Conectividade de rede

Próximas etapas

Comentários

Recursos adicionais