How to attach an existing usage plan to an api gateway using CDK

[affanc]

Describe the feature

How to attach an existing usage plan to an api gateway using CDK

Use Case

Cx wants to import existing usagePlan for aws-api-gateway using CDK, but running into this error below:

Resource handler returned message: "Invalid API Stage {api: %s, stage: %s} specified for usageplan %s (Service: ApiGateway, Status Code: 400, Request ID: ...)" (RequestToken: ..., HandlerErrorCode: InvalidRequest)

Proposed Solution

Tried to create new usagePlan from the link here : https://docs.aws.amazon.com/cdk/api/v1/docs/@aws-cdk_aws-apigateway.UsagePlan.htmlbut same error occurred. I have included the code snippet

Other Information

const usagePlanEvt = new UsagePlan(this, myUsagePlan, {
            name: myUsagePlan,
            description: `${this.stackEnv} usage plan`,
            throttle: {
                rateLimit: 5,
                burstLimit: 2
            },
            quota: {
                limit: 500,
                period: [Period.DAY ](#),
            }
        });
        const apiKeyNameEvt = `${prefix}-EVT-Api-Key`.toLocaleLowerCase();
        const apiKeyEvt = new ApiKey(this, apiKeyNameEvt, {
            apiKeyName: apiKeyNameEvt,
        });
        usagePlanEvt.addApiKey(apiKeyEvt);

        const api = RestApi.fromRestApiId(this, 'ImportedApi', 'ca69uil4i1');
        usagePlanEvt.addApiStage({
            api: api
        });

Acknowledgements

• I may be able to implement this feature request
• This feature might incur a breaking change

CDK version used

2.46.0

Environment details (OS name and version, etc.)

Windows

[brendonparker]

This seems to be a limitation of the AWS APIs, maybe not strictly a CDK thing. There aren't L1 constructs for associating an existing usage plan to a api stage. Only for creating the usage plan and associating it all together.

I think my scenario is similar, but the dependecies are inverted. I have a separate Infrastructure stack which defines my VPC, and I'd like the add the usage plan to this stack. I can then template out my Application stack, and run that stack multiple times for different environments. I want to share that usage plan across these Application stacks.

I can use the usagePlanId along with:

var usagePlan = APIGW.UsagePlan.FromUsagePlanId(this, "UsagePlan", props.UsagePlanId);

but then usagePlan is an IUsagePlan not a UsagePlan so I can't do:

usagePlan.AddApiStage(new UsagePlanPerApiStage
{
    Api = props.Api,
    Stage = props.Api.DeploymentStage
});

[brendonparker]

I think I was able to work around this by using an AwsCustomResource:

public class AddApiStageToUsagePlanProps
{
    public string UsagePlanId { get; init; }
    public string ApiId { get; init; }
    public string Stage { get; init; }
}

public class AddApiStageToUsagePlan : AwsCustomResource
{
    public AddApiStageToUsagePlan(Construct scope, string id, AddApiStageToUsagePlanProps props) : base(scope, id, new AwsCustomResourceProps
    {
        OnCreate = new AwsSdkCall
        {
            Service = "APIGateway",
            Action = "updateUsagePlan",
            Parameters = new Dictionary<string, object>
            {
                ["usagePlanId"] = props.UsagePlanId,
                ["patchOperations"] = new[]
                {
                    new Dictionary<string, string>
                    {
                        ["op"] = "add",
                        ["path"] = "/apiStages",
                        ["value"] = $"{props.ApiId}:{props.Stage}",
                    }
                }
            },
            PhysicalResourceId = PhysicalResourceId.Of(props.UsagePlanId),
        },
        OnDelete = new AwsSdkCall
        {
            Service = "APIGateway",
            Action = "updateUsagePlan",
            Parameters = new Dictionary<string, object>
            {
                ["usagePlanId"] = props.UsagePlanId,
                ["patchOperations"] = new[]
                {
                    new Dictionary<string, string>
                    {
                        ["op"] = "remove",
                        ["path"] = "/apiStages",
                        ["value"] = $"{props.ApiId}:{props.Stage}",
                    }
                }
            },
            PhysicalResourceId = PhysicalResourceId.Of(props.UsagePlanId),
        },
        Policy = AwsCustomResourcePolicy.FromStatements(new[]
        {
            new PolicyStatement(new PolicyStatementProps
            {
                Resources = AwsCustomResourcePolicy.ANY_RESOURCE,
                Actions = new[]
                {
                    "apigateway:PATCH"
                }
            })
        }),
    })
    {
    }
}

[brendonparker]

However, this is proving to be problematic if you edit/change the usage plan settings in the parent stack. Because the usage plan is dealt with as a single construct in the cloudformation template, that will effectively wipe out the usage plan assignment to the api gw stage.

[robin-coste]

for reference this worked well for me as well, the code in typescript:

import {
    AwsCustomResource,
    AwsSdkCall,
    PhysicalResourceId,
} from "aws-cdk-lib/custom-resources";
import { Construct } from "constructs";
import * as iam from "aws-cdk-lib/aws-iam";

export interface AddApiStageToUsagePlanProps {
    UsagePlanId: string;
    ApiId: string;
    Stage: string;
}

export class AddApiStageToUsagePlan extends AwsCustomResource {
    constructor(
        scope: Construct,
        name: string,
        props: AddApiStageToUsagePlanProps
    ) {
        const usagePlanSdkCall = (op: string): AwsSdkCall => ({
            service: "@aws-sdk/client-api-gateway",
            action: "UpdateUsagePlanCommand",
            parameters: {
                usagePlanId: props.UsagePlanId,
                patchOperations: [
                    {
                        op,
                        path: "/apiStages",
                        value: `${props.ApiId}:${props.Stage}`,
                    },
                ],
            },
            physicalResourceId: PhysicalResourceId.of(
                props.UsagePlanId + "--" + props.ApiId
            ),
        });

        super(scope, name, {
            onCreate: usagePlanSdkCall("add"),
            onDelete: usagePlanSdkCall("remove"),
            installLatestAwsSdk: false,
            policy: {
                statements: [
                    new iam.PolicyStatement({
                        resources: ["*"],
                        actions: ["apigateway:PATCH"],
                        effect: iam.Effect.ALLOW,
                    }),
                ],
            },
        });
    }
}

NB: only the physicalResourceId is different in order to reuse be able to reuse it many times in the same stack and different api gateways
Thanks @brendonparker for saving us :)

[ccddan]

Initially I was creating my usage plan and api key in the same stack where my rest api is created. Stage deployment happens in other stack, so I was trying to find a way to link my usage plan created from my api stack but from my stage deployment stack.
By moving my usage plan creation to the stage deployment stack, I ended up with the following impl:

export class ApiDeploymentStack extends Stack {
  constructor(scope: App, id: string, props: ApiDeploymentStackProps /* custom StackProps interface */) {
    super(scope, id, props as _StackProps /* cast custom props to original cdk StackProps interface */);

    const apiId = StringParameter.fromStringParameterName(this, "apiIdSSM", props.ssm.apiId).stringValue;
    const api = RestApi.fromRestApiId(this, "apiId", apiId);

    // Deployment
    const deployment = new Deployment(this, "apiDeployment", {
      api,
      retainDeployments: true,
    });

    // Stage
    const stage = new Stage(this, "apiStage", {
      deployment,
      stageName: "v1",
      metricsEnabled: true,
      tracingEnabled: true,
      dataTraceEnabled: true,
      loggingLevel: MethodLoggingLevel.INFO,
    });

    // Api Key
    const apiKey = new ApiKey(this, "ApiKey", {
      apiKeyName: "api-key",
    });

    // Usage Plan
    const usagePlan = new UsagePlan(this, "UsagePlan", {
      name: "usage-plan",
      apiStages: [{
        api,
        stage,
      }],
    });
    usagePlan.addApiKey(apiKey);
  }
}