SST serverless stack is an open-source infrastructure-as-code tool for building on AWS with TypeScript. Learn how to easily manage resources on AWS and handle deployments for JS frameworks like Next.js, Astro, Svelte, and more. 

#webdevelopment #javascript #100secondsofcode 

💬 Chat with Me on Discord

https://discord.gg/fireship

🔗 Resources

SST on GitHub https://github.com/serverless-stack/sst
SST Docs https://sst.dev
50 AWS services explained https://youtu.be/JIbIYCM48to
Serverless was a mistake https://youtu.be/qQk94CjRvIs

🔥 Get More Content - Upgrade to PRO

Upgrade at https://fireship.io/pro
Use code YT25 for 25% off PRO access 

🎨 My Editor Settings

- Atom One Dark 
- vscode-icons
- Fira Code Font

🔖 Topics Covered

- How to build serverless apps on AWS
- What is Amazon Web Services?
- What is IaC infrastructure-as-code
- Deploying Next.js to AWS lambda
- Deploying SvelteKit to AWS lambda
- SST quickstart tutorial
2024-02-04T05:03:53.758Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
e63f4cd7-b257-4d59-8050-434128691a4b
c93780c7191b2860fe810ba12658420527d8316e54f30c827963a6da58cd6e1d
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
SST, an open source tool that actually makes it fun to build full stack web applications with AWS.
The problem with Amazon Web Services is that it has too many web services, and putting them all together in a unified package can be extremely complicated.
SST fixes this for web purpose by representing back end infrastructure as code, TypeScript code, making it possible to integrate features like s three storage buckets, Lambda functions with API Gateway, databases like RDS and DynamoDB, Cognito user authentication, along with many other features without ever touching the AWS console, and it has built in deployment support for frameworks like Next.
Js, press Astro and Sveltekit.
Once initialized, it provides a variety of simple constructs that represent infrastructure declaratively.
Under the hood, this code is based on Amazon's Cloud Development Kit and CloudFormation.
These constructs are grouped together in stacks, which can be deployed together or run locally with the sstdev command.
It provides a local development environment with live reloading and provides a web based console to manage your stack minus the typical AWS pain points.
To get started, you'll need the AWS CLI with credentials set up locally.
Next, run the npx create sst command to drop in a deployment solution to your favorite framework or initialize it as a stand alone project.
This will scaffold a monorepo, and the packages directory is where you write the code to power the back end.
Inside here, we can write serverless functions in TypeScript that are powered provide AWS Lambda and use API Gateway as the front door.
To see it in action, run the dev command, and that will automatically deploy the required resources to the cloud, as we can see here on the AWS console.
What's really cool though is that we now have a local development environment, and if we go and change the code in the function, it's immediately reflected in the cloud.
In addition, it spins up the local SST console, where you can view logs and manage your stacks.
A stack is where you define your infrastructure as code.
In the stacks directory, we have an API PIE, that can map URLs to Lambda functions.
Pretty simple, but we can expand on this by adding an event bus, which is able to trigger Lambda functions based on different events that happen in the background, like when a new database record is created.
From there, we can enable file uploads by adding the bucket construct to the stack.
While we're at it, we might add a Postgres database with RDS press, and add the auth construct to enable user authentication.
And we can even define cron jobs here that run on a schedule and point to a specific Lambda And finally, when the stack is complete, we can add it to the s s t config file, then deploy it to the cloud with a single command.
This has proven SST in 100 seconds.
Thanks for watching, and I will see you in the next one.

Speaker 0: SST, an open source tool that actually makes it fun to build full stack web applications with AWS. The problem with Amazon Web Services is that it has too many web services, and putting them all together in a unified package can be extremely complicated. SST fixes this for web purpose by representing back end infrastructure as code, TypeScript code, making it possible to integrate features like s three storage buckets, Lambda functions with API Gateway, databases like RDS and DynamoDB, Cognito user authentication, along with many other features without ever touching the AWS console, and it has built in deployment support for frameworks like Next. Js, press Astro and Sveltekit. Once initialized, it provides a variety of simple constructs that represent infrastructure declaratively.

Under the hood, this code is based on Amazon's Cloud Development Kit and CloudFormation. These constructs are grouped together in stacks, which can be deployed together or run locally with the sstdev command. It provides a local development environment with live reloading and provides a web based console to manage your stack minus the typical AWS pain points. To get started, you'll need the AWS CLI with credentials set up locally. Next, run the npx create sst command to drop in a deployment solution to your favorite framework or initialize it as a stand alone project.

This will scaffold a monorepo, and the packages directory is where you write the code to power the back end. Inside here, we can write serverless functions in TypeScript that are powered provide AWS Lambda and use API Gateway as the front door. To see it in action, run the dev command, and that will automatically deploy the required resources to the cloud, as we can see here on the AWS console. What's really cool though is that we now have a local development environment, and if we go and change the code in the function, it's immediately reflected in the cloud. In addition, it spins up the local SST console, where you can view logs and manage your stacks.

A stack is where you define your infrastructure as code. In the stacks directory, we have an API PIE, that can map URLs to Lambda functions. Pretty simple, but we can expand on this by adding an event bus, which is able to trigger Lambda functions based on different events that happen in the background, like when a new database record is created. From there, we can enable file uploads by adding the bucket construct to the stack. While we're at it, we might add a Postgres database with RDS press, and add the auth construct to enable user authentication.

And we can even define cron jobs here that run on a schedule and point to a specific Lambda And finally, when the stack is complete, we can add it to the s s t config file, then deploy it to the cloud with a single command. This has proven SST in 100 seconds. Thanks for watching, and I will see you in the next one.
SST, an open source tool that actually makes it fun to build full stack web applications with AWS. The problem with Amazon Web Services is that it has too many web services, and putting them all together in a unified package can be extremely complicated. SST fixes this for web purpose by representing back end infrastructure as code, TypeScript code, making it possible to integrate features like s three storage buckets, Lambda functions with API Gateway, databases like RDS and DynamoDB, Cognito user authentication, along with many other features without ever touching the AWS console, and it has built in deployment support for frameworks like Next.
Js, press Astro and Sveltekit. Once initialized, it provides a variety of simple constructs that represent infrastructure declaratively. Under the hood, this code is based on Amazon's Cloud Development Kit and CloudFormation. These constructs are grouped together in stacks, which can be deployed together or run locally with the sstdev command. It provides a local development environment with live reloading and provides a web based console to manage your stack minus the typical AWS pain points. To get started, you'll need the AWS CLI with credentials set up locally. Next, run the npx create sst command to drop in a deployment solution to your favorite framework or initialize it as a stand alone project. This will scaffold a monorepo, and the packages directory is where you write the code to power the back end.
software development
programming
software
systems
Inside here, we can write serverless functions in TypeScript that are powered provide AWS Lambda and use API Gateway as the front door.
To see it in action, run the dev command, and that will automatically deploy the required resources to the cloud, as we can see here on the AWS console. What's really cool though is that we now have a local development environment, and if we go and change the code in the function, it's immediately reflected in the cloud. In addition, it spins up the local SST console, where you can view logs and manage your stacks. A stack is where you define your infrastructure as code. In the stacks directory, we have an API PIE, that can map URLs to Lambda functions. Pretty simple, but we can expand on this by adding an event bus, which is able to trigger Lambda functions based on different events that happen in the background, like when a new database record is created.
infrastructure
networking
software development
programming
software
architecture
databases
From there, we can enable file uploads by adding the bucket construct to the stack. While we're at it, we might add a Postgres database with RDS press, and add the auth construct to enable user authentication. And we can even define cron jobs here that run on a schedule and point to a specific Lambda And finally, when the stack is complete, we can add it to the s s t config file, then deploy it to the cloud with a single command. This has proven SST in 100 seconds. Thanks for watching, and I will see you in the next one.
SST, an open source tool that actually makes it fun to build full stack web applications with AWS. The problem with Amazon Web Services is that it has too many web services, and putting them all together in a unified package can be extremely complicated. SST fixes this for web purpose by representing back end infrastructure as code, TypeScript code, making it possible to integrate features like s three storage buckets, Lambda functions with API Gateway, databases like RDS and DynamoDB, Cognito user authentication, along with many other features without ever touching the AWS console, and it has built in deployment support for frameworks like Next. Js, press Astro and Sveltekit. Once initialized, it provides a variety of simple constructs that represent infrastructure declaratively. Under the hood, this code is based on Amazon's Cloud Development Kit and CloudFormation. These constructs are grouped together in stacks, which can be deployed together or run locally with the sstdev command. It provides a local development environment with live reloading and provides a web based console to manage your stack minus the typical AWS pain points. To get started, you'll need the AWS CLI with credentials set up locally. Next, run the npx create sst command to drop in a deployment solution to your favorite framework or initialize it as a stand alone project. This will scaffold a monorepo, and the packages directory is where you write the code to power the back end. Inside here, we can write serverless functions in TypeScript that are powered provide AWS Lambda and use API Gateway as the front door. To see it in action, run the dev command, and that will automatically deploy the required resources to the cloud, as we can see here on the AWS console. What's really cool though is that we now have a local development environment, and if we go and change the code in the function, it's immediately reflected in the cloud. In addition, it spins up the local SST console, where you can view logs and manage your stacks. A stack is where you define your infrastructure as code. In the stacks directory, we have an API PIE, that can map URLs to Lambda functions. Pretty simple, but we can expand on this by adding an event bus, which is able to trigger Lambda functions based on different events that happen in the background, like when a new database record is created. From there, we can enable file uploads by adding the bucket construct to the stack. While we're at it, we might add a Postgres database with RDS press, and add the auth construct to enable user authentication. And we can even define cron jobs here that run on a schedule and point to a specific Lambda And finally, when the stack is complete, we can add it to the s s t config file, then deploy it to the cloud with a single command. This has proven SST in 100 seconds. Thanks for watching, and I will see you in the next one.
SST,
sst
an
an
open
open
source
source
tool
tool
that
that
actually
actually
makes
makes
it
it
fun
fun
to
to
build
build
full
full
stack
stack
web
web
applications
applications
with
with
AWS.
aws
The
the
problem
problem
with
with
Amazon
amazon
Web
web
Services
services
is
is
that
that
it
it
has
has
too
too
many
many
web
web
services,
services
and
and
putting
putting
them
them
all
all
together
together
in
in
a
a
unified
unified
package
package
can
can
be
be
extremely
extremely
complicated.
complicated
SST
sst
fixes
fixes
this
this
for
for
web
web
purpose
purpose
by
by
representing
representing
back
back
end
end
infrastructure
infrastructure
as
as
code,
code
TypeScript
typescript
code,
code
making
making
it
it
possible
possible
to
to
integrate
integrate
features
features
like
like
s
s
three
three
storage
storage
buckets,
buckets
Lambda
lambda
functions
functions
with
with
API
api
Gateway,
gateway
databases
databases
like
like
RDS
rds
and
and
DynamoDB,
dynamodb
Cognito
cognito
user
user
authentication,
authentication
along
along
with
with
many
many
other
other
features
features
without
without
ever
ever
touching
touching
the
the
AWS
aws
console,
console
and
and
it
it
has
has
built
built
in
in
deployment
deployment
support
support
for
for
frameworks
frameworks
like
like
Next.
next
Js,
js
press
press
Astro
astro
and
and
Sveltekit.
sveltekit
Once
once
initialized,
initialized
it
it
provides
provides
a
a
variety
variety
of
of
simple
simple
constructs
constructs
that
that
represent
represent
infrastructure
infrastructure
declaratively.
declaratively
Under
under
the
the
hood,
hood
this
this
code
code
is
is
based
based
on
on
Amazon's
amazon's
Cloud
cloud
Development
development
Kit
kit
and
and
CloudFormation.
cloudformation
These
these
constructs
constructs
are
are
grouped
grouped
together
together
in
in
stacks,
stacks
which
which
can
can
be
be
deployed
deployed
together
together
or
or
run
run
locally
locally
with
with
the
the
sstdev
sstdev
command.
command
It
it
provides
provides
a
a
local
local
development
development
environment
environment
with
with
live
live
reloading
reloading
and
and
provides
provides
a
a
web
web
based
based
console
console
to
to
manage
manage
your
your
stack
stack
minus
minus
the
the
typical
typical
AWS
aws
pain
pain
points.
points
To
to
get
get
started,
started
you'll
you'll
need
need
the
the
AWS
aws
CLI
cli
with
with
credentials
credentials
set
set
up
up
locally.
locally
Next,
next
run
run
the
the
npx
npx
create
create
sst
sst
command
command
to
to
drop
drop
in
in
a
a
deployment
deployment
solution
solution
to
to
your
your
favorite
favorite
framework
framework
or
or
initialize
initialize
it
it
as
as
a
a
stand
stand
alone
alone
project.
project
This
this
will
will
scaffold
scaffold
a
a
monorepo,
monorepo
and
and
the
the
packages
packages
directory
directory
is
is
where
where
you
you
write
write
the
the
code
code
to
to
power
power
the
the
back
back
end.
end
Inside
inside
here,
here
we
we
can
can
write
write
serverless
serverless
functions
functions
in
in
TypeScript
typescript
that
that
are
are
powered
powered
provide
provide
AWS
aws
Lambda
lambda
and
and
use
use
API
api
Gateway
gateway
as
as
the
the
front
front
door.
door
To
to
see
see
it
it
in
in
action,
action
run
run
the
the
dev
dev
command,
command
and
and
that
that
will
will
automatically
automatically
deploy
deploy
the
the
required
required
resources
resources
to
to
the
the
cloud,
cloud
as
as
we
we
can
can
see
see
here
here
on
on
the
the
AWS
aws
console.
console
What's
what's
really
really
cool
cool
though
though
is
is
that
that
we
we
now
now
have
have
a
a
local
local
development
development
environment,
environment
and
and
if
if
we
we
go
go
and
and
change
change
the
the
code
code
in
in
the
the
function,
function
it's
it's
immediately
immediately
reflected
reflected
in
in
the
the
cloud.
cloud
In
in
addition,
addition
it
it
spins
spins
up
up
the
the
local
local
SST
sst
console,
console
where
where
you
you
can
can
view
view
logs
logs
and
and
manage
manage
your
your
stacks.
stacks
A
a
stack
stack
is
is
where
where
you
you
define
define
your
your
infrastructure
infrastructure
as
as
code.
code
In
in
the
the
stacks
stacks
directory,
directory
we
we
have
have
an
an
API
api
PIE,
pie
that
that
can
can
map
map
URLs
urls
to
to
Lambda
lambda
functions.
functions
Pretty
pretty
simple,
simple
but
but
we
we
can
can
expand
expand
on
on
this
this
by
by
adding
adding
an
an
event
event
bus,
bus
which
which
is
is
able
able
to
to
trigger
trigger
Lambda
lambda
functions
functions
based
based
on
on
different
different
events
events
that
that
happen
happen
in
in
the
the
background,
background
like
like
when
when
a
a
new
new
database
database
record
record
is
is
created.
created
From
from
there,
there
we
we
can
can
enable
enable
file
file
uploads
uploads
by
by
adding
adding
the
the
bucket
bucket
construct
construct
to
to
the
the
stack.
stack
While
while
we're
we're
at
at
it,
it
we
we
might
might
add
add
a
a
Postgres
postgres
database
database
with
with
RDS
rds
press,
press
and
and
add
add
the
the
auth
auth
construct
construct
to
to
enable
enable
user
user
authentication.
authentication
And
and
we
we
can
can
even
even
define
define
cron
cron
jobs
jobs
here
here
that
that
run
run
on
on
a
a
schedule
schedule
and
and
point
point
to
to
a
a
specific
specific
Lambda
lambda
And
and
finally,
finally
when
when
the
the
stack
stack
is
is
complete,
complete
we
we
can
can
add
add
it
it
to
to
the
the
s
s
s
s
t
t
config
config
file,
file
then
then
deploy
deploy
it
it
to
to
the
the
cloud
cloud
with
with
a
a
single
single
command.
command
This
this
has
has
proven
proven
SST
sst
in
in
100
100
seconds.
seconds
Thanks
thanks
for
for
watching,
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
success
The speaker discusses the benefits of using SST, an open source tool that allows web applications to be built with a unified package. SST fixes the problem of combining too many services and provides a deployment support for frameworks like Next. The tool provides a local development environment with live reloading, a web-based console, and various features like s three storage buckets, Lambda functions, and other functions. The speaker also discusses the development environment and how to use the tool to add events and functions to the stack.
SST in 100 seconds
SST, an open source tool that actually makes it fun to build full stack web applications with AWS. The problem with Amazon Web Services is that it has too many web services, and putting them all together in a unified package can be extremely complicated. SST fixes this for web purpose by representing back end infrastructure as code, TypeScript code, making it possible to integrate features like s three storage buckets, Lambda functions with API Gateway, databases like RDS and DynamoDB, Cognito user authentication, along with many other features without ever touching the AWS console, and it has built in deployment support for frameworks like Next. Js, press Astro and Sveltekit. Once initialized, it provides a variety of simple constructs that represent infrastructure declaratively. Under the hood, this code is based on Amazon's Cloud Development Kit and CloudFormation. These constructs are grouped together in stacks, which can be deployed together or run locally with the sstdev command. It provides a local development environment with live reloading and provides a web based console to manage your stack minus the typical AWS pain points. To get started, you'll need the AWS CLI with credentials set up locally. Next, run the npx create sst command to drop in a deployment solution to your favorite framework or initialize it as a stand alone project. This will scaffold a monorepo, and the packages directory is where you write the code to power the back end. Inside here, we can write serverless functions in TypeScript that are powered provide AWS Lambda and use API Gateway as the front door. To see it in action, run the dev command, and that will automatically deploy the required resources to the cloud, as we can see here on the AWS console. What's really cool though is that we now have a local development environment, and if we go and change the code in the function, it's immediately reflected in the cloud. In addition, it spins up the local SST console, where you can view logs and manage your stacks. A stack is where you define your infrastructure as code. In the stacks directory, we have an API PIE, that can map URLs to Lambda functions. Pretty simple, but we can expand on this by adding an event bus, which is able to trigger Lambda functions based on different events that happen in the background, like when a new database record is created. From there, we can enable file uploads by adding the bucket construct to the stack. While we're at it, we might add a Postgres database with RDS press, and add the auth construct to enable user authentication. And we can even define cron jobs here that run on a schedule and point to a specific Lambda And finally, when the stack is complete, we can add it to the s s t config file, then deploy it to the cloud with a single command. This has proven SST in 100 seconds. Thanks for watching, and I will see you in the next one.
The speaker discusses the benefits of using SST, an open source tool that allows web applications to be built with a unified package. SST fixes the problem of combining too many services and provides a deployment support for frameworks like Next. The tool provides a local development environment with live reloading, a web-based console, and various features like s three storage buckets, Lambda functions, and other functions. The speaker also discusses the development environment and how to use the tool to add events and functions to the stack.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : SST in 100 seconds 
        and a small summary : The speaker discusses the benefits of using SST, an open source tool that allows web applications to be built with a unified package. SST fixes the problem of combining too many services and provides a deployment support for frameworks like Next. The tool provides a local development environment with live reloading, a web-based console, and various features like s three storage buckets, Lambda functions, and other functions. The speaker also discusses the development environment and how to use the tool to add events and functions to the stack.
        [/INST]
        
        Generate the video : SST, an open source tool that actually makes it fun to build full stack web applications with AWS. The problem with Amazon Web Services is that it has too many web services, and putting them all together in a unified package can be extremely complicated. SST fixes this for web purpose by representing back end infrastructure as code, TypeScript code, making it possible to integrate features like s three storage buckets, Lambda functions with API Gateway, databases like RDS and DynamoDB, Cognito user authentication, along with many other features without ever touching the AWS console, and it has built in deployment support for frameworks like Next. Js, press Astro and Sveltekit. Once initialized, it provides a variety of simple constructs that represent infrastructure declaratively. Under the hood, this code is based on Amazon's Cloud Development Kit and CloudFormation. These constructs are grouped together in stacks, which can be deployed together or run locally with the sstdev command. It provides a local development environment with live reloading and provides a web based console to manage your stack minus the typical AWS pain points. To get started, you'll need the AWS CLI with credentials set up locally. Next, run the npx create sst command to drop in a deployment solution to your favorite framework or initialize it as a stand alone project. This will scaffold a monorepo, and the packages directory is where you write the code to power the back end. Inside here, we can write serverless functions in TypeScript that are powered provide AWS Lambda and use API Gateway as the front door. To see it in action, run the dev command, and that will automatically deploy the required resources to the cloud, as we can see here on the AWS console. What's really cool though is that we now have a local development environment, and if we go and change the code in the function, it's immediately reflected in the cloud. In addition, it spins up the local SST console, where you can view logs and manage your stacks. A stack is where you define your infrastructure as code. In the stacks directory, we have an API PIE, that can map URLs to Lambda functions. Pretty simple, but we can expand on this by adding an event bus, which is able to trigger Lambda functions based on different events that happen in the background, like when a new database record is created. From there, we can enable file uploads by adding the bucket construct to the stack. While we're at it, we might add a Postgres database with RDS press, and add the auth construct to enable user authentication. And we can even define cron jobs here that run on a schedule and point to a specific Lambda And finally, when the stack is complete, we can add it to the s s t config file, then deploy it to the cloud with a single command. This has proven SST in 100 seconds. Thanks for watching, and I will see you in the next one.
        