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

Cikk
05/30/2024

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 titkos kulcsát. Ezeket a feladatokat az Azure belsőleg kezeli biztonságosan.

A service Csatlakozás or lehetővé teszi a felügyelt identitásokat az olyan alkalmazás-üzemeltetési szolgáltatásokban, mint az Azure Spring Apps, a Azure-alkalmazás Service és az Azure Container Apps. A Service Csatlakozás or emellett konfigurálja az adatbázis-szolgáltatásokat, például az Azure Database for PostgreSQL-t, az Azure Database for MySQL-t és az Azure SQL Database-t 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 Csatlakozás or használatával.
Használja a Service Csatlakozás or á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

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

Saját környezet beállítása

Számla

Jelentkezzen be az Azure CLI-vel a következővel: az login. Ha az Azure Cloud Shellt használja, vagy már bejelentkezett, erősítse meg hitelesített fiókját a következővel az account show: .

A Service Csatlakozás or jelszó nélküli bővítmény telepítése

Telepítse a legújabb service Csatlakozás or jelszó nélküli bővítményt az Azure CLI-hez:

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

Feljegyzés

Futtassa a "serviceconnector-passwordless" bővítmény "2.0.2" vagy újabb az versionverzióját. 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

A következő lépésben a Azure-alkalmazás Szolgáltatást 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élda: Csatlakozás Azure Spring Apps az Azure-adatbázisba.
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.

Feljegyzés

Ha az Azure Portalt használja, lépjen Azure-alkalmazás Szolgáltatás, Azure Spring Apps vagy Azure Container Apps Szolgáltatás Csatlakozás or 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ó: Microsoft Entra-hitelesítés beállítása rugalmas Azure Database for MySQL-kiszolgálóhoz. A következő paranccsal hozhat létre felhasználó által hozzárendelt felügyelt identitást:

USER_IDENTITY_NAME=<YOUR_USER_ASSIGNED_MANAGEMED_IDENTITY_NAME>
IDENTITY_RESOURCE_ID=$(az identity create \
    --name $USER_IDENTITY_NAME \
    --resource-group $RESOURCE_GROUP \
    --query id \
    --output tsv)

Fontos

A felhasználó által hozzárendelt felügyelt identitás létrehozása után kérje meg a globális Rendszergazda istratort vagy a Privileged Role Rendszergazda istratort, 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 Csatlakozás or 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 támogatott ügyféltípusokat, és válassza ki az alkalmazásnak 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 támogatott ügyféltípusokat, és válassza ki az alkalmazásnak 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

Ez a Szolgáltatás Csatlakozás or 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 a Azure-alkalmazás 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ő parancskimenet kapcsolati sztring található.
Állítsa be a névvel ellátott AZURE_MYSQL_CONNECTIONSTRINGAZURE_POSTGRESQL_CONNECTIONSTRINGkonfigurációkat vagy AZURE_SQL_CONNECTIONSTRING az Azure-erőforrást az adatbázis típusa alapján.
- Az App Service esetében a konfigurációk az App Gépház 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 azok értékeit az Azure Portal Szolgáltatás Csatlakozás or paneljén szerezheti be.

A Service Csatlakozás or 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";

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

A kapcsolat létrehozása után az alkalmazásban található kapcsolati sztring használatával 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 according to the authentication type.
// For system-assigned identity.
// var sqlServerTokenProvider = new DefaultAzureCredential();

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

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

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

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

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

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

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.3.6</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-extensions</artifactId>
    <version>1.1.5</version>
</dependency>

Kérje le a kapcsolati sztring 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ókat találhat az alábbi forrásokban:

Spring-alkalmazások esetén, ha a beállítással --client-type springboothoz létre kapcsolatot, a Service Csatlakozás or beállítja a tulajdonságokatspring.datasource.azure.passwordless-enabled, spring.datasource.urlés spring.datasource.username az Azure Spring Appshez.

Frissítse az alkalmazást az oktatóanyagot követve, amely az Azure Database for PostgreSQL-et köti az alkalmazáshoz az Azure Spring Appsben. 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 Csatlakozás or á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 according to the authentication type.
# For system-assigned identity.
# cred = DefaultAzureCredential()

# For user-assigned identity.
# managed_identity_client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
# cred = ManagedIdentityCredential(client_id=managed_identity_client_id)   

# For service principal.
# tenant_id = os.getenv('AZURE_POSTGRESQL_TENANTID')
# client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
# client_secret = os.getenv('AZURE_POSTGRESQL_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

# Acquire the access token
accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')

# Combine the token with the connection string from the environment variables added by Service Connector to establish the connection.
conn_string = os.getenv('AZURE_POSTGRESQL_CONNECTIONSTRING')
conn = psycopg2.connect(conn_string + ' password=' + accessToken.token)

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

Hozzáférési jogkivonat lekérése kódtár használatával azure-identity a Service Csatlakozás or által hozzáadott környezeti változók használatával. 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 according to the authentication type.
# For system-assigned identity.
# credential = DefaultAzureCredential()

# For user-assigned identity.
# managed_identity_client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
# cred = ManagedIdentityCredential(client_id=managed_identity_client_id)    

# For service principal.
# tenant_id = os.getenv('AZURE_POSTGRESQL_TENANTID')
# client_id = os.getenv('AZURE_POSTGRESQL_CLIENTID')
# client_secret = os.getenv('AZURE_POSTGRESQL_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

# Acquire the access token.
accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')

A fájl beállításakor kérje le az Azure PostgreSQL-adatbázis adatait a Service Csatlakozás or 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"

Kódban szerezze be a hozzáférési jogkivonatot az Azure PostgreSQL-hez azidentityvaló csatlakozáshoz jelszóként a Service Csatlakozás or által megadott kapcsolati adatokkal együtt. 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 according to the authentication type.
// For system-assigned identity.
// cred, err := azidentity.NewDefaultAzureCredential(nil)

// For user-assigned identity.
// clientid := os.Getenv("AZURE_POSTGRESQL_CLIENTID")
// azidentity.ManagedIdentityCredentialOptions.ID := clientid
// options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
// cred, err := azidentity.NewManagedIdentityCredential(options)

// For service principal.
// clientid := os.Getenv("AZURE_POSTGRESQL_CLIENTID")
// tenantid := os.Getenv("AZURE_POSTGRESQL_TENANTID")
// clientsecret := os.Getenv("AZURE_POSTGRESQL_CLIENTSECRET")
// cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})

if err != nil {
    // error handling
}

// Acquire the access token
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
    Scopes: []string("https://ossrdbms-aad.database.windows.net/.default"),
})

// Combine the token with the connection string from the environment variables added by Service Connector to establish the connection.
connectionString := os.Getenv("AZURE_POSTGRESQL_CONNECTIONSTRING") + " password=" + token.Token

conn, err := sql.Open("postgres", connectionString)
 if err != nil {
 	panic(err)
 }

 conn.Close()

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 @azure/identity a Service Csatlakozás or szolgáltatás által hozzáadott környezeti változókból és PostgreSQL-kapcsolati információkból. Egyesítse ő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";
const { Client } = require('pg');

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

// For user-assigned identity.
// const clientId = process.env.AZURE_POSTGRESQL_CLIENTID;
// const credential = new DefaultAzureCredential({
//     managedIdentityClientId: clientId
// });

// For service principal.
// const tenantId = process.env.AZURE_POSTGRESQL_TENANTID;
// const clientId = process.env.AZURE_POSTGRESQL_CLIENTID;
// const clientSecret = process.env.AZURE_POSTGRESQL_CLIENTSECRET;

// Acquire the access token.
var accessToken = await credential.getToken('https://ossrdbms-aad.database.windows.net/.default');

// Use the token and the connection information from the environment variables added by Service Connector to establish the connection.
(async () => {
const client = new Client({
    host: process.env.AZURE_POSTGRESQL_HOST,
    user: process.env.AZURE_POSTGRESQL_USER,
    password: accesstoken.token,
    database: process.env.AZURE_POSTGRESQL_DATABASE,
    port: Number(process.env.AZURE_POSTGRESQL_PORT) ,
    ssl: process.env.AZURE_POSTGRESQL_SSL
});
await client.connect();

await client.end();
})();

PHP 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ódban kérje le a hozzáférési jogkivonatot a REST API-val a kedvenc kódtárával.

A felhasználó által hozzárendelt identitás és a rendszer által hozzárendelt identitás esetében az App Service és a 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 lekéréséhez http GET kérést kell küldenie az identitásvégponthoz, és a lekérdezéshez hasonlóan resource kell használniahttps://ossrdbms-aad.database.windows.net. A felhasználó által hozzárendelt identitáshoz adja meg a Service Csatlakozás or által hozzáadott környezeti változók ügyfél-azonosítóját is a lekérdezésben.

Szolgáltatásnév esetén tekintse meg az Azure AD szolgáltatás–szolgáltatás hozzáférési jogkivonat-kérését , és tekintse meg a hozzáférési jogkivonat beszerzésének részleteit. Kérje meg a POST-kérést a szolgáltatásnév bérlőazonosítójávalhttps://ossrdbms-aad.database.windows.net/.default, ügyfélazonosítójával és ügyféltitkával a Service Csatlakozás or által hozzáadott környezeti változókból.
A kapcsolat létrehozásához kombinálja a hozzáférési jogkivonatot és a PostgreSQL-kapcsolatot a Service Csatlakozás or szolgáltatás által hozzáadott környezeti változókból.
```
<?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 Csatlakozás or szolgáltatás által hozzáadott környezeti változókból. Egyesítse ő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 App Service és a 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 according to the authentication type.
# For system-assigned identity.
# uri = URI(ENV['IDENTITY_ENDPOINT'] + '?resource=https://ossrdbms-aad.database.windows.net&api-version=2019-08-01')
# res = Net::HTTP.get_response(uri, {'X-IDENTITY-HEADER' => ENV['IDENTITY_HEADER'], 'Metadata' => 'true'})  

# For user-assigned identity.
# uri = URI(ENV[IDENTITY_ENDPOINT] + '?resource=https://ossrdbms-aad.database.windows.net&api-version=2019-08-01&client-id=' + ENV['AZURE_POSTGRESQL_CLIENTID'])
# res = Net::HTTP.get_response(uri, {'X-IDENTITY-HEADER' => ENV['IDENTITY_HEADER'], 'Metadata' => 'true'})  

# For service principal
# uri = URI('https://login.microsoftonline.com/' + ENV['AZURE_POSTGRESQL_TENANTID'] + '/oauth2/v2.0/token')
# params = {
#     :grant_type => 'client_credentials',
#     :client_id: => ENV['AZURE_POSTGRESQL_CLIENTID'],
#     :client_secret => ENV['AZURE_POSTGRESQL_CLIENTSECRET'],
#     :scope => 'https://ossrdbms-aad.database.windows.net/.default'
# }
# req = Net::HTTP::POST.new(uri)
# req.set_form_data(params)
# req['Content-Type'] = 'application/x-www-form-urlencoded'
# res = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|
#   http.request(req)

parsed = JSON.parse(res.body)
access_token = parsed["access_token"]

# Use the token and the connection string from the environment variables added by Service Connector to establish the connection.
conn = PG::Connection.new(
    connection_string: ENV['AZURE_POSTGRESQL_CONNECTIONSTRING'] + " password="  + access_token,
)

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 Csatlakozás or használata előtt táblákat és sorozatokat hozott létre a Rugalmas PostgreSQL-kiszolgálón, tulajdonosként kell csatlakoznia, és engedélyt kell adnia a Service Csatlakozás or általi létrehozásra<aad-username>. A Service Csatlakozás or által beállított kapcsolati sztring vagy konfigurációból származó felhasználónévnek így kell kinéznieaad_<connection name>. Ha az Azure Portalt használja, válassza az oszlop melletti Service Type kibontás gombot, és kérje le az értéket. Ha az Azure CLI-t használja, ellenőrizze configurations a PARANCSSOR 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> meglévő tábla tulajdonosa, <owner-password> amely engedélyeket adhat másoknak. <aad-username>a Service Csatlakozás or á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 according to the authentication type.
// For system-assigned managed identity.
// var credential = new DefaultAzureCredential();

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

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

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

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

// do something

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.30</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-extensions</artifactId>
    <version>1.1.5</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";
Connection connection = DriverManager.getConnection(url + "&defaultAuthenticationPlugin=" +
    pluginName + "&authenticationPlugins=" + pluginName);

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

Frissítse az alkalmazást az oktatóanyagot követően, Csatlakozás egy Azure Database for MySQL-példányt az alkalmazáshoz az Azure Spring Appsben. 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ülazure-identity, és kapcsolati információk lekérése a Service Csatlakozás or á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 according to the authentication type.
# For system-assigned managed identity.
# cred = ManagedIdentityCredential()    

# For user-assigned managed identity.
# managed_identity_client_id = os.getenv('AZURE_MYSQL_CLIENTID')
# cred = ManagedIdentityCredential(client_id=managed_identity_client_id)

# For service principal
# tenant_id = os.getenv('AZURE_MYSQL_TENANTID')
# client_id = os.getenv('AZURE_MYSQL_CLIENTID')
# client_secret = os.getenv('AZURE_MYSQL_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

# acquire token
accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')

# open connect to Azure MySQL with the access token.
host = os.getenv('AZURE_MYSQL_HOST')
database = os.getenv('AZURE_MYSQL_NAME')
user = os.getenv('AZURE_MYSQL_USER')
password = accessToken.token

cnx = mysql.connector.connect(user=user,
                              password=password,
                              host=host,
                              database=database)
cnx.close()

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

Hozzáférési jogkivonat lekérése kódtáron keresztül azure-identity a Service Csatlakozás or á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 according to the authentication type.
# system-assigned managed identity
# cred = ManagedIdentityCredential()

# user-assigned managed identity
# managed_identity_client_id = os.getenv('AZURE_MYSQL_CLIENTID')
# cred = ManagedIdentityCredential(client_id=managed_identity_client_id)

# service principal
# tenant_id = os.getenv('AZURE_MYSQL_TENANTID')
# client_id = os.getenv('AZURE_MYSQL_CLIENTID')
# client_secret = os.getenv('AZURE_MYSQL_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

# acquire token
accessToken = cred.get_token('https://ossrdbms-aad.database.windows.net/.default')

A fájl beállításakor kérje le az Azure MySQL-adatbázis adatait a Service Csatlakozás or 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 according to the authentication type.
  // for system-assigned managed identity
  // cred, err := azidentity.NewDefaultAzureCredential(nil)

  // for user-assigned managed identity
  // clientid := os.Getenv("AZURE_MYSQL_CLIENTID")
  // azidentity.ManagedIdentityCredentialOptions.ID := clientid
  // options := &azidentity.ManagedIdentityCredentialOptions{ID: clientid}
  // cred, err := azidentity.NewManagedIdentityCredential(options)

  // for service principal
  // clientid := os.Getenv("AZURE_MYSQL_CLIENTID")
  // tenantid := os.Getenv("AZURE_MYSQL_TENANTID")
  // clientsecret := os.Getenv("AZURE_MYSQL_CLIENTSECRET")
  // cred, err := azidentity.NewClientSecretCredential(tenantid, clientid, clientsecret, &azidentity.ClientSecretCredentialOptions{})

  if err != nil {
  }

  ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
  token, err := cred.GetToken(ctx, policy.TokenRequestOptions{
    Scopes: []string("https://ossrdbms-aad.database.windows.net/.default"),
  })

  connectionString := os.Getenv("AZURE_MYSQL_CONNECTIONSTRING") + ";Password=" + token.Token
  db, err := sql.Open("mysql", connectionString)
}

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

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

Hozzáférési jogkivonat és @azure/identity Azure MySQL-adatbázis adatainak lekérése a Service Csatlakozás or szolgáltatás á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 { DefaultAzureCredential,ClientSecretCredential } from "@azure/identity";

const mysql = require('mysql2');

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

// for user-assigned managed identity
// const clientId = process.env.AZURE_MYSQL_CLIENTID;
// const credential = new DefaultAzureCredential({
//    managedIdentityClientId: clientId
// });

// for service principal
// const tenantId = process.env.AZURE_MYSQL_TENANTID;
// const clientId = process.env.AZURE_MYSQL_CLIENTID;
// const clientSecret = process.env.AZURE_MYSQL_CLIENTSECRET;
// const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);

// acquire token
var accessToken = await credential.getToken('https://ossrdbms-aad.database.windows.net/.default');

const connection = mysql.createConnection({
  host: process.env.AZURE_MYSQL_HOST,
  user: process.env.AZURE_MYSQL_USER,
  password: accessToken.token,
  database: process.env.AZURE_MYSQL_DATABASE,
  port: process.env.AZURE_MYSQL_PORT,
  ssl: process.env.AZURE_MYSQL_SSL
});

connection.connect((err) => {
  if (err) {
    console.error('Error connecting to MySQL database: ' + err.stack);
    return;
  }
  console.log('Connected to MySQL database');
});

További kódmintákért lásd: Csatlakozás azure-adatbázisokba 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

Kérje le az Azure SQL Database kapcsolati sztring a Service Csatlakozás or á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>

Kérje le az Azure SQL Database kapcsolati sztring a Service Csatlakozás or á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ázisokba az App Service-ből titkos kódok nélkül, felügyelt identitás használatával.

Spring-alkalmazások esetén, ha egy beállítással --client-type springboothoz létre kapcsolatot, a Service Csatlakozás or értékformátummal jdbc:sqlserver://<sql-server>.database.windows.net:1433;databaseName=<sql-db>;authentication=ActiveDirectoryMSI; állítja be a tulajdonságokat spring.datasource.url az Azure Spring Appsre.

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

Kérje le az Azure SQL Database kapcsolatkonfigurációit a Service Csatlakozás or á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. Ha számítási szolgáltatásként használja az Azure Container Appst, vagy a kódrészlet kapcsolati sztring nem működik, tekintse meg a Python-alkalmazás migrálását, amely jelszó nélküli kapcsolatokat használ az Azure SQL Database-zel az Azure SQL Database-hez való csatlakozáshoz hozzáférési jogkivonat használatával.

import os
import pyodbc

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

# Uncomment the following lines according to the authentication type.
# For system-assigned managed identity.
# connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server=tcp:{server},{port};Database={database};Authentication={authentication};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

# For user-assigned managed identity.
# clientID = os.getenv('AZURE_SQL_USER')
# connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server=tcp:{server},{port};Database={database};UID={clientID};Authentication={authentication};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

# For service principal.
# user = os.getenv('AZURE_SQL_USER')
# password = os.getenv('AZURE_SQL_PASSWORD')
# connString = f'Driver={{ODBC Driver 18 for SQL Server}};Server=tcp:{server},{port};Database={database};UID={user};PWD={password};Authentication={authentication};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

conn = pyodbc.connect(connString)

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

Kérje le az Azure SQL Database kapcsolatkonfigurációit a Service Csatlakozás or á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 according to the authentication type.
// For system-assigned managed identity.
// const config = {
//     server,
//     port,
//     database,
//     authentication: {
//         type: authenticationType
//     },
//     options: {
//        encrypt: true
//     }
// };  

// For user-assigned managed identity.
// const clientId = process.env.AZURE_SQL_CLIENTID;
// const config = {
//     server,
//     port,
//     database,
//     authentication: {
//         type: authenticationType
//     },
//     options: {
//         encrypt: true,
//         clientId: clientId
//     }
// };  

// For service principal.
// const clientId = process.env.AZURE_SQL_CLIENTID;
// const clientSecret = process.env.AZURE_SQL_CLIENTSECRET;
// const tenantId = process.env.AZURE_SQL_TENANTID;
// const config = {
//     server,
//     port,
//     database,
//     authentication: {
//         type: authenticationType
//     },
//     options: {
//         encrypt: true,
//         clientId: clientId,
//         clientSecret: clientSecret,
//         tenantId: tenantId
//     }
// };  

this.poolconnection = await sql.connect(config);

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

Az alkalmazás üzembe helyezése azure-beli üzemeltetési szolgáltatásban

Végül helyezze üzembe az alkalmazást egy Azure-beli üzemeltetési szolgáltatásban. Ez a forrásszolgáltatás egy felügyelt identitással csatlakozhat a céladatbázishoz az Azure-ban.

A Azure-alkalmazás Szolgáltatás esetében ellenőrizheti a dokumentumot a telepítés módjának kiválasztásához: Rövid útmutató: ASP.NET-webalkalmazás üzembe helyezése.

Ezután ellenőrizheti a naplót, vagy meghívhatja az alkalmazást, hogy ellenőrizze, sikeresen tud-e csatlakozni az Azure-adatbázishoz.

Hibaelhárítás

Engedély

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 a következő engedélyekkel, amelyek szükségesek lehetnek egy jelszó nélküli kapcsolat létrehozásához a Service Csatlakozás or használatával.

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 Csatlakozás or á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`	Azure CLI bejelentkezési felhasználó hozzáadása adatbázis-kiszolgálóként 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 Csatlakozás or á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`	Azure CLI bejelentkezési felhasználó hozzáadása adatbázis-kiszolgálóként 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 Csatlakozás or á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`	Azure CLI bejelentkezési felhasználó hozzáadása adatbázis-kiszolgálóként 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 istrator az SQL Serveren, 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 szolgáltatás Csatlakozás ornak hozzá kell férnie a Microsoft Entra-azonosítóhoz, hogy információkat kapjon a fiókjáról és a szolgáltatás felügyelt identitásáról. 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 a hiba é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 Csatlakozás orról és a jelszó nélküli kapcsolatokról a következő forrásokban talál további információt:

Szolgáltatás Csatlakozás or dokumentációja

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

Megosztás a következőn keresztül:

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

Előfeltételek

Saját környezet beállítása

Számla

A Service Csatlakozás or jelszó nélküli bővítmény telepítése

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

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

Az alkalmazás üzembe helyezése azure-beli üzemeltetési szolgáltatásban

Hibaelhárítás

Engedély

Microsoft Entra ID

Hálózati kapcsolat

Következő lépések

Visszajelzés

Visszajelzés

További források