Configuring HTTP probes for Azure Load Balancer health checks

HTTP probes are crucial for Azure Load Balancer as they determine the health of backend instances. They perform health checks by sending HTTP requests to the backend instances at a specified interval. If the instances don't respond correctly within a specified number of probes, the load balancer will stop sending traffic to the unhealthy instances.

In Pulumi, you would use the azure-native.network.LoadBalancer resource to create an Azure Load Balancer with HTTP health probes. Below I'll show you how to configure this resource to include HTTP probes for health checks.

First, let's define the health probe. This involves setting properties such as:

• name: The name of the health probe.
• protocol: The protocol to use for the health probe (for HTTP probes, this will be "Http").
• port: The port to send health probes to.
• requestPath: The path to use for health check requests (e.g., "/health" if your instances will respond to this path with a 200 OK status when healthy).
• intervalInSeconds: How often to send health probes, in seconds.
• numberOfProbes: The number of probes to use before deciding that a backend instance is not healthy.

Next, you will configure the Load Balancer itself. You will create a new LoadBalancer resource and attach the health probe configuration under the probes property.

Here is a TypeScript program implementing this configuration:

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

const resourceGroupName = "my-resources";
const location = "West US";

// Create an Azure Resource Group
const resourceGroup = new azure_native.resources.ResourceGroup("resourceGroup", {
    resourceGroupName: resourceGroupName,
    location: location,
});

// Create a new Load Balancer with an HTTP health probe
const loadBalancer = new azure_native.network.LoadBalancer("loadBalancer", {
    resourceGroupName: resourceGroupName,
    location: location,
    sku: {
        name: "Standard",  // SKU should be Standard for HTTP probes
    },
    // Define the health probe properties
    probes: [{
        protocol: "Http",
        port: 80,
        requestPath: "/health",
        intervalInSeconds: 15,
        numberOfProbes: 2,
        name: "httpProbe",  // Name your health probe
    }],
    // Add other necessary properties like frontendIPConfigurations, backendAddressPools, etc
    frontendIPConfigurations: [
        /* Configuration for the public IP or private IP */
    ],
    backendAddressPools: [
        /* Backend pool configurations */
    ],
}, { dependsOn: [resourceGroup] }); // Ensure the Load Balancer is created after the Resource Group

export const loadBalancerId = loadBalancer.id; // Export the Load Balancer ID

In this program:

• We import the necessary modules from Pulumi's Azure Native package.
• We set up an Azure Resource Group where our resources will live.
• We initialize a new Load Balancer within the resource group, specifying its SKU and location.
• We attach an HTTP health probe to the Load Balancer with the desired configuration (interval, number of probes, request path, port, and protocol).
• We add placeholders for other necessary configurations such as frontendIPConfigurations and backendAddressPools.
• Finally, we export the ID of the Load Balancer for reference.

Please note that in an actual implementation you would need to fill out the frontendIPConfigurations and backendAddressPools with proper values as per your architecture needs.

To apply this program, save it to a file (such as index.ts), ensure you are authenticated with Azure, and have Pulumi CLI installed. Then, you can run pulumi up, which will perform the deployment to Azure.

Be sure to read the Pulumi documentation for the azure-native.network.LoadBalancer to understand all of the properties that may be necessary for your specific setup.