pulumi-mongodbatlas 3.38.0__tar.gz → 3.38.0a1764802483__tar.gz

{pulumi_mongodbatlas-3.38.0 → pulumi_mongodbatlas-3.38.0a1764802483}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_mongodbatlas
-Version: 3.38.0
+Version: 3.38.0a1764802483
 Summary: A Pulumi package for creating and managing mongodbatlas cloud resources.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io

{pulumi_mongodbatlas-3.38.0 → pulumi_mongodbatlas-3.38.0a1764802483}/pulumi_mongodbatlas/get_stream_privatelink_endpoint.py

@@ -235,6 +235,101 @@ def get_stream_privatelink_endpoint(id: Optional[_builtins.str] = None,
     pulumi.export("interfaceEndpointIds", [__item.interface_endpoint_id for __item in plural_datasource.results])
     ```
 
+    ### AWS MSK Privatelink
+    ```python
+    import pulumi
+    import json
+    import pulumi_aws as aws
+    import pulumi_mongodbatlas as mongodbatlas
+
+    vpc = aws.ec2.Vpc("vpc", cidr_block="192.168.0.0/22")
+    azs = aws.get_availability_zones(state="available")
+    subnet_az1 = aws.ec2.Subnet("subnet_az1",
+        availability_zone=azs.names[0],
+        cidr_block="192.168.0.0/24",
+        vpc_id=vpc.id)
+    subnet_az2 = aws.ec2.Subnet("subnet_az2",
+        availability_zone=azs.names[1],
+        cidr_block="192.168.1.0/24",
+        vpc_id=vpc.id)
+    sg = aws.ec2.SecurityGroup("sg", vpc_id=vpc.id)
+    example_configuration = aws.msk.Configuration("example",
+        name=f"{msk_cluster_name}-msk-configuration",
+        server_properties=\"\"\"auto.create.topics.enable=false
+    default.replication.factor=3
+    min.insync.replicas=2
+    num.io.threads=8
+    num.network.threads=5
+    num.partitions=1
+    num.replica.fetchers=2
+    replica.lag.time.max.ms=30000
+    socket.receive.buffer.bytes=102400
+    socket.request.max.bytes=104857600
+    socket.send.buffer.bytes=102400
+    unclean.leader.election.enable=true
+    allow.everyone.if.no.acl.found=false
+    \"\"\")
+    example = aws.msk.Cluster("example",
+        cluster_name=msk_cluster_name,
+        kafka_version="3.6.0",
+        number_of_broker_nodes=2,
+        broker_node_group_info={
+            "instance_type": "kafka.m5.large",
+            "client_subnets": [
+                subnet_az1.id,
+                subnet_az2.id,
+            ],
+            "security_groups": [sg.id],
+            "connectivity_info": {
+                "vpc_connectivity": {
+                    "client_authentication": {
+                        "sasl": {
+                            "scram": True,
+                        },
+                    },
+                },
+            },
+        },
+        client_authentication={
+            "sasl": {
+                "scram": True,
+            },
+        },
+        configuration_info={
+            "arn": example_configuration.arn,
+            "revision": example_configuration.latest_revision,
+        })
+    example_cluster_policy = aws.msk.ClusterPolicy("example",
+        cluster_arn=example.arn,
+        policy=pulumi.Output.json_dumps({
+            "Version": "2012-10-17",
+            "Statement": [{
+                "Effect": "Allow",
+                "Principal": {
+                    "AWS": f"arn:aws:iam::{aws_account_id}:root",
+                },
+                "Action": [
+                    "kafka:CreateVpcConnection",
+                    "kafka:GetBootstrapBrokers",
+                    "kafka:DescribeCluster",
+                    "kafka:DescribeClusterV2",
+                ],
+                "Resource": example.arn,
+            }],
+        }))
+    example_msk_single_scram_secret_association = aws.index.MskSingleScramSecretAssociation("example",
+        cluster_arn=example.arn,
+        secret_arn=aws_secret_arn)
+    test = mongodbatlas.StreamPrivatelinkEndpoint("test",
+        project_id=project_id,
+        provider_name="AWS",
+        vendor="MSK",
+        arn=example.arn)
+    singular_datasource = test.id.apply(lambda id: mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
+        id=id))
+    pulumi.export("privatelinkEndpointId", singular_datasource.id)
+    ```
+
     ### AWS S3 Privatelink
     ```python
     import pulumi
@@ -242,20 +337,20 @@ def get_stream_privatelink_endpoint(id: Optional[_builtins.str] = None,
     import pulumi_mongodbatlas as mongodbatlas
 
     # S3 bucket for stream data
-    stream_bucket = aws.index.S3Bucket("stream_bucket",
+    stream_bucket = aws.s3.BucketV2("stream_bucket",
         bucket=s3_bucket_name,
         force_destroy=True)
-    stream_bucket_versioning = aws.index.S3BucketVersioning("stream_bucket_versioning",
+    stream_bucket_versioning = aws.s3.BucketVersioningV2("stream_bucket_versioning",
         bucket=stream_bucket.id,
-        versioning_configuration=[{
-            status: Enabled,
-        }])
-    stream_bucket_encryption = aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption",
+        versioning_configuration={
+            "status": "Enabled",
+        })
+    stream_bucket_encryption = aws.s3.BucketServerSideEncryptionConfigurationV2("stream_bucket_encryption",
         bucket=stream_bucket.id,
-        rule=[{
-            applyServerSideEncryptionByDefault: [{
-                sseAlgorithm: AES256,
-            }],
+        rules=[{
+            "apply_server_side_encryption_by_default": {
+                "sse_algorithm": "AES256",
+            },
         }])
     # PrivateLink for S3
     this = mongodbatlas.StreamPrivatelinkEndpoint("this",
@@ -360,6 +455,101 @@ def get_stream_privatelink_endpoint_output(id: Optional[pulumi.Input[_builtins.s
     pulumi.export("interfaceEndpointIds", [__item.interface_endpoint_id for __item in plural_datasource.results])
     ```
 
+    ### AWS MSK Privatelink
+    ```python
+    import pulumi
+    import json
+    import pulumi_aws as aws
+    import pulumi_mongodbatlas as mongodbatlas
+
+    vpc = aws.ec2.Vpc("vpc", cidr_block="192.168.0.0/22")
+    azs = aws.get_availability_zones(state="available")
+    subnet_az1 = aws.ec2.Subnet("subnet_az1",
+        availability_zone=azs.names[0],
+        cidr_block="192.168.0.0/24",
+        vpc_id=vpc.id)
+    subnet_az2 = aws.ec2.Subnet("subnet_az2",
+        availability_zone=azs.names[1],
+        cidr_block="192.168.1.0/24",
+        vpc_id=vpc.id)
+    sg = aws.ec2.SecurityGroup("sg", vpc_id=vpc.id)
+    example_configuration = aws.msk.Configuration("example",
+        name=f"{msk_cluster_name}-msk-configuration",
+        server_properties=\"\"\"auto.create.topics.enable=false
+    default.replication.factor=3
+    min.insync.replicas=2
+    num.io.threads=8
+    num.network.threads=5
+    num.partitions=1
+    num.replica.fetchers=2
+    replica.lag.time.max.ms=30000
+    socket.receive.buffer.bytes=102400
+    socket.request.max.bytes=104857600
+    socket.send.buffer.bytes=102400
+    unclean.leader.election.enable=true
+    allow.everyone.if.no.acl.found=false
+    \"\"\")
+    example = aws.msk.Cluster("example",
+        cluster_name=msk_cluster_name,
+        kafka_version="3.6.0",
+        number_of_broker_nodes=2,
+        broker_node_group_info={
+            "instance_type": "kafka.m5.large",
+            "client_subnets": [
+                subnet_az1.id,
+                subnet_az2.id,
+            ],
+            "security_groups": [sg.id],
+            "connectivity_info": {
+                "vpc_connectivity": {
+                    "client_authentication": {
+                        "sasl": {
+                            "scram": True,
+                        },
+                    },
+                },
+            },
+        },
+        client_authentication={
+            "sasl": {
+                "scram": True,
+            },
+        },
+        configuration_info={
+            "arn": example_configuration.arn,
+            "revision": example_configuration.latest_revision,
+        })
+    example_cluster_policy = aws.msk.ClusterPolicy("example",
+        cluster_arn=example.arn,
+        policy=pulumi.Output.json_dumps({
+            "Version": "2012-10-17",
+            "Statement": [{
+                "Effect": "Allow",
+                "Principal": {
+                    "AWS": f"arn:aws:iam::{aws_account_id}:root",
+                },
+                "Action": [
+                    "kafka:CreateVpcConnection",
+                    "kafka:GetBootstrapBrokers",
+                    "kafka:DescribeCluster",
+                    "kafka:DescribeClusterV2",
+                ],
+                "Resource": example.arn,
+            }],
+        }))
+    example_msk_single_scram_secret_association = aws.index.MskSingleScramSecretAssociation("example",
+        cluster_arn=example.arn,
+        secret_arn=aws_secret_arn)
+    test = mongodbatlas.StreamPrivatelinkEndpoint("test",
+        project_id=project_id,
+        provider_name="AWS",
+        vendor="MSK",
+        arn=example.arn)
+    singular_datasource = test.id.apply(lambda id: mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
+        id=id))
+    pulumi.export("privatelinkEndpointId", singular_datasource.id)
+    ```
+
     ### AWS S3 Privatelink
     ```python
     import pulumi
@@ -367,20 +557,20 @@ def get_stream_privatelink_endpoint_output(id: Optional[pulumi.Input[_builtins.s
     import pulumi_mongodbatlas as mongodbatlas
 
     # S3 bucket for stream data
-    stream_bucket = aws.index.S3Bucket("stream_bucket",
+    stream_bucket = aws.s3.BucketV2("stream_bucket",
         bucket=s3_bucket_name,
         force_destroy=True)
-    stream_bucket_versioning = aws.index.S3BucketVersioning("stream_bucket_versioning",
+    stream_bucket_versioning = aws.s3.BucketVersioningV2("stream_bucket_versioning",
         bucket=stream_bucket.id,
-        versioning_configuration=[{
-            status: Enabled,
-        }])
-    stream_bucket_encryption = aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption",
+        versioning_configuration={
+            "status": "Enabled",
+        })
+    stream_bucket_encryption = aws.s3.BucketServerSideEncryptionConfigurationV2("stream_bucket_encryption",
         bucket=stream_bucket.id,
-        rule=[{
-            applyServerSideEncryptionByDefault: [{
-                sseAlgorithm: AES256,
-            }],
+        rules=[{
+            "apply_server_side_encryption_by_default": {
+                "sse_algorithm": "AES256",
+            },
         }])
     # PrivateLink for S3
     this = mongodbatlas.StreamPrivatelinkEndpoint("this",

{pulumi_mongodbatlas-3.38.0 → pulumi_mongodbatlas-3.38.0a1764802483}/pulumi_mongodbatlas/get_stream_privatelink_endpoints.py

@@ -139,6 +139,101 @@ def get_stream_privatelink_endpoints(project_id: Optional[_builtins.str] = None,
     pulumi.export("interfaceEndpointIds", [__item.interface_endpoint_id for __item in plural_datasource.results])
     ```
 
+    ### AWS MSK Privatelink
+    ```python
+    import pulumi
+    import json
+    import pulumi_aws as aws
+    import pulumi_mongodbatlas as mongodbatlas
+
+    vpc = aws.ec2.Vpc("vpc", cidr_block="192.168.0.0/22")
+    azs = aws.get_availability_zones(state="available")
+    subnet_az1 = aws.ec2.Subnet("subnet_az1",
+        availability_zone=azs.names[0],
+        cidr_block="192.168.0.0/24",
+        vpc_id=vpc.id)
+    subnet_az2 = aws.ec2.Subnet("subnet_az2",
+        availability_zone=azs.names[1],
+        cidr_block="192.168.1.0/24",
+        vpc_id=vpc.id)
+    sg = aws.ec2.SecurityGroup("sg", vpc_id=vpc.id)
+    example_configuration = aws.msk.Configuration("example",
+        name=f"{msk_cluster_name}-msk-configuration",
+        server_properties=\"\"\"auto.create.topics.enable=false
+    default.replication.factor=3
+    min.insync.replicas=2
+    num.io.threads=8
+    num.network.threads=5
+    num.partitions=1
+    num.replica.fetchers=2
+    replica.lag.time.max.ms=30000
+    socket.receive.buffer.bytes=102400
+    socket.request.max.bytes=104857600
+    socket.send.buffer.bytes=102400
+    unclean.leader.election.enable=true
+    allow.everyone.if.no.acl.found=false
+    \"\"\")
+    example = aws.msk.Cluster("example",
+        cluster_name=msk_cluster_name,
+        kafka_version="3.6.0",
+        number_of_broker_nodes=2,
+        broker_node_group_info={
+            "instance_type": "kafka.m5.large",
+            "client_subnets": [
+                subnet_az1.id,
+                subnet_az2.id,
+            ],
+            "security_groups": [sg.id],
+            "connectivity_info": {
+                "vpc_connectivity": {
+                    "client_authentication": {
+                        "sasl": {
+                            "scram": True,
+                        },
+                    },
+                },
+            },
+        },
+        client_authentication={
+            "sasl": {
+                "scram": True,
+            },
+        },
+        configuration_info={
+            "arn": example_configuration.arn,
+            "revision": example_configuration.latest_revision,
+        })
+    example_cluster_policy = aws.msk.ClusterPolicy("example",
+        cluster_arn=example.arn,
+        policy=pulumi.Output.json_dumps({
+            "Version": "2012-10-17",
+            "Statement": [{
+                "Effect": "Allow",
+                "Principal": {
+                    "AWS": f"arn:aws:iam::{aws_account_id}:root",
+                },
+                "Action": [
+                    "kafka:CreateVpcConnection",
+                    "kafka:GetBootstrapBrokers",
+                    "kafka:DescribeCluster",
+                    "kafka:DescribeClusterV2",
+                ],
+                "Resource": example.arn,
+            }],
+        }))
+    example_msk_single_scram_secret_association = aws.index.MskSingleScramSecretAssociation("example",
+        cluster_arn=example.arn,
+        secret_arn=aws_secret_arn)
+    test = mongodbatlas.StreamPrivatelinkEndpoint("test",
+        project_id=project_id,
+        provider_name="AWS",
+        vendor="MSK",
+        arn=example.arn)
+    singular_datasource = test.id.apply(lambda id: mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
+        id=id))
+    pulumi.export("privatelinkEndpointId", singular_datasource.id)
+    ```
+
     ### AWS S3 Privatelink
     ```python
     import pulumi
@@ -146,20 +241,20 @@ def get_stream_privatelink_endpoints(project_id: Optional[_builtins.str] = None,
     import pulumi_mongodbatlas as mongodbatlas
 
     # S3 bucket for stream data
-    stream_bucket = aws.index.S3Bucket("stream_bucket",
+    stream_bucket = aws.s3.BucketV2("stream_bucket",
         bucket=s3_bucket_name,
         force_destroy=True)
-    stream_bucket_versioning = aws.index.S3BucketVersioning("stream_bucket_versioning",
+    stream_bucket_versioning = aws.s3.BucketVersioningV2("stream_bucket_versioning",
         bucket=stream_bucket.id,
-        versioning_configuration=[{
-            status: Enabled,
-        }])
-    stream_bucket_encryption = aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption",
+        versioning_configuration={
+            "status": "Enabled",
+        })
+    stream_bucket_encryption = aws.s3.BucketServerSideEncryptionConfigurationV2("stream_bucket_encryption",
         bucket=stream_bucket.id,
-        rule=[{
-            applyServerSideEncryptionByDefault: [{
-                sseAlgorithm: AES256,
-            }],
+        rules=[{
+            "apply_server_side_encryption_by_default": {
+                "sse_algorithm": "AES256",
+            },
         }])
     # PrivateLink for S3
     this = mongodbatlas.StreamPrivatelinkEndpoint("this",
@@ -251,6 +346,101 @@ def get_stream_privatelink_endpoints_output(project_id: Optional[pulumi.Input[_b
     pulumi.export("interfaceEndpointIds", [__item.interface_endpoint_id for __item in plural_datasource.results])
     ```
 
+    ### AWS MSK Privatelink
+    ```python
+    import pulumi
+    import json
+    import pulumi_aws as aws
+    import pulumi_mongodbatlas as mongodbatlas
+
+    vpc = aws.ec2.Vpc("vpc", cidr_block="192.168.0.0/22")
+    azs = aws.get_availability_zones(state="available")
+    subnet_az1 = aws.ec2.Subnet("subnet_az1",
+        availability_zone=azs.names[0],
+        cidr_block="192.168.0.0/24",
+        vpc_id=vpc.id)
+    subnet_az2 = aws.ec2.Subnet("subnet_az2",
+        availability_zone=azs.names[1],
+        cidr_block="192.168.1.0/24",
+        vpc_id=vpc.id)
+    sg = aws.ec2.SecurityGroup("sg", vpc_id=vpc.id)
+    example_configuration = aws.msk.Configuration("example",
+        name=f"{msk_cluster_name}-msk-configuration",
+        server_properties=\"\"\"auto.create.topics.enable=false
+    default.replication.factor=3
+    min.insync.replicas=2
+    num.io.threads=8
+    num.network.threads=5
+    num.partitions=1
+    num.replica.fetchers=2
+    replica.lag.time.max.ms=30000
+    socket.receive.buffer.bytes=102400
+    socket.request.max.bytes=104857600
+    socket.send.buffer.bytes=102400
+    unclean.leader.election.enable=true
+    allow.everyone.if.no.acl.found=false
+    \"\"\")
+    example = aws.msk.Cluster("example",
+        cluster_name=msk_cluster_name,
+        kafka_version="3.6.0",
+        number_of_broker_nodes=2,
+        broker_node_group_info={
+            "instance_type": "kafka.m5.large",
+            "client_subnets": [
+                subnet_az1.id,
+                subnet_az2.id,
+            ],
+            "security_groups": [sg.id],
+            "connectivity_info": {
+                "vpc_connectivity": {
+                    "client_authentication": {
+                        "sasl": {
+                            "scram": True,
+                        },
+                    },
+                },
+            },
+        },
+        client_authentication={
+            "sasl": {
+                "scram": True,
+            },
+        },
+        configuration_info={
+            "arn": example_configuration.arn,
+            "revision": example_configuration.latest_revision,
+        })
+    example_cluster_policy = aws.msk.ClusterPolicy("example",
+        cluster_arn=example.arn,
+        policy=pulumi.Output.json_dumps({
+            "Version": "2012-10-17",
+            "Statement": [{
+                "Effect": "Allow",
+                "Principal": {
+                    "AWS": f"arn:aws:iam::{aws_account_id}:root",
+                },
+                "Action": [
+                    "kafka:CreateVpcConnection",
+                    "kafka:GetBootstrapBrokers",
+                    "kafka:DescribeCluster",
+                    "kafka:DescribeClusterV2",
+                ],
+                "Resource": example.arn,
+            }],
+        }))
+    example_msk_single_scram_secret_association = aws.index.MskSingleScramSecretAssociation("example",
+        cluster_arn=example.arn,
+        secret_arn=aws_secret_arn)
+    test = mongodbatlas.StreamPrivatelinkEndpoint("test",
+        project_id=project_id,
+        provider_name="AWS",
+        vendor="MSK",
+        arn=example.arn)
+    singular_datasource = test.id.apply(lambda id: mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
+        id=id))
+    pulumi.export("privatelinkEndpointId", singular_datasource.id)
+    ```
+
     ### AWS S3 Privatelink
     ```python
     import pulumi
@@ -258,20 +448,20 @@ def get_stream_privatelink_endpoints_output(project_id: Optional[pulumi.Input[_b
     import pulumi_mongodbatlas as mongodbatlas
 
     # S3 bucket for stream data
-    stream_bucket = aws.index.S3Bucket("stream_bucket",
+    stream_bucket = aws.s3.BucketV2("stream_bucket",
         bucket=s3_bucket_name,
         force_destroy=True)
-    stream_bucket_versioning = aws.index.S3BucketVersioning("stream_bucket_versioning",
+    stream_bucket_versioning = aws.s3.BucketVersioningV2("stream_bucket_versioning",
         bucket=stream_bucket.id,
-        versioning_configuration=[{
-            status: Enabled,
-        }])
-    stream_bucket_encryption = aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption",
+        versioning_configuration={
+            "status": "Enabled",
+        })
+    stream_bucket_encryption = aws.s3.BucketServerSideEncryptionConfigurationV2("stream_bucket_encryption",
         bucket=stream_bucket.id,
-        rule=[{
-            applyServerSideEncryptionByDefault: [{
-                sseAlgorithm: AES256,
-            }],
+        rules=[{
+            "apply_server_side_encryption_by_default": {
+                "sse_algorithm": "AES256",
+            },
         }])
     # PrivateLink for S3
     this = mongodbatlas.StreamPrivatelinkEndpoint("this",

{pulumi_mongodbatlas-3.38.0 → pulumi_mongodbatlas-3.38.0a1764802483}/pulumi_mongodbatlas/network_peering.py

@@ -753,11 +753,62 @@ class NetworkPeering(pulumi.CustomResource):
             aws_account_id="abc123abc123")
         # the following assumes an AWS provider is configured
         # Accept the peering connection request
-        peer = aws.index.VpcPeeringConnectionAccepter("peer",
+        peer = aws.ec2.VpcPeeringConnectionAccepter("peer",
             vpc_peering_connection_id=test_network_peering.connection_id,
             auto_accept=True)
         ```
 
+        ### Example with GCP
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+        import pulumi_mongodbatlas as mongodbatlas
+
+        # Container example provided but not always required, 
+        # see network_container documentation for details. 
+        test = mongodbatlas.NetworkContainer("test",
+            project_id=project_id,
+            atlas_cidr_block="10.8.0.0/21",
+            provider_name="GCP")
+        # Create the peering connection request
+        test_network_peering = mongodbatlas.NetworkPeering("test",
+            project_id=project_id,
+            container_id=test.container_id,
+            provider_name="GCP",
+            gcp_project_id=gc_p__projec_t__id,
+            network_name="default")
+        # the following assumes a GCP provider is configured
+        default = gcp.compute.get_network(name="default")
+        # Create the GCP peer
+        peering = gcp.compute.NetworkPeering("peering",
+            name="peering-gcp-terraform-test",
+            network=default.self_link,
+            peer_network=pulumi.Output.all(
+                atlas_gcp_project_id=test_network_peering.atlas_gcp_project_id,
+                atlas_vpc_name=test_network_peering.atlas_vpc_name
+        ).apply(lambda resolved_outputs: f"https://www.googleapis.com/compute/v1/projects/{resolved_outputs['atlas_gcp_project_id']}/global/networks/{resolved_outputs['atlas_vpc_name']}")
+        )
+        # Create the cluster once the peering connection is completed
+        test_advanced_cluster = mongodbatlas.AdvancedCluster("test",
+            project_id=project_id,
+            name="terraform-manually-test",
+            cluster_type="REPLICASET",
+            backup_enabled=True,
+            replication_specs=[{
+                "region_configs": [{
+                    "priority": 7,
+                    "provider_name": "GCP",
+                    "region_name": "US_EAST_4",
+                    "electable_specs": {
+                        "instance_size": "M10",
+                        "node_count": 3,
+                    },
+                }],
+            }],
+            opts = pulumi.ResourceOptions(depends_on=[peering]))
+        ```
+
         ### Example with Azure
 
         ```python
@@ -900,11 +951,62 @@ class NetworkPeering(pulumi.CustomResource):
             aws_account_id="abc123abc123")
         # the following assumes an AWS provider is configured
         # Accept the peering connection request
-        peer = aws.index.VpcPeeringConnectionAccepter("peer",
+        peer = aws.ec2.VpcPeeringConnectionAccepter("peer",
             vpc_peering_connection_id=test_network_peering.connection_id,
             auto_accept=True)
         ```
 
+        ### Example with GCP
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+        import pulumi_mongodbatlas as mongodbatlas
+
+        # Container example provided but not always required, 
+        # see network_container documentation for details. 
+        test = mongodbatlas.NetworkContainer("test",
+            project_id=project_id,
+            atlas_cidr_block="10.8.0.0/21",
+            provider_name="GCP")
+        # Create the peering connection request
+        test_network_peering = mongodbatlas.NetworkPeering("test",
+            project_id=project_id,
+            container_id=test.container_id,
+            provider_name="GCP",
+            gcp_project_id=gc_p__projec_t__id,
+            network_name="default")
+        # the following assumes a GCP provider is configured
+        default = gcp.compute.get_network(name="default")
+        # Create the GCP peer
+        peering = gcp.compute.NetworkPeering("peering",
+            name="peering-gcp-terraform-test",
+            network=default.self_link,
+            peer_network=pulumi.Output.all(
+                atlas_gcp_project_id=test_network_peering.atlas_gcp_project_id,
+                atlas_vpc_name=test_network_peering.atlas_vpc_name
+        ).apply(lambda resolved_outputs: f"https://www.googleapis.com/compute/v1/projects/{resolved_outputs['atlas_gcp_project_id']}/global/networks/{resolved_outputs['atlas_vpc_name']}")
+        )
+        # Create the cluster once the peering connection is completed
+        test_advanced_cluster = mongodbatlas.AdvancedCluster("test",
+            project_id=project_id,
+            name="terraform-manually-test",
+            cluster_type="REPLICASET",
+            backup_enabled=True,
+            replication_specs=[{
+                "region_configs": [{
+                    "priority": 7,
+                    "provider_name": "GCP",
+                    "region_name": "US_EAST_4",
+                    "electable_specs": {
+                        "instance_size": "M10",
+                        "node_count": 3,
+                    },
+                }],
+            }],
+            opts = pulumi.ResourceOptions(depends_on=[peering]))
+        ```
+
         ### Example with Azure
 
         ```python