Tutorial: Erstellen einer kennwortlosen Verbindung mit einem Datenbankdienst über den Dienstconnector

Artikel
10/22/2024

Kennwortlose Verbindungen verwenden verwaltete Identitäten für den Zugriff auf Azure-Dienste. Bei diesem Ansatz müssen Sie Geheimnisse für verwaltete Identitäten nicht manuell nachverfolgen und verwalten. Diese Aufgaben werden intern sicher von Azure verarbeitet.

Der Dienstconnector ermöglicht verwaltete Identitäten in App-Hostingdiensten wie Azure Spring Apps, Azure App Service und Azure Container Apps. Außerdem konfiguriert der Dienstconnector auch Datenbankdienste wie Azure Database for PostgreSQL, Azure Database for MySQL und Azure SQL Datenbank, um verwaltete Identitäten zu akzeptieren.

In diesem Tutorial wird die Azure CLI verwendet, um folgende Aufgaben auszuführen:

Überprüfen Sie die anfängliche Umgebung mit der Azure CLI.
Erstellen Sie eine kennwortlose Verbindung mit Dienstconnector.
Verwenden Sie die vom Dienstconnector generierten Umgebungsvariablen oder Konfigurationen, um auf einen Datenbankdienst zuzugreifen.

Voraussetzungen

Mindestens Version 2.61.0 der Azure CLI
Ein Azure-Konto mit einem aktiven Abonnement. Erstellen Sie kostenlos ein Azure-Konto.
Eine App, die in Azure Spring Apps in einer vom Dienstconnector unterstützten Region bereitgestellt wird.

Erstellen Ihrer Umgebung

Konto

Anmelden mit der Azure CLI über az login. Wenn Sie Azure Cloud Shell verwenden oder bereits angemeldet sind, bestätigen Sie Ihr authentifiziertes Konto mit az account show.

Installieren der kennwortlosen Dienstconnector-Erweiterung

Installieren Sie die aktuelle kennwortlose Dienstconnector-Erweiterung für die Azure CLI:

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

Hinweis

Überprüfen Sie mit az version, ob Sie Version 2.0.2 oder höher der Erweiterung „serviceconnector-passwordless“ ausführen. Möglicherweise müssen Sie zuerst ein Upgrade der Azure CLI durchführen, um die Erweiterungsversion zu aktualisieren.

Erstellen einer kennwortlosen Verbindung

Als Nächstes verwenden wir Azure App Service als Beispiel, um eine Verbindung mit verwalteter Identität zu erstellen.

Wenn Sie:

Azure Spring Apps: verwenden Sie stattdessen az spring connection create. Weitere Beispiele finden Sie unter Verbinden von Azure Spring Apps mit der Azure-Datenbank.
Azure Container Apps: verwenden Sie stattdessen az containerapp connection create. Weitere Beispiele finden Sie unter Erstellen und Verbinden einer PostgreSQL-Datenbank mit Identitätskonnektivität.

Hinweis

Wenn Sie das Azure-Portal verwenden, wechseln Sie zum Blatt Dienstconnector von Azure App Service, Azure Spring Apps oder Azure Container Apps, und wählen Sie Erstellen aus, um eine Verbindung zu erstellen. Das Azure-Portal erstellt den Befehl automatisch und löst die Befehlsausführung auf Cloud Shell aus.

Der folgende Azure CLI-Befehl verwendet einen --client-type-Parameter. Zulässig sind Java, .NET, Python usw. sein. Führen Sie az webapp connection create postgres-flexible -h aus, um die unterstützten Clienttypen abzurufen, und wählen Sie den aus, der Ihrer Anwendung entspricht.

az webapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $POSTGRESQL_HOST \
    --database $DATABASE_NAME \
    --user-identity client-id=XX subs-id=XX \
    --client-type $CLIENT_TYPE

az webapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $POSTGRESQL_HOST \
    --database $DATABASE_NAME \
    --system-identity \
    --client-type $CLIENT_TYPE

az webapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $POSTGRESQL_HOST \
    --database $DATABASE_NAME \
    --service-principal client-id=XX secret=XX\
    --client-type $CLIENT_TYPE

Azure Database for MySQL – Flexibler Server erfordert eine benutzerseitig zugewiesene verwaltete Identität, um die Microsoft Entra-Authentifizierung zu aktivieren. Weitere Informationen finden Sie unter Einrichten der Microsoft Entra-Authentifizierung für Azure Database for MySQL – Flexibler Server. Mit dem folgenden Befehl können Sie eine benutzerzugeordnete verwaltete Identität erstellen:

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

Wichtig

Nach dem Erstellen der benutzerseitig zugewiesenen verwalteten Identität bitten Sie Ihren globalen Administrator oder Administrator für privilegierte Rollen, die folgenden Berechtigungen für diese Identität zu erteilen:

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

Weitere Informationen finden Sie im Abschnitt Berechtigungen der Active Directory-Authentifizierung.

Verbinden Sie dann Ihre App mithilfe des Dienstconnectors mit einer MySQL-Datenbank mit einer systemseitig zugewiesenen verwalteten Identität.

Der folgende Azure CLI-Befehl verwendet einen --client-type-Parameter. Führen Sie az webapp connection create mysql-flexible -h aus, um die unterstützten Clienttypen abzurufen, und wählen Sie den aus, der Ihrer Anwendung entspricht.

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

Der folgende Azure CLI-Befehl verwendet einen --client-type-Parameter. Führen Sie az webapp connection create sql -h aus, um die unterstützten Clienttypen abzurufen, und wählen Sie den aus, der Ihrer Anwendung entspricht.

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

Mit diesem Dienstconnector-Befehl werden die folgenden Aufgaben im Hintergrund ausgeführt:

Aktivieren Sie die systemseitig zugewiesene verwaltete Identität, oder weisen Sie der App $APPSERVICE_NAME, die von Azure App Service/Azure Spring Apps/Azure Container Apps gehostet wird, eine Benutzeridentität zu.
Aktivieren der Microsoft Entra-Authentifizierung für den Datenbankserver, sofern noch nicht geschehen
Legen Sie den Microsoft Entra-Administrator auf den aktuellen angemeldeten Benutzer fest.
Fügen Sie einen Datenbankbenutzer für die systemseitig zugewiesene verwaltete Identität, die vom Benutzer zugewiesene verwaltete Identität oder den Dienstprinzipal hinzu. Gewähren Sie diesem Benutzer alle Berechtigungen für die Datenbank $DATABASE_NAME. Der Benutzername befindet sich in der Verbindungszeichenfolge in der vorherigen Befehlsausgabe.
Legen Sie Konfigurationen mit dem Namen AZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRING oder AZURE_SQL_CONNECTIONSTRING entsprechend dem Datenbanktyp auf die Azure-Ressource fest.
- Für App Service werden die Konfigurationen auf dem Blatt App-Einstellungen festgelegt.
- Für Spring Apps werden die Konfigurationen festgelegt, wenn die Anwendung gestartet wird.
- Für Container Apps werden die Konfigurationen auf die Umgebungsvariablen festgelegt. Sie können alle Konfigurationen und ihre Werte auf dem Blatt Dienstconnector im Azure-Portal abrufen.

Der Dienstconnector weist dem Benutzer die folgenden Berechtigungen zu. Sie können sie widerrufen und die Berechtigungen basierend auf Ihren Anforderungen anpassen.

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

Herstellen einer Verbindung mit einer Datenbank mit Microsoft Entra-Authentifizierung

Nach dem Herstellen der Verbindung können Sie die Verbindungszeichenfolge in Ihrer Anwendung verwenden, um eine Verbindung mit der Datenbank mit Microsoft Entra-Authentifizierung herzustellen. Sie können beispielsweise die folgenden Lösungen verwenden, um eine Verbindung mit der Datenbank mit Microsoft Entra-Authentifizierung herzustellen.

Für .NET gibt es kein Plug-In und keine Bibliothek, die kennwortlose Verbindungen unterstützen. Sie können ein Zugriffstoken für die verwaltete Identität oder den Dienstprinzipal mithilfe einer Clientbibliothek wie Azure.Identity abrufen. Anschließend können Sie das Zugriffstoken als Kennwort verwenden, um eine Verbindung mit der Datenbank herzustellen. Wenn Sie den folgenden Code verwenden, heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

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

Fügen Sie der Datei pom.xml die folgenden Abhängigkeiten hinzu:

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

Rufen Sie die Verbindungszeichenfolge aus Umgebungsvariablen ab, und fügen Sie den Plug-In-Namen hinzu, um eine Verbindung mit der Datenbank herzustellen:

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

Weitere Informationen finden Sie in den folgenden Ressourcen:

Spring-Anwendung: Wenn Sie mit der Option --client-type springboot eine Verbindung herstellen, legt der Dienstconnector die Eigenschaften spring.datasource.azure.passwordless-enabled, spring.datasource.url und spring.datasource.username auf Azure Spring Apps fest.

Aktualisieren Sie Ihre Anwendung nach dem Tutorial Binden einer Azure Database for PostgreSQL an Ihre Anwendung in Azure Spring Apps. Denken Sie daran, die Konfigurationseigenschaft spring.datasource.password zu entfernen, wenn sie zuvor festgelegt wurde, und fügen Sie die richtigen Abhängigkeiten zu Ihrer Spring-Anwendung hinzu.

Weitere Tutorials finden Sie unter Verwenden von Spring Data JDBC mit Azure Database for PostgreSQL und Tutorial: Bereitstellen einer Spring-Anwendung in Azure Spring Apps mit kennwortloser Verbindung mit einer Azure-Datenbank.

Installieren Sie Abhängigkeiten.

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

Rufen Sie einen Zugriffstoken mithilfe der azure-identity-Bibliothek ab, und verwenden Sie das Token als Kennwort. Rufen Sie Verbindungsinformationen aus den Umgebungsvariablen ab, die vom Dienstconnector hinzugefügt wurden. Wenn Sie den folgenden Code verwenden, heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

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)

Installieren Sie Abhängigkeiten.
```
pip install azure-identity
```

Rufen Sie ein Zugriffstoken mithilfe der azure-identity-Bibliothek mithilfe der Umgebungsvariablen ab, die vom Dienstconnector hinzugefügt wurden. Wenn Sie den folgenden Code verwenden, heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

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

Rufen Sie in der Einstellungsdatei die Informationen zur Azure PostgreSQL-Datenbank aus den Umgebungsvariablen ab, die vom Dienstconnector hinzugefügt wurden. Verwenden Sie das im vorherigen Schritt abgerufene Zugriffstoken (accessToken), um auf die Datenbank zuzugreifen.

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

Installieren Sie Abhängigkeiten.

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"

Rufen Sie im Code ein Zugriffstoken mittels azidentity ab, und verwenden Sie es dann als Kennwort zusammen mit den vom Dienstconnector bereitgestellten Verbindungsinformationen, um eine Verbindung mit Azure PostgreSQL herzustellen. Wenn Sie den folgenden Code verwenden, heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

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

Installieren Sie Abhängigkeiten.

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

Rufen Sie im Code das Zugriffstoken mittels @azure/identity ab und die PostgreSQL-Verbindungsinformationen aus den vom Dienstconnector hinzugefügten Umgebungsvariablen. Kombinieren Sie sie, um die Verbindung herzustellen. Wenn Sie den folgenden Code verwenden, heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

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

Für PHP gibt es kein Plug-In und keine Bibliothek für kennwortlose Verbindungen. Sie können ein Zugriffstoken für die verwaltete Identität oder den Dienstprinzipal abrufen und es als Kennwort verwenden, um eine Verbindung mit der Datenbank herzustellen. Das Zugriffstoken kann mithilfe der Azure REST-API abgerufen werden.

Rufen Sie im Code das Zugriffstoken mittels der REST-API mit Ihrer bevorzugten Bibliothek ab.

Für benutzerseitig und systemseitig zugewiesene Identitäten dienen App Service und Container Apps als intern zugängliche REST-Endpunkte, um Token für verwaltete Identitäten abzurufen, indem zwei Umgebungsvariablen definiert werden: IDENTITY_ENDPOINT und IDENTITY_HEADER. Weitere Informationen finden Sie unter Referenz zu REST-Endpunkten. Rufen Sie das Zugriffstoken ab, indem Sie eine HTTP GET-Anforderung an den Identitätsendpunkt senden und https://ossrdbms-aad.database.windows.net als resource in der Abfrage verwenden. Fügen Sie für die benutzerseitig zugewiesene Identität auch die Client-ID aus den Umgebungsvariablen hinzu, die vom Dienstconnector zur Abfrage hinzugefügt wurden.

Für den Dienstprinzipal finden Sie Einzelheiten zum Abrufen von Zugriffstoken unter Dienst-zu-Dienst-Zugriffstokenanforderung in Azure AD. Geben Sie für die POST-Anforderung den Bereich https://ossrdbms-aad.database.windows.net/.default sowie die Mandanten-ID, die Client-ID und den geheimen Clientschlüssel des Dienstprinzipals aus den vom Dienstconnector hinzugefügten Umgebungsvariablen an.
Kombinieren Sie das Zugriffstoken und die PostgreSQL-Verbindungszeichenfolge aus den Umgebungsvariablen, die vom Dienstconnector hinzugefügt wurden, um die Verbindung herzustellen.
```
<?php
$conn_string = sprintf("%s password=", getenv('AZURE_POSTGRESQL_CONNECTIONSTRING'), $access_token);
$dbconn = pg_connect($conn_string);
?>
```

Für Ruby gibt es kein Plug-In und keine Bibliothek für kennwortlose Verbindungen. Sie können ein Zugriffstoken für die verwaltete Identität oder den Dienstprinzipal abrufen und es als Kennwort verwenden, um eine Verbindung mit der Datenbank herzustellen. Das Zugriffstoken kann mithilfe der Azure REST-API abgerufen werden.

Installieren Sie Abhängigkeiten.
```
gem install pg
```

Rufen Sie im Code das Zugriffstoken über die REST-API und die PostgreSQL-Verbindungsinformationen aus den vom Dienstconnector hinzugefügten Verbindungsinformationen ab. Kombinieren Sie sie, um die Verbindung herzustellen. Wenn Sie den folgenden Code verwenden, heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

App Service und Container Apps dienen als intern zugängliche REST-Endpunkte zum Abrufen von Token für verwaltete Identitäten. Weitere Informationen finden Sie unter Referenz zu REST-Endpunkten.

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

Einzelheiten zum Abrufen von Zugriffstoken für den Dienstprinzipal finden Sie unter Dienst-zu-Dienst-Zugriffstokenanforderung in Azure AD.

Wenn Sie vor der Verwendung des Dienstconnectors Tabellen und Sequenzen auf dem flexiblen PostgreSQL-Server erstellt haben, müssen Sie als Nächstes als der Besitzer eine Verbindung herstellen und dem vom Dienstconnector erstellten <aad-username> die Berechtigung erteilen. Der Benutzername aus der Verbindungszeichenfolge oder der vom Dienstconnector festgelegten Konfiguration sollte aad_<connection name> ähneln. Wenn Sie das Azure-Portal verwenden, wählen Sie die Schaltfläche „erweitern“ neben der Service Type-Spalte aus, und rufen Sie den Wert ab. Wenn Sie die Azure CLI verwenden, überprüfen Sie configurations in der CLI-Befehlsausgabe.

Führen Sie dann die Abfrage aus, um die Berechtigung zu erteilen.

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

Der <owner-username> und das <owner-password> sind der Besitzer einer vorhandenen Tabelle, der anderen Personen Berechtigungen erteilen kann. <aad-username> ist der bzw. die Benutzer*in, der bzw. die vom Dienstconnector erstellt wurde. Ersetzen Sie sie durch den tatsächlichen Wert.

Überprüfen Sie das Ergebnis mit dem folgenden Befehl:

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

Fügen Sie der Datei pom.xml die folgenden Abhängigkeiten hinzu:

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

Rufen Sie die Verbindungszeichenfolge aus den Umgebungsvariablen ab, und fügen Sie den Plug-In-Namen hinzu, um eine Verbindung mit der Datenbank herzustellen:

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

Weitere Informationen finden Sie unter Verwenden von Java und JDBC mit Azure Database for MySQL – Flexibler Server.

Aktualisieren Sie Ihre Anwendung nach dem Tutorial Verbinden einer Azure Database for MySQL-Instanz mit Ihrer Anwendung in Azure Spring Apps. Denken Sie daran, die Konfigurationseigenschaft spring.datasource.password zu entfernen, wenn sie zuvor festgelegt wurde, und fügen Sie die richtigen Abhängigkeiten zu Ihrer Spring-Anwendung hinzu.

Weitere Tutorials finden Sie unter Verwenden von Spring Data-JDBC mit Azure Database for MySQL.

Installieren von Abhängigkeiten

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

Authentifizieren Sie mit Zugriffstoken, die über die azure-identity-Bibliothek abgerufen werden, und rufen Sie Verbindungsinformationen aus der Umgebungsvariable ab, die vom Dienstconnector hinzugefügt wurde. Wenn Sie den folgenden Code verwenden, heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

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

Installieren Sie Abhängigkeiten.
```
pip install azure-identity
```

Rufen Sie ein Zugriffstoken über die azure-identity-Bibliothek mithilfe der Umgebungsvariablen ab, die vom Dienstconnector hinzugefügt wurden. Wenn Sie den folgenden Code verwenden, heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

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

Rufen Sie in der Einstellungsdatei die Informationen zur Azure MySQL-Datenbank aus den Umgebungsvariablen ab, die vom Dienstconnector hinzugefügt wurden. Verwenden Sie das im vorherigen Schritt abgerufene Zugriffstoken (accessToken), um auf die Datenbank zuzugreifen.

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

Installieren Sie Abhängigkeiten.

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"

Rufen Sie im Code das Zugriffstoken über azidentity ab, und stellen Sie dann mit dem Token eine Verbindung mit Azure MySQL her. Wenn Sie den folgenden Code verwenden, heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

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

Installieren von Abhängigkeiten

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

Rufen Sie einen Zugriffstoken mithilfe von @azure/identity und Azure MySQL-Datenbank aus den Umgebungsvariablen ab, die vom Dienstconnector hinzugefügt wurde. Wenn Sie den folgenden Code verwenden, heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

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

Weitere Codebeispiele finden Sie unter Verbindungsherstellung mit Azure-Datenbanken über App Service ohne Geheimnisse mithilfe einer verwalteten Identität.

Installieren Sie Abhängigkeiten.

dotnet add package Microsoft.Data.SqlClient

Rufen Sie die Azure SQL-Datenbank-Verbindungszeichenfolge aus der Umgebungsvariable ab, die vom Dienstconnector hinzugefügt wird.
```
using Microsoft.Data.SqlClient;

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

using var connection = new SqlConnection(connectionString);
connection.Open();
```
Weitere Informationen finden Sie unter Verwenden der Active Directory mit verwalteter Identität-Authentifizierung.

Fügen Sie der Datei pom.xml die folgenden Abhängigkeiten hinzu:

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

Rufen Sie die Azure SQL-Datenbank-Verbindungszeichenfolge aus der Umgebungsvariable ab, die vom Dienstconnector hinzugefügt wird.

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

Weitere Informationen finden Sie unter Herstellen einer Verbindung mit Azure-Datenbanken über App Service ohne Geheimnisse mithilfe einer verwalteten Identität.

Wenn Sie für eine Spring-Anwendung eine Verbindung mit der Option --client-type springboot erstellen, setzt Service Connector die Eigenschaften spring.datasource.url mit dem Werteformat jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; auf Azure Spring Apps.

Aktualisieren Sie Ihre Anwendung nach dem Tutorial Migrieren einer Java-Anwendung zur Verwendung von kennwortlosen Verbindungen mit Azure SQL-Datenbank. Denken Sie daran, die Konfigurationseigenschaft spring.datasource.password zu entfernen, wenn sie zuvor festgelegt wurde, und fügen Sie die richtigen Abhängigkeiten hinzu.

Installieren Sie Abhängigkeiten.
```
python -m pip install pyodbc
```

Rufen Sie die Azure SQL-Datenbank-Verbindungskonfigurationen aus der Umgebungsvariable ab, die von Service Connector hinzugefügt wurde. Wenn Sie den folgenden Code verwenden, heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten. Wenn Sie Azure Container Apps als Computedienst verwenden oder die Verbindungszeichenfolge im Codeausschnitt nicht funktioniert, lesen Sie Migrieren einer Python-Anwendung, um kennwortlose Verbindungen mit Azure SQL-Datenbank zum Herstellen einer Verbindung mit Azure SQL-Datenbank mithilfe eines Zugriffstokens zu verwenden.

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)

Installieren Sie Abhängigkeiten.
```
npm install mssql
```

Rufen Sie die Azure SQL-Datenbank-Verbindungskonfigurationen aus den vom Dienstconnector hinzugefügten Umgebungsvariablen ab. Wenn Sie den folgenden Code verwenden, heben Sie die Auskommentierung des Teils des Codeschnipsels für den Authentifizierungstyp auf, den Sie verwenden möchten.

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

Weitere Informationen finden Sie unter Startseite für die Clientprogrammierung in Microsoft SQL Server.

Bereitstellen der Anwendung in einem Azure-Hostingdienst

Stellen Sie schließlich Ihre Anwendung in einem Azure-Hostingdienst bereit. Dieser Quelldienst kann eine verwaltete Identität verwenden, um eine Verbindung mit der Zieldatenbank in Azure herzustellen.

Für Azure App Service können Sie das folgende Dokument überprüfen, um eine Möglichkeit für die Bereitstellung auszuwählen: Schnellstart: Bereitstellen einer ASP.NET-Web-App.

Anschließend können Sie das Protokoll überprüfen oder die Anwendung aufrufen, um festzustellen, ob eine Verbindung mit der Azure-Datenbank erfolgreich hergestellt werden kann.

Problembehandlung

Berechtigung

Wenn Fehler im Zusammenhang mit Berechtigungen auftreten, bestätigen Sie den angemeldeten Azure CLI-Benutzer mit dem Befehl az account show. Stellen Sie sicher, dass Sie sich mit dem richtigen Konto anmelden. Vergewissern Sie sich als Nächstes, dass Sie über die folgenden Berechtigungen verfügen, die möglicherweise erforderlich sind, um eine kennwortlose Verbindung mit dem Dienstconnector herzustellen.

Berechtigung	Vorgang
`Microsoft.DBforPostgreSQL/flexibleServers/read`	Erforderlich, um Informationen des Datenbankservers abzurufen
`Microsoft.DBforPostgreSQL/flexibleServers/write`	Erforderlich, um die Microsoft Entra-Authentifizierung für den Datenbankserver zu aktivieren
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write`	Erforderlich zum Erstellen einer Firewallregel für den Fall, dass die lokale IP-Adresse blockiert ist
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete`	Erforderlich, um die vom Service Connector erstellte Firewallregel zu rückgängig machen und so Sicherheitsrisiken zu vermeiden
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/read`	Erforderlich, um zu überprüfen, ob der Azure CLI-Anmeldebenutzer ein Microsoft Entra-Administrator für Datenbankserver ist
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/write`	Erforderlich, um den Azure CLI-Anmeldebenutzer als Azure AD-Administrator für den Datenbankserver hinzuzufügen

Berechtigung	Vorgang
`Microsoft.DBforMySQL/flexibleServers/read`	Erforderlich, um Informationen des Datenbankservers abzurufen
`Microsoft.DBforMySQL/flexibleServers/write`	Erforderlich, um die angegebene vom Benutzer zugewiesene verwaltete Identität zum Datenbankserver hinzuzufügen
`Microsoft.DBforMySQL/flexibleServers/firewallRules/write`	Erforderlich zum Erstellen einer Firewallregel für den Fall, dass die lokale IP-Adresse blockiert ist
`Microsoft.DBforMySQL/flexibleServers/firewallRules/delete`	Erforderlich, um die vom Service Connector erstellte Firewallregel zu rückgängig machen und so Sicherheitsrisiken zu vermeiden
`Microsoft.DBforMySQL/flexibleServers/administrators/read`	Erforderlich, um zu überprüfen, ob der Azure CLI-Anmeldebenutzer ein Microsoft Entra-Administrator für Datenbankserver ist
`Microsoft.DBforMySQL/flexibleServers/administrators/write`	Erforderlich, um den Azure CLI-Anmeldebenutzer als Azure AD-Administrator für den Datenbankserver hinzuzufügen

Berechtigung	Vorgang
`Microsoft.Sql/servers/read`	Erforderlich, um Informationen des Datenbankservers abzurufen
`Microsoft.Sql/servers/firewallRules/write`	Erforderlich zum Erstellen einer Firewallregel für den Fall, dass die lokale IP-Adresse blockiert ist
`Microsoft.Sql/servers/firewallRules/delete`	Erforderlich, um die vom Service Connector erstellte Firewallregel zu rückgängig machen und so Sicherheitsrisiken zu vermeiden
`Microsoft.Sql/servers/administrators/read`	Erforderlich, um zu überprüfen, ob der Azure CLI-Anmeldebenutzer ein Microsoft Entra-Administrator für Datenbankserver ist
`Microsoft.Sql/servers/administrators/write`	Erforderlich, um den Azure CLI-Anmeldebenutzer als Azure AD-Administrator für den Datenbankserver hinzuzufügen

In einigen Fällen sind die Berechtigungen nicht erforderlich. Wenn der mit der Azure CLI authentifizierte Benutzer beispielsweise bereits ein Active Directory-Administrator auf SQL Server ist, benötigen Sie die Microsoft.Sql/servers/administrators/write-Berechtigung nicht.

Microsoft Entra ID

Wenn die Fehlermeldung ERROR: AADSTS530003: Your device is required to be managed to access this resource. angezeigt wird, bitten Sie Ihre IT-Abteilung um Hilfe beim Einbinden dieses Geräts in Microsoft Entra ID. Weitere Informationen finden Sie unter In Microsoft Entra eingebundene Geräte.

Der Dienstconnector muss auf Microsoft Entra ID zugreifen, um Informationen zu Ihrem Konto und der verwalteten Identität des Hostingdiensts abrufen zu können. Sie können den folgenden Befehl verwenden, um zu überprüfen, ob Ihr Gerät auf Microsoft Entra ID zugreifen kann:

az ad signed-in-user show

Wenn Sie sich nicht interaktiv anmelden, erhalten Sie möglicherweise auch den Fehler und Interactive authentication is needed. Melden Sie sich mit dem az login-Befehl an, um den Fehler zu beheben.

Netzwerkkonnektivität

Wenn sich Ihr Datenbankserver in Virtual Network befindet, stellen Sie sicher, dass Ihre Umgebung, in der der Azure CLI-Befehl ausgeführt wird, auf den Server im Virtual Network zugreifen kann.

Wenn Ihr Datenbankserver den öffentlichen Zugriff nicht erlaubt, stellen Sie sicher, dass Ihre Umgebung, in der der Azure CLI-Befehl ausgeführt wird, über den privaten Endpunkt auf den Server zugreifen kann.

Nächste Schritte

Weitere Informationen zum Dienstconnector und kennwortlosen Verbindungen finden Sie in den folgenden Ressourcen:

Dokumentation zum Dienstconnector

Kennwortlose Verbindungen für Azure-Dienste

Freigeben über

Tutorial: Erstellen einer kennwortlosen Verbindung mit einem Datenbankdienst über den Dienstconnector

Voraussetzungen

Erstellen Ihrer Umgebung

Konto

Installieren der kennwortlosen Dienstconnector-Erweiterung

Erstellen einer kennwortlosen Verbindung

Herstellen einer Verbindung mit einer Datenbank mit Microsoft Entra-Authentifizierung

Bereitstellen der Anwendung in einem Azure-Hostingdienst

Problembehandlung

Berechtigung

Microsoft Entra ID

Netzwerkkonnektivität

Nächste Schritte

Feedback

Zusätzliche Ressourcen