Policies - Create Or Update

Usługa:

Front Door Service

Wersja interfejsu API:

2024-02-01

Twórca lub zaktualizuj zasady o określonej nazwie zestawu reguł w grupie zasobów.

PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/FrontDoorWebApplicationFirewallPolicies/{policyName}?api-version=2024-02-01

Parametry identyfikatora URI

Nazwa	W	Wymagane	Typ	Opis
policyName	path	True	string	Nazwa zasad Web Application Firewall.
resourceGroupName	path	True	string	Nazwa grupy zasobów w ramach subskrypcji platformy Azure. Wzorzec wyrażenia regularnego: ^[a-zA-Z0-9_\-\(\)\.]*[^\.]$
subscriptionId	path	True	string	Poświadczenia subskrypcji, które jednoznacznie identyfikują subskrypcję platformy Microsoft Azure. Identyfikator subskrypcji stanowi część identyfikatora URI dla każdego wywołania usługi.
api-version	query	True	string	Wersja interfejsu API klienta.

Treść żądania

Nazwa	Typ	Opis
etag	string	Pobiera unikatowy ciąg tylko do odczytu, który zmienia się za każdym razem, gdy zasób jest aktualizowany.
location	string	Lokalizacja zasobu.
properties.customRules	CustomRuleList	Opisuje reguły niestandardowe wewnątrz zasad.
properties.managedRules	ManagedRuleSetList	Opisuje reguły zarządzane wewnątrz zasad.
properties.policySettings	PolicySettings	Opisuje ustawienia zasad.
sku	Sku	Warstwa cenowa zasad zapory aplikacji internetowej. Wartość domyślna to Classic_AzureFrontDoor, jeśli nie zostanie określona.
tags	object	Tagi zasobów.

Odpowiedzi

Nazwa	Typ	Opis
200 OK	WebApplicationFirewallPolicy	OK. Żądanie zakończyło się pomyślnie.
201 Created	WebApplicationFirewallPolicy	Utworzone. Żądanie zostało spełnione i utworzono nowe zasady ochrony.
202 Accepted	WebApplicationFirewallPolicy	Akceptowane. Żądanie zostało zaakceptowane do przetwarzania, a operacja zostanie ukończona asynchronicznie.
Other Status Codes	ErrorResponse	Odpowiedź na błąd opisująca, dlaczego operacja nie powiodła się.

Zabezpieczenia

azure_auth

Przepływ OAuth2 usługi Azure Active Directory

Typ: oauth2
Flow: implicit
Adres URL autoryzacji: https://login.microsoftonline.com/common/oauth2/authorize

Zakresy

Nazwa	Opis
user_impersonation	personifikacja konta użytkownika

Przykłady

Creates specific policy

Przykładowe żądanie

HTTP

PUT https://management.azure.com/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/FrontDoorWebApplicationFirewallPolicies/Policy1?api-version=2024-02-01

{
  "location": "WestUs",
  "properties": {
    "policySettings": {
      "enabledState": "Enabled",
      "mode": "Prevention",
      "redirectUrl": "http://www.bing.com",
      "customBlockResponseStatusCode": 429,
      "customBlockResponseBody": "PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg==",
      "requestBodyCheck": "Disabled",
      "javascriptChallengeExpirationInMinutes": 30,
      "logScrubbing": {
        "state": "Enabled",
        "scrubbingRules": [
          {
            "matchVariable": "RequestIPAddress",
            "selectorMatchOperator": "EqualsAny",
            "selector": null,
            "state": "Enabled"
          }
        ]
      }
    },
    "customRules": {
      "rules": [
        {
          "name": "Rule1",
          "priority": 1,
          "ruleType": "RateLimitRule",
          "rateLimitThreshold": 1000,
          "matchConditions": [
            {
              "matchVariable": "RemoteAddr",
              "operator": "IPMatch",
              "matchValue": [
                "192.168.1.0/24",
                "10.0.0.0/24"
              ]
            }
          ],
          "action": "Block"
        },
        {
          "name": "Rule2",
          "priority": 2,
          "ruleType": "MatchRule",
          "matchConditions": [
            {
              "matchVariable": "RemoteAddr",
              "operator": "GeoMatch",
              "matchValue": [
                "CH"
              ]
            },
            {
              "matchVariable": "RequestHeader",
              "operator": "Contains",
              "selector": "UserAgent",
              "matchValue": [
                "windows"
              ],
              "transforms": [
                "Lowercase"
              ]
            }
          ],
          "action": "Block"
        }
      ]
    },
    "managedRules": {
      "managedRuleSets": [
        {
          "ruleSetType": "DefaultRuleSet",
          "ruleSetVersion": "1.0",
          "ruleSetAction": "Block",
          "exclusions": [
            {
              "matchVariable": "RequestHeaderNames",
              "selectorMatchOperator": "Equals",
              "selector": "User-Agent"
            }
          ],
          "ruleGroupOverrides": [
            {
              "ruleGroupName": "SQLI",
              "exclusions": [
                {
                  "matchVariable": "RequestCookieNames",
                  "selectorMatchOperator": "StartsWith",
                  "selector": "token"
                }
              ],
              "rules": [
                {
                  "ruleId": "942100",
                  "enabledState": "Enabled",
                  "action": "Redirect",
                  "exclusions": [
                    {
                      "matchVariable": "QueryStringArgNames",
                      "selectorMatchOperator": "Equals",
                      "selector": "query"
                    }
                  ]
                },
                {
                  "ruleId": "942110",
                  "enabledState": "Disabled"
                }
              ]
            }
          ]
        }
      ]
    }
  },
  "sku": {
    "name": "Premium_AzureFrontDoor"
  }
}

Java

import com.azure.resourcemanager.frontdoor.models.ActionType;
import com.azure.resourcemanager.frontdoor.models.CustomRule;
import com.azure.resourcemanager.frontdoor.models.CustomRuleList;
import com.azure.resourcemanager.frontdoor.models.ManagedRuleEnabledState;
import com.azure.resourcemanager.frontdoor.models.ManagedRuleExclusion;
import com.azure.resourcemanager.frontdoor.models.ManagedRuleExclusionMatchVariable;
import com.azure.resourcemanager.frontdoor.models.ManagedRuleExclusionSelectorMatchOperator;
import com.azure.resourcemanager.frontdoor.models.ManagedRuleGroupOverride;
import com.azure.resourcemanager.frontdoor.models.ManagedRuleOverride;
import com.azure.resourcemanager.frontdoor.models.ManagedRuleSet;
import com.azure.resourcemanager.frontdoor.models.ManagedRuleSetActionType;
import com.azure.resourcemanager.frontdoor.models.ManagedRuleSetList;
import com.azure.resourcemanager.frontdoor.models.MatchCondition;
import com.azure.resourcemanager.frontdoor.models.MatchVariable;
import com.azure.resourcemanager.frontdoor.models.Operator;
import com.azure.resourcemanager.frontdoor.models.PolicyEnabledState;
import com.azure.resourcemanager.frontdoor.models.PolicyMode;
import com.azure.resourcemanager.frontdoor.models.PolicyRequestBodyCheck;
import com.azure.resourcemanager.frontdoor.models.PolicySettings;
import com.azure.resourcemanager.frontdoor.models.RuleType;
import com.azure.resourcemanager.frontdoor.models.ScrubbingRuleEntryMatchOperator;
import com.azure.resourcemanager.frontdoor.models.ScrubbingRuleEntryMatchVariable;
import com.azure.resourcemanager.frontdoor.models.ScrubbingRuleEntryState;
import com.azure.resourcemanager.frontdoor.models.Sku;
import com.azure.resourcemanager.frontdoor.models.SkuName;
import com.azure.resourcemanager.frontdoor.models.TransformType;
import com.azure.resourcemanager.frontdoor.models.WebApplicationFirewallScrubbingRules;
import com.azure.resourcemanager.frontdoor.models.WebApplicationFirewallScrubbingState;
import java.util.Arrays;

/**
 * Samples for Policies CreateOrUpdate.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/frontdoor/resource-manager/Microsoft.Network/stable/2024-02-01/examples/WafPolicyCreateOrUpdate.
     * json
     */
    /**
     * Sample code: Creates specific policy.
     * 
     * @param manager Entry point to FrontDoorManager.
     */
    public static void createsSpecificPolicy(com.azure.resourcemanager.frontdoor.FrontDoorManager manager) {
        manager.policies().define("Policy1").withRegion("WestUs").withExistingResourceGroup("rg1")
            .withSku(new Sku().withName(SkuName.PREMIUM_AZURE_FRONT_DOOR))
            .withPolicySettings(new PolicySettings().withEnabledState(PolicyEnabledState.ENABLED)
                .withMode(PolicyMode.PREVENTION).withRedirectUrl("http://www.bing.com")
                .withCustomBlockResponseStatusCode(429)
                .withCustomBlockResponseBody(
                    "PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg==")
                .withRequestBodyCheck(
                    PolicyRequestBodyCheck.DISABLED)
                .withJavascriptChallengeExpirationInMinutes(30).withState(WebApplicationFirewallScrubbingState.ENABLED)
                .withScrubbingRules(Arrays.asList(new WebApplicationFirewallScrubbingRules()
                    .withMatchVariable(ScrubbingRuleEntryMatchVariable.REQUEST_IPADDRESS)
                    .withSelectorMatchOperator(ScrubbingRuleEntryMatchOperator.EQUALS_ANY)
                    .withState(ScrubbingRuleEntryState.ENABLED))))
            .withCustomRules(new CustomRuleList().withRules(Arrays.asList(
                new CustomRule().withName("Rule1").withPriority(1).withRuleType(RuleType.RATE_LIMIT_RULE)
                    .withRateLimitThreshold(1000)
                    .withMatchConditions(Arrays.asList(new MatchCondition().withMatchVariable(MatchVariable.REMOTE_ADDR)
                        .withOperator(Operator.IPMATCH).withMatchValue(Arrays.asList("192.168.1.0/24", "10.0.0.0/24"))))
                    .withAction(ActionType.BLOCK),
                new CustomRule().withName("Rule2").withPriority(2).withRuleType(RuleType.MATCH_RULE)
                    .withMatchConditions(Arrays.asList(
                        new MatchCondition().withMatchVariable(MatchVariable.REMOTE_ADDR)
                            .withOperator(Operator.GEO_MATCH).withMatchValue(Arrays.asList("CH")),
                        new MatchCondition().withMatchVariable(MatchVariable.REQUEST_HEADER).withSelector("UserAgent")
                            .withOperator(Operator.CONTAINS).withMatchValue(Arrays.asList("windows"))
                            .withTransforms(Arrays.asList(TransformType.LOWERCASE))))
                    .withAction(ActionType.BLOCK))))
            .withManagedRules(new ManagedRuleSetList()
                .withManagedRuleSets(Arrays.asList(new ManagedRuleSet().withRuleSetType("DefaultRuleSet")
                    .withRuleSetVersion("1.0").withRuleSetAction(ManagedRuleSetActionType.BLOCK)
                    .withExclusions(Arrays.asList(new ManagedRuleExclusion()
                        .withMatchVariable(ManagedRuleExclusionMatchVariable.REQUEST_HEADER_NAMES)
                        .withSelectorMatchOperator(ManagedRuleExclusionSelectorMatchOperator.EQUALS)
                        .withSelector("User-Agent")))
                    .withRuleGroupOverrides(
                        Arrays.asList(new ManagedRuleGroupOverride().withRuleGroupName("SQLI")
                            .withExclusions(Arrays.asList(new ManagedRuleExclusion()
                                .withMatchVariable(ManagedRuleExclusionMatchVariable.REQUEST_COOKIE_NAMES)
                                .withSelectorMatchOperator(ManagedRuleExclusionSelectorMatchOperator.STARTS_WITH)
                                .withSelector("token")))
                            .withRules(
                                Arrays
                                    .asList(
                                        new ManagedRuleOverride().withRuleId("942100")
                                            .withEnabledState(ManagedRuleEnabledState.ENABLED)
                                            .withAction(ActionType.REDIRECT)
                                            .withExclusions(Arrays.asList(new ManagedRuleExclusion()
                                                .withMatchVariable(
                                                    ManagedRuleExclusionMatchVariable.QUERY_STRING_ARG_NAMES)
                                                .withSelectorMatchOperator(
                                                    ManagedRuleExclusionSelectorMatchOperator.EQUALS)
                                                .withSelector("query"))),
                                        new ManagedRuleOverride().withRuleId("942110")
                                            .withEnabledState(ManagedRuleEnabledState.DISABLED))))))))
            .create();
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Go

package armfrontdoor_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/frontdoor/armfrontdoor"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/b54ffc9278eff071455b1dbb4ad2e772afce885d/specification/frontdoor/resource-manager/Microsoft.Network/stable/2024-02-01/examples/WafPolicyCreateOrUpdate.json
func ExamplePoliciesClient_BeginCreateOrUpdate() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfrontdoor.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewPoliciesClient().BeginCreateOrUpdate(ctx, "rg1", "Policy1", armfrontdoor.WebApplicationFirewallPolicy{
		Location: to.Ptr("WestUs"),
		Properties: &armfrontdoor.WebApplicationFirewallPolicyProperties{
			CustomRules: &armfrontdoor.CustomRuleList{
				Rules: []*armfrontdoor.CustomRule{
					{
						Name:   to.Ptr("Rule1"),
						Action: to.Ptr(armfrontdoor.ActionTypeBlock),
						MatchConditions: []*armfrontdoor.MatchCondition{
							{
								MatchValue: []*string{
									to.Ptr("192.168.1.0/24"),
									to.Ptr("10.0.0.0/24")},
								MatchVariable: to.Ptr(armfrontdoor.MatchVariableRemoteAddr),
								Operator:      to.Ptr(armfrontdoor.OperatorIPMatch),
							}},
						Priority:           to.Ptr[int32](1),
						RateLimitThreshold: to.Ptr[int32](1000),
						RuleType:           to.Ptr(armfrontdoor.RuleTypeRateLimitRule),
					},
					{
						Name:   to.Ptr("Rule2"),
						Action: to.Ptr(armfrontdoor.ActionTypeBlock),
						MatchConditions: []*armfrontdoor.MatchCondition{
							{
								MatchValue: []*string{
									to.Ptr("CH")},
								MatchVariable: to.Ptr(armfrontdoor.MatchVariableRemoteAddr),
								Operator:      to.Ptr(armfrontdoor.OperatorGeoMatch),
							},
							{
								MatchValue: []*string{
									to.Ptr("windows")},
								MatchVariable: to.Ptr(armfrontdoor.MatchVariableRequestHeader),
								Operator:      to.Ptr(armfrontdoor.OperatorContains),
								Selector:      to.Ptr("UserAgent"),
								Transforms: []*armfrontdoor.TransformType{
									to.Ptr(armfrontdoor.TransformTypeLowercase)},
							}},
						Priority: to.Ptr[int32](2),
						RuleType: to.Ptr(armfrontdoor.RuleTypeMatchRule),
					}},
			},
			ManagedRules: &armfrontdoor.ManagedRuleSetList{
				ManagedRuleSets: []*armfrontdoor.ManagedRuleSet{
					{
						Exclusions: []*armfrontdoor.ManagedRuleExclusion{
							{
								MatchVariable:         to.Ptr(armfrontdoor.ManagedRuleExclusionMatchVariableRequestHeaderNames),
								Selector:              to.Ptr("User-Agent"),
								SelectorMatchOperator: to.Ptr(armfrontdoor.ManagedRuleExclusionSelectorMatchOperatorEquals),
							}},
						RuleGroupOverrides: []*armfrontdoor.ManagedRuleGroupOverride{
							{
								Exclusions: []*armfrontdoor.ManagedRuleExclusion{
									{
										MatchVariable:         to.Ptr(armfrontdoor.ManagedRuleExclusionMatchVariableRequestCookieNames),
										Selector:              to.Ptr("token"),
										SelectorMatchOperator: to.Ptr(armfrontdoor.ManagedRuleExclusionSelectorMatchOperatorStartsWith),
									}},
								RuleGroupName: to.Ptr("SQLI"),
								Rules: []*armfrontdoor.ManagedRuleOverride{
									{
										Action:       to.Ptr(armfrontdoor.ActionTypeRedirect),
										EnabledState: to.Ptr(armfrontdoor.ManagedRuleEnabledStateEnabled),
										Exclusions: []*armfrontdoor.ManagedRuleExclusion{
											{
												MatchVariable:         to.Ptr(armfrontdoor.ManagedRuleExclusionMatchVariableQueryStringArgNames),
												Selector:              to.Ptr("query"),
												SelectorMatchOperator: to.Ptr(armfrontdoor.ManagedRuleExclusionSelectorMatchOperatorEquals),
											}},
										RuleID: to.Ptr("942100"),
									},
									{
										EnabledState: to.Ptr(armfrontdoor.ManagedRuleEnabledStateDisabled),
										RuleID:       to.Ptr("942110"),
									}},
							}},
						RuleSetAction:  to.Ptr(armfrontdoor.ManagedRuleSetActionTypeBlock),
						RuleSetType:    to.Ptr("DefaultRuleSet"),
						RuleSetVersion: to.Ptr("1.0"),
					}},
			},
			PolicySettings: &armfrontdoor.PolicySettings{
				CustomBlockResponseBody:                to.Ptr("PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg=="),
				CustomBlockResponseStatusCode:          to.Ptr[int32](429),
				EnabledState:                           to.Ptr(armfrontdoor.PolicyEnabledStateEnabled),
				JavascriptChallengeExpirationInMinutes: to.Ptr[int32](30),
				LogScrubbing: &armfrontdoor.PolicySettingsLogScrubbing{
					ScrubbingRules: []*armfrontdoor.WebApplicationFirewallScrubbingRules{
						{
							MatchVariable:         to.Ptr(armfrontdoor.ScrubbingRuleEntryMatchVariableRequestIPAddress),
							SelectorMatchOperator: to.Ptr(armfrontdoor.ScrubbingRuleEntryMatchOperatorEqualsAny),
							State:                 to.Ptr(armfrontdoor.ScrubbingRuleEntryStateEnabled),
						}},
					State: to.Ptr(armfrontdoor.WebApplicationFirewallScrubbingStateEnabled),
				},
				Mode:             to.Ptr(armfrontdoor.PolicyModePrevention),
				RedirectURL:      to.Ptr("http://www.bing.com"),
				RequestBodyCheck: to.Ptr(armfrontdoor.PolicyRequestBodyCheckDisabled),
			},
		},
		SKU: &armfrontdoor.SKU{
			Name: to.Ptr(armfrontdoor.SKUNamePremiumAzureFrontDoor),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.WebApplicationFirewallPolicy = armfrontdoor.WebApplicationFirewallPolicy{
	// 	Name: to.Ptr("Policy1"),
	// 	Type: to.Ptr("Microsoft.Network/frontdoorwebapplicationfirewallpolicies"),
	// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/FrontDoorWebApplicationFirewallPolicies/Policy1"),
	// 	Location: to.Ptr("WestUs"),
	// 	Tags: map[string]*string{
	// 		"key1": to.Ptr("value1"),
	// 		"key2": to.Ptr("value2"),
	// 	},
	// 	Properties: &armfrontdoor.WebApplicationFirewallPolicyProperties{
	// 		CustomRules: &armfrontdoor.CustomRuleList{
	// 			Rules: []*armfrontdoor.CustomRule{
	// 				{
	// 					Name: to.Ptr("Rule1"),
	// 					Action: to.Ptr(armfrontdoor.ActionTypeBlock),
	// 					EnabledState: to.Ptr(armfrontdoor.CustomRuleEnabledStateEnabled),
	// 					MatchConditions: []*armfrontdoor.MatchCondition{
	// 						{
	// 							MatchValue: []*string{
	// 								to.Ptr("192.168.1.0/24"),
	// 								to.Ptr("10.0.0.0/24")},
	// 								MatchVariable: to.Ptr(armfrontdoor.MatchVariableRemoteAddr),
	// 								NegateCondition: to.Ptr(false),
	// 								Operator: to.Ptr(armfrontdoor.OperatorIPMatch),
	// 								Transforms: []*armfrontdoor.TransformType{
	// 								},
	// 						}},
	// 						Priority: to.Ptr[int32](1),
	// 						RateLimitDurationInMinutes: to.Ptr[int32](0),
	// 						RateLimitThreshold: to.Ptr[int32](1000),
	// 						RuleType: to.Ptr(armfrontdoor.RuleTypeRateLimitRule),
	// 					},
	// 					{
	// 						Name: to.Ptr("Rule2"),
	// 						Action: to.Ptr(armfrontdoor.ActionTypeBlock),
	// 						EnabledState: to.Ptr(armfrontdoor.CustomRuleEnabledStateEnabled),
	// 						MatchConditions: []*armfrontdoor.MatchCondition{
	// 							{
	// 								MatchValue: []*string{
	// 									to.Ptr("CH")},
	// 									MatchVariable: to.Ptr(armfrontdoor.MatchVariableRemoteAddr),
	// 									NegateCondition: to.Ptr(false),
	// 									Operator: to.Ptr(armfrontdoor.OperatorGeoMatch),
	// 								},
	// 								{
	// 									MatchValue: []*string{
	// 										to.Ptr("windows")},
	// 										MatchVariable: to.Ptr(armfrontdoor.MatchVariableRequestHeader),
	// 										NegateCondition: to.Ptr(false),
	// 										Operator: to.Ptr(armfrontdoor.OperatorContains),
	// 										Selector: to.Ptr("UserAgent"),
	// 										Transforms: []*armfrontdoor.TransformType{
	// 											to.Ptr(armfrontdoor.TransformTypeLowercase)},
	// 									}},
	// 									Priority: to.Ptr[int32](2),
	// 									RateLimitDurationInMinutes: to.Ptr[int32](0),
	// 									RateLimitThreshold: to.Ptr[int32](0),
	// 									RuleType: to.Ptr(armfrontdoor.RuleTypeMatchRule),
	// 							}},
	// 						},
	// 						FrontendEndpointLinks: []*armfrontdoor.FrontendEndpointLink{
	// 						},
	// 						ManagedRules: &armfrontdoor.ManagedRuleSetList{
	// 							ManagedRuleSets: []*armfrontdoor.ManagedRuleSet{
	// 								{
	// 									Exclusions: []*armfrontdoor.ManagedRuleExclusion{
	// 										{
	// 											MatchVariable: to.Ptr(armfrontdoor.ManagedRuleExclusionMatchVariableRequestHeaderNames),
	// 											Selector: to.Ptr("User-Agent"),
	// 											SelectorMatchOperator: to.Ptr(armfrontdoor.ManagedRuleExclusionSelectorMatchOperatorEquals),
	// 									}},
	// 									RuleGroupOverrides: []*armfrontdoor.ManagedRuleGroupOverride{
	// 										{
	// 											Exclusions: []*armfrontdoor.ManagedRuleExclusion{
	// 												{
	// 													MatchVariable: to.Ptr(armfrontdoor.ManagedRuleExclusionMatchVariableRequestCookieNames),
	// 													Selector: to.Ptr("token"),
	// 													SelectorMatchOperator: to.Ptr(armfrontdoor.ManagedRuleExclusionSelectorMatchOperatorStartsWith),
	// 											}},
	// 											RuleGroupName: to.Ptr("SQLI"),
	// 											Rules: []*armfrontdoor.ManagedRuleOverride{
	// 												{
	// 													Action: to.Ptr(armfrontdoor.ActionTypeRedirect),
	// 													EnabledState: to.Ptr(armfrontdoor.ManagedRuleEnabledStateEnabled),
	// 													Exclusions: []*armfrontdoor.ManagedRuleExclusion{
	// 														{
	// 															MatchVariable: to.Ptr(armfrontdoor.ManagedRuleExclusionMatchVariableQueryStringArgNames),
	// 															Selector: to.Ptr("query"),
	// 															SelectorMatchOperator: to.Ptr(armfrontdoor.ManagedRuleExclusionSelectorMatchOperatorEquals),
	// 													}},
	// 													RuleID: to.Ptr("942100"),
	// 												},
	// 												{
	// 													EnabledState: to.Ptr(armfrontdoor.ManagedRuleEnabledStateDisabled),
	// 													RuleID: to.Ptr("942110"),
	// 											}},
	// 									}},
	// 									RuleSetAction: to.Ptr(armfrontdoor.ManagedRuleSetActionTypeBlock),
	// 									RuleSetType: to.Ptr("DefaultRuleSet"),
	// 									RuleSetVersion: to.Ptr("1.0"),
	// 							}},
	// 						},
	// 						PolicySettings: &armfrontdoor.PolicySettings{
	// 							CustomBlockResponseBody: to.Ptr("PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg=="),
	// 							CustomBlockResponseStatusCode: to.Ptr[int32](429),
	// 							EnabledState: to.Ptr(armfrontdoor.PolicyEnabledStateEnabled),
	// 							JavascriptChallengeExpirationInMinutes: to.Ptr[int32](30),
	// 							LogScrubbing: &armfrontdoor.PolicySettingsLogScrubbing{
	// 								ScrubbingRules: []*armfrontdoor.WebApplicationFirewallScrubbingRules{
	// 									{
	// 										MatchVariable: to.Ptr(armfrontdoor.ScrubbingRuleEntryMatchVariableRequestIPAddress),
	// 										SelectorMatchOperator: to.Ptr(armfrontdoor.ScrubbingRuleEntryMatchOperatorEqualsAny),
	// 										State: to.Ptr(armfrontdoor.ScrubbingRuleEntryStateEnabled),
	// 								}},
	// 								State: to.Ptr(armfrontdoor.WebApplicationFirewallScrubbingStateEnabled),
	// 							},
	// 							Mode: to.Ptr(armfrontdoor.PolicyModePrevention),
	// 							RedirectURL: to.Ptr("http://www.bing.com"),
	// 							RequestBodyCheck: to.Ptr(armfrontdoor.PolicyRequestBodyCheckDisabled),
	// 						},
	// 						ProvisioningState: to.Ptr("Succeeded"),
	// 						ResourceState: to.Ptr(armfrontdoor.PolicyResourceStateEnabled),
	// 						SecurityPolicyLinks: []*armfrontdoor.SecurityPolicyLink{
	// 						},
	// 					},
	// 					SKU: &armfrontdoor.SKU{
	// 						Name: to.Ptr(armfrontdoor.SKUNamePremiumAzureFrontDoor),
	// 					},
	// 				}
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { FrontDoorManagementClient } = require("@azure/arm-frontdoor");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Create or update policy with specified rule set name within a resource group.
 *
 * @summary Create or update policy with specified rule set name within a resource group.
 * x-ms-original-file: specification/frontdoor/resource-manager/Microsoft.Network/stable/2024-02-01/examples/WafPolicyCreateOrUpdate.json
 */
async function createsSpecificPolicy() {
  const subscriptionId = process.env["FRONTDOOR_SUBSCRIPTION_ID"] || "subid";
  const resourceGroupName = process.env["FRONTDOOR_RESOURCE_GROUP"] || "rg1";
  const policyName = "Policy1";
  const parameters = {
    customRules: {
      rules: [
        {
          name: "Rule1",
          action: "Block",
          matchConditions: [
            {
              matchValue: ["192.168.1.0/24", "10.0.0.0/24"],
              matchVariable: "RemoteAddr",
              operator: "IPMatch",
            },
          ],
          priority: 1,
          rateLimitThreshold: 1000,
          ruleType: "RateLimitRule",
        },
        {
          name: "Rule2",
          action: "Block",
          matchConditions: [
            {
              matchValue: ["CH"],
              matchVariable: "RemoteAddr",
              operator: "GeoMatch",
            },
            {
              matchValue: ["windows"],
              matchVariable: "RequestHeader",
              operator: "Contains",
              selector: "UserAgent",
              transforms: ["Lowercase"],
            },
          ],
          priority: 2,
          ruleType: "MatchRule",
        },
      ],
    },
    location: "WestUs",
    managedRules: {
      managedRuleSets: [
        {
          exclusions: [
            {
              matchVariable: "RequestHeaderNames",
              selector: "User-Agent",
              selectorMatchOperator: "Equals",
            },
          ],
          ruleGroupOverrides: [
            {
              exclusions: [
                {
                  matchVariable: "RequestCookieNames",
                  selector: "token",
                  selectorMatchOperator: "StartsWith",
                },
              ],
              ruleGroupName: "SQLI",
              rules: [
                {
                  action: "Redirect",
                  enabledState: "Enabled",
                  exclusions: [
                    {
                      matchVariable: "QueryStringArgNames",
                      selector: "query",
                      selectorMatchOperator: "Equals",
                    },
                  ],
                  ruleId: "942100",
                },
                { enabledState: "Disabled", ruleId: "942110" },
              ],
            },
          ],
          ruleSetAction: "Block",
          ruleSetType: "DefaultRuleSet",
          ruleSetVersion: "1.0",
        },
      ],
    },
    policySettings: {
      customBlockResponseBody:
        "PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg==",
      customBlockResponseStatusCode: 429,
      enabledState: "Enabled",
      javascriptChallengeExpirationInMinutes: 30,
      mode: "Prevention",
      redirectUrl: "http://www.bing.com",
      requestBodyCheck: "Disabled",
      scrubbingRules: [
        {
          matchVariable: "RequestIPAddress",
          selector: undefined,
          selectorMatchOperator: "EqualsAny",
          state: "Enabled",
        },
      ],
      state: "Enabled",
    },
    sku: { name: "Premium_AzureFrontDoor" },
  };
  const credential = new DefaultAzureCredential();
  const client = new FrontDoorManagementClient(credential, subscriptionId);
  const result = await client.policies.beginCreateOrUpdateAndWait(
    resourceGroupName,
    policyName,
    parameters,
  );
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

dotnet

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.FrontDoor.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.FrontDoor;

// Generated from example definition: specification/frontdoor/resource-manager/Microsoft.Network/stable/2024-02-01/examples/WafPolicyCreateOrUpdate.json
// this example is just showing the usage of "Policies_CreateOrUpdate" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "subid";
string resourceGroupName = "rg1";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this FrontDoorWebApplicationFirewallPolicyResource
FrontDoorWebApplicationFirewallPolicyCollection collection = resourceGroupResource.GetFrontDoorWebApplicationFirewallPolicies();

// invoke the operation
string policyName = "Policy1";
FrontDoorWebApplicationFirewallPolicyData data = new FrontDoorWebApplicationFirewallPolicyData(new AzureLocation("WestUs"))
{
    SkuName = FrontDoorSkuName.PremiumAzureFrontDoor,
    PolicySettings = new FrontDoorWebApplicationFirewallPolicySettings()
    {
        EnabledState = PolicyEnabledState.Enabled,
        Mode = FrontDoorWebApplicationFirewallPolicyMode.Prevention,
        RedirectUri = new Uri("http://www.bing.com"),
        CustomBlockResponseStatusCode = 429,
        CustomBlockResponseBody = "PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg==",
        RequestBodyCheck = PolicyRequestBodyCheck.Disabled,
        JavascriptChallengeExpirationInMinutes = 30,
        State = WebApplicationFirewallScrubbingState.Enabled,
        ScrubbingRules =
        {
        new WebApplicationFirewallScrubbingRules(ScrubbingRuleEntryMatchVariable.RequestIPAddress,ScrubbingRuleEntryMatchOperator.EqualsAny)
        {
        Selector = null,
        State = ScrubbingRuleEntryState.Enabled,
        }
        },
    },
    Rules =
    {
    new WebApplicationCustomRule(1,WebApplicationRuleType.RateLimitRule,new WebApplicationRuleMatchCondition[]
    {
    new WebApplicationRuleMatchCondition(WebApplicationRuleMatchVariable.RemoteAddr,WebApplicationRuleMatchOperator.IPMatch,new string[]
    {
    "192.168.1.0/24","10.0.0.0/24"
    })
    },RuleMatchActionType.Block)
    {
    Name = "Rule1",
    RateLimitThreshold = 1000,
    },new WebApplicationCustomRule(2,WebApplicationRuleType.MatchRule,new WebApplicationRuleMatchCondition[]
    {
    new WebApplicationRuleMatchCondition(WebApplicationRuleMatchVariable.RemoteAddr,WebApplicationRuleMatchOperator.GeoMatch,new string[]
    {
    "CH"
    }),new WebApplicationRuleMatchCondition(WebApplicationRuleMatchVariable.RequestHeader,WebApplicationRuleMatchOperator.Contains,new string[]
    {
    "windows"
    })
    {
    Selector = "UserAgent",
    Transforms =
    {
    WebApplicationRuleMatchTransformType.Lowercase
    },
    }
    },RuleMatchActionType.Block)
    {
    Name = "Rule2",
    }
    },
    ManagedRuleSets =
    {
    new ManagedRuleSet("DefaultRuleSet","1.0")
    {
    RuleSetAction = ManagedRuleSetActionType.Block,
    Exclusions =
    {
    new ManagedRuleExclusion(ManagedRuleExclusionMatchVariable.RequestHeaderNames,ManagedRuleExclusionSelectorMatchOperator.EqualsValue,"User-Agent")
    },
    RuleGroupOverrides =
    {
    new ManagedRuleGroupOverride("SQLI")
    {
    Exclusions =
    {
    new ManagedRuleExclusion(ManagedRuleExclusionMatchVariable.RequestCookieNames,ManagedRuleExclusionSelectorMatchOperator.StartsWith,"token")
    },
    Rules =
    {
    new ManagedRuleOverride("942100")
    {
    EnabledState = ManagedRuleEnabledState.Enabled,
    Action = RuleMatchActionType.Redirect,
    Exclusions =
    {
    new ManagedRuleExclusion(ManagedRuleExclusionMatchVariable.QueryStringArgNames,ManagedRuleExclusionSelectorMatchOperator.EqualsValue,"query")
    },
    },new ManagedRuleOverride("942110")
    {
    EnabledState = ManagedRuleEnabledState.Disabled,
    }
    },
    }
    },
    }
    },
};
ArmOperation<FrontDoorWebApplicationFirewallPolicyResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, policyName, data);
FrontDoorWebApplicationFirewallPolicyResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
FrontDoorWebApplicationFirewallPolicyData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Przykładowa odpowiedź

Kod stanu:

200

{
  "name": "Policy1",
  "id": "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/FrontDoorWebApplicationFirewallPolicies/Policy1",
  "type": "Microsoft.Network/frontdoorwebapplicationfirewallpolicies",
  "tags": {
    "key1": "value1",
    "key2": "value2"
  },
  "location": "WestUs",
  "properties": {
    "resourceState": "Enabled",
    "provisioningState": "Succeeded",
    "policySettings": {
      "enabledState": "Enabled",
      "mode": "Prevention",
      "redirectUrl": "http://www.bing.com",
      "customBlockResponseStatusCode": 429,
      "customBlockResponseBody": "PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg==",
      "requestBodyCheck": "Disabled",
      "javascriptChallengeExpirationInMinutes": 30,
      "logScrubbing": {
        "state": "Enabled",
        "scrubbingRules": [
          {
            "matchVariable": "RequestIPAddress",
            "selectorMatchOperator": "EqualsAny",
            "selector": null,
            "state": "Enabled"
          }
        ]
      }
    },
    "customRules": {
      "rules": [
        {
          "name": "Rule1",
          "priority": 1,
          "enabledState": "Enabled",
          "ruleType": "RateLimitRule",
          "rateLimitDurationInMinutes": 0,
          "rateLimitThreshold": 1000,
          "matchConditions": [
            {
              "matchVariable": "RemoteAddr",
              "selector": null,
              "operator": "IPMatch",
              "negateCondition": false,
              "matchValue": [
                "192.168.1.0/24",
                "10.0.0.0/24"
              ],
              "transforms": []
            }
          ],
          "action": "Block"
        },
        {
          "name": "Rule2",
          "priority": 2,
          "enabledState": "Enabled",
          "ruleType": "MatchRule",
          "rateLimitDurationInMinutes": 0,
          "rateLimitThreshold": 0,
          "matchConditions": [
            {
              "matchVariable": "RemoteAddr",
              "selector": null,
              "operator": "GeoMatch",
              "negateCondition": false,
              "matchValue": [
                "CH"
              ]
            },
            {
              "matchVariable": "RequestHeader",
              "selector": "UserAgent",
              "operator": "Contains",
              "negateCondition": false,
              "matchValue": [
                "windows"
              ],
              "transforms": [
                "Lowercase"
              ]
            }
          ],
          "action": "Block"
        }
      ]
    },
    "managedRules": {
      "managedRuleSets": [
        {
          "ruleSetType": "DefaultRuleSet",
          "ruleSetVersion": "1.0",
          "ruleSetAction": "Block",
          "exclusions": [
            {
              "matchVariable": "RequestHeaderNames",
              "selectorMatchOperator": "Equals",
              "selector": "User-Agent"
            }
          ],
          "ruleGroupOverrides": [
            {
              "ruleGroupName": "SQLI",
              "exclusions": [
                {
                  "matchVariable": "RequestCookieNames",
                  "selectorMatchOperator": "StartsWith",
                  "selector": "token"
                }
              ],
              "rules": [
                {
                  "ruleId": "942100",
                  "enabledState": "Enabled",
                  "action": "Redirect",
                  "exclusions": [
                    {
                      "matchVariable": "QueryStringArgNames",
                      "selectorMatchOperator": "Equals",
                      "selector": "query"
                    }
                  ]
                },
                {
                  "ruleId": "942110",
                  "enabledState": "Disabled"
                }
              ]
            }
          ]
        }
      ]
    },
    "frontendEndpointLinks": [],
    "securityPolicyLinks": []
  },
  "sku": {
    "name": "Premium_AzureFrontDoor"
  }
}

Kod stanu:

201

{
  "name": "Policy1",
  "id": "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/FrontDoorWebApplicationFirewallPolicies/Policy1",
  "type": "Microsoft.Network/frontdoorwebapplicationfirewallpolicies",
  "tags": {
    "key1": "value1",
    "key2": "value2"
  },
  "location": "WestUs",
  "properties": {
    "resourceState": "Enabled",
    "provisioningState": "Succeeded",
    "policySettings": {
      "enabledState": "Enabled",
      "mode": "Prevention",
      "redirectUrl": "http://www.bing.com",
      "customBlockResponseStatusCode": 429,
      "customBlockResponseBody": "PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg==",
      "requestBodyCheck": "Disabled",
      "logScrubbing": {
        "state": "Enabled",
        "scrubbingRules": [
          {
            "matchVariable": "RequestIPAddress",
            "selectorMatchOperator": "EqualsAny",
            "selector": null,
            "state": "Enabled"
          }
        ]
      }
    },
    "customRules": {
      "rules": [
        {
          "name": "Rule1",
          "priority": 1,
          "enabledState": "Enabled",
          "ruleType": "RateLimitRule",
          "rateLimitDurationInMinutes": 0,
          "rateLimitThreshold": 1000,
          "matchConditions": [
            {
              "matchVariable": "RemoteAddr",
              "selector": null,
              "operator": "IPMatch",
              "negateCondition": false,
              "matchValue": [
                "192.168.1.0/24",
                "10.0.0.0/24"
              ],
              "transforms": []
            }
          ],
          "action": "Block"
        },
        {
          "name": "Rule2",
          "priority": 2,
          "enabledState": "Enabled",
          "ruleType": "MatchRule",
          "rateLimitDurationInMinutes": 0,
          "rateLimitThreshold": 0,
          "matchConditions": [
            {
              "matchVariable": "RemoteAddr",
              "selector": null,
              "operator": "GeoMatch",
              "negateCondition": false,
              "matchValue": [
                "CH"
              ]
            },
            {
              "matchVariable": "RequestHeader",
              "selector": "UserAgent",
              "operator": "Contains",
              "negateCondition": false,
              "matchValue": [
                "windows"
              ],
              "transforms": [
                "Lowercase"
              ]
            }
          ],
          "action": "Block"
        }
      ]
    },
    "managedRules": {
      "managedRuleSets": [
        {
          "ruleSetType": "DefaultRuleSet",
          "ruleSetVersion": "1.0",
          "exclusions": [
            {
              "matchVariable": "RequestHeaderNames",
              "selectorMatchOperator": "Equals",
              "selector": "User-Agent"
            }
          ],
          "ruleGroupOverrides": [
            {
              "ruleGroupName": "SQLI",
              "exclusions": [
                {
                  "matchVariable": "RequestCookieNames",
                  "selectorMatchOperator": "StartsWith",
                  "selector": "token"
                }
              ],
              "rules": [
                {
                  "ruleId": "942100",
                  "enabledState": "Enabled",
                  "action": "Redirect",
                  "exclusions": [
                    {
                      "matchVariable": "QueryStringArgNames",
                      "selectorMatchOperator": "Equals",
                      "selector": "query"
                    }
                  ]
                },
                {
                  "ruleId": "942110",
                  "enabledState": "Disabled"
                }
              ]
            }
          ]
        }
      ]
    },
    "frontendEndpointLinks": [],
    "securityPolicyLinks": []
  },
  "sku": {
    "name": "Classic_AzureFrontDoor"
  }
}

Kod stanu:

202

{
  "name": "Policy1",
  "id": "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/FrontDoorWebApplicationFirewallPolicies/Policy1",
  "type": "Microsoft.Network/frontdoorwebapplicationfirewallpolicies",
  "tags": {
    "key1": "value1",
    "key2": "value2"
  },
  "location": "WestUs",
  "properties": {
    "resourceState": "Enabled",
    "provisioningState": "Succeeded",
    "policySettings": {
      "enabledState": "Enabled",
      "mode": "Prevention",
      "redirectUrl": "http://www.bing.com",
      "customBlockResponseStatusCode": 429,
      "customBlockResponseBody": "PGh0bWw+CjxoZWFkZXI+PHRpdGxlPkhlbGxvPC90aXRsZT48L2hlYWRlcj4KPGJvZHk+CkhlbGxvIHdvcmxkCjwvYm9keT4KPC9odG1sPg==",
      "requestBodyCheck": "Disabled",
      "logScrubbing": {
        "state": "Enabled",
        "scrubbingRules": [
          {
            "matchVariable": "RequestIPAddress",
            "selectorMatchOperator": "EqualsAny",
            "selector": null,
            "state": "Enabled"
          }
        ]
      }
    },
    "customRules": {
      "rules": [
        {
          "name": "Rule1",
          "priority": 1,
          "enabledState": "Enabled",
          "ruleType": "RateLimitRule",
          "rateLimitDurationInMinutes": 0,
          "rateLimitThreshold": 1000,
          "matchConditions": [
            {
              "matchVariable": "RemoteAddr",
              "selector": null,
              "operator": "IPMatch",
              "negateCondition": false,
              "matchValue": [
                "192.168.1.0/24",
                "10.0.0.0/24"
              ],
              "transforms": []
            }
          ],
          "action": "Block"
        },
        {
          "name": "Rule2",
          "priority": 2,
          "enabledState": "Enabled",
          "ruleType": "MatchRule",
          "rateLimitDurationInMinutes": 0,
          "rateLimitThreshold": 0,
          "matchConditions": [
            {
              "matchVariable": "RemoteAddr",
              "selector": null,
              "operator": "GeoMatch",
              "negateCondition": false,
              "matchValue": [
                "CH"
              ]
            },
            {
              "matchVariable": "RequestHeader",
              "selector": "UserAgent",
              "operator": "Contains",
              "negateCondition": false,
              "matchValue": [
                "windows"
              ],
              "transforms": [
                "Lowercase"
              ]
            }
          ],
          "action": "Block"
        }
      ]
    },
    "managedRules": {
      "managedRuleSets": [
        {
          "ruleSetType": "DefaultRuleSet",
          "ruleSetVersion": "1.0",
          "ruleSetAction": "Block",
          "exclusions": [
            {
              "matchVariable": "RequestHeaderNames",
              "selectorMatchOperator": "Equals",
              "selector": "User-Agent"
            }
          ],
          "ruleGroupOverrides": [
            {
              "ruleGroupName": "SQLI",
              "exclusions": [
                {
                  "matchVariable": "RequestCookieNames",
                  "selectorMatchOperator": "StartsWith",
                  "selector": "token"
                }
              ],
              "rules": [
                {
                  "ruleId": "942100",
                  "enabledState": "Enabled",
                  "action": "Redirect",
                  "exclusions": [
                    {
                      "matchVariable": "QueryStringArgNames",
                      "selectorMatchOperator": "Equals",
                      "selector": "query"
                    }
                  ]
                },
                {
                  "ruleId": "942110",
                  "enabledState": "Disabled"
                }
              ]
            }
          ]
        }
      ]
    },
    "frontendEndpointLinks": [],
    "securityPolicyLinks": []
  },
  "sku": {
    "name": "Premium_AzureFrontDoor"
  }
}

Definicje

Nazwa	Opis
scrubbingRuleEntryMatchOperator	Gdy element matchVariable jest kolekcją, należy pracować na selektorze, aby określić, które elementy w kolekcji mają zastosowanie do tej reguły.
scrubbingRuleEntryState	Definiuje stan reguły oczyszczania dziennika. Wartość domyślna jest włączona.
ActionType	Definiuje akcję do wykonania przy dopasowaniu reguły.
CustomRule	Definiuje zawartość reguły aplikacji internetowej
CustomRuleEnabledState	Opisuje, czy reguła niestandardowa jest w stanie włączonym lub wyłączonym. Wartość domyślna to Włączone, jeśli nie zostanie określona.
CustomRuleList	Definiuje zawartość reguł niestandardowych
ErrorResponse	Odpowiedź na błąd wskazuje, że usługa Front Door nie może przetworzyć żądania przychodzącego. Przyczyna jest podana w komunikacie o błędzie.
FrontendEndpointLink	Definiuje identyfikator zasobu dla punktu końcowego frontonu.
GroupByVariable	Opisuje zmienne dostępne do grupowania żądań limitu szybkości
ManagedRuleEnabledState	Opisuje, czy reguła zarządzana jest w stanie włączonym lub wyłączonym.
ManagedRuleExclusion	Wyklucz zmienne z oceny reguły zarządzanej.
ManagedRuleExclusionMatchVariable	Typ zmiennej, który ma zostać wykluczony.
ManagedRuleExclusionSelectorMatchOperator	Operator porównania, który ma zastosowanie do selektora podczas określania elementów w kolekcji, do których ma zastosowanie to wykluczenie.
ManagedRuleGroupOverride	Definiuje ustawienie zastąpienia zarządzanej grupy reguł.
ManagedRuleOverride	Definiuje ustawienie zastąpienia zarządzanej grupy reguł.
ManagedRuleSet	Definiuje zarządzany zestaw reguł.
ManagedRuleSetActionType	Definiuje akcję do wykonania po osiągnięciu progu oceny zestawu reguł zarządzanych.
ManagedRuleSetList	Definiuje listę zarządzanych zestawów reguł dla zasad.
MatchCondition	Zdefiniuj warunek dopasowania.
MatchVariable	Żądaj zmiennej do porównania.
Operator	Typ porównania używany do dopasowywania z wartością zmiennej.
PolicyEnabledState	Opisuje, czy zasady są w stanie włączonym lub wyłączonym. Wartość domyślna to Włączone, jeśli nie zostanie określona.
PolicyMode	Opisuje, czy jest w trybie wykrywania lub w trybie zapobiegania na poziomie zasad.
PolicyRequestBodyCheck	Opisuje, czy reguły zarządzane przez zasady będą sprawdzać zawartość treści żądania.
PolicyResourceState	Stan zasobu zasad.
PolicySettings	Definiuje ustawienia konfiguracji webapplicationFirewallPolicy najwyższego poziomu.
RoutingRuleLink	Definiuje identyfikator zasobu dla reguły routingu.
RuleType	Opisuje typ reguły.
scrubbingRuleEntryMatchVariable	Zmienna, która ma zostać wyczyszczone z dzienników.
SecurityPolicyLink	Definiuje identyfikator zasobu dla zasad zabezpieczeń.
Sku	Warstwa cenowa zasad zapory aplikacji internetowej.
SkuName	Nazwa warstwy cenowej.
TransformType	Opisuje przekształcenia zastosowane przed dopasowaniem.
VariableName	Opisuje obsługiwaną zmienną dla grupy według
WebApplicationFirewallPolicy	Definiuje zasady zapory aplikacji internetowej.
WebApplicationFirewallScrubbingRules	Definiuje zawartość reguł oczyszczania dziennika.
WebApplicationFirewallScrubbingState	Stan konfiguracji oczyszczania dziennika. Wartość domyślna to Włączone.

scrubbingRuleEntryMatchOperator

Gdy element matchVariable jest kolekcją, należy pracować na selektorze, aby określić, które elementy w kolekcji mają zastosowanie do tej reguły.

Nazwa	Typ	Opis
Equals	string
EqualsAny	string

scrubbingRuleEntryState

Definiuje stan reguły oczyszczania dziennika. Wartość domyślna jest włączona.

Nazwa	Typ	Opis
Disabled	string
Enabled	string

ActionType

Definiuje akcję do wykonania przy dopasowaniu reguły.

Nazwa	Typ	Opis
Allow	string
AnomalyScoring	string
Block	string
JSChallenge	string
Log	string
Redirect	string

CustomRule

Definiuje zawartość reguły aplikacji internetowej

Nazwa	Typ	Opis
action	ActionType	Opisuje akcję, która ma zostać zastosowana, gdy reguła jest zgodna.
enabledState	CustomRuleEnabledState	Opisuje, czy reguła niestandardowa jest w stanie włączonym lub wyłączonym. Wartość domyślna to Włączone, jeśli nie zostanie określona.
groupBy	GroupByVariable[]	Opisuje listę zmiennych do grupowania żądań limitu szybkości
matchConditions	MatchCondition[]	Lista warunków dopasowania.
name	string	Opisuje nazwę reguły.
priority	integer	Opisuje priorytet reguły. Reguły o niższej wartości zostaną ocenione przed regułami o wyższej wartości.
rateLimitDurationInMinutes	integer	Przedział czasu resetowania liczby limitów szybkości. Wartość domyślna to 1 minuta.
rateLimitThreshold	integer	Liczba dozwolonych żądań na klienta w przedziale czasu.
ruleType	RuleType	Opisuje typ reguły.

CustomRuleEnabledState

Opisuje, czy reguła niestandardowa jest w stanie włączonym lub wyłączonym. Wartość domyślna to Włączone, jeśli nie zostanie określona.

Nazwa	Typ	Opis
Disabled	string
Enabled	string

CustomRuleList

Definiuje zawartość reguł niestandardowych

Nazwa	Typ	Opis
rules	CustomRule[]	Lista reguł

ErrorResponse

Odpowiedź na błąd wskazuje, że usługa Front Door nie może przetworzyć żądania przychodzącego. Przyczyna jest podana w komunikacie o błędzie.

Nazwa	Typ	Opis
code	string	Kod błędu.
message	string	Komunikat o błędzie wskazujący, dlaczego operacja nie powiodła się.

FrontendEndpointLink

Definiuje identyfikator zasobu dla punktu końcowego frontonu.

Nazwa	Typ	Opis
id	string	Identyfikator zasobu.

GroupByVariable

Opisuje zmienne dostępne do grupowania żądań limitu szybkości

Nazwa	Typ	Opis
variableName	VariableName	Opisuje obsługiwaną zmienną dla grupy według

ManagedRuleEnabledState

Opisuje, czy reguła zarządzana jest w stanie włączonym lub wyłączonym.

Nazwa	Typ	Opis
Disabled	string
Enabled	string

ManagedRuleExclusion

Wyklucz zmienne z oceny reguły zarządzanej.

Nazwa	Typ	Opis
matchVariable	ManagedRuleExclusionMatchVariable	Typ zmiennej, który ma zostać wykluczony.
selector	string	Wartość selektora, do której mają zastosowanie elementy w kolekcji.
selectorMatchOperator	ManagedRuleExclusionSelectorMatchOperator	Operator porównania, który ma zastosowanie do selektora podczas określania elementów w kolekcji, do których ma zastosowanie to wykluczenie.

ManagedRuleExclusionMatchVariable

Typ zmiennej, który ma zostać wykluczony.

Nazwa	Typ	Opis
QueryStringArgNames	string
RequestBodyJsonArgNames	string
RequestBodyPostArgNames	string
RequestCookieNames	string
RequestHeaderNames	string

ManagedRuleExclusionSelectorMatchOperator

Operator porównania, który ma zastosowanie do selektora podczas określania elementów w kolekcji, do których ma zastosowanie to wykluczenie.

Nazwa	Typ	Opis
Contains	string
EndsWith	string
Equals	string
EqualsAny	string
StartsWith	string

ManagedRuleGroupOverride

Definiuje ustawienie zastąpienia zarządzanej grupy reguł.

Nazwa	Typ	Opis
exclusions	ManagedRuleExclusion[]	Opisuje wykluczenia, które są stosowane do wszystkich reguł w grupie.
ruleGroupName	string	Opisuje zarządzaną grupę reguł do zastąpienia.
rules	ManagedRuleOverride[]	Lista reguł, które zostaną wyłączone. Jeśli żadna z nich nie zostanie określona, wszystkie reguły w grupie zostaną wyłączone.

ManagedRuleOverride

Definiuje ustawienie zastąpienia zarządzanej grupy reguł.

Nazwa	Typ	Opis
action	ActionType	Opisuje akcję przesłonięcia, która ma być stosowana, gdy reguła jest zgodna.
enabledState	ManagedRuleEnabledState	Opisuje, czy reguła zarządzana jest w stanie włączonym lub wyłączonym. Wartość domyślna to Wyłączone, jeśli nie zostanie określona.
exclusions	ManagedRuleExclusion[]	Opisuje wykluczenia, które są stosowane do tej konkretnej reguły.
ruleId	string	Identyfikator reguły zarządzanej.

ManagedRuleSet

Definiuje zarządzany zestaw reguł.

Nazwa	Typ	Opis
exclusions	ManagedRuleExclusion[]	Opisuje wykluczenia, które są stosowane do wszystkich reguł w zestawie.
ruleGroupOverrides	ManagedRuleGroupOverride[]	Definiuje przesłonięcia grupy reguł, które mają być stosowane do zestawu reguł.
ruleSetAction	ManagedRuleSetActionType	ruleSetAction Definiuje akcję zestawu reguł.
ruleSetType	string	Definiuje typ zestawu reguł do użycia.
ruleSetVersion	string	Definiuje wersję zestawu reguł do użycia.

ManagedRuleSetActionType

Definiuje akcję do wykonania po osiągnięciu progu oceny zestawu reguł zarządzanych.

Nazwa	Typ	Opis
Block	string
Log	string
Redirect	string

ManagedRuleSetList

Definiuje listę zarządzanych zestawów reguł dla zasad.

Nazwa	Typ	Opis
managedRuleSets	ManagedRuleSet[]	Lista zestawów reguł.

MatchCondition

Zdefiniuj warunek dopasowania.

Nazwa	Typ	Opis
matchValue	string[]	Lista możliwych wartości dopasowania.
matchVariable	MatchVariable	Zażądaj zmiennej do porównania.
negateCondition	boolean	Opisuje, czy wynik tego warunku powinien zostać zanegowany.
operator	Operator	Typ porównania używany do dopasowywania do wartości zmiennej.
selector	string	Dopasuj do określonego klucza ze zmiennych QueryString, PostArgs, RequestHeader lub Cookies. Wartość domyślna to null.
transforms	TransformType[]	Lista przekształceń.

MatchVariable

Żądaj zmiennej do porównania.

Nazwa	Typ	Opis
Cookies	string
PostArgs	string
QueryString	string
RemoteAddr	string
RequestBody	string
RequestHeader	string
RequestMethod	string
RequestUri	string
SocketAddr	string

Operator

Typ porównania używany do dopasowywania z wartością zmiennej.

Nazwa	Typ	Opis
Any	string
BeginsWith	string
Contains	string
EndsWith	string
Equal	string
GeoMatch	string
GreaterThan	string
GreaterThanOrEqual	string
IPMatch	string
LessThan	string
LessThanOrEqual	string
RegEx	string

PolicyEnabledState

Opisuje, czy zasady są w stanie włączonym lub wyłączonym. Wartość domyślna to Włączone, jeśli nie zostanie określona.

Nazwa	Typ	Opis
Disabled	string
Enabled	string

PolicyMode

Opisuje, czy jest w trybie wykrywania lub w trybie zapobiegania na poziomie zasad.

Nazwa	Typ	Opis
Detection	string
Prevention	string

PolicyRequestBodyCheck

Opisuje, czy reguły zarządzane przez zasady będą sprawdzać zawartość treści żądania.

Nazwa	Typ	Opis
Disabled	string
Enabled	string

PolicyResourceState

Stan zasobu zasad.

Nazwa	Typ	Opis
Creating	string
Deleting	string
Disabled	string
Disabling	string
Enabled	string
Enabling	string

PolicySettings

Definiuje ustawienia konfiguracji webapplicationFirewallPolicy najwyższego poziomu.

Nazwa	Typ	Opis
customBlockResponseBody	string	Jeśli typ akcji jest zablokowany, klient może zastąpić treść odpowiedzi. Treść musi być określona w kodowaniu base64.
customBlockResponseStatusCode	integer	Jeśli typ akcji jest zablokowany, klient może zastąpić kod stanu odpowiedzi.
enabledState	PolicyEnabledState	Opisuje, czy zasady są w stanie włączonym lub wyłączonym. Wartość domyślna to Włączone, jeśli nie zostanie określona.
javascriptChallengeExpirationInMinutes	integer	Definiuje okres ważności pliku cookie wyzwania w języku JavaScript w ciągu kilku minut. To ustawienie ma zastosowanie tylko do Premium_AzureFrontDoor. Wartość musi być liczbą całkowitą z zakresu od 5 do 1440, a wartość domyślna to 30.
logScrubbing.scrubbingRules	WebApplicationFirewallScrubbingRules[]	Lista reguł kontroli dzienników zastosowanych do dzienników Web Application Firewall.
logScrubbing.state	WebApplicationFirewallScrubbingState	Stan konfiguracji oczyszczania dziennika. Wartość domyślna to Włączone.
mode	PolicyMode	Opisuje, czy jest w trybie wykrywania lub w trybie zapobiegania na poziomie zasad.
redirectUrl	string	Jeśli typ akcji to przekierowanie, to pole reprezentuje adres URL przekierowania dla klienta.
requestBodyCheck	PolicyRequestBodyCheck	Opisuje, czy reguły zarządzane przez zasady będą sprawdzać zawartość treści żądania.

RoutingRuleLink

Definiuje identyfikator zasobu dla reguły routingu.

Nazwa	Typ	Opis
id	string	Identyfikator zasobu.

RuleType

Opisuje typ reguły.

Nazwa	Typ	Opis
MatchRule	string
RateLimitRule	string

scrubbingRuleEntryMatchVariable

Zmienna, która ma zostać wyczyszczone z dzienników.

Nazwa	Typ	Opis
QueryStringArgNames	string
RequestBodyJsonArgNames	string
RequestBodyPostArgNames	string
RequestCookieNames	string
RequestHeaderNames	string
RequestIPAddress	string
RequestUri	string

SecurityPolicyLink

Definiuje identyfikator zasobu dla zasad zabezpieczeń.

Nazwa	Typ	Opis
id	string	Identyfikator zasobu.

Sku

Warstwa cenowa zasad zapory aplikacji internetowej.

Nazwa	Typ	Opis
name	SkuName	Nazwa warstwy cenowej.

SkuName

Nazwa warstwy cenowej.

Nazwa	Typ	Opis
Classic_AzureFrontDoor	string
Premium_AzureFrontDoor	string
Standard_AzureFrontDoor	string

TransformType

Opisuje przekształcenia zastosowane przed dopasowaniem.

Nazwa	Typ	Opis
Lowercase	string
RemoveNulls	string
Trim	string
Uppercase	string
UrlDecode	string
UrlEncode	string

VariableName

Opisuje obsługiwaną zmienną dla grupy według

Nazwa	Typ	Opis
GeoLocation	string
None	string
SocketAddr	string

WebApplicationFirewallPolicy

Definiuje zasady zapory aplikacji internetowej.

Nazwa	Typ	Opis
etag	string	Pobiera unikatowy ciąg tylko do odczytu, który zmienia się za każdym razem, gdy zasób jest aktualizowany.
id	string	Identyfikator zasobu.
location	string	Lokalizacja zasobu.
name	string	Nazwa zasobu.
properties.customRules	CustomRuleList	Opisuje reguły niestandardowe wewnątrz zasad.
properties.frontendEndpointLinks	FrontendEndpointLink[]	W tym artykule opisano punkty końcowe frontonu skojarzone z tym Web Application Firewall zasadami.
properties.managedRules	ManagedRuleSetList	Opisuje reguły zarządzane wewnątrz zasad.
properties.policySettings	PolicySettings	Opisuje ustawienia zasad.
properties.provisioningState	string	Stan aprowizacji zasad.
properties.resourceState	PolicyResourceState	Stan zasobu zasad.
properties.routingRuleLinks	RoutingRuleLink[]	Opisuje reguły routingu skojarzone z tym zasadami Web Application Firewall.
properties.securityPolicyLinks	SecurityPolicyLink[]	Opisuje zasady zabezpieczeń skojarzone z tym zasadami Web Application Firewall.
sku	Sku	Warstwa cenowa zasad zapory aplikacji internetowej. Wartość domyślna to Classic_AzureFrontDoor, jeśli nie zostanie określona.
tags	object	Tagi zasobów.
type	string	Typ zasobu.

WebApplicationFirewallScrubbingRules

Definiuje zawartość reguł oczyszczania dziennika.

Nazwa	Typ	Opis
matchVariable	scrubbingRuleEntryMatchVariable	Zmienna, która ma zostać wyczyszczone z dzienników.
selector	string	Gdy matchVariable jest kolekcją, operator używany do określania elementów w kolekcji, do których ma zastosowanie ta reguła.
selectorMatchOperator	scrubbingRuleEntryMatchOperator	Gdy element matchVariable jest kolekcją, należy pracować na selektorze, aby określić, które elementy w kolekcji mają zastosowanie do tej reguły.
state	scrubbingRuleEntryState	Definiuje stan reguły oczyszczania dziennika. Wartość domyślna jest włączona.

WebApplicationFirewallScrubbingState

Stan konfiguracji oczyszczania dziennika. Wartość domyślna to Włączone.

Nazwa	Typ	Opis
Disabled	string
Enabled	string