gcp.siteverification.WebResource

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

const token = gcp.siteverification.getToken({
    type: "INET_DOMAIN",
    identifier: "www.example.com",
    verificationMethod: "DNS_TXT",
});
const example = new gcp.dns.RecordSet("example", {
    managedZone: "example.com",
    name: "www.example.com.",
    type: "TXT",
    rrdatas: [token.then(token => token.token)],
    ttl: 86400,
});
const exampleWebResource = new gcp.siteverification.WebResource("example", {
    site: {
        type: token.then(token => token.type),
        identifier: token.then(token => token.identifier),
    },
    verificationMethod: token.then(token => token.verificationMethod),
}, {
    dependsOn: [example],
});

import pulumi
import pulumi_gcp as gcp

token = gcp.siteverification.get_token(type="INET_DOMAIN",
    identifier="www.example.com",
    verification_method="DNS_TXT")
example = gcp.dns.RecordSet("example",
    managed_zone="example.com",
    name="www.example.com.",
    type="TXT",
    rrdatas=[token.token],
    ttl=86400)
example_web_resource = gcp.siteverification.WebResource("example",
    site={
        "type": token.type,
        "identifier": token.identifier,
    },
    verification_method=token.verification_method,
    opts = pulumi.ResourceOptions(depends_on=[example]))

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/dns"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/siteverification"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		token, err := siteverification.GetToken(ctx, &siteverification.GetTokenArgs{
			Type:               "INET_DOMAIN",
			Identifier:         "www.example.com",
			VerificationMethod: "DNS_TXT",
		}, nil)
		if err != nil {
			return err
		}
		example, err := dns.NewRecordSet(ctx, "example", &dns.RecordSetArgs{
			ManagedZone: pulumi.String("example.com"),
			Name:        pulumi.String("www.example.com."),
			Type:        pulumi.String("TXT"),
			Rrdatas: pulumi.StringArray{
				pulumi.String(token.Token),
			},
			Ttl: pulumi.Int(86400),
		})
		if err != nil {
			return err
		}
		_, err = siteverification.NewWebResource(ctx, "example", &siteverification.WebResourceArgs{
			Site: &siteverification.WebResourceSiteArgs{
				Type:       pulumi.String(token.Type),
				Identifier: pulumi.String(token.Identifier),
			},
			VerificationMethod: pulumi.String(token.VerificationMethod),
		}, pulumi.DependsOn([]pulumi.Resource{
			example,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var token = Gcp.SiteVerification.GetToken.Invoke(new()
    {
        Type = "INET_DOMAIN",
        Identifier = "www.example.com",
        VerificationMethod = "DNS_TXT",
    });

    var example = new Gcp.Dns.RecordSet("example", new()
    {
        ManagedZone = "example.com",
        Name = "www.example.com.",
        Type = "TXT",
        Rrdatas = new[]
        {
            token.Apply(getTokenResult => getTokenResult.Token),
        },
        Ttl = 86400,
    });

    var exampleWebResource = new Gcp.SiteVerification.WebResource("example", new()
    {
        Site = new Gcp.SiteVerification.Inputs.WebResourceSiteArgs
        {
            Type = token.Apply(getTokenResult => getTokenResult.Type),
            Identifier = token.Apply(getTokenResult => getTokenResult.Identifier),
        },
        VerificationMethod = token.Apply(getTokenResult => getTokenResult.VerificationMethod),
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            example,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.siteverification.SiteverificationFunctions;
import com.pulumi.gcp.siteverification.inputs.GetTokenArgs;
import com.pulumi.gcp.dns.RecordSet;
import com.pulumi.gcp.dns.RecordSetArgs;
import com.pulumi.gcp.siteverification.WebResource;
import com.pulumi.gcp.siteverification.WebResourceArgs;
import com.pulumi.gcp.siteverification.inputs.WebResourceSiteArgs;
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) {
        final var token = SiteverificationFunctions.getToken(GetTokenArgs.builder()
            .type("INET_DOMAIN")
            .identifier("www.example.com")
            .verificationMethod("DNS_TXT")
            .build());

        var example = new RecordSet("example", RecordSetArgs.builder()
            .managedZone("example.com")
            .name("www.example.com.")
            .type("TXT")
            .rrdatas(token.applyValue(getTokenResult -> getTokenResult.token()))
            .ttl(86400)
            .build());

        var exampleWebResource = new WebResource("exampleWebResource", WebResourceArgs.builder()
            .site(WebResourceSiteArgs.builder()
                .type(token.applyValue(getTokenResult -> getTokenResult.type()))
                .identifier(token.applyValue(getTokenResult -> getTokenResult.identifier()))
                .build())
            .verificationMethod(token.applyValue(getTokenResult -> getTokenResult.verificationMethod()))
            .build(), CustomResourceOptions.builder()
                .dependsOn(example)
                .build());

    }
}

resources:
  example:
    type: gcp:dns:RecordSet
    properties:
      managedZone: example.com
      name: www.example.com.
      type: TXT
      rrdatas:
        - ${token.token}
      ttl: 86400
  exampleWebResource:
    type: gcp:siteverification:WebResource
    name: example
    properties:
      site:
        type: ${token.type}
        identifier: ${token.identifier}
      verificationMethod: ${token.verificationMethod}
    options:
      dependson:
        - ${example}
variables:
  token:
    fn::invoke:
      Function: gcp:siteverification:getToken
      Arguments:
        type: INET_DOMAIN
        identifier: www.example.com
        verificationMethod: DNS_TXT

var webResourceResource = new Gcp.SiteVerification.WebResource("webResourceResource", new()
{
    Site = new Gcp.SiteVerification.Inputs.WebResourceSiteArgs
    {
        Identifier = "string",
        Type = "string",
    },
    VerificationMethod = "string",
});

example, err := siteverification.NewWebResource(ctx, "webResourceResource", &siteverification.WebResourceArgs{
	Site: &siteverification.WebResourceSiteArgs{
		Identifier: pulumi.String("string"),
		Type:       pulumi.String("string"),
	},
	VerificationMethod: pulumi.String("string"),
})

var webResourceResource = new WebResource("webResourceResource", WebResourceArgs.builder()
    .site(WebResourceSiteArgs.builder()
        .identifier("string")
        .type("string")
        .build())
    .verificationMethod("string")
    .build());

web_resource_resource = gcp.siteverification.WebResource("webResourceResource",
    site={
        "identifier": "string",
        "type": "string",
    },
    verification_method="string")

const webResourceResource = new gcp.siteverification.WebResource("webResourceResource", {
    site: {
        identifier: "string",
        type: "string",
    },
    verificationMethod: "string",
});

type: gcp:siteverification:WebResource
properties:
    site:
        identifier: string
        type: string
    verificationMethod: string