Skip to content

aws/aws-cdk-rfcs

master
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Code

Latest commit

* RFC 431: SageMaker Model Hosting L2 Constructs

Co-authored-by: Matt McClean <mmcclean@amazon.com>
Co-authored-by: Long Yao <yl1984108@gmail.com>
Co-authored-by: Drew Jetter <60628154+jetterdj@users.noreply.github.com>
Co-authored-by: Murali Ganesh <59461079+foxpro24@users.noreply.github.com>
Co-authored-by: Abilash Rangoju <988529+rangoju@users.noreply.github.com>

* Update author list to mirror issue/PR

* Reword & restructure README based on feedback

* Remove one CDKv1-specific module reference

* Fix specification of defaults

* Simplify autoscaling documentation

* Remove mention of endpoint from model VPC docs

* Eliminate uppercase abbreviations

* Remove second CDKv1-specific module reference

* Simplify container/variant props

* Remove container limit in README as it may change

* Remove non-default Rosetta fixtures

* Document EndpointConfig reuse across Endpoints

* Reword ContainerImage unification as an open issue

* Drop scope/id specification in ContainerImage API

* Drop scope/id specification in ModelData API

* Distinguish instance-based variants

* Document open issues based on API evolution

* Distinguish instance-based variants for Endpoints

* Drop README mention of IEndpointProductionVariant

* Sync technical solution API with implementation

* Expand serverless evolution

* Create assets behind fromAsset APIs for image/data

* Trim README content in favor of links to AWS docs

* Link to SageMaker ENI CloudFormation issue

* signing off as api bar raiser

* Adjust EndpointProps to take IEndpointConfig

* Fix my own entry on original authors

* Add API bar raiser login to top to match sign-off

* Update 0431-sagemaker-l2-endpoint.md

Co-authored-by: Matt McClean <mmcclean@amazon.com>
Co-authored-by: Long Yao <yl1984108@gmail.com>
Co-authored-by: Drew Jetter <60628154+jetterdj@users.noreply.github.com>
Co-authored-by: Murali Ganesh <59461079+foxpro24@users.noreply.github.com>
Co-authored-by: Abilash Rangoju <988529+rangoju@users.noreply.github.com>
Co-authored-by: Kaizen Conroy <36202692+kaizencc@users.noreply.github.com>
470c005

Git stats

Files

Permalink
Failed to load latest commit information.

AWS CDK RFCs

This repo is a place to propose and track major upcoming changes to AWS CDK, jsii, and other related projects. It also is a great place to learn about the current and future state of the libraries and to discover projects for contribution.

Jump to: What is an RFC? | When to submit? | RFC Process | RFC Life Cycle

# Title Owner Status
52 Support resource import 👷 implementing
77 CloudFormation Registry Support 👷 implementing
340 Kinesis Data Firehose Delivery Stream L2 @BenChaimberg 👷 implementing
460 Reduce aws-cdk-lib package size 👷 implementing
431 SageMaker Model Hosting L2 Constructs final comments
8 Project Structure Guidelines @rix0rrr ✍️ review
175 AppSync Mapping Template Object Model @MrArnoldPalmer ✍️ review
317 CDK third-party dependencies management ✍️ review
362 Construct Library for Contributor Insights Rules ✍️ review
419 CDK environment setup for platform/system administrators ✍️ review
2 Support for CloudFormation Resource Imports 💡 proposed
4 CDK Testing Toolkit @nija-at 💡 proposed
5 Security-restricted environments 💡 proposed
9 Master developer guide sources in main repo 💡 proposed
10 New workshop modules 💡 proposed
13 Improvements to Reference docs 💡 proposed
14 Toolchain 2.0 💡 proposed
15 Scaffolding 💡 proposed
17 CLI support for multiple-environments 💡 proposed
18 Open Context Providers @ddneilson 💡 proposed
19 Introspection API 💡 proposed
20 Security posture summary 💡 proposed
21 CDK Explorer Roadmap 💡 proposed
22 Cost calculator 💡 proposed
23 Stateful resource support 💡 proposed
24 Resource imports 💡 proposed
25 Defaults & configuration policy 💡 proposed
26 Monitoring packs 💡 proposed
27 200 resource limit tools & guidance 💡 proposed
30 Improve synthesized template output 💡 proposed
31 Integration tests 💡 proposed
32 App-centric operational experience 💡 proposed
39 Release public artifacts (lambda layers for custom resources, docker images) 💡 proposed
40 Stack traces across language boundaries 💡 proposed
48 Faster builds 💡 proposed
51 Standardize security groups 💡 proposed
58 Improved ergonomics for stack default environment 💡 proposed
63 CDK in Secure Environments 💡 proposed
64 Garbage Collection for Assets @kaizencc 💡 proposed
65 CDK Code Generation from AWS Console 💡 proposed
66 StackSets Support 💡 proposed
67 Monitoring Packs 💡 proposed
69 One-off "job" Stacks ("auto destruct") 💡 proposed
70 Cost Estimation Tools 💡 proposed
72 Stack Policy 💡 proposed
73 AWS Resource Model 💡 proposed
74 Common API for Resources with Web Addresses 💡 proposed
78 Feature proposal: Workspaces 💡 proposed
81 AWS Landing Zone CDK pattern request 💡 proposed
82 Weak references 💡 proposed
83 Global Name Prefix 💡 proposed
86 AWS Account Alias Resource 💡 proposed
127 CDK to directly reference/import/update an existing stack 💡 proposed
139 "fromLookup" for additional resources 💡 proposed
158 Implement Custom Resources in the AWS Construct Library as CFN Registry Resource Types 💡 proposed
159 Cross-App Resource Sharing 💡 proposed
161 Cross-Region/Account References 💡 proposed
162 CDK Refactoring Tools 💡 proposed
180 CustomResources: Allow usage across accounts 💡 proposed
193 Fixing of type unions @RomainMuller 💡 proposed
201 Construct scope relocation 💡 proposed
217 Alternative Infrastructure Providers @ccfife 💡 proposed
219 ECS Patterns Service Builder 💡 proposed
223 Improvements to Lambda Development Experience 💡 proposed
228 CDK CLI Triggers 💡 proposed
229 Construct library pattern for metrics 💡 proposed
230 Construct library pattern for grants 💡 proposed
231 Construct library pattern for resources that use a VPC 💡 proposed
232 Construct library pattern for resources that need IAM roles 💡 proposed
242 Bootstrap stacks as CDK apps 💡 proposed
244 Migration path for EKS Developer Preview 💡 proposed
247 CDK Common Stored Data Type Model 💡 proposed
248 Standardized context key for "cheap mode" 💡 proposed
256 ReactCDK: Add JSX/TSX Support 💡 proposed
272 CI/CD to Cloudfront Deploy 💡 proposed
275 route53-patterns for cross account DNS delegation 💡 proposed
277 cdk logs 💡 proposed
294 Policy Definition and Enforcement 💡 proposed
300 Programmatic Access of CDK CLI Capabilities 💡 proposed
305 support code signing of assets 💡 proposed
309 Parameter Store for cross stack references 💡 proposed
313 Questions on the Go Bindings RFC 💡 proposed
348 CloudFormationController - refactor CloudFormation stacks 💡 proposed
370 CLI deploy with change set review confirmation 💡 proposed
375 Support Encode Properties for CloudFormation CustomResource 💡 proposed
380 Remove Node.js as an installed pre-requisite for the jsii runtime 💡 proposed
394 WAF v2 L2 Construct 💡 proposed
399 SSM Document as Objects 💡 proposed
400 RUM AppMonitor L2 Construct 💡 proposed
402 Glue DataBrew L2 Construct 💡 proposed
418 CDK Operator CLI 💡 proposed
423 IoT Sitewise L2 Construct 💡 proposed
426 AppConfig L2 Construct 💡 proposed
428 Amazon CloudWatch Evidently L2 Constructs 💡 proposed
434 AWS Ground Station L2 Constructs 💡 proposed
437 CDK post-deployment experience 💡 proposed
441 Add Sagemaker endpoint L2 construct 💡 proposed
446 Network Firewall L2 Constructs 💡 proposed
448 AWS Compute Optimizer Constructs 💡 proposed
450 AWS CDK public roadmap 💡 proposed
456 L2 ElastiCache support 💡 proposed
457 Add functional-style methods to assertions Template, to improve consumer test readability 💡 proposed
458 Service Catalog ProductStack Asset Support 💡 proposed
1 CDK Watch done
6 Monolithic Packaging done
7 Lambda Bundles done
16 RFC Process @MrArnoldPalmer done
34 Third-party construct ecosystem done
35 Publish construct library guidelines done
36 Constructs Programming Model done
37 Release from a "release" branch @MrArnoldPalmer done
49 CI/CD for CDK apps @rix0rrr done
55 Feature Flags done
71 Deployment Triggers done
79 CDK v2.0 done
92 CI/CD Asset Publishing @rix0rrr done
95 Cognito Construct Library @nija-at done
107 Publish a Construct Library Module Lifecycle document @ccfife done
110 CLI Compatibility Strategy @iliapolo done
116 Easier identification of experimental modules done
171 CloudFront Module Redesign done
192 Removal of the "constructs" compatibility layer (v2.0) @eladb done
204 JSII Go Support @MrArnoldPalmer done
249 Experimental Code in CDK v2 @ericzbeard done
253 CDK Metadata v2 done
282 CDK Pipelines security posture change approvals done
287 Deprecated API Warnings done
308 CLI notices done
322 CDK Pipelines Updated API done
324 Construct Hub @RomainMuller done
328 polyglot assert library @nija-at done
353 Constructs for all public CloudFormation resources and modules done
359 Construct Hub Deny List done
388 CLI Banners done
60 Bazel Build System 👎 rejected
164 Construct Library Segments @nija-at 👎 rejected
374 The jsii compiler to follow TypeScript versioning unknown
436 Amazon GameLift L2 Constructs unknown

What is an RFC?

An RFC is a document that proposes a change to one of the projects led by the CDK team at AWS. Request for Comments means a request for discussion and oversight about the future of the project from maintainers, contributors and users.

When should I write an RFC? The CDK team proactively decides to write RFCs on major features or complex changes that we feel require that extra vetting. However, the process is designed to be as lightweight as needed and can be used to request feedback on any change. Quite often, even changes that seem obvious and simple at first sight can be significantly improved once a wider group of interested and experienced people have a chance to weigh in.

Who should submit an RFC? An RFC can be submitted by anyone. In most cases, RFCs are authored by CDK maintainers, but contributors are more than welcome to submit RFCs.

If you are a contributor and you wish to write an RFC, please contact the core team at the #aws-cdk-rfcs to make sure someone from the core team can sponsor your work. Otherwise, there is a good chance we won't have bandwidth to help.

RFC Process

To start an RFC process, create a new tracking issue and follow the instructions in the issue template. It includes a checklist of the various stages an RFC goes through.

This section describes each stage in detail, so you can refer to it for guidance.

1. Tracking Issue

Each RFC has a GitHub issue which tracks it from start to finish. The issue is the hub for conversations, community signal (+1s) and the issue number is used as the unique identifier of this RFC.

Before creating a tracking issue, please search for similar or related ideas in the RFC table above or in the issue list of this repo. If there is a relevant RFC, collaborate on that existing RFC, based on its current stage.

Our tracking issue template includes a checklist of all the steps an RFC goes through and it's the driver's responsibility to update the checklist and assign the correct label to on the RFC throughout the process.

When the issue is created, it is required to fill in the following information:

  1. Title: the name of the feature or change - think changelog entry.
  2. Description: a short description of feature, as if it was already implemented.
  3. Proposed by: fill in the GitHub alias of the person who proposed the idea under "Proposed by".

2. API Bar Raiser

Reach us via #aws-cdk-rfcs to get an "API Bar Raiser" assigned to your RFC.

For each RFC, CDK leadership will assign an API Bar Raiser who reviews and approves the public API of the feature. API Bar Raisers have veto rights on API-related design decisions, such as naming, structure, options, CLI commands and others.

The public API of a feature represents the surface through which users interact with it, and we want to make sure these APIs are consistent, ergonomic and designed based on the intent and the mental model of our users. Additionally, once we announce that a feature is "stable" (1.0, GA, etc) any breaking change to its public API will require releasing a new major version, so we like think of API decisions as "one way doors".

API Bar Raisers will be assigned using a tiering model which is generally based on the size of the user base that will likely get exposed to the feature. As a general rule, the more "significant" the feature is, we will assign a bar raiser with a wider and longer-term context of the project.

To merge an RFC, a sign-off from the bar raiser is required on the public API of the feature, so we encourage to engage with them early in the process to make sure you are aligned on how the API should be designed.

NOTE: The technical solution proposed in an RFC does not require approval beyond the normal pull request approval model (e.g. a core team member needs to approve the RFC PR and any subsequent changes to it).

3. Kick-off

Before diving into writing the RFC, it is highly recommended to organize a kick-off meeting that includes the API Bar Raiser and any stakeholders that might be interested in this RFC or can contribute ideas and direction. The goal of the meeting is to discuss the feature, its scope and general direction for implementation.

If you are not part of the CDK team at Amazon, reach out to us via #aws-cdk-rfcs and we will help to organize the kick-off meeting.

Our experience shows that such a meeting can save a lot of time and energy.

You can use the tracking issue to record some initial API and design ideas and collect early feedback and use cases as a preparation for the kick-off meeting and RFC document itself. You can start the meeting by letting participants obtaining context from the tracking issue.

At the end of the meeting, record any ideas and decisions in the tracking issue and update the checklist to indicate that the kick-off meeting has happened.

4. RFC Document

The next step is to write the first revision of the RFC document itself.

Create a file under text/NNNN-name.md based off of the template under 0000-template.md (where NNNN is your tracking issue number). Follow the template. It includes useful guidance and tips on how to write a good RFC.

What should be included in an RFC? The purpose of an RFC is to reduce ambiguity and risk and get approval for public-facing interfaces (APIs), which are "one-way doors" after the feature is released. Another way to think about it is that the goal and contents of the document should allow us to create a high-confidence implementation plan for a feature or a change.

In many cases, it is useful to develop a prototype or even start coding the actual implementation while you are writing the RFC document. Take into account that you may need to throw your code away or refactor it substantially, but our experience shows that good RFCs are the ones who dive into the details. A prototype is great way to make sure your design "holds water".

5. Feedback

Once you have an initial version of your RFC document (it is completely fine to submit an unfinished RFC to get initial feedback), submit it as a pull request against this repo and start collecting feedback.

Contact the CDK core team at #aws-cdk-rfcs (or via email/Slack if you are part of the core team) and reach out to the public and Amazon internal communities via various Slack channels in cdk.dev, Twitter and any other relevant forum.

This is the likely going to be the longest part of your RFC process, and where most of the feedback is collected. Some RFCs resolve quickly and some can take months (!!). Take into account at least 1-2 weeks to allow community and stakeholders to provide their feedback.

A few tips:

  • If you decide to resolve a comment without addressing it, take the time to explain.
  • Try to understand where people are coming from. If a comment seems off, ask folks to elaborate and describe their use case or provide concrete examples.
  • Work with your API bar raiser: if there are disagreements, @mention them in a comment and ask them to provide their opinion.
  • Be patient: it sometimes takes time for an RFC to converge. Our experience shows that some ideas need to "bake" and solutions oftentimes emerge via a healthy debate. We've had RFCs that took months to resolve.
  • Not everything must be resolved in the first revision. It is okay to leave some things to resolve later. Make sure to capture them clearly and have an agreement about that. We oftentimes update an RFC doc a few times during the implementation.

6. API Sign-off

Before you can merge your RFC, you will need the API Bar Raiser to sign-off on the public API of your feature. This is will normally be described under the Working Backwards section of your RFC.

To sign-off, the API bar raiser will add the api-approved label to the RFC pull request.

Once the API was signed-off, update your RFC document and add a [x] the relevant location in the RFC document. For example:

[x] Signed-off by API Bar Raiser @foobar

7. Final Comments Period

At some point, you've reached consensus about most issues that were brought up during the review period, and you are ready to merge. To allow "last call" on feedback, the author can announce that the RFC enters "final comments period", which means that within a ~week, if no major concerns are raised, the RFC will be approved and merged.

Add a comment on the RFC pull request, tracking issue (and possibly slack/email if relevant) that the RFC entered this stage so that all relevant stakeholders will be notified.

Once the final comments period is over, seek an approval of one of the core team members, and you can merge your PR to the main branch. This will move your RFC to the "approved" state.

8. Implementation

For large changes, we highly recommend creating an implementation plan which lists all the tasks required. In many cases, large implementation should be broken down and released via multiple iterations. Devising a concrete plan to break down the break can be very helpful.

The implementation plan should be submitted through a PR that adds an addendum to the RFC document and seeks the approval of any relevant stakeholders.

Throughout this process, update the tracking issue:

  • Add the alias of the "implementation lead"
  • Execution plan submitted (label: status/planning)
  • Plan approved and merged (label: status/implementing)
  • Implementation complete (label: status/done)

State Diagram

The following state diagram describes the RFC process:

rfc-states

  1. Proposed - A tracking issue has been created with a basic outline of the proposal.
  2. Review - An RFC document has been written with a detailed design and a PR is under review. At this point the PR will be assigned a shepherd from the core team.
  3. Final Comment Period - The shepherd has approved the RFC PR, and announces that the RFC enters a period for final comments before it will be approved (~1wk). At this stage, if major issues are raised, the RFC may return to Review.
  4. Approved - The RFC PR is approved and merged to master, and the RFC is now ready to be implemented.
  5. Planning - A PR is created with the Implementation Plan section of the RFC.
  6. Implementing - Implemetation plan is approved and merged and the RFC is actively being implemented.
  7. Done - Implementation is complete and merged across appropriate repositories.
  8. Rejected - During the review period, the RFC may be rejected and then it will be marked as such.

AWS CDK's RFC process owes its inspiration to the Yarn RFC process, Rust RFC process, React RFC process, and Ember RFC process