►
Description
Web APIs with Rust Rocket
Is Rust only relevant for systems programming? Do you need platforms like Go or Node.js to build great web APIs? Rainer has been building cloud-based distributed systems for many years and for this Rust Linz meetup he looked into the Rocket framework. He will give a short introduction and compare it to frameworks he knows from other programming languages.
About Rainer Stropek (https://twitter.com/rstropek)
Rainer Stropek is co-founder and CEO of the company software architects and has been serving this role since 2008. At software architects, Rainer and his team are developing the award-winning SaaS time tracking solution “time cockpit”. Previously, Rainer founded and led two IT consulting firms that worked in the area of developing software solutions based on the Microsoft technology stack.
Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Speak at Rust Linz: https://sessionize.com/rust-linz
A
Hi
and
welcome
to
my
session
about
rusty
rockets
about
the
rocket
web
framework
for
building
web
apis
with
the
rust
programming
language.
I
originally
did
this
talk
at
the
rust
mints
meetup
a
few
days
ago.
Unfortunately,
things
didn't
go
very
well
with
the
recording
and
therefore
I'm
going
to
re-record
my
session
now,
so
that
we
can
share
it
with
all
of
you.
It
will
be
exactly
the
same
content
as
I
did
during
the
web
meeting,
but
this
time,
as
I
said,
it's
just
a
re-recording.
A
Let
me
quickly
introduce
myself
before
we
get
started
with
the
content.
My
name
is
reinastropic.
If
you
want
to
get
in
contact
with
me
just
visit
my
digital
cv,
you
find
it
here,
rina,
strawback.me
and
on
the
right,
lower
corner.
You
find
a
bunch
of
links
where
you
can
choose
your
favorite
developer
network
or
social
network
and
keep
in
touch
with
me.
I'm
one
of
the
co-founders
of
the
rust
linz
meetup,
and
I
am
an
enthusiast
when
it
comes
to
rust,
but
I'm
not
an
expert.
A
Yet
rust
is
not
one
of
my
main
programming
languages
yet,
and
this
is
to
be
honest,
one
of
the
reasons
why
I
co-founded
the
rustling
meetup
to
have
a
meetup,
where
I
can
share
my
my
journey
towards
becoming
an
a
more
experienced
ros
developer
with
other
people
who
are
also
interested
in
this
very
exciting
programming
language.
However,
I
am
yeah,
I'm
a
little
experienced
when
it
comes
to
building
distributed
systems,
so
building
web
apis
and
distributed
systems
using
c-sharp
node.js
go.
A
This
is
what
I
essentially
do
for
living,
so
you
can
expect
in
the
next
half
an
hour
or
so
you
can
expect
a
viewpoint
on
the
on
the
rocket
framework
from
somebody
who
knows
a
little
bit
about
rust
and
quite
a
bit
about
web
apis,
and
we
will
see
where
this
story
goes
now.
What
is
our
agenda?
My
goal
is
that
I
would
like
to
show
you
the
basic
principles
of
the
rocket
framework.
A
I
only
have
approximately
half
an
hour,
maybe
a
little
bit
more,
so
I
cannot
go
into
all
the
details,
but
the
important
thing
is,
I
don't
want
to
show
you
a
lot
of
slides.
I
would
really
like
to
focus
on
demos,
demos,
demos.
So
after
this
slide,
this
is
the
last
one
I
have.
I
will
switch
to
visual
studio
code
and
I
will
walk
you
through
a
series
of
demos
that
are
that
begin
very
simple
and
at
the
end
they
are
a
little
bit
more
elaborate.
A
You
can
find
it
here
just
go
to
github.comrustyrock
rockets
and
you
can
find
all
the
code
demos
that
I'm
going
to
show
you
in
the
upcoming
minutes
exactly
there,
and
with
that
I
think
it's
time
to
switch
to
visual
studio
code
and
get
going
I've
prepared
a
completely
empty
rust
solution.
Here,
it's
really
entirely
empty,
as
you
can
see,
so
we
have
to
fill
it
with
some
interesting
web
api
content.
A
The
first
thing
that
we
are
going
to
do
is
we
are
going
to
add
the
dependency
to
our
car
to
our
cargo
towel
file
in
the
cargo
towel
file.
I've
prepared
some
snippets
here.
We
could
of
course,
add
the
rocket
dependency
from
from
crates,
and
if
we
do
that,
we
have
a
slight
problem,
because
currently
we
can
only
get
the
0.4
version
from
there,
and
if
we
do
that,
we
cannot
compile
our
application
with
the
stable
version
of
rust.
A
We
would
need
the
nightly
version,
because
rockets
uses
a
lot
of
experimental
features
of
rust
and
the
current
version
of
0.4,
as
I
said,
is
not
ready
for
the
stable
version
of
rust.
So
therefore,
this
wouldn't
be
as
good
as
I
would
like
to
have
it.
Things
will
change
with
the
version
0.5
being
around
the
corner,
but
currently
only
0.4
has
been
published.
So
this
is
the
situation
we
can
get
around
this
situation.
A
However,
because
on
the
main
branch
in
the
in
the
github
repository
of
rockets,
there
is
already
a
version
which
can
be
compiled
with
a
stable
version
of
rust
and
therefore
I
am
going
to
switch
the
dependencies
here.
I
am
going
to
use
a
dependency,
as
you
can
see
it
here
to
the
git
repository
and
the
master
branch.
In
this
case,
and
with
this
repository
and
this
dependency,
I
can
compile
my
rocket
application
using
the
stable
version
of
rust.
This
is
exactly
what
I'm
going
to
show
you.
A
A
With
that,
let's
go
into
main
rs
and
add
a
bunch
of
things.
The
first
thing
that
I
am
going
to
add
is
I'm
going
to
add
a
bunch
of
uses
these
users
I'm
going
to
use
them
throughout
the
demo.
So
therefore
we
can
just
leave
them
here.
I
will
fold
them
up
because
it's
not
that
interesting.
To
be
honest,
let
me
do
that
like
this
and
that's
good.
The
second
thing
that
I'm
going
to
add
here
is
a
very,
very
basic,
get
method
that
we
need
in
order
to
get
everything
going.
A
A
A
If
you
would
like
to
return
your
own
type
on
in
this
situation,
you
have
to
implement
the
responder
trait
on
your
own.
If
you
want
just
follow
this
link-
and
you
can
read
all
the
details
in
the
documentation
about
how
you
can
do
that
for
our
very
simple
getting
started
example,
this
is
perfectly
fine
what
we
have
here.
We
also
do
not
need
to
implement
our
own
main
method.
A
All
we
need
to
do
is
to
provide
this
rocket
function
and
decorate
it
with
the
launch
macro,
and
this
will
generate
the
main
method
for
us
and
yeah.
Everything
will
get
going
if
we
run
this
guy
and
if
we
build
this
guy.
So
with
that,
let's
give
it
a
try.
Cargo
run,
it
should
be
done
in
attack,
and
here
we
are.
We
have
our
first
web
api
with
just
two
three
lines
of
code.
That's
exactly
what
I
wanted
to
show
you.
I
have
prepared
a
bunch
of
demo
requests
which
we
can
now
try.
A
If
we
would
like
to
run
this
one
as
you
can
see,
it
is
a
get
request
on
api.
You
might
wonder:
hey
reiner,
you
just
showed
us
that
you're
listening
on
the
root
path.
Well,
I
do,
but
those
of
you
who
watched
me
closely,
who
you
saw
that
I'm
using
here
kind
of
namespace,
so
all
the
routes
that
we
add
here
to
our
rocket
function
are
below
the
slash
api
route.
A
I
think
we
should
get
into
the
next
demo,
which
will
add
a
little
bit
more
interesting
features
in
order
to
to
get
going.
Let's
do
that?
Let's
add
the
next
one
here
this
one.
This
is
an
example
which
shows
you
how
you
can
use.
You
can
see
it
here,
dynamic
paths
for
your
routes,
in
this
case
I'm
defining
a
route
which
is
called
greeting
and
this
route
will
get
a
parameter
which
is
called
name
and
rust,
will
automatically
provide
the
content
from
the
url
from
the
path
in
our
parameter
in
the
greeting
method.
A
The
important
thing
here
is
that
again,
everything
relies
on
the
rust
type
system.
So
what
you
can
essentially
do
you
can
use
all
the
types
for
which
the
rust
framework
provides
the
from
param
trait
and
if
you
have
your
own
data
type,
your
own
structs,
for
instance,
you
can
also
provide
a
from
param
trade
implementation
so
that
the
rocket
framework
knows
how
to
get
the
parameter
for
the
method
from
your
http
request.
A
A
A
Let
me
add
a
third
method
here,
a
third
endpoint
and
then
we'll
take
a
look
at
testing.
Let
me
add
the
query
string
param
sample
this
is
the
third
sample
that
I
would
like
to
show.
You
and
it
adds
dynamic,
query
string
parameters,
as
you
can
see
them
here
here.
You
see
that
we
have
two
parameters.
The
first
one
is
a
string,
as
you
can
see
it
here
and
the
second
one
and
that's
the
important
thing
here
is,
for
instance,
oops,
I'm
very
sorry.
I
drew
wrong
lines.
A
Let
me
get
that
straight
yeah,
something
like
this.
The
second
one
is
of
data
type
option.
Data
type
option
is
also
has
also
the
from
param
trade
implemented.
So
therefore,
we
can
use
it
to
to
to
implement
optional
parameters
in
the
query
string.
The
return
value
again
is
a
basic
data
type,
but
we
have
learned
before
that
because
of
the
responder
trade,
everything
is
fine.
We
can
just
return
a
string,
so
this
is
how
you
can
add
parameters
to
the
query
string.
Let's
give
it
a
try,
query
greeting.
A
This
is
what
I
wanted
to
show
you
when
it
comes
to
dynamic,
query,
string
parameters
and
obviously
you
can
combine
dynamic
paths
and
dynamic
query
parameters
with
that.
I
would
like
to
enter
a
little
bit
different
topic,
the
topic
of
testing.
Can
we
test
those
those
web
requests?
Well,
of
course
we
can,
let's
add
a
new
rust
file
here,
tests.rs
and
in
this
tests.rs.
A
A
Let
me
quickly
go
back
to
my
main
method
here
and
add:
add
the
annotation
for
the
test
module
and
with
that
we
will
give
it
a
try.
We
will
say
cargo
test
and
let's
see
whether
it
works
client
re-implement
it.
Oh,
I
think
I
have.
Yes,
I
have
messed
up
something
duplicated
code.
I'm
very
sorry.
There
is
a
bug
in
my
snippets
here
I
corrected
it
and
give
it
a
try
and
now
hopefully
everything
will
work.
Yes,
it
works.
As
you
can
see.
Automated
testing
for
such
scenarios
is
pretty
obvious.
A
The
next
topic
that
I
would
like
to
cover
are
so
called
request
cards
because
request
guards
are
where
a
topic
or
a
concept
that
I
was
not
familiar
with
from
other
frameworks
like
c-sharp
or
go
and
so
on.
I
am
obviously
familiar
with
the
topic
of
middlewares,
but
request
cards
are
somewhat
different
and
I
would
like
to
include
them
in
my
demo
here.
A
Let
me
add
a
new
file
here,
api
key
dot
rs
and
in
this
api
key
I
have.
Let
me
see
here,
custom
request
card.
I
have
a
simple
demo
for
a
custom
request
card.
Let
me
walk
you
through
the
code
first
zoom
in,
and
I
think
it's
good
like
that,
as
you
can
see,
I'm
using
an
a
structure
here
that
is
called
api
key
and
I'm
implementing
the
from
request
trait
for
the
api
key
and
that's
exactly
the
request
card.
A
So
I
provide
a
method
implementation
from
request
where
I
get
the
request
and
I
have
a
chance
to
inspect
the
request
and
maybe
extract
data
and
fill
my
output,
which
will
be
my
outcome,
which
you
can
see
here,
which
will
be
an
instance
of
my
api
key
and
this
api
key
will
then
be
given
to
the
route.
In
my
very
simple
demo,
I
am
inspecting
the
request
and
extracting
from
the
http
headers,
the
header
x
dash
api
dash
key
and
I'm
using
base64
to
decode
this
string
here.
If
everything
works
correctly.
A
So
if
I
can
find
the
header
and
if
I
can
successfully
extract
the
header
or
decode
base64
decode,
the
header,
everything
is
fine
and
I
will
construct
an
api
key
as
you
can
see
it
here.
Otherwise,
I
will
not
let
the
request
go
through.
That's
the
whole
point
of
a
request
guard.
It
is
a
guard
in
front
of
the
request
and
it
lets
http
requests
only
through
if
all
the
requirements
are
fulfilled.
A
A
Now,
how
can
I
use
this
custom
request
card
in
one
of
my
routes?
I
will
add
the
next
sample
here.
This
is
the
route
with
guards.
It's
really
nothing
special,
it's
something
it's
very
similar
to
what
we
already
did
before,
but
this
time
we
are
here,
referencing
a
structure
for
which
this
request
card
has
been
has
been
implemented.
You
have
seen
it
a
second
ago
so
by
referring
to
this
type
and
because
of
the
fact
that
this
type
for
this
type,
the
the
trait
for
the
request
guards,
is
implemented.
A
A
If
I
do
not
provide
any
api
keys-
and
I
run
this
one-
I
will
get
a
401
unauthorized.
This
is
what
we
expected.
If
I
provide
a
proper
api
key.
Let
me
quickly
show
you
that
this
is
really
a
base.
64
value,
the
super
secret
api
key
secret
is
provided
oops.
I
didn't
want
to
do
that.
Let
me
base64
encode
it
again.
If
I
provide
this
x
api
key
everything
is
fine
and
we
get
allowed.
A
A
So,
as
you
can
see,
that
route
guards
are
a
pretty
powerful
mechanism
and
you
could
imagine
yourself
implementing
route
guards
for
your
specific
authorized,
authentication
and
authorization
system
or
you
can
use
existing
crates,
for
I
don't
know,
checking
a
presented
jot
token
from
any
kind
of
open
id
connect,
authentication
mechanism,
whatever
you
would
like
to
do.
Route
guards
are
your
friend
when
it
comes
to
checking
security
requirements
in
http
requests.
A
Good,
of
course,
rocket
is
not
limited
to
custom
route
guards.
There
are
also
existing
route
guards,
which
you
can
use
directly
as
they
are
presented
out
as
they
have
been
created
by
the
creators
of
the
rocket
framework.
Let
me
show
you
as
an
example,
one
route
guard,
which
I
find
particularly
interesting.
This
is
the
cookie
guard.
The
kooky
guard
allows
you
to
inspect
request
cookies
and
return
response
cookies
in
a
very
simple
way.
Let
me
show
you
this
demo
here,
the
first
one.
A
It's
just
a
very
simple
example:
the
first
one
implements
a
kind
of
faked,
very
naive,
granted
login
mechanism,
this
login
mechanism-
if
you
call
this
endpoint,
we'll
use
the
cookie
jar
type
for
which
is
a
request
guard
the
cookie
request
card.
It
will
give
you
access
to
all
the
cookies
inside
of
your
http
request
in
this
case,
I'm
not
reading
the
cookies,
but
in
this
case
I
am
adding
a
new
cookie.
As
you
can
see,
I
will
add
a
cookie
named
session
with
a
very,
very
a
very,
very
secure,
high
secure
session
key.
A
A
If
everything
is
okay,
it
says
you
got
the
cookie
if
it
doesn't
find
the
necessary
session
cookie,
it
will
say
sorry,
no
cookie.
Let's
give
that
a
try
and
see
how
the
ready-made
request
guard
for
cookies
works
with
the
rocket
framework
login
session,
let's
rerun
this
guy
and
go
to
our
requests
here,
as
you
can
see,
the
first
try
the
first
api
request.
Is
this
login
request?
Let's
give
it
a
try,
I
will
send
the
login
request,
and
this
is
exactly
what
I
get
back.
A
We
get
back
a
set
cookie
command
from
the
server
and
we
are
setting
the
session
cookie,
just
as
we
have
presented
this
session
cookie
using
the
cookie
chart
type
in
our
rust
code.
When
we
now
call
the
session
endpoint,
it
will
say
you
have
the
cookie,
because
our
login
request,
which
we
did
before
successfully
set
the
session
cookie,
which
we
can
now
consume.
A
I
think
we
are
now
ready
for
a
more
elaborate
example.
We
have
now
seen
the
concepts
of
routes,
the
concepts
of
starting
a
rocket
server.
We
have
talked
about
dynamic
paths,
dynamic,
query
stream
parameters,
you've
learned
about
the
the
cookie
request
card
and
custom
request
cards.
I
think
we
are
ready
to
build
a
small
rest
api
granted
a
very
simple
rest
api,
but
this
is
an
introductory
talk.
A
A
A
The
important
thing
here
is
this
one,
and
I
think
this
is
already
those
of
you
who
look
closely
at
the
code
already
spotted
that
the
rocket
framework
uses
30
to
do
deserialization
and
serialization
of
json
content.
So
therefore,
I
just
add
serialize
and
deserialize
the
proper
macros
here
at
the
beginning,
and
I
can
use
all
the
the
macros
here
from
certi
in
order
in
this
example,
for
instance,
to
rename
this
property
from
can
underscore
fly
to
the
typical
javascript
casing
can't
fly.
A
I
think
you
get
the
idea,
so
we
are
going
to
use
this
as
our
data
types.
Next,
we
need
some
kind
of
repository
now.
Let
me
tell
you
one
thing
rocket
comes
with
a
built-in
support
for
databases.
You
can
store
your
state
in
databases.
You
can
use,
for
instance,
postgres
and
many
other
databases.
You
can
also
use
an
or
mapper
like
diesel,
for
instance,
I
only
have
approximately
half
an
hour
here
for
this
presentation,
so
therefore,
I'm
not
going
to
dive
into
integration
of
databases
with
connection
pooling
and
all
this
stuff.
A
I
am
sure
those
of
you
who
find
this
topic
interesting
will
be
successful.
After
reading
the
documentation
of
the
rocket
framework,
in
my
case,
I
will
just
use
an
in-memory
hash
map
in
order
to
store
and
hashmap
of
the
heroes
and
the
key
will
be
the
heroes
id
in
order
to
protect
the
heroes
map.
Here,
I'm
going
to
use
a
reader
writer
lock
and
my
application
will
also
auto-generate
the
unique
ids
for
the
heroes
using
an
atomic
use
size,
as
you
can
see
it
here.
A
Now
we
can
start
implementing
our
api
and,
let
me
add
three-
add
hero,
get
single
hero
and
get
all
heroes.
Let
me
add
three
routes
here,
the
first
one
we
will
use
it
to
add
heroes.
The
second
one
is
a
route
with
which
you
can
get
a
single
hero,
and
the
last
one
is
that
the
route
with
which
we
can
get
a
list
of
all
the
heroes.
A
Let's
check
out
the
ad
oops.
Sorry,
let's
check
out
the
add
hero
function
at
the
beginning,
as
you
can
see,
we
are
listening
on
the
heroes
url,
and
here
you
can
see
a
format,
json
format.
Json
means
that
we
would
like
to
restrict
the
router
to
only
deliver
http
requests
which
contain
a
content
type
header
of
application,
slash
json.
This
is
what
the
format
what
this
format
thing
says
here.
The
next
thing
that
I
would
like
to
point
your
attention
to
is
the
data
here.
A
Data
says
that
the
http
request
body
should
be
deserialized
into
our
hero
parameter,
so
siri
will
be
used
to
deserialize
json,
which
comes
in
through
the
http
request
body,
and
we
can
expect
the
content
to
be
in
our
hero
variable.
Therefore,
we
can
access
this
hero
variable
throughout
the
implementation
of
our
add
hero
method.
A
Now
the
next
thing
looks
a
little
bit
strange
as
you
can
see
it
here.
We
get
two
parameters
here,
which
say
which
use
the
type
state
state
is
a
type
provided
by
the
rocket
framework,
and
I
know
this
concept
from
other
frameworks
as
some
kind
of
dependency
injection.
What
you
can
essentially
do.
You
can
register
global
states,
in
my
case,
just
in-memory
states,
and
these
global
states
will
then
be
injected
into
your
routes.
A
There
are
global
states,
but
there
would
also
be
request
local
states,
which
you
can
use
to
to
get
new
instances
of
the
according
types
for
every
hd
incoming
http
request.
I
will
not
use
request
local
states
in
this
example
here
I
will
just
use
global
states
in
my
case,
I'm
going
to
register
a
heroes
map
and
a
hero
count
in
order
to
generate
unique
ids
for
our
heroes
as
global
states.
Let
me
immediately
show
you
how
we
register
that
and
then
we
will
come
back
to
our
add
hero
function.
A
A
A
I
don't
think
that
I
need
to
go
into
all
the
details
of
the
rust
code,
because
it's
pretty
obvious
and
probably
you
have
already
taken
a
glimpse
on
this
source
code.
It's
just
generating
a
new
hero
and
it's
adding
it
to
our
hashmap,
nothing
special.
If
I
messed
something
up
concerning
rust.
If
I
didn't
write
some
idiomatic
rust
as
you
would
expect
it,
please
be
gentle
with
me.
As
I
told
you,
I'm
not
a
very
experienced
rust
developer.
Yet
I'm
an
enthusiast.
A
I
really
want
to
learn
it,
but
if
you
see
something
that
I
do,
which
is
not
idiomatic
rest,
please
get
in
contact
with
me.
Send
me
a
pull
request
for
my
sample
or
something
like
this.
I
am
just
a
beginner
and
I'm
trying
to
explore
what
I
can
do
with
rust.
Nevertheless,
I
hope
that
my
content
is
useful
for
you.
If
you
are
new
to
the
rust
platform-
and
you
are
an
api
developer,
then
maybe
this
will
hopefully
ease
your
your
journey
into
the
rust
world.
A
The
problem
here
is
that
I'm
implementing
an
add
method
and,
of
course
I
would
like
to
return
a
created
http
response
by
the
way,
responding
with
a
created
response
is
really
simple,
using
the
rocket
framework,
because
there
is
a
ready-made
type
for
that.
We
can
just
return
created
here
and
that
has
a
responded
trait
and
therefore
it
will
be
turned
into
an
h,
proper
http
response
with
the
proper
http
status
set,
and
things
like
that.
A
Let
me
show
you
that
here
we
can
reference
the
function,
the
route
with
which
you
can
get
a
single
hero
and
the
generating
of
the
proper
uri
is
done
by
the
rocket
framework.
You
don't
need
to
implement
your
own
string
building
functionality
that
you
can
maybe
mess
up,
because
if
you
change
the
route
url
here,
then
the
location
header
will
be
wrong
and
things
like
that.
The
uri
macro
is
really
really
useful
in
such
situations.
A
This
is
a
good
thing,
so
we
can
now
focus
on
the
get
hero
methods.
The
first
one
uses
a
dynamic
path
parameter.
We
are
here
requesting
data
about
a
single
hero
by
specifying
its
id.
Please
note
that
I'm
using
the
id
type
here
so
if
I
scroll
up
a
little
bit,
then
we
will
see
that
the
id
type
it's
just
a
hue
size
and
that
one
is
again
very
important.
I
repeat
myself
consciously.
A
Okay,
let's
give
it
a
try,
let's
add
our
add
hero
here
we
have
the
add
hero
oops
this
one,
then
I
want
to
add,
get
the
get
all
and
I
want
to
add
the
get
hero
here.
I
think
that
looks
good,
and
with
that
we
can
rerun
hey.
I
could
watch
this,
but
I
will
just
start
cargo
run
again
it's
running
and,
as
you
can
see
here,
we
have
our
very,
very
simple
rest
api
with
a
writing.
Endpoint
post
to
heroes
and
two
reading
endpoints
get
all
heroes
and
get
a
single
hero.
A
Here
you
see
the
heroes
and
the
first
thing
that
I'm
going
to
try
here
is
creating
a
hero.
Let's
create
the
hero,
homelander,
okay,
it
worked
perfectly
fine,
as
you
can
see
here,
201
created
and
even
our
fancy
location
header
works.
As
expected,
we
see
that
by
issuing
a
http
get
request
to
api
0-1,
we
should
get
back
data
about
homelander.
A
A
This
will
not
go
through
because
the
json
could
not
successfully
be
deserialized
into
our
rust
structure
type.
Therefore,
we
get
an
error
from
the
rocket
framework.
Yes,
we
can
catch
this
arrow,
an
error
and
yes,
we
can
customize
the
response
here.
I
will
show
you
that
in
a
second
last
but
not
least,
let's
quickly
check
the
get.
A
By
the
way,
if
you
are
new
to
visual
studio-
and
you
ask
yourself
hey
how
is
rhino
generating
all
these
http
requests,
this
is
a
very,
very
nice
extension
to
visual
studio
code.
It's
called
the
rest
client.
You
can
install
it
for
free,
it's
open
source
and
it
gives
you
the
possibility
to
document
a
typical
http
requests
in
a
nice
little
text
file
which
you
can
check
in
together
with
your
rest,
api
and
it
serves
as
a
kind
of
experimental
playground.
It
serves
as
a
kind
of
documentation.
A
A
That
was
just
a
side
step.
Okay,
we
have
created
our
nice
little
rest
api,
very
good.
We
are
making
progress
now
what
is
left
well,
I
promised
you
a
minute
ago
that
it
is
possible
to
customize
error
responses
and
you
can
do
that
by
using
so-called
catchers
here
you
see
a
custom
catcher
for
a
404
error
in
this
case
a
not
found
error
and
I'm
just
returning
a
custom
json
in
a
very,
very
simple
way.
A
A
So
if
we
try
to
ask
for
something
here
request,
maybe
let's
ask
for
a
hero
that
does
not
exist.
Let's
run
this
request
and
as
you
can
see,
we
now
get
our
custom
json
exactly
as
specified
in
the
catcher,
and
with
that
you
can
obviously
add
catches
for,
for
all
the
things
that
you
need
to
handle
for
all
the
kinds
of
errors
for
which
you
want
to
provide
your
own
implementation,
your
own
kind
of
responses,
good.
I
have
one
final
demo
for
you
and
this
final
demo.
A
Let
me
fold
this
up
is
about
fairings.
Fairings
is
what
you
might
know
from
other
api
platforms
as
middlewares.
It
comes
nearest
to
the
concept
of
middlewares
from
other
platforms,
at
least
on.
In
my
my
impression,
let
me
show
you
let
me
describe
theories
by
walking
you
through
this
example
that
I
created
for
you.
In
this
case,
I
created
a
very
simple
log
fairing.
So
the
idea
is
that
I
can
register
a
fairing,
and
this
fairing
has
a
chance
to
intercept
any
incoming
request
or
is
or
outgoing
response
and
do
do
something
with
it.
A
A
Currently
no
requests
are
here
and
what
I'm
going
to
do
whenever
the
rocket
framework
receives
an
http
request,
I'm
going
to
use
request,
as
you
can
see
it
here
and
oh
sorry,
not
here
here,
I'm
going
to
use
request
to
format
some
log
data
to
sec,
which
is
a
nice
little
tool.
It's
for
free
for
your
personal
use,
where
you
can
gather
all
the
log
information
about
your
applications
running
in
your
I
don't
know
private
cloud
or
whatever
you
want
to
do.
Please
use
your
imagination
here.
A
This
can
be
any
kind
of
middleware
for
logging
for
enriching,
http
requests
or
responses,
or
whatever
you
want
to
do.
Maybe
you
want
to
gather
some
metrics
and
you
would
like
to
send
it
to
your
specific
monitoring
and
telemetry
solution
for
all
these
application
scenarios.
You
can
use
fairings
now
how
are
these
fairings
implemented
here?
I
have
created
a
very
simple
structure,
which
is
a
log
event,
as
you
can
see
it
here,
and
this
log
event
is
then
used
in
the
fairing
down
here
here.
This
is
a
fairing
for
log
target.
A
This
is
a
very
simple
type.
You
will
see
it
in
a
second,
how
I
register
this
fairing
with
the
rocket
framework,
and
then
I
can
provide
a
bunch
of
a
bunch
of
methods
in
this
straight
implementation.
In
this
case,
I'm
only
implementing
the
on
request
method
and
this
method
builds
a
log
event.
It
notes
down
the
timestamp
when
the
http
request
came
in.
A
It
uses
a
very
simple
message:
template
and
adds
a
message
template
item
here,
the
path
where
we
use
the
request
uri
to
get
the
path
from,
and
we
add
it
to
our
log
event.
Last
but
not
least,
as
I
told
you,
this
is
a
rather
naive
implementation,
but
I
hope
it
is
still
useful
for
you
learning
about
the
the
rocket
framework
I'm
using
a
local
web
api
provided
by
the
sec
client,
where
I
just
send
the
the
log
information
in
json
format
to
this
endpoint
in
real
real
world.
A
You
will
obviously
not
send
each
request
immediately
to
your
your
logging
provider,
but
you
will
maybe
gather
all
the
requests
and
send
them
in
batches
to
your
log,
but
it's
this
is
out
of
scope
of
this
talk.
I
just
want
to
describe
what
these
fairings
are
all
about
and,
as
you
can
see
here,
it
is
all
about
providing
some
methods
which
are
called
on
request
responses
and
things
like
that.
A
A
Let
me
try
it,
let's
run
our
application
again
and
maybe
put
that
one
to
the
site
and
have
sec
here
on
the
right
hand,
side-
and
yes,
I
can
do
it
like
that
and
let's
go
to
our
requests
and
send
some
requests
here
and
here
and
here
and
here
and
as
you
can
see
here,
on
the
right
hand,
side
on
sec.
Let
me
send
just
a
bunch
of
things
here:
the
requests
are
coming
flying
in
and
of
this.
This
is
exactly
what
this
fairing
is
doing.
A
A
In
this
case,
I
didn't
specify
a
lot
of
information
just
the
path,
as
you
can
see
it
here,
but
I'm
quite
sure,
if
you
use
your
imagination,
you
can
come
up
with
much
more
useful
and
much
more
elaborate
scenarios
for
what
these
fairings
can
do.
For
you,
and
with
that
I
am
done
with
my
demo
and
I
also
used.
Oh,
I
used
a
little
bit
more
than
the
the
half
an
hour.
I
used
approximately
40
minutes.
I
hope
that's
okay
for
you.
Let
me
quickly
go
back
to
my
slides
here
to
my
first
slide.
A
This
was
an
introductionary
talk
about
the
rocket
framework
how
you
can
implement
apis
with
rust.
I
enjoyed
preparing
this
presentation
for
you.
I
hope
it
was
interesting.
If
you
have
any
problems,
don't
hesitate
to
get
in
touch
with
me.
Twitter
is
a
great
way
of
getting
in
touch.
Take
a
look
on
github,
where
you
can
find
all
the
sample
code
and
take
a
look
on
my
youtube
channel,
because
I
will
definitely
publish
this
this
video
either
on
the
ros
channel
or
in
my
personal
youtube
channel.