1. Packages
  2. MongoDB Atlas
  3. API Docs
  4. PrivatelinkEndpointServiceServerless
MongoDB Atlas v3.16.2 published on Friday, Jun 21, 2024 by Pulumi

mongodbatlas.PrivatelinkEndpointServiceServerless

Explore with Pulumi AI

mongodbatlas logo
MongoDB Atlas v3.16.2 published on Friday, Jun 21, 2024 by Pulumi

    privatelink_endpoint_service_serverless Provides a Serverless PrivateLink Endpoint Service resource. This is the second of two resources required to configure PrivateLink for Serverless, the first is mongodbatlas_privatelink_endpoint_serverless.

    NOTE: Groups and projects are synonymous terms. You may find group_id in the official documentation. NOTE: Create waits for all serverless instances on the project to IDLE in order for their operations to complete. This ensures the latest connection strings can be retrieved following creation of this resource. Default timeout is 2hrs.

    Example with AWS

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    import * as mongodbatlas from "@pulumi/mongodbatlas";
    
    const testServerlessInstance = new mongodbatlas.ServerlessInstance("test", {
        projectId: "<PROJECT_ID>",
        name: "test-db",
        providerSettingsBackingProviderName: "AWS",
        providerSettingsProviderName: "SERVERLESS",
        providerSettingsRegionName: "US_EAST_1",
        continuousBackupEnabled: true,
    });
    const test = new mongodbatlas.PrivatelinkEndpointServerless("test", {
        projectId: "<PROJECT_ID>",
        instanceName: testServerlessInstance.name,
        providerName: "AWS",
    });
    const ptfeService = new aws.index.VpcEndpoint("ptfe_service", {
        vpcId: "vpc-7fc0a543",
        serviceName: test.endpointServiceName,
        vpcEndpointType: "Interface",
        subnetIds: ["subnet-de0406d2"],
        securityGroupIds: ["sg-3f238186"],
    });
    const testPrivatelinkEndpointServiceServerless = new mongodbatlas.PrivatelinkEndpointServiceServerless("test", {
        projectId: "<PROJECT_ID>",
        instanceName: testServerlessInstance.name,
        endpointId: test.endpointId,
        cloudProviderEndpointId: ptfeService.id,
        providerName: "AWS",
        comment: "New serverless endpoint",
    });
    
    import pulumi
    import pulumi_aws as aws
    import pulumi_mongodbatlas as mongodbatlas
    
    test_serverless_instance = mongodbatlas.ServerlessInstance("test",
        project_id="<PROJECT_ID>",
        name="test-db",
        provider_settings_backing_provider_name="AWS",
        provider_settings_provider_name="SERVERLESS",
        provider_settings_region_name="US_EAST_1",
        continuous_backup_enabled=True)
    test = mongodbatlas.PrivatelinkEndpointServerless("test",
        project_id="<PROJECT_ID>",
        instance_name=test_serverless_instance.name,
        provider_name="AWS")
    ptfe_service = aws.index.VpcEndpoint("ptfe_service",
        vpc_id=vpc-7fc0a543,
        service_name=test.endpoint_service_name,
        vpc_endpoint_type=Interface,
        subnet_ids=[subnet-de0406d2],
        security_group_ids=[sg-3f238186])
    test_privatelink_endpoint_service_serverless = mongodbatlas.PrivatelinkEndpointServiceServerless("test",
        project_id="<PROJECT_ID>",
        instance_name=test_serverless_instance.name,
        endpoint_id=test.endpoint_id,
        cloud_provider_endpoint_id=ptfe_service["id"],
        provider_name="AWS",
        comment="New serverless endpoint")
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v4/go/aws"
    	"github.com/pulumi/pulumi-mongodbatlas/sdk/v3/go/mongodbatlas"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		testServerlessInstance, err := mongodbatlas.NewServerlessInstance(ctx, "test", &mongodbatlas.ServerlessInstanceArgs{
    			ProjectId:                           pulumi.String("<PROJECT_ID>"),
    			Name:                                pulumi.String("test-db"),
    			ProviderSettingsBackingProviderName: pulumi.String("AWS"),
    			ProviderSettingsProviderName:        pulumi.String("SERVERLESS"),
    			ProviderSettingsRegionName:          pulumi.String("US_EAST_1"),
    			ContinuousBackupEnabled:             pulumi.Bool(true),
    		})
    		if err != nil {
    			return err
    		}
    		test, err := mongodbatlas.NewPrivatelinkEndpointServerless(ctx, "test", &mongodbatlas.PrivatelinkEndpointServerlessArgs{
    			ProjectId:    pulumi.String("<PROJECT_ID>"),
    			InstanceName: testServerlessInstance.Name,
    			ProviderName: pulumi.String("AWS"),
    		})
    		if err != nil {
    			return err
    		}
    		ptfeService, err := aws.NewVpcEndpoint(ctx, "ptfe_service", &aws.VpcEndpointArgs{
    			VpcId:           "vpc-7fc0a543",
    			ServiceName:     test.EndpointServiceName,
    			VpcEndpointType: "Interface",
    			SubnetIds: []string{
    				"subnet-de0406d2",
    			},
    			SecurityGroupIds: []string{
    				"sg-3f238186",
    			},
    		})
    		if err != nil {
    			return err
    		}
    		_, err = mongodbatlas.NewPrivatelinkEndpointServiceServerless(ctx, "test", &mongodbatlas.PrivatelinkEndpointServiceServerlessArgs{
    			ProjectId:               pulumi.String("<PROJECT_ID>"),
    			InstanceName:            testServerlessInstance.Name,
    			EndpointId:              test.EndpointId,
    			CloudProviderEndpointId: ptfeService.Id,
    			ProviderName:            pulumi.String("AWS"),
    			Comment:                 pulumi.String("New serverless endpoint"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    using Mongodbatlas = Pulumi.Mongodbatlas;
    
    return await Deployment.RunAsync(() => 
    {
        var testServerlessInstance = new Mongodbatlas.ServerlessInstance("test", new()
        {
            ProjectId = "<PROJECT_ID>",
            Name = "test-db",
            ProviderSettingsBackingProviderName = "AWS",
            ProviderSettingsProviderName = "SERVERLESS",
            ProviderSettingsRegionName = "US_EAST_1",
            ContinuousBackupEnabled = true,
        });
    
        var test = new Mongodbatlas.PrivatelinkEndpointServerless("test", new()
        {
            ProjectId = "<PROJECT_ID>",
            InstanceName = testServerlessInstance.Name,
            ProviderName = "AWS",
        });
    
        var ptfeService = new Aws.Index.VpcEndpoint("ptfe_service", new()
        {
            VpcId = "vpc-7fc0a543",
            ServiceName = test.EndpointServiceName,
            VpcEndpointType = "Interface",
            SubnetIds = new[]
            {
                "subnet-de0406d2",
            },
            SecurityGroupIds = new[]
            {
                "sg-3f238186",
            },
        });
    
        var testPrivatelinkEndpointServiceServerless = new Mongodbatlas.PrivatelinkEndpointServiceServerless("test", new()
        {
            ProjectId = "<PROJECT_ID>",
            InstanceName = testServerlessInstance.Name,
            EndpointId = test.EndpointId,
            CloudProviderEndpointId = ptfeService.Id,
            ProviderName = "AWS",
            Comment = "New serverless endpoint",
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.mongodbatlas.ServerlessInstance;
    import com.pulumi.mongodbatlas.ServerlessInstanceArgs;
    import com.pulumi.mongodbatlas.PrivatelinkEndpointServerless;
    import com.pulumi.mongodbatlas.PrivatelinkEndpointServerlessArgs;
    import com.pulumi.aws.vpcEndpoint;
    import com.pulumi.aws.VpcEndpointArgs;
    import com.pulumi.mongodbatlas.PrivatelinkEndpointServiceServerless;
    import com.pulumi.mongodbatlas.PrivatelinkEndpointServiceServerlessArgs;
    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 testServerlessInstance = new ServerlessInstance("testServerlessInstance", ServerlessInstanceArgs.builder()
                .projectId("<PROJECT_ID>")
                .name("test-db")
                .providerSettingsBackingProviderName("AWS")
                .providerSettingsProviderName("SERVERLESS")
                .providerSettingsRegionName("US_EAST_1")
                .continuousBackupEnabled(true)
                .build());
    
            var test = new PrivatelinkEndpointServerless("test", PrivatelinkEndpointServerlessArgs.builder()
                .projectId("<PROJECT_ID>")
                .instanceName(testServerlessInstance.name())
                .providerName("AWS")
                .build());
    
            var ptfeService = new VpcEndpoint("ptfeService", VpcEndpointArgs.builder()
                .vpcId("vpc-7fc0a543")
                .serviceName(test.endpointServiceName())
                .vpcEndpointType("Interface")
                .subnetIds("subnet-de0406d2")
                .securityGroupIds("sg-3f238186")
                .build());
    
            var testPrivatelinkEndpointServiceServerless = new PrivatelinkEndpointServiceServerless("testPrivatelinkEndpointServiceServerless", PrivatelinkEndpointServiceServerlessArgs.builder()
                .projectId("<PROJECT_ID>")
                .instanceName(testServerlessInstance.name())
                .endpointId(test.endpointId())
                .cloudProviderEndpointId(ptfeService.id())
                .providerName("AWS")
                .comment("New serverless endpoint")
                .build());
    
        }
    }
    
    resources:
      test:
        type: mongodbatlas:PrivatelinkEndpointServerless
        properties:
          projectId: <PROJECT_ID>
          instanceName: ${testServerlessInstance.name}
          providerName: AWS
      ptfeService:
        type: aws:vpcEndpoint
        name: ptfe_service
        properties:
          vpcId: vpc-7fc0a543
          serviceName: ${test.endpointServiceName}
          vpcEndpointType: Interface
          subnetIds:
            - subnet-de0406d2
          securityGroupIds:
            - sg-3f238186
      testPrivatelinkEndpointServiceServerless:
        type: mongodbatlas:PrivatelinkEndpointServiceServerless
        name: test
        properties:
          projectId: <PROJECT_ID>
          instanceName: ${testServerlessInstance.name}
          endpointId: ${test.endpointId}
          cloudProviderEndpointId: ${ptfeService.id}
          providerName: AWS
          comment: New serverless endpoint
      testServerlessInstance:
        type: mongodbatlas:ServerlessInstance
        name: test
        properties:
          projectId: <PROJECT_ID>
          name: test-db
          providerSettingsBackingProviderName: AWS
          providerSettingsProviderName: SERVERLESS
          providerSettingsRegionName: US_EAST_1
          continuousBackupEnabled: true
    

    Example with AZURE

    import * as pulumi from "@pulumi/pulumi";
    import * as azurerm from "@pulumi/azurerm";
    import * as mongodbatlas from "@pulumi/mongodbatlas";
    
    const test = new mongodbatlas.PrivatelinkEndpointServerless("test", {
        projectId: projectId,
        providerName: "AZURE",
    });
    const testPrivateEndpoint = new azurerm.index.PrivateEndpoint("test", {
        name: "endpoint-test",
        location: testAzurermResourceGroup.location,
        resourceGroupName: resourceGroupName,
        subnetId: testAzurermSubnet.id,
        privateServiceConnection: [{
            name: test.privateLinkServiceName,
            privateConnectionResourceId: test.privateLinkServiceResourceId,
            isManualConnection: true,
            requestMessage: "Azure Private Link test",
        }],
    });
    const testServerlessInstance = new mongodbatlas.ServerlessInstance("test", {
        projectId: "<PROJECT_ID>",
        name: "test-db",
        providerSettingsBackingProviderName: "AZURE",
        providerSettingsProviderName: "SERVERLESS",
        providerSettingsRegionName: "US_EAST",
        continuousBackupEnabled: true,
    });
    const testPrivatelinkEndpointServiceServerless = new mongodbatlas.PrivatelinkEndpointServiceServerless("test", {
        projectId: test.projectId,
        instanceName: testServerlessInstance.name,
        endpointId: test.endpointId,
        cloudProviderEndpointId: testPrivateEndpoint.id,
        privateEndpointIpAddress: testPrivateEndpoint.privateServiceConnection[0].privateIpAddress,
        providerName: "AZURE",
        comment: "test",
    });
    
    import pulumi
    import pulumi_azurerm as azurerm
    import pulumi_mongodbatlas as mongodbatlas
    
    test = mongodbatlas.PrivatelinkEndpointServerless("test",
        project_id=project_id,
        provider_name="AZURE")
    test_private_endpoint = azurerm.index.PrivateEndpoint("test",
        name=endpoint-test,
        location=test_azurerm_resource_group.location,
        resource_group_name=resource_group_name,
        subnet_id=test_azurerm_subnet.id,
        private_service_connection=[{
            name: test.private_link_service_name,
            privateConnectionResourceId: test.private_link_service_resource_id,
            isManualConnection: True,
            requestMessage: Azure Private Link test,
        }])
    test_serverless_instance = mongodbatlas.ServerlessInstance("test",
        project_id="<PROJECT_ID>",
        name="test-db",
        provider_settings_backing_provider_name="AZURE",
        provider_settings_provider_name="SERVERLESS",
        provider_settings_region_name="US_EAST",
        continuous_backup_enabled=True)
    test_privatelink_endpoint_service_serverless = mongodbatlas.PrivatelinkEndpointServiceServerless("test",
        project_id=test.project_id,
        instance_name=test_serverless_instance.name,
        endpoint_id=test.endpoint_id,
        cloud_provider_endpoint_id=test_private_endpoint["id"],
        private_endpoint_ip_address=test_private_endpoint["privateServiceConnection"][0]["privateIpAddress"],
        provider_name="AZURE",
        comment="test")
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-azurerm/sdk/v1/go/azurerm"
    	"github.com/pulumi/pulumi-mongodbatlas/sdk/v3/go/mongodbatlas"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		test, err := mongodbatlas.NewPrivatelinkEndpointServerless(ctx, "test", &mongodbatlas.PrivatelinkEndpointServerlessArgs{
    			ProjectId:    pulumi.Any(projectId),
    			ProviderName: pulumi.String("AZURE"),
    		})
    		if err != nil {
    			return err
    		}
    		testPrivateEndpoint, err := index.NewPrivateEndpoint(ctx, "test", &index.PrivateEndpointArgs{
    			Name:              "endpoint-test",
    			Location:          testAzurermResourceGroup.Location,
    			ResourceGroupName: resourceGroupName,
    			SubnetId:          testAzurermSubnet.Id,
    			PrivateServiceConnection: []map[string]interface{}{
    				map[string]interface{}{
    					"name":                        test.PrivateLinkServiceName,
    					"privateConnectionResourceId": test.PrivateLinkServiceResourceId,
    					"isManualConnection":          true,
    					"requestMessage":              "Azure Private Link test",
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		testServerlessInstance, err := mongodbatlas.NewServerlessInstance(ctx, "test", &mongodbatlas.ServerlessInstanceArgs{
    			ProjectId:                           pulumi.String("<PROJECT_ID>"),
    			Name:                                pulumi.String("test-db"),
    			ProviderSettingsBackingProviderName: pulumi.String("AZURE"),
    			ProviderSettingsProviderName:        pulumi.String("SERVERLESS"),
    			ProviderSettingsRegionName:          pulumi.String("US_EAST"),
    			ContinuousBackupEnabled:             pulumi.Bool(true),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = mongodbatlas.NewPrivatelinkEndpointServiceServerless(ctx, "test", &mongodbatlas.PrivatelinkEndpointServiceServerlessArgs{
    			ProjectId:                test.ProjectId,
    			InstanceName:             testServerlessInstance.Name,
    			EndpointId:               test.EndpointId,
    			CloudProviderEndpointId:  testPrivateEndpoint.Id,
    			PrivateEndpointIpAddress: testPrivateEndpoint.PrivateServiceConnection[0].PrivateIpAddress,
    			ProviderName:             pulumi.String("AZURE"),
    			Comment:                  pulumi.String("test"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Azurerm = Pulumi.Azurerm;
    using Mongodbatlas = Pulumi.Mongodbatlas;
    
    return await Deployment.RunAsync(() => 
    {
        var test = new Mongodbatlas.PrivatelinkEndpointServerless("test", new()
        {
            ProjectId = projectId,
            ProviderName = "AZURE",
        });
    
        var testPrivateEndpoint = new Azurerm.Index.PrivateEndpoint("test", new()
        {
            Name = "endpoint-test",
            Location = testAzurermResourceGroup.Location,
            ResourceGroupName = resourceGroupName,
            SubnetId = testAzurermSubnet.Id,
            PrivateServiceConnection = new[]
            {
                
                {
                    { "name", test.PrivateLinkServiceName },
                    { "privateConnectionResourceId", test.PrivateLinkServiceResourceId },
                    { "isManualConnection", true },
                    { "requestMessage", "Azure Private Link test" },
                },
            },
        });
    
        var testServerlessInstance = new Mongodbatlas.ServerlessInstance("test", new()
        {
            ProjectId = "<PROJECT_ID>",
            Name = "test-db",
            ProviderSettingsBackingProviderName = "AZURE",
            ProviderSettingsProviderName = "SERVERLESS",
            ProviderSettingsRegionName = "US_EAST",
            ContinuousBackupEnabled = true,
        });
    
        var testPrivatelinkEndpointServiceServerless = new Mongodbatlas.PrivatelinkEndpointServiceServerless("test", new()
        {
            ProjectId = test.ProjectId,
            InstanceName = testServerlessInstance.Name,
            EndpointId = test.EndpointId,
            CloudProviderEndpointId = testPrivateEndpoint.Id,
            PrivateEndpointIpAddress = testPrivateEndpoint.PrivateServiceConnection[0].PrivateIpAddress,
            ProviderName = "AZURE",
            Comment = "test",
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.mongodbatlas.PrivatelinkEndpointServerless;
    import com.pulumi.mongodbatlas.PrivatelinkEndpointServerlessArgs;
    import com.pulumi.azurerm.privateEndpoint;
    import com.pulumi.azurerm.PrivateEndpointArgs;
    import com.pulumi.mongodbatlas.ServerlessInstance;
    import com.pulumi.mongodbatlas.ServerlessInstanceArgs;
    import com.pulumi.mongodbatlas.PrivatelinkEndpointServiceServerless;
    import com.pulumi.mongodbatlas.PrivatelinkEndpointServiceServerlessArgs;
    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 test = new PrivatelinkEndpointServerless("test", PrivatelinkEndpointServerlessArgs.builder()
                .projectId(projectId)
                .providerName("AZURE")
                .build());
    
            var testPrivateEndpoint = new PrivateEndpoint("testPrivateEndpoint", PrivateEndpointArgs.builder()
                .name("endpoint-test")
                .location(testAzurermResourceGroup.location())
                .resourceGroupName(resourceGroupName)
                .subnetId(testAzurermSubnet.id())
                .privateServiceConnection(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                .build());
    
            var testServerlessInstance = new ServerlessInstance("testServerlessInstance", ServerlessInstanceArgs.builder()
                .projectId("<PROJECT_ID>")
                .name("test-db")
                .providerSettingsBackingProviderName("AZURE")
                .providerSettingsProviderName("SERVERLESS")
                .providerSettingsRegionName("US_EAST")
                .continuousBackupEnabled(true)
                .build());
    
            var testPrivatelinkEndpointServiceServerless = new PrivatelinkEndpointServiceServerless("testPrivatelinkEndpointServiceServerless", PrivatelinkEndpointServiceServerlessArgs.builder()
                .projectId(test.projectId())
                .instanceName(testServerlessInstance.name())
                .endpointId(test.endpointId())
                .cloudProviderEndpointId(testPrivateEndpoint.id())
                .privateEndpointIpAddress(testPrivateEndpoint.privateServiceConnection()[0].privateIpAddress())
                .providerName("AZURE")
                .comment("test")
                .build());
    
        }
    }
    
    resources:
      test:
        type: mongodbatlas:PrivatelinkEndpointServerless
        properties:
          projectId: ${projectId}
          providerName: AZURE
      testPrivateEndpoint:
        type: azurerm:privateEndpoint
        name: test
        properties:
          name: endpoint-test
          location: ${testAzurermResourceGroup.location}
          resourceGroupName: ${resourceGroupName}
          subnetId: ${testAzurermSubnet.id}
          privateServiceConnection:
            - name: ${test.privateLinkServiceName}
              privateConnectionResourceId: ${test.privateLinkServiceResourceId}
              isManualConnection: true
              requestMessage: Azure Private Link test
      testPrivatelinkEndpointServiceServerless:
        type: mongodbatlas:PrivatelinkEndpointServiceServerless
        name: test
        properties:
          projectId: ${test.projectId}
          instanceName: ${testServerlessInstance.name}
          endpointId: ${test.endpointId}
          cloudProviderEndpointId: ${testPrivateEndpoint.id}
          privateEndpointIpAddress: ${testPrivateEndpoint.privateServiceConnection[0].privateIpAddress}
          providerName: AZURE
          comment: test
      testServerlessInstance:
        type: mongodbatlas:ServerlessInstance
        name: test
        properties:
          projectId: <PROJECT_ID>
          name: test-db
          providerSettingsBackingProviderName: AZURE
          providerSettingsProviderName: SERVERLESS
          providerSettingsRegionName: US_EAST
          continuousBackupEnabled: true
    

    Available complete examples

    • Setup private connection to a MongoDB Atlas Serverless Instance with AWS VPC

    Create PrivatelinkEndpointServiceServerless Resource

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

    Constructor syntax

    new PrivatelinkEndpointServiceServerless(name: string, args: PrivatelinkEndpointServiceServerlessArgs, opts?: CustomResourceOptions);
    @overload
    def PrivatelinkEndpointServiceServerless(resource_name: str,
                                             args: PrivatelinkEndpointServiceServerlessArgs,
                                             opts: Optional[ResourceOptions] = None)
    
    @overload
    def PrivatelinkEndpointServiceServerless(resource_name: str,
                                             opts: Optional[ResourceOptions] = None,
                                             endpoint_id: Optional[str] = None,
                                             instance_name: Optional[str] = None,
                                             project_id: Optional[str] = None,
                                             provider_name: Optional[str] = None,
                                             cloud_provider_endpoint_id: Optional[str] = None,
                                             comment: Optional[str] = None,
                                             private_endpoint_ip_address: Optional[str] = None)
    func NewPrivatelinkEndpointServiceServerless(ctx *Context, name string, args PrivatelinkEndpointServiceServerlessArgs, opts ...ResourceOption) (*PrivatelinkEndpointServiceServerless, error)
    public PrivatelinkEndpointServiceServerless(string name, PrivatelinkEndpointServiceServerlessArgs args, CustomResourceOptions? opts = null)
    public PrivatelinkEndpointServiceServerless(String name, PrivatelinkEndpointServiceServerlessArgs args)
    public PrivatelinkEndpointServiceServerless(String name, PrivatelinkEndpointServiceServerlessArgs args, CustomResourceOptions options)
    
    type: mongodbatlas:PrivatelinkEndpointServiceServerless
    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 PrivatelinkEndpointServiceServerlessArgs
    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 PrivatelinkEndpointServiceServerlessArgs
    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 PrivatelinkEndpointServiceServerlessArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args PrivatelinkEndpointServiceServerlessArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args PrivatelinkEndpointServiceServerlessArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

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

    var privatelinkEndpointServiceServerlessResource = new Mongodbatlas.PrivatelinkEndpointServiceServerless("privatelinkEndpointServiceServerlessResource", new()
    {
        EndpointId = "string",
        InstanceName = "string",
        ProjectId = "string",
        ProviderName = "string",
        CloudProviderEndpointId = "string",
        Comment = "string",
        PrivateEndpointIpAddress = "string",
    });
    
    example, err := mongodbatlas.NewPrivatelinkEndpointServiceServerless(ctx, "privatelinkEndpointServiceServerlessResource", &mongodbatlas.PrivatelinkEndpointServiceServerlessArgs{
    	EndpointId:               pulumi.String("string"),
    	InstanceName:             pulumi.String("string"),
    	ProjectId:                pulumi.String("string"),
    	ProviderName:             pulumi.String("string"),
    	CloudProviderEndpointId:  pulumi.String("string"),
    	Comment:                  pulumi.String("string"),
    	PrivateEndpointIpAddress: pulumi.String("string"),
    })
    
    var privatelinkEndpointServiceServerlessResource = new PrivatelinkEndpointServiceServerless("privatelinkEndpointServiceServerlessResource", PrivatelinkEndpointServiceServerlessArgs.builder()
        .endpointId("string")
        .instanceName("string")
        .projectId("string")
        .providerName("string")
        .cloudProviderEndpointId("string")
        .comment("string")
        .privateEndpointIpAddress("string")
        .build());
    
    privatelink_endpoint_service_serverless_resource = mongodbatlas.PrivatelinkEndpointServiceServerless("privatelinkEndpointServiceServerlessResource",
        endpoint_id="string",
        instance_name="string",
        project_id="string",
        provider_name="string",
        cloud_provider_endpoint_id="string",
        comment="string",
        private_endpoint_ip_address="string")
    
    const privatelinkEndpointServiceServerlessResource = new mongodbatlas.PrivatelinkEndpointServiceServerless("privatelinkEndpointServiceServerlessResource", {
        endpointId: "string",
        instanceName: "string",
        projectId: "string",
        providerName: "string",
        cloudProviderEndpointId: "string",
        comment: "string",
        privateEndpointIpAddress: "string",
    });
    
    type: mongodbatlas:PrivatelinkEndpointServiceServerless
    properties:
        cloudProviderEndpointId: string
        comment: string
        endpointId: string
        instanceName: string
        privateEndpointIpAddress: string
        projectId: string
        providerName: string
    

    PrivatelinkEndpointServiceServerless 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 PrivatelinkEndpointServiceServerless resource accepts the following input properties:

    EndpointId string
    Unique 24-hexadecimal digit string that identifies the private endpoint.
    InstanceName string
    Human-readable label that identifies the serverless instance.
    ProjectId string
    Unique 24-digit hexadecimal string that identifies the project.
    ProviderName string
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE.
    CloudProviderEndpointId string
    Unique string that identifies the private endpoint's network interface.
    Comment string
    Human-readable string to associate with this private endpoint.
    PrivateEndpointIpAddress string
    IPv4 address of the private endpoint in your Azure VNet that someone added to this private endpoint service.
    EndpointId string
    Unique 24-hexadecimal digit string that identifies the private endpoint.
    InstanceName string
    Human-readable label that identifies the serverless instance.
    ProjectId string
    Unique 24-digit hexadecimal string that identifies the project.
    ProviderName string
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE.
    CloudProviderEndpointId string
    Unique string that identifies the private endpoint's network interface.
    Comment string
    Human-readable string to associate with this private endpoint.
    PrivateEndpointIpAddress string
    IPv4 address of the private endpoint in your Azure VNet that someone added to this private endpoint service.
    endpointId String
    Unique 24-hexadecimal digit string that identifies the private endpoint.
    instanceName String
    Human-readable label that identifies the serverless instance.
    projectId String
    Unique 24-digit hexadecimal string that identifies the project.
    providerName String
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE.
    cloudProviderEndpointId String
    Unique string that identifies the private endpoint's network interface.
    comment String
    Human-readable string to associate with this private endpoint.
    privateEndpointIpAddress String
    IPv4 address of the private endpoint in your Azure VNet that someone added to this private endpoint service.
    endpointId string
    Unique 24-hexadecimal digit string that identifies the private endpoint.
    instanceName string
    Human-readable label that identifies the serverless instance.
    projectId string
    Unique 24-digit hexadecimal string that identifies the project.
    providerName string
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE.
    cloudProviderEndpointId string
    Unique string that identifies the private endpoint's network interface.
    comment string
    Human-readable string to associate with this private endpoint.
    privateEndpointIpAddress string
    IPv4 address of the private endpoint in your Azure VNet that someone added to this private endpoint service.
    endpoint_id str
    Unique 24-hexadecimal digit string that identifies the private endpoint.
    instance_name str
    Human-readable label that identifies the serverless instance.
    project_id str
    Unique 24-digit hexadecimal string that identifies the project.
    provider_name str
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE.
    cloud_provider_endpoint_id str
    Unique string that identifies the private endpoint's network interface.
    comment str
    Human-readable string to associate with this private endpoint.
    private_endpoint_ip_address str
    IPv4 address of the private endpoint in your Azure VNet that someone added to this private endpoint service.
    endpointId String
    Unique 24-hexadecimal digit string that identifies the private endpoint.
    instanceName String
    Human-readable label that identifies the serverless instance.
    projectId String
    Unique 24-digit hexadecimal string that identifies the project.
    providerName String
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE.
    cloudProviderEndpointId String
    Unique string that identifies the private endpoint's network interface.
    comment String
    Human-readable string to associate with this private endpoint.
    privateEndpointIpAddress String
    IPv4 address of the private endpoint in your Azure VNet that someone added to this private endpoint service.

    Outputs

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

    Id string
    The provider-assigned unique ID for this managed resource.
    PrivateLinkServiceResourceId string
    Root-relative path that identifies the Azure Private Link Service that MongoDB Cloud manages.
    Status string
    Human-readable label that indicates the current operating status of the private endpoint. Values include: RESERVATION_REQUESTED, RESERVED, INITIATING, AVAILABLE, FAILED, DELETING.
    Id string
    The provider-assigned unique ID for this managed resource.
    PrivateLinkServiceResourceId string
    Root-relative path that identifies the Azure Private Link Service that MongoDB Cloud manages.
    Status string
    Human-readable label that indicates the current operating status of the private endpoint. Values include: RESERVATION_REQUESTED, RESERVED, INITIATING, AVAILABLE, FAILED, DELETING.
    id String
    The provider-assigned unique ID for this managed resource.
    privateLinkServiceResourceId String
    Root-relative path that identifies the Azure Private Link Service that MongoDB Cloud manages.
    status String
    Human-readable label that indicates the current operating status of the private endpoint. Values include: RESERVATION_REQUESTED, RESERVED, INITIATING, AVAILABLE, FAILED, DELETING.
    id string
    The provider-assigned unique ID for this managed resource.
    privateLinkServiceResourceId string
    Root-relative path that identifies the Azure Private Link Service that MongoDB Cloud manages.
    status string
    Human-readable label that indicates the current operating status of the private endpoint. Values include: RESERVATION_REQUESTED, RESERVED, INITIATING, AVAILABLE, FAILED, DELETING.
    id str
    The provider-assigned unique ID for this managed resource.
    private_link_service_resource_id str
    Root-relative path that identifies the Azure Private Link Service that MongoDB Cloud manages.
    status str
    Human-readable label that indicates the current operating status of the private endpoint. Values include: RESERVATION_REQUESTED, RESERVED, INITIATING, AVAILABLE, FAILED, DELETING.
    id String
    The provider-assigned unique ID for this managed resource.
    privateLinkServiceResourceId String
    Root-relative path that identifies the Azure Private Link Service that MongoDB Cloud manages.
    status String
    Human-readable label that indicates the current operating status of the private endpoint. Values include: RESERVATION_REQUESTED, RESERVED, INITIATING, AVAILABLE, FAILED, DELETING.

    Look up Existing PrivatelinkEndpointServiceServerless Resource

    Get an existing PrivatelinkEndpointServiceServerless 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?: PrivatelinkEndpointServiceServerlessState, opts?: CustomResourceOptions): PrivatelinkEndpointServiceServerless
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            cloud_provider_endpoint_id: Optional[str] = None,
            comment: Optional[str] = None,
            endpoint_id: Optional[str] = None,
            instance_name: Optional[str] = None,
            private_endpoint_ip_address: Optional[str] = None,
            private_link_service_resource_id: Optional[str] = None,
            project_id: Optional[str] = None,
            provider_name: Optional[str] = None,
            status: Optional[str] = None) -> PrivatelinkEndpointServiceServerless
    func GetPrivatelinkEndpointServiceServerless(ctx *Context, name string, id IDInput, state *PrivatelinkEndpointServiceServerlessState, opts ...ResourceOption) (*PrivatelinkEndpointServiceServerless, error)
    public static PrivatelinkEndpointServiceServerless Get(string name, Input<string> id, PrivatelinkEndpointServiceServerlessState? state, CustomResourceOptions? opts = null)
    public static PrivatelinkEndpointServiceServerless get(String name, Output<String> id, PrivatelinkEndpointServiceServerlessState 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:
    CloudProviderEndpointId string
    Unique string that identifies the private endpoint's network interface.
    Comment string
    Human-readable string to associate with this private endpoint.
    EndpointId string
    Unique 24-hexadecimal digit string that identifies the private endpoint.
    InstanceName string
    Human-readable label that identifies the serverless instance.
    PrivateEndpointIpAddress string
    IPv4 address of the private endpoint in your Azure VNet that someone added to this private endpoint service.
    PrivateLinkServiceResourceId string
    Root-relative path that identifies the Azure Private Link Service that MongoDB Cloud manages.
    ProjectId string
    Unique 24-digit hexadecimal string that identifies the project.
    ProviderName string
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE.
    Status string
    Human-readable label that indicates the current operating status of the private endpoint. Values include: RESERVATION_REQUESTED, RESERVED, INITIATING, AVAILABLE, FAILED, DELETING.
    CloudProviderEndpointId string
    Unique string that identifies the private endpoint's network interface.
    Comment string
    Human-readable string to associate with this private endpoint.
    EndpointId string
    Unique 24-hexadecimal digit string that identifies the private endpoint.
    InstanceName string
    Human-readable label that identifies the serverless instance.
    PrivateEndpointIpAddress string
    IPv4 address of the private endpoint in your Azure VNet that someone added to this private endpoint service.
    PrivateLinkServiceResourceId string
    Root-relative path that identifies the Azure Private Link Service that MongoDB Cloud manages.
    ProjectId string
    Unique 24-digit hexadecimal string that identifies the project.
    ProviderName string
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE.
    Status string
    Human-readable label that indicates the current operating status of the private endpoint. Values include: RESERVATION_REQUESTED, RESERVED, INITIATING, AVAILABLE, FAILED, DELETING.
    cloudProviderEndpointId String
    Unique string that identifies the private endpoint's network interface.
    comment String
    Human-readable string to associate with this private endpoint.
    endpointId String
    Unique 24-hexadecimal digit string that identifies the private endpoint.
    instanceName String
    Human-readable label that identifies the serverless instance.
    privateEndpointIpAddress String
    IPv4 address of the private endpoint in your Azure VNet that someone added to this private endpoint service.
    privateLinkServiceResourceId String
    Root-relative path that identifies the Azure Private Link Service that MongoDB Cloud manages.
    projectId String
    Unique 24-digit hexadecimal string that identifies the project.
    providerName String
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE.
    status String
    Human-readable label that indicates the current operating status of the private endpoint. Values include: RESERVATION_REQUESTED, RESERVED, INITIATING, AVAILABLE, FAILED, DELETING.
    cloudProviderEndpointId string
    Unique string that identifies the private endpoint's network interface.
    comment string
    Human-readable string to associate with this private endpoint.
    endpointId string
    Unique 24-hexadecimal digit string that identifies the private endpoint.
    instanceName string
    Human-readable label that identifies the serverless instance.
    privateEndpointIpAddress string
    IPv4 address of the private endpoint in your Azure VNet that someone added to this private endpoint service.
    privateLinkServiceResourceId string
    Root-relative path that identifies the Azure Private Link Service that MongoDB Cloud manages.
    projectId string
    Unique 24-digit hexadecimal string that identifies the project.
    providerName string
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE.
    status string
    Human-readable label that indicates the current operating status of the private endpoint. Values include: RESERVATION_REQUESTED, RESERVED, INITIATING, AVAILABLE, FAILED, DELETING.
    cloud_provider_endpoint_id str
    Unique string that identifies the private endpoint's network interface.
    comment str
    Human-readable string to associate with this private endpoint.
    endpoint_id str
    Unique 24-hexadecimal digit string that identifies the private endpoint.
    instance_name str
    Human-readable label that identifies the serverless instance.
    private_endpoint_ip_address str
    IPv4 address of the private endpoint in your Azure VNet that someone added to this private endpoint service.
    private_link_service_resource_id str
    Root-relative path that identifies the Azure Private Link Service that MongoDB Cloud manages.
    project_id str
    Unique 24-digit hexadecimal string that identifies the project.
    provider_name str
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE.
    status str
    Human-readable label that indicates the current operating status of the private endpoint. Values include: RESERVATION_REQUESTED, RESERVED, INITIATING, AVAILABLE, FAILED, DELETING.
    cloudProviderEndpointId String
    Unique string that identifies the private endpoint's network interface.
    comment String
    Human-readable string to associate with this private endpoint.
    endpointId String
    Unique 24-hexadecimal digit string that identifies the private endpoint.
    instanceName String
    Human-readable label that identifies the serverless instance.
    privateEndpointIpAddress String
    IPv4 address of the private endpoint in your Azure VNet that someone added to this private endpoint service.
    privateLinkServiceResourceId String
    Root-relative path that identifies the Azure Private Link Service that MongoDB Cloud manages.
    projectId String
    Unique 24-digit hexadecimal string that identifies the project.
    providerName String
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE.
    status String
    Human-readable label that indicates the current operating status of the private endpoint. Values include: RESERVATION_REQUESTED, RESERVED, INITIATING, AVAILABLE, FAILED, DELETING.

    Import

    Serverless privatelink endpoint can be imported using project ID and endpoint ID, in the format project_idendpoint_id, e.g.

    $ pulumi import mongodbatlas:index/privatelinkEndpointServiceServerless:PrivatelinkEndpointServiceServerless test 1112222b3bf99403840e8934--serverless_name--vpce-jjg5e24qp93513h03
    

    For more information see: MongoDB Atlas API - Serverless Private Endpoints.

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

    Package Details

    Repository
    MongoDB Atlas pulumi/pulumi-mongodbatlas
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the mongodbatlas Terraform Provider.
    mongodbatlas logo
    MongoDB Atlas v3.16.2 published on Friday, Jun 21, 2024 by Pulumi