pulumi-gcp-kotlin/com.pulumi.gcp.activedirectory.kotlin/DomainTrust

DomainTrust

class DomainTrust : KotlinCustomResource

Adds a trust between Active Directory domains To get more information about DomainTrust, see:

API documentation
How-to Guides

Active Directory Trust

Example Usage

Active Directory Domain Trust Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const ad_domain_trust = new gcp.activedirectory.DomainTrust("ad-domain-trust", {
    domain: "test-managed-ad.com",
    targetDomainName: "example-gcp.com",
    targetDnsIpAddresses: ["10&#46;1&#46;0&#46;100"],
    trustDirection: "OUTBOUND",
    trustType: "FOREST",
    trustHandshakeSecret: "Testing1!",
});

import pulumi
import pulumi_gcp as gcp
ad_domain_trust = gcp.activedirectory.DomainTrust("ad-domain-trust",
    domain="test-managed-ad.com",
    target_domain_name="example-gcp.com",
    target_dns_ip_addresses=["10&#46;1&#46;0&#46;100"],
    trust_direction="OUTBOUND",
    trust_type="FOREST",
    trust_handshake_secret="Testing1!")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var ad_domain_trust = new Gcp.ActiveDirectory.DomainTrust("ad-domain-trust", new()
    {
        Domain = "test-managed-ad.com",
        TargetDomainName = "example-gcp.com",
        TargetDnsIpAddresses = new[]
        {
            "10.1.0.100",
        },
        TrustDirection = "OUTBOUND",
        TrustType = "FOREST",
        TrustHandshakeSecret = "Testing1!",
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/activedirectory"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := activedirectory.NewDomainTrust(ctx, "ad-domain-trust", &activedirectory.DomainTrustArgs{
			Domain:           pulumi.String("test-managed-ad.com"),
			TargetDomainName: pulumi.String("example-gcp.com"),
			TargetDnsIpAddresses: pulumi.StringArray{
				pulumi.String("10.1.0.100"),
			},
			TrustDirection:       pulumi.String("OUTBOUND"),
			TrustType:            pulumi.String("FOREST"),
			TrustHandshakeSecret: pulumi.String("Testing1!"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.activedirectory.DomainTrust;
import com.pulumi.gcp.activedirectory.DomainTrustArgs;
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 ad_domain_trust = new DomainTrust("ad-domain-trust", DomainTrustArgs.builder()
            .domain("test-managed-ad.com")
            .targetDomainName("example-gcp.com")
            .targetDnsIpAddresses("10.1.0.100")
            .trustDirection("OUTBOUND")
            .trustType("FOREST")
            .trustHandshakeSecret("Testing1!")
            .build());
    }
}

resources:
  ad-domain-trust:
    type: gcp:activedirectory:DomainTrust
    properties:
      domain: test-managed-ad.com
      targetDomainName: example-gcp.com
      targetDnsIpAddresses:
        - 10.1.0.100
      trustDirection: OUTBOUND
      trustType: FOREST
      trustHandshakeSecret: Testing1!

Import

DomainTrust can be imported using any of these accepted formats:

projects/{{project}}/locations/global/domains/{{domain}}/{{target_domain_name}}
{{project}}/{{domain}}/{{target_domain_name}}
{{domain}}/{{target_domain_name}} When using the pulumi import command, DomainTrust can be imported using one of the formats above. For example:

$ pulumi import gcp:activedirectory/domainTrust:DomainTrust default projects/{{project}}/locations/global/domains/{{domain}}/{{target_domain_name}}

$ pulumi import gcp:activedirectory/domainTrust:DomainTrust default {{project}}/{{domain}}/{{target_domain_name}}

$ pulumi import gcp:activedirectory/domainTrust:DomainTrust default {{domain}}/{{target_domain_name}}

Properties

domain

val domain: Output<String>

The fully qualified domain name. e.g. mydomain.myorganization.com, with the restrictions of https://cloud.google.com/managed-microsoft-ad/reference/rest/v1/projects.locations.global.domains.

val id: Output<String>

project

val project: Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

selectiveAuthentication

val selectiveAuthentication: Output<Boolean>?

Whether the trusted side has forest/domain wide access or selective access to an approved set of resources.

targetDnsIpAddresses

val targetDnsIpAddresses: Output<List<String>>

The target DNS server IP addresses which can resolve the remote domain involved in the trust.

targetDomainName

val targetDomainName: Output<String>

The fully qualified target domain name which will be in trust with the current domain.

trustDirection

val trustDirection: Output<String>

The trust direction, which decides if the current domain is trusted, trusting, or both. Possible values are: INBOUND, OUTBOUND, BIDIRECTIONAL.

trustHandshakeSecret

val trustHandshakeSecret: Output<String>

The trust secret used for the handshake with the target domain. This will not be stored. Note: This property is sensitive and will not be displayed in the plan.

trustType

val trustType: Output<String>

The type of trust represented by the trust resource. Possible values are: FOREST, EXTERNAL.

urn

val urn: Output<String>