►
From YouTube: The Serverless and Event-Driven Future - Austen Collins, Serverless (Intermediate Skill Level)
Description
Want to view more sessions and keep the conversations going? Join us for KubeCon + CloudNativeCon North America in Seattle, December 11 - 13, 2018 (http://bit.ly/KCCNCNA18) or in Shanghai, November 14-15 (http://bit.ly/kccncchina18).
The Serverless and Event-Driven Future - Austen Collins, Serverless (Intermediate Skill Level)
This talk is presented by Austen Collins, the creator of the Serverless Framework. It will cover the latest trends and use-cases of the serverless movement, as well as the effort happening within the CNCF to converge on a common format for event data. We'll discuss and demonstrate how that facilitates serverless computing across cloud providers and on premises, enables new types of applications and empowers developers.
"About Austen
Austen Collins is a product-obsessed, software engineering leader. His focus is not on technology, but on business value, customer experience and making meaning. Austen is a primary influencer of the emerging “serverless” movement. He is the creator of the Serverless Framework, the leading open-source tool for building applications with the least possible cost and overhead on top of infrastructure with “serverless” qualities. In 2015, he founded Serverless Inc. (serverless.com), which creates developer tools and infrastructure to help organizations build and operate serverless applications. He lives in San Francisco, CA."
Join us for KubeCon + CloudNativeCon in Barcelona May 20 - 23, Shanghai June 24 - 26, and San Diego November 18 - 21! 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.
A
A
All
right
look
at
all
this
isn't
that
amazing:
we've
got
scheduling,
orchestration
service
discovery,
service
management,
networking.
It
is
absolutely
amazing
what
all
of
you
have
accomplished
super
impressed,
but
let's
get
rid
of
this
because
this
is
the
serverless
talk
it.
We
don't
want
to
see
that
stuff
anymore,
I'm
just
kidding
the
service
community
is
really
standing
on
the
shoulders
of
giants.
I,
don't
think
any
of
us
in
the
community
would
be
here
without
all
of
you.
A
I
think
that
the
fact
that
serverless
has
a
thing
is
really
a
sign
of
your
success
and
that's
awesome
anyway.
This
is
the
service
an
event
driven
future
in
this
talk,
we're
going
to
chat
about
the
future
of
service,
we're
going
to
talk
about
what
the
CNC
f
is
doing
to
enable
that
and
we're
going
to
make
it
real
by
attempting
what
might
be
one
of
the
most
ambitious
demos
of
all
time.
I
don't
know
if
y'all
saw
that
tweet
I
posted
earlier,
but
it's
a
lot
of
moving
parts.
A
lot
of
different
parties
involved.
A
It's
it's
might
be
suicide.
I'm
Austin
Collins
I
made
a
popular
open-source
tool
called
the
service
framework
in
2015.
It
helps
you
build
applications
exclusively
on
AWS
lambda
as
your
function
as
Google
cloud
functions
and
other
server
list
services.
I
work
as
the
CEO
of
a
company
called
serverless
Inc,
which
I
founded
but
really
I'm.
Just
a
developer.
I
love
to
make
things
I
like
to
make
solutions,
applications,
meaning
in
the
world
I
didn't
become
a
developer
because
I
wanted
to
do
distributed.
Tracing
I
didn't
become
a
developer
because
I
needed
a
no
sequel
database.
A
I
didn't
become
a
developer
because
I
wanted
to
do
scheduling
and
orchestration.
I
became
a
developer
because
I
wanted
to
make
great
things
and
I
really
love
tools
that
helped
me
stay
focused
on
making
great
things.
I've
been
joined
by
a
fantastic
group
of
people
at
serverless
Inc,
where
we're
all
trying
to
make
tools
to
help
everybody
stay
focused
on
delivering
results
and
making
things
and
we're
not
alone,
because
a
couple
of
years
ago,
out
of
left
field,
suddenly
came
this
serverless
trend.
A
I,
don't
think
anyone
was
really
expecting
it
at
the
time
it
was
cultural
awakening
of
amount
of
people
cried
out
and
said.
You
know
what
software
is
essential
to
solving
humanity's
problems.
We
need
software
more
than
ever
before,
but
it
still
feels
too
complicated
to
make.
Can
we
get
rid
of
some
of
the
this
couplet
it's
complicated
stuff
and
we've
seen
the
desire
toward
higher
order
abstractions
before
in
so
many
iterations
from
cloud
to
virtualization,
to
containers
to
platforms
as
a
service
and
now
to
manage
functions
and
servlet
services
in
general
service?
A
Isn't
a
new
thing?
It's
not
a
different
thing.
It's
just
a
it's
just
the
next
chapter
in
the
same
old
story
towards
simplicity,
where
we
identified
a
new
level
of
abstraction
with
some
new
qualities
that
we
really
like,
and
these
qualities
our
functions
are
the
unit
of
deployment
and
the
unit
of
scale,
and
these
things
should
scale
fast
scale
quickly
and
scale
automatically
for
you.
You
shouldn't
have
to
think
about
that
and,
of
course
you
should
never
have
to
pay
for
idle.
You
shouldn't
pay
for
any
resources
that
you
aren't
using.
A
Current
trends,
here's
kind
of
what's
going
on
in
the
service
world
as
of
right
now,
this
whole
story
got
started
with
closed
source
service
platforms,
particularly
AWS
lambda
led
the
charge
in
late
2014
when
it
was
released.
It
was
followed
by
as
your
functions.
Google
cloud
functions,
IBM
cloud
functions,
and
now
today,
every
single
public
cloud
provider
has
their
own
functions
as
a
service
service
compute
option,
and
it's
pretty
cool.
A
These
things
are
great
for
low
overhead
ease,
speed
convenience,
and
these
are
kind
of
the
the
most
pure
service
experience
out
there
on
a
parallel
path
are
the
open
source
service,
compute
platforms,
and
these
are
platforms
that
are
building
a
service
experience
on
top
of
kubernetes
and
containers,
mostly
like
cublas
Apache,
open,
whisk,
Oracle,
FN,
fishin,
open
faz,
a
lot
of
fantastic
projects
here,
and
these
these
give
you
that
total
control
back
there's
still
a
lot
of
speed
and
ease.
But
you
do
have
the
ops
burden
here.
A
But
these
are
the
most
common
traits
and
the
use
cases
that
we
see
predominantly
from
the
perspective
of
the
service
framework,
our
data
processing
pipelines,
backends
api's
event,
Riven
workflows
and
just
a
whole
bunch
of
other
cool
creative
stuff
like
chat,
bots
and
voice
bots
and
all
types
of
neat
automation,
I,
think
this
is
what
happens
when
you
reduce
overhead
and
complexity.
Generally,
you
liberate
a
lot
of
productivity.
You
liberate
a
lot
of
creativity
and
that's
what
we
see
in
the
service
community
now,
why
is
this
popular
developers
love?
A
This
experience,
functions
and
events
are
really
easy
to
reason
about
it's
accessible,
it's
flexible.
It
checks
a
lot
of
the
boxes
it's
also
distributed,
and
now,
if
you
want
to
move
fast,
if
you
want
to
reduce
overhead,
if
you
want
to
increase
the
rate
of
innovation
and
organization,
if
those
are
your
goals,
this
is
now
like
the
best
option
in
town
and
we
see
fantastic
results
with
service
applications.
Almost
every
single
day
forecasts
where's
this
stuff
going.
What's
next,
that's
kind
of
what
has
happened.
A
Here's
where
we
think
it
might
be
going
first
off
service
is
a
story
of
functions
and
events
and
events
have
been
around
for
a
long
time.
Event-Driven
design
has
been
around
for
a
long
time,
but
we
think
events
are
going
to
be
especially
prevalent
in
the
future.
Probably
more
events
than
ever-
and
this
is
because
of
IOT-
is
a
good
reason
for
this.
A
There's
going
to
be
a
IOT
devices
everywhere,
sensors
everywhere
tracking
our
movements,
tracking,
every
single
thing
that
happens
and
we're
building
system,
intelligent
systems
now,
systems
that
can
analyze
events
and
make
decisions
on
our
own
in
real
time
and
also
integrations
integrations
between
services.
Your
micro
services,
your
legacy,
your
new
stuff,
integrations
across
your
stuff
and
all
the
third-party
vendors
that
you're
doing
integrations
are
generally
increasing
and
service.
A
Compute
aka
event-driven
compute,
as
it
was
originally
called
when
aw
slam
that
came
out
servos
compute
its
with
that,
has
never
been
easier
to
react
to
something
that
happens
with
code.
All
right,
I
could
upload
a
thousand
functions
right
now
to
AWS
lamda.
It's
not
going
to
charge
me
anything
until
something
happens
and
it
triggers
those
functions
and
when
that
does
happen,
it's
going
to
scale
so
anyway,
a
lot
of
this
stuff
is
going
to
create
this
habitat.
We
think
that
is
just
ripe
for
a
lot
of
events,
a
lot
of
event-driven
design
and
I.
A
A
So
what
follows
after
this
functions
everywhere.
We
think
we
have
events.
You
have
a
lot
of
events
more
events
than
ever.
We
have
the
proliferation
of
serverless
computing
platforms,
which
offer
this
fantastic
easy
experience
for
reacting
to
events
and
use
cases
that
require
computing
close
to
the
event
source,
and
we
think
this
will
bring
about
this
scenario
of
functions
everywhere.
So
functions
running
across
cloud
providers,
whether
in
those
kind
of
proprietary
services
or
in
containers
function,
is
running
on
prem
using
one
of
these
great
open
source
server.
A
Let's
compute
platforms
functions
running
and
running
in
the
edge,
so
in
general
this
is
kind
of
what
we
think
the
future
looks
like
how
the
applications
kind
of
combine.
All
these
things
to
produce
outcomes-
that's
still
that's
still
kind
of
unknown,
but
we
do
think
that
this
is
where
things
are
heading.
So
more
events
functions
everywhere,
and
the
next
question
is:
what
is
the
CNSC
F
do
amidst
all
this?
A
If
this
is
where
we
think
things
are
going,
what
is
the
CNCs
role
in
this
world
and
here's
what
we
think
it
is
standards
except
I'm,
not
supposed
to
say
standards
cuz,
the
CNC
F
is
allergic
to
that
word,
so
I
should
have
crossed
it
out.
Harmony's
common
specification
stuff,
like
that.
You
know
what
I'm
trying
to
say
here
so
great.
So
you
know
why
is
this
important
because
in
this
world,
where
there's
events
everywhere
and
functions
everywhere,
developers
just
want
a
single
experience
for
doing
things.
A
They
want
a
single
way
to
deploy
their
function
anywhere.
They
need
to
deploy
it
and
a
single
experience
for
reacting
to
the
event
data.
That's
coming
into
that
function.
If
we
could
do
that,
we
could
solve
a
lot
of
problems
and
make
developers
happy
and
achieve
achieve
this
future
developer
shouldn't
have
to
think
about
the
quirks
of
a
platform
right
now.
A
If
you
want
to
write
a
function
on
AWS
lambda
or
Google
Cloud
functions,
or
maybe
some
of
the
open
source
service
platforms,
the
function
signatures,
look
a
lot
look
different
event:
data,
that's
coming
into
them
all
looks
different.
So,
anyway,
there's
a
lot
of
problems
here,
and
the
next
question
is:
what
do
we
standardize?
What
do
we
sorry
harmonize?
What
are
we
going
to
approach?
A
First,
here's
where
we
see
a
lot
of
disorder
in
service
architectures
runtimes,
even
though
a
lot
of
the
providers
offer
the
same
runtime,
they
have
a
lot
of
quirks
a
lot
of
differences.
Still,
they
might
include
some
different
environment
variables.
Incorporate
libraries
that
are
pre-loaded
already
ap
is
again
the
function.
Signature
problem
is
a
great
example
of
this.
The
the
function
that
you
write
for
lambda
is
not
the
same
as
the
function
you
might
write
for
as
your
functions.
A
Events
everybody's
publishing
events,
but
all
the
event
data
looks
totally
different.
If
you
want
to
find
what
the
event
title
is,
if
you
want
to
find
what
the
event
version
is,
it's
all
in
different
types
of
properties
nobody's
agreed
to
the
to
like
a
consistent
format.
Even
Amazon
publishes
different
formatted
events
from
different
services,
so
they
couldn't
even
agree
on
a
single
event
format
and
then
plumbing.
How
does
this
stuff
get
wired
together?
How
do
we
actually
create
an
event-driven
workflow
where
something
triggers
something
else?
An
event
is
transmitted
in
a
function,
reacts
I.
A
Think
the
C
and
C
F
in
particular,
is
a
great
neutral
ground
to
work
on
these
and
the
service
working
group,
which
has
been
established
in
the
CNC.
F,
has
been
focused
on
doing
this
since
since
January
this
year,
and
it
turns
out
events
were
a
none,
controversial
starting
point
and
we
had
some
injured
interest
by
key
industry
stakeholders,
and
so
we
decided
to
start
there
and
again.
Events
are
super
important
service
is
a
story
of
function
and
functions
and
events.
We
think
that
there
going
to
be
more
events
than
ever
and
ultimately
yeah.
A
You
can
move
your
containers
and
your
functions
around.
You
know
if
you
can
achieve
that,
that's
fantastic,
but
what
are
you
going
to
do
about
that
data?
It's
your
data
that
gets
stuck
and
creates
a
lot
of
lock-in,
so
the
service
working
group
got
together
and
we
decided
to
create
a
specification
for
describing
event
data
in
a
common
way,
and
that
is
cloud
events.
Cloud
events
is
a
standardized
transport,
neutral
definition
of
the
structure
of
metadata
structure
and
metadata
of
events.
Basically,
it's
an
envelope.
A
It
wraps
around
your
event,
data
it
describes
what's
in
it
what's
in
the
event
and
more
details
like
where
it's
going
where
it
has
been
so
that
publishers
of
events
middleware
and
subscribers
can
all
consistently
rely
on
these
properties
to
understand
how
to
better
process
route
version
govern
event
data.
This
is
a
three
weeks
ago.
We
introduced
version
one
of
cloud
events
and.
A
Version
0.1,
sorry
very,
very
early.
Obviously,
it's
been
in
the
works
since
November
of
2017,
here's
a
JSON
representation
of
cloud
events
and
although
JSON
is
not
required
to
use
cloud
events,
this
is
just
representation
of
it
in
JSON
and
it's
got
a
lot
of
great
features
again.
This
is
a
0.1
version.
A
It's
very
early,
but
there's
already
a
lot
of
good
stuff
in
here,
like
just
consistency
in
properties
alone,
is
a
great
achievement,
but
first
off
we
have
a
vent
type,
of
course,
and
you
can
see
the
format
that
were
kind
of
converging
on
here
now.
These
should
be
prefixed
with
a
reverse
dns
name,
which
is
pretty
cool.
So
a
lot
of
lot
of
companies
have
TLDs
for
their
for
their
companies,
so
this
actually
works
in
that
model.
There's
a
vent
type
version.
A
This
enables
kind
of
interpretation
of
events
better
by
eventual
consumers
and
better
evolution
of
event
data.
That's
always
a
huge
problem
in
event-driven
design
is
how
do
you
evolve
that
data
as
it
changed,
changes
and
grows
cloud
events?
Aversion
was
essential
to
making
sure
that
this
whole
effort
was
agile
and
could
be
updated
as
we
continue
to
add
stuff
and
hopefully
not
introduce
any
breaking
changes,
but
it
could
happen
source,
there's
a
URI.
This
describes
the
event
producer.
This
will
include
information
such
as
the
event
source,
the
organization
publishing
the
event
and
some
unique
identifiers.
A
So
but
the
exact
kind
of
semantics
and
syntax
is,
is
up
to
the
event
for
up
to
the
event
producer.
There's
the
event
ID
pretty
self-explanatory,
there's
an
event
I'm
pretty
self-explanatory,
there's
a
schema
URL,
which
is
a
link
to
the
schema
that
the
data
attribute
adheres
to
and
there's
an
extensions
property.
Extensions
was
just
basically
kind
of
this
catch-all
property
where
we
thought
you
know,
we
don't
know
what
people
are
going
to
want
to
do
with
this.
A
Yet,
let's
see
if
we
could
just
put
in
a
way
into
this
event,
format
where
people
can
stick
their
custom
properties
and
let's
see
if
we
can
kind
of
identify
some
common
patterns
from
that
and
if
we
see
anything,
that's
becoming
increasingly
popular,
we'll
consider
promoting
it
to
be
a
first
class
event,
property
and,
lastly,
data.
So
all
this
is
the
envelope.
This
is
what
we
call
the
context
and
this
ships
consistently
with
all
your
events
and
the
data
is
where
you
actually
include
the
kind
of
the
custom
information
about
what
happened.
A
It
could
include
state
of
what
changed
or
it
could
just
include
a
place
or
a
link
where
you
can
go
and
get
information
about
what
happened
and
that's
it.
It's
it's
very
simple.
This
is
a
pretty
a
pretty
small
effort
in
scope.
That
I
think
has
a
lot
of
bait.
Big,
ambitious,
big
ambitions
so
use
cases.
What
can
we
do
with
this
thing?
A
First,
off
normalizing
events
across
environments,
I
talked
about
this
problem
earlier,
not
even
Amazon
can
agree
what
type
of
event
format
it
should
use.
So
that
would
be
great
alone,
so
now
developers
whenever
they're
going
to
write
their
functions,
they
don't
have
to
think
about
the
different
shapes
of
data.
That's
coming
into
those
functions,
facilitating
integrations
across
platforms
integrations
are
everywhere
we're
integrating
a
lot
of
legacy
stuff
with
the
new
stuff,
and
these
integrations
are
increasingly
event-driven.
A
However,
there's
no
kind
of
common
way
to
define
those,
so
this
can
help
out
a
lot
with
that
increasing
portability
of
functions
as
a
service.
Now,
if
you
write
a
function
that
expects
one
type
of
schema,
theoretically,
it's
a
bit
more
portable
than
it
was
when
it
expected
a
different
type
of
schema.
Normalizing
web
looks
web
hooks.
It's
a
common
event,
driven
pattern.
That's
been
around
for
a
long
time.
It's
made.
It's
come
a
long
way
without
without
being
standardized,
but
we
think
this
could
do
a
lot
for
web
ebooks
event:
data
evolution.
A
We
talked
about
that
event,
tracing
being
able
to
trace
events
where
they,
where
they
came
from,
where
they're
going
to
create
more
sophisticated
work
and
solved
that
notorious
observability
problem.
That's
there
with
event-driven
design.
The
future
looks
pretty
awesome.
If
you
like
to
build
things-
and
you
want
to
be
productive,
I
mean
we
could
provision
all
these
functions.
We
could
have
them
reacting
to
events.
We
can
create
incredible
workflows
and
stuff,
but
how
do
you
actually
understand?
What's
going
on
and
observe
all
that,
so
I
think
this
simple
format
can
help
a
lot
with
that.
A
What's
next
for
this,
we
have
the
JSON
event,
format
that
I
just
showed
off.
That
hasn't
actually
been
added,
I,
think
to
the
to
the
spec
there's
HTTP
bindings
that
we're
going
to
add
in
there's
mqtt
3.1
and
5.0
transport,
bindings,
amqp,
1.0
transport,
binding
and
a
web
hook
specification
specifically
for
cloud
events,
so
we
want
to
make
sure
this
thing
integrates
it
in
the
ecosystem
and
a
lot
of
protocols
and
transports
that
people
are
using
already
and
the
most
fantastic
thing
about
this.
A
Is
we
haven't
even
publicized
this
effort,
but
a
whole
bunch
of
people
jumped
on
board
I
think
they
recognized
the
potential
of
this
of
this.
This
small
little
thing
that
we're
doing
here
and
we
have
fantastic
individuals
from
the
service
working
group
working
on
this
from
all
types
of
different
companies.
A
So,
let's
jump
into
it,
we
talked
about
what
this
thing
is
kind
of
how
it
came
about
and
how?
Maybe
it
could
help
out
this
future
that
we're
expecting,
but
let's
actually
see
if
we
could,
if
we
could
do
a
demo
of
that
and
make
it
real.
So
the
everybody
in
the
working
group
has
been
working
for
a
long
time
on
this
demo.
It's
a
big
collaborative
effort
and
it's
certainly
ambitious
again.
It
involves
a
whole
bunch
of
moving
parts.
We're
going
to
keep
our
fingers
crossed
here.
I
pray
to
the
demo
gods.
A
All
right,
let's
explain!
What's
going
on
so
first
off,
we
wanted
to
show
off
interoperability,
because
that's
a
big
mission
of
cloud
events
right,
we're
taking
data
and
we're
giving
it
a
common
format
and
when
it
has
this
common
format,
a
whole
bunch
of
different
subscribers
and
know
what
to
expect
so,
theoretically
could
be
transported
across
environments
a
lot
more
easily,
it's
more
portable,
it's
more
liquid.
So
we
wanted
to
show
off
an
interoperability
demo,
and
this
is
the
scenario
that
we
decided
to
come
up
with.
A
It
starts
off
with
one
publisher,
that's
AWS
and
what's
gonna
happen
in
the
demo,
is
I'm
gonna
upload
an
image
to
AWS
s3
AWS
s3
is
going
to
send
out
an
event
and
it's
a
native
AWS
event
and
that
event
is
going
to
go
to
a
lambda
function
in
that
lambda
function.
That
events,
that
native
s3
event
is
going
to
be
converted
to
a
cloud
event
can
be
transferred
to
transform
to
a
cloud
event
because
obviously
we're
just
getting
started.
Aws
doesn't
support
this.
This
format
and
natively.
A
That's
you
know
that
might
be
a
ways
out
there,
but
there's
easy
way.
Thanks
to
servos
compute
to
actually
modify
this
thing
and
start
using
the
format
right
away,
so
that
s3
event
is
transformed
to
an
s3
cloud
event,
which
is
then
sent
over
to
something
called
the
event
gateway,
and
this
is
a
super
awesome
event.
Router
that
my
company
makes
and
it's
basically
kind
of
what
we
think
is
the
event
router
of
the
serverless
era.
A
You
could
take
any
type
of
event:
data
throw
it
at
it
and
it'll
route
it
to
AWS
lambda
as
your
functions,
Google
Cloud
functions,
cube
lists
any
place
where
there's
a
service
function.
I
think
you
might
have
seen.
Kelsi
Hightower
show
this
off
on
Wednesday.
He
did
a
quick
keynote
presentation
on
it
and
what
the
event
gateway
is
going
to
do.
Is
it's
going
to
take
that
event
that
s3
event
which
talks
about
an
image
that
was
just
uploaded?
A
It's
going
to
send
it
over
to
a
Google
cloud
function
and
the
Google
cloud
function
is
going
to
do
something
with
it,
but
actually
it's
not
just
going
to
send
it
out
to
a
Google
cloud
function.
It's
going
to
send
it
out
to
an
IBM
cloud
function
as
well,
but
at
the
same
time,
it's
also
going
to
send
it
out
to
an
azure
function.
A
An
SI
p
cublas
function
for
functions
now,
but
we
wanted
to
stretch
the
limits
a
bit
further,
so
we
also
added
a
new
Clio
function,
an
awesome
open-source
service
platform,
a
VMware
dispatch
dispatch
function,
another
open
source
platform,
Oracle
FN
function,
another
open
source
platform
and
the
wall
wave
function,
and
we
said
why
stop
there?
We
could
add
more.
So
if
we
added
on
a
Red
Hat,
open,
Wisco,
Red,
Hat,
open
Wisc
running
on
open
shift
function
in
AWS
lambda
function
in
an
Ali
Baba
cloud
function.
A
Okay,
so
the
s3
event
Coast's
into
the
Gateway
it
gets
transformed
to
a
cloud
event
goes
in
the
gateway
and
via
this
pub/sub
pattern
is
broadcasted
to
all
these
functions.
Now
all
these
functions
get
a
event
that
says
hey.
This
object
was
uploaded
s3
and
it's
up
to
these
functions.
To
go
then,
grab
the
image
from
the
s3
bucket
and
do
something
interesting
with
it,
and
so
we
left
it
up
to
these
providers
because
get
this
every
single
one
of
these
providers.
A
Almost
every
single
one
of
these
providers
built
the
function
themselves,
and
we
said
you
know
what
go
do
something
interesting
with
the
photo
a
lot
of
the
functions.
A
lot
of
the
providers
decided
to
do
image
analysis
on
the
photos,
so,
as
a
cool
bonus
of
this
demo,
you're
going
to
see
how
about
like
seven
image,
recognition,
technologies,
compare
against
the
same
image
and
then
we
thought,
okay.
How
do
we
make
this
observable
for
an
audience?
What
do
we?
What
are
we
going
to?
What
are
we
going
to
use
for
this?
A
A
But
why
stop
there?
What
have
we
brought
in
another
event-
source,
Azure
storage,
and
what,
if
we
also
uploaded
an
image
to
Azure,
Azure,
blob
storage
and
all
of
a
sudden
had
an
azure
blob
storage
cloud
event,
which
was
then
sent
over
to
Asher's
event
grid.
Also,
another
amazing
event:
router
built
into
the
azure
platform
and
Azure
event
grid,
then
sends
out
that
Azure
storage
event
in
a
pub
sub
pattern
and
also
sends
it
to
all
these
functions.
A
So
every
single
person
who
wrote
a
function
to
integrate
into
this
demo
I
wrote
the
function
to
react
to
the
AWS
s3
cloud
event
and
the
Azure
storage
cloud
event,
and
you
know
cloud
events
made
that
a
lot
easier
again,
consistency
in
that
event,
data
and
again
so
all
that
that's
coming
from
AWS
s3
all
of
the
event,
that's
coming
from
Azure
storage
and
being
processed
by
all
these
functions.
All
of
this
is
going
to
be
dumped
into
Twitter
if
it
works.
A
A
Ok,
so
far,
so
good,
first
part
of
the
demo
successful.
Let's
go
ahead
and
set
things
up
just
a
little
bit
better
here:
okay,
so
first
off
we're
going
to
start
off
with
Azure
the
azure
event.
Actually
I
have
the
azure
CLI
installed
and
we've
got
some
images
here.
The
first
thing
we're
going
to
send
out
is
a
cat
photo
and
I
already
have
the
the
command
written
in
here.
This
command
is
going
to
upload
this
cat
photo.
That's
local!
A
That's
on
my
local
system
here
up
to
Azure
storage
and
it's
going
to
go
through
that
whole
sequence
that
I
just
described
so
the
upload
happen.
Here's
a
little
kitty,
it's
a
cross-eyed
kitty,
but
it
was
in
the
public
domain,
so
I
thought
yeah,
that'll
work
and
let's
see,
let's
see
how
this,
how
this
shapes
up?
Ok,
so
here
is
our
Twitter
feed.
A
There's
some
test
stuff
going
on
in
here
already
and
I'm
gonna
go
ahead
and
try
and
refresh
this
and
keep
my
fingers
crossed
and
we'll
see
we'll
see
what
these
functions
have
done
with
with
the
cat
photo.
Ok,
we
have
Google
I'm
gonna
refresh
just
a
couple
times
here,
just
to
make
sure
we
get
all
the
events
in
there.
Okay
number
one
we
have
Google
Google
took
the
image
processed
it
and
they
said
I
see
a
kitten
with
crossed
eyes.
It
amazing,
that's
really
well
done.
A
A
We
have
a
Red
Hat
open,
wish
function
running
on
OpenShift
this
just
simply
dumped
it
into
the
Twitter
feed
worked
flawlessly
dispatch
then
went
and
put
on
a
watermark,
their
own
logo
onto
the
cat
photo.
So
there's
your
new
mascot
and
IBM
cloud
function
used
Watson
to
an
out
analyze.
This
and
Watson
thinks
this
is
a
picture
of
a
kitten.
Well
done.
Huawei
cloud
functions
simply
dumped
it
into
the
the
log
here
worked
flawlessly.
A
Aws
lambda
functions,
scanned
the
image
and
use
database
recognition
and
came
up
with
this
as
an
animal
cat
and
kitten
well
done.
Aws
recognition,
here's
a
sure,
an
azure
function
which
use
the
azure
image
analysis
technology,
a
white
cat
with
its
mouth
open
the
same
as
mouths
open,
but
there's
some
of
this
some
white
in
there.
So
that's
that's!
Pretty
good
I'll
still
give
it
to
you.
The
cube
list
is
using
si
P
Leonardo
and
thinks
this
might
be
an
Egyptian
cat.
A
A
But
you
know
yeah,
we
broke
down
the
barriers
between
clouds
and
did
a
pretty
awesome.
Interoperability.
Demo
I
want
to
just
push
the
limits
here,
a
little
bit
further.
Let's
just
let's
just
see,
let's
just
try
out
another
image,
real,
quick.
This
image
was
taken
by
one
of
our
main
contributors.
Clemens
he's
a
fantastic
photographer.
This
is
an
image
of
a
scooter,
I'm
gonna,
upload
it
to
address
storage
again.
That
event
is
going
to
be
sent
out
through
as
your
event
grid
and
we're
going
to
analyze
it.
A
Here's
the
scooter
again,
Clemens
I
forgot
to
give
you
credit
here,
but
but
it's
looking
pretty
sweet
all
right.
So,
let's
give
this
a
few
seconds
here
we
got
nine
new
tweets
that
looks
pretty
good.
Let's
give
it
a
shot.
Let's
see
what
these
functions
have
done.
All
right,
FN
project
says
motorcycle
on
the
outer
box
here,
but
unfortunately
it
says
handbag
on
the
inner
box.
Oh
that's
half
right,
half
right,
VMware,
Dispatch
watermark!
This
flawlessly
Huawei
function.
A
So
distressful
Watson
Asher
says
a
stack
of
Flyers
on
a
table,
but
wait
a
minute.
There
might
be
a
stack
of
Flyers
on
the
table
in
the
background
there,
so
maybe
we'll
give
it
to
him.
Asap
Leonardo
thinks
this
might
be
a
motor
scooter,
scooter
nice
job.
The
open,
whisk
function
dumped
it
in
here
flawlessly.
Aws
recognition
thinks
this
is
a
picture
of
a
motor
scooter
motorcycle
transportation.
All
of
this
worked
out
fairly
well,
not
as
good
as
last
time,
but
but
pretty
cool.
Alright,
that
was
the
Azure
flow.
A
Let's
do
the
same
thing
with
AWS
s3
and
to
do
this
I'm
simply
just
going
to
take
another
image
and
I'm
going
to
dump
it
into
the
UI
here
of
my
s3
bucket
and
I'm
gonna
upload
a
very
important
picture
of
a
spaceman,
but
not
just
any
spaceman.
This
is
this.
Is
you
know
one
of
the
first
men
on
the
moon,
let's
buzz
aldrin,
taken
by
a
neil
armstrong,
and
hopefully,
if
any
of
these
AIS
want
to
become
citizens
of
America
one
day
they
better
understand.
A
Okay,
that
likes
that
looks
pretty
good.
Oh,
we
have
Alibaba
in
the
house
awesome
all
right.
Let's
start
with
this,
Alibaba
I
think
they
all
came
in
Alibaba
image
recognition.
This
is
Alibaba
cloud
function
by
the
way
thinks
this
is
a
picture
of
something
in
Chinese
that
contains
something
else
in
Chinese.
A
So
I
ran
this
through
Google
Translate
according
to
Google
Translate.
This
means
dog,
and
this
means
shovel
so
anyway.
Okay,
credit
for
trying,
ok,
dispatch,
watermark
flawlessly,
while
Wade
opted
drums
dumped
it
in
here
flawlessly
FN
project
person.
Ok,
give
it
to
you
it's
a
strange
looking
person
at
that,
but
teddy
bear
I,
don't
know
about
that.
A
Everyone's
Gary
teddy
bear
to
give
to
kids
open
whisk
function
by
Red
Hat
dumps
it
in
here
flawlessly.
Database
recognition
thinks
this
is
an
astronaut
human
person,
pretty
good
a
dubious
recognition.
Nucleo
says
this:
is
a
gas
mask
only
48
percent?
Sure,
though
so
Watson
says,
this
is
a
picture
of
an
astronaut.
Well
done.
Watson
nice
job
there
sa
P
Leonardo
says
this
might
be
a
snorkel
or
there's
a
snorkel.
In
here
somewhere
Google
says:
I
see
the
landmark
Arches
National
Park.
A
These
are
hilarious,
classifications,
I
should
stop
they're
running
out
of
time,
but
we
have
just
one
more
bonus
and
then
we'll
wrap
it
up
here.
Real
quick,
we're
gonna
help.
Somebody
realize
their
dream.
Today,
this
person
wants
to
be
the
most
cloud
native
person
in
the
world.
His
name
is
Dan
Khan
he's
the
executive
director
of
the
CN
CF
and
we're
going
to
make
that
dream
happen
today.
We're
gonna
send
Dan
Khan
up
to
the
cloud
and
have
him
be
distributed
every
single
cloud
platform
out
there.
A
So
let's
just
do
this
and
and
make
Dan
fulfill
his
inevitable
destiny
here.
So
I'm
uploading,
Dan's
picture
to
s3
going
to
do
the
same
flow
and
the
upload
completed
here
is
what
we're
looking
at
damn
con,
but
we
added
some
sunglasses,
because
when
you're
gonna
be
the
most
cloud
native
person
in
the
world,
you
got
to
look
fly
so
he's
got
some
sweet
shades
on
and
let's
just
see
what
the
results
are
in
here.
I
don't
know
if
Dan's
out
there,
but
hopefully
he
watches
this
and
appreciates
it.
Okay,
the
functions
are
reporting.
A
We
see
some
sneak.
Peeks
in
here
results
are
looking
pretty
good.
Actually,
we've
got
the
Red
Hat
open
with
scope.
Sorry,
the
wall
wave
function,
dropped
it
in
here
flawlessly,
I
know
what
FN
is
doing
here
so
I'm
going
to
skip
that
real,
quick,
the
Red
Hat
open
Wis
function
just
dumped
it
in
here
worked
well
a
Tobias
recognition
thinks
this
is
a
picture
of
human
people.
Person
well
done,
keep
it
general,
that's
safe.
Alibaba
says
this
is
a
picture
of
something
in
Chinese
that
could
save
something
in
Chinese
I.
A
Looked
it
up,
it's
character
that
contains
sunglasses.
So
that's
pretty
good
nice
job,
Alibaba,
nucleophiles,
sunglasses,
94
percent,
sure
it
did
it's
fantastic.
Watson
says
this
person
it's
a
picture
of
a
myope,
not
sure
how
to
pronounce
that
person
with
glasses,
which
yeah
pretty
good,
Watson
well
done,
and
si
P
Leonardo
says
there
might
be
sunglasses,
dark,
glasses,
shades.
Google
says
I,
see
Dan
Cohen.
A
A
That's
pretty
good
nice
work
there
anyway,
Dan
Khan
has
never
been
more
cloud
native
than
he
is
today.
So
all
right
just
to
get
through
this
only
got
a
couple
minutes
left
future.
Where
is
this
stuff
going?
We
have
a
lot
of
ideas
to
add
to
cloud
events
on
tracing
to
help
enable
that
workflows,
make
more
sophisticated
adventures
and
workflows
correlations
so
that
you
could
identify
groups
of
events
via
tags
or
labels.
So
you
could
do
larger
processing
rules,
so
you
could
identify
where
this
event
should
go
where
it
should
not
go
standard
events.
A
You
know
we
think
this
might
be
a
good
opportunity
to
start
creating
some
type
of
registry
or
something
of
common
events,
and
in
this
example
that
we
just
showed
it
kind
of
prompted
this
idea
of
like
what,
if
we
just
made
an
abstract
events
that
was
almost
like
this
object
created
event
that
worked
across
different
storage
platforms.
That's
something
that's
interesting
to
look
into
and
just
a
cool
event
directory.
Overall
again,
we
have
almost
these
universally
unique
event
types
in
the
format:
I.
Don't
what
could
this
lead
to?
A
Maybe
a
directory
of
all
events
on
the
internet,
one
day
who
knows
and
webhooks
better
support
for
for
web
hooks
in
general.
So
anyway,
all
this
stuff
is
cool,
it's
very
kind
of
bleeding
edge
and
neat.
But
how
do
you
actually
use
this
today?
What
can
you
do
with
it?
Well,
actually,
you
saw
all
the
people
working
on
this
there's
a
lot
of
support
for
this
event.
Format
and
these
companies
are
moving
aggressively
fast.
Even
the
big
companies
they're
moving
at
startup
pace.
A
It's
amazing
support
for
all
as
your
platform
events
and
it's
available
today
in
production,
and
you
looks
like
you
can
even
send
custom
cloud
events
into
it
and
it's
in
three
regions,
three
data
centers
right
now
and
it's
gonna
be
rolled
out
globally
next
week.
That's
pretty
awesome!
You
can
start
using
cloud
events
today
with
Azure.
Incredibly
innovative
and
fast-moving
company
super
cool
up.
Next,
we
just
launched
our
host
an
event
gateway.
We
also
have
an
offering
for
this
and
again,
it's
very,
very
focused
on
the
multi
cloud
scenario
and
works
very
well
with
lambda.
A
We
have
a
lot
of
close
integrations
with
a
lot
of
other
lambda
services,
so
you
can
integrate
with
lambda.
You
can
integrate
directly
into
Kinesis
or
redshift
and
azure
functions,
and-
and
we
have
a
lot
more
plans
for
this-
but
this
is
the
event
gateway
uses
cloud
events
by
default.
That
is
its
default
format.
It's
a
completely
open
source.
You
saw
Kelsey,
deploy
it
a
couple
days
ago
and
it
integrates
with
our
service
framework.
You
know
our
service
framework
provides
that
great
application
experience
where
you
have
a
configuration
file
that
lists
functions
and
each
function.
A
You
just
write
the
events
that
trigger
that
function.
The
framework
will
go
provision
all
the
infrastructure.
You
need
upload
your
business
logic
on
top
of
that
and
wire
it
up,
so
that
it
works
together,
but
you've
always
been
limited
to
platform.
Events
like
all
the
events
on
AWS,
for
example,
but
now
with
the
event
gateway
and
its
support
in
the
framework
you
can
put
in
all
types
of
custom
events
in
there
and
literally
get
closer
to
reacting
to
anything
easily
with
code.
A
So
if
you
want
to
check
it
out,
service.com
slash
event
gateway
and
that's
a
wrap.
If
you're
interested
in
cloud
events
check
out
cloud
events,
do
there's
github.com
slash
cloud
events
which
has
contribution
information.
We
meet
every
Thursday
at
9
a.m.
we
do
a
call.
Then,
if
you
want
to
chat
with
me,
I'm
austin
collins
on
twitter-
and
I
just
want
to
give
a
round
of
applause
thanks
to
the
scene
staff,
but
especially
the
service
working
group.
The
people
in
these
front
rows
who
made
it
happen.