Sign in Dashboard Get started
  1. Registry
  2. Packages
  3. Fastly Provider
  4. API Docs
  5. RoutingConfig
Viewing docs for Fastly v12.8.1
published on Tuesday, Oct 13, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-fastly

fastly.RoutingConfig

fastly logo
Viewing docs for Fastly v12.8.1
published on Tuesday, Oct 13, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-fastly

    Routing configs let you route requests to different services (or other destinations) based on URL path, using conditional rules. This resource manages a routing config’s path and rule configuration using automatic versioning: every apply reconciles the routing config’s draft paths and rules against this resource’s configuration and, if anything changed, activates the result as the new active version. The underlying draft/version workflow exposed by the API is never surfaced to Terraform — there’s no version or activate argument for you to manage.

    A routing config isn’t useful on its own; it must be linked to one or more domains via fastly.RoutingConfigDomainLink before it will route traffic.

    Note: This resource refreshes each path and rule it manages individually by ID rather than listing a routing config’s current paths/rules. This means it will not detect a path or rule added to the routing config outside of Terraform (e.g. via the API or UI directly) — only drift on paths/rules this resource already created, or that were imported.

    Example Usage

    Basic usage:

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

const example = new fastly.RoutingConfig("example", {
    name: "example-routing-config",
    paths: [
        {
            path: "/api/*",
            rules: [{
                actionType: "service",
                actionValue: exampleFastlyServiceVcl.id,
            }],
        },
        {
            path: "/",
            rules: [
                {
                    actionType: "service",
                    actionValue: exampleFastlyServiceVcl.id,
                    conditions: [{
                        type: "header",
                        key: "X-Beta",
                        operator: "equals",
                        value: "true",
                    }],
                },
                {
                    actionType: "service",
                    actionValue: exampleFastlyServiceVcl.id,
                },
            ],
        },
    ],
});

    import pulumi
import pulumi_fastly as fastly

example = fastly.RoutingConfig("example",
    name="example-routing-config",
    paths=[
        {
            "path": "/api/*",
            "rules": [{
                "action_type": "service",
                "action_value": example_fastly_service_vcl["id"],
            }],
        },
        {
            "path": "/",
            "rules": [
                {
                    "action_type": "service",
                    "action_value": example_fastly_service_vcl["id"],
                    "conditions": [{
                        "type": "header",
                        "key": "X-Beta",
                        "operator": "equals",
                        "value": "true",
                    }],
                },
                {
                    "action_type": "service",
                    "action_value": example_fastly_service_vcl["id"],
                },
            ],
        },
    ])

    package main

import (
	"github.com/pulumi/pulumi-fastly/sdk/v12/go/fastly"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := fastly.NewRoutingConfig(ctx, "example", &fastly.RoutingConfigArgs{
			Name: pulumi.String("example-routing-config"),
			Paths: fastly.RoutingConfigPathArray{
				&fastly.RoutingConfigPathArgs{
					Path: pulumi.String("/api/*"),
					Rules: fastly.RoutingConfigPathRuleArray{
						&fastly.RoutingConfigPathRuleArgs{
							ActionType:  pulumi.String("service"),
							ActionValue: pulumi.Any(exampleFastlyServiceVcl.Id),
						},
					},
				},
				&fastly.RoutingConfigPathArgs{
					Path: pulumi.String("/"),
					Rules: fastly.RoutingConfigPathRuleArray{
						&fastly.RoutingConfigPathRuleArgs{
							ActionType:  pulumi.String("service"),
							ActionValue: pulumi.Any(exampleFastlyServiceVcl.Id),
							Conditions: fastly.RoutingConfigPathRuleConditionArray{
								&fastly.RoutingConfigPathRuleConditionArgs{
									Type:     pulumi.String("header"),
									Key:      pulumi.String("X-Beta"),
									Operator: pulumi.String("equals"),
									Value:    pulumi.String("true"),
								},
							},
						},
						&fastly.RoutingConfigPathRuleArgs{
							ActionType:  pulumi.String("service"),
							ActionValue: pulumi.Any(exampleFastlyServiceVcl.Id),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Fastly.RoutingConfig("example", new()
    {
        Name = "example-routing-config",
        Paths = new[]
        {
            new Fastly.Inputs.RoutingConfigPathArgs
            {
                Path = "/api/*",
                Rules = new[]
                {
                    new Fastly.Inputs.RoutingConfigPathRuleArgs
                    {
                        ActionType = "service",
                        ActionValue = exampleFastlyServiceVcl.Id,
                    },
                },
            },
            new Fastly.Inputs.RoutingConfigPathArgs
            {
                Path = "/",
                Rules = new[]
                {
                    new Fastly.Inputs.RoutingConfigPathRuleArgs
                    {
                        ActionType = "service",
                        ActionValue = exampleFastlyServiceVcl.Id,
                        Conditions = new[]
                        {
                            new Fastly.Inputs.RoutingConfigPathRuleConditionArgs
                            {
                                Type = "header",
                                Key = "X-Beta",
                                Operator = "equals",
                                Value = "true",
                            },
                        },
                    },
                    new Fastly.Inputs.RoutingConfigPathRuleArgs
                    {
                        ActionType = "service",
                        ActionValue = exampleFastlyServiceVcl.Id,
                    },
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.fastly.RoutingConfig;
import com.pulumi.fastly.RoutingConfigArgs;
import com.pulumi.fastly.inputs.RoutingConfigPathArgs;
import com.pulumi.fastly.inputs.RoutingConfigPathRuleArgs;
import com.pulumi.fastly.inputs.RoutingConfigPathRuleConditionArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 RoutingConfig("example", RoutingConfigArgs.builder()
            .name("example-routing-config")
            .paths(            
                RoutingConfigPathArgs.builder()
                    .path("/api/*")
                    .rules(RoutingConfigPathRuleArgs.builder()
                        .actionType("service")
                        .actionValue(exampleFastlyServiceVcl.get("id"))
                        .build())
                    .build(),
                RoutingConfigPathArgs.builder()
                    .path("/")
                    .rules(                    
                        RoutingConfigPathRuleArgs.builder()
                            .actionType("service")
                            .actionValue(exampleFastlyServiceVcl.get("id"))
                            .conditions(RoutingConfigPathRuleConditionArgs.builder()
                                .type("header")
                                .key("X-Beta")
                                .operator("equals")
                                .value("true")
                                .build())
                            .build(),
                        RoutingConfigPathRuleArgs.builder()
                            .actionType("service")
                            .actionValue(exampleFastlyServiceVcl.get("id"))
                            .build())
                    .build())
            .build());

    }
}

    resources:
  example:
    type: fastly:RoutingConfig
    properties:
      name: example-routing-config
      paths:
        - path: /api/*
          rules:
            - actionType: service
              actionValue: ${exampleFastlyServiceVcl.id}
        - path: /
          rules:
            - actionType: service
              actionValue: ${exampleFastlyServiceVcl.id}
              conditions:
                - type: header
                  key: X-Beta
                  operator: equals
                  value: 'true'
            - actionType: service
              actionValue: ${exampleFastlyServiceVcl.id}

    terraform {
  required_providers {
    fastly = {
      source = "pulumi/fastly"
    }
  }
}

resource "fastly_routing_config" "example" {
  lifecycle {
    create_before_destroy = true
  }
  name = "example-routing-config"
  paths {
    path = "/api/*"
    rules {
      action_type  = "service"
      action_value = exampleFastlyServiceVcl.id
    }
  }
  paths {
    path = "/"
    rules {
      action_type  = "service"
      action_value = exampleFastlyServiceVcl.id
      conditions {
        type     = "header"
        key      = "X-Beta"
        operator = "equals"
        value    = "true"
      }
    }
    rules {
      action_type  = "service"
      action_value = exampleFastlyServiceVcl.id
    }
  }
}

    Create RoutingConfig Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new RoutingConfig(name: string, args: RoutingConfigArgs, opts?: CustomResourceOptions);
    @overload
def RoutingConfig(resource_name: str,
                  args: RoutingConfigArgs,
                  opts: Optional[ResourceOptions] = None)

@overload
def RoutingConfig(resource_name: str,
                  opts: Optional[ResourceOptions] = None,
                  paths: Optional[Sequence[RoutingConfigPathArgs]] = None,
                  name: Optional[str] = None)
    func NewRoutingConfig(ctx *Context, name string, args RoutingConfigArgs, opts ...ResourceOption) (*RoutingConfig, error)
    public RoutingConfig(string name, RoutingConfigArgs args, CustomResourceOptions? opts = null)
    public RoutingConfig(String name, RoutingConfigArgs args)
public RoutingConfig(String name, RoutingConfigArgs args, CustomResourceOptions options)

    type: fastly:RoutingConfig
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.


    resource "fastly_routing_config" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args RoutingConfigArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args RoutingConfigArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args RoutingConfigArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args RoutingConfigArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args RoutingConfigArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var routingConfigResource = new Fastly.RoutingConfig("routingConfigResource", new()
{
    Paths = new[]
    {
        new Fastly.Inputs.RoutingConfigPathArgs
        {
            Path = "string",
            Rules = new[]
            {
                new Fastly.Inputs.RoutingConfigPathRuleArgs
                {
                    ActionType = "string",
                    ActionValue = "string",
                    Conditions = new[]
                    {
                        new Fastly.Inputs.RoutingConfigPathRuleConditionArgs
                        {
                            Operator = "string",
                            Type = "string",
                            Value = "string",
                            Key = "string",
                        },
                    },
                    IsDefault = false,
                    RuleId = "string",
                },
            },
            PathId = "string",
        },
    },
    Name = "string",
});

    example, err := fastly.NewRoutingConfig(ctx, "routingConfigResource", &fastly.RoutingConfigArgs{
	Paths: fastly.RoutingConfigPathArray{
		&fastly.RoutingConfigPathArgs{
			Path: pulumi.String("string"),
			Rules: fastly.RoutingConfigPathRuleArray{
				&fastly.RoutingConfigPathRuleArgs{
					ActionType:  pulumi.String("string"),
					ActionValue: pulumi.String("string"),
					Conditions: fastly.RoutingConfigPathRuleConditionArray{
						&fastly.RoutingConfigPathRuleConditionArgs{
							Operator: pulumi.String("string"),
							Type:     pulumi.String("string"),
							Value:    pulumi.String("string"),
							Key:      pulumi.String("string"),
						},
					},
					IsDefault: pulumi.Bool(false),
					RuleId:    pulumi.String("string"),
				},
			},
			PathId: pulumi.String("string"),
		},
	},
	Name: pulumi.String("string"),
})

    resource "fastly_routing_config" "routingConfigResource" {
  lifecycle {
    create_before_destroy = true
  }
  paths {
    path = "string"
    rules {
      action_type  = "string"
      action_value = "string"
      conditions {
        operator = "string"
        type     = "string"
        value    = "string"
        key      = "string"
      }
      is_default = false
      rule_id    = "string"
    }
    path_id = "string"
  }
  name = "string"
}

    var routingConfigResource = new RoutingConfig("routingConfigResource", RoutingConfigArgs.builder()
    .paths(RoutingConfigPathArgs.builder()
        .path("string")
        .rules(RoutingConfigPathRuleArgs.builder()
            .actionType("string")
            .actionValue("string")
            .conditions(RoutingConfigPathRuleConditionArgs.builder()
                .operator("string")
                .type("string")
                .value("string")
                .key("string")
                .build())
            .isDefault(false)
            .ruleId("string")
            .build())
        .pathId("string")
        .build())
    .name("string")
    .build());

    routing_config_resource = fastly.RoutingConfig("routingConfigResource",
    paths=[{
        "path": "string",
        "rules": [{
            "action_type": "string",
            "action_value": "string",
            "conditions": [{
                "operator": "string",
                "type": "string",
                "value": "string",
                "key": "string",
            }],
            "is_default": False,
            "rule_id": "string",
        }],
        "path_id": "string",
    }],
    name="string")

    const routingConfigResource = new fastly.RoutingConfig("routingConfigResource", {
    paths: [{
        path: "string",
        rules: [{
            actionType: "string",
            actionValue: "string",
            conditions: [{
                operator: "string",
                type: "string",
                value: "string",
                key: "string",
            }],
            isDefault: false,
            ruleId: "string",
        }],
        pathId: "string",
    }],
    name: "string",
});

    type: fastly:RoutingConfig
properties:
    name: string
    paths:
        - path: string
          pathId: string
          rules:
            - actionType: string
              actionValue: string
              conditions:
                - key: string
                  operator: string
                  type: string
                  value: string
              isDefault: false
              ruleId: string

    RoutingConfig Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The RoutingConfig resource accepts the following input properties:

    Paths List<RoutingConfigPath>
    A URL path pattern and the rules used to route matching requests.
    Name string
    The user-defined name of the routing config. Can be created, but not updated.
    Paths []RoutingConfigPathArgs
    A URL path pattern and the rules used to route matching requests.
    Name string
    The user-defined name of the routing config. Can be created, but not updated.
    paths list(object)
    A URL path pattern and the rules used to route matching requests.
    name string
    The user-defined name of the routing config. Can be created, but not updated.
    paths List<RoutingConfigPath>
    A URL path pattern and the rules used to route matching requests.
    name String
    The user-defined name of the routing config. Can be created, but not updated.
    paths RoutingConfigPath[]
    A URL path pattern and the rules used to route matching requests.
    name string
    The user-defined name of the routing config. Can be created, but not updated.
    paths Sequence[RoutingConfigPathArgs]
    A URL path pattern and the rules used to route matching requests.
    name str
    The user-defined name of the routing config. Can be created, but not updated.
    paths List<Property Map>
    A URL path pattern and the rules used to route matching requests.
    name String
    The user-defined name of the routing config. Can be created, but not updated.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the RoutingConfig resource produces the following output properties:

    ActivatedAt string
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    Id string
    The provider-assigned unique ID for this managed resource.
    RoutingConfigId string
    The routing config identifier.
    ActivatedAt string
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    Id string
    The provider-assigned unique ID for this managed resource.
    RoutingConfigId string
    The routing config identifier.
    activated_at string
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    id string
    The provider-assigned unique ID for this managed resource.
    routing_config_id string
    The routing config identifier.
    activatedAt String
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    id String
    The provider-assigned unique ID for this managed resource.
    routingConfigId String
    The routing config identifier.
    activatedAt string
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    id string
    The provider-assigned unique ID for this managed resource.
    routingConfigId string
    The routing config identifier.
    activated_at str
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    id str
    The provider-assigned unique ID for this managed resource.
    routing_config_id str
    The routing config identifier.
    activatedAt String
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    id String
    The provider-assigned unique ID for this managed resource.
    routingConfigId String
    The routing config identifier.

    Look up Existing RoutingConfig Resource

    Get an existing RoutingConfig resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: RoutingConfigState, opts?: CustomResourceOptions): RoutingConfig
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        activated_at: Optional[str] = None,
        name: Optional[str] = None,
        paths: Optional[Sequence[RoutingConfigPathArgs]] = None,
        routing_config_id: Optional[str] = None) -> RoutingConfig
    func GetRoutingConfig(ctx *Context, name string, id IDInput, state *RoutingConfigState, opts ...ResourceOption) (*RoutingConfig, error)
    public static RoutingConfig Get(string name, Input<string> id, RoutingConfigState? state, CustomResourceOptions? opts = null)
    public static RoutingConfig get(String name, Output<String> id, RoutingConfigState state, CustomResourceOptions options)
    resources:  _:    type: fastly:RoutingConfig    get:      id: ${id}
    import {
  to = fastly_routing_config.example
  id = "${id}"
}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    ActivatedAt string
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    Name string
    The user-defined name of the routing config. Can be created, but not updated.
    Paths List<RoutingConfigPath>
    A URL path pattern and the rules used to route matching requests.
    RoutingConfigId string
    The routing config identifier.
    ActivatedAt string
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    Name string
    The user-defined name of the routing config. Can be created, but not updated.
    Paths []RoutingConfigPathArgs
    A URL path pattern and the rules used to route matching requests.
    RoutingConfigId string
    The routing config identifier.
    activated_at string
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    name string
    The user-defined name of the routing config. Can be created, but not updated.
    paths list(object)
    A URL path pattern and the rules used to route matching requests.
    routing_config_id string
    The routing config identifier.
    activatedAt String
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    name String
    The user-defined name of the routing config. Can be created, but not updated.
    paths List<RoutingConfigPath>
    A URL path pattern and the rules used to route matching requests.
    routingConfigId String
    The routing config identifier.
    activatedAt string
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    name string
    The user-defined name of the routing config. Can be created, but not updated.
    paths RoutingConfigPath[]
    A URL path pattern and the rules used to route matching requests.
    routingConfigId string
    The routing config identifier.
    activated_at str
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    name str
    The user-defined name of the routing config. Can be created, but not updated.
    paths Sequence[RoutingConfigPathArgs]
    A URL path pattern and the rules used to route matching requests.
    routing_config_id str
    The routing config identifier.
    activatedAt String
    The date and time the routing config's active version was last activated, in ISO 8601 format.
    name String
    The user-defined name of the routing config. Can be created, but not updated.
    paths List<Property Map>
    A URL path pattern and the rules used to route matching requests.
    routingConfigId String
    The routing config identifier.

    Supporting Types

    RoutingConfigPath, RoutingConfigPathArgs

    Path string
    The URL path pattern (max 2048 characters, starts with /).
    Rules List<RoutingConfigPathRule>
    A conditional routing rule for this path. A rule with no condition blocks is the default (catch-all) rule for the path.
    PathId string
    The path identifier.
    Path string
    The URL path pattern (max 2048 characters, starts with /).
    Rules []RoutingConfigPathRule
    A conditional routing rule for this path. A rule with no condition blocks is the default (catch-all) rule for the path.
    PathId string
    The path identifier.
    path string
    The URL path pattern (max 2048 characters, starts with /).
    rules list(object)
    A conditional routing rule for this path. A rule with no condition blocks is the default (catch-all) rule for the path.
    path_id string
    The path identifier.
    path String
    The URL path pattern (max 2048 characters, starts with /).
    rules List<RoutingConfigPathRule>
    A conditional routing rule for this path. A rule with no condition blocks is the default (catch-all) rule for the path.
    pathId String
    The path identifier.
    path string
    The URL path pattern (max 2048 characters, starts with /).
    rules RoutingConfigPathRule[]
    A conditional routing rule for this path. A rule with no condition blocks is the default (catch-all) rule for the path.
    pathId string
    The path identifier.
    path str
    The URL path pattern (max 2048 characters, starts with /).
    rules Sequence[RoutingConfigPathRule]
    A conditional routing rule for this path. A rule with no condition blocks is the default (catch-all) rule for the path.
    path_id str
    The path identifier.
    path String
    The URL path pattern (max 2048 characters, starts with /).
    rules List<Property Map>
    A conditional routing rule for this path. A rule with no condition blocks is the default (catch-all) rule for the path.
    pathId String
    The path identifier.

    RoutingConfigPathRule, RoutingConfigPathRuleArgs

    ActionType string
    The action type. Currently only service is supported.
    ActionValue string
    The destination for the action (e.g. a service ID when actionType is service).
    Conditions List<RoutingConfigPathRuleCondition>
    A matching criterion evaluated against the incoming request. Omit to make this the default (catch-all) rule for the path.
    IsDefault bool
    Whether this is the catch-all rule for its path (i.e. it has no conditions).
    RuleId string
    The rule identifier.
    ActionType string
    The action type. Currently only service is supported.
    ActionValue string
    The destination for the action (e.g. a service ID when actionType is service).
    Conditions []RoutingConfigPathRuleCondition
    A matching criterion evaluated against the incoming request. Omit to make this the default (catch-all) rule for the path.
    IsDefault bool
    Whether this is the catch-all rule for its path (i.e. it has no conditions).
    RuleId string
    The rule identifier.
    action_type string
    The action type. Currently only service is supported.
    action_value string
    The destination for the action (e.g. a service ID when actionType is service).
    conditions list(object)
    A matching criterion evaluated against the incoming request. Omit to make this the default (catch-all) rule for the path.
    is_default bool
    Whether this is the catch-all rule for its path (i.e. it has no conditions).
    rule_id string
    The rule identifier.
    actionType String
    The action type. Currently only service is supported.
    actionValue String
    The destination for the action (e.g. a service ID when actionType is service).
    conditions List<RoutingConfigPathRuleCondition>
    A matching criterion evaluated against the incoming request. Omit to make this the default (catch-all) rule for the path.
    isDefault Boolean
    Whether this is the catch-all rule for its path (i.e. it has no conditions).
    ruleId String
    The rule identifier.
    actionType string
    The action type. Currently only service is supported.
    actionValue string
    The destination for the action (e.g. a service ID when actionType is service).
    conditions RoutingConfigPathRuleCondition[]
    A matching criterion evaluated against the incoming request. Omit to make this the default (catch-all) rule for the path.
    isDefault boolean
    Whether this is the catch-all rule for its path (i.e. it has no conditions).
    ruleId string
    The rule identifier.
    action_type str
    The action type. Currently only service is supported.
    action_value str
    The destination for the action (e.g. a service ID when actionType is service).
    conditions Sequence[RoutingConfigPathRuleCondition]
    A matching criterion evaluated against the incoming request. Omit to make this the default (catch-all) rule for the path.
    is_default bool
    Whether this is the catch-all rule for its path (i.e. it has no conditions).
    rule_id str
    The rule identifier.
    actionType String
    The action type. Currently only service is supported.
    actionValue String
    The destination for the action (e.g. a service ID when actionType is service).
    conditions List<Property Map>
    A matching criterion evaluated against the incoming request. Omit to make this the default (catch-all) rule for the path.
    isDefault Boolean
    Whether this is the catch-all rule for its path (i.e. it has no conditions).
    ruleId String
    The rule identifier.

    RoutingConfigPathRuleCondition, RoutingConfigPathRuleConditionArgs

    Operator string
    The comparison operator used to evaluate value against the request. One of equals, startsWith, endsWith, or contains.
    Type string
    The condition category. Currently only header is supported.
    Value string
    The value compared against the request using operator.
    Key string
    The header name to match against. Only applicable when type is header.
    Operator string
    The comparison operator used to evaluate value against the request. One of equals, startsWith, endsWith, or contains.
    Type string
    The condition category. Currently only header is supported.
    Value string
    The value compared against the request using operator.
    Key string
    The header name to match against. Only applicable when type is header.
    operator string
    The comparison operator used to evaluate value against the request. One of equals, startsWith, endsWith, or contains.
    type string
    The condition category. Currently only header is supported.
    value string
    The value compared against the request using operator.
    key string
    The header name to match against. Only applicable when type is header.
    operator String
    The comparison operator used to evaluate value against the request. One of equals, startsWith, endsWith, or contains.
    type String
    The condition category. Currently only header is supported.
    value String
    The value compared against the request using operator.
    key String
    The header name to match against. Only applicable when type is header.
    operator string
    The comparison operator used to evaluate value against the request. One of equals, startsWith, endsWith, or contains.
    type string
    The condition category. Currently only header is supported.
    value string
    The value compared against the request using operator.
    key string
    The header name to match against. Only applicable when type is header.
    operator str
    The comparison operator used to evaluate value against the request. One of equals, startsWith, endsWith, or contains.
    type str
    The condition category. Currently only header is supported.
    value str
    The value compared against the request using operator.
    key str
    The header name to match against. Only applicable when type is header.
    operator String
    The comparison operator used to evaluate value against the request. One of equals, startsWith, endsWith, or contains.
    type String
    The condition category. Currently only header is supported.
    value String
    The value compared against the request using operator.
    key String
    The header name to match against. Only applicable when type is header.

    Import

    Routing configs can be imported using their ID, e.g.

    $ pulumi import fastly:index/routingConfig:RoutingConfig example <routing_config_id>

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Fastly pulumi/pulumi-fastly
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the fastly Terraform Provider.
    fastly logo
    Viewing docs for Fastly v12.8.1
    published on Tuesday, Oct 13, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-fastly

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial