databricks.MwsCredentials

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

const config = new pulumi.Config();
// Account Id that could be found in the top right corner of https://accounts.cloud.databricks.com/
const databricksAccountId = config.requireObject("databricksAccountId");
// Names of created resources will be prefixed with this value
const prefix = config.requireObject("prefix");
const this = databricks.getAwsAssumeRolePolicy({
    externalId: databricksAccountId,
});
const crossAccountRole = new aws.iam.Role("cross_account_role", {
    name: `${prefix}-crossaccount`,
    assumeRolePolicy: _this.then(_this => _this.json),
    tags: tags,
});
const thisGetAwsCrossAccountPolicy = databricks.getAwsCrossAccountPolicy({});
const thisRolePolicy = new aws.iam.RolePolicy("this", {
    name: `${prefix}-policy`,
    role: crossAccountRole.id,
    policy: thisGetAwsCrossAccountPolicy.then(thisGetAwsCrossAccountPolicy => thisGetAwsCrossAccountPolicy.json),
});
const thisMwsCredentials = new databricks.MwsCredentials("this", {
    credentialsName: `${prefix}-creds`,
    roleArn: crossAccountRole.arn,
});

import pulumi
import pulumi_aws as aws
import pulumi_databricks as databricks

config = pulumi.Config()
# Account Id that could be found in the top right corner of https://accounts.cloud.databricks.com/
databricks_account_id = config.require_object("databricksAccountId")
# Names of created resources will be prefixed with this value
prefix = config.require_object("prefix")
this = databricks.get_aws_assume_role_policy(external_id=databricks_account_id)
cross_account_role = aws.iam.Role("cross_account_role",
    name=f"{prefix}-crossaccount",
    assume_role_policy=this.json,
    tags=tags)
this_get_aws_cross_account_policy = databricks.get_aws_cross_account_policy()
this_role_policy = aws.iam.RolePolicy("this",
    name=f"{prefix}-policy",
    role=cross_account_role.id,
    policy=this_get_aws_cross_account_policy.json)
this_mws_credentials = databricks.MwsCredentials("this",
    credentials_name=f"{prefix}-creds",
    role_arn=cross_account_role.arn)

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		// Account Id that could be found in the top right corner of https://accounts.cloud.databricks.com/
		databricksAccountId := cfg.RequireObject("databricksAccountId")
		// Names of created resources will be prefixed with this value
		prefix := cfg.RequireObject("prefix")
		this, err := databricks.GetAwsAssumeRolePolicy(ctx, &databricks.GetAwsAssumeRolePolicyArgs{
			ExternalId: databricksAccountId,
		}, nil)
		if err != nil {
			return err
		}
		crossAccountRole, err := iam.NewRole(ctx, "cross_account_role", &iam.RoleArgs{
			Name:             pulumi.Sprintf("%v-crossaccount", prefix),
			AssumeRolePolicy: pulumi.String(this.Json),
			Tags:             pulumi.Any(tags),
		})
		if err != nil {
			return err
		}
		thisGetAwsCrossAccountPolicy, err := databricks.GetAwsCrossAccountPolicy(ctx, &databricks.GetAwsCrossAccountPolicyArgs{}, nil)
		if err != nil {
			return err
		}
		_, err = iam.NewRolePolicy(ctx, "this", &iam.RolePolicyArgs{
			Name:   pulumi.Sprintf("%v-policy", prefix),
			Role:   crossAccountRole.ID(),
			Policy: pulumi.String(thisGetAwsCrossAccountPolicy.Json),
		})
		if err != nil {
			return err
		}
		_, err = databricks.NewMwsCredentials(ctx, "this", &databricks.MwsCredentialsArgs{
			CredentialsName: pulumi.Sprintf("%v-creds", prefix),
			RoleArn:         crossAccountRole.Arn,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Databricks = Pulumi.Databricks;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    // Account Id that could be found in the top right corner of https://accounts.cloud.databricks.com/
    var databricksAccountId = config.RequireObject<dynamic>("databricksAccountId");
    // Names of created resources will be prefixed with this value
    var prefix = config.RequireObject<dynamic>("prefix");
    var @this = Databricks.GetAwsAssumeRolePolicy.Invoke(new()
    {
        ExternalId = databricksAccountId,
    });

    var crossAccountRole = new Aws.Iam.Role("cross_account_role", new()
    {
        Name = $"{prefix}-crossaccount",
        AssumeRolePolicy = @this.Apply(@this => @this.Apply(getAwsAssumeRolePolicyResult => getAwsAssumeRolePolicyResult.Json)),
        Tags = tags,
    });

    var thisGetAwsCrossAccountPolicy = Databricks.GetAwsCrossAccountPolicy.Invoke();

    var thisRolePolicy = new Aws.Iam.RolePolicy("this", new()
    {
        Name = $"{prefix}-policy",
        Role = crossAccountRole.Id,
        Policy = thisGetAwsCrossAccountPolicy.Apply(getAwsCrossAccountPolicyResult => getAwsCrossAccountPolicyResult.Json),
    });

    var thisMwsCredentials = new Databricks.MwsCredentials("this", new()
    {
        CredentialsName = $"{prefix}-creds",
        RoleArn = crossAccountRole.Arn,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.DatabricksFunctions;
import com.pulumi.databricks.inputs.GetAwsAssumeRolePolicyArgs;
import com.pulumi.aws.iam.Role;
import com.pulumi.aws.iam.RoleArgs;
import com.pulumi.databricks.inputs.GetAwsCrossAccountPolicyArgs;
import com.pulumi.aws.iam.RolePolicy;
import com.pulumi.aws.iam.RolePolicyArgs;
import com.pulumi.databricks.MwsCredentials;
import com.pulumi.databricks.MwsCredentialsArgs;
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 databricksAccountId = config.get("databricksAccountId");
        final var prefix = config.get("prefix");
        final var this = DatabricksFunctions.getAwsAssumeRolePolicy(GetAwsAssumeRolePolicyArgs.builder()
            .externalId(databricksAccountId)
            .build());

        var crossAccountRole = new Role("crossAccountRole", RoleArgs.builder()
            .name(String.format("%s-crossaccount", prefix))
            .assumeRolePolicy(this_.json())
            .tags(tags)
            .build());

        final var thisGetAwsCrossAccountPolicy = DatabricksFunctions.getAwsCrossAccountPolicy();

        var thisRolePolicy = new RolePolicy("thisRolePolicy", RolePolicyArgs.builder()
            .name(String.format("%s-policy", prefix))
            .role(crossAccountRole.id())
            .policy(thisGetAwsCrossAccountPolicy.applyValue(getAwsCrossAccountPolicyResult -> getAwsCrossAccountPolicyResult.json()))
            .build());

        var thisMwsCredentials = new MwsCredentials("thisMwsCredentials", MwsCredentialsArgs.builder()
            .credentialsName(String.format("%s-creds", prefix))
            .roleArn(crossAccountRole.arn())
            .build());

    }
}

configuration:
  databricksAccountId:
    type: dynamic
  prefix:
    type: dynamic
resources:
  crossAccountRole:
    type: aws:iam:Role
    name: cross_account_role
    properties:
      name: ${prefix}-crossaccount
      assumeRolePolicy: ${this.json}
      tags: ${tags}
  thisRolePolicy:
    type: aws:iam:RolePolicy
    name: this
    properties:
      name: ${prefix}-policy
      role: ${crossAccountRole.id}
      policy: ${thisGetAwsCrossAccountPolicy.json}
  thisMwsCredentials:
    type: databricks:MwsCredentials
    name: this
    properties:
      credentialsName: ${prefix}-creds
      roleArn: ${crossAccountRole.arn}
variables:
  this:
    fn::invoke:
      Function: databricks:getAwsAssumeRolePolicy
      Arguments:
        externalId: ${databricksAccountId}
  thisGetAwsCrossAccountPolicy:
    fn::invoke:
      Function: databricks:getAwsCrossAccountPolicy
      Arguments: {}

var mwsCredentialsResource = new Databricks.MwsCredentials("mwsCredentialsResource", new()
{
    CredentialsName = "string",
    RoleArn = "string",
    CreationTime = 0,
    CredentialsId = "string",
    ExternalId = "string",
});

example, err := databricks.NewMwsCredentials(ctx, "mwsCredentialsResource", &databricks.MwsCredentialsArgs{
	CredentialsName: pulumi.String("string"),
	RoleArn:         pulumi.String("string"),
	CreationTime:    pulumi.Int(0),
	CredentialsId:   pulumi.String("string"),
	ExternalId:      pulumi.String("string"),
})

var mwsCredentialsResource = new MwsCredentials("mwsCredentialsResource", MwsCredentialsArgs.builder()
    .credentialsName("string")
    .roleArn("string")
    .creationTime(0)
    .credentialsId("string")
    .externalId("string")
    .build());

mws_credentials_resource = databricks.MwsCredentials("mwsCredentialsResource",
    credentials_name="string",
    role_arn="string",
    creation_time=0,
    credentials_id="string",
    external_id="string")

const mwsCredentialsResource = new databricks.MwsCredentials("mwsCredentialsResource", {
    credentialsName: "string",
    roleArn: "string",
    creationTime: 0,
    credentialsId: "string",
    externalId: "string",
});

type: databricks:MwsCredentials
properties:
    creationTime: 0
    credentialsId: string
    credentialsName: string
    externalId: string
    roleArn: string