cdk-django VS projen

cdk-django

CDK Construct Library: github.com/briancaffey/cdk-django

- Another aspect of my approach that I prefer over the other one is using a high-level construct that you publish and then consume in your project. This requires that you write a construct in TypeScript and then publish it to npm or PyPI. I'm working on a construct library for deploying Django apps with CDK called djagno-cdk, and one of the constructs in it uses ECS Fargate: https://github.com/briancaffey/django-cdk/blob/main/src/django-ecs.ts. Ideally you don't have everything in a single construct though, so I like how Mariano is doing that in his project. My Terraform project does a better job at separating layers of the application, so I need to apply that same principle to django-cdk when I get around to working on that project again.

Sure. My IaC journey actually started out with CloudFormation, and I learned a lot from this reference project: aws-samples/ecs-refarch-cloudformation. Then I picked up CDK when that became available and migrated a project from CloudFormation to CDK. It sounded like a nicer way to handle stacks in a familiar language with lots great one-liners and utility functions and constructs, and it definitely is. I have a similar project written in CDK that is an application/framework-first (Django) approach to learning and doing IaC that you can find here: https://github.com/briancaffey/django-cdk. This implements both ECS and EKS, but my attempts at learning EKS sort of fizzled out for now as I don't have the need to use it, and for the task at hand (running a monolithic Django application on AWS) I think ECS makes a LOT more sense.

I have an example of doing this here, and I posted about this earlier on this sub https://www.reddit.com/r/django/comments/rj7sj2/deploying_django_applications_to_a_singlenode/

I'm not sure what you mean by "architecture", and I'm not sure what is wrong with trying to save money while learning how to do IaC and CI/CD. My thinking is that I can use some of what I learned here in a more robust setup of a Django app that uses ECS, I'm working on that here: https://github.com/briancaffey/django-cdk/blob/main/src/django-ecs.ts.

Here is on that I’m working on: https://github.com/briancaffey/django-cdk

Here's a link to the repo: https://github.com/briancaffey/django-cdk. This library currently offers high level constructs for EKS as well as ECS. I have previously used ECS for most of the containerized web apps I have worked with, so I'm hoping to use this as a way to compare the two orchestration tools for my use case and gather some best practices. This project includes a companion repo that is included as a git submodule that I have been to do live tests/deployments using my construct library.

This project uses AWS CDK as infrastructure as code solution. To maintain project configuration files efficiently, the project structure is generated using projen:

I recommend visiting the github page for projen and flicking through the documentation as I won't do it justice. Projen aims to:

cdk-django uses projen for maintaining the changelog and bumping versions and publishing to npm. It is popular among developers in the CDK community and is a really awesome tool since it basically uses one file (.projenrc.ts) to configure your entire repo, including files like tsconfig.json, package.json, and even GitHub Action workflows. It has a lot of configuration options, but I'm using it in a pretty simple way. It generates a new release and items to the changelog when I manually trigger a GitHub Action.

I will give you step-by-step instructions to create your very first AWS Organization with the AWS CDK and the help of projen and cdk-organizations. You only need already an AWS Account created which is not a member or management account of another AWS Organization.

If you go down that route you should use Projen to maintain the dependencies.

An Open Source CDK Community project which I find super interesting. It is doing cherry-picking from AWS Amplify UI and AWS CDK for deployment. I do that in my private projects as well for example https://github.com/senjuns/senjuns. I think the author could enhance/simplify its repo even more by using https://github.com/projen/projen for the project setup.

That said - https://github.com/firecracker-microvm/firecracker and https://github.com/bottlerocket-os/bottlerocket are interesting, and while AWS CDK is very AWS specific, the underlying jsii https://github.com/aws/jsii and projen https://github.com/projen/projen/issues are fundamental services.

The documentation for the classes of the bundled project types is at https://github.com/projen/projen/. In this documentation, you can see that the property github includes a mergify entry, which will define if the Mergify configuration is used. The default if the github entry is not specified, is that it will be included. So in our test, we can check that this configuration is not in place, after creating a project with the mandatory parameters.