Virtual Machines - Install Patches

Tjänst:

Compute

API-version:

2024-07-01

Installerar korrigeringar på den virtuella datorn.

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

URI-parametrar

Name	I	Obligatorisk	Typ	Description
resourceGroupName	path	True	string	Namnet på resursgruppen.
subscriptionId	path	True	string	Prenumerationsautentiseringsuppgifter som unikt identifierar Microsoft Azure-prenumeration. Prenumerations-ID:t utgör en del av URI:n för varje tjänstanrop.
vmName	path	True	string	Namnet på den virtuella datorn.
api-version	query	True	string	Klient-API-version.

Begärandetext

Name	Typ	Description
installPatchesInput	VirtualMachineInstallPatchesParameters	Indata för InstallPatches som tas emot direkt av API:et

Svar

Name	Typ	Description
200 OK	VirtualMachineInstallPatchesResult	OKEJ
202 Accepted		Accepterad
Other Status Codes	CloudError	Felsvar som beskriver varför åtgärden misslyckades.

Säkerhet

azure_auth

Azure Active Directory OAuth2 Flow

Typ: oauth2
Flow: implicit
Auktoriseringswebbadress: https://login.microsoftonline.com/common/oauth2/authorize

Omfattningar

Name	Description
user_impersonation	personifiera ditt användarkonto

Exempel

Install patch state of a virtual machine.

Exempelbegäran

HTTP

POST https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroupName/providers/Microsoft.Compute/virtualMachines/myVMName/installPatches?api-version=2024-07-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-07-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 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-07-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/d6d0798c6f5eb196fba7bd1924db2b145a94f58c/specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2024-07-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");
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/2024-07-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.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2024-07-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

Exempelsvar

Statuskod:

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
}

Statuskod:

202

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

Definitioner

Name	Description
ApiError	Api-fel.
ApiErrorBase	Api-felbas.
CloudError	Ett felsvar från Compute-tjänsten.
InnerError	Inre felinformation.
LinuxParameters	Indata för InstallPatches på en virtuell Linux-dator, som tas emot direkt av API:et
PatchInstallationDetail	Korrigeringarna som installerades under åtgärden.
PatchInstallationState	Status för korrigeringen när installationen har slutförts.
PatchOperationStatus	Åtgärdens övergripande status för lyckade eller misslyckade åtgärder. Den förblir "InProgress" tills åtgärden har slutförts. Då blir det "Failed", "Succeeded", "Unknown" eller "CompletedWithWarnings".
VirtualMachineInstallPatchesParameters	Indata för InstallPatches som tas emot direkt av API:et
VirtualMachineInstallPatchesResult	Resultatsammanfattningen för en installationsåtgärd.
VMGuestPatchClassification_Linux	De uppdateringsklassificeringar som ska väljas när du installerar korrigeringar för Linux.
VMGuestPatchClassification_Windows	De uppdateringsklassificeringar som ska väljas vid installation av korrigeringar för Windows.
VMGuestPatchRebootSetting	Definierar när det är acceptabelt att starta om en virtuell dator under en programuppdateringsåtgärd.
VMGuestPatchRebootStatus	Omstartstillståndet för den virtuella datorn efter att åtgärden har slutförts.
WindowsParameters	Indata för InstallPatches på en virtuell Windows-dator, som tas emot direkt av API:et

ApiError

Objekt

Api-fel.

Name	Typ	Description
code	string	Felkoden.
details	ApiErrorBase[]	Api-felinformationen
innererror	InnerError	Api:ets inre fel
message	string	Felmeddelandet.
target	string	Målet för det specifika felet.

ApiErrorBase

Objekt

Api-felbas.

Name	Typ	Description
code	string	Felkoden.
message	string	Felmeddelandet.
target	string	Målet för det specifika felet.

CloudError

Objekt

Ett felsvar från Compute-tjänsten.

Name	Typ	Description
error	ApiError	Api-fel.

InnerError

Objekt

Inre felinformation.

Name	Typ	Description
errordetail	string	Det interna felmeddelandet eller undantagsdumpen.
exceptiontype	string	Undantagstypen.

LinuxParameters

Objekt

Indata för InstallPatches på en virtuell Linux-dator, som tas emot direkt av API:et

Name	Typ	Description
classificationsToInclude	VMGuestPatchClassification_Linux[]	De uppdateringsklassificeringar som ska väljas när du installerar korrigeringar för Linux.
maintenanceRunId	string	Detta används som en underhållskörningsidentifierare för automatisk vm-gästkorrigering i Linux.
packageNameMasksToExclude	string[]	paket som ska undantas i korrigeringsåtgärden. Format: packageName_packageVersion
packageNameMasksToInclude	string[]	paket som ska ingå i korrigeringsåtgärden. Format: packageName_packageVersion

PatchInstallationDetail

Objekt

Korrigeringarna som installerades under åtgärden.

Name	Typ	Description
classifications	string[]	Korrigeringsutgivarens klassificeringar.
installationState	PatchInstallationState	Status för korrigeringen när installationen har slutförts.
kbId	string	KBID för korrigeringen. Gäller endast Windows-korrigeringar.
name	string	Det egna namnet på korrigeringen.
patchId	string	En unik identifierare för korrigeringen.
version	string	Versionssträngen för paketet. Den kan överensstämma med semantisk versionshantering. Gäller endast för Linux.

PatchInstallationState

Uppräkning

Status för korrigeringen när installationen har slutförts.

Värde	Description
Excluded
Failed
Installed
NotSelected
Pending
Unknown

PatchOperationStatus

Uppräkning

Åtgärdens övergripande status för lyckade eller misslyckade åtgärder. Den förblir "InProgress" tills åtgärden har slutförts. Då blir det "Failed", "Succeeded", "Unknown" eller "CompletedWithWarnings".

Värde	Description
CompletedWithWarnings
Failed
InProgress
Succeeded
Unknown

VirtualMachineInstallPatchesParameters

Objekt

Indata för InstallPatches som tas emot direkt av API:et

Name	Typ	Description
linuxParameters	LinuxParameters	Indata för InstallPatches på en virtuell Linux-dator, som tas emot direkt av API:et
maximumDuration	string	Anger den maximala tid som åtgärden ska köras. Det måste vara en ISO 8601-kompatibel varaktighetssträng, till exempel PT4H (4 timmar)
rebootSetting	VMGuestPatchRebootSetting	Definierar när det är acceptabelt att starta om en virtuell dator under en programuppdateringsåtgärd.
windowsParameters	WindowsParameters	Indata för InstallPatches på en virtuell Windows-dator, som tas emot direkt av API:et

VirtualMachineInstallPatchesResult

Objekt

Resultatsammanfattningen för en installationsåtgärd.

Name	Typ	Description
error	ApiError	De fel som påträffades under körningen av åtgärden. Informationsmatrisen innehåller listan över dem.
excludedPatchCount	integer (int32)	Antalet korrigeringar som inte har installerats på grund av att användaren blockerar installationen.
failedPatchCount	integer (int32)	Antalet korrigeringar som inte kunde installeras på grund av ett problem. Mer information finns i fel.
installationActivityId	string	Aktivitets-ID för den åtgärd som genererade det här resultatet. Det används för att korrelera mellan CRP- och tilläggsloggar.
installedPatchCount	integer (int32)	Antalet korrigeringar har installerats.
maintenanceWindowExceeded	boolean	Om åtgärden tog slut innan den slutförde alla avsedda åtgärder.
notSelectedPatchCount	integer (int32)	Antalet korrigeringar som identifierades som tillgängliga för installation, men som inte uppfyllde åtgärdens villkor.
patches	PatchInstallationDetail[]	Korrigeringarna som installerades under åtgärden.
pendingPatchCount	integer (int32)	Antalet korrigeringar som identifierades som uppfyller installationsvillkoren, men som inte kunde installeras. Detta inträffar vanligtvis när underhållWindowExceeded == true.
rebootStatus	VMGuestPatchRebootStatus	Omstartstillståndet för den virtuella datorn efter att åtgärden har slutförts.
startDateTime	string (date-time)	UTC-tidsstämpeln när åtgärden påbörjades.
status	PatchOperationStatus	Åtgärdens övergripande status för lyckade eller misslyckade åtgärder. Den förblir "InProgress" tills åtgärden har slutförts. Då blir det "Failed", "Succeeded", "Unknown" eller "CompletedWithWarnings".

VMGuestPatchClassification_Linux

Uppräkning

De uppdateringsklassificeringar som ska väljas när du installerar korrigeringar för Linux.

Värde	Description
Critical
Other
Security

VMGuestPatchClassification_Windows

Uppräkning

De uppdateringsklassificeringar som ska väljas vid installation av korrigeringar för Windows.

Värde	Description
Critical
Definition
FeaturePack
Security
ServicePack
Tools
UpdateRollUp
Updates

VMGuestPatchRebootSetting

Uppräkning

Definierar när det är acceptabelt att starta om en virtuell dator under en programuppdateringsåtgärd.

Värde	Description
Always
IfRequired
Never

VMGuestPatchRebootStatus

Uppräkning

Omstartstillståndet för den virtuella datorn efter att åtgärden har slutförts.

Värde	Description
Completed
Failed
NotNeeded
Required
Started
Unknown

WindowsParameters

Objekt

Indata för InstallPatches på en virtuell Windows-dator, som tas emot direkt av API:et

Name	Typ	Description
classificationsToInclude	VMGuestPatchClassification_Windows[]	De uppdateringsklassificeringar som ska väljas vid installation av korrigeringar för Windows.
excludeKbsRequiringReboot	boolean	Filtrerar bort kbs som inte har en InstallationRebootBehavior av "NeverReboots" när detta är inställt på true.
kbNumbersToExclude	string[]	KB:ar som ska undantas i korrigeringsåtgärden
kbNumbersToInclude	string[]	Kbs som ska inkluderas i korrigeringsåtgärden
maxPatchPublishDate	string (date-time)	Detta används för att installera korrigeringar som publicerades på eller före det angivna maxpubliceringsdatumet.