►
From YouTube: Containerizing Java Applications for Kubernetes With Jib - Qingyang Chen & Appu Goundan, Google
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
Containerizing Java Applications for Kubernetes With Jib - Qingyang Chen & Appu Goundan, Google
Containers are at the heart of many complex distributed systems. But, for Java developers, building containers is a common obstacle on the road to Kubernetes adoption. Traditionally, Dockerfiles define container builds imperatively, which can be cumbersome, error-prone, and slow. In this talk, we’ll introduce a container image builder called Jib. Jib is declarative - it packs a Java application into a container by inferring what it needs from your Maven or Gradle project. Jib is fast, builds containers reproducibly, and allows Java developers to use the build tools they are already familiar with. We’ve released Jib as an open-source project and want to share how you too can leverage its capabilities to speed up your development process and orchestrate larger, more complex systems.
To learn more click here: https://sched.co/FuJT
A
B
A
A
So
many
of
you
are
already
familiar
with
containers
which
allow
you
to
say,
take
your
traditional
monolithic,
job
application
and
slip
into
micro
services
to
orchestrate,
while
acting
appreciation
platform
like
kubernetes
and
gala
developers
already
familiar
is
billing.
Jars
containers
are
sort
of
same
concept.
The
idea
behind
jars,
the
Tribune
of
hot
Java,
is
very
similar
to
the
idea
behind
containers,
which
is
idea
of
write
once
run
anywhere.
However,
building
containers
for
Java
applications
can
be
quite
a
confusing
and
tricky
process
to.
B
A
Right
so,
let's
say:
I'm
a
Java
developer
and
I'm
building
a
website
for
pet
click.
I
want
to
containerize
my
back-end,
my
Java
back-end
and
I
want
my
container
image
to
be
on
my
registry
at
I
love,
John,
io,
/,
Pecola
the
gap.
So
what
I
do
first
well
I
go
I
search,
Bill,
Java,
docker,
image
or
I
go
by
do
I
search
goes
yeah
and
Java,
it
seems
young
and
then
I
read
the
top.
You
toriel's
and
I'm
able
to
write
this
docker
file.
B
This
is
a
pretty
complex,
talker
file.
There's
a
lot
going
on
here.
You
have
to
looks
like
install
some
Python
packages.
You
accept
and
install
the
accept
license
for
and
install
the
Oracle
Java
8
JDK,
you
install
maven,
you
add
your
source
code
in
you.
Do
your
build
inside
your
container
and
then
you
can
tell
you
tell
your
container
how
to
run
your
application.
However,
doctors
come
a
long
way
from
this
and
there
must
be
a
simpler
way
to
do
this.
Okay,.
A
So
I
read
some
more
tutorials
and
I'm
able
to
write
this
much
better
doc
file
I'm
using
a
well
maintained
base
image
on
the
dog
hub.
The
open,
JDK
face
image
and
all
I'm
doing
it
is
on
copy.
My
fat
jar
into
my
container
image,
I,
say
my
entry
point
to
run
that
fat
charm.
So
this
is
a
lot
simpler,
a
lot
fewer
layers,
a
lot
more
readable,
yeah.
B
A
So
I
do
some
searching
and
I
find
that
the
open
JDK
base
image
is
two
hundred
eighty
four
megabytes
by
itself,
which
is
huge
making.
My
time
is
over
three
hundred
megabytes,
so
I
do
some
more
searching
and
I
find
that
I
can
use
the
Alpine
Rose
open.
Jdk
Alpine
is
a
tiny
execution
which,
by
itself
is
only
about
four
megabytes
and
also
just
using
the
GRU
version.
So
this
beige
snitch
is
only
82
megabytes,
making
my
entire
image
a
lot
of
smaller
all
right.
It
seems
that
well,
I
do
the
build.
B
For
those
of
you
familiar
doing,
docker
builds
at
the
beginning,
you'll
see
a
message
like
sending
docker
context
to
dr.
demon
and
what
that
means.
It's
sending
all
the
files
you're
dr.
demon
needs
to
do
your
docker
build,
and
in
this
case,
though,
what
the
default
case,
it's
all
the
files
in
the
directory
where
your
docker
file
is,
and
that
could
contain
any
number
of
files,
including
things
you
don't
need
at
all.
A
Fogg
best
practices,
so
I
searched,
talked
about
best
practices
and
I,
find
the
official
doctor
best
prices
and
that's
a
lot
of
best
practices
in
there.
I
see
something
about
a
doctor,
northbound,
so
I
do
tutorials
on
doc,
north
files
and
I'm
able
to
write
this
dr.
gore
file.
It
ignores
everything
in
my
product
directory,
except
for
the
fact
jars
I
wanna
copy
into
liked
image.
So
now
my
pill
runs
a
lot
faster.
B
You
remember
in
our
darker
file:
we
had
a
single
line
for
our
whole
application.
So
every
time
you
change
anything
in
your
application,
you
have
to
rebuild
the
jar,
put
it
in
your
container
and
send
that
container
over
to
container
registry,
but
docker
has
a
thing
called
layers
and
maybe
there's
a
way
we
can
split
our
application
into
separate
layers.
So
we
focus
all
our
changes
in
a
single
layer.
Okay,.
A
Dr.
Larry,
so
I
do
some
toriel's
I'm,
dr.
layering
and
I'm
able
to
write
this
better
docker
file.
I
stood
my
application
to
two
layers,
one
for
my
dependency
jars
and
one
for
my
class
files.
This
way
well,
I
only
changed
my
class
files.
The
only
layer
I
need
to
resend
is
the
class
layer
and
not
that
usually
much
larger
our
dependencies
layer.
So
now
my
build
runs
lot
faster.
I
can
do
it
or
development
I
think
we're
good
to
go
right.
Yeah.
B
A
Okay,
so
I
do
some
more
searching
and
I
find
that
there's
maven
plugin,
so
I
could
use
to
define
my
dog
a
build
with
send
my
maven
tommix.
No
so
I
saw
my
dog
fala
I
apply
this
maven
plug-in
and
I
could
run
my
dog
a
bill
from
maven
I
get
to
do
all
that
develop
in
with
native
commands.
Great
I
think
I'm
good
to
go
so.
B
That
was
a
pretty
long
process
to
get
from
writing
our
first
very
naive,
docker
file
to
where,
at
the
end,
where
we
had
a
maven
plugin,
you
reduce
the
image
size.
We
removed
all
the
install
commands
by
using
a
better
base
image.
We
added
a
docker
ignore
file
to
limit
the
initialization
cost
of
the
build,
and
we
split
our
application
up
into
layers
to
improve
incremental
build
times.
B
B
Your
cache
hits
you
can
use
multistage
docker
builds
to
separate
the
build
part
of
your
docker,
build
from
the
container
I
mean
from
the
part
that
containerize
your
application,
there's
other
dock
cache
mechanisms
and
quirks
that
you
might
want
to
be
aware
of.
You
truly
want
to
understand
your
docker
build.
B
A
When
containerized
is
docker,
there's
many
steps
that
exist
between
your
project
and
your
container
image
actually
existing
on
your
registry.
You
have
to
build
your
jar.
You
have
to
write
your
dog
file.
You
have
to
send
that,
along
with
your
jar
via
the
doctor,
client
to
dr.
demon
and
a
dog,
a
demon
has
to
run
a
container
or
the
Builder
container
image,
and
then
dr.
push
pushes
it
to
a
registry.
However,
well
our
Java
developers-
and
we
don't
want
to
have
to
care
about
docker
files.
A
The
containerization
process
should
be
as
simple
as
have
your
project
running
some
build
and
just
having
your
carriage
be
on
your
registry.
So
that's
why
we
build
Jim.
We
build
chip
as
plug-ins
for
maven
and
Gradle
that
you
can
containerize
an
existing
maven
or
greater
project
in
two
easy
steps.
Just
apply
the
plug-in
and
run
your
build.
Alright,
do
a
live
demo.
B
A
We
got
the
the
repo
cloned
and
all
we're
gonna.
Do.
Is
we're
gonna
run
trip
directly
on
here,
so
we're
gonna
fully
qualify
it
so
that
even
knows
where
to
find
it
I
only
use
version.
Although
1000
I'm
gonna
call
the
build
goal,
I'm
gonna
say
where
we
want
image
to
go
and
I'm
going
to
use.
My
talk
about
registry
and
I'm
gonna
tell
it
to
use
a
different
base
image
than
destroy
list,
which
is
the
default,
because
I
would
cache
to
that
from
here.
A
A
A
A
B
So,
in
that
demo
you
saw
we
took
a
project,
we
did
a
jib
build
and
we
ended
up
with
a
container
image
on
the
container
registry.
We
didn't,
we
didn't
need
to
use
docker
for
this
build
and
that's
what
we
want
chip
to
be
used
primarily
for,
however,
some
of
you
might
still
have
some
docker
infrastructure.
So
if
you
want
to
build
to
a
docker
demon,
jib
gives
you
the
option
of
building
to
that
docker
demon.
B
You
can
also
export
a
docker
context,
which
would
be
a
docker
file
with
all
the
accompanying
application
files
and
we'll
export
that
into
a
directory,
and
you
can
run
the
docker
built
there
yourself
or
you
can
inspect
that
directory
to
kind
of
see
what's
going
on.
But
if
you
want
to
extend
your
configuration,
maybe
it's
a
more
advanced
configuration.
You
can
set
JVM
flags
for
your
application.
You
can
set
how
chip
chooses
your
credentials.
You
can
add
labels
to
your
container
config.
A
A
B
So,
in
those
two
demos,
the
jib
containerization
happened
as
part
of
your
build
and
we
really
want
you
to
feel
like
a
compiler
for
containers
when
normally
using
docker
file.
It
feels
like
a
script.
You
pick
where
your
image
comes
from
what
commands
to
run
to
install
dependencies.
You
can
copy
your
application
files
over
or
an
application
jar,
and
maybe
do
your
build
on
the
container.
If
you
want
and
then
you
configure
the
entry
point,
that's
because
docker
is
a
language.
Agnostic
general-purpose
build
tool,
but
it
knows
nothing
about
your
job
application.
B
But
since
jib
is
integrated
into
your
build
system,
it
can
infer
what
it
needs
from
maven
and
Gradle
to
do.
Containerization
as
part
of
your
build
and
historically
you've
had
code
and
your
add
a
compiler,
and
you
use
those
two
to
create
an
executable
for
a
container
Iser.
You
would
just
want
to
do
the
same
thing.
You
want
to
take
your
java
code
and
turn
it
into
a
container
and
that's
kind
of
because
we
want
to
consider
containers
as
your
executable
unit
of
the
cloud.
B
So
we've
already
kind
of
done
this
with
jars.
You
know
you
with
Java,
you
take
your
application
files
in
your
jar
DUP
and
that
can
include
your
dependencies
in
like
a
fat
jar
and
similarly
Jib
acts
on
your
java
code.
In
the
same
way,
it
packages
it
up
with
its
dependencies
and
puts
it
in
a
container.
So
let's
talk
about,
let's
explore
a
little,
how
Jib
works
so.
A
When
we
went
to
an
open
ship,
we
kept
a
few
goals
in
mind.
First,
we
want
you
to
be
purely
in
Java
so
that
you
can
run
ship
with
nothing,
but
just
your
maven
or
Gradle
build
systems.
We
also
want
it
to
be
optimized
for
Java
applications,
so
you
have
fast
rebuilds
and
fast
development
iteration
cycles,
and
we
also
want
you
to
be
able
to
build
images
reproducibly.
A
So
we
implemented
you
purely
in
Java,
so
that
I
can
run
as
plug-ins
for
maven
and
Gradle.
So
with
ship,
you
don't
need
to
install
docker
or
any
Drupal
just
abroad,
docker
demon
and
you're
not
running
a
container
or
to
build
a
container.
So
how
do
we
achieve
this?
Well
first,
it
helps
to
understand
what
a
container
image
is.
A
A
container
image
is
just
a
directory
of
files
and
in
the
docker
image
format,
this
directory
of
files
is
slept
in
two
layers,
each
represented
as
tar
balls
and
these
tar
balls
composed
into
actual
file
system
for
the
container
image
and
in
this
format,
there's
also
to
continue
configuration
include
things
such
as
entry
point
volume,
mounts
house
checks,
things
for
when
you're
actually
running
the
container.
So,
for
example,
this
is
a
container
configuration
yeah.
A
A
This
is
example
of
manifest,
yet
the
unique
event
ice
inspires
all
the
layers
and
the
kateri
configuration
which
are
all
our
check
sums
and
as
by
default,
the
chip
image
is
built.
On
top
of
the
dish.
Realist
Java,
the
Shoeless
is
a
setup.
Language
focused
base
images
for
languages
such
as
Java
Python
go,
and
these
images
don't
include
anything,
but
what
just?
What
is
necessary
for
running
your
application?
So
compare
this
to
Alpine.
For
example,
which
is
a
popular
base,
image
recommended
eye:
talker
Alpine
is
still
a
Linux
distribution.
It's
just
a
tiny
alien.
A
This
choice,
on
our
hand,
doesn't
include
package
managers,
shells
or
any
other
unnecessary
programs.
So
this
helps
to
improve
security
by
reducing
possible
attack.
Surfaces
helps
keep
your
cut
images
as
minimal
as
possible,
and
this
is
really
what
a
container
should
be.
It
should
be
adjust
your
application
and
its
runtime
dependencies.
Now,
if
you
want
to
learn
more
about
this
rules,
there's
a
great
talk,
that's
linked
to
in
the
destroy
spot
story.
B
So
speed,
so,
if
we're
trying
to
replace
your
docker
build
with
the
Jib
build,
we
want
jib
to
be
faster,
or
at
least
as
fast
as
your
previous
docker,
and
to
understand.
What's
going
on
its
first
important
to
understand
how
docker
builds
happen
when
you
do
a
build,
it
creates
a
container
image
with
multiple
layers.
In
this
case
you
have
a
hundred
megabyte
layer
and
a
50
megabyte
layer,
and
when
you
do
a
docker
push,
it
pushes
these
layers
to
your
remote
container.
B
And
it'll
send
over
a
hundred
megabyte
layer
sent
over
50
megabyte
layer,
but
docker
builds
and
container
edges
are
smart.
When
you
make
a
change
to
one
layer,
let's
say
the
50
megabyte
layer,
it
already
knows,
100
megabyte
layer
exists
and
it's
cached,
and
it
only
needs
to
change
or
only
is
to
send
over
the
changed
layers.
So
in
this
case
the
50
megabyte
layer,
but
smart
developers
can
take
advantage
of
this
and
split
their
application
into
multiple
parts
and
they
can
focus
their
changes
on
the
small
layers
that
changed
the
most.
B
So
let's
say
here
we
have
a
1
megabyte
layer,
we
change
it.
It
only
needs
to
send
up
the
change
layer,
so
the
amount
of
data
going
over
the
wire,
it's
small
and
that
improves
your
build
times.
Jib
takes
advantage
of
this.
If
you
see
here,
this
is
a
docker
build
that
we
would
expect
Java
developers
to
use
it
splits,
your
application
dependencies
resources
in
classes.
So
if
you
change
a
class
file,
it
only
resends
your
classes
layer
and
for
many
job
applications
the
dependencies
and
resources
where
it
can
be
pretty
heavy
Jib
doesn't
build.
B
That's
like
this,
except
we
don't
use
docker
files,
so
there's
other
advantages
of
using
jib
when
you
container
eyes
with
docker,
since
it's
general-purpose
each
layer,
that's
being
built,
might
have
a
dependency
on
the
previous
layer
that
was
so
building
in
docker
has
to
happen
sequentially
once
all
the
layers
are
built,
all
the
pushes
can
happen
in
parallel
and
dr.
takes
advantage
of
that.
But
when
your
container
izing
with
jibs
since
it's
a
highly
controlled
environment,
each
layer
is
built
independently
and
pushed
independently.
B
So
you
paralyze
the
whole
process
and
you
can
reduce
your
total
build
time
since
jib
also
splits
your
application
into
multiple
layers.
You
can
take
advantage
of
caching
pretty
easily
because
it
happens
automatically
for
you.
Here's
a
small
kind
of
example
of
build
speed
up
that
jib
can
provide
you.
We
have
two
projects
here.
The
orange
one
is
built
with
jib,
just
all
default
config
and
the
docker
build
happens.
It's
pretty
simple
docker
build
with
a
single
fat
jar
that
contains
your
application
and
its
dependencies.
You
see
here.
B
The
first
builds
are
pretty
similar
they're,
both
around
20
seconds.
That's
because
both
jib
and
docker
have
to
push
your
whole
application
over
to
a
remote
registry,
and
then,
when
you
rebuild
without
changes,
they're
both
pretty
fast
as
they
basically
go
through
the
process
of
figuring
out
that
nothing
has
changed.
So
no
build
needs
to
be
done.
A
So
another
benefit
we
get
out
of
a
custom
image
builder
like
jib,
is
the
ability
of
build
images
reproducibly.
So
what
does
reproducibility
mean
really
means
that
the
same
image
same
code
always
produces
the
same
image.
So,
for
example,
if
you
were
making
a
change
and
commit
that
to
say
your
version,
control
system
that
commit
should
produce
the
same
image
on
your
machine
as
your
teamates
machine
as
a
reproduction
machine
or
CIC
some,
and
what
this
helps
you
do
is
reduce
possible
variations
that
could
occur
in
a
production
build
now.
A
B
So
because
jib
is
built
into
your
build
system
maven
in
Gradle,
there
are
other
possibilities
for
a
container
compiler
that
we'd
like
to
explore
that
are
not
yet
in
JIT
we
can
perhaps
do
smarter
inferences
like
expose
a
port
automatically
when
we
detect
your
application
is
listening
on
that
port.
We
can
do
other
container
optimizations
for
memory
and
CPU.
Based
on
your
application.
B
We
can
try
and
organise
your
build
into
logical
groups
of
code
that
changed
together,
so
the
layers
are
smaller
and
your
bills
are
faster
and
then,
finally,
we
can
try
and
take
advantage
of
J
Lincoln
modules
to
produce
a
smaller
container
images
for
you
by
reducing
the
size
of
your
JRE,
and
these
are
all
tools
for
building
the
container.
We
want
to
work
on
tools
for
running
the
container.
Now
that
your
container
is
built
and
Q
will
now
talk
about
some
work,
we're
doing
on
scaffold
for
the
Java
development
experience
on
kubernetes.
So.
A
We
actually
gave
this
talk
back
in
May,
but
since
then,
we've
made
a
lot
of
progress
and
we've
made
a
lot
of
integrations.
Other
tools,
and
one
is
great
rebuilt-
was
integration,
was
scaffold.
Also,
scaffold
is
a
command-line
tool
for
doing
continuous
small,
been
on
kubernetes,
specifically
it's
for
people
to
develop
and
iterate
directly
within
a
crew
Nerys
cluster,
so
scalpel
handles
various
external
workflow
click.
Billing
Catan
merges
push
them
to
a
registry
and
deploying
your
application
upon
every
single
change,
so
it
propagates
that
change
to
you're
running
cluster.
B
In
this
diagram,
you
see
there's
stuff
in
blue,
which
is
usually
your
inputs,
like
your
code
and
your
community's
config.
It
goes
through
this
whole
process
and
you
get
an
orange
your
application
running
on
your
cluster,
and
this
development
process
is
building
your
application
container,
izing
it
pushing
it
to
remote
registry
and
then,
if
you've
changed
the
version,
you
need
to
update
your
kubernetes
config
to
correctly
reference
that
version.
You
then
push
this
config
to
your
container
cluster
or
to
sorry
to
your
cluster
and
then
the
cluster
deploy
some
pods.
B
You
can
run
some
commands
to
tail
logs
or
to
port
forward,
so
you
can
access
your
application
from
your
computer
and
then,
finally,
your
application
is
up
and
running
and
you
can
evaluate
it
and
every
time
you
make
a
change,
you
have
to
go
through
this
whole
process
and
kubernetes
is
about
removing
all
the
stuff.
You
don't
care
about
and
only
concentrating
on
what
you
do
care
about.
B
A
We
have
a
repost
a
directory
set
up
with
scaffold,
and
all
that
needs
to
be
done
to
sub
scaffold
is
to
have
a
step
out
diamo.
So
you
make
this
bigger.
So
here
the
scaffold
yeah
mr.
Pirie
was
one
artifact
just
for
the
app
that
we
have
as
gonna
can
rise
to
a
table
registry
and
the
content
says
the
app
is
in
the
app
directory.
We
have
a
configured
with
the
chip
rado
builder,
to
tell
scalpel
to
use
Tripp
Gradle
plug-in
traffic
containerized
application,
so
application
is
just
a
simple
jetty.
A
Server
and
I'll
show
you
the
code
for
it,
just
one
hello
class
that
just
serves
a
page
that
says
hello
with
some
demo
word
that
comes
from
a
very
memorable
from
Shanghai.
So
what
we're
gonna
do
is
we're.
Gonna
just
run
scaffold
dev,
and
this
guy
launched
scaffold
with
the
continuous
development
iteration
cycle
that
manages
and
we're
actually
just
using
a
local
kubernetes
cluster
on
dr.
Podesta.
A
A
B
A
A
A
Mr.
VPN
gonna
carry
over
it.
Oh
it
done
right.
It
worked
okay,
tacos
back
up,
probably
alright,
so
the
server
started
and
we
can
go
and
hit
the
server
localhost:8080.
You
see
hello,
everyone
from
Rochelle
hi,
so
we're
gonna
say
we
want
to
make
a
change.
Come
on
change.
What
says
and
actually
I
go
back
to
the.
A
A
Okay
and
then
redeploy
our
application
and
once
that's
up,
we
can
curl
the
application
again:
okay,
hello,
everyone
from
China.
Now,
let's
say
we
want
to
change
that
in
volume
I
roll,
the
demo
word
that
we
had
so
we
go
and
edit
our
currency
MO,
and
this
is
just
a
standard
deployment
and
instead
of
everyone,
well
change
it
to
hello,
the
audience.
Okay.
Also
another
word
for
everyone,
so
we
said
that
if
scalpels
got
pick
that
up
as
notes
that
it's
only
needs
to
redeploy
the
criminals,
so
it's
already
back
up
and
running.
A
A
See
how
much
time
we
have?
Oh,
we
have
time
so
something
else:
Andrea's
a
Java
library
for
building
containers
College
of
a-kor,
and
this
is
actually
the
library
that
powers
Jim,
maven,
plug-in
ship,
Gradle
plugin
and
we
built
and
released
that
as
its
own
library
for
use
in
Java.
So
how
do
you
actually
use
this
this
example?
So
it
the
first
line
takes
busybox
and
uses
as
a
base
image.
Then
we
just
so.
This
example
is
actually
key.
A
Rising
a
hello
world
application
and
the
second
layer
just
adds
one
layer
with
a
shell
script
that
says
whole
world
to
the
root
of
the
experiment
and
then
we're
sending
an
entry
point
to
run
that
shell
script
and
telling
it
to
containerize
to
our
doctor
daemon
and
call
it
test
trip
Corp.
So
actually,
let's
show
a
demo
of
this
Jim
Court.
A
Another
thing
about
scuffle
is
that
it
also
cleans
up
your
application
when
you
exit
from
it.
We
go
it's
my
temporary
directory,
my
downloads
folder,
calling
this
repo
and
then
all
I'm
gonna
do
is
I'm
just
gonna
run.
It
run
the
application
with
maven
exec
execute
the
application.
My
first
show
what
the
application
actually
is
so
source
main
and
it's
just
the
same
code.
We
had
in
the
slides.
A
Back
again,
this
could
use
the
trip
core
library
to
containerize
our
hello
world
container
directly
to
our
dr.
demon,
all
right.
So
it's
done
and
we
can
just
go
and
run
it
test.
Your
core
was
what
we
called
it:
oh,
my
god,
hello
world.
Of
course
we
can
change
that.
We
can
say
change
the
shell
script
now
we
want
to
add
in
and
change
world
to
Shanghai.
A
A
A
Cool
Silas
trip
core
and,
of
course,
there's
many
other
things
that
we
didn't
cover.
We
are
recently
explosion,
oh
10
Oh,
with
support
for
wars,
so
you
can
take
a
war
project
and
just
containerize
it
with
ship
with
barely
any
configuration,
and
we
also
pill.
Integration
was
tentative,
which
is
a
neurological
service
modules
for
surveying.
Inventing
building
and
jib
is
wanna,
build
templates.
You
can
use,
there's
also
a
third-party
plug-in
for
the
Scala
pill
tool
as
d
plugin.
B
Oh,
so
what
is
the
future
hold
at
Google
we're
getting
the
language
teams
together
to
bring
jib
to
other
languages?
So
maybe
in
the
future
you
can
use
a
style
of
builder
like
jib
for
note
or
C,
sharp
or
Ruby.
We
want
to
work
on
more
scaffold
integration,
maybe
integrating
debug
directly
into
your
scaffold
process.
And
finally,
we
want
to
see
where
people
or
we
can
take
jib
core-
is
really
letting
the
developer
focus
on
writing
their
code
and
having
all
the
cluster
related
build
and
deploy,
be
automatic
and
just
disconnected
from
the
developer.
B
So
that's
our
talk.
This
is
the
github
page
for
jib.
You
can
go
there
for
documentation
or
if
you
want
to
file
an
issue,
there's
a
couple
links
below
for
scaffold
and
destroy
lists
and
some
docker
build
tips
and
tricks.
So
we
have
a
couple
minutes
for
questions
or
restaurant
recommendations
in
Shanghai.