Zelfstudie: Een wachtwoordloze verbinding maken met een databaseservice via Service Verbinding maken or

Verbindingen zonder wachtwoord maken gebruik van beheerde identiteiten voor toegang tot Azure-services. Met deze aanpak hoeft u geheimen voor beheerde identiteiten niet handmatig bij te houden en te beheren. Deze taken worden veilig intern verwerkt door Azure.

Service Verbinding maken or maakt beheerde identiteiten mogelijk in app-hostingservices zoals Azure Spring Apps, Azure-app Service en Azure Container Apps. Service Verbinding maken or configureert ook databaseservices, zoals Azure Database for PostgreSQL, Azure Database for MySQL en Azure SQL Database, om beheerde identiteiten te accepteren.

In deze zelfstudie gebruikt u de Azure CLI om de volgende taken te voltooien:

• Controleer uw eerste omgeving met de Azure CLI.
• Maak een wachtwoordloze verbinding met Service Verbinding maken or.
• Gebruik de omgevingsvariabelen of configuraties die zijn gegenereerd door Service Verbinding maken or voor toegang tot een databaseservice.

Vereisten

• Azure CLI versie 2.48.1 of hoger.
• Een Azure-account met een actief abonnement. Maak gratis een Azure-account.
• Een app die is geïmplementeerd in Azure-app Service in een regio die wordt ondersteund door Service Verbinding maken or.

Uw omgeving instellen

Rekening

Meld u aan met de Azure CLI via az login. Als u Azure Cloud Shell gebruikt of al bent aangemeld, bevestigt u uw geverifieerde account met az account show.

De service-Verbinding maken of extensie zonder wachtwoord installeren

Installeer de service-Verbinding maken of extensie zonder wachtwoord voor de Azure CLI:

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

Een verbinding zonder wachtwoord maken

Vervolgens gebruiken we Azure-app Service als voorbeeld om een verbinding te maken met behulp van een beheerde identiteit.

Als u het volgende gebruikt:

• Azure Spring Apps: gebruik az spring connection create in plaats daarvan. Zie Verbinding maken Azure Spring Apps naar de Azure-database voor meer voorbeelden.
• Azure Container Apps: gebruik az containerapp connection create in plaats daarvan. Zie Een PostgreSQL-database maken en verbinden met identiteitsconnectiviteit voor meer voorbeelden.

Notitie

Als u Azure Portal gebruikt, gaat u naar de blade Service Verbinding maken or van Azure-app Service, Azure Spring Apps of Azure Container Apps en selecteert u Maken om een verbinding te maken. De Azure-portal stelt automatisch de opdracht voor u samen en activeert de uitvoering van de opdracht in Cloud Shell.

De volgende Azure CLI-opdracht maakt gebruik van een --client-type parameter. Voer de az webapp connection create postgres-flexible -h opdracht uit om de ondersteunde clienttypen op te halen en kies de client die overeenkomt met uw toepassing.

Door de gebruiker toegewezen beheerde identiteit

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

Door het systeem toegewezen beheerde identiteit

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

Service/principal

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

Azure Database for MySQL - Flexible Server vereist een door de gebruiker toegewezen beheerde identiteit om Microsoft Entra-verificatie in te schakelen. Zie Microsoft Entra-verificatie instellen voor Azure Database for MySQL - Flexible Server voor meer informatie. U kunt de volgende opdracht gebruiken om een door de gebruiker toegewezen beheerde identiteit te maken:

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)

Belangrijk

Nadat u de door de gebruiker toegewezen beheerde identiteit hebt gemaakt, vraagt u uw globale Beheer istrator of bevoorrechte rol Beheer istrator om de volgende machtigingen voor deze identiteit te verlenen:

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

Zie de sectie Machtigingen van Active Directory-verificatie voor meer informatie.

Verbind vervolgens uw app met een MySQL-database met een door het systeem toegewezen beheerde identiteit met behulp van Service Verbinding maken or.

De volgende Azure CLI-opdracht maakt gebruik van een --client-type parameter. Voer de az webapp connection create mysql-flexible -h opdracht uit om de ondersteunde clienttypen op te halen en kies de client die overeenkomt met uw toepassing.

Door de gebruiker toegewezen beheerde identiteit

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

Door het systeem toegewezen beheerde identiteit

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

Service/principal

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

De volgende Azure CLI-opdracht maakt gebruik van een --client-type parameter. Voer de az webapp connection create sql -h opdracht uit om de ondersteunde clienttypen op te halen en kies de client die overeenkomt met uw toepassing.

Door de gebruiker toegewezen beheerde identiteit

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

Door het systeem toegewezen beheerde identiteit

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

Service/principal

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

Met deze service Verbinding maken oropdracht worden de volgende taken op de achtergrond uitgevoerd:

• Schakel door het systeem toegewezen beheerde identiteit in of wijs een gebruikersidentiteit toe voor de app $APPSERVICE_NAME die wordt gehost door Azure-app Service/Azure Spring Apps/Azure Container Apps.
• Stel de Microsoft Entra-beheerder in op de huidige aangemelde gebruiker.
• Voeg een databasegebruiker toe voor de door het systeem toegewezen beheerde identiteit, door de gebruiker toegewezen beheerde identiteit of service-principal. Verdeel alle bevoegdheden van de database $DATABASE_NAME aan deze gebruiker. De gebruikersnaam vindt u in de verbindingsreeks in de voorgaande opdrachtuitvoer.
• Stel configuraties met de naam AZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRINGof AZURE_SQL_CONNECTIONSTRING op de Azure-resource in op basis van het databasetype.
  • Voor App Service worden de configuraties ingesteld op de blade App Instellingen.
  • Voor Spring Apps worden de configuraties ingesteld wanneer de toepassing wordt gestart.
  • Voor Container Apps worden de configuraties ingesteld op de omgevingsvariabelen. U kunt alle configuraties en de bijbehorende waarden ophalen op de blade Service Verbinding maken or in Azure Portal.

Verbinding maken naar een database met Microsoft Entra-verificatie

Nadat u de verbinding hebt gemaakt, kunt u de verbindingsreeks in uw toepassing gebruiken om verbinding te maken met de database met Microsoft Entra-verificatie. U kunt bijvoorbeeld de volgende oplossingen gebruiken om verbinding te maken met de database met Microsoft Entra-verificatie.

.NET

Voor .NET is er geen invoegtoepassing of bibliotheek om wachtwoordloze verbindingen te ondersteunen. U kunt een toegangstoken ophalen voor de beheerde identiteit of service-principal met behulp van de clientbibliotheek, zoals Azure.Identity. Vervolgens kunt u het toegangstoken als wachtwoord gebruiken om verbinding te maken met de database. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

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

// Uncomment the following lines according to the authentication type.
// For system-assigned identity.
// var sqlServerTokenProvider = new DefaultAzureCredential();

// For user-assigned identity.
// var sqlServerTokenProvider = new DefaultAzureCredential(
//     new DefaultAzureCredentialOptions
//     {
//         ManagedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_CLIENTID");
//     }
// );

// For service principal.
// var tenantId = Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_TENANTID");
// var clientId = Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_CLIENTID");
// var clientSecret = Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_CLIENTSECRET");
// var sqlServerTokenProvider = new ClientSecretCredential(tenantId, clientId, clientSecret);

// Acquire the access token. 
AccessToken accessToken = await sqlServerTokenProvider.GetTokenAsync(
    new TokenRequestContext(scopes: new string[]
    {
        "https://ossrdbms-aad.database.windows.net/.default"
    }));

// Combine the token with the connection string from the environment variables provided by Service Connector.
string connectionString =
    $"{Environment.GetEnvironmentVariable("AZURE_POSTGRESQL_CONNECTIONSTRING")};Password={accessToken.Token}";

// Establish the connection.
using (var connection = new NpgsqlConnection(connectionString))
{
    Console.WriteLine("Opening connection using access token...");
    connection.Open();
}

Java

1. Voeg de volgende afhankelijkheden toe aan uw pom.xml-bestand :

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

2. Haal de verbindingsreeks op uit omgevingsvariabelen en voeg de naam van de invoegtoepassing toe om verbinding te maken met de database:

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

Voor meer informatie raadpleegt u de volgende bronnen:

• Zelfstudie: Verbinding maken naar PostgreSQL Database vanuit een Java Quarkus-container-app zonder geheimen met behulp van een beheerde identiteit
• Zelfstudie: Verbinding maken naar een PostgreSQL-database vanuit Java Tomcat App Service zonder geheimen met behulp van een beheerde identiteit
• Quickstart: Java en JDBC gebruiken met Azure Database for PostgreSQL Flexible Server
• Een toepassing migreren om wachtwoordloze verbindingen te gebruiken met Azure Database for PostgreSQL

SpringBoot

Als u voor een Spring-toepassing een verbinding maakt met de optie--client-type springboot, stelt Service Verbinding maken or de eigenschappen spring.datasource.azure.passwordless-enabledin spring.datasource.urlen spring.datasource.username op Azure Spring Apps.

Werk uw toepassing bij na de zelfstudie Bind an Azure Database for PostgreSQL to your application in Azure Spring Apps. Vergeet niet om de spring.datasource.password configuratie-eigenschap te verwijderen als deze eerder is ingesteld en de juiste afhankelijkheden aan uw Spring-toepassing toe te voegen.

Zie Spring Data JDBC gebruiken met Azure Database for PostgreSQL en zelfstudie: Een Spring-toepassing implementeren in Azure Spring Apps met een wachtwoordloze verbinding met een Azure-database voor meer zelfstudies.

Python

1. Installeer afhankelijkheden.

   pip install azure-identity
   pip install psycopg2-binary
   

2. Get access token using azure-identity library and use the token as password. Haal verbindingsgegevens op uit de omgevingsvariabelen die zijn toegevoegd door Service Verbinding maken or. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

   from azure.identity import DefaultAzureCredential
   import psycopg2
   
   # Uncomment the following lines according to the authentication type.
   # For system-assigned identity.
   # cred = DefaultAzureCredential()
   
   # For user-assigned identity.
   # managed_identity_client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
   # cred = ManagedIdentityCredential(client_id=managed_identity_client_id)   
   
   # For service principal.
   # tenant_id = os.getenv('AZURE_POSTGRESQL_TENANTID')
   # client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
   # client_secret = os.getenv('AZURE_POSTGRESQL_CLIENTSECRET')
   # cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)
   
   # Acquire the access token
   accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')
   
   # Combine the token with the connection string from the environment variables added by Service Connector to establish the connection.
   conn_string = os.getenv('AZURE_POSTGRESQL_CONNECTIONSTRING')
   conn = psycopg2.connect(conn_string + ' password=' + accessToken.token) 
   

Django

1. Installeer afhankelijkheden.

   pip install azure-identity
   

2. Toegangstoken ophalen met behulp van azure-identity bibliotheek met behulp van omgevingsvariabelen die zijn toegevoegd door Service Verbinding maken or. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

   from azure.identity import DefaultAzureCredential
   import psycopg2
   
   # Uncomment the following lines according to the authentication type.
   # For system-assigned identity.
   # credential = DefaultAzureCredential()
   
   # For user-assigned identity.
   # managed_identity_client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
   # cred = ManagedIdentityCredential(client_id=managed_identity_client_id)    
   
   # For service principal.
   # tenant_id = os.getenv('AZURE_POSTGRESQL_TENANTID')
   # client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
   # client_secret = os.getenv('AZURE_POSTGRESQL_CLIENTSECRET')
   # cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)
   
   # Acquire the access token.
   accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')
   

3. Haal bij het instellen van het bestand azure PostgreSQL-databasegegevens op uit omgevingsvariabelen die zijn toegevoegd door de Service Verbinding maken or-service. Gebruik accessToken verkregen in de vorige stap om toegang te krijgen tot de database.

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

Go

1. Installeer afhankelijkheden.

   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"
   

2. Haal in code het toegangstoken op met behulp van azidentityhet wachtwoord en gebruik het als wachtwoord om verbinding te maken met Azure PostgreSQL, samen met verbindingsgegevens van Service Verbinding maken or. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

   import (
   "database/sql"
   "fmt"
   "os"
   
   "context"
   
   "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
   "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   
    _ "github.com/lib/pq"
   )    
   
   // Uncomment the following lines according to the authentication type.
   // For system-assigned identity.
   // cred, err := azidentity.NewDefaultAzureCredential(nil)
   
   // For user-assigned identity.
   // clientid := os.Getenv("AZURE_POSTGRESQL_CLIENTID")
   // azidentity.ManagedIdentityCredentialOptions.ID := clientid
   // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
   // cred, err := azidentity.NewManagedIdentityCredential(options)
   
   // For service principal.
   // clientid := os.Getenv("AZURE_POSTGRESQL_CLIENTID")
   // tenantid := os.Getenv("AZURE_POSTGRESQL_TENANTID")
   // clientsecret := os.Getenv("AZURE_POSTGRESQL_CLIENTSECRET")
   // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})
   
   if err != nil {
       // error handling
   }
   
   // Acquire the access token
   ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
   token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
       Scopes: []string("https://ossrdbms-aad.database.windows.net/.default"),
   })
   
   // Combine the token with the connection string from the environment variables added by Service Connector to establish the connection.
   connectionString := os.Getenv("AZURE_POSTGRESQL_CONNECTIONSTRING") + " password=" + token.Token
   
   conn, err := sql.Open("postgres", connectionString)
    if err != nil {
    	panic(err)
    }
   
    conn.Close()
   

NodeJS

1. Installeer afhankelijkheden.

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

2. Haal in code het toegangstoken op met behulp van @azure/identity en PostgreSQL-verbindingsgegevens uit omgevingsvariabelen die zijn toegevoegd door service Verbinding maken orservice. Combineer ze om de verbinding tot stand te brengen. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

   import { DefaultAzureCredential, ClientSecretCredential } from "@azure/identity";
   const { Client } = require('pg');
   
   // Uncomment the following lines according to the authentication type.  
   // For system-assigned identity.
   // const credential = new DefaultAzureCredential();
   
   // For user-assigned identity.
   // const clientId = process.env.AZURE_POSTGRESQL_CLIENTID;
   // const credential = new DefaultAzureCredential({
   //     managedIdentityClientId: clientId
   // });
   
   // For service principal.
   // const tenantId = process.env.AZURE_POSTGRESQL_TENANTID;
   // const clientId = process.env.AZURE_POSTGRESQL_CLIENTID;
   // const clientSecret = process.env.AZURE_POSTGRESQL_CLIENTSECRET;
   
   // Acquire the access token.
   var accessToken = await credential.getToken('https://ossrdbms-aad.database.windows.net/.default');
   
   // Use the token and the connection information from the environment variables added by Service Connector to establish the connection.
   (async () => {
   const client = new Client({
       host: process.env.AZURE_POSTGRESQL_HOST,
       user: process.env.AZURE_POSTGRESQL_USER,
       password: accesstoken.token,
       database: process.env.AZURE_POSTGRESQL_DATABASE,
       port: Number(process.env.AZURE_POSTGRESQL_PORT) ,
       ssl: process.env.AZURE_POSTGRESQL_SSL
   });
   await client.connect();
   
   await client.end();
   })();
   

PHP

Voor PHP is er geen invoegtoepassing of bibliotheek voor wachtwoordloze verbindingen. U kunt een toegangstoken ophalen voor de beheerde identiteit of service-principal en dit gebruiken als het wachtwoord om verbinding te maken met de database. Het toegangstoken kan worden verkregen met behulp van de Azure REST API.

1. Haal in code het toegangstoken op met behulp van REST API met uw favoriete bibliotheek.

   Voor door de gebruiker toegewezen identiteit en door het systeem toegewezen identiteit biedt App Service en Container Apps een intern toegankelijk REST-eindpunt voor het ophalen van tokens voor beheerde identiteiten door twee omgevingsvariabelen te definiëren: IDENTITY_ENDPOINT en IDENTITY_HEADER. Zie rest-eindpuntreferentie voor meer informatie. Haal het toegangstoken op door een HTTP GET-aanvraag naar het identiteitseindpunt te maken en te gebruiken https://ossrdbms-aad.database.windows.net zoals resource in de query. Neem voor door de gebruiker toegewezen identiteit ook de client-id op uit de omgevingsvariabelen die door de Service Verbinding maken or in de query zijn toegevoegd.

   Raadpleeg de azure AD-service-to-service-toegangstokenaanvraag voor de service voor informatie over het verkrijgen van toegangstokens voor service-principals. Voer de POST-aanvraag uit voor het bereik van https://ossrdbms-aad.database.windows.net/.default en met de tenant-id, client-id en clientgeheim van de service-principal uit de omgevingsvariabelen die zijn toegevoegd door Service Verbinding maken or.

2. Combineer het toegangstoken en de PostgreSQL-verbindingslijn van omgevingsvariabelen die zijn toegevoegd door service Verbinding maken orservice om de verbinding tot stand te brengen.

   <?php
   $conn_string = sprintf("%s password=", getenv('AZURE_POSTGRESQL_CONNECTIONSTRING'), $access_token);
   $dbconn = pg_connect($conn_string);
   ?>
   

Ruby

Voor Ruby is er geen invoegtoepassing of bibliotheek voor wachtwoordloze verbindingen. U kunt een toegangstoken ophalen voor de beheerde identiteit of service-principal en dit gebruiken als het wachtwoord om verbinding te maken met de database. Het toegangstoken kan worden verkregen met behulp van de Azure REST API.

1. Installeer afhankelijkheden.

   gem install pg
   

2. Haal in code het toegangstoken op met behulp van REST API en PostgreSQL-verbindingsgegevens uit omgevingsvariabelen die zijn toegevoegd door de Service Verbinding maken or-service. Combineer ze om de verbinding tot stand te brengen. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

   App Service en container Apps bieden een intern toegankelijk REST-eindpunt voor het ophalen van tokens voor beheerde identiteiten. Zie rest-eindpuntreferentie voor meer informatie.

   require 'pg'
   require 'dotenv/load'
   require 'net/http'
   require 'json'
   
   # Uncomment the following lines according to the authentication type.
   # For system-assigned identity.
   # uri = URI(ENV['IDENTITY_ENDPOINT'] + '?resource=https://ossrdbms-aad.database.windows.net&api-version=2019-08-01')
   # res = Net::HTTP.get_response(uri, {'X-IDENTITY-HEADER' => ENV['IDENTITY_HEADER'], 'Metadata' => 'true'})  
   
   # For user-assigned identity.
   # uri = URI(ENV[IDENTITY_ENDPOINT] + '?resource=https://ossrdbms-aad.database.windows.net&api-version=2019-08-01&client-id=' + ENV['AZURE_POSTGRESQL_CLIENTID'])
   # res = Net::HTTP.get_response(uri, {'X-IDENTITY-HEADER' => ENV['IDENTITY_HEADER'], 'Metadata' => 'true'})  
   
   # For service principal
   # uri = URI('https://login.microsoftonline.com/' + ENV['AZURE_POSTGRESQL_TENANTID'] + '/oauth2/v2.0/token')
   # params = {
   #     :grant_type => 'client_credentials',
   #     :client_id: => ENV['AZURE_POSTGRESQL_CLIENTID'],
   #     :client_secret => ENV['AZURE_POSTGRESQL_CLIENTSECRET'],
   #     :scope => 'https://ossrdbms-aad.database.windows.net/.default'
   # }
   # req = Net::HTTP::POST.new(uri)
   # req.set_form_data(params)
   # req['Content-Type'] = 'application/x-www-form-urlencoded'
   # res = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|
   #   http.request(req)
   
   parsed = JSON.parse(res.body)
   access_token = parsed["access_token"]
   
   # Use the token and the connection string from the environment variables added by Service Connector to establish the connection.
   conn = PG::Connection.new(
       connection_string: ENV['AZURE_POSTGRESQL_CONNECTIONSTRING'] + " password="  + access_token,
   )
   

   Raadpleeg de azure AD-service-to-service-toegangstokenaanvraag voor meer informatie over het verkrijgen van toegangstokens voor de service-principal.

Overig

Voor andere talen gebruikt u de verbindingseigenschappen die Service Verbinding maken or instelt op de omgevingsvariabelen om de database te verbinden. Zie Azure Database for PostgreSQL integreren met Service Verbinding maken or voor meer informatie over omgevingsvariabelen.

Als u vervolgens tabellen en reeksen hebt gemaakt in de flexibele PostgreSQL-server voordat u Service Verbinding maken or gebruikt, moet u verbinding maken als eigenaar en toestemming verlenen voor <aad-username> het maken van service Verbinding maken or. De gebruikersnaam van de verbindingsreeks of configuratie die is ingesteld door Service Verbinding maken or moet er als aad_<connection name>volgt uitzien. Als u Azure Portal gebruikt, selecteert u de uitvouwknop naast de Service Type kolom en haalt u de waarde op. Als u Azure CLI gebruikt, controleert configurations u de uitvoer van de CLI-opdracht.

Voer vervolgens de query uit om toestemming te verlenen

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

De <owner-username> en <owner-password> is de eigenaar van de bestaande tabel die machtigingen kan verlenen aan anderen. <aad-username>is de gebruiker die is gemaakt door Service Verbinding maken or. Vervang ze door de werkelijke waarde.

Valideer het resultaat met de opdracht:

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

.NET

Voor .NET is er geen invoegtoepassing of bibliotheek om wachtwoordloze verbindingen te ondersteunen. U kunt een toegangstoken ophalen voor de beheerde identiteit of service-principal met behulp van de clientbibliotheek, zoals Azure.Identity. Vervolgens kunt u het toegangstoken als wachtwoord gebruiken om verbinding te maken met de database. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

using Azure.Core;
using Azure.Identity;
using MySqlConnector;

// Uncomment the following lines according to the authentication type.
// For system-assigned managed identity.
// var credential = new DefaultAzureCredential();

// For user-assigned managed identity.
// var credential = new DefaultAzureCredential(
//     new DefaultAzureCredentialOptions
//     {
//         ManagedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_MYSQL_CLIENTID");
//     });

// For service principal.
// var tenantId = Environment.GetEnvironmentVariable("AZURE_MYSQL_TENANTID");
// var clientId = Environment.GetEnvironmentVariable("AZURE_MYSQL_CLIENTID");
// var clientSecret = Environment.GetEnvironmentVariable("AZURE_MYSQL_CLIENTSECRET");
// var credential = new ClientSecretCredential(tenantId, clientId, clientSecret);

var tokenRequestContext = new TokenRequestContext(
    new[] { "https://ossrdbms-aad.database.windows.net/.default" });
AccessToken accessToken = await credential.GetTokenAsync(tokenRequestContext);
// Open a connection to the MySQL server using the access token.
string connectionString =
    $"{Environment.GetEnvironmentVariable("AZURE_MYSQL_CONNECTIONSTRING")};Password={accessToken.Token}";

using var connection = new MySqlConnection(connectionString);
Console.WriteLine("Opening connection using access token...");
await connection.OpenAsync();

// do something

Java

1. Voeg de volgende afhankelijkheden toe aan uw pom.xml-bestand :

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

2. Haal de verbindingsreeks op uit de omgevingsvariabele en voeg de naam van de invoegtoepassing toe om verbinding te maken met de database:

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

Zie Java en JDBC gebruiken met Azure Database for MySQL - Flexible Server voor meer informatie.

SpringBoot

Als u voor een Spring-toepassing een verbinding maakt met de optie--client-type springboot, stelt Service Verbinding maken or de eigenschappen spring.datasource.azure.passwordless-enabledin spring.datasource.urlen spring.datasource.username op Azure Spring Apps.

Werk uw toepassing bij na de zelfstudie Verbinding maken een Azure Database for MySQL-exemplaar naar uw toepassing in Azure Spring Apps. Vergeet niet om de spring.datasource.password configuratie-eigenschap te verwijderen als deze eerder is ingesteld en de juiste afhankelijkheden aan uw Spring-toepassing toe te voegen.

Zie Spring Data JDBC gebruiken met Azure Database for MySQL voor meer zelfstudies

Python

1. Afhankelijkheden installeren

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

2. Verifiëren met toegangstoken ophalen via azure-identity bibliotheek en verbindingsgegevens ophalen uit de omgevingsvariabele die is toegevoegd door Service Verbinding maken or. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   import mysql.connector
   import os
   
   # Uncomment the following lines according to the authentication type.
   # For system-assigned managed identity.
   # cred = ManagedIdentityCredential()    
   
   # For user-assigned managed identity.
   # managed_identity_client_id = os.getenv('AZURE_MYSQL_CLIENTID')
   # cred = ManagedIdentityCredential(client_id=managed_identity_client_id)
   
   # For service principal
   # tenant_id = os.getenv('AZURE_MYSQL_TENANTID')
   # client_id = os.getenv('AZURE_MYSQL_CLIENTID')
   # client_secret = os.getenv('AZURE_MYSQL_CLIENTSECRET')
   # cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)
   
   # acquire token
   accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')
   
   # open connect to Azure MySQL with the access token.
   host = os.getenv('AZURE_MYSQL_HOST')
   database = os.getenv('AZURE_MYSQL_NAME')
   user = os.getenv('AZURE_MYSQL_USER')
   password = accessToken.token
   
   cnx = mysql.connector.connect(user=user,
                                 password=password,
                                 host=host,
                                 database=database)
   cnx.close()
   
   

Django

1. Installeer afhankelijkheden.

   pip install azure-identity
   

2. Haal het toegangstoken op via azure-identity bibliotheek met de omgevingsvariabelen die zijn toegevoegd door Service Verbinding maken or. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

   from azure.identity import ManagedIdentityCredential, ClientSecretCredential
   import os
   
   # Uncomment the following lines according to the authentication type.
   # system-assigned managed identity
   # cred = ManagedIdentityCredential()
   
   # user-assigned managed identity
   # managed_identity_client_id = os.getenv('AZURE_MYSQL_CLIENTID')
   # cred = ManagedIdentityCredential(client_id=managed_identity_client_id)
   
   # service principal
   # tenant_id = os.getenv('AZURE_MYSQL_TENANTID')
   # client_id = os.getenv('AZURE_MYSQL_CLIENTID')
   # client_secret = os.getenv('AZURE_MYSQL_CLIENTSECRET')
   # cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)
   
   # acquire token
   accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')
   

3. Haal bij het instellen van het bestand azure MySQL-databasegegevens op uit omgevingsvariabelen die zijn toegevoegd door service Verbinding maken or service. Gebruik accessToken verkregen in de vorige stap om toegang te krijgen tot de database.

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

Go

1. Installeer afhankelijkheden.

   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"
   

2. Haal in code het toegangstoken op via azidentityen maak vervolgens verbinding met Azure MySQL met het token. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

   import (
     "context"
   
     "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
     "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
     "github.com/go-sql-driver/mysql"
   )
   
   
   func main() {
   
     // Uncomment the following lines according to the authentication type.
     // for system-assigned managed identity
     // cred, err := azidentity.NewDefaultAzureCredential(nil)
   
     // for user-assigned managed identity
     // clientid := os.Getenv("AZURE_MYSQL_CLIENTID")
     // azidentity.ManagedIdentityCredentialOptions.ID := clientid
     // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
     // cred, err := azidentity.NewManagedIdentityCredential(options)
   
     // for service principal
     // clientid := os.Getenv("AZURE_MYSQL_CLIENTID")
     // tenantid := os.Getenv("AZURE_MYSQL_TENANTID")
     // clientsecret := os.Getenv("AZURE_MYSQL_CLIENTSECRET")
     // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})
   
     if err != nil {
     }
   
     ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
     token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
       Scopes: []string("https://ossrdbms-aad.database.windows.net/.default"),
     })
   
     connectionString := os.Getenv("AZURE_MYSQL_CONNECTIONSTRING") + ";Password=" + token.Token
     db, err := sql.Open("mysql", connectionString)
   }
   

NodeJS

1. Afhankelijkheden installeren

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

2. Haal toegangstokens op met behulp van @azure/identity en Azure MySQL-databasegegevens uit omgevingsvariabelen die zijn toegevoegd door service Verbinding maken or service. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

   import { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";
   
   const mysql = require('mysql2');
   
   // Uncomment the following lines according to the authentication type.
   // for system-assigned managed identity
   // const credential = new DefaultAzureCredential();
   
   // for user-assigned managed identity
   // const clientId = process.env.AZURE_MYSQL_CLIENTID;
   // const credential = new DefaultAzureCredential({
   //    managedIdentityClientId: clientId
   // });
   
   // for service principal
   // const tenantId = process.env.AZURE_MYSQL_TENANTID;
   // const clientId = process.env.AZURE_MYSQL_CLIENTID;
   // const clientSecret = process.env.AZURE_MYSQL_CLIENTSECRET;
   // const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);
   
   // acquire token
   var accessToken = await credential.getToken('https://ossrdbms-aad.database.windows.net/.default');
   
   const connection = mysql.createConnection({
     host: process.env.AZURE_MYSQL_HOST,
     user: process.env.AZURE_MYSQL_USER,
     password: accessToken.token,
     database: process.env.AZURE_MYSQL_DATABASE,
     port: process.env.AZURE_MYSQL_PORT,
     ssl: process.env.AZURE_MYSQL_SSL
   });
   
   connection.connect((err) => {
     if (err) {
       console.error('Error connecting to MySQL database: ' + err.stack);
       return;
     }
     console.log('Connected to MySQL database');
   });
   

PHP

Gebruik voor andere talen de verbindingsreeks en gebruikersnaam die service Verbinding maken or instelt op de omgevingsvariabelen om de database te verbinden. Zie Azure Database for MySQL integreren met Service Verbinding maken or voor meer informatie over omgevingsvariabelen.

Ruby

Gebruik voor andere talen de verbindingsreeks en gebruikersnaam die service Verbinding maken or instelt op de omgevingsvariabelen om de database te verbinden. Zie Azure Database for MySQL integreren met Service Verbinding maken or voor meer informatie over omgevingsvariabelen.

Overig

Voor andere talen gebruikt u de verbindingseigenschappen die Service Verbinding maken or instelt op de omgevingsvariabelen om de database te verbinden. Zie Azure Database for MySQL integreren met Service Verbinding maken or voor meer informatie over omgevingsvariabelen.

Zie Verbinding maken naar Azure-databases vanuit App Service zonder geheimen met behulp van een beheerde identiteit voor meer codevoorbeelden.

.NET

1. Installeer afhankelijkheden.

   dotnet add package Microsoft.Data.SqlClient
   

2. Haal de Azure SQL Database-verbindingsreeks op uit de omgevingsvariabele die is toegevoegd door Service Verbinding maken or.

   using Microsoft.Data.SqlClient;
   
   string connectionString = 
       Environment.GetEnvironmentVariable("AZURE_SQL_CONNECTIONSTRING")!;
   
   using var connection = new SqlConnection(connectionString);
   connection.Open();
   

   Zie Active Directory Managed Identity-verificatie gebruiken voor meer informatie.

Java

1. Voeg de volgende afhankelijkheden toe aan uw pom.xml-bestand :

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

2. Haal de Azure SQL Database-verbindingsreeks op uit de omgevingsvariabele die is toegevoegd door Service Verbinding maken or.

   import java.sql.Connection;
   import java.sql.ResultSet;
   import java.sql.Statement;
   
   import com.microsoft.sqlserver.jdbc.SQLServerDataSource;
   
   public class Main {
       public static void main(String[] args) {
           // AZURE_SQL_CONNECTIONSTRING should be one of the following:
           // For system-assigned managed identity: "jdbc:sqlserver://{SQLName}.database.windows.net:1433;databaseName={SQLDbName};authentication=ActiveDirectoryMSI;"
           // For user-assigned managed identity: "jdbc:sqlserver://{SQLName}.database.windows.net:1433;databaseName={SQLDbName};msiClientId={UserAssignedMiClientId};authentication=ActiveDirectoryMSI;"
           // For service principal: "jdbc:sqlserver://{SQLName}.database.windows.net:1433;databaseName={SQLDbName};user={ServicePrincipalClientId};password={spSecret};authentication=ActiveDirectoryServicePrincipal;"
           String connectionString = System.getenv("AZURE_SQL_CONNECTIONSTRING");
           SQLServerDataSource ds = new SQLServerDataSource();
           ds.setURL(connectionString);
           try (Connection connection = ds.getConnection()) {
               System.out.println("Connected successfully.");
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
   }
   

   Zie Verbinding maken naar Azure-databases vanuit App Service zonder geheimen met behulp van een beheerde identiteit voor meer informatie.

SpringBoot

Als u voor een Spring-toepassing een verbinding met de optie --client-type springbootmaakt, stelt Service Verbinding maken or de eigenschappen spring.datasource.url met waarde-indeling jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; in op Azure Spring Apps.

Werk uw toepassing bij na de zelfstudie Een Java-toepassing migreren om wachtwoordloze verbindingen met Azure SQL Database te gebruiken. Vergeet niet om de spring.datasource.password configuratie-eigenschap te verwijderen als deze eerder is ingesteld en de juiste afhankelijkheden toe te voegen.

Python

1. Installeer afhankelijkheden.

   python -m pip install pyodbc
   

2. Haal de Azure SQL Database-verbindingsconfiguraties op uit de omgevingsvariabele die is toegevoegd door Service Verbinding maken or. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken. Als u Azure Container Apps als rekenservice gebruikt of als de verbindingsreeks in het codefragment niet werkt, raadpleegt u Een Python-toepassing migreren om wachtwoordloze verbindingen met Azure SQL Database te gebruiken om verbinding te maken met Azure SQL Database met behulp van een toegangstoken.

   import os
   import pyodbc
   
   server = os.getenv('AZURE_SQL_SERVER')
   port = os.getenv('AZURE_SQL_PORT')
   database = os.getenv('AZURE_SQL_DATABASE')
   authentication = os.getenv('AZURE_SQL_AUTHENTICATION')
   
   # Uncomment the following lines according to the authentication type.
   # For system-assigned managed identity.
   # connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server=tcp:{server},{port};Database={database};Authentication={authentication};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'
   
   # For user-assigned managed identity.
   # clientID = os.getenv('AZURE_SQL_USER')
   # connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server=tcp:{server},{port};Database={database};UID={clientID};Authentication={authentication};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'
   
   # For service principal.
   # user = os.getenv('AZURE_SQL_USER')
   # password = os.getenv('AZURE_SQL_PASSWORD')
   # connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server=tcp:{server},{port};Database={database};UID={user};PWD={password};Authentication={authentication};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'
   
   conn = pyodbc.connect(connString)
   

NodeJS

1. Installeer afhankelijkheden.

   npm install mssql
   

2. Haal de Azure SQL Database-verbindingsconfiguraties op uit de omgevingsvariabelen die zijn toegevoegd door Service Verbinding maken or. Als u de onderstaande code gebruikt, moet u het gedeelte van het codefragment verwijderen voor het verificatietype dat u wilt gebruiken.

   import sql from 'mssql';
   
   const server = process.env.AZURE_SQL_SERVER;
   const database = process.env.AZURE_SQL_DATABASE;
   const port = parseInt(process.env.AZURE_SQL_PORT);
   const authenticationType = process.env.AZURE_SQL_AUTHENTICATIONTYPE;
   
   // Uncomment the following lines according to the authentication type.
   // For system-assigned managed identity.
   // const config = {
   //     server,
   //     port,
   //     database,
   //     authentication: {
   //         type: authenticationType
   //     },
   //     options: {
   //        encrypt: true
   //     }
   // };  
   
   // For user-assigned managed identity.
   // const clientId = process.env.AZURE_SQL_CLIENTID;
   // const config = {
   //     server,
   //     port,
   //     database,
   //     authentication: {
   //         type: authenticationType
   //     },
   //     options: {
   //         encrypt: true,
   //         clientId: clientId
   //     }
   // };  
   
   // For service principal.
   // const clientId = process.env.AZURE_SQL_CLIENTID;
   // const clientSecret = process.env.AZURE_SQL_CLIENTSECRET;
   // const tenantId = process.env.AZURE_SQL_TENANTID;
   // const config = {
   //     server,
   //     port,
   //     database,
   //     authentication: {
   //         type: authenticationType
   //     },
   //     options: {
   //         encrypt: true,
   //         clientId: clientId,
   //         clientSecret: clientSecret,
   //         tenantId: tenantId
   //     }
   // };  
   
   this.poolconnection = await sql.connect(config);
   

Overig

Voor andere talen gebruikt u de verbindingseigenschappen die Service Verbinding maken or instelt op de omgevingsvariabelen om de database te verbinden. Zie Azure SQL Database integreren met Service Verbinding maken or voor meer informatie over omgevingsvariabelen.

Zie Startpagina voor clientprogrammering naar Microsoft SQL Server voor meer informatie.

De toepassing implementeren in een Azure-hostingservice

Implementeer ten slotte uw toepassing in een Azure-hostingservice. Deze bronservice kan een beheerde identiteit gebruiken om verbinding te maken met de doeldatabase in Azure.

App Service

Voor Azure-app Service kunt u de toepassingscode implementeren via de az webapp deploy opdracht. Zie Quickstart: Een ASP.NET-web-app implementeren voor meer informatie.

Spring-apps

Voor Azure Spring Apps kunt u de toepassingscode implementeren via de az spring app deploy opdracht. Zie quickstart: Uw eerste toepassing implementeren in Azure Spring Apps voor meer informatie.

Container Apps

Voor Azure Container Apps kunt u de toepassingscode implementeren via de az containerapp create opdracht. Zie Quickstart: Uw eerste container-app implementeren voor meer informatie.

Vervolgens kunt u het logboek controleren of de toepassing aanroepen om te zien of deze verbinding kan maken met de Azure-database.

Probleemoplossing

Machtiging

Als er machtigingsfouten optreden, bevestigt u de aangemelde Gebruiker van Azure CLI met de opdracht az account show. Zorg ervoor dat u zich aanmeldt met het juiste account. Controleer vervolgens of u de volgende machtigingen hebt die mogelijk vereist zijn om een verbinding zonder wachtwoord te maken met Service Verbinding maken or.

Machtiging	Operation
Microsoft.DBforPostgreSQL/flexibleServers/read	Vereist voor het ophalen van gegevens van de databaseserver
Microsoft.DBforPostgreSQL/flexibleServers/write	Vereist voor het inschakelen van Microsoft Entra-verificatie voor databaseserver
Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write	Vereist voor het maken van een firewallregel voor het geval het lokale IP-adres wordt geblokkeerd
Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete	Vereist om de firewallregel te herstellen die is gemaakt door Service Verbinding maken or om beveiligingsproblemen te voorkomen
Microsoft.DBforPostgreSQL/flexibleServers/administrators/read	Vereist om te controleren of de azure CLI-aanmeldingsgebruiker een databaseserver Microsoft Entra-beheerder is
Microsoft.DBforPostgreSQL/flexibleServers/administrators/write	Vereist om azure CLI-aanmeldingsgebruiker toe te voegen als databaseserver Microsoft Entra-beheerder

Machtiging	Operation
Microsoft.DBforMySQL/flexibleServers/read	Vereist voor het ophalen van gegevens van de databaseserver
Microsoft.DBforMySQL/flexibleServers/write	Vereist om de door de gebruiker toegewezen beheerde identiteit toe te voegen aan de databaseserver
Microsoft.DBforMySQL/flexibleServers/firewallRules/write	Vereist voor het maken van een firewallregel voor het geval het lokale IP-adres wordt geblokkeerd
Microsoft.DBforMySQL/flexibleServers/firewallRules/delete	Vereist om de firewallregel te herstellen die is gemaakt door Service Verbinding maken or om beveiligingsproblemen te voorkomen
Microsoft.DBforMySQL/flexibleServers/administrators/read	Vereist om te controleren of de azure CLI-aanmeldingsgebruiker een databaseserver Microsoft Entra-beheerder is
Microsoft.DBforMySQL/flexibleServers/administrators/write	Vereist om azure CLI-aanmeldingsgebruiker toe te voegen als databaseserver Microsoft Entra-beheerder

Machtiging	Operation
Microsoft.Sql/servers/read	Vereist voor het ophalen van gegevens van de databaseserver
Microsoft.Sql/servers/firewallRules/write	Vereist voor het maken van een firewallregel voor het geval het lokale IP-adres wordt geblokkeerd
Microsoft.Sql/servers/firewallRules/delete	Vereist om de firewallregel te herstellen die is gemaakt door Service Verbinding maken or om beveiligingsproblemen te voorkomen
Microsoft.Sql/servers/administrators/read	Vereist om te controleren of de azure CLI-aanmeldingsgebruiker een databaseserver Microsoft Entra-beheerder is
Microsoft.Sql/servers/administrators/write	Vereist om azure CLI-aanmeldingsgebruiker toe te voegen als databaseserver Microsoft Entra-beheerder

In sommige gevallen zijn de machtigingen niet vereist. Als de door Azure CLI geverifieerde gebruiker bijvoorbeeld al een Active Directory-Beheer istrator op SQL Server is, hoeft u niet over de Microsoft.Sql/servers/administrators/write machtiging te beschikken.

Microsoft Entra ID

Als er een fout ERROR: AADSTS530003: Your device is required to be managed to access this resource.optreedt, vraagt u uw IT-afdeling om hulp bij het toevoegen van dit apparaat aan Microsoft Entra-id. Zie Microsoft Entra-gekoppelde apparaten voor meer informatie.

Service Verbinding maken or moet toegang hebben tot Microsoft Entra ID om informatie op te halen over uw account en beheerde identiteit van hostingservice. U kunt de volgende opdracht gebruiken om te controleren of uw apparaat toegang heeft tot Microsoft Entra ID:

az ad signed-in-user show

Als u zich niet interactief aanmeldt, krijgt u mogelijk ook de fout en Interactive authentication is needed. Meld u aan met de opdracht om de az login fout op te lossen.

Netwerkverbinding

Als uw databaseserver zich in virtual network bevindt, moet u ervoor zorgen dat uw omgeving waarop de Azure CLI-opdracht wordt uitgevoerd, toegang heeft tot de server in het virtuele netwerk.

Als uw databaseserver zich in virtual network bevindt, moet u ervoor zorgen dat uw omgeving waarop de Azure CLI-opdracht wordt uitgevoerd, toegang heeft tot de server in het virtuele netwerk.

Als uw databaseserver openbare toegang weigert, moet u ervoor zorgen dat uw omgeving waarop de Azure CLI-opdracht wordt uitgevoerd, toegang heeft tot de server via het privé-eindpunt.

Volgende stappen

Zie de volgende bronnen voor meer informatie over Service Verbinding maken or- en wachtwoordloze verbindingen:

Documentatie voor service Verbinding maken or

Verbindingen zonder wachtwoord voor Azure-services