►
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
Java Developer’s Journey in Kubernetes - Arun Gupta, Amazon Web Services
Deploying your Java application in a Kubernetes cluster could feel like Alice in Wonderland. You keep going down the rabbit hole and don’t know how to make that ride comfortable. This no-slide and code-only session will explain how a Java application can be deployed in a Kubernetes cluster. Specifically, it will explain the following: Package the application as Docker image Create Kubernetes manifests Create Helm charts Test in a local k8s cluster Debug pods using Java IDE Observability using Istio Canary and A/B testing Migrate application from dev to prod environments Deployment pipeline on desktop and in the cloud
https://sched.co/NrlQ
A
Right
good
morning,
my
name
is
Arun
Gupta
and
I
work
for
Amazon
in
the
open
source
team.
How
many
of
you
are
Java
developers
know
almost
90%
of
you,
so
I
think
this
talk
is
very
relevant.
In
that
sense,
I've
been
a
longtime
Java
developer
I
started
my
Java
journey
back
in
99
when
we
were
doing
jdk
1.6
now
as
a
Java
developer,
I'm,
always
thinking
about
where
a
new
technology
comes
along.
How
do
I
start
with
that
technology?
How
do
I
start
learning
that
technology
applying
my
existing
skills?
A
So
this
is
how
sort
of
how
I
created
this
github
workspace.
There
are
no
slides,
and
so
this
is
purely
gonna,
be
code
driven
and
workshop
here,
so
in
the
next
35
minutes,
or
so
I
hope
to
guide
you.
What
should
your
journey
look
like
if
you
are
a
Java
developer
and
you
want
to
get
started
with
say
kubernetes,
essentially
that's
sort
of
what
it
looks
like
okay.
Now,
if
you
look
at
it
here,
as
I
said
earlier,
all
of
the
code
is
available
on
this
github
repo.
A
So
this
is
sort
of
the
one
that
you
wanna
bookmark,
essentially
and
the
way
I
look
at
it
is
file
issues.
Send
me
pull
requests
star.
It
fork
it.
You
know.
Whatever
way
you
want
to
monitor
it,
but
that's
sort
of
where
all
the
content
is
sitting
now
as
an
application
developer.
What
I'm
going
to
do
is
I'm
going
to
show
you
quickly
what
our
application
looks
like
it's
a
simple
spring:
good
application,
just
simple,
hello
world!
That's
the
intent,
because
you
know
how
to
build
a
lot
more
fancier
and
more
better
applications.
A
Essentially,
then,
I'm
gonna
show
you
how
you
build
and
test
that
using
maven.
Then
we
start
building
that
application
that
okay,
what
is
my
first
step
in
the
journey
for
kubernetes
I
need
to
make
a
docker
image
out
of
their
java
application?
What
are
my
choices
around
that?
So
we'll
talk
about
that
briefly,
then
we
take
it.
Take
a
look
at
it,
particularly
from
the
Java
perspective.
What
are
the
things
that
I
need
to
be
aware
of?
Can
I
use
JDK
as
a
base?
Image
should
I
use
JRE
as
the
base
image
with
JDK
11?
A
What
are
the
things
that
I
need
to
be
concerned
about,
then
we
talk
about
how
do
I
once
I
build
the
docker
image.
How
do
I
take
that
docker
image
and
now
run
it
on
a
Cuban
eros
cluster
and
what
are
my
choices
for
running
kubernetes
locally
on
my
machine
in
the
cloud,
so
those
are
the
different
options
that
we
can
consider.
A
Then
we're
going
to
migrate
the
application
from
your
development
mode,
which
is
on
your
laptop
to
the
production
mode,
which
is
in
the
in
the
cloud
we'll
talk
a
little
bit
about
the
relevance
of
surface
mesh.
What
does
it
give
you?
What
does
it
by
you?
Why
do
you
need
it
and
what
are
your
choices
around
that.
A
We'll
talk
a
little
bit
about
deployment
pipeline
because
that's
a
relevant
aspect
now,
as
you
are
doing
a
good
push
to
your
application
as
soon
as
you
do
git
push,
we
you
want
the
application
to
be
available
in
your
development
or
in
your
deployment
environment.
So
we'll
talk
about
all
of
those
different
options.
Okay,
so
let's
go
look
at
our
application
first
thing!
So
if
you
look
at
app,
this
is
a
directory
where
my
application
is
sitting
and
as
I
said,
this
is
a
simple
spring
boot
application.
A
A
Okay,
if
you
look
at
my
Palm
D'or
XML,
which
is
how
I
build
my
java
application,
nothing
fancy
I'm
using
spring
boot
starter
as
my
parent
I
have
the
spring
boot
maven
plug-in
in
there
and
we'll
talk
about
this
profile
a
bit
later,
but
so
very
standard
spring
food
application,
no
special
dependencies
required
over
there.
Okay.
A
Now,
if
I
were
to
run
this
application,
it
would
return
hello.
Okay,
that's
not
the
point,
though.
So,
if
you
go
down
here,
I'm
going
to
say
maven
spring
good
run
and
I
say
Karl
and
it
returns
hello,
yeah
I've
only
35
minutes,
so
you
can
only
do
live
demos
so
much
so
I'm,
just
gonna
walk
you
through
it.
Essentially
so
now.
The
second
step
for
you
is
now
that
your
application
is
up
and
running.
A
You
want
to
get
the
exact
same
out
from
the
darker
image,
because
the
first
step
in
your
journey
to
cover
notice
is
to
create
a
darker
image
out
of
a
java
application.
Okay,
so
what
are
your
choices
for
creating
darker
image?
You
can
use
docker
file.
That
is
one
of
the
ways
by
which
you
create
a
darker
image.
You
can
use
a
maven
plug-in
that
is
another
option
and
there
are
a
lot
of
variety
for
the
maven
plugins
that
is
available.
A
So
we'll
talk
a
little
bit
about
that
now,
as
you
are
using
a
darker
image
or
a
darker
file,
what
should
be
a
base
image
B
can
I
use
JDK
as
a
base
image
or
should
I
use
JRE
as
a
base
image
with
JDK
11
or
the
other
nine
onwards?
You
can
create
custom
Geri's.
So
how
does
that
work
out?
You
know,
because,
eventually,
when
your
application
is
deployed
in
kubernetes
and
you're,
using
a
micro
services
based
architecture,
your
docker
image
is
downloaded
on
the
fly
at
a
particular
node.
A
A
A
Now
in
this
dockerfile,
let's
talk
walk
through
this
little
bit:
okay,
so,
first
of
all
on
line,
one
I'm
using
maven
as
a
base
image.
Okay-
and
this
is
important-
because
now
I
can
give
this
docker
file
to
anywhere
where
docker
is
available
and
I
don't
need
to
deploy
or
install
maven
separately
I'm
using
maven
as
the
base
image
itself.
That
means
it
will
download
the
maven
docker
image
and
it
will
have
maven
pre-installed.
So
once
I
do
that,
then
I
can
copy
my
source
code
and
now
I
can
run
maven
itself
now.
A
One
of
the
steps
that
is
commented
out
here
is,
for
example,
I,
can
create
my
local
maven
repository
and
upload
it
into
the
image
itself.
This
will
save
time
by
which,
when
the
image
is
being
built,
it
will
not
download
the
maven
every
time
into
the
image.
So
that's
some
of
the
patterns
that
you
can
see
how
it
can
make
your
image
a
bit
more
efficient.
A
Now
this
is
first
from
statement
in
a
darker
file.
You
can
have
multiple
from
statements
and
those
are
called
as
a
multi-stage
darker
file.
So,
for
example,
in
this
case,
my
first
from
statement
is
maven
and
I'm,
calling
it
as
a
build
stage.
Okay.
Now.
The
second
statement
is
from
where
I
have
open,
JDK,
8
JRE
slim
as
the
base
image,
and
in
this
case,
what
I'm
doing
is
I'm
saying
from
the
build
stage
copy
my
jar
file
that
was
built
into
the
second
stage.
A
This
is
a
very
important
step
because
you
don't
want
to
have
all
the
classes,
all
the
jar
files,
everything
that
may
when
downloaded
to
be
included
in
your
eventual
image,
which
is
the
final
image.
So
what
you
do
is
you
just
copy
the
target
directory?
Because
that's
exactly
where
everything
is
going
to
live.
You
copy
that
and
then
you
set
up
your
java
options,
which
would
be
very
useful
if
you
were
to
debug
the
application
using
your
IDE
of
your
choice
and
then
you
fire
up
your
application.
A
Now
one
of
the
tools
that
was
introduced
in
jelly,
canine
or
other
two
tools,
they
are
called
as
J
link
and
J
depths
and
because
Jerry
canine
kind
of
fundamentally
change
how
the
JDK
itself
is
built.
So
what
J
depths
does
is
it
takes
a
look
at
your
application
and
it
says
give
me
the
list
of
modules
that
your
application
depends
upon.
Okay.
So
if
you
go
down
here,.
A
So
what
I've
done
is
I've
created
my
war
file,
I,
rename
it
to
a
jar
file.
Now
on
my
jar
file,
I'm
saying,
run
J
dips,
okay,
so
take
the
target,
slash,
AB,
dot,
jar
print,
all
the
module
that
it
depends
upon,
because
I
don't
want
to
include
everything
that
is
included
as
part
of
JDK
as
part
of
my
JRE.
What
I'm
doing
here
is
essentially
creating
a
custom
JRE.
A
So
with
this
custom
GRE
it
gives
me
the
ability
to
print
my
custom
modules,
and
these
are
the
modules
that
are
required
by
spring
boot
as
well.
So
now
what
I'm
doing
is
I
have
the
list
of
all
the
modules
that
are
specified
by
this
then
I'm,
using
the
tool,
J
link,
saying,
add
all
the
modules
and
create
my
custom
JRE.
So
up
until
JDK
8,
there
was
a
standard
Gerry
that
was
being
shipped
with
Java,
but
starting
JDK
9.
A
A
So
it's
a
lot
smaller
darker
image
and
as
we
talked
about
that
is
super
important,
particularly
because
you
know
in
a
micro-services
environment,
you
want
the
darker
image
to
be
small,
so
that
in
case
it
needs
to
be
downloaded
and
of
communities
host
it's
easier
to
download
another
tool
that
is
very
important,
particularly
from
a
Java
developer.
Perspective
is,
and
that
I
want
to
highlight
here
is:
if
you
look
at
the
Palm
D'or
XML,
it's
called
as
a
jib
plugin.
A
Now
in
my
maven
pom.xml
I
have
a
jib
profile
and
I'm
using
the
jib
maven
plugin.
This
is
version
1.1.2,
and
this
plugin
can
us
fits
seamlessly
with
your
entire
pound
or
XML
flow.
So
what
you
do
is
you
define
a
profile
here
now
when
you
say
maven
package,
and
if
you
specify
this
profile,
it
will
actually
generate
a
darker
image
for
you,
and
this
particular
tool
is
particularly
useful
because
in
this
case
thing
for
your
spring
application
in
spring
application.
How
many
times
your
dependencies
change
versus
your
application
change.
So
what
it
does
it.
A
It
says:
I'm
gonna
make
the
dependency
as
an
extra
layer
in
darker
image
and
the
application
as
an
extra
layer
in
darker
image.
Now,
if
you
take
a
step
back,
the
way
your
darker
image
is
created
is
a
bunch
of
layers
altogether
and
if
only
a
single
layer
is
changed
and
when
your
image
needs
to
be,
the
new
image
needs
to
be
downloaded.
It
will
download
only
that
single
layer,
so
by
splitting
a
spring
boot
application
into
dependencies
and
application
and
other
dependencies.
A
It
makes
it
easy
for
you
to
download
only
that
specific
layer,
so
essentially
your
dependencies,
which
may
not
have
changed
it,
will
not
download
them,
but
it
will
download
only
the
application
layer
that
has
changed
for
you.
So
what
I'm
doing
here
is
I'm
in
this
maven
plug-in
I'm,
saying
use
JRE
slim
as
the
base
image
and
everything
that
I
specified
in
my
darker
file
is
now
being
specified
here
so
same
image,
size,
but
a
little
bit
more
optimized
for
your
Java
development
environment,
particularly
for
a
spring
developer.
A
So
now
you
have
a
basic
darker
image,
ready
for
you.
Okay,
now
you
need
to
convert
that
darker
image
so
that
it
can
be
understood
by
kubernetes.
So
that's
where
you
know
you
can
start
learning
about
the
kubernetes
terminology.
You
need
to
understand
that
the
basic
terminology
in
kubernetes
is
a
pod,
so
you
deploy
a
pod
now.
Pod
is
not
something
that
you
deploy
by
itself.
So
pod
is
typically
done
by
a
deployment,
because
in
deployment
is
a
declarative
way
of
saying
what
the
pod
needs
to
have
and
how
many
replicas
it
needs
to
have.
A
So
what
you
say
is
take
this
deployment.
The
deployment
will
create
the
pod.
The
pod
will
have
the
container
and
how
many
replicas
of
the
part
that
you
want
and
all
of
those
are
essentially
your
resource
descriptions
in
kubernetes
that
you
need
to
create.
So
you
need
to
understand
what
the
schema
looks
like
and
then
essentially
create
your
resource
description
accordingly.
Now,
just
creating
a
pod
and
a
deployment
may
not
be
sufficient
because
all
of
those
so
the
pod
and
the
deployment
they're
given
IP
address,
but
that
IP
address
is
not
accessible
outside
the
cluster.
A
So
what
you
end
up
doing
is
you
also
create
a
service
description
and
that
service
description
depending
upon
how
you
write
the
service
description,
is
accessible
inside
or
outside
the
cluster?
Okay.
So
the
three
basic
concepts
that
you
need
to
understand:
it
is
a
part,
a
deployment
and
a
service.
Those
are
three
resources
that
you
need
to
create.
Ok,
so
let
me
show
you:
how
does
that
work?
Really?
A
Okay,
so
now
in
this
app,
this
is
sort
of
how
my
kubernetes
manifest
looks
like.
So,
if
you
look
at
this
on
the
line,
one
I'm
saying
this
is
the
app
version
1
line
2
I
describe.
This
is
of
a
kind
deployment
I
specify
some
metadata,
then
in
the
spec,
which
is
a
deployment,
spec,
I,
say
1
replicas,
and
this
is
one
replica
of
the
pot,
then
I
specify
certain
match
labels.
That
means
this
deployment
will
have
the
pod
that
are
going
to
have
these
labels
over
there
I
keep
going
down
over
here.
A
This
way,
I
define
my
template
for
the
deployment,
and
this
is
my
part
spec.
Essentially
ok,
so
this
is
sort
of
all
what
goes
into
the
pod
spec
now
I'm
saying
this
pod
has
one
container
of
the
tied
greeting
and
it
has
the
image
Arun
Gupta,
slash
greeting,
which
is
the
image
that
we
created
earlier,
and
this
pod
also
has
a
label
app
colon
greeting,
and
the
good
thing
is
because
this
pod
has
these.
Well,
what
are
labels?
A
Labels
is
basically
a
key
value
pair,
so
a
key
and
a
value
you
can
pick
them
randomly
whatever
you
want
in
this
case,
I
happen
to
choose
app
:
greeting,
so
the
pod
has
these
two
label,
this
one
label,
app
:
greeting
and
in
the
deployment
I'm
saying
match
any
part
that
has
these
labels.
Ok,
the
pod
also
expose
a
container
port
8080,
but
that
is
only
available
in
the
part
itself.
Okay,
so
my
deployment
has
the
pod
spec.
So
those
are
my
two
resources
that
I
wanted
to
create
earlier
and
now.
A
I
also
have
a
service
in
the
service
I'm,
giving
the
service
has
a
selector
and
what
the
service
is
saying
pick
any
pod
that
has
this
label
on
it,
so
app
:
greeting,
which
is
again
the
same
label
that
was
on
my
pod,
created
by
the
deployment
so
think
about
it.
This
way,
from
your
perspective,
you
had
your
java
application.
The
java
application
you
converted
into
a
docker
image.
A
So
now
you
have
done
a
deployment
and
you
have
a
service
service
is
a
standard
IP
address
that
is
available
to
you
that
is
accessible
to
you,
because
pods
are
given
IP
address,
but
if
parts
turbinate
and
if
they
come
up
on
a
different
host
of
your
kubernetes
cluster
may
be
given
a
different
IP
address.
That's
not
something
that
you
can
rely
upon,
but
service
is
given
a
standard
IP
address
that
is
accessible
and
is
fixed
for
the
duration
of
the
service.
A
In
this
case,
I'm
also
specifying
a
type
as
a
load
balancer,
and
the
advantage
of
that
is
depending
upon
where
this
service
is
deployed,
whether
it's
deployed
on
your
local
cluster
or
in
the
cloud
cluster.
If
it's
deployed
in
a
cloud
cluster
or
say
Amazon
in
that
case,
so
it
will
automatically
instantiate
an
ELB
for
you.
So
now
the
service
is
accessible
to
you
over
ELB.
Ok,
so
you
have
a
service
ready
to
go
accessible
on
a
ELB
and
a
load
balancer
and
then
behind
the
scene.
A
A
Now
another
part,
as
you
need
to
understand,
is,
as
you
are,
building
your
application,
which
is
micro
services
oriented
typically,
you
know
your
application
will
have
a
lot
of
micro
services
and
each
micro
service
in
that
sense,
will
map
to
a
deployment
and
a
service.
So
how
do
you
manage
all
of
these
multiple
deployments
and
services
altogether?
A
A
If
I
look
at
my
app,
this
directory
is
what
indicates
what
a
help
chart
looks
like
okay
now
this
is
using
version.
2
version
3
is
actively
being
developed
and
things
are
changing
over
there,
but
at
least
for
version
2.
What
you
have
is
a
top-level
chart,
dot
y
amyl,
which
basically
defines
you
know
the
metadata
about
the
application
itself.
So
you
can
say
the
API
version,
the
app
version.
A
What
the
description
of
the
helmet
chart
looks
like
then
in
the
values
30ml,
you
define
certain
values
so
think
of
this
as
your
constants
that
can
be
used
across
your
template
files.
So
if
your
application
has
multiple
micro
services,
that
means
it
has
multiple
resource
and
multiple
description
deployments
and
services.
These
values
can
be
templatized
over
there
in
those
description
files.
A
So
now,
if
I
go
to
my
templates
directory,
that's
where
all
the
magic
happens
essentially
so
here
I
have
my
greeting
deployment
and
greeting
service.
So
if
I
look
at
my
grading
deployment,
essentially
this
looks
very
much
like
my
deployment
file
that
I
saw
earlier,
but
now
it's
a
lot
more
templatized,
because
what
I'm
doing
is
I'm
saying
the
metadata
is
the
release
name
greeting
now.
This
release
name
is
the
one
that
is
defined
in
my
values,
gamma
already.
A
Similarly,
I
can
say
values
not
replicas
count
and
the
idea
of
whole
idea
over
here
is
now.
You
can
have
multiple
deployment
and
a
multiple
service
files
and
by
using
template
language
over
there.
It
gives
you
a
standard
mechanism
on
how
you
can
access
or
how
you
can
define
these
values
rather
so,
for
example,
in
my
this
is
my
deployment
and
in
here
I'm
saying
the
part
spec
has
released
dot,
name
gridding.
A
So
all
that
is
fun
now.
What
I
want
to
do
is
I
want
to
actually
deploy
this
helmet,
art
and
I
want
to
test
this
application.
How
do
you
test
this
application?
So
then,
again,
you
have
multiple
ways
of
spinning
up
a
kubernetes
cluster.
First
of
all
on
your
local
machine.
You
know
I
want
to
test
the
kubernetes
cluster
in
my
local
machine.
A
So
a
couple
of
options
you
can
use
docker
for
desktop,
so
if
you're,
using
docker
on
Windows
or
Linux
or
on
Mac,
at
least
on
Windows
and
Mac,
you
can
enable
kubernetes
very
easily.
So
if
you
have
darker
running,
then
you
go
to
the
preferences
and
say
enable
kubernetes,
and
what
that
gives
you
is
a
single
node,
kubernetes
cluster
that
is
running
on
your
local
machine,
so
very
easy
to
get
started
with
and
start
playing
with
it.
Well,
that's
one
option.
A
Second,
option
is
to
use
mini
cube,
so
you
can
download
mini
cube,
which
basically
requires
something
like
VirtualBox
to
spin
up
a
single
node
kubernetes
cluster
for
you
as
well,
but
once
you
have
either
of
those
environments
configured,
then
you
can
install
helm
charge
into
that
kubernetes
cluster
and
you
can
start
testing
your
application
over
there
and
the
advantage
is
whatever
works
on
a
single
node
kubernetes
cluster.
Then
you
can
migrate
that
application
to
in
the
cloud
where
you
are
possibly
running
a
multi
node,
kubernetes,
cluster,
okay,.
A
Now,
in
terms
of
running
a
kubernetes
cluster,
now
there
are
several
cloud
providers
well
I
work
for
Amazon,
so
my
preference
is
AWS
and,
as
a
matter
of
fact,
more
than
50%
of
kubernetes
runs
on
AWS.
This
is
per
the
latest
CN
CF
survey.
So
all
that
matters
is
where
you
run
your
kubernetes,
because
you
need
to
have
that
wide
variety
of
compute
choices
and
the
scalability
and
the
resilience
and
the
availability
of
all
of
that
as
part
of
their
eks
cluster.
So
Amazon
eks,
essentially,
is
our
our
fully
managed
kubernetes
service.
A
What
it
gives
you
is
a
control
plane,
and
then
you
bring
your
data
plane
and
attach
to
it
and
that
becomes
your
kubernetes
cluster
very
easy
way
to
get
started
with
Amazon
II
cares.
You
install
this
CL
I
call
as
brew.
Install
V
works,
tap,
eks
Caudill
and
then
literally,
you
can
say
e
KS
cuddle
create
cluster
if
I
just
give
this
command.
That
will
create
our
Amazon
eks
cluster.
For
me,
now
I've
specified
some
values
over
here
at
the
region
and
the
number
of
nodes
I
want
in
the
cluster.
A
I
have
multiple
clusters
running
in
the
cloud,
okay,
so
at
any
given
point
of
time.
So
if
you
look
at
this,
for
example,
I
have
a
mini
cube.
Cluster
running
I
have
two
darker
desktop
clusters:
running
and
I
have
a
few
clusters
running
up
in
the
cloud
now,
once
I
have
this
application
running
on
my
local
environment,
switching
that
application
to
environment
the
cluster
is
pretty
straightforward.
A
A
Say
I
pick
this
cluster
here,
okay,
now
the
context
switch
to
that
and
if
I
say
a
cue
card,
I'll
get
nodes,
it
will
show
me
the
number
of
nodes
that
are
available
in
that
cluster.
So
really
all
you
need
to
do
is
just
switch
your
context
from
the
cluster
that
is
running
on
the
desktop
to
the
cluster
that
is
running
in
the
cloud
and
then
just
redeploy
the
application,
and
that
is
R
as
the
recommended
methodology
as
well.
A
Now,
one
of
the
common
things
that
you
need
from
your
applications
is
you
want
to
use
the
right
language
for
the
right
tool,
so
you
may
be
using
Java,
you
may
be
using
node.
You
may
be
using
go
so
a
wide
variety
of
languages
because
end
of
the
day,
what
are
these
are
micro
services
which
are
raised
basically
talking
to
each
other
using
api's,
so
the
important
part
is
now
you
want
to
get
observability
into
those
micro
services.
So
how
do
you
get
observability?
Well,
the!
A
If
you
start
doing
the
libraries
for
each
specific
language,
the
java
and
load
and
go
it
quickly,
becomes
a
framework
explosion.
Because
then
we
need
to
start
maintaining
different
versions
of
these
libraries.
Then
your
application
becomes
cluttered.
So
one
of
the
common
design
patterns
that
we
have
seen
in
the
real
world
is
where
customers
use
envoy
as
a
proxy
and
on
Y
is
a
CNC
F
graduated
project.
So
we
were
happy
to
support
it.
So,
customers,
what
they
do
is,
if
you
think
about
pod
pod,
has
one
container,
which
is
your
application
container.
A
A
So
what
essentially
happens
is
any
communication
between
the
application
containers
across
the
pod
doesn't
happen
directly.
It
always
happens
through
the
sidecar,
and
so,
if
you
think
in
terms
of
the
logic,
the
application
container
talks
to
the
sidecar
container,
the
sidecar
container
then
looks
at
the
policies
that
are
being
enforced
at
that
point
of
time,
and
then
it
talks
to
the
other
side
card
container,
which
then
talks
to
the
application
container
and
because
all
the
network
traffic
is
going
through
the
sidecar.
It
makes
you
to
allow
some
more
observability
in
your
application.
A
So
with
on,
why
being
the
basis
for
your
network
traffic,
you
can
do
a
lot
of
fun
things
with
it.
You
can
start
doing
things
like
canary
deployment,
so
you
can
say
that
now
my
servers
on
one
of
the
service
is
running.
I
want
to
introduce
version
two
and
then,
when
I
introduce
the
version,
two
I
only
want
to
guide
the
traffic
to
five
percent
of
the
users,
or
maybe
the
users
who
are
coming
from
a
certain
geography.
Only
so
you
can
start
kind
of
narrowing
the
traffic
to
a
particular
part
of
the
world.
Okay.
A
A
You're
running
on
way
across
all
of
your
applications,
so
what
you
need
is
a
data
plane
on
top
of
it,
which
manages
all
of
those
sidecar
containers
and
that's
where
things
like
Sto
or
AWS
app
mesh
comes
in
now.
Sto
works
very
well
on
Amazon.
He
cares.
If
you
were
to
use
it
sure.
No,
no!
We
support
it.
I
actually
wrote
the
blog
post
on
that
on.
How
is
T
runs
on
Amazon
ETS,
but
AWS
at
mesh
is
a
fully
managed
service
that
we
provide
from
Amazon
as
well.
A
Excuse
me,
so
it
walks
you
through
that.
How
do
you
set
up
the
iam
permissions?
How
do
you
configure
the
app
mesh
so
essentially,
what
I'm
doing
is
I'm
a
neighboring,
an
aim
space
that
anytime
you
deploy
an
application
into
that
namespace
it'll
automatically
inject
the
unwise
sidecar
for
you,
so
it
walks
you
through
the
entire
process.
Then,
just
like
you
know
what
you're
doing
is
you
know,
you're
deploying
your
application
into
the
kubernetes
cluster.
You
need
to
deploy
certain
app
mesh
specific
constructs,
so
things
like
you
know
you
need
to
create
a
mesh.
A
A
So
you
could
say
if
the
users
have
a
particular
cookie
set,
then
guide
the
traffic
to
them
or
if
the
user
is
coming
from
a
certain
part
of
the
geography
or
I,
don't
care
of
the
entire
set
of
deployment
guide,
only
five
percent
of
the
traffic
to
the
new
service.
So
all
those
things
can
be
magically
done
using
these
deployment
descriptors
over
here
and
then
there
are
full
details
about
how
you
can
do
that
using
is
to
you
as
well
now.
A
Scaffold
is
a
tool
that
is
available
in
the
open
source.
Now,
typically,
what
you
do
is
as
part
of
your
development
experience.
You
want
to
get
started
with
that.
As
soon
as
I
make
a
change
in
my
source
code,
somebody
should
compile
it.
Somebody
should
build
a
docker
image
out
of
it
update
the
docker
Kuban.
It
is
manifest
and
redeploy
the
application
to
my
kubernetes
cluster,
and
this
is
all
happening
in
your
local
development
environment.
That
is
exactly
what
scaffold
is
used
for,
and
also
essentially,
what
you
have.
A
Is
you
download
scaffold,
you
setup
your
configuration
using
a
scaffold
or
camel
and
it
heavily
relies
upon
convention
over
configuration.
So
you
put
your
files
in
a
specific
location.
It
picks
them
up
and
sets
up
your
build
environment
where
is
constantly
deploying
files,
so
as
soon
as
in
your
IDE,
if
you
make
a
change,
you
save
it,
it
triggers
the
entire
build
cycle
and
your
application
is
automatically
deployed
to
the
cluster.
It's
very
good
for
iterative
feedback
and
right
away
the
field
that
you
get
back
now.
That's
one
part
of
it.
A
That
is
good
for
local
development.
Now,
when
you're
going
into
the
cloud,
that's
where
you
need
a
full-blown
deployment
pipeline,
of
course,
Jenkins
is
a
good
solution
and
a
lot
of
our
customers
use
it,
but
a
lot
of
the
time
customers
also
want
something
that
is
fully
managed
and
that's
exactly
where
AWS
code
pipeline
kind
of
comes
in.
So
this
section
kind
of
walks
you
through
how
easy
it
is
to
set
up
AWS
quote
pipeline
based
deployment
pipeline
up
in
the
cloud.
It's
a
fully
managed
service.
So
there's
nothing.
A
You
need
to
download
or
manage
on
your
local
machine
and
once
AWS
called
pipeline
is
set
up
once
again.
Every
time
you
make
a
change,
you
know
you
do
a
good
push.
It
triggers
the
entire
development
pipeline
or
a
deployment
pipeline
up
in
the
cloud
and
guides
you
through
the
entire
process.
Okay,
so
you
need
to
set
up
your
github
token
setup
here.
I
am
roll
cluster
name,
and
then
what
you
see
is
how
the
code
pipeline
looks
like.
So
it
says:
here's
my
source.
A
It
is
my
build
what's
being
billed
and
then
it
walks
you
through
the
entire
deployment
pipeline
and
then,
of
course,
you
can
see
the
instructions
for
Jenkins
X
as
well.
So
let's
go
back
through
the
entire
lifecycle
on
how
it
would
look
like
on
if
you
were
to
building
your
application
from
a
Java
developer
perspective.
First
thing
is:
make
sure
you
choose
your
base
image
wisely.
Choose
your
tools
wisely.
Are
you
using
a
multi-stage
darker
file
or
a
maven
plug-in
or
a
Gradle
plugin?
A
There
are
lots
of
options,
make
sure
to
leverage
the
custom
JRE
that
is
available,
JDK
9
onwards,
on
how
you
can
use
that
that
those
are
some
of
the
things
you
need
to
look
at
when
then
you
convert
that
darker
image
into
a
kubernetes
manifest
file.
You
can
test
that
on
your
local
machine,
docker
for
desktop
and
a
mini
cube
lots
of
different
options
over
there.
Then,
as
you
are
migrating,
those
applications
to
the
cloud
consider
Amazon
eks.
A
You
know
this
is
a
managed
service
up
in
the
cloud
you
click
no
eks
cuttle
create
cluster,
gives
you
Amazon.
Eks
cluster
switch
the
context,
and
then
you
migrate
your
application
over
there.
Then
you
start
looking
at
ok.
How
do
I
get
observability
into
my
application,
because
a
lot
of
these
services
are
running.
That's
where
your
service
mesh
comes
in
and
then
last,
but
not
the
least
think
about
what
are
your
deployment
pipelines
looking
like?
So
there
are
certain
steps
you
need
to
think
about
it.