mongodbatlas.getClusterOverloadSimulation

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

const thisAdvancedCluster = new mongodbatlas.AdvancedCluster("this", {
    projectId: projectId,
    name: clusterName,
    clusterType: "REPLICASET",
    replicationSpecs: [{
        regionConfigs: [{
            electableSpecs: {
                instanceSize: instanceSize,
                nodeCount: 3,
            },
            providerName: cloudProvider,
            priority: 7,
            regionName: regionName,
        }],
    }],
});
const thisClusterOverloadSimulation = new mongodbatlas.ClusterOverloadSimulation("this", {
    projectId: thisAdvancedCluster.projectId,
    clusterName: thisAdvancedCluster.name,
    durationSeconds: Number(durationSeconds),
});
const _this = mongodbatlas.getClusterOverloadSimulationOutput({
    projectId: thisClusterOverloadSimulation.projectId,
    clusterName: thisClusterOverloadSimulation.clusterName,
    simulationId: thisClusterOverloadSimulation.simulationId,
});

import pulumi
import pulumi_mongodbatlas as mongodbatlas

this_advanced_cluster = mongodbatlas.AdvancedCluster("this",
    project_id=project_id,
    name=cluster_name,
    cluster_type="REPLICASET",
    replication_specs=[{
        "region_configs": [{
            "electable_specs": {
                "instance_size": instance_size,
                "node_count": 3,
            },
            "provider_name": cloud_provider,
            "priority": 7,
            "region_name": region_name,
        }],
    }])
this_cluster_overload_simulation = mongodbatlas.ClusterOverloadSimulation("this",
    project_id=this_advanced_cluster.project_id,
    cluster_name=this_advanced_cluster.name,
    duration_seconds=int(duration_seconds))
this = mongodbatlas.get_cluster_overload_simulation_output(project_id=this_cluster_overload_simulation.project_id,
    cluster_name=this_cluster_overload_simulation.cluster_name,
    simulation_id=this_cluster_overload_simulation.simulation_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 {
		thisAdvancedCluster, err := mongodbatlas.NewAdvancedCluster(ctx, "this", &mongodbatlas.AdvancedClusterArgs{
			ProjectId:   pulumi.Any(projectId),
			Name:        pulumi.Any(clusterName),
			ClusterType: pulumi.String("REPLICASET"),
			ReplicationSpecs: mongodbatlas.AdvancedClusterReplicationSpecArray{
				&mongodbatlas.AdvancedClusterReplicationSpecArgs{
					RegionConfigs: mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArray{
						&mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArgs{
							ElectableSpecs: &mongodbatlas.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs{
								InstanceSize: pulumi.Any(instanceSize),
								NodeCount:    pulumi.Int(3),
							},
							ProviderName: pulumi.Any(cloudProvider),
							Priority:     pulumi.Int(7),
							RegionName:   pulumi.Any(regionName),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		thisClusterOverloadSimulation, err := mongodbatlas.NewClusterOverloadSimulation(ctx, "this", &mongodbatlas.ClusterOverloadSimulationArgs{
			ProjectId:       thisAdvancedCluster.ProjectId,
			ClusterName:     thisAdvancedCluster.Name,
			DurationSeconds: pulumi.Any(durationSeconds),
		})
		if err != nil {
			return err
		}
		_ = mongodbatlas.GetClusterOverloadSimulationOutput(ctx, mongodbatlas.GetClusterOverloadSimulationOutputArgs{
			ProjectId:    thisClusterOverloadSimulation.ProjectId,
			ClusterName:  thisClusterOverloadSimulation.ClusterName,
			SimulationId: thisClusterOverloadSimulation.SimulationId,
		}, nil)
		return nil
	})
}

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

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

    var thisClusterOverloadSimulation = new Mongodbatlas.ClusterOverloadSimulation("this", new()
    {
        ProjectId = thisAdvancedCluster.ProjectId,
        ClusterName = thisAdvancedCluster.Name,
        DurationSeconds = durationSeconds,
    });

    var @this = Mongodbatlas.GetClusterOverloadSimulation.Invoke(new()
    {
        ProjectId = thisClusterOverloadSimulation.ProjectId,
        ClusterName = thisClusterOverloadSimulation.ClusterName,
        SimulationId = thisClusterOverloadSimulation.SimulationId,
    });

});

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.ClusterOverloadSimulation;
import com.pulumi.mongodbatlas.ClusterOverloadSimulationArgs;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetClusterOverloadSimulationArgs;
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 thisAdvancedCluster = new AdvancedCluster("thisAdvancedCluster", AdvancedClusterArgs.builder()
            .projectId(projectId)
            .name(clusterName)
            .clusterType("REPLICASET")
            .replicationSpecs(AdvancedClusterReplicationSpecArgs.builder()
                .regionConfigs(AdvancedClusterReplicationSpecRegionConfigArgs.builder()
                    .electableSpecs(AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs.builder()
                        .instanceSize(instanceSize)
                        .nodeCount(3)
                        .build())
                    .providerName(cloudProvider)
                    .priority(7)
                    .regionName(regionName)
                    .build())
                .build())
            .build());

        var thisClusterOverloadSimulation = new ClusterOverloadSimulation("thisClusterOverloadSimulation", ClusterOverloadSimulationArgs.builder()
            .projectId(thisAdvancedCluster.projectId())
            .clusterName(thisAdvancedCluster.name())
            .durationSeconds(durationSeconds)
            .build());

        final var this = MongodbatlasFunctions.getClusterOverloadSimulation(GetClusterOverloadSimulationArgs.builder()
            .projectId(thisClusterOverloadSimulation.projectId())
            .clusterName(thisClusterOverloadSimulation.clusterName())
            .simulationId(thisClusterOverloadSimulation.simulationId())
            .build());

    }
}

resources:
  thisAdvancedCluster:
    type: mongodbatlas:AdvancedCluster
    name: this
    properties:
      projectId: ${projectId}
      name: ${clusterName}
      clusterType: REPLICASET
      replicationSpecs:
        - regionConfigs:
            - electableSpecs:
                instanceSize: ${instanceSize}
                nodeCount: 3
              providerName: ${cloudProvider}
              priority: 7
              regionName: ${regionName}
  thisClusterOverloadSimulation:
    type: mongodbatlas:ClusterOverloadSimulation
    name: this
    properties:
      projectId: ${thisAdvancedCluster.projectId}
      clusterName: ${thisAdvancedCluster.name}
      durationSeconds: ${durationSeconds}
variables:
  this:
    fn::invoke:
      function: mongodbatlas:getClusterOverloadSimulation
      arguments:
        projectId: ${thisClusterOverloadSimulation.projectId}
        clusterName: ${thisClusterOverloadSimulation.clusterName}
        simulationId: ${thisClusterOverloadSimulation.simulationId}

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

data "mongodbatlas_getclusteroverloadsimulation" "this" {
  project_id    = mongodbatlas_clusteroverloadsimulation.this.project_id
  cluster_name  = mongodbatlas_clusteroverloadsimulation.this.cluster_name
  simulation_id = mongodbatlas_clusteroverloadsimulation.this.simulation_id
}

resource "mongodbatlas_advancedcluster" "this" {
  project_id   = projectId
  name         = clusterName
  cluster_type = "REPLICASET"
  replication_specs {
    region_configs {
      electable_specs = {
        instance_size = instanceSize
        node_count    = 3
      }
      provider_name = cloudProvider
      priority      = 7
      region_name   = regionName
    }
  }
}
resource "mongodbatlas_clusteroverloadsimulation" "this" {
  project_id       = mongodbatlas_advancedcluster.this.project_id
  cluster_name     = mongodbatlas_advancedcluster.this.name
  duration_seconds = durationSeconds
}

function getClusterOverloadSimulation(args: GetClusterOverloadSimulationArgs, opts?: InvokeOptions): Promise<GetClusterOverloadSimulationResult>
function getClusterOverloadSimulationOutput(args: GetClusterOverloadSimulationOutputArgs, opts?: InvokeOutputOptions): Output<GetClusterOverloadSimulationResult>

def get_cluster_overload_simulation(cluster_name: Optional[str] = None,
                                    project_id: Optional[str] = None,
                                    simulation_id: Optional[str] = None,
                                    opts: Optional[InvokeOptions] = None) -> GetClusterOverloadSimulationResult
def get_cluster_overload_simulation_output(cluster_name: pulumi.Input[Optional[str]] = None,
                                    project_id: pulumi.Input[Optional[str]] = None,
                                    simulation_id: pulumi.Input[Optional[str]] = None,
                                    opts: Optional[InvokeOutputOptions] = None) -> Output[GetClusterOverloadSimulationResult]

func LookupClusterOverloadSimulation(ctx *Context, args *LookupClusterOverloadSimulationArgs, opts ...InvokeOption) (*LookupClusterOverloadSimulationResult, error)
func LookupClusterOverloadSimulationOutput(ctx *Context, args *LookupClusterOverloadSimulationOutputArgs, opts ...InvokeOption) LookupClusterOverloadSimulationResultOutput

public static class GetClusterOverloadSimulation 
{
    public static Task<GetClusterOverloadSimulationResult> InvokeAsync(GetClusterOverloadSimulationArgs args, InvokeOptions? opts = null)
    public static Output<GetClusterOverloadSimulationResult> Invoke(GetClusterOverloadSimulationInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetClusterOverloadSimulationResult> Invoke(GetClusterOverloadSimulationInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetClusterOverloadSimulationResult> getClusterOverloadSimulation(GetClusterOverloadSimulationArgs args, InvokeOptions options)
public static Output<GetClusterOverloadSimulationResult> getClusterOverloadSimulation(GetClusterOverloadSimulationArgs args, InvokeOptions options)
public static Output<GetClusterOverloadSimulationResult> getClusterOverloadSimulation(GetClusterOverloadSimulationArgs args, InvokeOutputOptions options)

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

data "mongodbatlas_get_cluster_overload_simulation" "name" {
    # arguments
}