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.3 published on Monday, Apr 7, 2025 by pulumiverse
pulumiverse/pulumi-grafana

grafana.MachineLearningJob

Explore with Pulumi AI

Grafana v0.16.3 published on Monday, Apr 7, 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",
    },
});
Copy
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",
    })
Copy
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
	})
}
Copy
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" },
        },
    });

});
Copy
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());

    }
}
Copy
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
Copy

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",
    },
});
Copy
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",
    })
Copy
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
	})
}
Copy
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" },
        },
    });

});
Copy
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());

    }
}
Copy
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
Copy

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",
    },
});
Copy
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",
    })
Copy
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
	})
}
Copy
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" },
        },
    });

});
Copy
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());

    }
}
Copy
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
Copy

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],
});
Copy
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])
Copy
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
	})
}
Copy
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,
        },
    });

});
Copy
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());

    }
}
Copy
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}
Copy

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 This property is required. string
The unique name of the resource.
args This property is required. MachineLearningJobArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
resource_name This property is required. str
The unique name of the resource.
args This property is required. 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 This property is required. string
The unique name of the resource.
args This property is required. MachineLearningJobArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name This property is required. string
The unique name of the resource.
args This property is required. MachineLearningJobArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
name This property is required. String
The unique name of the resource.
args This property is required. 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 This property is required. string
The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
DatasourceUid This property is required. string
The uid of the datasource to query.
Metric This property is required. string
The metric used to query the job results.
QueryParams This property is required. 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 This property is required. string
The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
DatasourceUid This property is required. string
The uid of the datasource to query.
Metric This property is required. string
The metric used to query the job results.
QueryParams This property is required. 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 This property is required. String
The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
datasourceUid This property is required. String
The uid of the datasource to query.
metric This property is required. String
The metric used to query the job results.
queryParams This property is required. 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 This property is required. string
The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
datasourceUid This property is required. string
The uid of the datasource to query.
metric This property is required. string
The metric used to query the job results.
queryParams This property is required. {[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 This property is required. str
The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
datasource_uid This property is required. str
The uid of the datasource to query.
metric This property is required. str
The metric used to query the job results.
query_params This property is required. 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 This property is required. String
The type of datasource being queried. Currently allowed values are prometheus, graphite, loki, postgres, and datadog.
datasourceUid This property is required. String
The uid of the datasource to query.
metric This property is required. String
The metric used to query the job results.
queryParams This property is required. 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 This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
name This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required.
The unique name of the resulting resource.
id This property is required.
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 }}"
Copy

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 v0.16.3 published on Monday, Apr 7, 2025 by pulumiverse
pulumiverse/pulumi-grafana