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

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

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

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

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

az webapp connection create mysql-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $MYSQL_HOST \
    --database $DATABASE_NAME \
    --system-identity mysql-identity-id=$IDENTITY_RESOURCE_ID \
    --client-type java

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

az webapp connection create sql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $SQL_HOST \
    --database $DATABASE_NAME \
    --user-identity client-id=XX subs-id=XX \
    --client-type dotnet

az webapp connection create sql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $SQL_HOST \
    --database $DATABASE_NAME \
    --system-identity \
    --client-type dotnet

az webapp connection create sql \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $SQL_HOST \
    --database $DATABASE_NAME \
    --service-principal client-id=XX secret=XX \
    --client-type dotnet

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

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

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

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

   <dependency>
       <groupId>org.postgresql</groupId>
       <artifactId>postgresql</artifactId>
       <version>42.7.5</version>
   </dependency>
   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity-extensions</artifactId>
       <version>1.2.0</version>
   </dependency>
   

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

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 aan de hand van de tutorial Azure Database voor PostgreSQL aan uw toepassing in Azure Spring Apps koppelen. 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.

1. Installeer afhankelijkheden.

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

2. Verkrijg toegangstoken met behulp van de azure-identity bibliotheek en gebruik de token als wachtwoord. 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) 
   

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

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

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

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 bieden Azure App Service en Azure Container Apps een intern toegankelijk REST-eindpunt om tokens voor beheerde identiteiten op te halen 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-toegangstokenaanvraag voor toegang tussen services voor meer 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-verbindingsreeks uit 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);
   ?>
   

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.

   Azure App Service en Azure 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.

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.

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

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

   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>8.0.33</version>
   </dependency>
   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity-extensions</artifactId>
       <version>1.2.0</version>
   </dependency>
   

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";
   
   Properties properties = new Properties();
   properties.put("defaultAuthenticationPlugin", pluginName);
   properties.put("authenticationPlugins", pluginName);
   
   // Uncomment the following lines corresponding to the authentication type you want to use.
   
   // for user-assigned managed identity
   // String clientId = System.getenv('AZURE_MYSQL_CLIENTID')
   // properties.put("azure.clientId", clientId);
   
   // For service principal
   // String tenantId = System.getenv('AZURE_MYSQL_TENANTID')
   // String clientId = System.getenv('AZURE_MYSQL_CLIENTID')
   // String clientSecret = System.getenv('AZURE_MYSQL_CLIENTSECRET')
   // properties.put("azure.clientId", clientId);
   // properties.put("azure.clientSecret", clientSecret);
   // properties.put("azure.tenantId", tenantId);
   
   Connection connection = DriverManager.getConnection(url, properties);
   

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

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

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

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

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

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

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.

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.

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.

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.

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.

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 applicatie bij volgens de handleiding 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.

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 gebruikt als rekenservice 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)
   

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

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.

1. Installeer afhankelijkheden.

   dotnet add package Microsoft.Data.SqlClient
   

2. Haal de SQL-database in Microsoft Fabric-verbindingsreeks op uit de omgevingsvariabele die is toegevoegd door Service Connector.

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

   Zie Verificatie van beheerde identiteiten in Active Directory gebruiken voor meer informatie.

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

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

Als u voor een Spring-toepassing een verbinding met de optie --client-type springbootmaakt, stelt Service Connector de omgevingsvariabele FABRIC_SQL_CONNECTIONSTRING in met waarde-indeling jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI; in Azure Spring Apps.

Voor door de gebruiker toegewezen beheerde identiteiten wordt msiClientId=<msiClientId>; toegevoegd.

Werk uw applicatie bij volgens de handleiding 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.

spring:
  datasource:
    url: ${FABRIC_SQL_CONNECTIONSTRING}

1. Installeer afhankelijkheden.

   python -m pip install pyodbc
   

2. Haal de SQL-database in Microsoft Fabric-verbindingsreeks op uit de omgevingsvariabele die is toegevoegd door Service Connector. Als u Azure Container Apps gebruikt als rekenservice 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 SQL Database in Microsoft Fabric met behulp van referenties zonder wachtwoord. Authentication=ActiveDirectoryMSI; is vereist in de verbindingsreeks bij het maken van verbinding met beheerde identiteiten. UID=<msiClientId> is ook vereist in de verbindingsreeks wanneer u verbinding maakt met een door de gebruiker toegewezen beheerde identiteit.

   import os
   import pyodbc, struct
   from azure.identity import DefaultAzureCredential
   
   connStr = os.getenv('FABRIC_SQL_CONNECTIONSTRING')
   
   # System-assigned managed identity connection string format
   # `Driver={ODBC Driver 17 for SQL Server};Server=tcp:<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;Database=<SQL-DB-name>-<Fabric-DB-Identifier>;Authentication=ActiveDirectoryMSI;`
   
   # User-assigned managed identity connection string format
   # `Driver={ODBC Driver 17 for SQL Server};Server=tcp:<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;Database=<SQL-DB-name>-<Fabric-DB-Identifier>;UID=<msiClientId>;Authentication=ActiveDirectoryMSI;`
   
   conn = pyodbc.connect(connString)
   

1. Installeer afhankelijkheden.

   go mod init <YourProjectName>
   go mod tidy
   

2. Haal de SQL-database in Microsoft Fabric-verbindingsreeks op uit de omgevingsvariabele die is toegevoegd door Service Connector.

   package main
   
   import (
       "github.com/microsoft/go-mssqldb/azuread"
       "database/sql"
       "context"
       "log"
       "fmt"
       "os"
   )
   
   var db *sql.DB
   
   var connectionString = os.Getenv("FABRIC_SQL_CONNECTIONSTRING")
   
   func main() {
       var err error
   
       // Create connection pool
       db, err = sql.Open(azuread.DriverName, connectionString)
       if err != nil {
           log.Fatal("Error creating connection pool: ", err.Error())
       }
       ctx := context.Background()
       err = db.PingContext(ctx)
       if err != nil {
           log.Fatal(err.Error())
       }
       fmt.Printf("Connected!\n")
   }
   

Zie Golang gebruiken om een query uit te voeren op een database in Azure SQL Database voor meer informatie.

Gebruik voor andere talen de verbindingsreeks die serviceconnector instelt op de omgevingsvariabelen om de database te verbinden. Zie Sql-database integreren in Microsoft Fabric met Service Connector voor meer informatie over omgevingsvariabelen.