databricks.Secret

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

return await Deployment.RunAsync(() => 
{
    var app = new Databricks.SecretScope("app");

    var publishingApi = new Databricks.Secret("publishingApi", new()
    {
        Key = "publishing_api",
        StringValue = data.Azurerm_key_vault_secret.Example.Value,
        Scope = app.Id,
    });

    var @this = new Databricks.Cluster("this", new()
    {
        SparkConf = 
        {
            { "fs.azure.account.oauth2.client.secret", publishingApi.ConfigReference },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		app, err := databricks.NewSecretScope(ctx, "app", nil)
		if err != nil {
			return err
		}
		publishingApi, err := databricks.NewSecret(ctx, "publishingApi", &databricks.SecretArgs{
			Key:         pulumi.String("publishing_api"),
			StringValue: pulumi.Any(data.Azurerm_key_vault_secret.Example.Value),
			Scope:       app.ID(),
		})
		if err != nil {
			return err
		}
		_, err = databricks.NewCluster(ctx, "this", &databricks.ClusterArgs{
			SparkConf: pulumi.AnyMap{
				"fs.azure.account.oauth2.client.secret": publishingApi.ConfigReference,
			},
		})
		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.databricks.SecretScope;
import com.pulumi.databricks.Secret;
import com.pulumi.databricks.SecretArgs;
import com.pulumi.databricks.Cluster;
import com.pulumi.databricks.ClusterArgs;
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 app = new SecretScope("app");

        var publishingApi = new Secret("publishingApi", SecretArgs.builder()        
            .key("publishing_api")
            .stringValue(data.azurerm_key_vault_secret().example().value())
            .scope(app.id())
            .build());

        var this_ = new Cluster("this", ClusterArgs.builder()        
            .sparkConf(Map.of("fs.azure.account.oauth2.client.secret", publishingApi.configReference()))
            .build());

    }
}

import pulumi
import pulumi_databricks as databricks

app = databricks.SecretScope("app")
publishing_api = databricks.Secret("publishingApi",
    key="publishing_api",
    string_value=data["azurerm_key_vault_secret"]["example"]["value"],
    scope=app.id)
this = databricks.Cluster("this", spark_conf={
    "fs.azure.account.oauth2.client.secret": publishing_api.config_reference,
})

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

const app = new databricks.SecretScope("app", {});
const publishingApi = new databricks.Secret("publishingApi", {
    key: "publishing_api",
    stringValue: data.azurerm_key_vault_secret.example.value,
    scope: app.id,
});
const _this = new databricks.Cluster("this", {sparkConf: {
    "fs.azure.account.oauth2.client.secret": publishingApi.configReference,
}});

resources:
  app:
    type: databricks:SecretScope
  publishingApi:
    type: databricks:Secret
    properties:
      key: publishing_api
      stringValue: ${data.azurerm_key_vault_secret.example.value}
      scope: ${app.id}
  this:
    type: databricks:Cluster
    properties:
      # ...
      sparkConf:
        fs.azure.account.oauth2.client.secret: ${publishingApi.configReference}