Sign in Dashboard Get started
  1. Packages
  2. Packages
  3. Mongodbatlas Provider
  4. API Docs
  5. getStreamPrivatelinkEndpoint
Viewing docs for MongoDB Atlas v4.13.0
published on Thursday, Jul 30, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-mongodbatlas

mongodbatlas.getStreamPrivatelinkEndpoint

mongodbatlas logo
Viewing docs for MongoDB Atlas v4.13.0
published on Thursday, Jul 30, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-mongodbatlas

    mongodbatlas.StreamPrivatelinkEndpoint describes a Privatelink Endpoint for Streams.

    Example Usage

    S

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

// S3 bucket for stream data
const streamBucket = new aws.index.S3Bucket("stream_bucket", {
    bucket: s3BucketName,
    forceDestroy: true,
});
const streamBucketVersioning = new aws.index.S3BucketVersioning("stream_bucket_versioning", {
    bucket: streamBucket.id,
    versioningConfiguration: [{
        status: "Enabled",
    }],
});
const streamBucketEncryption = new aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption", {
    bucket: streamBucket.id,
    rule: [{
        applyServerSideEncryptionByDefault: [{
            sseAlgorithm: "AES256",
        }],
    }],
});
// PrivateLink for S3
const _this = new mongodbatlas.StreamPrivatelinkEndpoint("this", {
    projectId: projectId,
    providerName: "AWS",
    vendor: "S3",
    region: region,
    serviceEndpointId: serviceEndpointId,
});
export const privatelinkEndpointId = _this.id;

    import pulumi
import pulumi_aws as aws
import pulumi_mongodbatlas as mongodbatlas

# S3 bucket for stream data
stream_bucket = aws.S3Bucket("stream_bucket",
    bucket=s3_bucket_name,
    force_destroy=True)
stream_bucket_versioning = aws.S3BucketVersioning("stream_bucket_versioning",
    bucket=stream_bucket.id,
    versioning_configuration=[{
        status: Enabled,
    }])
stream_bucket_encryption = aws.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption",
    bucket=stream_bucket.id,
    rule=[{
        applyServerSideEncryptionByDefault: [{
            sseAlgorithm: AES256,
        }],
    }])
# PrivateLink for S3
this = mongodbatlas.StreamPrivatelinkEndpoint("this",
    project_id=project_id,
    provider_name="AWS",
    vendor="S3",
    region=region,
    service_endpoint_id=service_endpoint_id)
pulumi.export("privatelinkEndpointId", this.id)

    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 {
		// S3 bucket for stream data
		streamBucket, err := aws.NewS3Bucket(ctx, "stream_bucket", &aws.S3BucketArgs{
			Bucket:       s3BucketName,
			ForceDestroy: true,
		})
		if err != nil {
			return err
		}
		_, err = aws.NewS3BucketVersioning(ctx, "stream_bucket_versioning", &aws.S3BucketVersioningArgs{
			Bucket: streamBucket.Id,
			VersioningConfiguration: []map[string]interface{}{
				map[string]interface{}{
					"status": "Enabled",
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = aws.NewS3BucketServerSideEncryptionConfiguration(ctx, "stream_bucket_encryption", &aws.S3BucketServerSideEncryptionConfigurationArgs{
			Bucket: streamBucket.Id,
			Rule: []map[string]interface{}{
				map[string]interface{}{
					"applyServerSideEncryptionByDefault": []map[string]interface{}{
						map[string]interface{}{
							"sseAlgorithm": "AES256",
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// PrivateLink for S3
		this, err := mongodbatlas.NewStreamPrivatelinkEndpoint(ctx, "this", &mongodbatlas.StreamPrivatelinkEndpointArgs{
			ProjectId:         pulumi.Any(projectId),
			ProviderName:      pulumi.String("AWS"),
			Vendor:            pulumi.String("S3"),
			Region:            pulumi.Any(region),
			ServiceEndpointId: pulumi.Any(serviceEndpointId),
		})
		if err != nil {
			return err
		}
		ctx.Export("privatelinkEndpointId", this.ID())
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // S3 bucket for stream data
    var streamBucket = new Aws.S3Bucket("stream_bucket", new()
    {
        Bucket = s3BucketName,
        ForceDestroy = true,
    });

    var streamBucketVersioning = new Aws.S3BucketVersioning("stream_bucket_versioning", new()
    {
        Bucket = streamBucket.Id,
        VersioningConfiguration = new[]
        {
            
            {
                { "status", "Enabled" },
            },
        },
    });

    var streamBucketEncryption = new Aws.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption", new()
    {
        Bucket = streamBucket.Id,
        Rule = new[]
        {
            
            {
                { "applyServerSideEncryptionByDefault", new[]
                {
                    
                    {
                        { "sseAlgorithm", "AES256" },
                    },
                } },
            },
        },
    });

    // PrivateLink for S3
    var @this = new Mongodbatlas.StreamPrivatelinkEndpoint("this", new()
    {
        ProjectId = projectId,
        ProviderName = "AWS",
        Vendor = "S3",
        Region = region,
        ServiceEndpointId = serviceEndpointId,
    });

    return new Dictionary<string, object?>
    {
        ["privatelinkEndpointId"] = @this.Id,
    };
});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.S3Bucket;
import com.pulumi.aws.S3BucketArgs;
import com.pulumi.aws.S3BucketVersioning;
import com.pulumi.aws.S3BucketVersioningArgs;
import com.pulumi.aws.S3BucketServerSideEncryptionConfiguration;
import com.pulumi.aws.S3BucketServerSideEncryptionConfigurationArgs;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpoint;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpointArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // S3 bucket for stream data
        var streamBucket = new S3Bucket("streamBucket", S3BucketArgs.builder()
            .bucket(s3BucketName)
            .forceDestroy(true)
            .build());

        var streamBucketVersioning = new S3BucketVersioning("streamBucketVersioning", S3BucketVersioningArgs.builder()
            .bucket(streamBucket.id())
            .versioningConfiguration(Arrays.asList(Map.of("status", "Enabled")))
            .build());

        var streamBucketEncryption = new S3BucketServerSideEncryptionConfiguration("streamBucketEncryption", S3BucketServerSideEncryptionConfigurationArgs.builder()
            .bucket(streamBucket.id())
            .rule(Arrays.asList(Map.of("applyServerSideEncryptionByDefault", Arrays.asList(Map.of("sseAlgorithm", "AES256")))))
            .build());

        // PrivateLink for S3
        var this_ = new StreamPrivatelinkEndpoint("this", StreamPrivatelinkEndpointArgs.builder()
            .projectId(projectId)
            .providerName("AWS")
            .vendor("S3")
            .region(region)
            .serviceEndpointId(serviceEndpointId)
            .build());

        ctx.export("privatelinkEndpointId", this_.id());
    }
}

    resources:
  # S3 bucket for stream data
  streamBucket:
    type: aws:S3Bucket
    name: stream_bucket
    properties:
      bucket: ${s3BucketName}
      forceDestroy: true
  streamBucketVersioning:
    type: aws:S3BucketVersioning
    name: stream_bucket_versioning
    properties:
      bucket: ${streamBucket.id}
      versioningConfiguration:
        - status: Enabled
  streamBucketEncryption:
    type: aws:S3BucketServerSideEncryptionConfiguration
    name: stream_bucket_encryption
    properties:
      bucket: ${streamBucket.id}
      rule:
        - applyServerSideEncryptionByDefault:
            - sseAlgorithm: AES256
  # PrivateLink for S3
  this:
    type: mongodbatlas:StreamPrivatelinkEndpoint
    properties:
      projectId: ${projectId}
      providerName: AWS
      vendor: S3
      region: ${region}
      serviceEndpointId: ${serviceEndpointId}
outputs:
  privatelinkEndpointId: ${this.id}

    pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
    mongodbatlas = {
      source = "pulumi/mongodbatlas"
    }
  }
}

# S3 bucket for stream data
resource "aws_s3bucket" "stream_bucket" {
  bucket        = s3BucketName
  force_destroy = true
}
resource "aws_s3bucketversioning" "stream_bucket_versioning" {
  bucket = aws_s3bucket.stream_bucket.id
  versioning_configuration = [{
    "status" = "Enabled"
  }]
}
resource "aws_s3bucketserversideencryptionconfiguration" "stream_bucket_encryption" {
  bucket = aws_s3bucket.stream_bucket.id
  rule = [{
    "applyServerSideEncryptionByDefault" = [{
      "sseAlgorithm" = "AES256"
    }]
  }]
}
# PrivateLink for S3
resource "mongodbatlas_streamprivatelinkendpoint" "this" {
  project_id          = projectId
  provider_name       = "AWS"
  vendor              = "S3"
  region              = region
  service_endpoint_id = serviceEndpointId
}
output "privatelinkEndpointId" {
  value = mongodbatlas_streamprivatelinkendpoint.this.id
}

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

const gcpConfluentStreamPrivatelinkEndpoint = new mongodbatlas.StreamPrivatelinkEndpoint("gcp_confluent", {
    projectId: projectId,
    providerName: "GCP",
    vendor: "CONFLUENT",
    region: gcpRegion,
    dnsDomain: confluentDnsDomain,
    dnsSubDomains: confluentDnsSubdomains,
    serviceAttachmentUris: [
        "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1",
        "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2",
    ],
});
const gcpConfluent = mongodbatlas.getStreamPrivatelinkEndpointOutput({
    projectId: projectId,
    id: gcpConfluentStreamPrivatelinkEndpoint.id,
});
export const privatelinkEndpointId = gcpConfluentStreamPrivatelinkEndpoint.id;
export const privatelinkEndpointState = gcpConfluent.apply(gcpConfluent => gcpConfluent.state);
export const serviceAttachmentUris = gcpConfluentStreamPrivatelinkEndpoint.serviceAttachmentUris;

    import pulumi
import pulumi_mongodbatlas as mongodbatlas

gcp_confluent_stream_privatelink_endpoint = mongodbatlas.StreamPrivatelinkEndpoint("gcp_confluent",
    project_id=project_id,
    provider_name="GCP",
    vendor="CONFLUENT",
    region=gcp_region,
    dns_domain=confluent_dns_domain,
    dns_sub_domains=confluent_dns_subdomains,
    service_attachment_uris=[
        "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1",
        "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2",
    ])
gcp_confluent = mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
    id=gcp_confluent_stream_privatelink_endpoint.id)
pulumi.export("privatelinkEndpointId", gcp_confluent_stream_privatelink_endpoint.id)
pulumi.export("privatelinkEndpointState", gcp_confluent.state)
pulumi.export("serviceAttachmentUris", gcp_confluent_stream_privatelink_endpoint.service_attachment_uris)

    package main

import (
	"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 {
		gcpConfluentStreamPrivatelinkEndpoint, err := mongodbatlas.NewStreamPrivatelinkEndpoint(ctx, "gcp_confluent", &mongodbatlas.StreamPrivatelinkEndpointArgs{
			ProjectId:     pulumi.Any(projectId),
			ProviderName:  pulumi.String("GCP"),
			Vendor:        pulumi.String("CONFLUENT"),
			Region:        pulumi.Any(gcpRegion),
			DnsDomain:     pulumi.Any(confluentDnsDomain),
			DnsSubDomains: pulumi.Any(confluentDnsSubdomains),
			ServiceAttachmentUris: pulumi.StringArray{
				pulumi.String("projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1"),
				pulumi.String("projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2"),
			},
		})
		if err != nil {
			return err
		}
		gcpConfluent := mongodbatlas.GetStreamPrivatelinkEndpointOutput(ctx, mongodbatlas.GetStreamPrivatelinkEndpointOutputArgs{
			ProjectId: pulumi.Any(projectId),
			Id:        gcpConfluentStreamPrivatelinkEndpoint.ID(),
		}, nil)
		ctx.Export("privatelinkEndpointId", gcpConfluentStreamPrivatelinkEndpoint.ID())
		ctx.Export("privatelinkEndpointState", gcpConfluent.ApplyT(func(gcpConfluent mongodbatlas.GetStreamPrivatelinkEndpointResult) (*string, error) {
			return gcpConfluent.State, nil
		}).(pulumi.StringPtrOutput))
		ctx.Export("serviceAttachmentUris", gcpConfluentStreamPrivatelinkEndpoint.ServiceAttachmentUris)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var gcpConfluentStreamPrivatelinkEndpoint = new Mongodbatlas.StreamPrivatelinkEndpoint("gcp_confluent", new()
    {
        ProjectId = projectId,
        ProviderName = "GCP",
        Vendor = "CONFLUENT",
        Region = gcpRegion,
        DnsDomain = confluentDnsDomain,
        DnsSubDomains = confluentDnsSubdomains,
        ServiceAttachmentUris = new[]
        {
            "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1",
            "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2",
        },
    });

    var gcpConfluent = Mongodbatlas.GetStreamPrivatelinkEndpoint.Invoke(new()
    {
        ProjectId = projectId,
        Id = gcpConfluentStreamPrivatelinkEndpoint.Id,
    });

    return new Dictionary<string, object?>
    {
        ["privatelinkEndpointId"] = gcpConfluentStreamPrivatelinkEndpoint.Id,
        ["privatelinkEndpointState"] = gcpConfluent.Apply(getStreamPrivatelinkEndpointResult => getStreamPrivatelinkEndpointResult.State),
        ["serviceAttachmentUris"] = gcpConfluentStreamPrivatelinkEndpoint.ServiceAttachmentUris,
    };
});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpoint;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpointArgs;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetStreamPrivatelinkEndpointArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 gcpConfluentStreamPrivatelinkEndpoint = new StreamPrivatelinkEndpoint("gcpConfluentStreamPrivatelinkEndpoint", StreamPrivatelinkEndpointArgs.builder()
            .projectId(projectId)
            .providerName("GCP")
            .vendor("CONFLUENT")
            .region(gcpRegion)
            .dnsDomain(confluentDnsDomain)
            .dnsSubDomains(confluentDnsSubdomains)
            .serviceAttachmentUris(            
                "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1",
                "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2")
            .build());

        final var gcpConfluent = MongodbatlasFunctions.getStreamPrivatelinkEndpoint(GetStreamPrivatelinkEndpointArgs.builder()
            .projectId(projectId)
            .id(gcpConfluentStreamPrivatelinkEndpoint.id())
            .build());

        ctx.export("privatelinkEndpointId", gcpConfluentStreamPrivatelinkEndpoint.id());
        ctx.export("privatelinkEndpointState", gcpConfluent.applyValue(_gcpConfluent -> _gcpConfluent.state()));
        ctx.export("serviceAttachmentUris", gcpConfluentStreamPrivatelinkEndpoint.serviceAttachmentUris());
    }
}

    resources:
  gcpConfluentStreamPrivatelinkEndpoint:
    type: mongodbatlas:StreamPrivatelinkEndpoint
    name: gcp_confluent
    properties:
      projectId: ${projectId}
      providerName: GCP
      vendor: CONFLUENT
      region: ${gcpRegion}
      dnsDomain: ${confluentDnsDomain}
      dnsSubDomains: ${confluentDnsSubdomains}
      serviceAttachmentUris:
        - projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1
        - projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2
variables:
  gcpConfluent:
    fn::invoke:
      function: mongodbatlas:getStreamPrivatelinkEndpoint
      arguments:
        projectId: ${projectId}
        id: ${gcpConfluentStreamPrivatelinkEndpoint.id}
outputs:
  privatelinkEndpointId: ${gcpConfluentStreamPrivatelinkEndpoint.id}
  privatelinkEndpointState: ${gcpConfluent.state}
  serviceAttachmentUris: ${gcpConfluentStreamPrivatelinkEndpoint.serviceAttachmentUris}

    pulumi {
  required_providers {
    mongodbatlas = {
      source = "pulumi/mongodbatlas"
    }
  }
}

data "mongodbatlas_getstreamprivatelinkendpoint" "gcpConfluent" {
  project_id = projectId
  id         = mongodbatlas_streamprivatelinkendpoint.gcp_confluent.id
}

resource "mongodbatlas_streamprivatelinkendpoint" "gcp_confluent" {
  project_id              = projectId
  provider_name           = "GCP"
  vendor                  = "CONFLUENT"
  region                  = gcpRegion
  dns_domain              = confluentDnsDomain
  dns_sub_domains         = confluentDnsSubdomains
  service_attachment_uris = ["projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1", "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2"]
}
output "privatelinkEndpointId" {
  value = mongodbatlas_streamprivatelinkendpoint.gcp_confluent.id
}
output "privatelinkEndpointState" {
  value = data.mongodbatlas_getstreamprivatelinkendpoint.gcpConfluent.state
}
output "serviceAttachmentUris" {
  value = mongodbatlas_streamprivatelinkendpoint.gcp_confluent.service_attachment_uris
}

    GCP Pub/Sub Private Service Connect

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

const cluster = new mongodbatlas.AdvancedCluster("cluster", {
    projectId: projectId,
    name: clusterName,
    clusterType: "REPLICASET",
    replicationSpecs: [{
        regionConfigs: [{
            priority: 7,
            providerName: "GCP",
            regionName: "US_EAST_4",
            electableSpecs: {
                instanceSize: "M10",
                nodeCount: 3,
            },
        }],
    }],
});
const gcpPubsubStreamPrivatelinkEndpoint = new mongodbatlas.StreamPrivatelinkEndpoint("gcp_pubsub", {
    projectId: projectId,
    providerName: "GCP",
    vendor: "PUBSUB",
    region: gcpRegion,
}, {
    dependsOn: [cluster],
});
const gcpPubsub = mongodbatlas.getStreamPrivatelinkEndpointOutput({
    projectId: projectId,
    id: gcpPubsubStreamPrivatelinkEndpoint.id,
});
export const privatelinkEndpointId = gcpPubsubStreamPrivatelinkEndpoint.id;
export const privatelinkEndpointState = gcpPubsub.apply(gcpPubsub => gcpPubsub.state);
export const dnsDomain = gcpPubsubStreamPrivatelinkEndpoint.dnsDomain;

    import pulumi
import pulumi_mongodbatlas as mongodbatlas

cluster = mongodbatlas.AdvancedCluster("cluster",
    project_id=project_id,
    name=cluster_name,
    cluster_type="REPLICASET",
    replication_specs=[{
        "region_configs": [{
            "priority": 7,
            "provider_name": "GCP",
            "region_name": "US_EAST_4",
            "electable_specs": {
                "instance_size": "M10",
                "node_count": 3,
            },
        }],
    }])
gcp_pubsub_stream_privatelink_endpoint = mongodbatlas.StreamPrivatelinkEndpoint("gcp_pubsub",
    project_id=project_id,
    provider_name="GCP",
    vendor="PUBSUB",
    region=gcp_region,
    opts = pulumi.ResourceOptions(depends_on=[cluster]))
gcp_pubsub = mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
    id=gcp_pubsub_stream_privatelink_endpoint.id)
pulumi.export("privatelinkEndpointId", gcp_pubsub_stream_privatelink_endpoint.id)
pulumi.export("privatelinkEndpointState", gcp_pubsub.state)
pulumi.export("dnsDomain", gcp_pubsub_stream_privatelink_endpoint.dns_domain)

    package main

import (
	"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 {
		cluster, err := mongodbatlas.NewAdvancedCluster(ctx, "cluster", &mongodbatlas.AdvancedClusterArgs{
			ProjectId:   pulumi.Any(projectId),
			Name:        pulumi.Any(clusterName),
			ClusterType: pulumi.String("REPLICASET"),
			ReplicationSpecs: mongodbatlas.AdvancedClusterReplicationSpecArray{
				&mongodbatlas.AdvancedClusterReplicationSpecArgs{
					RegionConfigs: mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArray{
						&mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArgs{
							Priority:     pulumi.Int(7),
							ProviderName: pulumi.String("GCP"),
							RegionName:   pulumi.String("US_EAST_4"),
							ElectableSpecs: &mongodbatlas.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs{
								InstanceSize: pulumi.String("M10"),
								NodeCount:    pulumi.Int(3),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		gcpPubsubStreamPrivatelinkEndpoint, err := mongodbatlas.NewStreamPrivatelinkEndpoint(ctx, "gcp_pubsub", &mongodbatlas.StreamPrivatelinkEndpointArgs{
			ProjectId:    pulumi.Any(projectId),
			ProviderName: pulumi.String("GCP"),
			Vendor:       pulumi.String("PUBSUB"),
			Region:       pulumi.Any(gcpRegion),
		}, pulumi.DependsOn([]pulumi.Resource{
			cluster,
		}))
		if err != nil {
			return err
		}
		gcpPubsub := mongodbatlas.GetStreamPrivatelinkEndpointOutput(ctx, mongodbatlas.GetStreamPrivatelinkEndpointOutputArgs{
			ProjectId: pulumi.Any(projectId),
			Id:        gcpPubsubStreamPrivatelinkEndpoint.ID(),
		}, nil)
		ctx.Export("privatelinkEndpointId", gcpPubsubStreamPrivatelinkEndpoint.ID())
		ctx.Export("privatelinkEndpointState", gcpPubsub.ApplyT(func(gcpPubsub mongodbatlas.GetStreamPrivatelinkEndpointResult) (*string, error) {
			return gcpPubsub.State, nil
		}).(pulumi.StringPtrOutput))
		ctx.Export("dnsDomain", gcpPubsubStreamPrivatelinkEndpoint.DnsDomain)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var cluster = new Mongodbatlas.AdvancedCluster("cluster", new()
    {
        ProjectId = projectId,
        Name = clusterName,
        ClusterType = "REPLICASET",
        ReplicationSpecs = new[]
        {
            new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecArgs
            {
                RegionConfigs = new[]
                {
                    new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigArgs
                    {
                        Priority = 7,
                        ProviderName = "GCP",
                        RegionName = "US_EAST_4",
                        ElectableSpecs = new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs
                        {
                            InstanceSize = "M10",
                            NodeCount = 3,
                        },
                    },
                },
            },
        },
    });

    var gcpPubsubStreamPrivatelinkEndpoint = new Mongodbatlas.StreamPrivatelinkEndpoint("gcp_pubsub", new()
    {
        ProjectId = projectId,
        ProviderName = "GCP",
        Vendor = "PUBSUB",
        Region = gcpRegion,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            cluster,
        },
    });

    var gcpPubsub = Mongodbatlas.GetStreamPrivatelinkEndpoint.Invoke(new()
    {
        ProjectId = projectId,
        Id = gcpPubsubStreamPrivatelinkEndpoint.Id,
    });

    return new Dictionary<string, object?>
    {
        ["privatelinkEndpointId"] = gcpPubsubStreamPrivatelinkEndpoint.Id,
        ["privatelinkEndpointState"] = gcpPubsub.Apply(getStreamPrivatelinkEndpointResult => getStreamPrivatelinkEndpointResult.State),
        ["dnsDomain"] = gcpPubsubStreamPrivatelinkEndpoint.DnsDomain,
    };
});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.AdvancedCluster;
import com.pulumi.mongodbatlas.AdvancedClusterArgs;
import com.pulumi.mongodbatlas.inputs.AdvancedClusterReplicationSpecArgs;
import com.pulumi.mongodbatlas.inputs.AdvancedClusterReplicationSpecRegionConfigArgs;
import com.pulumi.mongodbatlas.inputs.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpoint;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpointArgs;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetStreamPrivatelinkEndpointArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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 cluster = new AdvancedCluster("cluster", AdvancedClusterArgs.builder()
            .projectId(projectId)
            .name(clusterName)
            .clusterType("REPLICASET")
            .replicationSpecs(AdvancedClusterReplicationSpecArgs.builder()
                .regionConfigs(AdvancedClusterReplicationSpecRegionConfigArgs.builder()
                    .priority(7)
                    .providerName("GCP")
                    .regionName("US_EAST_4")
                    .electableSpecs(AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs.builder()
                        .instanceSize("M10")
                        .nodeCount(3)
                        .build())
                    .build())
                .build())
            .build());

        var gcpPubsubStreamPrivatelinkEndpoint = new StreamPrivatelinkEndpoint("gcpPubsubStreamPrivatelinkEndpoint", StreamPrivatelinkEndpointArgs.builder()
            .projectId(projectId)
            .providerName("GCP")
            .vendor("PUBSUB")
            .region(gcpRegion)
            .build(), CustomResourceOptions.builder()
                .dependsOn(cluster)
                .build());

        final var gcpPubsub = MongodbatlasFunctions.getStreamPrivatelinkEndpoint(GetStreamPrivatelinkEndpointArgs.builder()
            .projectId(projectId)
            .id(gcpPubsubStreamPrivatelinkEndpoint.id())
            .build());

        ctx.export("privatelinkEndpointId", gcpPubsubStreamPrivatelinkEndpoint.id());
        ctx.export("privatelinkEndpointState", gcpPubsub.applyValue(_gcpPubsub -> _gcpPubsub.state()));
        ctx.export("dnsDomain", gcpPubsubStreamPrivatelinkEndpoint.dnsDomain());
    }
}

    resources:
  cluster:
    type: mongodbatlas:AdvancedCluster
    properties:
      projectId: ${projectId}
      name: ${clusterName}
      clusterType: REPLICASET
      replicationSpecs:
        - regionConfigs:
            - priority: 7
              providerName: GCP
              regionName: US_EAST_4
              electableSpecs:
                instanceSize: M10
                nodeCount: 3
  gcpPubsubStreamPrivatelinkEndpoint:
    type: mongodbatlas:StreamPrivatelinkEndpoint
    name: gcp_pubsub
    properties:
      projectId: ${projectId}
      providerName: GCP
      vendor: PUBSUB
      region: ${gcpRegion}
    options:
      dependsOn:
        - ${cluster}
variables:
  gcpPubsub:
    fn::invoke:
      function: mongodbatlas:getStreamPrivatelinkEndpoint
      arguments:
        projectId: ${projectId}
        id: ${gcpPubsubStreamPrivatelinkEndpoint.id}
outputs:
  privatelinkEndpointId: ${gcpPubsubStreamPrivatelinkEndpoint.id}
  privatelinkEndpointState: ${gcpPubsub.state}
  dnsDomain: ${gcpPubsubStreamPrivatelinkEndpoint.dnsDomain}

    pulumi {
  required_providers {
    mongodbatlas = {
      source = "pulumi/mongodbatlas"
    }
  }
}

data "mongodbatlas_getstreamprivatelinkendpoint" "gcpPubsub" {
  project_id = projectId
  id         = mongodbatlas_streamprivatelinkendpoint.gcp_pubsub.id
}

resource "mongodbatlas_advancedcluster" "cluster" {
  project_id   = projectId
  name         = clusterName
  cluster_type = "REPLICASET"
  replication_specs {
    region_configs {
      priority      = 7
      provider_name = "GCP"
      region_name   = "US_EAST_4"
      electable_specs = {
        instance_size = "M10"
        node_count    = 3
      }
    }
  }
}
resource "mongodbatlas_streamprivatelinkendpoint" "gcp_pubsub" {
  depends_on    = [mongodbatlas_advancedcluster.cluster]
  project_id    = projectId
  provider_name = "GCP"
  vendor        = "PUBSUB"
  region        = gcpRegion
}
output "privatelinkEndpointId" {
  value = mongodbatlas_streamprivatelinkendpoint.gcp_pubsub.id
}
output "privatelinkEndpointState" {
  value = data.mongodbatlas_getstreamprivatelinkendpoint.gcpPubsub.state
}
output "dnsDomain" {
  value = mongodbatlas_streamprivatelinkendpoint.gcp_pubsub.dns_domain
}

    NOTE: An Azure cluster must be provisioned in the same region before creating an Azure Blob Storage private endpoint.

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

const cluster = new mongodbatlas.AdvancedCluster("cluster", {
    projectId: projectId,
    name: clusterName,
    clusterType: "REPLICASET",
    replicationSpecs: [{
        regionConfigs: [{
            priority: 7,
            providerName: "AZURE",
            regionName: "US_EAST_2",
            electableSpecs: {
                instanceSize: "M10",
                nodeCount: 3,
            },
        }],
    }],
});
const _this = new mongodbatlas.StreamPrivatelinkEndpoint("this", {
    projectId: projectId,
    vendor: "AZURE_BLOB_STORAGE",
    providerName: "AZURE",
    region: atlasRegion,
    dnsDomain: `${storageAccountName}.blob.core.windows.net`,
    serviceEndpointId: `/subscriptions/${current.subscriptionId}/resourceGroups/${azureResourceGroup}/providers/Microsoft.Storage/storageAccounts/${storageAccountName}`,
}, {
    dependsOn: [
        cluster,
        blobEndpoint,
    ],
});
export const privatelinkEndpointId = _this.id;

    import pulumi
import pulumi_mongodbatlas as mongodbatlas

cluster = mongodbatlas.AdvancedCluster("cluster",
    project_id=project_id,
    name=cluster_name,
    cluster_type="REPLICASET",
    replication_specs=[{
        "region_configs": [{
            "priority": 7,
            "provider_name": "AZURE",
            "region_name": "US_EAST_2",
            "electable_specs": {
                "instance_size": "M10",
                "node_count": 3,
            },
        }],
    }])
this = mongodbatlas.StreamPrivatelinkEndpoint("this",
    project_id=project_id,
    vendor="AZURE_BLOB_STORAGE",
    provider_name="AZURE",
    region=atlas_region,
    dns_domain=f"{storage_account_name}.blob.core.windows.net",
    service_endpoint_id=f"/subscriptions/{current['subscriptionId']}/resourceGroups/{azure_resource_group}/providers/Microsoft.Storage/storageAccounts/{storage_account_name}",
    opts = pulumi.ResourceOptions(depends_on=[
            cluster,
            blob_endpoint,
        ]))
pulumi.export("privatelinkEndpointId", this.id)

    package main

import (
	"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 {
		cluster, err := mongodbatlas.NewAdvancedCluster(ctx, "cluster", &mongodbatlas.AdvancedClusterArgs{
			ProjectId:   pulumi.Any(projectId),
			Name:        pulumi.Any(clusterName),
			ClusterType: pulumi.String("REPLICASET"),
			ReplicationSpecs: mongodbatlas.AdvancedClusterReplicationSpecArray{
				&mongodbatlas.AdvancedClusterReplicationSpecArgs{
					RegionConfigs: mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArray{
						&mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArgs{
							Priority:     pulumi.Int(7),
							ProviderName: pulumi.String("AZURE"),
							RegionName:   pulumi.String("US_EAST_2"),
							ElectableSpecs: &mongodbatlas.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs{
								InstanceSize: pulumi.String("M10"),
								NodeCount:    pulumi.Int(3),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		this, err := mongodbatlas.NewStreamPrivatelinkEndpoint(ctx, "this", &mongodbatlas.StreamPrivatelinkEndpointArgs{
			ProjectId:         pulumi.Any(projectId),
			Vendor:            pulumi.String("AZURE_BLOB_STORAGE"),
			ProviderName:      pulumi.String("AZURE"),
			Region:            pulumi.Any(atlasRegion),
			DnsDomain:         pulumi.Sprintf("%v.blob.core.windows.net", storageAccountName),
			ServiceEndpointId: pulumi.Sprintf("/subscriptions/%v/resourceGroups/%v/providers/Microsoft.Storage/storageAccounts/%v", current.SubscriptionId, azureResourceGroup, storageAccountName),
		}, pulumi.DependsOn([]pulumi.Resource{
			cluster,
			blobEndpoint,
		}))
		if err != nil {
			return err
		}
		ctx.Export("privatelinkEndpointId", this.ID())
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var cluster = new Mongodbatlas.AdvancedCluster("cluster", new()
    {
        ProjectId = projectId,
        Name = clusterName,
        ClusterType = "REPLICASET",
        ReplicationSpecs = new[]
        {
            new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecArgs
            {
                RegionConfigs = new[]
                {
                    new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigArgs
                    {
                        Priority = 7,
                        ProviderName = "AZURE",
                        RegionName = "US_EAST_2",
                        ElectableSpecs = new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs
                        {
                            InstanceSize = "M10",
                            NodeCount = 3,
                        },
                    },
                },
            },
        },
    });

    var @this = new Mongodbatlas.StreamPrivatelinkEndpoint("this", new()
    {
        ProjectId = projectId,
        Vendor = "AZURE_BLOB_STORAGE",
        ProviderName = "AZURE",
        Region = atlasRegion,
        DnsDomain = $"{storageAccountName}.blob.core.windows.net",
        ServiceEndpointId = $"/subscriptions/{current.SubscriptionId}/resourceGroups/{azureResourceGroup}/providers/Microsoft.Storage/storageAccounts/{storageAccountName}",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            cluster,
            blobEndpoint,
        },
    });

    return new Dictionary<string, object?>
    {
        ["privatelinkEndpointId"] = @this.Id,
    };
});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.AdvancedCluster;
import com.pulumi.mongodbatlas.AdvancedClusterArgs;
import com.pulumi.mongodbatlas.inputs.AdvancedClusterReplicationSpecArgs;
import com.pulumi.mongodbatlas.inputs.AdvancedClusterReplicationSpecRegionConfigArgs;
import com.pulumi.mongodbatlas.inputs.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpoint;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpointArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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 cluster = new AdvancedCluster("cluster", AdvancedClusterArgs.builder()
            .projectId(projectId)
            .name(clusterName)
            .clusterType("REPLICASET")
            .replicationSpecs(AdvancedClusterReplicationSpecArgs.builder()
                .regionConfigs(AdvancedClusterReplicationSpecRegionConfigArgs.builder()
                    .priority(7)
                    .providerName("AZURE")
                    .regionName("US_EAST_2")
                    .electableSpecs(AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs.builder()
                        .instanceSize("M10")
                        .nodeCount(3)
                        .build())
                    .build())
                .build())
            .build());

        var this_ = new StreamPrivatelinkEndpoint("this", StreamPrivatelinkEndpointArgs.builder()
            .projectId(projectId)
            .vendor("AZURE_BLOB_STORAGE")
            .providerName("AZURE")
            .region(atlasRegion)
            .dnsDomain(String.format("%s.blob.core.windows.net", storageAccountName))
            .serviceEndpointId(String.format("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Storage/storageAccounts/%s", current.subscriptionId(),azureResourceGroup,storageAccountName))
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    cluster,
                    blobEndpoint)
                .build());

        ctx.export("privatelinkEndpointId", this_.id());
    }
}

    resources:
  cluster:
    type: mongodbatlas:AdvancedCluster
    properties:
      projectId: ${projectId}
      name: ${clusterName}
      clusterType: REPLICASET
      replicationSpecs:
        - regionConfigs:
            - priority: 7
              providerName: AZURE
              regionName: US_EAST_2
              electableSpecs:
                instanceSize: M10
                nodeCount: 3
  this:
    type: mongodbatlas:StreamPrivatelinkEndpoint
    properties:
      projectId: ${projectId}
      vendor: AZURE_BLOB_STORAGE
      providerName: AZURE
      region: ${atlasRegion}
      dnsDomain: ${storageAccountName}.blob.core.windows.net
      serviceEndpointId: /subscriptions/${current.subscriptionId}/resourceGroups/${azureResourceGroup}/providers/Microsoft.Storage/storageAccounts/${storageAccountName}
    options:
      dependsOn:
        - ${cluster}
        - ${blobEndpoint}
outputs:
  privatelinkEndpointId: ${this.id}

    pulumi {
  required_providers {
    mongodbatlas = {
      source = "pulumi/mongodbatlas"
    }
  }
}

resource "mongodbatlas_advancedcluster" "cluster" {
  project_id   = projectId
  name         = clusterName
  cluster_type = "REPLICASET"
  replication_specs {
    region_configs {
      priority      = 7
      provider_name = "AZURE"
      region_name   = "US_EAST_2"
      electable_specs = {
        instance_size = "M10"
        node_count    = 3
      }
    }
  }
}
resource "mongodbatlas_streamprivatelinkendpoint" "this" {
  depends_on          = [mongodbatlas_advancedcluster.cluster, blobEndpoint]
  project_id          = projectId
  vendor              = "AZURE_BLOB_STORAGE"
  provider_name       = "AZURE"
  region              = atlasRegion
  dns_domain          ="${storageAccountName}.blob.core.windows.net"
  service_endpoint_id ="/subscriptions/${current.subscriptionId}/resourceGroups/${azureResourceGroup}/providers/Microsoft.Storage/storageAccounts/${storageAccountName}"
}
output "privatelinkEndpointId" {
  value = mongodbatlas_streamprivatelinkendpoint.this.id
}

    Using getStreamPrivatelinkEndpoint

    Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

    function getStreamPrivatelinkEndpoint(args: GetStreamPrivatelinkEndpointArgs, opts?: InvokeOptions): Promise<GetStreamPrivatelinkEndpointResult>
function getStreamPrivatelinkEndpointOutput(args: GetStreamPrivatelinkEndpointOutputArgs, opts?: InvokeOptions): Output<GetStreamPrivatelinkEndpointResult>
    def get_stream_privatelink_endpoint(id: Optional[str] = None,
                                    project_id: Optional[str] = None,
                                    opts: Optional[InvokeOptions] = None) -> GetStreamPrivatelinkEndpointResult
def get_stream_privatelink_endpoint_output(id: pulumi.Input[Optional[str]] = None,
                                    project_id: pulumi.Input[Optional[str]] = None,
                                    opts: Optional[InvokeOptions] = None) -> Output[GetStreamPrivatelinkEndpointResult]
    func LookupStreamPrivatelinkEndpoint(ctx *Context, args *LookupStreamPrivatelinkEndpointArgs, opts ...InvokeOption) (*LookupStreamPrivatelinkEndpointResult, error)
func LookupStreamPrivatelinkEndpointOutput(ctx *Context, args *LookupStreamPrivatelinkEndpointOutputArgs, opts ...InvokeOption) LookupStreamPrivatelinkEndpointResultOutput

    > Note: This function is named LookupStreamPrivatelinkEndpoint in the Go SDK.

    public static class GetStreamPrivatelinkEndpoint 
{
    public static Task<GetStreamPrivatelinkEndpointResult> InvokeAsync(GetStreamPrivatelinkEndpointArgs args, InvokeOptions? opts = null)
    public static Output<GetStreamPrivatelinkEndpointResult> Invoke(GetStreamPrivatelinkEndpointInvokeArgs args, InvokeOptions? opts = null)
}
    public static CompletableFuture<GetStreamPrivatelinkEndpointResult> getStreamPrivatelinkEndpoint(GetStreamPrivatelinkEndpointArgs args, InvokeOptions options)
public static Output<GetStreamPrivatelinkEndpointResult> getStreamPrivatelinkEndpoint(GetStreamPrivatelinkEndpointArgs args, InvokeOptions options)

    fn::invoke:
  function: mongodbatlas:index/getStreamPrivatelinkEndpoint:getStreamPrivatelinkEndpoint
  arguments:
    # arguments dictionary
    data "mongodbatlas_get_stream_privatelink_endpoint" "name" {
    # arguments
}

    The following arguments are supported:

    Id string
    ProjectId string
    Id string
    ProjectId string
    id string
    project_id string
    id String
    projectId String
    id string
    projectId string
    id str
    project_id str
    id String
    projectId String

    getStreamPrivatelinkEndpoint Result

    The following output properties are available:

    Arn string
    DnsDomain string
    DnsSubDomains List<string>
    ErrorMessage string
    Id string
    InterfaceEndpointId string
    InterfaceEndpointName string
    ProjectId string
    ProviderAccountId string
    ProviderName string
    Region string
    ServiceAttachmentUris List<string>
    ServiceEndpointId string
    State string
    Vendor string
    arn String
    dnsDomain String
    dnsSubDomains List<String>
    errorMessage String
    id String
    interfaceEndpointId String
    interfaceEndpointName String
    projectId String
    providerAccountId String
    providerName String
    region String
    serviceAttachmentUris List<String>
    serviceEndpointId String
    state String
    vendor String
    arn String
    dnsDomain String
    dnsSubDomains List<String>
    errorMessage String
    id String
    interfaceEndpointId String
    interfaceEndpointName String
    projectId String
    providerAccountId String
    providerName String
    region String
    serviceAttachmentUris List<String>
    serviceEndpointId String
    state String
    vendor String

    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.13.0
    published on Thursday, Jul 30, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-mongodbatlas

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial