►
From YouTube: A Hitchhiker's Guide to Ceph RGW PubSub & Cats vs. Dogs - a Hybrid Cloud Storage Story
Description
A Hitchhiker's Guide to Ceph RGW PubSub & Cats vs. Dogs - a Hybrid Cloud Storage Story - Huamin Chen, Yehuda Sadeh-Weinraub &,Yuval Lifshitz, Red Hat
About Huamin Chen
Principal Software Engineer, Red Hat
Dr. Huamin Chen is a passionate developer at Red Hat' CTO office. He is one of the founding member of Kubernetes SIG Storage, member of Ceph, Knative, and Rook. He previously spoke at KubeCon, OpenStack Summits, and other technical conferences.
About Yehuda Sadeh-Weinraub
Senior Principal Software Engineer, Red Hat
Yehuda is a senior principal software engineer at Red Hat, and has been working on the Ceph project for over 10 years.
About Yuval Lifshitz
Red Hat
Principal Software Engineer
Currently (since 2018) Principal Software Engineer
at Red Hat:
- Kubevirt: Developing networking solutions for
virtual machine payloads in k8s/openshift.
- Ceph: Adding connectivity between the
RadosGW and external message brokers (e.g.
RabbitMQ)
Previously a Senior Software Architect at Sandvine
(2007 - 2018):
- Designing and developing a pluggable policy
engine (C++/Linux/FreeBSD)
- Designing and developing policy charging and
enforcement products based on wireless
specifications (3GPP – Gx, Gy, Rx, Rf, Sd)
- Delegate to standards organization: IETF (co-
author of the update to RFC4006) and 3GPP
A
Show
how,
in
combination
with
with
other
things,
we
can
achieve
more
openness,
this
in
one
of
the
keynote
Gerald
from
Sousa.
It
said
that
you
know,
being
open
is
more
than
just
the
the
source
being
open
and
I
think
this
relates
to
this,
in
the
sense
that
this
feature
demonstrate
how
opening
the
product
to
the
ecosystem
can
facilitate
many
use
cases.
So
I'm
going
to
first
explain
a
couple
of
minutes
spent
couple
minutes
explaining
a
little
bit
about
canid
and
kubernetes,
then
about
the
pups,
are
featuring
self
and
then
a
demo.
A
Hopefully
a
live
demo,
so
Kay
native
Canada,
the
framework
in
kubernetes
that
is
built
to
allow
serverless
function.
It
gets
you
the
Builder
function
to
trigger
them,
to
monitor
them
and
to
invoke
and
run
them
in
our
case,
we're
just
using
a
subset
of
what
can
a
native
can
provide,
and
this
is
a
component
called
eventing,
and
this
is
the
reliable
event
delivery
spreading.
A
The
events
to
multiple
recipients
inside
the
canada,
world
and
so
on
and
serving
which
is
the
invocations
of
the
service
functions,
scaling
them
up
and
down
not
going
to
really
show
scale
up
now.
Well,
in
a
sense,
I
will
because
you
would
see
that
the
the
pod
executing
the
the
function
doesn't
exist
and
until
a
message
arrives,
and
then
it's
gonna
scale
up
and
create
one
instance
couple
of
words
about
server,
let's
just
because
it's
a
safe
conference,
so
maybe
not
everybody
is
so
versed
in
in
the
in
those
terms.
A
Serverless
is
is
on
a
spectrum
of
moving
between
bare
metal,
where
you
need
to
do
lots
of
Arts
through
VMs
through
VM
orchestrations
frameworks
like
OpenStack
containers,
were
you
know
you
have
to
do
even
less
ops
and
container
orchestration
this
kubernetes?
When
we
talk
about
server
less,
you
don't
need
to
do
to
deal
at
all
with
the
server.
The
only
thing
that
you
need
to
do
is
developer
is
write.
Your
function
write
your
code
and
then
somebody
else
is
invoking
it.
A
Somebody
else
is
writing
the
main
loop
waiting
for
messages
to
arrive,
and
the
only
thing
that
you
need
to
care
about
is
your
business
logic
and
and
that's
it.
So
this
is
the
term
server.
That's
just
to
make
sure
that
we're
on
the
same
page-
and
this
is
a
very
appealing
thing
for
simplicity,
because
developers
wants
to
develop
fast
and
deploy
fast,
don't
care
about
lots
of
stuff.
It's
also
sometimes
cost
effective
because
it
rhymes
only
when
you
need
it
to
run.
It
doesn't
always
run
so.
A
Okay,
so
so
what
was
done
in
set
for
for
pub/sub
a
little
bit
about
the
architecture?
Architecture,
how
we
did
that
so
we're
kind
of
building
on
the
sink
mechanism.
So
sink
mechanism
wasn't
intended
to
do
to
do
pop
server
and
it
seemed
like
that,
but
it
is
to
sink
different.
The
made
a
diode,
the
data
and
metadata
in
in
different
zones,
but
the
nature
of
it
that
you
have
a
ready,
scheduler
that
gets
notifications
about
something
they're
happening.
It
gets
all
the
reliable
delivery,
it
gets
an
ACK
mechanism.
A
It
gets
a
retry
mechanism,
lots
of
good
things
there
in
place.
That
allows
you
to
to
write
something
that
that
can
do
publishing
of
events.
Now
the
the
code
Arctic
architecture
was
done
in
such
a
way
that
it
is
easy
to
add
a
new
module,
so
there
are
only
couple
of
modules
taking
advantage
of
this
sinking
mechanism.
Those
are
called
sync
modules
and
again
they
get
verbal
delivery
to
get
aking
retry
as
everything,
and
they
are
implementing
all
kind
of
things.
A
I
think
Sage
listed
some
of
those
things
as
communicating
with
the
syncing
to
the
public
cloud
and
a
couple
more
things.
I,
don't
know
all
them,
but
he
listed
them
in
his
talk.
So
we've
built
just
another
module
like
that,
which
is
a
sync
module
getting
its.
It
is
getting
the
events
getting
the
metadata
from
them
from
the
main
zones
and
what
it
does
is
pub/sub.
A
So
the
basic
functionality
is
just
taking
the
event
and
storing
them
in
surf
itself,
but
that
doesn't
really
publish
anything,
but
the
events
are
there
and
if
somebody
wants
to
pull
them
out
off
of
the
offset
it
can.
So
this
is
the
the
most
basic
functionality
you
don't
publish
anything.
You
are
kind
of
the
message:
bus
or
the
storage
for
the
events
they're
stored
inside
SEF
and
people
can
pull
them
out.
This
is
what
we
call
pool
mode,
but
on
top
of
that
word,
a
couple
more
things.
A
So
when
people
talk
about
probably
subscribe,
do
you
want?
You
usually
want
to
get
the
event
out
of
your
system,
and
we
currently
have
two
mechanisms
in
or
two
protocols
on
which
we
can
send
events
out
of
the
system.
One
of
them
is
HTTP,
those
are
HTTP
posts
and
there
is
a
JSON
payload,
where
the
actual
content
of
the
event
of
whatever
happened
in
SEF
is
going
to
be
sent.
A
Another
system
that
we
can
connect
to
is
using
nqp,
we
using
nqp
0
9
1,
which
is
don't
really
matter,
but
this
is
what
rabbitmq,
which
is
the
most
prevalent
nqp
implementation
common
out
there.
So
this
is
what
they
use.
Once
you
send
the
message
to
something
like
a
m--
QP,
then
your
problems
are
over
because
they
have
reliable
storage.
They
have
reliable
delivery,
they
can
store
event.
They
can
push
the
event.
People
can
pull
the
event
from
them
like
it's
a
whole
system
that
is
meant
for
that
and
more
important.
A
Those
the
system
that
exists
I
mean
people
that
are
running
safe
or
want
to
run.
Seth
in
many
cases
already
have
some
kind
of
message:
bus
they
often
have
rabbit
and
queue.
So
when,
when
they're,
adding
this
functionality,
then
they're
going
to
get
all
the
events
into
in
the
system
that
they
already
have
things
that
and
the
reason
we
also
support
HTTP.
You
will
show
that,
because
it's
what
I'm
good
on
demo,
it's
it's
very
well.
It's
not
like.
A
A
So
how
do
we
define
and
configure
provision
the
system
to
use
pub/sub?
So
the
first
building
block
that
we
have
our
topics
again.
Topics
is
the
term
taking
from
Kafka
and
nqp
to
define
some
classification
of
messages,
because
this
is
what
those
message-
buses
brokers
eventually
use
to.
You
know,
send
those
those
events
all
over
the
place
where
people
need
them
and
inside
the
topic,
you
can
also
define
the
end
point.
A
This
is
how
we
done
like
if
you
ever
interacted
with
AWS,
sqs
or
SNS
one
of
those
guys,
then
this
is
how
they
define
their
the
topics
their
and
their
endpoints.
So
we
kind
of
borrowed
the
same
concept
from
them.
Then
we
have
subscription
subscriptions
our
definition
that
associate
a
certain
bucket
with
the
topic.
So
this
is
what
make
things
happen,
because
what
we
are
monitoring
our
events
happening
on
a
bucket,
and
you
want
to
associate
that
with
with
the
topic.
So
we
know
what
to
do
with
all
events.
A
If
no
endpoint
is
defined,
we
just
store
them
locally
and
then
they
can
be
cooled
out.
This
is
the
pull
mode.
If
an
endpoint
is
defined,
then
we're
gonna
ship
that
to
to
the
endpoint
and
a
little
more
thing
about
the
subscription.
You
can
also
define
a
filter
there,
because
sometimes
you
don't
want
to
get
all
the
events
that
happen
on
on
a
bucket.
A
Sometimes
you
want
to
get
only
the
object
creation,
something
going
to
get
the
object
delicious
without
which
are
the
two
types
of
the
villain
that
we
currently
support,
but
in
the
future
we
will
add
more
refined
triggers
of
the
event
like
you
know,
differentiate
the
start
of
a
multi-part
upload
from
the
end
of
a
multi-part
upload,
and
so
on
a
little
about
the
the
data
structure.
The
way
that
we
structured
the
data
you
can
use
the
same
topic
for
multiple
subscriptions.
Let's
say
that
you
have
a
name
QP
server,
this
rabbitmq
server
broker.
A
Then
you
probably
want
to
send
many
topics
to
it,
so
you
can
define
a
topic
or
many
things
happening
to
it.
So
you
can
define
one
topic
and
say
this:
is
the
topic
I?
Don't
care
exactly
about
the
bucket?
It's
one
topic,
getting
messages
from
multiple
buckets
and
then
I'm
going
to
create
multiple
subscriptions
with
the
same
topic,
all
coming
from
different
buckets
sent
to
the
same,
funnel
to
the
same
place
in
the
rabbitmq
server,
and
sometimes
you
want
to
have
different
topics.
A
Maybe,
on
the
same
bucket,
you
know
with
different
filters,
for
example,
so
I
want
you,
you
want
to
have
a
topic
of
object,
creation
on
that
bucket
X
or
you
want,
and
and
a
different
topic
for
object
relations
on
bucket
X.
So,
for
the
same
for
the
same,
you
can
define
multiple
subscriptions
on
the
same
bucket
and
the
filters
could
be
different.
A
As
I
said,
we
we
reused
in
a
very
nice
way,
the
existing
infrastructure
that
sage
spoke
about.
He
called
that
multi-site,
it's
not
a
great
name,
it's
like
the
thinking
of
multiple
sites,
but
it
has
nothing
to
do
with
multiple
sites.
It
is
just
using
the
the
leveraging,
the
mechanism
to
stand
there,
two
completely
different
other
entities
or
outside
of
self.
A
The
thing
is
that
and
and
when,
when
you
will
the
broker,
we
store
the
messages,
then
that
makes
perfect
sense
because
we
need
to
store
those
messages
and
we
are
the
message:
bus
we're
we're,
storing,
reliably
those
matches.
The
messages
and
Saif
is
the
best
reliable
storage.
We
can
think
about.
However,
when
we're
sending
things
outside
those
are
reliable
kind
of
message
buses
by
themselves.
So
adding
this
extra
layer,
reliability
could
be
an
overkill,
could
be
something
that
we
not
necessarily
want
to
need
to
have.
A
So,
for
example,
if
you
send
something
to
mqp-
and
there
are
clients
that
wants
this
information,
but
from
some
reason,
they're,
disconnected
and
so
on,
nqp
or
the
RabbitMQ
broker
will
take
care
of
that
would
put
that
into
reliable
storage
and
whenever
those
clients
wake
up,
they're
going
to
go
and
fax.
The
information
from
everything
queue
so
there's
very
little
point
in
also
storing
that
information
inside
inside
self.
In
this
case,
so
in
the
future,
we
plan
on
edit
something
called
a
push
only
mode
in
which
the
message
could
go
out
directly.
A
This
extra
zone
here
that
you
see
Zone
C
well,
it
doesn't
cost
too
much
to
add
that.
But
this
is
again
a
little
extra
thing
that
you
need
to
configure
in
your
system.
So
if,
in
your
system
you
really
have
zone
anal
be
adding
Zusi
just
for
pub/sub
could
be
perceived
as
an
extra
piece
of
configuration
that
you
don't
necessarily
need
and-
and
if,
if
in
this
case
of
a
push
only
mode,
we
don't
really
need
it
from
any
functional
reason.
Then
we
in
the
future
we
may
need
to.
A
We
may
want
to
to
avoid
that
this
would
give
us
a
little
more
availability.
So
in
the
sense
that
well
object,
creations
and
deletions
are
usually
important
pieces
of
information,
but
if
we're
more
tightly
integrated
we
may
need,
we
may
be
able
to
add
more
firm
own
events
to
the
mix
and
those
may
not
need
have
some
strict
requirements
on
on
delivery.
A
So
let's
say
that
we
have
events
that
if
they
got
delivered
it's
good,
if
they
didn't
get
delivered,
nothing
bad
happened,
so
those
depends
may
not
even
be
needed
to
persist
it
to
to
any
persistent
memory.
So,
for
example,
if
the
Redis,
Gator
crashes
and
restarts
events
are
lost,
might
be
okay
again,
depending
with
the
type
of
event.
So
this
is
another
kind
of
drive
towards
this
more
integral
implementation,
but
this
is
in
the
future:
okay,
a
little
bit
about
the
demo.
So
what
is
the
background
story?
A
And
you
know
I'm,
not
a
marketing
guy,
so
if,
if
any
of
you
guys
are
really
users
of
search,
you
can
come
up
with
better
better
stories
in
mind.
So
let's
say
that
we
want
to
do
an
image
specification-
I'm,
not
very
original
on
this
one,
but
let's
say
that
we
have
two
types
of
people
that
want
to
classify
the
images,
the
cat
owners
in
the
dog
owners
and,
from
some
reason
we
have
our
own
excellent
cat
classification
algorithm
that
we
built
in-house.
A
We
don't
mind
that
that
google
vision
or
AWS
recognition
or
who
knows
what
going
to
classified
dogs,
because
it's
I
know
less
important
or
no
privacy
to
do
whatever
and
for
cost-effectiveness
of
whatever
reason
you
can
come
up
with.
We
want
to
do
this
processing
in
the
cloud
in
the
public
cloud,
not
in
our
own
premise
cloud
and
again,
those
are
just
things
I
made
up,
but
I
can
pretty
much
be
sure
that
any
of
you
that
actually
used
those
system
can
come
up
with
cost
performance,
bandwidth,
privacy.
A
A
little
bit
about
how
the
hope
you
see
that
that
slide
so
a
little
bit
about
how
the
set
up
is
made.
So
we
have
a
private
cloud
that
runs
a
kubernetes
cluster
and
a
safe
cluster,
and
we
also
connected
to
a
public
cloud,
a
SS
in
this
case.
What
do
we
have
in
the
safe
cluster?
We
have
two
Raiders
gateways.
One
is
the
main
zone
where
you
get
the
images
to
the
other
one.
A
Then,
if
somebody's
going
to
upload
the
dog
into
the
dog
back
bucket,
then
we're
going
to
know
it's
a
different
bucket,
we're
going
to
have
a
different
subscription,
different
topic
and
all
that
stuff,
and
this
topic
is
going
to
have
a
different
end
point
and
the
end
point
that
this
topic
is
gonna.
Have.
Is
this
small
connector
call
HTTP
to
the
AWS,
as
I
said
before,
the
HTTP
is
a
very
basic
destination
and
the
payload
is
the
JSON
payload
that
we
were
sending,
but
the
actual
rests.
A
Api
is
kind
of
different,
so
a
plain
HTTP
POST
is
one
flavor
of
the
API.
Kay
native
is
a
slightly
different
flavor
in
pair
of
the
API
and
NW
x
to
the
third
flavor.
So
this
is
why
we
need
a
little
bit
connector.
Those
like
proxies
they're,
sending
the
same
payloads,
but
a
different
command
rest
command.
So
this
is
why
we
need
this
small
process
call
HP
to
AWS.
Once
we
have
that
native
into
the
this
Redis
gateway
pub/sub
mechanism,
then
those
connectors
go
away
and
everybody's
happy
again.
A
A
Do
the
magical,
processing
and
everybody's
happy
so,
as
I
said,
just
reiterating
that
gonna
create
two
buckets
and
we're
going
to
create
two
topics
and
subscriptions
one's
going
to
send
to
the
HTTP
to
creative
process,
the
other
one's
going
to
send
to
the
HTTP
to
AWS
process.
Those
are
just
converters
just
changing
how
the
rest
message
looks
like
same
payload,
exactly
and
as
I.
A
Also
already
we're
gonna
get
rid
of
these
in
the
future
and
if
there's
some
other
cloud
providers,
that
gonna
have
a
very
good
use
case
for
us,
and
people
would
need
to
would
like
to
to
have
native
support.
Then
again,
it's
pretty
easy
to
add
those
destinations.
It's
the
same,
payload
different
last
message:
if
we
want
to
use
lambda
function
or
service
functions
so
for
other
cloud
providers,.
A
The
setup
there
is
pretty
trivial,
as
I
said,
defining
a
server.
This
function
is
really
easy.
You
just
write
the
code.
You
don't
need
to
write
any
server.
That
gets
a
cheapy
message
or
anything
just
write
the
code.
Somebody
else
is
invoking
this
function.
Taking
care
of
everything.
The
only
gotcha
here
is
that
you
need
to
actually
go
and
fetch
the
image.
So
you'll
need
to
put
the
right
credentials
in
place,
whether
it's
inside
kubernetes
or
inside
the
lambda
function
to
go
and
fetch
the
image
from
SAP.
A
So
those
credentials
you
need
to
somehow
pass
that
up
there
and
make
sure
it's
inside
the
sacred
or
you
know,
make
sure
it's
protected
inside
kubernetes
I
didn't
say
that
we're
using
sto.
This
is
to
make
the
whole
thing
of
communicating
between
kubernetes
in
and
out
easier.
So
you
configure
it's
called
the
services
in
one
place
and
you
don't
need
to
open
ports
manually
and
so
on.
A
A
Okay,
buckets
created
now.
The
next
step
that
I
need
to
do
is
configure
those
topics
and
subscriptions.
So
I
can't
really
use
the
the
standard
tools
for
that,
because
they
they
don't
know
how
to
speak.
Those
language
of
creating
subscriptions
and
topics,
although
board
of
three,
does
support
creation
of
topics
and
subscriptions.
So
you
can
actually
use
that
in
order
to
create
opposite
topics
and
subscriptions
inside
self,
the
you
have
to
make
sure
I
mean
in
both
of
three.
A
A
So
I
have
some
old
events
that
I
didn't
bother
to
delete.
Okay,
I'm
going
to
show
you
the
events
later
in
the
more
in
a
nicer
way,
and
then
I'm
gonna
also
create
one
for
the
cats.
Now,
the
one
for
the
cats
again,
I'm
gonna
tell
it
which,
which
buckets
to
use
I'm
gonna,
give
it
a
name.
The
topic
is
cats
and
I'm,
going
to
give
it
an
endpoint
which
is
whatever
runs
inside
kubernetes.
A
That's
gonna,
take
those
HTP
message
and
convert
them
into
K
native
messages,
which
is
which
are
also
HTTP
messages,
just
a
different
flavor.
So
this
one
also
worked.
Ok,
so
now
we
have
the
configuration
everything
is
configured.
We
have.
The
buckets
I
need
to
make
sure
that
this
translation
process
works.
So
this
is
the
process
that
converts
from
the
plain
HTTP
to
AWS.
A
As
you
see
when
I
define
that
the
endpoint
I
defined
on
port
2001
and
here
I'm
gonna,
listen
on
port
2001,
I'm,
also
gonna
act
messages
acting
them
in
just
telling
the
pups
of
mechanism
that
I
process
the
message:
it's
not
it
a
little
more
and
then
it's
being
cleared
up.
Otherwise,
there's
rotation
of
a
couple
of
days,
I
think
so.
This
is
one.
This
one
is
going
to
wait
for
the
this
is
the
endpoint
of
the
of
the
dogs
and
it's
going
to
send
them
to
AWS.
A
Hopefully-
and
the
last
thing
is
that
we
said
we
are
running
something
in
kubernetes,
so
maybe
have
a
quick
tour
through
the
annals.
So
the
first
thing
we're
gonna
we're
running
kubernetes
is
the
thing
that
translate
from
HTTP
into
K
native
in
the
it's
a
pod.
If
you
know
kubernetes,
but
they
call
that
a
container
source
in
the
K
native
language-
and
it
also
does
the
acting
this
is
why
it
needs
like
the
subscription
name,
and
this
is
where
it
is
doing
the
acting.
A
So
this
is
the
greatest
gateway
surf,
as
I
showed
you
in
the
diagram
there
like
two
Raiders
gateway
is
one
where
the
actual
data
is
in
only
force
pub/sub.
So
the
acting
you
doing
pub/sub.
So
this
is
what
we
put
here
and
what
does
it
do
with
the
things
it
put
it
in
a
channel?
The
channel
is,
this
is
common
message,
but
she
put
in
a
native
that
spreads
the
information.
A
Subscription
is
something
that
ties
a
channel
messages
from
a
channel
into
invocation
of
the
lambda
function.
So
here
you
can
see
that
it
ties
the
channel
that
was
defined
beforehand
into
a
service.
The
service
is,
it
needs
some
information
like
the
because,
later
on,
it
would
need
to
fetch
fetch
the
the
the
images,
so
it
would
need
to
contact
the
Redis
gateway
and
fetch
the
images.
A
This
is
why
it
needs
those
secret
parameters
and,
under
the
hood,
it
just
uses
a
Google
vision,
which
kind
of
a
not
very
pretty,
because
I
said
we
have
a
secret
sauce
algorithm.
We
don't
really
have
that.
So
this
is
why
I
need
an
API
key
for
Google
vision
and
if
you
want
to
look
at
the
function
that
it
invokes.
So
this
is
the
definition
for
the
function
that
that
it
invokes
and
what
this
function
does.
A
It
has
the
name
of
the
of
the
Seth.
It
is
using
port
8000,
not
8000
one,
because
8000
is
worth
the
images
is,
it
doesn't
mean
one
is
worth
the
pub/sub
and
the
acting
is
done
so
it
needs
8,000
because
it
needs
to
get
the
images
from
there
and
it
has
the
Google
API
URL,
because
this
is
where
it.
Actually.
This
is
where
the
secret
sauce
is,
it
doesn't
exist,
okay,
so
those
are
the
animals
and
if
I'm
gonna
see
what's
running
there,
so
what
I
can
see
is
only
the
translator.
A
Pod
is
running,
so
the
the
actual
function
doesn't
run
because,
as
I
said,
it's
on
demand
and
nothing
demanded
it
so
far,
so
for
it
to
be
demanded,
let's
upload
an
image,
so
I
download
a
couple
of
dogs
and
cat
images
from
Wikipedia,
and
let's
start
you
know,
let's
start
with
the
dog.
Now
the
dog,
as
I
said,
is
going
to
the
AWS
one
and
okay,
let's
see
what
it
says.
So
this
is
the
translator,
and
what
we
can
see
is
the
translator
got
an
event.
A
This
is
the
pub
sort
of
event
an
object,
create
we've
got
a
timestamp
and
information,
and
this
is
the
dog
basket
and
it
also
got
the
an
object
called
dog,
three
jpg
and
because
the
dog
basket
is
associated
with
this
endpoint.
This
is
why
it
got
the
message
what
this
one
does
it
just
converts
takes
the
same
payload,
the
same
JSON
payload
that
you
see
here
and
changes
the
rest
message
and
set
it
to
the
lambda
function
and
what
the
longer
function
told
it
is
that
it's
Mamo
and
well.
A
A
A
Let's
see
okay,
so
what
do
I
expect
to
happen
now?
I
send
this
matches.
The
subscription
tells
it
that
it
went
to
the
cat
basket
in
the
subscription
or
the
cat
basket
has
a
different
destination
destination.
Now
is
this
serving
pod
inside
kubernetes
and,
as
I
said,
what
this
one
is
is
doing
the
translation
from
the
plain
HTTP
same
JSON,
payload
different
rest
message
and
put
that
into
the
que
native
message
bus
once
it's
in
the
que
native
message
was:
what
can
a
native
one
knows.
How
to
do.
A
Is
that
looking
at
the
que
native
subscription,
it
knows
how
to
invoke
this.
Google
Vision
pod
run
that
and
let's
see
what
it
says.
So,
first
of
all,
I
need
to
see
what's
running
here.
So
I
see
two
pods
now
the
first
one.
This
is
the
translator,
pod
always
running
and
the
second
one.
This
is
the
part
that
this
is
the
lambda
function.
So,
let's
see
what
the
logs
now
it's
gonna
be
a
different
name
every
time,
because
it's
a
lambda
function
and
it's
going
to
be
inactive
for
a
while,
just
gonna
go
away.
A
So
if
I
keep
on
uploading
images,
then
it's
going
to
still
be
the
same
pod.
But
if
I
don't
upload
an
image
for
like
two
minutes,
then
it's
just
gonna
go
away.
Okay,
so
this
one
contact
that
Google
Google
vision,
you
got
the
object,
cut
forward
and
gave
it
a
score
and
even
said
it's
a
cat.
Let's
try
another
one,
just
for
the
fun
of
it.
A
You
see
I
upload,
the
dog,
but
it's
to
the
cat
basket,
so
the
subscription
doesn't
send
anything
here
for
where
the
dog
should
go,
and
hopefully
it's
the
same.
It's
the
same
yeah,
it's
the
same
function,
and
this
one
says
it's
a
dog
okay.
This
is
pretty
much
it
if
you
have
questions
or
any
anything
to
say,
okay.
Thank
you
very
much,
Oh
with
your
question.
A
What
I
showed
now
it's
in
the
upstream,
you
can
just
fetch
the
latest
compiled
and
get
it
also
sorry,
one
maybe
more
one
last
thing:
the
actual
demo,
if
you
want,
like
all
those
small
connectors
and
the
animals
and
all
that
stuff,
it's
also
it's
also
like
exists.
It's
called
the
audio
pops
of
API
and
the
staff
kind
of
umbrella.