Konfigurowanie SQL Server włączonej przez Azure Arc

Applies to:SQL Server

Każdy serwer z obsługą Azure Arc zawiera zestaw właściwości, które mają zastosowanie do wszystkich wystąpień SQL Server zainstalowanych na tym serwerze. Te właściwości można skonfigurować po zainstalowaniu rozszerzenia Azure dla SQL Server na maszynie. Jednak właściwości zaczynają obowiązywać wyłącznie wtedy, gdy zainstalowane jest przynajmniej jedno wystąpienie SQL Server. W portalu Azure okienko Overview dla SQL Server włączone przez Azure Arc odzwierciedla sposób, w jaki konfiguracja SQL Server wpływa na określone wystąpienie.

Warunki wstępne

• Masz rolę Contributor w co najmniej jednej z subskrypcji Azure utworzonych przez organizację. Dowiedz się, jak utworzyć nową subskrypcję rozliczeniową.

• Masz rolę Contributor dla grupy zasobów, w której zostanie zarejestrowane wystąpienie SQL Server. Aby uzyskać szczegółowe informacje, zobacz Zarządzane grupy zasobów Azure.

• Dostawcy zasobów Microsoft.AzureArcData i Microsoft.HybridCompute są zarejestrowani w każdej subskrypcji, którą używasz do opłaty za SQL Server według rzeczywistego zużycia.

Rejestrowanie dostawców zasobów

Aby zarejestrować dostawców zasobów, użyj jednej z następujących metod:

Register-AzResourceProvider -ProviderNamespace Microsoft.AzureArcData

az provider register --namespace 'Microsoft.AzureArcData'

Modyfikowanie konfiguracji SQL Server

Możesz użyć portalu Azure, Azure PowerShell lub Azure CLI, aby zmienić wszystkie lub niektóre ustawienia konfiguracji na określonym serwerze z włączoną obsługą Azure Arc na żądany stan.

Aby zmodyfikować konfigurację SQL Server dla większego zakresu (na przykład grupy zasobów, subskrypcji lub wielu subskrypcji) za pomocą jednego polecenia, użyj skryptu modify-license-type.ps1 programu PowerShell. Jest on publikowany jako przykład typu open source SQL Server zawierający instrukcje krok po kroku.

Zalecamy uruchomienie skryptu z Azure Cloud Shell z następujących powodów:

• Ma on wstępnie zainstalowane wymagane moduły Azure PowerShell.
• Automatycznie cię uwierzytelnia.

Aby uzyskać szczegółowe informacje, zobacz Uruchamianie skryptu przy użyciu 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}}'

Subskrybowanie rozszerzonych aktualizacji zabezpieczeń na dużą skalę przy użyciu Azure Policy

Subskrypcję ESU można aktywować na wielu maszynach z obsługą Azure Arc przy użyciu definicji Azure Policy o nazwie Subkrybuj kwalifikujące się wystąpienia serwerów SQL z obsługą usługi Arc do rozszerzonych aktualizacji zabezpieczeń.

Podczas tworzenia przypisania tej definicji zasad do wybranego zakresu włącza ona ESU na wszystkich maszynach z obsługą Azure Arc, na których zainstalowano rozszerzenie Azure dla SQL Server. Jeśli którekolwiek z tych maszyn ma wystąpienie SQL Server spełniające wymagania, subskrypcja ESU zostanie natychmiast aktywowana.

Aby aktywować te zasady, wykonaj następujące czynności:

1. W portalu Azure przejdź do Azure Policy, a następnie wybierz pozycję Definitions.

2. Wyszukaj Zarejestruj kwalifikujące się instancje SQL Server z obsługą usługi Arc do rozszerzonych aktualizacji zabezpieczeń i kliknij prawym przyciskiem myszy na zasady.

3. Wybierz pozycję Przypisz politykę.

4. Wybierz subskrypcję i opcjonalnie grupę zasobów jako zakres.

5. Upewnij się, że wymuszanie zasad ma ustawioną wartość Włączone.

6. Na karcie Parametry ustaw wartość Włącz rozszerzone aktualizacje zabezpieczeń na wartość True.

7. Na karcie naprawa:

   1. Wybierz Utwórz zadanie korygowania, aby zastosować tę zasadę do istniejących zasobów. Jeśli nie wybierzesz tej opcji, zasady zostaną zastosowane tylko do nowo utworzonych zasobów.
   2. Wybierz Utwórz tożsamość zarządzaną, następnie wybierz Tożsamość zarządzana przypisana systemowi (zalecane) lub Tożsamość zarządzana przypisana użytkownikowi, które mają uprawnienia rozszerzenia Azure dla wdrażania SQL Server i Reader.
   3. Wybierz lokalizację tożsamości.

8. Wybierz Przejrzyj i utwórz.

9. Wybierz pozycję Utwórz.

Wykonywanie zapytań dotyczących konfiguracji SQL Server

Możesz użyć Azure Resource Graph, aby wykonać zapytanie o ustawienia konfiguracji SQL Server w wybranym zakresie. Zapoznaj się z poniższymi przykładami.

Uzyskaj liczbę według typu licencji

W tym przykładzie zwracana jest liczba według typu licencji:

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)

Identyfikowanie wystąpień, w których typ licencji jest niezdefiniowany

To zapytanie zwraca listę wystąpień, w których typ licencji jest 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

Wypisz dane konfiguracyjne dla każdego wystąpienia SQL Server

To zapytanie identyfikuje wiele szczegółów dotyczących każdego wystąpienia, w tym typ licencji, ustawienie ESU i włączone funkcje:

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

Wyświetl serwery obsługujące Azure Arc z instancjami SQL Server

To zapytanie identyfikuje serwery umożliwione przez Azure Arc z wystąpieniami SQL Server odkrytymi na nich.

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

Zapytanie to zwraca serwery z Azure Arc, które mają wystąpienia SQL Server, ale rozszerzenie SQL Server Azure Arc nie jest zainstalowane. To zapytanie dotyczy tylko serwerów 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

Aby uzyskać więcej przykładów zapytań Azure Resource Graph, zobacz przykłady zapytań Starter Resource Graph.

Wyświetlanie listy wystąpień SQL Server z obsługą Azure Arc subskrybowanych do jednostek ESU

W poniższym przykładzie pokazano, jak można wyświetlić wszystkie kwalifikujące się wystąpienia SQL Server 2014 (12.x) i ich stan subskrypcji 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

Wyświetlanie listy serwerów z obsługą Azure Arc hostujących rozliczane wystąpienie SQL Server

To zapytanie identyfikuje połączone maszyny (wirtualne lub fizyczne), które hostują wystąpienia SQL Server i które są rozliczane lub wymagają licencji na oprogramowanie SQL Server. Zawiera szczegółowe informacje o konfiguracji SQL Server, w tym typ licencji, ustawienie ESU, rozmiar w rdzeniach wirtualnych lub rdzeniach P oraz inne istotne parametry.

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

Zarządzanie nieograniczoną korzyścią wirtualizacji dla SQL Server

Aby włączyć nieograniczoną wirtualizację, SQL Server włączona przez Azure Arc obsługuje specjalny typ zasobu: SQLServerLicense. Można wykorzystać ten zasób do licencjonowania wielu maszyn wirtualnych, które mają zainstalowane wystąpienia SQL Server. Aby uzyskać szczegółowe informacje na temat modelu licencjonowania, zobacz Licencjonowanie wystąpień SQL Server z nieograniczoną wirtualizacją.

Warunki wstępne

Rola kontroli dostępu opartej na rolach (RBAC) obejmuje następujące uprawnienia:

• 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

Tworzenie licencji SQL Server

Aby utworzyć zasób licencji SQL Server, użyj jednej z następujących metod:

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

Aktualizowanie zasobu licencji SQL Server

Aby zmienić właściwość licencji SQL Server (na przykład aktywować ją w późniejszym terminie), użyj jednej z następujących metod:

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

Zarządzanie zasobami w zakresie licencji p-core

Można zarządzać zasobami w zakresie licencji na fizyczny rdzeń SQL Server, wykonując następujące kroki:

Wyświetlanie listy serwerów z obsługą Azure Arc w zakresie licencji SQL Server

To zapytanie zawiera listę wszystkich serwerów z obsługą Azure Arc w zakresie licencji i odpowiednich właściwości każdego z nich:

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

Zarządzanie nieograniczoną korzyścią wirtualizacji dla subskrypcji SQL Server ESU

Aby włączyć nieograniczoną wirtualizację dla subskrypcji ESU, SQL Server zarządzany przez Azure Arc obsługuje specjalny typ zasobu: SqlServerEsuLicenses. Za pomocą tego zasobu można włączyć subskrypcję ESU dla zestawu hostów fizycznych z nieograniczoną liczbą maszyn wirtualnych, które uruchamiają nieobsługiwane instancje SQL Server. Aby uzyskać szczegółowe informacje na temat modelu licencjonowania, zobacz Subskrybuj SQL Server ESUs, używając rdzeni fizycznych z nieograniczoną wirtualizacją.

Warunki wstępne

Rola RBAC obejmuje następujące uprawnienia:

• 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

Tworzenie zasobu licencji SQL Server ESU

Aby utworzyć zasób licencji SQL Server ESU, użyj jednej z następujących metod:

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

Aktualizowanie zasobu licencji SQL Server ESU

Aby zmienić właściwości licencji SQL Server ESU (na przykład zakończyć subskrypcję), użyj jednej z następujących metod:

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

Zarządzanie zasobami w zakresie licencji p-core ESU

Zasoby można zarządzać w zakresie określonej licencji SQL Server ESU, wykonując następujące czynności:

Wyświetl serwery z obsługą Azure Arc w ramach licencji SQL Server ESU

To zapytanie zawiera listę wszystkich serwerów z obsługą Azure Arc w zakresie licencji i odpowiednich właściwości każdego z nich:

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

Uaktualnianie rozszerzenia

Aby określić wersję bieżącej wersji rozszerzenia, zapoznaj się z informacjami o wersji.

Aby sprawdzić wersję rozszerzenia, użyj następującego polecenia programu PowerShell:

azcmagent version

Aby uprościć uaktualnienia rozszerzeń, pamiętaj o włączeniu aktualizacji automatycznych. Możesz również ręcznie uaktualnić rozszerzenie przy użyciu portalu Azure, programu PowerShell i Azure CLI.

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 

Aby uzyskać więcej informacji na temat uaktualniania rozszerzenia Azure dla SQL Server, zobacz sekcję Uaktualnij rozszerzenie.

Powiązana zawartość

• Zarządzanie licencjonowaniem i rozliczeniami SQL Server włączonymi przez Azure Arc
• cennik SQL Server 2022
• przewodnik instalacji SQL Server
• Jak są rozszerzone aktualizacje zabezpieczeń dla SQL Server?
• często zadawane pytania
• Konfiguruj automatyczne aktualizacje dla SQL Server włączone przez Azure Arc