# IntegrationType

- Source: [`aws-apigateway/lib/integration.ts`](https://github.com/aws/aws-cdk/blob/v2.278.0/packages/aws-cdk-lib/aws-apigateway/lib/integration.ts#L309)

## Example

TypeScript:

```ts
import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';

const vpc = new ec2.Vpc(this, 'VPC');
const nlb = new elbv2.NetworkLoadBalancer(this, 'NLB', {
  vpc,
});
const link = new apigateway.VpcLink(this, 'link', {
  targets: [nlb],
});

const integration = new apigateway.Integration({
  type: apigateway.IntegrationType.HTTP_PROXY,
  integrationHttpMethod: 'ANY',
  options: {
    connectionType: apigateway.ConnectionType.VPC_LINK,
    vpcLink: link,
  },
});
```

Python:

```python
import aws_cdk.aws_elasticloadbalancingv2 as elbv2

vpc = ec2.Vpc(self, "VPC")
nlb = elbv2.NetworkLoadBalancer(self, "NLB",
    vpc=vpc
)
link = apigateway.VpcLink(self, "link",
    targets=[nlb]
)

integration = apigateway.Integration(
    type=apigateway.IntegrationType.HTTP_PROXY,
    integration_http_method="ANY",
    options=apigateway.IntegrationOptions(
        connection_type=apigateway.ConnectionType.VPC_LINK,
        vpc_link=link
    )
)
```

Java:

```java
import software.amazon.awscdk.services.elasticloadbalancingv2.*;

Vpc vpc = new Vpc(this, "VPC");
NetworkLoadBalancer nlb = NetworkLoadBalancer.Builder.create(this, "NLB")
        .vpc(vpc)
        .build();
VpcLink link = VpcLink.Builder.create(this, "link")
        .targets(List.of(nlb))
        .build();

Integration integration = Integration.Builder.create()
        .type(IntegrationType.HTTP_PROXY)
        .integrationHttpMethod("ANY")
        .options(IntegrationOptions.builder()
                .connectionType(ConnectionType.VPC_LINK)
                .vpcLink(link)
                .build())
        .build();
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.Lib
using Amazon.CDK.AWS.ElasticLoadBalancingV2;

var vpc = new Vpc(this, "VPC");
var nlb = new NetworkLoadBalancer(this, "NLB", new NetworkLoadBalancerProps {
    Vpc = vpc
});
var link = new VpcLink(this, "link", new VpcLinkProps {
    Targets = new [] { nlb }
});

var integration = new Integration(new IntegrationProps {
    Type = IntegrationType.HTTP_PROXY,
    IntegrationHttpMethod = "ANY",
    Options = new IntegrationOptions {
        ConnectionType = ConnectionType.VPC_LINK,
        VpcLink = link
    }
});
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
import elbv2 "github.com/aws/aws-cdk-go/awscdk"

vpc := ec2.NewVpc(this, jsii.String("VPC"))
nlb := elbv2.NewNetworkLoadBalancer(this, jsii.String("NLB"), &NetworkLoadBalancerProps{
	Vpc: Vpc,
})
link := apigateway.NewVpcLink(this, jsii.String("link"), &VpcLinkProps{
	Targets: []INetworkLoadBalancer{
		nlb,
	},
})

integration := apigateway.NewIntegration(&IntegrationProps{
	Type: apigateway.IntegrationType_HTTP_PROXY,
	IntegrationHttpMethod: jsii.String("ANY"),
	Options: &IntegrationOptions{
		ConnectionType: apigateway.ConnectionType_VPC_LINK,
		VpcLink: link,
	},
})
```

## Members

| Member | Description |
| --- | --- |
| `AWS` | For integrating the API method request with an AWS service action, including the Lambda function-invoking action. |
| `AWS_PROXY` | For integrating the API method request with the Lambda function-invoking action with the client request passed through as-is. |
| `HTTP` | For integrating the API method request with an HTTP endpoint, including a private HTTP endpoint within a VPC. |
| `HTTP_PROXY` | For integrating the API method request with an HTTP endpoint, including a private HTTP endpoint within a VPC, with the client request passed through as-is. |
| `MOCK` | For integrating the API method request with API Gateway as a "loop-back" endpoint without invoking any backend. |

## Referenced by

- [`IntegrationConfig`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.IntegrationConfig.html).type
- [`IntegrationProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.IntegrationProps.html).type
