NodeJS Script for Automating VM Image Update in VM Scale Set

ylwong

Yes, in Microsoft Azure, you can automate these processes with a Node.js script using the Azure SDK for JavaScript and REST API calls. Here’s an overview of the process and code structure you can use for each step:

Requirements

Azure SDK for JavaScript (@azure/arm-compute, @azure/arm-resources, @azure/identity)
Node.js and npm

Steps and Code Structure

Step 1: Snapshot the VM Scale Set OS Disk

Use the Azure Compute Management client to create a snapshot and wait for it to complete.

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

const subscriptionId = "your-subscription-id";
const resourceGroupName = "your-resource-group";
const vmssName = "your-vmss-name";
const diskId = "your-disk-id"; // OS Disk ID

async function createSnapshot() {
  const computeClient = new ComputeManagementClient(new DefaultAzureCredential(), subscriptionId);
  const snapshotName = `snapshot-${Date.now()}`;

  const snapshot = await computeClient.snapshots.beginCreateOrUpdateAndWait(resourceGroupName, snapshotName, {
    location: "your-region",
    creationData: { createOption: "Copy", sourceResourceId: diskId },
  });

  return snapshot.id;
}

Step 2: Add a New Version to an Existing VM Image Definition

To add a new version, auto-generate the next version number by incrementing the latest version number and create a new image version.

const { GalleryImageVersions } = require("@azure/arm-compute");

async function createImageVersion(snapshotId) {
  const galleryImageName = "your-image-definition-name";
  const galleryName = "your-gallery-name";
  const location = "your-region";
  
  const galleryClient = new GalleryImageVersions(new DefaultAzureCredential(), subscriptionId);
  
  // Retrieve current versions and auto-generate the next version
  const existingVersions = await galleryClient.listByGalleryImage(resourceGroupName, galleryName, galleryImageName);
  const latestVersion = existingVersions[existingVersions.length - 1]?.name || "1.0.0";
  const [major, minor, patch] = latestVersion.split(".").map(Number);
  const newVersion = `${major}.${minor}.${patch + 1}`;

  // Create new image version using snapshot
  const imageVersion = await galleryClient.beginCreateOrUpdateAndWait(resourceGroupName, galleryName, galleryImageName, newVersion, {
    location: location,
    publishingProfile: { targetRegions: [{ name: location }] },
    storageProfile: { source: { id: snapshotId } },
  });

  return newVersion;
}

Step 3: Update the VM Scale Set to Use the New Image Version

Once the new image version is created, update the image reference for the VM scale set.

async function updateVmssImage(newVersion) {
  const vmssClient = new ComputeManagementClient(new DefaultAzureCredential(), subscriptionId);

  // Retrieve VMSS model
  const vmss = await vmssClient.virtualMachineScaleSets.get(resourceGroupName, vmssName);

  // Update image reference with the new version
  vmss.virtualMachineProfile.storageProfile.imageReference = {
    id: `/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.Compute/galleries/your-gallery-name/images/your-image-definition-name/versions/${newVersion}`
  };

  // Update VMSS
  await vmssClient.virtualMachineScaleSets.beginCreateOrUpdateAndWait(resourceGroupName, vmssName, vmss);
}

Step 4: Delete the Snapshot

After the VM Scale Set has been updated, delete the snapshot created in Step 1.

async function deleteSnapshot(snapshotId) {
  const computeClient = new ComputeManagementClient(new DefaultAzureCredential(), subscriptionId);
  const snapshotName = snapshotId.split("/").pop();

  await computeClient.snapshots.beginDeleteAndWait(resourceGroupName, snapshotName);
}

Full Automation Function

Combine all the steps in an async function to ensure each step completes before moving to the next:

async function automateVmssUpdate() {
  try {
    // Step 1: Create a Snapshot
    const snapshotId = await createSnapshot();
    console.log("Snapshot created:", snapshotId);

    // Step 2: Create a new Image Version
    const newVersion = await createImageVersion(snapshotId);
    console.log("New image version created:", newVersion);

    // Step 3: Update VM Scale Set
    await updateVmssImage(newVersion);
    console.log("VM Scale Set updated with new image version:", newVersion);

    // Step 4: Delete the Snapshot
    await deleteSnapshot(snapshotId);
    console.log("Snapshot deleted:", snapshotId);

  } catch (error) {
    console.error("An error occurred:", error);
  }
}

automateVmssUpdate();

Run the Script

Install dependencies:

   npm install @azure/identity @azure/arm-compute

Run the script:

   node automateVmssUpdate.js

This script will automate the process of creating a snapshot, updating the image version, applying it to a VM scale set, and cleaning up the snapshot, all while waiting for each step to complete.

ylwong

Yes, it's possible to automate this sequence in Azure with a Node.js script by using the Azure SDK for JavaScript and Azure REST APIs. Below is an outline of how you could structure this automation:

Snapshot VM Scale Set OS Disk:
- Use @azure/arm-compute to interact with the Compute resources.
- Obtain the VM disk ID and create a snapshot of the OS disk.
- Use beginCreateOrUpdate and pollUntilDone to ensure the snapshot creation completes before proceeding.
Add a New Version to VM Image Definition:
- After creating the snapshot, use the image definition’s current version and increment it to auto-generate the next version.
- Then, create a new image version and wait for it to complete before moving forward.
Update the VM Scale Set with the New Image Version:
- Once the new image version is created, modify the scale set’s image reference to point to this new version.
- Use the beginUpdate method and wait until the update is completed.
Delete the Snapshot:
- Finally, delete the snapshot that was initially created for this process.

Here’s a high-level example code that uses the Azure SDK for JavaScript:

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

async function automateScaleSetUpdate(subscriptionId, resourceGroup, scaleSetName, diskId, imageDefinition) {
  const credential = new DefaultAzureCredential();
  const computeClient = new ComputeManagementClient(credential, subscriptionId);

  // Step 1: Snapshot VM Scale Set OS Disk
  const snapshotName = `${scaleSetName}-snapshot-${Date.now()}`;
  const snapshotParams = {
    location: "YOUR_LOCATION",
    creationData: {
      createOption: "Copy",
      sourceResourceId: diskId,
    },
  };
  
  console.log("Creating snapshot...");
  const snapshotPoller = await computeClient.snapshots.beginCreateOrUpdateAndWait(
    resourceGroup,
    snapshotName,
    snapshotParams
  );
  console.log("Snapshot created:", snapshotPoller);

  // Step 2: Add New Version to VM Image Definition
  const newVersion = `1.0.${Date.now()}`; // Generate version dynamically
  const imageVersionParams = {
    location: "YOUR_LOCATION",
    source: {
      id: snapshotPoller.id,
    },
  };

  console.log("Creating new VM image version...");
  const imageVersionPoller = await computeClient.virtualMachineImages.beginCreateOrUpdateAndWait(
    resourceGroup,
    imageDefinition,
    newVersion,
    imageVersionParams
  );
  console.log("New image version created:", imageVersionPoller);

  // Step 3: Update VM Scale Set to New Image Version
  const scaleSetParams = {
    virtualMachineProfile: {
      storageProfile: {
        imageReference: {
          id: imageVersionPoller.id,
        },
      },
    },
  };

  console.log("Updating VM scale set...");
  const scaleSetPoller = await computeClient.virtualMachineScaleSets.beginUpdateAndWait(
    resourceGroup,
    scaleSetName,
    scaleSetParams
  );
  console.log("VM scale set updated:", scaleSetPoller);

  // Step 4: Delete the Snapshot
  console.log("Deleting snapshot...");
  await computeClient.snapshots.beginDeleteAndWait(resourceGroup, snapshotName);
  console.log("Snapshot deleted.");
}

// Usage
const subscriptionId = "YOUR_SUBSCRIPTION_ID";
const resourceGroup = "YOUR_RESOURCE_GROUP_NAME";
const scaleSetName = "YOUR_SCALE_SET_NAME";
const diskId = "YOUR_DISK_ID";
const imageDefinition = "YOUR_IMAGE_DEFINITION_NAME";

automateScaleSetUpdate(subscriptionId, resourceGroup, scaleSetName, diskId, imageDefinition)
  .then(() => console.log("Automation complete"))
  .catch((error) => console.error("Error:", error));

Explanation

Snapshot Creation: The beginCreateOrUpdateAndWait method waits for the snapshot to complete.
Image Version Creation: This uses beginCreateOrUpdateAndWait to add the new version, using the snapshot ID.
Scale Set Update: Updates the scale set image to the new version by setting imageReference.
Snapshot Deletion: Finally, deletes the snapshot to clean up resources.

Requirements

Install the required Azure packages:

  npm install @azure/identity @azure/arm-compute

Replace placeholders such as YOUR_LOCATION, YOUR_SUBSCRIPTION_ID, and others with actual values from your Azure setup.

This script will ensure that each step waits for completion, preventing conflicts between resource updates.

ylwong

Yes, in Azure, you can automate these processes in a single Node.js script using the Azure SDK for JavaScript and REST APIs. Here’s an outline of how you can achieve this:

Prerequisites:

Azure SDK for JavaScript - You’ll need to install packages like @azure/arm-compute for managing virtual machines, snapshots, and images.
Authentication - You’ll need to authenticate with Azure. For service-to-service scenarios, use a Service Principal and the Azure Identity SDK to authenticate via @azure/identity.

Outline of the Script

Initialize Azure Client Instances: Start by initializing clients for ComputeManagementClient and DiskManagementClient.
Step 1: Snapshot the OS Disk
- Use the DiskManagementClient to create a snapshot of the OS disk by specifying the Disk ID.
- Monitor the operation to ensure it completes.
Step 2: Update the VM Image Definition
- Retrieve the existing VM image definition and determine the next version number.
- Create a new image version using the snapshot from Step 1.
- Monitor until the image creation is complete.
Step 3: Update VM Scale Set to Use the New Image Version
- Retrieve the VM Scale Set, update the imageReference to the new image version, and apply the update.
- Wait for the update to propagate.
Step 4: Remove the Snapshot
- Once the VM Scale Set update is complete, delete the snapshot created in Step 1 to clean up.

Sample Code

Here's a general structure in Node.js for these steps:

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

const subscriptionId = "YOUR_SUBSCRIPTION_ID";
const resourceGroupName = "YOUR_RESOURCE_GROUP_NAME";
const vmssName = "YOUR_VMSS_NAME";
const imageDefinitionName = "YOUR_IMAGE_DEFINITION_NAME";
const osDiskId = "OS_DISK_ID";

const credential = new DefaultAzureCredential();

const computeClient = new ComputeManagementClient(credential, subscriptionId);
const diskClient = new DiskManagementClient(credential, subscriptionId);

async function main() {
    // Step 1: Create Snapshot
    console.log("Creating snapshot...");
    const snapshotName = `snapshot-${Date.now()}`;
    const snapshot = await diskClient.snapshots.beginCreateOrUpdateAndWait(resourceGroupName, snapshotName, {
        location: "YOUR_LOCATION",
        creationData: { createOption: "Copy", sourceResourceId: osDiskId },
    });
    console.log("Snapshot created:", snapshot.id);

    // Step 2: Create New Image Version
    console.log("Creating new VM image version...");
    const newVersion = "1.0.0"; // Or calculate based on existing versions
    const imageVersion = await computeClient.galleryImageVersions.beginCreateOrUpdateAndWait(
        resourceGroupName,
        "YOUR_GALLERY_NAME",
        imageDefinitionName,
        newVersion,
        {
            location: "YOUR_LOCATION",
            publishingProfile: {
                source: {
                    id: snapshot.id,
                },
            },
        }
    );
    console.log("New image version created:", imageVersion.id);

    // Step 3: Update VM Scale Set with New Image Version
    console.log("Updating VM Scale Set with new image version...");
    const vmss = await computeClient.virtualMachineScaleSets.get(resourceGroupName, vmssName);
    vmss.virtualMachineProfile.storageProfile.imageReference.id = imageVersion.id;
    await computeClient.virtualMachineScaleSets.beginCreateOrUpdateAndWait(resourceGroupName, vmssName, vmss);
    console.log("VM Scale Set updated with new image version.");

    // Step 4: Delete Snapshot
    console.log("Deleting snapshot...");
    await diskClient.snapshots.beginDeleteAndWait(resourceGroupName, snapshotName);
    console.log("Snapshot deleted.");
}

main().catch((err) => {
    console.error("Error:", err);
});

Explanation of Key Steps

Snapshot Creation: Creates a snapshot using the OS disk ID and waits for the operation to complete.
Image Version Creation: Automatically generates or retrieves the next version number for the VM image and creates a new version using the snapshot.
VMSS Update: Updates the VMSS with the new image version by modifying the imageReference.
Snapshot Cleanup: Deletes the snapshot created initially to free up resources.

Notes

Error Handling: Implement additional error handling for production.
Next Version Calculation: You may want to check existing versions dynamically to increment the version number.

This script should effectively automate the entire workflow in a single execution.