pulumi-aws-kotlin/com.pulumi.aws.apigatewayv2.kotlin/RouteArgs

RouteArgs

data class RouteArgs(val apiId: Output<String>? = null, val apiKeyRequired: Output<Boolean>? = null, val authorizationScopes: Output<List<String>>? = null, val authorizationType: Output<String>? = null, val authorizerId: Output<String>? = null, val modelSelectionExpression: Output<String>? = null, val operationName: Output<String>? = null, val requestModels: Output<Map<String, String>>? = null, val requestParameters: Output<List<RouteRequestParameterArgs>>? = null, val routeKey: Output<String>? = null, val routeResponseSelectionExpression: Output<String>? = null, val target: Output<String>? = null) : ConvertibleToJava<RouteArgs>

Manages an Amazon API Gateway Version 2 route. More information can be found in the Amazon API Gateway Developer Guide for WebSocket and HTTP APIs.

Example Usage

Basic

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.apigatewayv2.Api("example", {
    name: "example-websocket-api",
    protocolType: "WEBSOCKET",
    routeSelectionExpression: "$request.body.action",
});
const exampleRoute = new aws.apigatewayv2.Route("example", {
    apiId: example.id,
    routeKey: "$default",
});

import pulumi
import pulumi_aws as aws
example = aws.apigatewayv2.Api("example",
    name="example-websocket-api",
    protocol_type="WEBSOCKET",
    route_selection_expression="$request.body.action")
example_route = aws.apigatewayv2.Route("example",
    api_id=example.id,
    route_key="$default")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.ApiGatewayV2.Api("example", new()
    {
        Name = "example-websocket-api",
        ProtocolType = "WEBSOCKET",
        RouteSelectionExpression = "$request.body.action",
    });
    var exampleRoute = new Aws.ApiGatewayV2.Route("example", new()
    {
        ApiId = example.Id,
        RouteKey = "$default",
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/apigatewayv2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := apigatewayv2.NewApi(ctx, "example", &apigatewayv2.ApiArgs{
			Name:                     pulumi.String("example-websocket-api"),
			ProtocolType:             pulumi.String("WEBSOCKET"),
			RouteSelectionExpression: pulumi.String("$request.body.action"),
		})
		if err != nil {
			return err
		}
		_, err = apigatewayv2.NewRoute(ctx, "example", &apigatewayv2.RouteArgs{
			ApiId:    example.ID(),
			RouteKey: pulumi.String("$default"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.apigatewayv2.Api;
import com.pulumi.aws.apigatewayv2.ApiArgs;
import com.pulumi.aws.apigatewayv2.Route;
import com.pulumi.aws.apigatewayv2.RouteArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Api("example", ApiArgs.builder()
            .name("example-websocket-api")
            .protocolType("WEBSOCKET")
            .routeSelectionExpression("$request.body.action")
            .build());
        var exampleRoute = new Route("exampleRoute", RouteArgs.builder()
            .apiId(example.id())
            .routeKey("$default")
            .build());
    }
}

resources:
  example:
    type: aws:apigatewayv2:Api
    properties:
      name: example-websocket-api
      protocolType: WEBSOCKET
      routeSelectionExpression: $request.body.action
  exampleRoute:
    type: aws:apigatewayv2:Route
    name: example
    properties:
      apiId: ${example.id}
      routeKey: $default

HTTP Proxy Integration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.apigatewayv2.Api("example", {
    name: "example-http-api",
    protocolType: "HTTP",
});
const exampleIntegration = new aws.apigatewayv2.Integration("example", {
    apiId: example.id,
    integrationType: "HTTP_PROXY",
    integrationMethod: "ANY",
    integrationUri: "https://example.com/{proxy}",
});
const exampleRoute = new aws.apigatewayv2.Route("example", {
    apiId: example.id,
    routeKey: "ANY /example/{proxy+}",
    target: pulumi.interpolate`integrations/${exampleIntegration.id}`,
});

import pulumi
import pulumi_aws as aws
example = aws.apigatewayv2.Api("example",
    name="example-http-api",
    protocol_type="HTTP")
example_integration = aws.apigatewayv2.Integration("example",
    api_id=example.id,
    integration_type="HTTP_PROXY",
    integration_method="ANY",
    integration_uri="https://example.com/{proxy}")
example_route = aws.apigatewayv2.Route("example",
    api_id=example.id,
    route_key="ANY /example/{proxy+}",
    target=example_integration.id.apply(lambda id: f"integrations/{id}"))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.ApiGatewayV2.Api("example", new()
    {
        Name = "example-http-api",
        ProtocolType = "HTTP",
    });
    var exampleIntegration = new Aws.ApiGatewayV2.Integration("example", new()
    {
        ApiId = example.Id,
        IntegrationType = "HTTP_PROXY",
        IntegrationMethod = "ANY",
        IntegrationUri = "https://example.com/{proxy}",
    });
    var exampleRoute = new Aws.ApiGatewayV2.Route("example", new()
    {
        ApiId = example.Id,
        RouteKey = "ANY /example/{proxy+}",
        Target = exampleIntegration.Id.Apply(id => $"integrations/{id}"),
    });
});

package main
import (
	"fmt"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/apigatewayv2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := apigatewayv2.NewApi(ctx, "example", &apigatewayv2.ApiArgs{
			Name:         pulumi.String("example-http-api"),
			ProtocolType: pulumi.String("HTTP"),
		})
		if err != nil {
			return err
		}
		exampleIntegration, err := apigatewayv2.NewIntegration(ctx, "example", &apigatewayv2.IntegrationArgs{
			ApiId:             example.ID(),
			IntegrationType:   pulumi.String("HTTP_PROXY"),
			IntegrationMethod: pulumi.String("ANY"),
			IntegrationUri:    pulumi.String("https://example.com/{proxy}"),
		})
		if err != nil {
			return err
		}
		_, err = apigatewayv2.NewRoute(ctx, "example", &apigatewayv2.RouteArgs{
			ApiId:    example.ID(),
			RouteKey: pulumi.String("ANY /example/{proxy+}"),
			Target: exampleIntegration.ID().ApplyT(func(id string) (string, error) {
				return fmt.Sprintf("integrations/%v", id), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.apigatewayv2.Api;
import com.pulumi.aws.apigatewayv2.ApiArgs;
import com.pulumi.aws.apigatewayv2.Integration;
import com.pulumi.aws.apigatewayv2.IntegrationArgs;
import com.pulumi.aws.apigatewayv2.Route;
import com.pulumi.aws.apigatewayv2.RouteArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Api("example", ApiArgs.builder()
            .name("example-http-api")
            .protocolType("HTTP")
            .build());
        var exampleIntegration = new Integration("exampleIntegration", IntegrationArgs.builder()
            .apiId(example.id())
            .integrationType("HTTP_PROXY")
            .integrationMethod("ANY")
            .integrationUri("https://example.com/{proxy}")
            .build());
        var exampleRoute = new Route("exampleRoute", RouteArgs.builder()
            .apiId(example.id())
            .routeKey("ANY /example/{proxy+}")
            .target(exampleIntegration.id().applyValue(_id -> String.format("integrations/%s", _id)))
            .build());
    }
}

resources:
  example:
    type: aws:apigatewayv2:Api
    properties:
      name: example-http-api
      protocolType: HTTP
  exampleIntegration:
    type: aws:apigatewayv2:Integration
    name: example
    properties:
      apiId: ${example.id}
      integrationType: HTTP_PROXY
      integrationMethod: ANY
      integrationUri: https://example.com/{proxy}
  exampleRoute:
    type: aws:apigatewayv2:Route
    name: example
    properties:
      apiId: ${example.id}
      routeKey: ANY /example/{proxy+}
      target: integrations/${exampleIntegration.id}

Import

Using pulumi import, import aws_apigatewayv2_route using the API identifier and route identifier. For example:

$ pulumi import aws:apigatewayv2/route:Route example aabbccddee/1122334

->Note: The API Gateway managed route created as part of quick_create cannot be imported.

Constructors

RouteArgs

constructor(apiId: Output<String>? = null, apiKeyRequired: Output<Boolean>? = null, authorizationScopes: Output<List<String>>? = null, authorizationType: Output<String>? = null, authorizerId: Output<String>? = null, modelSelectionExpression: Output<String>? = null, operationName: Output<String>? = null, requestModels: Output<Map<String, String>>? = null, requestParameters: Output<List<RouteRequestParameterArgs>>? = null, routeKey: Output<String>? = null, routeResponseSelectionExpression: Output<String>? = null, target: Output<String>? = null)

Properties

apiId

val apiId: Output<String>? = null

API identifier.

apiKeyRequired

val apiKeyRequired: Output<Boolean>? = null

Boolean whether an API key is required for the route. Defaults to false. Supported only for WebSocket APIs.

authorizationScopes

val authorizationScopes: Output<List<String>>? = null

Authorization scopes supported by this route. The scopes are used with a JWT authorizer to authorize the method invocation.

authorizationType

val authorizationType: Output<String>? = null

Authorization type for the route. For WebSocket APIs, valid values are NONE for open access, AWS_IAM for using AWS IAM permissions, and CUSTOM for using a Lambda authorizer. For HTTP APIs, valid values are NONE for open access, JWT for using JSON Web Tokens, AWS_IAM for using AWS IAM permissions, and CUSTOM for using a Lambda authorizer. Defaults to NONE.

authorizerId

val authorizerId: Output<String>? = null

Identifier of the aws.apigatewayv2.Authorizer resource to be associated with this route.

modelSelectionExpression

val modelSelectionExpression: Output<String>? = null

The model selection expression for the route. Supported only for WebSocket APIs.

operationName

val operationName: Output<String>? = null

Operation name for the route. Must be between 1 and 64 characters in length.

requestModels

val requestModels: Output<Map<String, String>>? = null

Request models for the route. Supported only for WebSocket APIs.

requestParameters

val requestParameters: Output<List<RouteRequestParameterArgs>>? = null

Request parameters for the route. Supported only for WebSocket APIs.

routeKey

val routeKey: Output<String>? = null

Route key for the route. For HTTP APIs, the route key can be either $default, or a combination of an HTTP method and resource path, for example, GET /pets.

routeResponseSelectionExpression

val routeResponseSelectionExpression: Output<String>? = null

The route response selection expression for the route. Supported only for WebSocket APIs.

target

val target: Output<String>? = null

Target for the route, of the form integrations/IntegrationID, where IntegrationID is the identifier of an aws.apigatewayv2.Integration resource.

Functions

toJava

open override fun toJava(): RouteArgs