Configuring Cluster Upgrades with Azure Maintenance Configurations

Question

Pulumi · Accepted Answer

In Azure, Maintenance Configurations are used to define the maintenance policies for resources like virtual machines, virtual machine scale sets, and Azure Kubernetes Service (AKS) clusters. These maintenance configurations specify when updates or maintenance should occur, allowing for greater control over the potential impacts on your applications and workloads.

In this guide, we will focus on creating a Maintenance Configuration for an AKS cluster using Pulumi and the Azure Native provider. We'll walk through the process of defining a new maintenance configuration and then assigning it to an AKS cluster.

First, we need to set up a Pulumi program in TypeScript. The program will consist of the following steps:

1. Import the necessary Pulumi and Azure Native SDK packages.
2. Define a new `MaintenanceConfiguration` resource, specifying the maintenance window and other properties.
3. Assign the maintenance configuration to an AKS cluster.

Here is a Pulumi TypeScript program that accomplishes these tasks:

```typescript
import * as azure_native from "@pulumi/azure-native";

// Create a new maintenance configuration for an AKS cluster
const maintenanceConfiguration = new azure_native.containerservice.MaintenanceConfiguration("myMaintenanceConfig", {
    // Replace these with the appropriate resource group and AKS cluster name
    resourceGroupName: "myResourceGroup",
    resourceName: "myAksCluster",
    configName: "myMaintenanceConfig", // This can be any name you choose for the configuration
    // A list of times when maintenance is allowed in a given week
    timeInWeek: [
        {
            day: "Friday", // Specify the day of the week, e.g., Monday, Tuesday, etc.
            hourSlots: [1, 2], // Specify the hours in a 24-hour format when maintenance is allowed
        },
    ],
    // Optional: Specify times when maintenance is not allowed
    notAllowedTime: [
        {
            start: "2024-12-24T00:00:00Z",  // Date and time when the not-allowed period starts (in UTC)
            end: "2024-12-25T23:59:59Z",    // Date and time when the not-allowed period ends (in UTC)
        },
    ],
});

// Export the ID of the maintenance configuration
export const maintenanceConfigurationId = maintenanceConfiguration.id;
```

In the above program:

- We import the `@pulumi/azure-native` package that contains the Azure Native Pulumi provider, which allows us to interact with Azure resources.
- We create a new `MaintenanceConfiguration` for an AKS cluster by instantiating `azure_native.containerservice.MaintenanceConfiguration` with the required properties.
- We define the allowed maintenance windows using `timeInWeek`, which is an array of objects that specify the day and the hourly slots when maintenance operations are permitted.
- Optionally, we can define periods when maintenance is not allowed using `notAllowedTime`, which is also an array of objects specifying the start and end times.
- Lastly, we export the maintenance configuration ID to retrieve it later if necessary.

To run this Pulumi program, save the code into a file `index.ts`, open the terminal at the location of your file, and execute the following commands:

```bash
pulumi up
```

Keep in mind that for this code to work, you must have the Azure Pulumi plugin installed, be logged into Azure, and have Pulumi properly configured.

For more details on Azure maintenance configurations, you can refer to the [Maintenance Configuration documentation](https://www.pulumi.com/registry/packages/azure-native/api-docs/containerservice/maintenanceconfiguration/).