pulumi-gcp-kotlin/com.pulumi.gcp.dns.kotlin/ManagedZoneArgs

ManagedZoneArgs

data class ManagedZoneArgs(val cloudLoggingConfig: Output<ManagedZoneCloudLoggingConfigArgs>? = null, val description: Output<String>? = null, val dnsName: Output<String>? = null, val dnssecConfig: Output<ManagedZoneDnssecConfigArgs>? = null, val forceDestroy: Output<Boolean>? = null, val forwardingConfig: Output<ManagedZoneForwardingConfigArgs>? = null, val labels: Output<Map<String, String>>? = null, val name: Output<String>? = null, val peeringConfig: Output<ManagedZonePeeringConfigArgs>? = null, val privateVisibilityConfig: Output<ManagedZonePrivateVisibilityConfigArgs>? = null, val project: Output<String>? = null, val reverseLookup: Output<Boolean>? = null, val serviceDirectoryConfig: Output<ManagedZoneServiceDirectoryConfigArgs>? = null, val visibility: Output<String>? = null) : ConvertibleToJava<ManagedZoneArgs>

A zone is a subtree of the DNS namespace under one administrative responsibility. A ManagedZone is a resource that represents a DNS zone hosted by the Cloud DNS service. To get more information about ManagedZone, see:

Example Usage

Dns Managed Zone Basic

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dns.ManagedZone;
import com.pulumi.gcp.dns.ManagedZoneArgs;
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 example_zone = new ManagedZone("example-zone", ManagedZoneArgs.builder()
            .description("Example DNS zone")
            .dnsName("my-domain.com.")
            .labels(Map.of("foo", "bar"))
            .build());
    }
}
Content copied to clipboard

Dns Managed Zone Private

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.dns.ManagedZone;
import com.pulumi.gcp.dns.ManagedZoneArgs;
import com.pulumi.gcp.dns.inputs.ManagedZonePrivateVisibilityConfigArgs;
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 network_1 = new Network("network-1", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .build());
        var network_2 = new Network("network-2", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .build());
        var private_zone = new ManagedZone("private-zone", ManagedZoneArgs.builder()
            .dnsName("private.example.com.")
            .description("Example private DNS zone")
            .labels(Map.of("foo", "bar"))
            .visibility("private")
            .privateVisibilityConfig(ManagedZonePrivateVisibilityConfigArgs.builder()
                .networks(
                    ManagedZonePrivateVisibilityConfigNetworkArgs.builder()
                        .networkUrl(network_1.id())
                        .build(),
                    ManagedZonePrivateVisibilityConfigNetworkArgs.builder()
                        .networkUrl(network_2.id())
                        .build())
                .build())
            .build());
    }
}
Content copied to clipboard

Dns Managed Zone Private Forwarding

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.dns.ManagedZone;
import com.pulumi.gcp.dns.ManagedZoneArgs;
import com.pulumi.gcp.dns.inputs.ManagedZonePrivateVisibilityConfigArgs;
import com.pulumi.gcp.dns.inputs.ManagedZoneForwardingConfigArgs;
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 network_1 = new Network("network-1", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .build());
        var network_2 = new Network("network-2", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .build());
        var private_zone = new ManagedZone("private-zone", ManagedZoneArgs.builder()
            .dnsName("private.example.com.")
            .description("Example private DNS zone")
            .labels(Map.of("foo", "bar"))
            .visibility("private")
            .privateVisibilityConfig(ManagedZonePrivateVisibilityConfigArgs.builder()
                .networks(
                    ManagedZonePrivateVisibilityConfigNetworkArgs.builder()
                        .networkUrl(network_1.id())
                        .build(),
                    ManagedZonePrivateVisibilityConfigNetworkArgs.builder()
                        .networkUrl(network_2.id())
                        .build())
                .build())
            .forwardingConfig(ManagedZoneForwardingConfigArgs.builder()
                .targetNameServers(
                    ManagedZoneForwardingConfigTargetNameServerArgs.builder()
                        .ipv4Address("172.16.1.10")
                        .build(),
                    ManagedZoneForwardingConfigTargetNameServerArgs.builder()
                        .ipv4Address("172.16.1.20")
                        .build())
                .build())
            .build());
    }
}
Content copied to clipboard

Dns Managed Zone Private Gke

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.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.compute.inputs.SubnetworkSecondaryIpRangeArgs;
import com.pulumi.gcp.container.Cluster;
import com.pulumi.gcp.container.ClusterArgs;
import com.pulumi.gcp.container.inputs.ClusterDefaultSnatStatusArgs;
import com.pulumi.gcp.container.inputs.ClusterPrivateClusterConfigArgs;
import com.pulumi.gcp.container.inputs.ClusterPrivateClusterConfigMasterGlobalAccessConfigArgs;
import com.pulumi.gcp.container.inputs.ClusterMasterAuthorizedNetworksConfigArgs;
import com.pulumi.gcp.container.inputs.ClusterIpAllocationPolicyArgs;
import com.pulumi.gcp.dns.ManagedZone;
import com.pulumi.gcp.dns.ManagedZoneArgs;
import com.pulumi.gcp.dns.inputs.ManagedZonePrivateVisibilityConfigArgs;
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 network_1 = new Network("network-1", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .build());
        var subnetwork_1 = new Subnetwork("subnetwork-1", SubnetworkArgs.builder()
            .network(network_1.name())
            .ipCidrRange("10.0.36.0/24")
            .region("us-central1")
            .privateIpGoogleAccess(true)
            .secondaryIpRanges(
                SubnetworkSecondaryIpRangeArgs.builder()
                    .rangeName("pod")
                    .ipCidrRange("10.0.0.0/19")
                    .build(),
                SubnetworkSecondaryIpRangeArgs.builder()
                    .rangeName("svc")
                    .ipCidrRange("10.0.32.0/22")
                    .build())
            .build());
        var cluster_1 = new Cluster("cluster-1", ClusterArgs.builder()
            .location("us-central1-c")
            .initialNodeCount(1)
            .networkingMode("VPC_NATIVE")
            .defaultSnatStatus(ClusterDefaultSnatStatusArgs.builder()
                .disabled(true)
                .build())
            .network(network_1.name())
            .subnetwork(subnetwork_1.name())
            .privateClusterConfig(ClusterPrivateClusterConfigArgs.builder()
                .enablePrivateEndpoint(true)
                .enablePrivateNodes(true)
                .masterIpv4CidrBlock("10.42.0.0/28")
                .masterGlobalAccessConfig(ClusterPrivateClusterConfigMasterGlobalAccessConfigArgs.builder()
                    .enabled(true)
                    .build())
                .build())
            .masterAuthorizedNetworksConfig()
            .ipAllocationPolicy(ClusterIpAllocationPolicyArgs.builder()
                .clusterSecondaryRangeName(subnetwork_1.secondaryIpRanges().applyValue(secondaryIpRanges -> secondaryIpRanges[0].rangeName()))
                .servicesSecondaryRangeName(subnetwork_1.secondaryIpRanges().applyValue(secondaryIpRanges -> secondaryIpRanges[1].rangeName()))
                .build())
            .build());
        var private_zone_gke = new ManagedZone("private-zone-gke", ManagedZoneArgs.builder()
            .dnsName("private.example.com.")
            .description("Example private DNS zone")
            .labels(Map.of("foo", "bar"))
            .visibility("private")
            .privateVisibilityConfig(ManagedZonePrivateVisibilityConfigArgs.builder()
                .gkeClusters(ManagedZonePrivateVisibilityConfigGkeClusterArgs.builder()
                    .gkeClusterName(cluster_1.id())
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard

Dns Managed Zone Private Peering

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.dns.ManagedZone;
import com.pulumi.gcp.dns.ManagedZoneArgs;
import com.pulumi.gcp.dns.inputs.ManagedZonePrivateVisibilityConfigArgs;
import com.pulumi.gcp.dns.inputs.ManagedZonePeeringConfigArgs;
import com.pulumi.gcp.dns.inputs.ManagedZonePeeringConfigTargetNetworkArgs;
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 network_source = new Network("network-source", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .build());
        var network_target = new Network("network-target", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .build());
        var peering_zone = new ManagedZone("peering-zone", ManagedZoneArgs.builder()
            .dnsName("peering.example.com.")
            .description("Example private DNS peering zone")
            .visibility("private")
            .privateVisibilityConfig(ManagedZonePrivateVisibilityConfigArgs.builder()
                .networks(ManagedZonePrivateVisibilityConfigNetworkArgs.builder()
                    .networkUrl(network_source.id())
                    .build())
                .build())
            .peeringConfig(ManagedZonePeeringConfigArgs.builder()
                .targetNetwork(ManagedZonePeeringConfigTargetNetworkArgs.builder()
                    .networkUrl(network_target.id())
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard

Dns Managed Zone Service Directory

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.servicedirectory.Namespace;
import com.pulumi.gcp.servicedirectory.NamespaceArgs;
import com.pulumi.gcp.dns.ManagedZone;
import com.pulumi.gcp.dns.ManagedZoneArgs;
import com.pulumi.gcp.dns.inputs.ManagedZoneServiceDirectoryConfigArgs;
import com.pulumi.gcp.dns.inputs.ManagedZoneServiceDirectoryConfigNamespaceArgs;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
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 example = new Namespace("example", NamespaceArgs.builder()
            .namespaceId("example")
            .location("us-central1")
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
        var sd_zone = new ManagedZone("sd-zone", ManagedZoneArgs.builder()
            .dnsName("services.example.com.")
            .description("Example private DNS Service Directory zone")
            .visibility("private")
            .serviceDirectoryConfig(ManagedZoneServiceDirectoryConfigArgs.builder()
                .namespace(ManagedZoneServiceDirectoryConfigNamespaceArgs.builder()
                    .namespaceUrl(example.id())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
        var network = new Network("network", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
    }
}
Content copied to clipboard

Dns Managed Zone Cloud Logging

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dns.ManagedZone;
import com.pulumi.gcp.dns.ManagedZoneArgs;
import com.pulumi.gcp.dns.inputs.ManagedZoneCloudLoggingConfigArgs;
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 cloud_logging_enabled_zone = new ManagedZone("cloud-logging-enabled-zone", ManagedZoneArgs.builder()
            .cloudLoggingConfig(ManagedZoneCloudLoggingConfigArgs.builder()
                .enableLogging(true)
                .build())
            .description("Example cloud logging enabled DNS zone")
            .dnsName("services.example.com.")
            .labels(Map.of("foo", "bar"))
            .build());
    }
}
Content copied to clipboard

Import

ManagedZone can be imported using any of these accepted formats

$ pulumi import gcp:dns/managedZone:ManagedZone default projects/{{project}}/managedZones/{{name}}
Content copied to clipboard
$ pulumi import gcp:dns/managedZone:ManagedZone default {{project}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:dns/managedZone:ManagedZone default {{name}}
Content copied to clipboard

Constructors

Link copied to clipboard
fun ManagedZoneArgs(cloudLoggingConfig: Output<ManagedZoneCloudLoggingConfigArgs>? = null, description: Output<String>? = null, dnsName: Output<String>? = null, dnssecConfig: Output<ManagedZoneDnssecConfigArgs>? = null, forceDestroy: Output<Boolean>? = null, forwardingConfig: Output<ManagedZoneForwardingConfigArgs>? = null, labels: Output<Map<String, String>>? = null, name: Output<String>? = null, peeringConfig: Output<ManagedZonePeeringConfigArgs>? = null, privateVisibilityConfig: Output<ManagedZonePrivateVisibilityConfigArgs>? = null, project: Output<String>? = null, reverseLookup: Output<Boolean>? = null, serviceDirectoryConfig: Output<ManagedZoneServiceDirectoryConfigArgs>? = null, visibility: Output<String>? = null)

Functions

Link copied to clipboard
open override fun toJava(): ManagedZoneArgs

Properties

Link copied to clipboard
val cloudLoggingConfig: Output<ManagedZoneCloudLoggingConfigArgs>? = null

Cloud logging configuration Structure is documented below.

Link copied to clipboard
val description: Output<String>? = null

A textual description field. Defaults to 'Managed by Pulumi'.

Link copied to clipboard
val dnsName: Output<String>? = null

The DNS name of this managed zone, for instance "example.com.".

Link copied to clipboard
val dnssecConfig: Output<ManagedZoneDnssecConfigArgs>? = null

DNSSEC configuration Structure is documented below.

Link copied to clipboard
val forceDestroy: Output<Boolean>? = null

Set this true to delete all records in the zone.

Link copied to clipboard
val forwardingConfig: Output<ManagedZoneForwardingConfigArgs>? = null

The presence for this field indicates that outbound forwarding is enabled for this zone. The value of this field contains the set of destinations to forward to. Structure is documented below.

Link copied to clipboard
val labels: Output<Map<String, String>>? = null

A set of key/value label pairs to assign to this ManagedZone.

Link copied to clipboard
val name: Output<String>? = null

User assigned name for this resource. Must be unique within the project.

Link copied to clipboard
val peeringConfig: Output<ManagedZonePeeringConfigArgs>? = null

The presence of this field indicates that DNS Peering is enabled for this zone. The value of this field contains the network to peer with. Structure is documented below.

Link copied to clipboard
val privateVisibilityConfig: Output<ManagedZonePrivateVisibilityConfigArgs>? = null

For privately visible zones, the set of Virtual Private Cloud resources that the zone is visible from. At least one of gke_clusters or networks must be specified. Structure is documented below.

Link copied to clipboard
val project: Output<String>? = null

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

Link copied to clipboard
val reverseLookup: Output<Boolean>? = null

Specifies if this is a managed reverse lookup zone. If true, Cloud DNS will resolve reverse lookup queries using automatically configured records for VPC resources. This only applies to networks listed under private_visibility_config.

Link copied to clipboard
val serviceDirectoryConfig: Output<ManagedZoneServiceDirectoryConfigArgs>? = null

The presence of this field indicates that this zone is backed by Service Directory. The value of this field contains information related to the namespace associated with the zone. Structure is documented below.

Link copied to clipboard
val visibility: Output<String>? = null

The zone's visibility: public zones are exposed to the Internet, while private zones are visible only to Virtual Private Cloud resources. Default value is public. Possible values are: private, public.