grafana.RoleAssignment

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Grafana = Lbrlabs.PulumiPackage.Grafana;

return await Deployment.RunAsync(() => 
{
    var testRole = new Grafana.Role("testRole", new()
    {
        Uid = "testrole",
        Version = 1,
        Global = true,
        Permissions = new[]
        {
            new Grafana.Inputs.RolePermissionArgs
            {
                Action = "org.users:add",
                Scope = "users:*",
            },
        },
    });

    var testTeam = new Grafana.Team("testTeam");

    var testUser = new Grafana.User("testUser", new()
    {
        Email = "terraform_user@test.com",
        Login = "terraform_user@test.com",
        Password = "password",
    });

    var testSa = new Grafana.ServiceAccount("testSa", new()
    {
        Role = "Viewer",
    });

    var test = new Grafana.RoleAssignment("test", new()
    {
        RoleUid = testRole.Uid,
        Users = new[]
        {
            testUser.Id,
        },
        Teams = new[]
        {
            testTeam.Id,
        },
        ServiceAccounts = new[]
        {
            testSa.Id,
        },
    });

});

package main

import (
	"github.com/lbrlabs/pulumi-grafana/sdk/go/grafana"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testRole, err := grafana.NewRole(ctx, "testRole", &grafana.RoleArgs{
			Uid:     pulumi.String("testrole"),
			Version: pulumi.Int(1),
			Global:  pulumi.Bool(true),
			Permissions: grafana.RolePermissionArray{
				&grafana.RolePermissionArgs{
					Action: pulumi.String("org.users:add"),
					Scope:  pulumi.String("users:*"),
				},
			},
		})
		if err != nil {
			return err
		}
		testTeam, err := grafana.NewTeam(ctx, "testTeam", nil)
		if err != nil {
			return err
		}
		testUser, err := grafana.NewUser(ctx, "testUser", &grafana.UserArgs{
			Email:    pulumi.String("terraform_user@test.com"),
			Login:    pulumi.String("terraform_user@test.com"),
			Password: pulumi.String("password"),
		})
		if err != nil {
			return err
		}
		testSa, err := grafana.NewServiceAccount(ctx, "testSa", &grafana.ServiceAccountArgs{
			Role: pulumi.String("Viewer"),
		})
		if err != nil {
			return err
		}
		_, err = grafana.NewRoleAssignment(ctx, "test", &grafana.RoleAssignmentArgs{
			RoleUid: testRole.Uid,
			Users: pulumi.IntArray{
				testUser.ID(),
			},
			Teams: pulumi.IntArray{
				testTeam.ID(),
			},
			ServiceAccounts: pulumi.IntArray{
				testSa.ID(),
			},
		})
		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.grafana.Role;
import com.pulumi.grafana.RoleArgs;
import com.pulumi.grafana.inputs.RolePermissionArgs;
import com.pulumi.grafana.Team;
import com.pulumi.grafana.User;
import com.pulumi.grafana.UserArgs;
import com.pulumi.grafana.ServiceAccount;
import com.pulumi.grafana.ServiceAccountArgs;
import com.pulumi.grafana.RoleAssignment;
import com.pulumi.grafana.RoleAssignmentArgs;
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 testRole = new Role("testRole", RoleArgs.builder()        
            .uid("testrole")
            .version(1)
            .global(true)
            .permissions(RolePermissionArgs.builder()
                .action("org.users:add")
                .scope("users:*")
                .build())
            .build());

        var testTeam = new Team("testTeam");

        var testUser = new User("testUser", UserArgs.builder()        
            .email("terraform_user@test.com")
            .login("terraform_user@test.com")
            .password("password")
            .build());

        var testSa = new ServiceAccount("testSa", ServiceAccountArgs.builder()        
            .role("Viewer")
            .build());

        var test = new RoleAssignment("test", RoleAssignmentArgs.builder()        
            .roleUid(testRole.uid())
            .users(testUser.id())
            .teams(testTeam.id())
            .serviceAccounts(testSa.id())
            .build());

    }
}

import pulumi
import lbrlabs_pulumi_grafana as grafana

test_role = grafana.Role("testRole",
    uid="testrole",
    version=1,
    global_=True,
    permissions=[grafana.RolePermissionArgs(
        action="org.users:add",
        scope="users:*",
    )])
test_team = grafana.Team("testTeam")
test_user = grafana.User("testUser",
    email="terraform_user@test.com",
    login="terraform_user@test.com",
    password="password")
test_sa = grafana.ServiceAccount("testSa", role="Viewer")
test = grafana.RoleAssignment("test",
    role_uid=test_role.uid,
    users=[test_user.id],
    teams=[test_team.id],
    service_accounts=[test_sa.id])

import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@lbrlabs/pulumi-grafana";

const testRole = new grafana.Role("testRole", {
    uid: "testrole",
    version: 1,
    global: true,
    permissions: [{
        action: "org.users:add",
        scope: "users:*",
    }],
});
const testTeam = new grafana.Team("testTeam", {});
const testUser = new grafana.User("testUser", {
    email: "terraform_user@test.com",
    login: "terraform_user@test.com",
    password: "password",
});
const testSa = new grafana.ServiceAccount("testSa", {role: "Viewer"});
const test = new grafana.RoleAssignment("test", {
    roleUid: testRole.uid,
    users: [testUser.id],
    teams: [testTeam.id],
    serviceAccounts: [testSa.id],
});

resources:
  testRole:
    type: grafana:Role
    properties:
      uid: testrole
      version: 1
      global: true
      permissions:
        - action: org.users:add
          scope: users:*
  testTeam:
    type: grafana:Team
  testUser:
    type: grafana:User
    properties:
      email: terraform_user@test.com
      login: terraform_user@test.com
      password: password
  testSa:
    type: grafana:ServiceAccount
    properties:
      role: Viewer
  test:
    type: grafana:RoleAssignment
    properties:
      roleUid: ${testRole.uid}
      users:
        - ${testUser.id}
      teams:
        - ${testTeam.id}
      serviceAccounts:
        - ${testSa.id}