An HTTP API Gateway serves as an entry point for your application, routing HTTP traffic to your compute resources. It can be integrated with functions, batch jobs, and multi-container workloads.

Each API gateway is secured with TLS by default. You can also configure a custom domain name, enable CORS, or place a CDN in front of your gateway.

When to use them

HTTP API Gateways are a good fit for any modern web application, from a simple "front door" for a lightweight service to a powerful backend API with authorization and monitoring.

Advantages

• Pay-per-use: You are only charged for the number of requests your gateway processes (from $0.90 to $1.00 per million requests).
• Scalability: The gateway scales automatically to handle thousands of requests per second.
• Security: Each gateway is secured with TLS by default.
• High availability: API Gateway has a 99.95% monthly uptime SLA.
• Ease of use: You can integrate a gateway with your compute resources with just a few lines of configuration.

Disadvantages

• Limited routing: HTTP API Gateways only support path-based routing. If you need to route requests based on query parameters, IP addresses, or HTTP headers, consider using an Application Load Balancer instead.

Basic usage

You don't need to specify any properties to create a basic HTTP API Gateway.

resources:
  myHttpApi:
    type: 'http-api-gateway'

Integrating with compute resources

You can forward requests from an API gateway to your compute resources by creating an event integration on a multi-container workload, function, or batch job.

Each integration must specify:

• httpApiGatewayName: The name of the API gateway.
• path: A path pattern that the request must match.
• method: The HTTP method that the request must match.

If multiple integrations match a request, the most specific one is chosen.

This example shows two integrations:

• The first forwards all requests (/{proxy+}) to a multi-container workload.
• The second, which is more specific, forwards GET requests for /invoke-my-function to a Lambda function.

resources:
  myHttpApi:
    type: http-api-gateway

  myFunction:
    type: function
    properties:
      packaging:
        type: stacktape-lambda-buildpack
        properties:
          entryfilePath: 'path/to/my-lambda.ts'
      events:
        - type: http-api-gateway
          properties:
            httpApiGatewayName: 'myHttpApi'
            path: '/invoke-my-function'
            method: 'GET'

  mySingleContainer:
    type: 'multi-container-workload'
    properties:
      containers:
        - name: 'myAppContainer'
          packaging:
            type: stacktape-image-buildpack
            properties:
              entryfilePath: '_example-configs/containers/ts-container.ts'
          environment:
            - name: port
              value: 80
          events:
            - type: 'http-api-gateway'
              properties:
                httpApiGatewayName: 'myHttpApi'
                containerPort: 80
                path: /{proxy+} # greedy path
                method: '*'
      resources:
        cpu: 0.25
        memory: 512

For more information, see the documentation on integrating API gateways with functions and multi-container workloads.

CORS

Cross-Origin Resource Sharing (CORS) is a security feature that controls how web browsers handle requests to a different domain than the one the user is currently on. If your frontend and backend are on different domains (e.g., mydomain.com and api.mydomain.com), you'll need to configure CORS.

You can enable CORS with a single line:

resources:
  myHttpApi:
    type: 'http-api-gateway'
    properties:
      cors:
        enabled: true

You can also customize the CORS headers:

Custom domain names

You can use a custom domain for your API gateway. If you don't have one, you can register one through Stacktape.

If you already have a domain, you can either let Stacktape manage it (if you use AWS Route 53 for DNS) or use a third-party DNS provider.

For more details, see the Domains and Certificates page.

Using Stacktape to manage domains and certs

resources:
  myHttpApi:
    type: 'http-api-gateway'
    properties:
      customDomains:
        - domainName: whatever.mydomain.com

Using a 3rd-party DNS

To use a domain from a provider like GoDaddy or Cloudflare:

1. Create or import a TLS certificate for your domain in the AWS Certificate Manager console and copy its ARN.
2. Add the customDomains configuration to your API gateway, using the certificate ARN and disabling DNS record creation.

resources:
  myWebsite:
    type: http-api-gateway
    properties:
      customDomains:
        - domainName: mydomain.com
          disableDnsRecordCreation: true
          customCertificateArn: <<ARN_OF_YOUR_CERTIFICATE>>

3. After deploying, find the API gateway's domain name in the Stacktape Console.
4. In your DNS provider's dashboard, create a CNAME or ALIAS record pointing to the API gateway's domain name.

Access logs

Access logs contain basic information about requests to your API gateway, which can be useful for auditing and compliance. Stacktape enables access logging by default, with a retention period of 30 days.

resources:
  myHttpApi:
    type: 'http-api-gateway'
    properties:
      logging:
        format: CSV

CDN

You can place an AWS CloudFront CDN in front of your API gateway to cache responses and reduce latency.

For more information, see the CDN documentation.

Referenceable parameters