Create AWS_API_GATEWAY_RESOURCES in a loop

The full Amazon API Gateway schema is challenging to construct dynamically in Terraform because it ends up requiring resources that depend on themselves. Dependencies in Terraform are between resource blocks as a whole rather than the individual instances of them, because Terraform must evaluate for_each or count before knowing which instances exist and those expressions can themselves have dependencies.

However, you can avoid that problem by using the OpenAPI-based method for describing your API, which follows a flat structure similar to what you've shown as your input. The API Gateway API internally transforms that into the corresponding individual resources, resource methods, integration methods, etc, so the result is the same but constructed in a way that doesn't involve as many resources and doesn't involve any dependencies between the objects.

For example:

locals {
  api_ops_by_path = tomap({
    for op in local.api_endpoints : op.path => op
  })
}

resource "aws_api_gateway_rest_api" "example" {
  # ...

  body = jsonencode({
    openapi = "3.0.1"
    info = {
      title   = "example"
      version = "1.0"
    }
    paths = {
      for path, ops in local.api_ops_by_path : path => {
        for op in ops : lower(op.http_method) => {
          x-amazon-apigateway-integration = {
            httpMethod = op.http_method
            uri        = op.integration_uri
            # ...
          }
        }
      }
    }
  })
}

The above uses for expressions to derive a data structure that follows the OpenAPI spec for describing methods associated with paths, and uses the x-amazon-apigateway-integration extension, specific to Amazon API Gateway, to describe what each operation integrates with. It then uses jsonencode to encode that resulting data structure into a form that API Gateway can parse and analyze.

When you define an API Gateway REST API with a body argument, you don't need to use any other resources to describe the schema; the information in body describes the same tree of resources in a different way. You will still need resources for the deployment, stages, etc, though, because they are independent of the actual API definition.

OpenAPI uses a flat structure -- all paths listed together as a single map, rather than resources nested inside one another -- and so that's a better fit both for the way your input data is structured and for describing this in a form that doesn't cause problems for Terraform's dependency graph.

References:

• aws_api_gateway_rest_api resource type in the hashicorp/aws provider (and in particular, the OpenAPI example)
• Configuring a REST API using OpenAPI: Amazon's own docs on how to use OpenAPI to define an API Gateway REST API. The Terraform provider is just wrapping this functionality from the underlying system.
• Amazon's extensions to OpenAPI, which describe the extra properties you can set in your OpenAPI schema that define the "integration" side of the API, which is not normally part of a standard OpenAPI definition.
• Terraform's jsonencode function
• for expressions in Terraform, which allow you to project collection values from one shape to another, so you can reshape your input into a valid OpenAPI schema as API Gateway requires.