Połączenia bez hasła używają tożsamości zarządzanych do uzyskiwania dostępu do usług platformy Azure. Dzięki temu podejściu nie trzeba ręcznie śledzić wpisów tajnych tożsamości zarządzanych i zarządzać nimi. Te zadania są bezpiecznie obsługiwane wewnętrznie przez platformę Azure.
Łącznik usługi umożliwia tożsamości zarządzane w usługach hostingu aplikacji, takich jak Azure Spring Apps, aplikacja systemu Azure Service i Azure Container Apps. Łącznik usługi konfiguruje również usługi baz danych, takie jak Azure Database for PostgreSQL, Azure Database for MySQL, Azure SQL Database oraz SQL Database w Microsoft Fabric, aby akceptowały tożsamości zarządzane.
W tym samouczku użyjesz interfejsu wiersza polecenia platformy Azure, aby wykonać następujące zadania:
- Sprawdź środowisko początkowe przy użyciu interfejsu wiersza polecenia platformy Azure.
- Utwórz połączenie bez hasła z łącznikiem usługi.
- Użyj zmiennych środowiskowych lub konfiguracji wygenerowanych przez łącznik usługi, aby uzyskać dostęp do usługi bazy danych.
Wymagania wstępne
Aby rozpocząć korzystanie z interfejsu wiersza polecenia platformy Azure:
Instalowanie rozszerzenia bez hasła łącznika usługi
Zainstaluj najnowsze rozszerzenie bez hasła łącznika usługi dla interfejsu wiersza polecenia platformy Azure:
az extension add --name serviceconnector-passwordless --upgrade
Uwaga
Sprawdź rozszerzenie "serviceconnector-passwordless" w wersji "2.0.2" lub nowszej, uruchamiając polecenie az version. Aby uaktualnić wersję rozszerzenia, może być konieczne uaktualnienie interfejsu wiersza polecenia platformy Azure.
Tworzenie połączenia bez hasła
Następnie użyjemy usługi aplikacja systemu Azure Jako przykładu do utworzenia połączenia przy użyciu tożsamości zarządzanej.
Jeśli używasz:
Uwaga
Jeśli używasz portalu Azure, przejdź na blok Łącznik usługiAzure App Service, Azure Spring Apps lub Azure Container Apps i wybierz pozycję Utwórz, aby utworzyć połączenie. Witryna Azure Portal automatycznie utworzy polecenie i wyzwoli wykonanie polecenia w usłudze Cloud Shell.
Następujące polecenie interfejsu wiersza polecenia platformy Azure używa parametru --client-type , może to być java, dotnet, python itp. Uruchom polecenie az webapp connection create postgres-flexible -h , aby uzyskać obsługiwane typy klientów, a następnie wybierz ten, który jest zgodny z aplikacją.
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
Usługa Azure Database for MySQL — serwer elastyczny wymaga przypisanej przez użytkownika tożsamości zarządzanej w celu włączenia uwierzytelniania firmy Microsoft. Aby uzyskać więcej informacji, zobacz Skonfiguruj uwierzytelnianie Microsoft Entra dla Azure Database for MySQL – Flexible Server. Aby utworzyć tożsamość zarządzaną przypisaną przez użytkownika, możesz użyć następującego polecenia:
USER_IDENTITY_NAME=<YOUR_USER_ASSIGNED_MANAGED_IDENTITY_NAME>
IDENTITY_RESOURCE_ID=$(az identity create \
--name $USER_IDENTITY_NAME \
--resource-group $RESOURCE_GROUP \
--query id \
--output tsv)
Ważne
Po utworzeniu tożsamości zarządzanej przypisanej przez użytkownika poproś administratora globalnego lub administratora ról uprzywilejowanych o przyznanie następujących uprawnień dla tej tożsamości:
User.Read.AllGroupMember.Read.AllApplication.Read.All
Aby uzyskać więcej informacji, zobacz sekcję Uprawnieniauwierzytelniania usługi Active Directory.
Następnie połącz aplikację z bazą danych MySQL przy użyciu przypisanej przez system tożsamości zarządzanej przy użyciu łącznika usługi.
Następujące polecenie interfejsu wiersza polecenia platformy Azure używa parametru --client-type . Uruchom polecenie , az webapp connection create mysql-flexible -h aby uzyskać obsługiwane typy klientów, a następnie wybierz ten, który jest zgodny z twoją aplikacją.
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
Następujące polecenie interfejsu wiersza polecenia platformy Azure używa parametru --client-type . Uruchom polecenie , az webapp connection create sql -h aby uzyskać obsługiwane typy klientów, a następnie wybierz ten, który jest zgodny z twoją aplikacją.
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
Następujące polecenie interfejsu wiersza polecenia platformy Azure używa parametru --client-type . Uruchom polecenie , az webapp connection create fabricsql -h aby uzyskać obsługiwane typy klientów, a następnie wybierz ten, który jest zgodny z twoją aplikacją.
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
Uwaga
Połączenia usług korzystające z reprezentantów usług nie są obsługiwane przy kierowaniu bazy danych SQL w Microsoft Fabric.
To polecenie łącznika usługi wykonuje następujące zadania w tle:
- Włącz tożsamość zarządzaną przypisaną przez system lub przypisz tożsamość użytkownika dla aplikacji
$APPSERVICE_NAME hostowanej przez usługę aplikacja systemu Azure Service/Azure Spring Apps/Azure Container Apps.
- Włącz uwierzytelnianie Entra firmy Microsoft dla serwera bazy danych, jeśli nie jest włączone wcześniej.
- Ustaw administratora firmy Microsoft Entra na bieżącego zalogowanego użytkownika.
- Dodaj użytkownika bazy danych dla przypisanej przez system tożsamości zarządzanej, tożsamości zarządzanej przypisanej przez użytkownika lub jednostki usługi. Przyznaj temu użytkownikowi wszystkie uprawnienia bazy danych
$DATABASE_NAME . Nazwę użytkownika można znaleźć w parametry połączenia w poprzednich danych wyjściowych polecenia.
- Ustaw konfiguracje o nazwie
AZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRING, AZURE_SQL_CONNECTIONSTRINGlub FABRIC_SQL_CONNECTIONSTRING na zasób platformy Azure na podstawie typu bazy danych.
- W przypadku usługi App Service konfiguracje są ustawiane w bloku Ustawienia aplikacji .
- W przypadku aplikacji Spring Apps konfiguracje są ustawiane podczas uruchamiania aplikacji.
- W przypadku usługi Container Apps konfiguracje są ustawiane na zmienne środowiskowe. Wszystkie konfiguracje i ich wartości można pobrać w okienku Łącznik usługi w portalu Azure.
Łącznik usługi przypisze użytkownikowi następujące uprawnienia. Można je odwołać i dostosować uprawnienia zgodnie z wymaganiami.
GRANT ALL PRIVILEGES ON DATABASE "$DATABASE_NAME" TO "username";
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO "username";
GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO "username";
GRANT ALL PRIVILEGES ON $DATABASE_NAME.* TO 'username'@'%';
GRANT CONTROL ON DATABASE::"$DATABASE_NAME" TO "username";
ALTER ROLE db_datareader ADD MEMBER "username"
ALTER ROLE db_datawriter ADD MEMBER "username"
ALTER ROLE db_ddladmin ADD MEMBER "username"
Nawiązywanie połączenia z bazą danych przy użyciu uwierzytelniania firmy Microsoft Entra
Po utworzeniu połączenia możesz użyć parametry połączenia w aplikacji, aby nawiązać połączenie z bazą danych przy użyciu uwierzytelniania firmy Microsoft Entra. Na przykład możesz użyć następujących rozwiązań, aby nawiązać połączenie z bazą danych za pomocą uwierzytelniania firmy Microsoft Entra.
W przypadku platformy .NET nie ma wtyczki ani biblioteki do obsługi połączeń bez hasła. Token dostępu dla tożsamości zarządzanej lub jednostki usługi można uzyskać przy użyciu biblioteki klienta, takiej jak Azure.Identity. Następnie możesz użyć tokenu dostępu jako hasła, aby nawiązać połączenie z bazą danych. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.
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();
}
Dodaj następujące zależności w pliku pom.xml :
<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>
Pobierz parametry połączenia ze zmiennych środowiskowych i dodaj nazwę wtyczki, aby nawiązać połączenie z bazą danych:
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);
Aby uzyskać więcej informacji, zobacz następujące zasoby:
Instalowanie zależności.
pip install azure-identity
pip install psycopg2-binary
pip freeze > requirements.txt # Save the dependencies to a file
Uzyskiwanie tokenu dostępu przy użyciu azure-identity biblioteki i używanie tokenu jako hasła. Pobierz informacje o połączeniu ze zmiennych środowiskowych dodanych przez łącznik usługi. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.
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)
Instalowanie zależności.
pip install azure-identity
Uzyskiwanie tokenu dostępu przy użyciu biblioteki przy użyciu azure-identity zmiennych środowiskowych dodanych przez łącznik usługi. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.
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')
W pliku ustawień pobierz informacje o bazie danych Azure PostgreSQL ze zmiennych środowiskowych dodanych przez usługę Service Connector. Użyj accessToken metody uzyskanej w poprzednim kroku, aby uzyskać dostęp do bazy danych.
# 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'},
}
}
Instalowanie zależności.
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"
W kodzie uzyskaj token dostępu przy użyciu metody azidentity, a następnie użyj go jako hasła, aby nawiązać połączenie z usługą Azure PostgreSQL wraz z informacjami o połączeniu dostarczonymi przez łącznik usługi. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.
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()
Instalowanie zależności.
npm install --save @azure/identity
npm install --save pg
W kodzie uzyskaj token dostępu przy użyciu informacji o połączeniu i @azure/identity usłudze PostgreSQL ze zmiennych środowiskowych dodanych przez usługę Service Connector. Połącz je, aby nawiązać połączenie. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.
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();
})();
W przypadku języka PHP nie ma wtyczki ani biblioteki dla połączeń bez hasła. Możesz uzyskać token dostępu dla tożsamości zarządzanej lub jednostki usługi i użyć go jako hasła w celu nawiązania połączenia z bazą danych. Token dostępu można uzyskać przy użyciu interfejsu API REST platformy Azure.
W kodzie pobierz token dostępu przy użyciu interfejsu API REST z ulubioną biblioteką.
W przypadku tożsamości przypisanej przez użytkownika i tożsamości przypisanej przez system usługa Azure App Service i usługa Azure Container Apps zapewniają wewnętrznie dostępny punkt końcowy REST do pobierania tokenów dla tożsamości zarządzanych przez zdefiniowanie dwóch zmiennych środowiskowych: IDENTITY_ENDPOINT i IDENTITY_HEADER. Aby uzyskać więcej informacji, zapoznaj się z odwołaniem do punktu końcowego REST.
Pobierz token dostępu, wysyłając żądanie HTTP GET do punktu końcowego tożsamości i używając go https://ossrdbms-aad.database.windows.net tak jak resource w zapytaniu. W przypadku tożsamości przypisanej przez użytkownika dołącz identyfikator klienta ze zmiennych środowiskowych dodanych przez łącznik usługi w zapytaniu.
Dla głównej usługi, zapoznaj się z żądaniem tokenu dostępu do usługi Azure AD, aby uzyskać szczegółowe informacje na temat uzyskiwania tokenu dostępu. Utwórz żądanie POST zakresu https://ossrdbms-aad.database.windows.net/.default i za pomocą identyfikatora dzierżawy, identyfikatora klienta i wpisu tajnego klienta jednostki usługi ze zmiennych środowiskowych dodanych przez łącznik usługi.
Połącz token dostępu i ciąg połączenia PostgreSQL ze zmiennych środowiskowych dodanych przez usługę Service Connector, aby nawiązać połączenie.
<?php
$conn_string = sprintf("%s password=", getenv('AZURE_POSTGRESQL_CONNECTIONSTRING'), $access_token);
$dbconn = pg_connect($conn_string);
?>
W przypadku języka Ruby nie ma wtyczki ani biblioteki dla połączeń bez hasła. Możesz uzyskać token dostępu dla tożsamości zarządzanej lub jednostki usługi i użyć go jako hasła w celu nawiązania połączenia z bazą danych. Token dostępu można uzyskać przy użyciu interfejsu API REST platformy Azure.
Instalowanie zależności.
gem install pg
W kodzie uzyskaj token dostępu przy użyciu interfejsu API REST i informacji o połączeniu PostgreSQL ze zmiennych środowiskowych dodanych przez usługę Service Connector. Połącz je, aby nawiązać połączenie. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.
Usługi Azure App Service i Azure Container Apps zapewniają wewnętrznie dostępny punkt końcowy REST do pobierania tokenów dla tożsamości zarządzanych. Aby uzyskać więcej informacji, zapoznaj się z odwołaniem do punktu końcowego REST.
require 'pg'
require 'dotenv/load'
require 'net/http'
require 'json'
# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned identity.
# uri = URI(ENV['IDENTITY_ENDPOINT'] + '?resource=https://ossrdbms-aad.database.windows.net&api-version=2019-08-01')
# res = Net::HTTP.get_response(uri, {'X-IDENTITY-HEADER' => ENV['IDENTITY_HEADER'], 'Metadata' => 'true'})
# For user-assigned identity.
# uri = URI(ENV[IDENTITY_ENDPOINT] + '?resource=https://ossrdbms-aad.database.windows.net&api-version=2019-08-01&client_id=' + ENV['AZURE_POSTGRESQL_CLIENTID'])
# res = Net::HTTP.get_response(uri, {'X-IDENTITY-HEADER' => ENV['IDENTITY_HEADER'], 'Metadata' => 'true'})
# For service principal
# uri = URI('https://login.microsoftonline.com/' + ENV['AZURE_POSTGRESQL_TENANTID'] + '/oauth2/v2.0/token')
# params = {
# :grant_type => 'client_credentials',
# :client_id: => ENV['AZURE_POSTGRESQL_CLIENTID'],
# :client_secret => ENV['AZURE_POSTGRESQL_CLIENTSECRET'],
# :scope => 'https://ossrdbms-aad.database.windows.net/.default'
# }
# req = Net::HTTP::POST.new(uri)
# req.set_form_data(params)
# req['Content-Type'] = 'application/x-www-form-urlencoded'
# res = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|
# http.request(req)
parsed = JSON.parse(res.body)
access_token = parsed["access_token"]
# Use the token and the connection string from the environment variables added by Service Connector to establish the connection.
conn = PG::Connection.new(
connection_string: ENV['AZURE_POSTGRESQL_CONNECTIONSTRING'] + " password=" + access_token,
)
Aby uzyskać więcej informacji na temat uzyskiwania tokenu dostępu dla jednostki usługi, zapoznaj się z żądaniem tokenu dostępu do usługi Azure AD .
Następnie, jeśli utworzono tabele i sekwencje na serwerze elastycznym PostgreSQL przed użyciem łącznika usługi, musisz nawiązać połączenie jako właściciel i udzielić uprawnień do <aad-username> utworzenia przez łącznik usługi. Nazwa użytkownika z parametry połączenia lub konfiguracji ustawionej przez łącznik usługi powinna wyglądać następująco: aad_<connection name>. Jeśli używasz witryny Azure Portal, wybierz przycisk rozwijania obok Service Type kolumny i pobierz wartość. Jeśli używasz interfejsu wiersza polecenia platformy Azure, sprawdź configurations dane wyjściowe polecenia interfejsu wiersza polecenia.
Następnie wykonaj zapytanie, aby udzielić uprawnienia
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>\";"
Element <owner-username> i <owner-password> jest właścicielem istniejącej tabeli, która może udzielić uprawnień innym osobom.
<aad-username> to użytkownik utworzony przez łącznik usługi. Zastąp je rzeczywistą wartością.
Zweryfikuj wynik za pomocą polecenia :
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
W przypadku platformy .NET nie ma wtyczki ani biblioteki do obsługi połączeń bez hasła. Token dostępu dla tożsamości zarządzanej lub jednostki usługi można uzyskać przy użyciu biblioteki klienta, takiej jak Azure.Identity. Następnie możesz użyć tokenu dostępu jako hasła, aby nawiązać połączenie z bazą danych. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.
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
Dodaj następujące zależności w pliku pom.xml :
<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>
Pobierz parametry połączenia ze zmiennej środowiskowej i dodaj nazwę wtyczki, aby nawiązać połączenie z bazą danych:
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);
Aby uzyskać więcej informacji, zobacz Używanie języków Java i JDBC z usługą Azure Database for MySQL — serwer elastyczny.
Instalowanie zależności
pip install azure-identity
# install Connector/Python https://dev.mysql.com/doc/connector-python/en/connector-python-installation.html
pip install mysql-connector-python
Uwierzytelnianie za pomocą tokenu dostępu jest uzyskiwane za pośrednictwem azure-identity biblioteki i uzyskiwanie informacji o połączeniu ze zmiennej środowiskowej dodanej przez łącznik usługi. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.
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()
Instalowanie zależności.
pip install azure-identity
Uzyskiwanie tokenu dostępu za pośrednictwem biblioteki za pomocą azure-identity zmiennych środowiskowych dodanych przez łącznik usługi. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.
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')
W pliku ustawień pobierz informacje o bazie danych Azure MySQL ze zmiennych środowiskowych dodanych przez usługę Service Connector. Użyj accessToken metody uzyskanej w poprzednim kroku, aby uzyskać dostęp do bazy danych.
# 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
}
}
Instalowanie zależności.
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"
W kodzie uzyskaj token dostępu za pośrednictwem metody azidentity, a następnie połącz się z usługą Azure MySQL przy użyciu tokenu. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.
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)
}
Instalowanie zależności
npm install --save @azure/identity
npm install --save mysql2
Uzyskiwanie tokenu dostępu przy użyciu i @azure/identity informacji o bazie danych Azure MySQL ze zmiennych środowiskowych dodanych przez usługę Service Connector. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.
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');
});
Aby uzyskać więcej przykładów kodu, zobacz Nawiązywanie połączenia z bazami danych platformy Azure z usługi App Service bez wpisów tajnych przy użyciu tożsamości zarządzanej.
Instalowanie zależności.
dotnet add package Microsoft.Data.SqlClient
Pobierz parametry połączenia usługi Azure SQL Database ze zmiennej środowiskowej dodanej przez łącznik usługi.
using Microsoft.Data.SqlClient;
string connectionString =
Environment.GetEnvironmentVariable("AZURE_SQL_CONNECTIONSTRING")!;
using var connection = new SqlConnection(connectionString);
connection.Open();
Aby uzyskać więcej informacji, zobacz Używanie uwierzytelniania tożsamości zarządzanej usługi Active Directory.
Dodaj następujące zależności w pliku pom.xml :
<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>
Pobierz parametry połączenia usługi Azure SQL Database ze zmiennej środowiskowej dodanej przez łącznik usługi.
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();
}
}
}
Aby uzyskać więcej informacji, zapoznaj się z nawiązywaniem połączenia z bazami danych Azure z usługi App Service bez użycia tajnych danych przy użyciu zarządzanej tożsamości.
Instalowanie zależności.
python -m pip install pyodbc
Pobierz konfiguracje połączeń usługi Azure SQL Database ze zmiennej środowiskowej dodanej przez łącznik usługi. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć. Jeśli używasz usługi Azure Container Apps jako usługi obliczeniowej lub parametry połączenia w fragmencie kodu nie działają, zapoznaj się z artykułem Migrowanie aplikacji języka Python w celu używania połączeń bez hasła z usługą Azure SQL Database w celu nawiązania połączenia z usługą Azure SQL Database przy użyciu tokenu dostępu.
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)
- Instalowanie zależności.
npm install mssql
- Pobierz konfiguracje połączeń usługi Azure SQL Database ze zmiennych środowiskowych dodanych przez łącznik usługi. Korzystając z poniższego kodu, usuń komentarz z części fragmentu kodu dla typu uwierzytelniania, którego chcesz użyć.
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);
Aby uzyskać więcej informacji, zobacz Strona główna programowania klientów w programie Microsoft SQL Server.
Instalowanie zależności.
dotnet add package Microsoft.Data.SqlClient
Pobierz ciąg połączenia do bazy danych SQL w Microsoft Fabric ze zmiennej środowiskowej dodanej przez łącznik usługi Service Connector.
using Microsoft.Data.SqlClient;
string connectionString =
Environment.GetEnvironmentVariable("FABRIC_SQL_CONNECTIONSTRING")!;
using var connection = new SqlConnection(connectionString);
connection.Open();
Aby uzyskać więcej informacji, zobacz Używanie uwierzytelniania tożsamości zarządzanej usługi Active Directory.
Dodaj następujące zależności w pliku pom.xml :
<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>
Pobierz ciąg połączenia do bazy danych SQL w Microsoft Fabric ze zmiennej środowiskowej dodanej przez łącznik usługi 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();
}
}
}
Aby uzyskać więcej informacji, zapoznaj się z nawiązywaniem połączenia z bazami danych Azure z usługi App Service bez użycia tajnych danych przy użyciu zarządzanej tożsamości.
Dla aplikacji Spring, jeśli utworzysz połączenie z opcją --client-type springboot, Service Connector ustawia zmienną środowiskową FABRIC_SQL_CONNECTIONSTRING z formatem jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI; wartości na Azure Spring Apps.
W przypadku zarządzanych tożsamości przypisanych przez użytkownika, msiClientId=<msiClientId>; jest dodawany.
Zaktualizuj aplikację zgodnie z samouczkiem Migrate a Java application to use passwordless connections with Azure SQL Database (Migrowanie aplikacji Java w celu używania połączeń bez hasła z usługą Azure SQL Database). Pamiętaj, aby usunąć spring.datasource.password właściwość konfiguracji, jeśli została wcześniej ustawiona i dodać poprawne zależności.
spring:
datasource:
url: ${FABRIC_SQL_CONNECTIONSTRING}
Instalowanie zależności.
python -m pip install pyodbc
Pobierz ciąg połączenia do bazy danych SQL w Microsoft Fabric ze zmiennej środowiskowej dodanej przez łącznik usługi Service Connector. Jeśli używasz usługi Azure Container Apps jako usługi obliczeniowej lub parametry połączenia w fragmencie kodu nie działają, zapoznaj się z artykułem Migrowanie aplikacji języka Python w celu używania połączeń bez hasła z usługą Azure SQL Database w celu nawiązania połączenia z bazą danych SQL w usłudze Microsoft Fabric przy użyciu poświadczeń bez hasła.
Authentication=ActiveDirectoryMSI; jest wymagany w parametrach połączenia podczas nawiązywania połączenia przy użyciu tożsamości zarządzanych.
UID=<msiClientId> jest również wymagany w parametrach połączenia podczas nawiązywania połączenia przy użyciu tożsamości zarządzanej przypisanej przez użytkownika.
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)
- Instalowanie zależności.
go mod init <YourProjectName>
go mod tidy
- Pobierz ciąg połączenia do bazy danych SQL w Microsoft Fabric ze zmiennej środowiskowej dodanej przez łącznik usługi 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")
}
Aby uzyskać więcej informacji, zobacz Używanie języka Golang do wykonywania zapytań dotyczących bazy danych w usłudze Azure SQL Database.
Aby uzyskać więcej informacji, zobacz Nawiązywanie połączenia z bazą danych SQL w usłudze Microsoft Fabric.
Wdrażanie aplikacji w usłudze hostingu platformy Azure
Wdróż aplikację w usłudze hostingu platformy Azure. Opcjonalnie zapoznaj się z poniższymi przewodnikami, aby uzyskać więcej informacji na temat wdrażania tych zasobów.
Sprawdź dziennik lub wywołaj aplikację, aby sprawdzić, czy może pomyślnie nawiązać połączenie z bazą danych platformy Azure.
Rozwiązywanie problemów
Uprawnienia
Jeśli wystąpią jakiekolwiek błędy związane z uprawnieniami, potwierdź zalogowanego użytkownika interfejsu wiersza polecenia platformy Azure za pomocą polecenia az account show. Upewnij się, że logujesz się przy użyciu poprawnego konta. Następnie upewnij się, że masz następujące uprawnienia, które mogą być wymagane do utworzenia połączenia bez hasła z łącznikiem usługi.
| Uprawnienie |
Operacja |
Microsoft.DBforPostgreSQL/flexibleServers/read |
Wymagane do uzyskania informacji o serwerze bazy danych |
Microsoft.DBforPostgreSQL/flexibleServers/write |
Wymagane do włączenia uwierzytelniania entra firmy Microsoft dla serwera bazy danych |
Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write |
Wymagane do utworzenia reguły zapory w przypadku zablokowania lokalnego adresu IP |
Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete |
Wymagane do odwrócenia reguły zapory utworzonej przez łącznik usługi w celu uniknięcia problemu z zabezpieczeniami |
Microsoft.DBforPostgreSQL/flexibleServers/administrators/read |
Wymagane do sprawdzenia, czy użytkownik logowania interfejsu wiersza polecenia platformy Azure jest serwerem bazy danych Microsoft Entra administrator |
Microsoft.DBforPostgreSQL/flexibleServers/administrators/write |
Wymagane do dodania użytkownika logowania interfejsu wiersza polecenia platformy Azure jako serwera bazy danych Microsoft Entra administrator |
| Uprawnienie |
Operacja |
Microsoft.DBforMySQL/flexibleServers/read |
Wymagane do uzyskania informacji o serwerze bazy danych |
Microsoft.DBforMySQL/flexibleServers/write |
Wymagane do dodania podanej tożsamości zarządzanej przypisanej przez użytkownika do serwera bazy danych |
Microsoft.DBforMySQL/flexibleServers/firewallRules/write |
Wymagane do utworzenia reguły zapory w przypadku zablokowania lokalnego adresu IP |
Microsoft.DBforMySQL/flexibleServers/firewallRules/delete |
Wymagane do odwrócenia reguły zapory utworzonej przez łącznik usługi w celu uniknięcia problemu z zabezpieczeniami |
Microsoft.DBforMySQL/flexibleServers/administrators/read |
Wymagane do sprawdzenia, czy użytkownik logowania interfejsu wiersza polecenia platformy Azure jest serwerem bazy danych Microsoft Entra administrator |
Microsoft.DBforMySQL/flexibleServers/administrators/write |
Wymagane do dodania użytkownika logowania interfejsu wiersza polecenia platformy Azure jako serwera bazy danych Microsoft Entra administrator |
| Uprawnienie |
Operacja |
Microsoft.Sql/servers/read |
Wymagane do uzyskania informacji o serwerze bazy danych |
Microsoft.Sql/servers/firewallRules/write |
Wymagane do utworzenia reguły zapory w przypadku zablokowania lokalnego adresu IP |
Microsoft.Sql/servers/firewallRules/delete |
Wymagane do odwrócenia reguły zapory utworzonej przez łącznik usługi w celu uniknięcia problemu z zabezpieczeniami |
Microsoft.Sql/servers/administrators/read |
Wymagane do sprawdzenia, czy użytkownik logowania interfejsu wiersza polecenia platformy Azure jest serwerem bazy danych Microsoft Entra administrator |
Microsoft.Sql/servers/administrators/write |
Wymagane do dodania użytkownika logowania interfejsu wiersza polecenia platformy Azure jako serwera bazy danych Microsoft Entra administrator |
W niektórych przypadkach uprawnienia nie są wymagane. Jeśli na przykład użytkownik uwierzytelniony za pomocą interfejsu wiersza polecenia platformy Azure jest już administratorem usługi Active Directory na serwerze SQL, nie musisz mieć Microsoft.Sql/servers/administrators/write uprawnień.
Microsoft Entra ID
Jeśli wystąpi błąd ERROR: AADSTS530003: Your device is required to be managed to access this resource., poproś dział IT o pomoc przy dołączeniu tego urządzenia do identyfikatora Entra firmy Microsoft. Aby uzyskać więcej informacji, zobacz Urządzenia powiązane z Microsoft Entra.
Łącznik usługi musi uzyskać dostęp do identyfikatora entra firmy Microsoft, aby uzyskać informacje o twoim koncie i tożsamości zarządzanej usługi hostingu. Możesz użyć następującego polecenia, aby sprawdzić, czy urządzenie może uzyskać dostęp do identyfikatora Firmy Microsoft Entra:
az ad signed-in-user show
Jeśli nie logujesz się interaktywnie, może zostać wyświetlony błąd i Interactive authentication is needed. Aby rozwiązać ten problem, zaloguj się za az login pomocą polecenia .
Łączność sieciowa
Jeśli serwer bazy danych znajduje się w sieci wirtualnej, upewnij się, że środowisko uruchamiające polecenie interfejsu wiersza polecenia platformy Azure może uzyskać dostęp do serwera w sieci wirtualnej.
Jeśli serwer bazy danych znajduje się w sieci wirtualnej, upewnij się, że środowisko uruchamiające polecenie interfejsu wiersza polecenia platformy Azure może uzyskać dostęp do serwera w sieci wirtualnej.
Jeśli serwer bazy danych nie zezwala na dostęp publiczny, upewnij się, że środowisko uruchamiające polecenie interfejsu wiersza polecenia platformy Azure może uzyskać dostęp do serwera za pośrednictwem prywatnego punktu końcowego.
Następne kroki
Aby uzyskać więcej informacji na temat łącznika usługi i połączeń bez hasła, zapoznaj się z następującymi zasobami:
