Configurare SQL Server abilitato da Azure Arc

Si applica a:SQL Server

Ogni server con abilitazione Azure Arc include un set di proprietà che si applicano a tutte le istanze di SQL Server installate nel server in oggetto. È possibile configurare tali proprietà dopo l'installazione dell'estensione Azure per SQL Server nel computer. Tuttavia, le proprietà hanno effetto solo se vengono installate una o più istanze di SQL Server. Nel portale di Azure, il riquadro Panoramica per SQL Server abilitato da Azure Arc riflette il modo in cui la configurazione di SQL Server influisce su una particolare istanza.

Prerequisiti

• Si ha un ruolo Collaboratore in almeno una delle sottoscrizioni di Azure create dall'organizzazione. Informazioni su come creare una nuova sottoscrizione di fatturazione.

• Si ha un ruolo Collaboratore per il gruppo di risorse in cui l'istanza di SQL Server verrà registrata. Per informazioni dettagliate, si veda Gruppi di risorse Azure gestiti.

• I provider di risorse Microsoft.AzureArcData e Microsoft.HybridCompute sono registrati in ogni sottoscrizione usata per la fatturazione con pagamento in base al consumo di SQL Server.

Registrare i provider di risorse

Per registrare i provider di risorse, usare uno dei metodi seguenti:

Register-AzResourceProvider -ProviderNamespace Microsoft.AzureArcData

az provider register --namespace 'Microsoft.AzureArcData'

Modificare la configurazione di SQL Server

È possibile usare il portale di Azure, Azure PowerShell o l'interfaccia della riga di comando di Azure per modificare tutte o alcune impostazioni di configurazione su un server specifico abilitato per Azure Arc nello stato desiderato.

Per modificare la configurazione di SQL Server per un ambito più ampio (ad esempio un gruppo di risorse, una sottoscrizione o più sottoscrizioni) con un singolo comando, usare lo script di PowerShell modify-license-type.ps1. Viene pubblicato come campione open source di SQL Server e include istruzioni descritte in passaggi.

Si consiglia di eseguire lo script da Azure Cloud Shell perché:

• Include i moduli di Azure PowerShell necessari preinstallati.
• Esegue automaticamente l'autenticazione.

Per informazioni dettagliate, vedere Esecuzione dello script con Cloud Shell.

# Updated settings object
$Settings = @{
    SqlManagement = @{ IsEnabled = $true };
    ExcludedSqlInstances = @( "Foo", "Bar");
    LicenseType = "PAYG";
    enableExtendedSecurityUpdates = $True;
    esuLastUpdatedTimestamp = [DateTime]::UtcNow.ToString('yyyy-MM-ddTHH:mm:ss.fffZ')
}

# Command stays the same as before; only Settings is changed
New-AzConnectedMachineExtension -Name "WindowsAgent.SqlServer" -ResourceGroupName { your resource group name } -MachineName { your machine name } -Location { azure region } -Publisher "Microsoft.AzureData" -Settings $Settings -ExtensionType "WindowsAgent.SqlServer"

az connectedmachine extension update --machine-name "simple-vm" -g "<resource-group>" --name "WindowsAgent.SqlServer" --type "WindowsAgent.SqlServer" --publisher "Microsoft.AzureData" --settings '{"LicenseType":"PAYG", "SqlManagement": {"IsEnabled":true}}'

Sottoscrivere aggiornamenti di sicurezza estesa su larga scala mediante criteri di Azure

È possibile attivare la sottoscrizione agli aggiornamenti di sicurezza estesa in più computer abilitati per Arc usando una definizione di criteri di Azure denominata Sottoscrivere istanze di SQL Server abilitate per Arc idonee per gli aggiornamenti di sicurezza estesa.

Quando si crea un'assegnazione di questa definizione di criteri a un ambito di tua scelta, ciò abilita gli aggiornamenti di sicurezza estesa in tutti i computer abilitati da Arc in cui è installata l'estensione Azure per SQL Server. Se uno di questi computer dispone di un'istanza di SQL Server qualificata, la sottoscrizione agli aggiornamenti di sicurezza estesa viene attivata immediatamente.

Per attivare questo criterio, segui i passaggi seguenti:

1. Passare a Criteri di Azure nel portale di Azure e selezionare Definizioni.

2. Cercare Sottoscrivere istanze di SQL Server abilitate per Arc idonee per gli aggiornamenti di sicurezza estesa e fare clic con il pulsante destro del mouse sul criterio.

3. Seleziona Assegna criterio.

4. Seleziona una sottoscrizione e, facoltativamente, un gruppo di risorse come ambito.

5. Accertati che l’applicazione del criterio sia Abilitata.

6. Nella scheda Parametri, imposta il valore di Abilita aggiornamenti di sicurezza estesa su vero.

7. Nella scheda Rimedio:

   1. Seleziona Crea task di rimedio per applicare questo criterio alle risorse esistenti. Se non si seleziona questa opzione, i criteri vengono applicati solo alle risorse appena create.
   2. Selezionare Creare un'identità gestita e poi Identità gestita assegnata dal sistema (scelta consigliata) o Identità gestita assegnata dall'utente con estensione di Azure per la distribuzione di SQL Server e autorizzazioni Lettore.
   3. Seleziona la posizione dell'identità.

8. Selezionare Rivedi e crea.

9. Seleziona Crea.

Inviare query sulla configurazione di SQL Server

È possibile usare Azure Resource Graph per eseguire query sulle impostazioni di configurazione di SQL Server all'interno di un ambito selezionato. Vedere gli esempi seguenti.

Ricevere il conteggio per tipo di licenza

In questo esempio viene riportato il conteggio per tipo di licenza:

resources
| where type == "microsoft.hybridcompute/machines/extensions"
| where properties.type in ("WindowsAgent.SqlServer","LinuxAgent.SqlServer")
| extend licenseType = iff(properties.settings.LicenseType == '', 'Configuration needed', properties.settings.LicenseType)
| summarize count() by tostring(licenseType)

Identificare le istanze in cui il tipo di licenza è indefinito

Questa query fornisce un elenco di istanze in cui il tipo di licenza è null null:

resources
| where type == "microsoft.hybridcompute/machines/extensions"
| where properties.type in ("WindowsAgent.SqlServer","LinuxAgent.SqlServer")
| where isnull(properties.settings.LicenseType)
| project ['id'], resourceGroup, subscriptionId

Elencare i dettagli di configurazione per ogni istanza di SQL Server

Questa query identifica molti dettagli su ciascuna istanza, tra cui il tipo di licenza, l'impostazione degli aggiornamenti della sicurezza estesa e le funzionalità abilitate:

resources
| where type == "microsoft.hybridcompute/machines"
| where properties.detectedProperties.mssqldiscovered == "true"
| extend machineIdHasSQLServerDiscovered = id
| project name, machineIdHasSQLServerDiscovered, resourceGroup, subscriptionId
| join kind= leftouter (
    resources
    | where type == "microsoft.hybridcompute/machines/extensions"    | where properties.type in ("WindowsAgent.SqlServer","LinuxAgent.SqlServer")
    | extend machineIdHasSQLServerExtensionInstalled = iff(id contains "/extensions/WindowsAgent.SqlServer" or id contains "/extensions/LinuxAgent.SqlServer", substring(id, 0, indexof(id, "/extensions/")), "")
    | project Extension_State = properties.provisioningState,
    License_Type = properties.settings.LicenseType,
    ESU = iff(notnull(properties.settings.enableExtendedSecurityUpdates), iff(properties.settings.enableExtendedSecurityUpdates == true,"enabled","disabled"), ""),
    Extension_Version = properties.instanceView.typeHandlerVersion,
    Excluded_instances = properties.ExcludedSqlInstances,
    Purview = iff(notnull(properties.settings.ExternalPolicyBasedAuthorization),"enabled",""),
    Entra = iff(notnull(properties.settings.AzureAD),"enabled",""),
    BPA = iff(notnull(properties.settings.AssessmentSettings),"enabled",""),
    machineIdHasSQLServerExtensionInstalled)on $left.machineIdHasSQLServerDiscovered == $right.machineIdHasSQLServerExtensionInstalled
| where isnotempty(machineIdHasSQLServerExtensionInstalled)
| project-away machineIdHasSQLServerDiscovered, machineIdHasSQLServerExtensionInstalled

Elencare i server con abilitazione Azure Arc che presentano istanze di SQL Server

Questa query identifica i server con abilitazione Azure Arc su cui sono state individuate istanze di SQL Server:

resources
| where type == "microsoft.hybridcompute/machines"
| where properties.detectedProperties.mssqldiscovered == "true"
//| summarize count()

Questa query restituisce i server con abilitazione Azure Arc che presentano istanze di SQL Server, ma in cui l'estensione Azure Arc SQL Server non è installata. Questa query si applica solo ai server Windows.

resources
| where type == "microsoft.hybridcompute/machines"
| where properties.detectedProperties.mssqldiscovered == "true"
| project machineIdHasSQLServerDiscovered = id
| join kind= leftouter (
    resources
    | where type == "microsoft.hybridcompute/machines/extensions"
    | where properties.type == "WindowsAgent.SqlServer"
    | project machineIdHasSQLServerExtensionInstalled = substring(id, 0, indexof(id, "/extensions/WindowsAgent.SqlServer")))
on $left.machineIdHasSQLServerDiscovered == $right.machineIdHasSQLServerExtensionInstalled
| where isempty(machineIdHasSQLServerExtensionInstalled)
| project machineIdHasSQLServerDiscoveredButNotTheExtension = machineIdHasSQLServerDiscovered

Per altri esempi di query di Azure Resource Graph, vedere Esempi di query di avvio di Resource Graph.

Elencare le istanze di SQL Server abilitate per Azure Arc sottoscritte per gli ESU

Nell'esempio seguente viene illustrato come visualizzare tutte le istanze di SQL Server 2012 (11.x) o SQL Server 2014 (12.x) idonee e il relativo stato della sottoscrizione ESU:

resources
| where type == 'microsoft.azurearcdata/sqlserverinstances'
| extend Version = properties.version
| extend Edition = properties.edition
| extend containerId = tolower(tostring (properties.containerResourceId))
| where Version in ("SQL Server 2012", "SQL Server 2014")
| where Edition in ("Enterprise", "Standard")
| where isnotempty(containerId)
| project containerId, SQL_instance = name, Version, Edition
| join kind=inner (
    resources
    | where type == "microsoft.hybridcompute/machines"
    | extend machineId = tolower(tostring(id))
    | project machineId, Machine_name = name
)
on $left.containerId == $right.machineId
| join kind=inner (
    resources
    | where type == "microsoft.hybridcompute/machines/extensions"
    | where properties.type in ("WindowsAgent.SqlServer","LinuxAgent.SqlServer")
    | extend machineIdHasSQLServerExtensionInstalled = tolower(iff(id contains "/extensions/WindowsAgent.SqlServer" or id contains "/extensions/LinuxAgent.SqlServer", substring(id, 0, indexof(id, "/extensions/")), ""))
    | project machineIdHasSQLServerExtensionInstalled,
     Extension_State = properties.provisioningState, 
     License_Type = properties.settings.LicenseType, 
     ESU = iff(notnull(properties.settings.enableExtendedSecurityUpdates), iff(properties.settings.enableExtendedSecurityUpdates == 'true',"ENABLED","disabled"), "disabled"),
     Extension_Version = properties.instanceView.typeHandlerVersion
)
on $left.machineId == $right.machineIdHasSQLServerExtensionInstalled
| project-away machineId, containerId, machineIdHasSQLServerExtensionInstalled

Elencare i server abilitati per Azure Arc che ospitano un'istanza fatturabile di SQL Server

Questa query identifica le macchine connesse (virtuali o fisiche) che ospitano istanze di SQL Server e che sono fatturabili o richiedono una licenza per il software SQL Server. Fornisce i dettagli della configurazione di SQL Server, tra cui il tipo di licenza, l'impostazione ESU, le dimensioni in v-core o p-core e altri parametri pertinenti.

resources
| where type =~ 'Microsoft.HybridCompute/machines'
| extend status = tostring(properties.status)
| where status =~ 'Connected'
| extend machineID = tolower(id)
| extend VMbyManufacturer = toboolean(iff(properties.detectedProperties.manufacturer in (
        "VMware",
        "QEMU",
        "Amazon EC2",
        "OpenStack",
        "Hetzner",
        "Mission Critical Cloud",
        "DigitalOcean",
        "UpCloud",
        "oVirt",
        "Alibaba",
        "KubeVirt",
        "Parallels",
        "XEN"
    ), 1, 0))
| extend VMbyModel = toboolean(iff(properties.detectedProperties.model in (
        "OpenStack",
        "Droplet",
        "oVirt",
        "Hypervisor",
        "Virtual",
        "BHYVE",
        "KVM"
    ), 1, 0))
| extend GoogleVM = toboolean(iff((properties.detectedProperties.manufacturer =~ "Google") and (properties.detectedProperties.model =~ "Google Compute Engine"), 1, 0))
| extend NutanixVM = toboolean(iff((properties.detectedProperties.manufacturer =~ "Nutanix") and (properties.detectedProperties.model =~ "AHV"), 1, 0))
| extend MicrosoftVM = toboolean(iff((properties.detectedProperties.manufacturer =~ "Microsoft Corporation") and (properties.detectedProperties.model =~ "Virtual Machine"), 1, 0))
| extend billableCores = iff(VMbyManufacturer or VMbyModel or GoogleVM or NutanixVM or MicrosoftVM, properties.detectedProperties.logicalCoreCount, properties.detectedProperties.coreCount)
| join kind = leftouter // Join the extension
        (
        resources
        | where type =~ 'Microsoft.HybridCompute/machines/extensions'
        | where name == 'WindowsAgent.SqlServer' or name == 'LinuxAgent.SqlServer'
        | extend extMachineID = substring(id, 0, indexof(id, '/extensions'))
        | extend extensionId = id
        )
        on $left.id == $right.extMachineID
        | join kind = inner       // Join SQL Server instances
            (
            resources
            | where type =~ 'microsoft.azurearcdata/sqlserverinstances'
            | extend sqlVersion = tostring(properties.version)
            | extend sqlEdition = tostring(properties.edition)
            | extend is_Enterprise = toint(iff(sqlEdition == "Enterprise", 1, 0))
            | extend sqlStatus = tostring(properties.status)
            | extend licenseType = tostring(properties.licenseType)
            | where sqlEdition in ('Enterprise', 'Standard')
            | where licenseType !~ 'HADR'
            | extend ArcServer = tolower(tostring(properties.containerResourceId))
            | order by sqlEdition
            )
            on $left.machineID == $right.ArcServer
            | where isnotnull(extensionId)
            | summarize Edition = iff(sum(is_Enterprise) > 0, "Enterprise", "Standard") by machineID
            , name
            , resourceGroup
            , subscriptionId
            , Status = tostring(properties.status)
            , Model = tostring(properties.detectedProperties.model)
            , Manufacturer = tostring(properties.detectedProperties.manufacturer)
            , License_Type = tostring(properties1.settings.LicenseType)
            , ESU = iff(notnull(properties1.settings.enableExtendedSecurityUpdates), iff(properties1.settings.enableExtendedSecurityUpdates == true,"enabled","not enabled"), "not enabled")
            , OS = tostring(properties.osName)
            , Uses_UV = tostring(properties1.settings.UsePhysicalCoreLicense.IsApplied)
            , Cores = tostring(billableCores)
            , Version = sqlVersion
            | summarize by name, subscriptionId, resourceGroup, Model, Manufacturer, License_Type, ESU, OS, Cores, Status
            | project Name = name, Model, Manufacturer, OperatingSystem = OS, Status, HostLicenseType = License_Type, ESU, BillableCores = Cores, SubscriptionID = subscriptionId, ResourceGroup = resourceGroup
            | order by Name asc

Gestire il vantaggio di virtualizzazione illimitata per SQL Server

Per abilitare la virtualizzazione illimitata, SQL Server abilitato da Azure Arc supporta il tipo di risorsa speciale SQLServerLicense. Si può usare questa risorsa per concedere in licenza molte macchine virtuali con le istanze di SQL Server installate. Per informazioni dettagliate sul modello di licenza, si veda Licenze di istanze di SQL Server con virtualizzazione illimitata.

Prerequisiti

Il ruolo controllo degli accessi in base al ruolo (RBAC) include le seguenti autorizzazioni:

• Microsoft.AzureArcData/SqlLicenses/read
• Microsoft.AzureArcData/SqlLicenses/write
• Microsoft.Management/managementGroups/read
• Microsoft.Resources/subscriptions/read
• Microsoft.Resources/subscriptions/resourceGroups/read
• Microsoft.Support/supporttickets/write

Creare una licenza di SQL Server

Per creare la risorsa di licenza di SQL Server, usare uno dei metodi seguenti:

$subscriptionId="<sub id>"
$apiVersion="2024-03-01-preview"
$templateFile="sqlserverlicense.json"

$resourceGroupName="<rg-name>"
$uri = "https://management.azure.com/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.AzureArcData/sqlserverlicenses/{2}?api-version={3}" -f $subscriptionId, $resourceGroupName, $serverName, $apiVersion

az rest --method put --uri "$uri" --body "@$templateFile" --headers "Content-Type=application/json"

"location": "westeurope",
"properties": {
    "billingPlan": "PAYG",
    "physicalCores": 32,
    "activationState": "Deactivated",
    "scopeType": "ResourceGroup",
    "licenseCategory": "Core"
}

Aggiornare una risorsa di licenza di SQL Server

Per modificare la proprietà della licenza di SQL Server (ad esempio per attivarla in un secondo momento) usare uno dei metodi seguenti:

$subscriptionId="<sub id>"
$apiVersion="2024-03-01-preview"
$templateFile="activate.json"

$resourceGroupName="<rg-name>"
$uri = "https://management.azure.com/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.AzureArcData/sqlserverlicenses/{2}?api-version={3}" -f $subscriptionId, $resourceGroupName, $serverName, $apiVersion

az rest --method patch --uri "$uri" --body "@$templateFile" --headers "Content-Type=application/json"

{
  "activationState": "Activated"
}

Gestire le risorse nell'ambito di una licenza p-core

È possibile gestire le risorse nell'ambito di una licenza della memoria centrale fisica di SQL Server specifica attenendosi alla procedura seguente:

Elencare i server abilitati per Azure Arc nell'ambito della licenza di SQL Server

Questa query elenca tutti i server abilitati per Azure Arc nell'ambito della licenza e le proprietà pertinenti di ognuno di essi:

resources
        | where type =~ 'Microsoft.HybridCompute/machines'
        | where ('${scopeType}'!= 'Subscription' or subscriptionId == '${subscription}')
        | where ('${scopeType}' != 'ResourceGroup' or (resourceGroup == '${resourceGroup.toLowerCase()}' and subscriptionId == '${subscription}'))
        | extend status = tostring(properties.status)
        | where status =~ 'Connected'
        | join kind = leftouter
        (
        resources
        | where type =~ 'Microsoft.HybridCompute/machines/extensions'
        | where name == 'WindowsAgent.SqlServer' or name == 'LinuxAgent.SqlServer'
        | extend machineId = substring(id, 0, indexof(id, '/extensions'))
        | extend extensionId = id
        )
        on $left.id == $right.machineId
        | where isnotnull(extensionId)
        | project id, name, properties.status, resourceGroup, subscriptionId, Model = properties.detectedProperties.model, Manufacturer = properties.detectedProperties.manufacturer, kind, OSE = properties.osName, License_applied = properties1.settings.UsePhysicalCoreLicense.IsApplied
        |order by name asc

Gestire il vantaggio di virtualizzazione illimitato per una sottoscrizione ESU di SQL Server

Per abilitare la virtualizzazione illimitata per una sottoscrizione ESU, SQL Server abilitato da Azure Arc supporta un tipo di risorsa speciale: SQLServerEsuLicense. Si può usare questa risorsa per abilitare una sottoscrizione ESU per un set di host fisici con un numero illimitato di macchine virtuali che eseguono le istanze di SQL Server non supportate. Per informazioni dettagliate sul modello di licenza, si veda Sottoscrivere le ESU di SQL Server per core fisici con virtualizzazione illimitata.

Prerequisiti

Il ruolo Controllo degli accessi in base al ruolo include le autorizzazioni seguenti:

• Microsoft.AzureArcData/SqlLicenses/read
• Microsoft.AzureArcData/SqlLicenses/write
• Microsoft.Management/managementGroups/read
• Microsoft.Resources/subscriptions/read
• Microsoft.Resources/subscriptions/resourceGroups/read
• Microsoft.Support/supporttickets/write

Creare una risorsa di licenza ESU di SQL Server

Per creare una risorsa di licenza ESU di SQL Server, usare uno dei metodi seguenti:

$subscriptionId="<sub id>"
$apiVersion="2024-03-01-preview"
$templateFile="sqlserverlicense.json"

$resourceGroupName="<rg-name>"
$uri = "https://management.azure.com/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.AzureArcData/SqlServerEsuLicenses/{2}?api-version={3}" -f $subscriptionId, $resourceGroupName, $serverName, $apiVersion

az rest --method put --uri "$uri" --body "@$templateFile" --headers "Content-Type=application/json"

"location": "westeurope",
"properties": {
    "billingPlan": "PAYG",
    "physicalCores": 32,
    "activationState": "Active",
    "scopeType": "ResourceGroup",
    "version": "2014"
}

Aggiornare una risorsa di licenza ESU di SQL Server

Per modificare le proprietà della licenza ESU di SQL Server (ad esempio per terminare la sottoscrizione) usare uno dei metodi seguenti:

$subscriptionId="<sub id>"
$apiVersion="2024-03-01-preview"
$templateFile="terminate.json"

$resourceGroupName="<rg-name>"
$uri = "https://management.azure.com/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.AzureArcData/SqlServerEsuLicenses/{2}?api-version={3}" -f $subscriptionId, $resourceGroupName, $serverName, $apiVersion

az rest --method patch --uri "$uri" --body "@$templateFile" --headers "Content-Type=application/json"

{
  "activationState": "Terminated"
}

Gestire le risorse nell'ambito di una licenza p-core ESU

È possibile gestire le risorse nell'ambito di una licenza ESU di SQL Server specifica attenendosi alla procedura seguente:

Elencare i server abilitati per Azure Arc nell'ambito di una licenza ESU di SQL Server

Questa query elenca tutti i server abilitati per Azure Arc nell'ambito della licenza e le proprietà pertinenti di ognuno di essi:

resources
        | where type =~ 'Microsoft.HybridCompute/machines'
        | where ('${scopeType}'!= 'Subscription' or subscriptionId == '${subscription}')
        | where ('${scopeType}' != 'ResourceGroup' or (resourceGroup == '${resourceGroup.toLowerCase()}' and subscriptionId == '${subscription}'))
        | extend status = tostring(properties.status)
        | where status =~ 'Connected'
        | join kind = leftouter
        (
        resources
        | where type =~ 'Microsoft.HybridCompute/machines/extensions'
        | where name == 'WindowsAgent.SqlServer' or name == 'LinuxAgent.SqlServer'
        | extend machineId = substring(id, 0, indexof(id, '/extensions'))
        | extend extensionId = id
        )
        on $left.id == $right.machineId
        | where isnotnull(extensionId)
        | project id, name, properties.status, resourceGroup, subscriptionId, Model = properties.detectedProperties.model, Manufacturer = properties.detectedProperties.manufacturer, kind, OSE = properties.osName, License_applied = properties1.settings.UseEsuPhysicalCoreLicense.IsApplied
        |order by name asc

Contenuto correlato

• Gestire le licenze e la fatturazione di SQL Server abilitate da Azure Arc
• Prezzi di SQL Server 2022
• Guida all'installazione di SQL Server
• Che cosa sono gli Aggiornamenti estesi di sicurezza per SQL Server?
• Domande frequenti
• Configurare gli aggiornamenti automatici per SQL Server abilitato da Azure Arc