azure.cdn.FrontdoorRule

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

const example = new azure.core.ResourceGroup("example", {
    name: "example-cdn-frontdoor",
    location: "West Europe",
});
const exampleFrontdoorProfile = new azure.cdn.FrontdoorProfile("example", {
    name: "example-profile",
    resourceGroupName: example.name,
    skuName: "Premium_AzureFrontDoor",
});
const exampleFrontdoorEndpoint = new azure.cdn.FrontdoorEndpoint("example", {
    name: "example-endpoint",
    cdnFrontdoorProfileId: exampleFrontdoorProfile.id,
    tags: {
        endpoint: "contoso.com",
    },
});
const exampleFrontdoorOriginGroup = new azure.cdn.FrontdoorOriginGroup("example", {
    name: "example-originGroup",
    cdnFrontdoorProfileId: exampleFrontdoorProfile.id,
    sessionAffinityEnabled: true,
    restoreTrafficTimeToHealedOrNewEndpointInMinutes: 10,
    healthProbe: {
        intervalInSeconds: 240,
        path: "/healthProbe",
        protocol: "Https",
        requestType: "GET",
    },
    loadBalancing: {
        additionalLatencyInMilliseconds: 0,
        sampleSize: 16,
        successfulSamplesRequired: 3,
    },
});
const exampleFrontdoorOrigin = new azure.cdn.FrontdoorOrigin("example", {
    name: "example-origin",
    cdnFrontdoorOriginGroupId: exampleFrontdoorOriginGroup.id,
    enabled: true,
    certificateNameCheckEnabled: false,
    hostName: exampleFrontdoorEndpoint.hostName,
    httpPort: 80,
    httpsPort: 443,
    originHostHeader: "contoso.com",
    priority: 1,
    weight: 500,
});
const exampleFrontdoorRuleSet = new azure.cdn.FrontdoorRuleSet("example", {
    name: "exampleruleset",
    cdnFrontdoorProfileId: exampleFrontdoorProfile.id,
});
const exampleFrontdoorRule = new azure.cdn.FrontdoorRule("example", {
    name: "examplerule",
    cdnFrontdoorRuleSetId: exampleFrontdoorRuleSet.id,
    order: 1,
    behaviorOnMatch: "Continue",
    actions: {
        routeConfigurationOverrideAction: {
            cdnFrontdoorOriginGroupId: exampleFrontdoorOriginGroup.id,
            forwardingProtocol: "HttpsOnly",
            queryStringCachingBehavior: "IncludeSpecifiedQueryStrings",
            queryStringParameters: [
                "foo",
                "clientIp={client_ip}",
            ],
            compressionEnabled: true,
            cacheBehavior: "OverrideIfOriginMissing",
            cacheDuration: "365.23:59:59",
        },
        urlRedirectAction: {
            redirectType: "PermanentRedirect",
            redirectProtocol: "MatchRequest",
            queryString: "clientIp={client_ip}",
            destinationPath: "/exampleredirection",
            destinationHostname: "contoso.com",
            destinationFragment: "UrlRedirect",
        },
    },
    conditions: {
        hostNameConditions: [{
            operator: "Equal",
            negateCondition: false,
            matchValues: [
                "www.contoso.com",
                "images.contoso.com",
                "video.contoso.com",
            ],
            transforms: [
                "Lowercase",
                "Trim",
            ],
        }],
        isDeviceConditions: [{
            operator: "Equal",
            negateCondition: false,
            matchValues: "Mobile",
        }],
        postArgsConditions: [{
            postArgsName: "customerName",
            operator: "BeginsWith",
            matchValues: [
                "J",
                "K",
            ],
            transforms: ["Uppercase"],
        }],
        requestMethodConditions: [{
            operator: "Equal",
            negateCondition: false,
            matchValues: ["DELETE"],
        }],
        urlFilenameConditions: [{
            operator: "Equal",
            negateCondition: false,
            matchValues: ["media.mp4"],
            transforms: [
                "Lowercase",
                "RemoveNulls",
                "Trim",
            ],
        }],
    },
}, {
    dependsOn: [
        exampleFrontdoorOriginGroup,
        exampleFrontdoorOrigin,
    ],
});

import pulumi
import pulumi_azure as azure

example = azure.core.ResourceGroup("example",
    name="example-cdn-frontdoor",
    location="West Europe")
example_frontdoor_profile = azure.cdn.FrontdoorProfile("example",
    name="example-profile",
    resource_group_name=example.name,
    sku_name="Premium_AzureFrontDoor")
example_frontdoor_endpoint = azure.cdn.FrontdoorEndpoint("example",
    name="example-endpoint",
    cdn_frontdoor_profile_id=example_frontdoor_profile.id,
    tags={
        "endpoint": "contoso.com",
    })
example_frontdoor_origin_group = azure.cdn.FrontdoorOriginGroup("example",
    name="example-originGroup",
    cdn_frontdoor_profile_id=example_frontdoor_profile.id,
    session_affinity_enabled=True,
    restore_traffic_time_to_healed_or_new_endpoint_in_minutes=10,
    health_probe={
        "interval_in_seconds": 240,
        "path": "/healthProbe",
        "protocol": "Https",
        "request_type": "GET",
    },
    load_balancing={
        "additional_latency_in_milliseconds": 0,
        "sample_size": 16,
        "successful_samples_required": 3,
    })
example_frontdoor_origin = azure.cdn.FrontdoorOrigin("example",
    name="example-origin",
    cdn_frontdoor_origin_group_id=example_frontdoor_origin_group.id,
    enabled=True,
    certificate_name_check_enabled=False,
    host_name=example_frontdoor_endpoint.host_name,
    http_port=80,
    https_port=443,
    origin_host_header="contoso.com",
    priority=1,
    weight=500)
example_frontdoor_rule_set = azure.cdn.FrontdoorRuleSet("example",
    name="exampleruleset",
    cdn_frontdoor_profile_id=example_frontdoor_profile.id)
example_frontdoor_rule = azure.cdn.FrontdoorRule("example",
    name="examplerule",
    cdn_frontdoor_rule_set_id=example_frontdoor_rule_set.id,
    order=1,
    behavior_on_match="Continue",
    actions={
        "route_configuration_override_action": {
            "cdn_frontdoor_origin_group_id": example_frontdoor_origin_group.id,
            "forwarding_protocol": "HttpsOnly",
            "query_string_caching_behavior": "IncludeSpecifiedQueryStrings",
            "query_string_parameters": [
                "foo",
                "clientIp={client_ip}",
            ],
            "compression_enabled": True,
            "cache_behavior": "OverrideIfOriginMissing",
            "cache_duration": "365.23:59:59",
        },
        "url_redirect_action": {
            "redirect_type": "PermanentRedirect",
            "redirect_protocol": "MatchRequest",
            "query_string": "clientIp={client_ip}",
            "destination_path": "/exampleredirection",
            "destination_hostname": "contoso.com",
            "destination_fragment": "UrlRedirect",
        },
    },
    conditions={
        "host_name_conditions": [{
            "operator": "Equal",
            "negate_condition": False,
            "match_values": [
                "www.contoso.com",
                "images.contoso.com",
                "video.contoso.com",
            ],
            "transforms": [
                "Lowercase",
                "Trim",
            ],
        }],
        "is_device_conditions": [{
            "operator": "Equal",
            "negate_condition": False,
            "match_values": "Mobile",
        }],
        "post_args_conditions": [{
            "post_args_name": "customerName",
            "operator": "BeginsWith",
            "match_values": [
                "J",
                "K",
            ],
            "transforms": ["Uppercase"],
        }],
        "request_method_conditions": [{
            "operator": "Equal",
            "negate_condition": False,
            "match_values": ["DELETE"],
        }],
        "url_filename_conditions": [{
            "operator": "Equal",
            "negate_condition": False,
            "match_values": ["media.mp4"],
            "transforms": [
                "Lowercase",
                "RemoveNulls",
                "Trim",
            ],
        }],
    },
    opts = pulumi.ResourceOptions(depends_on=[
            example_frontdoor_origin_group,
            example_frontdoor_origin,
        ]))

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/cdn"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-cdn-frontdoor"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleFrontdoorProfile, err := cdn.NewFrontdoorProfile(ctx, "example", &cdn.FrontdoorProfileArgs{
			Name:              pulumi.String("example-profile"),
			ResourceGroupName: example.Name,
			SkuName:           pulumi.String("Premium_AzureFrontDoor"),
		})
		if err != nil {
			return err
		}
		exampleFrontdoorEndpoint, err := cdn.NewFrontdoorEndpoint(ctx, "example", &cdn.FrontdoorEndpointArgs{
			Name:                  pulumi.String("example-endpoint"),
			CdnFrontdoorProfileId: exampleFrontdoorProfile.ID(),
			Tags: pulumi.StringMap{
				"endpoint": pulumi.String("contoso.com"),
			},
		})
		if err != nil {
			return err
		}
		exampleFrontdoorOriginGroup, err := cdn.NewFrontdoorOriginGroup(ctx, "example", &cdn.FrontdoorOriginGroupArgs{
			Name:                   pulumi.String("example-originGroup"),
			CdnFrontdoorProfileId:  exampleFrontdoorProfile.ID(),
			SessionAffinityEnabled: pulumi.Bool(true),
			RestoreTrafficTimeToHealedOrNewEndpointInMinutes: pulumi.Int(10),
			HealthProbe: &cdn.FrontdoorOriginGroupHealthProbeArgs{
				IntervalInSeconds: pulumi.Int(240),
				Path:              pulumi.String("/healthProbe"),
				Protocol:          pulumi.String("Https"),
				RequestType:       pulumi.String("GET"),
			},
			LoadBalancing: &cdn.FrontdoorOriginGroupLoadBalancingArgs{
				AdditionalLatencyInMilliseconds: pulumi.Int(0),
				SampleSize:                      pulumi.Int(16),
				SuccessfulSamplesRequired:       pulumi.Int(3),
			},
		})
		if err != nil {
			return err
		}
		exampleFrontdoorOrigin, err := cdn.NewFrontdoorOrigin(ctx, "example", &cdn.FrontdoorOriginArgs{
			Name:                        pulumi.String("example-origin"),
			CdnFrontdoorOriginGroupId:   exampleFrontdoorOriginGroup.ID(),
			Enabled:                     pulumi.Bool(true),
			CertificateNameCheckEnabled: pulumi.Bool(false),
			HostName:                    exampleFrontdoorEndpoint.HostName,
			HttpPort:                    pulumi.Int(80),
			HttpsPort:                   pulumi.Int(443),
			OriginHostHeader:            pulumi.String("contoso.com"),
			Priority:                    pulumi.Int(1),
			Weight:                      pulumi.Int(500),
		})
		if err != nil {
			return err
		}
		exampleFrontdoorRuleSet, err := cdn.NewFrontdoorRuleSet(ctx, "example", &cdn.FrontdoorRuleSetArgs{
			Name:                  pulumi.String("exampleruleset"),
			CdnFrontdoorProfileId: exampleFrontdoorProfile.ID(),
		})
		if err != nil {
			return err
		}
		_, err = cdn.NewFrontdoorRule(ctx, "example", &cdn.FrontdoorRuleArgs{
			Name:                  pulumi.String("examplerule"),
			CdnFrontdoorRuleSetId: exampleFrontdoorRuleSet.ID(),
			Order:                 pulumi.Int(1),
			BehaviorOnMatch:       pulumi.String("Continue"),
			Actions: &cdn.FrontdoorRuleActionsArgs{
				RouteConfigurationOverrideAction: &cdn.FrontdoorRuleActionsRouteConfigurationOverrideActionArgs{
					CdnFrontdoorOriginGroupId:  exampleFrontdoorOriginGroup.ID(),
					ForwardingProtocol:         pulumi.String("HttpsOnly"),
					QueryStringCachingBehavior: pulumi.String("IncludeSpecifiedQueryStrings"),
					QueryStringParameters: pulumi.StringArray{
						pulumi.String("foo"),
						pulumi.String("clientIp={client_ip}"),
					},
					CompressionEnabled: pulumi.Bool(true),
					CacheBehavior:      pulumi.String("OverrideIfOriginMissing"),
					CacheDuration:      pulumi.String("365.23:59:59"),
				},
				UrlRedirectAction: &cdn.FrontdoorRuleActionsUrlRedirectActionArgs{
					RedirectType:        pulumi.String("PermanentRedirect"),
					RedirectProtocol:    pulumi.String("MatchRequest"),
					QueryString:         pulumi.String("clientIp={client_ip}"),
					DestinationPath:     pulumi.String("/exampleredirection"),
					DestinationHostname: pulumi.String("contoso.com"),
					DestinationFragment: pulumi.String("UrlRedirect"),
				},
			},
			Conditions: &cdn.FrontdoorRuleConditionsArgs{
				HostNameConditions: cdn.FrontdoorRuleConditionsHostNameConditionArray{
					&cdn.FrontdoorRuleConditionsHostNameConditionArgs{
						Operator:        pulumi.String("Equal"),
						NegateCondition: pulumi.Bool(false),
						MatchValues: pulumi.StringArray{
							pulumi.String("www.contoso.com"),
							pulumi.String("images.contoso.com"),
							pulumi.String("video.contoso.com"),
						},
						Transforms: pulumi.StringArray{
							pulumi.String("Lowercase"),
							pulumi.String("Trim"),
						},
					},
				},
				IsDeviceConditions: cdn.FrontdoorRuleConditionsIsDeviceConditionArray{
					&cdn.FrontdoorRuleConditionsIsDeviceConditionArgs{
						Operator:        pulumi.String("Equal"),
						NegateCondition: pulumi.Bool(false),
						MatchValues:     pulumi.String("Mobile"),
					},
				},
				PostArgsConditions: cdn.FrontdoorRuleConditionsPostArgsConditionArray{
					&cdn.FrontdoorRuleConditionsPostArgsConditionArgs{
						PostArgsName: pulumi.String("customerName"),
						Operator:     pulumi.String("BeginsWith"),
						MatchValues: pulumi.StringArray{
							pulumi.String("J"),
							pulumi.String("K"),
						},
						Transforms: pulumi.StringArray{
							pulumi.String("Uppercase"),
						},
					},
				},
				RequestMethodConditions: cdn.FrontdoorRuleConditionsRequestMethodConditionArray{
					&cdn.FrontdoorRuleConditionsRequestMethodConditionArgs{
						Operator:        pulumi.String("Equal"),
						NegateCondition: pulumi.Bool(false),
						MatchValues: pulumi.StringArray{
							pulumi.String("DELETE"),
						},
					},
				},
				UrlFilenameConditions: cdn.FrontdoorRuleConditionsUrlFilenameConditionArray{
					&cdn.FrontdoorRuleConditionsUrlFilenameConditionArgs{
						Operator:        pulumi.String("Equal"),
						NegateCondition: pulumi.Bool(false),
						MatchValues: pulumi.StringArray{
							pulumi.String("media.mp4"),
						},
						Transforms: pulumi.StringArray{
							pulumi.String("Lowercase"),
							pulumi.String("RemoveNulls"),
							pulumi.String("Trim"),
						},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleFrontdoorOriginGroup,
			exampleFrontdoorOrigin,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-cdn-frontdoor",
        Location = "West Europe",
    });

    var exampleFrontdoorProfile = new Azure.Cdn.FrontdoorProfile("example", new()
    {
        Name = "example-profile",
        ResourceGroupName = example.Name,
        SkuName = "Premium_AzureFrontDoor",
    });

    var exampleFrontdoorEndpoint = new Azure.Cdn.FrontdoorEndpoint("example", new()
    {
        Name = "example-endpoint",
        CdnFrontdoorProfileId = exampleFrontdoorProfile.Id,
        Tags = 
        {
            { "endpoint", "contoso.com" },
        },
    });

    var exampleFrontdoorOriginGroup = new Azure.Cdn.FrontdoorOriginGroup("example", new()
    {
        Name = "example-originGroup",
        CdnFrontdoorProfileId = exampleFrontdoorProfile.Id,
        SessionAffinityEnabled = true,
        RestoreTrafficTimeToHealedOrNewEndpointInMinutes = 10,
        HealthProbe = new Azure.Cdn.Inputs.FrontdoorOriginGroupHealthProbeArgs
        {
            IntervalInSeconds = 240,
            Path = "/healthProbe",
            Protocol = "Https",
            RequestType = "GET",
        },
        LoadBalancing = new Azure.Cdn.Inputs.FrontdoorOriginGroupLoadBalancingArgs
        {
            AdditionalLatencyInMilliseconds = 0,
            SampleSize = 16,
            SuccessfulSamplesRequired = 3,
        },
    });

    var exampleFrontdoorOrigin = new Azure.Cdn.FrontdoorOrigin("example", new()
    {
        Name = "example-origin",
        CdnFrontdoorOriginGroupId = exampleFrontdoorOriginGroup.Id,
        Enabled = true,
        CertificateNameCheckEnabled = false,
        HostName = exampleFrontdoorEndpoint.HostName,
        HttpPort = 80,
        HttpsPort = 443,
        OriginHostHeader = "contoso.com",
        Priority = 1,
        Weight = 500,
    });

    var exampleFrontdoorRuleSet = new Azure.Cdn.FrontdoorRuleSet("example", new()
    {
        Name = "exampleruleset",
        CdnFrontdoorProfileId = exampleFrontdoorProfile.Id,
    });

    var exampleFrontdoorRule = new Azure.Cdn.FrontdoorRule("example", new()
    {
        Name = "examplerule",
        CdnFrontdoorRuleSetId = exampleFrontdoorRuleSet.Id,
        Order = 1,
        BehaviorOnMatch = "Continue",
        Actions = new Azure.Cdn.Inputs.FrontdoorRuleActionsArgs
        {
            RouteConfigurationOverrideAction = new Azure.Cdn.Inputs.FrontdoorRuleActionsRouteConfigurationOverrideActionArgs
            {
                CdnFrontdoorOriginGroupId = exampleFrontdoorOriginGroup.Id,
                ForwardingProtocol = "HttpsOnly",
                QueryStringCachingBehavior = "IncludeSpecifiedQueryStrings",
                QueryStringParameters = new[]
                {
                    "foo",
                    "clientIp={client_ip}",
                },
                CompressionEnabled = true,
                CacheBehavior = "OverrideIfOriginMissing",
                CacheDuration = "365.23:59:59",
            },
            UrlRedirectAction = new Azure.Cdn.Inputs.FrontdoorRuleActionsUrlRedirectActionArgs
            {
                RedirectType = "PermanentRedirect",
                RedirectProtocol = "MatchRequest",
                QueryString = "clientIp={client_ip}",
                DestinationPath = "/exampleredirection",
                DestinationHostname = "contoso.com",
                DestinationFragment = "UrlRedirect",
            },
        },
        Conditions = new Azure.Cdn.Inputs.FrontdoorRuleConditionsArgs
        {
            HostNameConditions = new[]
            {
                new Azure.Cdn.Inputs.FrontdoorRuleConditionsHostNameConditionArgs
                {
                    Operator = "Equal",
                    NegateCondition = false,
                    MatchValues = new[]
                    {
                        "www.contoso.com",
                        "images.contoso.com",
                        "video.contoso.com",
                    },
                    Transforms = new[]
                    {
                        "Lowercase",
                        "Trim",
                    },
                },
            },
            IsDeviceConditions = new[]
            {
                new Azure.Cdn.Inputs.FrontdoorRuleConditionsIsDeviceConditionArgs
                {
                    Operator = "Equal",
                    NegateCondition = false,
                    MatchValues = "Mobile",
                },
            },
            PostArgsConditions = new[]
            {
                new Azure.Cdn.Inputs.FrontdoorRuleConditionsPostArgsConditionArgs
                {
                    PostArgsName = "customerName",
                    Operator = "BeginsWith",
                    MatchValues = new[]
                    {
                        "J",
                        "K",
                    },
                    Transforms = new[]
                    {
                        "Uppercase",
                    },
                },
            },
            RequestMethodConditions = new[]
            {
                new Azure.Cdn.Inputs.FrontdoorRuleConditionsRequestMethodConditionArgs
                {
                    Operator = "Equal",
                    NegateCondition = false,
                    MatchValues = new[]
                    {
                        "DELETE",
                    },
                },
            },
            UrlFilenameConditions = new[]
            {
                new Azure.Cdn.Inputs.FrontdoorRuleConditionsUrlFilenameConditionArgs
                {
                    Operator = "Equal",
                    NegateCondition = false,
                    MatchValues = new[]
                    {
                        "media.mp4",
                    },
                    Transforms = new[]
                    {
                        "Lowercase",
                        "RemoveNulls",
                        "Trim",
                    },
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleFrontdoorOriginGroup,
            exampleFrontdoorOrigin,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.cdn.FrontdoorProfile;
import com.pulumi.azure.cdn.FrontdoorProfileArgs;
import com.pulumi.azure.cdn.FrontdoorEndpoint;
import com.pulumi.azure.cdn.FrontdoorEndpointArgs;
import com.pulumi.azure.cdn.FrontdoorOriginGroup;
import com.pulumi.azure.cdn.FrontdoorOriginGroupArgs;
import com.pulumi.azure.cdn.inputs.FrontdoorOriginGroupHealthProbeArgs;
import com.pulumi.azure.cdn.inputs.FrontdoorOriginGroupLoadBalancingArgs;
import com.pulumi.azure.cdn.FrontdoorOrigin;
import com.pulumi.azure.cdn.FrontdoorOriginArgs;
import com.pulumi.azure.cdn.FrontdoorRuleSet;
import com.pulumi.azure.cdn.FrontdoorRuleSetArgs;
import com.pulumi.azure.cdn.FrontdoorRule;
import com.pulumi.azure.cdn.FrontdoorRuleArgs;
import com.pulumi.azure.cdn.inputs.FrontdoorRuleActionsArgs;
import com.pulumi.azure.cdn.inputs.FrontdoorRuleActionsRouteConfigurationOverrideActionArgs;
import com.pulumi.azure.cdn.inputs.FrontdoorRuleActionsUrlRedirectActionArgs;
import com.pulumi.azure.cdn.inputs.FrontdoorRuleConditionsArgs;
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 ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-cdn-frontdoor")
            .location("West Europe")
            .build());

        var exampleFrontdoorProfile = new FrontdoorProfile("exampleFrontdoorProfile", FrontdoorProfileArgs.builder()
            .name("example-profile")
            .resourceGroupName(example.name())
            .skuName("Premium_AzureFrontDoor")
            .build());

        var exampleFrontdoorEndpoint = new FrontdoorEndpoint("exampleFrontdoorEndpoint", FrontdoorEndpointArgs.builder()
            .name("example-endpoint")
            .cdnFrontdoorProfileId(exampleFrontdoorProfile.id())
            .tags(Map.of("endpoint", "contoso.com"))
            .build());

        var exampleFrontdoorOriginGroup = new FrontdoorOriginGroup("exampleFrontdoorOriginGroup", FrontdoorOriginGroupArgs.builder()
            .name("example-originGroup")
            .cdnFrontdoorProfileId(exampleFrontdoorProfile.id())
            .sessionAffinityEnabled(true)
            .restoreTrafficTimeToHealedOrNewEndpointInMinutes(10)
            .healthProbe(FrontdoorOriginGroupHealthProbeArgs.builder()
                .intervalInSeconds(240)
                .path("/healthProbe")
                .protocol("Https")
                .requestType("GET")
                .build())
            .loadBalancing(FrontdoorOriginGroupLoadBalancingArgs.builder()
                .additionalLatencyInMilliseconds(0)
                .sampleSize(16)
                .successfulSamplesRequired(3)
                .build())
            .build());

        var exampleFrontdoorOrigin = new FrontdoorOrigin("exampleFrontdoorOrigin", FrontdoorOriginArgs.builder()
            .name("example-origin")
            .cdnFrontdoorOriginGroupId(exampleFrontdoorOriginGroup.id())
            .enabled(true)
            .certificateNameCheckEnabled(false)
            .hostName(exampleFrontdoorEndpoint.hostName())
            .httpPort(80)
            .httpsPort(443)
            .originHostHeader("contoso.com")
            .priority(1)
            .weight(500)
            .build());

        var exampleFrontdoorRuleSet = new FrontdoorRuleSet("exampleFrontdoorRuleSet", FrontdoorRuleSetArgs.builder()
            .name("exampleruleset")
            .cdnFrontdoorProfileId(exampleFrontdoorProfile.id())
            .build());

        var exampleFrontdoorRule = new FrontdoorRule("exampleFrontdoorRule", FrontdoorRuleArgs.builder()
            .name("examplerule")
            .cdnFrontdoorRuleSetId(exampleFrontdoorRuleSet.id())
            .order(1)
            .behaviorOnMatch("Continue")
            .actions(FrontdoorRuleActionsArgs.builder()
                .routeConfigurationOverrideAction(FrontdoorRuleActionsRouteConfigurationOverrideActionArgs.builder()
                    .cdnFrontdoorOriginGroupId(exampleFrontdoorOriginGroup.id())
                    .forwardingProtocol("HttpsOnly")
                    .queryStringCachingBehavior("IncludeSpecifiedQueryStrings")
                    .queryStringParameters(                    
                        "foo",
                        "clientIp={client_ip}")
                    .compressionEnabled(true)
                    .cacheBehavior("OverrideIfOriginMissing")
                    .cacheDuration("365.23:59:59")
                    .build())
                .urlRedirectAction(FrontdoorRuleActionsUrlRedirectActionArgs.builder()
                    .redirectType("PermanentRedirect")
                    .redirectProtocol("MatchRequest")
                    .queryString("clientIp={client_ip}")
                    .destinationPath("/exampleredirection")
                    .destinationHostname("contoso.com")
                    .destinationFragment("UrlRedirect")
                    .build())
                .build())
            .conditions(FrontdoorRuleConditionsArgs.builder()
                .hostNameConditions(FrontdoorRuleConditionsHostNameConditionArgs.builder()
                    .operator("Equal")
                    .negateCondition(false)
                    .matchValues(                    
                        "www.contoso.com",
                        "images.contoso.com",
                        "video.contoso.com")
                    .transforms(                    
                        "Lowercase",
                        "Trim")
                    .build())
                .isDeviceConditions(FrontdoorRuleConditionsIsDeviceConditionArgs.builder()
                    .operator("Equal")
                    .negateCondition(false)
                    .matchValues("Mobile")
                    .build())
                .postArgsConditions(FrontdoorRuleConditionsPostArgsConditionArgs.builder()
                    .postArgsName("customerName")
                    .operator("BeginsWith")
                    .matchValues(                    
                        "J",
                        "K")
                    .transforms("Uppercase")
                    .build())
                .requestMethodConditions(FrontdoorRuleConditionsRequestMethodConditionArgs.builder()
                    .operator("Equal")
                    .negateCondition(false)
                    .matchValues("DELETE")
                    .build())
                .urlFilenameConditions(FrontdoorRuleConditionsUrlFilenameConditionArgs.builder()
                    .operator("Equal")
                    .negateCondition(false)
                    .matchValues("media.mp4")
                    .transforms(                    
                        "Lowercase",
                        "RemoveNulls",
                        "Trim")
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    exampleFrontdoorOriginGroup,
                    exampleFrontdoorOrigin)
                .build());

    }
}

resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-cdn-frontdoor
      location: West Europe
  exampleFrontdoorProfile:
    type: azure:cdn:FrontdoorProfile
    name: example
    properties:
      name: example-profile
      resourceGroupName: ${example.name}
      skuName: Premium_AzureFrontDoor
  exampleFrontdoorEndpoint:
    type: azure:cdn:FrontdoorEndpoint
    name: example
    properties:
      name: example-endpoint
      cdnFrontdoorProfileId: ${exampleFrontdoorProfile.id}
      tags:
        endpoint: contoso.com
  exampleFrontdoorOriginGroup:
    type: azure:cdn:FrontdoorOriginGroup
    name: example
    properties:
      name: example-originGroup
      cdnFrontdoorProfileId: ${exampleFrontdoorProfile.id}
      sessionAffinityEnabled: true
      restoreTrafficTimeToHealedOrNewEndpointInMinutes: 10
      healthProbe:
        intervalInSeconds: 240
        path: /healthProbe
        protocol: Https
        requestType: GET
      loadBalancing:
        additionalLatencyInMilliseconds: 0
        sampleSize: 16
        successfulSamplesRequired: 3
  exampleFrontdoorOrigin:
    type: azure:cdn:FrontdoorOrigin
    name: example
    properties:
      name: example-origin
      cdnFrontdoorOriginGroupId: ${exampleFrontdoorOriginGroup.id}
      enabled: true
      certificateNameCheckEnabled: false
      hostName: ${exampleFrontdoorEndpoint.hostName}
      httpPort: 80
      httpsPort: 443
      originHostHeader: contoso.com
      priority: 1
      weight: 500
  exampleFrontdoorRuleSet:
    type: azure:cdn:FrontdoorRuleSet
    name: example
    properties:
      name: exampleruleset
      cdnFrontdoorProfileId: ${exampleFrontdoorProfile.id}
  exampleFrontdoorRule:
    type: azure:cdn:FrontdoorRule
    name: example
    properties:
      name: examplerule
      cdnFrontdoorRuleSetId: ${exampleFrontdoorRuleSet.id}
      order: 1
      behaviorOnMatch: Continue
      actions:
        routeConfigurationOverrideAction:
          cdnFrontdoorOriginGroupId: ${exampleFrontdoorOriginGroup.id}
          forwardingProtocol: HttpsOnly
          queryStringCachingBehavior: IncludeSpecifiedQueryStrings
          queryStringParameters:
            - foo
            - clientIp={client_ip}
          compressionEnabled: true
          cacheBehavior: OverrideIfOriginMissing
          cacheDuration: 365.23:59:59
        urlRedirectAction:
          redirectType: PermanentRedirect
          redirectProtocol: MatchRequest
          queryString: clientIp={client_ip}
          destinationPath: /exampleredirection
          destinationHostname: contoso.com
          destinationFragment: UrlRedirect
      conditions:
        hostNameConditions:
          - operator: Equal
            negateCondition: false
            matchValues:
              - www.contoso.com
              - images.contoso.com
              - video.contoso.com
            transforms:
              - Lowercase
              - Trim
        isDeviceConditions:
          - operator: Equal
            negateCondition: false
            matchValues: Mobile
        postArgsConditions:
          - postArgsName: customerName
            operator: BeginsWith
            matchValues:
              - J
              - K
            transforms:
              - Uppercase
        requestMethodConditions:
          - operator: Equal
            negateCondition: false
            matchValues:
              - DELETE
        urlFilenameConditions:
          - operator: Equal
            negateCondition: false
            matchValues:
              - media.mp4
            transforms:
              - Lowercase
              - RemoveNulls
              - Trim
    options:
      dependsOn:
        - ${exampleFrontdoorOriginGroup}
        - ${exampleFrontdoorOrigin}

var frontdoorRuleResource = new Azure.Cdn.FrontdoorRule("frontdoorRuleResource", new()
{
    Actions = new Azure.Cdn.Inputs.FrontdoorRuleActionsArgs
    {
        RequestHeaderActions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleActionsRequestHeaderActionArgs
            {
                HeaderAction = "string",
                HeaderName = "string",
                Value = "string",
            },
        },
        ResponseHeaderActions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleActionsResponseHeaderActionArgs
            {
                HeaderAction = "string",
                HeaderName = "string",
                Value = "string",
            },
        },
        RouteConfigurationOverrideAction = new Azure.Cdn.Inputs.FrontdoorRuleActionsRouteConfigurationOverrideActionArgs
        {
            CacheBehavior = "string",
            CacheDuration = "string",
            CdnFrontdoorOriginGroupId = "string",
            CompressionEnabled = false,
            ForwardingProtocol = "string",
            QueryStringCachingBehavior = "string",
            QueryStringParameters = new[]
            {
                "string",
            },
        },
        UrlRedirectAction = new Azure.Cdn.Inputs.FrontdoorRuleActionsUrlRedirectActionArgs
        {
            DestinationHostname = "string",
            RedirectType = "string",
            DestinationFragment = "string",
            DestinationPath = "string",
            QueryString = "string",
            RedirectProtocol = "string",
        },
        UrlRewriteAction = new Azure.Cdn.Inputs.FrontdoorRuleActionsUrlRewriteActionArgs
        {
            Destination = "string",
            SourcePattern = "string",
            PreserveUnmatchedPath = false,
        },
    },
    CdnFrontdoorRuleSetId = "string",
    Order = 0,
    BehaviorOnMatch = "string",
    Conditions = new Azure.Cdn.Inputs.FrontdoorRuleConditionsArgs
    {
        ClientPortConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsClientPortConditionArgs
            {
                Operator = "string",
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
            },
        },
        CookiesConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsCookiesConditionArgs
            {
                CookieName = "string",
                Operator = "string",
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Transforms = new[]
                {
                    "string",
                },
            },
        },
        HostNameConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsHostNameConditionArgs
            {
                Operator = "string",
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Transforms = new[]
                {
                    "string",
                },
            },
        },
        HttpVersionConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsHttpVersionConditionArgs
            {
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Operator = "string",
            },
        },
        IsDeviceConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsIsDeviceConditionArgs
            {
                MatchValues = "string",
                NegateCondition = false,
                Operator = "string",
            },
        },
        PostArgsConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsPostArgsConditionArgs
            {
                Operator = "string",
                PostArgsName = "string",
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Transforms = new[]
                {
                    "string",
                },
            },
        },
        QueryStringConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsQueryStringConditionArgs
            {
                Operator = "string",
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Transforms = new[]
                {
                    "string",
                },
            },
        },
        RemoteAddressConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsRemoteAddressConditionArgs
            {
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Operator = "string",
            },
        },
        RequestBodyConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsRequestBodyConditionArgs
            {
                MatchValues = new[]
                {
                    "string",
                },
                Operator = "string",
                NegateCondition = false,
                Transforms = new[]
                {
                    "string",
                },
            },
        },
        RequestHeaderConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsRequestHeaderConditionArgs
            {
                HeaderName = "string",
                Operator = "string",
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Transforms = new[]
                {
                    "string",
                },
            },
        },
        RequestMethodConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsRequestMethodConditionArgs
            {
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Operator = "string",
            },
        },
        RequestSchemeConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsRequestSchemeConditionArgs
            {
                MatchValues = "string",
                NegateCondition = false,
                Operator = "string",
            },
        },
        RequestUriConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsRequestUriConditionArgs
            {
                Operator = "string",
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Transforms = new[]
                {
                    "string",
                },
            },
        },
        ServerPortConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsServerPortConditionArgs
            {
                MatchValues = new[]
                {
                    "string",
                },
                Operator = "string",
                NegateCondition = false,
            },
        },
        SocketAddressConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsSocketAddressConditionArgs
            {
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Operator = "string",
            },
        },
        SslProtocolConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsSslProtocolConditionArgs
            {
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Operator = "string",
            },
        },
        UrlFileExtensionConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsUrlFileExtensionConditionArgs
            {
                MatchValues = new[]
                {
                    "string",
                },
                Operator = "string",
                NegateCondition = false,
                Transforms = new[]
                {
                    "string",
                },
            },
        },
        UrlFilenameConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsUrlFilenameConditionArgs
            {
                Operator = "string",
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Transforms = new[]
                {
                    "string",
                },
            },
        },
        UrlPathConditions = new[]
        {
            new Azure.Cdn.Inputs.FrontdoorRuleConditionsUrlPathConditionArgs
            {
                Operator = "string",
                MatchValues = new[]
                {
                    "string",
                },
                NegateCondition = false,
                Transforms = new[]
                {
                    "string",
                },
            },
        },
    },
    Name = "string",
});