►
From YouTube: Deploying Your Spring Boot Application In Amazon Managed Kubernetes Service (EKS) by Divine Odazie
Description
The Java programming language remains a global leader for building enterprise applications. Using Spring Boot – a Java-based framework, new Java developers can create Spring-powered, production-grade applications and services with absolute minimum fuss. This tutorial will teach you how to deploy a Spring Boot application in Amazon Managed Kubernetes Service (EKS). From scratch, you will learn by creating a Spring Boot application, deploying it to Minikube, and then onto EKS.
---
KCD Africa 2022 is the 2nd iteration of the Kubernetes Community Days Africa, a CNCF-powered free community event. Visit https://kcdafrica.com for more information.
A
B
B
The
steps
you
follow
in
this
particular
session
would
be.
First,
you
create
this
spring
boots
application.
Then
you
dockerize
this
springboard
application
after
the
colorizing
springboard
application.
In
order
to
like
understand
how
kubernetes
work
before
we
move
on
to
like
to
eks
we'll
deploy
the
display
dockerized
image
on
locally
on
mini
cube,
which
is
a
onenote
kubernetes
cluster,
then,
in
order
to
use
the
application
on
eks,
we
push
the
dockerize
image
to
amazon
elastic
container
registry.
B
B
Now
you
need
to
have
mini
cube
installed
on
your
machine
I'll
cover
how
you
can
install
mini
cube
in
this
slide.
You
need
to
have
an
aws
account,
then
also
create
a
user
with
admin
access
on
ews,
iam
aws.
You
need
to
also
need
to
have
aws
cli
installed
on
your
machine
and
qctl
in
order
to
communicate
to
the
kubernetes
cluster
you
create
locally
and
also
on
amazon
dks.
B
So
before
we
start,
let's
overview
some
of
the
major
tools
we'll
use
in
this
session.
So
first
we
use
spring
boot
spring.
Boot
is
a
java
based
framework
for
building
spring
power.
Applications,
production
grid
applications
and
services
is
absolutely
unique
for
us
and
how
you
can
do.
That
is
because
springboard
has
abstracted
somewhat
configuration
that,
ideally,
you
do
with
spring
and
also
the
open
united
approach
makes
you
do
stuff
in
a
specific
way,
and
it
gives
you
production,
ready,
features
like
metrics
or
checks
external
configuration
and
has
an
embedded
tomcat
server
and
abstracts.
B
The
need
for
xml
configuration
that
normally
you
do
in
spring
with
spring
boots:
flexible
packaging
options,
packaging
into
java
files,
wire
files,
packaging
application
into
a
container
image.
You
can
deploy
your
application
on
several
basically
anywhere
right
can
deploy
on
cloud
platforms.
The
permissions
blue
machines
and,
in
this
session,
as
the
title
saves,
will
deploy
your
package
into
a
container
image
and
deploy
on
aws
ecr,
then
aws
eks,
amazon
managed
kubernetes
service.
B
The
next
mini
cube.
Basically
in
a
production
cluster,
there
will
be
multiple
what
kind
of
master
and
volcanoes
right
across
several
fitcom
virtual
machines
and
doing
that
require
a
lot
of
signal.
A
lot
of
system
resources,
cpu
resources,
storage
resources,
which
is
not
possible
when
working
with
quantities
on
your
local
machine.
So
many
cube
abstracts
all
that
and
gives
you
all
the
master
node
processes
on
one
single
cluster.
So
that's.
B
Why
I
said
earlier
in
onenote
companies
cluster
on
your
machine
on
your
mac,
os
your
linux
and
your
windows
machine
and
focuses
on
helping
application
developers
and
new
kubernetes
users
application
developers
to
trying
out
stuff
locally
before
going
to
production
and
also
onboarding
new
users
and
to
try
out
kubernetes
initially,
so
you
can
get
mini
cube
from
the
docs.
If
you
don't
have
it
on
your
machine
already.
B
Basically,
you
can
just
google
how
to
install
mini
cube
and
you'll
be
able
to
get
the
link
that
I
put
in
this
slide
and
next
the
amazon
elastic
container
registry,
just
like
docker,
hope,
github
container
registry
amazon
ecru
is
a
fully
magical,
fully
managed
container
registry
that
offers
high
performance
hosting.
So
it
offers
all
those
features
plus
other
features
that
docker
hub
and
guitar
guitar
continuation
and
other
containers.
Don't
like
limit
table
tags
image
tags.
B
So
the
main
stuff
we'll
do
in
this
session
will
be
on
amazon
manage
kubernetes
service,
which
is
a
managed
company
service
that
abstracts
all
the
effort
required
to
create
a
kubernetes
cluster.
You
need
to
install
and
now
maintain
your
own
kubernetes
control
plane
and
give
you
all
the
advantage
of
using
aws
scalability
reliability,
all
the
aws
infrastructure
and
its
integrations.
B
As
I
talked
about
earlier,
I'm
working
with
eks
radar,
first
of
all,
provisionally
costa
irani
case
costa,
and
it
automatically
deploys
the
kubernetes
master
and
ormata
rada
and
who
then
will
deploy
work
and
worker
nodes
and
in
order
to
communicate
to
the
kubernetes
cluster
on
eks,
we'll
use
kubectl,
which
we
also
use
to
communicate
with
the
onenote
cluster,
which
will
be
created
by
minicube,
we'll
use
qctl.
Then
we'll
deploy
our
applications
on
eks.
It's
demo
time
all
the
commands
codes,
yama
configuration
and
some
aws
specific
skip
steps.
I
will
talk
about
along
the
line.
B
B
So,
ideally,
you
use
create
a
springboard
application
using
the
spring
initializer
the
start.spring.io,
but
for
this
session
in
this
tutorial,
I'm
going
to
create
it
with
intellij
on
the
intellij
idea,
ide,
so
click
on
new
project,
then
we'll
name
the
project,
kcd
africa
we've
got
springboards,
it's
pretty
good.
The
application
is
going
to
be
based
on
java
version,
java,
17
and
next
create
the
application
we'll
select
the
dependency
to
use
which
spring
well,
because
I'm
going
to
create
a
restful
api.
C
B
This
would
be
a
restful
controller
to
test
our
application,
so
we're
going
to
annotate
it
to
the
right
to
control
our
annotation.
I'm
going
to
create
just
two
end
points.
One
will
be
the
index
endpoints,
then
the
other
one
will
be
just
the
name
endpoint.
So
let's
get
using
the
get
the
get
mapping,
rotation.
C
B
B
B
B
B
To
dockerize
the
application
first
of
all
created
a
docker
file,
so
there
are
the
other
ways
you
can
localize
the
spring
boot
application.
You
can
use
this.
You
can
use
mid
view
wrapper.
I
use
the
build
image
plugin
to
build
the
application
to
build
and
view
the
image,
but
here
we
create
a
docker
file.
So
let's
touch.
B
B
B
C
C
B
B
B
B
I'm
using
mini
cube
on
mac
or
m1
upper
silicone,
so
I
don't
think
you
get
the
same
outputs
on
linux
on
windows,
so
for
us
to
deploy
that
particular
image
right.
Ideally,
we
have
to
deploy
the
image
onto
a
container
registry,
so
maybe
docker
orb,
as
you
see
in
this
demo,
we're
going
to
be
using
amazon
ecr
both
for
this
right
instead
of
before
we
go
on
to
deploying
to
ecru
and
for
us
not
to
deploy
to
the
hub
we're
going
to
create
a
locale
registry.
B
B
So
as
well
as
currently
I
don't
have
the
registry
2
image
locally,
it's
going
to
find
image
and
projects
it's
going
to
take
a
few
seconds
depending
on
the
internet.
So,
yes,
I
have
the
emails.
I
can
do
docker
ps
to
check
that's
currently
running.
You
can
see
virtual
image
on
ports
5000,
so
we
then
next
right
we
have
to
point
the
local
registry
to
mini
cube,
so
we
pointing
localization
to
mini
cube.
So
when
we
deploy
our
application,
it
will
be
able
to.
It
will
be
able
to
find
the
application.
B
Now,
after
pointing
mini
cube
to
the
local
registry,
you
calculate
you,
then
need
to
and
to
check
if
to
check,
if
the
points
works,
you'll
notice
that
now
you're,
seeing
all
the
images
in
mini
cube,
are
no
longer
images
on
this
particular
session.
You
showing
images
in
mini,
cube
and
not
images
on
your
normal
docker
environment.
So
if
you
check
here
on
the
terminal
of
the
springboard
application
images,
you
see
different,
it's
not
the
same
as
this
right.
B
So
because
of
this,
you
need
to
rebuild
the
image,
so
you
can
do
that
with
docker
docker,
build
targets,
kcd,
springboard,
image,
t
and
view
the
image.
So
I've
already
done
that,
like
you
can
see
here
above
so
next,
you
need
to
tag
this
image
that
you
built.
You
need
to
type
this
image
that
has
been
built
so
points
to
be
able
to
push
the
image
to
your
localized
registry.
You
need
to
target
the
okay
to
explain
this
better.
B
B
Five
thousand,
so
if
you
remember
registry
is
talking,
is
on
ports,
five
thousand,
so
this
is
where
the
registry
is
five
thousand,
then
the
tag
of
the
registry.
So
if
you
remember,
I
said
for
docker
for
docker
hub
his
username
and
the
username
of
your
docker
account
local
accounts.
Then
you
repository
name,
but
for
this
we'll
give
it
the
who
uses
the
port's
name,
localhost
5000,
which
is
the
ports
directory,
called
the
listing
on
then
the
repository
name
and
which
will
give
you
the
latest
tag.
So
the
repository
name
we
use
for
this.
B
We
can
use
the
same
reposition
here
we
see
in
when
we
are
using
amazon
ecru.
You
see
how
we
do
that
using
when
we
tag.
We
see
you
see
when
we
tag
the
image
with
a
copy
with
the
repository
uri.
So
when
we
get
to
that,
you
better
understand
what
I'm
saying
so
type
the
image.
Then
the
image
has
been
tagged
and
you
can
view
it
with
docker
images.
C
B
When
I
run
docker
push
with
the
image
down,
I
noticed
that
it
refused
to
connect,
and
this
was
because,
if
you
notice,
I
explained
we
point-
we
pointed
mini
cube
to
the
local
registry,
so
it
kind
of
deleted
the
image
this
didn't
happen
before.
So
I
have
to
recreate
the
image
and
it's
currently
running,
so
let's
try
to
push
it
again.
B
Okay,
now
now
the
spring
out
spin
boot
application
in
the
local
registry.
Next
we
need
to
create
a
deployment.
The
component
is
deployment
so
to
do
that,
we
create
a
deployment
via
the
command
line.
The
terminal
without
having
to
create
a
yam
offer,
will
use
the
driver
on
client
flag,
which
will
create
the
entire
yaml
manifest
templates.
So
let's
see
how
to
do
that.
Cuban
ctrl
create
deployments.
C
C
B
B
B
C
B
B
You
can
see
the
port
it's
currently
running,
so
in
order
to
test
and
see
this
application,
that's
connected
to
the
application.
Without
the
springbook
application
just
deployed,
you
have
to
expose,
as
we
expose
the
port
8080
with
service,
we
cannot
access
it
externally
on.
Let's
say
we
go
to
browser
and
then
put
8080
you'll
be
able
to
access
the
application
in
order
to
access
the
application.
You
have
to
create
an
ssh
thumbnail,
so
customize
the
system
using
port
forward,
but
to
do
that
cube
ctl.
B
B
B
Before
you
can
push
your
container
image
to
amazon
ecru,
you
need
to
make
sure
that
you
have
aws
cli
installed
on
your
terminal.
So
if
you
run
you
write
the
command
aws
cli.
If
you
don't
get
any
response
similar
to
this,
then
you
have
to
like
install
aws
like
that,
so
we're
not
going
to
install
in
this
session
because
I
already
have
it
installed
or
you
can
just
google
and
you'll
be
able
to
get
the
information
to
store
for
a
particular
machine.
B
So
after
that
I
don't
know,
if
you
recall,
I
made
mention
of
how
creating
an
iem
user
for
this
particular
session
which
had
been
accessed
so
instead
of
using
your
the
root
user
of
your
aws
account.
So
you
should
have
also
done
that
then
next,
you
need
to
authenticate
and
configure
your
cli.
So
now
that's
configure.cll!
You
do
aws
configure
configure
your
cli
to
the
particular
local.
B
B
For
me
I
will
just
it'll
just
configure
lists,
so
I
will.
I
can
see
that
I'm
already
configured
the
access
key
is
the
security
and
the
region
usb
1..
So
after
that,
in
order
to
push
to
amazon
ecr,
I
need
to
first
of
all
create
a
repository.
So
just
like
the
registry,
you
created
right
when
you're
deploying
to
mini
cube,
just
like
docker
hub
when
you're
deploying
to
docker
hub
you
create
a
repository
under
your
account.
I
need
to
create
a
repository
on
ecr,
so
let's
create
a
repository
I'll
use,
this
command.
B
B
B
So
when
we
create
the
image
on
our
repository
and
when
we
push
the
image
to
the
repository
particular
version
of
the
image
the
tab
in
this
latest,
it
will
be
unchangeable
now
what
imitable
means
it
is
a
test,
whatever
we
name
it
as
we'll
get
to
see
that
and
also
image
scanning
configurations
scan
and
push.
So
this
now
tells
the
cr
discount,
like
I
may
mention
about
the
security
features
of
ecrs.
This
can
be
image
for
any
security
vulnerabilities.
B
Once
you
run
the
command,
you
should
receive
a
json
output
of
json
objects
like
a
response
of
the
repository
id
name,
we
repository
url
and
it
is
created.
So
in
order
to
check
that
this
repository
was
actually
created,
you
can
just
go
to
your
aws
accounts.
Ecr
accounts,
you
log
in
so
I
already
have
a
demo
repository.
So
I
refresh.
B
Once
I
refresh
I
can
see
this
is
the
question
africa
demo
repository
has
been
created,
your
repository
uri.
Then,
if
you
check
in
the
repository
there
is
no
image.
So
next
I'm
going
to
push
our
image
to
this
particular
repository
before
you
can
push
the
image
to
this
particular
repo
to
the
repository
to
this
repository
first
of
all
need
to
log
in
to
the
repository.
So
we
do
that
by
okay,
first
I'll
copy
the
repository
uri.
B
C
C
B
B
You
get
the
login
succeeded,
then
you're
successfully
logged
into
the
kcd
demo
repository
africa.
This
is
the
africa
demo
repository
then
next
we
need
to
tag
this
particular
image.
The
image
that
we
built.
If
you
remember
the
image
that
we
built
local
images,
this
is
springboard
demo
image
springboard
image.
You
need
to
type
the
image
with
the
username
right,
the
image
name
and
tag
so
to
do
that,
just
like
we
tagged
before
pushing
to
the
local
registry,
so
we'll
first
of
all
go
docker
tag.
The
repository
name
is
just
tag.
B
B
C
C
B
B
Now
see
the
image
and
see
all
the
details
of
the
image.
Next,
you
then
work
with
eks
to
deploy
your
application
to
work
with
amazon
eks,
that
is,
to
deploy
the
image
we
have
currently
out
of
amazon
ecru
to
a
kubernetes
course
on
ets.
We
need
the
amazon
equals
cli
tool,
so
I
currently
have
the
sale
to
install.
So
let
me
show
you
that
with
the
command
eks
cto
version,
so
I
can
see
the
version
of
eks,
so
an
error
for
the
question
of
details.
B
I
have
in
order
for
you
to
install
that
you
can
just
google
and
to
take
you
to
the
eks
documentation.
So,
as
we
have
gotten
in
case
now,
now
we
have
the
cli.
We
will
now
need
to
deploy
credit
cluster
and
then
deploy
our
credit
deployment
and
a
service
on
the
cluster.
So
before
that,
when
you've
gotten
the
eks
cli
tool
on
your
machine,
you
can
now
get
on
to
deploying
the
image
on
creating
a
kubernetes
cluster
and
deploying
the
image
on
venetis,
but
before
that,
let's
just
overview
creating
kubernetes
clusters
on
the
case.
B
So
an
amazon,
ks
cluster
consists
of
two
primary
components:
the
control
plane
and
work
on
those
registered
with
the
control
plane,
so
the
workout
missions,
which
are
part
of
the
compatibility
because
so
this
worker
knows,
like
I
say
earlier,
I
remember
the
slides.
You
deployed
the
worker
note
yourself
as
eks
provisions
the
master
nodes
for
you.
It
just
deploys
the
master
nodes
for
you
upon
creation
of
the
cluster.
So
next
before
we
can
do
that,
there
are
some
other
considerations
that
are,
let's
say,
peculiar,
somewhat
particular
to
amazon
eks.
B
So
what
you
need
to
consider
when
using
amazon
equals,
so
we
have
vp,
vapor,
vector
private
cloud,
configuration
security
group
consideration
so
to
launch
and
configure
an
eks
cluster.
You
need
to
specify
subnets
for
vpc
subnets,
which
are
practical,
subnets
required
for
the
cluster
to
be
hosted
in
and
now
right
you
can
create
a
private
subnet.
You
can
create
a
public
cloud
in
this
particular
section.
We
will
create
the
private
subnet
and
we
could
use
the
private
subnet
and
yeah.
B
This
is
to
maintain
high
availability
and
we
are
required
to
put
at
least
two
availabilities
from
zones
we'll
see
how
to
do
that.
Also
from
security
considerations,
when
the
worker
nodes
are
deployed
right
in
order
to
configure
like
eks
automatically
configures
communication
between
what
happens
on
the
control
plane
and
constructed
in
a
way
that
communication
like
for
privileged
ports,
ports
right
so
in
order
to
like
access
applications
via
an
external
api
that
will
be
generated
when
we
deploy
the
application
and
also
other,
let's
say,
other
access.
B
Let's
say
you
want
to
implement
accessing
their
load,
balancing
and
implement
dns
and
some
other
features
you
need
to
add
an
additional
inbound
rule
or
outbound
group.
Depending
on
the
specification
you
want
to
create
so
for
this
particular
session,
we're
just
going
to
when
we
are
when
we
work
on
security
group,
we're
just
going
to
create
an
inbound
group
for
the
particular
ports
for
which
we
listen
to
we'll
be
able
to
access
our
application
on
the
web.
B
B
Then,
to
edit
poster
that's
vmware,
okay,
then
I've
already
written
the
poster
configuration
for
my
particular
with
my
particular
subnets
and
to
create
the
workout
mode.
So
let
me
copy
that
and
paste
it
here.
Don't
worry
I'll
explain
this.
So
if
you
look
from
the
beginning,
we
see
the
api
version.
The
kind
which
is
cluster
configuration
the
name
metadata,
then
the
vpc,
the
virtual
private
cloud
subnet.
So
I
set
it
as
private
subnet.
So
these
are
subnets
peculiar
to
my
the
iem
user
I
created
earlier.
B
The
idea
is,
I
created
and
I've
been
using
trout
in
this
session
and
these
these
node
groups
here
node
groups
here,
amazon
eks,
has
a
feature
called
node
groups
right.
A
management
script
feature
that
automates
the
professional
in
a
life
cycle
of
lifecycle
management
of
nodes,
which
will
be
on
user
ecq
instances
for
each
amazon,
each
eks
kubernetes
cluster,
so
the
node
groups
are
being
updated
to
you
know
to
be
updated,
related
version
of
kubernetes.
B
So,
like
basically,
you
know
when
we
talked
about
when
I
talked
about
ets,
handling
the
deployments,
maintenance
and
some
other
stuff.
You
do
normally
it's
kind
of
like
a
self-managed
company,
this
coaster.
So
this
now
because
managers
load
groups
manages
the
nodes
for
you.
So
again
we
have
worker
nodes
and
they
are
of
type
three.
The
is
that
skype
is
type
creation
moto
to
okay.
Before
that,
let's
see
how
to
get
the
subnet,
how
to
get
the
subnet
on
your
aws
account.
B
B
B
So
these
low
cost
versatile
cpu
performance
instance
right,
that's
just
for
okay,
it's
not
something
you
use
when
you
want
to
build
an
application
that
has
that
received,
let's
say
thousands
or
hundreds
of
thousands
of
like
real-time
users
at
a
particular
time.
So
this
is
just
a
small
instance
for
this
specific
demo,
so
yeah
it
does
that
and
we
have
the
group
builders
for
building
the
containers,
images
and
pulling
and
building
the
images.
B
B
So
he's
currently
creating
using
dividend
grades
in
the
costa
and
particular
region,
so
this
will
take
some
time,
so
this
will
take
some
time
to
create
and
deploy
the
worker
nodes.
So
I'll
see
you
when
it's
done
so
that
really
took
a
while.
So
we
can
see
that
the
cluster
has
been
created
in
the
quesadilla
cluster
located
in
the
new
small
region
and
is
ready
and
also
on
the
aws
console
eks.
You
can
see
that
the
cluster
is
ready.
So
if
you
click
on
it
see
nothing,
there's
no
resource.
B
Yet,
okay,
not
okay!
There
are
resources
here,
the
ideal,
kubernetes
resources
and
the
nodes
have
been
deployed.
You
can
see
them
here,
nodes
with
the
t3
installs
three
small
instance.
Then
also
right.
So
if
you
remember
at
this
step,
see
when
working
with
this
figure
now,
what
can
it
because
connected?
It
is
right,
so
we
will
skip
that
step
because
eks
vks
cli2
has
already
done
that
for
us.
So
when
you
look
through
here,
you
see
saved
cube,
config
tube
config
configuration
as
so.
B
B
B
Okay,
so
we
can
see
all
the
nodes
and
keep
system
on
all
the
defaults
run
all
according
to
running,
so
our
cluster
is
fine.
Then
next
we
need
to
create
the
deployment
of
the
course
advocated
it's
time
for
us
to
create
the
deployment
to
deploy
our
image.
So
as
we
did
for
the
cluster
yammer
file
I'll
create
a
new
file
in
case
the
comment,
I
don't
know
why
I'm
always
making
mistakes.
B
B
Especially
the
africa
demo
deployment
it
requires
two
replicas
sets
right,
two
replicas.
So
when
we
create
this
deployment,
when
we
apply
this
deployment,
you
create
supports
and
the
name
and
the
container
this
name
of
the
container-
and
if
you
see
here,
I
get
the
placeholder
for
image
uri.
So
you
get
the
uri
of
this
specific
image.
You
deployed
on
the
immediate
specific
image
tag
we
deployed
on
eks.
So
if
you
have
like,
if
you
deployed
your
version
of
your
image
right,
you
can
change
the
image
stuff.
B
B
So
I'm
using
the
vi
editor
here,
because
it's
I've
been
using
video,
mostly
because
of
what
you
use
as
a
devops
engineer,
but
you
can
use
now
know
to
create
an
editor
file
you
can
also
use
detected.
It
depends
on
what
you
like
there
you
are,
so
this
is
the
url.
So
this
is
our
demo.
The
demo
repository
on
the
ecro,
your
demo
repository
recorded-
and
this
is
the
image
tag,
so
it
gets
the
latest
image
this
particular
image.
I
need
to
build
the
created
deployment
and
this
with
this
image.
C
B
And
then
look
at
the
make
sure
that
it
was
saved.
It
clears
deployment,
dot
yammer,
so
you
can
see-
and
also
I
forgot
to
mention
the
port
is
listening
to
so
the
container
part
is
listening.
You
remember
when
we
created
the
container,
we
suppose
but
8080
so
to
be
listening
to
this
8080
so
yeah.
When
the
image
is
running,
it's
running
images
in
the
container
so
yeah,
then
you
need
to
apply
this
deployment.
So
cto
dto
apply
killer
deployment.
B
B
C
B
So
what
kind
service
the
name
the
type
this
tablet
is
not
third
service
manager
communicates
for
all
the
nodes
communicated
and
we
define
the
ports,
the
node
ports
and
for
external
traffic.
So
we're
opening
this.
Let's
report
forward
traffic
and
deposits,
three
one,
four,
seven,
nine!
So
when
we
get
to
accessing
the
api
we
are
like,
we
can
see
in
the
step
these
steps
assessing
the
application
there
and
external
api
address,
we'll
see
how
we'll
go.
B
Take
the
security
group
in
consideration
they're,
going
to
go
feature
of
eks
and
contribution
to
then
create
an
inbound
rule,
not
allow
traffic,
so
yeah
then
increasing.
This
is
the
part
of
the
service
customer
stuff
to
this
port,
then
target
port
where
the
container
is
actually
running
so
yeah,
then
we
need
to.
Let
me
save
this.
B
B
So
currently
all
nodes
are
ready,
and
now
we
can
talk,
we
can
now
we
can
external.
We
can
access
our
application
via
one
of
these
ip
addresses
this
external
ip
addresses.
So
to
do
that,
connect
the
ip
address
down
to
that
we
need
to
create
a
rule
and
inbound
rule
in
the
security
group.
Let's
create
an
inbound
rule
in
the
security
group.
So
let's
set
security.
B
B
So
when
you
create
that
when
you
find
that
particular
security
group
you
go
and
you
create
an
inbound
rule,
so
I've
already
created
an
inbound
route
that
is
listening
to
the
ports
301,
the
notepad
31479
for
external
traffic,
so
it
just
has
to
show
how
to
create
any
boundary,
yes
yeah.
So
this
is
the.
B
B
Oh
sorry,
arrow
three,
one,
five,
three
one,
four,
seven,
nine
yeah
yeah
hello
world,
then
to
test
the
name
endpoints,
my
name
is
divine
audacious.
So
you
followed
me
on
work
through
creating
a
springboard
application
on
the
queries
in
the
springboot
application,
deploying
the
application
locally
in
onenote
cluster
mini
cube.
Also,
we
pushed
the
dockerized
image
of
the
application
to
amazon
elastic
container
registry,
created
the
kubernetes
cluster
on
eks
and
deployed
the
application
on
the
kubernetes
cluster
and
finally
using
the
eks
future.
We
are
able
to
access
the
application
with
an
external
ip
address.
B
So
thank
you
for
listening
to
this
session
and
for
following
along
you
can
follow
me
on
twitter.
This
is
my
art,
twitter,
divine
orders.
Here
I
underscore
dazzy
and
divine,
as
is
also
my
name
on
linkedin.
I
hope
you
enjoyed
this
session,
and
this
is
this
all
this
was
recorded.
I
don't
know
if
you
noticed
so
I'll
be
live
in
case.
You
have
any
questions
and
I'll
be
live
to
answer
all
your
questions
regarding
this
particular
session.
Thank
you
and
I
hope
now
you
you
know
how
to
deploy
your
springboard
application
in
amazon,
managed
communities.
A
D
D
D
D
D
B
B
When
I
pushed
the
image
to
ecro
when
I,
after
creating
applying
the
deployment
like,
I,
I
still
stopped
for
like
five
hours
trying
to
resolve
because
the
image
was
not
like
building.
It
was
not
running
so
like.
I
noticed
that,
like
I
didn't
remember,
wow
I'm
using
the
m1
chipset
and
my
nodes
are
based
on
amg64,
so
I
have
to
like
set
up
a
vm
with
colima,
which
is
a
container
on
time
for
lima
linux,
on
mac
os
and
then
after
I
did
that.
B
I
had
to
then
view
the
image
on
the
vm
to
be
on
amd
64
before
pushing
it
to
ecr
and
then
so
like
it
was
just.
The
m1
chip
has
just
been
like
making
my
life
a
lot
harder
as
doing
develop
stuff
so
yeah.
I
think
that's.
Why
being
I
kind
of
covered
it,
but
I
had
to
like
remove
it
in
order
to
make
the
talk
a
little
bit
to
meet
the
time
slots
here.
D
B
Okay,
sorry,
I
was
amazed
okay,
so
the
local
repository
created
is
just
like
it's
not
something
you
do
in
a
production
environment
right,
it's
just
for
testing
purpose.
So
it's
just.
Instead
of
like
the
demo,
I
had
to
focus
on
ecr
amazon
instead
of
pushing
to
docker
hub.
So
in
order
to
just
make
things
faster,
I
use
the
repository
registry
image,
the
registry
image,
the
animation
doc,
and
I
use
the
image
to
create
a
local
repository
for
that
particular
session.
D
D
B
So,
depending
on
how
you
provision
you
deploy
your
nodes
right,
so
I
don't
know,
I
kind
of
missed
talked
about
that
a
bit
earlier
when
I
joined
the
course,
so
you
have
to
make
sure
that
your
node
runs
on
the
same
architecture
as
your
image.
If
not
it
won't,
it
won't
be,
it
will
deploy
right
or
it
will
run.
You
get
like
a
crash
loop,
backup
status,
which
will
lead
to
an
error.
It
should
just
keep
restarting.