►
From YouTube: State of NATS: Core, Persistence, & Materialized Views - Tomasz Pietrek, Synadia Communications
Description
Don’t miss out! Join us at our upcoming hybrid event: KubeCon + CloudNativeCon North America 2022 from October 24-28 in Detroit (and online!). Learn more at https://kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
State of NATS: Core, Persistence, & Materialized Views - Tomasz Pietrek, Synadia Communications
NATS is a high performance cloud native distributed communications utility that allows you to build globally available and secure applications based on streams and services that are both fast and simple to operate. In this talk you will learn about the advanced features of NATS JetStream persistence implementation that includes both Key-Value & Object Store use-cases. You will also see a demo showcasing the flexibility of the NATS newly added Materialized Views capabilities. We will also discuss how it integrates with other CNCF projects, and simplifies your distributed application code base with functions like: watches, history, & sealed streams that are seamlessly integrated via the NATS CLI & API.
A
Hello,
everybody
welcome
to
the
nuts
presentation.
I'm
really
happy
that
you
are
so
many
of
you.
It
was
not
easy
to
find
the
place.
This
talk
is
about
state
of
nuts
about
the
core
persistence
materialized
views.
I
will
walk
through
some
basics
of
nuts
with
you
and
also
update
you
on
on
the
new
things.
A
Okay,
so
what
would
be
the
agenda?
First
of
all,
as
I
said,
I
want
to
do
some
introduction
to
nuts
for
those
of
you
who
are
maybe
heard
of
it
or
not
yet,
and
want
to
not
be
out
of
the
context
when
I
will
get
on
the
features,
then
we'll
get
through
the
new
features
and
we'll
do
some,
hopefully
successful
demo
of
chosen
features
which
are
key
value,
storage
and
object
store.
A
Actually,
the
adoption
that
came
is
something
that's
just
I
was
shocked
and
as
positively
as
I
can
be,
and
that's
what
makes
us
really
happy
and
really
impressed
those
hands.
Reason
tells
a
lot
but
okay,
so
I
feel
now
it's
a
little
pointless
to
talk
about
what
did
not
if
most
of
you
use
it
in
production.
A
So
let's
go
through
it
anyway.
So
basically
it's
performance,
simplicity,
security
and
availability.
It's
the
same
very
simple
thing
that
is,
at
the
same
time
very
performant
and
very
easy
to
secure
to
the
point
you
could
call
it
like
zero
trust
and
properly
secured.
In
addition,
for
last
one
year,
especially
more
than
one
year
when
jetstream
arrived,
I
think
that
it
improved
a
lot
in
terms
of
the
feature
coverage
because
it
it's
not
only
pops
up
it.
A
A
One
thousand-
and
I
was
like
whoa-
that's,
that's,
that's
really
a
lot
and
we
see
it
right
on
slack
that
it's
incredibly
active
community
that
sometimes
as
senator
employees
and
contributors,
we
just
I'm
doing
something.
I
see
a
question
and
before
I
manage
to
answer
it,
it's
somebody
else
from
community
answer
and
it's
really
incredible
and
just
something
I
wanted
to
share
and
thank
you
all
because
you
all
a
lot
of
you
are
contributing
to
those
answers
and
help,
and
it's
just
the
adoption
is
because
of
that
from
the
open
source
community.
A
A
So
who
is
using
an
ad
you?
Basically?
Yes,
I
saw
all
the
hands
up,
but
there
are
lots,
lots
of
actual
companies
very
big
ones
like
mastercard,
like
I
will
not
name
them
all,
because
we
could
spend
quite
some
time.
So
it's
not
only
open
source
adoption.
It's
also
the
actual
production
great
on
huge
scale.
A
A
Okay,
but
yeah.
The
overview
I'll
get
it
a
little
shorter
if,
if
you
most
of
you
use
snaps,
but
to
get
it
the
baseline
for
everybody
also,
those
online
the
things
are,
is
location
independent.
So
if
you
know
the
address
where
the
nas
cluster
or
server
is
you
you
you're
fine,
then
you
just
need
subjects
to
communicate,
to
to
publish
to
communicate
with
other
services
at
core.
A
It's
pops
up,
so
at
the
most
once
fire
and
forget
core
also
has
request
reply
patterns,
so
you
can
have
some
kind
of
synchronous
communication
when
the
you're,
not
that
independent,
then
because
the
replier
have
to
be
available
to
to
return
the
message,
but
it's
possible
in
in
corners
without
jet
streams.
But
then
streams
come
in
of
course,
which
are
the
base
were
based
on
that
streaming
before
now
they
are
on
jetstream
and
jet
stream
is
the
new
persistence
layer
which
is
built
in
not
servers.
A
So
it's
not
a
separate
site
or
anything
like
that.
So
right
now
we
have
already
three
patterns
for
communication.
Free
delivery
guarantees
it's
at
most
once,
if
you're,
using
cornets
and
at
least
once
with
standard
jet
stream
and
exactly
once,
if
you
do
a
little
more
stuff
with
jetstream,
it's
very
simple
but
a
little
less
efficient
security
is
very
important
thing.
The
the
ability
to
make
it
secure
from
almost
the
the
one
is:
it's
not
it's
not
a
something
that
you
play
with
nuts
and
after
some
time
you
realize
oh
now,
security.
A
A
The
fact
that
it's
15
megabytes
makes
it
really
nice
for
even
for
testing
when
you
can
test
it's
so
lightweight
that
you
can
test
it
against
the
actual
class,
actual
server
that
you
spin
in
your
tests
and
and
run
it
against,
and
you
can
run
thousands
of
them
on
your
machine
and
run
the
test
against
actual,
not
seven
of
some
mocks
and
what
usually
people
end
up
is
not
cluster.
That's
cluster!
A
For
consistency,
sorry
for
high
availability
and
horizontal
scalability,
the
next
step
is
super
clusters
which
are
clusters
connected
through
the
gateways
and
what
the
gateways
does
is
they
limit
the
chattiness?
So
even
you
have
clusters
spun
up
across
one
cluster
here,
one
clustering,
different
region,
different
cloud
provider-
you
don't
want
them
to
be
as
chatty
as
typical
clusters
of
whatever
software
you'd
like
to
so
what
gateway?
A
So
you
can
have
a
lyft
node
sitting
on
the
edge
device
in
the
factory
and
have
the
cluster
in
the
cloud
that,
for
example,
aggregates
all
the
data
and
then,
if
the
network
is
down
which
is
pretty
often
for
iot
factory
floors,
which
are
remote
locations,
etc.
The
state
when
the
link
is
up
will
synchronize
whenever
it's
available
and
then
the
leaf
node
is
able
to
function
and
serve
all
the
services.
All
the
features
as
the
connection
is,
is
down,
and
I
think
this
is
some
really
great
thing
in
that.
A
So,
let's
get
to
the
new
features.
Some
things
are
around
security,
so
encryption
address
and
ost
support.
So
so
we
can
revoke
the
public
case.
Next
one
is
monitoring
and
management.
We
put
some
some
efforts
in
quite
a
lot
of
efforts
in
it,
not
only
for
mqtt
and
web
sockets.
That's
also
important,
but
some
things
like
small
things,
but
evaluable
like
being
able
to
that
errors,
are
being
clocked
the
errors
from
health.
This
is
especially
useful
in
kubernetes
setups,
where
it
that
didn't
give
you
much.
A
A
So
this
is
basically
built
up
on
the
the
the
subject:
mapping
feature
of
nuts
we've
added,
some
small,
maybe
not
magic
mechanism
from
our
site.
That
allows
do
doing
the
hashing,
as
this
is
a
cube
con.
It
would
be
really
not
good
not
mentioned
that
a
lot
of
work
was
put
into
the
hand,
charts
the
officially
supported
home,
charts
and
right
now.
I
think
that
most
of
the
things
can
be
configured
via
the
home
charts,
so
you
can
set
up
authentication
all
the
accounts.
A
A
So
we
get
much
closer
to
kubernetes
to
being
easily
run
on
kubernetes,
because
we
think
it's
really
important
so
that
s
cloud
native
technology
should
run
really
well
on
humanities
and
from
jet
stream.
A
lot
of
small
and
big
things
you
can
now
limit
set
limits,
for
example,
on
accounts
of
different
kinds.
A
The
pool
consumers
were
a
lot
of
work
was
put
into
pool
consumers
and
the
ephemeral
pool
consumers
were
added,
so
the
consumers
that
are
only
there
for
justine
when,
when
you
subscribe
to
them,
so
the
pool
consumers
become
more
way
more
performant
and
it
also
inactive
threshold.
So
you
can
set
for
how
long
your
your
ephemera
consumer
will
live
after
you're
done
with
it.
So
you
don't
have
to
pick
if
it's
durable,
so
it
stays
forever
until
deleted
or
it
will
die
whenever
you
are
subscribed.
A
A
A
lot
of
work
also
was
put
into
I'll
gather
those
into
the
fact
that
you
can
attack,
for
example,
a
stream
and
so
stream
will
be
put
on
a
specific
location
or
a
cluster
with
specific
tag.
You
can
also
have
alternates
of
streams,
so
you
can
pick
from
the
closest
stream
for
you,
for
example,
and
get
messages
from
it,
so
it
allows
to
reduce
the
latency
if,
for
example,
the
publishers
put
the
jet,
the
consumer
was
pretty,
the
stream
was
far
away,
but
now
we
have
options
to
improve
the
latency.
A
lot.
A
If
you
like
to
seal
streams,
is
something
that
you
can
set
the
stream
to
be
sealed,
which
means
it
cannot
be.
You
can
read
it,
but
it's
only
basically
read
only
you
cannot
put
more
messages
into
it
and
two
more
import.
Most
important
features,
I
believe,
is
key
value,
storage
and
object,
storage,
key
value
and
object
store,
which
I
will
demo
in
a
moment
yeah.
Actually
I
will
download
them
now,
hopefully
so
for
this
time,
for
a
change
I'll
be
using
rust
client,
I
think
how
many
of
you
did
are
using
rust.
A
Yeah,
that's
yeah
more
than
I
expected.
Actually
because
you
know,
being
the
most
loved
language
always
speaks
on
the
stock
stackoverflow's
most
loved
language
also,
I
think
the
least
known
at
the
same
time,
but
I
think
that
it's
for
the
demo
for
you
for
those
who
are
whatever
other
language
guys,
it's
still,
it
should
be
okay,
because
the
api
is,
for
this,
at
least,
is
pretty
simple,
so
we
will
start
with
connecting
to
nuts
itself.
A
A
A
A
A
You
can
specify
in
history,
so
how
many
values
will
be
kept
for,
given
key
all
the
older
one
will
be
discarded
max
h.
Basically,
this
is
ttl.
You
can
set
that
after
one
second
or
one
minute.
The
key
is
that
the
tl
has
been
reached.
They
will
just
be
deleted.
Will
not
jeopardize
our
demo
with
this
max
bytes
max
number
of
of
the
stream
itself
for
the
given
key
value,
storage
is
file
or
memory
and
replicas
it's
just
number
of
replicas
of
the
stream
and
what's
interesting.
A
Is
I
get
a
question
recently
if
this
how
how
the
state
is
being
handled,
but
actually,
if
you
set
free
replicas,
it
behaves
exactly
as
a
typical
jet
stream.
So
it
doesn't
matter.
You
will
just
get
the
when
you
set
when
you
inserted
the
new
value,
it's
there
for
all
the
replicas
when
you
get
the
acknowledgement
for
this,
so
that's
really
fun.
Okay,
now,
let's
little
rust
magic,
okay.
So
this
is
just
this
fills
all
the
data
except
rust
doesn't
yeah.
Let's
not
talk
about
strings
in
rust.
Okay,
let's
just
skip
this.
A
It
makes
this
this
slice
a
string.
It's
a
really
good
read
to
read
about
how
rust
candles
strings,
because
every
language
has
to
do
it,
and
it's
not
easy
here.
It's
just
more
exposed
to
the
user.
For
some
reasons,
but
we'll
not
get
into
that
now
so
right
now,
let's
see
if
it
works.
Let's
run
this
okay,
we
didn't
fail
this
step
and
now
what
we
can
do
is
we
can
actually
what
we'll
do
what
how
we
called
it
things?
A
A
A
And
what
you
see
here
on
the
on
the
right
that
the
watcher
printed,
the
change
that
happened
in
the
key
value
underneath
this
is
just
again
just
stream
what
we
can
do
else
with
it
we
can.
We
can,
for
example,
this
returns
revision.
I
guess,
let's,
if
we
want
it
for
later
use,
so
what
else
we
can
do
is
we
can
get
the
value.
A
A
So
this
question
marks
handles
error,
but
what
I
would
actually
do,
I
will
match
against
this
pattern
matching
in
rust,
because
the
there
are
two
options.
What
can
happen
there
are
no
needles
in
rust,
so
either
will
get
a
key
or
there
is
no
key,
no
no
value
for
given
key.
So
if
there
is
a
key,
let's
say
value
and
then
we're
printing,
it.
A
A
Okay,
so
we
have
that
here
and
if
we
will
run
it,
we
should
see
yeah.
As
you
see,
we
see
the
value,
the
okay,
it's
nothing
relevant
for
now,
because
it's
another
wrapped
error
doesn't
matter
okay,
so
we
just
very
easily
put
a
value,
get
a
value
and
actually
being
able
to
watch
it.
The
watch
thing
I
will
not
show
it
now,
because
it's
just
an
api
that
enables
you
to
do
the
same
in
the
application.
A
A
A
A
A
A
Yeah,
if
I
will
do
this,
you
see
I
get
no
value
because
the
values
are
still
in
the
stream,
but
it's
fine.
The
last
value
is,
did
it,
so
we
will
just
not
get
this
value.
We
can
put
more
values
than
afterwards
or
we
can
retrieve
the
old
values.
We
are
watching
the
history,
but
you
explicitly
telling
I
want
to
view
the
whole
history
and
I
want
to
like,
take
the
old
value
and
get
it
back
again
or
do
whatever
you
want
to.
A
That's
exactly
that,
so,
if
you
will
run,
I
have
obviously
commented
this
because
it
will
error
whatever
it
will
be
fine,
but
never
mind.
So
if
we
purge
this
and
now
see
the
history,
all
the
values
were
deleted
and
the
marker
perch
is
put
on.
So,
if
you
do
this,
then
it's
yeah,
the
most
the
the
values
are
done.
A
You
cannot
retrieve
them
and
that's
basically,
the
the
basic
functionality
of
key
value.
It's
not
something
very
advanced
in
how
key
values
are,
but
it's
very
nice
for
those
who
want
some
kind
of
key
value,
storage
and
don't
want
to
spin
up.
I
don't
know
whatever
key
value
at
cd
red
is
or
whatever
and
just
want
some
basic
functionality,
and
with
this
you
just
you
just
have
this
key
value
for
free
if
you're
using
nuts,
you've
just
streamed
and
actually
it's.
A
A
A
A
A
A
A
Okay
and
now,
let's
put
in
some
values,
store
put
no
first.
We
have
to
have
something
to
put
in
there.
So
usually
the
question
is
what,
if
you
want
to
use
key
value
storage,
but
I
won't
have
big
files
yeah
in
gesture.
You
can
configure
the
storage
size
for
a
single
message,
but
going
above
few
megabytes
or
a
megabyte.
It's
getting
not
that
performance
and
it's
not
a
good
idea.
A
So
we
thought
that
okay,
so
if
you
want
to
have
bigger
files,
what's
that's
still
possible?
We
just
have
to
chunk
this
this
bytes
into
smaller
pieces.
So
that's
exactly
what
object
store
actually.
Does
it
just
chunks
that
those
messages
in
smaller
those
bytes
into
smaller
pieces
being
single
messages?
A
A
A
Okay
in
rust
files,
things
are
all
variables
are
immutable
by
by
default,
so
we
have
to
make
them
explicitly
mutable,
and
this
is
just
reference.
I
will
not
get
into
this,
because
this
is
a
long
long.
It
will
be
way
too
long,
okay,
yeah,
so
that's
fine,
so
we're
just
creating
we've
put
creating
a
new
meta
which
describes
how
the
file
is
named.
We
can
have
some
link
some
other
stuff
there
and
we're
putting
just
the
reader
there.
A
A
We
can
maybe
before
deleting
it,
I
will
show
you
also
object,
so
we
can
view
the
all
the
object
stores
and
we
can
view
the
files
in
this
object
store.
We
can
get
them
of
course,
etc.
All
the
operations,
typically
that
you
do
over
some
some
kind
of
storage
and
we
can
delete
the
message,
but
maybe
before
deleting
it,
because
it
will
be
too
late,
we
can
also
seal
it
and
what
it
does.
A
A
Deal
probably
yeah,
and
basically
the
old
data
is
now
done,
so
we
created
key
values,
manipulated
key
values
and
showed
you
how
to
delete
them,
how
to
have
non-non-destructive
operations
on
the
key
value.
All
of
that
is
backed
up
by
jet
stream
and
then
do
the
same
over
object
storm.
So
that
would
be
it.
Thank
you
very
much
for
coming
in
so
big
audience.
I'm
very
happy
to
have
you
here
and
if
you
want
to
talk
about
it,
just
reach
me
out
I'm
available
here
and
thank
you
very
much.