grafana.k6.Installation

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

const config = new pulumi.Config();
// Cloud Access Policy token for Grafana Cloud with the following scopes: stacks:read|write|delete, stack-service-accounts:write
const cloudAccessPolicyToken = config.requireObject<any>("cloudAccessPolicyToken");
const stackSlug = config.requireObject<any>("stackSlug");
const cloudRegion = config.get("cloudRegion") || "us";
const k6Stack = new grafana.cloud.Stack("k6_stack", {
    name: stackSlug,
    slug: stackSlug,
    regionSlug: cloudRegion,
});
// Step 2: Create a Service Account and a token to install the k6 App
const k6Sa = new grafana.cloud.StackServiceAccount("k6_sa", {
    stackSlug: stackSlug,
    name: `${stackSlug}-k6-app`,
    role: "Admin",
    isDisabled: false,
});
const k6SaToken = new grafana.cloud.StackServiceAccountToken("k6_sa_token", {
    stackSlug: stackSlug,
    name: `${stackSlug}-k6-app-token`,
    serviceAccountId: k6Sa.id,
});
// Step 3: Install the k6 App on the stack
const k6Installation = new grafana.k6.Installation("k6_installation", {
    cloudAccessPolicyToken: cloudAccessPolicyToken,
    stackId: k6Stack.id,
    grafanaSaToken: k6SaToken.key,
    grafanaUser: "admin",
});
const myK6Project = new grafana.k6.Project("my_k6_project", {name: "k6 Project created with TF"});

import pulumi
import pulumiverse_grafana as grafana

config = pulumi.Config()
# Cloud Access Policy token for Grafana Cloud with the following scopes: stacks:read|write|delete, stack-service-accounts:write
cloud_access_policy_token = config.require_object("cloudAccessPolicyToken")
stack_slug = config.require_object("stackSlug")
cloud_region = config.get("cloudRegion")
if cloud_region is None:
    cloud_region = "us"
k6_stack = grafana.cloud.Stack("k6_stack",
    name=stack_slug,
    slug=stack_slug,
    region_slug=cloud_region)
# Step 2: Create a Service Account and a token to install the k6 App
k6_sa = grafana.cloud.StackServiceAccount("k6_sa",
    stack_slug=stack_slug,
    name=f"{stack_slug}-k6-app",
    role="Admin",
    is_disabled=False)
k6_sa_token = grafana.cloud.StackServiceAccountToken("k6_sa_token",
    stack_slug=stack_slug,
    name=f"{stack_slug}-k6-app-token",
    service_account_id=k6_sa.id)
# Step 3: Install the k6 App on the stack
k6_installation = grafana.k6.Installation("k6_installation",
    cloud_access_policy_token=cloud_access_policy_token,
    stack_id=k6_stack.id,
    grafana_sa_token=k6_sa_token.key,
    grafana_user="admin")
my_k6_project = grafana.k6.Project("my_k6_project", name="k6 Project created with TF")

package main

import (
	"fmt"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/cloud"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/k6"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		// Cloud Access Policy token for Grafana Cloud with the following scopes: stacks:read|write|delete, stack-service-accounts:write
		cloudAccessPolicyToken := cfg.RequireObject("cloudAccessPolicyToken")
		stackSlug := cfg.RequireObject("stackSlug")
		cloudRegion := "us"
		if param := cfg.Get("cloudRegion"); param != "" {
			cloudRegion = param
		}
		k6Stack, err := cloud.NewStack(ctx, "k6_stack", &cloud.StackArgs{
			Name:       pulumi.Any(stackSlug),
			Slug:       pulumi.Any(stackSlug),
			RegionSlug: pulumi.String(cloudRegion),
		})
		if err != nil {
			return err
		}
		// Step 2: Create a Service Account and a token to install the k6 App
		k6Sa, err := cloud.NewStackServiceAccount(ctx, "k6_sa", &cloud.StackServiceAccountArgs{
			StackSlug:  pulumi.Any(stackSlug),
			Name:       pulumi.Sprintf("%v-k6-app", stackSlug),
			Role:       pulumi.String("Admin"),
			IsDisabled: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		k6SaToken, err := cloud.NewStackServiceAccountToken(ctx, "k6_sa_token", &cloud.StackServiceAccountTokenArgs{
			StackSlug:        pulumi.Any(stackSlug),
			Name:             pulumi.Sprintf("%v-k6-app-token", stackSlug),
			ServiceAccountId: k6Sa.ID(),
		})
		if err != nil {
			return err
		}
		// Step 3: Install the k6 App on the stack
		_, err = k6.NewInstallation(ctx, "k6_installation", &k6.InstallationArgs{
			CloudAccessPolicyToken: pulumi.Any(cloudAccessPolicyToken),
			StackId:                k6Stack.ID(),
			GrafanaSaToken:         k6SaToken.Key,
			GrafanaUser:            pulumi.String("admin"),
		})
		if err != nil {
			return err
		}
		_, err = k6.NewProject(ctx, "my_k6_project", &k6.ProjectArgs{
			Name: pulumi.String("k6 Project created with TF"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    // Cloud Access Policy token for Grafana Cloud with the following scopes: stacks:read|write|delete, stack-service-accounts:write
    var cloudAccessPolicyToken = config.RequireObject<dynamic>("cloudAccessPolicyToken");
    var stackSlug = config.RequireObject<dynamic>("stackSlug");
    var cloudRegion = config.Get("cloudRegion") ?? "us";
    var k6Stack = new Grafana.Cloud.Stack("k6_stack", new()
    {
        Name = stackSlug,
        Slug = stackSlug,
        RegionSlug = cloudRegion,
    });

    // Step 2: Create a Service Account and a token to install the k6 App
    var k6Sa = new Grafana.Cloud.StackServiceAccount("k6_sa", new()
    {
        StackSlug = stackSlug,
        Name = $"{stackSlug}-k6-app",
        Role = "Admin",
        IsDisabled = false,
    });

    var k6SaToken = new Grafana.Cloud.StackServiceAccountToken("k6_sa_token", new()
    {
        StackSlug = stackSlug,
        Name = $"{stackSlug}-k6-app-token",
        ServiceAccountId = k6Sa.Id,
    });

    // Step 3: Install the k6 App on the stack
    var k6Installation = new Grafana.K6.Installation("k6_installation", new()
    {
        CloudAccessPolicyToken = cloudAccessPolicyToken,
        StackId = k6Stack.Id,
        GrafanaSaToken = k6SaToken.Key,
        GrafanaUser = "admin",
    });

    var myK6Project = new Grafana.K6.Project("my_k6_project", new()
    {
        Name = "k6 Project created with TF",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.cloud.Stack;
import com.pulumi.grafana.cloud.StackArgs;
import com.pulumi.grafana.cloud.StackServiceAccount;
import com.pulumi.grafana.cloud.StackServiceAccountArgs;
import com.pulumi.grafana.cloud.StackServiceAccountToken;
import com.pulumi.grafana.cloud.StackServiceAccountTokenArgs;
import com.pulumi.grafana.k6.Installation;
import com.pulumi.grafana.k6.InstallationArgs;
import com.pulumi.grafana.k6.Project;
import com.pulumi.grafana.k6.ProjectArgs;
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) {
        final var config = ctx.config();
        final var cloudAccessPolicyToken = config.get("cloudAccessPolicyToken");
        final var stackSlug = config.get("stackSlug");
        final var cloudRegion = config.get("cloudRegion").orElse("us");
        var k6Stack = new Stack("k6Stack", StackArgs.builder()
            .name(stackSlug)
            .slug(stackSlug)
            .regionSlug(cloudRegion)
            .build());

        // Step 2: Create a Service Account and a token to install the k6 App
        var k6Sa = new StackServiceAccount("k6Sa", StackServiceAccountArgs.builder()
            .stackSlug(stackSlug)
            .name(String.format("%s-k6-app", stackSlug))
            .role("Admin")
            .isDisabled(false)
            .build());

        var k6SaToken = new StackServiceAccountToken("k6SaToken", StackServiceAccountTokenArgs.builder()
            .stackSlug(stackSlug)
            .name(String.format("%s-k6-app-token", stackSlug))
            .serviceAccountId(k6Sa.id())
            .build());

        // Step 3: Install the k6 App on the stack
        var k6Installation = new Installation("k6Installation", InstallationArgs.builder()
            .cloudAccessPolicyToken(cloudAccessPolicyToken)
            .stackId(k6Stack.id())
            .grafanaSaToken(k6SaToken.key())
            .grafanaUser("admin")
            .build());

        var myK6Project = new Project("myK6Project", ProjectArgs.builder()
            .name("k6 Project created with TF")
            .build());

    }
}

configuration:
  cloudAccessPolicyToken:
    type: dynamic
  stackSlug:
    type: dynamic
  cloudRegion:
    type: string
    default: us
resources:
  k6Stack:
    type: grafana:cloud:Stack
    name: k6_stack
    properties:
      name: ${stackSlug}
      slug: ${stackSlug}
      regionSlug: ${cloudRegion}
  # Step 2: Create a Service Account and a token to install the k6 App
  k6Sa:
    type: grafana:cloud:StackServiceAccount
    name: k6_sa
    properties:
      stackSlug: ${stackSlug}
      name: ${stackSlug}-k6-app
      role: Admin
      isDisabled: false
  k6SaToken:
    type: grafana:cloud:StackServiceAccountToken
    name: k6_sa_token
    properties:
      stackSlug: ${stackSlug}
      name: ${stackSlug}-k6-app-token
      serviceAccountId: ${k6Sa.id}
  # Step 3: Install the k6 App on the stack
  k6Installation:
    type: grafana:k6:Installation
    name: k6_installation
    properties:
      cloudAccessPolicyToken: ${cloudAccessPolicyToken}
      stackId: ${k6Stack.id}
      grafanaSaToken: ${k6SaToken.key}
      grafanaUser: admin
  myK6Project:
    type: grafana:k6:Project
    name: my_k6_project
    properties:
      name: k6 Project created with TF

var installationResource = new Grafana.K6.Installation("installationResource", new()
{
    CloudAccessPolicyToken = "string",
    GrafanaSaToken = "string",
    GrafanaUser = "string",
    StackId = "string",
});

example, err := k6.NewInstallation(ctx, "installationResource", &k6.InstallationArgs{
	CloudAccessPolicyToken: pulumi.String("string"),
	GrafanaSaToken:         pulumi.String("string"),
	GrafanaUser:            pulumi.String("string"),
	StackId:                pulumi.String("string"),
})

var installationResource = new com.pulumi.grafana.k6.Installation("installationResource", com.pulumi.grafana.k6.InstallationArgs.builder()
    .cloudAccessPolicyToken("string")
    .grafanaSaToken("string")
    .grafanaUser("string")
    .stackId("string")
    .build());

installation_resource = grafana.k6.Installation("installationResource",
    cloud_access_policy_token="string",
    grafana_sa_token="string",
    grafana_user="string",
    stack_id="string")

const installationResource = new grafana.k6.Installation("installationResource", {
    cloudAccessPolicyToken: "string",
    grafanaSaToken: "string",
    grafanaUser: "string",
    stackId: "string",
});

type: grafana:k6:Installation
properties:
    cloudAccessPolicyToken: string
    grafanaSaToken: string
    grafanaUser: string
    stackId: string