►
From YouTube: Cloud Native Live: Get more with multi-arch clouds
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
So
glad
you're
here
here
we
dive
into
the
code
behind
Cloud
native
I'm,
your
host
today
I'm
Whitney
Lee
and
I'm,
a
cncf
Ambassador
and
a
developer
Advocate
at
VMware
every
day.
Every
week.
Excuse
me:
we
bring
new
presenters
to
Showcase
how
to
work
with
Cloud
native
Technologies,
we'll
build
things
we'll
break
things
and
we'll
answer
your
questions
today.
We're
going
to
save
all
the
questions
to
the
end
and
have
a
discussion
after
the
presentation
here
with
us.
Now
we
have
Jason
Andrews
he's
here
to
teach
us
about
how
to
get
more
with
multi-arch
clouds.
A
So
this
is
an
officials
live
stream
of
the
cncf
and,
as
such,
it's
subject
to
the
cncf
code
of
conduct.
So
please
don't
add
anything
to
the
chat
with
that
would
be
in
violation
of
that
code
of
conduct,
so
basically
just
be
nice
to
each
other.
Be
nice
to
the
presenter,
be
nice
to
me.
You
got
this.
We
can
do
it
so
friends
who
are
joining
us
live.
A
Please
say
hello
in
the
chats
and
say
where
you're
from
I
love,
how
we're
a
global
Community
I
just
think
it's
the
coolest
thing
ever
so,
if
you
have
any
questions,
please
post
them
to
the
chat
and
we'll
get
to
them
at
the
end,
and
then,
with
that
I'll
hand
it
over
to
Jason
Andrews
to
kick
off
today's
presentation.
Jason
tell
us
about
yourself.
Please.
A
B
Okay,
all
right
everybody,
so
I'm
just
going
to
start
off
today
with
a
couple
quick
slides
just
to
give
you
a
little
bit
of
orientation
of
where
things
are
and
what
we're
going
to
talk
about,
and
then
we're
going
to
spend
the
majority
of
our
time
with
some
hand,
sign
activities
around
multi-architecture
infrastructure,
primarily
with
kubernetes.
Today,
that's
what
we're
going
to
talk
about
so.
A
B
I
mentioned
I'm
coming
from
arm
and
our
developer
ecosystem
group,
and
one
of
the
reasons
we're
here
to
talk
to
you
today
about
multi-architecture
is
that
the
arm
architecture
is
ramping
up
and
gaining
a
lot
of
attraction
in
different
areas
of
cloud
computing.
So
you
can
see
different
cloud.
Service
providers
have
been
adding
arm
instances
and
virtual
machines
and
a
lot
of
managed
Services,
which
all
run
on
our.
So
as
a
developer,
you
might
want
to
take
advantage
of
those,
so
yeah
I
guess
first
point
is
arm
is
growing.
B
The
architecture
is
spreading
in
many
different
kind
of
places,
and
then
you
might
ask
yourself
well
well
why
I
mean
what
what's
the
benefit
for
me.
So
as
a
developer,
there's
probably
three
main
things
that
you
want
to
think
about
here.
One
is
performance,
a
second
one
is
going
to
be
reduced
cost
and
the
third
one
is
sustainability.
B
So
lots
of
projects
are
looking
into
the
arm
architecture
as
a
way
to
really
benefit
from
Better
Price
performance,
as
well
as
build
sustainability
and
the
resources
that
they're
using.
So
that's
really
I
would
say
the
main
reason
why
people
look
into
the
arm
architecture.
Price
performance
is
a
big
one.
It's
always
better
to
run
fast
and
cost
less.
So
that
might
be
a
reason
why
you
look
into
the
the
architecture.
So
the
good
news
about
the
arm
architecture
is
lots
of
things
already
work,
so
lots
of
software
already
Works.
B
In
fact,
I
would
say
most
software
already
works,
but
as
a
developer,
if
you've
been
working
in
a
single
architecture
for
a
long
time,
this
might
be
a
little
bit
new
to
you
and
how
to
migrate
and
how
to
think
about
having
multiple
architectures
in
your
environment.
So
that's
what
we're
going
to
talk
about
today,
so
I
really
encourage
you.
If
you
haven't
spent
a
lot
of
time
with
the
arm
architecture
or
anytime,
the
best
way
to
get
started
is
to
just
get
a
machine
right.
B
There's
lots
of
ways
you
can
get
a
virtual
machine,
whether
that
be
on
your
laptop
up
or
in
the
cloud.
There's
there's
different
places.
You
can
do
that
and
then
I
would
just
experiment.
Ask
you
to
you
know
just
kind
of
experiment
with
your
projects
your
dependencies,
what
what
kind
of
things
work?
Maybe
you
find
something
that
doesn't
and
just.
A
B
Terms
of
what
some
other
things
you
need
to
think
about,
so
maybe
some
dependencies
yeah
take
a
quick
scan.
Look
over
your
libraries,
Frameworks
runtimes,
different
things
that
you
use
in
your
projects
and
see
if
they're
supported
on
on
our.
In
most
cases
most
software
is
already
working.
I
mean
all
the
Linux
distributions.
A
lot
of
the
tools
you
use
probably
are
already
there.
It's
not
a
big
deal,
but
typically
what
I
encourage
people
to
do
is
just
kind
of
make
a
little
bit
of
a
checklist
or
investigate
some
of
your
issues.
B
You
might
see
a
container
that
doesn't
work
on
harm.
Okay,
I'll.
Just
put
a
note,
make
make
a
note
of
that,
and
you
know
keep
that
in
my
pocket
as
I
continue
forward
in
my
my
journey.
The
other
thing
to
point
out
is
newer
is
better.
That's
not
always
the
case
in
software
development,
but
because
the
arm
architecture
is
newer
in
server
and
Cloud.
You
probably
want
to
use
the
latest
newer
software
if
possible,
that
will
typically
help
you
a
couple
other
tips
before
we
get
into
the
the
Hands-On
part.
B
You
know
if
you're
running
things
that
are
interpreted
languages,
it's
usually
very
straightforward.
Everything
is
typically
the
same.
If
you're
doing
things
like
Java,
you
might
find
that
the
performance
improves
significantly
on
newer
versions.
So
I'd
encourage
you
to
try
newer
versions
if
possible.
Another
little
bit
of
a
pitfall
is
sometimes
you'll
find
shared
objects
in
jar
files
that
that
are
kind
of
architecture.
Specific
they're,
compiled
images
compiled
objects.
You've
got
to
work
with
those
because
they
won't
run
at
the
wrong
architecture.
B
Containers
you
know,
tons
of
containers
are
already
multi-architecture,
not
always,
but
a
lot
of
the
things
are
and
then
on
the
right
side,
the
compiled
applications
you're
going
to
look
for
things
that
are
not
real
portable
in
C
and
C,
plus
plus,
could
be
intrinsics
things
like
that.
Some
other
languages
like
go
works
great
and
again.
Newer
versions
are
better,
so
starting
from
1.18
newer,
that's
going
to
give
great
performance.
If
you
have
older
ones,
then
that
might
work,
but
the
performance
isn't
going
to
be
as
good.
B
So
yeah
take
take
a
look
at
what
you
have
work
through
your
dependencies.
Keep
the
checklist
of
that
and
yeah
that's
a
good
way
to
get
started
on
our.
So
in
terms
of
some
scenarios,
I
mean
when,
when
developers
want
to
try
out
arm
and
check
into
the
price
performance
benefits,
typically
they'll
run
into
a
variety
of
different
things.
I.
C
B
Doing
something
like
node.js
application,
you
might
find
hey,
just
works,
I
moved
it
over.
I
can't
tell
anything
different
about
the
architecture
and
its
underlying
instructions
works
great.
If
you're
in
C,
plus
plus
applications,
you
might
come
across
intrinsics,
which
are
architecture
specific.
Typically,
these
are
Cindy
type
instructions
and
there
are
tools
and
libraries
that
help
you
to
migrate.
Those
over
so
SSE
to
Neon
and
Cindy
everywhere
are
examples
of
tools
you
can
use
that
are
very
minimal
in
terms
of
your
source
code
changes
and
allow
you
to
run
those
existing
intrinsics
in
your
code.
B
You
might
find
some
dependencies
that
don't
work
on
the
arm
architecture,
so
you
might
find
something
in
python
or
python
package.
That's
not
available,
so
you
know
again
try
to
either
you
have
to
work
around
it,
or
the
best
way
is
to
ask
the
maintainers
if
they
can
add
arm
support.
I
mentioned
some
performance
things,
so
yeah
newer
tools
are
better.
Sometimes
the
crypto
extensions
of
the
arm
architecture
haven't
been
implemented
and
the
best
performance
way
on
older
versions
of
tools.
So
take
a
look
at
that
containers
again.
B
If
you
find
containers
that
don't
support,
multi-architecture
ask
the
maintainers
if
they
can
do
that,
a
couple,
other
architecture,
specific
things
so
large
system
extensions,
is
a
feature
of
the
arm
architecture
that
will
normally
just
work
and
everything
is
fine.
But
if
you
had
say
an
older,
C
plus
compiler,
you
might
have
some
issues
with
that.
Anyway.
A
B
You
kind
of
get
the
flavor
that
you
know
most
stuff
is
there.
You
might
hit
some
hiccups
here
and
there,
but
definitely
reach
out
if
you
need
help
and
I
think
you'll
have
a
pretty
smooth
time.
So
what
we're
going
to
do
today
is
get
into
the
Hands-On
and
we're
going
to
have
a
little
bit
of
multi-architecture
discussion
running
in
kubernetes.
B
So
we
have
an
application
that
we're
going
to
build
we're
going
to
build
container
for
that,
it's
a
go,
Application,
we're
going
to
put
it
into
container
repository
and
then
we'll
work
with
AWS
eks
and
we'll
have
a
mixed
node
cluster,
where
we
have
a
couple
nodes
which
are
AMD
64.
and
we'll
have
a
couple
nodes
which
are
arm
64.
and
I'll.
Give
you
a
little
flavor
of
how
containers
map
onto
those
nodes
and
we
can
start
up.
B
You
know
different
kind
of
deployments
and
and
see
how
that
works.
So
that's
what
we'll
go
over
next.
B
Okay,
let
me
jump
out
of
the
PowerPoint
here
and
we
will
get
started
so
essentially
what.
A
B
Going
to
do
is
first,
let's
just
go
over
the
the
application
itself
a
little
bit.
So
it's
super
simple
I
mean
it's
just
a
go.
Application
that
is
going
to
respond
and
I
probably
won't
even
use
the
browser.
I'll
just
do
a
curl
and.
B
A
B
This
is
the
key
thing.
This
is
the
architecture
value.
So
you
know
if
this
application
and
its
container
lands
on
an
AMD,
64
node,
that's
what
will
be
printed
and
if
it's
running
on
an
arm64
node,
then
you'll
you'll
see
that
it's
printed
as
well.
So
that's
the
basic
application
we're
going
to
go
through
now.
B
Familiar
with
multi-architecture
containers,
this
is
kind
of
a
prerequisite,
I
would
say
to
get
into
kubernetes.
So
you
probably
want
to
learn
that
a
little
bit
now.
What
I've
done
here
with
the
the
simple
go
Application
is
I,
have
a
single
Docker
file
file,
which
can
actually
build
a
few
different
ways,
and
you
know
I
would
encourage
you
to
look
into
multi-architecture
containers,
but
essentially
what
we're
doing
here
is
we
have
we're
passing
Arguments
for
the
Target
architecture
and
then
also
here
for
the
runtime
container,
which
is
going
to
be
Alpine
in
this
case.
B
So
it's
copying
Indigo
and
then
it's
using
this
variable
to
compile
the
application
for
a
specific
architecture.
Now,
whatever
machine
you're
on
when
you
do
this,
if
you
don't
specify
the
go,
Arch
variable
it's
going
to
be
whatever
the
native
architecture
is
of
the
machine.
Now
things
are
getting
a
little
more
complicated
as
people
start
picking
up
Apple
silicon,
because
you
will
be
picking
up
arm
64
as
that
native
thing,
so
it
depends
which
way
you
go
and
if
you
just
say
from
golang,
you
know
that's
going
to
be
the
native
architecture
of
your
machine.
B
B
Which
is
the
second
one
down
here,
the
second
stage,
that's
the
one
that
needs
to
run
on
the
you
know
the
architecture
we're
going
to
schedule
it
on
okay.
So
that's
why
you
see
there's
a
variable
there,
which
is
going
to
place
whether
that's
AMD,
64
or
arm
64..
Now,
in
terms
of
building
the
container,
there's
a
couple
different
ways
to
do
it.
If
you.
B
B
So
if,
let's
just
say,
for
example,
if
I
I
can
build
this
application,
both
ways
I'll
do
a
Docker
build.
You
know
just
straight
build
and
I'll
pass
in
the
architecture
in
each
case
and
then
I'll
pass
in
that
runtime
container
for
Alpine
as
a
slightly
different
prefix
on
arm
and
then
I'll
get
I'll
get
two
containers
there.
So
what
it,
what
it
ends
up
when
I
had
do
that
I
have
here
in
my
Docker
Hub
account
you'll
see.
B
C
B
That's
that's
like
a
way
that
you
can
just
build
containers
that
are
architecture,
specific,
that's
kind
of
the
historical
way.
Now
the.
B
To
do
this
is
by
way
of
build
X,
so
build
X
is
a
ability
that
Docker
has
to
build
with
a
single
instance.
You
just
called
Docker
build
X,
and
then
you
specify
the
platforms
that
you
want
to
support
in
this
case,
AMD
64
and
arm
64,
and
then
it
will
build
that
as
a
multi-architecture
container.
So
if
I
jump
back
here
on
the
docker
Hub,
this
is
the
one.
I
have
go:
Dash,
Arch,
X,
okay,
so
the
tag
I
just
put
a
1.0
is
the
tag.
B
Yeah
great
so
so
this
one
is
a
multi-architecture
container.
So
if
I
do
the
drop
down
on
the
the
OS
architecture,
there
you'll
see
there's
two
two
entries:
one
is
AMD
64
and
one
is
arm
64..
Now
the
beauty
of
the
multi-architecture
container
is
that
whatever
machine
you're
on
when
you
go
to
run
the
container,
the.
B
Runtime
will
go
to
find
it
and
it'll
say:
oh
I'm,
on
arm
64
machine
I,
see
that
this
this
image
supports
arm,
64
and
it'll,
go
get
the
right
image
and
then
just
automatically
run
it
on
that
machine.
Okay.
So
this
is
the
way
just
to
you
know,
keep
everything
simple
support:
two
architectures
in
a
single
image:
okay,
now
there's
one
more
variable
that
I'm
going
to
show
here,
which
is
a
Docker,
manifest
command.
B
That
I
would,
as
if
I
use,
build
X,
and
this
is
handy
because
in
a
lot
of
cases
you
don't
want
to
go
through
a
lot
of
the
Hoops
related
to
build
X
you'd,
rather
just
you
know,
use
two
separate
machines,
build
for
each
architecture
and
kind
of
link
them
up
at
the
end
using
this
manifest
command.
So
you
know
all
that
gives
you
a
little
bit
of
background
multi-architecture
images.
You
know
what
you're
going
to
need
if
you
go
into
a
mixed,
node,
kubernetes
cluster,
that
we're
going
to
do
next.
C
B
B
Works
in
terms
of
running
the
application
in
our
cluster,
so
in
terms
of
the
cluster
that
we
have
I
mentioned
is
going
to
be
eks.
So
you
know
what
I
what
I
found
is
super
easy
to
create
a
cluster
with
eks
CTL.
So
that's
what
I
used
here
with
two
different
node
groups.
So
there's
one
node
Group,
which
is
the
amd64
architecture
with
two
nodes
and
then
there's
one,
which
is
a
c6g,
that's
the
graviton
processor,
and
so
that's
going
to
be
with
the
rm64
architecture.
B
B
We
want
to
do
is
think
about
you
know,
maybe
some
mixed
node
scenarios,
so
let's
just
go
with
the
AMD
64.,
so
I
have
a
yaml
file
here,
which
is
going
to
be
specifically
only
AMD
64.
okay.
So
it's
has
a
container,
which
is
the
one
I
just
showed
you
on
Docker
Hub,
and
it
has
that
AMD
64
at
the
end,
so
this
image
is
only
going
to
run
on
AMD,
64.,
I
guess.
B
The
other
interesting
point
is
the
node
selector
down
here
so
by
matching
this
node
selector
to
amd64
when
I
run
this
apply
this
yaml
file,
it's
going
to
get
that
container
and
it's
going
to
run
it
on
one
of
the
two
amd64
nodes
here.
So
let's
just
do
apply
Dash
F
and
then
the
AMD,
and
so
this
will
create
the
deployment
and
let's
do
a
get
pod
and
then
you'll
see
now
I'm
running
one
AMD,
64
deployment
and
I
believe
I
have
a
one
one
replica
right
here.
B
So
that's
that's
running
on
that
that
note
now
I
have
a
little
bit
of
a
script
here
or
I
can
just
do
a
curl,
probably
and
hit
that
endpoints
I
think
I
showed
on
the
first
picture.
There's
a
load
balancer
in
front
of
these
nodes.
I
can
hit
that
and
then
you'll
see
it
prints.
The
CPU
platform
is
Linux,
AMD
64..
So
that's
the
only
thing
currently
running
in
my
cluster.
So
every
time
I
do
a
curl
I'm
just
going
to
return
amd64
every
time.
B
B
B
The
way
it
goes
and
then
let's
go
back
and
get
the
pods
okay,
so
I
know
I
have
another
one
running.
So
I've
got
one
of
each
right,
because
I
also
had
one
replica
there
so
yeah
the
node
selector
can
be
used
to
take
architecture.
Specific
containers
put
them
on
the
right
nodes
and
then
you
know
you
can
you
can
use
your
cluster
that
way
now,
eventually
over
time,
which
you
may
want
to
get
to
is
the
multi-architecture
deployment.
So
in
that
case
we're
going
to
do
this
one.
B
So
what
I've
done
here
is
I
changed
the
image
to
be
the
go
Arch
X.
So
that's
the
the
image
that
I
built
with
build
X.
It
supports
both
architectures
I
had
that
tag
of
1.0
and
that's
pretty
much
it
so
in
this
case,
what
we
have
is
six
replicas
here
and
if
we
apply
this
one
you
know
it's
gonna,
it's
gonna
schedule,
six
replicas
with
some
mix
of
AMD,
64
and
arm
64,
and
you
know
the
right
nodes
will
pick
up
the
right
container
images
and
then
it
will
just
run
so.
B
Let's,
let's
apply
this
one.
B
Okay,
so
now
what
we
have
is
you
know
the
six
nodes
running
that
I
started
and
then
those
two
older
ones,
so
you
see
one
one
AMD
one
arm
and
then
six
multi-arch,
okay,
so
now
I
have
the
script
here
this
this
check,
which
is
basically
going
to
go,
hit
the
end
point
kind
of
in
a
loop
and
then
let's,
let's
see
what
happens
so
if
we,
if
we
hit
that
you'll,
see
you'll
get
a
some
arm
64,
it
looks
like
we're
getting
lots
of
arm
64.
There.
B
And
you'll
see,
then
some
AMD
64
is
mixing.
So
as
you,
you
know,
go
through
it'll
schedule,
it'll
it'll
go
to
whichever
notes
or
react
or
respond
to
that
and
you'll
see.
The
architecture
is
printed
and
you'll
see.
Some
of
these
are
coming
from
the
arm
deployment.
Some
of
them
come
from
the
multi-arch
deployment.
I
didn't
see
the
AMD.
Oh
here's
one
up
here:
AMD
64
there
deployment
okay,
so
that
that
gives
you
a
pretty
good
feel
for
how
to
you
know,
work
with
the
multi-architecture
cluster.
B
We
have
two
different
node
groups
yeah
in
the
end,
if
we
have
containers
that
can
run
on
either
one,
they
can
just
run
identically
and
they
can
be
used
on
either
architecture
right.
B
B
Know
over
time,
if
you
want
to
phase
out
some
of
the
the
AMD
64s
for
that
price
performance
benefit
can
certainly
do
that,
but
it
gives
you
a
way
to
kind
of
ramp
up
without
all
or
nothing
and
just
try
pieces
of
you
know.
Whatever
your
bigger
solution
is
okay,
so
I
think
that
pretty
much
covers
it.
We
went
over
the
you
know
the
image
creation,
how
to
build
it:
mixed
architecture,
cluster,
two
different
node
groups
and
how
we
can
schedule
either
the
individual
architecture
containers
or
the
multi-arch
on
the
cluster.
A
Be
a
good
discussion,
I
think
yeah
for
one
question:
just
to
lay
foundations,
like
you
said,
has
price
performance
and
sustainability.
It
seems
so
amazing,
like
are
there
any
drawbacks
that
we
should
be
aware
of.
B
Yeah
so
in
terms
of
drawbacks,
I
mean
it
takes
a
little
work.
Okay,
so.
B
In
order
to
get
the
price
performance
advantage
and
sustainability,
you
kind
of
have
to
do
something,
I
mean
in
a
lot
of
cases.
Let's
say,
new
hardware
comes
and
it's
faster
and
it's
cheaper
and
you
can
take
your
exact
same
software
and
just
move
it
on
to
the
new
hardware.
No
work,
I
save
money
goes
faster,
that's
ideal.
B
B
A
B
It
depends
kind
of
what
you
have
access
to
I
guess
I
mean
there's
lots
of
arm
development
boards
I
mean
even
if
you're,
using
a
Mac
with
apple
silicon.
You
can
even
use
Docker
desktop,
which
has
now
built-in
kubernetes
feature,
and
if
you,
if
you
do
that,
you'll
basically
have
a
one
node
kubernetes
Solution
on
your
laptop,
that's
arm
64.
B
right,
so
you
don't
have
to
do
anything
special,
there's
other
arm
development
boards
that
you
can
use
and
install
you
know
various
kubernetes
distributions
and
so
on
and
use
cloud
is
probably
the
easiest
I
mean
all
the
major
cloud
service
providers
now
have
armed.
The
one
I
I
probably
would
highlight
if
you're
super
new
is
r
Oracle
Cloud,
so
they
have
a
free
tier
which
gives
you
access
to
Armed
servers.
These
are
from
ampere,
so
it's
an
arm
server
and
basically
you
get
four
virtual
processors
and
I
think
it's
24
gig
ram,
always
free.
B
B
A
B
Yeah,
all
of
those
yeah,
so
there's
there's
no
real
limitations
in
terms
of
workloads,
yeah
and
all
of
those
things
should
should
definitely
work.
It
can
be,
you
know
they
can
be
interpreted,
languages
can
be,
Java
can
be
compile
things.
C,
C
plus
plus
go
rust,
yeah,
all
the
all
the
popular
languages
work.
A
And
then
we
have
this.
One
is
more
for
me:
I
think
it's
a
oops
I
lost
the
one,
that's
for
me,
but
what
kinds
of
workloads
would
be
best
to
to
fit
to
deploy
in
these
multi-arch
deployments?
Could
we
see
inconsistent
results
from
each
type?
That's.
B
A
great
yeah,
you
definitely
can
I
mean
it.
It
depends
a
lot.
The
workloads
depend
a
lot
on
the
you
know
the
underlying
hardware
and
there's
different
instance
types.
So
when,
when
arm
architecture
kind
of
first
came
into
the
cloud
you
know,
AWS
was
was
really
the
Pioneer
they've
been
deploying
arm
instances
since
2018,
basically
and
so
they're
on
the
third
generation,
and
it
depends
on
your
workloads,
so
price.
B
Is
better
web
serving
or
others
that
are
really
kind
of
scale
out
and
they're?
Not
you
know
performance
intensive
in
terms
of
you
know
floating
point
or
other
things,
because
yeah
they're
they're
able
to
respond
very
quickly
with
lots
of
traffic,
and
that
was
really
where
your
best
benefit
was
obtained.
I
would
say
in
most
cases,
but
over
time
you
know,
performances
keeps
getting
better
and
better.
So,
even
if
you
have
more
computational
intensive
workloads,
you
know
and
you
get
into
like
the
C7
G
family
from
AWS.
B
A
And
this
is
the
one
that
was
for
me
and
it
has
to
it's
a
compliment
to
you
being
able
to
see
it
in
real
time
makes
so
much
sense,
which
I
totally
agree
with.
Will
there
be
a
recording
to
watch
this
later
I'm
unfamiliar
with
the
LinkedIn
side,
but
I
know
that
this
is
also
streaming
on.
Youtube
cncf
has
a
YouTube
channel.
So
if
you
go
there
go
to
the
live,
tab
you'll
be
able
to
see
a
recording
of
this.
Thank
you
and
then
let's
go
for
what
other
arm-based
architectures
are
possible.
B
Okay,
so
the
question
isn't
totally
clear
in
that
the
RM
architecture
has
many
versions:
okay,
so
we're
in
actually
version
nine.
At
the
moment,
okay,.
C
B
Started
33
years
ago,
so
that's
you
know
that's
kind
of
a
wide
time
span,
but
you
know
for
the
most
part,
what
you're
going
to
find
in
cloud
service
providers
and
generally
you
know
all
other
Hardware
you'll
find
a
recent
version
of
the
architecture
where
everything
is
64-bit
and
you
know
they're
they're
based
on
typically
like
the
arm,
neoverse,
N1,
processor
or
the
V1
processor.
So
these
are
kind
of
server
class.
B
You
know,
processors
that
are
running
now,
there's
lots
of
other
arm
things
that
are
targeted
more
for
Edge,
Computing
or
embedded
or
you
know.
If
anybody
knows
Raspberry
Pi,
that's
kind
of
one
of
the
early
versions
of
the
arm
version,
8
architecture.
That's
still
out
there
tons
of
people
use
raspberry,
pies,
there's
32-bit
versions
of
the
architecture
that
go
back
in
time,
so
yeah.
C
A
So
I
just
want
to
make
a
quick
note
that
this
all
the
it
sounds
like
the
demo
that
you
showed
today.
If
people
want
to
get
their
own
hands
dirty
with
it,
they're
able
to
do
that
on
GitHub
with.
A
The
stream
too
so
get
to
play
with
it.
It
looks
amazing.
We
have
a
question
from
Kyle.
How
well
does
this
integrate
with
parallel
processing.
B
Yeah
I'm
not
totally
sure
about
that
I
mean
I,
don't
think,
there's
anything
different
about
architecture.
That
is
anything
different
in
terms
of
parallel
processing,
so
you
know
most
applications.
You
can
write
applications
with
multiple
threads
running
on
multiple
cores
and
so
on.
You
can
build
a
cluster
with
lots.
B
Yeah
I
wouldn't
say:
there's
anything
special
about
what
we're
doing
here
today.
That's
any
different
than
whatever
you
do
with
parallel
processing
today,.
A
A
Yeah,
what
if
developers,
prefer
keeping
arm-based
physical
boss
box
on
the
desk?
What's
what
are
the
options?
If
you
want
one
in
your
hands,.
B
B
A
good
question
so
there's
a
variety
of
things:
I
I
mentioned:
you
know
you
could
have
laptops
with
the
arm
architecture.
So
that's
that's
available.
Now,
in
fact,
there's
you
know
like
there's
a
Windows
laptops,
there's
even
Windows
dev
kit,
which
came
out
but
probably
I'm
thinking.
That's
not
super
interesting
to
people
here.
So
you
know,
Linux
is
a
possibility.
There's
a
bunch
of
boards
and
different
kind
of
things.
Oh
maybe
I
have
one
I,
don't
know.
C
B
C
B
Yeah,
so
this
is
an
eight
core.
You
know
arm
I
think
it's
cortex
a76
with
pretty
good
sized
memory.
You
can
get
large
memory
in
there
and
you
can
run
Linux
and
do
that
so
yeah.
That's
definitely
a
possibility.
So
I
think.
If
you
start
looking
around
you'll
see
lots
of
different
arm
Hardware.
You
probably
just
didn't
notice
it
or
pay
attention
before.
A
B
C
B
That
couldn't
run
on
the
arm
architecture.
Maybe
you
have
I,
don't
know
dependency
of
some
kind
or
some
container
that
you
can't
control
or
change.
I
mean
the
one
the
one
place
I
have
run
into
some
troubles
is
like
you
know,
a
lot
of
applications
have
layers
of
containers
and
some
of.
C
A
That's
actually
kind
of
related
to
kunal's
question,
which
is:
did
jars
need
to
be
compiled
to
be
architecture,
specific.
B
A
B
Itself,
you
know
is,
is
independent,
but.
B
Can
do
Native
code
in
Java
right,
so
you
can
mix
Java
with
native
code
and
there's
a
jni
is
an
interface
to
call
that
native
code.
So
that's
where
you
could
run
into
a
problem.
You
could
think
you,
oh
I,
just
have
a
job
application,
but
really
you
got
some
native
code
embedded
in
there.
You
might
not
have
known.
B
B
System
Extinction
was
an
enhancement
to
the
arm
architecture
somewhere
in
version
8.
That
makes
it
more
efficient
for
handling
atomics
right.
So
the
original
you
know
his
arm
grew
up.
The
the
number
of
cores
like
like
in
your
phone,
so
example,
those
are
all
armed
cores
and
most
people
probably
have
eight
cores
in
their
phone
and
when
you're.
C
B
You
know
Atomic
instructions
and
locking
and
so
on,
so
the
way
that
it
worked
was
fine
for
eight
cores,
but
then
somebody
built
a
server
with
64
cores
and
then
128
cores
and
now
I,
don't
know
what
the
largest
armed
server
192
cores,
maybe
and
the
the
the
atomic
instructions
weren't
great.
So
they
were
improved
in
the
architecture
and
so
when
you
compile
your
application,
you
know
these
things
are
built
into
your
libraries.
Typically
like
your
your
underlying
libraries.
A
Quite
sure
this
question,
but
maybe
you
can
help
me
figure
out.
Docker
images
can
have
multiple
tags
like
version
and
architecture.
So
it's
I,
guess
I,
don't
understand
the
question
two
different
tags
simultaneously.
B
That's
fine,
I
I
mean
yeah
in
Docker.
You
know
you
have
the
ability
to
use
tags
to
specify
whatever
you
want
it
to
mean
I
mean.
B
C
B
Regardless
of
what
you
do,
if
you,
if
you
look
like
in
Duck
or
Hub
I,
showed
that
pull
down
it
will
record
the
architecture.
You
know
that
the
images
are
for
kind
of
independently
of
the
tag
so
yeah
a
lot
of
people
use
the
tags
just
to
kind
of
denote
architecture,
but
it
doesn't
have
to
be
it's
it's
totally
flexible.
C
B
Oh
long-term
plans,
yeah.
B
Oh
sure,
yeah,
there's
lots
of
stuff
happening
all
the
time.
In
fact,
you
know
cloud
service
providers
are
constantly
announcing.
You
know
new
hardware.
There
was
some
events
recently,
so
Google
Cloud.
Next
it
was
a
few
weeks
ago
and
they
announced
new
arm
instances.
So
they
had.
You
know
originally
some
instances
already
in
Google
cloud
and
now
they've
known
some
new
instance.
Types
with
you
know
better
faster
Hardware,
Better,
Price
performance
I
mean
the
message
is
pretty
much
the
same.
The
hardware
gets.
A
B
A
Nice
can
I,
don't
know
the
acronym,
but
can
can
mult
I-arm
work
with
HBC
applications.
What's
HPC,
please.
B
Yeah
HPC
is
high
performance,
Computing,
okay,
so
yes,
definitely
HPC
works
with
arm.
In
fact,
for
a
couple
years,
I
don't
think
it's
true
anymore,
but
the
fugaku
super
computer,
which
is
has
won
the
performance
Crown
for
the
biggest
or
fastest
super
computer,
was
based
on
the
arm
architecture.
So
it's
definitely
used
in
HPC
applications.
Yeah.
B
Yeah
in
HPC
software
is
typically
like
very
large
scale
applications.
So,
like
your
your.
A
B
Oh,
that's
a
good
one.
Yeah.
A
B
You
can
use
open
jdk,
it's
perfectly
fine.
I
use
that
a
lot.
The
other
one
which
is
pretty
good,
is
a
coretto.
It's
called
from
AWS,
so
they
have
a
Java
distribution
and
because
they're
definitely
interested
in
getting
people
onto
the
graviton
processors
which
are
based
on
arm.
They
provide
that
as
well.
So
that
gives
you
an
Easy
distribution
so
again
that
one
that
one
is
easy
access,
it's
open
source,
so.
C
A
Excellence
and
then
so
and
I
have
one
more
question
for
you.
So
those
of
you
watching,
if
you
do
have
any
more
questions,
now's
your
chance,
so
get
those
in
right.
Now
we
have
one
question
which
is:
what
are
the
best
practices
when
preparing
for
arm
64
Cloud
deployment
and
are
there
any
anti-patterns?
What
are
those.
B
Then
start
experimenting,
you
know,
just
in
a
manual
sense
of
you
know
how
you
build
your
software
and
how
you
create
your
containers,
because
you're
gonna
easily
spot
when
things
go
wrong.
If
you
do
that
the
pitfall
is
kind
of
like
okay,
everything
looks
like
it
works
like
my
CI
CD
system
is
good
and
my
cluster
has
arm
nodes,
and
so
you
just
like
push
the
giant
go
button
and
expect
the
whole
thing
to
just
magically
work.
That's
probably
a.
C
B
Of
stories,
if
you
just
search
the
web
about
companies
that
have
migrated
to
arm
64.
C
A
That's
wise
and
then
the
second
part
of
the
question
was:
are
you
aware
of
any
anti-patterns.
A
All
right,
so
no
more
questions
came
in,
so
that
means
it's
About
Time
to
Say
Goodbye
Is.
There
anything
you'd
like
to
say
in
closing
before
I
say
the
closing
script
and.
B
B
A
Thanks
for
a
great
presentation,
thank
you
so
much
for
sharing
your
time
and
your
expertise
with
us.
Jason
thanks
everyone
also
for
joining
today's
episode
of
cloud
native
live.
It's
great.
Jason
was
great
learning
about
multi-architecture
clouds
is
amazing
and
also
learning
how
to
build
multi-talk
architecture
images
was
super
cool,
so
I
loved.
As
always,
the
questions
and
the
interaction
from
the
audience
y'all
are
the
best,
and
here
at
Cloud
native
live.
We
bring
you
the
latest
Cloud
native
code,
usually
on
Tuesdays
and
Wednesdays.