AgentcoreGatewayTarget class

Manages an AWS Bedrock AgentCore Gateway Target. Gateway targets define the endpoints and configurations that a gateway can invoke, such as Lambda functions, APIs, or AgentCore Runtime agents, allowing agents to interact with external services through the Model Context Protocol (MCP) or by routing HTTP traffic directly to a runtime.

Example Usage

Lambda Target with Gateway IAM Role

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

const gatewayAssume = aws.iam.getPolicyDocument({
    statements: [{
        principals: [{
            type: "Service",
            identifiers: ["bedrock-agentcore.amazonaws.com"],
        }],
        effect: "Allow",
        actions: ["sts:AssumeRole"],
    }],
});
const gatewayRole = new aws.iam.Role("gateway_role", {
    name: "bedrock-gateway-role",
    assumeRolePolicy: gatewayAssume.then(gatewayAssume => gatewayAssume.json),
});
const lambdaAssume = aws.iam.getPolicyDocument({
    statements: [{
        principals: [{
            type: "Service",
            identifiers: ["lambda.amazonaws.com"],
        }],
        effect: "Allow",
        actions: ["sts:AssumeRole"],
    }],
});
const lambdaRole = new aws.iam.Role("lambda_role", {
    name: "example-lambda-role",
    assumeRolePolicy: lambdaAssume.then(lambdaAssume => lambdaAssume.json),
});
const example = new aws.lambda.Function("example", {
    code: new pulumi.asset.FileArchive("example.zip"),
    name: "example-function",
    role: lambdaRole.arn,
    handler: "index.handler",
    runtime: aws.lambda.Runtime.NodeJS24dX,
});
const exampleAgentcoreGateway = new aws.bedrock.AgentcoreGateway("example", {
    authorizerConfiguration: {
        customJwtAuthorizer: {
            discoveryUrl: "https://accounts.google.com/.well-known/openid-configuration",
        },
    },
    name: "example-gateway",
    roleArn: gatewayRole.arn,
});
const exampleAgentcoreGatewayTarget = new aws.bedrock.AgentcoreGatewayTarget("example", {
    credentialProviderConfiguration: {
        gatewayIamRole: {},
    },
    targetConfiguration: {
        mcp: {
            lambda: {
                toolSchema: {
                    inlinePayloads: [{
                        inputSchema: {
                            properties: [
                                {
                                    name: "message",
                                    type: "string",
                                    description: "Message to process",
                                    required: true,
                                },
                                {
                                    properties: [
                                        {
                                            name: "priority",
                                            type: "string",
                                        },
                                        {
                                            items: [{
                                                type: "string",
                                            }],
                                            name: "tags",
                                            type: "array",
                                        },
                                    ],
                                    name: "options",
                                    type: "object",
                                },
                            ],
                            type: "object",
                            description: "Request processing schema",
                        },
                        outputSchema: {
                            properties: [
                                {
                                    name: "status",
                                    type: "string",
                                    required: true,
                                },
                                {
                                    name: "result",
                                    type: "string",
                                },
                            ],
                            type: "object",
                        },
                        name: "process_request",
                        description: "Process incoming requests",
                    }],
                },
                lambdaArn: example.arn,
            },
        },
    },
    name: "example-target",
    gatewayIdentifier: exampleAgentcoreGateway.gatewayId,
    description: "Lambda function target for processing requests",
});
import pulumi
import pulumi_aws as aws

gateway_assume = aws.iam.get_policy_document(statements=[{
    "principals": [{
        "type": "Service",
        "identifiers": ["bedrock-agentcore.amazonaws.com"],
    }],
    "effect": "Allow",
    "actions": ["sts:AssumeRole"],
}])
gateway_role = aws.iam.Role("gateway_role",
    name="bedrock-gateway-role",
    assume_role_policy=gateway_assume.json)
lambda_assume = aws.iam.get_policy_document(statements=[{
    "principals": [{
        "type": "Service",
        "identifiers": ["lambda.amazonaws.com"],
    }],
    "effect": "Allow",
    "actions": ["sts:AssumeRole"],
}])
lambda_role = aws.iam.Role("lambda_role",
    name="example-lambda-role",
    assume_role_policy=lambda_assume.json)
example = aws.lambda_.Function("example",
    code=pulumi.FileArchive("example.zip"),
    name="example-function",
    role=lambda_role.arn,
    handler="index.handler",
    runtime=aws.lambda_.Runtime.NODE_JS24D_X)
example_agentcore_gateway = aws.bedrock.AgentcoreGateway("example",
    authorizer_configuration={
        "custom_jwt_authorizer": {
            "discovery_url": "https://accounts.google.com/.well-known/openid-configuration",
        },
    },
    name="example-gateway",
    role_arn=gateway_role.arn)
example_agentcore_gateway_target = aws.bedrock.AgentcoreGatewayTarget("example",
    credential_provider_configuration={
        "gateway_iam_role": {},
    },
    target_configuration={
        "mcp": {
            "lambda_": {
                "tool_schema": {
                    "inline_payloads": [{
                        "input_schema": {
                            "properties": [
                                {
                                    "name": "message",
                                    "type": "string",
                                    "description": "Message to process",
                                    "required": True,
                                },
                                {
                                    "properties": [
                                        {
                                            "name": "priority",
                                            "type": "string",
                                        },
                                        {
                                            "items": [{
                                                "type": "string",
                                            }],
                                            "name": "tags",
                                            "type": "array",
                                        },
                                    ],
                                    "name": "options",
                                    "type": "object",
                                },
                            ],
                            "type": "object",
                            "description": "Request processing schema",
                        },
                        "output_schema": {
                            "properties": [
                                {
                                    "name": "status",
                                    "type": "string",
                                    "required": True,
                                },
                                {
                                    "name": "result",
                                    "type": "string",
                                },
                            ],
                            "type": "object",
                        },
                        "name": "process_request",
                        "description": "Process incoming requests",
                    }],
                },
                "lambda_arn": example.arn,
            },
        },
    },
    name="example-target",
    gateway_identifier=example_agentcore_gateway.gateway_id,
    description="Lambda function target for processing requests")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var gatewayAssume = Aws.Iam.GetPolicyDocument.Invoke(new()
    {
        Statements = new[]
        {
            new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
            {
                Principals = new[]
                {
                    new Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalInputArgs
                    {
                        Type = "Service",
                        Identifiers = new[]
                        {
                            "bedrock-agentcore.amazonaws.com",
                        },
                    },
                },
                Effect = "Allow",
                Actions = new[]
                {
                    "sts:AssumeRole",
                },
            },
        },
    });

    var gatewayRole = new Aws.Iam.Role("gateway_role", new()
    {
        Name = "bedrock-gateway-role",
        AssumeRolePolicy = gatewayAssume.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json),
    });

    var lambdaAssume = Aws.Iam.GetPolicyDocument.Invoke(new()
    {
        Statements = new[]
        {
            new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
            {
                Principals = new[]
                {
                    new Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalInputArgs
                    {
                        Type = "Service",
                        Identifiers = new[]
                        {
                            "lambda.amazonaws.com",
                        },
                    },
                },
                Effect = "Allow",
                Actions = new[]
                {
                    "sts:AssumeRole",
                },
            },
        },
    });

    var lambdaRole = new Aws.Iam.Role("lambda_role", new()
    {
        Name = "example-lambda-role",
        AssumeRolePolicy = lambdaAssume.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json),
    });

    var example = new Aws.Lambda.Function("example", new()
    {
        Code = new FileArchive("example.zip"),
        Name = "example-function",
        Role = lambdaRole.Arn,
        Handler = "index.handler",
        Runtime = Aws.Lambda.Runtime.NodeJS24dX,
    });

    var exampleAgentcoreGateway = new Aws.Bedrock.AgentcoreGateway("example", new()
    {
        AuthorizerConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayAuthorizerConfigurationArgs
        {
            CustomJwtAuthorizer = new Aws.Bedrock.Inputs.AgentcoreGatewayAuthorizerConfigurationCustomJwtAuthorizerArgs
            {
                DiscoveryUrl = "https://accounts.google.com/.well-known/openid-configuration",
            },
        },
        Name = "example-gateway",
        RoleArn = gatewayRole.Arn,
    });

    var exampleAgentcoreGatewayTarget = new Aws.Bedrock.AgentcoreGatewayTarget("example", new()
    {
        CredentialProviderConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetCredentialProviderConfigurationArgs
        {
            GatewayIamRole = null,
        },
        TargetConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationArgs
        {
            Mcp = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs
            {
                Lambda = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs
                {
                    ToolSchema = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs
                    {
                        InlinePayloads = new[]
                        {
                            new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs
                            {
                                InputSchema = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs
                                {
                                    Properties = new[]
                                    {
                                        new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArgs
                                        {
                                            Name = "message",
                                            Type = "string",
                                            Description = "Message to process",
                                            Required = true,
                                        },
                                        new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArgs
                                        {
                                            Properties = new[]
                                            {
                                                new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs
                                                {
                                                    Name = "priority",
                                                    Type = "string",
                                                },
                                                new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs
                                                {
                                                    Items = new[]
                                                    {

                                                        {
                                                            { "type", "string" },
                                                        },
                                                    },
                                                    Name = "tags",
                                                    Type = "array",
                                                },
                                            },
                                            Name = "options",
                                            Type = "object",
                                        },
                                    },
                                    Type = "object",
                                    Description = "Request processing schema",
                                },
                                OutputSchema = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadOutputSchemaArgs
                                {
                                    Properties = new[]
                                    {
                                        new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadOutputSchemaPropertyArgs
                                        {
                                            Name = "status",
                                            Type = "string",
                                            Required = true,
                                        },
                                        new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadOutputSchemaPropertyArgs
                                        {
                                            Name = "result",
                                            Type = "string",
                                        },
                                    },
                                    Type = "object",
                                },
                                Name = "process_request",
                                Description = "Process incoming requests",
                            },
                        },
                    },
                    LambdaArn = example.Arn,
                },
            },
        },
        Name = "example-target",
        GatewayIdentifier = exampleAgentcoreGateway.GatewayId,
        Description = "Lambda function target for processing requests",
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		gatewayAssume, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			Statements: []iam.GetPolicyDocumentStatement{
				{
					Principals: []iam.GetPolicyDocumentStatementPrincipal{
						{
							Type: "Service",
							Identifiers: []string{
								"bedrock-agentcore.amazonaws.com",
							},
						},
					},
					Effect: pulumi.StringRef("Allow"),
					Actions: []string{
						"sts:AssumeRole",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		gatewayRole, err := iam.NewRole(ctx, "gateway_role", &iam.RoleArgs{
			Name:             pulumi.String("bedrock-gateway-role"),
			AssumeRolePolicy: pulumi.String(gatewayAssume.Json),
		})
		if err != nil {
			return err
		}
		lambdaAssume, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			Statements: []iam.GetPolicyDocumentStatement{
				{
					Principals: []iam.GetPolicyDocumentStatementPrincipal{
						{
							Type: "Service",
							Identifiers: []string{
								"lambda.amazonaws.com",
							},
						},
					},
					Effect: pulumi.StringRef("Allow"),
					Actions: []string{
						"sts:AssumeRole",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		lambdaRole, err := iam.NewRole(ctx, "lambda_role", &iam.RoleArgs{
			Name:             pulumi.String("example-lambda-role"),
			AssumeRolePolicy: pulumi.String(lambdaAssume.Json),
		})
		if err != nil {
			return err
		}
		example, err := lambda.NewFunction(ctx, "example", &lambda.FunctionArgs{
			Code:    pulumi.NewFileArchive("example.zip"),
			Name:    pulumi.String("example-function"),
			Role:    lambdaRole.Arn,
			Handler: pulumi.String("index.handler"),
			Runtime: pulumi.String(lambda.RuntimeNodeJS24dX),
		})
		if err != nil {
			return err
		}
		exampleAgentcoreGateway, err := bedrock.NewAgentcoreGateway(ctx, "example", &bedrock.AgentcoreGatewayArgs{
			AuthorizerConfiguration: &bedrock.AgentcoreGatewayAuthorizerConfigurationArgs{
				CustomJwtAuthorizer: &bedrock.AgentcoreGatewayAuthorizerConfigurationCustomJwtAuthorizerArgs{
					DiscoveryUrl: pulumi.String("https://accounts.google.com/.well-known/openid-configuration"),
				},
			},
			Name:    pulumi.String("example-gateway"),
			RoleArn: gatewayRole.Arn,
		})
		if err != nil {
			return err
		}
		_, err = bedrock.NewAgentcoreGatewayTarget(ctx, "example", &bedrock.AgentcoreGatewayTargetArgs{
			CredentialProviderConfiguration: &bedrock.AgentcoreGatewayTargetCredentialProviderConfigurationArgs{
				GatewayIamRole: &bedrock.AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs{},
			},
			TargetConfiguration: &bedrock.AgentcoreGatewayTargetTargetConfigurationArgs{
				Mcp: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpArgs{
					Lambda: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs{
						ToolSchema: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs{
							InlinePayloads: bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArray{
								&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs{
									InputSchema: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs{
										Properties: bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArray{
											&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArgs{
												Name:        pulumi.String("message"),
												Type:        pulumi.String("string"),
												Description: pulumi.String("Message to process"),
												Required:    pulumi.Bool(true),
											},
											&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArgs{
												Properties: bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArray{
													&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs{
														Name: pulumi.String("priority"),
														Type: pulumi.String("string"),
													},
													&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs{
														Items: []map[string]string{
															{
																"type": "string",
															},
														},
														Name: pulumi.String("tags"),
														Type: pulumi.String("array"),
													},
												},
												Name: pulumi.String("options"),
												Type: pulumi.String("object"),
											},
										},
										Type:        pulumi.String("object"),
										Description: pulumi.String("Request processing schema"),
									},
									OutputSchema: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadOutputSchemaArgs{
										Properties: bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadOutputSchemaPropertyArray{
											&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadOutputSchemaPropertyArgs{
												Name:     pulumi.String("status"),
												Type:     pulumi.String("string"),
												Required: pulumi.Bool(true),
											},
											&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadOutputSchemaPropertyArgs{
												Name: pulumi.String("result"),
												Type: pulumi.String("string"),
											},
										},
										Type: pulumi.String("object"),
									},
									Name:        pulumi.String("process_request"),
									Description: pulumi.String("Process incoming requests"),
								},
							},
						},
						LambdaArn: example.Arn,
					},
				},
			},
			Name:              pulumi.String("example-target"),
			GatewayIdentifier: exampleAgentcoreGateway.GatewayId,
			Description:       pulumi.String("Lambda function target for processing requests"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_iam_getpolicydocument" "gatewayAssume" {
  statements {
    principals {
      type        = "Service"
      identifiers = ["bedrock-agentcore.amazonaws.com"]
    }
    effect  = "Allow"
    actions = ["sts:AssumeRole"]
  }
}
data "aws_iam_getpolicydocument" "lambdaAssume" {
  statements {
    principals {
      type        = "Service"
      identifiers = ["lambda.amazonaws.com"]
    }
    effect  = "Allow"
    actions = ["sts:AssumeRole"]
  }
}

resource "aws_iam_role" "gateway_role" {
  name               = "bedrock-gateway-role"
  assume_role_policy = data.aws_iam_getpolicydocument.gatewayAssume.json
}
resource "aws_iam_role" "lambda_role" {
  name               = "example-lambda-role"
  assume_role_policy = data.aws_iam_getpolicydocument.lambdaAssume.json
}
resource "aws_lambda_function" "example" {
  code    = fileArchive("example.zip")
  name    = "example-function"
  role    = aws_iam_role.lambda_role.arn
  handler = "index.handler"
  runtime = "nodejs24.x"
}
resource "aws_bedrock_agentcoregateway" "example" {
  authorizer_configuration = {
    custom_jwt_authorizer = {
      discovery_url = "https://accounts.google.com/.well-known/openid-configuration"
    }
  }
  name     = "example-gateway"
  role_arn = aws_iam_role.gateway_role.arn
}
resource "aws_bedrock_agentcoregatewaytarget" "example" {
  credential_provider_configuration = {
    gateway_iam_role = {}
  }
  target_configuration = {
    mcp = {
      lambda = {
        tool_schema = {
          inline_payloads = [{
            "inputSchema" = {
              "properties" = [{
                "name"        = "message"
                "type"        = "string"
                "description" = "Message to process"
                "required"    = true
                }, {
                "properties" = [{
                  "name" = "priority"
                  "type" = "string"
                  }, {
                  "items" = [{
                    "type" = "string"
                  }]
                  "name" = "tags"
                  "type" = "array"
                }]
                "name" = "options"
                "type" = "object"
              }]
              "type"        = "object"
              "description" = "Request processing schema"
            }
            "outputSchema" = {
              "properties" = [{
                "name"     = "status"
                "type"     = "string"
                "required" = true
                }, {
                "name" = "result"
                "type" = "string"
              }]
              "type" = "object"
            }
            "name"        = "process_request"
            "description" = "Process incoming requests"
          }]
        }
        lambda_arn = aws_lambda_function.example.arn
      }
    }
  }
  name               = "example-target"
  gateway_identifier = aws_bedrock_agentcoregateway.example.gateway_id
  description        = "Lambda function target for processing requests"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.iam.IamFunctions;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentStatementArgs;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentStatementPrincipalArgs;
import com.pulumi.aws.iam.Role;
import com.pulumi.aws.iam.RoleArgs;
import com.pulumi.aws.lambda.Function;
import com.pulumi.aws.lambda.FunctionArgs;
import com.pulumi.aws.bedrock.AgentcoreGateway;
import com.pulumi.aws.bedrock.AgentcoreGatewayArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayAuthorizerConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayAuthorizerConfigurationCustomJwtAuthorizerArgs;
import com.pulumi.aws.bedrock.AgentcoreGatewayTarget;
import com.pulumi.aws.bedrock.AgentcoreGatewayTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetCredentialProviderConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadOutputSchemaArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadOutputSchemaPropertyArgs;
import com.pulumi.asset.FileArchive;
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 gatewayAssume = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
            .statements(GetPolicyDocumentStatementArgs.builder()
                .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                    .type("Service")
                    .identifiers("bedrock-agentcore.amazonaws.com")
                    .build())
                .effect("Allow")
                .actions("sts:AssumeRole")
                .build())
            .build());

        var gatewayRole = new Role("gatewayRole", RoleArgs.builder()
            .name("bedrock-gateway-role")
            .assumeRolePolicy(gatewayAssume.json())
            .build());

        final var lambdaAssume = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
            .statements(GetPolicyDocumentStatementArgs.builder()
                .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                    .type("Service")
                    .identifiers("lambda.amazonaws.com")
                    .build())
                .effect("Allow")
                .actions("sts:AssumeRole")
                .build())
            .build());

        var lambdaRole = new Role("lambdaRole", RoleArgs.builder()
            .name("example-lambda-role")
            .assumeRolePolicy(lambdaAssume.json())
            .build());

        var example = new Function("example", FunctionArgs.builder()
            .code(new FileArchive("example.zip"))
            .name("example-function")
            .role(lambdaRole.arn())
            .handler("index.handler")
            .runtime("nodejs24.x")
            .build());

        var exampleAgentcoreGateway = new AgentcoreGateway("exampleAgentcoreGateway", AgentcoreGatewayArgs.builder()
            .authorizerConfiguration(AgentcoreGatewayAuthorizerConfigurationArgs.builder()
                .customJwtAuthorizer(AgentcoreGatewayAuthorizerConfigurationCustomJwtAuthorizerArgs.builder()
                    .discoveryUrl("https://accounts.google.com/.well-known/openid-configuration")
                    .build())
                .build())
            .name("example-gateway")
            .roleArn(gatewayRole.arn())
            .build());

        var exampleAgentcoreGatewayTarget = new AgentcoreGatewayTarget("exampleAgentcoreGatewayTarget", AgentcoreGatewayTargetArgs.builder()
            .credentialProviderConfiguration(AgentcoreGatewayTargetCredentialProviderConfigurationArgs.builder()
                .gatewayIamRole(AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs.builder()
                    .build())
                .build())
            .targetConfiguration(AgentcoreGatewayTargetTargetConfigurationArgs.builder()
                .mcp(AgentcoreGatewayTargetTargetConfigurationMcpArgs.builder()
                    .lambda(AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs.builder()
                        .toolSchema(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs.builder()
                            .inlinePayloads(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs.builder()
                                .inputSchema(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs.builder()
                                    .properties(
                                        AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArgs.builder()
                                            .name("message")
                                            .type("string")
                                            .description("Message to process")
                                            .required(true)
                                            .build(),
                                        AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArgs.builder()
                                            .properties(
                                                AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs.builder()
                                                    .name("priority")
                                                    .type("string")
                                                    .build(),
                                                AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs.builder()
                                                    .items(Arrays.asList(Map.of("type", "string")))
                                                    .name("tags")
                                                    .type("array")
                                                    .build())
                                            .name("options")
                                            .type("object")
                                            .build())
                                    .type("object")
                                    .description("Request processing schema")
                                    .build())
                                .outputSchema(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadOutputSchemaArgs.builder()
                                    .properties(
                                        AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadOutputSchemaPropertyArgs.builder()
                                            .name("status")
                                            .type("string")
                                            .required(true)
                                            .build(),
                                        AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadOutputSchemaPropertyArgs.builder()
                                            .name("result")
                                            .type("string")
                                            .build())
                                    .type("object")
                                    .build())
                                .name("process_request")
                                .description("Process incoming requests")
                                .build())
                            .build())
                        .lambdaArn(example.arn())
                        .build())
                    .build())
                .build())
            .name("example-target")
            .gatewayIdentifier(exampleAgentcoreGateway.gatewayId())
            .description("Lambda function target for processing requests")
            .build());

    }
}
resources:
  gatewayRole:
    type: aws:iam:Role
    name: gateway_role
    properties:
      name: bedrock-gateway-role
      assumeRolePolicy: ${gatewayAssume.json}
  lambdaRole:
    type: aws:iam:Role
    name: lambda_role
    properties:
      name: example-lambda-role
      assumeRolePolicy: ${lambdaAssume.json}
  example:
    type: aws:lambda:Function
    properties:
      code:
        fn::fileArchive: example.zip
      name: example-function
      role: ${lambdaRole.arn}
      handler: index.handler
      runtime: nodejs24.x
  exampleAgentcoreGateway:
    type: aws:bedrock:AgentcoreGateway
    name: example
    properties:
      authorizerConfiguration:
        customJwtAuthorizer:
          discoveryUrl: https://accounts.google.com/.well-known/openid-configuration
      name: example-gateway
      roleArn: ${gatewayRole.arn}
  exampleAgentcoreGatewayTarget:
    type: aws:bedrock:AgentcoreGatewayTarget
    name: example
    properties:
      credentialProviderConfiguration:
        gatewayIamRole: {}
      targetConfiguration:
        mcp:
          lambda:
            toolSchema:
              inlinePayloads:
                - inputSchema:
                    properties:
                      - name: message
                        type: string
                        description: Message to process
                        required: true
                      - properties:
                          - name: priority
                            type: string
                          - items:
                              - type: string
                            name: tags
                            type: array
                        name: options
                        type: object
                    type: object
                    description: Request processing schema
                  outputSchema:
                    properties:
                      - name: status
                        type: string
                        required: true
                      - name: result
                        type: string
                    type: object
                  name: process_request
                  description: Process incoming requests
            lambdaArn: ${example.arn}
      name: example-target
      gatewayIdentifier: ${exampleAgentcoreGateway.gatewayId}
      description: Lambda function target for processing requests
variables:
  gatewayAssume:
    fn::invoke:
      function: aws:iam:getPolicyDocument
      arguments:
        statements:
          - principals:
              - type: Service
                identifiers:
                  - bedrock-agentcore.amazonaws.com
            effect: Allow
            actions:
              - sts:AssumeRole
  lambdaAssume:
    fn::invoke:
      function: aws:iam:getPolicyDocument
      arguments:
        statements:
          - principals:
              - type: Service
                identifiers:
                  - lambda.amazonaws.com
            effect: Allow
            actions:
              - sts:AssumeRole

Target with API Key Authentication

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

const apiKeyExample = new aws.bedrock.AgentcoreGatewayTarget("api_key_example", {
    credentialProviderConfiguration: {
        apiKey: {
            providerArn: "arn:aws:iam::123456789012:oidc-provider/example.com",
            credentialLocation: "HEADER",
            credentialParameterName: "X-API-Key",
            credentialPrefix: "Bearer",
        },
    },
    targetConfiguration: {
        mcp: {
            lambda: {
                toolSchema: {
                    inlinePayloads: [{
                        inputSchema: {
                            type: "string",
                            description: "Simple string input for API calls",
                        },
                        name: "api_tool",
                        description: "External API integration tool",
                    }],
                },
                lambdaArn: example.arn,
            },
        },
    },
    name: "api-target",
    gatewayIdentifier: exampleAwsBedrockagentcoreGateway.gatewayId,
    description: "External API target with API key authentication",
});
import pulumi
import pulumi_aws as aws

api_key_example = aws.bedrock.AgentcoreGatewayTarget("api_key_example",
    credential_provider_configuration={
        "api_key": {
            "provider_arn": "arn:aws:iam::123456789012:oidc-provider/example.com",
            "credential_location": "HEADER",
            "credential_parameter_name": "X-API-Key",
            "credential_prefix": "Bearer",
        },
    },
    target_configuration={
        "mcp": {
            "lambda_": {
                "tool_schema": {
                    "inline_payloads": [{
                        "input_schema": {
                            "type": "string",
                            "description": "Simple string input for API calls",
                        },
                        "name": "api_tool",
                        "description": "External API integration tool",
                    }],
                },
                "lambda_arn": example["arn"],
            },
        },
    },
    name="api-target",
    gateway_identifier=example_aws_bedrockagentcore_gateway["gatewayId"],
    description="External API target with API key authentication")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var apiKeyExample = new Aws.Bedrock.AgentcoreGatewayTarget("api_key_example", new()
    {
        CredentialProviderConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetCredentialProviderConfigurationArgs
        {
            ApiKey = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetCredentialProviderConfigurationApiKeyArgs
            {
                ProviderArn = "arn:aws:iam::123456789012:oidc-provider/example.com",
                CredentialLocation = "HEADER",
                CredentialParameterName = "X-API-Key",
                CredentialPrefix = "Bearer",
            },
        },
        TargetConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationArgs
        {
            Mcp = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs
            {
                Lambda = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs
                {
                    ToolSchema = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs
                    {
                        InlinePayloads = new[]
                        {
                            new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs
                            {
                                InputSchema = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs
                                {
                                    Type = "string",
                                    Description = "Simple string input for API calls",
                                },
                                Name = "api_tool",
                                Description = "External API integration tool",
                            },
                        },
                    },
                    LambdaArn = example.Arn,
                },
            },
        },
        Name = "api-target",
        GatewayIdentifier = exampleAwsBedrockagentcoreGateway.GatewayId,
        Description = "External API target with API key authentication",
    });

});
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.NewAgentcoreGatewayTarget(ctx, "api_key_example", &bedrock.AgentcoreGatewayTargetArgs{
			CredentialProviderConfiguration: &bedrock.AgentcoreGatewayTargetCredentialProviderConfigurationArgs{
				ApiKey: &bedrock.AgentcoreGatewayTargetCredentialProviderConfigurationApiKeyArgs{
					ProviderArn:             pulumi.String("arn:aws:iam::123456789012:oidc-provider/example.com"),
					CredentialLocation:      pulumi.String("HEADER"),
					CredentialParameterName: pulumi.String("X-API-Key"),
					CredentialPrefix:        pulumi.String("Bearer"),
				},
			},
			TargetConfiguration: &bedrock.AgentcoreGatewayTargetTargetConfigurationArgs{
				Mcp: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpArgs{
					Lambda: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs{
						ToolSchema: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs{
							InlinePayloads: bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArray{
								&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs{
									InputSchema: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs{
										Type:        pulumi.String("string"),
										Description: pulumi.String("Simple string input for API calls"),
									},
									Name:        pulumi.String("api_tool"),
									Description: pulumi.String("External API integration tool"),
								},
							},
						},
						LambdaArn: pulumi.Any(example.Arn),
					},
				},
			},
			Name:              pulumi.String("api-target"),
			GatewayIdentifier: pulumi.Any(exampleAwsBedrockagentcoreGateway.GatewayId),
			Description:       pulumi.String("External API target with API key authentication"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcoregatewaytarget" "api_key_example" {
  credential_provider_configuration = {
    api_key = {
      provider_arn              = "arn:aws:iam::123456789012:oidc-provider/example.com"
      credential_location       = "HEADER"
      credential_parameter_name = "X-API-Key"
      credential_prefix         = "Bearer"
    }
  }
  target_configuration = {
    mcp = {
      lambda = {
        tool_schema = {
          inline_payloads = [{
            "inputSchema" = {
              "type"        = "string"
              "description" = "Simple string input for API calls"
            }
            "name"        = "api_tool"
            "description" = "External API integration tool"
          }]
        }
        lambda_arn = example.arn
      }
    }
  }
  name               = "api-target"
  gateway_identifier = exampleAwsBedrockagentcoreGateway.gatewayId
  description        = "External API target with API key authentication"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreGatewayTarget;
import com.pulumi.aws.bedrock.AgentcoreGatewayTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetCredentialProviderConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetCredentialProviderConfigurationApiKeyArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs;
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 apiKeyExample = new AgentcoreGatewayTarget("apiKeyExample", AgentcoreGatewayTargetArgs.builder()
            .credentialProviderConfiguration(AgentcoreGatewayTargetCredentialProviderConfigurationArgs.builder()
                .apiKey(AgentcoreGatewayTargetCredentialProviderConfigurationApiKeyArgs.builder()
                    .providerArn("arn:aws:iam::123456789012:oidc-provider/example.com")
                    .credentialLocation("HEADER")
                    .credentialParameterName("X-API-Key")
                    .credentialPrefix("Bearer")
                    .build())
                .build())
            .targetConfiguration(AgentcoreGatewayTargetTargetConfigurationArgs.builder()
                .mcp(AgentcoreGatewayTargetTargetConfigurationMcpArgs.builder()
                    .lambda(AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs.builder()
                        .toolSchema(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs.builder()
                            .inlinePayloads(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs.builder()
                                .inputSchema(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs.builder()
                                    .type("string")
                                    .description("Simple string input for API calls")
                                    .build())
                                .name("api_tool")
                                .description("External API integration tool")
                                .build())
                            .build())
                        .lambdaArn(example.arn())
                        .build())
                    .build())
                .build())
            .name("api-target")
            .gatewayIdentifier(exampleAwsBedrockagentcoreGateway.gatewayId())
            .description("External API target with API key authentication")
            .build());

    }
}
resources:
  apiKeyExample:
    type: aws:bedrock:AgentcoreGatewayTarget
    name: api_key_example
    properties:
      credentialProviderConfiguration:
        apiKey:
          providerArn: arn:aws:iam::123456789012:oidc-provider/example.com
          credentialLocation: HEADER
          credentialParameterName: X-API-Key
          credentialPrefix: Bearer
      targetConfiguration:
        mcp:
          lambda:
            toolSchema:
              inlinePayloads:
                - inputSchema:
                    type: string
                    description: Simple string input for API calls
                  name: api_tool
                  description: External API integration tool
            lambdaArn: ${example.arn}
      name: api-target
      gatewayIdentifier: ${exampleAwsBedrockagentcoreGateway.gatewayId}
      description: External API target with API key authentication

Target with OAuth Authentication

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

const oauthExample = new aws.bedrock.AgentcoreGatewayTarget("oauth_example", {
    credentialProviderConfiguration: {
        oauth: {
            providerArn: "arn:aws:iam::123456789012:oidc-provider/oauth.example.com",
            scopes: [
                "read",
                "write",
            ],
            grantType: "authorization_code",
            defaultReturnUrl: "https://myapp.example.com/callback",
            customParameters: {
                client_type: "confidential",
            },
        },
    },
    targetConfiguration: {
        mcp: {
            lambda: {
                toolSchema: {
                    inlinePayloads: [{
                        inputSchema: {
                            items: {
                                properties: [
                                    {
                                        name: "id",
                                        type: "string",
                                        required: true,
                                    },
                                    {
                                        name: "value",
                                        type: "number",
                                    },
                                ],
                                type: "object",
                            },
                            type: "array",
                        },
                        name: "oauth_tool",
                        description: "OAuth-authenticated service",
                    }],
                },
                lambdaArn: example.arn,
            },
        },
    },
    name: "oauth-target",
    gatewayIdentifier: exampleAwsBedrockagentcoreGateway.gatewayId,
});
import pulumi
import pulumi_aws as aws

oauth_example = aws.bedrock.AgentcoreGatewayTarget("oauth_example",
    credential_provider_configuration={
        "oauth": {
            "provider_arn": "arn:aws:iam::123456789012:oidc-provider/oauth.example.com",
            "scopes": [
                "read",
                "write",
            ],
            "grant_type": "authorization_code",
            "default_return_url": "https://myapp.example.com/callback",
            "custom_parameters": {
                "client_type": "confidential",
            },
        },
    },
    target_configuration={
        "mcp": {
            "lambda_": {
                "tool_schema": {
                    "inline_payloads": [{
                        "input_schema": {
                            "items": {
                                "properties": [
                                    {
                                        "name": "id",
                                        "type": "string",
                                        "required": True,
                                    },
                                    {
                                        "name": "value",
                                        "type": "number",
                                    },
                                ],
                                "type": "object",
                            },
                            "type": "array",
                        },
                        "name": "oauth_tool",
                        "description": "OAuth-authenticated service",
                    }],
                },
                "lambda_arn": example["arn"],
            },
        },
    },
    name="oauth-target",
    gateway_identifier=example_aws_bedrockagentcore_gateway["gatewayId"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var oauthExample = new Aws.Bedrock.AgentcoreGatewayTarget("oauth_example", new()
    {
        CredentialProviderConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetCredentialProviderConfigurationArgs
        {
            Oauth = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetCredentialProviderConfigurationOauthArgs
            {
                ProviderArn = "arn:aws:iam::123456789012:oidc-provider/oauth.example.com",
                Scopes = new[]
                {
                    "read",
                    "write",
                },
                GrantType = "authorization_code",
                DefaultReturnUrl = "https://myapp.example.com/callback",
                CustomParameters =
                {
                    { "client_type", "confidential" },
                },
            },
        },
        TargetConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationArgs
        {
            Mcp = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs
            {
                Lambda = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs
                {
                    ToolSchema = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs
                    {
                        InlinePayloads = new[]
                        {
                            new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs
                            {
                                InputSchema = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs
                                {
                                    Items = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaItemsArgs
                                    {
                                        Properties = new[]
                                        {
                                            new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaItemsPropertyArgs
                                            {
                                                Name = "id",
                                                Type = "string",
                                                Required = true,
                                            },
                                            new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaItemsPropertyArgs
                                            {
                                                Name = "value",
                                                Type = "number",
                                            },
                                        },
                                        Type = "object",
                                    },
                                    Type = "array",
                                },
                                Name = "oauth_tool",
                                Description = "OAuth-authenticated service",
                            },
                        },
                    },
                    LambdaArn = example.Arn,
                },
            },
        },
        Name = "oauth-target",
        GatewayIdentifier = exampleAwsBedrockagentcoreGateway.GatewayId,
    });

});
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.NewAgentcoreGatewayTarget(ctx, "oauth_example", &bedrock.AgentcoreGatewayTargetArgs{
			CredentialProviderConfiguration: &bedrock.AgentcoreGatewayTargetCredentialProviderConfigurationArgs{
				Oauth: &bedrock.AgentcoreGatewayTargetCredentialProviderConfigurationOauthArgs{
					ProviderArn: pulumi.String("arn:aws:iam::123456789012:oidc-provider/oauth.example.com"),
					Scopes: pulumi.StringArray{
						pulumi.String("read"),
						pulumi.String("write"),
					},
					GrantType:        pulumi.String("authorization_code"),
					DefaultReturnUrl: pulumi.String("https://myapp.example.com/callback"),
					CustomParameters: pulumi.StringMap{
						"client_type": pulumi.String("confidential"),
					},
				},
			},
			TargetConfiguration: &bedrock.AgentcoreGatewayTargetTargetConfigurationArgs{
				Mcp: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpArgs{
					Lambda: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs{
						ToolSchema: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs{
							InlinePayloads: bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArray{
								&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs{
									InputSchema: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs{
										Items: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaItemsArgs{
											Properties: bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaItemsPropertyArray{
												&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaItemsPropertyArgs{
													Name:     pulumi.String("id"),
													Type:     pulumi.String("string"),
													Required: pulumi.Bool(true),
												},
												&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaItemsPropertyArgs{
													Name: pulumi.String("value"),
													Type: pulumi.String("number"),
												},
											},
											Type: pulumi.String("object"),
										},
										Type: pulumi.String("array"),
									},
									Name:        pulumi.String("oauth_tool"),
									Description: pulumi.String("OAuth-authenticated service"),
								},
							},
						},
						LambdaArn: pulumi.Any(example.Arn),
					},
				},
			},
			Name:              pulumi.String("oauth-target"),
			GatewayIdentifier: pulumi.Any(exampleAwsBedrockagentcoreGateway.GatewayId),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcoregatewaytarget" "oauth_example" {
  credential_provider_configuration = {
    oauth = {
      provider_arn       = "arn:aws:iam::123456789012:oidc-provider/oauth.example.com"
      scopes             = ["read", "write"]
      grant_type         = "authorization_code"
      default_return_url = "https://myapp.example.com/callback"
      custom_parameters = {
        "client_type" = "confidential"
      }
    }
  }
  target_configuration = {
    mcp = {
      lambda = {
        tool_schema = {
          inline_payloads = [{
            "inputSchema" = {
              "items" = {
                "properties" = [{
                  "name"     = "id"
                  "type"     = "string"
                  "required" = true
                  }, {
                  "name" = "value"
                  "type" = "number"
                }]
                "type" = "object"
              }
              "type" = "array"
            }
            "name"        = "oauth_tool"
            "description" = "OAuth-authenticated service"
          }]
        }
        lambda_arn = example.arn
      }
    }
  }
  name               = "oauth-target"
  gateway_identifier = exampleAwsBedrockagentcoreGateway.gatewayId
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreGatewayTarget;
import com.pulumi.aws.bedrock.AgentcoreGatewayTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetCredentialProviderConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetCredentialProviderConfigurationOauthArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaItemsArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaItemsPropertyArgs;
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 oauthExample = new AgentcoreGatewayTarget("oauthExample", AgentcoreGatewayTargetArgs.builder()
            .credentialProviderConfiguration(AgentcoreGatewayTargetCredentialProviderConfigurationArgs.builder()
                .oauth(AgentcoreGatewayTargetCredentialProviderConfigurationOauthArgs.builder()
                    .providerArn("arn:aws:iam::123456789012:oidc-provider/oauth.example.com")
                    .scopes(
                        "read",
                        "write")
                    .grantType("authorization_code")
                    .defaultReturnUrl("https://myapp.example.com/callback")
                    .customParameters(Map.of("client_type", "confidential"))
                    .build())
                .build())
            .targetConfiguration(AgentcoreGatewayTargetTargetConfigurationArgs.builder()
                .mcp(AgentcoreGatewayTargetTargetConfigurationMcpArgs.builder()
                    .lambda(AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs.builder()
                        .toolSchema(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs.builder()
                            .inlinePayloads(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs.builder()
                                .inputSchema(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs.builder()
                                    .items(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaItemsArgs.builder()
                                        .properties(
                                            AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaItemsPropertyArgs.builder()
                                                .name("id")
                                                .type("string")
                                                .required(true)
                                                .build(),
                                            AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaItemsPropertyArgs.builder()
                                                .name("value")
                                                .type("number")
                                                .build())
                                        .type("object")
                                        .build())
                                    .type("array")
                                    .build())
                                .name("oauth_tool")
                                .description("OAuth-authenticated service")
                                .build())
                            .build())
                        .lambdaArn(example.arn())
                        .build())
                    .build())
                .build())
            .name("oauth-target")
            .gatewayIdentifier(exampleAwsBedrockagentcoreGateway.gatewayId())
            .build());

    }
}
resources:
  oauthExample:
    type: aws:bedrock:AgentcoreGatewayTarget
    name: oauth_example
    properties:
      credentialProviderConfiguration:
        oauth:
          providerArn: arn:aws:iam::123456789012:oidc-provider/oauth.example.com
          scopes:
            - read
            - write
          grantType: authorization_code
          defaultReturnUrl: https://myapp.example.com/callback
          customParameters:
            client_type: confidential
      targetConfiguration:
        mcp:
          lambda:
            toolSchema:
              inlinePayloads:
                - inputSchema:
                    items:
                      properties:
                        - name: id
                          type: string
                          required: true
                        - name: value
                          type: number
                      type: object
                    type: array
                  name: oauth_tool
                  description: OAuth-authenticated service
            lambdaArn: ${example.arn}
      name: oauth-target
      gatewayIdentifier: ${exampleAwsBedrockagentcoreGateway.gatewayId}

Target with IAM SigV4 Authentication (MCP Server)

Use this for mcpServer targets pointing at AWS-hosted SigV4-protected endpoints (e.g. another Bedrock AgentCore Runtime). The gateway signs upstream requests using its own IAM role.

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

const sigv4Example = new aws.bedrock.AgentcoreGatewayTarget("sigv4_example", {
    credentialProviderConfiguration: {
        gatewayIamRole: {
            service: "bedrock-agentcore",
        },
    },
    targetConfiguration: {
        mcp: {
            mcpServer: {
                endpoint: "https://example-runtime.bedrock-agentcore.us-east-1.amazonaws.com/runtimes/example/invocations?qualifier=DEFAULT",
            },
        },
    },
    name: "sigv4-target",
    gatewayIdentifier: example.gatewayId,
});
import pulumi
import pulumi_aws as aws

sigv4_example = aws.bedrock.AgentcoreGatewayTarget("sigv4_example",
    credential_provider_configuration={
        "gateway_iam_role": {
            "service": "bedrock-agentcore",
        },
    },
    target_configuration={
        "mcp": {
            "mcp_server": {
                "endpoint": "https://example-runtime.bedrock-agentcore.us-east-1.amazonaws.com/runtimes/example/invocations?qualifier=DEFAULT",
            },
        },
    },
    name="sigv4-target",
    gateway_identifier=example["gatewayId"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var sigv4Example = new Aws.Bedrock.AgentcoreGatewayTarget("sigv4_example", new()
    {
        CredentialProviderConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetCredentialProviderConfigurationArgs
        {
            GatewayIamRole = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs
            {
                Service = "bedrock-agentcore",
            },
        },
        TargetConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationArgs
        {
            Mcp = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs
            {
                McpServer = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs
                {
                    Endpoint = "https://example-runtime.bedrock-agentcore.us-east-1.amazonaws.com/runtimes/example/invocations?qualifier=DEFAULT",
                },
            },
        },
        Name = "sigv4-target",
        GatewayIdentifier = example.GatewayId,
    });

});
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.NewAgentcoreGatewayTarget(ctx, "sigv4_example", &bedrock.AgentcoreGatewayTargetArgs{
			CredentialProviderConfiguration: &bedrock.AgentcoreGatewayTargetCredentialProviderConfigurationArgs{
				GatewayIamRole: &bedrock.AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs{
					Service: pulumi.String("bedrock-agentcore"),
				},
			},
			TargetConfiguration: &bedrock.AgentcoreGatewayTargetTargetConfigurationArgs{
				Mcp: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpArgs{
					McpServer: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs{
						Endpoint: pulumi.String("https://example-runtime.bedrock-agentcore.us-east-1.amazonaws.com/runtimes/example/invocations?qualifier=DEFAULT"),
					},
				},
			},
			Name:              pulumi.String("sigv4-target"),
			GatewayIdentifier: pulumi.Any(example.GatewayId),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcoregatewaytarget" "sigv4_example" {
  credential_provider_configuration = {
    gateway_iam_role = {
      service = "bedrock-agentcore"
    }
  }
  target_configuration = {
    mcp = {
      mcp_server = {
        endpoint = "https://example-runtime.bedrock-agentcore.us-east-1.amazonaws.com/runtimes/example/invocations?qualifier=DEFAULT"
      }
    }
  }
  name               = "sigv4-target"
  gateway_identifier = example.gatewayId
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreGatewayTarget;
import com.pulumi.aws.bedrock.AgentcoreGatewayTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetCredentialProviderConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs;
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 sigv4Example = new AgentcoreGatewayTarget("sigv4Example", AgentcoreGatewayTargetArgs.builder()
            .credentialProviderConfiguration(AgentcoreGatewayTargetCredentialProviderConfigurationArgs.builder()
                .gatewayIamRole(AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs.builder()
                    .service("bedrock-agentcore")
                    .build())
                .build())
            .targetConfiguration(AgentcoreGatewayTargetTargetConfigurationArgs.builder()
                .mcp(AgentcoreGatewayTargetTargetConfigurationMcpArgs.builder()
                    .mcpServer(AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs.builder()
                        .endpoint("https://example-runtime.bedrock-agentcore.us-east-1.amazonaws.com/runtimes/example/invocations?qualifier=DEFAULT")
                        .build())
                    .build())
                .build())
            .name("sigv4-target")
            .gatewayIdentifier(example.gatewayId())
            .build());

    }
}
resources:
  sigv4Example:
    type: aws:bedrock:AgentcoreGatewayTarget
    name: sigv4_example
    properties:
      credentialProviderConfiguration:
        gatewayIamRole:
          service: bedrock-agentcore
      targetConfiguration:
        mcp:
          mcpServer:
            endpoint: https://example-runtime.bedrock-agentcore.us-east-1.amazonaws.com/runtimes/example/invocations?qualifier=DEFAULT
      name: sigv4-target
      gatewayIdentifier: ${example.gatewayId}

Complex Schema with JSON Serialization

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

const complexSchema = new aws.bedrock.AgentcoreGatewayTarget("complex_schema", {
    credentialProviderConfiguration: {
        gatewayIamRole: {},
    },
    targetConfiguration: {
        mcp: {
            lambda: {
                toolSchema: {
                    inlinePayloads: [{
                        inputSchema: {
                            properties: [{
                                properties: [
                                    {
                                        name: "nested_tags",
                                        type: "array",
                                        itemsJson: JSON.stringify({
                                            type: "string",
                                        }),
                                    },
                                    {
                                        name: "metadata",
                                        type: "object",
                                        propertiesJson: JSON.stringify({
                                            properties: {
                                                created_at: {
                                                    type: "string",
                                                },
                                                version: {
                                                    type: "number",
                                                },
                                            },
                                            required: ["created_at"],
                                        }),
                                    },
                                ],
                                name: "profile",
                                type: "object",
                            }],
                            type: "object",
                        },
                        name: "complex_tool",
                        description: "Tool with complex nested schema",
                    }],
                },
                lambdaArn: example.arn,
            },
        },
    },
    name: "complex-target",
    gatewayIdentifier: exampleAwsBedrockagentcoreGateway.gatewayId,
});
import pulumi
import json
import pulumi_aws as aws

complex_schema = aws.bedrock.AgentcoreGatewayTarget("complex_schema",
    credential_provider_configuration={
        "gateway_iam_role": {},
    },
    target_configuration={
        "mcp": {
            "lambda_": {
                "tool_schema": {
                    "inline_payloads": [{
                        "input_schema": {
                            "properties": [{
                                "properties": [
                                    {
                                        "name": "nested_tags",
                                        "type": "array",
                                        "items_json": json.dumps({
                                            "type": "string",
                                        }),
                                    },
                                    {
                                        "name": "metadata",
                                        "type": "object",
                                        "properties_json": json.dumps({
                                            "properties": {
                                                "created_at": {
                                                    "type": "string",
                                                },
                                                "version": {
                                                    "type": "number",
                                                },
                                            },
                                            "required": ["created_at"],
                                        }),
                                    },
                                ],
                                "name": "profile",
                                "type": "object",
                            }],
                            "type": "object",
                        },
                        "name": "complex_tool",
                        "description": "Tool with complex nested schema",
                    }],
                },
                "lambda_arn": example["arn"],
            },
        },
    },
    name="complex-target",
    gateway_identifier=example_aws_bedrockagentcore_gateway["gatewayId"])
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var complexSchema = new Aws.Bedrock.AgentcoreGatewayTarget("complex_schema", new()
    {
        CredentialProviderConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetCredentialProviderConfigurationArgs
        {
            GatewayIamRole = null,
        },
        TargetConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationArgs
        {
            Mcp = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs
            {
                Lambda = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs
                {
                    ToolSchema = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs
                    {
                        InlinePayloads = new[]
                        {
                            new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs
                            {
                                InputSchema = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs
                                {
                                    Properties = new[]
                                    {
                                        new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArgs
                                        {
                                            Properties = new[]
                                            {
                                                new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs
                                                {
                                                    Name = "nested_tags",
                                                    Type = "array",
                                                    ItemsJson = JsonSerializer.Serialize(new Dictionary<string, object?>
                                                    {
                                                        ["type"] = "string",
                                                    }),
                                                },
                                                new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs
                                                {
                                                    Name = "metadata",
                                                    Type = "object",
                                                    PropertiesJson = JsonSerializer.Serialize(new Dictionary<string, object?>
                                                    {
                                                        ["properties"] = new Dictionary<string, object?>
                                                        {
                                                            ["created_at"] = new Dictionary<string, object?>
                                                            {
                                                                ["type"] = "string",
                                                            },
                                                            ["version"] = new Dictionary<string, object?>
                                                            {
                                                                ["type"] = "number",
                                                            },
                                                        },
                                                        ["required"] = new[]
                                                        {
                                                            "created_at",
                                                        },
                                                    }),
                                                },
                                            },
                                            Name = "profile",
                                            Type = "object",
                                        },
                                    },
                                    Type = "object",
                                },
                                Name = "complex_tool",
                                Description = "Tool with complex nested schema",
                            },
                        },
                    },
                    LambdaArn = example.Arn,
                },
            },
        },
        Name = "complex-target",
        GatewayIdentifier = exampleAwsBedrockagentcoreGateway.GatewayId,
    });

});
package main

import (
	"encoding/json"

	"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 {
		tmpJSON0, err := json.Marshal(map[string]string{
			"type": "string",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"properties": map[string]map[string]string{
				"created_at": map[string]string{
					"type": "string",
				},
				"version": map[string]string{
					"type": "number",
				},
			},
			"required": []string{
				"created_at",
			},
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		_, err = bedrock.NewAgentcoreGatewayTarget(ctx, "complex_schema", &bedrock.AgentcoreGatewayTargetArgs{
			CredentialProviderConfiguration: &bedrock.AgentcoreGatewayTargetCredentialProviderConfigurationArgs{
				GatewayIamRole: &bedrock.AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs{},
			},
			TargetConfiguration: &bedrock.AgentcoreGatewayTargetTargetConfigurationArgs{
				Mcp: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpArgs{
					Lambda: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs{
						ToolSchema: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs{
							InlinePayloads: bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArray{
								&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs{
									InputSchema: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs{
										Properties: bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArray{
											&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArgs{
												Properties: bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArray{
													&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs{
														Name:      pulumi.String("nested_tags"),
														Type:      pulumi.String("array"),
														ItemsJson: pulumi.String(json0),
													},
													&bedrock.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs{
														Name:           pulumi.String("metadata"),
														Type:           pulumi.String("object"),
														PropertiesJson: pulumi.String(json1),
													},
												},
												Name: pulumi.String("profile"),
												Type: pulumi.String("object"),
											},
										},
										Type: pulumi.String("object"),
									},
									Name:        pulumi.String("complex_tool"),
									Description: pulumi.String("Tool with complex nested schema"),
								},
							},
						},
						LambdaArn: pulumi.Any(example.Arn),
					},
				},
			},
			Name:              pulumi.String("complex-target"),
			GatewayIdentifier: pulumi.Any(exampleAwsBedrockagentcoreGateway.GatewayId),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcoregatewaytarget" "complex_schema" {
  credential_provider_configuration = {
    gateway_iam_role = {}
  }
  target_configuration = {
    mcp = {
      lambda = {
        tool_schema = {
          inline_payloads = [{
            "inputSchema" = {
              "properties" = [{
                "properties" = [{
                  "name" = "nested_tags"
                  "type" = "array"
                  "itemsJson" = jsonencode({
                    "type" = "string"
                  })
                  }, {
                  "name" = "metadata"
                  "type" = "object"
                  "propertiesJson" = jsonencode({
                    "properties" = {
                      "created_at" = {
                        "type" = "string"
                      }
                      "version" = {
                        "type" = "number"
                      }
                    }
                    "required" = ["created_at"]
                  })
                }]
                "name" = "profile"
                "type" = "object"
              }]
              "type" = "object"
            }
            "name"        = "complex_tool"
            "description" = "Tool with complex nested schema"
          }]
        }
        lambda_arn = example.arn
      }
    }
  }
  name               = "complex-target"
  gateway_identifier = exampleAwsBedrockagentcoreGateway.gatewayId
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreGatewayTarget;
import com.pulumi.aws.bedrock.AgentcoreGatewayTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetCredentialProviderConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 complexSchema = new AgentcoreGatewayTarget("complexSchema", AgentcoreGatewayTargetArgs.builder()
            .credentialProviderConfiguration(AgentcoreGatewayTargetCredentialProviderConfigurationArgs.builder()
                .gatewayIamRole(AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs.builder()
                    .build())
                .build())
            .targetConfiguration(AgentcoreGatewayTargetTargetConfigurationArgs.builder()
                .mcp(AgentcoreGatewayTargetTargetConfigurationMcpArgs.builder()
                    .lambda(AgentcoreGatewayTargetTargetConfigurationMcpLambdaArgs.builder()
                        .toolSchema(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaArgs.builder()
                            .inlinePayloads(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadArgs.builder()
                                .inputSchema(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaArgs.builder()
                                    .properties(AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyArgs.builder()
                                        .properties(
                                            AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs.builder()
                                                .name("nested_tags")
                                                .type("array")
                                                .itemsJson(serializeJson(
                                                    jsonObject(
                                                        jsonProperty("type", "string")
                                                    )))
                                                .build(),
                                            AgentcoreGatewayTargetTargetConfigurationMcpLambdaToolSchemaInlinePayloadInputSchemaPropertyPropertyArgs.builder()
                                                .name("metadata")
                                                .type("object")
                                                .propertiesJson(serializeJson(
                                                    jsonObject(
                                                        jsonProperty("properties", jsonObject(
                                                            jsonProperty("created_at", jsonObject(
                                                                jsonProperty("type", "string")
                                                            )),
                                                            jsonProperty("version", jsonObject(
                                                                jsonProperty("type", "number")
                                                            ))
                                                        )),
                                                        jsonProperty("required", jsonArray("created_at"))
                                                    )))
                                                .build())
                                        .name("profile")
                                        .type("object")
                                        .build())
                                    .type("object")
                                    .build())
                                .name("complex_tool")
                                .description("Tool with complex nested schema")
                                .build())
                            .build())
                        .lambdaArn(example.arn())
                        .build())
                    .build())
                .build())
            .name("complex-target")
            .gatewayIdentifier(exampleAwsBedrockagentcoreGateway.gatewayId())
            .build());

    }
}
resources:
  complexSchema:
    type: aws:bedrock:AgentcoreGatewayTarget
    name: complex_schema
    properties:
      credentialProviderConfiguration:
        gatewayIamRole: {}
      targetConfiguration:
        mcp:
          lambda:
            toolSchema:
              inlinePayloads:
                - inputSchema:
                    properties:
                      - properties:
                          - name: nested_tags
                            type: array
                            itemsJson:
                              fn::toJSON:
                                type: string
                          - name: metadata
                            type: object
                            propertiesJson:
                              fn::toJSON:
                                properties:
                                  created_at:
                                    type: string
                                  version:
                                    type: number
                                required:
                                  - created_at
                        name: profile
                        type: object
                    type: object
                  name: complex_tool
                  description: Tool with complex nested schema
            lambdaArn: ${example.arn}
      name: complex-target
      gatewayIdentifier: ${exampleAwsBedrockagentcoreGateway.gatewayId}

MCP Server Target with Header Propagation

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

const mcpWithHeaders = new aws.bedrock.AgentcoreGatewayTarget("mcp_with_headers", {
    targetConfiguration: {
        mcp: {
            mcpServer: {
                endpoint: "https://example.com/mcp",
            },
        },
    },
    metadataConfiguration: {
        allowedRequestHeaders: [
            "x-correlation-id",
            "x-tenant-id",
        ],
        allowedResponseHeaders: ["x-rate-limit-remaining"],
        allowedQueryParameters: ["version"],
    },
    name: "mcp-target-with-headers",
    gatewayIdentifier: example.gatewayId,
    description: "MCP server target with header propagation",
});
import pulumi
import pulumi_aws as aws

mcp_with_headers = aws.bedrock.AgentcoreGatewayTarget("mcp_with_headers",
    target_configuration={
        "mcp": {
            "mcp_server": {
                "endpoint": "https://example.com/mcp",
            },
        },
    },
    metadata_configuration={
        "allowed_request_headers": [
            "x-correlation-id",
            "x-tenant-id",
        ],
        "allowed_response_headers": ["x-rate-limit-remaining"],
        "allowed_query_parameters": ["version"],
    },
    name="mcp-target-with-headers",
    gateway_identifier=example["gatewayId"],
    description="MCP server target with header propagation")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var mcpWithHeaders = new Aws.Bedrock.AgentcoreGatewayTarget("mcp_with_headers", new()
    {
        TargetConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationArgs
        {
            Mcp = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs
            {
                McpServer = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs
                {
                    Endpoint = "https://example.com/mcp",
                },
            },
        },
        MetadataConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetMetadataConfigurationArgs
        {
            AllowedRequestHeaders = new[]
            {
                "x-correlation-id",
                "x-tenant-id",
            },
            AllowedResponseHeaders = new[]
            {
                "x-rate-limit-remaining",
            },
            AllowedQueryParameters = new[]
            {
                "version",
            },
        },
        Name = "mcp-target-with-headers",
        GatewayIdentifier = example.GatewayId,
        Description = "MCP server target with header propagation",
    });

});
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.NewAgentcoreGatewayTarget(ctx, "mcp_with_headers", &bedrock.AgentcoreGatewayTargetArgs{
			TargetConfiguration: &bedrock.AgentcoreGatewayTargetTargetConfigurationArgs{
				Mcp: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpArgs{
					McpServer: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs{
						Endpoint: pulumi.String("https://example.com/mcp"),
					},
				},
			},
			MetadataConfiguration: &bedrock.AgentcoreGatewayTargetMetadataConfigurationArgs{
				AllowedRequestHeaders: pulumi.StringArray{
					pulumi.String("x-correlation-id"),
					pulumi.String("x-tenant-id"),
				},
				AllowedResponseHeaders: pulumi.StringArray{
					pulumi.String("x-rate-limit-remaining"),
				},
				AllowedQueryParameters: pulumi.StringArray{
					pulumi.String("version"),
				},
			},
			Name:              pulumi.String("mcp-target-with-headers"),
			GatewayIdentifier: pulumi.Any(example.GatewayId),
			Description:       pulumi.String("MCP server target with header propagation"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcoregatewaytarget" "mcp_with_headers" {
  target_configuration = {
    mcp = {
      mcp_server = {
        endpoint = "https://example.com/mcp"
      }
    }
  }
  metadata_configuration = {
    allowed_request_headers  = ["x-correlation-id", "x-tenant-id"]
    allowed_response_headers = ["x-rate-limit-remaining"]
    allowed_query_parameters = ["version"]
  }
  name               = "mcp-target-with-headers"
  gateway_identifier = example.gatewayId
  description        = "MCP server target with header propagation"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreGatewayTarget;
import com.pulumi.aws.bedrock.AgentcoreGatewayTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetMetadataConfigurationArgs;
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 mcpWithHeaders = new AgentcoreGatewayTarget("mcpWithHeaders", AgentcoreGatewayTargetArgs.builder()
            .targetConfiguration(AgentcoreGatewayTargetTargetConfigurationArgs.builder()
                .mcp(AgentcoreGatewayTargetTargetConfigurationMcpArgs.builder()
                    .mcpServer(AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs.builder()
                        .endpoint("https://example.com/mcp")
                        .build())
                    .build())
                .build())
            .metadataConfiguration(AgentcoreGatewayTargetMetadataConfigurationArgs.builder()
                .allowedRequestHeaders(
                    "x-correlation-id",
                    "x-tenant-id")
                .allowedResponseHeaders("x-rate-limit-remaining")
                .allowedQueryParameters("version")
                .build())
            .name("mcp-target-with-headers")
            .gatewayIdentifier(example.gatewayId())
            .description("MCP server target with header propagation")
            .build());

    }
}
resources:
  mcpWithHeaders:
    type: aws:bedrock:AgentcoreGatewayTarget
    name: mcp_with_headers
    properties:
      targetConfiguration:
        mcp:
          mcpServer:
            endpoint: https://example.com/mcp
      metadataConfiguration:
        allowedRequestHeaders:
          - x-correlation-id
          - x-tenant-id
        allowedResponseHeaders:
          - x-rate-limit-remaining
        allowedQueryParameters:
          - version
      name: mcp-target-with-headers
      gatewayIdentifier: ${example.gatewayId}
      description: MCP server target with header propagation

HTTP Target Routing to an AgentCore Runtime

Routes gateway traffic directly to an AgentCore Runtime agent over HTTP, without MCP aggregation. The gateway must not have a protocolType set.

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

const example = new aws.bedrock.AgentcoreAgentRuntime("example", {
    agentRuntimeArtifact: {
        containerConfiguration: {
            containerUri: "111122223333.dkr.ecr.us-west-2.amazonaws.com/example-runtime:latest",
        },
    },
    networkConfiguration: {
        networkMode: "PUBLIC",
    },
    agentRuntimeName: "example-runtime",
    roleArn: runtimeRole.arn,
});
const runtime = new aws.bedrock.AgentcoreGatewayTarget("runtime", {
    credentialProviderConfiguration: {
        gatewayIamRole: {},
    },
    targetConfiguration: {
        http: {
            agentcoreRuntime: {
                arn: example.agentRuntimeArn,
                qualifier: "DEFAULT",
            },
        },
    },
    name: "runtime-target",
    gatewayIdentifier: exampleAwsBedrockagentcoreGateway.gatewayId,
});
import pulumi
import pulumi_aws as aws

example = aws.bedrock.AgentcoreAgentRuntime("example",
    agent_runtime_artifact={
        "container_configuration": {
            "container_uri": "111122223333.dkr.ecr.us-west-2.amazonaws.com/example-runtime:latest",
        },
    },
    network_configuration={
        "network_mode": "PUBLIC",
    },
    agent_runtime_name="example-runtime",
    role_arn=runtime_role["arn"])
runtime = aws.bedrock.AgentcoreGatewayTarget("runtime",
    credential_provider_configuration={
        "gateway_iam_role": {},
    },
    target_configuration={
        "http": {
            "agentcore_runtime": {
                "arn": example.agent_runtime_arn,
                "qualifier": "DEFAULT",
            },
        },
    },
    name="runtime-target",
    gateway_identifier=example_aws_bedrockagentcore_gateway["gatewayId"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Bedrock.AgentcoreAgentRuntime("example", new()
    {
        AgentRuntimeArtifact = new Aws.Bedrock.Inputs.AgentcoreAgentRuntimeAgentRuntimeArtifactArgs
        {
            ContainerConfiguration = new Aws.Bedrock.Inputs.AgentcoreAgentRuntimeAgentRuntimeArtifactContainerConfigurationArgs
            {
                ContainerUri = "111122223333.dkr.ecr.us-west-2.amazonaws.com/example-runtime:latest",
            },
        },
        NetworkConfiguration = new Aws.Bedrock.Inputs.AgentcoreAgentRuntimeNetworkConfigurationArgs
        {
            NetworkMode = "PUBLIC",
        },
        AgentRuntimeName = "example-runtime",
        RoleArn = runtimeRole.Arn,
    });

    var runtime = new Aws.Bedrock.AgentcoreGatewayTarget("runtime", new()
    {
        CredentialProviderConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetCredentialProviderConfigurationArgs
        {
            GatewayIamRole = null,
        },
        TargetConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationArgs
        {
            Http = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationHttpArgs
            {
                AgentcoreRuntime = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationHttpAgentcoreRuntimeArgs
                {
                    Arn = example.AgentRuntimeArn,
                    Qualifier = "DEFAULT",
                },
            },
        },
        Name = "runtime-target",
        GatewayIdentifier = exampleAwsBedrockagentcoreGateway.GatewayId,
    });

});
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 {
		example, err := bedrock.NewAgentcoreAgentRuntime(ctx, "example", &bedrock.AgentcoreAgentRuntimeArgs{
			AgentRuntimeArtifact: &bedrock.AgentcoreAgentRuntimeAgentRuntimeArtifactArgs{
				ContainerConfiguration: &bedrock.AgentcoreAgentRuntimeAgentRuntimeArtifactContainerConfigurationArgs{
					ContainerUri: pulumi.String("111122223333.dkr.ecr.us-west-2.amazonaws.com/example-runtime:latest"),
				},
			},
			NetworkConfiguration: &bedrock.AgentcoreAgentRuntimeNetworkConfigurationArgs{
				NetworkMode: pulumi.String("PUBLIC"),
			},
			AgentRuntimeName: pulumi.String("example-runtime"),
			RoleArn:          pulumi.Any(runtimeRole.Arn),
		})
		if err != nil {
			return err
		}
		_, err = bedrock.NewAgentcoreGatewayTarget(ctx, "runtime", &bedrock.AgentcoreGatewayTargetArgs{
			CredentialProviderConfiguration: &bedrock.AgentcoreGatewayTargetCredentialProviderConfigurationArgs{
				GatewayIamRole: &bedrock.AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs{},
			},
			TargetConfiguration: &bedrock.AgentcoreGatewayTargetTargetConfigurationArgs{
				Http: &bedrock.AgentcoreGatewayTargetTargetConfigurationHttpArgs{
					AgentcoreRuntime: &bedrock.AgentcoreGatewayTargetTargetConfigurationHttpAgentcoreRuntimeArgs{
						Arn:       example.AgentRuntimeArn,
						Qualifier: pulumi.String("DEFAULT"),
					},
				},
			},
			Name:              pulumi.String("runtime-target"),
			GatewayIdentifier: pulumi.Any(exampleAwsBedrockagentcoreGateway.GatewayId),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcoreagentruntime" "example" {
  agent_runtime_artifact = {
    container_configuration = {
      container_uri = "111122223333.dkr.ecr.us-west-2.amazonaws.com/example-runtime:latest"
    }
  }
  network_configuration = {
    network_mode = "PUBLIC"
  }
  agent_runtime_name = "example-runtime"
  role_arn           = runtimeRole.arn
}
resource "aws_bedrock_agentcoregatewaytarget" "runtime" {
  credential_provider_configuration = {
    gateway_iam_role = {}
  }
  target_configuration = {
    http = {
      agentcore_runtime = {
        arn       = aws_bedrock_agentcoreagentruntime.example.agent_runtime_arn
        qualifier = "DEFAULT"
      }
    }
  }
  name               = "runtime-target"
  gateway_identifier = exampleAwsBedrockagentcoreGateway.gatewayId
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreAgentRuntime;
import com.pulumi.aws.bedrock.AgentcoreAgentRuntimeArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreAgentRuntimeAgentRuntimeArtifactArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreAgentRuntimeAgentRuntimeArtifactContainerConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreAgentRuntimeNetworkConfigurationArgs;
import com.pulumi.aws.bedrock.AgentcoreGatewayTarget;
import com.pulumi.aws.bedrock.AgentcoreGatewayTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetCredentialProviderConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationHttpArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationHttpAgentcoreRuntimeArgs;
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 AgentcoreAgentRuntime("example", AgentcoreAgentRuntimeArgs.builder()
            .agentRuntimeArtifact(AgentcoreAgentRuntimeAgentRuntimeArtifactArgs.builder()
                .containerConfiguration(AgentcoreAgentRuntimeAgentRuntimeArtifactContainerConfigurationArgs.builder()
                    .containerUri("111122223333.dkr.ecr.us-west-2.amazonaws.com/example-runtime:latest")
                    .build())
                .build())
            .networkConfiguration(AgentcoreAgentRuntimeNetworkConfigurationArgs.builder()
                .networkMode("PUBLIC")
                .build())
            .agentRuntimeName("example-runtime")
            .roleArn(runtimeRole.arn())
            .build());

        var runtime = new AgentcoreGatewayTarget("runtime", AgentcoreGatewayTargetArgs.builder()
            .credentialProviderConfiguration(AgentcoreGatewayTargetCredentialProviderConfigurationArgs.builder()
                .gatewayIamRole(AgentcoreGatewayTargetCredentialProviderConfigurationGatewayIamRoleArgs.builder()
                    .build())
                .build())
            .targetConfiguration(AgentcoreGatewayTargetTargetConfigurationArgs.builder()
                .http(AgentcoreGatewayTargetTargetConfigurationHttpArgs.builder()
                    .agentcoreRuntime(AgentcoreGatewayTargetTargetConfigurationHttpAgentcoreRuntimeArgs.builder()
                        .arn(example.agentRuntimeArn())
                        .qualifier("DEFAULT")
                        .build())
                    .build())
                .build())
            .name("runtime-target")
            .gatewayIdentifier(exampleAwsBedrockagentcoreGateway.gatewayId())
            .build());

    }
}
resources:
  example:
    type: aws:bedrock:AgentcoreAgentRuntime
    properties:
      agentRuntimeArtifact:
        containerConfiguration:
          containerUri: 111122223333.dkr.ecr.us-west-2.amazonaws.com/example-runtime:latest
      networkConfiguration:
        networkMode: PUBLIC
      agentRuntimeName: example-runtime
      roleArn: ${runtimeRole.arn}
  runtime:
    type: aws:bedrock:AgentcoreGatewayTarget
    properties:
      credentialProviderConfiguration:
        gatewayIamRole: {}
      targetConfiguration:
        http:
          agentcoreRuntime:
            arn: ${example.agentRuntimeArn}
            qualifier: DEFAULT
      name: runtime-target
      gatewayIdentifier: ${exampleAwsBedrockagentcoreGateway.gatewayId}

Self-hosted MCP server in a VPC (managed Lattice)

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

const example = new aws.bedrock.AgentcoreGatewayTarget("example", {
    targetConfiguration: {
        mcp: {
            mcpServer: {
                endpoint: "https://mcp.internal.example.com/mcp",
            },
        },
    },
    privateEndpoint: {
        managedVpcResource: {
            vpcIdentifier: exampleAwsVpc.id,
            subnetIds: exampleAwsSubnet.map(__item => __item.id),
            endpointIpAddressType: "IPV4",
            securityGroupIds: [mcpLattice.id],
        },
    },
    gatewayIdentifier: exampleAwsBedrockagentcoreGateway.gatewayId,
    name: "my-private-mcp-target",
});
import pulumi
import pulumi_aws as aws

example = aws.bedrock.AgentcoreGatewayTarget("example",
    target_configuration={
        "mcp": {
            "mcp_server": {
                "endpoint": "https://mcp.internal.example.com/mcp",
            },
        },
    },
    private_endpoint={
        "managed_vpc_resource": {
            "vpc_identifier": example_aws_vpc["id"],
            "subnet_ids": [__item["id"] for __item in example_aws_subnet],
            "endpoint_ip_address_type": "IPV4",
            "security_group_ids": [mcp_lattice["id"]],
        },
    },
    gateway_identifier=example_aws_bedrockagentcore_gateway["gatewayId"],
    name="my-private-mcp-target")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Bedrock.AgentcoreGatewayTarget("example", new()
    {
        TargetConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationArgs
        {
            Mcp = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs
            {
                McpServer = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs
                {
                    Endpoint = "https://mcp.internal.example.com/mcp",
                },
            },
        },
        PrivateEndpoint = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetPrivateEndpointArgs
        {
            ManagedVpcResource = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetPrivateEndpointManagedVpcResourceArgs
            {
                VpcIdentifier = exampleAwsVpc.Id,
                SubnetIds = exampleAwsSubnet.Select(__item => __item.Id).ToList(),
                EndpointIpAddressType = "IPV4",
                SecurityGroupIds = new[]
                {
                    mcpLattice.Id,
                },
            },
        },
        GatewayIdentifier = exampleAwsBedrockagentcoreGateway.GatewayId,
        Name = "my-private-mcp-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.NewAgentcoreGatewayTarget(ctx, "example", &bedrock.AgentcoreGatewayTargetArgs{
TargetConfiguration: &bedrock.AgentcoreGatewayTargetTargetConfigurationArgs{
Mcp: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpArgs{
McpServer: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs{
Endpoint: pulumi.String("https://mcp.internal.example.com/mcp"),
},
},
},
PrivateEndpoint: &bedrock.AgentcoreGatewayTargetPrivateEndpointArgs{
ManagedVpcResource: &bedrock.AgentcoreGatewayTargetPrivateEndpointManagedVpcResourceArgs{
VpcIdentifier: pulumi.Any(exampleAwsVpc.Id),
SubnetIds: pulumi.StringArray(%!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:13,31-53)),
EndpointIpAddressType: pulumi.String("IPV4"),
SecurityGroupIds: pulumi.StringArray{
mcpLattice.Id,
},
},
},
GatewayIdentifier: pulumi.Any(exampleAwsBedrockagentcoreGateway.GatewayId),
Name: pulumi.String("my-private-mcp-target"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcoregatewaytarget" "example" {
  target_configuration = {
    mcp = {
      mcp_server = {
        endpoint = "https://mcp.internal.example.com/mcp"
      }
    }
  }
  # The MCP server endpoint as seen from inside the VPC.
  private_endpoint = {
    managed_vpc_resource = {
      vpc_identifier           = exampleAwsVpc.id
      subnet_ids               = exampleAwsSubnet[*].id
      endpoint_ip_address_type = "IPV4"
      security_group_ids       = [mcpLattice.id]
    }
  }
  gateway_identifier = exampleAwsBedrockagentcoreGateway.gatewayId
  name               = "my-private-mcp-target"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreGatewayTarget;
import com.pulumi.aws.bedrock.AgentcoreGatewayTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetPrivateEndpointArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetPrivateEndpointManagedVpcResourceArgs;
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 AgentcoreGatewayTarget("example", AgentcoreGatewayTargetArgs.builder()
            .targetConfiguration(AgentcoreGatewayTargetTargetConfigurationArgs.builder()
                .mcp(AgentcoreGatewayTargetTargetConfigurationMcpArgs.builder()
                    .mcpServer(AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs.builder()
                        .endpoint("https://mcp.internal.example.com/mcp")
                        .build())
                    .build())
                .build())
            .privateEndpoint(AgentcoreGatewayTargetPrivateEndpointArgs.builder()
                .managedVpcResource(AgentcoreGatewayTargetPrivateEndpointManagedVpcResourceArgs.builder()
                    .vpcIdentifier(exampleAwsVpc.id())
                    .subnetIds(exampleAwsSubnet.stream().map(element -> element.id()).collect(toList()))
                    .endpointIpAddressType("IPV4")
                    .securityGroupIds(mcpLattice.id())
                    .build())
                .build())
            .gatewayIdentifier(exampleAwsBedrockagentcoreGateway.gatewayId())
            .name("my-private-mcp-target")
            .build());

    }
}

Self-hosted MCP server with routing through an internal ALB

Use routingDomain when the MCP server has a private TLS certificate. Place an internal ALB with a public ACM certificate in front of the server and set routingDomain to the ALB DNS name.

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

const example = new aws.bedrock.AgentcoreGatewayTarget("example", {
    targetConfiguration: {
        mcp: {
            mcpServer: {
                endpoint: "https://mcp.example.com/mcp",
            },
        },
    },
    privateEndpoint: {
        managedVpcResource: {
            vpcIdentifier: exampleAwsVpc.id,
            subnetIds: exampleAwsSubnet.map(__item => __item.id),
            endpointIpAddressType: "IPV4",
            routingDomain: mcpAlb.dnsName,
        },
    },
    gatewayIdentifier: exampleAwsBedrockagentcoreGateway.gatewayId,
    name: "my-private-mcp-via-alb",
});
import pulumi
import pulumi_aws as aws

example = aws.bedrock.AgentcoreGatewayTarget("example",
    target_configuration={
        "mcp": {
            "mcp_server": {
                "endpoint": "https://mcp.example.com/mcp",
            },
        },
    },
    private_endpoint={
        "managed_vpc_resource": {
            "vpc_identifier": example_aws_vpc["id"],
            "subnet_ids": [__item["id"] for __item in example_aws_subnet],
            "endpoint_ip_address_type": "IPV4",
            "routing_domain": mcp_alb["dnsName"],
        },
    },
    gateway_identifier=example_aws_bedrockagentcore_gateway["gatewayId"],
    name="my-private-mcp-via-alb")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Bedrock.AgentcoreGatewayTarget("example", new()
    {
        TargetConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationArgs
        {
            Mcp = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs
            {
                McpServer = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs
                {
                    Endpoint = "https://mcp.example.com/mcp",
                },
            },
        },
        PrivateEndpoint = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetPrivateEndpointArgs
        {
            ManagedVpcResource = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetPrivateEndpointManagedVpcResourceArgs
            {
                VpcIdentifier = exampleAwsVpc.Id,
                SubnetIds = exampleAwsSubnet.Select(__item => __item.Id).ToList(),
                EndpointIpAddressType = "IPV4",
                RoutingDomain = mcpAlb.DnsName,
            },
        },
        GatewayIdentifier = exampleAwsBedrockagentcoreGateway.GatewayId,
        Name = "my-private-mcp-via-alb",
    });

});
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.NewAgentcoreGatewayTarget(ctx, "example", &bedrock.AgentcoreGatewayTargetArgs{
TargetConfiguration: &bedrock.AgentcoreGatewayTargetTargetConfigurationArgs{
Mcp: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpArgs{
McpServer: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs{
Endpoint: pulumi.String("https://mcp.example.com/mcp"),
},
},
},
PrivateEndpoint: &bedrock.AgentcoreGatewayTargetPrivateEndpointArgs{
ManagedVpcResource: &bedrock.AgentcoreGatewayTargetPrivateEndpointManagedVpcResourceArgs{
VpcIdentifier: pulumi.Any(exampleAwsVpc.Id),
SubnetIds: pulumi.StringArray(%!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:13,31-53)),
EndpointIpAddressType: pulumi.String("IPV4"),
RoutingDomain: pulumi.Any(mcpAlb.DnsName),
},
},
GatewayIdentifier: pulumi.Any(exampleAwsBedrockagentcoreGateway.GatewayId),
Name: pulumi.String("my-private-mcp-via-alb"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcoregatewaytarget" "example" {
  target_configuration = {
    mcp = {
      mcp_server = {
        endpoint = "https://mcp.example.com/mcp"
      }
    }
  }
  # Must match the domain on the ALB's ACM certificate.
  private_endpoint = {
    managed_vpc_resource = {
      vpc_identifier           = exampleAwsVpc.id
      subnet_ids               = exampleAwsSubnet[*].id
      endpoint_ip_address_type = "IPV4"
      routing_domain           = mcpAlb.dnsName
    }
  }
  # Route through the internal ALB instead of the actual MCP server domain.
  gateway_identifier = exampleAwsBedrockagentcoreGateway.gatewayId
  name               = "my-private-mcp-via-alb"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreGatewayTarget;
import com.pulumi.aws.bedrock.AgentcoreGatewayTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetPrivateEndpointArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetPrivateEndpointManagedVpcResourceArgs;
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 AgentcoreGatewayTarget("example", AgentcoreGatewayTargetArgs.builder()
            .targetConfiguration(AgentcoreGatewayTargetTargetConfigurationArgs.builder()
                .mcp(AgentcoreGatewayTargetTargetConfigurationMcpArgs.builder()
                    .mcpServer(AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs.builder()
                        .endpoint("https://mcp.example.com/mcp")
                        .build())
                    .build())
                .build())
            .privateEndpoint(AgentcoreGatewayTargetPrivateEndpointArgs.builder()
                .managedVpcResource(AgentcoreGatewayTargetPrivateEndpointManagedVpcResourceArgs.builder()
                    .vpcIdentifier(exampleAwsVpc.id())
                    .subnetIds(exampleAwsSubnet.stream().map(element -> element.id()).collect(toList()))
                    .endpointIpAddressType("IPV4")
                    .routingDomain(mcpAlb.dnsName())
                    .build())
                .build())
            .gatewayIdentifier(exampleAwsBedrockagentcoreGateway.gatewayId())
            .name("my-private-mcp-via-alb")
            .build());

    }
}

Self-managed VPC Lattice resource configuration

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

const example = new aws.bedrock.AgentcoreGatewayTarget("example", {
    targetConfiguration: {
        mcp: {
            mcpServer: {
                endpoint: "https://mcp.internal.example.com/mcp",
            },
        },
    },
    privateEndpoint: {
        selfManagedLatticeResource: {
            resourceConfigurationIdentifier: mcp.arn,
        },
    },
    gatewayIdentifier: exampleAwsBedrockagentcoreGateway.gatewayId,
    name: "my-private-mcp-self-managed",
});
import pulumi
import pulumi_aws as aws

example = aws.bedrock.AgentcoreGatewayTarget("example",
    target_configuration={
        "mcp": {
            "mcp_server": {
                "endpoint": "https://mcp.internal.example.com/mcp",
            },
        },
    },
    private_endpoint={
        "self_managed_lattice_resource": {
            "resource_configuration_identifier": mcp["arn"],
        },
    },
    gateway_identifier=example_aws_bedrockagentcore_gateway["gatewayId"],
    name="my-private-mcp-self-managed")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Bedrock.AgentcoreGatewayTarget("example", new()
    {
        TargetConfiguration = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationArgs
        {
            Mcp = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs
            {
                McpServer = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs
                {
                    Endpoint = "https://mcp.internal.example.com/mcp",
                },
            },
        },
        PrivateEndpoint = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetPrivateEndpointArgs
        {
            SelfManagedLatticeResource = new Aws.Bedrock.Inputs.AgentcoreGatewayTargetPrivateEndpointSelfManagedLatticeResourceArgs
            {
                ResourceConfigurationIdentifier = mcp.Arn,
            },
        },
        GatewayIdentifier = exampleAwsBedrockagentcoreGateway.GatewayId,
        Name = "my-private-mcp-self-managed",
    });

});
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.NewAgentcoreGatewayTarget(ctx, "example", &bedrock.AgentcoreGatewayTargetArgs{
			TargetConfiguration: &bedrock.AgentcoreGatewayTargetTargetConfigurationArgs{
				Mcp: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpArgs{
					McpServer: &bedrock.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs{
						Endpoint: pulumi.String("https://mcp.internal.example.com/mcp"),
					},
				},
			},
			PrivateEndpoint: &bedrock.AgentcoreGatewayTargetPrivateEndpointArgs{
				SelfManagedLatticeResource: &bedrock.AgentcoreGatewayTargetPrivateEndpointSelfManagedLatticeResourceArgs{
					ResourceConfigurationIdentifier: pulumi.Any(mcp.Arn),
				},
			},
			GatewayIdentifier: pulumi.Any(exampleAwsBedrockagentcoreGateway.GatewayId),
			Name:              pulumi.String("my-private-mcp-self-managed"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcoregatewaytarget" "example" {
  target_configuration = {
    mcp = {
      mcp_server = {
        endpoint = "https://mcp.internal.example.com/mcp"
      }
    }
  }
  private_endpoint = {
    self_managed_lattice_resource = {
      resource_configuration_identifier = mcp.arn
    }
  }
  gateway_identifier = exampleAwsBedrockagentcoreGateway.gatewayId
  name               = "my-private-mcp-self-managed"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreGatewayTarget;
import com.pulumi.aws.bedrock.AgentcoreGatewayTargetArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetPrivateEndpointArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreGatewayTargetPrivateEndpointSelfManagedLatticeResourceArgs;
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 AgentcoreGatewayTarget("example", AgentcoreGatewayTargetArgs.builder()
            .targetConfiguration(AgentcoreGatewayTargetTargetConfigurationArgs.builder()
                .mcp(AgentcoreGatewayTargetTargetConfigurationMcpArgs.builder()
                    .mcpServer(AgentcoreGatewayTargetTargetConfigurationMcpMcpServerArgs.builder()
                        .endpoint("https://mcp.internal.example.com/mcp")
                        .build())
                    .build())
                .build())
            .privateEndpoint(AgentcoreGatewayTargetPrivateEndpointArgs.builder()
                .selfManagedLatticeResource(AgentcoreGatewayTargetPrivateEndpointSelfManagedLatticeResourceArgs.builder()
                    .resourceConfigurationIdentifier(mcp.arn())
                    .build())
                .build())
            .gatewayIdentifier(exampleAwsBedrockagentcoreGateway.gatewayId())
            .name("my-private-mcp-self-managed")
            .build());

    }
}
resources:
  example:
    type: aws:bedrock:AgentcoreGatewayTarget
    properties:
      targetConfiguration:
        mcp:
          mcpServer:
            endpoint: https://mcp.internal.example.com/mcp
      privateEndpoint:
        selfManagedLatticeResource:
          resourceConfigurationIdentifier: ${mcp.arn}
      gatewayIdentifier: ${exampleAwsBedrockagentcoreGateway.gatewayId}
      name: my-private-mcp-self-managed

Import

Using pulumi import, import Bedrock AgentCore Gateway Target using the gateway identifier and target ID separated by a comma. For example:

$ pulumi import aws:bedrock/agentcoreGatewayTarget:AgentcoreGatewayTarget example GATEWAY1234567890,TARGET0987654321

Constructors

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

Properties

childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
credentialProviderConfiguration ↔ Output<AgentcoreGatewayTargetCredentialProviderConfiguration?>
Configuration for authenticating requests to the target. Required when using lambda, openApiSchema and smithyModel in mcp block. If using mcpServer in mcp block with no authorization, it should not be specified. See credentialProviderConfiguration below.
latefinal
description ↔ Output<String?>
Description of the gateway target.
latefinal
gatewayIdentifier ↔ Output<String>
Identifier of the gateway that this target belongs 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
metadataConfiguration ↔ Output<AgentcoreGatewayTargetMetadataConfiguration?>
Configuration for HTTP header and query parameter propagation between the gateway and target servers. See metadataConfiguration below.
latefinal
name ↔ Output<String>
Name of the gateway target.
latefinal
privateEndpoint ↔ Output<AgentcoreGatewayTargetPrivateEndpoint?>
Configuration for private connectivity from AgentCore Gateway to a resource inside your VPC. Traffic is routed through Amazon VPC Lattice and never traverses the public internet. See privateEndpoint below.
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
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
targetConfiguration ↔ Output<AgentcoreGatewayTargetTargetConfiguration>
Configuration for the target endpoint. See targetConfiguration below.
latefinal
targetId ↔ Output<String>
Unique identifier of the gateway target.
latefinal
timeouts ↔ Output<AgentcoreGatewayTargetTimeouts?>
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, {AgentcoreGatewayTargetState? state, CustomResourceOptions? options}) → AgentcoreGatewayTarget
Gets an existing AgentcoreGatewayTarget resource's state with the given name and id.