Dotyczy:
SQL Server 2022 (16.x)
W tym artykule omówimy sposób konfigurowania administratora firmy Microsoft Entra w celu zezwolenia na uwierzytelnianie przy użyciu identyfikatora Entra firmy Microsoft (dawniej Azure Active Directory) dla programu SQL Server przy użyciu witryny Azure Portal i interfejsów API, takich jak:
- PowerShell
- Azure CLI
- Szablon ARM
Omówimy również zaktualizowane funkcje konfigurowania administratora usługi Microsoft Entra dla programu SQL Server w witrynie Azure Portal, które umożliwiłyby automatyczne tworzenie certyfikatów i rejestrację aplikacji. Wcześniej skonfigurowanie uwierzytelniania Microsoft Entra dla SQL Server wymagało ręcznej konfiguracji administratora Microsoft Entra za pomocą certyfikatu platformy Azure oraz rejestracji aplikacji.
Uwaga
Chociaż identyfikator Entra firmy Microsoft to nowa nazwa usługi Azure Active Directory (Azure AD), aby zapobiec zakłócaniu działania istniejących środowisk, usługa Azure AD nadal pozostaje w niektórych zakodowanych na stałe elementach, takich jak pola interfejsu użytkownika, dostawcy połączeń, kody błędów i polecenia cmdlet. W tym artykule dwie nazwy są wymienne.
Wymagania wstępne
Przygotowanie przed ustawieniem administratora firmy Microsoft Entra
Następujące uprawnienia są niezbędne do skonfigurowania administratora firmy Microsoft Entra w zasobach programu SQL Server — Azure Arc i Key Vault .
Postępuj zgodnie z przewodnikiem, aby upewnić się, że program SQL Server jest połączony z usługą Azure Arc. Użytkownik konfigurujący administratora Microsoft Entra dla programu SQL Server — zasób usługi Azure Arc powinien mieć rolę Współtwórca dla serwera.
- Przejdź do witryny Azure Portal.
- Wybierz SQL Server — Azure Arc i wybierz instancję dla swojego hosta SQL Server.
- Wybierz pozycję Kontrola dostępu (IAM).
- Wybierz Dodaj>Dodaj przypisanie roli, aby dodać rolę Współpracownik użytkownikowi konfigurującemu administratora Microsoft Entra.
Utwórz usługę Azure Key Vault , jeśli jeszcze jej nie masz. Użytkownik konfigurujący administratora Microsoft Entra powinien mieć rolę Współpracownik dla usługi Azure Key Vault. Aby dodać rolę do użytkownika w usłudze Azure Key Vault:
- Przejdź do witryny Azure Portal.
- Przejdź do zasobu magazynu kluczy.
- Wybierz pozycję Kontrola dostępu (IAM).
- Wybierz pozycję Dodaj>Dodaj przypisanie roli, aby dodać rolę Współautor użytkownikowi konfigurującemu rolę administratora Microsoft Entra.
Ustawianie zasad dostępu dla hosta programu SQL Server
W portalu Azure przejdź do instancji usługi Azure Key Vault i wybierz pozycję Zasady dostępu.
Wybierz opcję Dodaj zasady dostępu.
W obszarze Uprawnienia klucza użyj opcji Podpis.
W obszarze Uprawnienia tajne wybierz Pobierz i Lista.
W obszarze Uprawnienia certyfikatu wybierz pozycję Pobierz i Wyświetl.
Wybierz Dalej.
Na stronie Principal wyszukaj nazwę instancji Machine – Azure Arc, czyli nazwę hosta programu SQL Server.
Pomiń stronę Aplikacja (opcjonalnie), wybierając pozycję Dalej dwa razy lub wybierając pozycję Przejrzyj i utwórz.
Sprawdź, czy "Identyfikator obiektu" głównego podmiotu jest zgodny z identyfikatorem głównego podmiotu tożsamości zarządzanej przypisanej do wystąpienia.
Aby potwierdzić, przejdź do strony zasobów i wybierz pozycję Widok JSON w prawym górnym rogu sekcji Podstawowe elementy na stronie Przegląd. W obszarze tożsamość znajdziesz principalId.
Wybierz Utwórz.
Musisz wybrać Utwórz, aby upewnić się, że uprawnienia są stosowane. Aby upewnić się, że uprawnienia zostały zapisane, odśwież okno przeglądarki i sprawdź, czy wiersz wystąpienia usługi Azure Arc jest nadal obecny.
Ustawianie zasad dostępu dla użytkowników firmy Microsoft Entra
- W witrynie Azure Portal przejdź do wystąpienia usługi Azure Key Vault i wybierz pozycję Zasady dostępu.
- Wybierz opcję Dodaj zasady dostępu.
- W obszarze Uprawnienia klucza wybierz pozycję Pobierz, Wyświetl i Utwórz.
- W obszarze Uprawnienia wpisu tajnego wybierz pozycję Pobierz, Lista i Ustaw.
- W obszarze Uprawnienia certyfikatu wybierz pozycję Pobierz, Wyświetl i Utwórz.
- W polu Wybierz podmiot zabezpieczeń dodaj użytkownika Microsoft Entra, którego chcesz użyć do nawiązania połączenia z programem SQL Server.
- Wybierz pozycję Dodaj , a następnie wybierz pozycję Zapisz.
Konfigurowanie administratora usługi Microsoft Entra dla programu SQL Server
Nowe interfejsy API i funkcje portalu umożliwiają użytkownikom skonfigurowanie administratora usługi Microsoft Entra dla programu SQL Server bez konieczności oddzielnego tworzenia certyfikatu platformy Azure i aplikacji Microsoft Entra. Wybierz kartę, aby dowiedzieć się, jak skonfigurować administratora usługi Microsoft Entra dla programu SQL Server połączonego z Azure Arc z automatycznym tworzeniem certyfikatów i aplikacji.
Użyj witryny Azure Portal, aby skonfigurować administratora usługi Microsoft Entra, utworzyć certyfikat usługi Azure Key Vault i aplikację Microsoft Entra w tym samym procesie. Jest to konieczne do korzystania z uwierzytelniania microsoft Entra z programem SQL Server.
Konfigurowanie administratora firmy Microsoft Entra przy użyciu witryny Azure Portal
Przejdź do witryny Azure Portal i wybierz pozycję SQL Server — Azure Arc. Wybierz wystąpienie hosta programu SQL Server.
Sprawdź stan zasobu SQL Server — Azure Arc i zobacz, czy jest połączony, przechodząc do menu Właściwości. Aby uzyskać więcej informacji, zobacz Weryfikowanie zasobów SQL Server z obsługą Arc.
Wybierz Microsoft Entra ID i Purview w Ustawieniach z menu opcji zasobów.
Wybierz Ustaw administratora, aby otworzyć okienko Microsoft Entra ID, a następnie wybierz konto, które zostanie dodane do logowania administratora w SQL Server.
Wybierz Certyfikat zarządzany usługowo.
Wybierz pozycję Zmień magazyn kluczy i wybierz istniejący zasób usługi Azure Key Vault.
Wybierz pozycję Rejestracja aplikacji zarządzanej przez usługę.
Wybierz Zapisz. Spowoduje to wysłanie żądania do agenta serwera Arc, który konfiguruje uwierzytelnianie Microsoft Entra dla tej instancji SQL Server. Wykonanie operacji może potrwać kilka minut; poczekaj na potwierdzenie zakończenia procesu zapisywania za pomocą Saved successfully zanim spróbujesz zalogować się do Microsoft Entra.
Rejestracja aplikacji zarządzana przez usługę wykonuje dla Ciebie następujące czynności:
- Tworzy certyfikat w magazynie kluczy o nazwie w formie
<hostname>-<instanceName><uniqueNumber>.
- Tworzy aplikację Firmy Microsoft Entra o nazwie takiej jak
<hostname>-<instanceName><uniqueNumber>, i przypisuje niezbędne uprawnienia do tej aplikacji. Aby uzyskać więcej informacji, zobacz Udzielanie uprawnień aplikacji
- Przypisuje nowy certyfikat w usłudze Azure Key Vault do aplikacji.
- Zapisuje te ustawienia w usłudze Azure Arc.
Poniższy skrypt interfejsu wiersza polecenia platformy Azure konfiguruje administratora usługi Microsoft Entra, tworzy certyfikat usługi Azure Key Vault i tworzy aplikację firmy Microsoft Entra. Istnieje dodatkowa sekcja, która zawiera przykładowy skrypt konfigurowania administratora firmy Microsoft Entra, gdy certyfikat i aplikacja już istnieją.
Uwaga
Certyfikaty utworzone dla konfiguracji firmy Microsoft Entra nie są obracane automatycznie.
Aby zainstalować Az.ConnectedMachine moduł, użyj polecenia az extension add --name ConnectedMachine. Aby sprawdzić, która wersja interfejsu wiersza polecenia platformy Azure jest zainstalowana, użyj polecenia az version.
Następujące parametry wejściowe są używane dla skryptu interfejsu wiersza polecenia platformy Azure:
-
<applicationName> — Nazwa aplikacji, która zostanie utworzona
-
<certSubjectName> - Nazwa certyfikatu, który zostanie utworzony
-
<keyVaultName> — Nazwa magazynu kluczy. Ten magazyn kluczy należy utworzyć przed uruchomieniem skryptu
-
<machineName> - Nazwa komputera hosta programu SQL Server
-
<resourceGroupName>— Nazwa grupy zasobów, która zawiera instancję SQL Server – Azure Arc
-
<adminAccountName> — Konto administratora firmy Microsoft Entra, które chcesz ustawić dla programu SQL Server
-
<instanceName> - Opcjonalny parametr dla wystąpień nazwanych SQL Server. Użyj tego parametru, gdy masz nazwane wystąpienie. W przypadku pominięcia, zostanie użyta domyślna nazwa MSSQLSERVER.
-
<tenantId> - Opcjonalny parametr identyfikatora dzierżawy. Identyfikator dzierżawy można znaleźć, przechodząc do portalu Azure i otwierając zasób Microsoft Entra ID. W okienku Przegląd powinien zostać wyświetlony Identyfikator najemcy. W przypadku pominięcia domyślny identyfikator dzierżawy jest używany jako parametr
-
<subscriptionId> - Opcjonalny parametr identyfikatora subskrypcji. Identyfikator subskrypcji można znaleźć w witrynie Azure Portal. W przypadku pominięcia jest używany domyślny identyfikator subskrypcji
Aby użyć poniższego skryptu interfejsu wiersza polecenia platformy Azure, zapisz skrypt jako .ps1 plik i uruchom następujące polecenie:
./aadAzCliSetup.ps1 -applicationName "<applicationName>" -certSubjectName "<certSubjectName>" -keyVaultName "<keyVaultName>" -machineName "<machineName>" -resourceGroupName "<resourceGroupName>" -adminAccountName "<adminAccountName>" -instanceName "<instanceName>" -tenantId "<tenantId>" -subscriptionId "<subscriptionId>"
Skrypt CLI platformy Azure
Uwaga
W przypadku programu SQL Server na maszynach hosta z systemem Linux zastąp ciąg WindowsAgent.SqlServer ciągiem LinuxAgent.SqlServer w skrypcie.
# AZ CLI and AZ CLI's connected machine extension must be installed before running this script
param (
[Parameter(mandatory=$true)] $applicationName,
[Parameter(mandatory=$true)] $certSubjectName,
[Parameter(mandatory=$true)] $keyVaultName,
[Parameter(mandatory=$true)] $machineName,
[Parameter(mandatory=$true)] $resourceGroupName,
[Parameter(mandatory=$true)] $adminAccountName,
$instanceName,
$tenantId,
$subscriptionId
)
# Constants
#
$NUMRETRIES = 60
# Helper functions
#
function ConvertFrom-StringArray {
param (
[string[]] $stringArray
)
if (!$stringArray)
{
return $null
}
else
{
return ConvertFrom-JSON ($stringArray -join "`n")
}
}
# Check parameters
#
if ([string]::IsNullOrEmpty($instanceName))
{
Write-Host "Warning: SQL Instance name (-instanceName) not provided. Default of MSSQLSERVER will be used"
$instanceName = "MSSQLSERVER"
}
$tenantIdArgument = ""
if ([string]::IsNullOrEmpty($tenantId))
{
Write-Host "Warning: Tenant ID (-tenantId) not supplied to the script, so default tenant is being used"
}
else
{
$tenantIdArgument = "-TenantId '" + $tenantId + "'"
}
$subscriptionIdArgument = ""
if ([string]::IsNullOrEmpty($subscriptionId))
{
Write-Host "Warning: Subscription ID (-subscriptionId) not supplied to the script, so default subscription is being used"
}
else
{
$subscriptionIdArgument = "-SubscriptionId '" + $subscriptionId + "'"
}
# Login and select subscription
#
$login = az login --tenant $tenantId --use-device-code
if (!$login)
{
Write-Error "Login to Azure AD failed. Exiting."
exit 1
}
if ($subscriptionId)
{
az account set -s $subscriptionId
}
$accountInfo = ConvertFrom-StringArray (az account show)
if (!$accountInfo)
{
Write-Error "Cannot query logged in Azure AD account. Check that 'az login' and 'az account set' succeeded"
exit 1
}
if ($subscriptionId)
{
if ($subscriptionId.ToLower() -ne $accountInfo.id.ToLower())
{
Write-Error "Could not select the desired subscription"
exit 1
}
}
else
{
$subscriptionId = $accountInfo.id
}
# Check AKV path exists
#
$keyVault = ConvertFrom-StringArray (az keyvault show --name $keyVaultName)
if (!$keyVault)
{
Write-Error "Azure key vault '$keyVaultName' does not exist"
exit 1
}
# Check certificate doesn't exist
#
$cert = ConvertFrom-StringArray (az keyvault certificate show --name $certSubjectName --vault-name $keyVaultName 2>$null)
if ($cert)
{
Write-Error "Certificate '$certSubjectName' already exists in key vault '$keyVaultName'"
exit 1
}
# Check app registration doesn't exist
#
$applications = ConvertFrom-StringArray (az ad app list --display-name $applicationName --only-show-errors)
if ($applications.length -gt 0)
{
Write-Error "App registration with name '$applicationName' already exists"
exit 1
}
# Check Arc SQL instance is valid
#
$extension = ConvertFrom-StringArray (az connectedmachine extension show --machine-name $machineName --name "WindowsAgent.SqlServer" --resource-group $resourceGroupName)
if (!$extension)
{
Write-Error "SQL Server Arc Server not found for machine '$machineName' in resource group '$resourceGroupName'"
exit 1
}
$arcServicePrincipals = ConvertFrom-StringArray(az ad sp list --display-name $machineName --only-show-errors)
if (!$arcServicePrincipals -or $arcServicePrincipals.length -eq 0)
{
Write-Error "Could not find a service principal account with the name '$machineName'"
exit 1
}
else
{
$principalFound = $false
for ($i = 0; $i -lt $arcServicePrincipals.length; $i++)
{
if ($arcServicePrincipals[$i].displayName.toLower() -eq $machineName.toLower()) {
if ($principalFound) {
Write-Error "Could not find exactly one service principal account with the name '$machineName'"
exit 1
}
$arcServicePrincipal = $arcServicePrincipals[$i]
$principalFound = $true
}
}
if (!$principalFound) {
Write-Error "Could not find a service principal account with the name '$machineName'"
exit 1
}
}
# Check if admin account exists
#
$adminAccount = ConvertFrom-StringArray (az ad user show --id $adminAccountName --only-show-errors 2>$null)
$adminAccountType = 0
if (!$adminAccount)
{
$adminAccounts = ConvertFrom-StringArray (az ad user list --filter "mail eq '$adminAccountName'" --only-show-errors 2>$null)
if ($adminAccounts -and $adminAccounts.length -gt 0)
{
if ($adminAccounts.length -eq 1)
{
$adminAccount = $adminAccounts[0]
}
else
{
Write-Error "Multiple Azure AD accounts found with identifier '$adminAccountName'"
exit 1
}
}
else
{
$adminAccount = ConvertFrom-StringArray (az ad group show --group $adminAccountName --only-show-errors 2>$null)
if (!$adminAccount)
{
$adminAccounts = ConvertFrom-StringArray (az ad app list --display-name $adminAccountName --only-show-errors 2>$null)
if ($adminAccounts -and $adminAccounts.length -gt 0)
{
if ($adminAccounts.length -eq 1)
{
$adminAccount = $adminAccounts[0]
}
else
{
Write-Error "Multiple Azure AD applications found with identifier '$adminAccountName'"
exit 1
}
}
else
{
Write-Error "Admin account not found"
exit 1
}
}
else
{
$adminAccountType = 1
}
}
}
if ($adminAccount)
{
$adminAccountSid = $adminAccount.id
}
else
{
Write-Error "Admin account not found"
exit 1
}
# Create certificate in AKV
#
$keyVaultPolicy = ConvertFrom-StringArray (az keyvault certificate get-default-policy)
if (!$keyVaultPolicy)
{
Write-Error "Could not get default key vault policy"
exit 1
}
$keyVaultPolicy.x509CertificateProperties.subject = "CN=" + $certSubjectName
$policyString = (ConvertTo-JSON -Depth 8 $keyVaultPolicy).replace("`r`n", "")
$escapedPolicyString = $policyString.replace("`"", "\`"")
$cert = ConvertFrom-StringArray (az keyvault certificate create --vault-name $keyVaultName --name $certSubjectName --policy $escapedPolicyString)
if (!$cert)
{
Write-Error "Failed to create certificate '$certSubjectName'"
exit 1
}
# Wait until cert is created?
#
$cert = ConvertFrom-StringArray (az keyvault certificate show --vault-name $keyVaultName --name $certSubjectName)
for (($i = 0); $i -lt $NUMRETRIES -and (!$cert -or !$cert.attributes.enabled); $i++)
{
$cert = ConvertFrom-StringArray (az keyvault certificate show --vault-name $keyVaultName --name $certSubjectName)
if (!$cert -or !$cert.attributes.enabled)
{
Start-Sleep -Seconds 5
}
}
# Allow Arc to access AKV
#
$newPerms = ConvertFrom-StringArray (az keyvault set-policy --name $keyVaultName --secret-permissions get list --certificate-permissions get list --object-id $arcServicePrincipal.id)
if (!$newPerms)
{
Write-Host "Warning: Unable to add permissions to key vault '$keyVaultName' for Arc's service principal's identity '$($arcServicePrincipal.id)'. Arc may not be able to configure Azure AD authentication"
}
# Create an Azure AD application
#
$application = ConvertFrom-StringArray (az ad app create --display-name $applicationName --only-show-errors)
if (!$application)
{
Write-Error "Unable to create the app registration '$applicationName'"
exit 1
}
# Set perms on app registration
#
az ad app permission add --id $application.id --api 00000003-0000-0000-c000-000000000000 --api-permissions c79f8feb-a9db-4090-85f9-90d820caa0eb=Scope --only-show-errors # Delegated Application.Read.All
az ad app permission add --id $application.id --api 00000003-0000-0000-c000-000000000000 --api-permissions 0e263e50-5827-48a4-b97c-d940288653c7=Scope --only-show-errors # Delegated Directory.AccessAsUser.All
az ad app permission add --id $application.id --api 00000003-0000-0000-c000-000000000000 --api-permissions 7ab1d382-f21e-4acd-a863-ba3e13f7da61=Role --only-show-errors # Application Directory.Read.All
az ad app permission add --id $application.id --api 00000003-0000-0000-c000-000000000000 --api-permissions 5f8c59db-677d-491f-a6b8-5f174b11ec1d=Scope --only-show-errors # Delegated Group.Read.All
az ad app permission add --id $application.id --api 00000003-0000-0000-c000-000000000000 --api-permissions a154be20-db9c-4678-8ab7-66f6cc099a59=Scope --only-show-errors # Delegated User.Read.All
# Upload cert to Azure AD
#
$certUploadRes = ConvertFrom-StringArray (az ad app credential reset --id $application.id --cert $certSubjectName --keyvault $keyVaultName --append --only-show-errors)
if (!$certUploadRes)
{
Write-Error "Failed to set certificate '$certSubjectName' as a credential for app registration '$applicationName'"
exit 1
}
# Remove the version from the secret ID if present
#
$secretId = $cert.sid
if ($secretId -Match "(https:\/\/[^\/]+\/secrets\/[^\/]+)(\/.*){0,1}$") {
if ($Matches[1]) {
$secretId = $Matches[1]
}
}
# Create the settings object to write to the Azure extension for SQL Server
#
$instanceSettings = @{
instanceName = $instanceName
adminLoginName = $adminAccountName
adminLoginSid = $adminAccountSid
azureCertSecretId = $secretId
azureCertUri = $cert.id
azureKeyVaultResourceUID = $keyVault.id
managedCertSetting = "CUSTOMER MANAGED CERT"
managedAppSetting = "CUSTOMER MANAGED APP"
appRegistrationName = $application.displayName
appRegistrationSid = $application.appId
tenantId = $tenantId
aadCertSubjectName = $certSubjectName
adminLoginType = $adminAccountType
}
$extension = ConvertFrom-StringArray (az connectedmachine extension show --machine-name $machineName --name "WindowsAgent.SqlServer" --resource-group $resourceGroupName)
if ($extension.properties.Settings.AzureAD)
{
$aadSettings = $extension.properties.Settings.AzureAD
$instanceFound = $false
$instanceNameLower = $instanceName.ToLower()
$instanceIndex = 0
for (($i = 0); $i -lt $aadSettings.Length; $i++)
{
if ($aadSettings[$i].instanceName.ToLower() -eq $instanceNameLower)
{
$instanceIndex = $i
$instanceFound = $true
break
}
}
if ($instanceFound)
{
$aadSettings[$instanceIndex] = $instanceSettings
}
else
{
$aadSettings += $instanceSettings
}
$extension.properties.Settings.AzureAD = $aadSettings
}
else
{
$aadSettings = , $instanceSettings
$extension.properties.Settings | Add-Member -Name 'AzureAD' -Value $aadSettings -MemberType NoteProperty
}
$settingsString = (ConvertTo-Json $extension.properties.Settings).replace("`"", "\`"").replace("`r`n", "")
# Push settings to Arc
#
Write-Host "Writing Azure AD setting to Azure extension for SQL Server. This may take several minutes..."
$updateRes = az connectedmachine extension update --machine-name $machineName --name "WindowsAgent.SqlServer" --resource-group $resourceGroupName --settings $settingsString
if (!$updateRes)
{
Write-Error "Failed to update Azure extension for SQL Server with Azure AD settings"
exit 1
}
Write-Output "Success"
Uruchomienie skryptu może potrwać kilka minut. Po zakończeniu procesu zostanie wyświetlony komunikat podobny do następującego:
Name Location ProvisioningState
---- -------- -----------------
WindowsAgent.SqlServer westus2 Succeeded
Success
Konfigurowanie administratora firmy Microsoft Entra przy użyciu istniejącego certyfikatu i aplikacji przy użyciu interfejsu wiersza polecenia platformy Azure
Jeśli masz już istniejący certyfikat usługi Azure Key Vault i aplikację platformy Azure, której chcesz użyć do skonfigurowania administratora usługi Microsoft Entra, możesz użyć następującego skryptu interfejsu wiersza polecenia:
# Set up Microsoft Entra admin for user's existing key vault, certificate, and application
# Requires input parameters indicated below
# Connect statement
AZ Login
#Input parameters
$subscriptionId="<subscriptionId>"
$tenantId="<tenantId>"
$machineName="<machineName>" # hostname
$instanceName="<instanceName>" # SQL Server is define as `machine_name\instance_name`
$resourceGroupName="<resourceGroupName>"
$keyVaultName="<keyVaultName>"
$certSubjectName="<certSubjectName>" # Your existing certificate name
$applicationName="<applicationName>" # Your existing application name
$adminAccountName="<adminAccountName>"
$adminAccountSid="<adminID>" # Use object ID for the Azure AD user and group, or client ID for the Azure AD application
$adminAccountType= 0 # 0 – for Azure AD user and application, 1 for Azure AD group
# Helper function
#
function ConvertFrom-StringArray {
param (
[string[]] $stringArray
)
if (!$stringArray)
{
return $null
}
else
{
return ConvertFrom-JSON ($stringArray -join "`n")
}
}
$keyVault = ConvertFrom-StringArray (az keyvault show --name $keyVaultName)
if (!$keyVault)
{
Write-Error "Azure key vault '$keyVaultName' does not exist"
exit 1
}
$cert = ConvertFrom-StringArray (az keyvault certificate show --name $certSubjectName --vault-name $keyVaultName 2>$null)
if (!$cert)
{
Write-Error "Supplied certificate $certSubjectName was not found for this key vault. Please specify an existing certificate"
exit 1
}
$secretId = $cert.sid
if ($secretId -Match "(https:\/\/[^\/]+\/secrets\/[^\/]+)(\/.*){0,1}$") {
if ($Matches[1]) {
$secretId = $Matches[1]
}
}
$application = ConvertFrom-StringArray (az ad app list --display-name $applicationName --only-show-errors)
if (!$application)
{
Write-Error "Supplied application was not found in the subscription. Please specify an existing application"
exit 1
}
# Create the settings object to write to the Arc extension
#
$instanceSettings = @{
instanceName = $instanceName
adminLoginName = $adminAccountName
adminLoginSid = $adminAccountSid
azureCertSecretId = $secretId
azureCertUri = $cert.id
azureKeyVaultResourceUID = $keyVault.id
managedCertSetting = "CUSTOMER MANAGED CERT"
managedAppSetting = "CUSTOMER MANAGED APP"
appRegistrationName = $application.displayName
appRegistrationSid = $application.appId
tenantId = $tenantId
aadCertSubjectName = $certSubjectName
adminLoginType = $adminAccountType
}
$extension = ConvertFrom-StringArray (az connectedmachine extension show --machine-name $machineName --name "WindowsAgent.SqlServer" --resource-group $resourceGroupName)
if ($extension.properties.Settings.AzureAD)
{
$aadSettings = $extension.properties.Settings.AzureAD
$instanceFound = $false
$instanceNameLower = $instanceName.ToLower()
$instanceIndex = 0
for (($i = 0); $i -lt $aadSettings.Length; $i++)
{
if ($aadSettings[$i].instanceName.ToLower() -eq $instanceNameLower)
{
$instanceIndex = $i
$instanceFound = $true
break
}
}
if ($instanceFound)
{
$aadSettings[$instanceIndex] = $instanceSettings
}
else
{
$aadSettings += $instanceSettings
}
$extension.properties.Settings.AzureAD = $aadSettings
}
else
{
$aadSettings = , $instanceSettings
$extension.properties.Settings | Add-Member -Name 'AzureAD' -Value $aadSettings -MemberType NoteProperty
}
$settingsString = (ConvertTo-Json $extension.properties.Settings).replace("`"", "\`"").replace("`r`n", "")
# Push settings to Arc
#
Write-Host "Writing Azure AD setting to SQL Server Arc Extension. This may take several minutes..."
$updateRes = az connectedmachine extension update --machine-name $machineName --name "WindowsAgent.SqlServer" --resource-group $resourceGroupName --settings $settingsString
if (!$updateRes)
{
Write-Error "Failed to update SQL Arc Extension with Azure AD settings"
exit 1
}
Write-Output "Success"
Poniższy skrypt programu PowerShell konfiguruje administratora usługi Microsoft Entra, tworzy certyfikat usługi Azure Key Vault i tworzy aplikację Firmy Microsoft Entra. Istnieje dodatkowa sekcja, która zawiera przykładowy skrypt konfigurowania administratora firmy Microsoft Entra, gdy certyfikat i aplikacja już istnieją.
Uwaga
Certyfikaty utworzone dla konfiguracji firmy Microsoft Entra nie są obracane automatycznie.
Do tego samouczka wymagane są następujące moduły. Zainstaluj najnowsze wersje modułów lub nowsze niż zanotowaną wersję poniżej:
- Az.Accounts 3.37.0
- Az.ConnectedMachine 0.5.0
- Az.KeyVault 4.5.0
- Az.Resources 6.0.0
Następujące parametry wejściowe są używane dla skryptu programu PowerShell:
-
<applicationName> — Nazwa aplikacji, która zostanie utworzona
-
<certSubjectName> - Nazwa certyfikatu, który zostanie utworzony
-
<keyVaultName> — Nazwa magazynu kluczy. Ten magazyn kluczy należy utworzyć przed uruchomieniem skryptu
-
<machineName> - Nazwa komputera hosta programu SQL Server
-
<resourceGroupName>— Nazwa grupy zasobów, która zawiera wystąpienie Azure Arc — SQL Server
-
<adminAccountName> — Konto administratora firmy Microsoft Entra, które chcesz ustawić dla programu SQL Server
-
<instanceName> - Opcjonalny parametr dla nazwanych instancji SQL Server. Użyj tego parametru, gdy masz nazwane wystąpienie. Jeśli pominięto, zostanie użyta domyślna nazwa MSSQLSERVER
-
<tenantId> - Opcjonalny parametr identyfikatora dzierżawy. Identyfikator dzierżawy można znaleźć, przechodząc do portalu Azure i do zasobu Microsoft Entra ID. W okienku Przegląd powinien być wyświetlony Twój Tenant ID. W przypadku pominięcia domyślny identyfikator dzierżawy jest używany jako parametr
-
<subscriptionId> - Opcjonalny parametr identyfikatora subskrypcji. Identyfikator subskrypcji można znaleźć w witrynie Azure Portal. W przypadku pominięcia jest używany domyślny identyfikator subskrypcji
Aby użyć poniższego skryptu programu PowerShell, zapisz skrypt jako .ps1 plik i uruchom następujące polecenie:
./aadPowerShellsetup.ps1 -applicationName "<applicationName>" -certSubjectName "<certSubjectName>" -keyVaultName "<keyVaultName>" -machineName "<machineName>" -resourceGroupName "<resourceGroupName>" -adminAccountName "<adminAccountName>" -instanceName "<instanceName>" -tenantId "<tenantId>" -subscriptionId "<subscriptionId>"
Skrypt programu PowerShell
W przypadku programu SQL Server na maszynach hosta z systemem Linux zastąp ciąg WindowsAgent.SqlServer ciągiem LinuxAgent.SqlServer w skrypcie.
param (
[Parameter(mandatory=$true)] $applicationName,
[Parameter(mandatory=$true)] $certSubjectName,
[Parameter(mandatory=$true)] $keyVaultName,
[Parameter(mandatory=$true)] $machineName,
[Parameter(mandatory=$true)] $resourceGroupName,
[Parameter(mandatory=$true)] $adminAccountName,
$instanceName,
$tenantId,
$subscriptionId
)
Import-Module Az.Accounts
Import-Module Az.ConnectedMachine
Import-Module Az.KeyVault
Import-Module Az.Resources
# Constants
#
$NUMRETRIES = 60
# Check parameters
#
if ([string]::IsNullOrEmpty($instanceName))
{
Write-Host "Warning: SQL Instance name (-instanceName) not provided. Default of MSSQLSERVER will be used"
$instanceName = "MSSQLSERVER"
}
$tenantIdArgument = ""
if ([string]::IsNullOrEmpty($tenantId))
{
Write-Host "Warning: Tenant ID (-tenantId) not supplied to the script, so default tenant is being used"
}
else
{
$tenantIdArgument = "-TenantId '" + $tenantId + "'"
}
$subscriptionIdArgument = ""
if ([string]::IsNullOrEmpty($subscriptionId))
{
Write-Host "Warning: Subscription ID (-subscriptionId) not supplied to the script, so default subscription is being used"
}
else
{
$subscriptionIdArgument = "-SubscriptionId '" + $subscriptionId + "'"
}
# Login
#
try
{
$loginRes = Invoke-Expression -Command ("Connect-AzAccount " + $tenantIdArgument + " " + $subscriptionIdArgument + " -ErrorAction stop -UseDeviceAuthentication")
}
catch
{
Write-Error $_
Write-Error "Failed to login to Azure. Script can not continue"
exit 1
}
# Get subscription ID
#
if ([string]::IsNullOrEmpty($subscriptionId))
{
$context = Get-AzContext
if ($context)
{
if ($context.Name -Match "[^(]+\(([^)]{36})\)")
{
if ($Matches[1])
{
$subscriptionId = $Matches[1]
}
}
}
}
if ([string]::IsNullOrEmpty($subscriptionId))
{
Write-Error "Failed to find default subscription"
exit 1
}
# Check AKV path exists
#
$keyVault = Get-AzKeyVault -VaultName $keyVaultName
if (!$keyVault)
{
Write-Error "Supplied key vault was not found in the subscription. Please specify an existing key vault"
exit 1
}
# Check certificate doesn't exist
#
$cert = Get-AzKeyVaultCertificate -VaultName $keyVaultName -Name $certSubjectName
if ($cert)
{
Write-Error "Certificate $certSubjectName already exists"
exit 1
}
# Check app registration doesn't exist
#
$application = Get-AzADApplication -DisplayName $applicationName
if ($application)
{
Write-Error "Application $applicationName already exists"
exit 1
}
# Check Arc SQL instance is valid
#
$arcInstance = Get-AzConnectedMachineExtension -SubscriptionId $subscriptionId -MachineName $machineName -ResourceGroupName $resourceGroupName -Name "WindowsAgent.SqlServer"
if (!$arcInstance)
{
Write-Error "Could not find a SQL Server Arc instance in subscription '$subscriptionId' and resource group '$resourceGroupName' with name '$machineName'"
exit 1
}
# Check if admin account exists
#
$adminAccount = Get-AzADUser -UserPrincipalName $adminAccountName
$adminAccountType = 0
if (!$adminAccount)
{
# Check for guest user
#
$adminAccount = Get-AzADUser -Mail $adminAccountName
if (!$adminAccount)
{
$adminAccount = Get-AzADGroup -DisplayName $adminAccountName
if (!$adminAccount)
{
$adminAccount = Get-AzADServicePrincipal -DisplayName $adminAccountName
}
else
{
$adminAccountType = 1
}
}
}
if ($adminAccount)
{
if ($adminAccount.Length -gt 1)
{
Write-Error "Multiple accounts with found with name $adminAccountName"
exit 1
}
$adminAccountSid = $adminAccount.Id
}
else
{
Write-Error "Could not find an account with name $adminAccountName"
exit 1
}
# Create certificate in AKV
#
$Policy = New-AzKeyVaultCertificatePolicy -SecretContentType "application/x-pkcs12" -SubjectName "CN=$certSubjectName" -IssuerName "Self" -ValidityInMonths 12 -ReuseKeyOnRenewal
try
{
$addCertRes = Add-AzKeyVaultCertificate -VaultName $keyVaultName -Name $certSubjectName -CertificatePolicy $Policy -ErrorAction stop
}
catch
{
Write-Error $_
Write-Error "Certificate $certSubjectName could not be created"
exit 1
}
for (($i = 0); $i -lt $NUMRETRIES -and (!$cert -or !$cert.enabled); $i++)
{
$cert = Get-AzKeyVaultCertificate -VaultName $keyVaultName -Name $certSubjectName
if (!$cert -or !$cert.enabled)
{
Start-Sleep -Seconds 5
}
}
if (!$cert)
{
Write-Error "Certificate $certSubjectName could not be created"
exit 1
}
# Allow Arc to access AKV
#
$arcServicePrincipal = Get-AzADServicePrincipal -DisplayName $machineName
if ($arcServicePrincipal -and ![string]::IsNullOrEmpty($arcServicePrincipal.Id))
{
try
{
Set-AzKeyVaultAccessPolicy -VaultName $keyVaultName -ObjectId $arcServicePrincipal.Id -PermissionsToSecrets Get,List -PermissionsToCertificates Get,List
}
catch
{
Write-Error $_
Write-Host "Warning: Could not find the identity of the Azure extension for SQL Server and thus, could not add permissions for the Arc process to read from AKV. Ensure the Arc identity has the required permissions to read from AKV."
}
}
else
{
Write-Host "Warning: Could not find the identity of the Azure extension for SQL Server and thus, could not add permissions for the Arc process to read from AKV. Ensure the Arc identity has the required permissions to read from AKV."
}
# Create an Azure AD application
#
$application = New-AzADApplication -DisplayName $applicationName
if (!$application)
{
Write-Error "Application could not be created"
exit 1
}
# Set perms on app registration
#
Add-AzADAppPermission -ObjectId $application.Id -ApiId 00000003-0000-0000-c000-000000000000 -PermissionId c79f8feb-a9db-4090-85f9-90d820caa0eb # Delegated Application.Read.All
Add-AzADAppPermission -ObjectId $application.Id -ApiId 00000003-0000-0000-c000-000000000000 -PermissionId 0e263e50-5827-48a4-b97c-d940288653c7 # Delegated Directory.AccessAsUser.All
Add-AzADAppPermission -ObjectId $application.Id -ApiId 00000003-0000-0000-c000-000000000000 -PermissionId 7ab1d382-f21e-4acd-a863-ba3e13f7da61 -Type Role # Application Directory.Read.All
Add-AzADAppPermission -ObjectId $application.Id -ApiId 00000003-0000-0000-c000-000000000000 -PermissionId 5f8c59db-677d-491f-a6b8-5f174b11ec1d # Delegated Group.Read.All
Add-AzADAppPermission -ObjectId $application.Id -ApiId 00000003-0000-0000-c000-000000000000 -PermissionId a154be20-db9c-4678-8ab7-66f6cc099a59 # Delegated User.Read.All
# Upload cert to Azure AD
#
try
{
$base64Cert = [System.Convert]::ToBase64String($cert.Certificate.GetRawCertData())
New-AzADAppCredential -ApplicationObject $application -CertValue $base64Cert -EndDate $cert.Certificate.NotAfter -StartDate $cert.Certificate.NotBefore -ErrorAction stop
}
catch
{
Write-Error $_
Write-Error "Failed to add certificate to app registration"
exit 1
}
# Remove the version from the secret ID if present
#
$secretId = $cert.SecretId
if ($secretId -Match "(https:\/\/[^\/]+\/secrets\/[^\/]+)(\/.*){0,1}$") {
if ($Matches[1]) {
$secretId = $Matches[1]
}
}
# Create the settings object to write to the Azure extension for SQL Server
#
$instanceSettings = @{
instanceName = $instanceName
adminLoginName = $adminAccountName
adminLoginSid = $adminAccountSid
azureCertSecretId = $secretId.replace(":443", "")
azureCertUri = $cert.Id.replace(":443", "")
azureKeyVaultResourceUID = $keyVault.ResourceId
managedCertSetting = "CUSTOMER MANAGED CERT"
managedAppSetting = "CUSTOMER MANAGED APP"
appRegistrationName = $application.DisplayName
appRegistrationSid = $application.AppId
tenantId = $tenantId
aadCertSubjectName = $certSubjectName
adminLoginType = $adminAccountType
}
$arcInstance = Get-AzConnectedMachineExtension -SubscriptionId $subscriptionId -MachineName $machineName -ResourceGroupName $resourceGroupName -Name "WindowsAgent.SqlServer"
if ($arcInstance.Setting.AdditionalProperties.AzureAD)
{
$aadSettings = $arcInstance.Setting.AdditionalProperties.AzureAD
$instanceFound = $false
$instanceNameLower = $instanceName.ToLower()
$instanceIndex = 0
for (($i = 0); $i -lt $aadSettings.Length; $i++)
{
if ($aadSettings[$i].instanceName.ToLower() -eq $instanceNameLower)
{
$instanceIndex = $i
$instanceFound = $true
break
}
}
if ($instanceFound)
{
$aadSettings[$instanceIndex] = $instanceSettings
}
else
{
$aadSettings += $instanceSettings
}
}
else
{
$aadSettings = , $instanceSettings
}
Write-Host "Writing Microsoft Entra setting to SQL Server Arc Extension. This may take several minutes..."
# Push settings to Arc
#
try
{
#set the Entra ID / AzureAD setting in the hash table
$SettingsToConfigure = @{
AzureAD = $aadSettings
}
#add any non-AzureAD key value pairs back to the hashtable
$keys = $arcInstance.Setting.Keys | where-object {$_ -notin ("AzureAD")}
foreach ($key in $keys) {
$SettingsToConfigure.$key = $arcInstance.Setting["$key"]
}
#Issue the update of the updated settings
Update-AzConnectedMachineExtension `
-MachineName $machineName `
-Name "WindowsAgent.SqlServer" `
-ResourceGroupName $resourceGroupName `
-Setting $SettingsToConfigure
}
catch
{
Write-Error $_
Write-Error "Failed to write settings to Arc host"
exit 1
}
Write-Output "Success"
Konfigurowanie administratora firmy Microsoft Entra przy użyciu istniejącego certyfikatu i aplikacji przy użyciu programu PowerShell
Jeśli masz już istniejący certyfikat usługi Azure Key Vault i aplikację platformy Azure, której chcesz użyć do skonfigurowania administratora usługi Microsoft Entra, możesz użyć następującego skryptu programu PowerShell:
# Connect statement
Connect-AzAccount
#Input parameters
$subscriptionId="<subscriptionId>"
$tenantId="<tenantId>"
$machineName="<machineName>" # hostname
$instanceName="<instanceName>" # SQL Server is define as `machine_name\instance_name`
$resourceGroupName="<resourceGroupName>"
$keyVaultName="<keyVaultName>"
$certSubjectName="<certSubjectName>" # Your existing certificate name
$applicationName="<applicationName>" # Your existing application name
$adminAccountName="<adminAccountName>"
$adminAccountSid="<adminID>" # Use object ID for the Microsoft Entra user and group, or client ID for the Microsoft Entra application
$adminAccountType= 0 # 0 – for Microsoft Entra user and application, 1 for Microsoft Entra group
$keyVault = Get-AzKeyVault -VaultName $keyVaultName
if (!$keyVault)
{
Write-Error "Supplied key vault was not found in the subscription. Please specify an existing key vault"
exit 1
}
$cert = Get-AzKeyVaultCertificate -VaultName $keyVaultName -Name $certSubjectName
if (!$cert)
{
Write-Error "Supplied certificate $certSubjectName was not found for this key vault. Please specify an existing certificate"
exit 1
}
$secretId = $cert.SecretId
if ($secretId -Match "(https:\/\/[^\/]+\/secrets\/[^\/]+)(\/.*){0,1}$") {
if ($Matches[1]) {
$secretId = $Matches[1]
}
}
$application = Get-AzADApplication -DisplayName $applicationName
if (!$application)
{
Write-Error "Supplied application was not found in the subscription. Please specify an existing application"
exit 1
}
# Create the settings object to write to the Arc extension
#
$instanceSettings = @{
instanceName = $instanceName
adminLoginName = $adminAccountName
adminLoginSid = $adminAccountSid
azureCertSecretId = $secretId.replace(":443", "")
azureCertUri = $cert.Id.replace(":443", "")
azureKeyVaultResourceUID = $keyVault.ResourceId
managedCertSetting = "CUSTOMER MANAGED CERT"
managedAppSetting = "CUSTOMER MANAGED APP"
appRegistrationName = $application.DisplayName
appRegistrationSid = $application.AppId
tenantId = $tenantId
aadCertSubjectName = $certSubjectName
adminLoginType = $adminAccountType
}
$arcInstance = Get-AzConnectedMachineExtension -SubscriptionId $subscriptionId -MachineName $machineName -ResourceGroupName $resourceGroupName -Name "WindowsAgent.SqlServer"
if ($arcInstance.Setting.AdditionalProperties.AzureAD)
{
$aadSettings = $arcInstance.Setting.AdditionalProperties.AzureAD
$instanceFound = $false
$instanceNameLower = $instanceName.ToLower()
$instanceIndex = 0
for (($i = 0); $i -lt $aadSettings.Length; $i++)
{
if ($aadSettings[$i].instanceName.ToLower() -eq $instanceNameLower)
{
$instanceIndex = $i
$instanceFound = $true
break
}
}
if ($instanceFound)
{
$aadSettings[$instanceIndex] = $instanceSettings
}
else
{
$aadSettings += $instanceSettings
}
}
else
{
$aadSettings = , $instanceSettings
}
Write-Host "Writing Microsoft Entra setting to SQL Server Arc Extension. This may take several minutes..."
# Push settings to Arc
#
try
{
#set the Entra ID / AzureAD setting in the hash table
$SettingsToConfigure = @{
AzureAD = $aadSettings
}
#add any non-AzureAD key value pairs back to the hashtable
$keys = $arcInstance.Setting.Keys | where-object {$_ -notin ("AzureAD")}
foreach ($key in $keys) {
$SettingsToConfigure.$key = $arcInstance.Setting["$key"]
}
#Issue the update of the updated settings
Update-AzConnectedMachineExtension `
-MachineName $machineName `
-Name "WindowsAgent.SqlServer" `
-ResourceGroupName $resourceGroupName `
-Setting $SettingsToConfigure
}
catch
{
Write-Error $_
Write-Error "Failed to write settings to Arc host"
exit 1
}
Write-Output "Success"
Poniższy szablon usługi ARM konfiguruje administratora usługi Microsoft Entra przy użyciu istniejącego certyfikatu usługi Azure Key Vault i aplikacji Firmy Microsoft Entra.
Następujące parametry wejściowe są używane dla szablonu ARM:
-
<machineName> - Nazwa komputera hosta programu SQL Server
-
<Location> — Lokalizacja grupy zasobów programu SQL Server — Azure Arc, taka jak West US, lub Central US
-
<tenantId> — Identyfikator dzierżawcy można znaleźć, przechodząc do portalu Azure; a następnie do zasobu Microsoft Entra ID. W okienku Przegląd powinna być widoczna identyfikator najemcy
-
<instanceName> — Nazwa wystąpienia programu SQL Server. Domyślna nazwa wystąpienia programu SQL Server to MSSQLSERVER
-
<certSubjectName> - Nazwa utworzonego certyfikatu
-
<subscriptionId> - Identyfikator subskrypcji. Identyfikator subskrypcji można znaleźć w witrynie Azure Portal
-
<resourceGroupName> — Nazwa grupy zasobów, która zawiera magazyn kluczy. Pełną wartość azureKeyVaultResourceUID można znaleźć, przechodząc do zasobu usługi Key Vault , wybierając pozycję Właściwości i kopiując identyfikator zasobu
-
<keyVaultName> — Nazwa magazynu kluczy
-
<certIdentifier> — Identyfikator certyfikatu dla certyfikatu usługi Azure Key Vault. Aby uzyskać identyfikator certyfikatu, przejdź do zasobu magazynu kluczy i wybierz pozycję Certyfikaty w obszarze Ustawienia. Wybierz bieżącą wersję utworzonego certyfikatu i skopiuj wartość Identyfikator certyfikatu . Aby uzyskać więcej informacji, zobacz Dodawanie certyfikatu do usługi Key Vault
-
<certSecret> — Tajny identyfikator certyfikatu można znaleźć w tym samym menu, co Identyfikator certyfikatu
-
<applicationName> - Nazwa utworzonej aplikacji Firmy Microsoft Entra
-
<appID> — Identyfikator aplikacji (klienta) aplikacji firmy Microsoft Entra można znaleźć w menu Przegląd aplikacji
-
<adminAccountName> — Konto administratora firmy Microsoft Entra, które chcesz ustawić dla programu SQL Server
-
<adminID> — Identyfikator obiektu użytkownika lub grupy Microsoft Entra lub identyfikator aplikacji (klienta) aplikacji, jeśli używasz innej aplikacji jako konta administratora Microsoft Entra. Aby uzyskać więcej informacji, zobacz Tutorial: Create Microsoft Entra users using Microsoft Entra applications (Samouczek: tworzenie użytkowników entra firmy Microsoft przy użyciu aplikacji Firmy Microsoft Entra)
-
<adminType> — Używanie 0 dla użytkowników i aplikacji firmy Microsoft Entra oraz 1 dla grup Firmy Microsoft Entra
Użyj wdrożenia niestandardowego w witrynie Azure Portal i utwórz własny szablon w edytorze.
Następnie zapisz konfigurację po wklejeniu przykładowej konfiguracji.
Uwaga
W przypadku programu SQL Server na maszynach hosta z systemem Linux zastąp ciąg WindowsAgent.SqlServer ciągiem LinuxAgent.SqlServer w skrypcie.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {},
"resources": [
{
"type": "Microsoft.HybridCompute/machines/extensions",
"apiVersion": "2022-03-10",
"name": "<machineName>/WindowsAgent.SqlServer",
"location": "<Location>",
"properties": {
"publisher": "Microsoft.AzureData",
"type": "WindowsAgent.SqlServer",
"settings": {
"AzureAD": [
{
"tenantId": "<tenantId>",
"instanceName": "<instanceName>",
"managedCertSetting": "CUSTOMER MANAGED CERT",
"aadCertSubjectName": "<certSubjectName>",
"azureKeyVaultResourceUID": "/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.KeyVault/vaults/<keyVaultName>",
"azureCertUri": "<certIdentifier>",
"azureCertSecretId": "<certSecret>",
"managedAppSetting": "CUSTOMER MANAGED APP",
"appRegistrationName": "<applicationName>",
"appRegistrationSid": "<appID>",
"adminLoginName": "<adminAccountName>",
"adminLoginSid" : "<adminID>",
"adminLoginType": 0
}
]
}
}
}
]
}
Udzielanie zgody administratora dla aplikacji
Po skonfigurowaniu administratora firmy Microsoft Entra przy użyciu poświadczeń administratora firmy Microsoft Entra możesz nawiązać połączenie z programem SQL Server. Jednak wszelkie dalsze działania bazy danych, związane z tworzeniem nowych kont logowania i użytkowników Microsoft Entra, zakończą się niepowodzeniem, dopóki aplikacja Microsoft Entra nie uzyska zgody administratora.
Uwaga
Aby udzielić zgody administratora dla aplikacji, konto udzielające zgody wymaga roli Administratora ról uprzywilejowanych Microsoft Entra ID. Te role są niezbędne do udzielenia zgody administratora dla aplikacji, ale nie jest konieczne skonfigurowanie administratora firmy Microsoft Entra.
W witrynie Azure Portal wybierz pozycjęRejestracje aplikacjiMicrosoft Entra ID>, wybierz nowo utworzoną aplikację. Aplikacja powinna mieć nazwę taką jak <hostname>-<instanceName><uniqueNumber>.
Wybierz menu Uprawnienia interfejsu API .
Wybierz Udzielanie zgody administratora.
Bez udzielenia zgody administratora na aplikację, utworzenie logowania Microsoft Entra lub użytkownika w programie SQL Server spowoduje następujący błąd:
Msg 37455, Level 16, State 1, Line 2
Server identity does not have permissions to access MS Graph.
Nawiązywanie połączenia z programem SQL Server przy użyciu uwierzytelniania entra firmy Microsoft
Uwierzytelnianie Microsoft Entra jest teraz skonfigurowane dla programu SQL Server połączonego z usługą Azure Arc. Postępuj zgodnie z sekcjami po skonfigurowaniu administratora Microsoft Entra w artykule Samouczek: konfigurowanie uwierzytelniania Microsoft Entra dla programu SQL Server, aby połączyć się z programem SQL Server przy użyciu uwierzytelniania Microsoft Entra.
Zobacz też
