►
A
So,
hey
folks,
okay,
so
welcome
to
Cloud
native
live
where
we
dive
into
the
code
behind
you,
Cloud
Network
I.
Am
your
host
Chariot
of
Mr?
Give
me
so
here:
I
am
an
Ambassador
and
I
will
be
your
host
Tonight.
So
every
week
we
bring
a
new
set
of
presenters
to
Showcase
how
to
work
with
Cloud
native
Technologies.
They
will
build
things.
They
will
break
things
and,
in
today's
session,
I'm
stoked
to
introduce
Tom
Quinn,
who
will
be
presenting
on
introducing
a
kubernetes,
are
native
industrial
page.
A
This
is
an
official
live
stream
of
the
CNC
and,
as
such
is
subject
to
the
CSA
color.
For
them,
these
do
not
add
anything
into
the
chat
or
questions
that
would
be
in
violation
of
the
code
format.
Basically,
please
be
respectful
to
all
of
your
fellow
participants
and
presenters
with
that.
I
will
handle
it
over
to
a
problem
and
to
kick
off
today's
presentation.
Okay,.
B
A
B
Okay,
all
right
yeah,
so
hello,
everyone
I,
am
Tom
a
co-founder
and
chief
SRE
of
the
company
yeses
today.
My
topic
will
be
focusing
on
introducing
Shifu
a
kubernetes
native
industrial
Ash,
a
little
bit
of
introduction
of
the
company,
so
we
basically
solve
iot
interoperability
problem
using
a
kubernetes
native
way.
B
B
So
as
shown
here
in
the
architecture
for
each
iot
device,
we
actually
virtualizes
into
a
pod.
So
we
call
it
a
device
Shifu,
but
within
the
Pod
there
could
be
protocol
specific
or
driver
specific
or
system
SDK
specific
to
the
device,
so
each
device
corresponds
to
a
pod
and
that
way
we
can
deploy
our
whole
stack
just
as
deploying
a
software
and
then
on
top
of
that
we
can
easily
integrate
softwares
into
the
same
system.
So
we'll
use
the
same
IP
infrastructure
to
both
manage
our
software
and
iot
devices.
B
So
for
sureful
has
two
core
components:
one
is
called
the
device
Shifu
that
communicates
for
the
devices
and
the
other
one
on
the
top.
We
have
the
the
shuffle
controller
and
also
the
shuffled
for
device
Discovery,
so
Shuffle
controller
actually
manages
the
whole
life
cycle
of
the
iot
devices,
so
say
if
I
discover
the
device
or
if
I
manually
input
a
device,
the
Shifu
controller
will
automatically
deploy
deployments
Services
conflict
maps
accordingly,.
B
A
little
bit
of
introduction
to
shift
plus
architecture,
so
here
within
a
single
device
Tuple.
This
is
how
shippu
works.
So
at
the
bottom
we
happy
out
the
device
and
then,
within
the
device
Shifu
we
have
a
driver
of
the
outer
device
containerized.
Also
we
have
a
layer,
7
proxy,
that's
using
HTTP,
mqtt
or
even
grpc,
and
then
on
top
of
that
everything
is
exposed
as
recipi's.
B
Just
a
quick
note,
so
here
we
have
a
device
Shifu
with
the
driver
of
iot
devices,
but
if
the
device
uses
a
public
standard
protocols
such
as
HTTP
or
mqtt,
OPC
UA
stuff,
like
that,
we
don't
have
to
do
that.
So
we
have
a
device
Shifu
for
General,
open
protocols,
all
right
so
before
we
get
into
the
demo.
Here
is
the
architecture
itself.
A
B
Yeah,
so
this
is
today's
architecture:
I
have
an
existing
kubernetes
cluster
that
is
running
k3s
and
also
I
have
two
nodes:
the
master
nodes
runs
on
a
Raspberry
Pi,
the
worker
no
rents
in
AVM
all
my
host
and
in
today's
demo,
I
am
going
to
integrate
two
devices.
One
is
a
IP
camera
using
rtsp.
The
other
one
is
called
a
displacement
sensor
we'll
get
to
that
later.
B
B
Oh
I
use
multitask,
but
if
you
have
a
say,
Ubuntu
or
Linux
host,
you
can
just
do
this
directly,
so
we
installed
wireguard
for
to
ensure
that
the
interfaces
has
the
has
a
fixed
ID
set
up
the
wire
guard,
and
then
we
bring
up
the
k3s
monster
load
using
this,
and
we
have
to
make
sure
that
we
are
we're
advertising
it
on
the
wireguard
interface
and
then
using
the
wire
guard
interface
for
the
IP
and
then
on.
The
worker.
B
And,
lastly,
we
set
up
Shuffle.
So
what
I
have
here
is
a
just
a
cluster.
That's
that's
been
set
up.
So
if
I
do
get
nodes,
we
have
two
nodes
here.
So
one
is
k3s.
One
is
Raspberry.
Pi
k3s
is
the
host
that
I'm
showing
right
now
and
Raspberry.
Pi
is
kind
of
right
next
right
next
to
it.
So
let's
begin
first
by
installing
Shuffle.
B
So
since
Shuffle
is
kubernetes
native,
we
can
just
install
Legacy
one
line
of
command
and,
as
you
can
see
here,
most
of
them
are
unchanged
since
I've
already
applied
and
pre-downloaded
everything.
So
she
will
introduces
two
custom
resource
definitions.
One
is
called
The.
Edge
device
is
a
custom
resource
definition
in
Shuffle
that
allows
us
to
control
or
manage
the
iot
resources
so
yeah.
If
I
connected
a
camera,
so
there
will
be
a
edge
device
camera
in
there
and
then
the
second
custom
resource
definition
is
called
a
Telemetry
service.
B
B
B
So
you
can
see
here
we
have
the
Shifu
controller
installed
and
up
and
running
so
this
will
help
us
to
control
the
and
manage
the
four
lifestyle
called
the
devices
all
right.
So,
let's
get
into
the
first
step
of
a
demo,
so
here
is
the
architecture
of
the
demo
I'll
be
connecting
the
camera
into
my
worker
node.
That
has
an
IP
of
192.168.64.9
and
then
view
the
camera's
functionalities
through
a
browser
and
then
I
have
a
masternode
with
worker
note
connected
to
one
guard.
B
B
It
allows
us
to
configure
the
skew
of
the
device,
also
the
connection
and
protocol
of
the
device.
So
the
connection
could
be
ethernet.
It
could
be
a
USB,
it
could
be
different
interfaces,
but
here
we're
using
ethernet
and
the
protocol
can
be
say
nqtt
or
pcua,
and
in
that
case
you
would
fill
in
the
actual
OPC
UA
server
address
or
the
mqtt
broker
address
and
that's
the
Edge
device.
So
in
order
to
deploy
a
device
review,
you
also
need
a
conflict
map.
B
A
conflict
map
is
kind
of
like
a
configuration
for
the
digital
twin
or
the
device
Shifu,
and
then
within
that
you
give
it
the
driver,
image
or
the
device
queue
and
then
also
the
instructions.
Instructions
will
be.
What
the
what
abilities
you
would
like
to
have
from
your
device
say:
I
am
integrating
an
IP
camera
I
want
capture
which
Returns
the
current
frame,
I,
won't
stream.
The
return
say
continuous
stream
from
the
camera
television
service
telemetries
will
allow
us
to
periodically
detect
the
device
is
connected
or
not.
B
If
it
failed,
it
will
switch
to
the
file
state
and
then
the
rest
is
just
a
deployment
that
has
that
basically,
is
the
same
from
what
I'm
shown
here.
So
we
have
a
proxy
and
then
the
driver
So.
Within
this
deployment
pod
we
have
run
one
replica
and
then
for
the
Pod.
We
have
a
layer,
7
proxy,
that's
called
device,
receivable
HTTP
HTTP,
and
then
we
have
the
device
driver,
which
is
the
camera
python
version,
and
then
here
we
actually
specify
the
IP
address
of
the
camera
and
then
the
rtsp
port.
B
That's
if
it's
not
a
standard
one
you
can
specify
here
and
then
the
username
and
the
password,
since
this
is
just
a
demo
purposes.
I
use
plain
text
username
and
password,
but
in
a
real
world
situation
you
will.
You
will
like
to
use
a
kubernetes,
Secrets
or
other
Secret
store
for
your
own
deployment.
B
B
B
Let's
add
Port
30196:
we
can
also
check
the
status
of
the
pod
and
to
see
which
host
it's
running
on
okay.
So
it's
running
on
the
k3s
Node
it's
up
and
running
and
has
two
pods.
So
let's
go
to
the
the
browser
and
go
to
the
interface.
So
that's
the
IP
for
that
and
it's
three
zero
one,
nine
six
PN
30196
and
then
there
it
is
so,
as
you
can
see
here,
we
have
error
device
instruction
does
not
exist.
B
Remember
we
configure
that
in
in
our
in
our
conflict
map,
because
we
have
three
instructions
and
none
of
them
is
Slash.
So
so
therefore
the
root
there
doesn't
have
any
instruction
for
that.
But
we
can
use
slash
capture
which
captures
the
current
frame
from
the
camera.
We
can
actually
try
different
angles
and
then
move
around
a
bit
and
then,
if
we
wanted
to
see
the
stream,
we
can
actually
do
stream,
which
gives
us
a
continuous
string
from
the
camera
and
then
that's
it
for
the
camera
connection.
B
B
B
B
Http
server
that
has
the
ads
1115
ADC
converter
inside
exposes
one
interface,
which
is
called
the
slash
sensor
on
Port
5000
and
all
it
does
is
once
called
it
Returns
the
displacement
and
also
the
voltage.
It
calculates
the
displacement
from
the
voltage
this
one.
Two
five:
zero
is
the
maximum
range
for
the
displacement,
so
I,
divided
by
five
and
then
times
the
voltage,
so
it
gets
the
actual
displacement
value
from
it
and
then
for
the
sensor
deployment
similar
to
the
camera.
We
have
the
edge
device
resource
here.
B
And
then
here
we
have
a
different
instruction
called
sensor
and
then
the
driver
image
is
a
different
one
too.
So
that's
that
and
then
for
the
deployment
itself.
It's
similar
to
what
we
got
before.
We
have
a
layer,
7
proxy
plus
the
displacement
sensor
driver
here.
One
thing
to
note
that
we
have
to
mark
it
as
privileged
true
since
we're
accessing
local
devices
or
on
Raspberry
Pi.
We
have
to
give
it.
B
B
B
B
B
B
I'll
just
listened
of
it.
So,
as
you
can
see,
we
have
displacement
and
voltage
and
each
time
we
refresh
it
we'll
get
somewhat
different
value
because
it's
analog,
it
won't
say
the
same.
But
as
you
can
see
it
pretty
much
stays
at
5.7
here
and
for
the
voltage
is
0.02
on
the
voltage,
and
that
is
because
we
haven't
moved
the
the
sensor
itself.
B
B
So,
let's
continue
to
part
three
of
a
demo,
so
one
might
ask
so
what
can
we
do
with
those
connected
devices?
So
one
thing
about
truth
was
I
mentioned
before
we
abstract
devices
into
a
set
of
apis,
so,
for
example,
for
the
IP
camera
we
abstract
it
to
capture
and
stream
and
for
the
displacement
sensor.
B
We
abstract
it
to
a
slash
sensor,
so
that
made
app
develop,
really
easy,
see
if
I'm
developing
something
that
in
an
industry
scenario
or
just
fine
for
my
own
purposes,
I
can
just
develop
just
like
developing
a
web
app
so
part
three
of
the
demo
I'm
going
to
build
an
application
on
top
of
Shuffle,
since
everything
is
containerized
and
everything
is
exposed
as
pause.
I
can
just
build
on
top
of
it.
B
So,
for
example,
if
you
put
this
displacement
sensor
at
your
gate
and
then
when
the
gate
opens
up,
you're
going
to
take
a
picture
and
see
who's
coming,
so
that's
basically
what
we're
trying
to
do
here
so
to
do
that
we
have
to
write
a
application.
So
here
I
have
a
simple:
go:
Application
all
using
standard
gold
packages,
nothing
more
than
that.
B
So
the
first
I
have
declared
a
a
few
constants,
giving
the
sensor
URL
and
the
camera
URL
I'm
directly
using
the
service
names,
since
this
is
kubernetes
native
and
kubernetes
will
take
care
of
all
the
all
the
DNS
things.
So
I
can
use
other
names
directly,
so
the
sensor
URL
will
be
sensor
sensor
and
then
for
the
camera
URL.
Since
I'm
going
to
capture,
take
a
picture
from
it.
B
I'll
use
the
capture
URL,
and
then
we
have
a
pull
interval
that
is
0.5
seconds
and
for
the
sensor
data
we
have
a
struct.
That
is
directly
corresponds
to
this
truck.
We
have
here
so
that
way
we
can
module
it
into
describe
and
then
check
on
its
value.
So
in
the
main
Loop
for
this
application,
we
have
a
start
pooling.
This
is
the
main
logic
to
it.
B
B
So
how
we
get
the
sensor.
Data
is
just
a
simple
HTTP,
get
request,
nothing
more
than
that,
but
we
Marshall
it
into
our
data
struct.
That's
it
so
how
we
capture
an
image
similar
to
that
we
do
an
HTTP,
get
request
to
the
camera
URL
and
then
just
save
it
as
a
file
inside
the
container
for
demo
purposes.
The
format
will
be
using
its
timestamp
so
year
month,
day
and
then
till
seconds.
B
That's
it
so
and
then
the
other
two
handle
functions
here,
I
have
our
are
to
show
you
I,
better
visual,
so
I
have
a
slash
images
that
shows
you
all.
The
current
capture
images
I
have
Slash
images
that
actually
shows
you.
Each
individual
visual
images,
so
if
I
wanted
to
download
it,
I
can
actually
click
on
the
information
download
it.
So
all
these
two
endpoints
are
served
in
basic,
it's
wrapped
in
basic
HTML,
nothing
more
all
right!
So
now,
let's
continue
to
the
view
part.
B
So,
lastly,
we're
going
to
deploy
the
app
so
just
do
click
Auto
apply,
Dash,
f,
.yahoo,
so
just
show
you
the
app
now
always
nothing
more
than
just
the
deployment
and
the
service.
So
the
deployment
has
that
image
for
the
app
and
then
the
service
is
just
a
normal
service.
That's
it
okay
and
then,
let's
check
where
we
have
deployed
the
application.
B
B
Slash
images
will
be
our
URL,
let's
check
the
applicant,
to
see
if
you're
correct,
so
yeah
slash
images.
We
are
all
right.
So
let's
go
back
to
the
browser
and
then
here
all
right,
as
you
can
see,
we
have
a
blank
screen
since
the
application
is
running
and
it
hasn't
captured
anything
because
I
haven't
moved
to
displacement.
So
let's
do
a
bunch
of
retract
here
so
pull
out.
That
should
be
very
much
okay
and
we
should
get
some
images
here.
Let
me
do
the
refresh
too
see
we
capture
four
Images.
B
A
B
Yes,
so
the
difference
between
our
solution
or
Shifu
to
the
others
is
that
we
are
actually
Cloud
agnostic
and
then
we
provide
a
framework
itself.
We
don't
actually
provide
any
cloud
provider
specific.
We
are
a
cloud
agnostic
protocol
agnostic
and
then
we
are
it's
our
microservice.
So
let's
say
we
have
LF
Edge.
We
are
actually
under
lfh.
So
not
only.
B
We
are
a
cncf
landscape
program,
a
project
we
are
also
a
of
edge
project,
so
that's
that
and
then
for
AWS
or
other
other,
such
as
Azure
iot
or
AWS
Greengrass,
AWS,
iot,
core
or
LT
Pub.
We
can
actually
combined
together.
Actually
so
remember,
we
talked
about
the
television
service
that
is
within
the
device
Shifu.
We
can
actually
push
to
Azure
and
AWS
too,
so
we
can
work
together.
That's
that.
A
A
B
B
Yeah,
so
yeah,
just
a
little
bit
so
cool
batch
is
more
of
a
cool
net.
Is
another
kubernetes.
Basically,
so
it
has
some
iot
integration,
but,
like
I
said,
if
you,
if
you
wanted
to
integrate
a
device
with
proprietary
driver,
you
can't
do
that
with
existing
Solutions
or
you
have
to
do
it.
The
ad
hoc
way,
so
there's
no
way
that
lets
you
to
just
deploy
them
like
kubernetes
resources.
A
B
We
don't
really
tamper
with
that,
but
we
do
have
our
our
own
mechanism
that
evicts
pods
to
different
hosts
say,
for
example,
here
I
have
a
connected
device
onto
a
Raspberry
Pi
say
if
the
if
the
Raspberry
Pi
failed
we're
going
to
try
to
detect
if
it's
on
other
Edge
nodes,
if
it's
on
other
astronauts
will
move
the
part
there
to
the
specific
part,
but
for
the
park
eviction
it's
all
handled
by
kubernetes.
Since
we're
kubernetes
native,
we
can
take
an
advantageously.
A
B
B
B
So
we
have
all
the
devices
connected
and
now
I'm
going
to
add
a
new
service
to
it,
which
is
the
Chachi
BT
plugin
service
and
then
I'm
going
to
go
back
to
chattybt
and
let's
have
GPT
to
get
devices,
get
data
from
my
devices
in
real
time
and
render
it
in
real
time.
That
is
the
demo
and
then,
in
order
to
do
that,
first,
we're
going
to
clone
the
repository.
B
So
just
the
one
that
I'm
showing
here
so
on
the
repository
and
then
we're
going
to
modify
a
few
things,
since
this
demo
is
only
for
a
camera,
and
now
we
have
two
devices
we're
going
to
update
this
in
a
couple
of
fields.
So,
first
of
all
we're
going
to
modify
the
the
main.python
to
the
actual
ipu
from
no
port.
So
if
we're
going
to
main.python,
we
have
to
change
it
to
our
actual
port
numbers.
So,
for
example,
the
rtsp
camera
is
on
30196
or
update
that
and
then
the
sensor
is
on.
B
So
you
want
five
six
one
I'll
take
that
and
that's
the
first
step
and
then
for
the
second.
We
yeah
for
the
second
part
we're
going
to
add
the
sensor
API.
So
since
I'm
adding
a
new
API
into
the
the
chat
GP
service
I'm,
going
to
declare
it
here
so
sensor,
basically
a
routes
to
the
sensor,
URL
Pass
center
and
then
guess
the
data
returned
as
Json
format
and
then
next
we're
going
to
update
the
open,
API
yaml
so,
which
is
the
file
here.
We're
going
to
modify
two
parts.
B
First
is
the
title,
so
we
will
see
it's
just
IP
camera
control,
API
and
then
now
we're
adding
sensor
reading
into
it
and
then
for
the
description
part
previous
previously
and
stress
here.
So
now.
We
also
added
allow
us
to
read
value
from
a
displacement
sensor
and
for
the
API
specifications,
we're
going
to
add
slash
sensor
and
then
give
it
the
struct
here.
So
if
we
go
into
the
open,
API
yaml
file,
we
add
it
here
sensor
and
then
at
the
bottom.
B
B
So
it
is
going
to
do
a
request
to
the
Manifest
file.
So
here
we
have
a
plugin
for
shufu
and
then
the
open,
API
URL
and
then
for
the
open,
API,
spec
arrays
from
the
file
we
just
updated,
so
IP
camera
and
sensor
reading
and
then
API
to
access
hiki
camera,
and
it
allows
us
to
revalue
from
the
displacement
sensor.
And
then
we
have
the
sensor
API
and
the
sensor
struck
at
about
yeah
and
then
we're
going
to
hit
install
localhost
plugin
all
right.
B
B
B
Will
be
able
to
figure
out
on
its
own
to
see
which
device
am
I
going
to
call
and
which
API
am
I
going
to
call
since
what
I
since
I'm
asking
what
it's
saying
right
now,
it
directly
calls
the
camera
API
and
then
just
making
sure
this
is
in
real
time.
Let's
see
so,
we
can
actually
regenerate
this
to
making
sure
that
it's
real
time.
B
B
B
So
we
have
a
displacement
and
then
another
voltage
all
right,
so
so
that
is
how
you
can
bring
AI
embodiment
into
your
iot
system,
similar
to
what
we
call
the
a
artificial
intelligence
embodiment
all
right.
So
that
concludes
the
last
part
of
my
demo.
So
we'll
go
back
to
the
slangs
yeah.
So
that's
the
the
last
part
of
the
demo
and
any
questions
any
questions.
Anything.
A
B
I
think
chatgpt
plugin
is
available
to
General
users
right
now,
but
in
order
to
install
the
chat,
GPT
plugin
say
for
Shifu,
you
have
to
join
the
waitlist
for
that
yeah,
but
the
plugin
itself.
It's
I
think
it's
available.
If
we
start
a
new
chat
just
by
using
GPT
3.5,
okay,
okay,
I
see
so
plugins
you
have
to
use
gpt4,
and
that
is
for
the
plus
version
of
chat
gbt.
Only
for
now.
A
B
Yeah,
so
the
reason
we
built
triple
is
that,
first
of
all,
we
are
developers.
So
we
understand
that
when
integrating
iot
devices,
it's
such
a
pain
to
integrate
reality
devices.
It's
such
a
pain
to
build
a
software
with
physical
devices,
the
more
devices
you
have,
the
more
silos
you
introduce
because
usually
for
industrial
or
for
even
home
IELTS
devices,
each
device
has
their
own
ecosystem.
B
B
Oh
yeah,
so
we
actually
have
some
on
our
on
our
website.
So,
for
example,
here's
a
case
study.
Here's
why
the
actual
Shifu
looks
like
in
production.
So
the
this
is
one
of
our
customers
we're
one
of
our
users.
So
they
have
a
industry,
4.0
lab
it's
more
of
a
bio
biologies
and
synthetic
lab,
so
they
they
do
synthesize,
bacterias
or
enzymes,
so
they
have
different
equipments
so
before.
If
they
wanted
to
say,
add
a
dispenser
to
their
software.
B
They
have
to
change
their
software,
they
have
to
ride
the
driver,
they
have
to
maybe
reboot
everything
in
order
for
it
to
work,
but
with
Shuffle.
Adding
a
device
is
just
like
adding
another
pod
and
then
you
expose
it
as
a
service.
So
all
you
have
to
do
is
update
your
business
logic
and
that's
it.
You
don't
have
to
change
your
it
infrastructure
and
it
allows
you
to
focus
on
your
own
business
logic.
Instead
of
worrying
about
the
infrastructure.
B
Yeah
so
yeah,
like
I,
mentioned
before
we
virtualizes
devices
into
pods,
so
this
actually
solves
the
iot
interoperability
problem.
So
each
device
has
a
standalone
service,
so
device
and
devices
will
not
affect
each
other,
and
then
we
can
deploy
devices
just
like
the
deploying
our
applications.
Once
we
have
the
device
driver
or
the
device
shifo,
we
can
reuse
it
in
the
future
say
for
my
second
lab:
I
only
have
the
robot
arm
and
the
automated
guided
vehicle,
and
not
the
others.
I
can
do
that.
B
A
B
B
Where
is
it?
Okay,
oh
I,
see
so
the
scalability
of
the
of
the
Shifu
actually
depends
on
your
cluster.
Since
we
virtualizes
everything
into
Services
just
depends
on
your
cluster.
That
is
one
advantage
you
can
get
from
kubernetes.
So
the
more
nodes
you
have,
the
more
Computing
Powers
you
have.
So
the
more
parts
you
can
handle
in
your
clusters.
So
it
really
limits
on
your.
The
limitation
is
truly
on
the
computing
power
yeah.
B
Yeah
Shuffle
is
a
it's
a
brand
new,
it's
a
brand
new
architecture
or
a
brand
new
framework,
but
the
thing
that
Shifu
uses
is
all
existing,
so
kubernetes,
Edge,
Computing,
Cloud
native
ecosystem,
that's
all
existing,
but
the
architecture
itself
virtualizing
device
into
pause
and
then
abstract
the
device's
abilities
into
a
set
of
apis.
That
is
what
Shifu
introduces
Shifu,
doesn't
add
anything
new
to
the
kubernetes
cluster.
You
just
install
it
as
just
from
one
line
of
command.
That's
it.
A
B
A
B
Yeah
we
welcome
contributors,
so
we
open
source
this
project
about
a
year
ago
and
then
we
have
about
about
over
a
thousand
stars.
So
if
you
wanted
to
see
feature
gets
implemented
on
cheerful,
feel
free
to
create
an
issue
for
that
or
if
you
saw
some
open
source
open,
open
issues
that
request
help
you
can
comment
and
then
we
can
assign
that
to
you.
So
I
will
come
to
contribute.
A
Oh
awesome,
so
yeah,
that's
actually
awesome,
because
open
source
is
something
we
are
looking
for
here
right.
Yes,
so
yeah
I
think
so
we
also
mentioned
about
it
right
like.
Where
can
we
start
the
with
learning
more
about
Shifu
yeah?
Can
you
I
guess
it
would
be
awesome
if
you
just
show
us
from
the
screen
right,
yeah.
B
I'll
just
do
it
on
my
screen
and
then
first
thing
you
can
just
check
out
a
repository.
It's
called
a
Genesis
Shifu
and
then
we
have
a
documentation
site,
it's
called
shuffle.dev
and
then
on
there
we
have
all
of
our
architectures
and
all
that
for
development
materials
that
could
help
you
on
board.
We
also
have
a
quick
demo
for
you
to
try
it,
so
you
have
to
have
a
kubernetes
cluster.
All
you
have
to
do
is
have
Docker,
and
then
we
can.
B
You
can
deploy
this
using
just
one
one
line
of
command.
You
can
start
from
here.
We
provide
you.
Since
this
we
deal
with
physical
devices,
we
actually
provide.
We
have
eight
demo
devices
for
now,
so
those
are
mock
devices
using
real
protocols,
say
mqtt
protocol
or
software
protocol
or
PC
protocols.
That
gives
you
a
brief
understanding
of
how
Shuffle
works
and
how
shift
will
abstract
different
different
protocols
into
http
apis.
A
A
Okay,
great
yeah,
okay,
I
hope
this
query
has
been
solved
as
well:
okay,
yeah,
okay,
so
yeah,
let's
yeah,
can
you
if
there's
anything
you'd
like
to
add
you
can
add
it
here,
let's
wait
for
one
or
two
minutes.
If
Their
audience
is
having
any
questions
or
not,
so
if
anything,
you
would
like
to
add,
you
can
add
here
as
well.
Are
they
getting
shot
or.
B
Something
yeah.
So
if
you
like
a
project,
please
give
it
a
star
or
if
you
have
any
questions,
feel
free
to
email.
Me
I'll
reply
it.
If
you
have
any
questions
regarding
more
use,
cases
feel
free
to
visit
our
website.
It's
calledogenesis.com.
We
have
different
case
studies
and
then
we
have
different
use
cases
and
blogs.
Tech
blocks
so
for
attack
related,
go
to
shifu.dev
for
a
use
case
related.
You
can
go
to
genesis.com,
and
then
we
have
this
Shiva
plugin
for
Chachi
BT
repo.
Here
too,
it's
open
sourced.
B
Yeah,
so
we
are,
we
are
you
can
say
that
so
we
all,
we
only
require
a
kubernetes
kubernetes
cluster.
So,
whichever
it
is,
it's
microcades
or
k3s,
or
let's
say
what
else
do
you
have
Micro
kids,
k3s
and
then
mini
Cube?
We
can
also
work
on
that
and
by
the
way,
Shuffle
is
an
official
official
add-on
for
MacBook
case.
So
you
can
just
do
MacBook
case
enable
Shuffle
that
that
installs
Shuffle
right
there
just
using
that
command.
Yeah
we're
part
of
the
canonical
official
add-ons.
B
Micro,
so
we
have
a
different,
so
we
have
Micro
caves,
that's
one
of
the
distribution
and
we
have
k3s
T3
as
as
in
that
from
Rancher,
and
we
also
have
mini
2
from
that,
and
we
can.
You
can
install
it
on
kind
kind
as
in
kind.
Okay.
Yes,
so
all
those
distributions
you
can
install
on
top
of
it
or
the
real
kubernetes
yeah
that
works
too.
A
B
A
B
Exactly
so,
actually
what
we
have
here
is
a
not
in
the
cluster
but
inter
notes.
So
as
long
as
you
have
internet
connectivity,
you
can
have
multiple
clusters.
Let's
say
if
you're
using
Rancher
for
that
you
can
have
a
cluster
on
the
cloud
and
then
you
can
have
a
cluster
at
the
edge
Standalone
cluster.
So
when
network
connectivity
exists,
you
can
actually
pull
data
directly
from
the
edge
cluster.
B
A
Great
so
yeah
I
hope
there's
no
questions
left
now.
So,
yes,
we
can
add
up
the
session.
So
if
you
or
if
we
have
nothing
to
mention
okay,
so
I
think
we
can
end
the
session
right,
Tom,
yeah,
okay,
great
so
that
was
really
nice.
Having
you
on
this
session.
Hope
to
see
you
again,
I
guess
yeah!
So
thank
you
so
much
Tom
yeah!
So
thank
you,
yeah.
Let
me
take
it
to
the
backstage
yeah.
Thank
you!
So
much
yeah,
okay.