azure.cdn.EndpointCustomDomain

using Pulumi;
using Azure = Pulumi.Azure;

class MyStack : Stack
{
    public MyStack()
    {
        var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new Azure.Core.ResourceGroupArgs
        {
            Location = "west europe",
        });
        var exampleAccount = new Azure.Storage.Account("exampleAccount", new Azure.Storage.AccountArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
            AccountTier = "Standard",
            AccountReplicationType = "GRS",
        });
        var exampleProfile = new Azure.Cdn.Profile("exampleProfile", new Azure.Cdn.ProfileArgs
        {
            Location = exampleResourceGroup.Location,
            ResourceGroupName = exampleResourceGroup.Name,
            Sku = "Standard_Verizon",
        });
        var exampleEndpoint = new Azure.Cdn.Endpoint("exampleEndpoint", new Azure.Cdn.EndpointArgs
        {
            ProfileName = exampleProfile.Name,
            Location = exampleResourceGroup.Location,
            ResourceGroupName = exampleResourceGroup.Name,
            Origins = 
            {
                new Azure.Cdn.Inputs.EndpointOriginArgs
                {
                    Name = "example",
                    HostName = exampleAccount.PrimaryBlobHost,
                },
            },
        });
        var exampleZone = Output.Create(Azure.Dns.GetZone.InvokeAsync(new Azure.Dns.GetZoneArgs
        {
            Name = "example-domain.com",
            ResourceGroupName = "domain-rg",
        }));
        var exampleCNameRecord = new Azure.Dns.CNameRecord("exampleCNameRecord", new Azure.Dns.CNameRecordArgs
        {
            ZoneName = exampleZone.Apply(exampleZone => exampleZone.Name),
            ResourceGroupName = exampleZone.Apply(exampleZone => exampleZone.ResourceGroupName),
            Ttl = 3600,
            TargetResourceId = exampleEndpoint.Id,
        });
        var exampleEndpointCustomDomain = new Azure.Cdn.EndpointCustomDomain("exampleEndpointCustomDomain", new Azure.Cdn.EndpointCustomDomainArgs
        {
            CdnEndpointId = exampleEndpoint.Id,
            HostName = Output.Tuple(exampleCNameRecord.Name, exampleZone).Apply(values =>
            {
                var name = values.Item1;
                var exampleZone = values.Item2;
                return $"{name}.{exampleZone.Name}";
            }),
        });
    }

}

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/cdn"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/dns"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("west europe"),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "exampleAccount", &storage.AccountArgs{
			ResourceGroupName:      exampleResourceGroup.Name,
			Location:               exampleResourceGroup.Location,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("GRS"),
		})
		if err != nil {
			return err
		}
		exampleProfile, err := cdn.NewProfile(ctx, "exampleProfile", &cdn.ProfileArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			Sku:               pulumi.String("Standard_Verizon"),
		})
		if err != nil {
			return err
		}
		exampleEndpoint, err := cdn.NewEndpoint(ctx, "exampleEndpoint", &cdn.EndpointArgs{
			ProfileName:       exampleProfile.Name,
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			Origins: cdn.EndpointOriginArray{
				&cdn.EndpointOriginArgs{
					Name:     pulumi.String("example"),
					HostName: exampleAccount.PrimaryBlobHost,
				},
			},
		})
		if err != nil {
			return err
		}
		exampleZone, err := dns.LookupZone(ctx, &dns.LookupZoneArgs{
			Name:              "example-domain.com",
			ResourceGroupName: pulumi.StringRef("domain-rg"),
		}, nil)
		if err != nil {
			return err
		}
		exampleCNameRecord, err := dns.NewCNameRecord(ctx, "exampleCNameRecord", &dns.CNameRecordArgs{
			ZoneName:          pulumi.String(exampleZone.Name),
			ResourceGroupName: pulumi.String(exampleZone.ResourceGroupName),
			Ttl:               pulumi.Int(3600),
			TargetResourceId:  exampleEndpoint.ID(),
		})
		if err != nil {
			return err
		}
		_, err = cdn.NewEndpointCustomDomain(ctx, "exampleEndpointCustomDomain", &cdn.EndpointCustomDomainArgs{
			CdnEndpointId: exampleEndpoint.ID(),
			HostName: exampleCNameRecord.Name.ApplyT(func(name string) (string, error) {
				return fmt.Sprintf("%v%v%v", name, ".", exampleZone.Name), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "west europe"});
const exampleAccount = new azure.storage.Account("exampleAccount", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    accountTier: "Standard",
    accountReplicationType: "GRS",
});
const exampleProfile = new azure.cdn.Profile("exampleProfile", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    sku: "Standard_Verizon",
});
const exampleEndpoint = new azure.cdn.Endpoint("exampleEndpoint", {
    profileName: exampleProfile.name,
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    origins: [{
        name: "example",
        hostName: exampleAccount.primaryBlobHost,
    }],
});
const exampleZone = azure.dns.getZone({
    name: "example-domain.com",
    resourceGroupName: "domain-rg",
});
const exampleCNameRecord = new azure.dns.CNameRecord("exampleCNameRecord", {
    zoneName: exampleZone.then(exampleZone => exampleZone.name),
    resourceGroupName: exampleZone.then(exampleZone => exampleZone.resourceGroupName),
    ttl: 3600,
    targetResourceId: exampleEndpoint.id,
});
const exampleEndpointCustomDomain = new azure.cdn.EndpointCustomDomain("exampleEndpointCustomDomain", {
    cdnEndpointId: exampleEndpoint.id,
    hostName: pulumi.all([exampleCNameRecord.name, exampleZone]).apply(([name, exampleZone]) => `${name}.${exampleZone.name}`),
});

import pulumi
import pulumi_azure as azure

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="west europe")
example_account = azure.storage.Account("exampleAccount",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    account_tier="Standard",
    account_replication_type="GRS")
example_profile = azure.cdn.Profile("exampleProfile",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    sku="Standard_Verizon")
example_endpoint = azure.cdn.Endpoint("exampleEndpoint",
    profile_name=example_profile.name,
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    origins=[azure.cdn.EndpointOriginArgs(
        name="example",
        host_name=example_account.primary_blob_host,
    )])
example_zone = azure.dns.get_zone(name="example-domain.com",
    resource_group_name="domain-rg")
example_c_name_record = azure.dns.CNameRecord("exampleCNameRecord",
    zone_name=example_zone.name,
    resource_group_name=example_zone.resource_group_name,
    ttl=3600,
    target_resource_id=example_endpoint.id)
example_endpoint_custom_domain = azure.cdn.EndpointCustomDomain("exampleEndpointCustomDomain",
    cdn_endpoint_id=example_endpoint.id,
    host_name=example_c_name_record.name.apply(lambda name: f"{name}.{example_zone.name}"))