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

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, 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:

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

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.
Azure CLI versão 2.61.0 ou superior.

Para começar a usar a CLI do Azure:

Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, consulte Introdução ao Azure Cloud Shell.
Se preferir executar comandos de referência da CLI localmente, instale a CLI do Azure. Se você estiver executando no Windows ou macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, consulte 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 os passos apresentados no seu terminal. Para outras opções de entrada, consulte Autenticar no Azure usando a CLI do Azure.
- Quando solicitado, instale a extensão da CLI do Azure na primeira utilização. Para obter mais informações sobre extensões, consulte Usar e gerenciar extensões com a CLI do Azure.
- Execute 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 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" tem a 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_MANAGED_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

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

Importante

O compartilhamento manual de acesso é atualmente necessário para a 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

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 denominadas AZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRING, AZURE_SQL_CONNECTIONSTRINGou FABRIC_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";

ALTER ROLE db_datareader ADD MEMBER "username"
ALTER ROLE db_datawriter ADD MEMBER "username"
ALTER ROLE db_ddladmin ADD MEMBER "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 uma biblioteca 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.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 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 com a biblioteca azure-identity utilizando 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 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. Utilize accessToken adquirido 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 azidentity e depois utilize-o como palavra-passe para se conectar ao Azure PostgreSQL, juntamente com as informações de conexão fornecidas pelo Conector de Serviç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 (
"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";
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 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 utilizador e identidade atribuída pelo sistema, o Azure App Service e o Azure Container Apps fornecem um endpoint REST internamente acessível para recuperar tokens para identidades geridas, 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 ao fazer uma requisição HTTP GET para o endpoint 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 principal de serviço, consulte a solicitação de token de acesso de serviço a serviço do Azure AD para obter os detalhes sobre 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 do locatário, a ID do cliente e o segredo do cliente do principal de serviço a partir das variáveis de ambiente adicionadas pelo Service Connector.
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 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.

O Azure App Service e o Azure Container Apps fornecem um endpoint REST internamente acessível para recuperar tokens para identidades geridas. 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 para serviço do Azure AD para ver mais detalhes de como adquirir um token de acesso para principal de serviço.

Em seguida, se tiver criado tabelas e sequências no servidor flexível PostgreSQL antes de usar o Service Connector, precisará conectar-se como proprietário e conceder permissão a <aad-username> criado pelo Service Connector. O nome de utilizador na cadeia de conexão ou configuração definida pelo Service Connector deverá ser semelhante a 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 utilizar a CLI do Azure, verifique configurations na 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> são os proprietários da tabela existente que podem 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.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, 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 o token de acesso através da biblioteca azure-identity 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 o token de acesso através da biblioteca azure-identity 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. Utilize accessToken adquirido 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 azidentity, em seguida, conecte-se no 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 e 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 uma aplicação Spring, se criar uma conexão com a opção --client-type springboot, o Service Connector define as propriedades spring.datasource.url com o formato de valor jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; para o 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.

Instale 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 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>

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, 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á a variável FABRIC_SQL_CONNECTIONSTRING de ambiente com formato jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI; de valor para Azure Spring Apps.

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

spring:
  datasource:
    url: ${FABRIC_SQL_CONNECTIONSTRING}

Instale dependências.
```
python -m pip install pyodbc
```
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. 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 no Microsoft Fabric usando credenciais sem senha. 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
import pyodbc, struct
from azure.identity import DefaultAzureCredential

connStr = os.getenv('FABRIC_SQL_CONNECTIONSTRING')

# System-assigned managed identity connection string format
# `Driver={ODBC Driver 17 for SQL Server};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
# `Driver={ODBC Driver 17 for SQL Server};Server=tcp:<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;Database=<SQL-DB-name>-<Fabric-DB-Identifier>;UID=<msiClientId>;Authentication=ActiveDirectoryMSI;`

conn = pyodbc.connect(connString)
```

Instale 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 a implantação desses recursos.
- Serviço de Aplicativo do Azure: Guia de início rápido: implante um aplicativo Web ASP.NET.
- Aplicativos de contêiner do Azure: Guia de início rápido: implante seu primeiro aplicativo de contêiner.
- Azure Spring Apps: crie e implante o aplicativo.
  
  Nota
  
  Os planos Basic, Standard e Enterprise entraram em um período de aposentadoria em 17 de março de 2025. Para obter mais informações, consulte o anúncio de aposentadoria do Azure Spring Apps.
Verifique o log ou chame o aplicativo para ver se ele pode se conectar ao banco de dados do Azure com êxito.

Resolução de Problemas

Permissões

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 não fizeres login interactivamente, podes também receber o erro e Interactive authentication is needed. 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

Feedback

Esta página foi útil?

Last updated on 2025-09-29

Partilhar via

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

Pré-requisitos

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ões

Microsoft Entra ID

Conectividade de rede

Próximos passos

Feedback

Recursos adicionais