Zelfstudie: Een verbinding zonder wachtwoord maken met een databaseservice via serviceconnector

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 Connector maakt beheerde identiteiten mogelijk in app-hostingservices zoals Azure Spring Apps, Azure-app Service en Azure Container Apps. Service Connector 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 verbinding zonder wachtwoord met serviceconnector.
• Gebruik de omgevingsvariabelen of configuraties die door Service Connector worden gegenereerd voor toegang tot een databaseservice.

Vereisten

• Azure CLI versie 2.61.0 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 serviceconnector.

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 serviceconnector-extensie zonder wachtwoord installeren

Installeer de nieuwste serviceconnector-extensie zonder wachtwoord voor de Azure CLI:

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

Notitie

Controleer of de extensie 'serviceconnector-passwordless' versie '2.0.2' of hoger is door uit te voeren az version. Mogelijk moet u eerst azure CLI upgraden om de extensieversie te upgraden.

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 Azure Spring Apps verbinden met 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 Serviceconnector 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, dit kan java, dotnet, python, enzovoort zijn. Voer de az webapp connection create postgres-flexible -h opdracht uit om de ondersteunde clienttypen op te halen en kies de parameter 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 $CLIENT_TYPE

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

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

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 de globale beheerder of bevoorrechte rolbeheerder 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 Connector.

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 serviceconnectoropdracht 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.
• Schakel Microsoft Entra-verificatie in voor de databaseserver als deze nog niet is ingeschakeld.
• 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 Serviceconnector in Azure Portal.

ServiceConnector wijst de volgende bevoegdheden toe aan de gebruiker, u kunt deze intrekken en de bevoegdheden aanpassen op basis van uw vereisten.

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

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

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 met PostgreSQL Database vanuit een Java Quarkus-container-app zonder geheimen met behulp van een beheerde identiteit
• Zelfstudie: Verbinding maken met 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 ServiceConnector 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
   pip freeze > requirements.txt # Save the dependencies to a file
   

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

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

3. Haal bij het instellen van het bestand azure PostgreSQL-databasegegevens op uit omgevingsvariabelen die zijn toegevoegd door de Service Connector-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 Connector. 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 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()
   

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 de Service Connector-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.

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

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. Voor door de gebruiker toegewezen identiteit moet u ook de client-id van de omgevingsvariabelen opnemen die door Service Connector 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 Connector.

2. Combineer het toegangstoken en de PostgreSQL-verbindingslijn van omgevingsvariabelen die zijn toegevoegd door de Service Connector-service 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 Connector-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 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,
   )
   

   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 serviceconnector instelt op de omgevingsvariabelen om de database te verbinden. Zie Azure Database for PostgreSQL integreren met Service Connector voor meer informatie over omgevingsvariabelen.

Als u vervolgens tabellen en reeksen hebt gemaakt in postgreSQL flexibele server voordat u Service Connector gebruikt, moet u verbinding maken als eigenaar en toestemming verlenen voor <aad-username> het maken van serviceconnector. De gebruikersnaam van de verbindingsreeks of configuratie die is ingesteld door serviceconnector, 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 Connector. 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 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

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 ServiceConnector de eigenschappen spring.datasource.azure.passwordless-enabledin spring.datasource.urlen spring.datasource.username op Azure Spring Apps.

Werk uw toepassing bij na de zelfstudie Een Azure Database for MySQL-exemplaar verbinden met 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 Connector. 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 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()
   
   

Django

1. Installeer afhankelijkheden.

   pip install azure-identity
   

2. Haal het toegangstoken op via azure-identity de bibliotheek met de omgevingsvariabelen die zijn toegevoegd door Service Connector. 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 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')
   

3. Bij het instellen van een bestand haalt u azure MySQL-databasegegevens op uit omgevingsvariabelen die zijn toegevoegd door de Service Connector-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 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)
   }
   

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

PHP

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

Ruby

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

Overig

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

Zie Verbinding maken met 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 Connector.

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

   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 met 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, worden de eigenschappen spring.datasource.url met waardeindeling jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; ingesteld 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 Connector. 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 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)
   

NodeJS

1. Installeer afhankelijkheden.

   npm install mssql
   

2. Haal de azure SQL Database-verbindingsconfiguraties op uit de omgevingsvariabelen die zijn toegevoegd door Service Connector. 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 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);
   

Overig

Voor andere talen gebruikt u de verbindingseigenschappen die serviceconnector instelt op de omgevingsvariabelen om de database te verbinden. Zie Azure SQL Database integreren met serviceconnector 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 het document controleren om een manier te kiezen om te implementeren. Zie Quickstart: Een ASP.NET-web-app implementeren.

Spring-apps

Voor Azure Spring Apps kunt u het document controleren voor meer informatie over het bouwen van apps en implementaties. Zie De app bouwen en implementeren.

Container Apps

Voor Azure Container Apps kunt u het document controleren over het implementeren van uw app. Zie quickstart: Uw eerste container-app implementeren.

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

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 die door Service Connector is gemaakt, te herstellen 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 die door Service Connector is gemaakt, te herstellen 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 die door Service Connector is gemaakt, te herstellen 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-beheerder 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.

ServiceConnector moet toegang krijgen tot Microsoft Entra ID om informatie op te halen over uw account en de beheerde identiteit van de 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 serviceconnector en verbindingen zonder wachtwoord:

Documentatie voor serviceconnector

Verbindingen zonder wachtwoord voor Azure-services