►
From YouTube: Piranha Cloud: From Eclipse Glassfish to Super Fast Cloud & Serverless Jakarta EE - JakartaOne 2022
Description
Eclipse GlassFish means stability and tradition, while Piranha Cloud is a next generation cloud-native Jakarta EE runtime built for extreme speed, short cold starts and developers’ joy. Wanna see Jakarta EE boot under 100 milliseconds? Wanna understand how that’s possible and what’s the role of GlassFish in it? Then come to this talk.
Is Eclipse GlassFish server dead? Not really, it’s gone a long path since Oracle dropped commercial support for it and it’s being actively developed now by OmniFish and other companies, heading towards Jakarta EE 10, with many fixed bugs and performance improvements. But it still has a lot to catch up to match cloud and serverless requirements. And that’s exactly where Piranha Cloud shines. Built on some of the best GlassFish components, assembled from the bottom to provide only what’s necessary. Do you wonder how’s that possible? We’ll first review the current status of GlassFish, how Piranha happened and then show both in action. You’ll see for yourself how fast and powerful modern Jakarta EE runtimes can be nowadays!
-
Jakarta EE gives developers a comprehensive set of vendor-neutral, open specifications that are used for developing modern, cloud native Java applications from the ground up. With Jakarta EE, technology developers and consumers can be confident they have the best technologies for developing cloud native, mission-critical applications. And they can build on decades of Java developer expertise to move existing workloads to the cloud.
Learn more: https://jakarta.ee/
Follow us on Twitter: https://twitter.com/home
Follow us on LinkedIn: https://www.linkedin.com/showcase/jakartaee/
Like us on Facebook: https://www.facebook.com/JakartaEE/
A
Hello,
I'm
Andre,
mihari
and
I'm,
going
to
talk
to
you
about
a
little
bit
of
glass,
fish
history
of
glass,
fish
and
what
it
is
now
and
about
the
new
framework
called
pyramid
Cloud,
which
is
derived
from
glassfish.
So
we
will
see
where
glass,
fish,
or
at
least
a
lot
of
last
resource
codes,
can
get
you
nowadays
with
a
different
approach.
A
A
A
A
Application
servers
also
offer
management
during
runtime
and
and
they
are
basically
designed
to
to
run
almost
all
the
time
if,
if
that's
possible
and
you
deploy
applications
onto
it,
so
basically
you
get
a
an
advantage,
sometimes
of
running
our
application
server
and
deploying
an
obligation
on
it,
because
you
don't
have
to
restart
everything.
You
can
just
really
put
the
application,
and
that
is
quite
fast
depending
on
your
application.
Obviously
you
know.
Sometimes
the
application
is
very
heavy.
A
A
But
application
servers
are,
of
course
slow
to
start
everybody.
Everybody
knows
the
application
servers
run
a
lot
of
things
in
in
the
beginning
and
when
they
are
especially
designed
for
production,
they
start
a
lot
of
services
on
monitoring
Services
a
lot
of
services
that
should
be
up
and
running
immediately,
to
avoid
any
slow
down
major
when
the
application
needs
some
services.
A
So
a
lot
of
the
time
in
production,
you
want
everything
to
be
pre-loaded
so
that
the
application
server
responds
fast
to
any
request
that
comes
at
any
time,
but
application
or
the
Java
itself.
May
doesn't
need
to
be
that
slow
Java
is
just
language
it
can.
It
can
power
any
application,
even
fast
money
and
fast
starting
application,
and
the
truth
is
that
playing
Java
starts
very
fast.
A
It
is
in
milliseconds
compared
to
application
servers
which
run
in
or
start
in
seconds,
and
it's
not
that
Java
would
be
very
slow
to
start
compared
to
even
other
languages
like
node.js
or
not
other
platforms
like
node.js
or
python.
It's
mostly
that
we
have
these
Notions
that
application
servers
are
slow
to
start.
Then
we
switch
to
some
framework.
That's
let's
use
this.
A
So
the
question
now
is:
is
this
inherence
or
this
this
lonest
slowness,
inherence
to
application
servers
or
the
Jakarta
itself?
Is
it
possible
to
run
a
Jakarta
obligation
by
some
other
means
not
using
application
servers
but
still
get
to
really
fast
Java
startup
times?
Is
that
possible?
Do
you
think
that's
a
rhetoric
question,
but
I
will
just
show
you
how
fast
we
can
get
with
with
the
plain
Java
application.
B
A
I
prepared
some
some
applications
or
basically
the
same
application.
Besides
the
playing
job
application,
each
each
version
contains
an
application,
a
server,
that's
which
does
very
simple
job.
It
just
returns
a
message
in
the
request,
but
because
we
don't
have
support
for
servlets
in
plain
Java
for
for
the
reference,
I
will
just
use
playing
Java
application.
Then
this
just
spins
out
the
message.
So,
let's
see
what
is
what
does
the
what
the
simple
application
does
and
for.
A
A
A
A
A
With
Emily
glassfish,
which
is
a
very
end
of
a
application
server,
a
glassfish
server
which
starts
faster,
still
deploys
any
Jakarta
application,
but
without
Administration
console
and
basically
you
can
start
the
application
from
your
code
or
deploy
the
application
from
your
code.
So
you
don't
need
to
install
the
application
or
application
server.
You
don't
need
to
deploy
the
application
on
it.
It's
as
lightweight
as
the
last
fish
can
get.
A
A
A
So
we
initialize
a
glassfish
with
some
properties,
We
Set
with
some
boards
to
listen
to
and
then
with
bootstrap
the
runtime
and
start
it,
and
then
we
need
an
application
archive.
So
in
this
case
to
to
make
so
that
we
don't
have
another
module,
another
one
module
to
deploy
on
the
application.
We
basically
take
this
the
sources
or
the
the
code
of
the
application
in
this
project
we
create
so-called
scattered
archive
and
provides
where
to
find
the
classes,
and
then
this
is
like
a
virtual
icon
that
is
deployed
to
the
ground
fish.
A
B
A
Actually,
we
want
to
measure
the
full
full
startup,
including
the
request,
request
and
response
in
order
to
avoid
any
kind
of
tricks
that
the
application
server
can
may
do
because
it
may
reports
to
be
running.
But
when
you
actually
access
the
server
first
time
and
send
an
HTTP
request,
you
may
still
need
to
load
some
some
functionality.
Some
features-
and
that's
me
that
makes
the
first
because
slower.
A
So
we
want
to
measure
it
actually
really
the
time
from
the
beginning
until
it
produces
some
outputs
and
with
that
I
have
this
simple
script
and
I
stopped
the
server.
So
now
the
script
just
starts,
the
application
sends
a
gets
risk
request,
cleanse
the
output
and
measures
how
long
it
takes.
So
this
whole
day
took
five
seconds.
A
A
A
But
first,
let's
talk:
let's
explain
what
checkout.ee
actually
is
why
it's
not
just
application
servers
why
it
can
be
something
else.
It
can
be
something
else,
because
it's
just
an
API.
If
you
check
out
the
platform,
doesn't
specify
that
actually
the
implementation
has
to
be
an
obligation
server.
It
doesn't
specify
that
the
application
has
to
be
deployed.
It's
as
a
war
archive
it
used
to
have
deployments
interface,
which
was
kind
of
standard,
but
now
it's
it's
obsoleted.
So
this
is
not
required
and
Jakarta.
A
He
basically
specifies
an
API
and
the
behavior
of
the
implementation.
That's
that
implements
the
API
and
that's
from
the
application
point
of
view.
Usually
application
servers
contain
a
lot
of
other
vendor
stuff
that
allows
you
to
configure
things
on
the
server
side.
For
example,
data
sources
still
connect
to
the
database
or
connection
pools
or
monitoring
and
a
lot
of
other
things
that
are
not
defined
in
the
Jakarta
EE
and
the
certainly
not
in
the
API.
A
And
actually
the
boot
time
is
an
implementation
detail.
It
used
to
be
not
the
norm
that
application
servers
are
used
to
run
the
company
applications
and
then
application
servers
are
faster
or
slower,
but
never
really
fast.
Just
to
Startup.
Some
of
them
were
faster,
some
of
them
slower,
but
there
was
no
focus
on
getting
new
application
up
and
running
fast
with
application
servers.
A
But
with
with
an
API
one
is
actually
the
the
great
benefit
of
jakartai
is
that
it
specifies
the
single
API
and
within
with
a
standard
API,
you
can
change
the
implementations
later
or
even
in
the
beginning.
You
can
just
choose
what
is
the
best
implementation
for
you
and
you
can
still
use
the
same
API
and
you
you
use
what
you
learn.
You
have
a
documentation
of
the
same
API
and
same
behavior
in
this
single
place,
and
only
small
differences
or
differences
between
implementations.
A
There
are
documented
by
each
implementation
that
you
can
sort
of
rely
on
a
lot
of
common
stuff
across
multiple
takatai
foundations,
and
you
can
choose
an
implementation
like
application
server.
If
you
really
see
the
benefit
of
it,
you
want
to
see
use
clustering.
You
wouldn't
want
to
deploy
on
premise
like
businesses
used
to
do
for
for
a
lot
of
years,
but
sometimes
you
need
something
else.
Sometimes
you
need
something
to
advance
fast
is
is
easy
to
work
with
deploys
easily
in
kubernetes
and
clouds.
A
So
the
eclipse
glass
fish
where
it
is
actually
it
is
an
application
server.
It's
been
here
for
a
very
long
time
and
it's
open
source,
it's
robust
in
the
same
way
as
many
other
applications
servers.
It
contains
a
lot
of
features
besides
check
out
IE
platform
like
as
I
mentioned,
monitoring
or
connection
pooling,
or
you
can
deploy
multiple
applications
on
it.
A
If
you
want-
and
it
also
provides
easy
management
it-
it
contains
an
Administration
console
which
is
a
graphical
way
how
to
manage
a
running
server
and
tune
the
application
without
restarting
it.
It
provides
a
rest
interface
which
you
can
access
programmatically
outside
of
the
server
or
you
can
even
script
configuring
application
server
during
during
it's
being
running.
A
This
story
of
glass,
which
is
pretty
long-
it
actually
started
at
some
Microsystems
before
it's.
It
was
born
by
Oracle
And.
Even
before
glasses.
There
were
other
application
servers
developed
by
some
Microsystems
that
later
evolved
into
glassfish
and
then
grassfish
server,
the
open
source
server
and
also
the
commercial
one
were
maintained
by
Oracle.
But
with
the
the
version
of
glassfish
4,
there
was
no
commercial
version
of
glass
fish.
A
It's
a
commercial
supports,
ended
with
the
glass
fish
three
and
later
Oracle
decided
to
to
donate
Java
ee
to
increase
Foundation,
which
in
turn
made
it
into
a
close
Foundation
as
jakarte
project,
and
they
also
donated
glass,
resource
codes
and
and
also
the
trademark
to
the
grounds
fish
from
Bay
to
the
Equus
foundation.
So
now
not
only
Java
ee
rename
is
Jakarta
e
is
available
within
the
ocus
foundation,
but
also
the
whole
glass
fish.
Open
source
version
of
classic
server
is
under
the
name.
A
Eclipse
glass,
fish
and
all
of
all
of
the
source
code
train
bugs
are
owned
and
maintained
by
the
Atkins
Foundation
within
the
open
source
project.
But
there
are
also
some
companies-
third-party
companies,
not
Oracle,
not
if
some
Microsystems,
because
it
doesn't
exist,
but
other
companies
that
know
pretty
well
how
a
process
works
and
support
it
and
also
contribute
a
lot
of
work
to
improve
ground
fish
and
now
in
today,
in
2022.
We're.
A
For
ground,
including
class
57,
but
it's
only
days
and
most
weeks
away
and
it
proved
glass,
fish,
seven
Milestone,
I
think
eight.
Now
it's
the
latest
is
Milestone
10,
but
I.
Think
Milestone.
Eight
was
the
first
one
that
actually
passed
the
Jakarta
ee
10
tck,
and
it
was
the
first
implementation
of
Jakarta
E10
in
September
I
think,
but
on
top
of
Japan
glass,
fish
improved,
also
other
areas
which
it
supports.
Running
on
Java
11
to
18
or
even
19
I
forgot
to
update
this
on
my
site.
A
So
it
start
it
tries
to
be
to
be
up
to
date
with
any
Java
version.
It
has
some
other
apis
like
micro,
profile,
config
and
I
think
America
profile
Jewel.
It
is
already
there
too.
It
supports
Jakarta,
NBC
and
it's
it
provides
the
embedded
glass
fish
which
I
showed
you
which
didn't
work
so
well
in
the
in
the
past.
So
the
glass
fish
team
improved
and
bloody
glass
fish.
A
A
So
glassfish
is
not
only
the
application
server
itself,
but
it
provides
the
base
for
other
projects
or
it
uses
other
projects
that
are
used
also
used
by
other
application
servers
around
the
Frameworks
okay-
and
this
is
where
actually
the
new
here
on
your
Cloud
framework
benefits
from
it's
also
maintained
by
some
of
the
some
of
the
people
who
work
on
glassfish.
So
the
teams
are
not
completely
separate.
A
Currently
it
provides
only
subset
of
Jakarta
eapr,
it's
very
gross
and
every
now
and
then
there
is
a
new
component
either
from
last
video
from
other
other
open
source
projects
added
to
the
supported
component
list
and
integrated
with
the
core
of
Miranda
clouds
and
in
the
end
the
call
the
current
gold
of
pyramid
will
appear
on.
The
cloud
is
to
First,
implement
the
Jakarta
equal
profile
and
then
check
out
the
web
profile
with
very
fast
and
still
I'm
highly
extensible
platform.
A
So
initially,
parental
Clause
is
very
bare
bone.
You
can
build
really
small
applications
which
only
require
one
or
two
to
cut
the
earps,
and
you
can
you
build
a
more
complex
micro
services
that
require
some
more
apis
from
their
cart.
Ie
yeah
at
the
core
of
here
on
the
cloud
there
is
able
based
bearable,
servlet
companion,
which
is
written
from
scratch
and
is
very
fast,
and
on
top
of
it
there
are
multiple
or
distributions
that
implementary
profiles
not
for
like
not
complete
profiles.
A
So
you
can
see
that
later
that
there
is
a
core
profile
distribution.
That's
will
very
soon
support
all
of
the
functionalities
of
our
profile,
but
it's
still
not
there
yet.
So
the
name
just
references
that
it
aims
to
aims
to
provide
all
the
features
of
Jakarta
ee
profile,
the
code
profile
web
profile,
but
it's
still
not
full
called
profile
or
web
profile
compatible,
but
it's
fairly
modular.
It
provides
all
the
function.
It
is
provided
as
explanations,
so
you
can
even
assemble
your
own
runtime.
A
That
only
needs
to
only
provides
what
you
need
and
you
can
also
deploy
any
server,
because
the
silver
container
is
almost
almost
fully
compatible
with
the
server
tck.
This
is
just
one
person
of
tests,
a
few
edge
cases,
but
all
all
usual
so
but
I
run
on
it.
For
example,
Jersey
the
rest
nomination
is,
is
integrated
into
pyramid
Cloud
as
a
server,
and
you
can
also
drop
any
other
server
that
exists
out
there,
which
doesn't
even
have
to
be
an
extension.
A
A
A
It's
yeah.
There
is
almost
no
difference
only
that
the
hello
world
is
now
from
here
in
the
cloud
and
not
from
grassfish.
What
is
different
is
here.
This
gets
much
more
simple
because
you
just
create
the
the
Builder
and
configure
the
engine
using
this
Builder
build
the
build
the
engine
and
then
start
it.
A
What
I
also
need
to
add
is
HTTP
processor
and
HTTP
server.
This
is
because
pirania
goes
so
into
granularity
that
it
doesn't
even
contain
httpa
server
out
of
the
box.
It's
only
a
select
container,
which
you
can
use
in
your
code
and
you
just
can
virtually
create
an
object
that
represents
the
request
and
then
you
get
a
response
object.
So
you
can
just
run
the
request
inside
your
application
without
the
full
HTTP
stack,
it
is
actually
in
my
minimal
I'll.
A
Give
you
an
example
where
I
built
the
same
thing:
I
studied
the
application,
but
I
don't
create
HTTP
server,
I
just
create
a
request
and
then
service
request,
and
in
this
case
this
is
just
a
default
request,
but
I
can
add
a
URL
to
it
or
headers
to
to
the
request
everything
just
in
an
object.
I
can
assemble
it
in
my
code
and
then
I
call
during
the
service
get
response,
and
then
I
can
do
anything
with
it.
I
can
print
it
to
standard
output
or
yeah.
A
I
can
turn
it
into
an
HTTP
response
or
send
it
through
a
Kafka
message,
whatever
I'm
not
bound
to
the
HTTP
request
response
mechanism
that
I
can
can
do
that.
If,
if,
if
you
add
this
hdb
server
and
server
processor,
we
can
start
just
just
start
the
HTTP
server
and
then
when
we
run
it,
the
application
works
in
similar
way
as
embedded
glassfish.
It
listens
to
http
requests
and
response
with
a
90
degree
response.
A
So
this
is
what
actually
we're
going
to
measure
now,
but
first
I
forgot
to
to
show
an
intermediary
step,
and
this
is
something
many
people
might
think
about.
If
we
talk
about
application
servers
being
slow,
many
people
know
this
framework
called
Spring
spring
boots
or
spring,
which
is
very
widely
used
in
the
world
and
I
thought
that
it
might
be
interesting
to
use
it
also
as
a
reference
as
the
reference
and
deploy
a
servlet
which
is
supported
by
springboots,
and
here
I
have
the
the
same
application.
Again,
it's
a
little
more
boilerplate.
A
And
here
basically,
I
have
again
the
same
servlets,
it's
just
without
the
annotations,
because
spring
boot
doesn't
support
them,
or
at
least
maybe
I'm,
not
that
good.
In
this
thing,
what
I
did
is
I
normally
did
web
config,
which
basically
adds
these
mappings.
This
is
similar
to
what
I
can
do
with
piranha
too
I
can
add
the
servlet
and
mappings
configured
and
servers.
So
this
is
a
programmatic
way
how
to
deploy
and
configure
servers
with
spring
bow
down.
But
I
only
have
this
main
method
and
when
I
run
the
springboard
application.
A
I'm
not
kidding,
this
is
really
the
time
it
takes
pirania
to
actually
start
the
HTTP
server,
get
a
request,
respond
to
the
request
and
respond
with
help
from
bit
on
the
clouds
and
yeah.
That's
it.
So
this
is
400
milliseconds
that
it
takes
to
appear
on
for
appear
on
the
cloud
to
do
the
same
thing
as
with
spring
boot
or
embryo
glass
fish.
A
A
The
virtual
requested
response
cycle
so
we'll
just
start
the
pyramidal
engine
and
we
won't
run
HTTP
request,
but
we
will
just
create
an
object
for
the
request
and
compute
the
response
and
print
it
out.
This
is
very
similar
to
our
plain
Java
application.
We
just
outputs
a
string,
an
output,
the
hello
world,
because
here
we
actually
just
initialize
an
object,
just
just
use
the
code
and
don't
wait
for
anything
from
outside.
We
just
send
the
request.
A
Objects
to
the
engine
and
print
the
message
so
a
little
more
complicated
way
to
get
get
something
to
print
out
on
the
console,
but
it
demonstrates
how
the
server
can
be
running.
So
this
is
a
solution-
com
very
similar
to
the
plain
Java
application,
but
it
uses
server
actually
to
to
generate
the
response
and
then
print
the
response
and
in.
A
A
B
A
Trick
that
maybe
even
spring
boots
can
can
use
and
then
remember,
the
glass
fish
I
didn't,
try,
basically
plus
there's
a
sharing,
somehow
caches
or
stores
the
information
about
classes.
That
jvm
needs
to
read
from
the
application
from
the
byte
code
and
remember
this
in
some
kind
of
index
file
and
the
next
time
the
application
starts,
it
will
skip
the
initialization
phase
and
and
the
adavia
will
read
the
information
from
that
file
and
that
usually
improves
the
startup
time
but
around
by
around
20
to
30
percent.
A
From
my
experience,
but
for
that
we
need
to
do
two
steps
to
to
be
able
to
measure
the
application
startup
done.
We
first
need
to
prepare
the
index
so
we'll
use
yeah.
What's
this
one
we'll
use
this
option
of
open
jdk?
It's
not
a
it's,
not
a
standard
open
date
or
something
standard,
jdk
option,
so
some
other
jvms
not
based
on
open
jdk,
may
not
have
it
or
may
have
something
similar,
but
with
any
open,
jdk
distribution.
A
B
A
Getting
closer
and
closer
to
the
plane
Java,
if
we
remove
the
the
Glass
Vision
screen
with
measurements,
we
are
now
still
quite
so
slower
than
the
fine
job,
but
playing
Java
does
actually
not
do
any
much.
It
just
prints
prints
a
message.
Well,
these
two
with
with
piranha
they
actually
initialize
the
whole
solid
container
and
and
issue
a
request
and
get
a
response
from
from
the
container.
So
they
actually
do
some
something
more
and
the
world
is
not
ideal.
A
If
we
deploy
a
bigger
application
or,
for
example,
if
I
run
as
a
rest
application
with
pirania,
we
can
get
up
to
one
second
or
so
so
there
are
still
use
cases
where
the
difference
is
much
much
higher,
but
with
we
can,
at
least
with
the
simple
application,
can
can
get
very
close
to
playing
Java
start
at
times,
and
it's
still
around
200
300
milliseconds.
So
it's
not
very
noticeable.
A
Sorry
I
will
skip
these
are
going
to
demonstrated
Paradise,
flexible
and
I
wanted
to
show
you
how
it
works
with
cloud
deployments
and
where
it
evens
many
more
than
Google
realities
is
serverless,
because
with
kubernetes
and
microservices
you
can
bear
with
a
couple
of
seconds
start
a
time
for
services.
You
can
have
a
load
balancers
and
then
users,
usually
don't
notice
so
much,
but
with
serverless
when
you
deploy
serverless
applications
on
functions
as
a
service
like
AWS
Lambda,
you
actually
either.
You
may
have
may
may
notice
this.
A
So
it's
good
to
be
able
to
minimize
cold
starts
and
for
for
some
time
we
have
already
ground
VM
option
with
with
Java,
but
it
doesn't
work
with
all
Java
applications.
It's
just
supported
by
some
Frameworks
like
Marcus,
which
also
it
was
a
lot
of
Jakarta
apis
and
Springwood.
Recently
added
support
for
for
Native
completion
with
gravia,
but
it's
still
not
bulletproof.
It
doesn't
allow
you
to
compile
any
application
into
native
code.
You
may
have
some
troubles
to
compile
your
existing
applications
or
even
doing
developments.
A
And
the
other
side
of
ground
VM
compilation
is
that
the
compilation
step
takes
very
long
and
then
the
application
compatibility
codes
behaves
a
bit
differently
than
if
it
runs
on
playing
jvm.
So
may
you
may
have
all
sorts
of
issues
with
wellvm,
but
it's
definitely
good
to
try
it.
If
your
obligation
works
as
well
VM,
you
can
get
very
fast
startup
types,
but
even
without
that,
it's
good
to
have
an
option
to
work.
A
Java
application
without
these
necessary
steps,
just
plain
Java
application-
and
sometimes
you
get
even
benefits
from
this,
because
just
in
time,
compiler
of
java
virtual
machine
makes
your
application
run
fast
and
once
it's
already
running.
So,
if
you
have
a
longer
running
request
for
a
couple
of
seconds
or
minutes,
you
can
get
much
better
performance
than
running
on
jvm
instead
of
running
with
Ralph
VR
and.
B
A
Need
something
that
starts
faster,
I
would
recommend
using
native
compilation
and
ravian,
because
it
brings
a
lot
of
a
lot
of
other
problems.
It's
also
a
lot
of
problems,
but
it
also
may
bring
you
some
other
issues
later
and
Verona
is
very
convenient
to
an
application
in
AWS
Wonder
because
it
doesn't,
it
doesn't
require
to
run
a
HTTP
listener.
You
can
easily
build
an
appear
on
the
application.
You
know
Jakarta
application
on
PRN
without
the
HTTP
listener
adjustment
code,
because
this
is
actually
how
AWS
on
the
runs.
It
doesn't
start
your
server.
A
It
just
runs
your
code.
It
just
calls
your
message
and
all
the
handling
of
the
HTTP
requests
or
any
even
that
triggers
your
Lambda
is
handled
by
AWS
infrastructure
and
AWS
logger
just
hooks
into
your
method
and
calls
your
codes
in
Lambda.
You
can
initialize
a
lot
of
things
in
static
blocks
so
that
they
are
only
initialized
first
time
the
Lambda
is
warmed
up,
and
next
time
is
when
it's
sketched
and
reused.
A
You
don't
have
to
initialize
that.
So
this
is
pretty
easy
with
pyramid,
because
you
can
just
create
the
engine
in
the
static
ball,
gun
and
reuse
it
for
every
every
method
lubrication
later
and
it
put
on
the
stats
fast,
as
you
do
so
so,
there's
even
there's,
even
though
it's
not
zero
seconds,
it
can
be
200,
300,
milliseconds,
very
close
to
zero
and
even
with
cold
Stars.
The
first
time
the
Lambda
is
needed.
You
don't
suffer
with
very,
very
long
slowdowns.
A
The
disadvantage
with
perana
right
now
is
that
it
requires
to
have
a
70..
Some
people
don't
care
like
a
lot
of
projects
out.
There
are
already
on
the
other
17,
but
unfortunately,
AWS
doesn't
support
Java
17
natively
to
run
Java
70
applications.
You
would
need
a
custom
Java
17
layer,
so
this
is
actually
what
I
did
to
to
run.
A
Java
pyramid.
Application
on
clouds
or
item
is
under
and
to
prepare
everything
I'm
using
AWS
cdk,
which
is
clouds
development
kits,
and
it's
basically
a
way
out
to
configure
configure
the.
A
So,
just
shortly,
I
don't
have
much
more
time,
but
I
will
just
briefly
show
you
so
that
you
just
have
a
taste
of
it.
This
is
how
the
code
looks
like
in
Java
from
java.
You
can
specify
that
you
create
AWS
longer
instance,
that
you
want
to
use
this
custom
Java
17
layer
which
just
basically
zip
file
that
contains
the
Java
17
jdk
and
then
use
create
your
function.
A
B
A
Simple
as
it
gets
when,
when
you
know
what
you're
doing-
and
this
is
very
simple-
you
don't
need
to
remember
how
to
divide
it
in
Yamato,
there's
a
nice
API
in
Java
and
the
application
actually
looks
very
similar
to
us
into
the
application
that
I
showed
you
before
it
just
now
uses
the
AWS
interface
request.
Angler
and
AWS
calls
this
method
on
every
request,
but
it
also
calls
all
the
static
Parts
on
the
first
request.
A
B
A
Thing
we
need
to
do
is
to
actually
build
build.
Our
request
object
from
what
we
get
from
AWS,
so
we
have
to
turn
in
this
in
this
object.
This
API
Gateway
object
into
the
period
request,
so
there's
some
mapping
between
them
and
then
the
same
thing
with
the
response.
So
we
need
to
create
the
API
Gateway
response
from
the
response
that
we
get
from
here,
but
in
between
these
two
boilerplate
parts,
that
is
just
appear
on
a
service
that
we
already
saw
before,
and
this
will
call
again
the
servers.
A
B
Pushing
the
time
limit,
but
I
think
this
is
going
to
be
a
amazing
addition
to
our
Jakarta
Tech
talk,
so
we
will
work
with
you
to
add
you
to
the
list,
so
we
can
spend
a
little
bit
more
time
on
on
this
topic.
So
at
this
point,
I
would
like
to
thank
you
so
much
and
I
would
like
to
thank
Ariane
who
was
answering
the
questions.