AgentcoreGatewayRule class

Manages an AWS Bedrock AgentCore Gateway Rule. Rules define conditions and actions that control how requests are routed and processed through a gateway, including principal-based access control, path-based routing, weighted target routing, and configuration bundle overrides. Rules are evaluated in order of priority (lower numbers first).

Example Usage

Route to a Static Target

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

const example = new aws.bedrock.AgentcoreGatewayRule("example", {
    actions: [{
        routeToTarget: {
            staticRoute: {
                targetName: exampleAwsBedrockagentcoreGatewayTarget.name,
            },
        },
    }],
    gatewayIdentifier: exampleAwsBedrockagentcoreGateway.gatewayId,
    priority: 100,
    description: "Route all requests to the primary target",
});
import pulumi
import pulumi_aws as aws

example = aws.bedrock.AgentcoreGatewayRule("example",
    actions=[{
        "route_to_target": {
            "static_route": {
                "target_name": example_aws_bedrockagentcore_gateway_target["name"],
            },
        },
    }],
    gateway_identifier=example_aws_bedrockagentcore_gateway["gatewayId"],
    priority=100,
    description="Route all requests to the primary target")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Bedrock.AgentcoreGatewayRule("example", new()
    {
        Actions = new[]
        {
            new Aws.Bedrock.Inputs.AgentcoreGatewayRuleActionArgs
            {
                RouteToTarget = new Aws.Bedrock.Inputs.AgentcoreGatewayRuleActionRouteToTargetArgs
                {
                    StaticRoute = new Aws.Bedrock.Inputs.AgentcoreGatewayRuleActionRouteToTargetStaticRouteArgs
                    {
                        TargetName = exampleAwsBedrockagentcoreGatewayTarget.Name,
                    },
                },
            },
        },
        GatewayIdentifier = exampleAwsBedrockagentcoreGateway.GatewayId,
        Priority = 100,
        Description = "Route all requests to the primary target",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/bedrock"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bedrock.NewAgentcoreGatewayRule(ctx, "example", &bedrock.AgentcoreGatewayRuleArgs{
			Actions: bedrock.AgentcoreGatewayRuleActionArray{
				&bedrock.AgentcoreGatewayRuleActionArgs{
					RouteToTarget: &bedrock.AgentcoreGatewayRuleActionRouteToTargetArgs{
						StaticRoute: &bedrock.AgentcoreGatewayRuleActionRouteToTargetStaticRouteArgs{
							TargetName: pulumi.Any(exampleAwsBedrockagentcoreGatewayTarget.Name),
						},
					},
				},
			},
			GatewayIdentifier: pulumi.Any(exampleAwsBedrockagentcoreGateway.GatewayId),
			Priority:          pulumi.Int(100),
			Description:       pulumi.String("Route all requests to the primary target"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcoregatewayrule" "example" {
  actions {
    route_to_target = {
      static_route = {
        target_name = exampleAwsBedrockagentcoreGatewayTarget.name
      }
    }
  }
  gateway_identifier = exampleAwsBedrockagentcoreGateway.gatewayId
  priority           = 100
  description        = "Route all requests to the primary target"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreGatewayRule;
import com.pulumi.aws.bedrock.AgentcoreGatewayRuleArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleActionArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleActionRouteToTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleActionRouteToTargetStaticRouteArgs;
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 AgentcoreGatewayRule("example", AgentcoreGatewayRuleArgs.builder()
            .actions(AgentcoreGatewayRuleActionArgs.builder()
                .routeToTarget(AgentcoreGatewayRuleActionRouteToTargetArgs.builder()
                    .staticRoute(AgentcoreGatewayRuleActionRouteToTargetStaticRouteArgs.builder()
                        .targetName(exampleAwsBedrockagentcoreGatewayTarget.name())
                        .build())
                    .build())
                .build())
            .gatewayIdentifier(exampleAwsBedrockagentcoreGateway.gatewayId())
            .priority(100)
            .description("Route all requests to the primary target")
            .build());

    }
}
resources:
  example:
    type: aws:bedrock:AgentcoreGatewayRule
    properties:
      actions:
        - routeToTarget:
            staticRoute:
              targetName: ${exampleAwsBedrockagentcoreGatewayTarget.name}
      gatewayIdentifier: ${exampleAwsBedrockagentcoreGateway.gatewayId}
      priority: 100
      description: Route all requests to the primary target

Weighted Route (Canary Traffic Split)

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

const canary = new aws.bedrock.AgentcoreGatewayRule("canary", {
    actions: [{
        routeToTarget: {
            weightedRoute: {
                trafficSplits: [
                    {
                        name: "primary",
                        targetName: primary.name,
                        weight: 90,
                    },
                    {
                        name: "canary",
                        targetName: canaryAwsBedrockagentcoreGatewayTarget.name,
                        weight: 10,
                    },
                ],
            },
        },
    }],
    gatewayIdentifier: example.gatewayId,
    priority: 100,
});
import pulumi
import pulumi_aws as aws

canary = aws.bedrock.AgentcoreGatewayRule("canary",
    actions=[{
        "route_to_target": {
            "weighted_route": {
                "traffic_splits": [
                    {
                        "name": "primary",
                        "target_name": primary["name"],
                        "weight": 90,
                    },
                    {
                        "name": "canary",
                        "target_name": canary_aws_bedrockagentcore_gateway_target["name"],
                        "weight": 10,
                    },
                ],
            },
        },
    }],
    gateway_identifier=example["gatewayId"],
    priority=100)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var canary = new Aws.Bedrock.AgentcoreGatewayRule("canary", new()
    {
        Actions = new[]
        {
            new Aws.Bedrock.Inputs.AgentcoreGatewayRuleActionArgs
            {
                RouteToTarget = new Aws.Bedrock.Inputs.AgentcoreGatewayRuleActionRouteToTargetArgs
                {
                    WeightedRoute = new Aws.Bedrock.Inputs.AgentcoreGatewayRuleActionRouteToTargetWeightedRouteArgs
                    {
                        TrafficSplits = new[]
                        {
                            new Aws.Bedrock.Inputs.AgentcoreGatewayRuleActionRouteToTargetWeightedRouteTrafficSplitArgs
                            {
                                Name = "primary",
                                TargetName = primary.Name,
                                Weight = 90,
                            },
                            new Aws.Bedrock.Inputs.AgentcoreGatewayRuleActionRouteToTargetWeightedRouteTrafficSplitArgs
                            {
                                Name = "canary",
                                TargetName = canaryAwsBedrockagentcoreGatewayTarget.Name,
                                Weight = 10,
                            },
                        },
                    },
                },
            },
        },
        GatewayIdentifier = example.GatewayId,
        Priority = 100,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/bedrock"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bedrock.NewAgentcoreGatewayRule(ctx, "canary", &bedrock.AgentcoreGatewayRuleArgs{
			Actions: bedrock.AgentcoreGatewayRuleActionArray{
				&bedrock.AgentcoreGatewayRuleActionArgs{
					RouteToTarget: &bedrock.AgentcoreGatewayRuleActionRouteToTargetArgs{
						WeightedRoute: &bedrock.AgentcoreGatewayRuleActionRouteToTargetWeightedRouteArgs{
							TrafficSplits: bedrock.AgentcoreGatewayRuleActionRouteToTargetWeightedRouteTrafficSplitArray{
								&bedrock.AgentcoreGatewayRuleActionRouteToTargetWeightedRouteTrafficSplitArgs{
									Name:       pulumi.String("primary"),
									TargetName: pulumi.Any(primary.Name),
									Weight:     pulumi.Int(90),
								},
								&bedrock.AgentcoreGatewayRuleActionRouteToTargetWeightedRouteTrafficSplitArgs{
									Name:       pulumi.String("canary"),
									TargetName: pulumi.Any(canaryAwsBedrockagentcoreGatewayTarget.Name),
									Weight:     pulumi.Int(10),
								},
							},
						},
					},
				},
			},
			GatewayIdentifier: pulumi.Any(example.GatewayId),
			Priority:          pulumi.Int(100),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcoregatewayrule" "canary" {
  actions {
    route_to_target = {
      weighted_route = {
        traffic_splits = [{
          "name"       = "primary"
          "targetName" = primary.name
          "weight"     = 90
          }, {
          "name"       = "canary"
          "targetName" = canaryAwsBedrockagentcoreGatewayTarget.name
          "weight"     = 10
        }]
      }
    }
  }
  gateway_identifier = example.gatewayId
  priority           = 100
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreGatewayRule;
import com.pulumi.aws.bedrock.AgentcoreGatewayRuleArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleActionArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleActionRouteToTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleActionRouteToTargetWeightedRouteArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleActionRouteToTargetWeightedRouteTrafficSplitArgs;
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 canary = new AgentcoreGatewayRule("canary", AgentcoreGatewayRuleArgs.builder()
            .actions(AgentcoreGatewayRuleActionArgs.builder()
                .routeToTarget(AgentcoreGatewayRuleActionRouteToTargetArgs.builder()
                    .weightedRoute(AgentcoreGatewayRuleActionRouteToTargetWeightedRouteArgs.builder()
                        .trafficSplits(
                            AgentcoreGatewayRuleActionRouteToTargetWeightedRouteTrafficSplitArgs.builder()
                                .name("primary")
                                .targetName(primary.name())
                                .weight(90)
                                .build(),
                            AgentcoreGatewayRuleActionRouteToTargetWeightedRouteTrafficSplitArgs.builder()
                                .name("canary")
                                .targetName(canaryAwsBedrockagentcoreGatewayTarget.name())
                                .weight(10)
                                .build())
                        .build())
                    .build())
                .build())
            .gatewayIdentifier(example.gatewayId())
            .priority(100)
            .build());

    }
}
resources:
  canary:
    type: aws:bedrock:AgentcoreGatewayRule
    properties:
      actions:
        - routeToTarget:
            weightedRoute:
              trafficSplits:
                - name: primary
                  targetName: ${primary.name}
                  weight: 90
                - name: canary
                  targetName: ${canaryAwsBedrockagentcoreGatewayTarget.name}
                  weight: 10
      gatewayIdentifier: ${example.gatewayId}
      priority: 100

Match on IAM Principals and Paths

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

const current = aws.getCallerIdentity({});
const currentGetPartition = aws.getPartition({});
const restricted = new aws.bedrock.AgentcoreGatewayRule("restricted", {
    actions: [{
        routeToTarget: {
            staticRoute: {
                targetName: example.name,
            },
        },
    }],
    conditions: [
        {
            matchPrincipals: {
                anyOfs: [{
                    iamPrincipal: {
                        arn: Promise.all([currentGetPartition, current]).then(([currentGetPartition, current]) => `arn:${currentGetPartition.partition}:iam::${current.accountId}:role/agentcore-caller-*`),
                        operator: "StringLike",
                    },
                }],
            },
        },
        {
            matchPaths: {
                anyOfs: ["/api/*"],
            },
        },
    ],
    gatewayIdentifier: exampleAwsBedrockagentcoreGateway.gatewayId,
    priority: 50,
});
import pulumi
import pulumi_aws as aws

current = aws.get_caller_identity()
current_get_partition = aws.get_partition()
restricted = aws.bedrock.AgentcoreGatewayRule("restricted",
    actions=[{
        "route_to_target": {
            "static_route": {
                "target_name": example["name"],
            },
        },
    }],
    conditions=[
        {
            "match_principals": {
                "any_ofs": [{
                    "iam_principal": {
                        "arn": f"arn:{current_get_partition.partition}:iam::{current.account_id}:role/agentcore-caller-*",
                        "operator": "StringLike",
                    },
                }],
            },
        },
        {
            "match_paths": {
                "any_ofs": ["/api/*"],
            },
        },
    ],
    gateway_identifier=example_aws_bedrockagentcore_gateway["gatewayId"],
    priority=50)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var current = Aws.GetCallerIdentity.Invoke();

    var currentGetPartition = Aws.GetPartition.Invoke();

    var restricted = new Aws.Bedrock.AgentcoreGatewayRule("restricted", new()
    {
        Actions = new[]
        {
            new Aws.Bedrock.Inputs.AgentcoreGatewayRuleActionArgs
            {
                RouteToTarget = new Aws.Bedrock.Inputs.AgentcoreGatewayRuleActionRouteToTargetArgs
                {
                    StaticRoute = new Aws.Bedrock.Inputs.AgentcoreGatewayRuleActionRouteToTargetStaticRouteArgs
                    {
                        TargetName = example.Name,
                    },
                },
            },
        },
        Conditions = new[]
        {
            new Aws.Bedrock.Inputs.AgentcoreGatewayRuleConditionArgs
            {
                MatchPrincipals = new Aws.Bedrock.Inputs.AgentcoreGatewayRuleConditionMatchPrincipalsArgs
                {
                    AnyOfs = new[]
                    {
                        new Aws.Bedrock.Inputs.AgentcoreGatewayRuleConditionMatchPrincipalsAnyOfArgs
                        {
                            IamPrincipal = new Aws.Bedrock.Inputs.AgentcoreGatewayRuleConditionMatchPrincipalsAnyOfIamPrincipalArgs
                            {
                                Arn = Output.Tuple(currentGetPartition, current).Apply(values =>
                                {
                                    var currentGetPartition = values.Item1;
                                    var current = values.Item2;
                                    return $"arn:{currentGetPartition.Apply(getPartitionResult => getPartitionResult.Partition)}:iam::{current.Apply(getCallerIdentityResult => getCallerIdentityResult.AccountId)}:role/agentcore-caller-*";
                                }),
                                Operator = "StringLike",
                            },
                        },
                    },
                },
            },
            new Aws.Bedrock.Inputs.AgentcoreGatewayRuleConditionArgs
            {
                MatchPaths = new Aws.Bedrock.Inputs.AgentcoreGatewayRuleConditionMatchPathsArgs
                {
                    AnyOfs = new[]
                    {
                        "/api/*",
                    },
                },
            },
        },
        GatewayIdentifier = exampleAwsBedrockagentcoreGateway.GatewayId,
        Priority = 50,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/bedrock"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := aws.GetCallerIdentity(ctx, &aws.GetCallerIdentityArgs{}, nil)
		if err != nil {
			return err
		}
		currentGetPartition, err := aws.GetPartition(ctx, &aws.GetPartitionArgs{}, nil)
		if err != nil {
			return err
		}
		_, err = bedrock.NewAgentcoreGatewayRule(ctx, "restricted", &bedrock.AgentcoreGatewayRuleArgs{
			Actions: bedrock.AgentcoreGatewayRuleActionArray{
				&bedrock.AgentcoreGatewayRuleActionArgs{
					RouteToTarget: &bedrock.AgentcoreGatewayRuleActionRouteToTargetArgs{
						StaticRoute: &bedrock.AgentcoreGatewayRuleActionRouteToTargetStaticRouteArgs{
							TargetName: pulumi.Any(example.Name),
						},
					},
				},
			},
			Conditions: bedrock.AgentcoreGatewayRuleConditionArray{
				&bedrock.AgentcoreGatewayRuleConditionArgs{
					MatchPrincipals: &bedrock.AgentcoreGatewayRuleConditionMatchPrincipalsArgs{
						AnyOfs: bedrock.AgentcoreGatewayRuleConditionMatchPrincipalsAnyOfArray{
							&bedrock.AgentcoreGatewayRuleConditionMatchPrincipalsAnyOfArgs{
								IamPrincipal: &bedrock.AgentcoreGatewayRuleConditionMatchPrincipalsAnyOfIamPrincipalArgs{
									Arn:      pulumi.Sprintf("arn:%v:iam::%v:role/agentcore-caller-*", currentGetPartition.Partition, current.AccountId),
									Operator: pulumi.String("StringLike"),
								},
							},
						},
					},
				},
				&bedrock.AgentcoreGatewayRuleConditionArgs{
					MatchPaths: &bedrock.AgentcoreGatewayRuleConditionMatchPathsArgs{
						AnyOfs: pulumi.StringArray{
							pulumi.String("/api/*"),
						},
					},
				},
			},
			GatewayIdentifier: pulumi.Any(exampleAwsBedrockagentcoreGateway.GatewayId),
			Priority:          pulumi.Int(50),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_getcalleridentity" "current" {
}
data "aws_getpartition" "currentGetPartition" {
}

resource "aws_bedrock_agentcoregatewayrule" "restricted" {
  actions {
    route_to_target = {
      static_route = {
        target_name = example.name
      }
    }
  }
  conditions {
    match_principals = {
      any_ofs = [{
        "iamPrincipal" = {
          "arn"      ="arn:${data.aws_getpartition.currentGetPartition.partition}:iam::${data.aws_getcalleridentity.current.account_id}:role/agentcore-caller-*"
          "operator" = "StringLike"
        }
      }]
    }
  }
  conditions {
    match_paths = {
      any_ofs = ["/api/*"]
    }
  }
  gateway_identifier = exampleAwsBedrockagentcoreGateway.gatewayId
  priority           = 50
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.inputs.GetCallerIdentityArgs;
import com.pulumi.aws.inputs.GetPartitionArgs;
import com.pulumi.aws.bedrock.AgentcoreGatewayRule;
import com.pulumi.aws.bedrock.AgentcoreGatewayRuleArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleActionArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleActionRouteToTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleActionRouteToTargetStaticRouteArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleConditionArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleConditionMatchPrincipalsArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleConditionMatchPrincipalsAnyOfArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleConditionMatchPrincipalsAnyOfIamPrincipalArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayRuleConditionMatchPathsArgs;
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) {
        final var current = AwsFunctions.getCallerIdentity(GetCallerIdentityArgs.builder()
            .build());

        final var currentGetPartition = AwsFunctions.getPartition(GetPartitionArgs.builder()
            .build());

        var restricted = new AgentcoreGatewayRule("restricted", AgentcoreGatewayRuleArgs.builder()
            .actions(AgentcoreGatewayRuleActionArgs.builder()
                .routeToTarget(AgentcoreGatewayRuleActionRouteToTargetArgs.builder()
                    .staticRoute(AgentcoreGatewayRuleActionRouteToTargetStaticRouteArgs.builder()
                        .targetName(example.name())
                        .build())
                    .build())
                .build())
            .conditions(
                AgentcoreGatewayRuleConditionArgs.builder()
                    .matchPrincipals(AgentcoreGatewayRuleConditionMatchPrincipalsArgs.builder()
                        .anyOfs(AgentcoreGatewayRuleConditionMatchPrincipalsAnyOfArgs.builder()
                            .iamPrincipal(AgentcoreGatewayRuleConditionMatchPrincipalsAnyOfIamPrincipalArgs.builder()
                                .arn(String.format("arn:%s:iam::%s:role/agentcore-caller-*", currentGetPartition.partition(),current.accountId()))
                                .operator("StringLike")
                                .build())
                            .build())
                        .build())
                    .build(),
                AgentcoreGatewayRuleConditionArgs.builder()
                    .matchPaths(AgentcoreGatewayRuleConditionMatchPathsArgs.builder()
                        .anyOfs("/api/*")
                        .build())
                    .build())
            .gatewayIdentifier(exampleAwsBedrockagentcoreGateway.gatewayId())
            .priority(50)
            .build());

    }
}
resources:
  restricted:
    type: aws:bedrock:AgentcoreGatewayRule
    properties:
      actions:
        - routeToTarget:
            staticRoute:
              targetName: ${example.name}
      conditions:
        - matchPrincipals:
            anyOfs:
              - iamPrincipal:
                  arn: arn:${currentGetPartition.partition}:iam::${current.accountId}:role/agentcore-caller-*
                  operator: StringLike
        - matchPaths:
            anyOfs:
              - /api/*
      gatewayIdentifier: ${exampleAwsBedrockagentcoreGateway.gatewayId}
      priority: 50
variables:
  current:
    fn::invoke:
      function: aws:getCallerIdentity
      arguments: {}
  currentGetPartition:
    fn::invoke:
      function: aws:getPartition
      arguments: {}

Import

Identity Schema

Required

  • gatewayIdentifier (String) Identifier of the gateway.
  • ruleId (String) Identifier of the rule.

Optional

  • accountId (String) AWS Account where this resource is managed.
  • region (String) Region where this resource is managed.

Using pulumi import, import gateway rules using gatewayIdentifier and ruleId separated by a comma (,). For example:

$ pulumi import aws:bedrock/agentcoreGatewayRule:AgentcoreGatewayRule example example-gateway-abcdef1234,11111111-2222-3333-4444-555555555555

Constructors

AgentcoreGatewayRule(String name, {AgentcoreGatewayRuleArgs? args, CustomResourceOptions? options})
Creates a new AgentcoreGatewayRule. name The Pulumi resource name. args Arguments used to configure this AgentcoreGatewayRule. The set of arguments for AgentcoreGatewayRule. options Resource options controlling this resource's behavior.
AgentcoreGatewayRule.reference(String urn)
Creates a typed reference to an existing AgentcoreGatewayRule resource.

Properties

actions ↔ Output<List<AgentcoreGatewayRuleAction>?>
One or two action blocks defining what happens when the rule's conditions match. See Action below.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
conditions ↔ Output<List<AgentcoreGatewayRuleCondition>?>
Up to two condition blocks that must all be satisfied for the rule's actions to apply. See Condition below.
latefinal
description ↔ Output<String>
Description of the rule. Between 1 and 256 characters.
latefinal
gatewayArn ↔ Output<String>
ARN of the gateway that owns the rule.
latefinal
gatewayIdentifier ↔ Output<String>
Identifier of the gateway to attach the rule to.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
priority ↔ Output<int>
Priority of the rule, between 1 and 1000000. Rules are evaluated in ascending order of priority.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
ruleId ↔ Output<String>
Identifier of the rule.
latefinal
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
systems ↔ Output<List<AgentcoreGatewayRuleSystem>>
Present when the rule is system-managed. See system Block below.
latefinal
timeouts ↔ Output<AgentcoreGatewayRuleTimeouts?>
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {AgentcoreGatewayRuleState? state, CustomResourceOptions? options}) → AgentcoreGatewayRule
Gets an existing AgentcoreGatewayRule resource's state with the given name and id.