Predictive Metric - Get

Servizio:

Monitor

Versione API:

2022-10-01

ottenere i dati futuri della metrica di scalabilità automatica predittiva

GET https://management.azure.com/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Insights/autoscalesettings/{autoscaleSettingName}/predictiveMetrics?timespan={timespan}&interval={interval}&metricNamespace={metricNamespace}&metricName={metricName}&aggregation={aggregation}&api-version=2022-10-01

Parametri dell'URI

Nome	In	Necessario	Tipo	Descrizione
autoscaleSettingName	path	True	string	Nome dell'impostazione di scalabilità automatica.
resourceGroupName	path	True	string	Nome del gruppo di risorse. Per il nome non viene fatta distinzione tra maiuscole e minuscole.
subscriptionId	path	True	string	ID della sottoscrizione di destinazione.
aggregation	query	True	string	Elenco di tipi di aggregazione (delimitati da virgole) da recuperare.
api-version	query	True	string	Versione dell'API da usare per questa operazione.
interval	query	True	string duration	Intervallo (ad esempio timegrain) della query.
metricName	query	True	string	Nomi delle metriche (delimitate da virgole) da recuperare. Caso speciale: se un nome metrica stesso ha una virgola in esso, usare %2 per indicare. Ad esempio: 'Metric,Name1' deve essere 'Metric%2Name1'
metricNamespace	query	True	string	Spazio dei nomi delle metriche per cui eseguire query sulle definizioni delle metriche.
timespan	query	True	string	Intervallo di tempo della query. È una stringa con il formato seguente 'startDateTime_ISO/endDateTime_ISO'.

Risposte

Nome	Tipo	Descrizione
200 OK	PredictiveResponse	Richiesta riuscita per ottenere l'elenco dei valori delle metriche.
Other Status Codes	AutoscaleErrorResponse	Risposta di errore che descrive perché l'operazione non è riuscita.

Sicurezza

azure_auth

Flusso OAuth2 di Azure Active Directory

Tipo: oauth2
Flow: implicit
URL di autorizzazione: https://login.microsoftonline.com/common/oauth2/authorize

Ambiti

Nome	Descrizione
user_impersonation	rappresentare l'account utente

Esempio

Get Metric for data

Esempio di richiesta

HTTP

GET https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/myRG/providers/Microsoft.Insights/autoscalesettings/vmss1-Autoscale-775/predictiveMetrics?timespan=2021-10-14T22:00:00.000Z/2021-10-16T22:00:00.000Z&interval=PT1H&metricNamespace=Microsoft.Compute/virtualMachineScaleSets&metricName=PercentageCPU&aggregation=Total&api-version=2022-10-01

Java

import java.time.Duration;

/**
 * Samples for PredictiveMetric Get.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/monitor/resource-manager/Microsoft.Insights/stable/2022-10-01/examples/GetPredictiveMetric.json
     */
    /**
     * Sample code: Get Metric for data.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void getMetricForData(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.diagnosticSettings().manager().serviceClient().getPredictiveMetrics().getWithResponse("myRG",
            "vmss1-Autoscale-775", "2021-10-14T22:00:00.000Z/2021-10-16T22:00:00.000Z", Duration.parse("PT1H"),
            "Microsoft.Compute/virtualMachineScaleSets", "PercentageCPU", "Total", com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Python

import isodate

from azure.identity import DefaultAzureCredential

from azure.mgmt.monitor import MonitorManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-monitor
# USAGE
    python get_predictive_metric.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = MonitorManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="00000000-0000-0000-0000-000000000000",
    )

    response = client.predictive_metric.get(
        resource_group_name="myRG",
        autoscale_setting_name="vmss1-Autoscale-775",
        timespan="2021-10-14T22:00:00.000Z/2021-10-16T22:00:00.000Z",
        interval=isodate.parse_duration("PT1H"),
        metric_namespace="Microsoft.Compute/virtualMachineScaleSets",
        metric_name="PercentageCPU",
        aggregation="Total",
    )
    print(response)


# x-ms-original-file: specification/monitor/resource-manager/Microsoft.Insights/stable/2022-10-01/examples/GetPredictiveMetric.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Go

package armmonitor_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/monitor/armmonitor"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/969fd0c2634fbcc1975d7abe3749330a5145a97c/specification/monitor/resource-manager/Microsoft.Insights/stable/2022-10-01/examples/GetPredictiveMetric.json
func ExamplePredictiveMetricClient_Get() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmonitor.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPredictiveMetricClient().Get(ctx, "myRG", "vmss1-Autoscale-775", "2021-10-14T22:00:00.000Z/2021-10-16T22:00:00.000Z", "PT1H", "Microsoft.Compute/virtualMachineScaleSets", "PercentageCPU", "Total", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.PredictiveResponse = armmonitor.PredictiveResponse{
	// 	Data: []*armmonitor.PredictiveValue{
	// 		{
	// 			TimeStamp: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-10-14T22:00:00.000Z"); return t}()),
	// 			Value: to.Ptr[float64](123),
	// 		},
	// 		{
	// 			TimeStamp: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-10-14T22:02:00.000Z"); return t}()),
	// 			Value: to.Ptr[float64](120),
	// 		},
	// 		{
	// 			TimeStamp: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-10-14T22:02:00.000Z"); return t}()),
	// 			Value: to.Ptr[float64](88),
	// 		},
	// 		{
	// 			TimeStamp: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-10-14T22:03:00.000Z"); return t}()),
	// 			Value: to.Ptr[float64](100),
	// 	}},
	// 	Interval: to.Ptr("PT1H"),
	// 	MetricName: to.Ptr("PercentageCPU"),
	// 	TargetResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myRG/providers/Microsoft.Compute/virtualMachineScaleSets/vmss1"),
	// 	Timespan: to.Ptr("2021-10-14T22:00:00.000Z/2021-10-16T22:00:00.000Z"),
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { MonitorClient } = require("@azure/arm-monitor");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to get predictive autoscale metric future data
 *
 * @summary get predictive autoscale metric future data
 * x-ms-original-file: specification/monitor/resource-manager/Microsoft.Insights/stable/2022-10-01/examples/GetPredictiveMetric.json
 */
async function getMetricForData() {
  const subscriptionId =
    process.env["MONITOR_SUBSCRIPTION_ID"] || "00000000-0000-0000-0000-000000000000";
  const resourceGroupName = process.env["MONITOR_RESOURCE_GROUP"] || "myRG";
  const autoscaleSettingName = "vmss1-Autoscale-775";
  const timespan = "2021-10-14T22:00:00.000Z/2021-10-16T22:00:00.000Z";
  const interval = "PT1H";
  const metricNamespace = "Microsoft.Compute/virtualMachineScaleSets";
  const metricName = "PercentageCPU";
  const aggregation = "Total";
  const credential = new DefaultAzureCredential();
  const client = new MonitorClient(credential, subscriptionId);
  const result = await client.predictiveMetric.get(
    resourceGroupName,
    autoscaleSettingName,
    timespan,
    interval,
    metricNamespace,
    metricName,
    aggregation,
  );
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

dotnet

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Monitor.Models;
using Azure.ResourceManager.Monitor;

// Generated from example definition: specification/monitor/resource-manager/Microsoft.Insights/stable/2022-10-01/examples/GetPredictiveMetric.json
// this example is just showing the usage of "PredictiveMetric_Get" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this AutoscaleSettingResource created on azure
// for more information of creating AutoscaleSettingResource, please refer to the document of AutoscaleSettingResource
string subscriptionId = "00000000-0000-0000-0000-000000000000";
string resourceGroupName = "myRG";
string autoscaleSettingName = "vmss1-Autoscale-775";
ResourceIdentifier autoscaleSettingResourceId = AutoscaleSettingResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, autoscaleSettingName);
AutoscaleSettingResource autoscaleSetting = client.GetAutoscaleSettingResource(autoscaleSettingResourceId);

// invoke the operation
string timespan = "2021-10-14T22:00:00.000Z/2021-10-16T22:00:00.000Z";
TimeSpan interval = XmlConvert.ToTimeSpan("PT1H");
string metricNamespace = "Microsoft.Compute/virtualMachineScaleSets";
string metricName = "PercentageCPU";
string aggregation = "Total";
AutoscaleSettingPredicativeResult result = await autoscaleSetting.GetPredictiveMetricAsync(timespan, interval, metricNamespace, metricName, aggregation);

Console.WriteLine($"Succeeded: {result}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Risposta di esempio

Codice di stato:

200

{
  "timespan": "2021-10-14T22:00:00.000Z/2021-10-16T22:00:00.000Z",
  "interval": "PT1H",
  "metricName": "PercentageCPU",
  "targetResourceId": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myRG/providers/Microsoft.Compute/virtualMachineScaleSets/vmss1",
  "data": [
    {
      "timeStamp": "2021-10-14T22:00:00Z",
      "value": 123
    },
    {
      "timeStamp": "2021-10-14T22:02:00Z",
      "value": 120
    },
    {
      "timeStamp": "2021-10-14T22:02:00Z",
      "value": 88
    },
    {
      "timeStamp": "2021-10-14T22:03:00Z",
      "value": 100
    }
  ]
}

Definizioni

Nome	Descrizione
AutoscaleErrorResponse	Descrive il formato della risposta all'errore.
createdByType	Tipo di identità che ha creato la risorsa.
Error	Oggetto error.
PredictiveResponse	Risposta a una query sulle metriche.
PredictiveValue	Rappresenta un valore di metrica predittiva nel bucket specificato.
systemData	Metadati relativi alla creazione e all'ultima modifica della risorsa.

AutoscaleErrorResponse

Descrive il formato della risposta all'errore.

Nome	Tipo	Descrizione
error	Error	Oggetto error.
systemData	systemData	Metadati di sistema correlati alla risposta.

createdByType

Tipo di identità che ha creato la risorsa.

Nome	Tipo	Descrizione
Application	string
Key	string
ManagedIdentity	string
User	string

Error

Oggetto error.

Nome	Tipo	Descrizione
code	string	Uno di un set definito dal server di codici di errore.
details	string	Rappresentazione leggibile dei dettagli dell'errore.
message	string	Rappresentazione leggibile dell'errore.
target	string	Destinazione dell'errore specifico.

PredictiveResponse

Risposta a una query sulle metriche.

Nome	Tipo	Descrizione
data	PredictiveValue[]	valore della raccolta.
interval	string	Intervallo (dimensione finestra) in cui sono stati restituiti i dati delle metriche. Questo può essere modificato in futuro e restituito da ciò che è stato originariamente richiesto. Questa operazione non è presente se è stata effettuata una richiesta di metadati.
metricName	string	Query sulle metriche
targetResourceId	string	risorsa della metrica predittiva.
timespan	string	Intervallo di tempo per il quale sono stati recuperati i dati. Il valore è costituito da due datetime concatenate, separate da '/'. Questo può essere modificato in futuro e restituito da ciò che è stato originariamente richiesto.

PredictiveValue

Rappresenta un valore di metrica predittiva nel bucket specificato.

Nome	Tipo	Descrizione
timeStamp	string	timestamp per il valore della metrica nel formato ISO 8601.
value	number	Valore predittivo in questo bucket di tempo.

systemData

Metadati relativi alla creazione e all'ultima modifica della risorsa.

Nome	Tipo	Descrizione
createdAt	string	Timestamp della creazione di risorse (UTC).
createdBy	string	Identità che ha creato la risorsa.
createdByType	createdByType	Tipo di identità che ha creato la risorsa.
lastModifiedAt	string	Timestamp dell'ultima modifica della risorsa (UTC)
lastModifiedBy	string	Identità che ha modificato l'ultima risorsa.
lastModifiedByType	createdByType	Tipo di identità che ha modificato l'ultima risorsa.