►
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
Going Beyond the Node – Using VK to Realize Crazy Ideas - Brian Goff, Microsoft & Deep Kapur , Microsoft
Virtual-kubelet is an open source kubelet implementation that allows users to extend Kuberentes in multiple, crazy ways. A couple examples include, a provider to order Dominos pizza, or to spin out workloads to a satellite in space. This talk will go through the inner workings of virtual-kubelet (vk) and how users can build their own providers to leverage the flexibility that vk offers. Contributors to the virtual-kubelet have been working on new features past 1.0, this talk will also give a roadmap of what’s to come. Azure will also share their experiences with writing a provider for virtual-kubelet and the use-cases associated with it.
https://sched.co/Uag3
A
A
So
yeah
today
we're
gonna,
learn
about
virtual
couplets,
we'll
go
over
some
basics
first,
but
then
we're
gonna
get
pretty
deep
into
the
code.
So
you
can
kind
of
understand
how
why
it's
useful
and
how
you
can
actually
make
use
of
it
and
then
hopefully,
also
if
you
like
it,
then
you
can
you'll,
be
it
shouldn't,
get
ribbiting
to
the
project
and
we'll
talk
about
that
a
bit
as
well.
Okay,.
B
So
we're
gonna
start
out
by
talking
a
little
bit
about
what
a
couplet
actually
is
quick
show
of
hands.
You
do
you
know
what
a
Googler
it
is.
Okay,
this
is.
This
is
meant
to
be
like
a
mid
tier
talks.
You
better
know
now
I'm
kidding
I'm
going
to
go
into
just
a
little
bit,
so
you
guys
have
an
understanding
of
sort
of
basic
understanding
that
we
can
build
on.
So
Google
is
an
agent
that
runs
on
each
node
in
your
cluster.
B
It's
responsibility
is
to
make
things
actually
run
on
that
node,
and
so,
when
you
come
to
your
kubernetes
cluster
and
you
you
want
to
deploy
a
pod,
the
cupid
is
the
one
that's
actually
responsible
for
communicating
with
the
container
runtime
underneath
and
running
that
pod
for
you.
So
in
order
to
do
this,
the
first
thing
that
Google
does
is
it
registers
a
node
with
your
actual
API
server
with
your
kubernetes
cluster.
So
with
a
cool
bit
here
with
on
a
node,
that's
named
TARDIS
reaches
out
the
server
says:
hi
I'm
a
node.
B
So
now,
when
you
as
a
user,
come
to
your
cluster
and
want
to
deploy
an
actual
pod
or
set
of
containers,
you
come
with
your
pods
back
your
pod
specification
and
the
scheduler
looks
around
and
says:
oh,
it
looks
like
TARDIS.
The
node
has
some
space
on
it,
so
why
aren't
I
scheduled
this
particular
pod,
the
TARDIS,
so
the
pods
back
is
now
updated
to
effectively
say
that
it
needs
to
run
on
a
node
named
TARDIS
and
so
in
the
meanwhile.
B
What's
actually
happening
is
your
cubed
on
that
node
is
consistently
watching
for
pods
that
are
coming
in
that
are
apparently
supposed
to
be
running
on
TARDIS.
So
it
sees
this
new
pod
specification
come
in
with
a
new
pod
that
needs
to
run,
and
so
it
picks
it
up
and
looks
around
on
the
node
to
say:
hey.
Actually,
this
this
part
isn't
running
yet,
and
so
we
need
to
reconcile
the
state
with
what's
expected
from
the
user,
with
what's
actually
happening
on
the
node.
So
what
do
we
do?
B
We
actually
deploy
this,
so
the
Google
communicates
with
the
container
on
time,
underneath
so
maybe
CRI
and
deploys
the
container.
So
it's
actually
happening
here
is
that
the
the
Cooper
is
able
to
abstract
away
both
to
contain
at
around
time,
as
well
as
the
concept
of
the
node
away
from
the
cluster.
So
now
that
you
know
what
it
can,
what
a
Kubu
actually
is
Brian.
Why
don't
we
talk
a
little
bit
about
our
chocolate
right.
A
So
virtual
couplet,
first
of
all,
it
is
not
the
couplet
like
there's
a
lot
of
people.
Ask
me:
oh,
is
this
part
of
entry
whatever?
No,
it's
not
injury.
It's
a
totally
separate
project
Coupole,
it
doesn't
use
our
stuff.
We
use
some
stuff
in
couplet,
but
it's
not
the
couplet,
but
what
we
do
is
take
some
of
the
functionality
that
couplet
is
responsible
for
and
kind
of
make
it.
So
you
can
take
that
as
a
library
and
run
with
it.
So
you
can
abstract
away
the
container,
runtime
and
stuff
yourself.
A
B
A
You
create
a
pod,
it
says:
oh,
this
is
supposed
to
go
to
virtual
couplet,
let's
go
ahead
and
do
that
and
so
virtual
couplets
watching
the
API
server
for
pods
assigned
to
it
and
then
it
goes
ahead
and
says:
oh
I
have
a
pod
I
need
to
go
ahead
and
create
that
pod
and
so
yeah
really
quick.
That's
how
a
couplet
works!
That's
how
it
works,
real
good
that
works.
Nice.
B
Virtual
Cooper
today
is
a
project
that
does
exist
and
github
you're
welcome
to
go
to
the
link
whenever
you
get
a
chance.
So
today,
we've
got
five
core
main
dinners
from
Netflix
Microsoft
VMware.
The
latest
release
actually
ship
five
days
ago.
It
may
or
may
not
have
had
to
do
with
the
demo
that
we're
about
to
show
you
cannot
total
arm
it.
There's
six
official
providers
in
the
repo
itself
that
are
linked
to
that
you
can
take
a
look
I'll,
be
talking
a
little
bit
more
about
the
providers
later
on.
B
In
this
conversation,
we
also
have
several
more
unofficial
ones
again,
some
may
or
may
not
have
been
conceived
for
the
sake
of
this
talk
and
some
of
the
demos
that
we're
going
to
show
you
as
you'll,
find
out
it's
currently
a
sandbox
project,
we're
working
towards
getting
it
incubation.
The
last
time
we
talked
about
BK
in
depth
was
at
cube
con
over
the
summer.
Shanghai.
Actually,
that's
a
lie.
The
last
time
we
talked
about
BK
was
yesterday
Thank,
You,
Daria
and
sargon
for
their
talk
yesterday.
B
But
since
the
summer
few
different
things
we
want
to
call
out,
there
were
three
major
releases:
it
actually
1.0,
that's
a
pretty
big
deal
because
it
meant
that
we
stabilized
a
bunch
of
the
interfaces.
The
providers
moved
outside
the
organization
tree
and
now
consume
decays
of
library.
So
Brian
will
talk
a
little
bit
more
about
what
it
means
to
consume.
Bk's
of
library
we
had
a
bunch
of
bug,
fixes
we
introduced
support
for
graceful
par
deletion,
etc,
etc.
B
A
So
what
is
a
virtual
could
look
like
so
first,
it's
a
library
that
you
take
an
import
and
you
make
it
do
interesting
things.
Some
of
things
that
it
provides,
are
the
two
basic
components
that
it
provides.
Our
a
node
controller
and
a
pod
controller.
I
have
some
pretty
words
later
that
you
can.
If
you're
looking
at
the
slides
later,
you
can
actually
see
the
explanations,
but
so
no
controller
is
responsible
for
doing
that.
Hi,
I'm,
a
node
and
registering
itself
and
keeping
itself
kind
of
in
the
cluster.
A
Otherwise,
if
you
just
register
it
and
say
bye,
then
kubernetes
will
delete
your
node
it'll
go
not
ready.
So
yeah
register
is
a
node.
Then
you
have
a
pod
controller
and
the
pod
controller
is
responsible
for
watching
for
nodes
that
have
been
or
watching
for
pods
I've
been
scheduled
to
that
node
and
making
sure
that
that
it's
actually
running
those
are
the
green
parts.
The
orange
parts
are
kind
of
what
you
provide,
so
we
have
a
node
provider.
We
kind
of
just
have
this
default
new
provider
that
you
can
use.
A
That
doesn't
really
do
anything
other
than
exists
and
we
take
care
of
the
rest
or
you
can
choose
to
implement
your
own
and
basically
the
idea
there
is.
If
you
have
a
nodes
status
update,
then
you
will
go
ahead
and
notify
the
no
controller.
Oh
there's
a
status
update.
We
need
to
send
this
off,
but
otherwise
we
just
make
sure
this.
The
status
is
properly
taken
care
of
it
supports
node
leases,
which
is
an
alpha
API,
as
well
as
just
regular
node
status
updates.
Likewise,
for
the
pod
controller,
we
have
a
pod
provider.
B
A
Thank
you
see
a
bunch
of
import
statements,
so
so
we're
gonna
consume
virtual
Kubla
as
a
library
to
create
a
a
thing
that
will
run
itself
as
a
node
and
run
pods
on
a
cluster.
So
where
we
got
here
is
first
I
kind
of
loaded
this
up
to
serve
so
I
could
pull
staff
like
debug
stats
out
of
it.
When
I
was
testing
stuff,
it's
nothing!
Then
we
set
up
logging.
A
We
make
it
so
that
we
can't
when
so.
Everything
in
virtual
Kubla
kind
of
depends
on
context
that
you
pass
in
to
the
runtime.
When
the
context
is
canceled,
we
quit
the
runtime,
so
we
want
to
make
sure
the
runtime
shuts
down
properly
when
we
get
kill
signals.
So
we
go
ahead
and
set
up
a
context
for
that.
A
We
set
up
a
new
kubernetes
client
using
a
passed
in
config
koop
config
file.
We
pulled
a
node
name
off
of
because
it
doesn't
matter
what
the
node
name
is.
We
just
need
to
specify
one,
so
we
pull
that
out
of
environment
as
well.
Now,
for
the
next
thing
we
do,
is
we
go
ahead
and
create
a
pod
in
former
factory?
Now,
what
a
pod
informer
is
is
it's
a
cache
for
whatever
objects
you
are
wanting
to
watch.
A
So
when
things
happen,
the
pod
informer
is
automatically
updated
and
you
end
up
getting
a
notification
saying
that
something
changed.
The
cache
should
generally
always
be
up-to-date.
It's
a
nice
thing
you
know
have
to
deal
with
the
kubernetes
client
go
kind
of
deals
with
that.
The
main
thing
with
the
pot
Informer
here
is:
we
are
specifying
a
specific
filter
for
this,
so
we
are
only
caching
pods
that
are
assigned
to
our
node.
A
Then
we
go
ahead
and
create
the
pod
Informer
and
then,
since
we're
also
interested
in
other
things,
like
secrets,
config,
Maps
and
services,
because
pods
need
those
things
and
they
do
things
like
inject
those
in
through
download
API
and
all
that
fun
stuff.
We
have
to
pull
those
in
as
well.
Only
we
don't
care
about
no
name
there,
because
that
stuff
isn't
a
sight
to
notes.
A
We
have
an
event
broadcaster,
because
the
core
runtime
does
send
a
couple
events,
but
mostly
we
expect
a
provider
to
to
make
events,
because
it's
just
there's
more
going
on
inside
the
provider
than
in
a
quarter
on
time,
and
then
we've
got
some
nasty
things
so
I'm
not
planning
on
open
sourcing.
This
I'm!
Sorry,
because
I
don't
want
anybody
to
run
this
ever
it's
a
security
hole.
Just
don't
do
it.
You
will
see
you
later
so
yeah.
Some
context
for
that
is
this.
A
Is
a
provider
that's
going
to
run
on
my
macbook
pro
connecting
to
a
cluster
in
a
KS
and
what's
gonna
happen?
Is
this
is
going
to
run
container
images?
I
won't
call
them
containers
because
they're
they're
not,
but
we
take
the
image
and
execute
them
and
inside
the
image
is
a
statically
compiled
macit.
What's
binary
well,.
A
A
We
create
the
pod
controller,
so
the
pod
controller
just
needs
these
clients
and
pod
informers
and
and
critically
their
provider,
and
likewise
we
go
ahead
and
create
a
node
controller,
and
with
that
we
also
have
to
create
a
node
spec,
so
the
spec
can
be
literally
whatever
you
need
it
to
be.
You
can
see
here,
I'm
grabbing
the
number
of
CPUs
on
the
system
that
the
that
go
is
reporting
and
then
I
just
pulled
numbers
for
memory,
storage
and
max
number
of
pods
that
will
be
scheduled
to
it.
A
These
are
just
used
for
kind
of
soft
limits
that
the
KU
scheduler
uses
to
not
over
subscribe
to
node,
and
then
we
also
have
to
make
sure
all
our
conditions
are
correct.
If,
if
our
conditions
aren't
you
know
ready
or
whatever,
then
kubernetes
won't
schedule
to
it,
you
can
of
course,
customize
this
to
actually
query
real
things
and
figure
out
if
these
things
are
actually
ready
and
how
much
space
is
available
and
all
that
fun
stuff,
and
so
we've
got
a
patent
former
factory
and
regular.
A
The
other
informers
that
go
ahead
need
to
get
started
up
so
that
they
start
sinking
pods
and
and
all
that
fun
stuff,
and
then
we
go
ahead
and
start
up
the
pod
controller.
So
so
this
is
actually
where
the
runtime
fires
up
they're,
the
first
half
of
the
runtime.
So
what's
gonna
happen
here
is
inside
this
go
routine.
We're
gonna
run
some
some
reconciliation
loops
to
make
sure
that
our
pods
that
are
scheduled
are
in
sync,
with
pods
that
are
actually
running
or
not
or
not
running.
A
So
we
wait
for
the
boot
up
for
that
to
be
ready
or
for
things
to
have
gone,
horribly
wrong
and
canceled
out,
and
we
we
fatal
out
once
we
know
that
everything's
ready,
we
go
ahead
and
fire
up
the
node
and
at
this
point
kubernetes
will
be
able
to
schedule
to
our
node
in
your
mind.
What's
that
your
Mac,
let's
ooh
my
Mac,
it's
not
it's
hardly
a
node,
so
I
will
show
you
that
part
a
little
bit
later.
I
think
it's
time
to
talk
about
the.
What
actually
is
a
provider
yeah.
B
So
let
me
really
quickly
define
the
provider
for
you,
and
then
we
can
talk
a
little
bit
about
what
that
looks
like
by
turning
is
Mac
effectively
into
an
extension
of
a
cluster
but
main
things
for
you
to
know
number
one.
It
has
to
provide
the
plumbing
to
support
the
actual
pod
life
cycle,
as
well
as
the
supporting
resources
and
whatever
infrastructure
you
choose
to
extend
your
kubernetes
cluster
with
so
in
this
case
his
laptop,
but
in
other
cases,
whatever
infrastructure
you
so
choose
to
make
your
deployment
more
extensible
more
flexible
within
your
Cabrini's
cluster.
B
There
was
an
interesting
way
to
describe
this
I
heard
yesterday
from
Sargon.
That
I
really
liked
was
that
you
effectively
transforming
a
declarative
model
in
your
kubernetes
cluster
into
an
imperative
one
that
is
now
flexible
to
whatever
infrastructure
you're,
actually
choosing
to
deploy
things
into
so
uvk
becomes
a
way
in
which
you
you
take
your
kubernetes
cluster
and
effectively.
You
can
do
anything
with
it.
It
turns
it
into
just
the
control
plane
where
now
you
have
a
fully
flexible
data
plane.
B
Of
course,
that
also
means
it
must
conform
to
the
current
particular
API
surface
and
so
needs
to
use
a
well-defined
set
of
callbacks
to
get
status,
as
well
as
data
across
the
board
to
the
kubernetes
cluster,
because
we
don't
want
direct
access
to
the
API
server
from
wherever
that
infrastructure
is
actually
running.
Why
don't
you
actually
show
them
how
that
code
runs?
Nothing
you
think
about
so
far
into
it
sure.
A
So
first
I'll
go
over
the
kind
of
the
provider
interface
here
is
they're,
just
basic,
create
delete
things.
So
when
virtual
couplet
sees
that
a
pod
is
created
or
lead,
we
just
go
ahead
and
call
this
we'll
do
some
extra
things
like
fill
in
some
downward
API
things,
but
for
the
most
part
we're
just
you
know
determining.
A
A
A
A
Macbook
creat
keyboards
love
them,
okay,
so
they're
basura!
Yes,
alright!
So
you
can
see.
I've
got
a
couple
of
things
here.
So
one
of
the
things
that
happened
is
kubernetes
tried
to
schedule
a
bunch
of
stuff
to
us,
because
I
didn't
set
things
up
as
expected,
so
we
tried
to
set
up
two
Browz
on
the
on
the
node
that
doesn't
exist.
So
all
that
stuff
failed,
but
that's
fine.
A
A
A
B
A
It
looks
just
like
a
regular
node
or
a
regular
pot.
Rather
I
can
do
things
like
I
can
manually,
terminate
it.
I
can
delete
it
from
kubernetes
and
oh
get
terminated
or
I
can
just
go
ahead
and
kill
eight
seven,
eight
seven
three,
and
with
that
we
should
be
getting
some
so
we'll
see
some
logs
here
that
some
stuff
happened
container
exited
and
we
should
see
okay,
sweet,
we
got
exit
codes,
negative
one
and
that's
actually
nice.
Some
things
you
can
customize
is
kind
of
these
Status
Messages
or
whatever.
A
A
A
You
can
kind
of
see
what
what
does
a
matte
container
look
like
yeah
I
mean
there
we
go
originally
I
was
gonna
use
at
root,
but
apparently
you
can't
root
with
a
unprivileged
user
and
by
the
way
this
is
running
on
privilege,
which
is
kind
of
cool,
so
I
got
rid
of
the
two
root
and
added
a
dots
to
the
front
of
the
command
to
execute
it
in
their
proper.
So
we
changed
the
directory
and
then
just
make
sure
it's
not
executing
slash.
It's
doing
that.
A
So
it's
local,
so
yeah,
that
is
my
crappy
container
runtime.
One
of
the
things
here
is
notifying
of
pod
status
updates,
so
we
kind
of
have
two
modes
of
operating.
You
can
so
we
have
a
sink
and
not
a
sink.
So
non
async
is
kind
of
the
old
way
I
wish
we
didn't
put
in
1.0,
but
we
did
what
happens
in
this
case.
Is
we
kind
of
see
that
you're,
not
an
async
provider,
and
we
just
kind
of
run
this
loop
that
asks
every
five
seconds?
What
pods
do
you
have?
A
What
are
the
statuses
of
the
pods
and
we
have
to
go
and
determine
if
you
need
a
pod
status
update?
And
it's
really
it's
not
bad
for
just
a
couple
of
pods.
But
when
you
have
you
know
hundred
pods,
that's
really
terrible.
So
we
changed
over
to
have
this
async
notification
model
where
we
pass.
We
tell
the
provider
hey
when
you
get
a
pod
status,
update,
call
this
function,
and
so
that's
what
we're
doing
here.
A
We
make
a
copy
of
our
internal
pod
state
and
send
that
up
to
virtual
couplet
and
when,
when
it
receives
that
it
sends
the
status
update
to
kubernetes
so
in
inside
here
we
actually
don't
have
any
there's,
no
kubernetes
client
or
anything
like
that.
The
provider
just
has
a
bunch
of
pod
States
content
store
for
this
is
for
storing
images
from
that.
We
pull
and
notify
function
that
gets
passed
down
on
startup
and
some
basic
pod
state,
so
yeah
in
general.
It's
relatively
easy
to
make
to
destroy
my
laptop
so
yeah
and.
B
Just
not
breaking
your
laptop
yeah,
whatever
it
is
really
so.
Why
should
you
build
a
provider
right
so
number?
One
main
thing
we'd
like
to
talk
about
is
that
it
gives
you
this
abstraction
away
from
the
concept
of
a
node
that
you're
used
to.
So
you
can
now
extend
this
cluster
to
done
anyway.
So
here
we
ran
it
on
a
Mac.
We
have
a
lot
of
customers
that
I
a
whole
bunch
of
more
interesting
things.
B
For
those
of
you
that
were
sargans
talked
yesterday,
you
heard
about
how
they
use
it
at
Netflix,
with
their
infrastructure
called
Titus.
But
the
idea
is,
you
can
dig
this
queries.
Cluster
use
it
as
your
surface,
your
control
plan
for
deploying
applications
to
your
infrastructure,
which
could
be
nodes
that
are
in
VMs
and
wherever
you're
running
your
kubernetes
cluster.
It
could
be
anything
else
it
could
be.
His
mac
would
not
recommend
but
yeah.
So
that's
the
main
thing
other
than
that.
It
gives
you
with
those
infrastructures
a
way
to
have
more
granular
resource
consumption.
B
So,
for
example,
one
of
the
products
we
have
in
Azure
is
called
as
your
container
instances.
So
the
purpose
behind,
as
your
container
instances
or
ACI,
is
effectively
to
deploy
pods,
on-demand
or
just
container
images
on
demand
and
when
you
deploy
those
pods
you're
only
consuming
the
resources
required
for
that
part.
Specifically,
so
you
define
how
many
cores
you
need
and
how
much
memory
you
need
for
that
part
and
that's
the
resource
you
consume.
B
That's
the
resource
you
pay,
for
which
that
means,
if
you've
got
a
kubernetes
cluster
running,
and
you
want
to
spin
up
pods
on
demand,
but
you
don't
want
to
pay
for
an
entire
VM
in
Azure
or
pay
for
setting
up
a
server
or
you
want
to
buy
Brian's
Mac
off
of
him
whatever
you
have
that
set
of
options
or
you
could
just
go
and
deploy
a
pod
and
just
pay
for
the
resources
that
that
you
need
for
that.
It
also
unlocks
a
bunch
of
hybrid
scenarios.
B
So
we've
got
people
using
this
where
clusters
are
either
running
in
the
cloud
or
on-premise
and
are
extending
in
one
way
or
another.
If
you
can
get
the
networking
right,
it
also
allows
you
to
then
have
a
bunch
of
h.a
deployments.
It
allows
you
to
deploy
things
on
the
edge
so
with
really
really
small
machines.
B
Additionally,
in
the
case
of
private
networking
or
setting
up
the
cube
proxy
or
whatever,
so
every
semester
choose
to
use
or
l7
routing,
you
want
to
set
up
across
those
different
places,
not
necessarily
the
most
trivial,
but
certainly
achievable.
One
question
that
came
up
a
lot
when
we
were
building
the
provider
for
a
CI
was
what's
the
max
node
resource.
Do
we
just
set
it
at
infinite
because
you
can
just
deploy
as
many
as
you
want,
then?
What
stops
the
scheduler
from
putting
everything
onto
a
CI,
then?
B
What's
the
point
of
having
you
work,
you
know
it's
like
all
of
these
things
sort
of
come
into
play
where
you
have
to
be.
You
have
to
be
a
little
bit
more
deliberate
about
how
you're
actually
placing
things
inside
the
cluster
and
educate
your
cluster
to
do
the
things
in
a
way
that
you
expected
to
are
supposed
to
be
caught
off
guard,
and
so
we
settled
on
setting
like
dozens
of
course
and
like
some
terabyte
memory
effectively
and
then
using
paints
and
tolerances
within
all
IKS
clusters.
B
That's
as
your
community
service
clusters
did
not
automatically
put
everything
on
a
CI
print.
Instead,
the
poem
OSHA
lead
to
worker
notes,
if
available
and
then
deliberately
deploy
out
a
CI
when
needed
other
than
that.
Versioning
you'd
now
have
a
virtual
Cooper
version,
as
well
as
the
kubernetes
version.
We
figured
out
some
ways
around
that
happy
to
take
feedback
if
you've
got
better
suggestions
on
that
monitoring,
pods
as
well.
So
a
lot
of
people
look
to
VK
is
a
way
of
dynamic
scaling
for
pods.
B
B
That's
helping
you
scale
these
pods
out,
but
if
you
move
to
more
flexible
infrastructures,
you
may
not
have
the
notion
of
something
that
can
run
on
the
host
and
we
don't
support
the
notion
of
a
demon
set
in
in
virtual
Google,
because
it's
effectively
like
infinite
notes
that
are
actually
backing
up
like
this
single
node
sort
of
concept
or
node
extension
in
your
cluster.
So
you
should
do
some
tricks
as
well.
B
We
currently
try
to
come
as
close
as
we
can
to
note
aggregation,
so
we
aggregated
all
the
metrics
of
the
containers
coming
through
that
particular
VK
instance,
and
aggregate
them
and
send
them
back,
didn't
open,
still
stuff
we're.
You
know
looking
to
improve
it
and
figure
out
on
so
we've
got
a
pretty
good
set
of
providers
so
far,
so
some
familiar
names
and
logos
up
here,
you
can
take
a
look
at
these
more
in
depth
on
our
github
page,
but
yeah
I'm
gonna
show
you
guys
a
little
bit
more
on
the
HCI
side
of
things.
B
So
that's
the
azure
ACI
connector
that
we
have
a
provider
that
we
have
to
set
the
stage
for
that
sort
of
just
so
you're
aware.
The
idea
is
that,
as
I
was
describing,
you
sort
of
have
pods
on
demand,
so
your
VK
instance
at
your
cluster
or
we
even
have
an
add-on
to
a
PS
clusters,
called
virtual
nodes
that
you
can
just
sort
of
add
an
extension.
B
A
B
Think
things
should
be
good,
so
I
mean
okay.
Somebody
was
complaining
about
this
yesterday,
Joey.
Where
are
you
it's?
Okay
now
so
I'm
inside
my
kubernetes
cluster,
you
can
see
there's
a
bunch
of
pods
that
are
currently
running,
so
these
actually
map
to
virtual
cubelets
that
are
identified
for
specific
regions.
So
you
see
Australia,
East,
East,
US,
Japan,
east,
north
Europe
and
West
US
and
and
what
I've
effectively
done
is
just
set
up
virtual
ku
boots
that
are
pointed
to
different
geographic
regions
and
getting
to
go
around
Asia
into
those
regions.
B
I've
got
this
really
cool,
front-end
I!
Don't
want
you
to
think
of
this
as
an
end
solution.
I
want
this
more
that
sort
of
spark
your
thoughts
when
it
comes
to
how
can
I
use
communities
or
virtual
cooperate
to
have
geo
distributed
deployments
demands
deployments
on
demand.
Different
parts
of
the
world
just
have
an
extensional
extensible
for
the
back
and
not
be
limited
by
the
fact
that
everything
needs
to
run
in
one
place,
whether
that's
for
security
reasons
or
networking
reasons
or
infrastructure,
availability
yeah.
B
So
I've
got
these
regions,
this
map
sort
of
zooms
out,
and
you
can
see
all
the
places
where
I've
got
these
little
hotspots
and
currently
nothing's
deploy
for
those
of
you
that
in
the
room
and
are
smarter
than
I
am
you've.
Also
looked
at,
the
top
of
the
browser
is
seen
that
this
endpoint
is
not
secure.
You're
welcome
to
go
to
it
if
you
want
and
start
pressing
these
buttons,
but
the
idea
is
effectively
that
I'm
gonna.
Do
this
a
more
programmatic
way?
If
you
actually
do
this
yourself,
you're,
probably
gonna.
B
Do
this
in
an
automated
way,
will
you
look
at
incoming
requests
and,
and
you
can
trigger
them
using
teens
in
tolerances
to
actually
go
somewhere?
I
see
somebody
entering
the
IP
address
nice,
but
I'm
effectively.
Just
gonna
do
a
few
and
you're
gonna
see
and
then
I'll
skip
a
bunch
more,
but
I'm
gonna
start
with
one
in
just
Wes
u.s.
so
effectively.
What
should
happen
is
you
should
see
a
deployment
starting
ECG
or
demo
Wes,
you
guys,
so
that's
VK
is
trying
to
spin
up
an
ACI
deployment
in
that
particular
region.
B
Oh
I
should
have
also
shown
you
this.
You
can
see
that
the
virtual
nodes
is
set
up
for
each
of
these
regions
and
the
way
it
sort
of
azure
does
things
with
the
communities
cluster.
Is
you
have
this
like
hidden
resource
group
that
actually
contains
all
the
things
that
are
required
for
kubernetes
to
run
in
this
resource
group?
In
a
couple
of
seconds,
you
actually
see
the
a
CI
resource
pop
up
boom.
Okay,
somebody
else
click
West
us
as
well.
B
B
Okay,
I
just
did
a
bunch
yeah,
let's
see
what
okay
yeah
lots,
lots
coming
and
yeah.
So
if
I
click
into
this
like
very
soon
you'll
start
to
see
okay,
so
four
and
each
of
us
have
already
come
up
to
one
North,
Europe,
sorry
up
somebody
yelled
Australia
Australia
once
already
up
and
there's
a
bunch
on
the
way.
So
as
I
continue
to
click
on
these,
that
number
used
to
be
two.
It's
now
five,
this
number
you
should
be
for
I.
Think
now
it's
eight
so
yeah!
B
You
can
start
to
see
that
this
is
giving
up
really
really
quickly.
That's
because
that's
what
a
CI
specialized
for
and
so
you're
able
to
leverage
that
inside
of
your
kubernetes
cluster,
without
necessarily
extending
everywhere
and
now
in
that
backing
resource
group.
You
can
see
here
the
ones
that
are
deployed
in
Australia
lots
in
Australia,
some
in
East,
US,
Japan,
etc.
Yeah
sorry
I
want
this.
B
You
need
them
to
be
in
any
infrastructure
that
you
want
them
to
be
in
and
use
this
as
a
tool
to
enable
workloads,
whether
they're,
service
or
on-premises
or
anywhere,
in
a
way
that
that
solves
the
problems
that
you
actually
haven't.
Delivering
production
scale,
production
grade
workloads
for
your
company
for
yourselves
for
your
customers
and
and
generate
the
business
value.
They're
awesome
I'm,
going
to
switch
back
to
the
slides
nice.
A
A
If
you
get
an
error
on
and
create
pod,
we
would
be
able
to
report
some
metric
that
something
happened,
that
kind
of
stuff
one
thing:
building
a
few
providers
now
I've
noticed
is
there's
a
lot
of
shared
code
and
between
providers
or
at
least
shared
concepts,
so
building
some
sort
of
helpers
for
for
actually
building
a
provider.
So
you
don't
have
to
do
a
lot
of
rigorous
code
to
do
things
like
how
do
you
turn
a
pod
into
a
bunch
of
containers
with
the
right
settings?
And
you
know
crazy
stuff,
like
that.
A
The
other
thing
is
a
little
bit
more
crazy,
but
maybe
not
is
kind
of
a
run
timeless
model
where,
instead
of
you
spinning
up
a
runtime,
you
create
the
runtime.
So
we
provide
all
the
helpers
and
you
run
the
four
loops
and
basically
enabling
us
to
allow
you
to
inject
whatever
behavior
you
need
to,
rather
than
have
to
have
a
specific
extension
points.
A
B
Want
to
say
that
somebody
definitely
hopped
on
this
and
helped
me
because
I
just
ended
up
doing
160
instances
and
I
definitely
didn't
click
160
times,
but
it's
pretty
cool
that
we
were
able
to
schedule
across
all
those
regions
in
like
the
3-4
minutes
and
we've
been
watching
but
anyway,
so
we're
about
to
wrap
up
main
things
about
again.
That's
the
github
repo
go
check
it
out
go
help
us
contribute,
there's
a
slack
channel
that
you
should
join.
We
have
community
meetings
every
other
week
on
Wednesdays
at
11
a.m.
A
A
B
Sure
so
we
do
some
of
this
for
the
ACI
provider
specifically
as
well,
and
so
part
of
it
is
that
when
you
deploy
resources
in
a
different
infrastructure,
they
come
with
different
networking
settings.
They
don't
always
map
back
to
what
you
have
set
up
in
your
kubernetes
cluster.
It
may
mean
that
it's
coming
up
in
a
different,
vennett
and
I
need
to
find
a
way
in
which
you
can
actually
communicate
over
a
private
Internet
across
this
to
v-net.
So
in
Azure
we
have
the
technology
called
V
net
peering.
That
enables
us
to
do
this.
B
Other
things
that
you
can
do
is
actually
introduced
a
new
subnet
and
make
sure
wherever
your
infrastructure
is
running,
is
actually
part
of
the
same
V
net,
and
it's
just
a
point
in
a
different
subnet
with
the
right
IP
spacing
you
can
also
solve
for
that.
The
other
thing
we
wanted
to
do
is
make
sure
we
had
q
proxy
compatibility,
and
so
we
actually
deploy
something
alongside
the
pod
in
a
CI.
B
Whatever
foreign
infrastructure
it
may
be,
it
might
be
that
the
infrastructure
you
choose
may
not
support
those
things,
and
it's
kind
of
the
caveat
is
that
and
sure
that
you
think
about
these
things,
because
it's
gonna
be
one
of
the
big
problems.
You
don't
know
if
you
haven't,
and
so
I
just
want
to
make
sure
that
that's
a
deliberate
thought.
It's
it's
part
of
your
planning
process
and
you
ensure
that
you've
got
a
path
for
the
things
you
actually
need.
You
don't
have
to
solve
all
the
cases
like
a
lot
of
VA
implementations.
B
C
C
There
any
intention
to
upstream
this
in
any
way
and
if
you
look
at
what
a
real
real
couplet
is,
it's
a
battle-tested
virtual
couplet
with
a
provider
for
Linux.
Essentially
the
core
Kubb
is
moving
that
direction.
Largely
right.
Controller
managers
have
become
virtual
CCMS,
with
a
provider
storage.
Any
attention
to
do
that
here
too,.
A
So
we've
definitely
brought
this
up
to
like
sick
node
and
what
have
you
at
least
even
like
pulling
it
into
the
kubernetes
project
and
like
there's,
there's
things
to
to
kind
of
work
out
there,
and
certainly
one
of
the
things
that
we
really
need
to
do
is
like
get
a
real
node.
Implementation
like
like
I,
have
cried
container
d
available,
but
it's
not
done
and
run
that
through
no
conformance
and
that
kind
of
stuff
to
kind
of
prove
out
the
runtime.
A
To
make
sure
it's
solid
in
terms
of
like
you
know,
could
the
could
the
couplet
import
VK
instead
of
some
of
the
stuff
that
they
they've
been
hacking
on
I?
Don't
know
that
even
makes
sense
to
do
that,
but
yeah
it
there's.
Certainly
nothing
preventing
outside
of
technical
discussions
and
and
non-technical
discussions.
I'm
like
just
making
make
things
happen.
Cool.
B
I
think
with
that
we'll
take
a
close
I've
got
a
bunch
of
stickers
here,
thanks
to
Rhea
who's
sitting
at
the
back.
If
you'd
like
a
virtual
couplet
sticker,
please
come
up
and
grab
one
for
me.
If
you
have
any
additional
questions,
please
come
up
and
see
us
we'll
be
here
for
a
while.
Thank
you
so
much
for
coming.