Oktatóanyag: Jelszó nélküli kapcsolat létrehozása adatbázis-szolgáltatással a Service Connectoron keresztül

A jelszó nélküli kapcsolatok felügyelt identitásokat használnak az Azure-szolgáltatások eléréséhez. Ezzel a módszerrel nem kell manuálisan nyomon követnie és kezelnie a felügyelt identitások titkait. Ezeket a feladatokat az Azure belsőleg kezeli biztonságosan.

A Service Connector lehetővé teszi a felügyelt identitásokat az olyan alkalmazás-üzemeltetési szolgáltatásokban, mint az Azure Spring Apps, az Azure App Service és az Azure Container Apps. A Service Connector olyan adatbázis-szolgáltatásokat is konfigurál, mint az Azure Database for PostgreSQL, az Azure Database for MySQL, az Azure SQL Database és az SQL Database a Microsoft Fabricben a felügyelt identitások elfogadásához.

Ebben az oktatóanyagban az Azure CLI használatával hajtja végre a következő feladatokat:

Ellenőrizze a kezdeti környezetet az Azure CLI-vel.
Jelszó nélküli kapcsolat létrehozása a Service Connector használatával.
Használja a Service Connector által létrehozott környezeti változókat vagy konfigurációkat egy adatbázis-szolgáltatás eléréséhez.

Előfeltételek

Egy Azure-fiók, aktív előfizetéssel. Hozzon létre ingyenes Azure-fiókot.
Az Azure App Service-ben a Service Connector által támogatott régióban üzembe helyezett alkalmazás.
Az Azure CLI 2.61.0-s vagy újabb verziója.

Az Azure CLI használatának megkezdése:

Használja a Bash-környezetet az Azure Cloud Shellben. További információ: Az Azure Cloud Shell használatának első lépései.
Ha inkább helyi cli-referenciaparancsokat szeretne futtatni, telepítse az Azure CLI-t. Ha Windows vagy macOS rendszeren fut, fontolja meg az Azure CLI docker-tárolóban való futtatását. További információ : Az Azure CLI futtatása Docker-tárolóban.
- Ha helyi telepítést használ, jelentkezzen be az Azure CLI-be az az login paranccsal. A hitelesítési folyamat befejezéséhez kövesse a terminálban megjelenő lépéseket. További bejelentkezési lehetőségekért lásd: Hitelesítés az Azure-ba az Azure CLI használatával.
- Amikor a rendszer kéri, először telepítse az Azure CLI-bővítményt. További információ a bővítményekről: Bővítmények használata és kezelése az Azure CLI-vel.
- Futtassa az az verziót a telepített verzió és a függő kódtárak megkereséséhez. A legújabb verzióra való frissítéshez futtassa az az upgrade parancsot.

A Service Connector jelszó nélküli bővítményének telepítése

Telepítse a service connector legújabb jelszó nélküli bővítményét az Azure CLI-hez:

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

Megjegyzés:

Ellenőrizze, hogy a "serviceconnector-passwordless" bővítmény verziója "2.0.2" vagy újabb-e azáltal, hogy futtatja a következő parancsot: az version. Előfordulhat, hogy előbb frissítenie kell az Azure CLI-t a bővítményverzió frissítéséhez.

Jelszó nélküli kapcsolat létrehozása

Ezt követően az Azure App Service-t használjuk példaként egy felügyelt identitással való kapcsolat létrehozásához.

Ha a következőt használja:

Azure Spring Apps: használja az spring connection create helyette. További példákért lásd: Az Azure Spring Apps csatlakoztatása az Azure-adatbázishoz.
Azure Container Apps: használja az containerapp connection create helyette. További példákért lásd: PostgreSQL-adatbázis létrehozása és csatlakoztatása identitáskapcsolattal.

Megjegyzés:

Ha az Azure Portalt használja, lépjen az Azure App Service, az Azure Spring Apps vagy az Azure Container Apps Szolgáltatás-összekötő paneljére, és válassza a Létrehozás lehetőséget a kapcsolat létrehozásához. Az Azure Portal automatikusan meg fogja írni a parancsot, és elindítja a parancs végrehajtását a Cloud Shellben.

A következő Azure CLI-parancs egy paramétert --client-type használ, amely lehet java, dotnet, python stb. A támogatott ügyféltípusok lekéréséhez futtassa a az webapp connection create postgres-flexible -h parancsot, és válassza ki az alkalmazásnak megfelelőt.

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

A Rugalmas Azure Database for MySQL-kiszolgálóhoz felhasználó által hozzárendelt felügyelt identitás szükséges a Microsoft Entra-hitelesítés engedélyezéséhez. További információkért, lásd: Microsoft Entra-hitelesítés beállítása az Azure Database for MySQL - Rugalmas Kiszolgálón. A következő paranccsal hozhat létre felhasználó által hozzárendelt felügyelt identitást:

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)

Fontos

A felhasználó által hozzárendelt felügyelt identitás létrehozása után kérje meg a globális rendszergazdát vagy a kiemelt szerepkör-rendszergazdát, hogy adja meg az alábbi engedélyeket ehhez az identitáshoz:

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

További információ: Az Active Directory-hitelesítés Engedélyek szakasza.

Ezután csatlakoztassa az alkalmazást egy MySQL-adatbázishoz egy rendszer által hozzárendelt felügyelt identitással a Service Connector használatával.

Az alábbi Azure CLI-parancs egy paramétert --client-type használ. Futtassa a az webapp connection create mysql-flexible -h parancsot a támogatott ügyféltípusok megtekintéséhez, és válassza ki az az alkalmazásához leginkább megfelelőt.

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 alábbi Azure CLI-parancs egy paramétert --client-type használ. Futtassa a az webapp connection create sql -h parancsot a támogatott ügyféltípusok megtekintéséhez, és válassza ki az az alkalmazásához leginkább megfelelőt.

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 alábbi Azure CLI-parancs egy paramétert --client-type használ. Futtassa a az webapp connection create fabricsql -h parancsot a támogatott ügyféltípusok megtekintéséhez, és válassza ki az az alkalmazásához leginkább megfelelőt.

Fontos

A teljes beilleszkedéshez jelenleg manuális hozzáférés megosztására van szükség. Lásd : SQL-adatbázishoz való hozzáférés megosztása a Fabricben.

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

Ez a Service Connector-parancs a következő feladatokat hajtja végre a háttérben:

Engedélyezze a rendszer által hozzárendelt felügyelt identitást, vagy rendeljen hozzá egy felhasználói identitást az Azure App Service/Azure Spring Apps/Azure Container Apps által üzemeltetett alkalmazáshoz $APPSERVICE_NAME .
Ha korábban még nincs engedélyezve, engedélyezze a Microsoft Entra-hitelesítést az adatbázis-kiszolgálóhoz.
Állítsa a Microsoft Entra rendszergazdát az aktuális bejelentkezett felhasználóra.
Adjon hozzá adatbázis-felhasználót a rendszer által hozzárendelt felügyelt identitáshoz, felhasználó által hozzárendelt felügyelt identitáshoz vagy szolgáltatásnévhez. Adja meg az adatbázis $DATABASE_NAME összes jogosultságát ennek a felhasználónak. A felhasználónév az előző parancskimenetben található a kapcsolati karakterláncban.
Állítsa be a AZURE_MYSQL_CONNECTIONSTRING, AZURE_POSTGRESQL_CONNECTIONSTRING, AZURE_SQL_CONNECTIONSTRING vagy FABRIC_SQL_CONNECTIONSTRING néven felsorolt konfigurációkat az Azure-erőforráshoz az adatbázis típusa alapján.
- App Service esetén a konfigurációk az Alkalmazásbeállítások panelen vannak beállítva.
- A Spring Apps esetében a konfigurációk az alkalmazás indításakor vannak beállítva.
- A Container Apps esetében a konfigurációk a környezeti változókra vannak állítva. Az összes konfigurációt és értéküket lekérheti az Azure Portal Service Connector paneljén.

A Service Connector a következő jogosultságokat rendeli a felhasználóhoz, visszavonhatja őket, és a követelményeknek megfelelően módosíthatja a jogosultságokat.

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"

Csatlakozás adatbázishoz Microsoft Entra-hitelesítéssel

A kapcsolat létrehozása után az alkalmazás kapcsolati sztringjével Microsoft Entra-hitelesítéssel csatlakozhat az adatbázishoz. Az alábbi megoldásokkal például Microsoft Entra-hitelesítéssel csatlakozhat az adatbázishoz.

A .NET esetében nincs beépülő modul vagy tár a jelszó nélküli kapcsolatok támogatásához. A felügyelt identitáshoz vagy szolgáltatásnévhez hozzáférési jogkivonatot kérhet le az olyan ügyfélkódtárak használatával, mint az Azure.Identity. Ezután jelszóként használhatja a hozzáférési jogkivonatot az adatbázishoz való csatlakozáshoz. Az alábbi kód használatakor bontsa ki a kódrészlet azon részét, amely a használni kívánt hitelesítési típushoz tartozik.

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

Adja hozzá a következő függőségeket a pom.xml fájlhoz:

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

Kérje le a kapcsolati sztringet a környezeti változókból, és adja hozzá a beépülő modul nevét az adatbázishoz való csatlakozáshoz:

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

További információt a következő források tartalmaznak:

Egy Spring-alkalmazás esetén, ha egy kapcsolatot hoz létre az --client-type springboot beállítással, a Service Connector beállítja a spring.datasource.azure.passwordless-enabled, spring.datasource.url és spring.datasource.username tulajdonságokat az Azure Spring Apps számára.

Frissítse az alkalmazást a(z) Azure Database for PostgreSQL alkalmazás összekapcsolása az Azure Spring Appsben című oktatóanyagot követve. Ne felejtse el eltávolítani a spring.datasource.password konfigurációs tulajdonságot, ha korábban be lett állítva, és adja hozzá a megfelelő függőségeket a Spring-alkalmazáshoz.

További oktatóanyagok: A Spring Data JDBC használata az Azure Database for PostgreSQL-lel és oktatóanyag: Spring-alkalmazás üzembe helyezése az Azure Spring Appsben jelszó nélküli kapcsolattal egy Azure-adatbázishoz.

Telepítse a függőségeket.

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

Szerezze be a hozzáférési jogkivonatot a kódtár használatával azure-identity , és használja a jogkivonatot jelszóként. Kapcsolati adatok lekérése a Service Connector által hozzáadott környezeti változókból. Az alábbi kód használatakor bontsa ki a kódrészlet azon részét, amely a használni kívánt hitelesítési típushoz tartozik.

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)

Telepítse a függőségeket.
```
pip install azure-identity
```

Szerezz hozzáférési jogkivonatot a azure-identity könyvtár használatával a Service Connector által hozzáadott környezeti változók révén. Az alábbi kód használatakor bontsa ki a kódrészlet azon részét, amely a használni kívánt hitelesítési típushoz tartozik.

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

A fájl beállításakor kérje le az Azure PostgreSQL-adatbázis adatait a Service Connector szolgáltatás által hozzáadott környezeti változókból. Az adatbázis eléréséhez használja accessToken az előző lépésben beszerzett adatokat.

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

Telepítse a függőségeket.

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"

A kódban szerezze be a hozzáférési tokent, azidentity, majd jelszóként használja az Azure PostgreSQL-hez csatlakozva, együttműködve a Service Connector által megadott kapcsolati információkkal. Az alábbi kód használatakor bontsa ki a kódrészlet azon részét, amely a használni kívánt hitelesítési típushoz tartozik.

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

Telepítse a függőségeket.

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

Kódban kérje le a hozzáférési jogkivonatot a Service Connector szolgáltatás által hozzáadott környezeti változók és PostgreSQL-kapcsolati adatok használatával @azure/identity . Kapcsolja össze őket a kapcsolat létrehozásához. Az alábbi kód használatakor bontsa ki a kódrészlet azon részét, amely a használni kívánt hitelesítési típushoz tartozik.

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

PHP esetén nincs beépülő modul vagy kódtár a jelszó nélküli kapcsolatokhoz. Lekérhet egy hozzáférési jogkivonatot a felügyelt identitáshoz vagy szolgáltatásnévhez, és jelszóként használhatja az adatbázishoz való csatlakozáshoz. A hozzáférési jogkivonat az Azure REST API-val szerezhető be.

Kód segítségével szerezze meg a hozzáférési tokent a REST API használatával és a kedvenc könyvtárával.

A felhasználó által hozzárendelt identitás és a rendszer által hozzárendelt identitás esetében az Azure App Service és az Azure Container Apps egy belsőleg elérhető REST-végpontot biztosít a felügyelt identitások jogkivonatainak lekéréséhez két környezeti változó definiálásával: IDENTITY_ENDPOINT és IDENTITY_HEADER. További információkért lásd a REST-végpontok hivatkozását. A hozzáférési jogkivonat megszerzéséhez küldjön egy HTTP GET kérést az identitásvégponthoz, és a lekérdezésben használja a https://ossrdbms-aad.database.windows.net-t resource-ként. A felhasználó által hozzárendelt identitáshoz adja meg a Service Connector által a lekérdezésben hozzáadott környezeti változók ügyfél-azonosítóját is.

Szolgáltatás-princípium esetén tekintse meg az Azure AD szolgáltatás–szolgáltatás hozzáférési jogkivonat-kérés részleteit a hozzáférési jogkivonat beszerzésének módjáról. A POST kérést tegye a https://ossrdbms-aad.database.windows.net/.default hatókörébe, és használja a Service Connector által hozzáadott környezeti változókban található bérlőazonosítót, szolgáltatásnév azonosítót és szolgáltatásnév titkot.
Kombinálja a hozzáférési jogkivonatot és a PostgreSQL kapcsolati sztringet a Service Connector szolgáltatás által hozzáadott környezeti változókból a kapcsolat létrehozásához.
```
<?php
$conn_string = sprintf("%s password=", getenv('AZURE_POSTGRESQL_CONNECTIONSTRING'), $access_token);
$dbconn = pg_connect($conn_string);
?>
```

Ruby esetében nincs beépülő modul vagy kódtár a jelszó nélküli kapcsolatokhoz. Lekérhet egy hozzáférési jogkivonatot a felügyelt identitáshoz vagy szolgáltatásnévhez, és jelszóként használhatja az adatbázishoz való csatlakozáshoz. A hozzáférési jogkivonat az Azure REST API-val szerezhető be.

Telepítse a függőségeket.
```
gem install pg
```

Kódban kérje le a hozzáférési jogkivonatot a REST API és a PostgreSQL kapcsolati adataival a Service Connector szolgáltatás által hozzáadott környezeti változókból. Kapcsolja össze őket a kapcsolat létrehozásához. Az alábbi kód használatakor bontsa ki a kódrészlet azon részét, amely a használni kívánt hitelesítési típushoz tartozik.

Az Azure App Service és az Azure Container Apps egy belsőleg elérhető REST-végpontot biztosít a felügyelt identitások jogkivonatainak lekéréséhez. További információkért lásd a REST-végpontok hivatkozását.

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

A szolgáltatásnév hozzáférési jogkivonatának beszerzéséről az Azure AD szolgáltatásközi hozzáférési jogkivonat-kérésében olvashat bővebben.

Ezután, ha a Service Connector használata előtt táblákat és szekvenciákat hozott létre a Rugalmas PostgreSQL-kiszolgálón, tulajdonosként kell csatlakoznia, és engedélyt kell adnia a Service Connector általi létrehozásra <aad-username> . A Service Connector által beállított kapcsolati szöveg vagy konfigurációs csoport felhasználónevének így kell kinéznie: aad_<connection name>. Ha az Azure Portalt használja, válassza ki a kibontás gombot az Service Type oszlop mellett, és kapja meg az értéket. Ha az Azure CLI-t használja, ellenőrizze a CLI-parancs kimenetét.

Ezután hajtsa végre a lekérdezést az engedély megadásához

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

A <owner-username> és <owner-password> a meglévő tábla tulajdonosai, akik engedélyeket adhatnak másoknak. <aad-username> a Service Connector által létrehozott felhasználó. Cserélje le őket a tényleges értékre.

Ellenőrizze az eredményt a következő paranccsal:

az postgres flexible-server execute -n <postgres-name> -u <owner-username> -p "<owner-password>" -d <database-name> --querytext "SELECT distinct(table_name) FROM information_schema.table_privileges WHERE grantee='<aad-username>' AND table_schema='public';" --output table

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

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

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

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

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

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

// do something

Adja hozzá a következő függőségeket a pom.xml fájlhoz:

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

Kérje le a kapcsolati sztring a környezeti változóból, és adja hozzá a beépülő modul nevét az adatbázishoz való csatlakozáshoz:

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

További információ: A Java és a JDBC használata rugalmas Azure Database for MySQL-kiszolgálóval.

Frissítse alkalmazását az „Azure Database for MySQL példány csatlakoztatása az alkalmazáshoz az Azure Spring Appsben” című oktatóanyagot követve. Ne felejtse el eltávolítani a spring.datasource.password konfigurációs tulajdonságot, ha korábban be lett állítva, és adja hozzá a megfelelő függőségeket a Spring-alkalmazáshoz.

További oktatóanyagok: A Spring Data JDBC használata az Azure Database for MySQL-hez

Függőségek telepítése

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

Hitelesítés hozzáférési jogkivonattal a kódtáron keresztül azure-identity , és kapcsolati információk lekérése a Service Connector által hozzáadott környezeti változóból. Az alábbi kód használatakor bontsa ki a kódrészlet azon részét, amely a használni kívánt hitelesítési típushoz tartozik.

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

Telepítse a függőségeket.
```
pip install azure-identity
```

Hozzáférési jogkivonat lekérése a azure-identity könyvtár segítségével, a Service Connector által hozzáadott környezeti változókkal. Az alábbi kód használatakor bontsa ki a kódrészlet azon részét, amely a használni kívánt hitelesítési típushoz tartozik.

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

A fájl beállításakor kérje le az Azure MySQL-adatbázis adatait a Service Connector szolgáltatás által hozzáadott környezeti változókból. Az adatbázis eléréséhez használja accessToken az előző lépésben beszerzett adatokat.

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

Telepítse a függőségeket.

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"

Kódban szerezze be a hozzáférési jogkivonatot, azidentitymajd csatlakozzon az Azure MySQL-hez a jogkivonattal. Az alábbi kód használatakor bontsa ki a kódrészlet azon részét, amely a használni kívánt hitelesítési típushoz tartozik.

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

Függőségek telepítése

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

A hozzáférési kód lekérése a Service Connector szolgáltatás által hozzáadott környezeti változókban található @azure/identity és Azure MySQL-adatbázis információk segítségével. Az alábbi kód használatakor bontsa ki a kódrészlet azon részét, amely a használni kívánt hitelesítési típushoz tartozik.

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

További kódmintákért lásd: Csatlakozás azure-adatbázisokhoz az App Service-ből titkos kódok nélkül felügyelt identitás használatával.

Telepítse a függőségeket.

dotnet add package Microsoft.Data.SqlClient

Szerezze be az Azure SQL Database kapcsolati sztringet a Service Connector által hozzáadott környezeti változóból.
```
using Microsoft.Data.SqlClient;

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

using var connection = new SqlConnection(connectionString);
connection.Open();
```
További információ: Az Active Directory felügyelt identitás hitelesítésének használata.

Adja hozzá a következő függőségeket a pom.xml fájlhoz:

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

Szerezze be az Azure SQL Database kapcsolati sztringet a Service Connector által hozzáadott környezeti változóból.

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

További információ: Csatlakozás azure-adatbázisokhoz az App Service-ből titkos kulcsok nélkül felügyelt identitás használatával.

Spring-alkalmazások esetén, ha egy opcióval --client-type springboot hoz létre kapcsolatot, a Service Connector az Azure Spring Apps számára a tulajdonságokat spring.datasource.url érték formátummal jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI;-ra állítja be.

Frissítse az alkalmazást a Java-alkalmazások áttelepítése jelszó nélküli kapcsolatok használatára az Azure SQL Database-lel című oktatóanyagot követve. Ne felejtse el eltávolítani a spring.datasource.password konfigurációs tulajdonságot, ha korábban be lett állítva, és adja hozzá a megfelelő függőségeket.

Telepítse a függőségeket.

python -m pip install mssql-python python-dotenv

Kérje le az Azure SQL Database kapcsolatkonfigurációit a Service Connector által hozzáadott környezeti változóból. Az alábbi kód használatakor bontsa ki a kódrészlet azon részét, amely a használni kívánt hitelesítési típushoz tartozik.

import os
from mssql_python import connect

server = os.getenv('AZURE_SQL_SERVER')
port = os.getenv('AZURE_SQL_PORT')
database = os.getenv('AZURE_SQL_DATABASE')

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned managed identity.
# connection_string = f'Server={server},{port};Database={database};Authentication=ActiveDirectoryMSI;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

# For user-assigned managed identity.
# client_id = os.getenv('AZURE_SQL_USER')
# connection_string = f'Server={server},{port};Database={database};UID={client_id};Authentication=ActiveDirectoryMSI;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

# For service principal.
# user = os.getenv('AZURE_SQL_USER')
# password = os.getenv('AZURE_SQL_PASSWORD')
# connection_string = f'Server={server},{port};Database={database};UID={user};PWD={password};Authentication=ActiveDirectoryServicePrincipal;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

conn = connect(connection_string)

Telepítse a függőségeket.
```
npm install mssql
```

Kérje le az Azure SQL Database kapcsolatkonfigurációit a Service Connector által hozzáadott környezeti változókból. Az alábbi kód használatakor bontsa ki a kódrészlet azon részét, amely a használni kívánt hitelesítési típushoz tartozik.

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

További információ: Kezdőlap a Microsoft SQL Server ügyfélprogramozásához.

Telepítse a függőségeket.

dotnet add package Microsoft.Data.SqlClient

Kérje le az SQL-adatbázist a Microsoft Fabric kapcsolati sztringjében a Service Connector által hozzáadott környezeti változóból.
```
using Microsoft.Data.SqlClient;

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

using var connection = new SqlConnection(connectionString);
connection.Open();
```
További információ: Active Directory által felügyelt identitáshitelesítés használata.

Adja hozzá a következő függőségeket a pom.xml fájlhoz:

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

Kérje le az SQL-adatbázist a Microsoft Fabric kapcsolati sztringjében a Service Connector által hozzáadott környezeti változóból.

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

További információ: Csatlakozás azure-adatbázisokhoz az App Service-ből titkos kulcsok nélkül felügyelt identitás használatával.

Spring alkalmazás esetében, ha létrehoz egy kapcsolatot a --client-type springboot lehetőséggel, a Service Connector az FABRIC_SQL_CONNECTIONSTRING környezeti változót az jdbc:sqlserver://<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;databaseName=<SQL-DB-name>-<Fabric-DB-Identifier>;authentication=ActiveDirectoryMSI; értékformátummal állítja be az Azure Spring Apps számára.

A felhasználó által hozzárendelt felügyelt identitásokhoz msiClientId=<msiClientId>; hozzáadásra kerül.

spring:
  datasource:
    url: ${FABRIC_SQL_CONNECTIONSTRING}

Telepítse a függőségeket.

python -m pip install mssql-python python-dotenv

Kérje le az SQL-adatbázist a Microsoft Fabric kapcsolati sztringjében a Service Connector által hozzáadott környezeti változóból. Authentication=ActiveDirectoryMSI; a kapcsolati sztringben a felügyelt identitások használatával való csatlakozáshoz szükséges. UID=<msiClientId> A kapcsolati sztringben a felhasználó által hozzárendelt felügyelt identitással való csatlakozáskor is szükség van rá.

import os
from mssql_python import connect

connection_string = os.getenv('FABRIC_SQL_CONNECTIONSTRING')

# System-assigned managed identity connection string format
# `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
# `Server=tcp:<Fabric-SQL-Identifier>.msit-database.fabric.microsoft.com,1433;Database=<SQL-DB-name>-<Fabric-DB-Identifier>;UID=<msiClientId>;Authentication=ActiveDirectoryMSI;`

conn = connect(connection_string)

Telepítse a függőségeket.

go mod init <YourProjectName>
go mod tidy

Kérje le az SQL-adatbázist a Microsoft Fabric kapcsolati sztringjében a Service Connector által hozzáadott környezeti változóból.

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

További információ: Adatbázis lekérdezése az Azure SQL Database-ben a Golang használatával.

További információ: Csatlakozás az SQL-adatbázishoz a Microsoft Fabricben.

Az alkalmazás üzembe helyezése az Azure üzemeltetési szolgáltatásra

Helyezze üzembe az alkalmazást egy Azure-beli üzemeltetési szolgáltatásban. Az erőforrások telepítésével kapcsolatos további információkért tekintse meg az alábbi útmutatókat.
- Azure App Service: Rövid útmutató: ASP.NET webalkalmazás üzembe helyezése.
- Azure Container Apps: Rövid útmutató: Az első tárolóalkalmazás üzembe helyezése.
- Azure Spring Apps: Az alkalmazás létrehozása és üzembe helyezése.
  
  Megjegyzés:
  
  Az Alapszintű, Standard és Nagyvállalati csomagok 2025. március 17-én léptek nyugdíjba. További információkért lásd az Azure Spring Apps kivonási bejelentését.
Ellenőrizze a naplót, vagy hívja fel az alkalmazást, és ellenőrizze, hogy sikeresen tud-e csatlakozni az Azure-adatbázishoz.

Hibaelhárítás

Engedélyek

Ha bármilyen engedélyekkel kapcsolatos hibát tapasztal, erősítse meg az Azure CLI bejelentkezett felhasználót a paranccsal az account show. Győződjön meg arról, hogy a megfelelő fiókkal jelentkezik be. Ezután győződjön meg arról, hogy rendelkezik az alábbi engedélyekkel, amelyek szükségesek lehetnek a Service Connectorhoz való jelszó nélküli kapcsolat létrehozásához.

Engedély	Művelet
`Microsoft.DBforPostgreSQL/flexibleServers/read`	Az adatbázis-kiszolgáló adatainak lekéréséhez szükséges
`Microsoft.DBforPostgreSQL/flexibleServers/write`	A Microsoft Entra-hitelesítés adatbázis-kiszolgálóhoz való engedélyezéséhez szükséges
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write`	Tűzfalszabály létrehozásához szükséges, ha a helyi IP-cím le van tiltva
`Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete`	A biztonsági probléma elkerülése érdekében a Service Connector által létrehozott tűzfalszabály visszaállításához szükséges
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/read`	Annak ellenőrzéséhez szükséges, hogy az Azure CLI bejelentkezési felhasználója adatbázis-kiszolgáló Microsoft Entra-rendszergazda-e
`Microsoft.DBforPostgreSQL/flexibleServers/administrators/write`	Számít, hogy az Azure CLI bejelentkezési felhasználót hozzáadja az adatbázis-kiszolgálóhoz Microsoft Entra rendszergazdaként.

Engedély	Művelet
`Microsoft.DBforMySQL/flexibleServers/read`	Az adatbázis-kiszolgáló adatainak lekéréséhez szükséges
`Microsoft.DBforMySQL/flexibleServers/write`	A megadott felhasználó által hozzárendelt felügyelt identitás adatbázis-kiszolgálóhoz való hozzáadásához szükséges
`Microsoft.DBforMySQL/flexibleServers/firewallRules/write`	Tűzfalszabály létrehozásához szükséges, ha a helyi IP-cím le van tiltva
`Microsoft.DBforMySQL/flexibleServers/firewallRules/delete`	A biztonsági probléma elkerülése érdekében a Service Connector által létrehozott tűzfalszabály visszaállításához szükséges
`Microsoft.DBforMySQL/flexibleServers/administrators/read`	Annak ellenőrzéséhez szükséges, hogy az Azure CLI bejelentkezési felhasználója adatbázis-kiszolgáló Microsoft Entra-rendszergazda-e
`Microsoft.DBforMySQL/flexibleServers/administrators/write`	Számít, hogy az Azure CLI bejelentkezési felhasználót hozzáadja az adatbázis-kiszolgálóhoz Microsoft Entra rendszergazdaként.

Engedély	Művelet
`Microsoft.Sql/servers/read`	Az adatbázis-kiszolgáló adatainak lekéréséhez szükséges
`Microsoft.Sql/servers/firewallRules/write`	Tűzfalszabály létrehozásához szükséges, ha a helyi IP-cím le van tiltva
`Microsoft.Sql/servers/firewallRules/delete`	A biztonsági probléma elkerülése érdekében a Service Connector által létrehozott tűzfalszabály visszaállításához szükséges
`Microsoft.Sql/servers/administrators/read`	Annak ellenőrzéséhez szükséges, hogy az Azure CLI bejelentkezési felhasználója adatbázis-kiszolgáló Microsoft Entra-rendszergazda-e
`Microsoft.Sql/servers/administrators/write`	Számít, hogy az Azure CLI bejelentkezési felhasználót hozzáadja az adatbázis-kiszolgálóhoz Microsoft Entra rendszergazdaként.

Bizonyos esetekben az engedélyek nem szükségesek. Ha például az Azure CLI által hitelesített felhasználó már Active Directory-rendszergazda az SQL Serveren, akkor nincs szükség az Microsoft.Sql/servers/administrators/write engedélyre.

Microsoft Entra ID

Ha hibaüzenetet ERROR: AADSTS530003: Your device is required to be managed to access this resource.kap, kérjen segítséget az informatikai részlegtől az eszköz Microsoft Entra-azonosítóhoz való csatlakoztatásához. További információ: Microsoft Entra csatlakoztatott eszközök.

A Service Connectornak hozzá kell férnie a Microsoft Entra-azonosítóhoz a fiók adatainak és az üzemeltetési szolgáltatás felügyelt identitásának lekéréséhez. Az alábbi paranccsal ellenőrizheti, hogy az eszköz hozzáfér-e a Microsoft Entra-azonosítóhoz:

az ad signed-in-user show

Ha nem jelentkezik be interaktívan, előfordulhat, hogy szintén hibába ütközik, és Interactive authentication is neededa. A hiba elhárításához jelentkezzen be a az login paranccsal.

Hálózati kapcsolat

Ha az adatbázis-kiszolgáló virtuális hálózaton található, győződjön meg arról, hogy az Azure CLI-parancsot futtató környezet hozzáfér a kiszolgálóhoz a virtuális hálózaton.

Ha az adatbázis-kiszolgáló nem engedélyezi a nyilvános hozzáférést, győződjön meg arról, hogy az Azure CLI-parancsot futtató környezet a privát végponton keresztül férhet hozzá a kiszolgálóhoz.

Következő lépések

A Szolgáltatás-összekötőről és a jelszó nélküli kapcsolatokról a következő forrásokban talál további információt:

Service Connector dokumentáció

Jelszó nélküli kapcsolatok az Azure-szolgáltatásokhoz

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-09-29

Oktatóanyag: Jelszó nélküli kapcsolat létrehozása adatbázis-szolgáltatással a Service Connectoron keresztül

Előfeltételek

A Service Connector jelszó nélküli bővítményének telepítése

Jelszó nélküli kapcsolat létrehozása

Csatlakozás adatbázishoz Microsoft Entra-hitelesítéssel

Az alkalmazás üzembe helyezése az Azure üzemeltetési szolgáltatásra

Hibaelhárítás

Engedélyek

Microsoft Entra ID

Hálózati kapcsolat

Következő lépések

Visszajelzés

További források