• simple Lambda-based HTTP endpoint that stores data in ElastiCache Redis.
• This project includes a pre-configured stacktape.yml configuration. The configured infrastructure is described in the stack description section

1. AWS account. If you don't have one, create new account here.

2. Stacktape account. If you don't have one, create new account here.

3. Stacktape installed.

iwr https://installs.stacktape.com/windows.ps1 -useb | iex

curl -L https://installs.stacktape.com/linux.sh | sh

curl -L https://installs.stacktape.com/macos.sh | sh

curl -L https://installs.stacktape.com/macos-arm.sh | sh

To initialize the project, use

stacktape init --starterId lambda-app-redis

The deployment will take ~5-15 minutes. Subsequent deploys will be significantly faster.

stacktape deploy --projectName <<project-name>> --stage <<stage>> --region <<region>>

stacktape codebuild:deploy --stage <<stage>> --region <<region>> --projectName <<project-name>>

After a successful deployment, some information about the stack will be printed to the terminal (URLs of the deployed services, links to logs, metrics, etc.).

• Navigate to the URL <<main-api-gateway-url>>/{<<key>>}/{<<value>>} to store the key-value pair in Redis. The URL of your mainApiGateway is printed to the terminal as mainApiGateway -> url.

To run functions in the development mode (remotely on AWS), you can use the dev command. For example, to develop and debug lambda function storeKeyValuePair, you can use

stacktape dev --region <<your-region>> --stage <<stage>> --resourceName storeKeyValuePair

The command will:

• quickly re-build and re-deploy your new function code
• watch for the function logs and pretty-print them to the terminal

The function is rebuilt and redeployed, when you either:

• type rs + enter to the terminal
• use the --watch option and one of your source code files changes

• Stacktape deployments use AWS CloudFormation under the hood. It brings a lot of guarantees and convenience, but can be slow for certain use-cases.

• To speed up the deployment, you can use the --hotSwap flag which avoids using Cloudformation.

• Hotswap deployments work only for source code changes (for lambda function, containers and batch jobs) and for content uploads to buckets.

• If the update deployment is not hot-swappable, Stacktape will automatically fall back to using a Cloudformation deployment.

stacktape deploy --hotSwap --stage <<stage>> --region <<region>> --projectName <<project-name>>

• If you no longer want to use your stack, you can delete it.
• Stacktape will automatically delete every infrastructure resource and deployment artifact associated with your stack.

stacktape delete --stage <<stage>> --region <<region>>

Stacktape uses a simple stacktape.yml configuration file to describe infrastructure resources, packaging, deployment pipeline and other aspects of your project.

You can deploy your project to multiple environments (stages) - for example production, staging or dev-john. A stack is a running instance of an project. It consists of your application code (if any) and the infrastructure resources required to run it.

The configuration for this project is described below.

• Every resource must have an arbitrary, alphanumeric name (A-z0-9).
• Stacktape resources consist of multiple underlying AWS or 3rd party resources.

API Gateway receives requests and routes them to the Lambda function.

For convenience, it has CORS allowed.

resources:
  mainApiGateway:
    type: http-api-gateway
    properties:
      cors:
        enabled: true

The application uses an AWS ElastiCache Redis cluster for key-value storage.

The password is auto-generated using a $Secret directive. You can also configure other properties if desired.

redis:
  type: redis-cluster
  properties:
    defaultUserPassword: $Secret('redis.password')
    instanceSize: cache.t3.micro
    engineVersion: '7.1'

The application itself is fairly simple. It consists of a single lambda function storeKeyValuePair that stores a value inside our Redis cluster.

The function is configured as follows:

• Packaging - determines how the lambda artifact is built. The easiest and most optimized way to build the lambda from Typescript/Javascript is using stacktape-lambda-buildpack. We only need to configure entryfilePath. Stacktape automatically transpiles and builds the application code with all of its dependencies, creates the lambda zip artifact, and uploads it to a pre-created S3 bucket on AWS. You can also use other types of packaging.
• VPC - the function is connected to the default VPC (joinDefaultVpc: true) so it can reach the Redis cluster inside the VPC.
• ConnectTo list - we are adding redis cluster redis into connectTo list. By doing this, Stacktape will automatically inject relevant environment variables into the function's runtime (such as redis connection string required for connecting to the cluster).
• Events - Events determine how is function triggered. In this case, we are triggering the function when an event (HTTP request) is delivered to the HTTP API gateway to URL path /save/{key}/{value}, where {key} and ${value} are path parameters(key and value can be arbitrary values). The event(request) including the path parameters is passed to the function handler as an argument.

storeKeyValuePair:
  type: function
  properties:
    packaging:
      type: stacktape-lambda-buildpack
      properties:
        entryfilePath: ./src/store-key-value-pair.ts
    connectTo:
      - redis
    events:
      - type: http-api-gateway
        properties:
          httpApiGatewayName: mainApiGateway
          method: GET
          path: /save/{key}/{value}