edgecenter.DnsZoneRecord

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

const config = new pulumi.Config();
const exampleDomain0 = config.get("exampleDomain0") || "examplezone.com";
const examplezone0 = new edgecenter.DnsZone("examplezone0", {});
const exampleRrset0 = new edgecenter.DnsZoneRecord("exampleRrset0", {
    zone: examplezone0.name,
    domain: examplezone0.name,
    type: "A",
    ttl: 100,
    meta: {},
    resourceRecords: [
        {
            content: "127.0.0.100",
        },
        {
            content: "127.0.0.200",
        },
    ],
});
const subdomainExamplezone = new edgecenter.DnsZoneRecord("subdomainExamplezone", {
    zone: "examplezone.com",
    domain: "subdomain.examplezone.com",
    type: "TXT",
    ttl: 10,
    filters: [{
        type: "geodistance",
        limit: 1,
        strict: true,
    }],
    meta: {},
    resourceRecords: [{
        content: "1234",
        enabled: true,
        meta: {
            latlongs: [
                52.367,
                4.9041,
            ],
            asns: [12345],
            ips: ["1.1.1.1"],
            notes: ["notes"],
            continents: ["asia"],
            countries: ["russia"],
            "default": true,
        },
    }],
});
const subdomainExamplezoneMx = new edgecenter.DnsZoneRecord("subdomainExamplezoneMx", {
    zone: "examplezone.com",
    domain: "subdomain.examplezone.com",
    type: "MX",
    ttl: 10,
    meta: {},
    resourceRecords: [{
        content: "10 mail.my.com.",
        enabled: true,
    }],
});
const string = "0 issue \"company.org;account=12345\"";
const subdomainExamplezoneCaa = new edgecenter.DnsZoneRecord("subdomainExamplezoneCaa", {
    zone: "examplezone.com",
    domain: "subdomain.examplezone.com",
    type: "CAA",
    ttl: 10,
    meta: {},
    resourceRecords: [{
        content: string,
        enabled: true,
    }],
});

import pulumi
import pulumi_edgecenter as edgecenter

config = pulumi.Config()
example_domain0 = config.get("exampleDomain0")
if example_domain0 is None:
    example_domain0 = "examplezone.com"
examplezone0 = edgecenter.DnsZone("examplezone0")
example_rrset0 = edgecenter.DnsZoneRecord("exampleRrset0",
    zone=examplezone0.name,
    domain=examplezone0.name,
    type="A",
    ttl=100,
    meta={},
    resource_records=[
        {
            "content": "127.0.0.100",
        },
        {
            "content": "127.0.0.200",
        },
    ])
subdomain_examplezone = edgecenter.DnsZoneRecord("subdomainExamplezone",
    zone="examplezone.com",
    domain="subdomain.examplezone.com",
    type="TXT",
    ttl=10,
    filters=[{
        "type": "geodistance",
        "limit": 1,
        "strict": True,
    }],
    meta={},
    resource_records=[{
        "content": "1234",
        "enabled": True,
        "meta": {
            "latlongs": [
                52.367,
                4.9041,
            ],
            "asns": [12345],
            "ips": ["1.1.1.1"],
            "notes": ["notes"],
            "continents": ["asia"],
            "countries": ["russia"],
            "default": True,
        },
    }])
subdomain_examplezone_mx = edgecenter.DnsZoneRecord("subdomainExamplezoneMx",
    zone="examplezone.com",
    domain="subdomain.examplezone.com",
    type="MX",
    ttl=10,
    meta={},
    resource_records=[{
        "content": "10 mail.my.com.",
        "enabled": True,
    }])
string = "0 issue \"company.org;account=12345\""
subdomain_examplezone_caa = edgecenter.DnsZoneRecord("subdomainExamplezoneCaa",
    zone="examplezone.com",
    domain="subdomain.examplezone.com",
    type="CAA",
    ttl=10,
    meta={},
    resource_records=[{
        "content": string,
        "enabled": True,
    }])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/edgecenter/edgecenter"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		exampleDomain0 := "examplezone.com"
		if param := cfg.Get("exampleDomain0"); param != "" {
			exampleDomain0 = param
		}
		examplezone0, err := edgecenter.NewDnsZone(ctx, "examplezone0", nil)
		if err != nil {
			return err
		}
		_, err = edgecenter.NewDnsZoneRecord(ctx, "exampleRrset0", &edgecenter.DnsZoneRecordArgs{
			Zone:   examplezone0.Name,
			Domain: examplezone0.Name,
			Type:   pulumi.String("A"),
			Ttl:    pulumi.Float64(100),
			Meta:   &edgecenter.DnsZoneRecordMetaArgs{},
			ResourceRecords: edgecenter.DnsZoneRecordResourceRecordArray{
				&edgecenter.DnsZoneRecordResourceRecordArgs{
					Content: pulumi.String("127.0.0.100"),
				},
				&edgecenter.DnsZoneRecordResourceRecordArgs{
					Content: pulumi.String("127.0.0.200"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = edgecenter.NewDnsZoneRecord(ctx, "subdomainExamplezone", &edgecenter.DnsZoneRecordArgs{
			Zone:   pulumi.String("examplezone.com"),
			Domain: pulumi.String("subdomain.examplezone.com"),
			Type:   pulumi.String("TXT"),
			Ttl:    pulumi.Float64(10),
			Filters: edgecenter.DnsZoneRecordFilterArray{
				&edgecenter.DnsZoneRecordFilterArgs{
					Type:   pulumi.String("geodistance"),
					Limit:  pulumi.Float64(1),
					Strict: pulumi.Bool(true),
				},
			},
			Meta: &edgecenter.DnsZoneRecordMetaArgs{},
			ResourceRecords: edgecenter.DnsZoneRecordResourceRecordArray{
				&edgecenter.DnsZoneRecordResourceRecordArgs{
					Content: pulumi.String("1234"),
					Enabled: pulumi.Bool(true),
					Meta: &edgecenter.DnsZoneRecordResourceRecordMetaArgs{
						Latlongs: pulumi.Float64Array{
							pulumi.Float64(52.367),
							pulumi.Float64(4.9041),
						},
						Asns: pulumi.Float64Array{
							pulumi.Float64(12345),
						},
						Ips: pulumi.StringArray{
							pulumi.String("1.1.1.1"),
						},
						Notes: pulumi.StringArray{
							pulumi.String("notes"),
						},
						Continents: pulumi.StringArray{
							pulumi.String("asia"),
						},
						Countries: pulumi.StringArray{
							pulumi.String("russia"),
						},
						Default: pulumi.Bool(true),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = edgecenter.NewDnsZoneRecord(ctx, "subdomainExamplezoneMx", &edgecenter.DnsZoneRecordArgs{
			Zone:   pulumi.String("examplezone.com"),
			Domain: pulumi.String("subdomain.examplezone.com"),
			Type:   pulumi.String("MX"),
			Ttl:    pulumi.Float64(10),
			Meta:   &edgecenter.DnsZoneRecordMetaArgs{},
			ResourceRecords: edgecenter.DnsZoneRecordResourceRecordArray{
				&edgecenter.DnsZoneRecordResourceRecordArgs{
					Content: pulumi.String("10 mail.my.com."),
					Enabled: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		string := "0 issue \"company.org;account=12345\""
		_, err = edgecenter.NewDnsZoneRecord(ctx, "subdomainExamplezoneCaa", &edgecenter.DnsZoneRecordArgs{
			Zone:   pulumi.String("examplezone.com"),
			Domain: pulumi.String("subdomain.examplezone.com"),
			Type:   pulumi.String("CAA"),
			Ttl:    pulumi.Float64(10),
			Meta:   &edgecenter.DnsZoneRecordMetaArgs{},
			ResourceRecords: edgecenter.DnsZoneRecordResourceRecordArray{
				&edgecenter.DnsZoneRecordResourceRecordArgs{
					Content: pulumi.String(string),
					Enabled: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var exampleDomain0 = config.Get("exampleDomain0") ?? "examplezone.com";
    var examplezone0 = new Edgecenter.DnsZone("examplezone0");

    var exampleRrset0 = new Edgecenter.DnsZoneRecord("exampleRrset0", new()
    {
        Zone = examplezone0.Name,
        Domain = examplezone0.Name,
        Type = "A",
        Ttl = 100,
        Meta = null,
        ResourceRecords = new[]
        {
            new Edgecenter.Inputs.DnsZoneRecordResourceRecordArgs
            {
                Content = "127.0.0.100",
            },
            new Edgecenter.Inputs.DnsZoneRecordResourceRecordArgs
            {
                Content = "127.0.0.200",
            },
        },
    });

    var subdomainExamplezone = new Edgecenter.DnsZoneRecord("subdomainExamplezone", new()
    {
        Zone = "examplezone.com",
        Domain = "subdomain.examplezone.com",
        Type = "TXT",
        Ttl = 10,
        Filters = new[]
        {
            new Edgecenter.Inputs.DnsZoneRecordFilterArgs
            {
                Type = "geodistance",
                Limit = 1,
                Strict = true,
            },
        },
        Meta = null,
        ResourceRecords = new[]
        {
            new Edgecenter.Inputs.DnsZoneRecordResourceRecordArgs
            {
                Content = "1234",
                Enabled = true,
                Meta = new Edgecenter.Inputs.DnsZoneRecordResourceRecordMetaArgs
                {
                    Latlongs = new[]
                    {
                        52.367,
                        4.9041,
                    },
                    Asns = new[]
                    {
                        12345,
                    },
                    Ips = new[]
                    {
                        "1.1.1.1",
                    },
                    Notes = new[]
                    {
                        "notes",
                    },
                    Continents = new[]
                    {
                        "asia",
                    },
                    Countries = new[]
                    {
                        "russia",
                    },
                    Default = true,
                },
            },
        },
    });

    var subdomainExamplezoneMx = new Edgecenter.DnsZoneRecord("subdomainExamplezoneMx", new()
    {
        Zone = "examplezone.com",
        Domain = "subdomain.examplezone.com",
        Type = "MX",
        Ttl = 10,
        Meta = null,
        ResourceRecords = new[]
        {
            new Edgecenter.Inputs.DnsZoneRecordResourceRecordArgs
            {
                Content = "10 mail.my.com.",
                Enabled = true,
            },
        },
    });

    var @string = "0 issue \"company.org;account=12345\"";

    var subdomainExamplezoneCaa = new Edgecenter.DnsZoneRecord("subdomainExamplezoneCaa", new()
    {
        Zone = "examplezone.com",
        Domain = "subdomain.examplezone.com",
        Type = "CAA",
        Ttl = 10,
        Meta = null,
        ResourceRecords = new[]
        {
            new Edgecenter.Inputs.DnsZoneRecordResourceRecordArgs
            {
                Content = @string,
                Enabled = true,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.edgecenter.DnsZone;
import com.pulumi.edgecenter.DnsZoneRecord;
import com.pulumi.edgecenter.DnsZoneRecordArgs;
import com.pulumi.edgecenter.inputs.DnsZoneRecordMetaArgs;
import com.pulumi.edgecenter.inputs.DnsZoneRecordResourceRecordArgs;
import com.pulumi.edgecenter.inputs.DnsZoneRecordFilterArgs;
import com.pulumi.edgecenter.inputs.DnsZoneRecordResourceRecordMetaArgs;
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) {
        final var config = ctx.config();
        final var exampleDomain0 = config.get("exampleDomain0").orElse("examplezone.com");
        var examplezone0 = new DnsZone("examplezone0");

        var exampleRrset0 = new DnsZoneRecord("exampleRrset0", DnsZoneRecordArgs.builder()
            .zone(examplezone0.name())
            .domain(examplezone0.name())
            .type("A")
            .ttl(100)
            .meta()
            .resourceRecords(            
                DnsZoneRecordResourceRecordArgs.builder()
                    .content("127.0.0.100")
                    .build(),
                DnsZoneRecordResourceRecordArgs.builder()
                    .content("127.0.0.200")
                    .build())
            .build());

        var subdomainExamplezone = new DnsZoneRecord("subdomainExamplezone", DnsZoneRecordArgs.builder()
            .zone("examplezone.com")
            .domain("subdomain.examplezone.com")
            .type("TXT")
            .ttl(10)
            .filters(DnsZoneRecordFilterArgs.builder()
                .type("geodistance")
                .limit(1)
                .strict(true)
                .build())
            .meta()
            .resourceRecords(DnsZoneRecordResourceRecordArgs.builder()
                .content("1234")
                .enabled(true)
                .meta(DnsZoneRecordResourceRecordMetaArgs.builder()
                    .latlongs(                    
                        52.367,
                        4.9041)
                    .asns(12345)
                    .ips("1.1.1.1")
                    .notes("notes")
                    .continents("asia")
                    .countries("russia")
                    .default_(true)
                    .build())
                .build())
            .build());

        var subdomainExamplezoneMx = new DnsZoneRecord("subdomainExamplezoneMx", DnsZoneRecordArgs.builder()
            .zone("examplezone.com")
            .domain("subdomain.examplezone.com")
            .type("MX")
            .ttl(10)
            .meta()
            .resourceRecords(DnsZoneRecordResourceRecordArgs.builder()
                .content("10 mail.my.com.")
                .enabled(true)
                .build())
            .build());

        final var string = "0 issue \"company.org;account=12345\"";

        var subdomainExamplezoneCaa = new DnsZoneRecord("subdomainExamplezoneCaa", DnsZoneRecordArgs.builder()
            .zone("examplezone.com")
            .domain("subdomain.examplezone.com")
            .type("CAA")
            .ttl(10)
            .meta()
            .resourceRecords(DnsZoneRecordResourceRecordArgs.builder()
                .content(string)
                .enabled(true)
                .build())
            .build());

    }
}

configuration:
  # // example0: managing zone and records by TF using variables
  # //
  exampleDomain0:
    type: string
    default: examplezone.com
resources:
  examplezone0:
    type: edgecenter:DnsZone
  exampleRrset0:
    type: edgecenter:DnsZoneRecord
    properties:
      zone: ${examplezone0.name}
      domain: ${examplezone0.name}
      type: A
      ttl: 100
      meta: {}
      resourceRecords:
        - content: 127.0.0.100
        - content: 127.0.0.200
  subdomainExamplezone:
    type: edgecenter:DnsZoneRecord
    properties:
      zone: examplezone.com
      domain: subdomain.examplezone.com
      type: TXT
      ttl: 10
      filters:
        - type: geodistance
          limit: 1
          strict: true
      meta: {}
      resourceRecords:
        - content: '1234'
          enabled: true
          meta:
            latlongs:
              - 52.367
              - 4.9041
            asns:
              - 12345
            ips:
              - 1.1.1.1
            notes:
              - notes
            continents:
              - asia
            countries:
              - russia
            default: true
  subdomainExamplezoneMx:
    type: edgecenter:DnsZoneRecord
    properties:
      zone: examplezone.com
      domain: subdomain.examplezone.com
      type: MX
      ttl: 10
      meta: {}
      resourceRecords:
        - content: 10 mail.my.com.
          enabled: true
  subdomainExamplezoneCaa:
    type: edgecenter:DnsZoneRecord
    properties:
      zone: examplezone.com
      domain: subdomain.examplezone.com
      type: CAA
      ttl: 10
      meta: {}
      resourceRecords:
        - content: ${string}
          enabled: true
variables:
  string: 0 issue "company.org;account=12345"

var dnsZoneRecordResource = new Edgecenter.DnsZoneRecord("dnsZoneRecordResource", new()
{
    Domain = "string",
    Meta = new Edgecenter.Inputs.DnsZoneRecordMetaArgs
    {
        Failover = new Edgecenter.Inputs.DnsZoneRecordMetaFailoverArgs
        {
            Frequency = 0,
            Protocol = "string",
            Timeout = 0,
            Host = "string",
            HttpStatusCode = 0,
            Method = "string",
            Port = 0,
            Regexp = "string",
            Tls = false,
            Url = "string",
            Verify = false,
        },
    },
    ResourceRecords = new[]
    {
        new Edgecenter.Inputs.DnsZoneRecordResourceRecordArgs
        {
            Content = "string",
            Enabled = false,
            Meta = new Edgecenter.Inputs.DnsZoneRecordResourceRecordMetaArgs
            {
                Asns = new[]
                {
                    0,
                },
                Continents = new[]
                {
                    "string",
                },
                Countries = new[]
                {
                    "string",
                },
                Default = false,
                Ips = new[]
                {
                    "string",
                },
                Latlongs = new[]
                {
                    0,
                },
                Notes = new[]
                {
                    "string",
                },
            },
        },
    },
    Type = "string",
    Zone = "string",
    DnsZoneRecordId = "string",
    Filters = new[]
    {
        new Edgecenter.Inputs.DnsZoneRecordFilterArgs
        {
            Type = "string",
            Limit = 0,
            Strict = false,
        },
    },
    Ttl = 0,
});

example, err := edgecenter.NewDnsZoneRecord(ctx, "dnsZoneRecordResource", &edgecenter.DnsZoneRecordArgs{
	Domain: pulumi.String("string"),
	Meta: &edgecenter.DnsZoneRecordMetaArgs{
		Failover: &edgecenter.DnsZoneRecordMetaFailoverArgs{
			Frequency:      pulumi.Float64(0),
			Protocol:       pulumi.String("string"),
			Timeout:        pulumi.Float64(0),
			Host:           pulumi.String("string"),
			HttpStatusCode: pulumi.Float64(0),
			Method:         pulumi.String("string"),
			Port:           pulumi.Float64(0),
			Regexp:         pulumi.String("string"),
			Tls:            pulumi.Bool(false),
			Url:            pulumi.String("string"),
			Verify:         pulumi.Bool(false),
		},
	},
	ResourceRecords: edgecenter.DnsZoneRecordResourceRecordArray{
		&edgecenter.DnsZoneRecordResourceRecordArgs{
			Content: pulumi.String("string"),
			Enabled: pulumi.Bool(false),
			Meta: &edgecenter.DnsZoneRecordResourceRecordMetaArgs{
				Asns: pulumi.Float64Array{
					pulumi.Float64(0),
				},
				Continents: pulumi.StringArray{
					pulumi.String("string"),
				},
				Countries: pulumi.StringArray{
					pulumi.String("string"),
				},
				Default: pulumi.Bool(false),
				Ips: pulumi.StringArray{
					pulumi.String("string"),
				},
				Latlongs: pulumi.Float64Array{
					pulumi.Float64(0),
				},
				Notes: pulumi.StringArray{
					pulumi.String("string"),
				},
			},
		},
	},
	Type:            pulumi.String("string"),
	Zone:            pulumi.String("string"),
	DnsZoneRecordId: pulumi.String("string"),
	Filters: edgecenter.DnsZoneRecordFilterArray{
		&edgecenter.DnsZoneRecordFilterArgs{
			Type:   pulumi.String("string"),
			Limit:  pulumi.Float64(0),
			Strict: pulumi.Bool(false),
		},
	},
	Ttl: pulumi.Float64(0),
})

var dnsZoneRecordResource = new DnsZoneRecord("dnsZoneRecordResource", DnsZoneRecordArgs.builder()
    .domain("string")
    .meta(DnsZoneRecordMetaArgs.builder()
        .failover(DnsZoneRecordMetaFailoverArgs.builder()
            .frequency(0)
            .protocol("string")
            .timeout(0)
            .host("string")
            .httpStatusCode(0)
            .method("string")
            .port(0)
            .regexp("string")
            .tls(false)
            .url("string")
            .verify(false)
            .build())
        .build())
    .resourceRecords(DnsZoneRecordResourceRecordArgs.builder()
        .content("string")
        .enabled(false)
        .meta(DnsZoneRecordResourceRecordMetaArgs.builder()
            .asns(0)
            .continents("string")
            .countries("string")
            .default_(false)
            .ips("string")
            .latlongs(0)
            .notes("string")
            .build())
        .build())
    .type("string")
    .zone("string")
    .dnsZoneRecordId("string")
    .filters(DnsZoneRecordFilterArgs.builder()
        .type("string")
        .limit(0)
        .strict(false)
        .build())
    .ttl(0)
    .build());

dns_zone_record_resource = edgecenter.DnsZoneRecord("dnsZoneRecordResource",
    domain="string",
    meta={
        "failover": {
            "frequency": 0,
            "protocol": "string",
            "timeout": 0,
            "host": "string",
            "http_status_code": 0,
            "method": "string",
            "port": 0,
            "regexp": "string",
            "tls": False,
            "url": "string",
            "verify": False,
        },
    },
    resource_records=[{
        "content": "string",
        "enabled": False,
        "meta": {
            "asns": [0],
            "continents": ["string"],
            "countries": ["string"],
            "default": False,
            "ips": ["string"],
            "latlongs": [0],
            "notes": ["string"],
        },
    }],
    type="string",
    zone="string",
    dns_zone_record_id="string",
    filters=[{
        "type": "string",
        "limit": 0,
        "strict": False,
    }],
    ttl=0)

const dnsZoneRecordResource = new edgecenter.DnsZoneRecord("dnsZoneRecordResource", {
    domain: "string",
    meta: {
        failover: {
            frequency: 0,
            protocol: "string",
            timeout: 0,
            host: "string",
            httpStatusCode: 0,
            method: "string",
            port: 0,
            regexp: "string",
            tls: false,
            url: "string",
            verify: false,
        },
    },
    resourceRecords: [{
        content: "string",
        enabled: false,
        meta: {
            asns: [0],
            continents: ["string"],
            countries: ["string"],
            "default": false,
            ips: ["string"],
            latlongs: [0],
            notes: ["string"],
        },
    }],
    type: "string",
    zone: "string",
    dnsZoneRecordId: "string",
    filters: [{
        type: "string",
        limit: 0,
        strict: false,
    }],
    ttl: 0,
});

type: edgecenter:DnsZoneRecord
properties:
    dnsZoneRecordId: string
    domain: string
    filters:
        - limit: 0
          strict: false
          type: string
    meta:
        failover:
            frequency: 0
            host: string
            httpStatusCode: 0
            method: string
            port: 0
            protocol: string
            regexp: string
            timeout: 0
            tls: false
            url: string
            verify: false
    resourceRecords:
        - content: string
          enabled: false
          meta:
            asns:
                - 0
            continents:
                - string
            countries:
                - string
            default: false
            ips:
                - string
            latlongs:
                - 0
            notes:
                - string
    ttl: 0
    type: string
    zone: string