1. Packages
  2. Mongodbatlas Provider
  3. API Docs
  4. PrivateLinkEndpointService
Viewing docs for MongoDB Atlas v4.6.0
published on Tuesday, Mar 31, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-mongodbatlas

mongodbatlas.PrivateLinkEndpointService

mongodbatlas logo
Viewing docs for MongoDB Atlas v4.6.0
published on Tuesday, Mar 31, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-mongodbatlas

    mongodbatlas.PrivateLinkEndpointService provides a Private Endpoint Interface Link resource. This represents a Private Endpoint Interface Link, which adds one Interface Endpoint to a private endpoint connection in an Atlas project.

    IMPORTANT: This resource links your cloud provider’s Private Endpoint to the MongoDB Atlas Private Endpoint Service. It does not create the service itself (this is done by mongodbatlas.PrivateLinkEndpoint). You first create the service in Atlas with mongodbatlas.PrivateLinkEndpoint, then the endpoint is created in your cloud provider, and you link them together with the mongodbatlas.PrivateLinkEndpointService resource.

    The private link Terraform module makes use of this resource and simplifies its use.

    NOTE: You must have Organization Owner or Project Owner role. Create and delete operations wait for all clusters on the project to IDLE to ensure the latest connection strings can be retrieved (default timeout: 2hrs).

    IMPORTANT: For GCP, MongoDB encourages customers to use the port-mapped architecture by setting portMappingEnabled = true on the mongodbatlas.PrivateLinkEndpoint resource. This architecture uses a single set of resources to support up to 150 nodes. The legacy architecture requires dedicated resources for each Atlas node, which can lead to IP address exhaustion. For migration guidance, see the GCP Private Service Connect to Port-Mapped Architecture.

    Example with AWS

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

const _this = new mongodbatlas.PrivateLinkEndpoint("this", {
    projectId: "<PROJECT_ID>",
    providerName: "AWS",
    region: "US_EAST_1",
});
const ptfeService = new aws.index.VpcEndpoint("ptfe_service", {
    vpcId: "vpc-7fc0a543",
    serviceName: _this.endpointServiceName,
    vpcEndpointType: "Interface",
    subnetIds: ["subnet-de0406d2"],
    securityGroupIds: ["sg-3f238186"],
});
const thisPrivateLinkEndpointService = new mongodbatlas.PrivateLinkEndpointService("this", {
    projectId: _this.projectId,
    privateLinkId: _this.privateLinkId,
    endpointServiceId: ptfeService.id,
    providerName: "AWS",
});

    import pulumi
import pulumi_aws as aws
import pulumi_mongodbatlas as mongodbatlas

this = mongodbatlas.PrivateLinkEndpoint("this",
    project_id="<PROJECT_ID>",
    provider_name="AWS",
    region="US_EAST_1")
ptfe_service = aws.index.VpcEndpoint("ptfe_service",
    vpc_id=vpc-7fc0a543,
    service_name=this.endpoint_service_name,
    vpc_endpoint_type=Interface,
    subnet_ids=[subnet-de0406d2],
    security_group_ids=[sg-3f238186])
this_private_link_endpoint_service = mongodbatlas.PrivateLinkEndpointService("this",
    project_id=this.project_id,
    private_link_id=this.private_link_id,
    endpoint_service_id=ptfe_service["id"],
    provider_name="AWS")

    package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws"
	"github.com/pulumi/pulumi-mongodbatlas/sdk/v4/go/mongodbatlas"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		this, err := mongodbatlas.NewPrivateLinkEndpoint(ctx, "this", &mongodbatlas.PrivateLinkEndpointArgs{
			ProjectId:    pulumi.String("<PROJECT_ID>"),
			ProviderName: pulumi.String("AWS"),
			Region:       pulumi.String("US_EAST_1"),
		})
		if err != nil {
			return err
		}
		ptfeService, err := aws.NewVpcEndpoint(ctx, "ptfe_service", &aws.VpcEndpointArgs{
			VpcId:           "vpc-7fc0a543",
			ServiceName:     this.EndpointServiceName,
			VpcEndpointType: "Interface",
			SubnetIds: []string{
				"subnet-de0406d2",
			},
			SecurityGroupIds: []string{
				"sg-3f238186",
			},
		})
		if err != nil {
			return err
		}
		_, err = mongodbatlas.NewPrivateLinkEndpointService(ctx, "this", &mongodbatlas.PrivateLinkEndpointServiceArgs{
			ProjectId:         this.ProjectId,
			PrivateLinkId:     this.PrivateLinkId,
			EndpointServiceId: ptfeService.Id,
			ProviderName:      pulumi.String("AWS"),
		})
		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 @this = new Mongodbatlas.PrivateLinkEndpoint("this", new()
    {
        ProjectId = "<PROJECT_ID>",
        ProviderName = "AWS",
        Region = "US_EAST_1",
    });

    var ptfeService = new Aws.Index.VpcEndpoint("ptfe_service", new()
    {
        VpcId = "vpc-7fc0a543",
        ServiceName = @this.EndpointServiceName,
        VpcEndpointType = "Interface",
        SubnetIds = new[]
        {
            "subnet-de0406d2",
        },
        SecurityGroupIds = new[]
        {
            "sg-3f238186",
        },
    });

    var thisPrivateLinkEndpointService = new Mongodbatlas.PrivateLinkEndpointService("this", new()
    {
        ProjectId = @this.ProjectId,
        PrivateLinkId = @this.PrivateLinkId,
        EndpointServiceId = ptfeService.Id,
        ProviderName = "AWS",
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.PrivateLinkEndpoint;
import com.pulumi.mongodbatlas.PrivateLinkEndpointArgs;
import com.pulumi.aws.VpcEndpoint;
import com.pulumi.aws.VpcEndpointArgs;
import com.pulumi.mongodbatlas.PrivateLinkEndpointService;
import com.pulumi.mongodbatlas.PrivateLinkEndpointServiceArgs;
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 PrivateLinkEndpoint("this", PrivateLinkEndpointArgs.builder()
            .projectId("<PROJECT_ID>")
            .providerName("AWS")
            .region("US_EAST_1")
            .build());

        var ptfeService = new VpcEndpoint("ptfeService", VpcEndpointArgs.builder()
            .vpcId("vpc-7fc0a543")
            .serviceName(this_.endpointServiceName())
            .vpcEndpointType("Interface")
            .subnetIds(List.of("subnet-de0406d2"))
            .securityGroupIds(List.of("sg-3f238186"))
            .build());

        var thisPrivateLinkEndpointService = new PrivateLinkEndpointService("thisPrivateLinkEndpointService", PrivateLinkEndpointServiceArgs.builder()
            .projectId(this_.projectId())
            .privateLinkId(this_.privateLinkId())
            .endpointServiceId(ptfeService.id())
            .providerName("AWS")
            .build());

    }
}

    resources:
  this:
    type: mongodbatlas:PrivateLinkEndpoint
    properties:
      projectId: <PROJECT_ID>
      providerName: AWS
      region: US_EAST_1
  ptfeService:
    type: aws:VpcEndpoint
    name: ptfe_service
    properties:
      vpcId: vpc-7fc0a543
      serviceName: ${this.endpointServiceName}
      vpcEndpointType: Interface
      subnetIds:
        - subnet-de0406d2
      securityGroupIds:
        - sg-3f238186
  thisPrivateLinkEndpointService:
    type: mongodbatlas:PrivateLinkEndpointService
    name: this
    properties:
      projectId: ${this.projectId}
      privateLinkId: ${this.privateLinkId}
      endpointServiceId: ${ptfeService.id}
      providerName: AWS

    Example with Azure

    import * as pulumi from "@pulumi/pulumi";
import * as azurerm from "@pulumi/azurerm";
import * as mongodbatlas from "@pulumi/mongodbatlas";

const _this = new mongodbatlas.PrivateLinkEndpoint("this", {
    projectId: projectId,
    providerName: "AZURE",
    region: "eastus2",
});
const thisPrivateEndpoint = new azurerm.index.PrivateEndpoint("this", {
    name: "endpoint-this",
    location: thisAzurermResourceGroup.location,
    resourceGroupName: resourceGroupName,
    subnetId: thisAzurermSubnet.id,
    privateServiceConnection: [{
        name: _this.privateLinkServiceName,
        privateConnectionResourceId: _this.privateLinkServiceResourceId,
        isManualConnection: true,
        requestMessage: "Azure Private Link this",
    }],
});
const thisPrivateLinkEndpointService = new mongodbatlas.PrivateLinkEndpointService("this", {
    projectId: _this.projectId,
    privateLinkId: _this.privateLinkId,
    endpointServiceId: thisPrivateEndpoint.id,
    privateEndpointIpAddress: thisPrivateEndpoint.privateServiceConnection[0].privateIpAddress,
    providerName: "AZURE",
});

    import pulumi
import pulumi_azurerm as azurerm
import pulumi_mongodbatlas as mongodbatlas

this = mongodbatlas.PrivateLinkEndpoint("this",
    project_id=project_id,
    provider_name="AZURE",
    region="eastus2")
this_private_endpoint = azurerm.index.PrivateEndpoint("this",
    name=endpoint-this,
    location=this_azurerm_resource_group.location,
    resource_group_name=resource_group_name,
    subnet_id=this_azurerm_subnet.id,
    private_service_connection=[{
        name: this.private_link_service_name,
        privateConnectionResourceId: this.private_link_service_resource_id,
        isManualConnection: True,
        requestMessage: Azure Private Link this,
    }])
this_private_link_endpoint_service = mongodbatlas.PrivateLinkEndpointService("this",
    project_id=this.project_id,
    private_link_id=this.private_link_id,
    endpoint_service_id=this_private_endpoint["id"],
    private_endpoint_ip_address=this_private_endpoint["privateServiceConnection"][0]["privateIpAddress"],
    provider_name="AZURE")

    package main

import (
	"github.com/pulumi/pulumi-azurerm/sdk/go/azurerm"
	"github.com/pulumi/pulumi-mongodbatlas/sdk/v4/go/mongodbatlas"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		this, err := mongodbatlas.NewPrivateLinkEndpoint(ctx, "this", &mongodbatlas.PrivateLinkEndpointArgs{
			ProjectId:    pulumi.Any(projectId),
			ProviderName: pulumi.String("AZURE"),
			Region:       pulumi.String("eastus2"),
		})
		if err != nil {
			return err
		}
		thisPrivateEndpoint, err := azurerm.NewPrivateEndpoint(ctx, "this", &azurerm.PrivateEndpointArgs{
			Name:              "endpoint-this",
			Location:          thisAzurermResourceGroup.Location,
			ResourceGroupName: resourceGroupName,
			SubnetId:          thisAzurermSubnet.Id,
			PrivateServiceConnection: []map[string]interface{}{
				map[string]interface{}{
					"name":                        this.PrivateLinkServiceName,
					"privateConnectionResourceId": this.PrivateLinkServiceResourceId,
					"isManualConnection":          true,
					"requestMessage":              "Azure Private Link this",
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = mongodbatlas.NewPrivateLinkEndpointService(ctx, "this", &mongodbatlas.PrivateLinkEndpointServiceArgs{
			ProjectId:                this.ProjectId,
			PrivateLinkId:            this.PrivateLinkId,
			EndpointServiceId:        thisPrivateEndpoint.Id,
			PrivateEndpointIpAddress: thisPrivateEndpoint.PrivateServiceConnection[0].PrivateIpAddress,
			ProviderName:             pulumi.String("AZURE"),
		})
		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 @this = new Mongodbatlas.PrivateLinkEndpoint("this", new()
    {
        ProjectId = projectId,
        ProviderName = "AZURE",
        Region = "eastus2",
    });

    var thisPrivateEndpoint = new Azurerm.Index.PrivateEndpoint("this", new()
    {
        Name = "endpoint-this",
        Location = thisAzurermResourceGroup.Location,
        ResourceGroupName = resourceGroupName,
        SubnetId = thisAzurermSubnet.Id,
        PrivateServiceConnection = new[]
        {
            
            {
                { "name", @this.PrivateLinkServiceName },
                { "privateConnectionResourceId", @this.PrivateLinkServiceResourceId },
                { "isManualConnection", true },
                { "requestMessage", "Azure Private Link this" },
            },
        },
    });

    var thisPrivateLinkEndpointService = new Mongodbatlas.PrivateLinkEndpointService("this", new()
    {
        ProjectId = @this.ProjectId,
        PrivateLinkId = @this.PrivateLinkId,
        EndpointServiceId = thisPrivateEndpoint.Id,
        PrivateEndpointIpAddress = thisPrivateEndpoint.PrivateServiceConnection[0].PrivateIpAddress,
        ProviderName = "AZURE",
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.PrivateLinkEndpoint;
import com.pulumi.mongodbatlas.PrivateLinkEndpointArgs;
import com.pulumi.azurerm.PrivateEndpoint;
import com.pulumi.azurerm.PrivateEndpointArgs;
import com.pulumi.mongodbatlas.PrivateLinkEndpointService;
import com.pulumi.mongodbatlas.PrivateLinkEndpointServiceArgs;
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 PrivateLinkEndpoint("this", PrivateLinkEndpointArgs.builder()
            .projectId(projectId)
            .providerName("AZURE")
            .region("eastus2")
            .build());

        var thisPrivateEndpoint = new PrivateEndpoint("thisPrivateEndpoint", PrivateEndpointArgs.builder()
            .name("endpoint-this")
            .location(thisAzurermResourceGroup.location())
            .resourceGroupName(resourceGroupName)
            .subnetId(thisAzurermSubnet.id())
            .privateServiceConnection(List.of(Map.ofEntries(
                Map.entry("name", this_.privateLinkServiceName()),
                Map.entry("privateConnectionResourceId", this_.privateLinkServiceResourceId()),
                Map.entry("isManualConnection", true),
                Map.entry("requestMessage", "Azure Private Link this")
            )))
            .build());

        var thisPrivateLinkEndpointService = new PrivateLinkEndpointService("thisPrivateLinkEndpointService", PrivateLinkEndpointServiceArgs.builder()
            .projectId(this_.projectId())
            .privateLinkId(this_.privateLinkId())
            .endpointServiceId(thisPrivateEndpoint.id())
            .privateEndpointIpAddress(thisPrivateEndpoint.privateServiceConnection()[0].privateIpAddress())
            .providerName("AZURE")
            .build());

    }
}

    resources:
  this:
    type: mongodbatlas:PrivateLinkEndpoint
    properties:
      projectId: ${projectId}
      providerName: AZURE
      region: eastus2
  thisPrivateEndpoint:
    type: azurerm:PrivateEndpoint
    name: this
    properties:
      name: endpoint-this
      location: ${thisAzurermResourceGroup.location}
      resourceGroupName: ${resourceGroupName}
      subnetId: ${thisAzurermSubnet.id}
      privateServiceConnection:
        - name: ${this.privateLinkServiceName}
          privateConnectionResourceId: ${this.privateLinkServiceResourceId}
          isManualConnection: true
          requestMessage: Azure Private Link this
  thisPrivateLinkEndpointService:
    type: mongodbatlas:PrivateLinkEndpointService
    name: this
    properties:
      projectId: ${this.projectId}
      privateLinkId: ${this.privateLinkId}
      endpointServiceId: ${thisPrivateEndpoint.id}
      privateEndpointIpAddress: ${thisPrivateEndpoint.privateServiceConnection[0].privateIpAddress}
      providerName: AZURE

    Example with GCP (Legacy Architecture)

    import * as pulumi from "@pulumi/pulumi";
import * as google from "@pulumi/google";
import * as mongodbatlas from "@pulumi/mongodbatlas";

const _this = new mongodbatlas.PrivateLinkEndpoint("this", {
    projectId: projectId,
    providerName: "GCP",
    region: gcpRegion,
});
// Create a Google Network
const _default = new google.index.ComputeNetwork("default", {
    project: gcpProjectId,
    name: "my-network",
    autoCreateSubnetworks: false,
});
// Create a Google Sub Network
const defaultComputeSubnetwork = new google.index.ComputeSubnetwork("default", {
    project: _default.project,
    name: "my-subnet",
    ipCidrRange: "10.0.0.0/16",
    region: gcpRegion,
    network: _default.id,
});
// Create Google 50 Addresses (required for GCP legacy private endpoint architecture)
const defaultComputeAddress: google.index.ComputeAddress[] = [];
for (const range = {value: 0}; range.value < 50; range.value++) {
    defaultComputeAddress.push(new google.index.ComputeAddress(`default-${range.value}`, {
        project: defaultComputeSubnetwork.project,
        name: `tf-this${range.value}`,
        subnetwork: defaultComputeSubnetwork.id,
        addressType: "INTERNAL",
        address: `10.0.42.${range.value}`,
        region: gcpRegion,
    }, {
    dependsOn: [_this],
}));
}
// Create 50 Forwarding rules (required for GCP legacy private endpoint architecture)
const defaultComputeForwardingRule: google.index.ComputeForwardingRule[] = [];
for (const range = {value: 0}; range.value < 50; range.value++) {
    defaultComputeForwardingRule.push(new google.index.ComputeForwardingRule(`default-${range.value}`, {
        target: _this.serviceAttachmentNames[range.value],
        project: defaultComputeAddress[range.value].project,
        region: defaultComputeAddress[range.value].region,
        name: defaultComputeAddress[range.value].name,
        ipAddress: defaultComputeAddress[range.value].id,
        network: _default.id,
        loadBalancingScheme: "",
    }));
}
const thisPrivateLinkEndpointService = new mongodbatlas.PrivateLinkEndpointService("this", {
    endpoints: defaultComputeAddress.map((v, k) => ({key: k, value: v})).map(entry => ({
        ipAddress: entry.value.address,
        endpointName: defaultComputeForwardingRule[entry.key].name,
    })),
    projectId: _this.projectId,
    privateLinkId: _this.privateLinkId,
    providerName: "GCP",
    endpointServiceId: _default.name,
    gcpProjectId: gcpProjectId,
}, {
    dependsOn: [defaultComputeForwardingRule],
});

    import pulumi
import pulumi_google as google
import pulumi_mongodbatlas as mongodbatlas

this = mongodbatlas.PrivateLinkEndpoint("this",
    project_id=project_id,
    provider_name="GCP",
    region=gcp_region)
# Create a Google Network
default = google.index.ComputeNetwork("default",
    project=gcp_project_id,
    name=my-network,
    auto_create_subnetworks=False)
# Create a Google Sub Network
default_compute_subnetwork = google.index.ComputeSubnetwork("default",
    project=default.project,
    name=my-subnet,
    ip_cidr_range=10.0.0.0/16,
    region=gcp_region,
    network=default.id)
# Create Google 50 Addresses (required for GCP legacy private endpoint architecture)
default_compute_address = []
for range in [{"value": i} for i in range(0, 50)]:
    default_compute_address.append(google.index.ComputeAddress(f"default-{range['value']}",
        project=default_compute_subnetwork.project,
        name=ftf-this{range.value},
        subnetwork=default_compute_subnetwork.id,
        address_type=INTERNAL,
        address=f10.0.42.{range.value},
        region=gcp_region,
        opts = pulumi.ResourceOptions(depends_on=[this])))
# Create 50 Forwarding rules (required for GCP legacy private endpoint architecture)
default_compute_forwarding_rule = []
for range in [{"value": i} for i in range(0, 50)]:
    default_compute_forwarding_rule.append(google.index.ComputeForwardingRule(f"default-{range['value']}",
        target=this.service_attachment_names[range.value],
        project=default_compute_address[range.value].project,
        region=default_compute_address[range.value].region,
        name=default_compute_address[range.value].name,
        ip_address=default_compute_address[range.value].id,
        network=default.id,
        load_balancing_scheme=))
this_private_link_endpoint_service = mongodbatlas.PrivateLinkEndpointService("this",
    endpoints=[{
        "ip_address": entry["value"]["address"],
        "endpoint_name": default_compute_forwarding_rule[entry["key"]]["name"],
    } for entry in [{"key": k, "value": v} for k, v in default_compute_address.items()]],
    project_id=this.project_id,
    private_link_id=this.private_link_id,
    provider_name="GCP",
    endpoint_service_id=default["name"],
    gcp_project_id=gcp_project_id,
    opts = pulumi.ResourceOptions(depends_on=[default_compute_forwarding_rule]))

    Example coming soon!

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Google = Pulumi.Google;
using Mongodbatlas = Pulumi.Mongodbatlas;

return await Deployment.RunAsync(() => 
{
    var @this = new Mongodbatlas.PrivateLinkEndpoint("this", new()
    {
        ProjectId = projectId,
        ProviderName = "GCP",
        Region = gcpRegion,
    });

    // Create a Google Network
    var @default = new Google.Index.ComputeNetwork("default", new()
    {
        Project = gcpProjectId,
        Name = "my-network",
        AutoCreateSubnetworks = false,
    });

    // Create a Google Sub Network
    var defaultComputeSubnetwork = new Google.Index.ComputeSubnetwork("default", new()
    {
        Project = @default.Project,
        Name = "my-subnet",
        IpCidrRange = "10.0.0.0/16",
        Region = gcpRegion,
        Network = @default.Id,
    });

    // Create Google 50 Addresses (required for GCP legacy private endpoint architecture)
    var defaultComputeAddress = new List<Google.Index.ComputeAddress>();
    for (var rangeIndex = 0; rangeIndex < 50; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        defaultComputeAddress.Add(new Google.Index.ComputeAddress($"default-{range.Value}", new()
        {
            Project = defaultComputeSubnetwork.Project,
            Name = $"tf-this{range.Value}",
            Subnetwork = defaultComputeSubnetwork.Id,
            AddressType = "INTERNAL",
            Address = $"10.0.42.{range.Value}",
            Region = gcpRegion,
        }, new CustomResourceOptions
        {
            DependsOn =
            {
                @this,
            },
        }));
    }
    // Create 50 Forwarding rules (required for GCP legacy private endpoint architecture)
    var defaultComputeForwardingRule = new List<Google.Index.ComputeForwardingRule>();
    for (var rangeIndex = 0; rangeIndex < 50; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        defaultComputeForwardingRule.Add(new Google.Index.ComputeForwardingRule($"default-{range.Value}", new()
        {
            Target = @this.ServiceAttachmentNames[range.Value],
            Project = defaultComputeAddress[range.Value].Project,
            Region = defaultComputeAddress[range.Value].Region,
            Name = defaultComputeAddress[range.Value].Name,
            IpAddress = defaultComputeAddress[range.Value].Id,
            Network = @default.Id,
            LoadBalancingScheme = "",
        }));
    }
    var thisPrivateLinkEndpointService = new Mongodbatlas.PrivateLinkEndpointService("this", new()
    {
        Endpoints = defaultComputeAddress.Select((v, k) => new { Key = k, Value = v }).Select(entry => 
        {
            return new Mongodbatlas.Inputs.PrivateLinkEndpointServiceEndpointArgs
            {
                IpAddress = entry.Value.Address,
                EndpointName = defaultComputeForwardingRule[entry.Key].Name,
            };
        }).ToList(),
        ProjectId = @this.ProjectId,
        PrivateLinkId = @this.PrivateLinkId,
        ProviderName = "GCP",
        EndpointServiceId = @default.Name,
        GcpProjectId = gcpProjectId,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            defaultComputeForwardingRule,
        },
    });

});

    Example coming soon!

    Example coming soon!

    Example with GCP (Port-Mapped Architecture)

    The port-mapped architecture uses port mapping to reduce resource provisioning. In the GCP legacy private endpoint architecture, service attachments were mapped 1:1 with Atlas nodes (one service attachment per node). In the port-mapped architecture, regardless of cloud provider, one service attachment can be mapped to up to 150 nodes via ports designated per node, enabling direct targeting of specific nodes using only one customer IP address. Enable it by setting portMappingEnabled = true on the mongodbatlas.PrivateLinkEndpoint resource.

    Important: For the port-mapped architecture, use endpointServiceId (the forwarding rule name) and privateEndpointIpAddress (the IP address). The endpoints list is no longer used for the port-mapped architecture.

    import * as pulumi from "@pulumi/pulumi";
import * as google from "@pulumi/google";
import * as mongodbatlas from "@pulumi/mongodbatlas";

const _this = new mongodbatlas.PrivateLinkEndpoint("this", {
    projectId: projectId,
    providerName: "GCP",
    region: gcpRegion,
    portMappingEnabled: true,
});
// Create a Google Network
const _default = new google.index.ComputeNetwork("default", {
    project: gcpProjectId,
    name: "my-network",
    autoCreateSubnetworks: false,
});
// Create a Google Sub Network
const defaultComputeSubnetwork = new google.index.ComputeSubnetwork("default", {
    project: _default.project,
    name: "my-subnet",
    ipCidrRange: "10.0.0.0/16",
    region: gcpRegion,
    network: _default.id,
});
// Create Google Address (1 address for port-mapped architecture)
const defaultComputeAddress = new google.index.ComputeAddress("default", {
    project: defaultComputeSubnetwork.project,
    name: "tf-this-psc-endpoint",
    subnetwork: defaultComputeSubnetwork.id,
    addressType: "INTERNAL",
    address: "10.0.42.1",
    region: defaultComputeSubnetwork.region,
}, {
    dependsOn: [_this],
});
// Create Forwarding Rule (1 rule for port-mapped architecture)
const defaultComputeForwardingRule = new google.index.ComputeForwardingRule("default", {
    target: _this.serviceAttachmentNames[0],
    project: defaultComputeAddress.project,
    region: defaultComputeAddress.region,
    name: defaultComputeAddress.name,
    ipAddress: defaultComputeAddress.id,
    network: _default.id,
    loadBalancingScheme: "",
});
const thisPrivateLinkEndpointService = new mongodbatlas.PrivateLinkEndpointService("this", {
    projectId: _this.projectId,
    privateLinkId: _this.privateLinkId,
    providerName: "GCP",
    endpointServiceId: defaultComputeForwardingRule.name,
    privateEndpointIpAddress: defaultComputeAddress.address,
    gcpProjectId: gcpProjectId,
}, {
    dependsOn: [defaultComputeForwardingRule],
});

    import pulumi
import pulumi_google as google
import pulumi_mongodbatlas as mongodbatlas

this = mongodbatlas.PrivateLinkEndpoint("this",
    project_id=project_id,
    provider_name="GCP",
    region=gcp_region,
    port_mapping_enabled=True)
# Create a Google Network
default = google.index.ComputeNetwork("default",
    project=gcp_project_id,
    name=my-network,
    auto_create_subnetworks=False)
# Create a Google Sub Network
default_compute_subnetwork = google.index.ComputeSubnetwork("default",
    project=default.project,
    name=my-subnet,
    ip_cidr_range=10.0.0.0/16,
    region=gcp_region,
    network=default.id)
# Create Google Address (1 address for port-mapped architecture)
default_compute_address = google.index.ComputeAddress("default",
    project=default_compute_subnetwork.project,
    name=tf-this-psc-endpoint,
    subnetwork=default_compute_subnetwork.id,
    address_type=INTERNAL,
    address=10.0.42.1,
    region=default_compute_subnetwork.region,
    opts = pulumi.ResourceOptions(depends_on=[this]))
# Create Forwarding Rule (1 rule for port-mapped architecture)
default_compute_forwarding_rule = google.index.ComputeForwardingRule("default",
    target=this.service_attachment_names[0],
    project=default_compute_address.project,
    region=default_compute_address.region,
    name=default_compute_address.name,
    ip_address=default_compute_address.id,
    network=default.id,
    load_balancing_scheme=)
this_private_link_endpoint_service = mongodbatlas.PrivateLinkEndpointService("this",
    project_id=this.project_id,
    private_link_id=this.private_link_id,
    provider_name="GCP",
    endpoint_service_id=default_compute_forwarding_rule["name"],
    private_endpoint_ip_address=default_compute_address["address"],
    gcp_project_id=gcp_project_id,
    opts = pulumi.ResourceOptions(depends_on=[default_compute_forwarding_rule]))

    package main

import (
	"github.com/pulumi/pulumi-google/sdk/go/google"
	"github.com/pulumi/pulumi-mongodbatlas/sdk/v4/go/mongodbatlas"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		this, err := mongodbatlas.NewPrivateLinkEndpoint(ctx, "this", &mongodbatlas.PrivateLinkEndpointArgs{
			ProjectId:          pulumi.Any(projectId),
			ProviderName:       pulumi.String("GCP"),
			Region:             pulumi.Any(gcpRegion),
			PortMappingEnabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// Create a Google Network
		_default, err := google.NewComputeNetwork(ctx, "default", &google.ComputeNetworkArgs{
			Project:               gcpProjectId,
			Name:                  "my-network",
			AutoCreateSubnetworks: false,
		})
		if err != nil {
			return err
		}
		// Create a Google Sub Network
		defaultComputeSubnetwork, err := google.NewComputeSubnetwork(ctx, "default", &google.ComputeSubnetworkArgs{
			Project:     _default.Project,
			Name:        "my-subnet",
			IpCidrRange: "10.0.0.0/16",
			Region:      gcpRegion,
			Network:     _default.Id,
		})
		if err != nil {
			return err
		}
		// Create Google Address (1 address for port-mapped architecture)
		defaultComputeAddress, err := google.NewComputeAddress(ctx, "default", &google.ComputeAddressArgs{
			Project:     defaultComputeSubnetwork.Project,
			Name:        "tf-this-psc-endpoint",
			Subnetwork:  defaultComputeSubnetwork.Id,
			AddressType: "INTERNAL",
			Address:     "10.0.42.1",
			Region:      defaultComputeSubnetwork.Region,
		}, pulumi.DependsOn([]pulumi.Resource{
			this,
		}))
		if err != nil {
			return err
		}
		// Create Forwarding Rule (1 rule for port-mapped architecture)
		defaultComputeForwardingRule, err := google.NewComputeForwardingRule(ctx, "default", &google.ComputeForwardingRuleArgs{
			Target:              this.ServiceAttachmentNames[0],
			Project:             defaultComputeAddress.Project,
			Region:              defaultComputeAddress.Region,
			Name:                defaultComputeAddress.Name,
			IpAddress:           defaultComputeAddress.Id,
			Network:             _default.Id,
			LoadBalancingScheme: "",
		})
		if err != nil {
			return err
		}
		_, err = mongodbatlas.NewPrivateLinkEndpointService(ctx, "this", &mongodbatlas.PrivateLinkEndpointServiceArgs{
			ProjectId:                this.ProjectId,
			PrivateLinkId:            this.PrivateLinkId,
			ProviderName:             pulumi.String("GCP"),
			EndpointServiceId:        defaultComputeForwardingRule.Name,
			PrivateEndpointIpAddress: defaultComputeAddress.Address,
			GcpProjectId:             pulumi.Any(gcpProjectId),
		}, pulumi.DependsOn([]pulumi.Resource{
			defaultComputeForwardingRule,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Google = Pulumi.Google;
using Mongodbatlas = Pulumi.Mongodbatlas;

return await Deployment.RunAsync(() => 
{
    var @this = new Mongodbatlas.PrivateLinkEndpoint("this", new()
    {
        ProjectId = projectId,
        ProviderName = "GCP",
        Region = gcpRegion,
        PortMappingEnabled = true,
    });

    // Create a Google Network
    var @default = new Google.Index.ComputeNetwork("default", new()
    {
        Project = gcpProjectId,
        Name = "my-network",
        AutoCreateSubnetworks = false,
    });

    // Create a Google Sub Network
    var defaultComputeSubnetwork = new Google.Index.ComputeSubnetwork("default", new()
    {
        Project = @default.Project,
        Name = "my-subnet",
        IpCidrRange = "10.0.0.0/16",
        Region = gcpRegion,
        Network = @default.Id,
    });

    // Create Google Address (1 address for port-mapped architecture)
    var defaultComputeAddress = new Google.Index.ComputeAddress("default", new()
    {
        Project = defaultComputeSubnetwork.Project,
        Name = "tf-this-psc-endpoint",
        Subnetwork = defaultComputeSubnetwork.Id,
        AddressType = "INTERNAL",
        Address = "10.0.42.1",
        Region = defaultComputeSubnetwork.Region,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            @this,
        },
    });

    // Create Forwarding Rule (1 rule for port-mapped architecture)
    var defaultComputeForwardingRule = new Google.Index.ComputeForwardingRule("default", new()
    {
        Target = @this.ServiceAttachmentNames[0],
        Project = defaultComputeAddress.Project,
        Region = defaultComputeAddress.Region,
        Name = defaultComputeAddress.Name,
        IpAddress = defaultComputeAddress.Id,
        Network = @default.Id,
        LoadBalancingScheme = "",
    });

    var thisPrivateLinkEndpointService = new Mongodbatlas.PrivateLinkEndpointService("this", new()
    {
        ProjectId = @this.ProjectId,
        PrivateLinkId = @this.PrivateLinkId,
        ProviderName = "GCP",
        EndpointServiceId = defaultComputeForwardingRule.Name,
        PrivateEndpointIpAddress = defaultComputeAddress.Address,
        GcpProjectId = gcpProjectId,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            defaultComputeForwardingRule,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.PrivateLinkEndpoint;
import com.pulumi.mongodbatlas.PrivateLinkEndpointArgs;
import com.pulumi.google.ComputeNetwork;
import com.pulumi.google.ComputeNetworkArgs;
import com.pulumi.google.ComputeSubnetwork;
import com.pulumi.google.ComputeSubnetworkArgs;
import com.pulumi.google.ComputeAddress;
import com.pulumi.google.ComputeAddressArgs;
import com.pulumi.google.ComputeForwardingRule;
import com.pulumi.google.ComputeForwardingRuleArgs;
import com.pulumi.mongodbatlas.PrivateLinkEndpointService;
import com.pulumi.mongodbatlas.PrivateLinkEndpointServiceArgs;
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 PrivateLinkEndpoint("this", PrivateLinkEndpointArgs.builder()
            .projectId(projectId)
            .providerName("GCP")
            .region(gcpRegion)
            .portMappingEnabled(true)
            .build());

        // Create a Google Network
        var default_ = new ComputeNetwork("default", ComputeNetworkArgs.builder()
            .project(gcpProjectId)
            .name("my-network")
            .autoCreateSubnetworks(false)
            .build());

        // Create a Google Sub Network
        var defaultComputeSubnetwork = new ComputeSubnetwork("defaultComputeSubnetwork", ComputeSubnetworkArgs.builder()
            .project(default_.project())
            .name("my-subnet")
            .ipCidrRange("10.0.0.0/16")
            .region(gcpRegion)
            .network(default_.id())
            .build());

        // Create Google Address (1 address for port-mapped architecture)
        var defaultComputeAddress = new ComputeAddress("defaultComputeAddress", ComputeAddressArgs.builder()
            .project(defaultComputeSubnetwork.project())
            .name("tf-this-psc-endpoint")
            .subnetwork(defaultComputeSubnetwork.id())
            .addressType("INTERNAL")
            .address("10.0.42.1")
            .region(defaultComputeSubnetwork.region())
            .build(), CustomResourceOptions.builder()
                .dependsOn(List.of(this_))
                .build());

        // Create Forwarding Rule (1 rule for port-mapped architecture)
        var defaultComputeForwardingRule = new ComputeForwardingRule("defaultComputeForwardingRule", ComputeForwardingRuleArgs.builder()
            .target(this_.serviceAttachmentNames()[0])
            .project(defaultComputeAddress.project())
            .region(defaultComputeAddress.region())
            .name(defaultComputeAddress.name())
            .ipAddress(defaultComputeAddress.id())
            .network(default_.id())
            .loadBalancingScheme("")
            .build());

        var thisPrivateLinkEndpointService = new PrivateLinkEndpointService("thisPrivateLinkEndpointService", PrivateLinkEndpointServiceArgs.builder()
            .projectId(this_.projectId())
            .privateLinkId(this_.privateLinkId())
            .providerName("GCP")
            .endpointServiceId(defaultComputeForwardingRule.name())
            .privateEndpointIpAddress(defaultComputeAddress.address())
            .gcpProjectId(gcpProjectId)
            .build(), CustomResourceOptions.builder()
                .dependsOn(defaultComputeForwardingRule)
                .build());

    }
}

    resources:
  this:
    type: mongodbatlas:PrivateLinkEndpoint
    properties:
      projectId: ${projectId}
      providerName: GCP
      region: ${gcpRegion}
      portMappingEnabled: true # Enable port-mapped architecture
  # Create a Google Network
  default:
    type: google:ComputeNetwork
    properties:
      project: ${gcpProjectId}
      name: my-network
      autoCreateSubnetworks: false
  # Create a Google Sub Network
  defaultComputeSubnetwork:
    type: google:ComputeSubnetwork
    name: default
    properties:
      project: ${default.project}
      name: my-subnet
      ipCidrRange: 10.0.0.0/16
      region: ${gcpRegion}
      network: ${default.id}
  # Create Google Address (1 address for port-mapped architecture)
  defaultComputeAddress:
    type: google:ComputeAddress
    name: default
    properties:
      project: ${defaultComputeSubnetwork.project}
      name: tf-this-psc-endpoint
      subnetwork: ${defaultComputeSubnetwork.id}
      addressType: INTERNAL
      address: 10.0.42.1
      region: ${defaultComputeSubnetwork.region}
    options:
      dependsOn:
        - ${this}
  # Create Forwarding Rule (1 rule for port-mapped architecture)
  defaultComputeForwardingRule:
    type: google:ComputeForwardingRule
    name: default
    properties:
      target: ${this.serviceAttachmentNames[0]}
      project: ${defaultComputeAddress.project}
      region: ${defaultComputeAddress.region}
      name: ${defaultComputeAddress.name}
      ipAddress: ${defaultComputeAddress.id}
      network: ${default.id}
      loadBalancingScheme: ""
  thisPrivateLinkEndpointService:
    type: mongodbatlas:PrivateLinkEndpointService
    name: this
    properties:
      projectId: ${this.projectId}
      privateLinkId: ${this.privateLinkId}
      providerName: GCP
      endpointServiceId: ${defaultComputeForwardingRule.name}
      privateEndpointIpAddress: ${defaultComputeAddress.address}
      gcpProjectId: ${gcpProjectId}
    options:
      dependsOn:
        - ${defaultComputeForwardingRule}

    Further Examples

    • AWS PrivateLink Endpoint and Service
    • Azure Private Link Endpoint and Service
    • GCP Private Service Connect Endpoint and Service (Port-Mapped Architecture)

    Create PrivateLinkEndpointService Resource

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

    Constructor syntax

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

@overload
def PrivateLinkEndpointService(resource_name: str,
                               opts: Optional[ResourceOptions] = None,
                               endpoint_service_id: Optional[str] = None,
                               private_link_id: Optional[str] = None,
                               project_id: Optional[str] = None,
                               provider_name: Optional[str] = None,
                               delete_on_create_timeout: Optional[bool] = None,
                               endpoints: Optional[Sequence[PrivateLinkEndpointServiceEndpointArgs]] = None,
                               gcp_project_id: Optional[str] = None,
                               private_endpoint_ip_address: Optional[str] = None)
    func NewPrivateLinkEndpointService(ctx *Context, name string, args PrivateLinkEndpointServiceArgs, opts ...ResourceOption) (*PrivateLinkEndpointService, error)
    public PrivateLinkEndpointService(string name, PrivateLinkEndpointServiceArgs args, CustomResourceOptions? opts = null)
    public PrivateLinkEndpointService(String name, PrivateLinkEndpointServiceArgs args)
public PrivateLinkEndpointService(String name, PrivateLinkEndpointServiceArgs args, CustomResourceOptions options)

    type: mongodbatlas:PrivateLinkEndpointService
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 PrivateLinkEndpointServiceArgs
    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 PrivateLinkEndpointServiceArgs
    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 PrivateLinkEndpointServiceArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args PrivateLinkEndpointServiceArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args PrivateLinkEndpointServiceArgs
    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 privateLinkEndpointServiceResource = new Mongodbatlas.Index.PrivateLinkEndpointService("privateLinkEndpointServiceResource", new()
{
    EndpointServiceId = "string",
    PrivateLinkId = "string",
    ProjectId = "string",
    ProviderName = "string",
    DeleteOnCreateTimeout = false,
    Endpoints = new[]
    {
        new Mongodbatlas.Inputs.PrivateLinkEndpointServiceEndpointArgs
        {
            EndpointName = "string",
            IpAddress = "string",
            Status = "string",
        },
    },
    GcpProjectId = "string",
    PrivateEndpointIpAddress = "string",
});

    example, err := mongodbatlas.NewPrivateLinkEndpointService(ctx, "privateLinkEndpointServiceResource", &mongodbatlas.PrivateLinkEndpointServiceArgs{
	EndpointServiceId:     pulumi.String("string"),
	PrivateLinkId:         pulumi.String("string"),
	ProjectId:             pulumi.String("string"),
	ProviderName:          pulumi.String("string"),
	DeleteOnCreateTimeout: pulumi.Bool(false),
	Endpoints: mongodbatlas.PrivateLinkEndpointServiceEndpointArray{
		&mongodbatlas.PrivateLinkEndpointServiceEndpointArgs{
			EndpointName: pulumi.String("string"),
			IpAddress:    pulumi.String("string"),
			Status:       pulumi.String("string"),
		},
	},
	GcpProjectId:             pulumi.String("string"),
	PrivateEndpointIpAddress: pulumi.String("string"),
})

    var privateLinkEndpointServiceResource = new PrivateLinkEndpointService("privateLinkEndpointServiceResource", PrivateLinkEndpointServiceArgs.builder()
    .endpointServiceId("string")
    .privateLinkId("string")
    .projectId("string")
    .providerName("string")
    .deleteOnCreateTimeout(false)
    .endpoints(PrivateLinkEndpointServiceEndpointArgs.builder()
        .endpointName("string")
        .ipAddress("string")
        .status("string")
        .build())
    .gcpProjectId("string")
    .privateEndpointIpAddress("string")
    .build());

    private_link_endpoint_service_resource = mongodbatlas.PrivateLinkEndpointService("privateLinkEndpointServiceResource",
    endpoint_service_id="string",
    private_link_id="string",
    project_id="string",
    provider_name="string",
    delete_on_create_timeout=False,
    endpoints=[{
        "endpoint_name": "string",
        "ip_address": "string",
        "status": "string",
    }],
    gcp_project_id="string",
    private_endpoint_ip_address="string")

    const privateLinkEndpointServiceResource = new mongodbatlas.PrivateLinkEndpointService("privateLinkEndpointServiceResource", {
    endpointServiceId: "string",
    privateLinkId: "string",
    projectId: "string",
    providerName: "string",
    deleteOnCreateTimeout: false,
    endpoints: [{
        endpointName: "string",
        ipAddress: "string",
        status: "string",
    }],
    gcpProjectId: "string",
    privateEndpointIpAddress: "string",
});

    type: mongodbatlas:PrivateLinkEndpointService
properties:
    deleteOnCreateTimeout: false
    endpointServiceId: string
    endpoints:
        - endpointName: string
          ipAddress: string
          status: string
    gcpProjectId: string
    privateEndpointIpAddress: string
    privateLinkId: string
    projectId: string
    providerName: string

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

    EndpointServiceId string
    Unique identifier of the interface endpoint you created in your VPC. For AWS and AZURE, this is the interface endpoint identifier. For GCP port-mapped architecture, this is the forwarding rule name. For GCP legacy private endpoint architecture, this is the endpoint group name.
    PrivateLinkId string
    Unique identifier of the AWS, AZURE or GCP PrivateLink connection which is created by mongodbatlas.PrivateLinkEndpoint resource.
    ProjectId string
    Unique identifier for the project, also known as groupId in the official documentation.
    ProviderName string
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE or GCP.
    DeleteOnCreateTimeout bool
    Indicates whether to delete the resource being created if a timeout is reached when waiting for completion. When set to true and timeout occurs, it triggers the deletion and returns immediately without waiting for deletion to complete. When set to false, the timeout will not trigger resource deletion. If you suspect a transient error when the value is true, wait before retrying to allow resource deletion to finish. Default is true.
    Endpoints List<PrivateLinkEndpointServiceEndpoint>
    Collection of individual private endpoints that comprise your endpoint group. Only for GCP legacy private endpoint architecture. Note: For the port-mapped architecture, this field is no longer used - use endpointServiceId and privateEndpointIpAddress instead.
    GcpProjectId string
    Unique identifier of the GCP project in which you created your endpoints. Required for GCP (both legacy and port-mapped architectures). Only for GCP.
    PrivateEndpointIpAddress string
    Private IP address of the private endpoint network interface. Required for AZURE and GCP Port-Mapped. For port-mapped architecture, this is required and is the IP address of the forwarding rule. For GCP legacy private endpoint architecture, this is not used.
    EndpointServiceId string
    Unique identifier of the interface endpoint you created in your VPC. For AWS and AZURE, this is the interface endpoint identifier. For GCP port-mapped architecture, this is the forwarding rule name. For GCP legacy private endpoint architecture, this is the endpoint group name.
    PrivateLinkId string
    Unique identifier of the AWS, AZURE or GCP PrivateLink connection which is created by mongodbatlas.PrivateLinkEndpoint resource.
    ProjectId string
    Unique identifier for the project, also known as groupId in the official documentation.
    ProviderName string
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE or GCP.
    DeleteOnCreateTimeout bool
    Indicates whether to delete the resource being created if a timeout is reached when waiting for completion. When set to true and timeout occurs, it triggers the deletion and returns immediately without waiting for deletion to complete. When set to false, the timeout will not trigger resource deletion. If you suspect a transient error when the value is true, wait before retrying to allow resource deletion to finish. Default is true.
    Endpoints []PrivateLinkEndpointServiceEndpointArgs
    Collection of individual private endpoints that comprise your endpoint group. Only for GCP legacy private endpoint architecture. Note: For the port-mapped architecture, this field is no longer used - use endpointServiceId and privateEndpointIpAddress instead.
    GcpProjectId string
    Unique identifier of the GCP project in which you created your endpoints. Required for GCP (both legacy and port-mapped architectures). Only for GCP.
    PrivateEndpointIpAddress string
    Private IP address of the private endpoint network interface. Required for AZURE and GCP Port-Mapped. For port-mapped architecture, this is required and is the IP address of the forwarding rule. For GCP legacy private endpoint architecture, this is not used.
    endpointServiceId String
    Unique identifier of the interface endpoint you created in your VPC. For AWS and AZURE, this is the interface endpoint identifier. For GCP port-mapped architecture, this is the forwarding rule name. For GCP legacy private endpoint architecture, this is the endpoint group name.
    privateLinkId String
    Unique identifier of the AWS, AZURE or GCP PrivateLink connection which is created by mongodbatlas.PrivateLinkEndpoint resource.
    projectId String
    Unique identifier for the project, also known as groupId in the official documentation.
    providerName String
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE or GCP.
    deleteOnCreateTimeout Boolean
    Indicates whether to delete the resource being created if a timeout is reached when waiting for completion. When set to true and timeout occurs, it triggers the deletion and returns immediately without waiting for deletion to complete. When set to false, the timeout will not trigger resource deletion. If you suspect a transient error when the value is true, wait before retrying to allow resource deletion to finish. Default is true.
    endpoints List<PrivateLinkEndpointServiceEndpoint>
    Collection of individual private endpoints that comprise your endpoint group. Only for GCP legacy private endpoint architecture. Note: For the port-mapped architecture, this field is no longer used - use endpointServiceId and privateEndpointIpAddress instead.
    gcpProjectId String
    Unique identifier of the GCP project in which you created your endpoints. Required for GCP (both legacy and port-mapped architectures). Only for GCP.
    privateEndpointIpAddress String
    Private IP address of the private endpoint network interface. Required for AZURE and GCP Port-Mapped. For port-mapped architecture, this is required and is the IP address of the forwarding rule. For GCP legacy private endpoint architecture, this is not used.
    endpointServiceId string
    Unique identifier of the interface endpoint you created in your VPC. For AWS and AZURE, this is the interface endpoint identifier. For GCP port-mapped architecture, this is the forwarding rule name. For GCP legacy private endpoint architecture, this is the endpoint group name.
    privateLinkId string
    Unique identifier of the AWS, AZURE or GCP PrivateLink connection which is created by mongodbatlas.PrivateLinkEndpoint resource.
    projectId string
    Unique identifier for the project, also known as groupId in the official documentation.
    providerName string
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE or GCP.
    deleteOnCreateTimeout boolean
    Indicates whether to delete the resource being created if a timeout is reached when waiting for completion. When set to true and timeout occurs, it triggers the deletion and returns immediately without waiting for deletion to complete. When set to false, the timeout will not trigger resource deletion. If you suspect a transient error when the value is true, wait before retrying to allow resource deletion to finish. Default is true.
    endpoints PrivateLinkEndpointServiceEndpoint[]
    Collection of individual private endpoints that comprise your endpoint group. Only for GCP legacy private endpoint architecture. Note: For the port-mapped architecture, this field is no longer used - use endpointServiceId and privateEndpointIpAddress instead.
    gcpProjectId string
    Unique identifier of the GCP project in which you created your endpoints. Required for GCP (both legacy and port-mapped architectures). Only for GCP.
    privateEndpointIpAddress string
    Private IP address of the private endpoint network interface. Required for AZURE and GCP Port-Mapped. For port-mapped architecture, this is required and is the IP address of the forwarding rule. For GCP legacy private endpoint architecture, this is not used.
    endpoint_service_id str
    Unique identifier of the interface endpoint you created in your VPC. For AWS and AZURE, this is the interface endpoint identifier. For GCP port-mapped architecture, this is the forwarding rule name. For GCP legacy private endpoint architecture, this is the endpoint group name.
    private_link_id str
    Unique identifier of the AWS, AZURE or GCP PrivateLink connection which is created by mongodbatlas.PrivateLinkEndpoint resource.
    project_id str
    Unique identifier for the project, also known as groupId in the official documentation.
    provider_name str
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE or GCP.
    delete_on_create_timeout bool
    Indicates whether to delete the resource being created if a timeout is reached when waiting for completion. When set to true and timeout occurs, it triggers the deletion and returns immediately without waiting for deletion to complete. When set to false, the timeout will not trigger resource deletion. If you suspect a transient error when the value is true, wait before retrying to allow resource deletion to finish. Default is true.
    endpoints Sequence[PrivateLinkEndpointServiceEndpointArgs]
    Collection of individual private endpoints that comprise your endpoint group. Only for GCP legacy private endpoint architecture. Note: For the port-mapped architecture, this field is no longer used - use endpointServiceId and privateEndpointIpAddress instead.
    gcp_project_id str
    Unique identifier of the GCP project in which you created your endpoints. Required for GCP (both legacy and port-mapped architectures). Only for GCP.
    private_endpoint_ip_address str
    Private IP address of the private endpoint network interface. Required for AZURE and GCP Port-Mapped. For port-mapped architecture, this is required and is the IP address of the forwarding rule. For GCP legacy private endpoint architecture, this is not used.
    endpointServiceId String
    Unique identifier of the interface endpoint you created in your VPC. For AWS and AZURE, this is the interface endpoint identifier. For GCP port-mapped architecture, this is the forwarding rule name. For GCP legacy private endpoint architecture, this is the endpoint group name.
    privateLinkId String
    Unique identifier of the AWS, AZURE or GCP PrivateLink connection which is created by mongodbatlas.PrivateLinkEndpoint resource.
    projectId String
    Unique identifier for the project, also known as groupId in the official documentation.
    providerName String
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE or GCP.
    deleteOnCreateTimeout Boolean
    Indicates whether to delete the resource being created if a timeout is reached when waiting for completion. When set to true and timeout occurs, it triggers the deletion and returns immediately without waiting for deletion to complete. When set to false, the timeout will not trigger resource deletion. If you suspect a transient error when the value is true, wait before retrying to allow resource deletion to finish. Default is true.
    endpoints List<Property Map>
    Collection of individual private endpoints that comprise your endpoint group. Only for GCP legacy private endpoint architecture. Note: For the port-mapped architecture, this field is no longer used - use endpointServiceId and privateEndpointIpAddress instead.
    gcpProjectId String
    Unique identifier of the GCP project in which you created your endpoints. Required for GCP (both legacy and port-mapped architectures). Only for GCP.
    privateEndpointIpAddress String
    Private IP address of the private endpoint network interface. Required for AZURE and GCP Port-Mapped. For port-mapped architecture, this is required and is the IP address of the forwarding rule. For GCP legacy private endpoint architecture, this is not used.

    Outputs

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

    AwsConnectionStatus string
    Status of the interface endpoint for AWS. Returns one of the following values:

    • NONE - Atlas created the network load balancer and VPC endpoint service, but AWS hasn't yet created the VPC endpoint.
    • PENDING_ACCEPTANCE - AWS has received the connection request from your VPC endpoint to the Atlas VPC endpoint service.
    • PENDING - AWS is establishing the connection between your VPC endpoint and the Atlas VPC endpoint service.
    • AVAILABLE - Atlas VPC resources are connected to the VPC endpoint in your VPC. You can connect to Atlas clusters in this region using AWS PrivateLink.
    • REJECTED - AWS failed to establish a connection between Atlas VPC resources to the VPC endpoint in your VPC.
    • DELETING - Atlas is removing the interface endpoint from the private endpoint connection.
    AzureStatus string
    Status of the interface endpoint for AZURE. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    DeleteRequested bool
    Indicates if Atlas received a request to remove the interface endpoint from the private endpoint connection.
    EndpointGroupName string
    ErrorMessage string
    Error message pertaining to the interface endpoint. Returns null if there are no errors.
    GcpEndpointStatus string
    Status of the individual endpoint. Only populated for port-mapped architecture. Returns one of the following values: INITIATING, AVAILABLE, FAILED, DELETING.
    GcpStatus string
    Status of the interface endpoint. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    Id string
    The provider-assigned unique ID for this managed resource.
    InterfaceEndpointId string
    Unique identifier of the interface endpoint.
    PortMappingEnabled bool
    Flag that indicates whether the underlying privatelinkEndpoint resource uses GCP port-mapping. This is a read-only attribute that reflects the architecture type. When true, the endpoint service uses the port-mapped architecture. When false, it uses the GCP legacy private endpoint architecture. Only applicable for GCP provider.
    PrivateEndpointConnectionName string
    Name of the connection for this private endpoint that Atlas generates.
    PrivateEndpointResourceId string
    Unique identifier of the private endpoint.
    AwsConnectionStatus string
    Status of the interface endpoint for AWS. Returns one of the following values:

    • NONE - Atlas created the network load balancer and VPC endpoint service, but AWS hasn't yet created the VPC endpoint.
    • PENDING_ACCEPTANCE - AWS has received the connection request from your VPC endpoint to the Atlas VPC endpoint service.
    • PENDING - AWS is establishing the connection between your VPC endpoint and the Atlas VPC endpoint service.
    • AVAILABLE - Atlas VPC resources are connected to the VPC endpoint in your VPC. You can connect to Atlas clusters in this region using AWS PrivateLink.
    • REJECTED - AWS failed to establish a connection between Atlas VPC resources to the VPC endpoint in your VPC.
    • DELETING - Atlas is removing the interface endpoint from the private endpoint connection.
    AzureStatus string
    Status of the interface endpoint for AZURE. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    DeleteRequested bool
    Indicates if Atlas received a request to remove the interface endpoint from the private endpoint connection.
    EndpointGroupName string
    ErrorMessage string
    Error message pertaining to the interface endpoint. Returns null if there are no errors.
    GcpEndpointStatus string
    Status of the individual endpoint. Only populated for port-mapped architecture. Returns one of the following values: INITIATING, AVAILABLE, FAILED, DELETING.
    GcpStatus string
    Status of the interface endpoint. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    Id string
    The provider-assigned unique ID for this managed resource.
    InterfaceEndpointId string
    Unique identifier of the interface endpoint.
    PortMappingEnabled bool
    Flag that indicates whether the underlying privatelinkEndpoint resource uses GCP port-mapping. This is a read-only attribute that reflects the architecture type. When true, the endpoint service uses the port-mapped architecture. When false, it uses the GCP legacy private endpoint architecture. Only applicable for GCP provider.
    PrivateEndpointConnectionName string
    Name of the connection for this private endpoint that Atlas generates.
    PrivateEndpointResourceId string
    Unique identifier of the private endpoint.
    awsConnectionStatus String
    Status of the interface endpoint for AWS. Returns one of the following values:

    • NONE - Atlas created the network load balancer and VPC endpoint service, but AWS hasn't yet created the VPC endpoint.
    • PENDING_ACCEPTANCE - AWS has received the connection request from your VPC endpoint to the Atlas VPC endpoint service.
    • PENDING - AWS is establishing the connection between your VPC endpoint and the Atlas VPC endpoint service.
    • AVAILABLE - Atlas VPC resources are connected to the VPC endpoint in your VPC. You can connect to Atlas clusters in this region using AWS PrivateLink.
    • REJECTED - AWS failed to establish a connection between Atlas VPC resources to the VPC endpoint in your VPC.
    • DELETING - Atlas is removing the interface endpoint from the private endpoint connection.
    azureStatus String
    Status of the interface endpoint for AZURE. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    deleteRequested Boolean
    Indicates if Atlas received a request to remove the interface endpoint from the private endpoint connection.
    endpointGroupName String
    errorMessage String
    Error message pertaining to the interface endpoint. Returns null if there are no errors.
    gcpEndpointStatus String
    Status of the individual endpoint. Only populated for port-mapped architecture. Returns one of the following values: INITIATING, AVAILABLE, FAILED, DELETING.
    gcpStatus String
    Status of the interface endpoint. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    id String
    The provider-assigned unique ID for this managed resource.
    interfaceEndpointId String
    Unique identifier of the interface endpoint.
    portMappingEnabled Boolean
    Flag that indicates whether the underlying privatelinkEndpoint resource uses GCP port-mapping. This is a read-only attribute that reflects the architecture type. When true, the endpoint service uses the port-mapped architecture. When false, it uses the GCP legacy private endpoint architecture. Only applicable for GCP provider.
    privateEndpointConnectionName String
    Name of the connection for this private endpoint that Atlas generates.
    privateEndpointResourceId String
    Unique identifier of the private endpoint.
    awsConnectionStatus string
    Status of the interface endpoint for AWS. Returns one of the following values:

    • NONE - Atlas created the network load balancer and VPC endpoint service, but AWS hasn't yet created the VPC endpoint.
    • PENDING_ACCEPTANCE - AWS has received the connection request from your VPC endpoint to the Atlas VPC endpoint service.
    • PENDING - AWS is establishing the connection between your VPC endpoint and the Atlas VPC endpoint service.
    • AVAILABLE - Atlas VPC resources are connected to the VPC endpoint in your VPC. You can connect to Atlas clusters in this region using AWS PrivateLink.
    • REJECTED - AWS failed to establish a connection between Atlas VPC resources to the VPC endpoint in your VPC.
    • DELETING - Atlas is removing the interface endpoint from the private endpoint connection.
    azureStatus string
    Status of the interface endpoint for AZURE. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    deleteRequested boolean
    Indicates if Atlas received a request to remove the interface endpoint from the private endpoint connection.
    endpointGroupName string
    errorMessage string
    Error message pertaining to the interface endpoint. Returns null if there are no errors.
    gcpEndpointStatus string
    Status of the individual endpoint. Only populated for port-mapped architecture. Returns one of the following values: INITIATING, AVAILABLE, FAILED, DELETING.
    gcpStatus string
    Status of the interface endpoint. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    id string
    The provider-assigned unique ID for this managed resource.
    interfaceEndpointId string
    Unique identifier of the interface endpoint.
    portMappingEnabled boolean
    Flag that indicates whether the underlying privatelinkEndpoint resource uses GCP port-mapping. This is a read-only attribute that reflects the architecture type. When true, the endpoint service uses the port-mapped architecture. When false, it uses the GCP legacy private endpoint architecture. Only applicable for GCP provider.
    privateEndpointConnectionName string
    Name of the connection for this private endpoint that Atlas generates.
    privateEndpointResourceId string
    Unique identifier of the private endpoint.
    aws_connection_status str
    Status of the interface endpoint for AWS. Returns one of the following values:

    • NONE - Atlas created the network load balancer and VPC endpoint service, but AWS hasn't yet created the VPC endpoint.
    • PENDING_ACCEPTANCE - AWS has received the connection request from your VPC endpoint to the Atlas VPC endpoint service.
    • PENDING - AWS is establishing the connection between your VPC endpoint and the Atlas VPC endpoint service.
    • AVAILABLE - Atlas VPC resources are connected to the VPC endpoint in your VPC. You can connect to Atlas clusters in this region using AWS PrivateLink.
    • REJECTED - AWS failed to establish a connection between Atlas VPC resources to the VPC endpoint in your VPC.
    • DELETING - Atlas is removing the interface endpoint from the private endpoint connection.
    azure_status str
    Status of the interface endpoint for AZURE. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    delete_requested bool
    Indicates if Atlas received a request to remove the interface endpoint from the private endpoint connection.
    endpoint_group_name str
    error_message str
    Error message pertaining to the interface endpoint. Returns null if there are no errors.
    gcp_endpoint_status str
    Status of the individual endpoint. Only populated for port-mapped architecture. Returns one of the following values: INITIATING, AVAILABLE, FAILED, DELETING.
    gcp_status str
    Status of the interface endpoint. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    id str
    The provider-assigned unique ID for this managed resource.
    interface_endpoint_id str
    Unique identifier of the interface endpoint.
    port_mapping_enabled bool
    Flag that indicates whether the underlying privatelinkEndpoint resource uses GCP port-mapping. This is a read-only attribute that reflects the architecture type. When true, the endpoint service uses the port-mapped architecture. When false, it uses the GCP legacy private endpoint architecture. Only applicable for GCP provider.
    private_endpoint_connection_name str
    Name of the connection for this private endpoint that Atlas generates.
    private_endpoint_resource_id str
    Unique identifier of the private endpoint.
    awsConnectionStatus String
    Status of the interface endpoint for AWS. Returns one of the following values:

    • NONE - Atlas created the network load balancer and VPC endpoint service, but AWS hasn't yet created the VPC endpoint.
    • PENDING_ACCEPTANCE - AWS has received the connection request from your VPC endpoint to the Atlas VPC endpoint service.
    • PENDING - AWS is establishing the connection between your VPC endpoint and the Atlas VPC endpoint service.
    • AVAILABLE - Atlas VPC resources are connected to the VPC endpoint in your VPC. You can connect to Atlas clusters in this region using AWS PrivateLink.
    • REJECTED - AWS failed to establish a connection between Atlas VPC resources to the VPC endpoint in your VPC.
    • DELETING - Atlas is removing the interface endpoint from the private endpoint connection.
    azureStatus String
    Status of the interface endpoint for AZURE. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    deleteRequested Boolean
    Indicates if Atlas received a request to remove the interface endpoint from the private endpoint connection.
    endpointGroupName String
    errorMessage String
    Error message pertaining to the interface endpoint. Returns null if there are no errors.
    gcpEndpointStatus String
    Status of the individual endpoint. Only populated for port-mapped architecture. Returns one of the following values: INITIATING, AVAILABLE, FAILED, DELETING.
    gcpStatus String
    Status of the interface endpoint. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    id String
    The provider-assigned unique ID for this managed resource.
    interfaceEndpointId String
    Unique identifier of the interface endpoint.
    portMappingEnabled Boolean
    Flag that indicates whether the underlying privatelinkEndpoint resource uses GCP port-mapping. This is a read-only attribute that reflects the architecture type. When true, the endpoint service uses the port-mapped architecture. When false, it uses the GCP legacy private endpoint architecture. Only applicable for GCP provider.
    privateEndpointConnectionName String
    Name of the connection for this private endpoint that Atlas generates.
    privateEndpointResourceId String
    Unique identifier of the private endpoint.

    Look up Existing PrivateLinkEndpointService Resource

    Get an existing PrivateLinkEndpointService 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?: PrivateLinkEndpointServiceState, opts?: CustomResourceOptions): PrivateLinkEndpointService
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        aws_connection_status: Optional[str] = None,
        azure_status: Optional[str] = None,
        delete_on_create_timeout: Optional[bool] = None,
        delete_requested: Optional[bool] = None,
        endpoint_group_name: Optional[str] = None,
        endpoint_service_id: Optional[str] = None,
        endpoints: Optional[Sequence[PrivateLinkEndpointServiceEndpointArgs]] = None,
        error_message: Optional[str] = None,
        gcp_endpoint_status: Optional[str] = None,
        gcp_project_id: Optional[str] = None,
        gcp_status: Optional[str] = None,
        interface_endpoint_id: Optional[str] = None,
        port_mapping_enabled: Optional[bool] = None,
        private_endpoint_connection_name: Optional[str] = None,
        private_endpoint_ip_address: Optional[str] = None,
        private_endpoint_resource_id: Optional[str] = None,
        private_link_id: Optional[str] = None,
        project_id: Optional[str] = None,
        provider_name: Optional[str] = None) -> PrivateLinkEndpointService
    func GetPrivateLinkEndpointService(ctx *Context, name string, id IDInput, state *PrivateLinkEndpointServiceState, opts ...ResourceOption) (*PrivateLinkEndpointService, error)
    public static PrivateLinkEndpointService Get(string name, Input<string> id, PrivateLinkEndpointServiceState? state, CustomResourceOptions? opts = null)
    public static PrivateLinkEndpointService get(String name, Output<String> id, PrivateLinkEndpointServiceState state, CustomResourceOptions options)
    resources:  _:    type: mongodbatlas:PrivateLinkEndpointService    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:
    AwsConnectionStatus string
    Status of the interface endpoint for AWS. Returns one of the following values:

    • NONE - Atlas created the network load balancer and VPC endpoint service, but AWS hasn't yet created the VPC endpoint.
    • PENDING_ACCEPTANCE - AWS has received the connection request from your VPC endpoint to the Atlas VPC endpoint service.
    • PENDING - AWS is establishing the connection between your VPC endpoint and the Atlas VPC endpoint service.
    • AVAILABLE - Atlas VPC resources are connected to the VPC endpoint in your VPC. You can connect to Atlas clusters in this region using AWS PrivateLink.
    • REJECTED - AWS failed to establish a connection between Atlas VPC resources to the VPC endpoint in your VPC.
    • DELETING - Atlas is removing the interface endpoint from the private endpoint connection.
    AzureStatus string
    Status of the interface endpoint for AZURE. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    DeleteOnCreateTimeout bool
    Indicates whether to delete the resource being created if a timeout is reached when waiting for completion. When set to true and timeout occurs, it triggers the deletion and returns immediately without waiting for deletion to complete. When set to false, the timeout will not trigger resource deletion. If you suspect a transient error when the value is true, wait before retrying to allow resource deletion to finish. Default is true.
    DeleteRequested bool
    Indicates if Atlas received a request to remove the interface endpoint from the private endpoint connection.
    EndpointGroupName string
    EndpointServiceId string
    Unique identifier of the interface endpoint you created in your VPC. For AWS and AZURE, this is the interface endpoint identifier. For GCP port-mapped architecture, this is the forwarding rule name. For GCP legacy private endpoint architecture, this is the endpoint group name.
    Endpoints List<PrivateLinkEndpointServiceEndpoint>
    Collection of individual private endpoints that comprise your endpoint group. Only for GCP legacy private endpoint architecture. Note: For the port-mapped architecture, this field is no longer used - use endpointServiceId and privateEndpointIpAddress instead.
    ErrorMessage string
    Error message pertaining to the interface endpoint. Returns null if there are no errors.
    GcpEndpointStatus string
    Status of the individual endpoint. Only populated for port-mapped architecture. Returns one of the following values: INITIATING, AVAILABLE, FAILED, DELETING.
    GcpProjectId string
    Unique identifier of the GCP project in which you created your endpoints. Required for GCP (both legacy and port-mapped architectures). Only for GCP.
    GcpStatus string
    Status of the interface endpoint. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    InterfaceEndpointId string
    Unique identifier of the interface endpoint.
    PortMappingEnabled bool
    Flag that indicates whether the underlying privatelinkEndpoint resource uses GCP port-mapping. This is a read-only attribute that reflects the architecture type. When true, the endpoint service uses the port-mapped architecture. When false, it uses the GCP legacy private endpoint architecture. Only applicable for GCP provider.
    PrivateEndpointConnectionName string
    Name of the connection for this private endpoint that Atlas generates.
    PrivateEndpointIpAddress string
    Private IP address of the private endpoint network interface. Required for AZURE and GCP Port-Mapped. For port-mapped architecture, this is required and is the IP address of the forwarding rule. For GCP legacy private endpoint architecture, this is not used.
    PrivateEndpointResourceId string
    Unique identifier of the private endpoint.
    PrivateLinkId string
    Unique identifier of the AWS, AZURE or GCP PrivateLink connection which is created by mongodbatlas.PrivateLinkEndpoint resource.
    ProjectId string
    Unique identifier for the project, also known as groupId in the official documentation.
    ProviderName string
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE or GCP.
    AwsConnectionStatus string
    Status of the interface endpoint for AWS. Returns one of the following values:

    • NONE - Atlas created the network load balancer and VPC endpoint service, but AWS hasn't yet created the VPC endpoint.
    • PENDING_ACCEPTANCE - AWS has received the connection request from your VPC endpoint to the Atlas VPC endpoint service.
    • PENDING - AWS is establishing the connection between your VPC endpoint and the Atlas VPC endpoint service.
    • AVAILABLE - Atlas VPC resources are connected to the VPC endpoint in your VPC. You can connect to Atlas clusters in this region using AWS PrivateLink.
    • REJECTED - AWS failed to establish a connection between Atlas VPC resources to the VPC endpoint in your VPC.
    • DELETING - Atlas is removing the interface endpoint from the private endpoint connection.
    AzureStatus string
    Status of the interface endpoint for AZURE. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    DeleteOnCreateTimeout bool
    Indicates whether to delete the resource being created if a timeout is reached when waiting for completion. When set to true and timeout occurs, it triggers the deletion and returns immediately without waiting for deletion to complete. When set to false, the timeout will not trigger resource deletion. If you suspect a transient error when the value is true, wait before retrying to allow resource deletion to finish. Default is true.
    DeleteRequested bool
    Indicates if Atlas received a request to remove the interface endpoint from the private endpoint connection.
    EndpointGroupName string
    EndpointServiceId string
    Unique identifier of the interface endpoint you created in your VPC. For AWS and AZURE, this is the interface endpoint identifier. For GCP port-mapped architecture, this is the forwarding rule name. For GCP legacy private endpoint architecture, this is the endpoint group name.
    Endpoints []PrivateLinkEndpointServiceEndpointArgs
    Collection of individual private endpoints that comprise your endpoint group. Only for GCP legacy private endpoint architecture. Note: For the port-mapped architecture, this field is no longer used - use endpointServiceId and privateEndpointIpAddress instead.
    ErrorMessage string
    Error message pertaining to the interface endpoint. Returns null if there are no errors.
    GcpEndpointStatus string
    Status of the individual endpoint. Only populated for port-mapped architecture. Returns one of the following values: INITIATING, AVAILABLE, FAILED, DELETING.
    GcpProjectId string
    Unique identifier of the GCP project in which you created your endpoints. Required for GCP (both legacy and port-mapped architectures). Only for GCP.
    GcpStatus string
    Status of the interface endpoint. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    InterfaceEndpointId string
    Unique identifier of the interface endpoint.
    PortMappingEnabled bool
    Flag that indicates whether the underlying privatelinkEndpoint resource uses GCP port-mapping. This is a read-only attribute that reflects the architecture type. When true, the endpoint service uses the port-mapped architecture. When false, it uses the GCP legacy private endpoint architecture. Only applicable for GCP provider.
    PrivateEndpointConnectionName string
    Name of the connection for this private endpoint that Atlas generates.
    PrivateEndpointIpAddress string
    Private IP address of the private endpoint network interface. Required for AZURE and GCP Port-Mapped. For port-mapped architecture, this is required and is the IP address of the forwarding rule. For GCP legacy private endpoint architecture, this is not used.
    PrivateEndpointResourceId string
    Unique identifier of the private endpoint.
    PrivateLinkId string
    Unique identifier of the AWS, AZURE or GCP PrivateLink connection which is created by mongodbatlas.PrivateLinkEndpoint resource.
    ProjectId string
    Unique identifier for the project, also known as groupId in the official documentation.
    ProviderName string
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE or GCP.
    awsConnectionStatus String
    Status of the interface endpoint for AWS. Returns one of the following values:

    • NONE - Atlas created the network load balancer and VPC endpoint service, but AWS hasn't yet created the VPC endpoint.
    • PENDING_ACCEPTANCE - AWS has received the connection request from your VPC endpoint to the Atlas VPC endpoint service.
    • PENDING - AWS is establishing the connection between your VPC endpoint and the Atlas VPC endpoint service.
    • AVAILABLE - Atlas VPC resources are connected to the VPC endpoint in your VPC. You can connect to Atlas clusters in this region using AWS PrivateLink.
    • REJECTED - AWS failed to establish a connection between Atlas VPC resources to the VPC endpoint in your VPC.
    • DELETING - Atlas is removing the interface endpoint from the private endpoint connection.
    azureStatus String
    Status of the interface endpoint for AZURE. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    deleteOnCreateTimeout Boolean
    Indicates whether to delete the resource being created if a timeout is reached when waiting for completion. When set to true and timeout occurs, it triggers the deletion and returns immediately without waiting for deletion to complete. When set to false, the timeout will not trigger resource deletion. If you suspect a transient error when the value is true, wait before retrying to allow resource deletion to finish. Default is true.
    deleteRequested Boolean
    Indicates if Atlas received a request to remove the interface endpoint from the private endpoint connection.
    endpointGroupName String
    endpointServiceId String
    Unique identifier of the interface endpoint you created in your VPC. For AWS and AZURE, this is the interface endpoint identifier. For GCP port-mapped architecture, this is the forwarding rule name. For GCP legacy private endpoint architecture, this is the endpoint group name.
    endpoints List<PrivateLinkEndpointServiceEndpoint>
    Collection of individual private endpoints that comprise your endpoint group. Only for GCP legacy private endpoint architecture. Note: For the port-mapped architecture, this field is no longer used - use endpointServiceId and privateEndpointIpAddress instead.
    errorMessage String
    Error message pertaining to the interface endpoint. Returns null if there are no errors.
    gcpEndpointStatus String
    Status of the individual endpoint. Only populated for port-mapped architecture. Returns one of the following values: INITIATING, AVAILABLE, FAILED, DELETING.
    gcpProjectId String
    Unique identifier of the GCP project in which you created your endpoints. Required for GCP (both legacy and port-mapped architectures). Only for GCP.
    gcpStatus String
    Status of the interface endpoint. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    interfaceEndpointId String
    Unique identifier of the interface endpoint.
    portMappingEnabled Boolean
    Flag that indicates whether the underlying privatelinkEndpoint resource uses GCP port-mapping. This is a read-only attribute that reflects the architecture type. When true, the endpoint service uses the port-mapped architecture. When false, it uses the GCP legacy private endpoint architecture. Only applicable for GCP provider.
    privateEndpointConnectionName String
    Name of the connection for this private endpoint that Atlas generates.
    privateEndpointIpAddress String
    Private IP address of the private endpoint network interface. Required for AZURE and GCP Port-Mapped. For port-mapped architecture, this is required and is the IP address of the forwarding rule. For GCP legacy private endpoint architecture, this is not used.
    privateEndpointResourceId String
    Unique identifier of the private endpoint.
    privateLinkId String
    Unique identifier of the AWS, AZURE or GCP PrivateLink connection which is created by mongodbatlas.PrivateLinkEndpoint resource.
    projectId String
    Unique identifier for the project, also known as groupId in the official documentation.
    providerName String
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE or GCP.
    awsConnectionStatus string
    Status of the interface endpoint for AWS. Returns one of the following values:

    • NONE - Atlas created the network load balancer and VPC endpoint service, but AWS hasn't yet created the VPC endpoint.
    • PENDING_ACCEPTANCE - AWS has received the connection request from your VPC endpoint to the Atlas VPC endpoint service.
    • PENDING - AWS is establishing the connection between your VPC endpoint and the Atlas VPC endpoint service.
    • AVAILABLE - Atlas VPC resources are connected to the VPC endpoint in your VPC. You can connect to Atlas clusters in this region using AWS PrivateLink.
    • REJECTED - AWS failed to establish a connection between Atlas VPC resources to the VPC endpoint in your VPC.
    • DELETING - Atlas is removing the interface endpoint from the private endpoint connection.
    azureStatus string
    Status of the interface endpoint for AZURE. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    deleteOnCreateTimeout boolean
    Indicates whether to delete the resource being created if a timeout is reached when waiting for completion. When set to true and timeout occurs, it triggers the deletion and returns immediately without waiting for deletion to complete. When set to false, the timeout will not trigger resource deletion. If you suspect a transient error when the value is true, wait before retrying to allow resource deletion to finish. Default is true.
    deleteRequested boolean
    Indicates if Atlas received a request to remove the interface endpoint from the private endpoint connection.
    endpointGroupName string
    endpointServiceId string
    Unique identifier of the interface endpoint you created in your VPC. For AWS and AZURE, this is the interface endpoint identifier. For GCP port-mapped architecture, this is the forwarding rule name. For GCP legacy private endpoint architecture, this is the endpoint group name.
    endpoints PrivateLinkEndpointServiceEndpoint[]
    Collection of individual private endpoints that comprise your endpoint group. Only for GCP legacy private endpoint architecture. Note: For the port-mapped architecture, this field is no longer used - use endpointServiceId and privateEndpointIpAddress instead.
    errorMessage string
    Error message pertaining to the interface endpoint. Returns null if there are no errors.
    gcpEndpointStatus string
    Status of the individual endpoint. Only populated for port-mapped architecture. Returns one of the following values: INITIATING, AVAILABLE, FAILED, DELETING.
    gcpProjectId string
    Unique identifier of the GCP project in which you created your endpoints. Required for GCP (both legacy and port-mapped architectures). Only for GCP.
    gcpStatus string
    Status of the interface endpoint. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    interfaceEndpointId string
    Unique identifier of the interface endpoint.
    portMappingEnabled boolean
    Flag that indicates whether the underlying privatelinkEndpoint resource uses GCP port-mapping. This is a read-only attribute that reflects the architecture type. When true, the endpoint service uses the port-mapped architecture. When false, it uses the GCP legacy private endpoint architecture. Only applicable for GCP provider.
    privateEndpointConnectionName string
    Name of the connection for this private endpoint that Atlas generates.
    privateEndpointIpAddress string
    Private IP address of the private endpoint network interface. Required for AZURE and GCP Port-Mapped. For port-mapped architecture, this is required and is the IP address of the forwarding rule. For GCP legacy private endpoint architecture, this is not used.
    privateEndpointResourceId string
    Unique identifier of the private endpoint.
    privateLinkId string
    Unique identifier of the AWS, AZURE or GCP PrivateLink connection which is created by mongodbatlas.PrivateLinkEndpoint resource.
    projectId string
    Unique identifier for the project, also known as groupId in the official documentation.
    providerName string
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE or GCP.
    aws_connection_status str
    Status of the interface endpoint for AWS. Returns one of the following values:

    • NONE - Atlas created the network load balancer and VPC endpoint service, but AWS hasn't yet created the VPC endpoint.
    • PENDING_ACCEPTANCE - AWS has received the connection request from your VPC endpoint to the Atlas VPC endpoint service.
    • PENDING - AWS is establishing the connection between your VPC endpoint and the Atlas VPC endpoint service.
    • AVAILABLE - Atlas VPC resources are connected to the VPC endpoint in your VPC. You can connect to Atlas clusters in this region using AWS PrivateLink.
    • REJECTED - AWS failed to establish a connection between Atlas VPC resources to the VPC endpoint in your VPC.
    • DELETING - Atlas is removing the interface endpoint from the private endpoint connection.
    azure_status str
    Status of the interface endpoint for AZURE. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    delete_on_create_timeout bool
    Indicates whether to delete the resource being created if a timeout is reached when waiting for completion. When set to true and timeout occurs, it triggers the deletion and returns immediately without waiting for deletion to complete. When set to false, the timeout will not trigger resource deletion. If you suspect a transient error when the value is true, wait before retrying to allow resource deletion to finish. Default is true.
    delete_requested bool
    Indicates if Atlas received a request to remove the interface endpoint from the private endpoint connection.
    endpoint_group_name str
    endpoint_service_id str
    Unique identifier of the interface endpoint you created in your VPC. For AWS and AZURE, this is the interface endpoint identifier. For GCP port-mapped architecture, this is the forwarding rule name. For GCP legacy private endpoint architecture, this is the endpoint group name.
    endpoints Sequence[PrivateLinkEndpointServiceEndpointArgs]
    Collection of individual private endpoints that comprise your endpoint group. Only for GCP legacy private endpoint architecture. Note: For the port-mapped architecture, this field is no longer used - use endpointServiceId and privateEndpointIpAddress instead.
    error_message str
    Error message pertaining to the interface endpoint. Returns null if there are no errors.
    gcp_endpoint_status str
    Status of the individual endpoint. Only populated for port-mapped architecture. Returns one of the following values: INITIATING, AVAILABLE, FAILED, DELETING.
    gcp_project_id str
    Unique identifier of the GCP project in which you created your endpoints. Required for GCP (both legacy and port-mapped architectures). Only for GCP.
    gcp_status str
    Status of the interface endpoint. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    interface_endpoint_id str
    Unique identifier of the interface endpoint.
    port_mapping_enabled bool
    Flag that indicates whether the underlying privatelinkEndpoint resource uses GCP port-mapping. This is a read-only attribute that reflects the architecture type. When true, the endpoint service uses the port-mapped architecture. When false, it uses the GCP legacy private endpoint architecture. Only applicable for GCP provider.
    private_endpoint_connection_name str
    Name of the connection for this private endpoint that Atlas generates.
    private_endpoint_ip_address str
    Private IP address of the private endpoint network interface. Required for AZURE and GCP Port-Mapped. For port-mapped architecture, this is required and is the IP address of the forwarding rule. For GCP legacy private endpoint architecture, this is not used.
    private_endpoint_resource_id str
    Unique identifier of the private endpoint.
    private_link_id str
    Unique identifier of the AWS, AZURE or GCP PrivateLink connection which is created by mongodbatlas.PrivateLinkEndpoint resource.
    project_id str
    Unique identifier for the project, also known as groupId in the official documentation.
    provider_name str
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE or GCP.
    awsConnectionStatus String
    Status of the interface endpoint for AWS. Returns one of the following values:

    • NONE - Atlas created the network load balancer and VPC endpoint service, but AWS hasn't yet created the VPC endpoint.
    • PENDING_ACCEPTANCE - AWS has received the connection request from your VPC endpoint to the Atlas VPC endpoint service.
    • PENDING - AWS is establishing the connection between your VPC endpoint and the Atlas VPC endpoint service.
    • AVAILABLE - Atlas VPC resources are connected to the VPC endpoint in your VPC. You can connect to Atlas clusters in this region using AWS PrivateLink.
    • REJECTED - AWS failed to establish a connection between Atlas VPC resources to the VPC endpoint in your VPC.
    • DELETING - Atlas is removing the interface endpoint from the private endpoint connection.
    azureStatus String
    Status of the interface endpoint for AZURE. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    deleteOnCreateTimeout Boolean
    Indicates whether to delete the resource being created if a timeout is reached when waiting for completion. When set to true and timeout occurs, it triggers the deletion and returns immediately without waiting for deletion to complete. When set to false, the timeout will not trigger resource deletion. If you suspect a transient error when the value is true, wait before retrying to allow resource deletion to finish. Default is true.
    deleteRequested Boolean
    Indicates if Atlas received a request to remove the interface endpoint from the private endpoint connection.
    endpointGroupName String
    endpointServiceId String
    Unique identifier of the interface endpoint you created in your VPC. For AWS and AZURE, this is the interface endpoint identifier. For GCP port-mapped architecture, this is the forwarding rule name. For GCP legacy private endpoint architecture, this is the endpoint group name.
    endpoints List<Property Map>
    Collection of individual private endpoints that comprise your endpoint group. Only for GCP legacy private endpoint architecture. Note: For the port-mapped architecture, this field is no longer used - use endpointServiceId and privateEndpointIpAddress instead.
    errorMessage String
    Error message pertaining to the interface endpoint. Returns null if there are no errors.
    gcpEndpointStatus String
    Status of the individual endpoint. Only populated for port-mapped architecture. Returns one of the following values: INITIATING, AVAILABLE, FAILED, DELETING.
    gcpProjectId String
    Unique identifier of the GCP project in which you created your endpoints. Required for GCP (both legacy and port-mapped architectures). Only for GCP.
    gcpStatus String
    Status of the interface endpoint. Returns one of the following values:

    • INITIATING - Atlas has not yet accepted the connection to your private endpoint.
    • AVAILABLE - Atlas approved the connection to your private endpoint.
    • FAILED - Atlas failed to accept the connection your private endpoint.
    • DELETING - Atlas is removing the connection to your private endpoint from the Private Link service.
    interfaceEndpointId String
    Unique identifier of the interface endpoint.
    portMappingEnabled Boolean
    Flag that indicates whether the underlying privatelinkEndpoint resource uses GCP port-mapping. This is a read-only attribute that reflects the architecture type. When true, the endpoint service uses the port-mapped architecture. When false, it uses the GCP legacy private endpoint architecture. Only applicable for GCP provider.
    privateEndpointConnectionName String
    Name of the connection for this private endpoint that Atlas generates.
    privateEndpointIpAddress String
    Private IP address of the private endpoint network interface. Required for AZURE and GCP Port-Mapped. For port-mapped architecture, this is required and is the IP address of the forwarding rule. For GCP legacy private endpoint architecture, this is not used.
    privateEndpointResourceId String
    Unique identifier of the private endpoint.
    privateLinkId String
    Unique identifier of the AWS, AZURE or GCP PrivateLink connection which is created by mongodbatlas.PrivateLinkEndpoint resource.
    projectId String
    Unique identifier for the project, also known as groupId in the official documentation.
    providerName String
    Cloud provider for which you want to create a private endpoint. Atlas accepts AWS, AZURE or GCP.

    Supporting Types

    PrivateLinkEndpointServiceEndpoint, PrivateLinkEndpointServiceEndpointArgs

    EndpointName string
    Forwarding rule that corresponds to the endpoint you created.
    IpAddress string
    Private IP address of the endpoint you created.
    Status string
    Status of the endpoint. Atlas returns one of the values shown above.
    EndpointName string
    Forwarding rule that corresponds to the endpoint you created.
    IpAddress string
    Private IP address of the endpoint you created.
    Status string
    Status of the endpoint. Atlas returns one of the values shown above.
    endpointName String
    Forwarding rule that corresponds to the endpoint you created.
    ipAddress String
    Private IP address of the endpoint you created.
    status String
    Status of the endpoint. Atlas returns one of the values shown above.
    endpointName string
    Forwarding rule that corresponds to the endpoint you created.
    ipAddress string
    Private IP address of the endpoint you created.
    status string
    Status of the endpoint. Atlas returns one of the values shown above.
    endpoint_name str
    Forwarding rule that corresponds to the endpoint you created.
    ip_address str
    Private IP address of the endpoint you created.
    status str
    Status of the endpoint. Atlas returns one of the values shown above.
    endpointName String
    Forwarding rule that corresponds to the endpoint you created.
    ipAddress String
    Private IP address of the endpoint you created.
    status String
    Status of the endpoint. Atlas returns one of the values shown above.

    Import

    Private Endpoint Link Connection can be imported using project ID, private link ID, endpoint service ID, and provider name, in the format {project_id}--{private_link_id}--{endpoint_service_id}--{provider_name}, e.g.

    $ pulumi import mongodbatlas:index/privateLinkEndpointService:PrivateLinkEndpointService this 1112222b3bf99403840e8934--3242342343112--vpce-4242342343--AWS

    For more information, see:

    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
    Viewing docs for MongoDB Atlas v4.6.0
    published on Tuesday, Mar 31, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-mongodbatlas
      Try Pulumi Cloud free. Your team will thank you.