docs(refresh): refresh docs

Author: briancaffey

vuepress-docs/docs/.vuepress/configs/navbar/en.ts

@@ -9,26 +9,18 @@ export const en: NavbarConfig = [
     text: 'Topics',
     link: '/topics',
     children: [
-      {
-        text: 'Twelve-Factor App',
-        link: '/topics/twelve-factor-app',
-      },
       {
         text: 'Django Application',
         link: '/topics/django/',
       },
       {
-        text: 'Quasar Application',
-        link: '/topics/quasar/',
+        text: 'Nuxt Application',
+        link: '/topics/nuxt/',
       },
       {
         text: 'Docker Compose',
         link: '/topics/docker-compose/',
       },
-      {
-        text: 'Authentication',
-        link: '/topics/jwt-authentication/',
-      },
       {
         text: 'VuePress Documentation',
         link: '/topics/vuepress/',
@@ -56,27 +48,36 @@ export const en: NavbarConfig = [
   },
   {
     text: 'Deploy',
-    link: '/deploy/',
+    // link: '/deploy/',
     children: [
       {
-        text: 'Overview',
-        link: '/deploy/aws/',
+        link: '/deploy/aws',
+        text: 'AWS ECS',
         children: [
-          {
-            link: '/deploy/aws/cdk',
-            text: 'CDK',
-            ariaLabel: 'CDK',
-          },
           {
             link: '/deploy/aws/terraform',
             text: 'Terraform'
           },
           {
             link: '/deploy/aws/pulumi',
             text: 'Pulumi'
+          },
+          {
+            link: '/deploy/aws/cdk',
+            text: 'CDK'
           }
-        ],
+        ]
       },
-    ],
-  },
+      {
+        text: 'Application Updates',
+        // link: '/deploy/app'
+        children: [
+          {
+            link: '/deploy/app',
+            text: 'GitHub Action'
+          }
+        ]
+      }
+    ]
+  }
 ]

vuepress-docs/docs/README.md

@@ -12,8 +12,6 @@ features:
     details: This project covers the full technology stack of modern web applications, from frontend to backend to CI/CD and Infrastructure as Code
   - title: Twelve-Factor App
     details: This project adheres to the 12Factor App philosophy
-  - title: Best Practices
-    details: This project focuses on implementing a simple application with all of the best practices you would see in a healthy, production-ready application
   - title: IaC Rosetta Stone
     details: This project implements the same application architecture using CDK, Terraform and Pulumi
   - title: GitHub Actions
@@ -24,54 +22,19 @@ features:
     details: The backend Django app is implemented using Django templates using both functions-based views and class-based views
   - title: DRF and GraphQL
     details: The Django app also implements an API using both REST with DRF and GraphQL with Graphene
-  - title: Quasar Framework
-    details: A frontend client built with TypeScript, Vue.js, and Quasar Framework consumes the DRF REST API
+  - title: Nuxt.js
+    details: A SSR frontend client built with TypeScript, Vue.js, and Nuxt.js consumes the DRF REST API
   - title: Python and TypeScript
     details: Python is used on the backend and TypeScript is used for both the frontend client and infrastructure code
-  - title: Load testing
-    details: The project uses k6 for simulating traffic which can run locally or using GitHub Actions
   - title: Developer Experience
     details: This project aims to have a simple and understandable developer experience
-  - title: compose and venv
-    details: Local backend development can be done with both virtual environments and docker compose
   - title: Testing and coverage
     details: pytest is used for backend tests, and test coverage is measured with pytest-cov
-  - title: Makefile
-    details: All commands for local development are documented in the Makefile
 
 
-footer: MIT Licensed | Copyright © 2023 Brian Caffey
+footer: MIT Licensed | Copyright © 2025 Brian Caffey
 ---
 
-<!-- <div style="text-align: center">
-  <Bit/>
-</div>
-
-<div class="features">
-  <div class="feature">
-    <h2>Simplicity First</h2>
-    <p>Minimal setup with markdown-centered project structure helps you focus on writing.</p>
-  </div>
-  <div class="feature">
-    <h2>Vue-Powered</h2>
-    <p>Enjoy the dev experience of Vue + webpack, use Vue components in markdown, and develop custom themes with Vue.</p>
-  </div>
-  <div class="feature">
-    <h2>Performant</h2>
-    <p>VuePress generates pre-rendered static HTML for each page, and runs as an SPA once a page is loaded.</p>
-  </div>
-</div> -->
-
-This documentation covers lots of different topics that are related to various aspects of the project. The project aims to provide two things:
-
-- a working example of a sample web application called μblog.
-- in-depth technical guides on how to build each part of the application
-
-At a high level, the documentation can be broken down into the following categories:
-
-- Django application set up
-- Local development environment
-
 ## How to get help
 
 This project is driven by a community of contributors. If you are having trouble with any part of this application, you can get help in a number of ways:

vuepress-docs/docs/deploy/app/README.md

@@ -0,0 +1,33 @@
+---
+prev: /deploy/aws
+
+head:
+  - - meta
+    - name: description
+      content: How to update the version of the application with GitHub Actions
+  - - link
+    - rel: canonical
+      href: https://briancaffey.github.io/django-step-by-step/deploy/app
+---
+
+# Updating the application version
+
+This page describes the process of updating the backend or frontend applications to a new version. The processes for updating the backend Django application and the frontend Nuxt.js application are different, but the logic for updating both of these applications is contained in the same GitHub Action workflow.
+
+## Backend
+
+Updating the backend application is a two-step process.
+
+- Step 1: create a new task definition for the `pre-backend-update` task using the new backend application version (e.g. `v1.2.3`), publish this new task definition and then run the `pre-backend-update` task. This task applies migrations and runs the `collectstatic` command as well as any other Django management commands that are called in the `pre-backend-update` command
+
+::: warning
+Database migrations included in the NEW version of code should be backward-compatible with the application code in the OLD version of code.
+:::
+
+- Step 2: Create new task definitions for the backend ECS services (`gunicorn` webserver, celery worker and celery beat scheduler)
+
+## Frontend
+
+Updating the frontend requires updating the frontend task definition with the new frontend application version (e.g. `v1.2.3`) and then updating the service with the new task definition.
+
+You can provide an version tag for the backend app, the frontend app or both. The GitHub Actions pipeline will first update the backend and then update the frontend.

vuepress-docs/docs/deploy/aws/README.md

@@ -5,23 +5,23 @@ prev: /guide/ci-cd/github-actions
 head:
   - - meta
     - name: description
-      content: Using Terraform for Infrastructure as Code for Django projects
+      content: Using different Infrastructure as Code tools for deploying Django projects
   # - - link
   #   - rel: canonical
   #     href: https://briancaffey.github.io/
 ---
 
 # Overview of options for deploying μblog
 
-This project focuses on deploying to AWS using ECS Fargate. GitHub Actions are used for deployment pipelines.
+This project primarily focuses on deploying to AWS using ECS Fargate. GitHub Actions are used for deployment pipelines.
 
 ## Infrastructure as Code Libraries
 
 There are three options for Infrastructure as Code:
 
 - [`terraform-aws-django`](https://github.com/briancaffey/terraform-aws-django)
-- [`cdk-django`](https://github.com/briancaffey/cdk-django)
 - [`pulumi-aws-django`](https://github.com/briancaffey/pulumi-aws-django)
+- [`cdk-django`](https://github.com/briancaffey/cdk-django)
 
 ## Consuming IaC libraries
 
@@ -40,28 +40,47 @@ Each of these directories includes code that uses the IaC libraries referenced a
 
 Each of these options has corresponding GitHub Actions workflow files.
 
-These workflow files can be found in the `.github/workflows` folder of `django-step-by-step` using the following naming convention:
+These workflow files can be found in the `.github/workflows` folder of `django-step-by-step` under the following names:
 
-```
-{ad_hoc,prod}_{base,app}_{create_update,destroy}_{cdk,terraform_pulumi}.yml
+```yaml
+iac_cdk_actions.yml
+iac_pulumi_actions.yml
+iac_terraform_actions.yml
 ```
 
-::: warning
-Some workflow files may be missing
-:::
+These three GitHub Actions all work in the same way:
 
-::: warning
-At some point these GitHub Actions and associated files in the `iac` directory may be moved to another GitHub repository
-:::
+- they can be used for deploying either the `base` or `app` infrastructure stack
+- they can accept a name for the `base` and `app` stack that must correspond to the "live" configuration files mentioned above
+- they can be used to destroy resources for a stack by selecting a `destroy` option
+- the plan/preview/diff is added to the summary of each workflow
+
+These workflows can be easily copied or adapted for different needs. For example, if you would like to manually approve the deployment of infrastructure resources after viewing the plan/preview/diff, then you can using GitHub environments for the deploy steps.
 
 ::: warning
-Some workflow files may be using different patterns. All workflows should be using the `actions/upload-artifact` and `actions/download-artifact` GitHub Actions
+Understanding the difference between infrastructure and application CI/CD pipelines is very important! The following sections go into detail about the `app` infrastructure pipeline and the `App Update` pipeline and things to consider when using these pipelines.
 :::
 
+## `app` stack
+
+When the `app` stack is deployed, it sets up the ECS cluster, ECS task definitions and ECS services for an `app` environment. Each task definition uses the `latest` tag for the container image (for the backend and frontend services) and uses a `desiredCount` of `0` for each service.
+
+For each of the IaC libraries, the ECS service uses `ignore_changes` for the `task_definition` and `desired_count`, this means that deploying a change to the `app` stack (such as adding a new environment variable to the backend task definitions) will not change anything in the running application. Instead, it publishes a new task definition. This new task definition will be used as the basis for the new task definition created by the `[CD] App Update` workflow.
+
+After you deploy the `app` stack, you need to run the `[CD] App Update` GitHub Action. This will use the most recent version of each task definition and updated the `image` tag to the version specified in the Action's inputs (e.g. `v1.2.3`). Also the desired count for each service will be set to `1` which will start each service. You may want to use different values for the `desiredCount` when deploying your own application.
+
+## `[CD] App Update`
+
+To make regular application updates, you can use the `[CD] App Update` GitHub Action. This Action will first run the `pre-backend-update` job. This job is set up to run migrations, collectstatic and anything else that must be done prior to updating the server code (`gunicorn`, `celery`, `celery-beat` services).
+
+The `pre-backend-update` step will also attempt to create a database using the name of the `app` environment. For example, if you select the `app` name `alpha`, this step will attempt to create an `alpha-db` database if it does not already exist. This allows for using a shared RDS instance with multiple postgres databases for each `app` environment.
+
+After creating the database, the `pre-backend-update` job runs database migrations using Django's `migrate` command.
+
+The `[CD] App Update` Action then does a rolling update for each of the backend application services (`gunicorn`, `default` celery worker and celery `beat`).
+
+These actions use the official AWS GitHub Action called `aws-actions/amazon-ecs-deploy-task-definition` for updating task definitions, updating services and running one-off tasks (like the `pre-backend-update`).
+
 ::: tip
 For the most up-to-date information on these projects, please see their open-issues and recent CHANGELOG entries.
 :::
-
-## Article
-
-[See this article for an in-depth overview of these different deployment options](https://briancaffey.github.io/2023/01/07/i-deployed-the-same-containerized-serverless-django-app-with-aws-cdk-terraform-and-pulumi)

vuepress-docs/docs/deploy/aws/cdk/README.md

@@ -11,7 +11,7 @@ head:
   #     href: https://briancaffey.github.io/django-step-by-step/
 ---
 
-# IaC with CDK
+# AWS CDK (Cloud Development Kit)
 
 ## Repo
 
@@ -28,9 +28,5 @@ For the most up-to-date information on `cdk-django`, please see the repository's
 :::
 
 - `cdk-django` is a CDK Component Library that is built using the `projen` framework
-- This project supports ad-hoc environments and production environments
-- Ad-hoc and production environments both use a base stack and an app stack
-- The base and app stack in both ad-hoc and production environments have 2 stacks in the same CDK **app**
+- The base and app stack have 2 stacks in the same CDK **app**
 - The related Pulumi and Terraform libraries pass references via unique identifiers, CDK uses stack references
-- This project is not yet fully implemented in GitHub Actions.
-- The production application has not yet implemented autoscaling