Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Mongodbatlas Provider
  3. API Docs
  4. PrivatelinkEndpointServiceServerless
MongoDB Atlas v3.30.0 published on Friday, Mar 21, 2025 by Pulumi
pulumi/pulumi-mongodbatlas

mongodbatlas.PrivatelinkEndpointServiceServerless

Explore with Pulumi AI

mongodbatlas logo
MongoDB Atlas v3.30.0 published on Friday, Mar 21, 2025 by Pulumi
pulumi/pulumi-mongodbatlas

    WARNING: This resource is deprecated and will be removed in March 2025. For more datails see Migration Guide: Transition out of Serverless Instances and Shared-tier clusters

    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/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 := azurerm.NewPrivateEndpoint(ctx, "test", &azurerm.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.

    Constructor 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

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    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)
    resources:  _:    type: mongodbatlas:PrivatelinkEndpointServiceServerless    get:      id: ${id}
    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_id–endpoint_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.30.0 published on Friday, Mar 21, 2025 by Pulumi
    pulumi/pulumi-mongodbatlas