mongodbatlas.getLdapVerify

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

const testProject = new mongodbatlas.Project("test", {
    name: "NAME OF THE PROJECT",
    orgId: "ORG ID",
});
const testAdvancedCluster = new mongodbatlas.AdvancedCluster("test", {
    projectId: testProject.id,
    name: "ClusterName",
    clusterType: "REPLICASET",
    backupEnabled: true,
    replicationSpecs: [{
        regionConfigs: [{
            priority: 7,
            providerName: "AWS",
            regionName: "US_EAST_1",
            electableSpecs: {
                instanceSize: "M10",
                nodeCount: 3,
            },
        }],
    }],
});
const testLdapVerify = new mongodbatlas.LdapVerify("test", {
    projectId: testProject.id,
    hostname: "HOSTNAME",
    port: 636,
    bindUsername: "USERNAME",
    bindPassword: "PASSWORD",
}, {
    dependsOn: [testAdvancedCluster],
});
const test = mongodbatlas.getLdapVerifyOutput({
    projectId: testLdapVerify.projectId,
    requestId: testLdapVerify.requestId,
});

import pulumi
import pulumi_mongodbatlas as mongodbatlas

test_project = mongodbatlas.Project("test",
    name="NAME OF THE PROJECT",
    org_id="ORG ID")
test_advanced_cluster = mongodbatlas.AdvancedCluster("test",
    project_id=test_project.id,
    name="ClusterName",
    cluster_type="REPLICASET",
    backup_enabled=True,
    replication_specs=[{
        "region_configs": [{
            "priority": 7,
            "provider_name": "AWS",
            "region_name": "US_EAST_1",
            "electable_specs": {
                "instance_size": "M10",
                "node_count": 3,
            },
        }],
    }])
test_ldap_verify = mongodbatlas.LdapVerify("test",
    project_id=test_project.id,
    hostname="HOSTNAME",
    port=636,
    bind_username="USERNAME",
    bind_password="PASSWORD",
    opts = pulumi.ResourceOptions(depends_on=[test_advanced_cluster]))
test = mongodbatlas.get_ldap_verify_output(project_id=test_ldap_verify.project_id,
    request_id=test_ldap_verify.request_id)

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 {
		testProject, err := mongodbatlas.NewProject(ctx, "test", &mongodbatlas.ProjectArgs{
			Name:  pulumi.String("NAME OF THE PROJECT"),
			OrgId: pulumi.String("ORG ID"),
		})
		if err != nil {
			return err
		}
		testAdvancedCluster, err := mongodbatlas.NewAdvancedCluster(ctx, "test", &mongodbatlas.AdvancedClusterArgs{
			ProjectId:     testProject.ID(),
			Name:          pulumi.String("ClusterName"),
			ClusterType:   pulumi.String("REPLICASET"),
			BackupEnabled: pulumi.Bool(true),
			ReplicationSpecs: mongodbatlas.AdvancedClusterReplicationSpecArray{
				&mongodbatlas.AdvancedClusterReplicationSpecArgs{
					RegionConfigs: mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArray{
						&mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArgs{
							Priority:     pulumi.Int(7),
							ProviderName: pulumi.String("AWS"),
							RegionName:   pulumi.String("US_EAST_1"),
							ElectableSpecs: &mongodbatlas.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs{
								InstanceSize: pulumi.String("M10"),
								NodeCount:    pulumi.Int(3),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		testLdapVerify, err := mongodbatlas.NewLdapVerify(ctx, "test", &mongodbatlas.LdapVerifyArgs{
			ProjectId:    testProject.ID(),
			Hostname:     pulumi.String("HOSTNAME"),
			Port:         pulumi.Int(636),
			BindUsername: pulumi.String("USERNAME"),
			BindPassword: pulumi.String("PASSWORD"),
		}, pulumi.DependsOn([]pulumi.Resource{
			testAdvancedCluster,
		}))
		if err != nil {
			return err
		}
		_ = mongodbatlas.LookupLdapVerifyOutput(ctx, mongodbatlas.GetLdapVerifyOutputArgs{
			ProjectId: testLdapVerify.ProjectId,
			RequestId: testLdapVerify.RequestId,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var testProject = new Mongodbatlas.Project("test", new()
    {
        Name = "NAME OF THE PROJECT",
        OrgId = "ORG ID",
    });

    var testAdvancedCluster = new Mongodbatlas.AdvancedCluster("test", new()
    {
        ProjectId = testProject.Id,
        Name = "ClusterName",
        ClusterType = "REPLICASET",
        BackupEnabled = true,
        ReplicationSpecs = new[]
        {
            new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecArgs
            {
                RegionConfigs = new[]
                {
                    new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigArgs
                    {
                        Priority = 7,
                        ProviderName = "AWS",
                        RegionName = "US_EAST_1",
                        ElectableSpecs = new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs
                        {
                            InstanceSize = "M10",
                            NodeCount = 3,
                        },
                    },
                },
            },
        },
    });

    var testLdapVerify = new Mongodbatlas.LdapVerify("test", new()
    {
        ProjectId = testProject.Id,
        Hostname = "HOSTNAME",
        Port = 636,
        BindUsername = "USERNAME",
        BindPassword = "PASSWORD",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            testAdvancedCluster,
        },
    });

    var test = Mongodbatlas.GetLdapVerify.Invoke(new()
    {
        ProjectId = testLdapVerify.ProjectId,
        RequestId = testLdapVerify.RequestId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.Project;
import com.pulumi.mongodbatlas.ProjectArgs;
import com.pulumi.mongodbatlas.AdvancedCluster;
import com.pulumi.mongodbatlas.AdvancedClusterArgs;
import com.pulumi.mongodbatlas.inputs.AdvancedClusterReplicationSpecArgs;
import com.pulumi.mongodbatlas.LdapVerify;
import com.pulumi.mongodbatlas.LdapVerifyArgs;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetLdapVerifyArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var testProject = new Project("testProject", ProjectArgs.builder()
            .name("NAME OF THE PROJECT")
            .orgId("ORG ID")
            .build());

        var testAdvancedCluster = new AdvancedCluster("testAdvancedCluster", AdvancedClusterArgs.builder()
            .projectId(testProject.id())
            .name("ClusterName")
            .clusterType("REPLICASET")
            .backupEnabled(true)
            .replicationSpecs(AdvancedClusterReplicationSpecArgs.builder()
                .regionConfigs(AdvancedClusterReplicationSpecRegionConfigArgs.builder()
                    .priority(7)
                    .providerName("AWS")
                    .regionName("US_EAST_1")
                    .electableSpecs(AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs.builder()
                        .instanceSize("M10")
                        .nodeCount(3)
                        .build())
                    .build())
                .build())
            .build());

        var testLdapVerify = new LdapVerify("testLdapVerify", LdapVerifyArgs.builder()
            .projectId(testProject.id())
            .hostname("HOSTNAME")
            .port(636)
            .bindUsername("USERNAME")
            .bindPassword("PASSWORD")
            .build(), CustomResourceOptions.builder()
                .dependsOn(testAdvancedCluster)
                .build());

        final var test = MongodbatlasFunctions.getLdapVerify(GetLdapVerifyArgs.builder()
            .projectId(testLdapVerify.projectId())
            .requestId(testLdapVerify.requestId())
            .build());

    }
}

resources:
  testProject:
    type: mongodbatlas:Project
    name: test
    properties:
      name: NAME OF THE PROJECT
      orgId: ORG ID
  testAdvancedCluster:
    type: mongodbatlas:AdvancedCluster
    name: test
    properties:
      projectId: ${testProject.id}
      name: ClusterName
      clusterType: REPLICASET
      backupEnabled: true # enable cloud provider snapshots
      replicationSpecs:
        - regionConfigs:
            - priority: 7
              providerName: AWS
              regionName: US_EAST_1
              electableSpecs:
                instanceSize: M10
                nodeCount: 3
  testLdapVerify:
    type: mongodbatlas:LdapVerify
    name: test
    properties:
      projectId: ${testProject.id}
      hostname: HOSTNAME
      port: 636
      bindUsername: USERNAME
      bindPassword: PASSWORD
    options:
      dependson:
        - ${testAdvancedCluster}
variables:
  test:
    fn::invoke:
      Function: mongodbatlas:getLdapVerify
      Arguments:
        projectId: ${testLdapVerify.projectId}
        requestId: ${testLdapVerify.requestId}

function getLdapVerify(args: GetLdapVerifyArgs, opts?: InvokeOptions): Promise<GetLdapVerifyResult>
function getLdapVerifyOutput(args: GetLdapVerifyOutputArgs, opts?: InvokeOptions): Output<GetLdapVerifyResult>

def get_ldap_verify(project_id: Optional[str] = None,
                    request_id: Optional[str] = None,
                    opts: Optional[InvokeOptions] = None) -> GetLdapVerifyResult
def get_ldap_verify_output(project_id: Optional[pulumi.Input[str]] = None,
                    request_id: Optional[pulumi.Input[str]] = None,
                    opts: Optional[InvokeOptions] = None) -> Output[GetLdapVerifyResult]

func LookupLdapVerify(ctx *Context, args *LookupLdapVerifyArgs, opts ...InvokeOption) (*LookupLdapVerifyResult, error)
func LookupLdapVerifyOutput(ctx *Context, args *LookupLdapVerifyOutputArgs, opts ...InvokeOption) LookupLdapVerifyResultOutput

public static class GetLdapVerify 
{
    public static Task<GetLdapVerifyResult> InvokeAsync(GetLdapVerifyArgs args, InvokeOptions? opts = null)
    public static Output<GetLdapVerifyResult> Invoke(GetLdapVerifyInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetLdapVerifyResult> getLdapVerify(GetLdapVerifyArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

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