databricks.SecretAcl

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

const ds = new databricks.Group("ds", {displayName: "data-scientists"});
const app = new databricks.SecretScope("app", {name: "app-secret-scope"});
const mySecretAcl = new databricks.SecretAcl("my_secret_acl", {
    principal: ds.displayName,
    permission: "READ",
    scope: app.name,
});
const publishingApi = new databricks.Secret("publishing_api", {
    key: "publishing_api",
    stringValue: example.value,
    scope: app.name,
});

import pulumi
import pulumi_databricks as databricks

ds = databricks.Group("ds", display_name="data-scientists")
app = databricks.SecretScope("app", name="app-secret-scope")
my_secret_acl = databricks.SecretAcl("my_secret_acl",
    principal=ds.display_name,
    permission="READ",
    scope=app.name)
publishing_api = databricks.Secret("publishing_api",
    key="publishing_api",
    string_value=example["value"],
    scope=app.name)

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 {
		ds, err := databricks.NewGroup(ctx, "ds", &databricks.GroupArgs{
			DisplayName: pulumi.String("data-scientists"),
		})
		if err != nil {
			return err
		}
		app, err := databricks.NewSecretScope(ctx, "app", &databricks.SecretScopeArgs{
			Name: pulumi.String("app-secret-scope"),
		})
		if err != nil {
			return err
		}
		_, err = databricks.NewSecretAcl(ctx, "my_secret_acl", &databricks.SecretAclArgs{
			Principal:  ds.DisplayName,
			Permission: pulumi.String("READ"),
			Scope:      app.Name,
		})
		if err != nil {
			return err
		}
		_, err = databricks.NewSecret(ctx, "publishing_api", &databricks.SecretArgs{
			Key:         pulumi.String("publishing_api"),
			StringValue: pulumi.Any(example.Value),
			Scope:       app.Name,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var ds = new Databricks.Group("ds", new()
    {
        DisplayName = "data-scientists",
    });

    var app = new Databricks.SecretScope("app", new()
    {
        Name = "app-secret-scope",
    });

    var mySecretAcl = new Databricks.SecretAcl("my_secret_acl", new()
    {
        Principal = ds.DisplayName,
        Permission = "READ",
        Scope = app.Name,
    });

    var publishingApi = new Databricks.Secret("publishing_api", new()
    {
        Key = "publishing_api",
        StringValue = example.Value,
        Scope = app.Name,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.Group;
import com.pulumi.databricks.GroupArgs;
import com.pulumi.databricks.SecretScope;
import com.pulumi.databricks.SecretScopeArgs;
import com.pulumi.databricks.SecretAcl;
import com.pulumi.databricks.SecretAclArgs;
import com.pulumi.databricks.Secret;
import com.pulumi.databricks.SecretArgs;
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 ds = new Group("ds", GroupArgs.builder()
            .displayName("data-scientists")
            .build());

        var app = new SecretScope("app", SecretScopeArgs.builder()
            .name("app-secret-scope")
            .build());

        var mySecretAcl = new SecretAcl("mySecretAcl", SecretAclArgs.builder()
            .principal(ds.displayName())
            .permission("READ")
            .scope(app.name())
            .build());

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

    }
}

resources:
  ds:
    type: databricks:Group
    properties:
      displayName: data-scientists
  app:
    type: databricks:SecretScope
    properties:
      name: app-secret-scope
  mySecretAcl:
    type: databricks:SecretAcl
    name: my_secret_acl
    properties:
      principal: ${ds.displayName}
      permission: READ
      scope: ${app.name}
  publishingApi:
    type: databricks:Secret
    name: publishing_api
    properties:
      key: publishing_api
      stringValue: ${example.value}
      scope: ${app.name}

var secretAclResource = new Databricks.SecretAcl("secretAclResource", new()
{
    Permission = "string",
    Principal = "string",
    Scope = "string",
});

example, err := databricks.NewSecretAcl(ctx, "secretAclResource", &databricks.SecretAclArgs{
	Permission: pulumi.String("string"),
	Principal:  pulumi.String("string"),
	Scope:      pulumi.String("string"),
})

var secretAclResource = new SecretAcl("secretAclResource", SecretAclArgs.builder()
    .permission("string")
    .principal("string")
    .scope("string")
    .build());

secret_acl_resource = databricks.SecretAcl("secretAclResource",
    permission="string",
    principal="string",
    scope="string")

const secretAclResource = new databricks.SecretAcl("secretAclResource", {
    permission: "string",
    principal: "string",
    scope: "string",
});

type: databricks:SecretAcl
properties:
    permission: string
    principal: string
    scope: string