Workspace class

Provides an Amazon Managed Grafana workspace resource.

Example Usage

Basic configuration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const assume = new aws.iam.Role("assume", {
    name: "grafana-assume",
    assumeRolePolicy: JSON.stringify({
        Version: "2012-10-17",
        Statement: [{
            Action: "sts:AssumeRole",
            Effect: "Allow",
            Sid: "",
            Principal: {
                Service: "grafana.amazonaws.com",
            },
        }],
    }),
});
const example = new aws.grafana.Workspace("example", {
    accountAccessType: "CURRENT_ACCOUNT",
    authenticationProviders: ["SAML"],
    permissionType: "SERVICE_MANAGED",
    roleArn: assume.arn,
});
import pulumi
import json
import pulumi_aws as aws

assume = aws.iam.Role("assume",
    name="grafana-assume",
    assume_role_policy=json.dumps({
        "Version": "2012-10-17",
        "Statement": [{
            "Action": "sts:AssumeRole",
            "Effect": "Allow",
            "Sid": "",
            "Principal": {
                "Service": "grafana.amazonaws.com",
            },
        }],
    }))
example = aws.grafana.Workspace("example",
    account_access_type="CURRENT_ACCOUNT",
    authentication_providers=["SAML"],
    permission_type="SERVICE_MANAGED",
    role_arn=assume.arn)
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var assume = new Aws.Iam.Role("assume", new()
    {
        Name = "grafana-assume",
        AssumeRolePolicy = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Version"] = "2012-10-17",
            ["Statement"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Action"] = "sts:AssumeRole",
                    ["Effect"] = "Allow",
                    ["Sid"] = "",
                    ["Principal"] = new Dictionary<string, object?>
                    {
                        ["Service"] = "grafana.amazonaws.com",
                    },
                },
            },
        }),
    });

    var example = new Aws.Grafana.Workspace("example", new()
    {
        AccountAccessType = "CURRENT_ACCOUNT",
        AuthenticationProviders = new[]
        {
            "SAML",
        },
        PermissionType = "SERVICE_MANAGED",
        RoleArn = assume.Arn,
    });

});
package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/grafana"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Action": "sts:AssumeRole",
					"Effect": "Allow",
					"Sid":    "",
					"Principal": map[string]string{
						"Service": "grafana.amazonaws.com",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		assume, err := iam.NewRole(ctx, "assume", &iam.RoleArgs{
			Name:             pulumi.String("grafana-assume"),
			AssumeRolePolicy: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		_, err = grafana.NewWorkspace(ctx, "example", &grafana.WorkspaceArgs{
			AccountAccessType: pulumi.String("CURRENT_ACCOUNT"),
			AuthenticationProviders: pulumi.StringArray{
				pulumi.String("SAML"),
			},
			PermissionType: pulumi.String("SERVICE_MANAGED"),
			RoleArn:        assume.Arn,
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_grafana_workspace" "example" {
  account_access_type      = "CURRENT_ACCOUNT"
  authentication_providers = ["SAML"]
  permission_type          = "SERVICE_MANAGED"
  role_arn                 = aws_iam_role.assume.arn
}
resource "aws_iam_role" "assume" {
  name = "grafana-assume"
  assume_role_policy = jsonencode({
    "Version" = "2012-10-17"
    "Statement" = [{
      "Action" = "sts:AssumeRole"
      "Effect" = "Allow"
      "Sid"    = ""
      "Principal" = {
        "Service" = "grafana.amazonaws.com"
      }
    }]
  })
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.iam.Role;
import com.pulumi.aws.iam.RoleArgs;
import com.pulumi.aws.grafana.Workspace;
import com.pulumi.aws.grafana.WorkspaceArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.ArrayList;
import java.util.Arrays;
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 assume = new Role("assume", RoleArgs.builder()
            .name("grafana-assume")
            .assumeRolePolicy(serializeJson(
                jsonObject(
                    jsonProperty("Version", "2012-10-17"),
                    jsonProperty("Statement", jsonArray(jsonObject(
                        jsonProperty("Action", "sts:AssumeRole"),
                        jsonProperty("Effect", "Allow"),
                        jsonProperty("Sid", ""),
                        jsonProperty("Principal", jsonObject(
                            jsonProperty("Service", "grafana.amazonaws.com")
                        ))
                    )))
                )))
            .build());

        var example = new Workspace("example", WorkspaceArgs.builder()
            .accountAccessType("CURRENT_ACCOUNT")
            .authenticationProviders("SAML")
            .permissionType("SERVICE_MANAGED")
            .roleArn(assume.arn())
            .build());

    }
}
resources:
  example:
    type: aws:grafana:Workspace
    properties:
      accountAccessType: CURRENT_ACCOUNT
      authenticationProviders:
        - SAML
      permissionType: SERVICE_MANAGED
      roleArn: ${assume.arn}
  assume:
    type: aws:iam:Role
    properties:
      name: grafana-assume
      assumeRolePolicy:
        fn::toJSON:
          Version: 2012-10-17
          Statement:
            - Action: sts:AssumeRole
              Effect: Allow
              Sid: ""
              Principal:
                Service: grafana.amazonaws.com

Workspace configuration options

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.grafana.Workspace("example", {
    accountAccessType: "CURRENT_ACCOUNT",
    authenticationProviders: ["SAML"],
    permissionType: "SERVICE_MANAGED",
    roleArn: assume.arn,
    configuration: JSON.stringify({
        plugins: {
            pluginAdminEnabled: true,
        },
        unifiedAlerting: {
            enabled: false,
        },
    }),
});
import pulumi
import json
import pulumi_aws as aws

example = aws.grafana.Workspace("example",
    account_access_type="CURRENT_ACCOUNT",
    authentication_providers=["SAML"],
    permission_type="SERVICE_MANAGED",
    role_arn=assume["arn"],
    configuration=json.dumps({
        "plugins": {
            "pluginAdminEnabled": True,
        },
        "unifiedAlerting": {
            "enabled": False,
        },
    }))
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Grafana.Workspace("example", new()
    {
        AccountAccessType = "CURRENT_ACCOUNT",
        AuthenticationProviders = new[]
        {
            "SAML",
        },
        PermissionType = "SERVICE_MANAGED",
        RoleArn = assume.Arn,
        Configuration = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["plugins"] = new Dictionary<string, object?>
            {
                ["pluginAdminEnabled"] = true,
            },
            ["unifiedAlerting"] = new Dictionary<string, object?>
            {
                ["enabled"] = false,
            },
        }),
    });

});
package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/grafana"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]map[string]bool{
			"plugins": map[string]bool{
				"pluginAdminEnabled": true,
			},
			"unifiedAlerting": map[string]bool{
				"enabled": false,
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = grafana.NewWorkspace(ctx, "example", &grafana.WorkspaceArgs{
			AccountAccessType: pulumi.String("CURRENT_ACCOUNT"),
			AuthenticationProviders: pulumi.StringArray{
				pulumi.String("SAML"),
			},
			PermissionType: pulumi.String("SERVICE_MANAGED"),
			RoleArn:        pulumi.Any(assume.Arn),
			Configuration:  pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_grafana_workspace" "example" {
  account_access_type      = "CURRENT_ACCOUNT"
  authentication_providers = ["SAML"]
  permission_type          = "SERVICE_MANAGED"
  role_arn                 = assume.arn
  configuration = jsonencode({
    "plugins" = {
      "pluginAdminEnabled" = true
    }
    "unifiedAlerting" = {
      "enabled" = false
    }
  })
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.grafana.Workspace;
import com.pulumi.aws.grafana.WorkspaceArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new Workspace("example", WorkspaceArgs.builder()
            .accountAccessType("CURRENT_ACCOUNT")
            .authenticationProviders("SAML")
            .permissionType("SERVICE_MANAGED")
            .roleArn(assume.arn())
            .configuration(serializeJson(
                jsonObject(
                    jsonProperty("plugins", jsonObject(
                        jsonProperty("pluginAdminEnabled", true)
                    )),
                    jsonProperty("unifiedAlerting", jsonObject(
                        jsonProperty("enabled", false)
                    ))
                )))
            .build());

    }
}
resources:
  example:
    type: aws:grafana:Workspace
    properties:
      accountAccessType: CURRENT_ACCOUNT
      authenticationProviders:
        - SAML
      permissionType: SERVICE_MANAGED
      roleArn: ${assume.arn}
      configuration:
        fn::toJSON:
          plugins:
            pluginAdminEnabled: true
          unifiedAlerting:
            enabled: false

The optional argument configuration is a JSON string that disables the unified Grafana Alerting (Grafana version 10 or newer) and enables Plugin Management (Grafana version 9 or newer) on the Grafana Workspaces.

For more information about using Grafana alerting, and the effects of turning it on or off, see Alerts in Grafana version 10.

Import

Using pulumi import, import Grafana Workspace using the workspace's id. For example:

$ pulumi import aws:grafana/workspace:Workspace example g-2054c75a02

Constructors

Workspace(String name, {WorkspaceArgs? args, CustomResourceOptions? options})
Creates a new Workspace. name The Pulumi resource name. args Arguments used to configure this Workspace. The set of arguments for Workspace. options Resource options controlling this resource's behavior.
Workspace.reference(String urn)
Creates a typed reference to an existing Workspace resource.

Properties

accountAccessType ↔ Output<String>
The type of account access for the workspace. Valid values are CURRENT_ACCOUNT and ORGANIZATION. If ORGANIZATION is specified, then organizationalUnits must also be present.
latefinal
arn ↔ Output<String>
ARN of the Grafana workspace.
latefinal
authenticationProviders ↔ Output<List<String>>
The authentication providers for the workspace. Valid values are AWS_SSO, SAML, or both.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
configuration ↔ Output<String>
The configuration string for the workspace that you create. For more information about the format and configuration options available, see Working in your Grafana workspace.
latefinal
dataSources ↔ Output<List<String>?>
The data sources for the workspace. Valid values are AMAZON_OPENSEARCH_SERVICE, ATHENA, CLOUDWATCH, PROMETHEUS, REDSHIFT, SITEWISE, TIMESTREAM, TWINMAKER, XRAY
latefinal
description ↔ Output<String?>
The workspace description.
latefinal
endpoint ↔ Output<String>
The endpoint of the Grafana workspace.
latefinal
grafanaVersion ↔ Output<String>
Specifies the version of Grafana to support in the new workspace. Supported values are 9.4, 10.4 and 12.4. If not specified, defaults to the latest version.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
kmsKeyId ↔ Output<String>
The ARN of the AWS KMS key for encrypting workspace data.
latefinal
name ↔ Output<String>
The Grafana workspace name.
latefinal
networkAccessControl ↔ Output<WorkspaceNetworkAccessControl?>
Configuration for network access to your workspace.See Network Access Control below.
latefinal
notificationDestinations ↔ Output<List<String>?>
The notification destinations. If a data source is specified here, Amazon Managed Grafana will create IAM roles and permissions needed to use these destinations. Must be set to SNS.
latefinal
organizationalUnits ↔ Output<List<String>?>
The Amazon Organizations organizational units that the workspace is authorized to use data sources from.
latefinal
organizationRoleName ↔ Output<String?>
The role name that the workspace uses to access resources through Amazon Organizations.
latefinal
permissionType ↔ Output<String>
The permission type of the workspace. If SERVICE_MANAGED is specified, the IAM roles and IAM policy attachments are generated automatically. If CUSTOMER_MANAGED is specified, the IAM roles and IAM policy attachments will not be created.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
roleArn ↔ Output<String?>
The IAM role ARN that the workspace assumes.
latefinal
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
samlConfigurationStatus ↔ Output<String>
latefinal
stackSetName ↔ Output<String?>
The AWS CloudFormation stack set name that provisions IAM roles to be used by the workspace.
latefinal
tags ↔ Output<Map<String, String>?>
Key-value mapping of resource tags. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
vpcConfiguration ↔ Output<WorkspaceVpcConfiguration?>
The configuration settings for an Amazon VPC that contains data sources for your Grafana workspace to connect to. See VPC Configuration below.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {WorkspaceState? state, CustomResourceOptions? options}) → Workspace
Gets an existing Workspace resource's state with the given name and id.