Using aws apigateway with elasticache

Question

Pulumi · Accepted Answer

To integrate AWS Elasticache with an API Gateway, you need to create an API Gateway that can send requests to an AWS Elasticache instance. However, AWS Elasticache is not directly accessible from the internet or API Gateway due to its nature of being designed for high-performance, in-memory data store and cache within a VPC. To expose Elasticache to an API Gateway, you usually need to set up a Lambda function or an EC2 instance to act as an intermediary that resides within the same VPC as Elasticache.

Here is a high-level overview of the steps you will need to carry out in your Pulumi program:

1. Create an Elasticache Cluster or Replication Group.
2. Establish a subnet and security group for Elasticache that allows traffic from Lambda or EC2.
3. Create a Lambda function or an EC2 instance within the same VPC and set up the required network configurations to communicate with Elasticache.
4. Develop your Lambda function to interact with Elasticache as needed.
5. Create an API Gateway resource with a method and an integration that triggers the Lambda function.

Below is a Pulumi TypeScript program that outlines these steps. It assumes that you already have a VPC set up with at least one subnet and that you're intending to use a Lambda function to mediate between API Gateway and Elasticache. We're using the `aws.elasticache.Cluster` and `aws.apigateway.RestApi` for creating Elasticache and API Gateway respectively. The Lambda function is represented by `aws.lambda.Function`.

Please note that this example focuses on infrastructure setup:

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

// Create an ElastiCache cluster
const elasticacheCluster = new aws.elasticache.Cluster("my-cache", {
  engine: "redis",
  nodeType: "cache.m3.medium",
  // Set other required properties such as subnetGroupName and securityGroupIds
  // ...
});

// Assume your VPC, Subnet and Security Group are already set up.

// Create a Lambda function that will communicate with Elasticache
const lambdaFn = new aws.lambda.Function("my-lambda", {
  runtime: aws.lambda.NodeJS12dXRuntime,
  code: new pulumi.AssetArchive({
    // Place your zipped Lambda code here
  }),
  handler: "index.handler",
  role: myLambdaRole.arn, // Assume you have defined a role for your Lambda with the necessary permissions
  environment: {
    variables: {
      ELASTICACHE_ENDPOINT: elasticacheCluster.cacheNodes.apply(nodes => nodes[0].address),
    },
  },
  vpcConfig: {
    // Make sure your Lambda function is in the same VPC and can access your Elasticache cluster
    subnetIds: [mySubnet.id],
    securityGroupIds: [mySecurityGroup.id],
  }
});

// Create an API Gateway to trigger the Lambda function
const api = new aws.apigateway.RestApi("my-api", {
  description: "API Gateway to interact with Elasticache",
});

const resource = new aws.apigateway.Resource("my-resource", {
  restApi: api.id,
  parentId: api.rootResourceId,
  pathPart: "{proxy+}",
});

const method = new aws.apigateway.Method("my-method", {
  restApi: api,
  resourceId: resource.id,
  httpMethod: "ANY",
  authorization: "NONE",
});

const integration = new aws.apigateway.Integration("my-integration", {
  restApi: api,
  resourceId: resource.id,
  httpMethod: method.httpMethod,
  integrationHttpMethod: "POST",
  type: "AWS_PROXY",
  uri: lambdaFn.invokeArn,
});

const deployment = new aws.apigateway.Deployment("my-deployment", {
  restApi: api,
  // Setting stageName will create a new deployment stage
  stageName: "prod",
  // Ensure the deployment is re-created with every new integration update
  triggers: {
    redeployment: integration.id.apply(i => `${i}`),
  },
});

export const apiUrl = deployment.invokeUrl;
```

This code does the following:

- Sets up an Elasticache Redis cluster with a specific node type.
- Creates a Lambda function within the VPC that has the Elasticache subnet and security group, which enables it to connect to Elasticache. The function's ZIP archive and handler need to be specified with code suited to your application's requirements.
- Initializes an API Gateway `RestApi` resource which contains a `Resource` representing a URL path part.
- Defines a `Method` for the API Gateway resource that indicates the type of HTTP method accepted.
- Establishes an `Integration` between the API Gateway method and the Lambda function. We use the `AWS_PROXY` integration type so the Lambda function receives the raw request and can return a raw response back to the API Gateway.
- Deploys the API Gateway using the `Deployment` resource, which activates the API Gateway with a stage name for public access.

This is a simple example to get you started with integrating these services. The actual implementation for handling requests and interfacing with Elasticache will depend on your application's logic, which should be implemented within the Lambda function code. Remember to manage access permissions and environmental configuration according to your security and operational requirements.