Konfigurieren Sie den mit Azure Arc aktivierten SQL Server

Gilt für:SQL Server

Jeder Azure Arc-fähige Server enthält eine Reihe von Eigenschaften, die für alle auf diesem Server installierten SQL Server Instanzen gelten. Sie können diese Eigenschaften konfigurieren, nachdem Azure Erweiterung für SQL Server auf dem Computer installiert wurde. Die Eigenschaften werden jedoch nur wirksam, wenn eine SQL Server Instanz oder Instanzen installiert sind. Im Azure-Portal spiegelt der Bereich Overview für SQL Server, die durch Azure Arc aktiviert werden, wider, wie sich die SQL Server-Konfiguration auf eine bestimmte Instanz auswirkt.

Voraussetzungen

• Sie verfügen über eine Contributor-Rolle in mindestens einem der Azure Abonnements, die Ihre Organisation erstellt hat. Hier erfahren Sie, wie Sie ein neues Abrechnungsabonnement erstellen.

• Sie verfügen über eine Contributorrolle für die Ressourcengruppe, in der die SQL Server Instanz registriert wird. Ausführliche Informationen finden Sie unter Managed Azure Ressourcengruppen.

• Die Microsoft.AzureArcData- und Microsoft.HybridCompute-Ressourcenanbieter werden in jedem Abonnement, das Sie für die Abrechnung nach Nutzung für SQL Server verwenden, registriert.

Registrieren von Ressourcenanbietern

Verwenden Sie eine der folgenden Methoden, um die Ressourcenanbieter zu registrieren:

Register-AzResourceProvider -ProviderNamespace Microsoft.AzureArcData

az provider register --namespace 'Microsoft.AzureArcData'

Ändern SQL Server Konfiguration

Sie können das Azure Portal, Azure PowerShell oder die Azure CLI verwenden, um alle oder einige Konfigurationseinstellungen auf einem bestimmten Azure Arc-fähigen Server in den gewünschten Zustand zu ändern.

Verwenden Sie das PowerShell-Skript modify-license-type.ps1 PowerShell, um die SQL Server konfiguration für einen größeren Bereich (z. B. eine Ressourcengruppe, ein Abonnement oder mehrere Abonnements) mit einem einzigen Befehl zu ändern. Sie wird als Open Source-SQL Server Beispiel veröffentlicht und enthält schrittweise Anleitungen.

Es wird empfohlen, das Skript aus Azure Cloud Shell auszuführen, da:

• Es verfügt über die erforderlichen Azure PowerShell Module vorinstalliert.
• Es authentifiziert Sie automatisch.

Ausführliche Informationen finden Sie unter Running the script using 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}}'

Abonnieren von erweiterten Sicherheitsupdates im großen Maßstab mithilfe von Azure Policy

Sie können das ESU-Abonnement auf mehreren Azure Arc-fähigen Computern aktivieren, indem Sie eine Azure Policy-Definition namens Subscribe-berechtigte Arc-fähige SQL Server-Instanzen für erweiterte Sicherheitsupdates verwendet.

Wenn Sie eine Zuordnung dieser Richtliniendefinition zu einem Bereich Ihrer Wahl erstellen, werden ESUs auf allen Azure Arc-fähigen Computern aktiviert, auf denen Azure Erweiterung für SQL Server installiert ist. Wenn eines dieser Computer über eine qualifizierte SQL Server Instanz verfügt, wird das ESU-Abonnement sofort aktiviert.

Führen Sie die folgenden Schritte aus, um diese Richtlinie zu aktivieren:

1. Wechseln Sie im Azure-Portal zu Azure Policy, und wählen Sie dann Definitions aus.

2. Suchen Sie nach Erweiterte Sicherheitsupdates für Arc-fähige SQL Server-Instanzen abonnieren, und klicken Sie mit der rechten Maustaste auf die Richtlinie.

3. Wählen Sie Richtlinie zuweisen aus.

4. Wählen Sie ein Abonnement und optional eine Ressourcengruppe als Umfang aus.

5. Stellen Sie sicher, dass die Durchsetzung von Richtlinien auf Aktiviert gesetzt ist.

6. Legen Sie in der Registerkarte Parameter den Wert von Erweiterte Sicherheitsupdates aktivieren auf True fest.

7. Gehen Sie auf der Registerkarte Wartung wie folgt vor:

   1. Wählen Sie "Wartungsaufgabe erstellen" für diese Richtlinie aus, die auf vorhandene Ressourcen angewendet werden soll. Wenn Sie diese Option nicht auswählen, wird die Richtlinie nur auf die neu erstellten Ressourcen angewendet.
   2. Wählen Sie Eine verwaltete Identität erstellen und wählen Sie dann die systemdefinierte verwaltete Identität (empfohlen) oder die benutzerdefinierte verwaltete Identität aus, die über die Azure-Erweiterung für SQL Server-Bereitstellung und Reader-Berechtigungen verfügt.
   3. Wählen Sie den Standort der Identität aus.

8. Klicken Sie auf Überprüfen + erstellen.

9. Klicken Sie auf Erstellen.

Abfragen der SQL Server-Konfiguration

Sie können Azure Resource Graph verwenden, um die SQL Server Konfigurationseinstellungen in einem ausgewählten Bereich abzufragen. Siehe folgende Beispiele:

Abfrage der Anzahl nach Lizenztyp

In diesem Beispiel wird die Anzahl nach Lizenztyp zurückgegeben:

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)

Identifizieren Sie Instanzen, bei denen der Lizenztyp undefiniert ist

Diese Abfrage gibt eine Liste von Instanzen zurück, bei denen der Lizenztyp null lautet:

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

Auflisten von Konfigurationsdetails für jede SQL Server Instanz

Diese Abfrage ermittelt zahlreiche Details zu den einzelnen Instanzen, darunter den Lizenztyp, ESU-Einstellung und die aktivierten Features:

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

Auflisten von Azure Arc-fähigen Servern mit Instanzen von SQL Server

Eine Abfrage identifiziert Azure Arc-fähige Server mit darauf entdeckten SQL Server-Instanzen.

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

Diese Abfrage gibt Azure Arc-fähigen Server zurück, die SQL Server Instanzen aufweisen, die Azure Arc SQL Server Erweiterung jedoch nicht installiert ist. Diese Abfrage gilt nur für Windows Server.

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

Weitere Beispiele für Azure Resource Graph Abfragen finden Sie unter Starter Resource Graph-Abfragebeispiele.

Auflisten Azure Arc aktivierter SQL Server Instanzen, die ESUs abonniert haben

Das folgende Beispiel zeigt, wie Sie alle berechtigten SQL Server 2014 (12.x)-Instanzen und deren ESU-Abonnementstatus anzeigen können:

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

Auflisten Azure Arc-aktivierter Server, die eine abrechnende SQL Server Instanz hosten

Diese Abfrage identifiziert die verbundenen Computer (virtuell oder physisch), die SQL Server Instanzen hosten und die abgerechnet werden können oder eine Lizenz für SQL Server Software erfordern. Es enthält die Details der SQL Server Konfiguration, einschließlich lizenztyp, ESU-Einstellung, Größe in v-Cores oder p-Cores und anderen relevanten Parametern.

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

Verwalten des unbegrenzten Virtualisierungsvorteils für SQL Server

Um die unbegrenzte Virtualisierung zu aktivieren, unterstützt SQL Server von Azure Arc einen speziellen Ressourcentyp: SQLServerLicense. Sie können diese Ressource verwenden, um viele virtuelle Computer mit den installierten SQL Server Instanzen zu lizenzieren. Ausführliche Informationen zum Lizenzierungsmodell finden Sie unter License SQL Server Instanzen mit unbegrenzter Virtualisierung.

Voraussetzungen

Ihre rollenbasierte Zugriffssteuerungsrolle (RBAC) enthält die folgenden Berechtigungen:

• 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

Erstellen einer SQL Server-Lizenz

Verwenden Sie eine der folgenden Methoden, um eine SQL Server-Lizenzressource zu erstellen:

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

Aktualisieren einer SQL Server-Lizenzressource

Um die SQL Server Lizenzeigenschaft zu ändern (z. B. zu einem späteren Zeitpunkt aktivieren), verwenden Sie eine der folgenden Methoden:

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

Verwalten von Ressourcen im Rahmen einer P-Kernlizenz

Sie können die Ressourcen im Bereich einer bestimmten SQL Server physischen Kernlizenz verwalten, indem Sie die folgenden Schritte ausführen:

Auflisten der Azure Arc-fähigen Server im Rahmen der SQL Server-Lizenz

Diese Abfrage listet alle Azure Arc-fähigen Server im Bereich der Lizenz und die relevanten Eigenschaften der einzelnen Server auf:

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

Verwalten des unbegrenzten Virtualisierungsvorteils für ein SQL Server ESU-Abonnement

Um die unbegrenzte Virtualisierung für ein ESU-Abonnement zu aktivieren, unterstützt SQL Server von Azure Arc einen speziellen Ressourcentyp: SqlServerEsuLicenses. Sie können diese Ressource verwenden, um ein ESU-Abonnement für eine Reihe physischer Hosts mit einer unbegrenzten Anzahl von virtuellen Computern zu aktivieren, auf denen die out-of-Support-SQL Server Instanzen ausgeführt werden. Ausführliche Informationen zum Lizenzierungsmodell finden Sie unter Abonnieren Sie SQL Server ESUs mit physischen Kernen und unbegrenzter Virtualisierung.

Voraussetzungen

Ihre RBAC-Rolle umfasst die folgenden Berechtigungen:

• 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

Erstellen einer SQL Server ESU-Lizenzressource

Verwenden Sie eine der folgenden Methoden, um eine SQL Server ESU-Lizenzressource zu erstellen:

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

Aktualisieren einer SQL Server ESU-Lizenzressource

Verwenden Sie eine der folgenden Methoden, um die SQL Server ESU-Lizenzeigenschaften zu ändern (z. B. das Abonnement beenden):

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

Verwalten von Ressourcen im Rahmen einer ESU-P-Kernlizenz

Sie können die Ressourcen im Bereich einer bestimmten SQL Server ESU-Lizenz verwalten, indem Sie die folgenden Schritte ausführen:

Liste der Azure Arc-aktivierten Server im Rahmen einer SQL Server ESU-Lizenz

Diese Abfrage listet alle Azure Arc-fähigen Server im Bereich der Lizenz und die relevanten Eigenschaften der einzelnen Server auf:

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

Erweiterung aktualisieren

Um die Version der aktuellen Erweiterungsversion zu ermitteln, lesen Sie die Versionshinweise.

Verwenden Sie den folgenden PowerShell-Befehl, um die Version Ihrer Erweiterung zu überprüfen:

azcmagent version

Um Erweiterungsupgrades zu vereinfachen, müssen Sie automatische Updates aktivieren. Sie können die Erweiterung auch manuell aktualisieren, indem Sie das Azure-Portal, PowerShell und die Azure CLI verwenden.

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 

Weitere Informationen zum Aktualisieren der Azure-Erweiterung für SQL Server finden Sie unter Upgrade-Erweiterung.

Zugehöriger Inhalt

• Lizenzierung und Abrechnung von SQL Server aktiviert durch Azure Arc
• SQL Server 2022-Preise
• SQL Server Installationshandbuch
• Was sind Erweiterte Sicherheitsupdates für SQL Server?
• Häufig gestellte Fragen
• Konfigurieren Sie automatische Updates für SQL Server, die von Azure Arc aktiviert werden