Virtual Machines - Install Patches

Référence

Service:: Compute

Version d'API:: 2024-03-01

Installe des correctifs sur la machine virtuelle.

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

Paramètres URI

Nom	Dans	Obligatoire	Type	Description
resourceGroupName	path	True	string	Nom du groupe de ressources.
subscriptionId	path	True	string	Informations d’identification d’abonnement qui identifient de manière unique l’abonnement Microsoft Azure. L’ID d’abonnement fait partie de l’URI de chaque appel de service.
vmName	path	True	string	Nom de la machine virtuelle.
api-version	query	True	string	Version de l’API cliente.

Corps de la demande

Nom	Type	Description
installPatchesInput	VirtualMachineInstallPatchesParameters	Entrée pour InstallPatches directement reçue par l’API

Réponses

Nom	Type	Description
200 OK	VirtualMachineInstallPatchesResult	D’ACCORD
202 Accepted		Accepté
Other Status Codes	CloudError	Réponse d’erreur décrivant pourquoi l’opération a échoué.

Sécurité

azure_auth

Flux OAuth2 Azure Active Directory

Type: oauth2
Flux: implicit
URL d’autorisation: https://login.microsoftonline.com/common/oauth2/authorize

Étendues

Nom	Description
user_impersonation	emprunter l’identité de votre compte d’utilisateur

Exemples

Install patch state of a virtual machine.

Exemple de requête

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


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

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

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

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

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

Exemple de réponse

Code d’état:: 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
}

Code d’état:: 202

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

Définitions

Nom	Description
ApiError	Erreur d’API.
ApiErrorBase	Base d’erreurs d’API.
CloudError	Réponse d’erreur du service de calcul.
InnerError	Détails de l’erreur interne.
LinuxParameters	Entrée pour InstallPatches sur une machine virtuelle Linux, telle que reçue directement par l’API
PatchInstallationDetail	Correctifs installés pendant l’opération.
PatchInstallationState	État du correctif une fois l’opération d’installation terminée.
PatchOperationStatus	État global de réussite ou d’échec de l’opération. Il reste « InProgress » jusqu’à ce que l’opération se termine. À ce stade, il devient « Échec », « Réussite », « Inconnu » ou « CompletedWithWarnings ».
VirtualMachineInstallPatchesParameters	Entrée pour InstallPatches directement reçue par l’API
VirtualMachineInstallPatchesResult	Résumé du résultat d’une opération d’installation.
VMGuestPatchClassification_Linux	Classifications de mise à jour à sélectionner lors de l’installation des correctifs pour Linux.
VMGuestPatchClassification_Windows	Classifications de mise à jour à sélectionner lors de l’installation des correctifs pour Windows.
VMGuestPatchRebootSetting	Définit quand il est acceptable de redémarrer une machine virtuelle pendant une opération de mise à jour logicielle.
VMGuestPatchRebootStatus	État de redémarrage de la machine virtuelle après la fin de l’opération.
WindowsParameters	Entrée pour InstallPatches sur une machine virtuelle Windows, telle que reçue directement par l’API

ApiError

Erreur d’API.

Nom	Type	Description
code	string	Code d’erreur.
details	ApiErrorBase[]	Détails de l’erreur api
innererror	InnerError	Erreur interne de l’API
message	string	Message d’erreur.
target	string	Cible de l’erreur particulière.

ApiErrorBase

Base d’erreurs d’API.

Nom	Type	Description
code	string	Code d’erreur.
message	string	Message d’erreur.
target	string	Cible de l’erreur particulière.

CloudError

Réponse d’erreur du service de calcul.

Nom	Type	Description
error	ApiError	Erreur d’API.

InnerError

Détails de l’erreur interne.

Nom	Type	Description
errordetail	string	Message d’erreur interne ou vidage d’exception.
exceptiontype	string	Type d’exception.

LinuxParameters

Entrée pour InstallPatches sur une machine virtuelle Linux, telle que reçue directement par l’API

Nom	Type	Description
classificationsToInclude	VMGuestPatchClassification_Linux[]	Classifications de mise à jour à sélectionner lors de l’installation des correctifs pour Linux.
maintenanceRunId	string	Il s’agit d’un identificateur d’exécution de maintenance pour la mise à jour corrective d’invité de machine virtuelle automatique dans Linux.
packageNameMasksToExclude	string[]	packages à exclure dans l’opération de correctif. Format : packageName_packageVersion
packageNameMasksToInclude	string[]	packages à inclure dans l’opération de correctif. Format : packageName_packageVersion

PatchInstallationDetail

Correctifs installés pendant l’opération.

Nom	Type	Description
classifications	string[]	Classification(s) du correctif tel que fourni par l’éditeur de correctifs.
installationState	PatchInstallationState	État du correctif une fois l’opération d’installation terminée.
kbId	string	KBID du correctif. S’applique uniquement aux correctifs Windows.
name	string	Nom convivial du correctif.
patchId	string	Identificateur unique du correctif.
version	string	Chaîne de version du package. Il peut être conforme au contrôle de version sémantique. S’applique uniquement à Linux.

PatchInstallationState

État du correctif une fois l’opération d’installation terminée.

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

PatchOperationStatus

État global de réussite ou d’échec de l’opération. Il reste « InProgress » jusqu’à ce que l’opération se termine. À ce stade, il devient « Échec », « Réussite », « Inconnu » ou « CompletedWithWarnings ».

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

VirtualMachineInstallPatchesParameters

Entrée pour InstallPatches directement reçue par l’API

Nom	Type	Description
linuxParameters	LinuxParameters	Entrée pour InstallPatches sur une machine virtuelle Linux, telle que reçue directement par l’API
maximumDuration	string	Spécifie la durée maximale pendant laquelle l’opération s’exécutera. Il doit s’agir d’une chaîne de durée conforme ISO 8601 telle que PT4H (4 heures)
rebootSetting	VMGuestPatchRebootSetting	Définit quand il est acceptable de redémarrer une machine virtuelle pendant une opération de mise à jour logicielle.
windowsParameters	WindowsParameters	Entrée pour InstallPatches sur une machine virtuelle Windows, telle que reçue directement par l’API

VirtualMachineInstallPatchesResult

Résumé du résultat d’une opération d’installation.

Nom	Type	Description
error	ApiError	Erreurs rencontrées lors de l’exécution de l’opération. Le tableau de détails contient la liste d’entre eux.
excludedPatchCount	integer	Nombre de correctifs qui n’ont pas été installés en raison du blocage de l’installation par l’utilisateur.
failedPatchCount	integer	Nombre de correctifs qui n’ont pas pu être installés en raison d’un problème. Pour plus d’informations, consultez les erreurs.
installationActivityId	string	ID d’activité de l’opération qui a produit ce résultat. Il est utilisé pour mettre en corrélation entre les journaux d’activité de la CRP et de l’extension.
installedPatchCount	integer	Nombre de correctifs correctement installés.
maintenanceWindowExceeded	boolean	Indique si l’opération a expiré avant qu’elle n’ait terminé toutes ses actions prévues.
notSelectedPatchCount	integer	Nombre de correctifs détectés comme disponibles pour l’installation, mais qui ne répondent pas aux critères de l’opération.
patches	PatchInstallationDetail[]	Correctifs installés pendant l’opération.
pendingPatchCount	integer	Nombre de correctifs identifiés comme répondant aux critères d’installation, mais qui n’ont pas pu être installés. Cela se produit généralement quand maintenanceWindowExceeded == true.
rebootStatus	VMGuestPatchRebootStatus	État de redémarrage de la machine virtuelle après la fin de l’opération.
startDateTime	string	Horodatage UTC au début de l’opération.
status	PatchOperationStatus	État global de réussite ou d’échec de l’opération. Il reste « InProgress » jusqu’à ce que l’opération se termine. À ce stade, il devient « Échec », « Réussite », « Inconnu » ou « CompletedWithWarnings ».

VMGuestPatchClassification_Linux

Classifications de mise à jour à sélectionner lors de l’installation des correctifs pour Linux.

Nom	Type	Description
Critical	string
Other	string
Security	string

VMGuestPatchClassification_Windows

Classifications de mise à jour à sélectionner lors de l’installation des correctifs pour Windows.

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

VMGuestPatchRebootSetting

Définit quand il est acceptable de redémarrer une machine virtuelle pendant une opération de mise à jour logicielle.

Nom	Type	Description
Always	string
IfRequired	string
Never	string

VMGuestPatchRebootStatus

État de redémarrage de la machine virtuelle après la fin de l’opération.

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

WindowsParameters

Entrée pour InstallPatches sur une machine virtuelle Windows, telle que reçue directement par l’API

Nom	Type	Description
classificationsToInclude	VMGuestPatchClassification_Windows[]	Classifications de mise à jour à sélectionner lors de l’installation des correctifs pour Windows.
excludeKbsRequiringReboot	boolean	Filtre les Ko qui n’ont pas d’installationRebootBehavior de « NeverReboots » quand cette valeur est définie sur true.
kbNumbersToExclude	string[]	Ko à exclure dans l’opération de correctif
kbNumbersToInclude	string[]	Kbs à inclure dans l’opération de correctif
maxPatchPublishDate	string	Il est utilisé pour installer des correctifs publiés ou avant cette date de publication maximale donnée.