Deleting obsolete MetricDescriptors for clean-up and maintenance

Question

Pulumi · Accepted Answer

To delete obsolete MetricDescriptors, you typically need to interact with the monitoring service of the cloud provider where your metrics are stored. For example, if you're using Google Cloud Monitoring (formerly known as Stackdriver), you would use the MetricServiceClient from the @google-cloud/monitoring library to list and delete metric descriptors.

In a Pulumi program, you would not directly delete resources like MetricDescriptors; instead, you manage infrastructure resources such as compute instances, databases, etc. However, Pulumi does allow you to run dynamic providers or external programs through automation API to manage such items if that's within the scope of your infrastructure management.

For the purpose of learning, I'll guide you through how you could approach this using a Pulumi dynamic provider in TypeScript, which is essentially a way to create custom resources not directly supported by Pulumi's existing providers.

Here's a simplified version of how such a program might look. In a real-world scenario, you would need to handle authentication, error checking, and probably pagination of the results too.

import * as pulumi from '@pulumi/pulumi';
import * as gcp from '@pulumi/gcp';
import { MetricServiceClient } from '@google-cloud/monitoring';

class CustomMetricDescriptorResource extends pulumi.dynamic.Resource {
  constructor(name: string, args: MetricDescriptorResourceArgs, opts?: pulumi.CustomResourceOptions) {
    super(new CustomMetricDescriptorProvider(), name, args, opts);
  }
}

interface MetricDescriptorResourceArgs {
  project: pulumi.Input<string>;
  // Here you might define other inputs necessary for identifying which MetricDescriptors to delete
}

class CustomMetricDescriptorProvider implements pulumi.dynamic.ResourceProvider {
  public async create(inputs: MetricDescriptorResourceArgs): Promise<pulumi.dynamic.CreateResult> {
    const client = new MetricServiceClient();

    // List all MetricDescriptors for the provided project
    const [descriptors] = await client.listMetricDescriptors({
      name: `projects/${inputs.project}`,
    });

    // Filter descriptors to define what you consider as obsolete
    const obsoleteDescriptors = descriptors.filter(descriptor => /* your logic here */);

    // Delete the obsolete MetricDescriptors
    for (const descriptor of obsoleteDescriptors) {
      await client.deleteMetricDescriptor({ name: descriptor.name });
    }

    return { id: `projects/${inputs.project}/metricDescriptors`, outs: {} };
  }

  // We only implement `create` as we are focusing on deleting resources.
}

// Usage of the CustomMetricDescriptorResource
const project = gcp.config.project;

// Creating the custom resource to delete MetricDescriptors
const obsoleteMetricsCleanup = new CustomMetricDescriptorResource('obsolete-metrics-cleanup', {
  project: project,
});

Before running this code, ensure you have the Google Cloud SDK installed and that you're authenticated with a user or service account with sufficient permissions to delete metric descriptors.

In this program:

We define a custom resource class CustomMetricDescriptorResource, which is what you can use in your Pulumi program to represent a set of MetricDescriptors you want to delete.
MetricDescriptorResourceArgs is the interface for our custom resource's arguments. For now, it only contains the project ID.
CustomMetricDescriptorProvider is a dynamic provider that implements the logic for deleting metric descriptors. The create method is where it lists and deletes obsolete MetricDescriptors.
Finally, we create an instance of our custom resource, obsoleteMetricsCleanup, which will delete the obsolete MetricDescriptors when applied.

Keep in mind that this is a custom approach and would need to be fully developed and tested before using it in a production scenario. Additionally, managing custom deletions with Pulumi should be done cautiously, as the declarative approach of Pulumi is generally not aimed at imperative operational scripting like direct deletes outside of the resource lifecycle.