Virtual Machines - Install Patches

Dienst:: Compute

API-Version:: 2025-04-01

Installiert Patches auf der VM.

POST https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/installPatches?api-version=2025-04-01

URI-Parameter

Name	In	Erforderlich	Typ	Beschreibung
resourceGroupName	path	True	string minLength: 1 maxLength: 90	Der Name der Ressourcengruppe. Bei dem Namen wird die Groß-/Kleinschreibung nicht beachtet.
subscriptionId	path	True	string minLength: 1	Hierbei handelt es sich um die ID des Zielabonnements.
vmName	path	True	string	Der Name des virtuellen Computers.
api-version	query	True	string minLength: 1	Hierbei handelt es sich um die für diesen Vorgang zu verwendende API-Version.

Anforderungstext

Name	Erforderlich	Typ	Beschreibung
rebootSetting	True	VMGuestPatchRebootSetting	Definiert, wann es akzeptabel ist, einen virtuellen Computer während eines Softwareupdatevorgangs neu zu starten.
linuxParameters		LinuxParameters	Eingabe für InstallPatches auf einer Linux-VM, wie sie direkt von der API empfangen wird
maximumDuration		string (duration)	Gibt die maximale Zeitspanne an, die der Vorgang ausführt. Es muss eine ISO 8601-kompatible Dauerzeichenfolge wie PT4H (4 Stunden) sein.
windowsParameters		WindowsParameters	Eingabe für InstallPatches auf einer Windows-VM, wie sie direkt von der API empfangen wird

Antworten

Name

Typ

Beschreibung

200 OK

VirtualMachineInstallPatchesResult

Der Azure-Vorgang wurde erfolgreich abgeschlossen.

202 Accepted

Ressourcenvorgang akzeptiert.

Header

Location: string
Retry-After: integer

Other Status Codes

Unerwartete Fehlerantwort.

Sicherheit

azure_auth

Azure Active Directory OAuth2-Fluss.

Typ: oauth2
Ablauf: implicit
Autorisierungs-URL: https://login.microsoftonline.com/common/oauth2/authorize

Bereiche

Name	Beschreibung
user_impersonation	Identitätswechsel ihres Benutzerkontos

Beispiele

Install patch state of a virtual machine.

Beispielanforderung

POST https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroupName/providers/Microsoft.Compute/virtualMachines/myVMName/installPatches?api-version=2025-04-01

{
  "maximumDuration": "PT4H",
  "rebootSetting": "IfRequired",
  "windowsParameters": {
    "classificationsToInclude": [
      "Critical",
      "Security"
    ],
    "maxPatchPublishDate": "2020-11-19T02:36:43.0539904+00:00",
    "patchNameMasksToInclude": [
      "*SQL*"
    ],
    "patchNameMasksToExclude": [
      "*Windows*"
    ]
  }
}


import com.azure.resourcemanager.compute.models.VMGuestPatchClassificationWindows;
import com.azure.resourcemanager.compute.models.VMGuestPatchRebootSetting;
import com.azure.resourcemanager.compute.models.VirtualMachineInstallPatchesParameters;
import com.azure.resourcemanager.compute.models.WindowsParameters;
import java.time.OffsetDateTime;
import java.util.Arrays;

/**
 * Samples for VirtualMachines InstallPatches.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2025-04-01/examples/
     * virtualMachineExamples/VirtualMachine_InstallPatches.json
     */
    /**
     * Sample code: Install patch state of a virtual machine.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void installPatchStateOfAVirtualMachine(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.virtualMachines().manager().serviceClient().getVirtualMachines().installPatches("myResourceGroupName",
            "myVMName",
            new VirtualMachineInstallPatchesParameters().withMaximumDuration("PT4H")
                .withRebootSetting(VMGuestPatchRebootSetting.IF_REQUIRED)
                .withWindowsParameters(new WindowsParameters()
                    .withClassificationsToInclude(Arrays.asList(VMGuestPatchClassificationWindows.CRITICAL,
                        VMGuestPatchClassificationWindows.SECURITY))
                    .withMaxPatchPublishDate(OffsetDateTime.parse("2020-11-19T02:36:43.0539904+00:00"))
                    .withPatchNameMasksToInclude(Arrays.asList("*SQL*"))
                    .withPatchNameMasksToExclude(Arrays.asList("*Windows*"))),
            com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.compute import ComputeManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-compute
# USAGE
    python virtual_machine_install_patches.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ComputeManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="{subscription-id}",
    )

    response = client.virtual_machines.begin_install_patches(
        resource_group_name="myResourceGroupName",
        vm_name="myVMName",
        install_patches_input={
            "maximumDuration": "PT4H",
            "rebootSetting": "IfRequired",
            "windowsParameters": {
                "classificationsToInclude": ["Critical", "Security"],
                "maxPatchPublishDate": "2020-11-19T02:36:43.0539904+00:00",
                "patchNameMasksToExclude": ["*Windows*"],
                "patchNameMasksToInclude": ["*SQL*"],
            },
        },
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2025-04-01/examples/virtualMachineExamples/VirtualMachine_InstallPatches.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armcompute_test

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v7"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7033e85e1f80ef5cd9ca664b538ed193a8fd815b/specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2025-04-01/examples/virtualMachineExamples/VirtualMachine_InstallPatches.json
func ExampleVirtualMachinesClient_BeginInstallPatches() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcompute.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewVirtualMachinesClient().BeginInstallPatches(ctx, "myResourceGroupName", "myVMName", armcompute.VirtualMachineInstallPatchesParameters{
		MaximumDuration: to.Ptr("PT4H"),
		RebootSetting:   to.Ptr(armcompute.VMGuestPatchRebootSettingIfRequired),
		WindowsParameters: &armcompute.WindowsParameters{
			ClassificationsToInclude: []*armcompute.VMGuestPatchClassificationWindows{
				to.Ptr(armcompute.VMGuestPatchClassificationWindowsCritical),
				to.Ptr(armcompute.VMGuestPatchClassificationWindowsSecurity)},
			MaxPatchPublishDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-19T02:36:43.053Z"); return t }()),
			PatchNameMasksToExclude: []*string{
				to.Ptr("*Windows*")},
			PatchNameMasksToInclude: []*string{
				to.Ptr("*SQL*")},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.VirtualMachineInstallPatchesResult = armcompute.VirtualMachineInstallPatchesResult{
	// 	ExcludedPatchCount: to.Ptr[int32](0),
	// 	FailedPatchCount: to.Ptr[int32](0),
	// 	InstallationActivityID: to.Ptr("68f8b292-dfc2-4646-9781-33cc88631968"),
	// 	InstalledPatchCount: to.Ptr[int32](3),
	// 	MaintenanceWindowExceeded: to.Ptr(false),
	// 	NotSelectedPatchCount: to.Ptr[int32](0),
	// 	Patches: []*armcompute.PatchInstallationDetail{
	// 		{
	// 			Name: to.Ptr("Definition Update for Windows Defender Antivirus - KB2267602 (Definition 1.279.1373.0)"),
	// 			Classifications: []*string{
	// 				to.Ptr("Definition Updates")},
	// 				InstallationState: to.Ptr(armcompute.PatchInstallationStateInstalled),
	// 				KbID: to.Ptr("2267602"),
	// 				PatchID: to.Ptr("35428702-5784-4ba4-a6e0-5222258b5411"),
	// 				Version: to.Ptr(""),
	// 			},
	// 			{
	// 				Name: to.Ptr("Windows Malicious Software Removal Tool x64 - October 2018 (KB890830)"),
	// 				Classifications: []*string{
	// 					to.Ptr("Update Rollups")},
	// 					InstallationState: to.Ptr(armcompute.PatchInstallationStatePending),
	// 					KbID: to.Ptr("890830"),
	// 					PatchID: to.Ptr("39f9cdd1-795c-4d0e-8c0a-73ab3f31746d"),
	// 					Version: to.Ptr(""),
	// 			}},
	// 			PendingPatchCount: to.Ptr[int32](2),
	// 			RebootStatus: to.Ptr(armcompute.VMGuestPatchRebootStatusCompleted),
	// 			StartDateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T21:02:04.255Z"); return t}()),
	// 			Status: to.Ptr(armcompute.PatchOperationStatusSucceeded),
	// 		}
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { ComputeManagementClient } = require("@azure/arm-compute");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Installs patches on the VM.
 *
 * @summary Installs patches on the VM.
 * x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2025-04-01/examples/virtualMachineExamples/VirtualMachine_InstallPatches.json
 */
async function installPatchStateOfAVirtualMachine() {
  const subscriptionId = process.env["COMPUTE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["COMPUTE_RESOURCE_GROUP"] || "myResourceGroupName";
  const vmName = "myVMName";
  const installPatchesInput = {
    maximumDuration: "PT4H",
    rebootSetting: "IfRequired",
    windowsParameters: {
      classificationsToInclude: ["Critical", "Security"],
      maxPatchPublishDate: new Date("2020-11-19T02:36:43.0539904+00:00"),
      patchNameMasksToExclude: ["*Windows*"],
      patchNameMasksToInclude: ["*SQL*"],
    },
  };
  const credential = new DefaultAzureCredential();
  const client = new ComputeManagementClient(credential, subscriptionId);
  const result = await client.virtualMachines.beginInstallPatchesAndWait(
    resourceGroupName,
    vmName,
    installPatchesInput,
  );
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2025-04-01/examples/virtualMachineExamples/VirtualMachine_InstallPatches.json
// this example is just showing the usage of "VirtualMachines_InstallPatches" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this VirtualMachineResource created on azure
// for more information of creating VirtualMachineResource, please refer to the document of VirtualMachineResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "myResourceGroupName";
string vmName = "myVMName";
ResourceIdentifier virtualMachineResourceId = VirtualMachineResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, vmName);
VirtualMachineResource virtualMachine = client.GetVirtualMachineResource(virtualMachineResourceId);

// invoke the operation
VirtualMachineInstallPatchesContent content = new VirtualMachineInstallPatchesContent(VmGuestPatchRebootSetting.IfRequired)
{
    MaximumDuration = XmlConvert.ToTimeSpan("PT4H"),
    WindowsParameters = new WindowsParameters
    {
        ClassificationsToInclude = { VmGuestPatchClassificationForWindows.Critical, VmGuestPatchClassificationForWindows.Security },
        MaxPatchPublishOn = DateTimeOffset.Parse("2020-11-19T02:36:43.0539904+00:00"),
        PatchNameMasksToInclude = { "*SQL*" },
        PatchNameMasksToExclude = { "*Windows*" },
    },
};
ArmOperation<VirtualMachineInstallPatchesResult> lro = await virtualMachine.InstallPatchesAsync(WaitUntil.Completed, content);
VirtualMachineInstallPatchesResult result = lro.Value;

Console.WriteLine($"Succeeded: {result}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Beispiel für eine Antwort

Statuscode:: 200

{
  "status": "Succeeded",
  "installationActivityId": "68f8b292-dfc2-4646-9781-33cc88631968",
  "rebootStatus": "Completed",
  "maintenanceWindowExceeded": false,
  "excludedPatchCount": 0,
  "notSelectedPatchCount": 0,
  "pendingPatchCount": 2,
  "installedPatchCount": 3,
  "failedPatchCount": 0,
  "startDateTime": "2020-04-24T21:02:04.2556154Z",
  "patches": [
    {
      "patchId": "35428702-5784-4ba4-a6e0-5222258b5411",
      "name": "Definition Update for Windows Defender Antivirus - KB2267602 (Definition 1.279.1373.0)",
      "version": "",
      "kbId": "2267602",
      "classifications": [
        "Definition Updates"
      ],
      "installationState": "Installed"
    },
    {
      "patchId": "39f9cdd1-795c-4d0e-8c0a-73ab3f31746d",
      "name": "Windows Malicious Software Removal Tool x64 - October 2018 (KB890830)",
      "version": "",
      "kbId": "890830",
      "classifications": [
        "Update Rollups"
      ],
      "installationState": "Pending"
    }
  ],
  "error": null
}

Statuscode:: 202

Location: https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/westus/operations/{operationId}&monitor=true&api-version=2025-04-01

Definitionen

Name	Beschreibung
ApiError	API-Fehler.
ApiErrorBase	API-Fehlerbasis.
CloudError	Eine Fehlerantwort vom Compute-Dienst.
InnerError	Innere Fehlerdetails.
LinuxParameters	Eingabe für InstallPatches auf einer Linux-VM, wie sie direkt von der API empfangen wird
PatchInstallationDetail	Informationen zu einem bestimmten Patch, der während einer Installationsaktion aufgetreten ist.
PatchInstallationState	Der Status des Patches nach Abschluss des Installationsvorgangs.
PatchOperationStatus	Der allgemeine Erfolgs- oder Fehlerstatus des Vorgangs. Er bleibt "InProgress", bis der Vorgang abgeschlossen ist. Zu diesem Zeitpunkt wird es zu "Unbekannt", "Fehlgeschlagen", "Erfolgreich" oder "AbgeschlossenWithWarnings".
VirtualMachineInstallPatchesParameters	Eingabe für InstallPatches, wie sie direkt von der API empfangen wird
VirtualMachineInstallPatchesResult	Die Ergebniszusammenfassung eines Installationsvorgangs.
VMGuestPatchClassificationLinux
VMGuestPatchClassificationWindows
VMGuestPatchRebootSetting	Definiert, wann es akzeptabel ist, einen virtuellen Computer während eines Softwareupdatevorgangs neu zu starten.
VMGuestPatchRebootStatus	Der Neustartstatus der VM nach Abschluss des Vorgangs.
WindowsParameters	Eingabe für InstallPatches auf einer Windows-VM, wie sie direkt von der API empfangen wird

ApiError

Objekt

API-Fehler.

Name	Typ	Beschreibung
code	string	Der Fehlercode.
details	ApiErrorBase[]	Die Details zum API-Fehler
innererror	InnerError	Der innere API-Fehler
message	string	Die Fehlermeldung.
target	string	Das Ziel des bestimmten Fehlers.

ApiErrorBase

Objekt

API-Fehlerbasis.

Name	Typ	Beschreibung
code	string	Der Fehlercode.
message	string	Die Fehlermeldung.
target	string	Das Ziel des bestimmten Fehlers.

CloudError

Objekt

Eine Fehlerantwort vom Compute-Dienst.

Name	Typ	Beschreibung
error	ApiError	API-Fehler.

InnerError

Objekt

Innere Fehlerdetails.

Name	Typ	Beschreibung
errordetail	string	Die interne Fehlermeldung oder der Ausnahmedump.
exceptiontype	string	Der Ausnahmetyp.

LinuxParameters

Objekt

Eingabe für InstallPatches auf einer Linux-VM, wie sie direkt von der API empfangen wird

Name	Typ	Beschreibung
classificationsToInclude	VMGuestPatchClassificationLinux[]	Die Updateklassifizierungen, die beim Installieren von Patches für Linux ausgewählt werden sollen.
maintenanceRunId	string	Dies wird als Wartungslauf-ID für das automatische Patchen von VM-Gästen unter Linux verwendet.
packageNameMasksToExclude	string[]	Pakete, die im Patchvorgang ausgeschlossen werden sollen. Format: packageName_packageVersion
packageNameMasksToInclude	string[]	Pakete, die in den Patchvorgang eingeschlossen werden sollen. Format: packageName_packageVersion

PatchInstallationDetail

Objekt

Informationen zu einem bestimmten Patch, der während einer Installationsaktion aufgetreten ist.

Name	Typ	Beschreibung
classifications	string[]	Die Klassifizierung(en) des Patches, wie sie vom Patch-Herausgeber bereitgestellt werden.
installationState	PatchInstallationState	Der Status des Patches nach Abschluss des Installationsvorgangs.
kbId	string	Die KBID des Patches. Gilt nur für Windows-Patches.
name	string	Der Anzeigename des Patches.
patchId	string	Eine eindeutige Kennung für den Patch.
version	string	Die Versionszeichenfolge des Pakets. Sie kann der semantischen Versionierung entsprechen. Gilt nur für Linux.

PatchInstallationState

Enumeration

Der Status des Patches nach Abschluss des Installationsvorgangs.

Wert	Beschreibung
Unknown
Installed
Failed
Excluded
NotSelected
Pending

PatchOperationStatus

Enumeration

Der allgemeine Erfolgs- oder Fehlerstatus des Vorgangs. Er bleibt "InProgress", bis der Vorgang abgeschlossen ist. Zu diesem Zeitpunkt wird es zu "Unbekannt", "Fehlgeschlagen", "Erfolgreich" oder "AbgeschlossenWithWarnings".

Wert	Beschreibung
Unknown
InProgress
Failed
Succeeded
CompletedWithWarnings

VirtualMachineInstallPatchesParameters

Objekt

Eingabe für InstallPatches, wie sie direkt von der API empfangen wird

Name	Typ	Beschreibung
linuxParameters	LinuxParameters	Eingabe für InstallPatches auf einer Linux-VM, wie sie direkt von der API empfangen wird
maximumDuration	string (duration)	Gibt die maximale Zeitspanne an, die der Vorgang ausführt. Es muss eine ISO 8601-kompatible Dauerzeichenfolge wie PT4H (4 Stunden) sein.
rebootSetting	VMGuestPatchRebootSetting	Definiert, wann es akzeptabel ist, einen virtuellen Computer während eines Softwareupdatevorgangs neu zu starten.
windowsParameters	WindowsParameters	Eingabe für InstallPatches auf einer Windows-VM, wie sie direkt von der API empfangen wird

VirtualMachineInstallPatchesResult

Objekt

Die Ergebniszusammenfassung eines Installationsvorgangs.

Name	Typ	Beschreibung
error	ApiError	Die Fehler, die während der Ausführung des Vorgangs aufgetreten sind. Das Details-Array enthält die Liste der Arrays.
excludedPatchCount	integer (int32)	Die Anzahl der Patches, die nicht installiert wurden, weil der Benutzer die Installation blockiert hat.
failedPatchCount	integer (int32)	Die Anzahl der Patches, die aufgrund eines Problems nicht installiert werden konnten. Weitere Informationen finden Sie unter Fehler.
installationActivityId	string	Die Aktivitäts-ID des Vorgangs, der dieses Ergebnis erzeugt hat. Es wird verwendet, um CRP- und Erweiterungsprotokolle zu korrelieren.
installedPatchCount	integer (int32)	Die Anzahl der erfolgreich installierten Patches.
maintenanceWindowExceeded	boolean	Gibt an, ob die Zeit des Vorgangs abgelaufen ist, bevor er alle beabsichtigten Aktionen ausgeführt hat.
notSelectedPatchCount	integer (int32)	Die Anzahl der Patches, die als zur Installation verfügbar erkannt wurden, aber die Kriterien des Vorgangs nicht erfüllten.
patches	PatchInstallationDetail[]	Die Patches, die während des Vorgangs installiert wurden.
pendingPatchCount	integer (int32)	Die Anzahl der Patches, die als die Installationskriterien erfüllend identifiziert wurden, aber nicht installiert werden konnten. In der Regel geschieht dies, wenn maintenanceWindowExceeded == true ist.
rebootStatus	VMGuestPatchRebootStatus	Der Neustartstatus der VM nach Abschluss des Vorgangs.
startDateTime	string (date-time)	Der UTC-Zeitstempel, zu dem der Vorgang gestartet wurde.
status	PatchOperationStatus	Der allgemeine Erfolgs- oder Fehlerstatus des Vorgangs. Er bleibt "InProgress", bis der Vorgang abgeschlossen ist. Zu diesem Zeitpunkt wird es zu "Fehlgeschlagen", "Erfolgreich", "Unbekannt" oder "AbgeschlossenWithWarnings".

VMGuestPatchClassificationLinux

Enumeration

Wert	Beschreibung
Critical
Security
Other

VMGuestPatchClassificationWindows

Enumeration

Wert	Beschreibung
Critical
Security
UpdateRollUp
FeaturePack
ServicePack
Definition
Tools
Updates

VMGuestPatchRebootSetting

Enumeration

Definiert, wann es akzeptabel ist, einen virtuellen Computer während eines Softwareupdatevorgangs neu zu starten.

Wert	Beschreibung
IfRequired
Never
Always

VMGuestPatchRebootStatus

Enumeration

Der Neustartstatus der VM nach Abschluss des Vorgangs.

Wert	Beschreibung
Unknown
NotNeeded
Required
Started
Failed
Completed

WindowsParameters

Objekt

Eingabe für InstallPatches auf einer Windows-VM, wie sie direkt von der API empfangen wird

Name	Typ	Beschreibung
classificationsToInclude	VMGuestPatchClassificationWindows[]	Die Updateklassifizierungen, die beim Installieren von Patches für Windows ausgewählt werden sollen.
excludeKbsRequiringReboot	boolean	Filtert KBs aus, die nicht über "InstallationRebootBehavior" von "NeverReboots" verfügen, wenn dies auf "true" festgelegt ist.
kbNumbersToExclude	string[]	Kbs, die im Patchvorgang ausgeschlossen werden sollen
kbNumbersToInclude	string[]	Kbs, die in den Patchvorgang aufgenommen werden sollen
maxPatchPublishDate	string (date-time)	Dies wird verwendet, um Patches zu installieren, die am oder vor diesem angegebenen maximalen Veröffentlichungsdatum veröffentlicht wurden.
patchNameMasksToExclude	string[]	Dies wird verwendet, um Patches auszuschließen, die mit den angegebenen Patch-Namensmasken übereinstimmen. Alphanumerische Zeichenfolgen und Platzhalterausdrücke, die aus * und ? werden nur als Eingabewerte in der Liste unterstützt. Null-, Leerzeichenfolgen und nur Leerzeichen als Eingabewerte werden nicht unterstützt.
patchNameMasksToInclude	string[]	Dies wird verwendet, um Patches einzuschließen, die mit den angegebenen Patch-Namensmasken übereinstimmen. Alphanumerische Zeichenfolgen und Platzhalterausdrücke, die aus * und ? werden nur als Eingabewerte in der Liste unterstützt. Null-, Leerzeichenfolgen und nur Leerzeichen als Eingabewerte werden nicht unterstützt.