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 testCluster = new mongodbatlas.Cluster("test", {
    projectId: testProject.id,
    name: "NAME OF THE CLUSTER",
    providerName: "AWS",
    providerRegionName: "US_EAST_2",
    providerInstanceSizeName: "M10",
    cloudBackup: true,
});
const testLdapVerify = new mongodbatlas.LdapVerify("test", {
    projectId: testProject.id,
    hostname: "HOSTNAME",
    port: 636,
    bindUsername: "USERNAME",
    bindPassword: "PASSWORD",
}, {
    dependsOn: [testCluster],
});
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_cluster = mongodbatlas.Cluster("test",
    project_id=test_project.id,
    name="NAME OF THE CLUSTER",
    provider_name="AWS",
    provider_region_name="US_EAST_2",
    provider_instance_size_name="M10",
    cloud_backup=True)
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_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
		}
		testCluster, err := mongodbatlas.NewCluster(ctx, "test", &mongodbatlas.ClusterArgs{
			ProjectId:                testProject.ID(),
			Name:                     pulumi.String("NAME OF THE CLUSTER"),
			ProviderName:             pulumi.String("AWS"),
			ProviderRegionName:       pulumi.String("US_EAST_2"),
			ProviderInstanceSizeName: pulumi.String("M10"),
			CloudBackup:              pulumi.Bool(true),
		})
		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{
			testCluster,
		}))
		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 testCluster = new Mongodbatlas.Cluster("test", new()
    {
        ProjectId = testProject.Id,
        Name = "NAME OF THE CLUSTER",
        ProviderName = "AWS",
        ProviderRegionName = "US_EAST_2",
        ProviderInstanceSizeName = "M10",
        CloudBackup = true,
    });

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

    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.Cluster;
import com.pulumi.mongodbatlas.ClusterArgs;
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 testCluster = new Cluster("testCluster", ClusterArgs.builder()
            .projectId(testProject.id())
            .name("NAME OF THE CLUSTER")
            .providerName("AWS")
            .providerRegionName("US_EAST_2")
            .providerInstanceSizeName("M10")
            .cloudBackup(true)
            .build());

        var testLdapVerify = new LdapVerify("testLdapVerify", LdapVerifyArgs.builder()
            .projectId(testProject.id())
            .hostname("HOSTNAME")
            .port(636)
            .bindUsername("USERNAME")
            .bindPassword("PASSWORD")
            .build(), CustomResourceOptions.builder()
                .dependsOn(testCluster)
                .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
  testCluster:
    type: mongodbatlas:Cluster
    name: test
    properties:
      projectId: ${testProject.id}
      name: NAME OF THE CLUSTER
      providerName: AWS
      providerRegionName: US_EAST_2
      providerInstanceSizeName: M10
      cloudBackup: true # enable cloud provider snapshots
  testLdapVerify:
    type: mongodbatlas:LdapVerify
    name: test
    properties:
      projectId: ${testProject.id}
      hostname: HOSTNAME
      port: 636
      bindUsername: USERNAME
      bindPassword: PASSWORD
    options:
      dependson:
        - ${testCluster}
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