pulumi-azure-native-kotlin/com.pulumi.azurenative.databricks.kotlin/Workspace

Workspace

class Workspace : KotlinCustomResource

Information about workspace. Azure REST API version: 2023-02-01. Prior API version in Azure Native 1.x: 2018-04-01.

Example Usage

Create a workspace which is ready for Customer-Managed Key (CMK) encryption

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var workspace = new AzureNative.Databricks.Workspace("workspace", new()
    {
        Location = "westus",
        ManagedResourceGroupId = "/subscriptions/subid/resourceGroups/myManagedRG",
        Parameters = new AzureNative.Databricks.Inputs.WorkspaceCustomParametersArgs
        {
            PrepareEncryption = new AzureNative.Databricks.Inputs.WorkspaceCustomBooleanParameterArgs
            {
                Value = true,
            },
        },
        ResourceGroupName = "rg",
        WorkspaceName = "myWorkspace",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/databricks/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databricks.NewWorkspace(ctx, "workspace", &databricks.WorkspaceArgs{
			Location:               pulumi.String("westus"),
			ManagedResourceGroupId: pulumi.String("/subscriptions/subid/resourceGroups/myManagedRG"),
			Parameters: databricks.WorkspaceCustomParametersResponse{
				PrepareEncryption: &databricks.WorkspaceCustomBooleanParameterArgs{
					Value: pulumi.Bool(true),
				},
			},
			ResourceGroupName: pulumi.String("rg"),
			WorkspaceName:     pulumi.String("myWorkspace"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.databricks.Workspace;
import com.pulumi.azurenative.databricks.WorkspaceArgs;
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 workspace = new Workspace("workspace", WorkspaceArgs.builder()
            .location("westus")
            .managedResourceGroupId("/subscriptions/subid/resourceGroups/myManagedRG")
            .parameters(Map.of("prepareEncryption", Map.of("value", true)))
            .resourceGroupName("rg")
            .workspaceName("myWorkspace")
            .build());
    }
}
Content copied to clipboard

Create a workspace with Customer-Managed Key (CMK) encryption for Managed Disks

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var workspace = new AzureNative.Databricks.Workspace("workspace", new()
    {
        Encryption = new AzureNative.Databricks.Inputs.WorkspacePropertiesEncryptionArgs
        {
            Entities = new AzureNative.Databricks.Inputs.EncryptionEntitiesDefinitionArgs
            {
                ManagedDisk = new AzureNative.Databricks.Inputs.ManagedDiskEncryptionArgs
                {
                    KeySource = "Microsoft.Keyvault",
                    KeyVaultProperties = new AzureNative.Databricks.Inputs.ManagedDiskEncryptionKeyVaultPropertiesArgs
                    {
                        KeyName = "test-cmk-key",
                        KeyVaultUri = "https://test-vault-name.vault.azure.net/",
                        KeyVersion = "00000000000000000000000000000000",
                    },
                    RotationToLatestKeyVersionEnabled = true,
                },
            },
        },
        Location = "westus",
        ManagedResourceGroupId = "/subscriptions/subid/resourceGroups/myManagedRG",
        ResourceGroupName = "rg",
        WorkspaceName = "myWorkspace",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/databricks/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := databricks.NewWorkspace(ctx, "workspace", &databricks.WorkspaceArgs{
Encryption: databricks.WorkspacePropertiesResponseEncryption{
Entities: interface{}{
ManagedDisk: interface{}{
KeySource: pulumi.String("Microsoft.Keyvault"),
KeyVaultProperties: &databricks.ManagedDiskEncryptionKeyVaultPropertiesArgs{
KeyName: pulumi.String("test-cmk-key"),
KeyVaultUri: pulumi.String("https://test-vault-name.vault.azure.net/"),
KeyVersion: pulumi.String("00000000000000000000000000000000"),
},
RotationToLatestKeyVersionEnabled: pulumi.Bool(true),
},
},
},
Location: pulumi.String("westus"),
ManagedResourceGroupId: pulumi.String("/subscriptions/subid/resourceGroups/myManagedRG"),
ResourceGroupName: pulumi.String("rg"),
WorkspaceName: pulumi.String("myWorkspace"),
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.databricks.Workspace;
import com.pulumi.azurenative.databricks.WorkspaceArgs;
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 workspace = new Workspace("workspace", WorkspaceArgs.builder()
            .encryption(Map.of("entities", Map.of("managedDisk", Map.ofEntries(
                Map.entry("keySource", "Microsoft.Keyvault"),
                Map.entry("keyVaultProperties", Map.ofEntries(
                    Map.entry("keyName", "test-cmk-key"),
                    Map.entry("keyVaultUri", "https://test-vault-name.vault.azure.net/"),
                    Map.entry("keyVersion", "00000000000000000000000000000000")
                )),
                Map.entry("rotationToLatestKeyVersionEnabled", true)
            ))))
            .location("westus")
            .managedResourceGroupId("/subscriptions/subid/resourceGroups/myManagedRG")
            .resourceGroupName("rg")
            .workspaceName("myWorkspace")
            .build());
    }
}
Content copied to clipboard

Create or update workspace

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var workspace = new AzureNative.Databricks.Workspace("workspace", new()
    {
        Location = "westus",
        ManagedResourceGroupId = "/subscriptions/subid/resourceGroups/myManagedRG",
        ResourceGroupName = "rg",
        WorkspaceName = "myWorkspace",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/databricks/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databricks.NewWorkspace(ctx, "workspace", &databricks.WorkspaceArgs{
			Location:               pulumi.String("westus"),
			ManagedResourceGroupId: pulumi.String("/subscriptions/subid/resourceGroups/myManagedRG"),
			ResourceGroupName:      pulumi.String("rg"),
			WorkspaceName:          pulumi.String("myWorkspace"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.databricks.Workspace;
import com.pulumi.azurenative.databricks.WorkspaceArgs;
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 workspace = new Workspace("workspace", WorkspaceArgs.builder()
            .location("westus")
            .managedResourceGroupId("/subscriptions/subid/resourceGroups/myManagedRG")
            .resourceGroupName("rg")
            .workspaceName("myWorkspace")
            .build());
    }
}
Content copied to clipboard

Create or update workspace with custom parameters

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var workspace = new AzureNative.Databricks.Workspace("workspace", new()
    {
        Location = "westus",
        ManagedResourceGroupId = "/subscriptions/subid/resourceGroups/myManagedRG",
        Parameters = new AzureNative.Databricks.Inputs.WorkspaceCustomParametersArgs
        {
            CustomPrivateSubnetName = new AzureNative.Databricks.Inputs.WorkspaceCustomStringParameterArgs
            {
                Value = "myPrivateSubnet",
            },
            CustomPublicSubnetName = new AzureNative.Databricks.Inputs.WorkspaceCustomStringParameterArgs
            {
                Value = "myPublicSubnet",
            },
            CustomVirtualNetworkId = new AzureNative.Databricks.Inputs.WorkspaceCustomStringParameterArgs
            {
                Value = "/subscriptions/subid/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/myNetwork",
            },
        },
        ResourceGroupName = "rg",
        WorkspaceName = "myWorkspace",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/databricks/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databricks.NewWorkspace(ctx, "workspace", &databricks.WorkspaceArgs{
			Location:               pulumi.String("westus"),
			ManagedResourceGroupId: pulumi.String("/subscriptions/subid/resourceGroups/myManagedRG"),
			Parameters: databricks.WorkspaceCustomParametersResponse{
				CustomPrivateSubnetName: &databricks.WorkspaceCustomStringParameterArgs{
					Value: pulumi.String("myPrivateSubnet"),
				},
				CustomPublicSubnetName: &databricks.WorkspaceCustomStringParameterArgs{
					Value: pulumi.String("myPublicSubnet"),
				},
				CustomVirtualNetworkId: &databricks.WorkspaceCustomStringParameterArgs{
					Value: pulumi.String("/subscriptions/subid/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/myNetwork"),
				},
			},
			ResourceGroupName: pulumi.String("rg"),
			WorkspaceName:     pulumi.String("myWorkspace"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.databricks.Workspace;
import com.pulumi.azurenative.databricks.WorkspaceArgs;
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 workspace = new Workspace("workspace", WorkspaceArgs.builder()
            .location("westus")
            .managedResourceGroupId("/subscriptions/subid/resourceGroups/myManagedRG")
            .parameters(Map.ofEntries(
                Map.entry("customPrivateSubnetName", Map.of("value", "myPrivateSubnet")),
                Map.entry("customPublicSubnetName", Map.of("value", "myPublicSubnet")),
                Map.entry("customVirtualNetworkId", Map.of("value", "/subscriptions/subid/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/myNetwork"))
            ))
            .resourceGroupName("rg")
            .workspaceName("myWorkspace")
            .build());
    }
}
Content copied to clipboard

Enable Customer-Managed Key (CMK) encryption on a workspace which is prepared for encryption

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var workspace = new AzureNative.Databricks.Workspace("workspace", new()
    {
        Location = "westus",
        ManagedResourceGroupId = "/subscriptions/subid/resourceGroups/myManagedRG",
        Parameters = new AzureNative.Databricks.Inputs.WorkspaceCustomParametersArgs
        {
            Encryption = new AzureNative.Databricks.Inputs.WorkspaceEncryptionParameterArgs
            {
                Value = new AzureNative.Databricks.Inputs.EncryptionArgs
                {
                    KeyName = "myKeyName",
                    KeySource = "Microsoft.Keyvault",
                    KeyVaultUri = "https://myKeyVault.vault.azure.net/",
                    KeyVersion = "00000000000000000000000000000000",
                },
            },
            PrepareEncryption = new AzureNative.Databricks.Inputs.WorkspaceCustomBooleanParameterArgs
            {
                Value = true,
            },
        },
        ResourceGroupName = "rg",
        WorkspaceName = "myWorkspace",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/databricks/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := databricks.NewWorkspace(ctx, "workspace", &databricks.WorkspaceArgs{
Location: pulumi.String("westus"),
ManagedResourceGroupId: pulumi.String("/subscriptions/subid/resourceGroups/myManagedRG"),
Parameters: databricks.WorkspaceCustomParametersResponse{
Encryption: interface{}{
Value: &databricks.EncryptionArgs{
KeyName: pulumi.String("myKeyName"),
KeySource: pulumi.String("Microsoft.Keyvault"),
KeyVaultUri: pulumi.String("https://myKeyVault.vault.azure.net/"),
KeyVersion: pulumi.String("00000000000000000000000000000000"),
},
},
PrepareEncryption: &databricks.WorkspaceCustomBooleanParameterArgs{
Value: pulumi.Bool(true),
},
},
ResourceGroupName: pulumi.String("rg"),
WorkspaceName: pulumi.String("myWorkspace"),
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.databricks.Workspace;
import com.pulumi.azurenative.databricks.WorkspaceArgs;
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 workspace = new Workspace("workspace", WorkspaceArgs.builder()
            .location("westus")
            .managedResourceGroupId("/subscriptions/subid/resourceGroups/myManagedRG")
            .parameters(Map.ofEntries(
                Map.entry("encryption", Map.of("value", Map.ofEntries(
                    Map.entry("keyName", "myKeyName"),
                    Map.entry("keySource", "Microsoft.Keyvault"),
                    Map.entry("keyVaultUri", "https://myKeyVault.vault.azure.net/"),
                    Map.entry("keyVersion", "00000000000000000000000000000000")
                ))),
                Map.entry("prepareEncryption", Map.of("value", true))
            ))
            .resourceGroupName("rg")
            .workspaceName("myWorkspace")
            .build());
    }
}
Content copied to clipboard

Revert Customer-Managed Key (CMK) encryption to Microsoft Managed Keys encryption on a workspace

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var workspace = new AzureNative.Databricks.Workspace("workspace", new()
    {
        Location = "westus",
        ManagedResourceGroupId = "/subscriptions/subid/resourceGroups/myManagedRG",
        Parameters = new AzureNative.Databricks.Inputs.WorkspaceCustomParametersArgs
        {
            Encryption = new AzureNative.Databricks.Inputs.WorkspaceEncryptionParameterArgs
            {
                Value = new AzureNative.Databricks.Inputs.EncryptionArgs
                {
                    KeySource = "Default",
                },
            },
        },
        ResourceGroupName = "rg",
        WorkspaceName = "myWorkspace",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/databricks/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := databricks.NewWorkspace(ctx, "workspace", &databricks.WorkspaceArgs{
Location: pulumi.String("westus"),
ManagedResourceGroupId: pulumi.String("/subscriptions/subid/resourceGroups/myManagedRG"),
Parameters: databricks.WorkspaceCustomParametersResponse{
Encryption: interface{}{
Value: &databricks.EncryptionArgs{
KeySource: pulumi.String("Default"),
},
},
},
ResourceGroupName: pulumi.String("rg"),
WorkspaceName: pulumi.String("myWorkspace"),
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.databricks.Workspace;
import com.pulumi.azurenative.databricks.WorkspaceArgs;
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 workspace = new Workspace("workspace", WorkspaceArgs.builder()
            .location("westus")
            .managedResourceGroupId("/subscriptions/subid/resourceGroups/myManagedRG")
            .parameters(Map.of("encryption", Map.of("value", Map.of("keySource", "Default"))))
            .resourceGroupName("rg")
            .workspaceName("myWorkspace")
            .build());
    }
}
Content copied to clipboard

Update a workspace with Customer-Managed Key (CMK) encryption for Managed Disks

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var workspace = new AzureNative.Databricks.Workspace("workspace", new()
    {
        Encryption = new AzureNative.Databricks.Inputs.WorkspacePropertiesEncryptionArgs
        {
            Entities = new AzureNative.Databricks.Inputs.EncryptionEntitiesDefinitionArgs
            {
                ManagedDisk = new AzureNative.Databricks.Inputs.ManagedDiskEncryptionArgs
                {
                    KeySource = "Microsoft.Keyvault",
                    KeyVaultProperties = new AzureNative.Databricks.Inputs.ManagedDiskEncryptionKeyVaultPropertiesArgs
                    {
                        KeyName = "test-cmk-key",
                        KeyVaultUri = "https://test-vault-name.vault.azure.net/",
                        KeyVersion = "00000000000000000000000000000000",
                    },
                    RotationToLatestKeyVersionEnabled = true,
                },
            },
        },
        Location = "westus",
        ManagedResourceGroupId = "/subscriptions/subid/resourceGroups/myManagedRG",
        ResourceGroupName = "rg",
        Tags =
        {
            { "mytag1", "myvalue1" },
        },
        WorkspaceName = "myWorkspace",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/databricks/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := databricks.NewWorkspace(ctx, "workspace", &databricks.WorkspaceArgs{
Encryption: databricks.WorkspacePropertiesResponseEncryption{
Entities: interface{}{
ManagedDisk: interface{}{
KeySource: pulumi.String("Microsoft.Keyvault"),
KeyVaultProperties: &databricks.ManagedDiskEncryptionKeyVaultPropertiesArgs{
KeyName: pulumi.String("test-cmk-key"),
KeyVaultUri: pulumi.String("https://test-vault-name.vault.azure.net/"),
KeyVersion: pulumi.String("00000000000000000000000000000000"),
},
RotationToLatestKeyVersionEnabled: pulumi.Bool(true),
},
},
},
Location: pulumi.String("westus"),
ManagedResourceGroupId: pulumi.String("/subscriptions/subid/resourceGroups/myManagedRG"),
ResourceGroupName: pulumi.String("rg"),
Tags: pulumi.StringMap{
"mytag1": pulumi.String("myvalue1"),
},
WorkspaceName: pulumi.String("myWorkspace"),
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.databricks.Workspace;
import com.pulumi.azurenative.databricks.WorkspaceArgs;
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 workspace = new Workspace("workspace", WorkspaceArgs.builder()
            .encryption(Map.of("entities", Map.of("managedDisk", Map.ofEntries(
                Map.entry("keySource", "Microsoft.Keyvault"),
                Map.entry("keyVaultProperties", Map.ofEntries(
                    Map.entry("keyName", "test-cmk-key"),
                    Map.entry("keyVaultUri", "https://test-vault-name.vault.azure.net/"),
                    Map.entry("keyVersion", "00000000000000000000000000000000")
                )),
                Map.entry("rotationToLatestKeyVersionEnabled", true)
            ))))
            .location("westus")
            .managedResourceGroupId("/subscriptions/subid/resourceGroups/myManagedRG")
            .resourceGroupName("rg")
            .tags(Map.of("mytag1", "myvalue1"))
            .workspaceName("myWorkspace")
            .build());
    }
}
Content copied to clipboard

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:databricks:Workspace myWorkspace /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Databricks/workspaces/{workspaceName}
Content copied to clipboard

Properties

Link copied to clipboard
val authorizations: Output<List<WorkspaceProviderAuthorizationResponse>>?

The workspace provider authorizations.

Link copied to clipboard
val createdBy: Output<CreatedByResponse>?

Indicates the Object ID, PUID and Application ID of entity that created the workspace.

Link copied to clipboard
val createdDateTime: Output<String>

Specifies the date and time when the workspace is created.

Link copied to clipboard
val diskEncryptionSetId: Output<String>

The resource Id of the managed disk encryption set.

Link copied to clipboard
val encryption: Output<WorkspacePropertiesResponseEncryption>?

Encryption properties for databricks workspace

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val location: Output<String>

The geo-location where the resource lives

Link copied to clipboard
val managedDiskIdentity: Output<ManagedIdentityConfigurationResponse>?

The details of Managed Identity of Disk Encryption Set used for Managed Disk Encryption

Link copied to clipboard
val managedResourceGroupId: Output<String>

The managed resource group Id.

Link copied to clipboard
val name: Output<String>

The name of the resource

Link copied to clipboard
val parameters: Output<WorkspaceCustomParametersResponse>?

The workspace's custom parameters.

Link copied to clipboard
val privateEndpointConnections: Output<List<PrivateEndpointConnectionResponse>>

Private endpoint connections created on the workspace

Link copied to clipboard
val provisioningState: Output<String>

The workspace provisioning state.

Link copied to clipboard
val publicNetworkAccess: Output<String>?

The network access type for accessing workspace. Set value to disabled to access workspace only via private link.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val requiredNsgRules: Output<String>?

Gets or sets a value indicating whether data plane (clusters) to control plane communication happen over private endpoint. Supported values are 'AllRules' and 'NoAzureDatabricksRules'. 'NoAzureServiceRules' value is for internal use only.

Link copied to clipboard
val sku: Output<SkuResponse>?

The SKU of the resource.

Link copied to clipboard
val storageAccountIdentity: Output<ManagedIdentityConfigurationResponse>?

The details of Managed Identity of Storage Account

Link copied to clipboard
val systemData: Output<SystemDataResponse>

The system metadata relating to this resource

Link copied to clipboard
val tags: Output<Map<String, String>>?

Resource tags.

Link copied to clipboard
val type: Output<String>

The type of the resource. Ex- Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.

Link copied to clipboard
val uiDefinitionUri: Output<String>?

The blob URI where the UI definition file is located.

Link copied to clipboard
val updatedBy: Output<CreatedByResponse>?

Indicates the Object ID, PUID and Application ID of entity that last updated the workspace.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val workspaceId: Output<String>

The unique identifier of the databricks workspace in databricks control plane.

Link copied to clipboard
val workspaceUrl: Output<String>

The workspace URL which is of the format 'adb-{workspaceId}.{random}.azuredatabricks.net'