Using aws apigateway with route53domains

Question

Pulumi · Accepted Answer

When integrating AWS API Gateway with Route 53 domains, the general workflow involves creating and configuring your API Gateway resources such as methods, deployments, stages, and possibly models or authorizers. Then you would set up a custom domain name within API Gateway, including the creation of an SSL/TLS certificate (if you don't already have one). Once your custom domain is configured, you can create the necessary DNS records in Route 53 to point your domain to the API Gateway.

Here's the process, broken down with Pulumi in TypeScript, which will guide you through setting up an API Gateway and configuring a custom domain name for it, with the necessary Route 53 configuration:

1. **Set up the API Gateway**: Configure the API, its resources, methods, and a deployment.
2. **Create a Custom Domain Name**: Create a domain name in API Gateway and associate it with the API.
3. **Set up an SSL/TLS Certificate**: You will need an SSL/TLS certificate in AWS Certificate Manager (ACM) that covers the custom domain.
4. **Configure DNS in Route 53**: Once the custom domain is ready, configure Route 53 to create an `A` or `Alias` record that points to the API Gateway endpoint.

Below is a Pulumi TypeScript program to set up an API Gateway with a custom domain name pointed to by Route 53.

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

const stackConfig = new pulumi.Config();
const domainName = stackConfig.require("domainName"); // Your domain name

// Create a new API Gateway REST API
const api = new aws.apigateway.RestApi("myApi", {
    description: "This is my API for demonstration purposes",
});

// Create a new API Resource
const resource = new aws.apigateway.Resource("myResource", {
    restApi: api.id,
    parentId: api.rootResourceId,
    pathPart: "myResource",
});

// Create a new GET method on the specified resource
const method = new aws.apigateway.Method("myMethod", {
    restApi: api.id,
    resourceId: resource.id,
    httpMethod: "GET",
    authorization: "NONE",
});

// Create a new Integration to connect the GET method to a backend endpoint
const integration = new aws.apigateway.Integration("myIntegration", {
    restApi: api.id,
    resourceId: resource.id,
    httpMethod: method.httpMethod,
    integrationHttpMethod: "POST",
    type: "MOCK", // Use MOCK for simplicity, replace with actual integration details
});

// Create a new Deployment of the REST API
const deployment = new aws.apigateway.Deployment("myDeployment", {
    restApi: api.id,
    // The stage name to deploy to
    stageName: "prod",
});

// Create a new Domain Name
const apiDomain = new aws.apigateway.DomainName("myCustomDomain", {
    domainName: domainName, // Your custom domain name
    certificateArn: aws.acm.getCertificate({
      domain: domainName,
      statuses: ["ISSUED"], // Ensure certificate is issued
    }).then(certificate => certificate.arn), // Assuming you have an existing certificate
});

// Map the custom domain name to a particular stage
const basepathMapping = new aws.apigateway.BasePathMapping("myBasePathMapping", {
    restApi: api.id,
    stageName: deployment.stageName,
    domainName: apiDomain.domainName,
});

// Attach the API Gateway to a Route 53 record
const dnsRecord = new aws.route53.Record("apiDNSRecord", {
    zoneId: aws.route53.getZone({ name: domainName }).then(zone => zone.id), // Ensure you have a hosted zone for your domain
    name: domainName,
    type: "A",
    aliases: [
        {
            evaluateTargetHealth: true,
            name: apiDomain.cloudfrontDomainName,
            zoneId: apiDomain.cloudfrontZoneId,
        },
    ],
});

export const apiUrl = pulumi.interpolate`https://${apiDomain.domainName}/`;
```

Make sure you replace `domainName` in `stackConfig.require("domainName")` with your actual domain name and ensure that the SSL/TLS certificate exists and is verified in AWS Certificate Manager. The `apiDomain.cloudfrontDomainName` and `apiDomain.cloudfrontZoneId` are automatically set up by the `DomainName` resource, which creates a CloudFront distribution under the hood to work with API Gateway.

This code will output the custom URL for the API Gateway, which can be accessed via the provided domain name. The given resources and their interrelationships create a basic API Gateway setup with a custom domain name served through Route 53.

Please make sure you are familiar with the pricing and other considerations when using these services on AWS, as creating resources may incur costs.