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

2025-04-30

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 jsou Azure Database for PostgreSQL, Azure Database for MySQL, Azure SQL Database a DATABÁZE SQL v Microsoft Fabric, 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

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

Jak začít používat Azure CLI:

Použijte prostředí Bash v Azure Cloud Shellu. Další informace najdete v tématu Začínáme s Azure Cloud Shellem.
Pokud dáváte přednost místnímu spouštění referenčních příkazů rozhraní příkazového řádku, nainstalujte Azure CLI. Pokud používáte Windows nebo macOS, zvažte spuštění Azure CLI v kontejneru Dockeru. Další informace najdete v tématu Jak spustit Azure CLI v kontejneru Dockeru.
- Pokud používáte místní instalaci, přihlaste se k Azure CLI pomocí příkazu az login . Pokud chcete dokončit proces ověřování, postupujte podle kroků zobrazených v terminálu. Další možnosti přihlášení najdete v tématu Ověřování v Azure pomocí Azure CLI.
- Po zobrazení výzvy nainstalujte rozšíření Azure CLI při prvním použití. Další informace o rozšířeních najdete v tématu Použití a správa rozšíření pomocí Azure CLI.
- Spuštěním příkazu az version vyhledejte nainstalovanou verzi a závislé knihovny. Pokud chcete upgradovat na nejnovější verzi, spusťte příkaz az upgrade.

Nainstalujte rozšíření konektoru služby bez hesla

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žbyazure App 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íslužby 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

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

Důležité

K dokončení onboardingu se v současné době vyžaduje sdílení ručního přístupu. Viz Sdílení přístupu k databázi SQL ve Fabric.

az webapp connection create fabricsql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --fabric-workspace-uuid $FABRIC_WORKSPACE_UUID \
    --fabric-sql-db-uuid $FABRIC_SQL_DB_UUID \
    --user-identity client-id=XX subs-id=XX \
    --client-type dotnet

az webapp connection create fabricsql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --fabric-workspace-uuid $FABRIC_WORKSPACE_UUID \
    --fabric-sql-db-uuid $FABRIC_SQL_DB_UUID \
    --system-identity \
    --client-type dotnet

Tento příkaz služby konektoru dokončí na pozadí 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_CONNECTIONSTRING, AZURE_SQL_CONNECTIONSTRINGnebo FABRIC_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";

ALTER ROLE db_datareader ADD MEMBER "username"
ALTER ROLE db_datawriter ADD MEMBER "username"
ALTER ROLE db_ddladmin ADD MEMBER "username"

Připojení k databázi pomocí ověřování Microsoft Entra

Po vytvoření připojení můžete ve své aplikaci použít připojovací řetězec k připojení k databázi s ověřováním 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.7.5</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-extensions</artifactId>
    <version>1.2.0</version>
</dependency>

Získejte připojovací řetězec z proměnných prostředí a přidejte název pluginu 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 volbou --client-type springboot, Service Connector nastaví vlastnosti spring.datasource.azure.passwordless-enabled, spring.datasource.url a spring.datasource.username na 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ískejte přístupový token pomocí knihovny azure-identity s využitím 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 a informací o připojení k PostgreSQL z proměnných prostředí přidaných službou 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";
import { Client } from 'pg';

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

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

// For service principal.
// const tenantId = process.env.AZURE_POSTGRESQL_TENANTID;
// const clientId = process.env.AZURE_POSTGRESQL_CLIENTID;
// const clientSecret = process.env.AZURE_POSTGRESQL_CLIENTSECRET;
// const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);

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

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

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

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 provedete požadavek HTTP GET na koncový bod identity a použijete https://ossrdbms-aad.database.windows.net jako resource v dotazu. U identit přiřazených uživateli zahrňte do dotazu také ID klienta z proměnných prostředí přidaných konektorem služby (Service Connector).

V případě principálního objektu služby se podívejte na žádost o přístupový token služby Azure AD, kde najdete postup, jak získat přístupový token. Vytvořte požadavek POST v rozsahu https://ossrdbms-aad.database.windows.net/.default a použijte ID tenanta, ID klienta a klientský tajný klíč hlavní služby z proměnných prostředí přidaných konektorem služby.
Zkombinujte přístupový token a připojovací řetězec 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 tom, jak získat přístupový token pro service principal, 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ým 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 rozbalit vedle sloupce Service Type a získejte hodnotu. Pokud používáte Azure CLI, zkontrolujte configurations výstup příkazu CLI.

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-username> a <owner-password> je vlastníkem existující tabulky, který může udělit oprávnění ostatním. <aad-username> je uživatel vytvořený Service Connectoru. 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.33</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-extensions</artifactId>
    <version>1.2.0</version>
</dependency>

Získejte připojovací řetězec z prostřední proměnné a přidejte název pluginu k 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

Nainstalujte závislosti

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ískaného prostřednictvím azure-identity knihovny a získejte informace o připojení z proměnné prostředí přidanou 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)
}

Nainstalujte závislosti

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

Získejte přístupový token pomocí informací o databázi Azure MySQL a 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, nastaví Service Connector vlastnosti spring.datasource.url ve formátu hodnoty jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; pro 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ískat konfigurace připojení k Azure SQL Database z proměnné prostředí, kterou přidal 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. 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 v Pythonu pro použití bez hesel s Azure SQL Database pro 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.

Nainstalujte závislosti.

dotnet add package Microsoft.Data.SqlClient

Načtěte databázi SQL v připojovacím řetězci Microsoft Fabric z proměnné prostředí přidané konektorem služby.
```
using Microsoft.Data.SqlClient;

string connectionString = 
    Environment.GetEnvironmentVariable("FABRIC_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>

Načtěte databázi SQL v připojovacím řetězci Microsoft Fabric 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) {
        // FABRIC_SQL_CONNECTIONSTRING should be one of the following:
        // For system-assigned managed identity: "jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI;"
        // For user-assigned managed identity: "jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;msiClientId=<msiClientId>;authentication=ActiveDirectoryMSI;"
        String connectionString = System.getenv("FABRIC_SQL_CONNECTIONSTRING");
        SQLServerDataSource ds = new SQLServerDataSource();
        ds.setURL(connectionString);
        try (Connection connection = ds.getConnection()) {
            System.out.println("Connected successfully.");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

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í na Azure Spring Apps proměnnou prostředí FABRIC_SQL_CONNECTIONSTRING ve formátu hodnoty jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI;.

Pro spravované identity přiřazené uživatelem se přidá msiClientId=<msiClientId>;.

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 dříve nastavena, a přidat správné závislosti.

spring:
  datasource:
    url: ${FABRIC_SQL_CONNECTIONSTRING}

Nainstalujte závislosti.
```
python -m pip install pyodbc
```
Načtěte databázi SQL v připojovacím řetězci Microsoft Fabric z proměnné prostředí přidané konektorem služby. 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 Python, která používá bez hesel připojení ke službě Azure SQL Database pro připojení k databázi SQL v Microsoft Fabric pomocí přihlašovacích údajů bez hesel. Authentication=ActiveDirectoryMSI; je vyžadován v připojovacím řetězci při připojování pomocí spravovaných identit. UID=<msiClientId> je také vyžadován v připojovacím řetězci při připojování pomocí spravované identity přiřazené uživatelem.
```
import os
import pyodbc, struct
from azure.identity import DefaultAzureCredential

connStr = os.getenv('FABRIC_SQL_CONNECTIONSTRING')

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

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

conn = pyodbc.connect(connString)
```

Nainstalujte závislosti.

go mod init <YourProjectName>
go mod tidy

Načtěte databázi SQL v připojovacím řetězci Microsoft Fabric z proměnné prostředí přidané konektorem služby.

package main

import (
    "github.com/microsoft/go-mssqldb/azuread"
    "database/sql"
    "context"
    "log"
    "fmt"
    "os"
)

var db *sql.DB

var connectionString = os.Getenv("FABRIC_SQL_CONNECTIONSTRING")

func main() {
    var err error

    // Create connection pool
    db, err = sql.Open(azuread.DriverName, connectionString)
    if err != nil {
        log.Fatal("Error creating connection pool: ", err.Error())
    }
    ctx := context.Background()
    err = db.PingContext(ctx)
    if err != nil {
        log.Fatal(err.Error())
    }
    fmt.Printf("Connected!\n")
}

Další informace najdete v tématu Použití jazyka Go k dotazování databáze ve službě Azure SQL Database.

Další informace najdete v tématu Připojení k databázi SQL v Microsoft Fabric.

Nasazení aplikace do hostitelské služby Azure

Nasaďte aplikaci do hostitelské služby Azure. Další informace o nasazení těchto prostředků najdete v následujících příručkách.
- Azure App Service: Rychlý start: Nasazení webové aplikace ASP.NET
- Azure Container Apps: Rychlý start: Nasazení první aplikace kontejneru
- Azure Spring Apps: Sestavte a nasaďte aplikaci.
  
  Poznámka:
  
  Plány Basic, Standard a Enterprise vstoupily do období vyřazení 17. března 2025. Další informace najdete v oznámení o vyřazení Azure Spring Apps.
  
  Standardní spotřeba a vyhrazený plán se dostaly do období vyřazování 30. září 2024, s úplným vypnutím do konce března 2025. Další informace naleznete v části Migrace konzumace služby Azure Spring Apps úrovně Standard a vyhrazeného plánu do Azure Container Apps.
Zkontrolujte protokol nebo zavolejte aplikaci, abyste zjistili, jestli se může úspěšně připojit k databázi Azure.

Řešení problému

Dovolení

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`	Je nutné vytvořit pravidlo brány firewall, pokud je místní IP adresa blokována.
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete`	Je třeba vrátit pravidlo brány firewall vytvořené konektorem služby, aby se zabránilo problému se zabezpečením.
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/read`	Je požadováno zkontrolovat, zda je přihlašovací uživatel Azure CLI správcem na databázovém serveru Microsoft Entra.
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/write`	Je nutné přidat uživatele přihlášeného pomocí Azure CLI jako administrátora serveru databáze 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`	Je nutné vytvořit pravidlo brány firewall, pokud je místní IP adresa blokována.
`Microsoft.DBforMySQL/flexibleServers/firewallRules/delete`	Je třeba vrátit pravidlo brány firewall vytvořené konektorem služby, aby se zabránilo problému se zabezpečením.
`Microsoft.DBforMySQL/flexibleServers/administrators/read`	Je požadováno zkontrolovat, zda je přihlašovací uživatel Azure CLI správcem na databázovém serveru Microsoft Entra.
`Microsoft.DBforMySQL/flexibleServers/administrators/write`	Je nutné přidat uživatele přihlášeného pomocí Azure CLI jako administrátora serveru databáze 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`	Je nutné vytvořit pravidlo brány firewall, pokud je místní IP adresa blokována.
`Microsoft.Sql/servers/firewallRules/delete`	Je třeba vrátit pravidlo brány firewall vytvořené konektorem služby, aby se zabránilo problému se zabezpečením.
`Microsoft.Sql/servers/administrators/read`	Je požadováno zkontrolovat, zda je přihlašovací uživatel Azure CLI správcem na databázovém serveru Microsoft Entra.
`Microsoft.Sql/servers/administrators/write`	Je nutné přidat uživatele přihlášeného pomocí Azure CLI jako administrátora serveru databáze Microsoft Entra.

V některých případech nejsou oprávnění vyžadována. 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

Nainstalujte rozšíření konektoru služby bez hesla

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

Dovolení

Microsoft Entra ID

Připojení k síti

Další kroky

Váš názor

Další materiály