Tutorial: Creación de una conexión sin contraseña en un servicio de base de datos mediante el conector de servicio

Artículo
10/22/2024

Las conexiones sin contraseña usan identidades administradas para acceder a los servicios de Azure. Con este enfoque, no es necesario realizar un seguimiento manual y administrar secretos para identidades administradas. Azure controla de forma segura estas tareas internamente.

El conector de servicio permite identidades administradas en servicios de hospedaje de aplicaciones como Azure Spring Apps, Azure App Service y Azure Container Apps. El conector de servicio también configura servicios de base de datos, como Azure Database for PostgreSQL, Azure Database for MySQL y Azure SQL Database, para aceptar identidades administradas.

En este tutorial, se usa la CLI de Azure para completar las siguientes tareas:

Compruebe el entorno inicial con la CLI de Azure.
Cree una conexión sin contraseña con el conector de servicio.
Use las variables de entorno o las configuraciones generadas por el conector de servicio para acceder a un servicio de base de datos.

Requisitos previos

CLI de Azure, versión 2.61.0 o superior.
Una cuenta de Azure con una suscripción activa. Cree una cuenta de Azure de forma gratuita.
Una aplicación implementada en Azure App Service en una región compatible con el conector de servicio.

Configuración del entorno

Cuenta

Inicie sesión con la CLI de Azure mediante az login. Si usa Azure Cloud Shell o ya ha iniciado sesión, confirme la cuenta autenticada con az account show.

Instalar la extensión sin contraseña del conector de servicio

Instale la extensión sin contraseña más reciente del Conector de servicio para la CLI de Azure:

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

Nota:

Para comprobar que la versión de "serviceconnector-passwordless" es "2.0.2" o posterior, ejecute az version. Es posible que tenga que actualizar primero la CLI de Azure para actualizar la versión de la extensión.

Creación de una conexión sin contraseña

A continuación, usamos Azure App Service como ejemplo para crear una conexión mediante la identidad administrada.

Si utiliza:

Azure Spring Apps: use az spring connection create en su lugar. Para ver más ejemplos, consulte Conexión de Azure Spring Apps a la base de datos de Azure.
Azure Container Apps: use az containerapp connection create en su lugar. Para ver más ejemplos, consulte Creación y conexión de una base de datos PostgreSQL con conectividad de identidad.

Nota

Si usa Azure Portal, vaya a la hoja Conector de servicio de Azure App Service, Azure Spring Apps o Azure Container Apps y seleccione Crear para crear una conexión. Azure Portal redactará automáticamente el comando y desencadenará la ejecución del comando en Cloud Shell.

El siguiente comando de la CLI de Azure usa un parámetro --client-type, puede ser java, dotnet, python, etc. Ejecute az webapp connection create postgres-flexible -h para obtener los tipos de cliente admitidos y elija el que coincida con la aplicación.

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

Azure Database for MySQL: servidor flexible requiere una identidad administrada asignada por el usuario para habilitar la autenticación de Microsoft Entra. Para obtener más información, consulte Configuración de la autenticación de Microsoft Entra para Azure Database for MySQL: servidor flexible. Puede usar el siguiente comando para crear una identidad administrada asignada por el usuario:

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

Importante

Después de crear la identidad administrada asignada por el usuario, pida al administrador global o administrador de roles con privilegios que conceda los siguientes permisos para esta identidad:

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

Para obtener más información, consulte la sección Permisos de autenticación de Active Directory.

Después, conecte la aplicación a una base de datos de MySQL con una identidad administrada asignada por el sistema mediante el conector de servicio.

El siguiente comando de la CLI de Azure usa un parámetro --client-type. Ejecute az webapp connection create mysql-flexible -h para obtener los tipos de cliente admitidos y elija el que coincida con la aplicación.

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

El siguiente comando de la CLI de Azure usa un parámetro --client-type. Ejecute az webapp connection create sql -h para obtener los tipos de cliente admitidos y elija el que coincida con la aplicación.

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

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

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

Este comando del conector de servicio completa las siguientes tareas en segundo plano:

Habilite la identidad administrada asignada por el sistema o asigne una identidad de usuario para la aplicación $APPSERVICE_NAME hospedada por Azure App Service/Azure Spring Apps/Azure Container Apps.
Habilite la autenticación de Microsoft Entra para el servidor de bases de datos si no está habilitada antes.
Establezca el administrador de Microsoft Entra en el usuario que tiene actualmente la sesión iniciada.
Agregue un usuario de base de datos para la identidad administrada asignada por el sistema, la identidad administrada asignada por el usuario o la entidad de servicio. Conceda todos los privilegios de la base de datos $DATABASE_NAME a este usuario. El nombre de usuario se puede encontrar en la cadena de conexión en la salida del comando anterior.
Establezca configuraciones denominadas AZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRING o AZURE_SQL_CONNECTIONSTRING en el recurso de Azure en función del tipo de base de datos.
- Para App Service, las configuraciones se establecen en la hoja Configuración de la aplicación.
- Para Spring Apps, las configuraciones se establecen cuando se inicia la aplicación.
- Para Container Apps, las configuraciones se establecen en las variables de entorno. Puede obtener todas las configuraciones y sus valores en la hoja Conector de servicio de Azure Portal.

Service Connector asignará los siguientes privilegios al usuario, puede revocarlos y ajustarlos en función de sus 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";

Conexión a una base de datos con la autenticación de Microsoft Entra

Después de crear la conexión, puede usar la cadena de conexión de la aplicación para conectarse a la base de datos con la autenticación de Microsoft Entra. Por ejemplo, puede usar las siguientes soluciones para conectarse a la base de datos con la autenticación de Microsoft Entra.

Para .NET, no hay un complemento ni una biblioteca que admita las conexiones sin contraseña. Puede obtener un token de acceso para la identidad administrada o la entidad de servicio utilizando una biblioteca de cliente como Azure.Identity. Luego puede usar el token de acceso como contraseña para conectarse a la base de datos. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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();
}

Agregue las siguientes dependencias al archivo 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>

Obtenga la cadena de conexión de las variables de entorno y agregue el nombre del complemento para conectarse a la base de datos:

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 obtener más información, vea los siguientes recursos:

Para una aplicación de Spring, si crea una conexión con la opción --client-type springboot, el conector de servicio establecerá las propiedades spring.datasource.azure.passwordless-enabled, spring.datasource.url y spring.datasource.username en Azure Spring Apps.

Actualice la aplicación siguiendo el tutorial Enlace de una instancia de Azure Database for PostgreSQL a la aplicación en Azure Spring Apps. Recuerde quitar la propiedad de configuración spring.datasource.password si se estableció antes y agregar las dependencias correctas en la aplicación de Spring.

Para obtener más tutoriales, consulte Uso de Spring Data JDBC con Azure Database for PostgreSQL y Tutorial: Implementación de una aplicación Spring en Azure Spring Apps con una conexión sin contraseña a una base de datos de Azure.

Instale las dependencias.

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

Obtenga el token de acceso mediante la biblioteca azure-identity y use el token como contraseña. Obtenga información de conexión de las variables de entorno agregadas por el conector de servicio. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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 las dependencias.
```
pip install azure-identity
```

Obtenga el token de acceso a través de la biblioteca azure-identity mediante variables de entorno agregadas por el conector de servicio. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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')

En el archivo de configuración, obtenga información de la base de datos de Azure PostgreSQL de las variables de entorno agregadas por el servicio del conector de servicio. Use accessToken adquirido en el paso anterior para acceder a la base de datos.

# 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 las dependencias.

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"

En el código, obtenga el token de acceso mediante azidentity y úselo como contraseña para conectarse a Azure PostgreSQL junto con la información de conexión proporcionada por el conector de servicio. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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 las dependencias.

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

En el código, obtenga el token de acceso mediante @azure/identity y la información de conexión de PostgreSQL a partir de variables de entorno agregadas por el conector de servicio. Combínelos para establecer la conexión. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea usar.

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

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

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

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

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

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

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

Para PHP, no hay un complemento ni una biblioteca para las conexiones sin contraseña. Puede obtener un token de acceso para la identidad administrada o la entidad de servicio y usarla como contraseña para conectarse a la base de datos. El token de acceso se puede adquirir mediante la API REST de Azure.

En el código, obtenga el token de acceso mediante la API REST con su biblioteca favorita.

Para la identidad asignada por el usuario y la identidad asignada por el sistema, App Service y Container Apps proporcionan un punto de conexión REST accesible internamente para recuperar tokens para identidades administradas mediante la definición de dos variables de entorno: IDENTITY_ENDPOINT y IDENTITY_HEADER. Para obtener más información, consulte Referencia de puntos de conexión de REST. Obtenga el token de acceso mediante la realización de una solicitud HTTP GET al punto de conexión de identidad y use https://ossrdbms-aad.database.windows.net como resource en la consulta. Para la identidad asignada por el usuario, incluya también el identificador de cliente de las variables de entorno agregadas por el conector de servicio en la consulta.

Para la entidad de servicio, consulte la solicitud de token de acceso de servicio a servicio de Azure AD para ver los detalles de cómo adquirir el token de acceso. Haga que POST solicite el ámbito de https://ossrdbms-aad.database.windows.net/.default y con el identificador de inquilino, el identificador de cliente y el secreto de cliente de la entidad de servicio de las variables de entorno agregadas por el conector de servicio.
Combine el token de acceso y la cadena de conexión de PostgreSQL de las variables de entorno agregadas por el conector de servicio para establecer la conexión.
```
<?php
$conn_string = sprintf("%s password=", getenv('AZURE_POSTGRESQL_CONNECTIONSTRING'), $access_token);
$dbconn = pg_connect($conn_string);
?>
```

Para Ruby, no hay un complemento ni una biblioteca para las conexiones sin contraseña. Puede obtener un token de acceso para la identidad administrada o la entidad de servicio y usarla como contraseña para conectarse a la base de datos. El token de acceso se puede adquirir mediante la API REST de Azure.

Instale las dependencias.
```
gem install pg
```

En el código, obtenga el token de acceso mediante la API REST y la información de conexión de PostgreSQL a partir de variables de entorno agregadas por el conector de servicio. Combínelos para establecer la conexión. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea usar.

App Service y Container Apps proporcionan un punto de conexión REST accesible internamente para recuperar tokens para identidades administradas. Para obtener más información, consulte Referencia de puntos de conexión de 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,
)

Para la entidad de servicio, consulte la solicitud de token de acceso de servicio a servicio de Azure AD para ver los detalles de cómo adquirir el token de acceso.

A continuación, si ha creado tablas y secuencias en el servidor flexible de PostgreSQL antes de usar el conector de servicio, debe conectarse como propietario y conceder permiso a <aad-username>, que se crea mediante el conector de servicio. El nombre de usuario de la cadena de conexión o la configuración establecida por el conector de servicio debería parecerse a aad_<connection name>. Si usa Azure Portal, seleccione el botón expandir situado junto a la columna Service Type y obtenga el valor. Si usa la CLI de Azure, compruebe configurations en la salida del comando de la CLI.

A continuación, ejecute la consulta para conceder permiso

az extension add --name rdbms-connect

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

<owner-username> y <owner-password> es el propietario de la tabla existente que puede conceder permisos a otros usuarios. <aad-username> es el usuario creado por Service Connector. Reemplácelos por el valor real.

Valide el resultado con el 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

Agregue las siguientes dependencias al archivo 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>

Obtenga la cadena de conexión de la variable de entorno y agregue el nombre del complemento para conectarse a la base de datos:

String url = System.getenv("AZURE_MYSQL_CONNECTIONSTRING");  
String pluginName = "com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin";
Connection connection = DriverManager.getConnection(url + "&defaultAuthenticationPlugin=" +
    pluginName + "&authenticationPlugins=" + pluginName);

Para obtener más información, consulte Uso de Java y JDBC con Azure Database for MySQL: servidor flexible.

Actualice la aplicación siguiendo el tutorial Conexión de una instancia de Azure Database for MySQL a la aplicación en Azure Spring Apps. Recuerde quitar la propiedad de configuración spring.datasource.password si se estableció antes y agregar las dependencias correctas en la aplicación de Spring.

Para ver más tutoriales, consulte Uso de Spring Data JDBC con Azure Database for MySQL

Instalar dependencias

pip install azure-identity
# install Connector/Python https://dev.mysql.com/doc/connector-python/en/connector-python-installation.html
pip install mysql-connector-python

Autentíquese con el token de acceso a través de la biblioteca azure-identity y obtenga información de conexión de la variable de entorno agregada por el conector de servicio. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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 las dependencias.
```
pip install azure-identity
```

Obtenga el token de acceso a través de la biblioteca azure-identity mediante las variables de entorno agregadas por el conector de servicio. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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')

En el archivo de configuración, obtenga información de la base de datos de Azure MySQL de las variables de entorno agregadas por el servicio de conector de servicio. Use accessToken adquirido en el paso anterior para acceder a la base de datos.

# 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 las dependencias.

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"

En el código, obtenga el token de acceso a través de azidentity y conéctese a Azure MySQL con el token. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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 dependencias

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

Obtenga el token de acceso mediante @azure/identity y la información de base de datos de Azure MySQL de las variables de entorno agregadas por el servicio Conector de servicio. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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 obtener ejemplos de código, consulte Conexión a bases de datos de Azure desde App Service sin secretos mediante una identidad administrada.

Instale las dependencias.

dotnet add package Microsoft.Data.SqlClient

Obtenga la cadena de conexión de Azure SQL Database de la variable de entorno agregada por Service Connector.
```
using Microsoft.Data.SqlClient;

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

using var connection = new SqlConnection(connectionString);
connection.Open();
```
Para obtener más información, consulte Uso de la autenticación de identidad administrada de Active Directory.

Agregue las siguientes dependencias al archivo 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>

Obtenga la cadena de conexión de Azure SQL Database de la variable de entorno agregada por 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 más información, consulte Conexión a bases de datos de Azure desde App Service sin secretos mediante una identidad administrada.

Para una aplicación de Spring, si crea una conexión con la opción --client-type springboot, Service Connector establece las propiedades spring.datasource.url con formato de valor jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; a Azure Spring Apps.

Actualice la aplicación siguiendo el tutorial Migración de una aplicación Java para usar conexiones sin contraseña con Azure SQL Database. Recuerde quitar la propiedad de configuración spring.datasource.password si se estableció antes y agregar las dependencias correctas.

Instale las dependencias.
```
python -m pip install pyodbc
```

Obtenga las configuraciones de conexión de Azure SQL Database de la variable de entorno agregada por Service Connector. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea usar. Si usa Azure Container Apps como servicio de proceso o la cadena de conexión del fragmento de código no funciona, consulte Migración de una aplicación de Python para usar conexiones sin contraseña con Azure SQL Database para conectarse a Azure SQL Database mediante un token de acceso.

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 las dependencias.
```
npm install mssql
```

Obtenga las configuraciones de conexión de Azure SQL Database de las variables de entorno agregadas por Service Connector. Al usar el código siguiente, quite la marca de comentario de la parte del fragmento de código para el tipo de autenticación que desea 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 obtener más información, consulte Página principal de la programación de cliente en Microsoft SQL Server.

Implementación de la aplicación en un servicio de hospedaje de Azure

Por último, implemente la aplicación en un servicio de hospedaje de Azure. Ese servicio de origen puede usar una identidad administrada para conectarse a la base de datos de destino en Azure.

En cuanto a Azure App Service, puede consultar el documento para elegir una manera de implementación, consulte Inicio rápido: Implementar una aplicación web de ASP.NET.

A continuación, puede comprobar el registro o llamar a la aplicación para ver si puede conectarse a la base de datos en Azure correctamente.

Solución de problemas

Permiso

Si encuentra algún error relacionado con los permisos, confirme el usuario que ha iniciado sesión en la CLI de Azure con el comando az account show. Asegúrese de que ha iniciado sesión con la cuenta correcta. A continuación, confirme que tiene los siguientes permisos que pueden ser necesarios para crear una conexión sin contraseña con el conector de servicio.

Permiso	Operación
`Microsoft.DBforPostgreSQL/flexibleServers/read`	Necesario para obtener información del servidor de bases de datos
`Microsoft.DBforPostgreSQL/flexibleServers/write`	Necesario para habilitar la autenticación de Microsoft Entra para el servidor de bases de datos
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write`	Necesario para crear una regla de firewall en caso de que se bloquee la dirección IP local
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete`	Necesario para revertir la regla de firewall creada por el conector de servicio para evitar problemas de seguridad
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/read`	Necesario para comprobar si el usuario de inicio de sesión de la CLI de Azure es un administrador de Microsoft Entra del servidor de bases de datos
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/write`	Necesario para agregar el usuario de inicio de sesión de la CLI de Azure como administrador de Microsoft Entra del servidor de bases de datos

Permiso	Operación
`Microsoft.DBforMySQL/flexibleServers/read`	Necesario para obtener información del servidor de bases de datos
`Microsoft.DBforMySQL/flexibleServers/write`	Necesario para agregar la identidad administrada asignada por el usuario proporcionada al servidor de bases de datos
`Microsoft.DBforMySQL/flexibleServers/firewallRules/write`	Necesario para crear una regla de firewall en caso de que se bloquee la dirección IP local
`Microsoft.DBforMySQL/flexibleServers/firewallRules/delete`	Necesario para revertir la regla de firewall creada por el conector de servicio para evitar problemas de seguridad
`Microsoft.DBforMySQL/flexibleServers/administrators/read`	Necesario para comprobar si el usuario de inicio de sesión de la CLI de Azure es un administrador de Microsoft Entra del servidor de bases de datos
`Microsoft.DBforMySQL/flexibleServers/administrators/write`	Necesario para agregar el usuario de inicio de sesión de la CLI de Azure como administrador de Microsoft Entra del servidor de bases de datos

Permiso	Operación
`Microsoft.Sql/servers/read`	Necesario para obtener información del servidor de bases de datos
`Microsoft.Sql/servers/firewallRules/write`	Necesario para crear una regla de firewall en caso de que se bloquee la dirección IP local
`Microsoft.Sql/servers/firewallRules/delete`	Necesario para revertir la regla de firewall creada por el conector de servicio para evitar problemas de seguridad
`Microsoft.Sql/servers/administrators/read`	Necesario para comprobar si el usuario de inicio de sesión de la CLI de Azure es un administrador de Microsoft Entra del servidor de bases de datos
`Microsoft.Sql/servers/administrators/write`	Necesario para agregar el usuario de inicio de sesión de la CLI de Azure como administrador de Microsoft Entra del servidor de bases de datos

En algunos casos, los permisos no son necesarios. Por ejemplo, si el usuario autenticado por la CLI de Azure ya es un administrador de Active Directory en SQL Server, no es necesario tener el permiso Microsoft.Sql/servers/administrators/write.

Microsoft Entra ID

Si recibe un error ERROR: AADSTS530003: Your device is required to be managed to access this resource., pida a su departamento de TI ayuda para unir este dispositivo a Microsoft Entra ID. Para obtener más información, consulte Dispositivos unidos a Microsoft Entra.

El conector de servicio debe acceder a Microsoft Entra ID para obtener información de la cuenta y la identidad administrada del servicio de hospedaje. Puede usar el siguiente comando para comprobar si el dispositivo puede acceder a Microsoft Entra ID:

az ad signed-in-user show

Si no inicia sesión de forma interactiva, también puede obtener el error y Interactive authentication is needed. Para resolver el error, inicie sesión con el comando az login.

Conectividad de red

Si el servidor de bases de datos está en Virtual Network, asegúrese de que el entorno que ejecuta el comando de la CLI de Azure pueda acceder al servidor en Virtual Network.

Si el servidor de bases de datos no permite el acceso público, asegúrese de que el entorno que ejecuta el comando de la CLI de Azure pueda acceder al servidor a través del punto de conexión privado.

Pasos siguientes

Para obtener más información sobre el conector de servicio y las conexiones sin contraseña, consulte los siguientes recursos:

Documentación del conector de servicio

Conexiones sin contraseña para servicios de Azure

Compartir a través de

Tutorial: Creación de una conexión sin contraseña en un servicio de base de datos mediante el conector de servicio

Requisitos previos

Configuración del entorno

Cuenta

Instalar la extensión sin contraseña del conector de servicio

Creación de una conexión sin contraseña

Conexión a una base de datos con la autenticación de Microsoft Entra

Implementación de la aplicación en un servicio de hospedaje de Azure

Solución de problemas

Permiso

Microsoft Entra ID

Conectividad de red

Pasos siguientes

Comentarios

Recursos adicionales