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

Peering

class Peering : KotlinCustomResource

Example Usage

Active Directory Peering Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const source_network = new gcp.compute.Network("source-network", {name: "ad-network"});
const ad_domain = new gcp.activedirectory.Domain("ad-domain", {
    domainName: "ad.test.hashicorptest.com",
    locations: ["us-central1"],
    reservedIpRange: "192.168.255.0/24",
    authorizedNetworks: [source_network&#46;id],
});
const peered_project = new gcp.organizations.Project("peered-project", {
    name: "my-peered-project",
    projectId: "my-peered-project",
    orgId: "123456789",
    billingAccount: "000000-0000000-0000000-000000",
});
const compute = new gcp.projects.Service("compute", {
    project: peered_project.projectId,
    service: "compute.googleapis.com",
});
const peered_network = new gcp.compute.Network("peered-network", {
    project: compute.project,
    name: "ad-peered-network",
});
const ad_domain_peering = new gcp.activedirectory.Peering("ad-domain-peering", {
    domainResource: ad_domain.name,
    peeringId: "ad-domain-peering",
    authorizedNetwork: peered_network.id,
    labels: {
        foo: "bar",
    },
});

import pulumi
import pulumi_gcp as gcp
source_network = gcp.compute.Network("source-network", name="ad-network")
ad_domain = gcp.activedirectory.Domain("ad-domain",
    domain_name="ad.test.hashicorptest.com",
    locations=["us-central1"],
    reserved_ip_range="192.168.255.0/24",
    authorized_networks=[source_network&#46;id])
peered_project = gcp.organizations.Project("peered-project",
    name="my-peered-project",
    project_id="my-peered-project",
    org_id="123456789",
    billing_account="000000-0000000-0000000-000000")
compute = gcp.projects.Service("compute",
    project=peered_project.project_id,
    service="compute.googleapis.com")
peered_network = gcp.compute.Network("peered-network",
    project=compute.project,
    name="ad-peered-network")
ad_domain_peering = gcp.activedirectory.Peering("ad-domain-peering",
    domain_resource=ad_domain.name,
    peering_id="ad-domain-peering",
    authorized_network=peered_network.id,
    labels={
        "foo": "bar",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var source_network = new Gcp.Compute.Network("source-network", new()
    {
        Name = "ad-network",
    });
    var ad_domain = new Gcp.ActiveDirectory.Domain("ad-domain", new()
    {
        DomainName = "ad.test.hashicorptest.com",
        Locations = new[]
        {
            "us-central1",
        },
        ReservedIpRange = "192.168.255.0/24",
        AuthorizedNetworks = new[]
        {
            source_network.Id,
        },
    });
    var peered_project = new Gcp.Organizations.Project("peered-project", new()
    {
        Name = "my-peered-project",
        ProjectId = "my-peered-project",
        OrgId = "123456789",
        BillingAccount = "000000-0000000-0000000-000000",
    });
    var compute = new Gcp.Projects.Service("compute", new()
    {
        Project = peered_project.ProjectId,
        ServiceName = "compute.googleapis.com",
    });
    var peered_network = new Gcp.Compute.Network("peered-network", new()
    {
        Project = compute.Project,
        Name = "ad-peered-network",
    });
    var ad_domain_peering = new Gcp.ActiveDirectory.Peering("ad-domain-peering", new()
    {
        DomainResource = ad_domain.Name,
        PeeringId = "ad-domain-peering",
        AuthorizedNetwork = peered_network.Id,
        Labels =
        {
            { "foo", "bar" },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/activedirectory"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/projects"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewNetwork(ctx, "source-network", &compute.NetworkArgs{
			Name: pulumi.String("ad-network"),
		})
		if err != nil {
			return err
		}
		_, err = activedirectory.NewDomain(ctx, "ad-domain", &activedirectory.DomainArgs{
			DomainName: pulumi.String("ad.test.hashicorptest.com"),
			Locations: pulumi.StringArray{
				pulumi.String("us-central1"),
			},
			ReservedIpRange: pulumi.String("192.168.255.0/24"),
			AuthorizedNetworks: pulumi.StringArray{
				source_network.ID(),
			},
		})
		if err != nil {
			return err
		}
		_, err = organizations.NewProject(ctx, "peered-project", &organizations.ProjectArgs{
			Name:           pulumi.String("my-peered-project"),
			ProjectId:      pulumi.String("my-peered-project"),
			OrgId:          pulumi.String("123456789"),
			BillingAccount: pulumi.String("000000-0000000-0000000-000000"),
		})
		if err != nil {
			return err
		}
		compute, err := projects.NewService(ctx, "compute", &projects.ServiceArgs{
			Project: peered_project.ProjectId,
			Service: pulumi.String("compute.googleapis.com"),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewNetwork(ctx, "peered-network", &compute.NetworkArgs{
			Project: compute.Project,
			Name:    pulumi.String("ad-peered-network"),
		})
		if err != nil {
			return err
		}
		_, err = activedirectory.NewPeering(ctx, "ad-domain-peering", &activedirectory.PeeringArgs{
			DomainResource:    ad_domain.Name,
			PeeringId:         pulumi.String("ad-domain-peering"),
			AuthorizedNetwork: peered_network.ID(),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
		})
		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.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.activedirectory.Domain;
import com.pulumi.gcp.activedirectory.DomainArgs;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.gcp.projects.Service;
import com.pulumi.gcp.projects.ServiceArgs;
import com.pulumi.gcp.activedirectory.Peering;
import com.pulumi.gcp.activedirectory.PeeringArgs;
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 source_network = new Network("source-network", NetworkArgs.builder()
            .name("ad-network")
            .build());
        var ad_domain = new Domain("ad-domain", DomainArgs.builder()
            .domainName("ad.test.hashicorptest.com")
            .locations("us-central1")
            .reservedIpRange("192.168.255.0/24")
            .authorizedNetworks(source_network.id())
            .build());
        var peered_project = new Project("peered-project", ProjectArgs.builder()
            .name("my-peered-project")
            .projectId("my-peered-project")
            .orgId("123456789")
            .billingAccount("000000-0000000-0000000-000000")
            .build());
        var compute = new Service("compute", ServiceArgs.builder()
            .project(peered_project.projectId())
            .service("compute.googleapis.com")
            .build());
        var peered_network = new Network("peered-network", NetworkArgs.builder()
            .project(compute.project())
            .name("ad-peered-network")
            .build());
        var ad_domain_peering = new Peering("ad-domain-peering", PeeringArgs.builder()
            .domainResource(ad_domain.name())
            .peeringId("ad-domain-peering")
            .authorizedNetwork(peered_network.id())
            .labels(Map.of("foo", "bar"))
            .build());
    }
}

resources:
  ad-domain-peering:
    type: gcp:activedirectory:Peering
    properties:
      domainResource: ${["ad-domain"].name}
      peeringId: ad-domain-peering
      authorizedNetwork: ${["peered-network"].id}
      labels:
        foo: bar
  ad-domain:
    type: gcp:activedirectory:Domain
    properties:
      domainName: ad.test.hashicorptest.com
      locations:
        - us-central1
      reservedIpRange: 192.168.255.0/24
      authorizedNetworks:
        - ${["source-network"].id}
  peered-network:
    type: gcp:compute:Network
    properties:
      project: ${compute.project}
      name: ad-peered-network
  source-network:
    type: gcp:compute:Network
    properties:
      name: ad-network
  compute:
    type: gcp:projects:Service
    properties:
      project: ${["peered-project"].projectId}
      service: compute.googleapis.com
  peered-project:
    type: gcp:organizations:Project
    properties:
      name: my-peered-project
      projectId: my-peered-project
      orgId: '123456789'
      billingAccount: 000000-0000000-0000000-000000

Import

This resource does not support import.

Properties

authorizedNetwork

val authorizedNetwork: Output<String>

The full names of the Google Compute Engine networks to which the instance is connected. Caller needs to make sure that CIDR subnets do not overlap between networks, else peering creation will fail.

domainResource

val domainResource: Output<String>

Full domain resource path for the Managed AD Domain involved in peering. The resource path should be in the form projects/{projectId}/locations/global/domains/{domainName}

effectiveLabels

val effectiveLabels: Output<Map<String, String>>

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

val id: Output<String>

labels

val labels: Output<Map<String, String>>?

Resource labels that can contain user-provided metadata Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.

name

val name: Output<String>

Unique name of the peering in this scope including projects and location using the form: projects/{projectId}/locations/global/peerings/{peeringId}.

peeringId

val peeringId: 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>

pulumiLabels