►
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
Intro: Virtual Kubelet - Ria Bhatia, Microsoft & Anubhav Mishra, HashiCorp
Virtual Kubelet has most recently been accepted into the CNCF as a sandboxed project. In this session we will go through the benefits of the project and the landscape of providers that contribute to VK in the open. We will highlight the HashiCorp Nomad provider and the Azure provider for Azure Container Instances. Folks can expect to learn about three different use-cases for Virtual Kubelet including, burst capacity, abstraction of infrastructure, and translating any APIs into Kubernetes APIs. We hope to spark new ideas, and conversation by bringing up a new way to connect Kubernetes to "any" service or technology.
https://sched.co/MPin
A
Hello,
hi
everyone,
so
we're
gonna
go
ahead
and
get
started.
It
is
our
introduction.
The
virtual
couplet
thanks
for
coming
out
I,
have
one
question:
how
many
of
you
guys
have
actually
tried
virtual
ku
butter
used
it
nice,
okay,
great
so,
for
the
majority
of
you,
this
will
be
really
helpful
and
even
for
the
people
that
have
used
it
before
we
have
some
cool
things
to
show
off.
So
in
the
next
slide,
no
I
can
do
it.
Okay,
so
my
name
is
Rita
Bhatia
I'm,
a
program
manager
at
Microsoft.
A
That's
my
twitter
handle
I
am
currently
a
maintainer,
a
core
maintainer
of
virtual
cubelet.
So
we've
done
some
governance
things
in
the
next
one
dotto.
So
we
have
a
difference
between
provider,
maintainer,
x'
and
then
core
maintainer
x',
I'm
in
the
upstream
team,
and
that's
my
new
rescue
pup,
her
name's
rue.
She
came
from
to
taiwan
like
two
weeks
ago,
so
I
just
wanted
everybody
up
there,
because
I
think
she's
really
cute
alright.
B
A
So
virtual
couplet,
this
is
our
fancy
logo
and
we
did
a
little
like
we
basically
voted
or
on
github
for
logoed,
maybe
a
little
making
you
in
one
day,
I,
don't
know,
that's
what
happened
so
a
little
bit
of
history
and
we
open
sourced
it
in
2017,
and
this
project
actually
started
out
a
little
bit
before
that
as
something
called
the
ACI
connector
and
it
was
just
for
Microsoft.
We
realized
that
this
was
probably
a.
A
We
could
solve
a
lot
more
problems
by
making
it
pluggable
and
making
an
open
interface,
so
anyone
could
create
providers
from
virtual
couplet
and
that's
exactly
what
we
did
at
KU
con
Austin
two
years
ago,
so
I
think
yeah
2017
December
is
when
we
ended
up
releasing
it,
we're
also
in
the
CNC
f
as
a
sandbox
project.
So
this
happened
about
I,
don't
know
six
to
eight
months
ago.
A
We're
really
excited
to
be
part
of
the
CNC
F,
there's
a
lot
of
support
that
we
get
from
them,
and
then
we
also
get
to
come
here
and
do
these
fun
talks
with
you
guys.
So
a
little
bit
more
history
on
the
ACA
connector
was
the
first
version
of
virtual
Kubla.
It
was
actually
written
in
typescript.
It
was
Brendan
Burns's,
baby
pet
project,
we've
revamped
everything
with
a
bunch
of
people
at
Microsoft,
a
bunch
of
different
teams
in
Microsoft,
and
we
actually
tried
to
create
this
culture
of
open-source
kind
of
just
within
our
company.
A
So
you
know,
Microsoft
is
huge
and
we
kind
of
stay
within
our
own
realm
of
teams
and
that
what
virtual
kuben
allowed
us
to
do
was
actually
reach
out
to
CDA's
and
other
teams
within
Microsoft
to
help
us
build
this.
So
that
was
really
cool,
I'm
part
of
product.
So
it
was
awesome
to
see
that
happen,
but
then
past
that
it's
awesome
to
see
that
continue
on,
and
now
we
have
a
huge
community
past
Microsoft
actually
like.
A
We
have
a
couple
people
in
Microsoft
working
on
this,
but
really
it's
like
the
providers
that
are
pushing
this
through
and
everyone
else
and
we're
1.0.
So
we
went
one
dot.
Oh
we're
going
one
dot
o
this
week.
What
that
means
for
you
guys
is
that
it
is
stable,
we're
stabilizing
the
interface.
So
we
won't
change
much
in
the
interface
without
telling
you
basically
and
that's
for
our
users.
So
now
users
can
be
sure
and
they
can
feel
confident
that
our
core
interface
is
stable.
Now
each
provider
isn't
at
maybe
a
1
dot
o
level.
A
Yet
so
that's
different.
If,
depending
on
what
provider
you're
using
if
you're
using
Microsoft's,
we
are
like
GA,
but
if
you're
using
Fargate,
for
example,
they're,
probably
still
in
preview
or
other
ones,
so
you
have
to
look
at
which
provider
you're
using
with
virtual
couplet,
but
you
can
be
sure
cert
in
that
core
has
stabilized
and
we've
also
done
a
lot
of
work
around
governance.
So
we've
figured
out
how
our
relationship
works
with
providers
we
figured
out
who
our
core
maintainers
are.
A
B
So
that
was
a
bit
a
bit
of
a
background
on
kind
of
the
project,
but
it
is
now
we
have
via
100,
which
is
super
nice
now
I'm,
going
to
dive
into
some
of
the
kind
of
the
intro
level
stuff
like
which
what
couplet
is
what
it
stands
for?
Maybe
talk
about
the
providers
a
little
bit
so
in
order
to
understand
that
I
want
to
do
a
quick
like
kind
of
intro,
of
like
the
kubernetes
architecture,
who
here
like
knows
kubernetes
architecture
in
the
inside
out,
there's
decent
amount
of
people.
B
Great
I
was
gonna,
call
someone
upstate
and
like
up
on
stage,
and
they
can
talk
about
it,
but
no
I
won't
do
that.
I
won't
put
you
on
the
spot,
so
yeah.
This
is
probably
the
quickest,
like
architecture
overview
that
you've
heard
for
communities
is
going
to
be
super
quick,
as
it's
not
relevant
for,
like
everything
is
not
relevant
in
in
in
the
stock.
So
yeah
we
talk
about
kind
of
the
API
server,
the
kubernetes
api
server,
that's
responsible
for
kind
of
storing
and
creating
and
retrieving
api
objects.
B
These
objects
might
be
pass,
the
objects
might
be
a
deployments
or
services
or
any
object
any
CRD.
You
store
that
in
using
the
api
server
and
that's
what
the
users
use
and
that's
what
other
kubernetes
components
inside
kubernetes
use
as
well.
Then
you
have
the
the
kind
of
the
scheduler,
which
is
very
much
what
the
name
is.
It's
a
scheduler.
It
Maps
the
set
of
workload
to
a
set
of
resources.
B
So
in
a
cluster
you
might
have
you
know,
100
CPUs
and
you
know
200
gigs
of
ram
or
something
the
scheduler
actually
Maps,
that
maximum
maps
of
workload
to
a
set
of
resources
which
might
be
a
node.
And
then
you
have
the
controller
manager
which
is
responsible
for
kind
of
the
control
loops
in
the
in
the
cluster.
B
To
keep
a
certain
set
of
controller
is
a
certain
set
of
actions
happening
during
during
the
course
of
the
kind
of
the
cluster
scheduler
and
then
there's
the
the
actual
stateful
component,
which
is
EDD,
which
is
the
kind
of
the
main
database
where
everything
is
stored.
So
the
API
server
interacts
with
HCDE
and
stores
and
I
think
kind
of
helps
it
retrieve.
Some
of
these
objects
and
then
on
the
other
side,
we
have
the
nodes.
B
The
nodes
are
running,
something
called
the
cubelet,
and
this
is
where
we
kind
of
zoom
and
zone
into
the
kind
of
a
couplet
and
where
virtual
cupola
kind
of
fits
in
so
couplet
is
responsible
for
a
lot
of
different
things.
I
think
yeah
we'll
go
into
the
kind
of
the
depth
of
like
what
all
it
does.
It
does
a
lot
of
different
things,
but-
and
it
just
is
basically
responsible
for
registering
a
note.
So
when,
when
a
node
comes
up,
the
cubelet
process
starts
it
fingerprints,
the
node.
B
It
figures
that
okay,
you
have
two
CPUs,
this
much
RAM.
Let
me
register
you
to
the
kubernetes
cluster
and
does
that
for
you
and
then
there's
other
components
like
the
proxy,
but
we
won't
go
into
it
and
you
might
also
be
running
things
like
Damon,
like
a
doctor,
Damon
or
something
on
the
node
which
the
couplet
also
fingerprints
and
registers
with
the
kubernetes
api.
Now
we
won
in
into
kind
of
the
kind
of
zoom
in
into
sorry
into
the
KU
blade
portion.
B
So,
as
I
said,
the
couplet
is
is
the
one
that
does
a
lot
of
different
things.
You
know
some
of
these
things
might
be
like
you
know,
making
sure
certain
set
of
pods
are
running
on
the
node
making
sure
you
know
certain
volumes
are
being
mounted
to
a
certain
part
and
so
on.
So
what
you
could
basically
register
itself
like
like
a
couplet,
so
it
basically
behaves
like
a
node.
B
Almost
it
is
like
a
node
and
then
it
basically
implements
a
series
of
functions
that
the
couplet
implements
and
then
it's
basically
fake
node
and
in
a
kubernetes
cluster,
and
it's
it
to
what
it
is.
It
really
is
just
a
program
that
you
can
run
inside
the
cluster
outside
the
cluster.
If
you
have
access
to
the
kubernetes
api
outside
the
cluster,
you
can
run
it
outside
the
cluster
and
then
register
itself,
and
then
the
API
server
says
oh
you're,
a
node.
It
just
registered
it
as
registers.
A
Okay,
so
I'm,
when
we
started
virtual
couplet,
we
have
to
look
into
what
a
node
was,
and
this
is
kind
of
what
we
figured
out
and
notice
the
static
size.
You
have
to
figure
out
how
many
pods
have
to
go
into
a
node.
It
has
a
standard
capacity.
There
are
things
that
the
pods
get
from
the
node
inherently
and
then
it's
also
a
single
falta
main,
so
that
was
also
a
consideration
to
make.
If
the
node
goes
down,
everything
on
that
node
will
go
down.
A
Kubernetes
will
try
and
reschedule,
but
if
you
don't
have
enough
nodes
in
your
cluster,
the
node
is
the
single
like
it
is
the
baseline
for
all
of
your
workloads,
and
this
is
what
the
control
loops
look
like.
So
we
have
asynchronous
control
if
you
have
synchronous
control
loops,
and
this
was
something
an
early
design
of
what
we
had
for
virtual
coolant.
So
we
were
like
we
need
to
create
all
of
these
control
loops
to
actually
be
conformant
to
what
a
node
is
in
kubernetes.
A
We
haven't
actually
gone
through
the
conformance
testing
in
kubernetes
to
figure
out.
If
for
a
node,
I
don't
know
if
we
really
need
to
because
customers
aren't
really
asking
us
for
it,
but
what's
important
to
note
is
that
we
started
over
here,
so
we
started
with
getting
container
logs.
We
started
with
getting
images
and
deleting
deleting
them
and
then
also
like
starting
the
container
itself.
So
what
virtual
cool
it
was
allowed
us
to
do
was
basically
extend
kubernetes,
extend
those
api's
to
a
different
service
and
we'll
go
through
some.
A
What
that
means
in
a
second
too
so
I
first
wrote
couplet,
basically,
is
a
concept
of
pods
and
nodes
in
that
abstract.
We
have
this
concept
of
an
abstract
node
when
you
install
virtual
coolant
into
into
your
cluster,
so
you'll
have
a
bunch
of
nodes
and
then
you'll
have
this
kind
of
fake
node.
It
doesn't
actually
have
boundaries
for
capacity.
It
doesn't
have
boundaries
for
CPU
or
memory.
Your
networking,
or
anything
like
that,
it's
literally
a
string
that
we're
passing
through
to
Cooper
Nettie's
and
we're
like
this
is
a
node
registered
like
a
node.
A
Now
the
fun
the
fun
stuff
happens
when
you
actually
start
to
create
pods.
So
when
you
create
a
pod-
and
you
schedule
it
to
that
node-
that's
when
we
do
the
work
of
reaching
out
to
a
different
API
on
whether
it's
an
API
and
Amazon
and
API
and
Microsoft
and
API
at
Domino's-
that's
a
pizza
place
and
then
that
API
will
basically
take
that
request
and
process
it
in
the
way
that
it's
supposed
to
process
it.
A
So
it
might
not
it'll
create
a
pot
in
kubernetes,
but
what
it's
doing
the
backend
could
be
creating
a
pod
in
a
different
data
center
in
a
different
cloud,
possibly
or
it
could
be
registering
that
pod
and
ordering
you
a
pizza
from
dominos,
there's
a
lot
of
different
things
you
can
do
with
virtual
coublon.
It
doesn't
just
have
to
be
the
concept
of
creating
containers.
It
can
do
a
lot
of
other
things,
so
why
about
virtual
couplet?
So
yeah,
it's
flexible!
It's
a
flexible
abstraction!
A
If
you
have
an
idea
for
what
you
want
to
do
in
kubernetes
and
kubernetes
doesn't
support
it
today,
you
could
possibly
make
it
happen
with
virtual
couplet
and
we
have
a
lot
of
different
use
cases.
So
we
have
this
really
cool
use
case
for
bursting
and
on
demand
capacity.
For
example,
if
you
have
a
bunch
of
it's
an
example
I
like
to
give
all
the
time,
but
basically,
if
there
is
a
hurricane
say
in
Barcelona
I'm
a
meter
reading
company
and
I'm
trying
to
read
all
the
meters
and
all
these
different
buildings.
A
I'm,
probably
gonna
need
more
capacity
in
that
instant
because
it's
a
random
like
a
vet
that
just
happened.
I
wasn't
prepared
for
it.
So
you
have
to
ramp
up
your
capacity
for
otoku,
but
it
allows
you
to
not
have
to
have
that
capacity
directly
in
your
cluster.
You
can
basically
ask
for
it
on
demand,
depending
on
the
service.
A
That's
backing
you
up,
which
is
pretty
cool,
and
then
we
have
some
other
interesting
use
cases
like
high
availability,
so
you
can
put
a
virtual
Kubla
in
different
regions
and
then
you
suddenly
have
high
availability
within
your
cluster
I'm,
not
working.
You
might
not
work,
but
we
can
work
through
that
IOT
edge
use
cases
and
alternate
couplets.
So
you
can
have
a
virtual
couplet
that
spins
out
to
Windows
or
a
different
OS
and
one
that
spins
out
to
Linux
all.
B
Right,
so
where
is
the
magic
right
like
what
this
is
a
lot
of
text
here
right
and
so
what
what?
What?
What
does
like?
Where
does?
Where?
Does
it
get
interesting
for
a
user
of
our
developer?
Who
is
interested
in
using
virtual
couplet
right
so
so
the
provider
interface
is
basically
where
it
gets
interesting.
So
the
problem
for
the
provider
interface
itself
kind
of
allows
you
to
use
virtual
cubelet
framework
that
that
that's
written
that's
open
source,
that's
the
the
the
kind
of
the
big
project,
so
the
provider
interface
has
a
lot
of
different
functions.
B
These
are
some
of
the
functions
that
you
might
see
the
create
function,
the
update
function,
the
delete
function.
They
get
get
pod
function,
you
might
you
might
want
to
satisfy
most
of
them,
but
there's
some
functions
that
you
you
can't
satisfy.
Given
the
target
platform,
for
example,
the
Domino's
pizza
case,
I,
don't
know
like
there
might
be
some
functions
that
you
can't
support
support
in
that
one
use
case.
But
the
idea
here
is
to
kind
of
once
you
satisfy
this
interface
you're
able
to
use
the
widget
cook
that
framework
and
then
be
able
to
schedule.
B
B
There's
a
other
list
of
things
that
we
kind
of
now
have
as
part
of
a
last
in-person
meeting
that
we
did,
which
kind
of
gives
you
a
good
guideline
of
like
what
other
things
that
you,
you
would
need
to
kind
of,
submit
an
official
provider
basically
and
then
you
do
not
have
access
to
the
kubernetes
api
server
using
virtual
cubelet.
So
let
for
example,
you
want
to
get
secrets
and
do
things
like
mount
volumes.
B
A
And
so
yeah
we
have
a
bunch
of
providers
in
virtual
couplet.
You
can
pick
and
choose
which
ones
you
want
to
use
and
install
them
in
your
own
cluster.
But
in
this
case
we
today
you
can
spin
out
to
a
CI
as
your
container
instances.
You
can
spin
out
to
aw
AWS,
far
gate
and
then
Nomad
Domino's,
Mesa
I
see
edge
and
a
bunch
of
others
that
I
have
on
this
slide.
So
we
also
have
Hawaa
way.
We
have
Alibaba
as
your
batch
and
yeah
I,
CRI
and
stuff
like
that.
A
So
if
you
want
to
use
any
of
these
in
any
kind
of
cluster,
so
if
you're
in
Google
or
Amazon,
you
can
pick
up
any
of
these
or,
if
you're,
an
on-prem,
and
now
you
can
spin
out
to
these
kinds
of
clouds,
which
is
pretty
cool.
Okay,
so
the
IOT
edge
use
case.
This
is
might
be
self-explanatory,
but
it
might
not
be.
But
basically
you
can
mask
virtual
kulit
and
make
it
look
like
a
node.
A
But
if,
for
example,
if
he
wants
to
turn
on
a
light
in
this
room,
you
could
spin
out
a
node,
it
would
start
and
then
it
would
turn
on
a
light.
If
you
wanted
to
update
the
pod,
you
could
update
it
with
a
new
Hamel
and
then
it
would
maybe
change
the
light
color
for
example.
So
that's
an
example
of
how
you
could
use
IOT
edge.
You
can
actually
go
into
your
physical
environment
or
you
could
spin
out
to
your
microwave.
A
We
had
some
people
talking
about
how
they
wanted
to
use
kind
of
scenarios
like
this
to
spin
out
to
satellites,
so
they
wanted
to
connect
satellites
to
their
kubernetes
clusters
and
they
wanted
each
node
to
look
like
a
satellite
I'm.
You
could
kind
of
do
that
actually,
and
then
you
have
one
common
API
to
work
from
instead
of
working
from
something
else,
if
you're
familiar
with
kubernetes
and
this
this
is
the
Microsoft
use
case,
so
I'm
from
Microsoft,
so
I'm
gonna
plug
that
one
too.
So
the
virtual
node.
A
We
call
it
virtual
node,
it's
GA
today
in
Azure,
but
basically
you
have.
You
can
have
a
bunch
of
VMs
in
your
cluster,
but
if
you
need
on-demand
capacity
or
compute
or
you
want
to
burst
out,
you
can
use
a
CI.
Is
that
kind
of
safety
mechanism
to
burst
out?
It's
also
like
you
pay
per
second
and
that
sort
of
stuff.
So
that's
also
cool
use
case.
I
know,
Amazon
has
a
similar.
One.
Alibaba
actually
also
has
a
similar
one.
A
So
a
lot
of
us
have
this
similar
use
case
of
just
bursting
out
into
compute
the
way
that
you
would
use
virtual
cubelet
and
actually
schedule
out
to
it
is
through
these
toleration,
so
we've
tainted
virtual
coolant
and
what
that
means
is
we
basically
have
a
lock
on
it.
You
can't
schedule
anything
to
this
node
and
we've
done
this
because
we
think
think
it.
We
think
it
makes
it
easier
for
customers,
because
you
don't
want
to
randomly
get
scheduled
out
to
something
that
you
don't
know.
A
We
also
can
use
these
affinity,
rules,
anti
affinity
and
affinity
rules
to
say
that
we
prefer
different
nodes
in
our
cluster,
so
in
this
case
we're
actually
preferring
the
nodes,
the
actual
nodes
in
our
cluster
versus
virtual
couplet.
So
this
will
allow
you
to
fill
up
the
nodes
and
then
burst
out
into
VK.
A
A
Okay,
this
is
the
cool
part.
So
we
have
this
graph
on
a
dashboard
and
what
we've
done
here
is
we've
used,
first
of
all,
couplet
to
be
able
to
burst
out
into
it.
So
we
have
to
note
two
pods
reading
in
our
cluster
by
ourselves
and
then
we
have
19
pods
running
in
a
CI.
So
what
we've
done
is
we've
spun
out
a
bunch
of
load
to
the
cluster
itself
and
a
bunch
of
requests,
and
we
are
basically
we're
scaling
on
custom
metrics.
A
So
what
that
means
is
we're
using
requests
per
second
and
that's
the
all
of
the
requests
per
second
to
the
entire
cluster
and
we're
calculating
it
per
pod,
and
once
we
get
to
ten
requests,
we're
scaling
out
another
pod.
So
this
these
are
all
kubernetes
concepts
that
we're
using
to
auto
scale
and
tasty
I,
which
is
pretty
nice.
You
can
also
see
our
response
time.
So
this
is
how
you
know
it's
working.
A
So
our
response
time
went
up,
so
it
was
really
slow
to
get
back
to
people
because
we
didn't
have
enough
capacity
in
our
cluster.
We
jumped
back
down
when
we
got
a
bunch,
a
note,
a
bunch
of
pods
in
our
cluster
ramped
up
and
they
were
actually
contributing
to
getting
all
those
requests
and
those
were
the
pods
in
a
CI
so
that
our
response
time
jump
back
down.
So
that's
what
you
want
to
see.
B
Now
we
have
another
demo
which
is
live
so
hopefully
the
demo
gods
are
with
us
today.
Otherwise
we
will
stay
in
this
room
until
I
fix
the
demo,
and
then
we
leave
so
alright.
So
here
I
have
a
kubernetes
cluster,
so
I
do
get.
No
it's
hopefully
I
do
have
it
still.
Yes,
I
do
have
a
kubernetes
cluster
of
two
notes.
Right.
We
have
to
work
up
rules.
This
is
actually
running
on
digital
oceans.
Manage
service
shout-out
to
them.
I
just
wanted
to
use
do
something
some
day
or
the
other.
B
This
is
one
of
my
bucket
list
things.
So
I
did
that.
So
we
have
two.
The
two
node
cluster
super
scalable,
of
course
cuz
two
nodes
in
there
between
schedule,
whatever
we
want
on
it.
So,
let's
schedule
something
on
it.
So
here
I
have
a
simple
engine:
X
pod,
so
I'll
open
this
up
here,
I
was
simple
engine
export.
There
is
no
trigger
in
here,
there's
no
Taine's
as
well,
which
which
we
are
talked
about
on
purpose.
I
just
wanted
to
keep
things
super
simple.
B
Nginx
and
hopefully
this
works
and
I
do
coop
CDL
get
pods
it's
pending
pending
pending,
which
is
not
a
good
thing,
and
it's
running
now,
which
is
great,
so
this
the
I'm
just
by
the
way.
This
is
not
the
demo
I'm
just
making
sure
the
cluster
works
is
that
okay,
yeah,
that's
okay,
so
yeah
that
so
you
you
are
like.
Why
is
he
showing
us
how
to
use
kubernetes?
We
know
that
already
so,
okay,
so
that
was
just
to
check
the
bit
less.
B
B
Was
great
okay,
so
the
so
the
so
the
cluster
works
and
that's
it
that's
that's
all
I
know
I
don't
have
more
stuff.
Okay!
So
now,
let's,
let's
inspect
one
of
the
nodes
right.
So
let's
do
a
describe
node
on
one
of
the
worker
pool.
So
this
is
one
of
the
nodes.
Let
me
actually
grab
one
of
the
real
nodes
here.
Oopsie
do
I
get
notes
and
then
let's
do
coop
CTL
describe
node
and
then
the
node
name.
So
here
you'll
notice,
like
the
node
itself,
has
some
stuff
running
on
here.
B
So
this
is
all
the
solutions
by
default
they
run
see
Liam
and
things
like
that.
You'll
see
some
of
the
capacity
things
here
like
how
much
how
much
CPU
is
allocated
and
allocate
allocatable,
and
then
we
have
a
few
of
the
events
and
stuff.
So
here
you
see
like
we
have,
we
have
about
20
CPUs
available
and
then
100.
It
gives
you
memory.
I
think
this
is
the
wrong
wrong
way.
I
guess
I'm
definitely
listing
the
wrong
node
hold
on
a
second
here.
B
B
B
Okay,
so
here's
the
capacity
so
there's
the
one
CPU
I'm
apologize:
okay,
one
CPU
and
and
the
storage
and
and
the
memory,
and
that
these
many
parts
right
so
that
that's
kind
of
the
the
gist
of
it.
So
now,
what
we'll
do
something
interesting
will
actually
make
one
of
these
nodes
unavailable
in
kubernetes
and
I'll.
Show
you
and
I'll
talk
about?
Why
we're
doing
that.
So,
let's
do
coop
CTL
get
nodes,
so
who's
used
the
in
command
in
kubernetes.
B
That
allows
you
to
kind
of
just
market:
okay,
sweet,
so
coop,
CDL
Gordon,
and
what
this
does
is
basically
makes
one
of
the
nodes
unschedulable.
So
the
scheduling
is
disabled
on
one
of
the
notes.
So
now,
if
I
create
another
part,
it
won't
land
on
this
one,
but
instead
will
land
on
the
other,
the
other
node.
So
now,
what
do
you
think
would
happen
if
I
actually
schedule
a
lot
of
workload
if
this
is
just
a
cluster
with
two
nodes
and
like
one
CPU
and
a
bunch
of
bunch
of
memory?
B
So
let's
see
I'll
run
engine
X
pods
many,
which
has
many
engine
exports
and
I'm
not
using
deployments
on
purpose.
I
just
want
to
show
you
the
simplest
form
of
thing
because
it
says,
like
I,
don't
know
how
many
18
engine
exports.
So
let's
schedule
this
right,
it's
a
cube,
CTO
apply
and
then
do
this
alright,
so
we
scheduled
eight
and
now
we
do
get
pods
and
they
should
you're
only
going
pending,
well
they're,
all
running
I!
Wonder
why
they're
running
so
now.
B
Actually
the
what
has
happened
here
is
like
what
I
tricked
you
in
in
thinking
that
the
the
other
node
was
like
kind
of
part
of
the
part
of
the
digitalocean
managed
service,
but
other
node
was
actually
a
virtual
copilot
right
and
it's
masking
another
scheduler.
So
where
did
these
pods
are
where
these,
like?
These
workloads
actually
running
if
we
switch-
and
hopefully
this
does,
okay,
where
we
go
one?
Second,
no
one
saw
that.
B
Okay
here
we
go
so
they're
actually
running
on
nomads,
so
on
a
different,
completely
different
scheduler,
but
you're
still
using
you're
still
using
the
same
kind
of
definition
that
you
see
on
the
kubernetes
set.
So
if
I
open
the
Yama
file
I
can
which
we
loved
looking
at
these
llamo
files.
Here
we
go
so
here:
it's
like
there's
nothing
different
about
this
llamo
file
to
kind
of
schedule
it
here
and
that
I'm
not
using
any
tolerances
or
anything
just
to
keep
things
simple,
so
just
to
show
you.
B
B
It's
actually
a
pretty
clean
interface
and
I
think
this
is
one
of
the
things
that
I
felt
like
was.
Is
it
interesting
because
you're
using
two
schedulers
right
like
this,
is
I'm
just
showing
you
like
an
the
extensibility
of
VK?
It's
not
in
many
cases.
This
does
not
make
sense.
So
do
not
you
know,
do
this
in
production
all
the
time,
but
for
a
particular
use
case
it
might
make
sense.
B
If
you
only
want
to
use
a
nomad
for
batch
scheduling,
then
you
know
you
can
still
use
the
same
common
interface
to
interact
with
it
if
you're
used
to
kubernetes-
and
you
want
to
use
that
you
can
do
that
too.
It's
super,
flexible
and
I.
Think
one
of
the
things
I
want
to
point
out
is
like
just
my
personal
experience
of
building
the
provider.
B
It
literally
took
me
like
I,
think
I
spend
it
was
my
Christmas
project,
so
I
spent
like
the
four
or
five
hours
at
night
after
we
had
dinner
to
work
on
this
and
I
was
able
to
get
to
kind
of
you
know
from
zero
to
something
and
then
I
spend
a
few
more
times.
A
few
few
more
hours
that
kind
of
going
through
some
of
the
docks
and
and
finish
the
provider.
So
it's
a
fairly
easy
thing
to
kind
of
get
started
so
I
think
it's
very
easy
to
write.
B
A
B
So
in
that
case
you
see
that
gets
translated
into
a
task
group.
The
nomad
scheduler
kicks
in
again
schedules
it
into
a
nomad
client,
and
that
starts
the
process.
So
that's
kind
of
the
kind
of
flow
of
events
for
those
of
you
ever
interested.
So
that
was
the
the
cool
demo
I'm,
not
saying
your
demo
wasn't
cool
about
that.
But
that
was
an
interesting
demo
and
thank
you
for
coming
to
our
talk
and
there's
another
deep
dive
session
that
Jeremy
and
and
they're
doing.