Konfigurieren von SQL Server mit Azure Arc-Unterstützung

Gilt für:SQL Server

Jeder Azure Arc-fähige Server enthält eine Reihe von Eigenschaften, die für alle SQL Server-Instanzen gelten, die auf diesem Server installiert sind. Sie können diese Eigenschaften konfigurieren, nachdem Azure Extension für SQL Server auf dem Computer installiert wurde. Die Eigenschaften werden jedoch nur wirksam, wenn eine oder mehrere SQL Server-Instanzen installiert sind. Im Azure-Portal zeigt der Bereich Übersicht für SQL Server mit Azure Arc-Unterstützung an, wie sich die SQL Server-Konfiguration auf eine bestimmte Instanz auswirkt.

Voraussetzungen

• Sie haben in mindestens einem der von Ihrer Organisation erstellten Azure-Abonnements die Rolle Teilnehmerrolle. Hier erfahren Sie, wie Sie ein neues Abrechnungsabonnement erstellen.

• Sie haben eine Teilnehmerrolle für die Ressourcengruppe, in der die SQL Server-Instanz registriert wird. Weitere Informationen finden Sie unter Verwaltete Azure-Ressourcengruppen.

• Die Ressourcenanbieter Microsoft.AzureArcData und Microsoft.HybridCompute sind in jedem Abonnement registriert, das Sie für die nutzungsbasierte Bezahlung in SQL Server verwenden.

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'

SQL Server-Konfiguration ändern

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

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, verwenden Sie das PowerShell-Skript modify-license-type.ps1. Es wird als Open-Source-Beispiel für SQL Server veröffentlicht und umfasst Schrittanweisungen.

Wir empfehlen Ihnen, das Skript von Azure Cloud Shell aus auszuführen, weil:

• Es hat die erforderlichen Azure PowerShell-Module vorinstalliert.
• Es authentifiziert Sie automatisch.

Ausführliche Informationen finden Sie unter Ausführen des Skripts mit 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 erweiterter Sicherheitsupdates im großen Stil mithilfe von Azure Policy

Mithilfe einer Azure-Richtliniendefinition namens Abonnieren berechtigter Azure Arc-fähiger SQL Server-Instanzen für erweiterte Sicherheitsupdates können Sie das ESU-Abonnement auf mehreren Arc-fähigen Computern aktivieren.

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 Extension für SQL Server installiert ist. Wenn einer 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. Gehen Sie im Azure-Portal zu Azure Policy und wählen Sie dann Definitionen aus.

2. Suchen Sie nach Abonnieren berechtigter Arc-fähiger SQL Server-Instanzen für erweiterte Sicherheitsupdates und klicken Sie mit der rechten Maustaste die Richtlinie an.

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 Verwaltete Identität erstellen und wählen Sie eine vom System zugewiesene verwaltete Identität (empfohlen) oder eine vom Benutzer zugewiesene verwaltete Identität aus, die über Azure-Erweiterung für SQL Server-Bereitstellung und Leseberechtigungen verfügt.
   3. Wählen Sie den Standort der Identität aus.

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

9. Klicken Sie auf Erstellen.

Die SQL Server-Konfiguration abfragen

Sie können Azure Resource Graph verwenden, um die SQL Server-Konfigurationseinstellungen innerhalb eines ausgewählten Bereichs 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 SQL Server-Instanzen

Diese Abfrage identifiziert Azure Arc-fähige Server, auf denen SQL Server-Instanzen ermittelt wurden:

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

Diese Abfrage gibt Azure Arc-fähige Server mit SQL Server-Instanzen zurück, auf denen 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 Beispiele für den Einstieg in Resource Graph-Abfragen.

Auflisten Azure Arc-fähiger SQL Server-Instanzen, die bei ESUs abonniert sind

Das folgende Beispiel zeigt, wie Sie alle berechtigten SQL Server 2012 (11.x)- oder 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 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

Auflisten von Azure Arc-fähigen Servern, 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-Kernen oder P-Kernen 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 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

Verwalten des unbegrenzten Virtualisierungsvorteils für SQL Server

Um die unbegrenzte Virtualisierung zu aktivieren, unterstützt SQL Server mit Unterstützung von Azure Arc einen speziellen Ressourcentyp: SQLServerLicense. Sie können diese Ressource verwenden, um viele virtuelle Maschinen mit den installierten SQL Server-Instanzen zu lizenzieren. Ausführliche Informationen über das Lizenzierungsmodell finden Sie unter Lizenzierung von 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 zum Erstellen einer SQL Server-Lizenzressource eine der folgenden Methoden:

$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

Wenn Sie die SQL Server-Lizenzeigenschaft ändern möchten (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 Bereich einer P-Kern-Lizenz

Sie können die Ressourcen im Bereich einer bestimmten physischen SQL Server-Kernlizenz mithilfe der folgenden Schritte verwalten:

Auflisten von Azure Arc-fähigen Servern im Bereich 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 ESU-Abonnement von SQL Server

Um die unbegrenzte Virtualisierung für ein ESU-Abonnement zu aktivieren, unterstützt SQL Server mit Unterstützung von Azure Arc einen speziellen Ressourcentyp: SQLServerEsuLicense. Sie können diese Ressource nutzen, um ein ESU-Abonnement für eine Reihe physischer Hosts mit einer unbegrenzter Anzahl von virtuellen Computern zu aktivieren, auf denen die nicht unterstützten SQL Server-Instanzen ausgeführt werden. Ausführliche Informationen über das Lizenzierungsmodell finden Sie unter Abonnieren von SQL Server-ESUs mithilfe physischer Kerne mit 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 Ressource SQL Server-ESU-Lizenz

Verwenden Sie zum Erstellen einer SQL Server-ESU-Lizenzressource eine der folgenden Methoden:

$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 Ressource SQL Server-ESU-Lizenz

Wenn Sie die SQL Server-ESU-Lizenzeigenschaft ändern möchten (z. B. das Abonnement kündigen) verwenden Sie eine der folgenden Methoden:

$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 Bereich einer ESU-P-Kern-Lizenz

Sie können die Ressourcen im Bereich einer bestimmten SQL Server-ESU-Lizenz mithilfe der folgenden Schritte verwalten:

Auflisten von Azure Arc-fähigen Servern im Bereich 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

Zugehöriger Inhalt

• Verwalten der Lizenzierung und Abrechnung von SQL Server mit Azure Arc-Unterstützung
• SQL Server 2022 – Preise
• Installationsleitfaden für SQL Server
• Was sind erweiterte Sicherheitsupdates für SQL Server?
• Häufig gestellte Fragen
• Automatisierte Updates für SQL Server mit Unterstützung von Azure Arc konfigurieren