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

IntegrationArgs

data class IntegrationArgs(val apiId: Output<String>? = null, val connectionId: Output<String>? = null, val connectionType: Output<String>? = null, val contentHandlingStrategy: Output<String>? = null, val credentialsArn: Output<String>? = null, val description: Output<String>? = null, val integrationMethod: Output<String>? = null, val integrationSubtype: Output<String>? = null, val integrationType: Output<String>? = null, val integrationUri: Output<String>? = null, val passthroughBehavior: Output<String>? = null, val payloadFormatVersion: Output<String>? = null, val requestParameters: Output<Map<String, String>>? = null, val requestTemplates: Output<Map<String, String>>? = null, val responseParameters: Output<List<IntegrationResponseParameterArgs>>? = null, val templateSelectionExpression: Output<String>? = null, val timeoutMilliseconds: Output<Int>? = null, val tlsConfig: Output<IntegrationTlsConfigArgs>? = null) : ConvertibleToJava<IntegrationArgs>

Manages an Amazon API Gateway Version 2 integration. More information can be found in the Amazon API Gateway Developer Guide.

Example Usage

Basic

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.apigatewayv2.Integration("example", {
    apiId: exampleAwsApigatewayv2Api.id,
    integrationType: "MOCK",
});

import pulumi
import pulumi_aws as aws
example = aws.apigatewayv2.Integration("example",
    api_id=example_aws_apigatewayv2_api["id"],
    integration_type="MOCK")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.ApiGatewayV2.Integration("example", new()
    {
        ApiId = exampleAwsApigatewayv2Api.Id,
        IntegrationType = "MOCK",
    });
});

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 {
		_, err := apigatewayv2.NewIntegration(ctx, "example", &apigatewayv2.IntegrationArgs{
			ApiId:           pulumi.Any(exampleAwsApigatewayv2Api.Id),
			IntegrationType: pulumi.String("MOCK"),
		})
		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.Integration;
import com.pulumi.aws.apigatewayv2.IntegrationArgs;
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 Integration("example", IntegrationArgs.builder()
            .apiId(exampleAwsApigatewayv2Api.id())
            .integrationType("MOCK")
            .build());
    }
}

resources:
  example:
    type: aws:apigatewayv2:Integration
    properties:
      apiId: ${exampleAwsApigatewayv2Api.id}
      integrationType: MOCK

Lambda Integration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.lambda.Function("example", {
    code: new pulumi.asset.FileArchive("example.zip"),
    name: "Example",
    role: exampleAwsIamRole.arn,
    handler: "index.handler",
    runtime: aws.lambda.Runtime.NodeJS16dX,
});
const exampleIntegration = new aws.apigatewayv2.Integration("example", {
    apiId: exampleAwsApigatewayv2Api.id,
    integrationType: "AWS_PROXY",
    connectionType: "INTERNET",
    contentHandlingStrategy: "CONVERT_TO_TEXT",
    description: "Lambda example",
    integrationMethod: "POST",
    integrationUri: example.invokeArn,
    passthroughBehavior: "WHEN_NO_MATCH",
});

import pulumi
import pulumi_aws as aws
example = aws.lambda_.Function("example",
    code=pulumi.FileArchive("example.zip"),
    name="Example",
    role=example_aws_iam_role["arn"],
    handler="index.handler",
    runtime=aws.lambda_.Runtime.NODE_JS16D_X)
example_integration = aws.apigatewayv2.Integration("example",
    api_id=example_aws_apigatewayv2_api["id"],
    integration_type="AWS_PROXY",
    connection_type="INTERNET",
    content_handling_strategy="CONVERT_TO_TEXT",
    description="Lambda example",
    integration_method="POST",
    integration_uri=example.invoke_arn,
    passthrough_behavior="WHEN_NO_MATCH")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Lambda.Function("example", new()
    {
        Code = new FileArchive("example.zip"),
        Name = "Example",
        Role = exampleAwsIamRole.Arn,
        Handler = "index.handler",
        Runtime = Aws.Lambda.Runtime.NodeJS16dX,
    });
    var exampleIntegration = new Aws.ApiGatewayV2.Integration("example", new()
    {
        ApiId = exampleAwsApigatewayv2Api.Id,
        IntegrationType = "AWS_PROXY",
        ConnectionType = "INTERNET",
        ContentHandlingStrategy = "CONVERT_TO_TEXT",
        Description = "Lambda example",
        IntegrationMethod = "POST",
        IntegrationUri = example.InvokeArn,
        PassthroughBehavior = "WHEN_NO_MATCH",
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/apigatewayv2"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lambda"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := lambda.NewFunction(ctx, "example", &lambda.FunctionArgs{
			Code:    pulumi.NewFileArchive("example.zip"),
			Name:    pulumi.String("Example"),
			Role:    pulumi.Any(exampleAwsIamRole.Arn),
			Handler: pulumi.String("index.handler"),
			Runtime: pulumi.String(lambda.RuntimeNodeJS16dX),
		})
		if err != nil {
			return err
		}
		_, err = apigatewayv2.NewIntegration(ctx, "example", &apigatewayv2.IntegrationArgs{
			ApiId:                   pulumi.Any(exampleAwsApigatewayv2Api.Id),
			IntegrationType:         pulumi.String("AWS_PROXY"),
			ConnectionType:          pulumi.String("INTERNET"),
			ContentHandlingStrategy: pulumi.String("CONVERT_TO_TEXT"),
			Description:             pulumi.String("Lambda example"),
			IntegrationMethod:       pulumi.String("POST"),
			IntegrationUri:          example.InvokeArn,
			PassthroughBehavior:     pulumi.String("WHEN_NO_MATCH"),
		})
		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.lambda.Function;
import com.pulumi.aws.lambda.FunctionArgs;
import com.pulumi.aws.apigatewayv2.Integration;
import com.pulumi.aws.apigatewayv2.IntegrationArgs;
import com.pulumi.asset.FileArchive;
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 Function("example", FunctionArgs.builder()
            .code(new FileArchive("example.zip"))
            .name("Example")
            .role(exampleAwsIamRole.arn())
            .handler("index.handler")
            .runtime("nodejs16.x")
            .build());
        var exampleIntegration = new Integration("exampleIntegration", IntegrationArgs.builder()
            .apiId(exampleAwsApigatewayv2Api.id())
            .integrationType("AWS_PROXY")
            .connectionType("INTERNET")
            .contentHandlingStrategy("CONVERT_TO_TEXT")
            .description("Lambda example")
            .integrationMethod("POST")
            .integrationUri(example.invokeArn())
            .passthroughBehavior("WHEN_NO_MATCH")
            .build());
    }
}

resources:
  example:
    type: aws:lambda:Function
    properties:
      code:
        fn::FileArchive: example.zip
      name: Example
      role: ${exampleAwsIamRole.arn}
      handler: index.handler
      runtime: nodejs16.x
  exampleIntegration:
    type: aws:apigatewayv2:Integration
    name: example
    properties:
      apiId: ${exampleAwsApigatewayv2Api.id}
      integrationType: AWS_PROXY
      connectionType: INTERNET
      contentHandlingStrategy: CONVERT_TO_TEXT
      description: Lambda example
      integrationMethod: POST
      integrationUri: ${example.invokeArn}
      passthroughBehavior: WHEN_NO_MATCH

AWS Service Integration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.apigatewayv2.Integration("example", {
    apiId: exampleAwsApigatewayv2Api.id,
    credentialsArn: exampleAwsIamRole.arn,
    description: "SQS example",
    integrationType: "AWS_PROXY",
    integrationSubtype: "SQS-SendMessage",
    requestParameters: {
        QueueUrl: "$request.header.queueUrl",
        MessageBody: "$request.body.message",
    },
});

import pulumi
import pulumi_aws as aws
example = aws.apigatewayv2.Integration("example",
    api_id=example_aws_apigatewayv2_api["id"],
    credentials_arn=example_aws_iam_role["arn"],
    description="SQS example",
    integration_type="AWS_PROXY",
    integration_subtype="SQS-SendMessage",
    request_parameters={
        "QueueUrl": "$request.header.queueUrl",
        "MessageBody": "$request.body.message",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.ApiGatewayV2.Integration("example", new()
    {
        ApiId = exampleAwsApigatewayv2Api.Id,
        CredentialsArn = exampleAwsIamRole.Arn,
        Description = "SQS example",
        IntegrationType = "AWS_PROXY",
        IntegrationSubtype = "SQS-SendMessage",
        RequestParameters =
        {
            { "QueueUrl", "$request.header.queueUrl" },
            { "MessageBody", "$request.body.message" },
        },
    });
});

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 {
		_, err := apigatewayv2.NewIntegration(ctx, "example", &apigatewayv2.IntegrationArgs{
			ApiId:              pulumi.Any(exampleAwsApigatewayv2Api.Id),
			CredentialsArn:     pulumi.Any(exampleAwsIamRole.Arn),
			Description:        pulumi.String("SQS example"),
			IntegrationType:    pulumi.String("AWS_PROXY"),
			IntegrationSubtype: pulumi.String("SQS-SendMessage"),
			RequestParameters: pulumi.StringMap{
				"QueueUrl":    pulumi.String("$request.header.queueUrl"),
				"MessageBody": pulumi.String("$request.body.message"),
			},
		})
		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.Integration;
import com.pulumi.aws.apigatewayv2.IntegrationArgs;
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 Integration("example", IntegrationArgs.builder()
            .apiId(exampleAwsApigatewayv2Api.id())
            .credentialsArn(exampleAwsIamRole.arn())
            .description("SQS example")
            .integrationType("AWS_PROXY")
            .integrationSubtype("SQS-SendMessage")
            .requestParameters(Map.ofEntries(
                Map.entry("QueueUrl", "$request.header.queueUrl"),
                Map.entry("MessageBody", "$request.body.message")
            ))
            .build());
    }
}

resources:
  example:
    type: aws:apigatewayv2:Integration
    properties:
      apiId: ${exampleAwsApigatewayv2Api.id}
      credentialsArn: ${exampleAwsIamRole.arn}
      description: SQS example
      integrationType: AWS_PROXY
      integrationSubtype: SQS-SendMessage
      requestParameters:
        QueueUrl: $request.header.queueUrl
        MessageBody: $request.body.message

Private Integration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.apigatewayv2.Integration("example", {
    apiId: exampleAwsApigatewayv2Api.id,
    credentialsArn: exampleAwsIamRole.arn,
    description: "Example with a load balancer",
    integrationType: "HTTP_PROXY",
    integrationUri: exampleAwsLbListener.arn,
    integrationMethod: "ANY",
    connectionType: "VPC_LINK",
    connectionId: exampleAwsApigatewayv2VpcLink.id,
    tlsConfig: {
        serverNameToVerify: "example.com",
    },
    requestParameters: {
        "append:header.authforintegration": "$context.authorizer.authorizerResponse",
        "overwrite:path": "staticValueForIntegration",
    },
    responseParameters: [
        {
            statusCode: "403",
            mappings: {
                "append:header.auth": "$context.authorizer.authorizerResponse",
            },
        },
        {
            statusCode: "200",
            mappings: {
                "overwrite:statuscode": "204",
            },
        },
    ],
});

import pulumi
import pulumi_aws as aws
example = aws.apigatewayv2.Integration("example",
    api_id=example_aws_apigatewayv2_api["id"],
    credentials_arn=example_aws_iam_role["arn"],
    description="Example with a load balancer",
    integration_type="HTTP_PROXY",
    integration_uri=example_aws_lb_listener["arn"],
    integration_method="ANY",
    connection_type="VPC_LINK",
    connection_id=example_aws_apigatewayv2_vpc_link["id"],
    tls_config=aws.apigatewayv2.IntegrationTlsConfigArgs(
        server_name_to_verify="example.com",
    ),
    request_parameters={
        "append:header.authforintegration": "$context.authorizer.authorizerResponse",
        "overwrite:path": "staticValueForIntegration",
    },
    response_parameters=[
        aws.apigatewayv2.IntegrationResponseParameterArgs(
            status_code="403",
            mappings={
                "append:header.auth": "$context.authorizer.authorizerResponse",
            },
        ),
        aws.apigatewayv2.IntegrationResponseParameterArgs(
            status_code="200",
            mappings={
                "overwrite:statuscode": "204",
            },
        ),
    ])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.ApiGatewayV2.Integration("example", new()
    {
        ApiId = exampleAwsApigatewayv2Api.Id,
        CredentialsArn = exampleAwsIamRole.Arn,
        Description = "Example with a load balancer",
        IntegrationType = "HTTP_PROXY",
        IntegrationUri = exampleAwsLbListener.Arn,
        IntegrationMethod = "ANY",
        ConnectionType = "VPC_LINK",
        ConnectionId = exampleAwsApigatewayv2VpcLink.Id,
        TlsConfig = new Aws.ApiGatewayV2.Inputs.IntegrationTlsConfigArgs
        {
            ServerNameToVerify = "example.com",
        },
        RequestParameters =
        {
            { "append:header.authforintegration", "$context.authorizer.authorizerResponse" },
            { "overwrite:path", "staticValueForIntegration" },
        },
        ResponseParameters = new[]
        {
            new Aws.ApiGatewayV2.Inputs.IntegrationResponseParameterArgs
            {
                StatusCode = "403",
                Mappings =
                {
                    { "append:header.auth", "$context.authorizer.authorizerResponse" },
                },
            },
            new Aws.ApiGatewayV2.Inputs.IntegrationResponseParameterArgs
            {
                StatusCode = "200",
                Mappings =
                {
                    { "overwrite:statuscode", "204" },
                },
            },
        },
    });
});

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 {
		_, err := apigatewayv2.NewIntegration(ctx, "example", &apigatewayv2.IntegrationArgs{
			ApiId:             pulumi.Any(exampleAwsApigatewayv2Api.Id),
			CredentialsArn:    pulumi.Any(exampleAwsIamRole.Arn),
			Description:       pulumi.String("Example with a load balancer"),
			IntegrationType:   pulumi.String("HTTP_PROXY"),
			IntegrationUri:    pulumi.Any(exampleAwsLbListener.Arn),
			IntegrationMethod: pulumi.String("ANY"),
			ConnectionType:    pulumi.String("VPC_LINK"),
			ConnectionId:      pulumi.Any(exampleAwsApigatewayv2VpcLink.Id),
			TlsConfig: &apigatewayv2.IntegrationTlsConfigArgs{
				ServerNameToVerify: pulumi.String("example.com"),
			},
			RequestParameters: pulumi.StringMap{
				"append:header.authforintegration": pulumi.String("$context.authorizer.authorizerResponse"),
				"overwrite:path":                   pulumi.String("staticValueForIntegration"),
			},
			ResponseParameters: apigatewayv2.IntegrationResponseParameterArray{
				&apigatewayv2.IntegrationResponseParameterArgs{
					StatusCode: pulumi.String("403"),
					Mappings: pulumi.StringMap{
						"append:header.auth": pulumi.String("$context.authorizer.authorizerResponse"),
					},
				},
				&apigatewayv2.IntegrationResponseParameterArgs{
					StatusCode: pulumi.String("200"),
					Mappings: pulumi.StringMap{
						"overwrite:statuscode": pulumi.String("204"),
					},
				},
			},
		})
		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.Integration;
import com.pulumi.aws.apigatewayv2.IntegrationArgs;
import com.pulumi.aws.apigatewayv2.inputs.IntegrationTlsConfigArgs;
import com.pulumi.aws.apigatewayv2.inputs.IntegrationResponseParameterArgs;
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 Integration("example", IntegrationArgs.builder()
            .apiId(exampleAwsApigatewayv2Api.id())
            .credentialsArn(exampleAwsIamRole.arn())
            .description("Example with a load balancer")
            .integrationType("HTTP_PROXY")
            .integrationUri(exampleAwsLbListener.arn())
            .integrationMethod("ANY")
            .connectionType("VPC_LINK")
            .connectionId(exampleAwsApigatewayv2VpcLink.id())
            .tlsConfig(IntegrationTlsConfigArgs.builder()
                .serverNameToVerify("example.com")
                .build())
            .requestParameters(Map.ofEntries(
                Map.entry("append:header.authforintegration", "$context.authorizer.authorizerResponse"),
                Map.entry("overwrite:path", "staticValueForIntegration")
            ))
            .responseParameters(
                IntegrationResponseParameterArgs.builder()
                    .statusCode(403)
                    .mappings(Map.of("append:header.auth", "$context.authorizer.authorizerResponse"))
                    .build(),
                IntegrationResponseParameterArgs.builder()
                    .statusCode(200)
                    .mappings(Map.of("overwrite:statuscode", "204"))
                    .build())
            .build());
    }
}

resources:
  example:
    type: aws:apigatewayv2:Integration
    properties:
      apiId: ${exampleAwsApigatewayv2Api.id}
      credentialsArn: ${exampleAwsIamRole.arn}
      description: Example with a load balancer
      integrationType: HTTP_PROXY
      integrationUri: ${exampleAwsLbListener.arn}
      integrationMethod: ANY
      connectionType: VPC_LINK
      connectionId: ${exampleAwsApigatewayv2VpcLink.id}
      tlsConfig:
        serverNameToVerify: example.com
      requestParameters:
        append:header.authforintegration: $context.authorizer.authorizerResponse
        overwrite:path: staticValueForIntegration
      responseParameters:
        - statusCode: 403
          mappings:
            append:header.auth: $context.authorizer.authorizerResponse
        - statusCode: 200
          mappings:
            overwrite:statuscode: '204'

Import

Using pulumi import, import aws_apigatewayv2_integration using the API identifier and integration identifier. For example:

$ pulumi import aws:apigatewayv2/integration:Integration example aabbccddee/1122334

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

Constructors

IntegrationArgs

fun IntegrationArgs(apiId: Output<String>? = null, connectionId: Output<String>? = null, connectionType: Output<String>? = null, contentHandlingStrategy: Output<String>? = null, credentialsArn: Output<String>? = null, description: Output<String>? = null, integrationMethod: Output<String>? = null, integrationSubtype: Output<String>? = null, integrationType: Output<String>? = null, integrationUri: Output<String>? = null, passthroughBehavior: Output<String>? = null, payloadFormatVersion: Output<String>? = null, requestParameters: Output<Map<String, String>>? = null, requestTemplates: Output<Map<String, String>>? = null, responseParameters: Output<List<IntegrationResponseParameterArgs>>? = null, templateSelectionExpression: Output<String>? = null, timeoutMilliseconds: Output<Int>? = null, tlsConfig: Output<IntegrationTlsConfigArgs>? = null)

Functions

toJava

open override fun toJava(): IntegrationArgs

Properties

apiId

val apiId: Output<String>? = null

API identifier.

connectionId

val connectionId: Output<String>? = null

ID of the VPC link for a private integration. Supported only for HTTP APIs. Must be between 1 and 1024 characters in length.

connectionType

val connectionType: Output<String>? = null

Type of the network connection to the integration endpoint. Valid values: INTERNET, VPC_LINK. Default is INTERNET.

contentHandlingStrategy

val contentHandlingStrategy: Output<String>? = null

How to handle response payload content type conversions. Valid values: CONVERT_TO_BINARY, CONVERT_TO_TEXT. Supported only for WebSocket APIs.

credentialsArn

val credentialsArn: Output<String>? = null

Credentials required for the integration, if any.

description

val description: Output<String>? = null

Description of the integration.

integrationMethod

val integrationMethod: Output<String>? = null

Integration's HTTP method. Must be specified if integration_type is not MOCK.

integrationSubtype

val integrationSubtype: Output<String>? = null

AWS service action to invoke. Supported only for HTTP APIs when integration_type is AWS_PROXY. See the AWS service integration reference documentation for supported values. Must be between 1 and 128 characters in length.

integrationType

val integrationType: Output<String>? = null

Integration type of an integration. Valid values: AWS (supported only for WebSocket APIs), AWS_PROXY, HTTP (supported only for WebSocket APIs), HTTP_PROXY, MOCK (supported only for WebSocket APIs). For an HTTP API private integration, use HTTP_PROXY.

integrationUri

val integrationUri: Output<String>? = null

URI of the Lambda function for a Lambda proxy integration, when integration_type is AWS_PROXY. For an HTTP integration, specify a fully-qualified URL. For an HTTP API private integration, specify the ARN of an Application Load Balancer listener, Network Load Balancer listener, or AWS Cloud Map service.

passthroughBehavior

val passthroughBehavior: Output<String>? = null

Pass-through behavior for incoming requests based on the Content-Type header in the request, and the available mapping templates specified as the request_templates attribute. Valid values: WHEN_NO_MATCH, WHEN_NO_TEMPLATES, NEVER. Default is WHEN_NO_MATCH. Supported only for WebSocket APIs.

payloadFormatVersion

val payloadFormatVersion: Output<String>? = null

The format of the payload sent to an integration. Valid values: 1.0, 2.0. Default is 1.0.

requestParameters

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

For WebSocket APIs, a key-value map specifying request parameters that are passed from the method request to the backend. For HTTP APIs with a specified integration_subtype, a key-value map specifying parameters that are passed to AWS_PROXY integrations. For HTTP APIs without a specified integration_subtype, a key-value map specifying how to transform HTTP requests before sending them to the backend. See the Amazon API Gateway Developer Guide for details.

requestTemplates

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

Map of Velocity templates that are applied on the request payload based on the value of the Content-Type header sent by the client. Supported only for WebSocket APIs.

responseParameters

val responseParameters: Output<List<IntegrationResponseParameterArgs>>? = null

Mappings to transform the HTTP response from a backend integration before returning the response to clients. Supported only for HTTP APIs.

templateSelectionExpression

val templateSelectionExpression: Output<String>? = null

The template selection expression for the integration.

timeoutMilliseconds

val timeoutMilliseconds: Output<Int>? = null

Custom timeout between 50 and 29,000 milliseconds for WebSocket APIs and between 50 and 30,000 milliseconds for HTTP APIs. The default timeout is 29 seconds for WebSocket APIs and 30 seconds for HTTP APIs. this provider will only perform drift detection of its value when present in a configuration.

tlsConfig

val tlsConfig: Output<IntegrationTlsConfigArgs>? = null

TLS configuration for a private integration. Supported only for HTTP APIs.