Forem: Jayson Rawlins

Use Fork Git Client to Remove Passwords from Git History

Jayson Rawlins — Mon, 24 Nov 2025 10:52:25 +0000

What is Fork

Fork is a git client that runs your git commands for you inside of an interface. Similar to other products like GitHub Desktop abd GitKraken.

Why I like Fork

Fork UI provides a great deal of flexibility when setting up custom commands. The interface is decent and provides quick and easy GUI for all your Git needs.

However, being able to setup your client to run various commands on the repo is very handy.

Currently I have my JetBrain's products plus the ability to scan for secrets using nosey parker. All very very handy. I even use AICommit2 from time to time with a click of a button.

Meat and Potatoes

Using fork to delete a file out of git history.

1.) Create a Custom Command

2.) Call the custom command 'Remove Selected File from History'

Target needs to be File visible in file context menu

3.) Select Bash Command

Add the following Script:

git filter-branch --force --index-filter "git rm --cached --ignore-unmatch '${file}'" --prune-empty --tag-name-filter cat -- --all && git for-each-ref --format="%(refname)" refs/original/ | xargs -n 1 git update-ref -d && git reflog expire --expire=now --all && git gc --prune=now --aggressive

Now you can simply right click on the offending file and remove its entire history (remember to ignore the file so it doesn't get committed again).

Ever Heard of Agentic Memory?

Jayson Rawlins — Mon, 23 Jun 2025 12:05:49 +0000

Agentic memory is an interesting concept designed to address a specific challenge: the cumbersome ways we currently save preferences, whether through cursor files, Windsurf files, Claude.MD, or other IDEs and AI agents.

Over time, this becomes unwieldy, as you constantly track preferences and re-teach your agent problems it has already solved in different contexts.

While a flat file could repeatedly instruct the agent on how to solve problems, you would then need to meticulously track the location of these solutions, much like managing a scattered collection of notes across various Git repositories.

How about keeping these preferences in a database?

Thus, agentic memory is the idea of remembering your preferences in a graph database.

With each request, your agent will call an MCP server (model context protocol) and look up your preferences already saved in your database. If they don’t exist, then you can have the agent save it from the current projects results.

This greatly speeds up the life cycle when you are vibe coding or asking for help with projects but now you don’t have to keep reminding the agent of your preferences.

My guess is that over time, use of agentic memory will be standard practice. Just google ‘agentic memory’ and you will find copious amounts of resources and products.

Here are some examples that I shamelessly took from https://www.graphlit.com/blog/survey-of-ai-agent-memory-frameworks

Letta: https://docs.letta.com/

Mem0: https://docs.mem0.ai/

CrewAI: https://docs.crewai.com/concepts/memory

Zep: https://help.getzep.com/

Memary: https://kingjulio8238.github.io/memarydocs/concepts/

Cognee: https://www.cognee.ai/blog/fundamentals/llm-memory-cognitive-architectures-with-ai

SlackBot Timeouts Getting You Down?

Jayson Rawlins — Wed, 16 Apr 2025 11:53:20 +0000

Problem with SlackBots and Lambdas:

Slack APIs have a 3-second timeout, so if the Lambda doesn’t respond, you’ll receive a timeout message in the Slack channel before the response is ever issued.

Here are some reasons for these timeouts:

Attempting to process too much information within the 3-second window.
Cold Starts. Lambdas that haven’t been used in a way can suffer from taking an extra second or two to process the incoming message.
Database retrieval. Pulling data and processing can sometimes eat up what remains from that 3-second window.

However, by using an API gateway, you now have plenty of time to process the data because Slack will get the response immediately.

Solution Architecture

By first going through the API Gateway, you can respond immediately to Slack while sending a copy to SQS, triggering the Lambda with the SQS message. This gives your lambda plenty of time to process data, look up information, make requests, or do whatever it needs to do to provide a response back to the originating channel or perhaps another Slack channel.

No timeouts, just a nice workflow that you could wire in any logic.

Secure Your AWS Resources with Twingate VPN

Jayson Rawlins — Wed, 26 Mar 2025 21:33:16 +0000

Twingate Architecture:

Benefits:

1.) Unlike OpenVPN, which requires exposing your VPN EC2 asset to a public subnet, Twingate connectors do not require an inbound security group.

Another benefit is that the network is controlled by groups, so you don’t need separate logins for each account. Log in once, and if you have the correct resource permissions set up, you can access everything you need.

Deployment:

There are several options for deploying a connector. The documentation is really good. You can deploy via Kubernetes, CloudFormation, or Terraform.

We rolled our own CDK stack that deploys the AMI, AWS Secret, and maintenance schedule with an SSM document to perform the updates. This allowed us to deploy it once and basically forget about it as it updates itself. Since we deploy it in two AZs, it rarely ever has an outage.

For more information, I highly recommend their documentation ->

https://www.twingate.com/docs/

ECS CloudFormation Taking Forever – Just for a Failed Deployment

Jayson Rawlins — Thu, 20 Mar 2025 16:16:54 +0000

Introduction

Sometimes, when you deploy an AWS ECS service using CDK or a CloudFormation stack, you end up in a strange situation where the deployment seems to go on forever. The tasks aren’t deployed, the tasks are failing health checks, and ECS just keeps starting new tasks.

Sometimes, you can see even the old tasks aren’t passing health checks. That’s a guarantee that your poor service is going to take forever to fail, according to CloudFormation.

You’re waiting and waiting and waiting. You already know how to fix it and are ready to move on; however, CloudFormation just keeps trying in vain. This can be a really frustrating experience.

How to Trick CloudFormation Into ‘Thinking’ It Succeeded

So, a basic way to trick CloudFormation into thinking everything has been deployed successfully is to redeploy the service in the AWS Console.

Yes, that’s right. You can redeploy the service in the AWS Console, but this time, you are going to set the following parameters:

DesiredCount: 0
MinCount: 0
MaxCount: 0

REMEMBER: You are not changing anything else in the service; you are just changing the desired, min, and max count to 0. Also, you don’t need to check the box to force a redeployment.

After all the tasks have been stopped, CloudFormation will think that everything has been deployed successfully.

This will allow you to continue debugging your service without waiting hours for CloudFormation to time out or for the number of retries to finally be exhausted.

This trick has saved me much time and frustration over the years.

Site to Site VPN

Jayson Rawlins — Thu, 20 Mar 2025 16:09:33 +0000

Introduction

Site-to-site VPN provides a secure tunnel between two networks. Unlike, say, VPN peering, where you have a connection between one AWS VPC and another AWS VPC, site-to-site VPN allows you to connect two networks that are not even in AWS. You could connect an on-premise network to the AWS network, or you could connect two different cloud providers together, like AWS and Azure.

Here is an example of a Site-to-Site VPN between AWS and Azure

https://www.youtube.com/watch?v=G8hwCso8JSs&t=3s

Here is a YouTube video that shows how to set up a Site-to-Site VPN between AWS and Azure.

Play

Site-to-Site VPN AWS to Azure

Here is a step-by-step guide to setting up a Site-to-Site VPN between AWS and Azure.

https://github.com/jjrawlins/youtube/blob/main/entra-id-site-2-site-vpn/instructions.md

Conclusion

Site-to-Site VPN is a great way to connect two networks that are not on the same cloud provider. It is also a great way to connect on-premise networks to the cloud.

Stay tuned for more tutorials and examples of building durable, secure cloud infrastructure!

How to Create a Custom Resource with AWS CDK

Jayson Rawlins — Thu, 20 Mar 2025 01:54:22 +0000

Introduction

The AWS Cloud Development Kit (CDK) allows you to define cloud infrastructure using familiar programming languages. While CDK provides a wide range of constructs, there are scenarios where you might need to create custom resources to extend its capabilities.

What are Custom Resources?

Custom Resources in AWS CDK enable you to write custom provisioning logic in AWS Lambda or other services. This allows you to perform operations that are not natively supported by CDK constructs.

Creating a Custom Resource

To create a custom resource, follow these steps:

Initialize the CDK Project using Projen
Define the Lambda Function: This function will contain the custom logic using Projen
Create the Custom Resource: Use the CustomResource construct and link it to your Lambda function.
Use the Custom Resource in Your Stack: Integrate the custom resource into your CDK stack as needed.

Example

Here’s a simple example of creating a custom resource in AWS CDK:

Step 1: Initialize a new Projen Project

npx projen new awscdk-app-ts

Here’s a simple example of creating a custom resource in AWS CDK:

https://github.com/jjrawlins/cdk-examples/tree/main/projen-typescript/cdk-custom-resource

Inside the src directory, create a new directory called stacks. Then, create a new file called CustomResourceExampleStack.ts inside the src/ stacks directory.

CustomResourceExampleStack.ts

import { CustomResource, Duration, Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import { ExampleCustomResourceLambdaFunction } from '../lambdas/ExampleCustomResourceLambda-function';

interface CustomResourceExampleStackProps extends StackProps {

}

export class CustomResourceExampleStack extends Stack {
  constructor(scope: Construct, id: string, props: CustomResourceExampleStackProps) {
    super(scope, id, props);

    const customResourceLambda = new ExampleCustomResourceLambdaFunction(this, 'CustomResourceLambda', {
      description: 'Example of a custom resource lambda',
      memorySize: 128,
      timeout: Duration.seconds(30),
    });

    const stackName = Stack.of(this).stackName;
    new CustomResource(this, 'CustomResource', {
      serviceToken: provider.serviceToken,
      properties: {
        PhysicalResourceId: \${stackName}-CustomResourceResource-version,
        MyCustomProperty: 'MyCustomValue',
      },
    });
  }
}

Step 2: Define the Lambda Function

Create a new directory called lambdas inside the src/ directory. Inside the lambdas directory, create a new file called ExampleCustomResource.lambda.ts. This file will contain the logic for your custom resource.

You can always add more logic to this file as needed. Mostly serves as a starting point.

 import {
    CdkCustomResourceResponse,
    CloudFormationCustomResourceCreateEvent,
    CloudFormationCustomResourceDeleteEvent,
    CloudFormationCustomResourceEvent,
    CloudFormationCustomResourceUpdateEvent,
    Context,
} from 'aws-lambda';

    const region = process.env.AWS_REGION;

    export const handler = async (
    event: CloudFormationCustomResourceEvent,
    context: Context,
    ): Promise<CdkCustomResourceResponse> => {
    console.log('Lambda is invoked with:' + JSON.stringify(event));
    console.log('Context is invoked with:' + JSON.stringify(context));
    console.log('Lambda is invoked with:' + JSON.stringify(event));
    console.log('Region: ' + region);
    const physicalResourceId = event.ResourceProperties.PhysicalResourceId;

    let response: CdkCustomResourceResponse = {
    Status: 'SUCCESS',
    Reason: 'See the details in CloudWatch Log Stream: ' + context.logStreamName,
    PhysicalResourceId: physicalResourceId,
    StackId: event.StackId,
    RequestId: event.RequestId,
    LogicalResourceId: event.LogicalResourceId,
};

    switch (event.RequestType) {
    case 'Create':
    response = await onCreate(response, event, context);
    break;
    case 'Delete':
    response = await onDelete(response, event, context);
    break;
    case 'Update':
    response = await onUpdate(response, event, context);
    break;
    default:
    throw new Error('Unknown Request Type of CloudFormation');
}
    console.log('Return value:', JSON.stringify(response));
    return response;
};

    /**
    * Executes the create event for a CloudFormation custom resource.
    * @param {CdkCustomResourceResponse} response - The custom resource response object.
    * @param {CloudFormationCustomResourceCreateEvent} event - The create event object.
    * @param {Context} context - The AWS Lambda context object.
    * @return {Promise<CdkCustomResourceResponse>} - A promise that resolves to the custom resource response object.
    */
    export async function onCreate(
    response: CdkCustomResourceResponse,
    event: CloudFormationCustomResourceCreateEvent,
    context: Context): Promise<CdkCustomResourceResponse> {
    try {
    console.log('We are in the Create Event');
    console.log('Event is invoked with:' + JSON.stringify(event));
    console.log('Context is invoked with:' + JSON.stringify(context));
} catch (error) {
    if (error instanceof Error) {
    response.Reason = error.message;
}
    response.Status = 'FAILED';
    response.Data = { Result: error };
    return response;
}
    return response;
}

    /**
    * Handles delete event for a cloud formation custom resource.
    *
    * @param {CdkCustomResourceResponse} response - The custom resource response object.
    * @param {CloudFormationCustomResourceDeleteEvent} event - The delete event object.
    * @param {Context} context - The AWS lambda context object.
    * @returns {Promise<CdkCustomResourceResponse>} - The updated custom resource response object.
    */
    export async function onDelete(
    response: CdkCustomResourceResponse,
    event: CloudFormationCustomResourceDeleteEvent,
    context: Context): Promise<CdkCustomResourceResponse> {
    try {
    console.log('We are in the Delete Event');
    console.log('Context is invoked with:' + JSON.stringify(context));
    console.log('Event is invoked with:' + JSON.stringify(event));
    response.Status = 'SUCCESS';
} catch (error) {
    if (error instanceof Error) {
    response.Reason = error.message;
}
    response.Status = 'FAILED';
    response.Data = { Result: error };
    return response;
}
    return response;
}

    /**
    * Executes the onUpdate logic for a CloudFormation custom resource.
    *
    * @param {CdkCustomResourceResponse} response - The response object for the custom resource.
    * @param {CloudFormationCustomResourceUpdateEvent} event - The update event object from CloudFormation.
    * @param {Context} context - The execution context object.
    * @returns {Promise<CdkCustomResourceResponse>} A promise that resolves to the updated response object.
    */
    export async function onUpdate(
    response: CdkCustomResourceResponse,
    event: CloudFormationCustomResourceUpdateEvent,
    context: Context): Promise<CdkCustomResourceResponse> {
    try {
    console.log('Resource properties: ' + JSON.stringify(event.ResourceProperties));
    console.log('Event is invoked with:' + JSON.stringify(event));
    console.log('Context is invoked with:' + JSON.stringify(context));
} catch (error) {
    if (error instanceof Error) {
    response.Reason = error.message;
}
    response.Status = 'FAILED';
    response.Data = { Result: error };
    return response;
}
    return response;
}

Step 3: Generate New Lambda Function

One of the neat things about using projen to create your lambda function is that it will autogenerate the lambda function.

Play

ProjenLambdaGeneration

npx projen

main.ts

   import { App } from 'aws-cdk-lib';
    import { CustomResourceExampleStack } from './stacks/CustomResourceExampleStack';

    // for development, use account/region from cdk cli
    const devEnv = {
    account: process.env.CDK_DEFAULT_ACCOUNT,
    region: process.env.CDK_DEFAULT_REGION,
};

    const app = new App();

    new CustomResourceExampleStack(app, 'cdk-custom-resource-dev', { env: devEnv });

    app.synth();

Step 4: Deploy Your Custom Resource

Deploy the custom resource using the following commands:

NOTE: You will have to be authenticated in an AWS Profile to work.

yarn cdk deploy cdk-custom-resource-dev

Play

Deploy CDK Custom Resource

Conclusion

CDK custom resources are a powerful way to extend the functionality of AWS CDK. They allow you to perform operations that are not directly supported by existing CDK constructs, giving you greater flexibility in defining your infrastructure.

Stay tuned for more tutorials and examples on AWS CDK and other cloud technologies!

ECS CloudFormation Taking Forever - Just for a Failed Deployment

Jayson Rawlins — Thu, 13 Mar 2025 20:57:34 +0000

Introduction
Sometimes times when you are deploying an AWS ECS service using CDK or a CloudFormation stack, you end up in a strange situation where the deployment seems to go on forever. The tasks aren't deployed, the tasks are failing health checks, and ECS just keeps starting new tasks.

Sometimes, you can see even the old tasks aren't passing health checks. That's a guarantee that your poor service is going to take forever to fail, according to CloudFormation.

You're waiting and waiting and waiting. You already know how to fix it and are ready to move on; however, CloudFormation just keeps trying in vain. This can be a really frustrating experience.

How to Trick CloudFormation Into 'Thinking' It Succeeded
So, a basic way to trick CloudFormation into thinking that everything has been deployed successfully is to simply redeploy the service in the AWS Console.

Yeap, that's right. You can redeploy the service in the AWS Console, but this time, you are going to set the following parameters:

DesiredCount: 0
MinCount: 0
MaxCount: 0

REMEMBER: You are not changing anything else in the service; you are just changing the desired, min, and max count to 0. Also, you don't need to check the box to force a redeployment.

After all the tasks have been stopped, cloudformation will think that everything has been deployed successfully.

This will allow you to continue debugging your service without waiting hours for cloudformation to timeout or for the number of retries to finally have been exhausted.

This trick has saved me a lot of time and frustration over the years.

Tired of Evernote? Try Obsidian!

Jayson Rawlins — Mon, 06 Nov 2023 02:56:13 +0000

Introduction:

Back in my college days, Evernote was my go-to digital notebook for both academic and professional use. Its robust features and seamless browser integration significantly boosted my productivity. Despite its premium price tag, the value it delivered made it a justifiable expense. The convenience and efficiency it brought to my daily workflow were undeniable, turning the routine task of note-taking into a dynamic and integral part of my success.

The tactile tradition of pen and paper soon gave way to the digital convenience of Evernote’s Plugin. This modern method became a staple of my daily routine, faithfully serving me throughout the extended journey of earning my second Bachelor’s degree at the University of Central Florida. Over those years, my reliance on the Evernote Plugin transformed the way I captured information and organized my academic life.

Cutting Costs

After getting that shiny diploma from UCF, my wallet was like, ‘No more fancy stuff!’ So, I gave it a break and hopped onto the freebie train with OneNote! ”

Using OneNote was fine for a while. I already had Office 365. However, in the world of note-taking, Obsidian’s integration of markdown makes it an optimal choice for those handling code. Markdown offers consistent and easy-to-add code assertions, streamlining the note-taking process. While OneNote might require external plugins like NoteHighlight2016 to achieve similar functionality, Evernote, though plugin-free, can sometimes present challenges with buggy code formatting. In contrast, Obsidian provides a seamless and reliable experience straight from the outset. Dive into the Obsidian platform and witness the precision and efficiency markdown can bring to your notes.

Getting Started

So, there are two complaints that I have with Obsidian.

Videos. It is not practical or easy to embed YouTube videos.

Sometimes they work great but other times, its kinda annoying in that you end up with blank videos. Here is an example:

<iframe width="560" height="315" src="https://www.youtube.com/embed/mPaGi1Phc5A?si=M9x50CP3zk5oKi0O" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

<iframe width="560" height="315" src="https://www.youtube.com/embed/giroZqjTJqE?si=pOjMZtf4S6rerAYW" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

This what it should look like:

The reason, as I understand it, is that embedded YouTube videos sometimes have settings that make them not work locally. Obsidian uses a local file system rather than a hosted website like OneNote, Evernote, or Google Keep.

However, I recommend using the ‘thumbnails’ community plugin.

This isn’t quite as nice as embedding, but it works well. So, for the above two videos, I can use the following markdown:

vid
https://www.youtube.com/watch?v=mPaGi1Phc5A
vid
https://www.youtube.com/watch?v=giroZqjTJqE

File-explorer.

By default, only markdown files are displayed. To add files like animated GIFs or, in my case, I wanted to link to PDFs stored within my notes. However, you can turn this feature on:

Storage Options:

If you are OK with keeping your notes on your cloud, it can be pretty much limitless. If you need your notes on the go, remember you will pay an extra premium. At the time of writing, it was $8.00 US/month billed yearly and $10.00 US/month billed monthly. It’s slightly less expensive than Evernote but definitely a premium compared to OneNote or Google Keep, which are both free.

Conclusion:

While Obsidian may come with its share of quirks, its speed and practicality cannot be overstated when it comes to organizing notes. Opting for the cloud sync service proved to be a wise decision, especially during my vacation. The ability to access my notes on my phone, effortlessly embed PDFs, and manage my itinerary was nothing short of remarkable. Even in moments when internet connectivity was a distant dream, Obsidian stood out as an indispensable travel companion, keeping my plans well-ordered and within reach. It’s clear that despite any minor inconveniences, Obsidian offers a seamless, user-friendly experience for anyone looking to keep their thoughts and plans neatly aligned.

The post Tired of Evernote? Try Obsidian! appeared first on Jayson Rawlins.

ECS Copilot with SQS Autoscaling

Jayson Rawlins — Fri, 27 Oct 2023 18:46:21 +0000

Prerequisites:

ECS Copilot: ECS Copilot that has been overridden to expose CDK. See svc override — AWS Copilot CLI. Probably could use the same principles with regular CDK as well but this particular example assumes we are using ECS Copilot.
Typescript
CDK v2
NPM
CDK IAM Floyd (Library for helping manage AWS IAM)

npm install cdk-iam-floyd

tranformService(): This is the function that starts of with

const service = this.template.getResource("Service") as ecs.CfnService;

Notes:

As mentioned before, this could be used for any CDK project. However, for this demonstration ECS Copilot is assumed which will include some commands that simply would not be necessary.

Lets get started:

transformService() {
  let minCapacity = 2;
  let maxCapacity = 48;
  let queueName = "your_queue_name"

  ## With regular CDK, you will have the Service Object directly.
  const service = this.template.getResource("Service") as ecs.CfnService;
  const clusterName = service.cluster;
  const serviceName = service.attrName;

  const scalingRole = new iam.Role(this, 'ServiceScalingRole', {
      assumedBy: new iam.ServicePrincipal('ecs.application-autoscaling.amazonaws.com'),
      inlinePolicies: {
          'ScalingRoleInlinePolicy': new PolicyDocument({
              statements: [
                  new floyd.ApplicationAutoscaling().allow().onAllResources().allActions(),
                  new floyd.Ecs().allow().onAllResources()
                      .toDescribeServices()
                      .toUpdateService(),
                  new floyd.Cloudwatch().allow().onAllResources()
                      .toDescribeAlarms()
                      .toPutMetricAlarm()
                      .toDeleteAlarms()
                      .toDescribeAlarmHistory()
                      .toDescribeAlarmsForMetric()
                      .toGetMetricStatistics()
                      .toListMetrics()
                      .toDisableAlarmActions()
                      .toEnableAlarmActions(),
                  new floyd.Iam().allow().onAllResources()
                      .toCreateServiceLinkedRole(),
                  new floyd.Sns().allow().onAllResources()
                      .toCreateTopic()
                      .toSubscribe(),
                  new floyd.Sns({
                      actions: [
                          "sns:Get*",
                          "sns:List*"
                      ]
                  }).allow().onAllResources()
              ]
          })
      }
  });

  // First, get the ScalableTarget associated with the service
  const resourceId = `service/${clusterName}/${serviceName}`;

  const scalableTarget = new appscaling.CfnScalableTarget(this, 'ServiceScalableTarget', {
      maxCapacity: maxCapacity,
      minCapacity: minCapacity,
      resourceId: resourceId,
      roleArn: scalingRole.roleArn,
      scalableDimension: 'ecs:service:DesiredCount',
      serviceNamespace: 'ecs',
  });

 // This and the previous are only necessary because of ECS Copilot.
 // Could just declare the ScalableTarget directly with CDK.
 const cdkScalableTarget = appscaling.ScalableTarget.fromScalableTargetId(
      this,
      'CdkServiceScalableTarget',
      scalableTarget.ref,
  )

 const metric = new cloudwatch.Metric({
    namespace: 'AWS/SQS',
    metricName: 'ApproximateNumberOfMessagesVisible',
    dimensionsMap: {
        QueueName: queueName,
    },
    statistic: 'Average',
});

}

How to build a site using SST, NextJS and a NextJS theme

Jayson Rawlins — Fri, 27 Oct 2023 17:38:02 +0000

Introduction

What is SST?

SST is a framework for building serverless. With SST you can build modern full-stack applications on AWS.

Deploy Next.js, Svelte, or Astro to AWS.
Add any backend feature.
Go from idea to IPO!

What is NextJS?

Next.js is a React framework that enables several features such as server-side rendering and generating static websites.

What is TailwindCSS?

A NextJS theme is a way to share functionality across multiple NextJS applications. Themes are a great way to share components, pages, and styles across multiple applications.

I got this theme from https://themefisher.com/best-nextjs-templates

Getting Started

Step 1: Download the theme

Go to a theme site like https://themefisher.com/best-nextjs-templates

Step 2: Unzip the theme

Place the zipped them into a folder.

In my case I downloaded it to ~/Dev/bookwork-light-nextjs

Step 3: Compile the theme and see how it works.

cd ~/Dev/bookwork-light-nextjs
yarn install

Step 4: Create a new SST project

npx create-sst@latest

Step 5: Deploy the application

npx sst deploy --stage prod