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

Artigo
10/22/2024

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

O Conector de Serviço habilita identidades gerenciadas nos serviços de hospedagem de aplicativos como os Aplicativos Spring do Azure, o Serviço de Aplicativo do Azure e os Aplicativos de Contêiner do Azure. O Conector de Serviço também configura os serviços de banco de dados, como o Banco de Dados do Azure para PostgreSQL, o Banco de Dados do Azure para MySQL e o Banco de Dados SQL do Azure, para aceitar identidades gerenciadas.

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

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

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

Configure seu ambiente

Conta

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

Instalar a extensão sem senha do 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 extensão "serviceconnector-passwordless" é "2.0.2" ou superior executando az version. Pode ser necessário atualizar a CLI do Azure primeiro para depois atualizar a versão da extensão.

Criar a conexão sem senha

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

Se você usar:

Aplicativos Spring do Azure: use az spring connection create em vez disso. Para obter mais exemplos, confira Conectar os Aplicativos Spring do Azure ao banco de dados do Azure.
Aplicativos de Contêiner do Azure: use az containerapp connection create em vez disso. Para obter mais exemplos, confira Criar e conectar um banco de dados PostgreSQL com conectividade de identidade.

Observação

Se você usar o portal do Azure, vá para a folha Conector de Serviço do Serviço de Aplicativo do Azure, dos Aplicativos Spring do Azure ou dos Aplicativos de Contêiner do Azure e selecione Criar para criar uma conexão. O portal do Azure irá redigir o comando automaticamente para você e disparar a execução do comando no 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

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

Habilite a identidade gerenciada atribuída pelo sistema ou atribua uma identidade de usuário para o aplicativo $APPSERVICE_NAME hospedado pelo Serviço de Aplicativo do Azure/Aplicativos Spring do Azure/Aplicativos de Contêiner do Azure.
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 chamadas AZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRINGou AZURE_SQL_CONNECTIONSTRING para o recurso do Azure com base no tipo de banco de dados.
- Para o Serviço de Aplicativo, as configurações são definidas na folha Configurações do Aplicativo.
- Para os Aplicativos Spring, as configurações são definidas quando o aplicativo é iniciado.
- Para os Aplicativos de Contêiner, as configurações são definidas para as variáveis do ambiente. Você pode obter todas as configurações e seus valores na folha Conector de Serviço no portal do Azure.

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

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 utilizando 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, descompacte a parte do snippet 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 dependências a seguir no seu arquivo pom.xml:

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.3.6</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-extensions</artifactId>
    <version>1.1.5</version>
</dependency>

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, descompacte a parte do snippet 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 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, descompacte a parte do snippet 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 as informações do banco de dados PostgreSQL do Azure das 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_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, descompacte a parte do snippet 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 as 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 do conector de serviço. Conectar-se a eles para estabelecer a conexão. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

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

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

// For user-assigned identity.
// const clientId = process.env.AZURE_POSTGRESQL_CLIENTID;
// const credential = new DefaultAzureCredential({
//     managedIdentityClientId: clientId
// });

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

// Acquire the access token.
var accessToken = await credential.getToken('https://ossrdbms-aad.database.windows.net/.default');

// Use the token and the connection information from the environment variables added by Service Connector to establish the connection.
(async () => {
const client = new Client({
    host: process.env.AZURE_POSTGRESQL_HOST,
    user: process.env.AZURE_POSTGRESQL_USER,
    password: accesstoken.token,
    database: process.env.AZURE_POSTGRESQL_DATABASE,
    port: Number(process.env.AZURE_POSTGRESQL_PORT) ,
    ssl: process.env.AZURE_POSTGRESQL_SSL
});
await client.connect();

await client.end();
})();

Para 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, o Serviço de Aplicativo e os Aplicativos de Contêiner fornecem um ponto de extremidade REST acessível internamente para recuperar tokens para identidades gerenciadas, definindo duas variáveis de ambiente: IDENTITY_ENDPOINT e IDENTITY_HEADER. Para obter mais informações, consulte 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 das variáveis de ambiente adicionadas pelo serviço Conector de Serviço 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, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar.

O serviço de aplicativo e os Aplicativos de contêiner fornecem um ponto de extremidade REST acessível internamente para recuperar tokens para identidades gerenciadas. 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 Microsoft Azure AD para ver mais detalhes sobre como adquirir o token de acesso para a entidade de serviço.

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

Em seguida, execute a consulta para conceder permissão

az extension add --name rdbms-connect

az postgres flexible-server execute -n <postgres-name> -u <owner-username> -p "<owner-password>" -d <database-name> --querytext "GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO \"<aad-username>\";GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO \"<aad username>\";"

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

Você pode validar o resultado com o comando:

az postgres flexible-server execute -n <postgres-name> -u <owner-username> -p "<owner-password>" -d <database-name> --querytext "SELECT distinct(table_name) FROM information_schema.table_privileges WHERE grantee='<aad-username>' AND table_schema='public';" --output table

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

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.30</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-extensions</artifactId>
    <version>1.1.5</version>
</dependency>

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 com 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, descompacte a parte do snippet 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 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, descompacte a parte do snippet 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 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, descompacte a parte do snippet 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 informações do banco de dados MySQL do Azure de variáveis de ambiente adicionadas pelo serviço de Conector de Serviço. Ao usar o código abaixo, descompacte a parte do snippet 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 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 dependências a seguir 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 tiver sido configurada antes e adicionar as dependências corretas.

Instale as 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 Conector de Serviço. Ao usar o código abaixo, descompacte a parte do snippet de código para o tipo de autenticação que você deseja usar. Se você usar os Aplicativos de Contêiner do Azure como serviço de computação ou a cadeia de conexão no snippet de código não funcionar, confira Migrar um aplicativo Python para que ele use conexões sem senha com o Banco de Dados SQL do Azure a fim de conectar-se 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 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. Ao usar o código abaixo, descompacte a parte do snippet 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, confira Página inicial para a programação de cliente para o Microsoft SQL Server.

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

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

Para o Serviço de Aplicativo do Azure, você pode verificar o documento para escolher uma maneira de implantar, confira Início Rápido: Implantar um aplicativo Web ASP.NET.

Em seguida, você pode conferir o log ou chamar o aplicativo para ver se ele consegue se conectar ao banco de dados no Azure com sucesso.

Solução de problemas

Permissão

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.

ID do Microsoft Entra

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 Conector de Serviço e conexões sem senha, confira os seguintes recursos:

Documentação do conector de serviço

Conexões sem senha para serviços do Azure

Compartilhar via

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

Pré-requisitos

Configure seu ambiente

Conta

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ão

ID do Microsoft Entra

Conectividade de rede

Próximas etapas

Comentários

Recursos adicionais