Using azure monitoring with mariadb

Question

Pulumi · Accepted Answer

If you want to set up Azure Monitoring with MariaDB on Azure, you'll typically involve creating an instance of Azure Database for MariaDB, enabling diagnostics settings to collect logs and metrics, and then configuring Azure Monitor to analyze and alert based on those logs and metrics. Here's a walkthrough and a corresponding Pulumi program written in TypeScript that sets up Azure Database for MariaDB and configures monitoring.

### Detailed Explanation

1. **Azure Database for MariaDB**: This is a managed service that provides MariaDB databases without the overhead of managing the infrastructure. It's a scalable service that supports high availability.

2. **Diagnostic Settings**: In Azure, diagnostic settings are used to define what logs and metrics are collected for a resource. For MariaDB, you can enable diagnostics to capture queries, errors, connections, etc.

3. **Azure Monitor**: This is a comprehensive solution for collecting, analyzing, and acting on telemetry from your cloud and on-premises environments. Azure Monitor can use the data collected through diagnostic settings for insights, alerts, and more.

4. **Log Analytics Workspace**: This service collects and aggregates data from a variety of sources. You will need one to query and visualize the logs from MariaDB.

5. **Alerts and Action Groups**: They can be configured to notify or automate responses when certain conditions are met, based on the metrics or logs.

### Pulumi Program

Below is a TypeScript program for use with Pulumi that sets up Azure Database for MariaDB and configures basic monitoring through Azure Monitor. In this example, we will create a database, then a diagnostic setting for that database to send its logs to a Log Analytics Workspace, and finally set up an alert rule to notify us when certain conditions are met.

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

// Create an Azure Resource Group
const resourceGroup = new azure.core.ResourceGroup("my-resource-group");

// Create an Azure Database for MariaDB server
const mariadbServer = new azure.dbformariadb.Server("my-mariadb-server", {
    resourceGroupName: resourceGroup.name,
    skuName: "B_Gen5_2",
    storageMb: 5120,
    adminLogin: "adminuser",
    adminPassword: "AdminPassword123!",
    version: "10.2",
});

// Create a MariaDB database on the server
const database = new azure.dbformariadb.Database("my-database", {
    resourceGroupName: resourceGroup.name,
    serverName: mariadbServer.name,
    charset: "utf8",
    collation: "utf8_unicode_ci",
});

// Create a Log Analytics Workspace
const analyticsWorkspace = new azure.operationalinsights.AnalyticsWorkspace("my-analytics-workspace", {
    resourceGroupName: resourceGroup.name,
    sku: "PerGB2018",
});

// Enable diagnostics settings for MariaDB to send logs to the Log Analytics Workspace
const mariadbDiagnostics = new azure.monitoring.DiagnosticSetting("my-mariadb-diagnostics", {
    logAnalyticsWorkspaceId: analyticsWorkspace.id,
    targetResourceId: mariadbServer.id,
    logs: [{
        category: "MyCategory",
        enabled: true,
        retentionPolicy: {
            days: 0,
            enabled: false,
        },
    }],
    metrics: [{
        category: "AllMetrics",
        retentionPolicy: {
            days: 0,
            enabled: false,
        },
    }],
});

// Alert rule for CPU usage
const cpuAlertRule = new azure.monitoring.MetricAlertRule("my-cpu-alert-rule", {
    resourceGroupName: resourceGroup.name,
    scopes: [mariadbServer.id],
    criteria: [{
        metricName: "cpu_percent",
        operator: "GreaterThan",
        threshold: 90,
        aggregation: "Average",
        windowSize: "PT5M"
    }],
    actions: [{
        // Configure this with the details of the action group you wish to invoke
        actionGroupId: "your-action-group-id",
    }],
});

// Export the connection string for the MariaDB database
export const connectionString = pulumi.all([mariadbServer.name, database.name]).apply(([server, db]) => 
    `Server=${server}.mariadb.database.azure.com;Database=${db};Uid=adminuser@${server};Pwd=AdminPassword123!;`);

// Outputs
export const databaseName = database.name;
export const analyticsWorkspaceId = analyticsWorkspace.id;
```

In this program:

- We create a new instance of a MariaDB server and a database.
- A Log Analytics Workspace is set up to collect and store logs.
- Then we set up diagnostics settings to forward logs and metrics from the MariaDB server to this workspace.
- We also set up an alert rule that will trigger if the CPU usage goes over 90%, indicating high load.

Please replace placeholders like `your-action-group-id` with actual values that you intend to use in your setup. Also, ensure that the admin password is secure and managed appropriately, possibly using Azure Key Vault or another secrets management solution.

Make sure to install necessary Pulumi packages using NPM or Yarn before running this program:
```sh
npm install @pulumi/pulumi @pulumi/azure
```

This program should be placed in a Pulumi project and can be deployed using the Pulumi CLI. After setting up your Pulumi and Azure credentials, you can deploy these resources with the following commands:

```sh
pulumi up         # Preview and deploy changes
pulumi stack      # Manage stack outputs
pulumi destroy    # Tear down created resources
```

Each resource in the program is an abstraction provided by Pulumi that maps to corresponding Azure resources. Once deployed, it will create the infrastructure described in code, and you can observe its behavior and manipulate it further directly via code.