Virtual Machines - Install Patches

Service:

Compute

API Version:

2024-03-01

Installeert patches op de VM.

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

URI-parameters

Name	In	Vereist	Type	Description
resourceGroupName	path	True	string	De naam van de resourcegroep.
subscriptionId	path	True	string	Abonnementsreferenties waarmee het Microsoft Azure-abonnement uniek wordt geïdentificeerd. De abonnements-id maakt deel uit van de URI voor elke service-aanroep.
vmName	path	True	string	De naam van de virtuele machine.
api-version	query	True	string	Client-API-versie.

Aanvraagbody

Name	Type	Description
installPatchesInput	VirtualMachineInstallPatchesParameters	Invoer voor InstallPatches zoals rechtstreeks ontvangen door de API

Antwoorden

Name	Type	Description
200 OK	VirtualMachineInstallPatchesResult	OK
202 Accepted		Geaccepteerd
Other Status Codes	CloudError	Foutreactie waarin wordt beschreven waarom de bewerking is mislukt.

Beveiliging

azure_auth

Azure Active Directory OAuth2-stroom

Type: oauth2
Flow: implicit
Authorization URL: https://login.microsoftonline.com/common/oauth2/authorize

Scopes

Name	Description
user_impersonation	Uw gebruikersaccount imiteren

Voorbeelden

Install patch state of a virtual machine.

Sample Request

HTTP

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

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

Java

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/2024-03-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"))),
            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

Python

from typing import Any, IO, Union

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",
            },
        },
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2024-03-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

Go

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/v5"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2024-03-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 }()),
		},
	}, 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

JavaScript

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

/**
 * 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/2024-03-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"),
    },
  };
  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

Sample Response

Status code:

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
}

Status code:

202

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

Definities

Name	Description
ApiError	API-fout.
ApiErrorBase	API-foutbasis.
CloudError	Een foutreactie van de Compute-service.
InnerError	Details van interne fout.
LinuxParameters	Invoer voor InstallPatches op een Virtuele Linux-machine, zoals rechtstreeks ontvangen door de API
PatchInstallationDetail	De patches die tijdens de bewerking zijn geïnstalleerd.
PatchInstallationState	De status van de patch nadat de installatiebewerking is voltooid.
PatchOperationStatus	De algehele geslaagde of mislukte status van de bewerking. Het blijft 'InProgress' totdat de bewerking is voltooid. Op dat moment wordt het 'Failed', 'Succeeded', 'Unknown' of 'CompletedWithWarnings'.
VirtualMachineInstallPatchesParameters	Invoer voor InstallPatches zoals rechtstreeks ontvangen door de API
VirtualMachineInstallPatchesResult	De samenvatting van het resultaat van een installatiebewerking.
VMGuestPatchClassification_Linux	De updateclassificaties die moeten worden geselecteerd bij het installeren van patches voor Linux.
VMGuestPatchClassification_Windows	De updateclassificaties die moeten worden geselecteerd bij het installeren van patches voor Windows.
VMGuestPatchRebootSetting	Definieert wanneer het acceptabel is om een VM opnieuw op te starten tijdens een software-updatebewerking.
VMGuestPatchRebootStatus	De status van het opnieuw opstarten van de VM na voltooiing van de bewerking.
WindowsParameters	Invoer voor InstallPatches op een Windows-VM, zoals rechtstreeks ontvangen door de API

ApiError

API-fout.

Name	Type	Description
code	string	De foutcode.
details	ApiErrorBase[]	De API-foutdetails
innererror	InnerError	De interne api-fout
message	string	Het foutbericht.
target	string	Het doel van de specifieke fout.

ApiErrorBase

API-foutbasis.

Name	Type	Description
code	string	De foutcode.
message	string	Het foutbericht.
target	string	Het doel van de specifieke fout.

CloudError

Een foutreactie van de Compute-service.

Name	Type	Description
error	ApiError	API-fout.

InnerError

Details van interne fout.

Name	Type	Description
errordetail	string	Het interne foutbericht of de uitzonderingsdump.
exceptiontype	string	Het uitzonderingstype.

LinuxParameters

Invoer voor InstallPatches op een Virtuele Linux-machine, zoals rechtstreeks ontvangen door de API

Name	Type	Description
classificationsToInclude	VMGuestPatchClassification_Linux[]	De updateclassificaties die moeten worden geselecteerd bij het installeren van patches voor Linux.
maintenanceRunId	string	Dit wordt gebruikt als een onderhoudsuitvoerings-id voor automatische VM-gastpatching in Linux.
packageNameMasksToExclude	string[]	pakketten die moeten worden uitgesloten in de patchbewerking. Indeling: packageName_packageVersion
packageNameMasksToInclude	string[]	pakketten die moeten worden opgenomen in de patchbewerking. Indeling: packageName_packageVersion

PatchInstallationDetail

De patches die tijdens de bewerking zijn geïnstalleerd.

Name	Type	Description
classifications	string[]	De classificatie(s) van de patch zoals opgegeven door de uitgever van de patch.
installationState	PatchInstallationState	De status van de patch nadat de installatiebewerking is voltooid.
kbId	string	De KBID van de patch. Alleen van toepassing op Windows-patches.
name	string	De beschrijvende naam van de patch.
patchId	string	Een unieke id voor de patch.
version	string	De versietekenreeks van het pakket. Het kan voldoen aan Semantic Versioning. Alleen van toepassing op Linux.

PatchInstallationState

De status van de patch nadat de installatiebewerking is voltooid.

Name	Type	Description
Excluded	string
Failed	string
Installed	string
NotSelected	string
Pending	string
Unknown	string

PatchOperationStatus

De algehele geslaagde of mislukte status van de bewerking. Het blijft 'InProgress' totdat de bewerking is voltooid. Op dat moment wordt het 'Failed', 'Succeeded', 'Unknown' of 'CompletedWithWarnings'.

Name	Type	Description
CompletedWithWarnings	string
Failed	string
InProgress	string
Succeeded	string
Unknown	string

VirtualMachineInstallPatchesParameters

Invoer voor InstallPatches zoals rechtstreeks ontvangen door de API

Name	Type	Description
linuxParameters	LinuxParameters	Invoer voor InstallPatches op een Virtuele Linux-machine, zoals rechtstreeks ontvangen door de API
maximumDuration	string	Hiermee geeft u de maximale tijdsduur op die de bewerking moet worden uitgevoerd. Het moet een ISO 8601-compatibele duurtekenreeks zijn, zoals PT4H (4 uur)
rebootSetting	VMGuestPatchRebootSetting	Definieert wanneer het acceptabel is om een VM opnieuw op te starten tijdens een software-updatebewerking.
windowsParameters	WindowsParameters	Invoer voor InstallPatches op een Windows-VM, zoals rechtstreeks ontvangen door de API

VirtualMachineInstallPatchesResult

De samenvatting van het resultaat van een installatiebewerking.

Name	Type	Description
error	ApiError	De fouten die zijn opgetreden tijdens het uitvoeren van de bewerking. De matrix met details bevat de lijst ervan.
excludedPatchCount	integer	Het aantal patches dat niet is geïnstalleerd omdat de gebruiker de installatie heeft geblokkeerd.
failedPatchCount	integer	Het aantal patches dat niet kan worden geïnstalleerd vanwege een probleem. Zie fouten voor meer informatie.
installationActivityId	string	De activiteits-id van de bewerking die dit resultaat heeft gegenereerd. Het wordt gebruikt om te correleren tussen CRP- en extensielogboeken.
installedPatchCount	integer	Het aantal patches dat is geïnstalleerd.
maintenanceWindowExceeded	boolean	Of de bewerking te laat is voordat alle beoogde acties zijn voltooid.
notSelectedPatchCount	integer	Het aantal patches dat is gedetecteerd als beschikbaar voor installatie, maar niet voldoet aan de criteria van de bewerking.
patches	PatchInstallationDetail[]	De patches die tijdens de bewerking zijn geïnstalleerd.
pendingPatchCount	integer	Het aantal patches dat aan de installatiecriteria voldoet, maar niet kan worden geïnstalleerd. Dit gebeurt meestal wanneer maintenanceWindowExceeded == true is.
rebootStatus	VMGuestPatchRebootStatus	De status van het opnieuw opstarten van de VM na voltooiing van de bewerking.
startDateTime	string	De UTC-tijdstempel wanneer de bewerking is gestart.
status	PatchOperationStatus	De algehele geslaagde of mislukte status van de bewerking. Het blijft 'InProgress' totdat de bewerking is voltooid. Op dat moment wordt het 'Failed', 'Succeeded', 'Unknown' of 'CompletedWithWarnings'.

VMGuestPatchClassification_Linux

De updateclassificaties die moeten worden geselecteerd bij het installeren van patches voor Linux.

Name	Type	Description
Critical	string
Other	string
Security	string

VMGuestPatchClassification_Windows

De updateclassificaties die moeten worden geselecteerd bij het installeren van patches voor Windows.

Name	Type	Description
Critical	string
Definition	string
FeaturePack	string
Security	string
ServicePack	string
Tools	string
UpdateRollUp	string
Updates	string

VMGuestPatchRebootSetting

Definieert wanneer het acceptabel is om een VM opnieuw op te starten tijdens een software-updatebewerking.

Name	Type	Description
Always	string
IfRequired	string
Never	string

VMGuestPatchRebootStatus

De status van het opnieuw opstarten van de VM na voltooiing van de bewerking.

Name	Type	Description
Completed	string
Failed	string
NotNeeded	string
Required	string
Started	string
Unknown	string

WindowsParameters

Invoer voor InstallPatches op een Windows-VM, zoals rechtstreeks ontvangen door de API

Name	Type	Description
classificationsToInclude	VMGuestPatchClassification_Windows[]	De updateclassificaties die moeten worden geselecteerd bij het installeren van patches voor Windows.
excludeKbsRequiringReboot	boolean	Filtert Kb's uit die geen InstallationRebootBehavior van 'NeverReboots' hebben wanneer dit is ingesteld op true.
kbNumbersToExclude	string[]	Kbs die moeten worden uitgesloten in de patchbewerking
kbNumbersToInclude	string[]	Kbs die moeten worden opgenomen in de patchbewerking
maxPatchPublishDate	string	Dit wordt gebruikt voor het installeren van patches die zijn gepubliceerd op of vóór deze opgegeven maximale publicatiedatum.