►
From YouTube: VMware Enterprise PKS Overview
Description
VMware Product Manager Merlin Glynn provides an architectural overview of VMware Enterprise PKS.
VMware Enterprise PKS delivers enterprise grade Kubernetes with complete automation, backed by vSphere data center resources as well as public cloud services, to enable modern public cloud application development and delivery in the the Private Cloud.
For more information visit:
https://cloud.vmware.com/pivotal-container-service
A
Hi
I'm
Roland,
Glen
and
I'm
a
product
manager
here
at
vm
here
at
VMware
and
today,
in
this
light
board,
we
are
gonna
talk
about
a
PKS
overview.
What
is
PKS
are
pivotal
container
service.
It's
a
main
goal
that
we
have
a
PKS
as
we
want
to
offer
self-service
of
kubernetes
at
scale
and
I'm
gonna
use
kate's
is
the
abbreviation
previous
of
kubernetes,
and
this
is
gonna.
Give
our
customers
the
ability
to
have
an
agile
development
process
in
place,
so
they
can
rapidly
deliver
business
goals
and
business
value
as
quickly
as
possible.
A
So
we're
gonna
start
with
the
developers.
You
know
there's
a
lot
of
personas
that
we
built
PKS
for
but
one
of
the
key
personas
the
developer,
and
what
does
she
use
a
little
set
of
classes
to
describe
the
developer
and
we
want
to
be
able
to
offer
the
service
to
more
than
one
developer,
so
we're
not
talking
about
one
developer
but
developers
or
development
teams
or
DevOps
teams.
So
the
key
thing
that
we
want
to
give
them
is
kubernetes
right,
so
we
want
to
give
them
a
kubernetes
cluster.
A
And
we
want
to
offer
the
access
to
that
cluster
in
a
way
that
they
are
familiar
with
using.
So
we're
gonna
use
cute
cuddle
to
represent
this
in
the
whiteboard,
but
we
could
just
as
easily
be
talking
about
the
communities
API.
So
our
goal
is
to
offer
these
development
teams
access
to
our
kubernetes
clusters
in
a
way
that
they're
used
to
consuming
them
to
deliver
application
value.
Now,
one
of
the
ways
we're
going
to
do
that
is
we're
gonna,
give
them
a
new
tool.
It's
gonna
be
a
pretty
simplistic
tool.
A
A
A
And
we
want
to
be
able
to
offer
that
cute
cuddle
experience
to
all
three
of
them
for
all
our
development
teams,
so
be
able
to
run
applications
on
kubernetes
to
be
able
to
really
get
business
value
out
of
this
Yee.
You
also
need
to
have
a
lot
of
other
key
services,
one
of
those
other
key
services
that
must
exist
as
you
need
a
place
to
store
your
images.
A
You
need
a
registry
of
some
sort,
so
we
have
VMware
Harbor,
which
is
an
open
source
implementation
of
docker
registry,
as
well
as
some
other
key
services
like
Claire
for
CVE
scanning
and
notary,
so
that
we
can
even
do
image
signing.
So
we
can
ensure
that
there's
a
degree
of
validity
to
our
images
that
we're,
storing
and
pulling
and
we're
going
to
be
able
to
offer
that
store
and
pull
experience
so
be
is
something
like
the
docker
CLI,
which
is
another
tool
that
our
development
teams
are
already
familiar
with.
A
You
can
do
a
push
or
or
most
importantly,
when
we
need
to
actually
run
our
images.
We'll
need
to
do
a
pull
in
chart
various
kubernetes
clusters,
so
pkas
is
offering
this
key
harbor
registry
service.
In
addition,
when
we're
running
our
applications,
this
is
not
just
a
place
to
run
them
in
kubernetes
and
a
place
to
store
our
images,
but
we're
gonna
need
access
to
external
services,
and
some
of
the
services
can
expose
themselves
in
different
ways.
So
one
of
the
one
of
the
concepts
that
we
offer
with
PKS
will
have
a
catalog
API.
A
And
this
will
be
behind
the
kubernetes
experience,
so
the
developer
would
still
be
accessing
all
this
through
the
cube,
cuddle,
API
or
through
the
cube,
cuddle
command
lit
or
through
the
kubernetes
api,
so
that
this
catalog
api
experience,
we
can
actually
offer
something
in
the
backend
via
something
we
call
oz
bappy,
which
is
the
open
service
broker
API.
We
can
actually
offer
services
from
key
platforms
like
GCP
or
other
third-party
services.
You
know
so
far.
A
Applications
need
things
like
a
message
store
or
persistent
data
external
from
the
clusters
or
some
place
to
store
analytical
data
or
stream
logging
information.
We
can.
We
can
expose
that,
via
this
catalog
API,
all
through
a
consistent
development
experience
through
the
kubernetes
api
through
cube
kettle.
Now
it's
not
just
about
external
services,
but
you
also
need
to
have
networking
security.
A
Declaratively,
meaning
I
can
write
a
Yambol
structure
that
says
how
my
firewall
should
be
deployed
for
a
certain
application
or
how
that
application
should
be
exposed
in
a
load.
Balancer
set
and
I
can
do
all
that
through
the
kubernetes
api
and
have
this
done
for
me
in
my
infrastructure
and
last
I
need
to
find
a
way
to
offer
storage.
A
Persistent
volume
claims,
so
we
just
put
a
PV
C
here.
The
ability
in
our
infrastructure
to
be
able
to
offer
a
persistent
storage
set
for
our
applications
running
inside
our
kubernetes
clusters,
and
all
this
has
done
is
declared
through
the
kubernetes
api.
So
our
developer
doesn't
have
to
learn
any
new
tools
or
reach
out
to
any
other
sets
they're
using
these
key
things
like
the
cube
kettle
command,
lenay,
the
kubernetes
api,
docker
CLI
and
our
new
self-service
pts
api.
So
they
can
request
a
kubernetes
cluster
to
expand
and
offer
all
these
capabilities.
A
So
it's
not
all
about
the
developer,
although
that
you
know
these
are
the
key
services
that
we
want
to
offer
to
give
rapid
and
agile
development.
But
we
got
to
consider
what
happens
you
know
what
happens
underneath
is
what
happens
actually
providing
all
of
these
services
for
us
with
PKS.
So
what
happens
underneath
this
service
layer,
so
the
PKS
API
interacts
with
a
component
that
we
call
Bosh
and
Bosh
does
a
very
important
day.
One
capability
for
us.
It
offers
a
deployment
mechanism.
A
So
when
a
development,
a
developer,
a
development
team
makes
a
request
that
PKS
API
that
API
is
going
to
is
going
to
build
something
for
us.
It's
going
to
build
us
a
manifest,
and
it's
going
to
work
with
Bosh
to
make
sure
that
we
deploy
instances.
For
example,
our
kubernetes
cluster
here
would
be
built
with
maybe
one
master
node,
we'll
just
use
an
M
and
a
couple
of
worker
nodes
and
we'd
have
a
repetitive
set
for
all
of
our
other
clusters
that
are
being
deployed
all
in
a
self-service
manner.
A
Now
it's
not
just
about
the
kubernetes
clusters.
We
talked
about.
For
example,
this
harbor
service
will
also
have
boss
managing
the
instances
for
this
harbor
service
as
well
and
notice.
I
use
the
term
managed
instead
of
deploy
so
Bosch
deploy,
has
all
of
these
forests
via
request
from
either
the
kubernetes
api
or
a
tool
that
we
call
ops.
Man.
A
A
A
A
Bosch
also
is
a
the
exposed
view.
This
PKS
API
will
offer
the
capability
that
our
developer
or
development
teams
can
make
a
request
to
expand.
For
example,
we
can
add
a
worker
on
to
one
of
our
clusters,
or
our
operator
can
also
make
that
determination,
based
on
capacity
analysis,
what
type
of
scale
dynamic
growth
and
collapse.
What
type
of
scale
do
we
need
an
infrastructure,
that's
serving
all
of
these
services,
so
we
mentioned
here
or
I
mentioned
here.
A
That
kubernetes
is
also
extending
out
to
all
these
other
cool
things
that
we
offer
to
the
to
our
applications
and
developers.
You
know
this
network
security
with
these
load
balancers
and
policy.
This
persistent
volumes
and
catalog
ap
is
well.
Some
of
that
has
to
be
provided
by
the
infrastructure,
so
network
and
security
will
focus
on
that
for
right
now,
in
addition
to
Bosch,
another
key
component
of
PKS
is
Innes
x,
and
our
operator
can
actually
interact
with
in
a
sex
via
is
something
called
in
a
sex
manager
or
the
nsx
T
manager.
A
So
what
happens
here
is
our
integration
with
it
with
kubernetes
is
any
time
a
developer
needs
a
policy
or
shouldn't
say
a
developer,
but
the
application
that
the
developer,
the
Python,
is
pushing,
needs
a
security
policy
or
needs
a
load
balancer
construct.
Our
integration
with
kubernetes
is
actually
having
that
automatically
created,
it's
being
deployed
as
the
event
of
the
object
being
created
in
kubernetes.
A
There's,
automation
that
will
actually
build
fire
distributed
firewall
policies,
load,
balancer,
constructs
virtual
server,
constructs
HTTP
rules
all
based
on
the
declarative,
the
animal
that's
being
pushed
in
when
an
application
is
being
instantiated
inside
of
kubernetes.
It's
a
really
powerful
capability.
In
addition,
we
see
our
PVCs
are
persistent
volume
claims
we're
running
underneath
NSX
is
you're,
gonna
need
an
is,
and
in
this
case
the
is
that
we're
gonna
be
talking
about
is
vSphere
an
NP
KS.
A
A
So
that
they
can
then
result
in
the
creation
of
persistent
volumes
and
persistent
volume,
claims
and
kubernetes,
so
that
we
can
give
static
arts
that
we
can
get
persistent
storage
to
our
application
base.
So
we
put
all
these
things
together
and
this
this
is
PKS,
and
we
will
look
at
this,
this
component
of
the
PKS
API
and
Bosch
and
NS
xt
these
components,
these
key
components
make
PKS,
and
what
PKS
does
is
this
I
mentioned
before
our
main
goal
with
PKS
is
that
we
can
offer
self-service
kubernetes
at
scale
in
production
for
your
enterprise?