Kurz: Vytvoření připojení bez hesla k databázové službě prostřednictvím konektoru Service Connector

Článek
10/22/2024

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 Connector umožňuje spravované identity v hostitelských službách aplikací, jako jsou Azure Spring Apps, Aplikace Azure Service a Azure Container Apps. Konektor služby také konfiguruje databázové služby, jako je Azure Database for PostgreSQL, Azure Database for MySQL a Azure SQL Database, tak, aby přijímaly spravované identity.

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í konektoru Service Connector.
Pro přístup k databázové službě použijte proměnné prostředí nebo konfigurace vygenerované konektorem služby Service Connector.

Požadavky

Azure CLI verze 2.61.0 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é konektorem služby.

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í Bez hesla konektoru služby

Nainstalujte nejnovější rozšíření bez hesla konektoru Service Connector pro Azure CLI:

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

Poznámka:

Spuštěním příkazu az version zkontrolujte, jestli je verze serviceconnector-passwordless verze 2.0.2 nebo vyšší. Abyste mohli upgradovat verzi rozšíření, možná budete muset nejprve upgradovat Azure CLI.

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 k databázi 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 Konektor služby Aplikace Azure Service, Azure Spring Apps nebo Azure Container Apps a vyberte Vytvořit a 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, může to být java, dotnet, python atd. Spusťte az webapp connection create postgres-flexible -h příkaz pro 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 $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

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_MANAGED_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ího správce nebo správce privilegovaných rolí, 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í konektoru služby.

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 konektoru 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.
Povolte ověřování Microsoft Entra pro databázový server, pokud ještě není povoleno.
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 se konfigurace nastaví 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ě Konektor služby na webu Azure Portal.

Service Connector uživateli přiřadí následující oprávnění, můžete je odvolat a upravit podle svých požadavků.

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

Připojení k databázi pomocí ověřování 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 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();
}

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 Connector nastaví vlastnosti spring.datasource.azure.passwordless-enabledspring.datasource.urla 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
pip freeze > requirements.txt # Save the dependencies to a file

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 konektorem Service Connector. 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 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)

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 konektorem Service Connector 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 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')

V souboru nastavení získejte informace o databázi Azure PostgreSQL z proměnných prostředí přidaných službou Service Connector. 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 konektorem služby. 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 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()

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 konektoru služby Service Connector. 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 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();
})();

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 konektorem služby 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 https://ossrdbms-aad.database.windows.net/.default ID tenanta, ID klienta a tajný klíč klienta instančního objektu z proměnných prostředí přidaných konektorem služby.
Zkombinujte přístupový token a bodování připojení PostgreSQL z proměnných prostředí přidaných službou Service Connector a vytvořte 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 Konektor služby. 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 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,
)

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 konektoru služby, musíte se připojit jako vlastník a udělit oprávnění k <aad-username> vytvoření konektorem služby. Uživatelské jméno z připojovací řetězec nebo konfigurace nastavené konektorem služby by mělo vypadat taktoaad_<connection name>. 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ý konektorem služby. 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 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

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

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

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

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

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

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

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í instance Azure Database for MySQL 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 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 získat prostřednictvím azure-identity knihovny a získejte informace o připojení z proměnné prostředí přidané konektorem service connectoru. 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 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()

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 konektorem služby Service Connector. 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 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')

V souboru nastavení získejte informace o databázi Azure MySQL z proměnných prostředí přidaných službou Service Connector. 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 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)
}

Instalace závislostí

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

Získání přístupového tokenu pomocí @azure/identity informací o databázi Azure MySQL z proměnných prostředí přidaných službou Service Connector 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 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');
});

Další ukázky kódu najdete v tématu Připojení k databázím Azure ze služby App Service bez tajných kódů pomocí spravované identity.

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é konektorem služby.

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é konektorem služby.

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 ze služby 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 Connector 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í ke službě Azure SQL Database z proměnné prostředí přidané konektorem služby. 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 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)

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 konektorem služby. 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 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);

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 můžete zkontrolovat dokument a zvolit způsob nasazení, viz 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 konektoru Service Connector.

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, aby se vrátilo pravidlo brány firewall vytvořené konektorem služby Service Connector, 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, aby se vrátilo pravidlo brány firewall vytvořené konektorem služby Service Connector, 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, aby se vrátilo pravidlo brány firewall vytvořené konektorem služby Service Connector, 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 uživatel ověřený rozhraním příkazového řádku Azure už na SQL Serveru správcem služby Active Directory, 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.

Service Connector potřebuje přístup k Microsoft Entra ID, 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 konektoru Service Connector a připojeních bez hesel najdete v následujících zdrojích informací:

Dokumentace ke službě Service Connector

Připojení bez hesla pro služby Azure

Sdílet prostřednictvím

Kurz: Vytvoření připojení bez hesla k databázové službě prostřednictvím konektoru Service Connector

Požadavky

Nastavení prostředí

Obchodní vztah

Instalace rozšíření Bez hesla konektoru služby

Vytvoření připojení bez hesla

Připojení k databázi pomocí ověřování 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

Váš názor

Další materiály