如何从Google Cloud Monitoring API获取GCE实例的机器类型信息？

Absolutely! You can pull in machine type, vCPU count, and other instance properties alongside your CPU usage metrics—you just need to adjust your approach a bit. Here are two reliable ways to do this with Node.js:

Option 1: Fetch Machine Details Directly from Cloud Monitoring API #

The Cloud Monitoring API can return additional resource labels (including machine type) if you tweak your request's view parameter. Machine type is a built-in resource label for GCE instances, and you can parse vCPU count from the machine type string (since GCE's standard naming convention includes core counts, e.g., n1-standard-4 = 4 vCPUs).

Here's how to modify your existing Monitoring API call:

const monitoring = require('@google-cloud/monitoring');
const client = new monitoring.MetricServiceClient();

async function getMetricsWithMachineInfo() {
  const request = {
    name: 'projects/your-project-id',
    filter: 'metric.type = "compute.googleapis.com/instance/cpu/usage_time" AND resource.type = "gce_instance"',
    interval: {
      startTime: { seconds: Date.now() / 1000 - 3600 }, // Last hour of data
      endTime: { seconds: Date.now() / 1000 }
    },
    view: 'FULL' // Critical: Returns all resource labels, including machine_type
  };

  const [timeSeries] = await client.listTimeSeries(request);
  
  timeSeries.forEach(series => {
    const instanceName = series.resource.labels.instance_name;
    const machineType = series.resource.labels.machine_type;
    const vCpuCount = parseVcpuFromMachineType(machineType);

    console.log(`Instance: ${instanceName}`);
    console.log(`Machine Type: ${machineType}`);
    console.log(`vCPUs: ${vCpuCount}`);
    // Access your CPU usage points from series.points here
  });
}

// Helper to extract vCPU count from machine type string
function parseVcpuFromMachineType(machineType) {
  const coreMatch = machineType.match(/-\d+$/);
  return coreMatch ? parseInt(coreMatch[0].slice(1)) : null;
}

getMetricsWithMachineInfo();

Notes: #

• The view: 'FULL' flag ensures all resource labels are included in the response, not just the ones required for filtering.
• This method is efficient because it only requires one API call, but parsing vCPU count relies on GCE's naming convention (which works for standard machine types, but might fail for custom types).

Option 2: Get Precise Instance Details via Compute Engine API #

For 100% accurate vCPU counts (especially for custom machine types) and additional instance properties, pair your Monitoring API call with a request to the Compute Engine API. This gives you direct access to fields like guestCpus (exact vCPU count) and full machine type info.

First, install the Compute Engine client library if you haven't already:

npm install @google-cloud/compute

Then use this code to fetch instance details alongside your metrics:

const monitoring = require('@google-cloud/monitoring');
const compute = require('@google-cloud/compute');

const monitoringClient = new monitoring.MetricServiceClient();
const computeClient = new compute.InstancesClient();

async function getMetricsWithFullInstanceDetails() {
  // First, fetch CPU metrics as before
  const metricRequest = {
    name: 'projects/your-project-id',
    filter: 'metric.type = "compute.googleapis.com/instance/cpu/usage_time" AND resource.type = "gce_instance"',
    interval: {
      startTime: { seconds: Date.now() / 1000 - 3600 },
      endTime: { seconds: Date.now() / 1000 }
    }
  };

  const [timeSeries] = await monitoringClient.listTimeSeries(metricRequest);

  // For each time series, fetch corresponding instance details
  for (const series of timeSeries) {
    const { instance_id, zone, project_id } = series.resource.labels;
    
    const instanceRequest = {
      instance: instance_id,
      zone: zone,
      project: project_id
    };

    const [instance] = await computeClient.get(instanceRequest);
    const machineType = instance.machineType.split('/').pop(); // Extracts the machine type name from the full URL
    const vCpuCount = instance.guestCpus;

    console.log(`Instance: ${series.resource.labels.instance_name}`);
    console.log(`Machine Type: ${machineType}`);
    console.log(`Exact vCPUs: ${vCpuCount}`);
    // Access CPU usage points from series.points here
  }
}

getMetricsWithFullInstanceDetails();

Notes: #

• This method requires additional API calls (one per instance), but gives you precise, unparsed vCPU counts and access to other instance properties like cpuPlatform, diskSizeGb, etc.
• Make sure your service account has permissions for both monitoring.timeSeries.list and compute.instances.get.

内容的提问来源于stack exchange，提问作者Jamgreen