Kurz: Vytvoření připojení k databázové službě bez hesla prostřednictvím služby Připojení or

Článek
11/08/2023

Připojení bez hesla používají spravované identity pro přístup ke službám Azure. Díky tomuto přístupu nemusíte ručně sledovat a spravovat tajné kódy pro spravované identity. Tyto úlohy jsou bezpečně zpracovávány interně v Azure.

Service Připojení or umožňuje spravované identity v hostitelských službách aplikací, jako jsou Azure Spring Apps, Aplikace Azure Service a Azure Container Apps. Služba Připojení or také konfiguruje databázové služby, jako je Azure Database for PostgreSQL, Azure Database for MySQL a Azure SQL Database, pro příjem spravovaných identit.

V tomto kurzu pomocí Azure CLI provedete následující úlohy:

Zkontrolujte počáteční prostředí pomocí Azure CLI.
Vytvořte připojení bez hesla pomocí service Připojení or.
Použijte proměnné prostředí nebo konfigurace vygenerované službou Service Připojení or pro přístup k databázové službě.

Požadavky

Azure CLI verze 2.48.1 nebo vyšší
Účet Azure s aktivním předplatným. Vytvořte si bezplatný účet Azure.
Aplikace nasazená do služby Aplikace Azure Service v oblasti podporované službou Service Připojení or.

Nastavení prostředí

Obchodní vztah

Přihlaste se pomocí Azure CLI přes az login. Pokud používáte Azure Cloud Shell nebo jste už přihlášení, ověřte svůj ověřený účet pomocí az account show.

Instalace rozšíření service Připojení or bez hesla

Nainstalujte rozšíření service Připojení or bez hesla pro Azure CLI:

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

Vytvoření připojení bez hesla

Dále jako příklad použijeme službu Aplikace Azure Service k vytvoření připojení pomocí spravované identity.

Pokud používáte:

Azure Spring Apps: Použijte az spring connection create místo toho. Další příklady najdete v tématu Připojení Azure Spring Apps do databáze Azure.
Azure Container Apps: Použijte az containerapp connection create místo toho. Další příklady najdete v tématu Vytvoření a připojení databáze PostgreSQL s připojením identit.

Poznámka:

Pokud používáte Azure Portal, přejděte do okna Service Připojení or služby Aplikace Azure Service, Azure Spring Apps nebo Azure Container Apps a výběrem možnosti Vytvořit vytvořte připojení. Azure Portal automaticky vytvoří příkaz za vás a aktivuje spuštění příkazu v Cloud Shellu.

Následující příkaz Azure CLI používá --client-type parametr. Spusťte příkaz pro az webapp connection create postgres-flexible -h získání podporovaných typů klientů a zvolte ten, který odpovídá vaší aplikaci.

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 java

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 java

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 java

Flexibilní server Azure Database for MySQL vyžaduje spravovanou identitu přiřazenou uživatelem, aby bylo možné povolit ověřování Microsoft Entra. Další informace najdete v tématu Nastavení ověřování Microsoft Entra pro flexibilní server Azure Database for MySQL. K vytvoření spravované identity přiřazené uživatelem můžete použít následující příkaz:

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)

Důležité

Po vytvoření spravované identity přiřazené uživatelem požádejte globální Správa istrator nebo privilegovanou roli Správa istrator, aby této identitě udělil následující oprávnění:

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

Další informace najdete v části Oprávnění ověřování active directory.

Pak aplikaci připojte k databázi MySQL pomocí spravované identity přiřazené systémem pomocí služby Připojení or.

Následující příkaz Azure CLI používá --client-type parametr. Spusťte příkaz pro az webapp connection create mysql-flexible -h získání podporovaných typů klientů a zvolte ten, který odpovídá vaší aplikaci.

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

Následující příkaz Azure CLI používá --client-type parametr. Spusťte příkaz pro az webapp connection create sql -h získání podporovaných typů klientů a zvolte ten, který odpovídá vaší aplikaci.

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

Tento příkaz Připojení or služby na pozadí dokončí následující úlohy:

Povolte spravovanou identitu přiřazenou systémem nebo přiřaďte identitu uživatele pro aplikaci $APPSERVICE_NAME hostované službou Aplikace Azure Service, Azure Spring Apps nebo Azure Container Apps.
Nastavte správce Microsoft Entra na aktuální přihlášeného uživatele.
Přidejte uživatele databáze pro spravovanou identitu přiřazenou systémem, spravovanou identitu přiřazenou uživatelem nebo instanční objekt. Udělte tomuto uživateli všechna oprávnění databáze $DATABASE_NAME . Uživatelské jméno najdete v připojovací řetězec v předchozím výstupu příkazu.
Nastavte konfigurace s názvem AZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRINGnebo AZURE_SQL_CONNECTIONSTRING na prostředek Azure na základě typu databáze.
- V případě služby App Service jsou konfigurace nastavené v okně Nastavení aplikace.
- Pro Spring Apps se konfigurace nastaví při spuštění aplikace.
- Pro Container Apps jsou konfigurace nastavené na proměnné prostředí. Všechny konfigurace a jejich hodnoty můžete získat v okně Service Připojení or na webu Azure Portal.

Připojení do databáze s ověřováním Microsoft Entra

Po vytvoření připojení můžete pomocí připojovací řetězec v aplikaci připojit k databázi pomocí ověřování Microsoft Entra. K připojení k databázi pomocí ověřování Microsoft Entra můžete použít například následující řešení.

Pro .NET neexistuje modul plug-in ani knihovna, které podporují připojení bez hesla. Přístupový token pro spravovanou identitu nebo instanční objekt můžete získat pomocí klientské knihovny, jako je Azure.Identity. Přístupový token pak můžete použít jako heslo pro připojení k databázi. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

// Uncomment the following lines according to the authentication type.
// 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();
}

Do souboru pom.xml přidejte následující závislosti:

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

Získejte připojovací řetězec z proměnných prostředí a přidejte název modulu plug-in pro připojení k databázi:

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

Další informace naleznete v následujících zdrojích:

Pokud pro aplikaci Spring vytvoříte připojení s možností --client-type springboot, service Připojení or nastaví vlastnosti spring.datasource.azure.passwordless-enabledspring.datasource.url, a spring.datasource.username azure Spring Apps.

Aktualizujte aplikaci podle kurzu Vytvoření vazby služby Azure Database for PostgreSQL k vaší aplikaci v Azure Spring Apps. Nezapomeňte odebrat spring.datasource.password vlastnost konfigurace, pokud byla nastavena dříve, a přidat do aplikace Spring správné závislosti.

Další kurzy najdete v tématu Použití Spring Data JDBC se službou Azure Database for PostgreSQL a kurz: Nasazení aplikace Spring do Azure Spring Apps s bez heslovým připojením k databázi Azure.

Nainstalujte závislosti.

pip install azure-identity
pip install psycopg2-binary

Získejte přístupový token pomocí azure-identity knihovny a použijte token jako heslo. Získejte informace o připojení z proměnných prostředí přidaných službou Service Připojení or. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

from azure.identity import DefaultAzureCredential
import psycopg2

# Uncomment the following lines according to the authentication type.
# 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)

Nainstalujte závislosti.
```
pip install azure-identity
```

Získání přístupového tokenu pomocí azure-identity knihovny pomocí proměnných prostředí přidaných službou Service Připojení or Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

from azure.identity import DefaultAzureCredential
import psycopg2

# Uncomment the following lines according to the authentication type.
# 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')

V souboru nastavení získejte informace o databázi Azure PostgreSQL z proměnných prostředí přidaných službou Service Připojení or. Pro přístup k databázi použijte accessToken získané v předchozím kroku.

# 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'},
    }
}

Nainstalujte závislosti.

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"

V kódu získejte přístupový token pomocí azidentitya pak ho použijte jako heslo pro připojení k Azure PostgreSQL spolu s informacemi o připojení poskytovaných službou Připojení or. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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 according to the authentication type.
// 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()

Nainstalujte závislosti.

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

V kódu získejte přístupový token pomocí @azure/identity informací o připojení PostgreSQL z proměnných prostředí přidaných službou Service Připojení or. Zkombinujte je za účelem navázání připojení. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

// Uncomment the following lines according to the authentication type.  
// 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();
})();

Pro PHP neexistuje modul plug-in ani knihovna pro připojení bez hesla. Můžete získat přístupový token pro spravovanou identitu nebo instanční objekt a použít ho jako heslo pro připojení k databázi. Přístupový token je možné získat pomocí rozhraní Azure REST API.

V kódu získejte přístupový token pomocí rozhraní REST API s vaší oblíbenou knihovnou.

Pro identitu přiřazenou uživatelem a identitu přiřazenou systémem poskytuje App Service a Container Apps interně přístupný koncový bod REST pro načtení tokenů pro spravované identity definováním dvou proměnných prostředí: IDENTITY_ENDPOINT a IDENTITY_HEADER. Další informace najdete v referenčních informacích ke koncovému bodu REST. Získejte přístupový token tak, že do koncového bodu identity vytvoříte požadavek HTTP GET a použijete https://ossrdbms-aad.database.windows.net ho jako resource v dotazu. Pro identitu přiřazenou uživatelem uveďte ID klienta z proměnných prostředí přidaných službou service Připojení or do dotazu.

V případě instančního objektu se podívejte na žádost o přístupový token služby Azure AD, kde najdete podrobnosti o získání přístupového tokenu. Zadejte požadavek POST na rozsah ID https://ossrdbms-aad.database.windows.net/.default tenanta, ID klienta a tajný klíč klienta instančního objektu z proměnných prostředí přidaných službou Service Připojení or.
Zkombinujte přístupový token a bodování připojení PostgreSQL z proměnných prostředí přidaných službou Service Připojení or za účelem navázání připojení.
```
<?php
$conn_string = sprintf("%s password=", getenv('AZURE_POSTGRESQL_CONNECTIONSTRING'), $access_token);
$dbconn = pg_connect($conn_string);
?>
```

Pro Ruby neexistuje modul plug-in ani knihovna pro připojení bez hesla. Můžete získat přístupový token pro spravovanou identitu nebo instanční objekt a použít ho jako heslo pro připojení k databázi. Přístupový token je možné získat pomocí rozhraní Azure REST API.

Nainstalujte závislosti.
```
gem install pg
```

V kódu získejte přístupový token pomocí rozhraní REST API a informací o připojení PostgreSQL z proměnných prostředí přidaných službou Service Připojení or. Zkombinujte je za účelem navázání připojení. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

App Service a container Apps poskytují interně přístupný koncový bod REST pro načtení tokenů pro spravované identity. Další informace najdete v referenčních informacích ke koncovému bodu REST.

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

# Uncomment the following lines according to the authentication type.
# 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,
)

Další podrobnosti o získání přístupového tokenu pro instanční objekt najdete v žádosti o přístupový token azure AD.

Pokud jste vytvořili tabulky a sekvence na flexibilním serveru PostgreSQL před použitím service Připojení or, musíte se připojit jako vlastník a udělit oprávnění k <aad-username> vytvoření službou Připojení or. Uživatelské jméno z připojovací řetězec nebo konfigurace nastavené službou Připojení or by měl vypadat nějak aad_<connection name>takto. Pokud používáte Azure Portal, vyberte tlačítko rozbalení vedle Service Type sloupce a získejte hodnotu. Pokud používáte Azure CLI, zkontrolujte configurations výstup příkazu rozhraní příkazového řádku.

Pak spusťte dotaz, který udělí oprávnění.

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-password> A <owner-username> je vlastníkem existující tabulky, která může udělit oprávnění ostatním. <aad-username>je uživatel vytvořený službou Připojení or. Nahraďte je skutečnou hodnotou.

Pomocí příkazu ověřte výsledek:

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 according to the authentication type.
// 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

Do souboru pom.xml přidejte následující závislosti:

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

Získejte připojovací řetězec z proměnné prostředí a přidejte název modulu plug-in pro připojení k databázi:

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

Další informace najdete v tématu Použití Javy a JDBC s flexibilním serverem Azure Database for MySQL.

Aktualizujte aplikaci podle kurzu Připojení instanci Azure Database for MySQL na aplikaci v Azure Spring Apps. Nezapomeňte odebrat spring.datasource.password vlastnost konfigurace, pokud byla nastavena dříve, a přidat do aplikace Spring správné závislosti.

Další kurzy najdete v tématu Použití Spring Data JDBC se službou Azure Database for MySQL

Instalace závislostí

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

Ověřte se pomocí přístupového tokenu get prostřednictvím azure-identity knihovny a získejte informace o připojení z proměnné prostředí přidané službou Připojení or. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

# Uncomment the following lines according to the authentication type.
# 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()

Nainstalujte závislosti.
```
pip install azure-identity
```

Získejte přístupový token prostřednictvím azure-identity knihovny s proměnnými prostředí přidanými službou Service Připojení or. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

from azure.identity import ManagedIdentityCredential, ClientSecretCredential
import os

# Uncomment the following lines according to the authentication type.
# 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')

V souboru nastavení získejte informace o databázi Azure MySQL z proměnných prostředí přidaných službou Service Připojení or. Pro přístup k databázi použijte accessToken získané v předchozím kroku.

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

Nainstalujte závislosti.

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"

V kódu získejte přístupový token prostřednictvím azidentitya pak se pomocí tokenu připojte k Azure MySQL. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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 according to the authentication type.
  // 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)
}

Instalace závislostí

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

Získání přístupového tokenu pomocí @azure/identity a informací o databázi Azure MySQL z proměnných prostředí přidaných službou Service Připojení or. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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

const mysql = require('mysql2');

// Uncomment the following lines according to the authentication type.
// 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');
});

Další ukázky kódu najdete v tématu Připojení do databází Azure z App Service bez tajných kódů využívajících spravovanou identitu.

Nainstalujte závislosti.

dotnet add package Microsoft.Data.SqlClient

Získejte připojovací řetězec Azure SQL Database z proměnné prostředí přidané službou Service Připojení or.
```
using Microsoft.Data.SqlClient;

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

using var connection = new SqlConnection(connectionString);
connection.Open();
```
Další informace najdete v tématu Použití ověřování spravované identity služby Active Directory.

Do souboru pom.xml přidejte následující závislosti:

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

Získejte připojovací řetězec Azure SQL Database z proměnné prostředí přidané službou Service Připojení or.

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

Další informace najdete v tématu Připojení k databázím Azure z App Service bez tajných kódů pomocí spravované identity.

Pokud pro aplikaci Spring vytvoříte připojení s možností --client-type springboot, service Připojení or nastaví vlastnosti spring.datasource.url s formátem jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; hodnoty na Azure Spring Apps.

Aktualizujte aplikaci podle kurzu Migrace aplikace v Javě tak, aby používala připojení bez hesla se službou Azure SQL Database. Nezapomeňte odebrat spring.datasource.password vlastnost konfigurace, pokud byla nastavena dříve, a přidat správné závislosti.

Nainstalujte závislosti.
```
python -m pip install pyodbc
```

Získejte konfigurace připojení azure SQL Database z proměnné prostředí přidané službou Service Připojení or. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít. Pokud používáte Azure Container Apps jako výpočetní službu nebo připojovací řetězec v fragmentu kódu nefunguje, přečtěte si článek o migraci aplikace Pythonu, která k připojení ke službě Azure SQL Database používá bez hesla připojení ke službě Azure SQL Database pomocí přístupového tokenu.

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 according to the authentication type.
# 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)

Nainstalujte závislosti.
```
npm install mssql
```

Získejte konfigurace připojení ke službě Azure SQL Database z proměnných prostředí přidaných službou Service Připojení or. Při použití následujícího kódu odkomentujte část fragmentu kódu pro typ ověřování, který chcete použít.

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 according to the authentication type.
// 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);

Další informace naleznete v tématu Domovská stránka pro programování klientů na Microsoft SQL Server.

Nasazení aplikace do hostitelské služby Azure

Nakonec nasaďte aplikaci do hostitelské služby Azure. Tato zdrojová služba může použít spravovanou identitu pro připojení k cílové databázi v Azure.

Pro službu Aplikace Azure Service můžete kód aplikace nasadit pomocí az webapp deploy příkazu. Další informace najdete v tématu Rychlý start: Nasazení webové aplikace ASP.NET.

Pak můžete zkontrolovat protokol nebo volat aplikaci a zjistit, jestli se může úspěšně připojit k databázi Azure.

Řešení problému

Oprávnění

Pokud dojde k nějakým chybám souvisejícím s oprávněními, pomocí příkazu az account showpotvrďte přihlášeného uživatele Azure CLI . Ujistěte se, že se přihlašujete pomocí správného účtu. Dále ověřte, že máte následující oprávnění, která můžou být nutná k vytvoření připojení bez hesla ke službě Připojení or.

Oprávnění	Operace
`Microsoft.DBforPostgreSQL/flexibleServers/read`	Vyžadováno pro získání informací o databázovém serveru
`Microsoft.DBforPostgreSQL/flexibleServers/write`	Vyžadováno pro povolení ověřování Microsoft Entra pro databázový server
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write`	Vyžaduje se k vytvoření pravidla brány firewall pro případ, že je místní IP adresa blokovaná.
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete`	Vyžaduje se vrácení pravidla brány firewall vytvořeného službou Service Připojení or, aby se zabránilo problému se zabezpečením.
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/read`	Vyžaduje se ke kontrole, jestli je přihlašovacím uživatelem Azure CLI databázový server Microsoft Entra administrator.
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/write`	Vyžaduje se přidání přihlašovacího uživatele Azure CLI jako databázového serveru Microsoft Entra.

Oprávnění	Operace
`Microsoft.DBforMySQL/flexibleServers/read`	Vyžadováno pro získání informací o databázovém serveru
`Microsoft.DBforMySQL/flexibleServers/write`	Vyžaduje se přidání poskytnuté spravované identity přiřazené uživatelem na databázový server.
`Microsoft.DBforMySQL/flexibleServers/firewallRules/write`	Vyžaduje se k vytvoření pravidla brány firewall pro případ, že je místní IP adresa blokovaná.
`Microsoft.DBforMySQL/flexibleServers/firewallRules/delete`	Vyžaduje se vrácení pravidla brány firewall vytvořeného službou Service Připojení or, aby se zabránilo problému se zabezpečením.
`Microsoft.DBforMySQL/flexibleServers/administrators/read`	Vyžaduje se ke kontrole, jestli je přihlašovacím uživatelem Azure CLI databázový server Microsoft Entra administrator.
`Microsoft.DBforMySQL/flexibleServers/administrators/write`	Vyžaduje se přidání přihlašovacího uživatele Azure CLI jako databázového serveru Microsoft Entra.

Oprávnění	Operace
`Microsoft.Sql/servers/read`	Vyžadováno pro získání informací o databázovém serveru
`Microsoft.Sql/servers/firewallRules/write`	Vyžaduje se k vytvoření pravidla brány firewall pro případ, že je místní IP adresa blokovaná.
`Microsoft.Sql/servers/firewallRules/delete`	Vyžaduje se vrácení pravidla brány firewall vytvořeného službou Service Připojení or, aby se zabránilo problému se zabezpečením.
`Microsoft.Sql/servers/administrators/read`	Vyžaduje se ke kontrole, jestli je přihlašovacím uživatelem Azure CLI databázový server Microsoft Entra administrator.
`Microsoft.Sql/servers/administrators/write`	Vyžaduje se přidání přihlašovacího uživatele Azure CLI jako databázového serveru Microsoft Entra.

V některýchpřípadechch Pokud je například ověřený uživatel Azure CLI již službou Active Directory Správa istrator na SQL Serveru, nemusíte mít Microsoft.Sql/servers/administrators/write oprávnění.

Microsoft Entra ID

Pokud se zobrazí chyba ERROR: AADSTS530003: Your device is required to be managed to access this resource., požádejte oddělení IT o pomoc s připojením tohoto zařízení k Microsoft Entra ID. Další informace najdete v tématu Zařízení připojená k Microsoft Entra.

Služba Připojení or potřebuje přístup k ID Microsoft Entra, aby získal informace o vašem účtu a spravované identitě hostitelské služby. Pomocí následujícího příkazu můžete zkontrolovat, jestli má vaše zařízení přístup k Microsoft Entra ID:

az ad signed-in-user show

Pokud se nepřihlásíte interaktivně, může se zobrazit také chyba a Interactive authentication is needed. Pokud chcete chybu vyřešit, přihlaste se pomocí az login příkazu.

Připojení k síti

Pokud je váš databázový server ve virtuální síti, ujistěte se, že vaše prostředí, na kterém běží příkaz Azure CLI, má přístup k serveru ve virtuální síti.

Pokud databázový server nepovoluje veřejný přístup, ujistěte se, že vaše prostředí, na kterém běží příkaz Azure CLI, má přístup k serveru prostřednictvím privátního koncového bodu.

Další kroky

Další informace o službě Připojení or a bez hesla najdete v následujících zdrojích informací:

Dokumentace ke službě Připojení or

Připojení bez hesla pro služby Azure

Share via

Kurz: Vytvoření připojení k databázové službě bez hesla prostřednictvím služby Připojení or

Požadavky

Nastavení prostředí

Obchodní vztah

Instalace rozšíření service Připojení or bez hesla

Vytvoření připojení bez hesla

Připojení do databáze s ověřováním Microsoft Entra

Nasazení aplikace do hostitelské služby Azure

Řešení problému

Oprávnění

Microsoft Entra ID

Připojení k síti

Další kroky

Další materiály