Självstudie: Använda automatisering för att konfigurera Microsoft Entra-administratören för SQL Server

gäller för: SQL Server 2022 (16.x)

Anmärkning

Den här funktionen är tillgänglig i SQL Server 2022 (16.x) eller senare versioner och stöds endast för SQL Server lokalt, för Windows- och Linux-värdar och SQL Server 2022 på virtuella Windows Azure-datorer.

I den här artikeln går vi vidare med hur du konfigurerar Microsoft Entra-administratören för att tillåta autentisering med Microsoft Entra-ID (tidigare Azure Active Directory) för SQL Server med hjälp av Azure-portalen och API:er som:

• PowerShell
• The Azure CLI
• ARM-mall

Vi går också över de uppdaterade funktionerna för att konfigurera en Microsoft Entra-administratör för SQL Server i Azure-portalen som möjliggör automatisk skapande av certifikat och programregistrering. Tidigare behövde du konfigurera Microsoft Entra-autentisering för SQL Server manuell installation av Microsoft Entra-administratör med ett Azure-certifikat och programregistrering.

Anmärkning

Även om Microsoft Entra ID är det nya namnet för Azure Active Directory (Azure AD), för att förhindra avbrott i befintliga miljöer, förblir Azure AD fortfarande i vissa hårdkodade element som gränssnittsfält, anslutningsproviders, felkoder och cmdletar. I den här artikeln är de två namnen utbytbara.

Förutsättningar

• SQL Server 2022 (16.x) eller senare installeras.
• SQL Server är anslutet till Azure-molnet. Mer information finns i Ansluta SQL Server till Azure Arc.
• Microsoft Entra-ID har konfigurerats för autentisering i samma klientorganisation som Azure Arc-instansen.
• Ett Azure Key Vault krävs.
• Nätverkskrav för att aktivera Entra-ID-autentisering uppfylls.

Förberedelse innan du ställer in Microsoft Entra-administratören

Följande behörigheter krävs för att konfigurera Microsoft Entra-administratören i resurserna SQL Server – Azure Arc och Key Vault .

Konfigurera behörigheter för Azure Arc

Följ guiden för att se till att DIN SQL Server är ansluten till Azure Arc. Användaren som konfigurerar Microsoft Entra-administratören för SQL Server – Azure Arc-resursen bör ha rollen Deltagare för servern.

1. Gå till Azure-portalen
2. Välj SQL Server – Azure Arc och välj instansen för SQL Server-värden.
3. Välj Åtkomstkontroll (IAM) .
4. Välj Lägg till>rolltilldelning för att lägga till rollen Deltagare i användaren som konfigurerar Microsoft Entra-administratören.

Konfigurera behörigheter för Azure Key Vault

Skapa ett Azure Key Vault om du inte redan har ett. Användaren som konfigurerar Microsoft Entra-administratören bör ha rollen Deltagare för ditt Azure Key Vault. Så här lägger du till en roll till en användare i Azure Key Vault:

1. Gå till Azure-portalen
2. Gå till key vault-resursen .
3. Välj Åtkomstkontroll (IAM).
4. Välj Lägg till>rolltilldelning för att lägga till rollen Deltagare i användaren som konfigurerar Microsoft Entra-administratören.

Ange åtkomstprinciper för SQL Server-värden

1. I Azure-portalen går du till din Azure Key Vault-instans och väljer Åtkomstprinciper.

2. Välj Lägg till åtkomstprincip.

3. För Nyckelbehörigheter använder du Signera.

4. För Hemliga behörigheter väljer du Hämta och Lista.

5. För Certifikatbehörigheter väljer du Hämta och Lista.

6. Välj Nästa.

7. På sidan Principal söker du efter namnet på din Maskin - Azure Arc-instans, som är värdnamnet för SQL Server-värden.

   

8. Hoppa över sidan Program (valfritt) genom att välja Nästa två gånger eller välja Granska + skapa.

   

   Kontrollera att "Objekt-ID" för principalen matchar principal-ID för den hanterade identitet som tilldelats till instansen.

   

   Bekräfta genom att gå till resurssidan och välja JSON-vy längst upp till höger i rutan Essentials på sidan Översikt. Under identitet hittar du principalId.

9. Välj Skapa.

Du måste välja Skapa för att säkerställa att behörigheterna tillämpas. För att säkerställa att behörigheter har lagrats uppdaterar du webbläsarfönstret och kontrollerar att raden för din Azure Arc-instans fortfarande finns.

Ange åtkomstprinciper för Microsoft Entra-användare

1. I Azure-portalen går du till din Azure Key Vault-instans och väljer Åtkomstprinciper.
2. Välj Lägg till åtkomstprincip.
3. För Nyckelbehörigheter väljer du Hämta, Lista och Skapa.
4. För Hemliga behörigheter väljer du Hämta, Lista och Ange.
5. För Certifikatbehörigheter väljer du Hämta, Lista och Skapa.
6. För Välj huvudnamn lägger du till den Microsoft Entra-användare som du vill använda för att ansluta till SQL Server.
7. Välj Lägg till och välj sedan Spara.

Konfigurera Microsoft Entra-administratören för SQL Server

Med nya API:er och portalfunktioner kan användare konfigurera en Microsoft Entra-administratör för SQL Server utan att behöva skapa ett Azure-certifikat och Microsoft Entra-program separat. Välj en flik för att lära dig hur du konfigurerar en Microsoft Entra-administratör för din SQL Server som är ansluten till Azure Arc med automatiskt certifikat och programskapande.

Anmärkning

ARM-mallen kräver fortfarande att ett Azure Key Vault-certifikat och Microsoft Entra-program skapas innan du konfigurerar en Microsoft Entra-administratör. Mer information om den här processen finns i Självstudie: Konfigurera Microsoft Entra-autentisering för SQL Server.

Portal

Använd Azure-portalen för att konfigurera en Microsoft Entra-administratör, skapa ett Azure Key Vault-certifikat och Microsoft Entra-program i samma process. Detta är nödvändigt för att använda Microsoft Entra-autentisering med SQL Server.

Anmärkning

Tidigare, innan du konfigurerade en Microsoft Entra-administratör, behövdes ett Azure Key Vault-certifikat och Microsoft Entra-programregistrering. Detta är inte längre nödvändigt, men användarna kan fortfarande välja att ange sitt eget certifikat och program för att konfigurera Microsoft Entra-administratören.

Konfigurera Microsoft Entra-administratör med hjälp av Azure-portalen

1. Gå till Azure-portalen och välj SQL Server – Azure Arc. Välj instansen för din SQL Server-värd.

2. Kontrollera statusen för din SQL Server – Azure Arc resurs och se om den är ansluten genom att gå till menyn Egenskaper. Mer information finns i Verifiera dina Arc-aktiverade SQL Server-resurser.

3. Välj Microsoft Entra ID och Purview under Inställningar på resursmenyn.

4. Välj Ange administratör för att öppna fönstret Microsoft Entra-ID och välj ett konto som ska läggas till som administratörsinloggning till SQL Server.

5. Välj Tjänsthanterat certifikat.

6. Välj Ändra nyckelvalv och välj din befintliga Azure Key Vault-resurs.

7. Välj Tjänsthanterad appregistrering.

8. Välj Spara. Detta skickar en begäran till Arc-serveragenten, som konfigurerar Microsoft Entra-autentisering för den SQL Server-instansen. Åtgärden kan ta flera minuter att slutföra. vänta tills spara-processen har bekräftats med Saved successfully innan du försöker logga in på Microsoft Entra.

   Registreringen av tjänsthanterade appar gör följande åt dig:

   • Skapar ett certifikat i nyckelvalvet med ett namn i formuläret <hostname>-<instanceName><uniqueNumber>.
   • Skapar ett Microsoft Entra-program med ett namn som <hostname>-<instanceName><uniqueNumber>, och tilldelar nödvändiga behörigheter till programmet. Mer information finns i Bevilja programbehörigheter
   • Tilldelar det nya certifikatet i Azure Key Vault till programmet.
   • Sparar de här inställningarna i Azure Arc.

   

Anmärkning

Certifikaten som skapats för Microsoft Entra roteras inte automatiskt. Kunder kan välja att ange ett eget certifikat och program för microsoft Entra-administratörskonfigurationen. Mer information finns i Självstudie: Konfigurera Microsoft Entra-autentisering för SQL Server.

Azure CLI-

Azure CLI-skriptet nedan konfigurerar en Microsoft Entra-administratör, skapar ett Azure Key Vault-certifikat och skapar ett Microsoft Entra-program. Det finns ytterligare ett avsnitt som innehåller ett exempelskript för att konfigurera en Microsoft Entra-administratör när ett certifikat och program redan finns.

Anmärkning

Certifikaten som skapats för Microsoft Entra-installationen roteras inte automatiskt.

• Azure CLI version 2.37.0 eller senare krävs
• Az.ConnectedMachine 0.5.1 eller senare krävs

Om du vill installera modulen Az.ConnectedMachine använder du az extension add --name ConnectedMachine. Om du vill kontrollera vilken version av Azure CLI som är installerad använder du az version.

Följande indataparametrar används för Azure CLI-skriptet:

• <applicationName> – Programnamn som ska skapas
• <certSubjectName> – Certifikatnamn som ska skapas
• <keyVaultName> - Ditt nyckelvalvnamn. Det här nyckelvalvet måste skapas innan skriptet körs
• <machineName> – Datornamnet på din SQL Server-värd
• <resourceGroupName>– Resursgruppsnamn som innehåller din SQL Server – Azure Arc-instans
• <adminAccountName> – Microsoft Entra-administratörskonto som du vill ange för din SQL Server
• <instanceName> – Valfri parameter för SQL Server-namngivna instanser. Använd den här parametern när du har en namngiven instans. Om det utelämnas används standardnamnet för MSSQLSERVER
• <tenantId> – Valfri parameter för klientorganisations-ID. Du hittar klientorganisations-ID:t genom att gå till Azure-portalen och gå till din Microsoft Entra-ID-resurs . I Översikt-fönstret bör du se ditt hyresgäst-ID. Om det utelämnas används standardklient-ID:t som en parameter
• <subscriptionId> – Valfri parameter för prenumerations-ID. Ditt prenumerations-ID finns i Azure-portalen. Om det utelämnas används standardprenumerations-ID:t

Om du vill använda Azure CLI-skriptet nedan sparar du skriptet som en .ps1 fil och kör följande kommando:

./aadAzCliSetup.ps1 -applicationName "<applicationName>" -certSubjectName "<certSubjectName>" -keyVaultName "<keyVaultName>" -machineName "<machineName>" -resourceGroupName "<resourceGroupName>" -adminAccountName "<adminAccountName>" -instanceName "<instanceName>" -tenantId "<tenantId>" -subscriptionId "<subscriptionId>"

Azure CLI-skriptet

Anmärkning

För SQL Server på Linux-värddatorer ersätter du WindowsAgent.SqlServer med LinuxAgent.SqlServer i skriptet.

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

Det kan ta flera minuter att köra skriptet. När processen är klar visas ett meddelande som liknar följande:

Name                   Location ProvisioningState
----                   -------- -----------------
WindowsAgent.SqlServer westus2 Succeeded
Success  

Konfigurera en Microsoft Entra-administratör med befintligt certifikat och program med hjälp av Azure CLI

Om du redan har ett befintligt Azure Key Vault-certifikat och ett Azure-program som du vill använda för att konfigurera en Microsoft Entra-administratör kan du använda följande CLI-skript:

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

PowerShell

PowerShell-skriptet nedan konfigurerar en Microsoft Entra-administratör, skapar ett Azure Key Vault-certifikat och skapar ett Microsoft Entra-program. Det finns ytterligare ett avsnitt som innehåller ett exempelskript för att konfigurera en Microsoft Entra-administratör när ett certifikat och program redan finns.

Anmärkning

Certifikaten som skapats för Microsoft Entra-konfigurationen roteras inte automatiskt.

Följande moduler krävs för den här handledningen. Installera de senaste versionerna av modulerna eller högre än den antecknade versionen nedan:

• Az.Accounts 3.37.0
• Az.ConnectedMachine 0.5.0
• Az.KeyVault 4.5.0
• Az.Resources 6.0.0

Följande indataparametrar används för PowerShell-skriptet:

• <applicationName> – Programnamn som ska skapas
• <certSubjectName> – Certifikatnamn som ska skapas
• <keyVaultName> - Ditt nyckelvalvnamn. Det här nyckelvalvet måste skapas innan skriptet körs
• <machineName> – Datornamnet för din SQL Server-värd
• <resourceGroupName>– Resursgruppsnamn som innehåller din SQL Server – Azure Arc-instans
• <adminAccountName> – Microsoft Entra-administratörskonto som du vill ange för din SQL Server
• <instanceName> – Valfri parameter för SQL Server-namngivna instanser. Använd den här parametern när du har en namngiven instans. Om det utelämnas används standardnamnet för MSSQLSERVER
• <tenantId> – Valfri parameter för klientorganisations-ID. Du hittar klientorganisations-ID:t genom att gå till Azure-portalen och gå till din Microsoft Entra-ID-resurs . I fönstret Översikt bör du se ditt Hyresgästs-ID. Om det utelämnas används standardklient-ID:t som en parameter
• <subscriptionId> – Valfri parameter för prenumerations-ID. Ditt prenumerations-ID finns i Azure-portalen. Om det utelämnas används standardprenumerations-ID:t

Om du vill använda PowerShell-skriptet nedan sparar du skriptet som en .ps1 fil och kör följande kommando:

./aadPowerShellsetup.ps1 -applicationName "<applicationName>" -certSubjectName "<certSubjectName>" -keyVaultName "<keyVaultName>" -machineName "<machineName>" -resourceGroupName "<resourceGroupName>" -adminAccountName "<adminAccountName>" -instanceName "<instanceName>" -tenantId "<tenantId>" -subscriptionId "<subscriptionId>"

PowerShell-skriptet

För SQL Server på Linux-värddatorer ersätter du WindowsAgent.SqlServer med LinuxAgent.SqlServer i skriptet.

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"

Konfigurera en Microsoft Entra-administratör med ett befintligt certifikat och ett befintligt program med hjälp av PowerShell

Om du redan har ett befintligt Azure Key Vault-certifikat och ett Azure-program som du vill använda för att konfigurera en Microsoft Entra-administratör kan du använda följande PowerShell-skript:

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

ARM-template

Följande ARM-mall konfigurerar en Microsoft Entra-administratör med hjälp av ett befintligt Azure Key Vault-certifikat och Microsoft Entra-program.

Följande indataparametrar används för ARM-mallen:

• <machineName> – Datornamnet på SQL Server-värden
• <Location> – Platsen för din SQL Server – Azure Arc-resursgrupp , till exempel West US, eller Central US
• <tenantId> – Du hittar klientorganisations-ID:t genom att gå till Azure-portalen och gå till din Microsoft Entra-ID-resurs . I fönstret Översikt bör du se ditt Hyresgäst-ID
• <instanceName> – SQL Server-instansens namn. Standardinstansnamnet för SQL Server är MSSQLSERVER
• <certSubjectName> – Certifikatnamnet som du skapade
• <subscriptionId> – Prenumerations-ID. Ditt prenumerations-ID finns i Azure-portalen
• <resourceGroupName> – Resursgruppsnamn som innehåller ditt nyckelvalv. Du hittar det fullständiga azureKeyVaultResourceUID-värdet genom att gå till nyckelvalvsresursen , välja Egenskaper och kopiera resurs-ID
• <keyVaultName> – Ditt nyckelvalvnamn
• <certIdentifier> – Certifikatidentifieraren för ditt Azure Key Vault-certifikat. Hämta certifikatidentifieraren genom att gå till nyckelvalvsresursen och välja Certifikat under Inställningar. Välj den aktuella versionen av certifikatet som du skapade och kopiera certifikatidentifierarvärdet . Mer information finns i Lägga till ett certifikat i Key Vault
• <certSecret> – Hemlighetsidentifieraren för ditt certifikat och finns på samma meny som certifikatidentifieraren
• <applicationName> – Namnet på ditt skapade Microsoft Entra-program
• <appID> - Program-ID:t (klient) för ditt Microsoft Entra-program finns på menyn Översikt i programmet
• <adminAccountName> – Microsoft Entra-administratörskonto som du vill ange för din SQL Server
• <adminID> – Objekt-ID för Microsoft Entra-användaren eller -gruppen eller programmets (klient)-ID om du använder ett annat program som Microsoft Entra-administratörskonto. Mer information finns i Självstudie: Skapa Microsoft Entra-användare med Hjälp av Microsoft Entra-program
• <adminType> – Används 0 för Microsoft Entra-användare och program och 1 för Microsoft Entra-grupper

Använd en anpassad distribution i Azure-portalenoch Skapa en egen mall i redigeraren. Sedan Spara konfigurationen när du har klistrat in exemplet.

Anmärkning

För SQL Server på Linux-värddatorer ersätter du WindowsAgent.SqlServer med LinuxAgent.SqlServer i skriptet.

{
  "$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
            }
          ]
        }
      }
    }
  ]
}

Bevilja administratörsmedgivande för programmet

När Microsoft Entra-administratören har konfigurerats kan du ansluta till SQL Server med autentiseringsuppgifterna för Microsoft Entra-administratören. Ytterligare databasaktiviteter som innebär att skapa nya Microsoft Entra-inloggningar och användare misslyckas dock tills administratörsmedgivande har beviljats till Microsoft Entra-programmet.

Anmärkning

För att ge administratörsmedgivande för programmet kräver kontot som beviljar medgivande en roll som Microsoft Entra ID Privileged Role Administrator. De här rollerna är nödvändiga för att bevilja administratörsmedgivande för programmet, men det är inte nödvändigt att konfigurera Microsoft Entra-administratören.

1. I Azure-portalen väljer duAppregistreringar för Microsoft Entra-ID> och väljer det nyligen skapade programmet. Programmet bör ha ett namn som <hostname>-<instanceName><uniqueNumber>.

2. Välj menyn API-behörigheter .

3. Välj Bevilja administratörsmedgivande.

   

Utan att ge administratörsmedgivande till programmet resulterar det i följande fel när du skapar en Microsoft Entra-inloggning eller användare i SQL Server:

Msg 37455, Level 16, State 1, Line 2
Server identity does not have permissions to access MS Graph.

Använda Microsoft Entra-autentisering för att ansluta till SQL Server

Microsoft Entra-autentisering har nu konfigurerats för din SQL Server som är ansluten till Azure Arc. Följ avsnitten efter att du har konfigurerat Microsoft Entra-administratören i artikeln Självstudie: Konfigurera Microsoft Entra-autentisering för SQL Server för att ansluta till SQL Server med Microsoft Entra-autentisering.

Se även

• Ansluta SQL Server till Azure Arc
• Microsoft Entra-autentisering för SQL Server
• Självstudie: Konfigurera Microsoft Entra-autentisering för SQL Server
• länkad server för SQL Server med Microsoft Entra-autentisering