►
Description
Easy Buttons for GitLab HA Scaling Runner Vending Machine for AWS
You can also checkout the video for all options of the template in GitLab Scaling Runner Vending Machine for AWS: HA, Scaling, Spot and Windows: https://youtu.be/llbSTVEeY28
Playlists:
- GitLab and AWS (https://youtube.com/playlist?list=PL05JrBw4t0Ko30Bkf8bAvR-8E441Fy2G9)
- GitLab Alliances Tech (https://youtube.com/playlist?list=PL05JrBw4t0KqaWCrU4avIY6TQveKTDMso)
- GitLab Guided Explorations (Working Examples) (https://youtube.com/playlist?list=PL05JrBw4t0KruBVtI-Ynb3mCHQTkh2eBY)
- GitLab CI/CD Tips Tricks and Hacks (https://youtube.com/playlist?list=PL05JrBw4t0Kr92rF9z0PEuOtQnH89VD7n)
- GitLab and .NET (DotNet) (https://youtube.com/playlist?list=PL05JrBw4t0KpYmx1n5PPhYCxxfGJdMxzZ)
- GitLab and Windows (https://youtube.com/playlist?list=PL05JrBw4t0KqOJeQ1y5wSBxArdTEtmnxb)
- GitLab and PowerShell (https://youtube.com/playlist?list=PL05JrBw4t0KrklJ2kDTl2qXNaGSlzKeoW)
- DarwinTheorizes (https://youtube.com/playlist?list=PL05JrBw4t0KoH74CcAtP0Ze7JXjX7zT6g)
A
A
Basically,
there
was
some
desire
on
the
part
of
get
lab
teams
and
folks
at
amazon
to
make
this
a
little
bit
easier,
especially
for
those
of
you
who
do
not
need
to
do
infrastructure
as
code
for
any
other
reason.
So
for
gitlab,
a
primary
target
would
be
if
someone
is
using
gitlab.com
sas
and
they
are
using
the
shared
runners
there,
but
then
they
realize
they
need
to
use
private
runners
for
a
variety
of
reasons,
there's
a
whole
lot
of
reasons
why
you
might
need
to
use
private
runners.
A
However,
if
you
just
have
a
simple
scenario,
you
might
not
need
all
20
parameters,
so
this
allows
some
parent
cloud
formation
templates
to
be
put
in
front
of
that
and
to
simplify
the
parameters
around
specific
use
cases.
So
if
you
have
a
simple
situation
where
you
just
want
docker
linux
runner
capability-
and
you
want
it
to
be
hot
h,
a
which
means
we
would
put
two
of
them
into
a
asg
and
you
don't
need
scaling
well,
then
you
don't
turn
on
the
scaling
part
and
have
to
tune
that
and
pay
attention
to
it.
A
You
simply
let
it
run
and
if
one
of
them
dies,
the
other
one
will
respawn
and
reestablish
itself.
So
let's
take
a
look.
Basically,
what
this
is
going
to,
let
you
do
is
use
a
very
graphical
experience
in
order
to
work
with
the
get
lab
runner.
This
is
kind
of
an
announcement
that
explains
the
benefits
of
doing
it.
This
way,
in
addition,
for
those
of
you
who
are
advanced
users,
you
don't
have
to
think
of
this
project
as
just
for
basic
ui
oriented
operations,
it's
full
infrastructure.
A
One
interesting
thing
here
too,
to
keep
in
mind,
is
that
these
scenarios
can
be
put
into
aws
service
catalog.
So
each
of
the
cloudformation
templates
that
are
parent
templates
to
simplify
things
can
be
put
in
aws
service
catalog.
Not
only
that,
it's
really
easy
to
take
a
look
at
them
and
build
your
own.
A
So,
let's
take
a
look
at
what
this
looks
like
I'm
going
to
go
to
the
root
of
our
repository,
which
will
expose
my
readme
and
the
documentation
has
also
been
reorganized,
a
couple
things
that
have
been
moved.
The
features
there's
a
lot
of
really
cool
features,
and
these
are
just
the
categories
of
the
features
of
this
template
listed
here,
but
it
the
features
have
been
moved
out
to
a
features
document
so
that
they
don't
clutter
the
readme
experience.
A
The
easy
buttons
have
been
put
up
front.
Previously
they
were
code,
so
they
required
you
to
have
the
aws
cli
installed
and
configured
to
work
properly
and
then
to
grab
this
really
long
command
line
and
drop
it
in
there
and
substitute
a
couple
parameters.
So
still
not
a
really
super
smooth
experience.
If
you
would
just
prefer
to
do
this
in
the
ui,
that
capability
has
not
gone
away.
A
A
The
other
thing
is
it
defaults
to
the
gitlab
instance,
and
you
can
of
course
change
that
to
any
instance.
You
wish
and
then
I'm
going
to
quickly
find
a
runner
token,
and
I
will
be
well
actually
it
doesn't
matter
anymore.
So
I'm
going
to
put
my
runner
token
right
in
here,
and
you
don't
see
it
because
we
have
the
no
mask
turned
on
for
that
parameter.
A
A
In
addition,
you
can
pick
your
instance
type.
I
would
caution
you
on
using
bursty
instance
types
for
anything
in
production.
I
always
do
this
for
folks,
because
I've
seen
individuals,
rework
automation,
code
and
even
application
code
to
get
around
weird
timing
and
error
conditions
that
only
happen
on
bursty
instances,
so
you
might
be
able
to
get
away
with
running
on
a
t2
or
t3
for
your
runner
and
if
you
can
that's
great,
but
if
you
start
to
see
any
oddities,
that
would
be
the
first
thing
I
would
think
about
changing.
A
All
I
have
to
do
now
is
click
these
two.
So
if
you're
on
gitlab.com,
you
literally
just
pasted
in
a
runner
token
or
runner
token
list,
if
you
use
a
list
use
semicolons
to
separate
also
in
the
documentation,
it
discusses
that
runner
tokens
exist
at
the
instance
level.
If
you
have
a
private
instance
of
gitlab,
they
exist
at
the
group
levels,
all
every
group
level,
in
your
organization
hierarchy
and
at
the
project
level.
A
Whatever
token
or
tokens
you
pick
and
insert
here
will
attach
the
runner
at
that
level
at
get
in
get
lab
and
it
will
be
available
to
all
projects
in
the
downbound
hierarchy.
So
just
keep
that
in
mind.
I'm
going
to
hit
create
stack
now
and
what's
going
to
happen,
is
aws
is
going
to
start
to
create
this
template.
A
Now
it's
going
to
create
the
template
from
a
sub
template,
so
that
initial
template
that
we
fired
off
is
simply
to
abstract
a
bunch
of
command
line
parameters
that
maybe
you
don't
want
to
have
to
think
about.
If
you
just
need
this
simple
scenario,
and
so
it's
starting
the
runner
asg
sub
template
in
order
to
actually
launch
this.
A
You
can
find
out
where
the
child
stack
is
either
by
looking
at
the
similar
name
over
here
on
the
left
or
if
you
go
into
resources,
it
will
provide
you
a
direct
link
to
that
stack
and
we
go
look
at
this
stack.
We
can
now
see
that
we
have
things
that
created
successfully.
So
if
we
had
any
failures,
we
could
start
digging
into
this
sub
stack
and
finding
out
what
exactly
happened.
A
One
common
reason
for
failure
would
be
you
created
too
long
of
a
name
for
the
asg
which
created
too
long
of
a
name
for
the
bucket
and
the
bucket
creation
fails,
and
everything
else
fails.
So
just
keep
that
in
mind.
Also,
if
you
need
to
delete
and
restart
you
can
just
hit
delete
on
the
parent
stack,
it's
usually
preferable
to
delete
on
the
parent
stack.
A
So
now,
let's
take
a
quick
look
at
how
this
plays
out
inside
of
git
lab
I'm
going
to
bring
up
the
exact
gitlab
group
that
we've
registered
to
which
is
a
private
group
and
has
no
repository
code
in
it.
It
just
has
test
gitlab
ci
test
code
to
do
stuff
like
generate
artifacts,
to
make
sure
the
artifact
cache
is
working,
etc.
A
So,
if
I
go
to
runners
here,
we
actually
created
these
bottom
two
right
here
now
notice
the
tagging.
It
tells
you
the
hardware
architecture,
and
that
is
because
we
also
for
linux,
support
arm.
So
we
support
arm64
if
you
specify
it
for
linux,
the
compute
type.
So
it's
telling
me
this
is
an
on-demand
instance,
which
means
that
it
is
not
spot
and
we
can
also
support
spot
with
these
templates
and
even
with
the
easy
buttons.
A
So
when
that
happens,
if
a
specific
instance
is
spot,
compute
it'll
say
compute
type
spot
and
then
your
workload
can
be
sent
routed
there
or
not
routed
there.
Based
on
that
tag,
so
you
can
decide
that
you're
going
to
explicitly
run
something
on
demand
or
onspot
by
controlling
the
tags
for
a
given
job.
We
also
tell
you
the
gitlab
executor
type,
so
you
can
see
here,
it's
docker
and
the
operating
system
is
linux,
so
this
also
supports
windows.
A
So
we
could
also
be
doing
shell
on
windows
or
linux
on
so
all
the
different
kinds
of
combos
will
kind
of
self-publish
what
they're
running
so
that
you
know
what
workloads
they
can
take.
Just
note
that
when
you
use
the
linux
docker
executor,
it
will
take
untagged
jobs
and
that's
because
that's
what
happens
on
gitlab.com,
every
other
executor
type
will
require
that
you
specify
tags.
A
So
if
you're
doing
a
linux,
shell,
runner
or
any
windows
runner,
you
have
to
specify
the
full
set
of
tags
to
route
to
that
runner
in
your
job
and
that's
simply
to
make
sure
that
it
behaves
kind
of
like
com.
So
the
default
ideas,
any
job
can
be
picked
up
by
a
linux,
docker
runner.
And
if
you
need
to
do
specialty
other
operations,
you
have
to
add
some
tags
to
your
job.
A
Also
note
that
I
logged
into
the
console
with
my
amazon
credentials
and
launched
the
template
in
there
and
that's
what
allowed
me
to
drop
this
code
into
a
specific
amazon
account.
One
thing
I
didn't
point
out
too
was
back
here
when
we
did
do
the
cloud
formation
launch.
Let
me
just
launch
another
one.
A
A
So
now,
let's
take
a
look
at
the
instances
which
we'll
find
in
ec2,
and
when
we
take
a
look
here,
I
was
mentioning
that
you
may
be
an
enablement
team
that
is
letting
your
your
end.
Customers
within
your
internal
organization,
deploy
runners
and,
at
a
certain
point,
someone's
going
to
say,
hey
this
runner's,
not
working
right
and
you're,
going
to
wonder
if
it's
an
aws
side
problem
and
then
starts
the
rabbit
holes
of
trying
to
figure
out
where
exactly
in
amazon
is
this
runner?
A
I
worked
at
one
organization
that
had
over
a
thousand
aws
accounts
and
we
were
pointing
at
one
gitlab
instance,
but
you
might
have
many
many
aws
accounts
and
multiple
gitlab
instances,
and
so
all
of
a
sudden
you
have
this
quandary
of.
Where
is
this
runner
machine?
So
what
this
template
does
is
create
some
tagging
to
make
that
identification
more.
Quick,
so
if
I
click
on
these
now,
I
happen
to
know
they're
in
this
region
and
in
this
account.
A
But
if
I
have
running
any
kind
of
inventory
anywhere
in
the
organization,
we
have
tags
that
start
to
tell
you
what's
going
on
with
the
runner
bits.
So
here's
the
get
lab
runner
tags
that
were
used
on
this
inside
and
what
we
should
see
in
the
console
which
we
did.
Here's
the
compute
type
also
gets
flagged
at
this
level,
which
is
not
a
natural
amazon
thing
to
do.
A
But
here
the
gitlab
runner
name
is
the
instance
name
in
the
account
name
in
the
region,
and
so,
if
we
go
back
to
gitlab,
we
can
observe
that
right
here
instance
id
in
account
number
in
region.
So
we
just
make
the
name
kind
of
overload
the
name
so
that
you
can
find
it.
The
reason
why
you
wouldn't
use
tags
for
that
information
is
if
the
runner
requires
tags,
then
it's
going
to
require
this
tags,
and
people
are
going
to
ask
you.
Why
am
I
required
to
enter
the
tag
us
east
one?
A
I
don't
care
where
the
runner
is.
So
that's
why
the
name
is
kind
of
overloaded
with
that
data
in
order
to
allow
quick
correlation
between
the
two.
That's
about
it,
for
the
for
helping.
You
understand
how
these
work.
There
are
a
bunch
of
pre-built
scenarios.
Here
there
are
four
five
for
amazon
linux,
two,
including
one
for
arm.
A
Then
there
are
four
for
windows.
1903
build
note
that
on
all
of
these
that
do
scaling,
the
scaling
is
not
particularly
tuned
to
anything.
It's
just
an
example
of
scaling,
so
I
believe
I
did
scale
on
cpu
with
usage
of
70
across
the
asg
will
trigger
scale
up
and
usage
of
20
or
40
will
scale
down,
and
it
will
use
step
scaling,
which
means
that,
if
you're
under
a
sudden
burst
of
activity,
it
won't
wait
till
you
know
the
first
one
it
spins
up
is
done
to
start
spinning
up
more.
A
A
In
order
to
do
scaling
up
and
down
which
might
be
more
appropriate
for
docker
machine
runners,
so
as
soon
as
you
get
into
scaling
a
little
bit
of
sre
skills,
both
in
terms
of
what
your
runner
workloads
look
like
and
how
you
might
scale
them
is
important,
you
should
know
that
we
turn
on
cloudwatch
metrics
for
both
operating
systems
and
load.
The
memory
is
uploaded
into
cloudwatch
metrics,
as
well
as
disk
io,
as
well
as
disk
space
and
other
things
so
that
you
can
potentially,
if
you're
having
problems
go
in
and
see.
A
Oh,
you
know,
even
though
we're
scaling
on
memory.
The
network
io
of
these
instances
is
not
sufficient.
So
let's
pick
a
different
instance
type.
So
even
if
you're,
not
if
you're
manually
scaling,
you
can
still
go
in
and
look
at
those
metrics
and
decide.
Oh,
let's
pick
a
different
instance
type
or
let's
have
five
now,
if
you
prefer
to
do
manual,
scaling
versus
auto
scaling.
So
just
keep
that
in
mind.
The
built-in
auto
scaling
scenarios
are
just
for
demonstration
purposes.
A
We're
going
to
work
to
try
to
see
if
we
can
track
more
scenarios
for
scaling
and
get
feedback
from
customers
into
this
project
and
find
out
what
people
are
using
for
scaling.
That
works
well
say
for
a
very
generic
load
in
runners,
but
quite
frankly,
there's
no
specific
machine
metric
that
is
predictive
of
your
load
on
gitlab.com.
We
do
use
job
cues
lengths,
but
those
are
not
really.
Those
will
cause
you
to
be
very
responsive
but
potentially
over
scale
in
order
to
be
responsive
and
so
there's
a
variety
of
ways
to
scale.
A
I
just
wanted
to
note
that
in
today's
easy
button
demonstration
we
were
using
a
default
vpc
in
amazon
and
going
out
to
gitlab.com.
That
means
that
I
automatically
had
the
ability
to
reach
out
to
the
internet
from
within
my
vpc
and
that
dns
and
network
routing
were
all
working
just
fine
to
my
gitlab
instance.
A
If
you
have
a
more
restricted
scenario
in
terms
of
the
vpc
or
the
gitlab
instance,
then
you'd
have
to
make
sure
that
those
paths
are
clear
and
open,
including
firewalling.
One
really
cool
thing
about
gitlab
runner
is
it
does
lightweight
polling
only.
So
you
only
need
to
be
able
to
reach
out
from
the
runner
on
port
443
to
the
gitlab
instance
and
then
be
allowed
to
have
return
conversations.
A
So
that's
the
good
news
as
far
as
network
connectivity
goes,
we'll
have
more
information
in
the
future
on
how
to
service
more
restricted
scenarios.
So
I
hope
that
this
new
ui
oriented
capability
to
quickly
get
runners
running
on
amazon
will
be
helpful
to
everyone
out
there,
our
customers,
our
channel
partners
and
our
internal
organizations
thanks
a
lot.