chronosphere.ClassicDashboard

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Pulumi = Chronosphere.Pulumi;

return await Deployment.RunAsync(() => 
{
    var collection = new Pulumi.Collection("collection", new()
    {
        Name = "Platform",
    });

    var platform = new Pulumi.ClassicDashboard("platform", new()
    {
        CollectionId = collection.Id,
        DashboardJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["title"] = "Dashboard",
            ["panels"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["gridPos"] = new Dictionary<string, object?>
                    {
                        ["h"] = 12,
                        ["w"] = 24,
                        ["x"] = 0,
                        ["y"] = 0,
                    },
                    ["id"] = 2,
                    ["targets"] = new[]
                    {
                        new Dictionary<string, object?>
                        {
                            ["expr"] = "up",
                        },
                    },
                    ["title"] = "Up by instance",
                    ["type"] = "graph",
                },
            },
        }),
    });

});

package main

import (
	"encoding/json"

	"github.com/chronosphereio/pulumi-chronosphere/sdk/go/chronosphere"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		collection, err := chronosphere.NewCollection(ctx, "collection", &chronosphere.CollectionArgs{
			Name: pulumi.String("Platform"),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"title": "Dashboard",
			"panels": []map[string]interface{}{
				map[string]interface{}{
					"gridPos": map[string]interface{}{
						"h": 12,
						"w": 24,
						"x": 0,
						"y": 0,
					},
					"id": 2,
					"targets": []map[string]interface{}{
						map[string]interface{}{
							"expr": "up",
						},
					},
					"title": "Up by instance",
					"type":  "graph",
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = chronosphere.NewClassicDashboard(ctx, "platform", &chronosphere.ClassicDashboardArgs{
			CollectionId:  collection.ID(),
			DashboardJson: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.chronosphere.Collection;
import com.pulumi.chronosphere.CollectionArgs;
import com.pulumi.chronosphere.ClassicDashboard;
import com.pulumi.chronosphere.ClassicDashboardArgs;
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 collection = new Collection("collection", CollectionArgs.builder()        
            .name("Platform")
            .build());

        var platform = new ClassicDashboard("platform", ClassicDashboardArgs.builder()        
            .collectionId(collection.id())
            .dashboardJson(serializeJson(
                jsonObject(
                    jsonProperty("title", "Dashboard"),
                    jsonProperty("panels", jsonArray(jsonObject(
                        jsonProperty("gridPos", jsonObject(
                            jsonProperty("h", 12),
                            jsonProperty("w", 24),
                            jsonProperty("x", 0),
                            jsonProperty("y", 0)
                        )),
                        jsonProperty("id", 2),
                        jsonProperty("targets", jsonArray(jsonObject(
                            jsonProperty("expr", "up")
                        ))),
                        jsonProperty("title", "Up by instance"),
                        jsonProperty("type", "graph")
                    )))
                )))
            .build());

    }
}

import * as pulumi from "@pulumi/pulumi";
import * as chronosphere from "@pulumi-chronosphere/pulumi-chronosphere";

const collection = new chronosphere.Collection("collection", {name: "Platform"});
const platform = new chronosphere.ClassicDashboard("platform", {
    collectionId: collection.id,
    dashboardJson: JSON.stringify({
        title: "Dashboard",
        panels: [{
            gridPos: {
                h: 12,
                w: 24,
                x: 0,
                y: 0,
            },
            id: 2,
            targets: [{
                expr: "up",
            }],
            title: "Up by instance",
            type: "graph",
        }],
    }),
});

import pulumi
import json
import pulumi_chronosphere as chronosphere

collection = chronosphere.Collection("collection", name="Platform")
platform = chronosphere.ClassicDashboard("platform",
    collection_id=collection.id,
    dashboard_json=json.dumps({
        "title": "Dashboard",
        "panels": [{
            "gridPos": {
                "h": 12,
                "w": 24,
                "x": 0,
                "y": 0,
            },
            "id": 2,
            "targets": [{
                "expr": "up",
            }],
            "title": "Up by instance",
            "type": "graph",
        }],
    }))

resources:
  collection:
    type: chronosphere:Collection
    properties:
      name: Platform
  platform:
    type: chronosphere:ClassicDashboard
    properties:
      collectionId: ${collection.id}
      dashboardJson:
        fn::toJSON:
          title: Dashboard
          panels:
            - gridPos:
                h: 12
                w: 24
                x: 0
                y: 0
              id: 2
              targets:
                - expr: up
              title: Up by instance
              type: graph