Configurar o SQL Server habilitado pelo Azure Arc

Aplica-se:SQL Server

Cada servidor habilitado para o Azure Arc inclui um conjunto de propriedades que se aplicam a todas as instâncias do SQL Server instaladas nesse servidor. Você poderá configurar essas propriedades depois que a Extensão do Azure para SQL Server for instalada no computador. No entanto, as propriedades terão efeito apenas se uma ou mais instâncias do SQL Server estiverem instaladas. No portal do Azure, a painel Visão geral do SQL Server habilitado pelo Azure Arc reflete como a configuração do SQL Server afeta uma instância específica.

Pré-requisitos

• Você tem a função Colaborador em, pelo menos, uma das assinaturas do Azure criadas pela sua organização. Saiba como criar uma assinatura para cobrança.

• Você tem a função Colaborador no grupo de recursos em que a instância do SQL Server será gerenciada. Para obter mais detalhes, confira Grupos de recursos gerenciados do Azure.

• Os provedores de recursos Microsoft.AzureArcData e Microsoft.HybridCompute são registrados em cada assinatura usada para a cobrança de pagamento conforme o uso do SQL Server.

Registrar provedores de recursos

Para registrar os provedores de recursos, use um dos seguintes métodos:

Register-AzResourceProvider -ProviderNamespace Microsoft.AzureArcData

az provider register --namespace 'Microsoft.AzureArcData'

Modificar a configuração do SQL Server

Você pode usar o portal do Azure, o Azure PowerShell ou a CLI do Azure para alterar todas ou algumas configurações em um servidor específico habilitado para o Azure Arc para o estado desejado.

Para modificar a configuração do SQL Server para um escopo maior (como um grupo de recursos, uma assinatura ou várias assinaturas) com um único comando, use o script modify-license-type.ps1 do PowerShell. Ele é publicado como um exemplo de código aberto do SQL Server e inclui as instruções passo a passo.

Recomendamos executar o script do Azure Cloud Shell porque:

• Ele tem os módulos necessários do Azure PowerShell pré-instalados.
• Ele autentica você automaticamente.

Para obter detalhes, confira Executar o script usando 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}}'

Assinar as Atualizações de Segurança estendidas em escala usando o Azure Policy

É possível ativar a assinatura do ESU em vários computadores habilitados para Azure Arc usando uma definição do Azure Policy chamada Inscrever instâncias qualificadas de SQL Server habilitadas para Arc em Atualizações de Segurança Estendidas.

Quando você cria uma atribuição dessa definição de política a um escopo de sua escolha, ela habilita ESUs em todos os computadores habilitados para Azure Arc que têm instalada a extensão do Azure para SQL Server. Se qualquer um desses computadores tiver uma instância do SQL Server qualificada, a assinatura ESU é ativada imediatamente.

Siga estas etapas para ativar essa política:

1. Entre no portal do Azure, acesse o Azure Policy, e então selecione Definições.

2. Procure por Inscrever instâncias qualificadas do SQL Server habilitadas para Arc em Atualizações de Segurança Estendidas e clique com o botão direito do mouse na política.

3. Selecione Atribuir política.

4. Selecione uma assinatura e, opcionalmente, um grupo de recursos como escopo.

5. Verifique se a Imposição de política está definida como Habilitada.

6. Na guia Parâmetros, defina o valor de Habilitar Atualizações de Segurança Estendidas como True.

7. Na guia Correção:

   1. Selecione Criar tarefa de correção para que essa política seja aplicada aos recursos existentes. Se você não selecionar essa opção, a política será aplicada somente aos recursos recém-criados.
   2. Escolha Criar identidade gerenciada e depois escolha Identidade gerenciada atribuída pelo sistema (recomendado) ou Identidade gerenciada atribuída pelo usuário, que tem permissões de Extensão do Azure para Implantação do SQL Server. e de Leitor.
   3. Selecione a localização da identidade.

8. Selecione Examinar + criar.

9. Selecione Criar.

Consultar a configuração do SQL Server

Você pode usar o Azure Resource Graph para consultar as configurações do SQL Server dentro de um escopo selecionado. Consulte os exemplos a seguir.

Obter a contagem por tipo de licença

Este exemplo retorna a contagem por tipo de licença:

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)

Identificar instâncias em que o tipo de licença é indefinido

Essa consulta retorna uma lista de instâncias em que o tipo de licença é 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

Listar detalhes de configuração para cada instância do SQL Server

Essa consulta identifica vários detalhes sobre cada instância, incluindo o tipo de licença, as configurações de ESU e os recursos habilitados:

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

Listar servidores habilitados pelo Azure Arc com instâncias do SQL Server

Essa consulta identifica os servidores habilitados pelo Azure Arc com instâncias do SQL Server detectadas neles:

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

Essa consulta retorna os servidores habilitados pelo Azure Arc que têm instâncias do SQL Server, mas a extensão do SQL Server do Azure Arc não está instalada. Essa consulta se aplica apenas a servidores 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

Para obter mais exemplos de Consultas do Azure Resource Graph, confira Exemplos de consultas do Resource Graph para iniciantes.

Listar instâncias do SQL Server habilitadas para Azure Arc com assinaturas ESU

O exemplo a seguir mostra como você pode exibir todas as instâncias qualificadas do SQL Server 2012 (11.x) ou do SQL Server 2014 (12.x) e o status da assinatura da 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

Listar servidores habilitados para Azure Arc que hospedam uma instância do SQL Server cobrável

Essa consulta identifica as máquinas conectadas (virtuais ou físicas) que hospedam instâncias do SQL Server e que são faturáveis ou exigem uma licença para software do SQL Server. Ele fornece os detalhes da configuração do SQL Server, incluindo o tipo de licença, configuração de ESU, tamanho em núcleos virtuais ou físicos e outros parâmetros relevantes.

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

Gerenciar o benefício da virtualização ilimitada para o SQL Server

Para habilitar a virtualização ilimitada, o SQL Server habilitado pelo Azure Arc oferece suporte a um tipo de recurso especial: SQLServerLicense. Você pode usar esse recurso para licenciar muitas máquinas virtuais com as instâncias do SQL Server instaladas. Para obter detalhes sobre o modelo de licenciamento, consulte Licenciar instâncias do SQL Server com virtualização ilimitada.

Pré-requisitos

Sua função de controle de acesso baseado em função (RBAC) inclui as seguintes permissões:

• 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

Criar uma licença do SQL Server

Para criar um recurso de licença do SQL Server, use um dos seguintes métodos:

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

Atualizar um recurso de licença do SQL Server

Para alterar a propriedade da licença do SQL Server (por exemplo, ativá-la posteriormente), use um dos seguintes métodos:

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

Gerenciar os recursos no escopo de uma licença de núcleos físicos

Você pode gerenciar os recursos no escopo de uma licença de núcleo físico específica do SQL Server usando as seguintes etapas:

Listar servidores habilitados para Azure Arc no escopo da licença do SQL Server

Esta consulta lista todos os servidores habilitados para Azure Arc no escopo da licença e as propriedades relevantes de cada um:

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

Gerenciar o benefício da virtualização ilimitada para uma assinatura ESU do SQL Server

Para habilitar a virtualização ilimitada para uma assinatura ESU, o SQL Server habilitado pelo Azure Arc oferece suporte a um tipo de recurso especial: SQLServerEsuLicense. Você pode usar esse recurso para habilitar uma assinatura ESU para um conjunto de hosts físicos com um número ilimitado de máquinas virtuais executando as instâncias do SQL Server fora de suporte. Para obter detalhes sobre o modelo de licenciamento, confira Assinar ESUs do SQL Server usando núcleos físicos com virtualização ilimitada.

Pré-requisitos

Sua função RBAC inclui as seguintes permissões:

• 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

Criar um recurso de licença ESU do SQL Server

Para criar um recurso de licença ESU do SQL Server, use um dos seguintes métodos:

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

Atualizar um recurso de licença ESU do SQL Server

Para alterar as propriedades da licença ESU do SQL Server (por exemplo, terminar a assinatura), use um dos seguintes métodos:

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

Gerenciar recursos no escopo de uma licença ESU de núcleos físicos

Você pode gerenciar os recursos no escopo da licença ESU de um SQL Server específico usando as seguintes etapas:

Listar servidores habilitados para Azure Arc no escopo de uma licença ESU do SQL Server

Esta consulta lista todos os servidores habilitados para Azure Arc no escopo da licença e as propriedades relevantes de cada um:

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

Conteúdo relacionado

• Gerenciar o licenciamento e a cobrança do SQL Server habilitado pelo Azure Arc
• Preços do SQL Server 2022
• Guia de instalação do SQL Server
• Quais são as Atualizações de Segurança Estendidas para o SQL Server?
• Perguntas frequentes
• Configurar a atualização automática para o SQL Server habilitado pelo Azure Arc