Autoscaling based on Performance Metrics with Azure Insights

Question

Pulumi · Accepted Answer

To create an autoscaling setup based on performance metrics with Azure Insights, you need to do a few things:

1. Provision an Azure Application Insights instance that will collect the performance metrics of your application.
2. Deploy resources, such as Azure Virtual Machine Scale Sets (VMSS), that you want to autoscale.
3. Define autoscaling rules and attach them to the VMSS. These rules will specify how the VMSS should scale in response to the performance metrics gathered by Azure Insights.

Azure Application Insights is an extensible Application Performance Management (APM) service for web developers, helping you monitor your live applications. It will automatically detect performance anomalies and includes powerful analytics tools to help you diagnose issues and understand what users actually do with your app.

Azure Insights can monitor a variety of performance metrics, such as CPU usage, memory pressure, or custom metrics that your application emits. When a particular performance metric crosses a threshold that you've defined, Azure can automatically scale your resources up or down to match the current demand.

Now, let's write a Pulumi program to set up autoscaling for Azure Virtual Machine Scale Sets based on CPU utilization:

```python
import pulumi
from pulumi_azure_native import insights as azure_insights
from pulumi_azure_native import compute as azure_compute
from pulumi_azure_native import resources as azure_resources

# Create an Azure Resource Group
resource_group = azure_resources.ResourceGroup('rg')

# Create an Application Insights instance
app_insights = azure_insights.Component('appInsights',
    resource_group_name=resource_group.name,
    kind="web",
    application_type='web',
)

# Create a Virtual Machine Scale Set
scale_set = azure_compute.VirtualMachineScaleSet('vmss',
    resource_group_name=resource_group.name,
    sku=azure_compute.SkuArgs(
        capacity=2,
        name='Standard_DS1_v2',
        tier='Standard',
    ),
    # further configuration for networks, VM images, etc. goes here
)

# Define Autoscale Profile
profile = azure_insights.AutoscaleProfileArgs(
    name="autoscaleProfile",
    capacity=azure_insights.ScaleCapacityArgs(
        default="2",
        minimum="1",
        maximum="10",
    ),
    rules=[
        azure_insights.ScaleRuleArgs(
            metric_trigger=azure_insights.MetricTriggerArgs(
                metric_name="Percentage CPU",
                metric_resource_uri=scale_set.id,
                time_grain="PT1M",
                statistic="Average",
                time_window="PT5M",
                time_aggregation="Average",
                operator="GreaterThan",
                threshold=75,
            ),
            scale_action=azure_insights.ScaleActionArgs(
                direction="Increase",
                type="ChangeCount",
                value="1",
                cooldown="PT1M",
            ),
        ),
        # Additional rules could be added for scale-in or other metrics
    ],
)

# Create an Autoscale Setting
autoscale_setting = azure_insights.AutoscaleSetting('autoscaleSetting',
    resource_group_name=resource_group.name,
    target_resource_uri=scale_set.id,
    profiles=[profile],
    enabled=True,
)

# Export the App Insights instrumentation key
pulumi.export('instrumentation_key', app_insights.instrumentation_key)
```

In this code:

- We create a new resource group `rg` which will contain all of our resources.
- We then set up Azure Application Insights with the kind `web` suitable for web applications, and this resource is also placed into the same resource group.
- Next, we create a Virtual Machine Scale Set (VMSS) named `vmss` within our resource group.
- We define an autoscale profile `profile` with a scale capacity specifying the default, minimum, and maximum number of instances.
- We add a `ScaleRule` to the autoscale profile, which describes how to scale out. Specifically, we're scaling if the CPU percentage exceeds 75% over a 5-minute window.
- We apply these autoscaling settings with `AutoscaleSetting`, linking them to our VMSS and setting them as enabled.
- Finally, we export the instrumentation key for the Application Insights instance, which you can use within your application to send metrics to Application Insights.

Before applying this setup, ensure that you've configured Pulumi with Azure credentials and selected the appropriate Azure location. This Pulumi program is a starting point to autoscale your resources based on performance metrics that Application Insights will collect. You can customize the scale rules and profiles according to your specific use case and performance indicators.