►
Description
Don’t miss out! Join us at our upcoming event: KubeCon + CloudNativeCon North America 2021 in Los Angeles, CA from October 12-15. Learn more at https://kubecon.io The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Sponsored Session: CircleCI - Building Arm Compatible CI/CD Pipelines
Speakers: Angel Rivera
Arm architectures are increasingly popular and are becoming widely adopted by teams and organizations. As this adoption grows, developers and organizations must ensure their software and services are capable to support Arm architecture which begins by ensuring their CI/CD tooling and workload are Arm capable. In this tutorial, attendees will learn how to ensure their CI/CD pipelines and workloads are Arm compatible and capable of providing Arm support in their products.
A
Hello,
everyone.
I
want
to
welcome
you
all
to
this
presentation
where
I'll
be
discussing
how
you
can
build
ci
cd
pipelines
that
support
arm
architectures
and
processors.
My
name
is
angel
rivera.
I'm
a
developer
advocate
for
circleci
and
again
I'm
super
excited
to
be
talking
to
you
about
arm
architectures
and
processors.
A
As
many
of
you
know,
arm
architectures
have
been
around
for
quite
some
time
right.
Processors
have
been
embedded
in
hardware
in
different
shapes
and
forms
for
for
some
years
now,
and
these
are
the
more
commonly
types
of
devices
or
hardware
that
have
armed
processors
powering
them.
Things
such
as
mobile
phones
or
smartphones
tablets,
raspberry
pi's
and
iot,
and
smart
devices
such
as
tvs
appliances,
wearables
and
even
certain
medical
devices.
A
So
again,
arm
architectures
have
been
around
for
quite
some
time,
they're
in
a
lot
of
the
devices
that
we
use
on
a
daily
basis
and
the
reason
for
their
high
adoption
in
in
like
the
mobile
space
and
other
you
know,
smart
device
type
spaces
is
because
of
their
low
power
consumption
right,
so
we're
usually
carrying
a
phone
around,
and
that
requires
a
battery.
The
processor's
ability
to
process
data
using
very
minimal
energy
is
one
of
the
appealing
aspects
of
implementing
or
adopting
arm
architecture
within
the
mobile
devices.
A
Certain
operating
systems
have
been
supporting
arm,
architectures
and
processors
for
quite
some
time,
and
more
recently,
apple
has
basically
adopted
the
arm
processors
into
their
current
and
new
releases
of
their
their
macbook
laptop
devices
as
well.
As
you
know,
any
other
kind
of
desktop
or
server
devices
that
they're
gonna
push
out
in
the
future.
So
having
you
know
that
popularity
of
adoption
with
arm
by
apple,
it's
it's
just
gaining
more
popularity
in
the
industry.
Now
servers
have
adopted
arm,
architectures
and
processors.
A
You
know
for
a
while
now-
and
this
is
not
anything
new,
but
it
is
gaining
popularity
in
in
the
infrastructure
spaces
so,
like
the
cloud
providers
are
now
providing
options
for
developers
to
basically
leverage
you
know
arm
hardware
within
in
their
services.
Aws
graviton
2
is
a
good
example
of
that.
They've
actually
implemented
a
new
instance
type
that
basically
is
powered
by
arm
processors.
That
enables
again
the
the
floodgates
to
open
for
the
usage
of
arm
within
these
these
provider
services.
A
The
problem
is
that
arm
and
x86
processors
are
not
compatible,
which
leads
to
applications
that
were
built
for
x86
processors
are
not
going
to
function
well
with
an
arm
ecosystem
right.
So
that
means
the
instruction
sets
are
just
different.
So
again
that
basically
means
that
the
applications
have
to
be
compiled
for
the
processor
that
they're
targeting
again,
you
know
code
doesn't
really
care
about
where
it's
executed
on,
but
it
does
need
to
be
compiled
for
whatever
process
or
environment.
A
It's
going
to
be
working
on,
in
this
case,
we're
going
to
be
compiling
applications
for
arm
architectures
and
processors,
and
that
must
actually
be
done
on
the
hardware
itself
right.
So
that
you
can
get
the
the
proper
instructions
for
your
application,
circleci
has
recognized
this
and
we're
actually
cr
we've
created
a
new
resource
class
is
what
we're
calling
it,
which
is
a
compute
node,
where
you
can
execute
your
ci
cd
pipelines
on
arm
hardware.
A
Now,
while
doing
that,
essentially
you
know
will
give
the
developer
the
ability
again
to
you,
know,
compile
their
code
and
then
ensure
test
their
code,
ensure
that
it's
actually
functioning
specifically
on
the
arm
architecture
right
on
the
for
the
arm
processors,
as
well
as
the
ability
to
do
the
same
for
an
x86
architecture.
So
now
we're
just
giving
the
developer
a
bunch
more
power
to
be
able
to.
You
know,
build
their
applications
for
whatever
target
hardware
that
they
need
to.
A
So
before
we
jump
in,
I
wanted
to
show
you
some
code.
I
have
a
project
here
that
essentially
is
a
simple
node.js
application.
The
application
should
not
be
your
focus
at
this
point.
What
I'm
going
to
focus
in
on
is
how
you
can
implement
arm
capabilities
into
your
cscd
pipelines
using
the
circleci
config.yaml
file,
which
is
the
way
you
define
cicd
pipelines
in
the
circleci
platform.
A
Now
this
is
a
collapsed
version
of
the
of
the
pipeline
and
the
reason
why
I
collapsed
it
was
so
that
I
can
focus
in
on
the
bits
that,
actually
matter
so
this
configuration
pipeline
configuration
has
four
jobs
in
it.
One
is
obviously
to
run
some
tests.
The
other
one
is
to
build
a
docker
image
and
then
the
other
two
are
leveraging
infrastructures
code,
a
tool
called
terraform
created
by
or
maintained
by
created
and
maintained
by
a
company
called
hashicorp.
A
So
basically,
what's
going
to
happen
here
is
we're
going
to
run
some
build.
Our
code
run
some
tests,
we're
going
to
build
a
docker
image
based
off
of
that
code
and
it's
going
to
be
an
arm,
compatible,
docker
image
and
then
finally,
we're
going
to
deploy
we're
going
to
create
using
infrastructure's
code,
create
a
amazon,
elastic
container
service
cluster
and
that's
going
to
be
powered
by
arm
compute
nodes.
A
Underneath
you
know
that
that
are
basically
powering
the
cluster,
so,
finally,
we're
going
to
destroy
all
of
that
using
a
manual
button,
push
encircle
ci,
so
let's
jump
into
it
real
quick.
I
just
want
to
show
you
how
you
can
easily
implement
this
and
the
run
test
job
which
I'm
showing
here
we're
going
to
create
a
machine
executor,
which
is
the
resource
class
or
the
type
of
of
environment
that
we're
going
to
execute
our
code
on
and
we're
going
to
be
using
an
ubuntu
image.
A
A
Essentially,
the
system
knows
to
spin
up
an
arm
environment
for
you,
so
that
you
can
run
your
code.
I'm
not
going
to
go
too
deep
into
this
code,
but
essentially
right
you're,
just
looking
at
the
important
bits
of
how
to
build
a
cicd
pipeline
that
supports
arm-
and
this
is
essentially
how
you
would
do
it.
You
just
tell
the
resource
class
key
that
you
want
an
arm
resource
class
and
then
it
will
create
that
for
you.
So
let's
go
ahead
and
just
change
the
application.
A
I
just
want
to
demonstrate
how
easy
it
is
to
implement
this
in
your
pipeline.
So
I'm
going
to
go
ahead
and
create
a
version
too
just
change
the
value
again.
The
application
is
not
really
the
the
focus
here,
but
we're
going
to
go
ahead
and
commit
those
changes.
So
let's
do
a
git
status.
Make
sure
that
our
our
change,
we
do
have
some
changes
to
commit
and
we
do
we're.
Gonna
do
a
git
commit
and
then
it's
the
application
app.js
that
we
want
to
commit.
A
Give
it
a
message
with
the
lower
m
and
then
we're
going
to
say
I
don't
know
up
updated
the
version
number,
which
is
what
we
did
right
and
then
we're
gonna
go
ahead
and
essentially
just
push
our
changes
upstream
to
our
version
control
system.
Now
this
is
where
circle
ci
will
jump
in
and
pick
up.
The
fact
that
you
know
we
push
some
changes
to
our
version
control
system
and
it
detected
those
changes.
Circle
ci
triggered
that
pipeline
build
that
we
had
in
our
config.yml
file.
A
So,
while
that's
happening,
let's
go
ahead
and
look
at
the
dashboard,
real
quick,
so
that
we
can
see
exactly
what
what's
going
on
I'm
running
three
jobs
in
parallel
right.
So
this
is
what
that
kind
of
looks
like
and,
as
you
can
see,
we're
running
our
tests,
we're
running
we're,
building
our
docker
image
and
we're
also
creating
the
aws
infrastructure
that
we're
going
to
deploy
to
so
the
initial
segments
of
our
build
have
completed,
and
if
we
want
to
dig
into
one
of
these,
let's
go
ahead
and
look
at
the
build
docker
image
job.
A
Essentially,
what
we've
done
here
is
created
an
arm
compatible,
docker
image
right
so
that
we
can
deploy
this
to
arm
hardware,
and
what
we
have
here
is
essentially
you
know
the
designator
for
the
executor,
which
is
where
the
environment,
where
we
you
know,
built
our
code
and
built
our
docker
image
and
again
right.
It's
an
arm,
a
linux
medium
as
opposed
to
an
x86
platform.
A
Now,
let's
take
a
look
at
what
exactly
happened
within
our
pipeline
again,
so
we've
run
our
tests,
we've
built
the
docker
image
and
now,
let's
take
a
look
at
our
deploy
to
aws
ecs
so
with
the
terraform
application
running
again
we're
using
an
arm
executor
here
and
it's
built
the
infrastructure
using
terraform
on
an
aws
cloud.
So
let's
go
ahead
and
just
see
if
our
application
is
actually
running
now.
Remember
we
updated
the
application
to
version
two.
So
hopefully
oh,
it's
still
running
version
one.
A
So
let's
go
ahead
and
see.
What's
going
on
there,
I'm
going
to
go
ahead
and
click
in
here
on
the
cluster
and
then
look
at
the
task,
because
that's
what
we're
looking
at
so
now
we
have
tasks
that
are
updated.
They
look
like
they're
running
it
may
have
been
that
they
were
still
in
the
process
of
updating.
So
the
way
it
works
is
because
of
its
scaling-
and
you
can
see
here
right.
A
You
know
that
your
application
compiled
in
arm
infrastructures,
you
know
that
your
application
has
been
deployed
or
deployed
using
a
docker
container
to
an
ecs
cluster
that
is
also
based
off
of
arm
capable
or
arm
powered
compute
nodes.
So
you
have
a
full
end
to
end
experience
there
with
arm,
and
you
know
that
your
application
is
basically
fully
compatible
with
the
arm
architecture.
Now,
coming
back
to
the
pipeline,
I
wanted
to
show
you
that
you
know
these
are
three
things
that
ran
in
parallel.
They
ran
pretty
quickly,
as
you
can
see.
A
Sometimes
it
takes
a
little
bit
of
time
for
the
underlying
cloud
infrastructure
or
or
the
deployment
environment.
The
arm
or
the
environment
you're
deploying
to
to
actually
re
you
know,
change
the
application
and
update
the
the
new
version
through
a
rolling
release
or
a
rolling
deployment.
I
should
say
so.
Finally,
I
just
wanted
to
show
you
this
last
bit,
which
is
basically
where
you
get
to
how
you
can
instantiate
or
define
a
step
in
your
in
your
pipeline.
A
That
adds
some
manual
capabilities,
so
this
this
manual
step
requires
someone
to
actually
click
a
button.
In
this
case.
It's
the
approve
this
job
and
once
you
click
this
button,
it
just
it's
like
a
contin,
a
block,
and
then
it
continues
to
the
next
job
in
the
in
the
pipeline,
which
in
this
case
is
going
to
be
destroying
all
of
that
awesome,
aws
ecs
clusters
and
all
that
stuff
that
we
built.
So
let's
go
ahead
and
click
on
that
button,
so
that
we
can
destroy
our
infrastructure
since
we
don't
need
it
anymore
right.
A
This
is
for
demonstration
purposes,
but
what
it'll
essentially
do
again
is
to
go
into
amazon
and
terminate
all
of
the
resources
and
all
of
the
objects
that
it
created
that
were
needed
for
our
ecs
cluster
things
like
vpc
security
groups.
I
am
roles
the
the
graviton
2
cluster
nodes
that
we
created
right
to
support
to
host
our
our
application
in
our
ecs
cluster.
A
A
Now,
when
this
is
completed,
all
of
that
stuff
will
be
terminated
that
we
created
in
amazon
will
be
gone
and
not
functioning
anymore
and
again
right.
This
will
have
a
should
lead
to
a
green
build,
but
I
just
wanted
to
show
you
the
power
of
you,
know
the
circle,
ci
pipelines
and
how
it
can
be
used
to
implement
arm
architectures,
so
that
now
developers
can
build
their
applications
with
confidence
using
arm
processors,
as
well
as
deploying
to
arm
powered
infrastructures
such
as
amazon
ecs
on
amazon's
graviton
to
compute
nodes.