Configurare SQL Server abilitato da Azure Arc

Applica a:SQL Server

Ogni server abilitato per Azure Arc include un set di proprietà che si applicano a tutte le istanze di SQL Server installate in tale server. È possibile configurare queste proprietà dopo l'installazione dell'estensione Azure per SQL Server nel computer. Tuttavia, le proprietà diventano effettive solo se viene installata un'istanza o un'istanza di SQL Server. Nel portale di Azure il riquadro Overview per SQL Server abilitato da Azure Arc riflette il modo in cui la configurazione SQL Server influisce su una determinata istanza.

Prerequisiti

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

• Si dispone di un ruolo Contributor per il gruppo di risorse in cui verrà registrata l'istanza di SQL Server. Per informazioni dettagliate, vedere Gruppi di risorse Azure gestiti.

• I provider di risorse Microsoft.AzureArcData e Microsoft.HybridCompute vengono registrati in ogni sottoscrizione usata per la fatturazione con pagamento in base al consumo 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 SQL Server configurazione

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

Per modificare la configurazione 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 esempio di SQL Server open source e include istruzioni dettagliate.

È consigliabile 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 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}}'

Sottoscrivere gli aggiornamenti della sicurezza estesi su larga scala usando Criteri di Azure

È possibile attivare la sottoscrizione ESU su più computer abilitati ad Azure Arc usando una definizione di Criteri di Azure denominata Sottoscrivi le istanze idonee di SQL Server abilitate ad Azure Arc agli Aggiornamenti della Sicurezza Estesa.

Quando si crea un'assegnazione di questa definizione di criteri a un ambito di propria scelta, abilita le ESU in tutti i computer abilitati per Azure Arc in cui è installata Azure Extension for SQL Server. Se uno di questi computer dispone di un'istanza di SQL Server qualificata, la sottoscrizione ESU viene attivata immediatamente.

Per attivare questo criterio, segui i passaggi seguenti:

1. Nel portale di Azure passare a Criteri di Azure e quindi selezionare Definitions.

2. Cercare Iscrivere le istanze idonee di SQL Server abilitate per Arc agli 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 della politica sia abilitata.

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

7. Nella scheda Rimedio:

   1. Seleziona Crea attività di correzione per far 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 quindi selezionare Identity gestita assegnata dal sistema (scelta consigliata) o Identity gestita assegnata dall'utente con estensione Azure per la distribuzione SQL Server e Reader.
   3. Seleziona la posizione dell'identità.

8. Selezionare Rivedi e crea.

9. Seleziona Crea.

Eseguire una query sulla configurazione SQL Server

È possibile usare Azure Resource Graph per eseguire query sulle impostazioni di configurazione 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:

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 abilitati per Azure Arc con istanze di SQL Server

Questa query identifica i server abilitati per Azure Arc con istanze di SQL Server individuate:

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

Questa query restituisce i server abilitati da Azure Arc con istanze di SQL Server, ma l'estensione SQL Server di Azure Arc 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 Starter Resource Graph.

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

L'esempio seguente mostra come visualizzare tutte le istanze idonee SQL Server 2014 (12.x) 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 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 di SQL Server fatturabile

Questa query identifica le macchine connesse (virtuali o fisiche) che ospitano istanze di SQL Server e che sono fatturabili o richiedono una licenza per SQL Server software. Fornisce i dettagli della configurazione 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 contains_cs "VMware" or
    properties.detectedProperties.manufacturer contains_cs "QEMU" or
    properties.detectedProperties.manufacturer contains_cs "Amazon EC2" or
    properties.detectedProperties.manufacturer contains_cs "OpenStack" or
    properties.detectedProperties.manufacturer contains_cs "Hetzner" or
    properties.detectedProperties.manufacturer contains_cs "Mission Critical Cloud" or
    properties.detectedProperties.manufacturer contains_cs "DigitalOcean" or
    properties.detectedProperties.manufacturer contains_cs "UpCloud" or
    properties.detectedProperties.manufacturer contains_cs "oVirt" or
    properties.detectedProperties.manufacturer contains_cs "Alibaba" or
    properties.detectedProperties.manufacturer contains_cs "KubeVirt" or
    properties.detectedProperties.manufacturer contains_cs "Parallels" or
    properties.detectedProperties.manufacturer contains_cs "Bochs" or
    properties.detectedProperties.manufacturer contains_cs "XEN", 1, 0))
| extend VMbyModel = toboolean(iff(
    properties.detectedProperties.model contains_cs "OpenStack" or
    properties.detectedProperties.model contains_cs "Droplet" or
    properties.detectedProperties.model contains_cs "oVirt" or
    properties.detectedProperties.model contains_cs "Hypervisor" or
    properties.detectedProperties.model contains_cs "Virtual" or
    properties.detectedProperties.model contains_cs "BHYVE" or
    properties.detectedProperties.model contains_cs "KVM", 1, 0))
| extend GoogleVM = toboolean(iff(
    properties.detectedProperties.manufacturer contains_cs "Google" and
    properties.detectedProperties.model contains_cs "Google Compute Engine", 1, 0))
| extend NutanixVM = toboolean(iff(
    properties.detectedProperties.manufacturer contains_cs "Nutanix" and
    properties.detectedProperties.model contains_cs "AHV", 1, 0))
| extend MicrosoftVM = toboolean(iff(
    properties.detectedProperties.manufacturer contains_cs "Microsoft Corporation" and
    properties.detectedProperties.model contains_cs "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 (
    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 (
    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, HostType = iff(VMbyManufacturer or VMbyModel or GoogleVM or NutanixVM or MicrosoftVM, "VM", "Physical")
| summarize by name, subscriptionId, resourceGroup, Model, Manufacturer, HostType, License_Type, ESU, OS, Cores, Status
| project Name = name, Model, Manufacturer, HostType, OperatingSystem = OS, Status, HostLicenseType = License_Type, ESU, BillableCores = Cores, SubscriptionID = subscriptionId, ResourceGroup = resourceGroup
| order by Name asc

Gestire il vantaggio illimitato per la virtualizzazione per SQL Server

Per abilitare la virtualizzazione illimitata, SQL Server abilitata da Azure Arc supporta un tipo di risorsa speciale: SQLServerLicense. È possibile usare questa risorsa per concedere in licenza molte macchine virtuali con le istanze di SQL Server installate. Per informazioni dettagliate sul modello di licenza, vedere License SQL Server istanze con virtualizzazione illimitata.

Prerequisiti

Il ruolo RBAC (controllo degli accessi basato sul ruolo) include i seguenti permessi:

• 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 una risorsa di licenza 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 SQL Server

Per modificare la proprietà della licenza SQL Server (ad esempio, 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 core fisica 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 di SQL Server ESU

Per abilitare la virtualizzazione illimitata per una sottoscrizione ESU, SQL Server abilitata da Azure Arc supporta un tipo di risorsa speciale: SqlServerEsuLicenses. È possibile 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, vedere Sottoscrivere agli ESU di SQL Server utilizzando core fisici con virtualizzazione illimitata.

Prerequisiti

Il tuo 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 risorsa di licenza ESU SQL Server

Per creare una risorsa di licenza ESU 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 la risorsa licenza ESU per SQL Server

Per modificare le proprietà della licenza ESU SQL Server (ad esempio, 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 ESU p-core

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

Elencare i server abilitati per Azure Arc nell'ambito di una licenza ESU 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

Aggiornare l'estensione

Per determinare la versione della versione corrente dell'estensione, esaminare le note sulla versione.

Per controllare la versione dell'estensione, usare il comando di PowerShell seguente:

azcmagent version

Per semplificare gli aggiornamenti delle estensioni, assicurarsi di abilitare gli aggiornamenti automatici. È anche possibile aggiornare manualmente l'estensione usando il portale di Azure, PowerShell e il interfaccia della riga di comando di Azure.

Install-Module -Name Az.ConnectedMachine

# Variables 
$Subscription_Id = "<SubscriptionId>" 
$ResourceGroup = "<ResourceGroup>" 
$MachineName = "<MachineName>" 
$ExtensionName = "WindowsAgent.SqlServer" 
$Publisher = "Microsoft.AzureData" 
$TargetVersion = "<LatestVersion>"  # Example: 1.1.3211.337 

# Upgrade the extension 
Set-AzContext -Subscription $SubscriptionId 

$params = @{
  ResourceGroupName = $ResourceGroup
  MachineName = $MachineName
  Name = $ExtensionName
  Publisher = $Publisher
  Type = $ExtensionName
  TypeHandlerVersion = $TargetVersion
}

Update-AzConnectedMachineExtension @params

az extension add --name connectedmachine 

# Variables 
Subscription_Id="<SubscriptionId>" 
Resource_Group="<ResourceGroup>" 
Machine_Name="<ArcEnabledServerName>" 
Extension_Name="WindowsAgent.SqlServer" 
Publisher="Microsoft.AzureData" 
Target_Version="<LatestVersion>"  # Example: 1.1.3211.337 

# Upgrade the extension 

az account set --subscription $Subscription_Id 
az connectedmachine extension update \ 
    --resource-group $Resource_Group \ 
    --machine-name $Machine_Name \ 
    --name $Extension_Name \ 
    --publisher $Publisher \ 
    --type $Extension_Name \ 
    --type-handler-version $Target_Version 

Per altre informazioni sull'aggiornamento dell'estensione Azure per SQL Server, vedere Upgrade extension.

Contenuto correlato

• Gestisci le licenze e la fatturazione delle SQL Server abilitate da Azure Arc
• SQL Server 2022 prezzi
• guida all'installazione di SQL Server
• Che sono gli aggiornamenti della sicurezza estesi per SQL Server?
• Domande frequenti
• Configurare gli aggiornamenti automatici per SQL Server abilitati da Azure Arc