Virtual Machines - Install Patches

Service:

Compute

API-versie:

2024-03-01

Installeert patches op de virtuele machine.

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 die het Microsoft Azure-abonnement uniek identificeren. De abonnements-id maakt deel uit van de URI voor elke serviceoproep.
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
Stroom: implicit
Autorisatie-URL: https://login.microsoftonline.com/common/oauth2/authorize

Bereiken

Name	Description
user_impersonation	Uw gebruikersaccount imiteren

Voorbeelden

Install patch state of a virtual machine.

Voorbeeldaanvraag

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

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/81a4ee5a83ae38620c0e1404793caffe005d26e4/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

dotnet

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.Resources;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2024-03-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"),
    },
};
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

Voorbeeldrespons

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=2024-03-01

Definities

Name	Description
ApiError	Api-fout.
ApiErrorBase	Api-foutbasis.
CloudError	Een foutreactie van de Compute-service.
InnerError	Interne foutdetails.
LinuxParameters	Invoer voor InstallPatches op een Linux-VM, 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 succes- of foutstatus van de bewerking. Het blijft 'InProgress' totdat de bewerking is voltooid. Op dat moment wordt het 'Mislukt', 'Geslaagd', 'Onbekend' of 'CompletedWithWarnings'.
VirtualMachineInstallPatchesParameters	Invoer voor InstallPatches zoals rechtstreeks ontvangen door de API
VirtualMachineInstallPatchesResult	Het resultaatoverzicht 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 VIRTUELE machine opnieuw op te starten tijdens een software-updatebewerking.
VMGuestPatchRebootStatus	De herstartstatus van de VIRTUELE machine 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[]	Details van de API-fout
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

Interne foutdetails.

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

LinuxParameters

Invoer voor InstallPatches op een Linux-VM, 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 geleverd door de patchuitgever.
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 succes- of foutstatus van de bewerking. Het blijft 'InProgress' totdat de bewerking is voltooid. Op dat moment wordt het 'Mislukt', 'Geslaagd', 'Onbekend' 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 Linux-VM, zoals rechtstreeks ontvangen door de API
maximumDuration	string	Hiermee geeft u de maximale tijdsduur op die de bewerking wordt uitgevoerd. Het moet een iso 8601-compatibele duurtekenreeks zijn, zoals PT4H (4 uur)
rebootSetting	VMGuestPatchRebootSetting	Definieert wanneer het acceptabel is om een VIRTUELE machine opnieuw op te starten tijdens een software-updatebewerking.
windowsParameters	WindowsParameters	Invoer voor InstallPatches op een Windows-VM, zoals rechtstreeks ontvangen door de API

VirtualMachineInstallPatchesResult

Het resultaatoverzicht van een installatiebewerking.

Name	Type	Description
error	ApiError	De fouten die zijn opgetreden tijdens de uitvoering van de bewerking. De detailmatrix bevat de lijst met deze.
excludedPatchCount	integer	Het aantal patches dat niet is geïnstalleerd omdat de gebruiker de installatie blokkeert.
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 geproduceerd. Het wordt gebruikt om te correleren tussen CRP- en extensielogboeken.
installedPatchCount	integer	Het aantal patches dat is geïnstalleerd.
maintenanceWindowExceeded	boolean	Of de bewerking onvoldoende tijd heeft 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 is geïdentificeerd als voldoen aan de installatiecriteria, maar die niet konden worden geïnstalleerd. Dit gebeurt meestal wanneer maintenanceWindowExceeded == true.
rebootStatus	VMGuestPatchRebootStatus	De herstartstatus van de VIRTUELE machine na voltooiing van de bewerking.
startDateTime	string	De UTC-tijdstempel waarop de bewerking is gestart.
status	PatchOperationStatus	De algehele succes- of foutstatus van de bewerking. Het blijft 'InProgress' totdat de bewerking is voltooid. Op dat moment wordt het 'Mislukt', 'Geslaagd', 'Onbekend' 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 VIRTUELE machine opnieuw op te starten tijdens een software-updatebewerking.

Name	Type	Description
Always	string
IfRequired	string
Never	string

VMGuestPatchRebootStatus

De herstartstatus van de VIRTUELE machine 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	Hiermee filtert u Kbs die geen InstallationRebootBehavior van 'NeverReboots' hebben als dit is ingesteld op waar.
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 om patches te installeren die zijn gepubliceerd op of vóór deze maximale gepubliceerde datum.