►
From YouTube: wasmCloud: CI/CD Process Update, k8s Operator + Lattice Controller Demo - 10/27/2021 Community Call
Description
wasmCloud is a platform for writing portable business logic that can run anywhere from the edge to the cloud, that boasts a secure-by-default, boilerplate-free developer experience with rapid feedback loop.
A
A
So
we're
just
hanging
out
yeah,
I'm
gonna
share.
My
screen
should
be
able
to
see
a
nice
little
nice
little
yaml
here
I'll
go
to
the
nicest
demo
or
the
the
diagram
first.
Actually
so
it's
kind
of
a
half
demo
half
just
showing
off
what
some
of
the
work
that
I've
put
in
on
our
build
and
release
pipelines.
Lately.
What
we
previously
had
was
like.
A
We
had
three
different
three
different
github
actions
with
various
degrees
of
building
artifacts
for
testing
and
for
releasing-
and
you
know
we
were
not
only
like
copying
and
pasting
things
in
places,
but
we
were
also
you
know
doing
it
kind
of
inefficiently,
so
I've
refactored
the
wasp
cloud
host
action
to
use
matrix
matrices
more
efficiently.
So
we
have
our
build
and
test
matrix,
which
tests
a
variety
of
elixir
and
otp
version
combinations.
A
And
then,
after
after
that
passes,
you
know
our
building
test
pass.
We
can
we're
now
using
a
matrix
to
build
our
our
release,
tarballs
for
windows,
mac
and
ubuntu,
and
for
linux
we're
also
releasing
the
docker
image
as
a
separate
step,
and
then
once
all
that
is
successful,
we
create
a
github
release.
A
What
you're
looking
at
here
is
just
the
it's
the
the
manual
release
for
this,
so
we
can
manually
kick
off
building
the
application
tar
balls
at
any
time
that
doesn't
release
a
new
version
of
the
docker
image.
It's
not
going
to
create
a
new
github
release,
or
anything
like
that.
A
So
to
show
you
what
this
looks
like
previously,
we
had
a
workflow
to
build
a
host
core,
a
workflow
to
build
watson
cloud
host
and
we
had
a
manual
build
action
that
manual
action
for
creating
tar
balls
for
testing
we've
kind
of
consolidated
into
excuse
me
into
the
watsonville
host
action
here.
If
we
take
a
look
at
that,
you
know
you
can
see
the
job
build
strategy
that
we
we've
got
the.
Let
me
do
this
real,
quick,
that'll
that'll.
Give
you
a
better
view.
A
We
have
the
the
build
strategy
for
different
elixir
and
otp
versions.
That
kind
of
just
runs
our.
A
Great
nice,
that
just
kind
of
runs
through
our
build
and
test
process.
If
we
run
down
here
a
little
bit,
we
have
the
release,
docker
action.
That
only
runs
when
we
run
a
tag.
Push
it's
not
when
we
run
manually,
but
notably
something
that's
added.
Here
is
the
platforms
section
here
so
before
we
were
just
building
and
releasing
for
a
docker
file
for
amd64,
architectures
or
like
x86,
but
with
the
apple
silicone
like
m1
chips,.
A
A
A
lot
of
this
previously
was
just
copy
paste
between
the
different
targets,
but
we
have
our
three
different
os's
that
we
target
with
with
pen
versions
on
on
github
action,
runners,
so
ubuntu
windows
and
mac
os,
and
then
this
actually
just
runs
on
the
the
build
matrix
or
it
runs
on
whatever
operating
system
we
are
using.
For
that.
A
Most
of
this
is
pretty
generalized.
You
don't
have
to
change
much
per
operating
system.
There
are
a
couple
places
that,
like
setting
up
erlang
and
elixir
is
different
for
ubuntu
than
it
is
for
mac
and
that's
usually
just
a
limitation
of
whatever,
like
this
rlf
setup
beam,
only
works
on
ubuntu
and
on
windows.
It
doesn't
work
on
mac,
so
we
use
the
brew
version
here
for
mac.
A
But
what
this
ends
up
making
is
a
much
more
concise
flow
for
for
releasing
our
application
and
really
enables
us
to
do
things
like
releasing.
Only
host
core
should
be
fairly
simple,
to
follow
the
same
process
that
we're
using
here
so
yeah,
that's
pretty
much
what
I
had
going
on
anybody
had
any
questions
or
want
to
see
a
little
bit
more
about
this.
Well
yeah
brooks:
do
you
have
any?
Do
you
have
like
the
next
steps
or
improvements
kind
of
laid
out
anywhere
for
this?
A
You
know
in
a
repost
somewhere
I
have
a
couple
of
different
there's
a
couple
different
issues
in
the
otp
repo,
so
one
that
the
taylor
taylor
put
up
is
is
building
host
core
only
for
the
for
the
docker
image.
I
think
we
should
release
tar
balls
with
just
the
host
core
too.
It's
gonna,
be
you
know.
A
Without
the
ui
it'll
be
more
like
minimal,
something
you'd
run
on
an
edge
device
because
you
don't
need
the
dashboard
and
all
of
its
dependencies
included
there,
and
then
this
npm
dependencies
for
wazo
cloud
host
is
more
of
a
it's
another
issue
for
just
kind
of
trimming
down
what
we
use
in
this
phoenix
dashboard,
anyways.
A
Okay,
great
now,
apologies
to
everyone.
We
had
some
pretty
insanely
hot
chicken
for
lunch,
so
there's
still
some
lingering
after
effects
on
our
spicy
eating
contest.
Here,
a
couple
of
us
here
in
the
weeks.
Well,
thank
you
brooks
very
much.
Jennifer
you've
got
a
great
demo
or
you
have
a
demo
some
questions
you
wanted
to
pull
up
and
take
us
through.
You
want
to
go
and
share
your
screen.
C
A
C
C
C
C
Yeah,
I'm
on
dual
monitors.
Well,
I'm
on
a
large
monitor,
which
is
kind
of
why
I
wanted
to
have
windows
open.
Is
that
okay?
Do
you
want
one
minute
switch
over?
I
think
you're
gonna
be
sure
again.
Are
you
on
a
oh
you're
on
linux,
I'm
on
the
next
computer,
but
I
wanted
to
use
a
large
monitor
because
I
wanted
the
window
side
by
side.
A
If
you
could,
maybe
just
like
command
plus
or
like
control
plus
it
just
make
the
text
a
little
bit
bigger
that
would
probably
that
would
help
them
yeah.
They
should
be
able
to
stay
side
by
side
yeah
after
you
change
the
font
size
is
that
cool,
maybe
just
a
little
more
we've
got
to
project
it
on
a
wall.
C
A
C
So,
on
the
right
hand,
side
here
I'll
just
blow
this
up
now.
Actually
this
is
a
simple
test
that
is
written
in.
Go
that
pretty
much
does
what
the
operator
does,
which
is
to
load
the
applied
yaml
in
onto
the
wire.
So
we
had
an
opinion
of
doing
this
through
json
and
when
looking
at
the
the
lattice
controller,
the
ammo
seems
to
be
a
lot
better,
so
I
just
converted
that
and
the
ammo
marshaled
it
and
that
will
go
on
the
wire
also.
C
I
did
choose
zigzag
case
because
that
serializes
a
lot
better
than
this
guy
here,
because
it
I
mean,
I
guess,
the
recursive
design
processor-
doesn't
actually
work
well
for
the
data
structure
that
we've
chosen
here
have
an
ad
server
running
in
the
background
here:
it's
not
using
jet
stream,
so
I
will
actually
end
up
starting
the
test
here
to
listen
so
right
now.
This
is
how
the
link
started.
It
goes
through.
C
There
gets
and
listens
on
the
same
topic
that
we're
publishing
to
which
is
just
well
somewhere
down
here,
but
actually
down
here
has
a
small
timeout,
so
I
don't
wonder
what's
going
on,
then
I
get
that
and
I
serialize
it
into
a
map
because
that's
the
way
it
gets
read
and
then
that
gets
called
into
an
aspect.
C
This
is
pretty
much
copy
paste
code
from
what
kevin
had
before
and
I've
kind
of
hacked
it,
because
I
don't
necessarily
understand
all
the
parts
and
also
the
fact
that
I
haven't
completely
figured
out
how
to
configure
vs
code
to
work
nicely
with
elixir.
Yet
things
are
a
bit
rough
on
me,
so
bear
with
me
there.
So
this
is
just
running
the
reconciler
working.
C
I've
changed
the
weights
here
to
pretty
much
use
the
same
that
we
had
before
or
that
actually
triggers
this
and
as
normal,
so
jesus
50,
50
and
us
less
than
east
here
and
that
maps
down
here
to
the
zones.
C
So
I'm
starting
using
just
a
tag,
so
this
is
me
learning
index
from
the
fly
here
actually,
but
that
tag
actually
might
as
much
as
must
exact
here.
So
I'm
going
to
do
that.
That
will
actually
be
listening.
You'll
see
it
actually
listen
there
down
the
bottom.
B
C
Then
I'll
actually
run
the
test
here
within
10
seconds
and
so
yeah.
The
message
actually
came
through
and
it
got
well.
This
is
for,
I
guess,
I'm
eating
just
to
dump
it
out
as
an
inspect,
which
is
just
coming
out
of
this
part
here.
So
it
is
getting.
It
is
coming
through
the
wire,
it's
listening
on
the
right
topic
and
then
it
reconciles
so
to
speak.
C
I
so
the
questions
are,
I'm
not
necessarily
sure
how
the
apply
event
actually
works,
and
I
see
that
the
reconciler
actually
has
opinions
on
things
like
if
there
is
not
enough
enough
actors
or
there
aren't
enough
factors
on
a
certain
zone,
black
key,
throw
up,
for
example-
and
I
don't
I
guess
I
just
don't
know
how
the
whole
flow
is
supposed
to
work.
So,
for
example,
if
I
change
this
to
80.
C
Probably
nothing
with
this
one
here,
so
let
me
put
it
into
this
and
again
and
run
it
through,
and
this
test
will
actually
fail
with
the
error
based
on
the
records
at
it.
C
Yeah,
so
this
is
well,
I
thought
it
actually
fell,
but
I
guess
in
this
case
it
doesn't
actually
fail
because
it
did
properly
yeah,
that's
kind
of
the
extent
of
what
I've
actually
looked
up.
I
haven't
hooked
it
up
all
the
way
to
otp
and
I'm
also
not
sending
messages
back
yet,
and
I
really
wondering
whether
that's
kind
of
the
intention
of
what
we
want
in
terms
of
the
flow
of
what
that,
what
needs
to
happen
between
the
operator
and
the
lattice
controller
and
then
going
from
there
into.
C
B
So
can
you
can
you
hear
me
through
the
mic?
Okay
yeah,
I
can
hear
you
okay,
this
is
a
great
demo.
I
think
part
of
the
the
stuff
that
might
be
confusing
right
now
is
the
reconciler
just
emits
recommendations
to
be
taken
and
there's
no
code
written
yet
that
actually
takes
those
actions.
So
the
reconciliation
is
designed
as
a
pure
functional
model
where
it
looks
at
the
state
of
the
lattice
and
the
application
plan
or
the
application
spec,
and
then
gives
you
a
list
of
things
of
gaps
that
need
to
be
closed.
B
The
other
thing
is
that
we've
moved
the
lattice
observation
code,
so
the
observed
directory
in
the
lattice
controller.
That's
actually
now
part
of
a
repository
called
lattice
observer,
and
so
the
goal
is
to
make
it
so
that
the
observation
of
a
lattice
is
a
reusable
elixir
library
that
can
be
used
by
both
the
lattice
controller
and
the
dashboard
for
the
weizencloud
otp
runtime.
B
So
what
you've
got
here
is
a
pretty
close
to
like
a
hard-coded
version
of
what
we're
actually
going
to
end
up
build
building.
So
this
is
great,
especially,
you
know
like
the
the
piece
that
we
haven't
coded
yet
is
how
do
you
get
the
app
spec
yaml
file
into
the
lattice
controller?
And
so
that's
that
looks
like
that's
what
you
kind
of
hard
coded
in
your
your
test
there,
and
so
we'll.
We'll
eventually
have
all
that
stuff
fleshed
out,
but
yeah.
My
apologies
for
us
not
having
the
code
there.
It's
just
you
know.
B
We
haven't.
We've
been
working
on
other
priorities,
so
the
latter's
controller
stuff
hasn't
been
moved
as
forward
as
I'd
like
it
to
be.
B
C
B
Produces
a
new
version
of
the
state
which
is
the
observed
lattice
and
so
the
workflow
once
we
code
it
is
we
receive
events
from
the
wasmbus
dot,
ebt
dot,
whatever
that's
topic
and
apply
all
of
those
as
they
come
in
to
the
observed,
lattice
state
and
then
at
some
time
dinner
will
we
will
then
ask
the
reconciler
to
look
at
the
observed
state
of
the
lattice
with
regard
to
a
given
app
spec,
and
the
reconciler
then
gives
you
a
list
of
actions
that
need
to
take
place
in
order
to
bring
the
state
of
the
lattice
to
a
state
to
its
desired
state
versus
its
current
state.
B
So
if
the
reconciler
has
no
recommendations,
then
you
can
assume
that
the
lattice
has
or
is
in
your
desired
state
in
order
to
satisfy
that
particular
aspect.
B
So
what's
not
coded
yet
is
the
control
loop
built
into
the
lattice
controller
that
applies.
Events
puts
the
state
through
the
reconciler
and
then
converts
the
recon
reconciler
recommendations
into
commands
issued
to
the
lattice
control,
interface
and
and
so
on.
So
I'm
I'm
hoping
that
we'll
have
some
more
some
more
scaffolding
in
place,
so
that
you'll
have
some
more
to
work
on.
C
So
then,
how
do
we
so
I
guess
the
with
the
operator
with
the
kubernetes
operator.
If
you're
I
mean
it
kind
of
sound.
Well
I
mean
the
controller
body
right
so
like
the
operator
itself
is
designed
as
a
controller
kubernetes
operator.
Sorry,
so
then
there
are
kind
of
two
things
running
controllers
running.
At
the
same
time,
you.
A
B
In
this
specific
scenario,
what
we
wanted
it
was
to
have
the
ability
to
monitor,
deployed
applications
in
a
lattice
and
manage
those
either
from
a
kubernetes
operator
or
without
a
kubernetes
operator,
and
so
what
the
situation
we
end
up
in
is
the
kubernetes
operator
is
really
more
like
a
proxy
for
the
lattice
controller,
and
so
when
you
push
the
yaml
app
spec
to
the
kubernetes
operator,
it
should
then
just
push
that
on
whatever
api
endpoint,
the
lattice
controller
has
exposed,
and
then
the
lattice
controller
is
then
responsible
for,
for
you
know,
running
the
control
loop
on
it.
B
So
the
control
of
the
kubernetes
operator
should,
at
a
high
level,
be
pushing
the
app
spec
to
the
lattice
controller
and
then
receiving
second
order
or
higher
level.
Events
from
the
lattice
controller.
C
So
I
guess
then,
for
example,
we
had
a
situation
where
the
lattice
controller
makes
recommendations
which
are
realistically
different
from
what
the
aspect
asks
for,
like
the
error
that
I
was
actually
trying
to
trigger
is
when
you
don't
have
enough
actors
in
one
zone,
and
I
guess
I
did
not
figure
it-
probably
because
I
didn't
drop
the
numbers
properly.
But
when
that
happens,
what
is
the
status
that
we
want
to
return
back
to
kubernetes,
because
now
the
abstech
is
going
to
be
different
from?
C
B
Yeah,
so
I'm
not
really
sure
of
all
the
details,
but
generally
what
we're
going
to
want
to
be
able
to
do
so.
B
The
the
lattice
controller
will
also
allow
you
to
query
the
current
state
of
the
observed
lattice,
and
so
the
lattice
controller
is
responsible
for
mutating
the
state
of
the
lattice,
so
that
it
makes
the
app
spec
happen,
and
so
the
kubernetes
operator
is
basically
just
responsible
for
getting
that
aspect
into
the
hands
of
the
lattice
controller
and
then
sitting
back
and
letting
the
lattice
controller
do
all
of
the
work
and
the
kubernetes
operator.
Then
reports
on
the
state
changes.
B
So
if
there's
a
gap
between
the
current
state
of
the
lattice
and
the
desired
state,
then
you
should
be
able
to
you'll
be
able
to
query
that
through
the
lattice
controller's
api
and
you'll
be
able
to
get
that
information
you'll
be
able
to
bubble
that
information
out
through
the
the
kubernetes
controller,
but
that
api
doesn't
yet
exist.
So
there's
like
I
said,
that's
there's
not
really
that
much!
You
have
to
go
on,
so
I'm
I'm
kind
of
impressed
that
you've
got
a
demo.
That
goes
this
far
all
right.
Thank
you,
yeah.
C
C
B
Would
probably
not
spend
effort
hooking
things
up
to
otp
because,
like
I
said
we
have,
we
have
work
happening
in
the
lattice
observer,
repo,
that
is
building
an
otp
supervision
hierarchy
for
observation
and
we're
then,
going
to
once
that's
up
and
running
we're
going
to
go
back
into
the
lattice
controller
and
build
another
otp
supervision
hierarchy
that
incorporates
both
of
those.
So
I
don't
well,
it
feels
bad
to
tell
you
to
not
do
anything.
I
think
at
least
for
the
the
short
term.
It's
probably
best
to
to
wait
a
bit
because.
B
Okay,
you
have
to
you
know,
rig
everything
up
to
otp
on
your
own
and
then
you
suddenly
see
a
pull
request
come
through
that
redid.
All
of
the
work
that
you
did
right.
A
Janitor,
this
is
awesome,
work
great
job
on
this
kevin.
How
do
we
coordinate
you
know
the
next
steps
here
between
the
lattice
controller
and
this
operator.
B
Basically,
like
I
said,
the
suggestion
is
gonna
have
to
be
to
for
for
people
to
hold
off
on
contributions
to
the
lattice
controller
and
the
lattice
observer,
at
least
for
a
very
short
period
of
time,
until
we
can
get
the
changes
that
we're
making
to
them
pushed
out.
And
then,
after
that
point
when,
when
all
the
scaffolding
is
in
place,
we
should
have,
we
should
be
able
to
take
contributions.
But
right
now
it's
just
kind
of
it's
too
much
in
limbo,
and
we
just
haven't
had
the
time
to
move
it
forward.
C
Okay,
janitha
is
this
blocking
you
for
something,
or
did
you
just
think
of
it
as
an
interesting
project,
just
something
interesting
to
do?
While
I
have
some
spare
time
and
the
spare
time
might
be
running
short
pretty
soon,
but
for
me
it
was
just
well,
I
mean,
since
I
kind
of
kicked
off
the
controller
or
set
up
the
direction.
At
least
I
wanted
to
see
how
far
I
can
push
it
to
see
the
whole
thing
working
together,
but
I
don't
have
a
business
use
case,
at
least
at
this
time.
C
A
Super
cool
all
right.
Well,
we
are
doing
you
know
roadmap
planning
now
this
week,
so
let
us
get
through
a
little
bit
of
a
prioritization
on
our
side,
but
I
definitely
feel
that
you
know
we're
kind
of
you're
kind
of
blocked
on
this
at
the
moment.
So
that
feels
like
this
kind
of
escalates
the
priority
a
little
bit,
but
let's
see
what
we
can
do
to
try
to
get
you
moving
again.
A
A
What
else
open
calls
here?
I
don't
think
we
have
anything
we
want
to
present
on
zendesk,
steve
or
anything
roadmap
wise
from
planning.
Just
given
what
we're
doing
this
week
is
just
you
know,
trying
to
plan
out
the
next
couple
months
of
work
here.
Yeah
we'll
definitely
make
some
posts
on
the
slack
next
week.
Okay,
all
right!
So
we'll
we'll
take
the
output
of
this
week
and
we'll
do
some
posts
next
week
and
pick
up
and
go
from
there.
Is
there
anything
else
that
anyone
would
like
to
demo
today.
A
Okay,
I
think
we'll
go
ahead
and
stop
here
today.
I
really
appreciate
everybody's
time
and
jordan,
a
huge
call
out
and
thanks
to
you,
the
you
know,
the
watson
club
wednesday
videos
look
great.
I
love
all
the
new
headers
and
stuff
you
put
in
there
and
it
sure
is
great
to
get
that
stuff
out
and
I
noticed
you've
even
started
tweeting
out.
You
know
contents
of
the
meetings
and
calls
to
action,
and
things
like
that.
A
So
thank
you
very
much
and
I
think
we
shared
on
on
slack
the
you
know
the
output
of
the
survey
around
what
languages
to
focus
on
next.
I
think
we
do
have
some
business
use
cases
coming
up
around
c
plus
plus,
so
the
business
users
may
kind
of
push
that
to
the
top
of
this
top
of
the
pile
if
somebody
is
blocked
on
going
into
production
there,
but
we'll
give
some
feedback
out
over
the
next
few
days
as
we
get
the
roadmap
together
here.