Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Grafana Cloud
  3. API Docs
  4. MachineLearningJob
Grafana v0.16.1 published on Saturday, Mar 15, 2025 by pulumiverse
pulumiverse/pulumi-grafana

grafana.MachineLearningJob

Explore with Pulumi AI

grafana logo
Grafana v0.16.1 published on Saturday, Mar 15, 2025 by pulumiverse
pulumiverse/pulumi-grafana
    Deprecated: grafana.index/machinelearningjob.MachineLearningJob has been deprecated in favor of grafana.machinelearning/job.Job

    A job defines the queries and model parameters for a machine learning task.

    See the Grafana Cloud docs for more information on available hyperparameters for use in the hyper_params field.

    Example Usage

    Basic Forecast

    This forecast uses a Prometheus datasource, where the source query is defined in the expr field of the query_params attribute.

    Other datasources are supported, but the structure query_params may differ.

    import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@pulumiverse/grafana";

const foo = new grafana.oss.DataSource("foo", {
    type: "prometheus",
    name: "prometheus-ds-test",
    uid: "prometheus-ds-test-uid",
    url: "https://my-instance.com",
    basicAuthEnabled: true,
    basicAuthUsername: "username",
    jsonDataEncoded: JSON.stringify({
        httpMethod: "POST",
        prometheusType: "Mimir",
        prometheusVersion: "2.4.0",
    }),
    secureJsonDataEncoded: JSON.stringify({
        basicAuthPassword: "password",
    }),
});
const testJob = new grafana.machinelearning.Job("test_job", {
    name: "Test Job",
    metric: "tf_test_job",
    datasourceType: "prometheus",
    datasourceUid: foo.uid,
    queryParams: {
        expr: "grafanacloud_grafana_instance_active_user_count",
    },
});

    import pulumi
import json
import pulumiverse_grafana as grafana

foo = grafana.oss.DataSource("foo",
    type="prometheus",
    name="prometheus-ds-test",
    uid="prometheus-ds-test-uid",
    url="https://my-instance.com",
    basic_auth_enabled=True,
    basic_auth_username="username",
    json_data_encoded=json.dumps({
        "httpMethod": "POST",
        "prometheusType": "Mimir",
        "prometheusVersion": "2.4.0",
    }),
    secure_json_data_encoded=json.dumps({
        "basicAuthPassword": "password",
    }))
test_job = grafana.machine_learning.Job("test_job",
    name="Test Job",
    metric="tf_test_job",
    datasource_type="prometheus",
    datasource_uid=foo.uid,
    query_params={
        "expr": "grafanacloud_grafana_instance_active_user_count",
    })

    package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/machinelearning"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/oss"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"httpMethod":        "POST",
			"prometheusType":    "Mimir",
			"prometheusVersion": "2.4.0",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"basicAuthPassword": "password",
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		foo, err := oss.NewDataSource(ctx, "foo", &oss.DataSourceArgs{
			Type:                  pulumi.String("prometheus"),
			Name:                  pulumi.String("prometheus-ds-test"),
			Uid:                   pulumi.String("prometheus-ds-test-uid"),
			Url:                   pulumi.String("https://my-instance.com"),
			BasicAuthEnabled:      pulumi.Bool(true),
			BasicAuthUsername:     pulumi.String("username"),
			JsonDataEncoded:       pulumi.String(json0),
			SecureJsonDataEncoded: pulumi.String(json1),
		})
		if err != nil {
			return err
		}
		_, err = machinelearning.NewJob(ctx, "test_job", &machinelearning.JobArgs{
			Name:           pulumi.String("Test Job"),
			Metric:         pulumi.String("tf_test_job"),
			DatasourceType: pulumi.String("prometheus"),
			DatasourceUid:  foo.Uid,
			QueryParams: pulumi.StringMap{
				"expr": pulumi.String("grafanacloud_grafana_instance_active_user_count"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Grafana = Pulumiverse.Grafana;

return await Deployment.RunAsync(() => 
{
    var foo = new Grafana.Oss.DataSource("foo", new()
    {
        Type = "prometheus",
        Name = "prometheus-ds-test",
        Uid = "prometheus-ds-test-uid",
        Url = "https://my-instance.com",
        BasicAuthEnabled = true,
        BasicAuthUsername = "username",
        JsonDataEncoded = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["httpMethod"] = "POST",
            ["prometheusType"] = "Mimir",
            ["prometheusVersion"] = "2.4.0",
        }),
        SecureJsonDataEncoded = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["basicAuthPassword"] = "password",
        }),
    });

    var testJob = new Grafana.MachineLearning.Job("test_job", new()
    {
        Name = "Test Job",
        Metric = "tf_test_job",
        DatasourceType = "prometheus",
        DatasourceUid = foo.Uid,
        QueryParams = 
        {
            { "expr", "grafanacloud_grafana_instance_active_user_count" },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.oss.DataSource;
import com.pulumi.grafana.oss.DataSourceArgs;
import com.pulumi.grafana.machineLearning.Job;
import com.pulumi.grafana.machineLearning.JobArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var foo = new DataSource("foo", DataSourceArgs.builder()
            .type("prometheus")
            .name("prometheus-ds-test")
            .uid("prometheus-ds-test-uid")
            .url("https://my-instance.com")
            .basicAuthEnabled(true)
            .basicAuthUsername("username")
            .jsonDataEncoded(serializeJson(
                jsonObject(
                    jsonProperty("httpMethod", "POST"),
                    jsonProperty("prometheusType", "Mimir"),
                    jsonProperty("prometheusVersion", "2.4.0")
                )))
            .secureJsonDataEncoded(serializeJson(
                jsonObject(
                    jsonProperty("basicAuthPassword", "password")
                )))
            .build());

        var testJob = new Job("testJob", JobArgs.builder()
            .name("Test Job")
            .metric("tf_test_job")
            .datasourceType("prometheus")
            .datasourceUid(foo.uid())
            .queryParams(Map.of("expr", "grafanacloud_grafana_instance_active_user_count"))
            .build());

    }
}

    resources:
  foo:
    type: grafana:oss:DataSource
    properties:
      type: prometheus
      name: prometheus-ds-test
      uid: prometheus-ds-test-uid
      url: https://my-instance.com
      basicAuthEnabled: true
      basicAuthUsername: username
      jsonDataEncoded:
        fn::toJSON:
          httpMethod: POST
          prometheusType: Mimir
          prometheusVersion: 2.4.0
      secureJsonDataEncoded:
        fn::toJSON:
          basicAuthPassword: password
  testJob:
    type: grafana:machineLearning:Job
    name: test_job
    properties:
      name: Test Job
      metric: tf_test_job
      datasourceType: prometheus
      datasourceUid: ${foo.uid}
      queryParams:
        expr: grafanacloud_grafana_instance_active_user_count

    Tuned Forecast

    This forecast has tuned hyperparameters to improve the accuracy of the model.

    import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@pulumiverse/grafana";

const foo = new grafana.oss.DataSource("foo", {
    type: "prometheus",
    name: "prometheus-ds-test",
    uid: "prometheus-ds-test-uid",
    url: "https://my-instance.com",
    basicAuthEnabled: true,
    basicAuthUsername: "username",
    jsonDataEncoded: JSON.stringify({
        httpMethod: "POST",
        prometheusType: "Mimir",
        prometheusVersion: "2.4.0",
    }),
    secureJsonDataEncoded: JSON.stringify({
        basicAuthPassword: "password",
    }),
});
const testJob = new grafana.machinelearning.Job("test_job", {
    name: "Test Job",
    metric: "tf_test_job",
    datasourceType: "prometheus",
    datasourceUid: foo.uid,
    queryParams: {
        expr: "grafanacloud_grafana_instance_active_user_count",
    },
    hyperParams: {
        daily_seasonality: "15",
        weekly_seasonality: "10",
    },
    customLabels: {
        example_label: "example_value",
    },
});

    import pulumi
import json
import pulumiverse_grafana as grafana

foo = grafana.oss.DataSource("foo",
    type="prometheus",
    name="prometheus-ds-test",
    uid="prometheus-ds-test-uid",
    url="https://my-instance.com",
    basic_auth_enabled=True,
    basic_auth_username="username",
    json_data_encoded=json.dumps({
        "httpMethod": "POST",
        "prometheusType": "Mimir",
        "prometheusVersion": "2.4.0",
    }),
    secure_json_data_encoded=json.dumps({
        "basicAuthPassword": "password",
    }))
test_job = grafana.machine_learning.Job("test_job",
    name="Test Job",
    metric="tf_test_job",
    datasource_type="prometheus",
    datasource_uid=foo.uid,
    query_params={
        "expr": "grafanacloud_grafana_instance_active_user_count",
    },
    hyper_params={
        "daily_seasonality": "15",
        "weekly_seasonality": "10",
    },
    custom_labels={
        "example_label": "example_value",
    })

    package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/machinelearning"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/oss"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"httpMethod":        "POST",
			"prometheusType":    "Mimir",
			"prometheusVersion": "2.4.0",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"basicAuthPassword": "password",
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		foo, err := oss.NewDataSource(ctx, "foo", &oss.DataSourceArgs{
			Type:                  pulumi.String("prometheus"),
			Name:                  pulumi.String("prometheus-ds-test"),
			Uid:                   pulumi.String("prometheus-ds-test-uid"),
			Url:                   pulumi.String("https://my-instance.com"),
			BasicAuthEnabled:      pulumi.Bool(true),
			BasicAuthUsername:     pulumi.String("username"),
			JsonDataEncoded:       pulumi.String(json0),
			SecureJsonDataEncoded: pulumi.String(json1),
		})
		if err != nil {
			return err
		}
		_, err = machinelearning.NewJob(ctx, "test_job", &machinelearning.JobArgs{
			Name:           pulumi.String("Test Job"),
			Metric:         pulumi.String("tf_test_job"),
			DatasourceType: pulumi.String("prometheus"),
			DatasourceUid:  foo.Uid,
			QueryParams: pulumi.StringMap{
				"expr": pulumi.String("grafanacloud_grafana_instance_active_user_count"),
			},
			HyperParams: pulumi.StringMap{
				"daily_seasonality":  pulumi.String("15"),
				"weekly_seasonality": pulumi.String("10"),
			},
			CustomLabels: pulumi.StringMap{
				"example_label": pulumi.String("example_value"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Grafana = Pulumiverse.Grafana;

return await Deployment.RunAsync(() => 
{
    var foo = new Grafana.Oss.DataSource("foo", new()
    {
        Type = "prometheus",
        Name = "prometheus-ds-test",
        Uid = "prometheus-ds-test-uid",
        Url = "https://my-instance.com",
        BasicAuthEnabled = true,
        BasicAuthUsername = "username",
        JsonDataEncoded = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["httpMethod"] = "POST",
            ["prometheusType"] = "Mimir",
            ["prometheusVersion"] = "2.4.0",
        }),
        SecureJsonDataEncoded = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["basicAuthPassword"] = "password",
        }),
    });

    var testJob = new Grafana.MachineLearning.Job("test_job", new()
    {
        Name = "Test Job",
        Metric = "tf_test_job",
        DatasourceType = "prometheus",
        DatasourceUid = foo.Uid,
        QueryParams = 
        {
            { "expr", "grafanacloud_grafana_instance_active_user_count" },
        },
        HyperParams = 
        {
            { "daily_seasonality", "15" },
            { "weekly_seasonality", "10" },
        },
        CustomLabels = 
        {
            { "example_label", "example_value" },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.oss.DataSource;
import com.pulumi.grafana.oss.DataSourceArgs;
import com.pulumi.grafana.machineLearning.Job;
import com.pulumi.grafana.machineLearning.JobArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var foo = new DataSource("foo", DataSourceArgs.builder()
            .type("prometheus")
            .name("prometheus-ds-test")
            .uid("prometheus-ds-test-uid")
            .url("https://my-instance.com")
            .basicAuthEnabled(true)
            .basicAuthUsername("username")
            .jsonDataEncoded(serializeJson(
                jsonObject(
                    jsonProperty("httpMethod", "POST"),
                    jsonProperty("prometheusType", "Mimir"),
                    jsonProperty("prometheusVersion", "2.4.0")
                )))
            .secureJsonDataEncoded(serializeJson(
                jsonObject(
                    jsonProperty("basicAuthPassword", "password")
                )))
            .build());

        var testJob = new Job("testJob", JobArgs.builder()
            .name("Test Job")
            .metric("tf_test_job")
            .datasourceType("prometheus")
            .datasourceUid(foo.uid())
            .queryParams(Map.of("expr", "grafanacloud_grafana_instance_active_user_count"))
            .hyperParams(Map.ofEntries(
                Map.entry("daily_seasonality", 15),
                Map.entry("weekly_seasonality", 10)
            ))
            .customLabels(Map.of("example_label", "example_value"))
            .build());

    }
}

    resources:
  foo:
    type: grafana:oss:DataSource
    properties:
      type: prometheus
      name: prometheus-ds-test
      uid: prometheus-ds-test-uid
      url: https://my-instance.com
      basicAuthEnabled: true
      basicAuthUsername: username
      jsonDataEncoded:
        fn::toJSON:
          httpMethod: POST
          prometheusType: Mimir
          prometheusVersion: 2.4.0
      secureJsonDataEncoded:
        fn::toJSON:
          basicAuthPassword: password
  testJob:
    type: grafana:machineLearning:Job
    name: test_job
    properties:
      name: Test Job
      metric: tf_test_job
      datasourceType: prometheus
      datasourceUid: ${foo.uid}
      queryParams:
        expr: grafanacloud_grafana_instance_active_user_count
      hyperParams:
        daily_seasonality: 15
        weekly_seasonality: 10
      customLabels:
        example_label: example_value

    Rescaled Forecast

    This forecast has had the data transformed using a power transformation in order to avoid negative lower predictions.

    import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@pulumiverse/grafana";

const foo = new grafana.oss.DataSource("foo", {
    type: "prometheus",
    name: "prometheus-ds-test",
    uid: "prometheus-ds-test-uid",
    url: "https://my-instance.com",
    basicAuthEnabled: true,
    basicAuthUsername: "username",
    jsonDataEncoded: JSON.stringify({
        httpMethod: "POST",
        prometheusType: "Mimir",
        prometheusVersion: "2.4.0",
    }),
    secureJsonDataEncoded: JSON.stringify({
        basicAuthPassword: "password",
    }),
});
const testJob = new grafana.machinelearning.Job("test_job", {
    name: "Test Job",
    metric: "tf_test_job",
    datasourceType: "prometheus",
    datasourceUid: foo.uid,
    queryParams: {
        expr: "grafanacloud_grafana_instance_active_user_count",
    },
    hyperParams: {
        transformation_id: "power",
    },
});

    import pulumi
import json
import pulumiverse_grafana as grafana

foo = grafana.oss.DataSource("foo",
    type="prometheus",
    name="prometheus-ds-test",
    uid="prometheus-ds-test-uid",
    url="https://my-instance.com",
    basic_auth_enabled=True,
    basic_auth_username="username",
    json_data_encoded=json.dumps({
        "httpMethod": "POST",
        "prometheusType": "Mimir",
        "prometheusVersion": "2.4.0",
    }),
    secure_json_data_encoded=json.dumps({
        "basicAuthPassword": "password",
    }))
test_job = grafana.machine_learning.Job("test_job",
    name="Test Job",
    metric="tf_test_job",
    datasource_type="prometheus",
    datasource_uid=foo.uid,
    query_params={
        "expr": "grafanacloud_grafana_instance_active_user_count",
    },
    hyper_params={
        "transformation_id": "power",
    })

    package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/machinelearning"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/oss"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"httpMethod":        "POST",
			"prometheusType":    "Mimir",
			"prometheusVersion": "2.4.0",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"basicAuthPassword": "password",
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		foo, err := oss.NewDataSource(ctx, "foo", &oss.DataSourceArgs{
			Type:                  pulumi.String("prometheus"),
			Name:                  pulumi.String("prometheus-ds-test"),
			Uid:                   pulumi.String("prometheus-ds-test-uid"),
			Url:                   pulumi.String("https://my-instance.com"),
			BasicAuthEnabled:      pulumi.Bool(true),
			BasicAuthUsername:     pulumi.String("username"),
			JsonDataEncoded:       pulumi.String(json0),
			SecureJsonDataEncoded: pulumi.String(json1),
		})
		if err != nil {
			return err
		}
		_, err = machinelearning.NewJob(ctx, "test_job", &machinelearning.JobArgs{
			Name:           pulumi.String("Test Job"),
			Metric:         pulumi.String("tf_test_job"),
			DatasourceType: pulumi.String("prometheus"),
			DatasourceUid:  foo.Uid,
			QueryParams: pulumi.StringMap{
				"expr": pulumi.String("grafanacloud_grafana_instance_active_user_count"),
			},
			HyperParams: pulumi.StringMap{
				"transformation_id": pulumi.String("power"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Grafana = Pulumiverse.Grafana;

return await Deployment.RunAsync(() => 
{
    var foo = new Grafana.Oss.DataSource("foo", new()
    {
        Type = "prometheus",
        Name = "prometheus-ds-test",
        Uid = "prometheus-ds-test-uid",
        Url = "https://my-instance.com",
        BasicAuthEnabled = true,
        BasicAuthUsername = "username",
        JsonDataEncoded = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["httpMethod"] = "POST",
            ["prometheusType"] = "Mimir",
            ["prometheusVersion"] = "2.4.0",
        }),
        SecureJsonDataEncoded = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["basicAuthPassword"] = "password",
        }),
    });

    var testJob = new Grafana.MachineLearning.Job("test_job", new()
    {
        Name = "Test Job",
        Metric = "tf_test_job",
        DatasourceType = "prometheus",
        DatasourceUid = foo.Uid,
        QueryParams = 
        {
            { "expr", "grafanacloud_grafana_instance_active_user_count" },
        },
        HyperParams = 
        {
            { "transformation_id", "power" },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.oss.DataSource;
import com.pulumi.grafana.oss.DataSourceArgs;
import com.pulumi.grafana.machineLearning.Job;
import com.pulumi.grafana.machineLearning.JobArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var foo = new DataSource("foo", DataSourceArgs.builder()
            .type("prometheus")
            .name("prometheus-ds-test")
            .uid("prometheus-ds-test-uid")
            .url("https://my-instance.com")
            .basicAuthEnabled(true)
            .basicAuthUsername("username")
            .jsonDataEncoded(serializeJson(
                jsonObject(
                    jsonProperty("httpMethod", "POST"),
                    jsonProperty("prometheusType", "Mimir"),
                    jsonProperty("prometheusVersion", "2.4.0")
                )))
            .secureJsonDataEncoded(serializeJson(
                jsonObject(
                    jsonProperty("basicAuthPassword", "password")
                )))
            .build());

        var testJob = new Job("testJob", JobArgs.builder()
            .name("Test Job")
            .metric("tf_test_job")
            .datasourceType("prometheus")
            .datasourceUid(foo.uid())
            .queryParams(Map.of("expr", "grafanacloud_grafana_instance_active_user_count"))
            .hyperParams(Map.of("transformation_id", "power"))
            .build());

    }
}

    resources:
  foo:
    type: grafana:oss:DataSource
    properties:
      type: prometheus
      name: prometheus-ds-test
      uid: prometheus-ds-test-uid
      url: https://my-instance.com
      basicAuthEnabled: true
      basicAuthUsername: username
      jsonDataEncoded:
        fn::toJSON:
          httpMethod: POST
          prometheusType: Mimir
          prometheusVersion: 2.4.0
      secureJsonDataEncoded:
        fn::toJSON:
          basicAuthPassword: password
  testJob:
    type: grafana:machineLearning:Job
    name: test_job
    properties:
      name: Test Job
      metric: tf_test_job
      datasourceType: prometheus
      datasourceUid: ${foo.uid}
      queryParams:
        expr: grafanacloud_grafana_instance_active_user_count
      hyperParams:
        transformation_id: power

    Forecast with Holidays

    This forecast has holidays which will be taken into account when training the model.

    import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@pulumiverse/grafana";

const foo = new grafana.oss.DataSource("foo", {
    type: "prometheus",
    name: "prometheus-ds-test",
    uid: "prometheus-ds-test-uid",
    url: "https://my-instance.com",
    basicAuthEnabled: true,
    basicAuthUsername: "username",
    jsonDataEncoded: JSON.stringify({
        httpMethod: "POST",
        prometheusType: "Mimir",
        prometheusVersion: "2.4.0",
    }),
    secureJsonDataEncoded: JSON.stringify({
        basicAuthPassword: "password",
    }),
});
const testHoliday = new grafana.machinelearning.Holiday("test_holiday", {
    name: "Test Holiday",
    customPeriods: [{
        name: "First of January",
        startTime: "2023-01-01T00:00:00Z",
        endTime: "2023-01-02T00:00:00Z",
    }],
});
const testJob = new grafana.machinelearning.Job("test_job", {
    name: "Test Job",
    metric: "tf_test_job",
    datasourceType: "prometheus",
    datasourceUid: foo.uid,
    queryParams: {
        expr: "grafanacloud_grafana_instance_active_user_count",
    },
    holidays: [testHoliday.id],
});

    import pulumi
import json
import pulumiverse_grafana as grafana

foo = grafana.oss.DataSource("foo",
    type="prometheus",
    name="prometheus-ds-test",
    uid="prometheus-ds-test-uid",
    url="https://my-instance.com",
    basic_auth_enabled=True,
    basic_auth_username="username",
    json_data_encoded=json.dumps({
        "httpMethod": "POST",
        "prometheusType": "Mimir",
        "prometheusVersion": "2.4.0",
    }),
    secure_json_data_encoded=json.dumps({
        "basicAuthPassword": "password",
    }))
test_holiday = grafana.machine_learning.Holiday("test_holiday",
    name="Test Holiday",
    custom_periods=[{
        "name": "First of January",
        "start_time": "2023-01-01T00:00:00Z",
        "end_time": "2023-01-02T00:00:00Z",
    }])
test_job = grafana.machine_learning.Job("test_job",
    name="Test Job",
    metric="tf_test_job",
    datasource_type="prometheus",
    datasource_uid=foo.uid,
    query_params={
        "expr": "grafanacloud_grafana_instance_active_user_count",
    },
    holidays=[test_holiday.id])

    package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/machinelearning"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/oss"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"httpMethod":        "POST",
			"prometheusType":    "Mimir",
			"prometheusVersion": "2.4.0",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"basicAuthPassword": "password",
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		foo, err := oss.NewDataSource(ctx, "foo", &oss.DataSourceArgs{
			Type:                  pulumi.String("prometheus"),
			Name:                  pulumi.String("prometheus-ds-test"),
			Uid:                   pulumi.String("prometheus-ds-test-uid"),
			Url:                   pulumi.String("https://my-instance.com"),
			BasicAuthEnabled:      pulumi.Bool(true),
			BasicAuthUsername:     pulumi.String("username"),
			JsonDataEncoded:       pulumi.String(json0),
			SecureJsonDataEncoded: pulumi.String(json1),
		})
		if err != nil {
			return err
		}
		testHoliday, err := machinelearning.NewHoliday(ctx, "test_holiday", &machinelearning.HolidayArgs{
			Name: pulumi.String("Test Holiday"),
			CustomPeriods: machinelearning.HolidayCustomPeriodArray{
				&machinelearning.HolidayCustomPeriodArgs{
					Name:      pulumi.String("First of January"),
					StartTime: pulumi.String("2023-01-01T00:00:00Z"),
					EndTime:   pulumi.String("2023-01-02T00:00:00Z"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = machinelearning.NewJob(ctx, "test_job", &machinelearning.JobArgs{
			Name:           pulumi.String("Test Job"),
			Metric:         pulumi.String("tf_test_job"),
			DatasourceType: pulumi.String("prometheus"),
			DatasourceUid:  foo.Uid,
			QueryParams: pulumi.StringMap{
				"expr": pulumi.String("grafanacloud_grafana_instance_active_user_count"),
			},
			Holidays: pulumi.StringArray{
				testHoliday.ID(),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Grafana = Pulumiverse.Grafana;

return await Deployment.RunAsync(() => 
{
    var foo = new Grafana.Oss.DataSource("foo", new()
    {
        Type = "prometheus",
        Name = "prometheus-ds-test",
        Uid = "prometheus-ds-test-uid",
        Url = "https://my-instance.com",
        BasicAuthEnabled = true,
        BasicAuthUsername = "username",
        JsonDataEncoded = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["httpMethod"] = "POST",
            ["prometheusType"] = "Mimir",
            ["prometheusVersion"] = "2.4.0",
        }),
        SecureJsonDataEncoded = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["basicAuthPassword"] = "password",
        }),
    });

    var testHoliday = new Grafana.MachineLearning.Holiday("test_holiday", new()
    {
        Name = "Test Holiday",
        CustomPeriods = new[]
        {
            new Grafana.MachineLearning.Inputs.HolidayCustomPeriodArgs
            {
                Name = "First of January",
                StartTime = "2023-01-01T00:00:00Z",
                EndTime = "2023-01-02T00:00:00Z",
            },
        },
    });

    var testJob = new Grafana.MachineLearning.Job("test_job", new()
    {
        Name = "Test Job",
        Metric = "tf_test_job",
        DatasourceType = "prometheus",
        DatasourceUid = foo.Uid,
        QueryParams = 
        {
            { "expr", "grafanacloud_grafana_instance_active_user_count" },
        },
        Holidays = new[]
        {
            testHoliday.Id,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.oss.DataSource;
import com.pulumi.grafana.oss.DataSourceArgs;
import com.pulumi.grafana.machineLearning.Holiday;
import com.pulumi.grafana.machineLearning.HolidayArgs;
import com.pulumi.grafana.machineLearning.inputs.HolidayCustomPeriodArgs;
import com.pulumi.grafana.machineLearning.Job;
import com.pulumi.grafana.machineLearning.JobArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var foo = new DataSource("foo", DataSourceArgs.builder()
            .type("prometheus")
            .name("prometheus-ds-test")
            .uid("prometheus-ds-test-uid")
            .url("https://my-instance.com")
            .basicAuthEnabled(true)
            .basicAuthUsername("username")
            .jsonDataEncoded(serializeJson(
                jsonObject(
                    jsonProperty("httpMethod", "POST"),
                    jsonProperty("prometheusType", "Mimir"),
                    jsonProperty("prometheusVersion", "2.4.0")
                )))
            .secureJsonDataEncoded(serializeJson(
                jsonObject(
                    jsonProperty("basicAuthPassword", "password")
                )))
            .build());

        var testHoliday = new Holiday("testHoliday", HolidayArgs.builder()
            .name("Test Holiday")
            .customPeriods(HolidayCustomPeriodArgs.builder()
                .name("First of January")
                .startTime("2023-01-01T00:00:00Z")
                .endTime("2023-01-02T00:00:00Z")
                .build())
            .build());

        var testJob = new Job("testJob", JobArgs.builder()
            .name("Test Job")
            .metric("tf_test_job")
            .datasourceType("prometheus")
            .datasourceUid(foo.uid())
            .queryParams(Map.of("expr", "grafanacloud_grafana_instance_active_user_count"))
            .holidays(testHoliday.id())
            .build());

    }
}

    resources:
  foo:
    type: grafana:oss:DataSource
    properties:
      type: prometheus
      name: prometheus-ds-test
      uid: prometheus-ds-test-uid
      url: https://my-instance.com
      basicAuthEnabled: true
      basicAuthUsername: username
      jsonDataEncoded:
        fn::toJSON:
          httpMethod: POST
          prometheusType: Mimir
          prometheusVersion: 2.4.0
      secureJsonDataEncoded:
        fn::toJSON:
          basicAuthPassword: password
  testHoliday:
    type: grafana:machineLearning:Holiday
    name: test_holiday
    properties:
      name: Test Holiday
      customPeriods:
        - name: First of January
          startTime: 2023-01-01T00:00:00Z
          endTime: 2023-01-02T00:00:00Z
  testJob:
    type: grafana:machineLearning:Job
    name: test_job
    properties:
      name: Test Job
      metric: tf_test_job
      datasourceType: prometheus
      datasourceUid: ${foo.uid}
      queryParams:
        expr: grafanacloud_grafana_instance_active_user_count
      holidays:
        - ${testHoliday.id}

    Create MachineLearningJob Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new MachineLearningJob(name: string, args: MachineLearningJobArgs, opts?: CustomResourceOptions);
    @overload
def MachineLearningJob(resource_name: str,
                       args: MachineLearningJobArgs,
                       opts: Optional[ResourceOptions] = None)

@overload
def MachineLearningJob(resource_name: str,
                       opts: Optional[ResourceOptions] = None,
                       custom_labels: Optional[Mapping[str, str]] = None,
                       datasource_type: Optional[str] = None,
                       datasource_uid: Optional[str] = None,
                       description: Optional[str] = None,
                       holidays: Optional[Sequence[str]] = None,
                       hyper_params: Optional[Mapping[str, str]] = None,
                       interval: Optional[int] = None,
                       metric: Optional[str] = None,
                       name: Optional[str] = None,
                       query_params: Optional[Mapping[str, str]] = None,
                       training_window: Optional[int] = None)
    func NewMachineLearningJob(ctx *Context, name string, args MachineLearningJobArgs, opts ...ResourceOption) (*MachineLearningJob, error)
    public MachineLearningJob(string name, MachineLearningJobArgs args, CustomResourceOptions? opts = null)
    public MachineLearningJob(String name, MachineLearningJobArgs args)
public MachineLearningJob(String name, MachineLearningJobArgs args, CustomResourceOptions options)

    type: grafana:MachineLearningJob
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args MachineLearningJobArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args MachineLearningJobArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args MachineLearningJobArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args MachineLearningJobArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args MachineLearningJobArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    MachineLearningJob Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The MachineLearningJob resource accepts the following input properties:

    DatasourceType string
    The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
    DatasourceUid string
    The uid of the datasource to query.
    Metric string
    The metric used to query the job results.
    QueryParams Dictionary<string, string>
    An object representing the query params to query Grafana with.
    CustomLabels Dictionary<string, string>
    An object representing the custom labels added on the forecast.
    Description string
    A description of the job.
    Holidays List<string>
    A list of holiday IDs or names to take into account when training the model.
    HyperParams Dictionary<string, string>
    The hyperparameters used to fine tune the algorithm. See https://grafana.com/docs/grafana-cloud/alerting-and-irm/machine-learning/forecasts/models/ for the full list of available hyperparameters.
    Interval int
    The data interval in seconds to train the data on.
    Name string
    The name of the job.
    TrainingWindow int
    The data interval in seconds to train the data on.
    DatasourceType string
    The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
    DatasourceUid string
    The uid of the datasource to query.
    Metric string
    The metric used to query the job results.
    QueryParams map[string]string
    An object representing the query params to query Grafana with.
    CustomLabels map[string]string
    An object representing the custom labels added on the forecast.
    Description string
    A description of the job.
    Holidays []string
    A list of holiday IDs or names to take into account when training the model.
    HyperParams map[string]string
    The hyperparameters used to fine tune the algorithm. See https://grafana.com/docs/grafana-cloud/alerting-and-irm/machine-learning/forecasts/models/ for the full list of available hyperparameters.
    Interval int
    The data interval in seconds to train the data on.
    Name string
    The name of the job.
    TrainingWindow int
    The data interval in seconds to train the data on.
    datasourceType String
    The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
    datasourceUid String
    The uid of the datasource to query.
    metric String
    The metric used to query the job results.
    queryParams Map<String,String>
    An object representing the query params to query Grafana with.
    customLabels Map<String,String>
    An object representing the custom labels added on the forecast.
    description String
    A description of the job.
    holidays List<String>
    A list of holiday IDs or names to take into account when training the model.
    hyperParams Map<String,String>
    The hyperparameters used to fine tune the algorithm. See https://grafana.com/docs/grafana-cloud/alerting-and-irm/machine-learning/forecasts/models/ for the full list of available hyperparameters.
    interval Integer
    The data interval in seconds to train the data on.
    name String
    The name of the job.
    trainingWindow Integer
    The data interval in seconds to train the data on.
    datasourceType string
    The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
    datasourceUid string
    The uid of the datasource to query.
    metric string
    The metric used to query the job results.
    queryParams {[key: string]: string}
    An object representing the query params to query Grafana with.
    customLabels {[key: string]: string}
    An object representing the custom labels added on the forecast.
    description string
    A description of the job.
    holidays string[]
    A list of holiday IDs or names to take into account when training the model.
    hyperParams {[key: string]: string}
    The hyperparameters used to fine tune the algorithm. See https://grafana.com/docs/grafana-cloud/alerting-and-irm/machine-learning/forecasts/models/ for the full list of available hyperparameters.
    interval number
    The data interval in seconds to train the data on.
    name string
    The name of the job.
    trainingWindow number
    The data interval in seconds to train the data on.
    datasource_type str
    The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
    datasource_uid str
    The uid of the datasource to query.
    metric str
    The metric used to query the job results.
    query_params Mapping[str, str]
    An object representing the query params to query Grafana with.
    custom_labels Mapping[str, str]
    An object representing the custom labels added on the forecast.
    description str
    A description of the job.
    holidays Sequence[str]
    A list of holiday IDs or names to take into account when training the model.
    hyper_params Mapping[str, str]
    The hyperparameters used to fine tune the algorithm. See https://grafana.com/docs/grafana-cloud/alerting-and-irm/machine-learning/forecasts/models/ for the full list of available hyperparameters.
    interval int
    The data interval in seconds to train the data on.
    name str
    The name of the job.
    training_window int
    The data interval in seconds to train the data on.
    datasourceType String
    The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
    datasourceUid String
    The uid of the datasource to query.
    metric String
    The metric used to query the job results.
    queryParams Map<String>
    An object representing the query params to query Grafana with.
    customLabels Map<String>
    An object representing the custom labels added on the forecast.
    description String
    A description of the job.
    holidays List<String>
    A list of holiday IDs or names to take into account when training the model.
    hyperParams Map<String>
    The hyperparameters used to fine tune the algorithm. See https://grafana.com/docs/grafana-cloud/alerting-and-irm/machine-learning/forecasts/models/ for the full list of available hyperparameters.
    interval Number
    The data interval in seconds to train the data on.
    name String
    The name of the job.
    trainingWindow Number
    The data interval in seconds to train the data on.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the MachineLearningJob resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing MachineLearningJob Resource

    Get an existing MachineLearningJob resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: MachineLearningJobState, opts?: CustomResourceOptions): MachineLearningJob
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        custom_labels: Optional[Mapping[str, str]] = None,
        datasource_type: Optional[str] = None,
        datasource_uid: Optional[str] = None,
        description: Optional[str] = None,
        holidays: Optional[Sequence[str]] = None,
        hyper_params: Optional[Mapping[str, str]] = None,
        interval: Optional[int] = None,
        metric: Optional[str] = None,
        name: Optional[str] = None,
        query_params: Optional[Mapping[str, str]] = None,
        training_window: Optional[int] = None) -> MachineLearningJob
    func GetMachineLearningJob(ctx *Context, name string, id IDInput, state *MachineLearningJobState, opts ...ResourceOption) (*MachineLearningJob, error)
    public static MachineLearningJob Get(string name, Input<string> id, MachineLearningJobState? state, CustomResourceOptions? opts = null)
    public static MachineLearningJob get(String name, Output<String> id, MachineLearningJobState state, CustomResourceOptions options)
    resources:  _:    type: grafana:MachineLearningJob    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    CustomLabels Dictionary<string, string>
    An object representing the custom labels added on the forecast.
    DatasourceType string
    The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
    DatasourceUid string
    The uid of the datasource to query.
    Description string
    A description of the job.
    Holidays List<string>
    A list of holiday IDs or names to take into account when training the model.
    HyperParams Dictionary<string, string>
    The hyperparameters used to fine tune the algorithm. See https://grafana.com/docs/grafana-cloud/alerting-and-irm/machine-learning/forecasts/models/ for the full list of available hyperparameters.
    Interval int
    The data interval in seconds to train the data on.
    Metric string
    The metric used to query the job results.
    Name string
    The name of the job.
    QueryParams Dictionary<string, string>
    An object representing the query params to query Grafana with.
    TrainingWindow int
    The data interval in seconds to train the data on.
    CustomLabels map[string]string
    An object representing the custom labels added on the forecast.
    DatasourceType string
    The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
    DatasourceUid string
    The uid of the datasource to query.
    Description string
    A description of the job.
    Holidays []string
    A list of holiday IDs or names to take into account when training the model.
    HyperParams map[string]string
    The hyperparameters used to fine tune the algorithm. See https://grafana.com/docs/grafana-cloud/alerting-and-irm/machine-learning/forecasts/models/ for the full list of available hyperparameters.
    Interval int
    The data interval in seconds to train the data on.
    Metric string
    The metric used to query the job results.
    Name string
    The name of the job.
    QueryParams map[string]string
    An object representing the query params to query Grafana with.
    TrainingWindow int
    The data interval in seconds to train the data on.
    customLabels Map<String,String>
    An object representing the custom labels added on the forecast.
    datasourceType String
    The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
    datasourceUid String
    The uid of the datasource to query.
    description String
    A description of the job.
    holidays List<String>
    A list of holiday IDs or names to take into account when training the model.
    hyperParams Map<String,String>
    The hyperparameters used to fine tune the algorithm. See https://grafana.com/docs/grafana-cloud/alerting-and-irm/machine-learning/forecasts/models/ for the full list of available hyperparameters.
    interval Integer
    The data interval in seconds to train the data on.
    metric String
    The metric used to query the job results.
    name String
    The name of the job.
    queryParams Map<String,String>
    An object representing the query params to query Grafana with.
    trainingWindow Integer
    The data interval in seconds to train the data on.
    customLabels {[key: string]: string}
    An object representing the custom labels added on the forecast.
    datasourceType string
    The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
    datasourceUid string
    The uid of the datasource to query.
    description string
    A description of the job.
    holidays string[]
    A list of holiday IDs or names to take into account when training the model.
    hyperParams {[key: string]: string}
    The hyperparameters used to fine tune the algorithm. See https://grafana.com/docs/grafana-cloud/alerting-and-irm/machine-learning/forecasts/models/ for the full list of available hyperparameters.
    interval number
    The data interval in seconds to train the data on.
    metric string
    The metric used to query the job results.
    name string
    The name of the job.
    queryParams {[key: string]: string}
    An object representing the query params to query Grafana with.
    trainingWindow number
    The data interval in seconds to train the data on.
    custom_labels Mapping[str, str]
    An object representing the custom labels added on the forecast.
    datasource_type str
    The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
    datasource_uid str
    The uid of the datasource to query.
    description str
    A description of the job.
    holidays Sequence[str]
    A list of holiday IDs or names to take into account when training the model.
    hyper_params Mapping[str, str]
    The hyperparameters used to fine tune the algorithm. See https://grafana.com/docs/grafana-cloud/alerting-and-irm/machine-learning/forecasts/models/ for the full list of available hyperparameters.
    interval int
    The data interval in seconds to train the data on.
    metric str
    The metric used to query the job results.
    name str
    The name of the job.
    query_params Mapping[str, str]
    An object representing the query params to query Grafana with.
    training_window int
    The data interval in seconds to train the data on.
    customLabels Map<String>
    An object representing the custom labels added on the forecast.
    datasourceType String
    The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
    datasourceUid String
    The uid of the datasource to query.
    description String
    A description of the job.
    holidays List<String>
    A list of holiday IDs or names to take into account when training the model.
    hyperParams Map<String>
    The hyperparameters used to fine tune the algorithm. See https://grafana.com/docs/grafana-cloud/alerting-and-irm/machine-learning/forecasts/models/ for the full list of available hyperparameters.
    interval Number
    The data interval in seconds to train the data on.
    metric String
    The metric used to query the job results.
    name String
    The name of the job.
    queryParams Map<String>
    An object representing the query params to query Grafana with.
    trainingWindow Number
    The data interval in seconds to train the data on.

    Import

    $ pulumi import grafana:index/machineLearningJob:MachineLearningJob name "{{ id }}"

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    grafana pulumiverse/pulumi-grafana
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the grafana Terraform Provider.
    grafana logo
    Grafana v0.16.1 published on Saturday, Mar 15, 2025 by pulumiverse
    pulumiverse/pulumi-grafana