databricks.MwsStorageConfigurations

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");
const rootStorageBucket = new aws.s3.BucketV2("root_storage_bucket", {
    bucket: `${prefix}-rootbucket`,
    acl: "private",
});
const rootVersioning = new aws.s3.BucketVersioningV2("root_versioning", {
    bucket: rootStorageBucket.id,
    versioningConfiguration: {
        status: "Disabled",
    },
});
const _this = new databricks.MwsStorageConfigurations("this", {
    accountId: databricksAccountId,
    storageConfigurationName: `${prefix}-storage`,
    bucketName: rootStorageBucket.bucket,
});

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")
root_storage_bucket = aws.s3.BucketV2("root_storage_bucket",
    bucket=f"{prefix}-rootbucket",
    acl="private")
root_versioning = aws.s3.BucketVersioningV2("root_versioning",
    bucket=root_storage_bucket.id,
    versioning_configuration={
        "status": "Disabled",
    })
this = databricks.MwsStorageConfigurations("this",
    account_id=databricks_account_id,
    storage_configuration_name=f"{prefix}-storage",
    bucket_name=root_storage_bucket.bucket)

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
	"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")
		rootStorageBucket, err := s3.NewBucketV2(ctx, "root_storage_bucket", &s3.BucketV2Args{
			Bucket: pulumi.Sprintf("%v-rootbucket", prefix),
			Acl:    pulumi.String("private"),
		})
		if err != nil {
			return err
		}
		_, err = s3.NewBucketVersioningV2(ctx, "root_versioning", &s3.BucketVersioningV2Args{
			Bucket: rootStorageBucket.ID(),
			VersioningConfiguration: &s3.BucketVersioningV2VersioningConfigurationArgs{
				Status: pulumi.String("Disabled"),
			},
		})
		if err != nil {
			return err
		}
		_, err = databricks.NewMwsStorageConfigurations(ctx, "this", &databricks.MwsStorageConfigurationsArgs{
			AccountId:                pulumi.Any(databricksAccountId),
			StorageConfigurationName: pulumi.Sprintf("%v-storage", prefix),
			BucketName:               rootStorageBucket.Bucket,
		})
		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");
    var rootStorageBucket = new Aws.S3.BucketV2("root_storage_bucket", new()
    {
        Bucket = $"{prefix}-rootbucket",
        Acl = "private",
    });

    var rootVersioning = new Aws.S3.BucketVersioningV2("root_versioning", new()
    {
        Bucket = rootStorageBucket.Id,
        VersioningConfiguration = new Aws.S3.Inputs.BucketVersioningV2VersioningConfigurationArgs
        {
            Status = "Disabled",
        },
    });

    var @this = new Databricks.MwsStorageConfigurations("this", new()
    {
        AccountId = databricksAccountId,
        StorageConfigurationName = $"{prefix}-storage",
        BucketName = rootStorageBucket.Bucket,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketV2;
import com.pulumi.aws.s3.BucketV2Args;
import com.pulumi.aws.s3.BucketVersioningV2;
import com.pulumi.aws.s3.BucketVersioningV2Args;
import com.pulumi.aws.s3.inputs.BucketVersioningV2VersioningConfigurationArgs;
import com.pulumi.databricks.MwsStorageConfigurations;
import com.pulumi.databricks.MwsStorageConfigurationsArgs;
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");
        var rootStorageBucket = new BucketV2("rootStorageBucket", BucketV2Args.builder()
            .bucket(String.format("%s-rootbucket", prefix))
            .acl("private")
            .build());

        var rootVersioning = new BucketVersioningV2("rootVersioning", BucketVersioningV2Args.builder()
            .bucket(rootStorageBucket.id())
            .versioningConfiguration(BucketVersioningV2VersioningConfigurationArgs.builder()
                .status("Disabled")
                .build())
            .build());

        var this_ = new MwsStorageConfigurations("this", MwsStorageConfigurationsArgs.builder()
            .accountId(databricksAccountId)
            .storageConfigurationName(String.format("%s-storage", prefix))
            .bucketName(rootStorageBucket.bucket())
            .build());

    }
}

configuration:
  databricksAccountId:
    type: dynamic
resources:
  rootStorageBucket:
    type: aws:s3:BucketV2
    name: root_storage_bucket
    properties:
      bucket: ${prefix}-rootbucket
      acl: private
  rootVersioning:
    type: aws:s3:BucketVersioningV2
    name: root_versioning
    properties:
      bucket: ${rootStorageBucket.id}
      versioningConfiguration:
        status: Disabled
  this:
    type: databricks:MwsStorageConfigurations
    properties:
      accountId: ${databricksAccountId}
      storageConfigurationName: ${prefix}-storage
      bucketName: ${rootStorageBucket.bucket}

var mwsStorageConfigurationsResource = new Databricks.MwsStorageConfigurations("mwsStorageConfigurationsResource", new()
{
    AccountId = "string",
    BucketName = "string",
    StorageConfigurationName = "string",
});

example, err := databricks.NewMwsStorageConfigurations(ctx, "mwsStorageConfigurationsResource", &databricks.MwsStorageConfigurationsArgs{
	AccountId:                pulumi.String("string"),
	BucketName:               pulumi.String("string"),
	StorageConfigurationName: pulumi.String("string"),
})

var mwsStorageConfigurationsResource = new MwsStorageConfigurations("mwsStorageConfigurationsResource", MwsStorageConfigurationsArgs.builder()
    .accountId("string")
    .bucketName("string")
    .storageConfigurationName("string")
    .build());

mws_storage_configurations_resource = databricks.MwsStorageConfigurations("mwsStorageConfigurationsResource",
    account_id="string",
    bucket_name="string",
    storage_configuration_name="string")

const mwsStorageConfigurationsResource = new databricks.MwsStorageConfigurations("mwsStorageConfigurationsResource", {
    accountId: "string",
    bucketName: "string",
    storageConfigurationName: "string",
});

type: databricks:MwsStorageConfigurations
properties:
    accountId: string
    bucketName: string
    storageConfigurationName: string