Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Mongodbatlas Provider
  3. API Docs
  4. getGlobalClusterConfig
MongoDB Atlas v3.20.4 published on Wednesday, Oct 30, 2024 by Pulumi
pulumi/pulumi-mongodbatlas

mongodbatlas.getGlobalClusterConfig

Explore with Pulumi AI

mongodbatlas logo
MongoDB Atlas v3.20.4 published on Wednesday, Oct 30, 2024 by Pulumi
pulumi/pulumi-mongodbatlas

    # Data Source: mongodbatlas.GlobalClusterConfig

    mongodbatlas.GlobalClusterConfig describes all managed namespaces and custom zone mappings associated with the specified Global Cluster.

    NOTE: Groups and projects are synonymous terms. You may find group_id in the official documentation.

    Example Usage

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

const test = new mongodbatlas.AdvancedCluster("test", {
    projectId: "<YOUR-PROJECT-ID>",
    name: "<CLUSTER-NAME>",
    clusterType: "GEOSHARDED",
    backupEnabled: true,
    replicationSpecs: [
        {
            zoneName: "Zone 1",
            regionConfigs: [{
                electableSpecs: {
                    instanceSize: "M30",
                    nodeCount: 3,
                },
                providerName: "AWS",
                priority: 7,
                regionName: "EU_CENTRAL_1",
            }],
        },
        {
            zoneName: "Zone 1",
            regionConfigs: [{
                electableSpecs: {
                    instanceSize: "M30",
                    nodeCount: 3,
                },
                providerName: "AWS",
                priority: 7,
                regionName: "EU_CENTRAL_1",
            }],
        },
        {
            zoneName: "Zone 2",
            regionConfigs: [{
                electableSpecs: {
                    instanceSize: "M30",
                    nodeCount: 3,
                },
                providerName: "AWS",
                priority: 7,
                regionName: "US_EAST_2",
            }],
        },
        {
            zoneName: "Zone 2",
            regionConfigs: [{
                electableSpecs: {
                    instanceSize: "M30",
                    nodeCount: 3,
                },
                providerName: "AWS",
                priority: 7,
                regionName: "US_EAST_2",
            }],
        },
    ],
});
const configGlobalClusterConfig = new mongodbatlas.GlobalClusterConfig("config", {
    projectId: test.projectId,
    clusterName: test.name,
    managedNamespaces: [{
        db: "mydata",
        collection: "publishers",
        customShardKey: "city",
    }],
    customZoneMappings: [{
        location: "CA",
        zone: "Zone 1",
    }],
});
const config = mongodbatlas.getGlobalClusterConfigOutput({
    projectId: configGlobalClusterConfig.projectId,
    clusterName: configGlobalClusterConfig.clusterName,
});

    import pulumi
import pulumi_mongodbatlas as mongodbatlas

test = mongodbatlas.AdvancedCluster("test",
    project_id="<YOUR-PROJECT-ID>",
    name="<CLUSTER-NAME>",
    cluster_type="GEOSHARDED",
    backup_enabled=True,
    replication_specs=[
        {
            "zone_name": "Zone 1",
            "region_configs": [{
                "electable_specs": {
                    "instance_size": "M30",
                    "node_count": 3,
                },
                "provider_name": "AWS",
                "priority": 7,
                "region_name": "EU_CENTRAL_1",
            }],
        },
        {
            "zone_name": "Zone 1",
            "region_configs": [{
                "electable_specs": {
                    "instance_size": "M30",
                    "node_count": 3,
                },
                "provider_name": "AWS",
                "priority": 7,
                "region_name": "EU_CENTRAL_1",
            }],
        },
        {
            "zone_name": "Zone 2",
            "region_configs": [{
                "electable_specs": {
                    "instance_size": "M30",
                    "node_count": 3,
                },
                "provider_name": "AWS",
                "priority": 7,
                "region_name": "US_EAST_2",
            }],
        },
        {
            "zone_name": "Zone 2",
            "region_configs": [{
                "electable_specs": {
                    "instance_size": "M30",
                    "node_count": 3,
                },
                "provider_name": "AWS",
                "priority": 7,
                "region_name": "US_EAST_2",
            }],
        },
    ])
config_global_cluster_config = mongodbatlas.GlobalClusterConfig("config",
    project_id=test.project_id,
    cluster_name=test.name,
    managed_namespaces=[{
        "db": "mydata",
        "collection": "publishers",
        "custom_shard_key": "city",
    }],
    custom_zone_mappings=[{
        "location": "CA",
        "zone": "Zone 1",
    }])
config = mongodbatlas.get_global_cluster_config_output(project_id=config_global_cluster_config.project_id,
    cluster_name=config_global_cluster_config.cluster_name)

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := mongodbatlas.NewAdvancedCluster(ctx, "test", &mongodbatlas.AdvancedClusterArgs{
			ProjectId:     pulumi.String("<YOUR-PROJECT-ID>"),
			Name:          pulumi.String("<CLUSTER-NAME>"),
			ClusterType:   pulumi.String("GEOSHARDED"),
			BackupEnabled: pulumi.Bool(true),
			ReplicationSpecs: mongodbatlas.AdvancedClusterReplicationSpecArray{
				&mongodbatlas.AdvancedClusterReplicationSpecArgs{
					ZoneName: pulumi.String("Zone 1"),
					RegionConfigs: mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArray{
						&mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArgs{
							ElectableSpecs: &mongodbatlas.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs{
								InstanceSize: pulumi.String("M30"),
								NodeCount:    pulumi.Int(3),
							},
							ProviderName: pulumi.String("AWS"),
							Priority:     pulumi.Int(7),
							RegionName:   pulumi.String("EU_CENTRAL_1"),
						},
					},
				},
				&mongodbatlas.AdvancedClusterReplicationSpecArgs{
					ZoneName: pulumi.String("Zone 1"),
					RegionConfigs: mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArray{
						&mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArgs{
							ElectableSpecs: &mongodbatlas.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs{
								InstanceSize: pulumi.String("M30"),
								NodeCount:    pulumi.Int(3),
							},
							ProviderName: pulumi.String("AWS"),
							Priority:     pulumi.Int(7),
							RegionName:   pulumi.String("EU_CENTRAL_1"),
						},
					},
				},
				&mongodbatlas.AdvancedClusterReplicationSpecArgs{
					ZoneName: pulumi.String("Zone 2"),
					RegionConfigs: mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArray{
						&mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArgs{
							ElectableSpecs: &mongodbatlas.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs{
								InstanceSize: pulumi.String("M30"),
								NodeCount:    pulumi.Int(3),
							},
							ProviderName: pulumi.String("AWS"),
							Priority:     pulumi.Int(7),
							RegionName:   pulumi.String("US_EAST_2"),
						},
					},
				},
				&mongodbatlas.AdvancedClusterReplicationSpecArgs{
					ZoneName: pulumi.String("Zone 2"),
					RegionConfigs: mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArray{
						&mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArgs{
							ElectableSpecs: &mongodbatlas.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs{
								InstanceSize: pulumi.String("M30"),
								NodeCount:    pulumi.Int(3),
							},
							ProviderName: pulumi.String("AWS"),
							Priority:     pulumi.Int(7),
							RegionName:   pulumi.String("US_EAST_2"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		configGlobalClusterConfig, err := mongodbatlas.NewGlobalClusterConfig(ctx, "config", &mongodbatlas.GlobalClusterConfigArgs{
			ProjectId:   test.ProjectId,
			ClusterName: test.Name,
			ManagedNamespaces: mongodbatlas.GlobalClusterConfigManagedNamespaceArray{
				&mongodbatlas.GlobalClusterConfigManagedNamespaceArgs{
					Db:             pulumi.String("mydata"),
					Collection:     pulumi.String("publishers"),
					CustomShardKey: pulumi.String("city"),
				},
			},
			CustomZoneMappings: mongodbatlas.GlobalClusterConfigCustomZoneMappingArray{
				&mongodbatlas.GlobalClusterConfigCustomZoneMappingArgs{
					Location: pulumi.String("CA"),
					Zone:     pulumi.String("Zone 1"),
				},
			},
		})
		if err != nil {
			return err
		}
		_ = mongodbatlas.LookupGlobalClusterConfigOutput(ctx, mongodbatlas.GetGlobalClusterConfigOutputArgs{
			ProjectId:   configGlobalClusterConfig.ProjectId,
			ClusterName: configGlobalClusterConfig.ClusterName,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var test = new Mongodbatlas.AdvancedCluster("test", new()
    {
        ProjectId = "<YOUR-PROJECT-ID>",
        Name = "<CLUSTER-NAME>",
        ClusterType = "GEOSHARDED",
        BackupEnabled = true,
        ReplicationSpecs = new[]
        {
            new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecArgs
            {
                ZoneName = "Zone 1",
                RegionConfigs = new[]
                {
                    new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigArgs
                    {
                        ElectableSpecs = new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs
                        {
                            InstanceSize = "M30",
                            NodeCount = 3,
                        },
                        ProviderName = "AWS",
                        Priority = 7,
                        RegionName = "EU_CENTRAL_1",
                    },
                },
            },
            new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecArgs
            {
                ZoneName = "Zone 1",
                RegionConfigs = new[]
                {
                    new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigArgs
                    {
                        ElectableSpecs = new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs
                        {
                            InstanceSize = "M30",
                            NodeCount = 3,
                        },
                        ProviderName = "AWS",
                        Priority = 7,
                        RegionName = "EU_CENTRAL_1",
                    },
                },
            },
            new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecArgs
            {
                ZoneName = "Zone 2",
                RegionConfigs = new[]
                {
                    new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigArgs
                    {
                        ElectableSpecs = new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs
                        {
                            InstanceSize = "M30",
                            NodeCount = 3,
                        },
                        ProviderName = "AWS",
                        Priority = 7,
                        RegionName = "US_EAST_2",
                    },
                },
            },
            new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecArgs
            {
                ZoneName = "Zone 2",
                RegionConfigs = new[]
                {
                    new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigArgs
                    {
                        ElectableSpecs = new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs
                        {
                            InstanceSize = "M30",
                            NodeCount = 3,
                        },
                        ProviderName = "AWS",
                        Priority = 7,
                        RegionName = "US_EAST_2",
                    },
                },
            },
        },
    });

    var configGlobalClusterConfig = new Mongodbatlas.GlobalClusterConfig("config", new()
    {
        ProjectId = test.ProjectId,
        ClusterName = test.Name,
        ManagedNamespaces = new[]
        {
            new Mongodbatlas.Inputs.GlobalClusterConfigManagedNamespaceArgs
            {
                Db = "mydata",
                Collection = "publishers",
                CustomShardKey = "city",
            },
        },
        CustomZoneMappings = new[]
        {
            new Mongodbatlas.Inputs.GlobalClusterConfigCustomZoneMappingArgs
            {
                Location = "CA",
                Zone = "Zone 1",
            },
        },
    });

    var config = Mongodbatlas.GetGlobalClusterConfig.Invoke(new()
    {
        ProjectId = configGlobalClusterConfig.ProjectId,
        ClusterName = configGlobalClusterConfig.ClusterName,
    });

});

    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.GlobalClusterConfig;
import com.pulumi.mongodbatlas.GlobalClusterConfigArgs;
import com.pulumi.mongodbatlas.inputs.GlobalClusterConfigManagedNamespaceArgs;
import com.pulumi.mongodbatlas.inputs.GlobalClusterConfigCustomZoneMappingArgs;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetGlobalClusterConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var test = new AdvancedCluster("test", AdvancedClusterArgs.builder()
            .projectId("<YOUR-PROJECT-ID>")
            .name("<CLUSTER-NAME>")
            .clusterType("GEOSHARDED")
            .backupEnabled(true)
            .replicationSpecs(            
                AdvancedClusterReplicationSpecArgs.builder()
                    .zoneName("Zone 1")
                    .regionConfigs(AdvancedClusterReplicationSpecRegionConfigArgs.builder()
                        .electableSpecs(AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs.builder()
                            .instanceSize("M30")
                            .nodeCount(3)
                            .build())
                        .providerName("AWS")
                        .priority(7)
                        .regionName("EU_CENTRAL_1")
                        .build())
                    .build(),
                AdvancedClusterReplicationSpecArgs.builder()
                    .zoneName("Zone 1")
                    .regionConfigs(AdvancedClusterReplicationSpecRegionConfigArgs.builder()
                        .electableSpecs(AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs.builder()
                            .instanceSize("M30")
                            .nodeCount(3)
                            .build())
                        .providerName("AWS")
                        .priority(7)
                        .regionName("EU_CENTRAL_1")
                        .build())
                    .build(),
                AdvancedClusterReplicationSpecArgs.builder()
                    .zoneName("Zone 2")
                    .regionConfigs(AdvancedClusterReplicationSpecRegionConfigArgs.builder()
                        .electableSpecs(AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs.builder()
                            .instanceSize("M30")
                            .nodeCount(3)
                            .build())
                        .providerName("AWS")
                        .priority(7)
                        .regionName("US_EAST_2")
                        .build())
                    .build(),
                AdvancedClusterReplicationSpecArgs.builder()
                    .zoneName("Zone 2")
                    .regionConfigs(AdvancedClusterReplicationSpecRegionConfigArgs.builder()
                        .electableSpecs(AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs.builder()
                            .instanceSize("M30")
                            .nodeCount(3)
                            .build())
                        .providerName("AWS")
                        .priority(7)
                        .regionName("US_EAST_2")
                        .build())
                    .build())
            .build());

        var configGlobalClusterConfig = new GlobalClusterConfig("configGlobalClusterConfig", GlobalClusterConfigArgs.builder()
            .projectId(test.projectId())
            .clusterName(test.name())
            .managedNamespaces(GlobalClusterConfigManagedNamespaceArgs.builder()
                .db("mydata")
                .collection("publishers")
                .customShardKey("city")
                .build())
            .customZoneMappings(GlobalClusterConfigCustomZoneMappingArgs.builder()
                .location("CA")
                .zone("Zone 1")
                .build())
            .build());

        final var config = MongodbatlasFunctions.getGlobalClusterConfig(GetGlobalClusterConfigArgs.builder()
            .projectId(configGlobalClusterConfig.projectId())
            .clusterName(configGlobalClusterConfig.clusterName())
            .build());

    }
}

    resources:
  test:
    type: mongodbatlas:AdvancedCluster
    properties:
      projectId: <YOUR-PROJECT-ID>
      name: <CLUSTER-NAME>
      clusterType: GEOSHARDED
      backupEnabled: true
      replicationSpecs:
        - zoneName: Zone 1
          regionConfigs:
            - electableSpecs:
                instanceSize: M30
                nodeCount: 3
              providerName: AWS
              priority: 7
              regionName: EU_CENTRAL_1
        - zoneName: Zone 1
          regionConfigs:
            - electableSpecs:
                instanceSize: M30
                nodeCount: 3
              providerName: AWS
              priority: 7
              regionName: EU_CENTRAL_1
        - zoneName: Zone 2
          regionConfigs:
            - electableSpecs:
                instanceSize: M30
                nodeCount: 3
              providerName: AWS
              priority: 7
              regionName: US_EAST_2
        - zoneName: Zone 2
          regionConfigs:
            - electableSpecs:
                instanceSize: M30
                nodeCount: 3
              providerName: AWS
              priority: 7
              regionName: US_EAST_2
  configGlobalClusterConfig:
    type: mongodbatlas:GlobalClusterConfig
    name: config
    properties:
      projectId: ${test.projectId}
      clusterName: ${test.name}
      managedNamespaces:
        - db: mydata
          collection: publishers
          customShardKey: city
      customZoneMappings:
        - location: CA
          zone: Zone 1
variables:
  config:
    fn::invoke:
      Function: mongodbatlas:getGlobalClusterConfig
      Arguments:
        projectId: ${configGlobalClusterConfig.projectId}
        clusterName: ${configGlobalClusterConfig.clusterName}

    Using getGlobalClusterConfig

    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 getGlobalClusterConfig(args: GetGlobalClusterConfigArgs, opts?: InvokeOptions): Promise<GetGlobalClusterConfigResult>
function getGlobalClusterConfigOutput(args: GetGlobalClusterConfigOutputArgs, opts?: InvokeOptions): Output<GetGlobalClusterConfigResult>
    def get_global_cluster_config(cluster_name: Optional[str] = None,
                              managed_namespaces: Optional[Sequence[GetGlobalClusterConfigManagedNamespace]] = None,
                              project_id: Optional[str] = None,
                              opts: Optional[InvokeOptions] = None) -> GetGlobalClusterConfigResult
def get_global_cluster_config_output(cluster_name: Optional[pulumi.Input[str]] = None,
                              managed_namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[GetGlobalClusterConfigManagedNamespaceArgs]]]] = None,
                              project_id: Optional[pulumi.Input[str]] = None,
                              opts: Optional[InvokeOptions] = None) -> Output[GetGlobalClusterConfigResult]
    func LookupGlobalClusterConfig(ctx *Context, args *LookupGlobalClusterConfigArgs, opts ...InvokeOption) (*LookupGlobalClusterConfigResult, error)
func LookupGlobalClusterConfigOutput(ctx *Context, args *LookupGlobalClusterConfigOutputArgs, opts ...InvokeOption) LookupGlobalClusterConfigResultOutput

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

    public static class GetGlobalClusterConfig 
{
    public static Task<GetGlobalClusterConfigResult> InvokeAsync(GetGlobalClusterConfigArgs args, InvokeOptions? opts = null)
    public static Output<GetGlobalClusterConfigResult> Invoke(GetGlobalClusterConfigInvokeArgs args, InvokeOptions? opts = null)
}
    public static CompletableFuture<GetGlobalClusterConfigResult> getGlobalClusterConfig(GetGlobalClusterConfigArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

    fn::invoke:
  function: mongodbatlas:index/getGlobalClusterConfig:getGlobalClusterConfig
  arguments:
    # arguments dictionary

    The following arguments are supported:

    ClusterName string
    The name of the Global Cluster.
    ProjectId string
    The unique ID for the project to create the database user.
    ManagedNamespaces List<GetGlobalClusterConfigManagedNamespace>
    Add a managed namespaces to a Global Cluster. For more information about managed namespaces, see Global Clusters. See Managed Namespace below for more details.
    ClusterName string
    The name of the Global Cluster.
    ProjectId string
    The unique ID for the project to create the database user.
    ManagedNamespaces []GetGlobalClusterConfigManagedNamespace
    Add a managed namespaces to a Global Cluster. For more information about managed namespaces, see Global Clusters. See Managed Namespace below for more details.
    clusterName String
    The name of the Global Cluster.
    projectId String
    The unique ID for the project to create the database user.
    managedNamespaces List<GetGlobalClusterConfigManagedNamespace>
    Add a managed namespaces to a Global Cluster. For more information about managed namespaces, see Global Clusters. See Managed Namespace below for more details.
    clusterName string
    The name of the Global Cluster.
    projectId string
    The unique ID for the project to create the database user.
    managedNamespaces GetGlobalClusterConfigManagedNamespace[]
    Add a managed namespaces to a Global Cluster. For more information about managed namespaces, see Global Clusters. See Managed Namespace below for more details.
    cluster_name str
    The name of the Global Cluster.
    project_id str
    The unique ID for the project to create the database user.
    managed_namespaces Sequence[GetGlobalClusterConfigManagedNamespace]
    Add a managed namespaces to a Global Cluster. For more information about managed namespaces, see Global Clusters. See Managed Namespace below for more details.
    clusterName String
    The name of the Global Cluster.
    projectId String
    The unique ID for the project to create the database user.
    managedNamespaces List<Property Map>
    Add a managed namespaces to a Global Cluster. For more information about managed namespaces, see Global Clusters. See Managed Namespace below for more details.

    getGlobalClusterConfig Result

    The following output properties are available:

    ClusterName string
    CustomZoneMapping Dictionary<string, string>
    (Deprecated) A map of all custom zone mappings defined for the Global Cluster to replication_specs.*.id. This attribute is deprecated, use custom_zone_mapping_zone_id instead.

    Deprecated: This parameter is deprecated and will be removed in version 1.23.0. Please transition to custom_zone_mapping_zone_id.

    CustomZoneMappingZoneId Dictionary<string, string>
    A map of all custom zone mappings defined for the Global Cluster to replication_specs.*.zone_id. Atlas automatically maps each location code to the closest geographical zone. Custom zone mappings allow administrators to override these automatic mappings. If your Global Cluster does not have any custom zone mappings, this document is empty.
    Id string
    The provider-assigned unique ID for this managed resource.
    ManagedNamespaces List<GetGlobalClusterConfigManagedNamespace>
    Add a managed namespaces to a Global Cluster. For more information about managed namespaces, see Global Clusters. See Managed Namespace below for more details.
    ProjectId string
    ClusterName string
    CustomZoneMapping map[string]string
    (Deprecated) A map of all custom zone mappings defined for the Global Cluster to replication_specs.*.id. This attribute is deprecated, use custom_zone_mapping_zone_id instead.

    Deprecated: This parameter is deprecated and will be removed in version 1.23.0. Please transition to custom_zone_mapping_zone_id.

    CustomZoneMappingZoneId map[string]string
    A map of all custom zone mappings defined for the Global Cluster to replication_specs.*.zone_id. Atlas automatically maps each location code to the closest geographical zone. Custom zone mappings allow administrators to override these automatic mappings. If your Global Cluster does not have any custom zone mappings, this document is empty.
    Id string
    The provider-assigned unique ID for this managed resource.
    ManagedNamespaces []GetGlobalClusterConfigManagedNamespace
    Add a managed namespaces to a Global Cluster. For more information about managed namespaces, see Global Clusters. See Managed Namespace below for more details.
    ProjectId string
    clusterName String
    customZoneMapping Map<String,String>
    (Deprecated) A map of all custom zone mappings defined for the Global Cluster to replication_specs.*.id. This attribute is deprecated, use custom_zone_mapping_zone_id instead.

    Deprecated: This parameter is deprecated and will be removed in version 1.23.0. Please transition to custom_zone_mapping_zone_id.

    customZoneMappingZoneId Map<String,String>
    A map of all custom zone mappings defined for the Global Cluster to replication_specs.*.zone_id. Atlas automatically maps each location code to the closest geographical zone. Custom zone mappings allow administrators to override these automatic mappings. If your Global Cluster does not have any custom zone mappings, this document is empty.
    id String
    The provider-assigned unique ID for this managed resource.
    managedNamespaces List<GetGlobalClusterConfigManagedNamespace>
    Add a managed namespaces to a Global Cluster. For more information about managed namespaces, see Global Clusters. See Managed Namespace below for more details.
    projectId String
    clusterName string
    customZoneMapping {[key: string]: string}
    (Deprecated) A map of all custom zone mappings defined for the Global Cluster to replication_specs.*.id. This attribute is deprecated, use custom_zone_mapping_zone_id instead.

    Deprecated: This parameter is deprecated and will be removed in version 1.23.0. Please transition to custom_zone_mapping_zone_id.

    customZoneMappingZoneId {[key: string]: string}
    A map of all custom zone mappings defined for the Global Cluster to replication_specs.*.zone_id. Atlas automatically maps each location code to the closest geographical zone. Custom zone mappings allow administrators to override these automatic mappings. If your Global Cluster does not have any custom zone mappings, this document is empty.
    id string
    The provider-assigned unique ID for this managed resource.
    managedNamespaces GetGlobalClusterConfigManagedNamespace[]
    Add a managed namespaces to a Global Cluster. For more information about managed namespaces, see Global Clusters. See Managed Namespace below for more details.
    projectId string
    cluster_name str
    custom_zone_mapping Mapping[str, str]
    (Deprecated) A map of all custom zone mappings defined for the Global Cluster to replication_specs.*.id. This attribute is deprecated, use custom_zone_mapping_zone_id instead.

    Deprecated: This parameter is deprecated and will be removed in version 1.23.0. Please transition to custom_zone_mapping_zone_id.

    custom_zone_mapping_zone_id Mapping[str, str]
    A map of all custom zone mappings defined for the Global Cluster to replication_specs.*.zone_id. Atlas automatically maps each location code to the closest geographical zone. Custom zone mappings allow administrators to override these automatic mappings. If your Global Cluster does not have any custom zone mappings, this document is empty.
    id str
    The provider-assigned unique ID for this managed resource.
    managed_namespaces Sequence[GetGlobalClusterConfigManagedNamespace]
    Add a managed namespaces to a Global Cluster. For more information about managed namespaces, see Global Clusters. See Managed Namespace below for more details.
    project_id str
    clusterName String
    customZoneMapping Map<String>
    (Deprecated) A map of all custom zone mappings defined for the Global Cluster to replication_specs.*.id. This attribute is deprecated, use custom_zone_mapping_zone_id instead.

    Deprecated: This parameter is deprecated and will be removed in version 1.23.0. Please transition to custom_zone_mapping_zone_id.

    customZoneMappingZoneId Map<String>
    A map of all custom zone mappings defined for the Global Cluster to replication_specs.*.zone_id. Atlas automatically maps each location code to the closest geographical zone. Custom zone mappings allow administrators to override these automatic mappings. If your Global Cluster does not have any custom zone mappings, this document is empty.
    id String
    The provider-assigned unique ID for this managed resource.
    managedNamespaces List<Property Map>
    Add a managed namespaces to a Global Cluster. For more information about managed namespaces, see Global Clusters. See Managed Namespace below for more details.
    projectId String

    Supporting Types

    GetGlobalClusterConfigManagedNamespace

    Collection string
    (Required) The name of the collection associated with the managed namespace.
    CustomShardKey string
    (Required) The custom shard key for the collection. Global Clusters require a compound shard key consisting of a location field and a user-selected second key, the custom shard key.
    Db string
    (Required) The name of the database containing the collection.
    IsCustomShardKeyHashed bool
    Specifies whether the custom shard key for the collection is hashed. If omitted, defaults to false. If false, Atlas uses ranged sharding. This is only available for Atlas clusters with MongoDB v4.4 and later.
    IsShardKeyUnique bool
    Specifies whether the underlying index enforces a unique constraint. If omitted, defaults to false. You cannot specify true when using hashed shard keys.
    Collection string
    (Required) The name of the collection associated with the managed namespace.
    CustomShardKey string
    (Required) The custom shard key for the collection. Global Clusters require a compound shard key consisting of a location field and a user-selected second key, the custom shard key.
    Db string
    (Required) The name of the database containing the collection.
    IsCustomShardKeyHashed bool
    Specifies whether the custom shard key for the collection is hashed. If omitted, defaults to false. If false, Atlas uses ranged sharding. This is only available for Atlas clusters with MongoDB v4.4 and later.
    IsShardKeyUnique bool
    Specifies whether the underlying index enforces a unique constraint. If omitted, defaults to false. You cannot specify true when using hashed shard keys.
    collection String
    (Required) The name of the collection associated with the managed namespace.
    customShardKey String
    (Required) The custom shard key for the collection. Global Clusters require a compound shard key consisting of a location field and a user-selected second key, the custom shard key.
    db String
    (Required) The name of the database containing the collection.
    isCustomShardKeyHashed Boolean
    Specifies whether the custom shard key for the collection is hashed. If omitted, defaults to false. If false, Atlas uses ranged sharding. This is only available for Atlas clusters with MongoDB v4.4 and later.
    isShardKeyUnique Boolean
    Specifies whether the underlying index enforces a unique constraint. If omitted, defaults to false. You cannot specify true when using hashed shard keys.
    collection string
    (Required) The name of the collection associated with the managed namespace.
    customShardKey string
    (Required) The custom shard key for the collection. Global Clusters require a compound shard key consisting of a location field and a user-selected second key, the custom shard key.
    db string
    (Required) The name of the database containing the collection.
    isCustomShardKeyHashed boolean
    Specifies whether the custom shard key for the collection is hashed. If omitted, defaults to false. If false, Atlas uses ranged sharding. This is only available for Atlas clusters with MongoDB v4.4 and later.
    isShardKeyUnique boolean
    Specifies whether the underlying index enforces a unique constraint. If omitted, defaults to false. You cannot specify true when using hashed shard keys.
    collection str
    (Required) The name of the collection associated with the managed namespace.
    custom_shard_key str
    (Required) The custom shard key for the collection. Global Clusters require a compound shard key consisting of a location field and a user-selected second key, the custom shard key.
    db str
    (Required) The name of the database containing the collection.
    is_custom_shard_key_hashed bool
    Specifies whether the custom shard key for the collection is hashed. If omitted, defaults to false. If false, Atlas uses ranged sharding. This is only available for Atlas clusters with MongoDB v4.4 and later.
    is_shard_key_unique bool
    Specifies whether the underlying index enforces a unique constraint. If omitted, defaults to false. You cannot specify true when using hashed shard keys.
    collection String
    (Required) The name of the collection associated with the managed namespace.
    customShardKey String
    (Required) The custom shard key for the collection. Global Clusters require a compound shard key consisting of a location field and a user-selected second key, the custom shard key.
    db String
    (Required) The name of the database containing the collection.
    isCustomShardKeyHashed Boolean
    Specifies whether the custom shard key for the collection is hashed. If omitted, defaults to false. If false, Atlas uses ranged sharding. This is only available for Atlas clusters with MongoDB v4.4 and later.
    isShardKeyUnique Boolean
    Specifies whether the underlying index enforces a unique constraint. If omitted, defaults to false. You cannot specify true when using hashed shard keys.

    Package Details

    Repository
    MongoDB Atlas pulumi/pulumi-mongodbatlas
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the mongodbatlas Terraform Provider.
    mongodbatlas logo
    MongoDB Atlas v3.20.4 published on Wednesday, Oct 30, 2024 by Pulumi
    pulumi/pulumi-mongodbatlas