Oktatóanyag: Az Automation használata az SQL Server Microsoft Entra-rendszergazdájának beállításához

A következőkre vonatkozik: SQL Server 2022 (16.x)

Megjegyzés

Ez a funkció az SQL Server 2022 (16.x) vagy újabb verzióiban érhető el, és csak a helyszíni SQL Serverhez, a Windows és Linux rendszerű gazdagépekhez, valamint a Windows Azure-beli virtuális gépeken futó SQL Server 2022-hez érhető el.

Ebben a cikkben bemutatjuk, hogyan állíthatja be a Microsoft Entra-rendszergazdát az SQL Serverhez készült Microsoft Entra-azonosítóval (korábbi nevén Azure Active Directory) történő hitelesítés engedélyezéséhez az Azure Portal és az API-k használatával, például:

• PowerShell
• Az Azure CLI
• ARM-sablon

A frissített funkciókat is át fogjuk járni, hogy beállítsunk egy Microsoft Entra-rendszergazdát az SQL Serverhez az Azure Portalon, amely lehetővé tenné az automatikus tanúsítványlétrehozás és -alkalmazásregisztráció használatát. Korábban a Microsoft Entra-hitelesítés SQL Serverhez való beállításához a Microsoft Entra rendszergazdájának manuális beállítása szükséges egy Azure-tanúsítvánnyal és alkalmazásregisztrációval.

Megjegyzés

Bár a Microsoft Entra ID az Azure Active Directory (Azure AD) új neve, a meglévő környezetek megzavarásának megakadályozása érdekében az Azure AD továbbra is megmarad néhány kódoltan rögzített elemben, például a felhasználói felület mezőiben, kapcsolatszolgáltatókban, hibakódokban és parancsmagokban. Ebben a cikkben a két név felcserélhető.

Előfeltételek

• Az SQL Server 2022 (16.x) vagy újabb verziója telepítve van.
• Az SQL Server csatlakoztatva van az Azure-felhőhöz. További információért lásd: Csatlakoztassa SQL Serverét az Azure Archoz.
• A Microsoft Entra-azonosító az Azure Arc-példányával azonos bérlői hitelesítésre van konfigurálva.
• Azure Key Vault szükséges.
• Az Entra ID-hitelesítés engedélyezésére vonatkozó hálózati követelmények teljesülnek.

Előkészítés a Microsoft Entra rendszergazdájának beállítása előtt

Az alábbi engedélyek szükségesek a Microsoft Entra rendszergazdájának beállításához az SQL Server – Azure Arc és Key Vault erőforrásokban.

Az Azure Arc engedélyeinek konfigurálása

Kövesse az útmutatót, és győződjön meg arról, hogy az SQL Server csatlakoztatva van az Azure Archoz. Az SQL Server – Azure Arc-erőforráshoz a Microsoft Entra rendszergazdát állító felhasználónak rendelkeznie kell a kiszolgáló közreműködői szerepkörével.

1. Nyissa meg a Azure Portal
2. Válassza az SQL Server – Azure Arc lehetőséget, és válassza ki az SQL Server-gazdagép példányát.
3. Válassza a Hozzáférés-vezérlés (IAM) lehetőséget.
4. Válassza a Hozzáadás>Szerepkör-hozzárendelés hozzáadása lehetőséget, hogy a közreműködői szerepkört hozzáadja a Microsoft Entra rendszergazdát beállító felhasználóhoz.

Az Azure Key Vault engedélyeinek konfigurálása

Hozzon létre egy Azure Key Vaultot , ha még nincs ilyenje. A Microsoft Entra rendszergazdáját állító felhasználónak rendelkeznie kell az Azure Key Vault közreműködői szerepkörével. Szerepkör hozzáadása egy felhasználóhoz az Azure Key Vaultban:

1. Nyissa meg a Azure Portal
2. Nyissa meg a Key Vault-erőforrást .
3. Válassza a Hozzáférés-vezérlés (IAM) lehetőséget.
4. Válassza a Hozzáadás>Szerepkör-hozzárendelés hozzáadása lehetőséget, hogy a közreműködői szerepkört hozzáadja a Microsoft Entra rendszergazdát beállító felhasználóhoz.

Hozzáférési szabályzatok beállítása az SQL Server-gazdagéphez

1. Az Azure Portalon lépjen az Azure Key Vault-példányra, és válassza ki az Access-szabályzatokat.

2. Válassza a Hozzáférési szabályzat hozzáadása lehetőséget.

3. A kulcsengedélyekhez használja a Sign (Aláírás) lehetőséget.

4. Titkos kódokhoz válassza a Beolvasás és a Lista lehetőséget.

5. Tanúsítványengedélyek esetén válassza a Megtekintés és Listázás lehetőséget.

6. Válassza a Következőlehetőséget.

7. Az Fő lapon keresse meg a gépe – Azure Arc-példány nevét, amely az SQL Server-gazdagép állomásneve.

   

8. Az Alkalmazás (nem kötelező) lap kihagyásához kattintson kétszer a Tovább gombra, vagy válassza a Véleményezés + létrehozás lehetőséget.

   

   Ellenőrizze, hogy a Főentitás objektumazonosító megegyezik-e a példányhoz rendelt felügyelt identitás főentitás azonosítójával.

   

   A megerősítéshez nyissa meg az erőforrásoldalt, és válassza JSON-nézet az Áttekintés lap Essentials mezőjének jobb felső sarkában. Az identitás alatt megtalálja a principalId azonosítót.

9. Válassza a Create gombot.

Az engedélyek alkalmazásának biztosításához létrehozása lehetőséget kell választania. Az engedélyek tárolásának biztosításához frissítse a böngészőablakot, és ellenőrizze, hogy az Azure Arc-példány sora továbbra is jelen van-e.

Hozzáférési szabályzatok beállítása Microsoft Entra-felhasználók számára

1. Az Azure Portalon lépjen az Azure Key Vault-példányra, és válassza ki az Access-szabályzatokat.
2. Válassza a Hozzáférési szabályzat hozzáadása lehetőséget.
3. A kulcsengedélyek esetében válassza a Beolvasás, a Lista és a Létrehozás lehetőséget.
4. Titkos engedélyekhez válassza a Beolvasás, Listázás, és Beállítás lehetőséget.
5. Tanúsítványengedélyek esetén válassza a Olvasás, Listázás és a Létrehozás lehetőséget.
6. A fő kiválasztásához adja hozzá az SQL Serverhez csatlakoztatni kívánt Microsoft Entra felhasználót.
7. Válassza a Hozzáadás, majd a Mentés lehetőséget.

A Microsoft Entra-rendszergazda beállítása az SQL Serverhez

Az új API-k és portálfunkciók lehetővé teszik a felhasználók számára, hogy microsoft entra-rendszergazdát állítsanak be az SQL Serverhez anélkül, hogy külön azure-tanúsítványt és Microsoft Entra-alkalmazást kellene létrehozniuk. Válasszon egy lapot, hogy megtudja, hogyan állíthat be Microsoft Entra rendszergazdát az Azure Archoz csatlakoztatott SQL Serverhez az automatikus tanúsítvány- és alkalmazáslétrehozással.

Megjegyzés

Az ARM-sablonhoz továbbra is létre kell hozatni egy Azure Key Vault-tanúsítványt és egy Microsoft Entra-alkalmazást a Microsoft Entra-rendszergazda beállítása előtt. A folyamattal kapcsolatos további információkért lásd : Oktatóanyag: Microsoft Entra-hitelesítés beállítása AZ SQL Serverhez.

portál

Az Azure Portal használatával beállíthat egy Microsoft Entra-rendszergazdát, létrehozhat egy Azure Key Vault-tanúsítványt és egy Microsoft Entra-alkalmazást ugyanabban a folyamatban. Ez a Microsoft Entra-hitelesítés SQL Serverrel való használatához szükséges.

Megjegyzés

Korábban a Microsoft Entra-rendszergazda beállítása előtt azure Key Vault-tanúsítványra és Microsoft Entra-alkalmazásregisztrációra volt szükség. Ez már nem szükséges, de a felhasználók továbbra is dönthetnek úgy, hogy saját tanúsítványt és alkalmazást biztosítanak a Microsoft Entra rendszergazdájának beállításához.

A Microsoft Entra rendszergazdájának beállítása az Azure Portal használatával

1. Nyissa meg az Azure Portalt, és válassza az SQL Server – Azure Arc lehetőséget. Válassza ki az SQL Server-gazdagép példányát.

2. Ellenőrizze a SQL Server – Azure Arc erőforrás állapotát, és ellenőrizze, hogy csatlakoztatva van-e a Tulajdonságok menüben. További információ: Arc-kompatibilis SQL Server-erőforrások érvényesítése.

3. Válassza a Microsoft Entra ID és Purview lehetőséget az erőforrásmenü Beállítások területén .

4. Válassza a Rendszergazda beállítása lehetőséget a Microsoft Entra ID panel megnyitásához, és válasszon ki egy fiókot, amelyet rendszergazdai bejelentkezésként ad hozzá az SQL Serverhez.

5. Válassza ki a szolgáltatás által felügyelt tanúsítványt.

6. Válassza a Kulcstartó módosítása lehetőséget, és válassza ki a meglévő Azure Key Vault-erőforrást.

7. Válassza ki a szolgáltatás által felügyelt alkalmazásregisztrációt.

8. Válassza az Mentésgombot. Ez egy kérést küld az Arc-kiszolgálóügynöknek, amely konfigurálja a Microsoft Entra-hitelesítést az adott SQL Server-példányhoz. A művelet végrehajtása több percet is igénybe vehet; várjon, amíg a mentési folyamat megerősítést Saved successfully nyer, mielőtt megkísérli a Microsoft Entra-bejelentkezést.

   A szolgáltatás által felügyelt alkalmazásregisztráció az alábbiakat végzi El Önnek:

   • Létrehoz egy tanúsítványt a kulcstárban egy névvel a következő formátumban: <hostname>-<instanceName><uniqueNumber>.
   • Létrehoz egy Microsoft Entra-alkalmazást egy hasonló <hostname>-<instanceName><uniqueNumber>nevű alkalmazással, és hozzárendeli a szükséges engedélyeket az adott alkalmazáshoz. További információ: Alkalmazásengedélyek megadása
   • Hozzárendeli az új tanúsítványt az Azure Key Vaultban az alkalmazáshoz.
   • Menti ezeket a beállításokat az Azure Arcba.

   

Megjegyzés

A Microsoft Entra számára létrehozott tanúsítványok nem lesznek automatikusan elforgatva. Az ügyfelek dönthetnek úgy, hogy saját tanúsítványt és alkalmazást biztosítanak a Microsoft Entra rendszergazdai beállításához. További információ : Oktatóanyag: Microsoft Entra-hitelesítés beállítása AZ SQL Serverhez.

Az Azure CLI

Az alábbi Azure CLI-szkript beállít egy Microsoft Entra-rendszergazdát, létrehoz egy Azure Key Vault-tanúsítványt, és létrehoz egy Microsoft Entra-alkalmazást. Van egy további szakasz, amely egy mintaszkriptet biztosít a Microsoft Entra rendszergazdájának beállításához, ha már létezik tanúsítvány és alkalmazás.

Megjegyzés

A Microsoft Entra beállításához létrehozott tanúsítványok nem lesznek automatikusan elforgatva.

• Az Azure CLI 2.37.0-s vagy újabb verziója szükséges
• Az.ConnectedMachine 0.5.1 vagy újabb verzió szükséges

A Az.ConnectedMachine modul telepítéséhez használja a az extension add --name ConnectedMachine parancsot. Az Azure CLI telepített verziójának ellenőrzéséhez használja a következőt az version: .

Az Azure CLI-szkripthez a következő bemeneti paraméterek használhatók:

• <applicationName> - Létrehozandó alkalmazásnév
• <certSubjectName> - A létrehozandó tanúsítvány neve
• <keyVaultName> - A kulcstár neve. Ezt a kulcstartót a szkript futtatása előtt létre kell hozni
• <machineName> - Az SQL Server-gazdagép gépneve
• <resourceGroupName>– Az erőforráscsoport neve, amely tartalmazza az SQL Server – Azure Arc-példányt
• <adminAccountName> – Az SQL Serverhez beállítani kívánt Microsoft Entra rendszergazdai fiók
• <instanceName> – Nem kötelező paraméter nevesített SQL Server-példányokhoz. Ezt a paramétert akkor használja, ha elnevezett példánnyal rendelkezik. Ha nincs megadva, a rendszer az alapértelmezett nevet MSSQLSERVER használja
• <tenantId> - Nem kötelező paraméter a bérlőazonosítóhoz. A bérlőazonosító az Azure Portalon és a Microsoft Entra ID-erőforrásban található. Az Áttekintés panelen meg kell jelennie a bérlőazonosítónak. Ha nincs megadva, a rendszer az alapértelmezett bérlőazonosítót használja paraméterként
• <subscriptionId> - Nem kötelező paraméter az előfizetés-azonosítóhoz. Az előfizetés-azonosító az Azure Portalon található. Ha nincs megadva, a rendszer az alapértelmezett előfizetés-azonosítót használja

Az alábbi Azure CLI-szkript használatához mentse a szkriptet fájlként .ps1 , és futtassa a következő parancsot:

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

Az Azure CLI-szkript

Megjegyzés

Linux rendszerű gazdagépeken futó SQL Server esetén a szkriptben cserélje le a(z) WindowsAgent.SqlServer elemet a(z) LinuxAgent.SqlServer elemre.

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

A szkript futtatása több percet is igénybe vehet. Ha a folyamat befejeződött, a következőhöz hasonló üzenet jelenik meg:

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

Microsoft Entra-rendszergazda beállítása meglévő tanúsítvánnyal és alkalmazással az Azure CLI használatával

Ha már rendelkezik egy meglévő Azure Key Vault-tanúsítvánnyal és egy Olyan Azure-alkalmazással, amelyet a Microsoft Entra-rendszergazda beállításához szeretne használni, a következő CLI-szkriptet használhatja:

# 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

Az alábbi PowerShell-szkript beállít egy Microsoft Entra-rendszergazdát, létrehoz egy Azure Key Vault-tanúsítványt, és létrehoz egy Microsoft Entra-alkalmazást. Van egy további szakasz, amely egy mintaszkriptet biztosít a Microsoft Entra rendszergazdájának beállításához, ha már létezik tanúsítvány és alkalmazás.

Megjegyzés

A Microsoft Entra beállításához létrehozott tanúsítványok nem lesznek automatikusan elforgatva.

Az oktatóanyaghoz a következő modulok szükségesek. Telepítse a modulok legújabb vagy az alábbinál magasabb verzióját:

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

A PowerShell-szkripthez a következő bemeneti paraméterek használhatók:

• <applicationName> - Létrehozandó alkalmazásnév
• <certSubjectName> - A létrehozandó tanúsítvány neve
• <keyVaultName> - A kulcstár neve. Ezt a kulcstartót a szkript futtatása előtt létre kell hozni
• <machineName> - Az SQL Server-gazdagép gépneve
• <resourceGroupName>– Az erőforráscsoport neve, amely tartalmazza az SQL Server – Azure Arc-példányt
• <adminAccountName> – Az SQL Serverhez beállítani kívánt Microsoft Entra rendszergazdai fiók
• <instanceName> – Nem kötelező paraméter nevesített SQL Server-példányokhoz. Ezt a paramétert akkor használja, ha elnevezett példánnyal rendelkezik. Ha nincs megadva, a rendszer az alapértelmezett nevet MSSQLSERVER használja
• <tenantId> - Nem kötelező paraméter a bérlőazonosítóhoz. A bérlőazonosító az Azure Portalon és a Microsoft Entra ID-erőforrásban található. Az Áttekintés panelen meg kell jelennie a bérlőazonosítónak. Ha nincs megadva, a rendszer az alapértelmezett bérlőazonosítót használja paraméterként
• <subscriptionId> - Nem kötelező paraméter az előfizetés-azonosítóhoz. Az előfizetés-azonosító az Azure Portalon található. Ha nincs megadva, a rendszer az alapértelmezett előfizetés-azonosítót használja

Az alábbi PowerShell-szkript használatához mentse a szkriptet fájlként .ps1 , és futtassa a következő parancsot:

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

A PowerShell-szkript

Linux rendszerű gazdagépeken futó SQL Server esetén a szkriptben cserélje le a(z) WindowsAgent.SqlServer elemet a(z) LinuxAgent.SqlServer elemre.

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"

Microsoft Entra-rendszergazda beállítása meglévő tanúsítvánnyal és alkalmazással a PowerShell használatával

Ha már rendelkezik egy meglévő Azure Key Vault-tanúsítvánnyal és egy Olyan Azure-alkalmazással, amelyet a Microsoft Entra rendszergazdájának beállításához szeretne használni, a következő PowerShell-szkriptet használhatja:

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

Az alábbi ARM-sablon beállít egy Microsoft Entra-rendszergazdát egy meglévő Azure Key Vault-tanúsítvány és a Microsoft Entra-alkalmazás használatával.

Az ARM-sablonhoz a következő bemeneti paraméterek használhatók:

• <machineName> - Az SQL Server-gazdagép gépneve
• <Location> – Az SQL Server – Azure Arc-erőforráscsoport elhelyezkedése, például West US vagy Central US
• <tenantId> – A bérlőazonosítót az Azure Portalon keresztül, a Microsoft Entra ID erőforráshoz navigálva találhatja meg. Az Áttekintés panelen meg kell jelennie a bérlőazonosítónak
• <instanceName> - SQL Server-példány neve. Az SQL Server alapértelmezett példányneve a következő: MSSQLSERVER
• <certSubjectName> - A létrehozott tanúsítvány neve
• <subscriptionId> - Előfizetés azonosítója. Az előfizetés azonosítója az Azure Portalon található
• <resourceGroupName> - A kulcstárat tartalmazó erőforráscsoport neve. A teljes azureKeyVaultResourceUID érték a Key Vault-erőforrásra való ugrással, a Tulajdonságok kiválasztásával és az erőforrás-azonosító másolásával érhető el
• <keyVaultName> - Kulcstár vagy kulcsszéf neve
• <certIdentifier> - Az Azure Key Vault-tanúsítvány tanúsítványazonosítója . A tanúsítványazonosító beszerzéséhez nyissa meg a Key Vault-erőforrást, és válassza a Tanúsítványok lehetőséget a Beállítások területen. Válassza ki a létrehozott tanúsítvány aktuális verzióját, és másolja ki a tanúsítványazonosító értékét. További információ: Tanúsítvány hozzáadása a Key Vaulthoz
• <certSecret>– A tanúsítvány titkos azonosítója, és a tanúsítványazonosítóval megegyező menüben található
• <applicationName>- A létrehozott Microsoft Entra-alkalmazás neve
• <appID> – A Microsoft Entra-alkalmazás alkalmazásazonosítója (ügyfélazonosítója) az alkalmazás Áttekintés menüjében található
• <adminAccountName> – Az SQL Serverhez beállítani kívánt Microsoft Entra rendszergazdai fiók
• <adminID> – A Microsoft Entra-felhasználó vagy -csoport objektumazonosítója , illetve az alkalmazás (ügyfél) azonosítója , ha egy másik alkalmazást használ Microsoft Entra rendszergazdai fiókként. További információ : Oktatóanyag: Microsoft Entra-felhasználók létrehozása Microsoft Entra-alkalmazások használatával
• <adminType> – Használata 0 Microsoft Entra-felhasználók és -alkalmazások, valamint 1 Microsoft Entra-csoportok esetén

Használjon egyéni üzembe helyezést az Azure portálonés építse meg saját sablonját a szerkesztőben. Ezután Mentse a konfigurációt, miután beillesztette a példát.

Megjegyzés

Linux rendszerű gazdagépeken futó SQL Server esetén a szkriptben cserélje le a(z) WindowsAgent.SqlServer elemet a(z) LinuxAgent.SqlServer elemre.

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

Rendszergazdai hozzájárulás megadása az alkalmazáshoz

A Microsoft Entra rendszergazdájának beállítása után a Microsoft Entra rendszergazdai hitelesítő adataival csatlakozhat az SQL Serverhez. Az új Microsoft Entra-bejelentkezések és -felhasználók létrehozásával kapcsolatos további adatbázis-tevékenységek azonban mindaddig sikertelenek lesznek, amíg a microsoft entra alkalmazás rendszergazdai hozzájárulást nem kap.

Megjegyzés

Ahhoz, hogy rendszergazdai hozzájárulást adjon az alkalmazáshoz, a hozzájárulást megadó fiókhoz a Microsoft Entra ID Privileged Role Administrator szerepkörre van szükség. Ezek a szerepkörök szükségesek ahhoz, hogy rendszergazdai hozzájárulást adjanak az alkalmazáshoz, de nem szükséges a Microsoft Entra rendszergazdájának beállításához.

1. Az Azure Portalon válassza a Microsoft Entra ID>alkalmazásregisztrációit, és válassza ki az újonnan létrehozott alkalmazást. Az alkalmazásnak olyan névvel kell rendelkeznie, mint a <hostname>-<instanceName><uniqueNumber>.

2. Válassza az API-engedélyek menüt .

3. Válassza a Rendszergazdai hozzájárulás megadása elemet.

   

Ha nem ad rendszergazdai hozzájárulást az alkalmazáshoz, a Microsoft Entra-bejelentkezés vagy -felhasználó SQL Serveren való létrehozása a következő hibát eredményezi:

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

Microsoft Entra-hitelesítés használata az SQL Serverhez való csatlakozáshoz

A Microsoft Entra-hitelesítés most már be van állítva az Azure Archoz csatlakoztatott SQL Serverhez. Kövesse a Microsoft Entra-rendszergazda beállítását követő szakaszokat az oktatóanyagban: Az SQL Serverhez készült Microsoft Entra-hitelesítés beállítása az SQL Serverhez való csatlakozáshoz a Microsoft Entra-hitelesítés használatával.

Lásd még

• Az SQL Server csatlakoztatása az Azure Arc-hoz
• Microsoft Entra-hitelesítés az SQL Serverhez
• Oktatóanyag: A Microsoft Entra hitelesítés beállítása az SQL Serverhez
• Kapcsolt kiszolgáló az SQL Serverhez Microsoft Entra-hitelesítéssel