►
From YouTube: Using Kubernetes with Data Processing Units to Offload Infrastructure- Thomas Phelan & Thomas Golway
Description
Don’t miss out! Join us at our next event: KubeCon + CloudNativeCon Europe 2022 in Valencia, Spain from May 17-20. 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.
Using Kubernetes with Data Processing Units to Offload Infrastructure - Thomas Phelan & Thomas Golway, HPE
Application architectures are shifting toward a more disaggregated model that offers greater agility, supports elasticity, and provides greater control for software quality assurance. This has led to an increase in complexity for application topologies, flows and security.
In this session, we will describe some novel work related to offloading core Kubernetes software infrastructure components from the main CPU onto the processing units of DPUs (data processing units). We will show a vendor-neutral way to not only offload the implementation of a Kubernetes CNI (container network interface) plugin, but also offload network packet tracing functionality, such as jaeger, and service mesh components, such as envoy.
In this session, you will learn about CNIs, SmartNICs, Arm CPUs, and how to run software somewhere other than the main CPU. You will also learn why this is becoming increasingly important in the quickly evolving world of DPUs.
A
A
A
Now,
before
we
can
discuss
the
use
of
data
processing
units
more
commonly
known
as
dpus
with
kubernetes,
we
need
to
understand
why
we
want
to
use
them
to
run
containerized
workloads
in
the
first
place.
For
this,
let
me
turn
it
over
to
tom
galway
to
tell
us
about
some
recent
developments
and
foundational
trends
in
it.
A
B
B
The
expectation
is
that
this
virtual
infrastructure
is
optimized
for
the
business
outcome
and
fully
abstracted
from
the
physical
infrastructure
as
enterprises
innovate.
On
the
business
side,
we
see
data
and
application.
Architectures
are
shifting
towards
a
more
disaggregated
model,
offering
greater
agility
and
supporting
elasticity.
B
This
gravitational
pull
influences
the
how
and
where
compute
and
data
need
to
be
processed.
Despite
the
hype,
data
doesn't
always
exert
the
strongest
gravitational
pull
to
deliver
these
new
models.
Application
developers
are
adopting
cloud
native
and
micro
service
based
architectures
as
applications
move
towards
cloud
native.
B
We
are
seeing
technologies
such
as
service
mesh
that
support
greater
agility
and
move.
I
t
towards
the
ultimate
goal,
which
is
operating
in
a
just-in-time
model
by
leveraging
a
scale-out
disaggregated
model
applications
have
the
ability
to
be
deployed
using
a
composable
model
with
a
mix
of
core
code,
libraries,
open
source,
external
applications
and
microservices
individual
components
of
the
application
will
be
executed
on
the
platform
that
best
fits
its
function
in
the
context
of
the
overall
class
of
service.
B
Application,
topologies
and
flows
will
have
greater
complexity,
which
brings
a
greater
potential
for
increased
latency,
jitter
and
traffic
flow.
Small
degradations
and
performance
may
seem
inconsequential
for
an
individual
microservice,
but
when
aggregated
to
the
application
level,
it
will
impact
business
process
service
levels.
B
This
will
require
a
cloud-native
infrastructure
that
supports
the
optimal
placement
of
workload,
ensures
the
placement
supports
its
performance,
security,
manageability
and
accessibility
to
data.
This
also
needs
to
be
extensible
to
support
the
connectivity
and
flows
to
all
services
that
are
part
of
the
application.
B
B
In
addition,
there
is
a
trend
towards
protection
of
these
assets
in
use
known
as
confidential
computing,
as
business
requirements
evolve.
So
does
the
need
to
improve
service
metrics
by
like
performance,
latency.
Gender
there's
also
an
increased
focus
on
measuring
the
return
on
investment
for
an
application
which
increases
the
need
to
support
service
level,
differentiation
that
correlates
to
the
business
value
of
the
application
and,
lastly,
we're
seeing
a
broad
adaptation
of
the
tenant
operator
model
separating
the
application
running
from
the
underlying
services.
B
So
we
talked
about
the
trends
and
drivers
for
moving
to
cloud
native
and
touched
on
some
of
the
challenges
in
looking
at
technologies
that
can
serve
as
an
enabler
to
unlock
the
value
of
these
trends,
while
solving
the
challenges.
The
value
provided
by
the
capabilities
of
some
of
the
cncf
projects
start
to
become
clear.
B
B
The
shift
towards
disaggregation
and
disaggregated
architectures
is
driving
the
need
for
building
the
underlying
infrastructure
to
support
what
I
call
infrastructure
plasticity
now.
Infrastructure
plasticity
is
where
the
underlying
physical
infrastructure
is
enriched
and
presented
to
the
application
as
a
virtual
ecosystem
that
is
fully
optimized
to
support
the
application's
classes,
service
requirements,
in
addition
to
supporting
service
level
requirements.
This
also
provides
isolation
between
workloads
on
the
host
processor
and
isolation
between
workloads
and
the
underlying
services.
B
B
This
is
also
where
policies
are
enforced,
both
explicit
as
set
by
the
application
owner
and
implicit
as
an
action
taken
in
response
to
conflicts
and
resource
consumption.
So,
for
example,
an
example
of
an
implicit
enforcement
would
be
invoking
a
traffic
shaping
algorithm
in
response
to
a
noisy
neighbor
event.
B
B
A
A
These
are
typically
arm.
Processors
that
have
a
smaller
space
footprint,
consume
less
power
and
cost
less,
but
also
run
slower
and
have
less
functionality
than
the
x86
based
cpus
usually
found
on
computer
hosts.
There
is
memory
typically
32
or
64
gigabytes,
but
that
number
is
rapidly
increasing.
There
can
also
be
specialized
hardware
dedicated
to
performing
specific
functionality.
A
One
such
piece
of
specialized
hardware
is
a
p4
engine.
P4
is
a
language
that
is
used
to
define
how
data
packets
are
processed.
Having
a
p4
engine
allows
the
dpu
to
support
a
programmable
data
plane.
This
means
that
many
network
and
storage
packet
processing
activities
can
be
moved
from
the
host
to
the
dpu
without
loss
of
performance.
A
Similarly,
there
can
be
dedicated
hardware
to
implement
data
encryption
or
decryption
without
using
the
arm
cores.
In
fact,
there
could
be
fpgas
on
the
dpu
which
implement
many
cpu
intensive
operations,
greatly
reducing
the
consumption
of
cpu
cycles
without
loss
of
any
performance.
This
could
even
include
functionality
to
support
the
offload
of
portions
of
libraries
and
development
kits.
A
A
Similarly,
the
dpu
happens
to
be
a
smart
nic
designed
to
offload
network
processing.
It
will
have
nik
support
as
well
as
ethernet
ports,
so
there
we
have
it
the
composition
of
a
dpu
now
that
we
know
what
dpus
are
and
why
we
need
them.
Let's
spend
some
time
understanding
how
we
can
use
them
since
we're
at
cubecon
and
focusing
on
containerized
applications.
A
There
are
three
common
software
methods
for
using
a
dpu.
First,
we
can
treat
the
dpu
as
just
another
kubernetes
node.
We
can
assume
that
it
is
running
some
version
of
linux
and
we
can
use
the
standard
kubernetes
apis
to
access
the
node
and
deploy
containerized
workloads
on
it.
This
is
the
easiest
way
to
use
a
dpu,
but
it
hides
a
great
deal
of
the
power
of
the
device.
A
A
A
A
A
A
A
A
A
A
Application
architectures
are
becoming
increasingly
disaggregated
in
a
move
to
provide
greater
application,
agility
and
elasticity
data
processing
units
and
cpu
offload
devices
in
general
are
well
positioned
to
aid.
In
this
ongoing
transformation
of
the
compute
ecosystem,
we
have
discussed
how
dpus
can
provide
a
number
of
value-added
capabilities.
A
A
As
we
noted
application,
specific
value-added
services
can
be
run
on
the
dpu,
in
addition
to
the
common
services
and
finally,
the
running
of
services
on
the
arm
course
of
the
dpu
allows
more
application
code
to
be
run
on
the
x86
processors
of
the
host.
Increasing
the
overall
utilization
of
the
server
hardware,
with
this
sort
of
intelligent
use,
dpus
can
become
an
integral
part
of
modern
computing
environments.