Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Databricks
  3. API Docs
  4. MwsVpcEndpoint
Databricks v1.50.2 published on Tuesday, Sep 24, 2024 by Pulumi
pulumi/pulumi-databricks

databricks.MwsVpcEndpoint

Explore with Pulumi AI

databricks logo
Databricks v1.50.2 published on Tuesday, Sep 24, 2024 by Pulumi
pulumi/pulumi-databricks

    Note Initialize provider with alias = "mws", host = "https://accounts.cloud.databricks.com" and use provider = databricks.mws

    Enables you to register aws_vpc_endpoint resources or gcp vpc_endpoint resources with Databricks such that they can be used as part of a databricks.MwsNetworks configuration.

    It is strongly recommended that customers read the Enable AWS Private Link or the Enable GCP Private Service Connect documentation before trying to leverage this resource.

    Example Usage

    Databricks on AWS usage

    Before using this resource, you will need to create the necessary VPC Endpoints as per your VPC endpoint requirements. You can use the aws_vpc_endpoint resource for this, for example:

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

const workspace = new aws.ec2.VpcEndpoint("workspace", {
    vpcId: vpc.vpcId,
    serviceName: privateLink.workspaceService,
    vpcEndpointType: "Interface",
    securityGroupIds: [vpc.defaultSecurityGroupId],
    subnetIds: [plSubnet.id],
    privateDnsEnabled: true,
}, {
    dependsOn: [plSubnet],
});
const relay = new aws.ec2.VpcEndpoint("relay", {
    vpcId: vpc.vpcId,
    serviceName: privateLink.relayService,
    vpcEndpointType: "Interface",
    securityGroupIds: [vpc.defaultSecurityGroupId],
    subnetIds: [plSubnet.id],
    privateDnsEnabled: true,
}, {
    dependsOn: [plSubnet],
});

    import pulumi
import pulumi_aws as aws

workspace = aws.ec2.VpcEndpoint("workspace",
    vpc_id=vpc["vpcId"],
    service_name=private_link["workspaceService"],
    vpc_endpoint_type="Interface",
    security_group_ids=[vpc["defaultSecurityGroupId"]],
    subnet_ids=[pl_subnet["id"]],
    private_dns_enabled=True,
    opts = pulumi.ResourceOptions(depends_on=[pl_subnet]))
relay = aws.ec2.VpcEndpoint("relay",
    vpc_id=vpc["vpcId"],
    service_name=private_link["relayService"],
    vpc_endpoint_type="Interface",
    security_group_ids=[vpc["defaultSecurityGroupId"]],
    subnet_ids=[pl_subnet["id"]],
    private_dns_enabled=True,
    opts = pulumi.ResourceOptions(depends_on=[pl_subnet]))

    package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ec2.NewVpcEndpoint(ctx, "workspace", &ec2.VpcEndpointArgs{
			VpcId:           pulumi.Any(vpc.VpcId),
			ServiceName:     pulumi.Any(privateLink.WorkspaceService),
			VpcEndpointType: pulumi.String("Interface"),
			SecurityGroupIds: pulumi.StringArray{
				vpc.DefaultSecurityGroupId,
			},
			SubnetIds: pulumi.StringArray{
				plSubnet.Id,
			},
			PrivateDnsEnabled: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			plSubnet,
		}))
		if err != nil {
			return err
		}
		_, err = ec2.NewVpcEndpoint(ctx, "relay", &ec2.VpcEndpointArgs{
			VpcId:           pulumi.Any(vpc.VpcId),
			ServiceName:     pulumi.Any(privateLink.RelayService),
			VpcEndpointType: pulumi.String("Interface"),
			SecurityGroupIds: pulumi.StringArray{
				vpc.DefaultSecurityGroupId,
			},
			SubnetIds: pulumi.StringArray{
				plSubnet.Id,
			},
			PrivateDnsEnabled: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			plSubnet,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var workspace = new Aws.Ec2.VpcEndpoint("workspace", new()
    {
        VpcId = vpc.VpcId,
        ServiceName = privateLink.WorkspaceService,
        VpcEndpointType = "Interface",
        SecurityGroupIds = new[]
        {
            vpc.DefaultSecurityGroupId,
        },
        SubnetIds = new[]
        {
            plSubnet.Id,
        },
        PrivateDnsEnabled = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            plSubnet,
        },
    });

    var relay = new Aws.Ec2.VpcEndpoint("relay", new()
    {
        VpcId = vpc.VpcId,
        ServiceName = privateLink.RelayService,
        VpcEndpointType = "Interface",
        SecurityGroupIds = new[]
        {
            vpc.DefaultSecurityGroupId,
        },
        SubnetIds = new[]
        {
            plSubnet.Id,
        },
        PrivateDnsEnabled = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            plSubnet,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.VpcEndpoint;
import com.pulumi.aws.ec2.VpcEndpointArgs;
import com.pulumi.resources.CustomResourceOptions;
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 VpcEndpoint("workspace", VpcEndpointArgs.builder()
            .vpcId(vpc.vpcId())
            .serviceName(privateLink.workspaceService())
            .vpcEndpointType("Interface")
            .securityGroupIds(vpc.defaultSecurityGroupId())
            .subnetIds(plSubnet.id())
            .privateDnsEnabled(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(plSubnet)
                .build());

        var relay = new VpcEndpoint("relay", VpcEndpointArgs.builder()
            .vpcId(vpc.vpcId())
            .serviceName(privateLink.relayService())
            .vpcEndpointType("Interface")
            .securityGroupIds(vpc.defaultSecurityGroupId())
            .subnetIds(plSubnet.id())
            .privateDnsEnabled(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(plSubnet)
                .build());

    }
}

    resources:
  workspace:
    type: aws:ec2:VpcEndpoint
    properties:
      vpcId: ${vpc.vpcId}
      serviceName: ${privateLink.workspaceService}
      vpcEndpointType: Interface
      securityGroupIds:
        - ${vpc.defaultSecurityGroupId}
      subnetIds:
        - ${plSubnet.id}
      privateDnsEnabled: true
    options:
      dependson:
        - ${plSubnet}
  relay:
    type: aws:ec2:VpcEndpoint
    properties:
      vpcId: ${vpc.vpcId}
      serviceName: ${privateLink.relayService}
      vpcEndpointType: Interface
      securityGroupIds:
        - ${vpc.defaultSecurityGroupId}
      subnetIds:
        - ${plSubnet.id}
      privateDnsEnabled: true
    options:
      dependson:
        - ${plSubnet}

    Depending on your use case, you may need or choose to add VPC Endpoints for the AWS Services Databricks uses. See Add VPC endpoints for other AWS services (recommended but optional) for more information. For example:

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

const s3 = new aws.ec2.VpcEndpoint("s3", {
    vpcId: vpc.vpcId,
    routeTableIds: vpc.privateRouteTableIds,
    serviceName: `com.amazonaws.${region}.s3`,
}, {
    dependsOn: [vpc],
});
const sts = new aws.ec2.VpcEndpoint("sts", {
    vpcId: vpc.vpcId,
    serviceName: `com.amazonaws.${region}.sts`,
    vpcEndpointType: "Interface",
    subnetIds: vpc.privateSubnets,
    securityGroupIds: [vpc.defaultSecurityGroupId],
    privateDnsEnabled: true,
}, {
    dependsOn: [vpc],
});
const kinesis_streams = new aws.ec2.VpcEndpoint("kinesis-streams", {
    vpcId: vpc.vpcId,
    serviceName: `com.amazonaws.${region}.kinesis-streams`,
    vpcEndpointType: "Interface",
    subnetIds: vpc.privateSubnets,
    securityGroupIds: [vpc.defaultSecurityGroupId],
}, {
    dependsOn: [vpc],
});

    import pulumi
import pulumi_aws as aws

s3 = aws.ec2.VpcEndpoint("s3",
    vpc_id=vpc["vpcId"],
    route_table_ids=vpc["privateRouteTableIds"],
    service_name=f"com.amazonaws.{region}.s3",
    opts = pulumi.ResourceOptions(depends_on=[vpc]))
sts = aws.ec2.VpcEndpoint("sts",
    vpc_id=vpc["vpcId"],
    service_name=f"com.amazonaws.{region}.sts",
    vpc_endpoint_type="Interface",
    subnet_ids=vpc["privateSubnets"],
    security_group_ids=[vpc["defaultSecurityGroupId"]],
    private_dns_enabled=True,
    opts = pulumi.ResourceOptions(depends_on=[vpc]))
kinesis_streams = aws.ec2.VpcEndpoint("kinesis-streams",
    vpc_id=vpc["vpcId"],
    service_name=f"com.amazonaws.{region}.kinesis-streams",
    vpc_endpoint_type="Interface",
    subnet_ids=vpc["privateSubnets"],
    security_group_ids=[vpc["defaultSecurityGroupId"]],
    opts = pulumi.ResourceOptions(depends_on=[vpc]))

    package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ec2.NewVpcEndpoint(ctx, "s3", &ec2.VpcEndpointArgs{
			VpcId:         pulumi.Any(vpc.VpcId),
			RouteTableIds: pulumi.Any(vpc.PrivateRouteTableIds),
			ServiceName:   pulumi.Sprintf("com.amazonaws.%v.s3", region),
		}, pulumi.DependsOn([]pulumi.Resource{
			vpc,
		}))
		if err != nil {
			return err
		}
		_, err = ec2.NewVpcEndpoint(ctx, "sts", &ec2.VpcEndpointArgs{
			VpcId:           pulumi.Any(vpc.VpcId),
			ServiceName:     pulumi.Sprintf("com.amazonaws.%v.sts", region),
			VpcEndpointType: pulumi.String("Interface"),
			SubnetIds:       pulumi.Any(vpc.PrivateSubnets),
			SecurityGroupIds: pulumi.StringArray{
				vpc.DefaultSecurityGroupId,
			},
			PrivateDnsEnabled: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			vpc,
		}))
		if err != nil {
			return err
		}
		_, err = ec2.NewVpcEndpoint(ctx, "kinesis-streams", &ec2.VpcEndpointArgs{
			VpcId:           pulumi.Any(vpc.VpcId),
			ServiceName:     pulumi.Sprintf("com.amazonaws.%v.kinesis-streams", region),
			VpcEndpointType: pulumi.String("Interface"),
			SubnetIds:       pulumi.Any(vpc.PrivateSubnets),
			SecurityGroupIds: pulumi.StringArray{
				vpc.DefaultSecurityGroupId,
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			vpc,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var s3 = new Aws.Ec2.VpcEndpoint("s3", new()
    {
        VpcId = vpc.VpcId,
        RouteTableIds = vpc.PrivateRouteTableIds,
        ServiceName = $"com.amazonaws.{region}.s3",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            vpc,
        },
    });

    var sts = new Aws.Ec2.VpcEndpoint("sts", new()
    {
        VpcId = vpc.VpcId,
        ServiceName = $"com.amazonaws.{region}.sts",
        VpcEndpointType = "Interface",
        SubnetIds = vpc.PrivateSubnets,
        SecurityGroupIds = new[]
        {
            vpc.DefaultSecurityGroupId,
        },
        PrivateDnsEnabled = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            vpc,
        },
    });

    var kinesis_streams = new Aws.Ec2.VpcEndpoint("kinesis-streams", new()
    {
        VpcId = vpc.VpcId,
        ServiceName = $"com.amazonaws.{region}.kinesis-streams",
        VpcEndpointType = "Interface",
        SubnetIds = vpc.PrivateSubnets,
        SecurityGroupIds = new[]
        {
            vpc.DefaultSecurityGroupId,
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            vpc,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.VpcEndpoint;
import com.pulumi.aws.ec2.VpcEndpointArgs;
import com.pulumi.resources.CustomResourceOptions;
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 s3 = new VpcEndpoint("s3", VpcEndpointArgs.builder()
            .vpcId(vpc.vpcId())
            .routeTableIds(vpc.privateRouteTableIds())
            .serviceName(String.format("com.amazonaws.%s.s3", region))
            .build(), CustomResourceOptions.builder()
                .dependsOn(vpc)
                .build());

        var sts = new VpcEndpoint("sts", VpcEndpointArgs.builder()
            .vpcId(vpc.vpcId())
            .serviceName(String.format("com.amazonaws.%s.sts", region))
            .vpcEndpointType("Interface")
            .subnetIds(vpc.privateSubnets())
            .securityGroupIds(vpc.defaultSecurityGroupId())
            .privateDnsEnabled(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(vpc)
                .build());

        var kinesis_streams = new VpcEndpoint("kinesis-streams", VpcEndpointArgs.builder()
            .vpcId(vpc.vpcId())
            .serviceName(String.format("com.amazonaws.%s.kinesis-streams", region))
            .vpcEndpointType("Interface")
            .subnetIds(vpc.privateSubnets())
            .securityGroupIds(vpc.defaultSecurityGroupId())
            .build(), CustomResourceOptions.builder()
                .dependsOn(vpc)
                .build());

    }
}

    resources:
  s3:
    type: aws:ec2:VpcEndpoint
    properties:
      vpcId: ${vpc.vpcId}
      routeTableIds: ${vpc.privateRouteTableIds}
      serviceName: com.amazonaws.${region}.s3
    options:
      dependson:
        - ${vpc}
  sts:
    type: aws:ec2:VpcEndpoint
    properties:
      vpcId: ${vpc.vpcId}
      serviceName: com.amazonaws.${region}.sts
      vpcEndpointType: Interface
      subnetIds: ${vpc.privateSubnets}
      securityGroupIds:
        - ${vpc.defaultSecurityGroupId}
      privateDnsEnabled: true
    options:
      dependson:
        - ${vpc}
  kinesis-streams:
    type: aws:ec2:VpcEndpoint
    properties:
      vpcId: ${vpc.vpcId}
      serviceName: com.amazonaws.${region}.kinesis-streams
      vpcEndpointType: Interface
      subnetIds: ${vpc.privateSubnets}
      securityGroupIds:
        - ${vpc.defaultSecurityGroupId}
    options:
      dependson:
        - ${vpc}

    Once you have created the necessary endpoints, you need to register each of them via this Pulumi resource, which calls out to the Databricks Account API):

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

const workspace = new databricks.MwsVpcEndpoint("workspace", {
    accountId: databricksAccountId,
    awsVpcEndpointId: workspaceAwsVpcEndpoint.id,
    vpcEndpointName: `VPC Relay for ${vpc.vpcId}`,
    region: region,
}, {
    dependsOn: [workspaceAwsVpcEndpoint],
});
const relay = new databricks.MwsVpcEndpoint("relay", {
    accountId: databricksAccountId,
    awsVpcEndpointId: relayAwsVpcEndpoint.id,
    vpcEndpointName: `VPC Relay for ${vpc.vpcId}`,
    region: region,
}, {
    dependsOn: [relayAwsVpcEndpoint],
});

    import pulumi
import pulumi_databricks as databricks

workspace = databricks.MwsVpcEndpoint("workspace",
    account_id=databricks_account_id,
    aws_vpc_endpoint_id=workspace_aws_vpc_endpoint["id"],
    vpc_endpoint_name=f"VPC Relay for {vpc['vpcId']}",
    region=region,
    opts = pulumi.ResourceOptions(depends_on=[workspace_aws_vpc_endpoint]))
relay = databricks.MwsVpcEndpoint("relay",
    account_id=databricks_account_id,
    aws_vpc_endpoint_id=relay_aws_vpc_endpoint["id"],
    vpc_endpoint_name=f"VPC Relay for {vpc['vpcId']}",
    region=region,
    opts = pulumi.ResourceOptions(depends_on=[relay_aws_vpc_endpoint]))

    package main

import (
	"fmt"

	"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 {
		_, err := databricks.NewMwsVpcEndpoint(ctx, "workspace", &databricks.MwsVpcEndpointArgs{
			AccountId:        pulumi.Any(databricksAccountId),
			AwsVpcEndpointId: pulumi.Any(workspaceAwsVpcEndpoint.Id),
			VpcEndpointName:  pulumi.Sprintf("VPC Relay for %v", vpc.VpcId),
			Region:           pulumi.Any(region),
		}, pulumi.DependsOn([]pulumi.Resource{
			workspaceAwsVpcEndpoint,
		}))
		if err != nil {
			return err
		}
		_, err = databricks.NewMwsVpcEndpoint(ctx, "relay", &databricks.MwsVpcEndpointArgs{
			AccountId:        pulumi.Any(databricksAccountId),
			AwsVpcEndpointId: pulumi.Any(relayAwsVpcEndpoint.Id),
			VpcEndpointName:  pulumi.Sprintf("VPC Relay for %v", vpc.VpcId),
			Region:           pulumi.Any(region),
		}, pulumi.DependsOn([]pulumi.Resource{
			relayAwsVpcEndpoint,
		}))
		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 workspace = new Databricks.MwsVpcEndpoint("workspace", new()
    {
        AccountId = databricksAccountId,
        AwsVpcEndpointId = workspaceAwsVpcEndpoint.Id,
        VpcEndpointName = $"VPC Relay for {vpc.VpcId}",
        Region = region,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            workspaceAwsVpcEndpoint,
        },
    });

    var relay = new Databricks.MwsVpcEndpoint("relay", new()
    {
        AccountId = databricksAccountId,
        AwsVpcEndpointId = relayAwsVpcEndpoint.Id,
        VpcEndpointName = $"VPC Relay for {vpc.VpcId}",
        Region = region,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            relayAwsVpcEndpoint,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.MwsVpcEndpoint;
import com.pulumi.databricks.MwsVpcEndpointArgs;
import com.pulumi.resources.CustomResourceOptions;
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 MwsVpcEndpoint("workspace", MwsVpcEndpointArgs.builder()
            .accountId(databricksAccountId)
            .awsVpcEndpointId(workspaceAwsVpcEndpoint.id())
            .vpcEndpointName(String.format("VPC Relay for %s", vpc.vpcId()))
            .region(region)
            .build(), CustomResourceOptions.builder()
                .dependsOn(workspaceAwsVpcEndpoint)
                .build());

        var relay = new MwsVpcEndpoint("relay", MwsVpcEndpointArgs.builder()
            .accountId(databricksAccountId)
            .awsVpcEndpointId(relayAwsVpcEndpoint.id())
            .vpcEndpointName(String.format("VPC Relay for %s", vpc.vpcId()))
            .region(region)
            .build(), CustomResourceOptions.builder()
                .dependsOn(relayAwsVpcEndpoint)
                .build());

    }
}

    resources:
  workspace:
    type: databricks:MwsVpcEndpoint
    properties:
      accountId: ${databricksAccountId}
      awsVpcEndpointId: ${workspaceAwsVpcEndpoint.id}
      vpcEndpointName: VPC Relay for ${vpc.vpcId}
      region: ${region}
    options:
      dependson:
        - ${workspaceAwsVpcEndpoint}
  relay:
    type: databricks:MwsVpcEndpoint
    properties:
      accountId: ${databricksAccountId}
      awsVpcEndpointId: ${relayAwsVpcEndpoint.id}
      vpcEndpointName: VPC Relay for ${vpc.vpcId}
      region: ${region}
    options:
      dependson:
        - ${relayAwsVpcEndpoint}

    Typically the next steps after this would be to create a databricks.MwsPrivateAccessSettings and databricks.MwsNetworks configuration, before passing the databricks_mws_private_access_settings.pas.private_access_settings_id and databricks_mws_networks.this.network_id into a databricks.MwsWorkspaces resource:

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

const _this = new databricks.MwsWorkspaces("this", {
    accountId: databricksAccountId,
    awsRegion: region,
    workspaceName: prefix,
    credentialsId: thisDatabricksMwsCredentials.credentialsId,
    storageConfigurationId: thisDatabricksMwsStorageConfigurations.storageConfigurationId,
    networkId: thisDatabricksMwsNetworks.networkId,
    privateAccessSettingsId: pas.privateAccessSettingsId,
    pricingTier: "ENTERPRISE",
}, {
    dependsOn: [thisDatabricksMwsNetworks],
});

    import pulumi
import pulumi_databricks as databricks

this = databricks.MwsWorkspaces("this",
    account_id=databricks_account_id,
    aws_region=region,
    workspace_name=prefix,
    credentials_id=this_databricks_mws_credentials["credentialsId"],
    storage_configuration_id=this_databricks_mws_storage_configurations["storageConfigurationId"],
    network_id=this_databricks_mws_networks["networkId"],
    private_access_settings_id=pas["privateAccessSettingsId"],
    pricing_tier="ENTERPRISE",
    opts = pulumi.ResourceOptions(depends_on=[this_databricks_mws_networks]))

    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 {
		_, err := databricks.NewMwsWorkspaces(ctx, "this", &databricks.MwsWorkspacesArgs{
			AccountId:               pulumi.Any(databricksAccountId),
			AwsRegion:               pulumi.Any(region),
			WorkspaceName:           pulumi.Any(prefix),
			CredentialsId:           pulumi.Any(thisDatabricksMwsCredentials.CredentialsId),
			StorageConfigurationId:  pulumi.Any(thisDatabricksMwsStorageConfigurations.StorageConfigurationId),
			NetworkId:               pulumi.Any(thisDatabricksMwsNetworks.NetworkId),
			PrivateAccessSettingsId: pulumi.Any(pas.PrivateAccessSettingsId),
			PricingTier:             pulumi.String("ENTERPRISE"),
		}, pulumi.DependsOn([]pulumi.Resource{
			thisDatabricksMwsNetworks,
		}))
		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 @this = new Databricks.MwsWorkspaces("this", new()
    {
        AccountId = databricksAccountId,
        AwsRegion = region,
        WorkspaceName = prefix,
        CredentialsId = thisDatabricksMwsCredentials.CredentialsId,
        StorageConfigurationId = thisDatabricksMwsStorageConfigurations.StorageConfigurationId,
        NetworkId = thisDatabricksMwsNetworks.NetworkId,
        PrivateAccessSettingsId = pas.PrivateAccessSettingsId,
        PricingTier = "ENTERPRISE",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            thisDatabricksMwsNetworks,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.MwsWorkspaces;
import com.pulumi.databricks.MwsWorkspacesArgs;
import com.pulumi.resources.CustomResourceOptions;
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 this_ = new MwsWorkspaces("this", MwsWorkspacesArgs.builder()
            .accountId(databricksAccountId)
            .awsRegion(region)
            .workspaceName(prefix)
            .credentialsId(thisDatabricksMwsCredentials.credentialsId())
            .storageConfigurationId(thisDatabricksMwsStorageConfigurations.storageConfigurationId())
            .networkId(thisDatabricksMwsNetworks.networkId())
            .privateAccessSettingsId(pas.privateAccessSettingsId())
            .pricingTier("ENTERPRISE")
            .build(), CustomResourceOptions.builder()
                .dependsOn(thisDatabricksMwsNetworks)
                .build());

    }
}

    resources:
  this:
    type: databricks:MwsWorkspaces
    properties:
      accountId: ${databricksAccountId}
      awsRegion: ${region}
      workspaceName: ${prefix}
      credentialsId: ${thisDatabricksMwsCredentials.credentialsId}
      storageConfigurationId: ${thisDatabricksMwsStorageConfigurations.storageConfigurationId}
      networkId: ${thisDatabricksMwsNetworks.networkId}
      privateAccessSettingsId: ${pas.privateAccessSettingsId}
      pricingTier: ENTERPRISE
    options:
      dependson:
        - ${thisDatabricksMwsNetworks}

    Databricks on GCP usage

    Before using this resource, you will need to create the necessary Private Service Connect (PSC) connections on your Google Cloud VPC networks. You can see Enable Private Service Connect for your workspace for more details.

    Once you have created the necessary PSC connections, you need to register each of them via this Pulumi resource, which calls out to the Databricks Account API.

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

const config = new pulumi.Config();
// Account Id that could be found in https://accounts.gcp.databricks.com/
const databricksAccountId = config.requireObject("databricksAccountId");
const databricksGoogleServiceAccount = config.requireObject("databricksGoogleServiceAccount");
const googleProject = config.requireObject("googleProject");
const subnetRegion = config.requireObject("subnetRegion");
const workspace = new databricks.MwsVpcEndpoint("workspace", {
    accountId: databricksAccountId,
    vpcEndpointName: "PSC Rest API endpoint",
    gcpVpcEndpointInfo: {
        projectId: googleProject,
        pscEndpointName: "PSC Rest API endpoint",
        endpointRegion: subnetRegion,
    },
});
const relay = new databricks.MwsVpcEndpoint("relay", {
    accountId: databricksAccountId,
    vpcEndpointName: "PSC Relay endpoint",
    gcpVpcEndpointInfo: {
        projectId: googleProject,
        pscEndpointName: "PSC Relay endpoint",
        endpointRegion: subnetRegion,
    },
});

    import pulumi
import pulumi_databricks as databricks

config = pulumi.Config()
# Account Id that could be found in https://accounts.gcp.databricks.com/
databricks_account_id = config.require_object("databricksAccountId")
databricks_google_service_account = config.require_object("databricksGoogleServiceAccount")
google_project = config.require_object("googleProject")
subnet_region = config.require_object("subnetRegion")
workspace = databricks.MwsVpcEndpoint("workspace",
    account_id=databricks_account_id,
    vpc_endpoint_name="PSC Rest API endpoint",
    gcp_vpc_endpoint_info={
        "project_id": google_project,
        "psc_endpoint_name": "PSC Rest API endpoint",
        "endpoint_region": subnet_region,
    })
relay = databricks.MwsVpcEndpoint("relay",
    account_id=databricks_account_id,
    vpc_endpoint_name="PSC Relay endpoint",
    gcp_vpc_endpoint_info={
        "project_id": google_project,
        "psc_endpoint_name": "PSC Relay endpoint",
        "endpoint_region": subnet_region,
    })

    package main

import (
	"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 https://accounts.gcp.databricks.com/
		databricksAccountId := cfg.RequireObject("databricksAccountId")
		databricksGoogleServiceAccount := cfg.RequireObject("databricksGoogleServiceAccount")
		googleProject := cfg.RequireObject("googleProject")
		subnetRegion := cfg.RequireObject("subnetRegion")
		_, err := databricks.NewMwsVpcEndpoint(ctx, "workspace", &databricks.MwsVpcEndpointArgs{
			AccountId:       pulumi.Any(databricksAccountId),
			VpcEndpointName: pulumi.String("PSC Rest API endpoint"),
			GcpVpcEndpointInfo: &databricks.MwsVpcEndpointGcpVpcEndpointInfoArgs{
				ProjectId:       pulumi.Any(googleProject),
				PscEndpointName: pulumi.String("PSC Rest API endpoint"),
				EndpointRegion:  pulumi.Any(subnetRegion),
			},
		})
		if err != nil {
			return err
		}
		_, err = databricks.NewMwsVpcEndpoint(ctx, "relay", &databricks.MwsVpcEndpointArgs{
			AccountId:       pulumi.Any(databricksAccountId),
			VpcEndpointName: pulumi.String("PSC Relay endpoint"),
			GcpVpcEndpointInfo: &databricks.MwsVpcEndpointGcpVpcEndpointInfoArgs{
				ProjectId:       pulumi.Any(googleProject),
				PscEndpointName: pulumi.String("PSC Relay endpoint"),
				EndpointRegion:  pulumi.Any(subnetRegion),
			},
		})
		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 config = new Config();
    // Account Id that could be found in https://accounts.gcp.databricks.com/
    var databricksAccountId = config.RequireObject<dynamic>("databricksAccountId");
    var databricksGoogleServiceAccount = config.RequireObject<dynamic>("databricksGoogleServiceAccount");
    var googleProject = config.RequireObject<dynamic>("googleProject");
    var subnetRegion = config.RequireObject<dynamic>("subnetRegion");
    var workspace = new Databricks.MwsVpcEndpoint("workspace", new()
    {
        AccountId = databricksAccountId,
        VpcEndpointName = "PSC Rest API endpoint",
        GcpVpcEndpointInfo = new Databricks.Inputs.MwsVpcEndpointGcpVpcEndpointInfoArgs
        {
            ProjectId = googleProject,
            PscEndpointName = "PSC Rest API endpoint",
            EndpointRegion = subnetRegion,
        },
    });

    var relay = new Databricks.MwsVpcEndpoint("relay", new()
    {
        AccountId = databricksAccountId,
        VpcEndpointName = "PSC Relay endpoint",
        GcpVpcEndpointInfo = new Databricks.Inputs.MwsVpcEndpointGcpVpcEndpointInfoArgs
        {
            ProjectId = googleProject,
            PscEndpointName = "PSC Relay endpoint",
            EndpointRegion = subnetRegion,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.MwsVpcEndpoint;
import com.pulumi.databricks.MwsVpcEndpointArgs;
import com.pulumi.databricks.inputs.MwsVpcEndpointGcpVpcEndpointInfoArgs;
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 databricksGoogleServiceAccount = config.get("databricksGoogleServiceAccount");
        final var googleProject = config.get("googleProject");
        final var subnetRegion = config.get("subnetRegion");
        var workspace = new MwsVpcEndpoint("workspace", MwsVpcEndpointArgs.builder()
            .accountId(databricksAccountId)
            .vpcEndpointName("PSC Rest API endpoint")
            .gcpVpcEndpointInfo(MwsVpcEndpointGcpVpcEndpointInfoArgs.builder()
                .projectId(googleProject)
                .pscEndpointName("PSC Rest API endpoint")
                .endpointRegion(subnetRegion)
                .build())
            .build());

        var relay = new MwsVpcEndpoint("relay", MwsVpcEndpointArgs.builder()
            .accountId(databricksAccountId)
            .vpcEndpointName("PSC Relay endpoint")
            .gcpVpcEndpointInfo(MwsVpcEndpointGcpVpcEndpointInfoArgs.builder()
                .projectId(googleProject)
                .pscEndpointName("PSC Relay endpoint")
                .endpointRegion(subnetRegion)
                .build())
            .build());

    }
}

    configuration:
  databricksAccountId:
    type: dynamic
  databricksGoogleServiceAccount:
    type: dynamic
  googleProject:
    type: dynamic
  subnetRegion:
    type: dynamic
resources:
  workspace:
    type: databricks:MwsVpcEndpoint
    properties:
      accountId: ${databricksAccountId}
      vpcEndpointName: PSC Rest API endpoint
      gcpVpcEndpointInfo:
        projectId: ${googleProject}
        pscEndpointName: PSC Rest API endpoint
        endpointRegion: ${subnetRegion}
  relay:
    type: databricks:MwsVpcEndpoint
    properties:
      accountId: ${databricksAccountId}
      vpcEndpointName: PSC Relay endpoint
      gcpVpcEndpointInfo:
        projectId: ${googleProject}
        pscEndpointName: PSC Relay endpoint
        endpointRegion: ${subnetRegion}

    Typically the next steps after this would be to create a databricks.MwsPrivateAccessSettings and databricks.MwsNetworks configuration, before passing the databricks_mws_private_access_settings.pas.private_access_settings_id and databricks_mws_networks.this.network_id into a databricks.MwsWorkspaces resource:

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

const _this = new databricks.MwsWorkspaces("this", {
    accountId: databricksAccountId,
    workspaceName: "gcp workspace",
    location: subnetRegion,
    cloudResourceContainer: {
        gcp: {
            projectId: googleProject,
        },
    },
    gkeConfig: {
        connectivityType: "PRIVATE_NODE_PUBLIC_MASTER",
        masterIpRange: "10.3.0.0/28",
    },
    networkId: thisDatabricksMwsNetworks.networkId,
    privateAccessSettingsId: pas.privateAccessSettingsId,
    pricingTier: "PREMIUM",
}, {
    dependsOn: [thisDatabricksMwsNetworks],
});

    import pulumi
import pulumi_databricks as databricks

this = databricks.MwsWorkspaces("this",
    account_id=databricks_account_id,
    workspace_name="gcp workspace",
    location=subnet_region,
    cloud_resource_container={
        "gcp": {
            "project_id": google_project,
        },
    },
    gke_config={
        "connectivity_type": "PRIVATE_NODE_PUBLIC_MASTER",
        "master_ip_range": "10.3.0.0/28",
    },
    network_id=this_databricks_mws_networks["networkId"],
    private_access_settings_id=pas["privateAccessSettingsId"],
    pricing_tier="PREMIUM",
    opts = pulumi.ResourceOptions(depends_on=[this_databricks_mws_networks]))

    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 {
		_, err := databricks.NewMwsWorkspaces(ctx, "this", &databricks.MwsWorkspacesArgs{
			AccountId:     pulumi.Any(databricksAccountId),
			WorkspaceName: pulumi.String("gcp workspace"),
			Location:      pulumi.Any(subnetRegion),
			CloudResourceContainer: &databricks.MwsWorkspacesCloudResourceContainerArgs{
				Gcp: &databricks.MwsWorkspacesCloudResourceContainerGcpArgs{
					ProjectId: pulumi.Any(googleProject),
				},
			},
			GkeConfig: &databricks.MwsWorkspacesGkeConfigArgs{
				ConnectivityType: pulumi.String("PRIVATE_NODE_PUBLIC_MASTER"),
				MasterIpRange:    pulumi.String("10.3.0.0/28"),
			},
			NetworkId:               pulumi.Any(thisDatabricksMwsNetworks.NetworkId),
			PrivateAccessSettingsId: pulumi.Any(pas.PrivateAccessSettingsId),
			PricingTier:             pulumi.String("PREMIUM"),
		}, pulumi.DependsOn([]pulumi.Resource{
			thisDatabricksMwsNetworks,
		}))
		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 @this = new Databricks.MwsWorkspaces("this", new()
    {
        AccountId = databricksAccountId,
        WorkspaceName = "gcp workspace",
        Location = subnetRegion,
        CloudResourceContainer = new Databricks.Inputs.MwsWorkspacesCloudResourceContainerArgs
        {
            Gcp = new Databricks.Inputs.MwsWorkspacesCloudResourceContainerGcpArgs
            {
                ProjectId = googleProject,
            },
        },
        GkeConfig = new Databricks.Inputs.MwsWorkspacesGkeConfigArgs
        {
            ConnectivityType = "PRIVATE_NODE_PUBLIC_MASTER",
            MasterIpRange = "10.3.0.0/28",
        },
        NetworkId = thisDatabricksMwsNetworks.NetworkId,
        PrivateAccessSettingsId = pas.PrivateAccessSettingsId,
        PricingTier = "PREMIUM",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            thisDatabricksMwsNetworks,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.MwsWorkspaces;
import com.pulumi.databricks.MwsWorkspacesArgs;
import com.pulumi.databricks.inputs.MwsWorkspacesCloudResourceContainerArgs;
import com.pulumi.databricks.inputs.MwsWorkspacesCloudResourceContainerGcpArgs;
import com.pulumi.databricks.inputs.MwsWorkspacesGkeConfigArgs;
import com.pulumi.resources.CustomResourceOptions;
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 this_ = new MwsWorkspaces("this", MwsWorkspacesArgs.builder()
            .accountId(databricksAccountId)
            .workspaceName("gcp workspace")
            .location(subnetRegion)
            .cloudResourceContainer(MwsWorkspacesCloudResourceContainerArgs.builder()
                .gcp(MwsWorkspacesCloudResourceContainerGcpArgs.builder()
                    .projectId(googleProject)
                    .build())
                .build())
            .gkeConfig(MwsWorkspacesGkeConfigArgs.builder()
                .connectivityType("PRIVATE_NODE_PUBLIC_MASTER")
                .masterIpRange("10.3.0.0/28")
                .build())
            .networkId(thisDatabricksMwsNetworks.networkId())
            .privateAccessSettingsId(pas.privateAccessSettingsId())
            .pricingTier("PREMIUM")
            .build(), CustomResourceOptions.builder()
                .dependsOn(thisDatabricksMwsNetworks)
                .build());

    }
}

    resources:
  this:
    type: databricks:MwsWorkspaces
    properties:
      accountId: ${databricksAccountId}
      workspaceName: gcp workspace
      location: ${subnetRegion}
      cloudResourceContainer:
        gcp:
          projectId: ${googleProject}
      gkeConfig:
        connectivityType: PRIVATE_NODE_PUBLIC_MASTER
        masterIpRange: 10.3.0.0/28
      networkId: ${thisDatabricksMwsNetworks.networkId}
      privateAccessSettingsId: ${pas.privateAccessSettingsId}
      pricingTier: PREMIUM
    options:
      dependson:
        - ${thisDatabricksMwsNetworks}

    The following resources are used in the same context:

    • Provisioning Databricks on AWS guide.
    • Provisioning Databricks on AWS with Private Link guide.
    • Provisioning AWS Databricks workspaces with a Hub & Spoke firewall for data exfiltration protection guide.
    • Provisioning Databricks workspaces on GCP with Private Service Connect guide.
    • databricks.MwsNetworks to configure VPC & subnets for new workspaces within AWS.
    • databricks.MwsPrivateAccessSettings to create a Private Access Setting that can be used as part of a databricks.MwsWorkspaces resource to create a Databricks Workspace that leverages AWS Private Link.
    • databricks.MwsWorkspaces to set up AWS and GCP workspaces.

    Create MwsVpcEndpoint Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new MwsVpcEndpoint(name: string, args: MwsVpcEndpointArgs, opts?: CustomResourceOptions);
    @overload
def MwsVpcEndpoint(resource_name: str,
                   args: MwsVpcEndpointArgs,
                   opts: Optional[ResourceOptions] = None)

@overload
def MwsVpcEndpoint(resource_name: str,
                   opts: Optional[ResourceOptions] = None,
                   vpc_endpoint_name: Optional[str] = None,
                   account_id: Optional[str] = None,
                   aws_account_id: Optional[str] = None,
                   aws_endpoint_service_id: Optional[str] = None,
                   aws_vpc_endpoint_id: Optional[str] = None,
                   gcp_vpc_endpoint_info: Optional[MwsVpcEndpointGcpVpcEndpointInfoArgs] = None,
                   region: Optional[str] = None,
                   state: Optional[str] = None,
                   use_case: Optional[str] = None,
                   vpc_endpoint_id: Optional[str] = None)
    func NewMwsVpcEndpoint(ctx *Context, name string, args MwsVpcEndpointArgs, opts ...ResourceOption) (*MwsVpcEndpoint, error)
    public MwsVpcEndpoint(string name, MwsVpcEndpointArgs args, CustomResourceOptions? opts = null)
    public MwsVpcEndpoint(String name, MwsVpcEndpointArgs args)
public MwsVpcEndpoint(String name, MwsVpcEndpointArgs args, CustomResourceOptions options)

    type: databricks:MwsVpcEndpoint
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args MwsVpcEndpointArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args MwsVpcEndpointArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args MwsVpcEndpointArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args MwsVpcEndpointArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args MwsVpcEndpointArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var mwsVpcEndpointResource = new Databricks.MwsVpcEndpoint("mwsVpcEndpointResource", new()
{
    VpcEndpointName = "string",
    AccountId = "string",
    AwsAccountId = "string",
    AwsEndpointServiceId = "string",
    AwsVpcEndpointId = "string",
    GcpVpcEndpointInfo = new Databricks.Inputs.MwsVpcEndpointGcpVpcEndpointInfoArgs
    {
        EndpointRegion = "string",
        ProjectId = "string",
        PscEndpointName = "string",
        PscConnectionId = "string",
        ServiceAttachmentId = "string",
    },
    Region = "string",
    State = "string",
    UseCase = "string",
    VpcEndpointId = "string",
});

    example, err := databricks.NewMwsVpcEndpoint(ctx, "mwsVpcEndpointResource", &databricks.MwsVpcEndpointArgs{
	VpcEndpointName:      pulumi.String("string"),
	AccountId:            pulumi.String("string"),
	AwsAccountId:         pulumi.String("string"),
	AwsEndpointServiceId: pulumi.String("string"),
	AwsVpcEndpointId:     pulumi.String("string"),
	GcpVpcEndpointInfo: &databricks.MwsVpcEndpointGcpVpcEndpointInfoArgs{
		EndpointRegion:      pulumi.String("string"),
		ProjectId:           pulumi.String("string"),
		PscEndpointName:     pulumi.String("string"),
		PscConnectionId:     pulumi.String("string"),
		ServiceAttachmentId: pulumi.String("string"),
	},
	Region:        pulumi.String("string"),
	State:         pulumi.String("string"),
	UseCase:       pulumi.String("string"),
	VpcEndpointId: pulumi.String("string"),
})

    var mwsVpcEndpointResource = new MwsVpcEndpoint("mwsVpcEndpointResource", MwsVpcEndpointArgs.builder()
    .vpcEndpointName("string")
    .accountId("string")
    .awsAccountId("string")
    .awsEndpointServiceId("string")
    .awsVpcEndpointId("string")
    .gcpVpcEndpointInfo(MwsVpcEndpointGcpVpcEndpointInfoArgs.builder()
        .endpointRegion("string")
        .projectId("string")
        .pscEndpointName("string")
        .pscConnectionId("string")
        .serviceAttachmentId("string")
        .build())
    .region("string")
    .state("string")
    .useCase("string")
    .vpcEndpointId("string")
    .build());

    mws_vpc_endpoint_resource = databricks.MwsVpcEndpoint("mwsVpcEndpointResource",
    vpc_endpoint_name="string",
    account_id="string",
    aws_account_id="string",
    aws_endpoint_service_id="string",
    aws_vpc_endpoint_id="string",
    gcp_vpc_endpoint_info=databricks.MwsVpcEndpointGcpVpcEndpointInfoArgs(
        endpoint_region="string",
        project_id="string",
        psc_endpoint_name="string",
        psc_connection_id="string",
        service_attachment_id="string",
    ),
    region="string",
    state="string",
    use_case="string",
    vpc_endpoint_id="string")

    const mwsVpcEndpointResource = new databricks.MwsVpcEndpoint("mwsVpcEndpointResource", {
    vpcEndpointName: "string",
    accountId: "string",
    awsAccountId: "string",
    awsEndpointServiceId: "string",
    awsVpcEndpointId: "string",
    gcpVpcEndpointInfo: {
        endpointRegion: "string",
        projectId: "string",
        pscEndpointName: "string",
        pscConnectionId: "string",
        serviceAttachmentId: "string",
    },
    region: "string",
    state: "string",
    useCase: "string",
    vpcEndpointId: "string",
});

    type: databricks:MwsVpcEndpoint
properties:
    accountId: string
    awsAccountId: string
    awsEndpointServiceId: string
    awsVpcEndpointId: string
    gcpVpcEndpointInfo:
        endpointRegion: string
        projectId: string
        pscConnectionId: string
        pscEndpointName: string
        serviceAttachmentId: string
    region: string
    state: string
    useCase: string
    vpcEndpointId: string
    vpcEndpointName: string

    MwsVpcEndpoint Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The MwsVpcEndpoint resource accepts the following input properties:

    VpcEndpointName string
    Name of VPC Endpoint in Databricks Account
    AccountId string
    Account Id that could be found in the Accounts Console for AWS or GCP
    AwsAccountId string
    AwsEndpointServiceId string
    (AWS Only) The ID of the Databricks endpoint service that this VPC endpoint is connected to. Please find the list of endpoint service IDs for each supported region in the Databricks PrivateLink documentation
    AwsVpcEndpointId string
    ID of configured aws_vpc_endpoint
    GcpVpcEndpointInfo MwsVpcEndpointGcpVpcEndpointInfo
    a block consists of Google Cloud specific information for this PSC endpoint. It has the following fields:
    Region string
    Region of AWS VPC
    State string
    (AWS Only) State of VPC Endpoint
    UseCase string
    VpcEndpointId string
    Canonical unique identifier of VPC Endpoint in Databricks Account
    VpcEndpointName string
    Name of VPC Endpoint in Databricks Account
    AccountId string
    Account Id that could be found in the Accounts Console for AWS or GCP
    AwsAccountId string
    AwsEndpointServiceId string
    (AWS Only) The ID of the Databricks endpoint service that this VPC endpoint is connected to. Please find the list of endpoint service IDs for each supported region in the Databricks PrivateLink documentation
    AwsVpcEndpointId string
    ID of configured aws_vpc_endpoint
    GcpVpcEndpointInfo MwsVpcEndpointGcpVpcEndpointInfoArgs
    a block consists of Google Cloud specific information for this PSC endpoint. It has the following fields:
    Region string
    Region of AWS VPC
    State string
    (AWS Only) State of VPC Endpoint
    UseCase string
    VpcEndpointId string
    Canonical unique identifier of VPC Endpoint in Databricks Account
    vpcEndpointName String
    Name of VPC Endpoint in Databricks Account
    accountId String
    Account Id that could be found in the Accounts Console for AWS or GCP
    awsAccountId String
    awsEndpointServiceId String
    (AWS Only) The ID of the Databricks endpoint service that this VPC endpoint is connected to. Please find the list of endpoint service IDs for each supported region in the Databricks PrivateLink documentation
    awsVpcEndpointId String
    ID of configured aws_vpc_endpoint
    gcpVpcEndpointInfo MwsVpcEndpointGcpVpcEndpointInfo
    a block consists of Google Cloud specific information for this PSC endpoint. It has the following fields:
    region String
    Region of AWS VPC
    state String
    (AWS Only) State of VPC Endpoint
    useCase String
    vpcEndpointId String
    Canonical unique identifier of VPC Endpoint in Databricks Account
    vpcEndpointName string
    Name of VPC Endpoint in Databricks Account
    accountId string
    Account Id that could be found in the Accounts Console for AWS or GCP
    awsAccountId string
    awsEndpointServiceId string
    (AWS Only) The ID of the Databricks endpoint service that this VPC endpoint is connected to. Please find the list of endpoint service IDs for each supported region in the Databricks PrivateLink documentation
    awsVpcEndpointId string
    ID of configured aws_vpc_endpoint
    gcpVpcEndpointInfo MwsVpcEndpointGcpVpcEndpointInfo
    a block consists of Google Cloud specific information for this PSC endpoint. It has the following fields:
    region string
    Region of AWS VPC
    state string
    (AWS Only) State of VPC Endpoint
    useCase string
    vpcEndpointId string
    Canonical unique identifier of VPC Endpoint in Databricks Account
    vpc_endpoint_name str
    Name of VPC Endpoint in Databricks Account
    account_id str
    Account Id that could be found in the Accounts Console for AWS or GCP
    aws_account_id str
    aws_endpoint_service_id str
    (AWS Only) The ID of the Databricks endpoint service that this VPC endpoint is connected to. Please find the list of endpoint service IDs for each supported region in the Databricks PrivateLink documentation
    aws_vpc_endpoint_id str
    ID of configured aws_vpc_endpoint
    gcp_vpc_endpoint_info MwsVpcEndpointGcpVpcEndpointInfoArgs
    a block consists of Google Cloud specific information for this PSC endpoint. It has the following fields:
    region str
    Region of AWS VPC
    state str
    (AWS Only) State of VPC Endpoint
    use_case str
    vpc_endpoint_id str
    Canonical unique identifier of VPC Endpoint in Databricks Account
    vpcEndpointName String
    Name of VPC Endpoint in Databricks Account
    accountId String
    Account Id that could be found in the Accounts Console for AWS or GCP
    awsAccountId String
    awsEndpointServiceId String
    (AWS Only) The ID of the Databricks endpoint service that this VPC endpoint is connected to. Please find the list of endpoint service IDs for each supported region in the Databricks PrivateLink documentation
    awsVpcEndpointId String
    ID of configured aws_vpc_endpoint
    gcpVpcEndpointInfo Property Map
    a block consists of Google Cloud specific information for this PSC endpoint. It has the following fields:
    region String
    Region of AWS VPC
    state String
    (AWS Only) State of VPC Endpoint
    useCase String
    vpcEndpointId String
    Canonical unique identifier of VPC Endpoint in Databricks Account

    Outputs

    All input properties are implicitly available as output properties. Additionally, the MwsVpcEndpoint resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing MwsVpcEndpoint Resource

    Get an existing MwsVpcEndpoint resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: MwsVpcEndpointState, opts?: CustomResourceOptions): MwsVpcEndpoint
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        account_id: Optional[str] = None,
        aws_account_id: Optional[str] = None,
        aws_endpoint_service_id: Optional[str] = None,
        aws_vpc_endpoint_id: Optional[str] = None,
        gcp_vpc_endpoint_info: Optional[MwsVpcEndpointGcpVpcEndpointInfoArgs] = None,
        region: Optional[str] = None,
        state: Optional[str] = None,
        use_case: Optional[str] = None,
        vpc_endpoint_id: Optional[str] = None,
        vpc_endpoint_name: Optional[str] = None) -> MwsVpcEndpoint
    func GetMwsVpcEndpoint(ctx *Context, name string, id IDInput, state *MwsVpcEndpointState, opts ...ResourceOption) (*MwsVpcEndpoint, error)
    public static MwsVpcEndpoint Get(string name, Input<string> id, MwsVpcEndpointState? state, CustomResourceOptions? opts = null)
    public static MwsVpcEndpoint get(String name, Output<String> id, MwsVpcEndpointState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    AccountId string
    Account Id that could be found in the Accounts Console for AWS or GCP
    AwsAccountId string
    AwsEndpointServiceId string
    (AWS Only) The ID of the Databricks endpoint service that this VPC endpoint is connected to. Please find the list of endpoint service IDs for each supported region in the Databricks PrivateLink documentation
    AwsVpcEndpointId string
    ID of configured aws_vpc_endpoint
    GcpVpcEndpointInfo MwsVpcEndpointGcpVpcEndpointInfo
    a block consists of Google Cloud specific information for this PSC endpoint. It has the following fields:
    Region string
    Region of AWS VPC
    State string
    (AWS Only) State of VPC Endpoint
    UseCase string
    VpcEndpointId string
    Canonical unique identifier of VPC Endpoint in Databricks Account
    VpcEndpointName string
    Name of VPC Endpoint in Databricks Account
    AccountId string
    Account Id that could be found in the Accounts Console for AWS or GCP
    AwsAccountId string
    AwsEndpointServiceId string
    (AWS Only) The ID of the Databricks endpoint service that this VPC endpoint is connected to. Please find the list of endpoint service IDs for each supported region in the Databricks PrivateLink documentation
    AwsVpcEndpointId string
    ID of configured aws_vpc_endpoint
    GcpVpcEndpointInfo MwsVpcEndpointGcpVpcEndpointInfoArgs
    a block consists of Google Cloud specific information for this PSC endpoint. It has the following fields:
    Region string
    Region of AWS VPC
    State string
    (AWS Only) State of VPC Endpoint
    UseCase string
    VpcEndpointId string
    Canonical unique identifier of VPC Endpoint in Databricks Account
    VpcEndpointName string
    Name of VPC Endpoint in Databricks Account
    accountId String
    Account Id that could be found in the Accounts Console for AWS or GCP
    awsAccountId String
    awsEndpointServiceId String
    (AWS Only) The ID of the Databricks endpoint service that this VPC endpoint is connected to. Please find the list of endpoint service IDs for each supported region in the Databricks PrivateLink documentation
    awsVpcEndpointId String
    ID of configured aws_vpc_endpoint
    gcpVpcEndpointInfo MwsVpcEndpointGcpVpcEndpointInfo
    a block consists of Google Cloud specific information for this PSC endpoint. It has the following fields:
    region String
    Region of AWS VPC
    state String
    (AWS Only) State of VPC Endpoint
    useCase String
    vpcEndpointId String
    Canonical unique identifier of VPC Endpoint in Databricks Account
    vpcEndpointName String
    Name of VPC Endpoint in Databricks Account
    accountId string
    Account Id that could be found in the Accounts Console for AWS or GCP
    awsAccountId string
    awsEndpointServiceId string
    (AWS Only) The ID of the Databricks endpoint service that this VPC endpoint is connected to. Please find the list of endpoint service IDs for each supported region in the Databricks PrivateLink documentation
    awsVpcEndpointId string
    ID of configured aws_vpc_endpoint
    gcpVpcEndpointInfo MwsVpcEndpointGcpVpcEndpointInfo
    a block consists of Google Cloud specific information for this PSC endpoint. It has the following fields:
    region string
    Region of AWS VPC
    state string
    (AWS Only) State of VPC Endpoint
    useCase string
    vpcEndpointId string
    Canonical unique identifier of VPC Endpoint in Databricks Account
    vpcEndpointName string
    Name of VPC Endpoint in Databricks Account
    account_id str
    Account Id that could be found in the Accounts Console for AWS or GCP
    aws_account_id str
    aws_endpoint_service_id str
    (AWS Only) The ID of the Databricks endpoint service that this VPC endpoint is connected to. Please find the list of endpoint service IDs for each supported region in the Databricks PrivateLink documentation
    aws_vpc_endpoint_id str
    ID of configured aws_vpc_endpoint
    gcp_vpc_endpoint_info MwsVpcEndpointGcpVpcEndpointInfoArgs
    a block consists of Google Cloud specific information for this PSC endpoint. It has the following fields:
    region str
    Region of AWS VPC
    state str
    (AWS Only) State of VPC Endpoint
    use_case str
    vpc_endpoint_id str
    Canonical unique identifier of VPC Endpoint in Databricks Account
    vpc_endpoint_name str
    Name of VPC Endpoint in Databricks Account
    accountId String
    Account Id that could be found in the Accounts Console for AWS or GCP
    awsAccountId String
    awsEndpointServiceId String
    (AWS Only) The ID of the Databricks endpoint service that this VPC endpoint is connected to. Please find the list of endpoint service IDs for each supported region in the Databricks PrivateLink documentation
    awsVpcEndpointId String
    ID of configured aws_vpc_endpoint
    gcpVpcEndpointInfo Property Map
    a block consists of Google Cloud specific information for this PSC endpoint. It has the following fields:
    region String
    Region of AWS VPC
    state String
    (AWS Only) State of VPC Endpoint
    useCase String
    vpcEndpointId String
    Canonical unique identifier of VPC Endpoint in Databricks Account
    vpcEndpointName String
    Name of VPC Endpoint in Databricks Account

    Supporting Types

    MwsVpcEndpointGcpVpcEndpointInfo, MwsVpcEndpointGcpVpcEndpointInfoArgs

    EndpointRegion string
    Region of the PSC endpoint.
    ProjectId string
    The Google Cloud project ID of the VPC network where the PSC connection resides.
    PscEndpointName string
    The name of the PSC endpoint in the Google Cloud project.
    PscConnectionId string
    The unique ID of this PSC connection.
    ServiceAttachmentId string
    The service attachment this PSC connection connects to.
    EndpointRegion string
    Region of the PSC endpoint.
    ProjectId string
    The Google Cloud project ID of the VPC network where the PSC connection resides.
    PscEndpointName string
    The name of the PSC endpoint in the Google Cloud project.
    PscConnectionId string
    The unique ID of this PSC connection.
    ServiceAttachmentId string
    The service attachment this PSC connection connects to.
    endpointRegion String
    Region of the PSC endpoint.
    projectId String
    The Google Cloud project ID of the VPC network where the PSC connection resides.
    pscEndpointName String
    The name of the PSC endpoint in the Google Cloud project.
    pscConnectionId String
    The unique ID of this PSC connection.
    serviceAttachmentId String
    The service attachment this PSC connection connects to.
    endpointRegion string
    Region of the PSC endpoint.
    projectId string
    The Google Cloud project ID of the VPC network where the PSC connection resides.
    pscEndpointName string
    The name of the PSC endpoint in the Google Cloud project.
    pscConnectionId string
    The unique ID of this PSC connection.
    serviceAttachmentId string
    The service attachment this PSC connection connects to.
    endpoint_region str
    Region of the PSC endpoint.
    project_id str
    The Google Cloud project ID of the VPC network where the PSC connection resides.
    psc_endpoint_name str
    The name of the PSC endpoint in the Google Cloud project.
    psc_connection_id str
    The unique ID of this PSC connection.
    service_attachment_id str
    The service attachment this PSC connection connects to.
    endpointRegion String
    Region of the PSC endpoint.
    projectId String
    The Google Cloud project ID of the VPC network where the PSC connection resides.
    pscEndpointName String
    The name of the PSC endpoint in the Google Cloud project.
    pscConnectionId String
    The unique ID of this PSC connection.
    serviceAttachmentId String
    The service attachment this PSC connection connects to.

    Import

    -> Note Importing this resource is not currently supported.

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    databricks pulumi/pulumi-databricks
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the databricks Terraform Provider.
    databricks logo
    Databricks v1.50.2 published on Tuesday, Sep 24, 2024 by Pulumi
    pulumi/pulumi-databricks