►
Description
Coding toolkit: .NET Workloads on AWS GitLab Toolkit: https://gitlab.com/guided-explorations/aws/dotnet-aws-toolkit/getting-started-with-net-on-aws
Learn how to leverage the code examples to create your own scaled runner for Windows builds. The example purposely builds .NET 4 Framework 4.x to show how the methods can be used for legacy builds - but the exact same methods are extensible to modern Windows development as well.
- 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 and .NET (DotNet) (https://youtube.com/playlist?list=PL05JrBw4t0KpYmx1n5PPhYCxxfGJdMxzZ)
- GitLab and Windows (https://youtube.com/playlist?list=PL05JrBw4t0KqOJeQ1y5wSBxArdTEtmnxb)
- DarwinTheorizes at GitLab (https://youtube.com/playlist?list=PL05JrBw4t0KoH74CcAtP0Ze7JXjX7zT6g)
A
B
So
we'll
talk
a
little
bit
about
some
of
the
things
we're
gonna
go
through
today.
First
spend
a
little
bit
of
time
on
the
common
development
approach
between
gitlab
and
aws.
It
turns
out
that
we
have
some
common
ways
of
building
technology,
which
makes
it
a
great
solution.
When
you
knit
us
together
to
be
used
together,
we'll
also
talk
about
what
is
get
lab
runner.
It
turns
out
that
it's
more
than
meets
the
eye.
B
B
Specifically,
there
are
ec2
image
builder
configuration
files
to
allow
you
to
build
your
windows,
runner
armies,
using
ec2
image
builder,
there's
also
a
what
we
call
the
scaling
git
lab
runner
vending
machine
for
aws,
and
this
allows
you
to
scale
a
typical
shell
runner
on
amazon
and
then
also
we
have
a
sample.net
for
x
project.
That
is,
you
can
use
to
build
and
test
a
forex
running
mechanism
all
right.
So
let's
talk
a
little
bit
about
the
commonalities
in
how
gitlab
and
amazon
develop
technology.
B
Both
companies
are
really
dedicated
to
iteration,
which
is
the
way
to
bring
continuous
customer
value
into
the
into
play.
At
amazon
you'll
see
they
bring
new
services
on
board
at
gitlab
we
bring
new
devops
stages
on
board
and
then,
as
those
are
brought
on
board,
they're
continually
improved
over
time.
Gitlab
is
actually
just
past.
The
10th
year
mark
of
month
over
month
releases,
each
of
which
usually
has
some
pretty
significant
functionality
in
it.
B
So
this
approach
is
common
between
both
companies
and
allows
us
to
iterate
together
and
to
to
make
the
value
of
using
the
solutions
together
better.
In
addition,
amazon
has
obviously
had
what's
called
a
platform
approach.
Gitlab
shares
this
approach,
as
well,
so
across
the
devops
stages
that
we
support.
We
have
our
own
solution
in
the
box.
We
are
very
forthright
about
the
maturity
of
those
solutions
in
each
of
these
different
stages.
You
can
find
that
information
on
our
product
direction
page,
and
so
we
provide
something
for
you
in
all
of
the
stages.
B
B
It
can
be
contractual
reasons
it
might
be,
because
you
need
to
keep
that
particular
piece
in
perpetuity
going
forward,
or
it
might
be
that
you
just
need
more
time
to
migrate
and
consolidate
tools,
and
so
for
all
those
reasons,
we
also
have
a
platform
approach
where
you
can
bring
what
you
need
to
the
to
the
mark
to
the
the
situation
and
wire
it
in
and
then.
Finally,
a
very
common
principle
is
code
first,
so
at
gitlab
everything
is
code.
B
Apis
and
clis
is
how
we
develop
things
and
then,
if
there
needs
to
be
a
graphical
user
experience
on
top
of
that,
so
be
it.
But
the
initial
entry
into
things
is
to
build
them
as
code
with
code
and
with
apis
and
cli.
So
that's
another
strongly
shared
fundamental
tenant
that
we
develop
commonly
with
technology
with
amazon.
B
It
say
in
a
container
or
in
rpm
packages
for
for
linux,
in
packaging
or
binaries
for
windows,
so
there's
a
lot
of
ways
that
we
build
it
for
you
ahead
of
time,
which
we'll
we'll
take
a
peek
at
in
just
a
minute,
but
you
can
also
anywhere
where
the
golang
runtime
run
works.
If
you
need
to
get
up
running,
you
can
actually
compile
it
and
build
it
for
that
platform
and
get
it
working
for
that
platform
as
well.
B
It
is
what
I
call
super
crazy,
flexible.
So
frequently
people
ask
questions
about
the
gitlab
runner
that
reveal
that
they're
thinking
it's
kind
of
a
simplistic
mechanism
and
they
say
well.
How
would
you
deploy
it
in
this
situation
and
we
generally
have
to
get
in
side
of
the
situation
and
say
well
what
are
your
goals?
What
what
do
you
need
to
do?
Are
teams
going
to
self-provision?
It
are
teams
going
to
rely
on
a
shared
pool
of
runners
or
a
combination
of
both
and
so
there's
what
platforms
do
you
need
to
support?
B
B
Gitlab
runner
has
something
called
executors
which
are
sort
of
modes
of
operation
and
with
executors
we
accommodate
platform
differences
for
at
the
operating
system
level.
So
linux,
windows
and
mac
are
fully
supported.
You
could
extend
it
to
another
os
platform
if
the
go
runtimes
are
there,
it
is
also
multiple
hardware
architecture
capable
so
arm.
B
Now
the
runner
itself
processes
the
jobs
of
a
gitlab
ci
yaml
file,
gitlab
ci
yaml
is
the
file
that
contains
the
gitlab
ci
domain,
specific
language
for
doing
ci.
It
is
declarative
and
it
is
pipeline
as
code,
and
what
this
means
is
that
when
you
see
something
that's
pipeline
or
billed
as
code,
everything
a
developer
might
need
to
do
in
a
build,
can
be
specified
inside
of
this
file
as
code,
and
that
makes
it
very
much
more
flexible
and
gives
developers
a
lot
of
self-empowerment
to
be
able
to
do
things
for
themselves.
B
So
I
actually
have
an
example
of
doing
powershell
where
it
does
powershell
on
a
windows
machine,
then
that
same
exact
pipeline
starts
running
on
powershell
on
a
linux
machine
that
same
pipeline
then
runs
powershell
on
a
dot-net
linux
container
where
powershell
is
pre-installed
and
then
the
same
pipeline,
installs
powershell
on
amazon,
linux
and
runs
inside
of
that
context
and
passes
artifacts
and
code
down
the
entire
pipeline.
So
just
keep
that
in
mind.
B
You
have
a
lot
of
flexibility
as
far
as
how
a
given
pipeline
routes
through
specific
runners
that
you
have
deployed
gitlab
runner
also
has
advanced
dispatching
capabilities
or
orchestration
capabilities.
So
when
you
use
the
docker
plus
machine
executor,
then
each
job
is
the
runner
actually
spins
up
virtual
machines
as
needed
and
deploys
jobs
to
them.
B
There's
also
just
the
plain
docker
executor,
which
is
what
we
use
in
the
runner
vending
machine,
there's
also
kubernetes
runner,
and
so
when
you
set
that
up
that
initial
pod,
that's
running
as
a
service
actually
deploys
pods
for
each
job
that
come
along
and
destroys
them
as
it
goes.
So.
The
container-based
runners
are
really
not
reusing
containers
for
between
different
jobs
and
then
there's
also
the
possibility
of
doing
a
custom,
executor,
and
so
one
example
of
a
customer
executor
is
on
gitlab.com.
B
We
actually
spin
up
a
virtual
machine,
run
a
job
on
it
and
destroy
it,
and
the
next
job
is
a
different
virtual
machine
as
we
go
through
you'll
get
the
picture
that
on.com,
it's
very
important,
that
we
do
not
reuse
compute
nodes,
because
we
don't
want
to
have
any
security
issues
of
leftovers
from
one
job
of
one
customer
being
accessible
by
another
customer.
So
we
have
a
high
level
of
sort
of
machine
destruction.
B
B
You
have
a
certain
number
of
included
minutes
and
you
can
buy
up
additional
minutes
and
then,
in
addition,
you
can
do
get
lab
self-managed
runners,
so
self-managed
runners
is
where
you
run
the
runner
binaries
on
your
compute,
and
that
can
really
be
anywhere.
It
could
be
a
physical
machine
on
a
physical
premise
if
you
want
it
to
be,
it
could
also
be
in
a
cloud
and
we're
talking
in
terms
of
amazon
today,
so
we're
talking
about
hosting
those
in
amazon.
B
B
One
of
the
common
patterns
for
having
a
gitlab
self-managed
runner
is
having
to
service
a
secure
account.
This
happens
more
in
cd,
so
get
lab
runners
used
for
both
ci
and
cd
in
the
gitlab
world,
and
you
can
embed
a
runner
very
deeply
in
a
secure
environment.
All
it
needs
is
port
443
out
to
the
instance
and
return
conversations
allowed.
So
this
allows
you
to
make
it
very
secure
because
it's
a
polling
type
structure.
B
B
So
with
runners,
when
you
have
net
framework,
I'm
going
to
assume
here
that
you're
not
trying
to
do
containers
while
you're
still
working
with
net
framework
code,
it's
possible,
but
it's
very
challenging
and
there's
very
few
organizations
that
approach
it
that
way.
So
with
that
constraint,
here's
some
of
your
options
when
you
use
gitlab
sas
runners,
you
do
not
have
control
over
the
windows
operating
system
version,
so
gitlab
does
one
operating
system
version
and
installs
a
lot
of
the
build
tools
pre-installed
for
fairly
modern.net
setups
with
self-managed.
B
Of
course
you
can
have
whatever
you
want
on
your
runner
image,
so
you
can
create,
have
full
control
over
the
windows
operating
system
version.
If
that
plays
an
important
role
in
your
software,
I
should
also
just
say
that
if
you're
compiling
windows-
software-
that
is
not.net-
that
is
c,
plus
plus
or
something
like
that,
all
of
what
we're
talking
about
today
also
applies
to
those
frameworks.
As
far
as
self-managed
runners
custom
build
agent
dependencies,
you
can
customize
the
build
agent
at
gitlab
only
by
pre-installing
stuff
as
part
of
a
job.
B
So
right
before
you
need,
say
some
additional
build
dependencies.
You
could
install
them,
not
a
problem
if
it's
a
few
k
or
even
a
few
megabytes,
but
if
it
starts
to
be
a
lot
of
code
like
an
alternate
version
of
the
net
sdk
or
entire
chunks
of
visual
studio
code,
this
is
a
rather
onerous
process
to
sit
there
and
build
out.
B
You
know
run
times
every
time
you
run
the
job,
so
it's
less
customizable
on
self-managed.
Of
course
you
have
control
over
that.
The
runnerspinupon.com
is
a
per
job,
ephemeral
vm,
so
it
takes
a
little
while
to
spend
up
an
entire
vm
run
your
job,
destroy
it
and
spin
up
another
one
with
your
own
self-managed
runners.
You
can
make
them
persistent
shell
runners,
so
they
do
not
need
to
have
the
software.
They
do
not
need
to
spun
down.
B
A
B
B
B
B
We
have
a
per
job
ephemeral
container
as
well
for
self-managed
windows,
container
availability
generally,
as
we
said,
we're
eliminating
the
windows
dependencies
for
this
scenario.
So
you
wouldn't
generally
need
that
if
you
have
linuxcompatible.net
and
then
for
runner,
scaling
managed
for
you
and
then,
of
course,
when
you're
in
linux
containerworldfor.net,
you
can
either
use
the
render
vending
machine
infrastructures
code
that
I'll
be
sharing
with
you
or
you
could
scale,
with
kubernetes
executor
using
eks
as
your
scaling
and
management
mechanism.
B
So
that's
kind
of
a
summary
of
where
you're
at
when
considering
net,
and
so
in
this
case,
using
the
shared
runners
of
gitlab
is
a
lot
more
serviceable
and
usable
as
we
go
forward.
We're
going
to
talk
about
how
you
create
your
own
self-managed
runner,
which
is
how
you
move
forward
with
this,
regardless
of
what
is
available
on
gitlabs.com
shared
runners.
B
So
one
of
the
big
linchpins
is
event.
The
eventing
system
in
windows
is
typically
been
graphical.
Now
you
can
get
to
with
powershell
command
list,
but
you
have
to
become
an
expert
in
those
commandments
to
really
navigate
the
eventing
system
of
that
logging
system.
So
one
of
the
interesting
things
here
is,
if
that
team
still
making
this
transition,
is
you
could
put
the
desktop
experience
on
or
use
a
an
army
that
has
a
desktop
experience
there,
so
that
that
root
cause
approach
can
still
be
used.
B
Then
we
just
the
previous
slide
back.
We
talked
about
this
scenario
and
of
course,
once
you
move
forward
to
open
source.net
with
no
windows
dependencies,
you
can
look
towards
potentially
using
eks
or
regular
container
higher
infrastructures
to
deploy
too
or
if
it's
going
to
stay
on
instances,
you
could
use
linux
instances,
so
it
opens
up
some
deployment
options
for
you,
these
other
scenarios,
I'm
not
going
to
go
through
in
detail
if
you
have
opensource.net
but
you've
retained
windows
dependencies.
B
Well,
then
that
implies
a
certain
runner
type,
a
certain
deployment
to
infrastructure
and
in
the
runner
column
I
tell
you
how
you
might
want
to
manage
runners
for
that.
This
also
talks
a
little
bit
about
nano.
I
have
watched
the
nano
version
of
windows
evolve
and
it
is
so
different
from
standard
windows
that
you
know.
My
question
is
always
well.
B
If
you're
going
to
re-learn
windows
at
that
gut
level,
does
it
make
sense
to
go
to
net
at
that
time?
It
may
not,
if
you're,
taking
advantage
of
some
specific
microsoft
technologies
that
you
find
really
valuable
in
your
stack
and
then
also.net
on
lambda
requires
that
you're
using
net
open
source.
So
if
you're
going
to
be
using.net
on
lambda,
that's
another
mechanism
there
and
so
we're
going
to
zoom
in
on
this
one.
Now
we're
going
to
spend
some
time
on
unpacking
how
to
do
this
kind
of
challenging
case.
B
B
At
this
point,
we
will
not
have
the
get
lab
runner
on
there,
and
that
is
because
the
gitlab
runner
is
a
small
single
binary
and
if
you
pre-deploy
it
to
this
image,
it
usually
creates
more
challenges
than
it's
worth,
because
you
have
to
do
a
lot
of
configuration
when
it
comes
time
to
actually
use
it.
In
addition,
you
need
to
keep
your
runner
in
step
with
your
gitlab
version,
so
if
you're
on
gitlab.com-
and
you
get
too
many
runner
versions
behind
the
actual
version
of
gitlab
sas,
frequently
you're
advised
to
update
that.
B
B
B
So
once
we
all
all,
this
is
totally
controlled
just
by
the
runner
registration
token
and
where
you
take
it
from
on
the
gitlab
site
and
then,
as
a
part
of
the
information
that
we're
sharing
with
you
today.
We
have
working
examples
in
these
three
areas,
so
we
have
the
ec2
image
recipe
components
for
you.
We
have
that
vending
machine
cloud
formation,
template
and
then
a
working.net
project
that
you
can
use
to
test
out
if
you're,
if
everything
you're
doing
is
working
as
you
expect
it
to.
B
B
B
B
When
we
take
a
look
at
this,
one
of
the
things
you
can
see
right
away
is
that
some
of
these
are
owned
by
amazon.
So
these
are
some
standard
ones,
they've
built,
and
then
I
have
some
custom
ones
that
I
built
that
are
available
for
you
in
a
repository
that
I
will
be
showing
in
just
a
moment
so
on
this
particular
image.
B
I'm
installing
the
cloud
watch
agent,
which
allows
me
to
then
be
able
to
get
metrics
back
for
scaling
capabilities,
I'm
using
the
amazon
one
for
chocolaty
and
then
also
the
aws
cli,
and
then
I
built
this
one
for
visual
studio
runtimes
when
we
dig
into
here
there's
a
couple
lines
here
that
control
some
prerequisites
for
gitlab,
and
that
is
git.
So
you
have
to
pre-install
git
and
then
powershell
core
on
windows
by
default.
Gitlab
runner
will
use
powershell
core.
B
In
this
case
these
particular
files
that
are
needed
in
this
directory,
we're
no
longer
in
any
build
tools
anywhere.
So
I
found
out
that
they
were
in
a
nuget
package,
and
so
I
expand
that
nuget
package
and
then
copy
those
files
in
place
and
voila
the
build
works.
So
one
of
the
cool
things
about
image
builder
is
it
can
accommodate
some
of
these
custom
requirements.
B
We
then
have
a
validation
test
for
my
validation
tests.
I
usually
just
do
get
command
on
the
commands
that
I'm
expecting
to
see
on
the
system.
One
of
the
cool
things
about
validation
tests
on
image
builder.
Is
it
will
build
the
image
it
as
an
omni,
then
reboot
it
and
run
your
tests
and
that's
really
cool,
because
then
you
know
that,
after
an
image,
boot
things
are
working
the
way
they
expect.
You
expect
them
to
frequently
too.
B
B
In
addition,
it
also
added
addition,
an
additional
one
that
was
not
in
the
original
code,
but
then
importantly,
when
working
with
the
ec2
image
builder
team,
they
shared
with
me.
The
best
way
to
reboot
between
stages
in
ec2
image
builder
is
to
simply
give
an
exit
code
of
3010
and
then
the
the
ec2
image
builder
engine
will
reboot
for
you
and
continue
where,
if
you
try
to
do
any
other
type
of
manual
reboot
or
a
timed
reboot,
where
you
get
some
latency
time,
you
can
easily
run
into
some
timing
problems.
B
So
this
can
be
really
handy.
You
can
put
it
in
it
as
many
times
as
you
want,
and
it'll
only
reboot,
if
necessary.
Many
of
you
run
into
the
scenario
where
you're
doing
a
build
and
you
suppress
all
the
reboots.
But
lo
and
behold,
one
of
the
components
won't
go
on
without
a
reboot
required
by
a
previously
installed
component,
and
this
helps
you
solve
that
problem
over
here
we've
run
the
image
builder
pipelines.
B
B
Now,
let's
make
this
image
available
to
you
know:
30
accounts
where
I
worked,
we
had
over
a
thousand
and
we
want
it
in
10
regions
and
all
of
a
sudden,
you
have
to
write
automation
to
replicate
that
one
army
into
10
regions,
which
gives
it
10
different
ami
ids
and
then
expose
it
to
100
accounts
and
I've
had
to
write
this
automation
from
scratch
and
it's
quite
a
pain.
Well,
lo
and
behold,
distribution
settings
are
built
right
into
this
framework.
B
B
B
If
this
is
not
sufficient,
you
can
also
tell
image
builder.
Do
not
destroy
the
image,
the
running
machine
if
I
have
a
failure,
and
so
you
can
also
diagnose
that
way,
with
tools
like
packer,
if
you're
using
packer
only
for
amazon.
This
problem
of
trying
to
diagnose
image,
build
failures
can
be
very
challenging
under
packer,
because
not
all
the
logs
are
brought
back
home
and
you
have
to
do
a
lot
of
special
fooling
around
the
other
thing
about
ec2,
that's
much
better
than
packer
is
with
packer.
B
You
have
to
open
up
remoting
endpoints
on
the
os
you're
automating
and
in
the
case
of
windows.
This
is
winrm
and
I
actually
have
a
blog
article
on
mission
impossible
code
that
talks
about
how
there's
no
way
to
return
win
rm
to
a
pristine
state.
An
ec2
image
builder
is
not
using
those
endpoints,
it's
using
ssm
to
do
all
the
automation
so
because
of
that,
you
do
not
have
to
worry
about
opening
up
those
endpoints
and
then
whoever
uses
the
image
can
decide
how
and
whether
to
open
up
the
endpoints
for
remoting
into
a
machine.
B
So
that's
another
big
benefit
or
advantage
to
it.
So
we're
going
to
take
a
look
at
the
last
image
generated
and
then
talk
a
little
bit
about
how
we
would
use
that
in
the
runner
vending
machine.
So
here's
the
last
image
that
was
generated
and
I'm
going
to
go
over
here
under
guided
explorations,
aws
get
lab
h
a
scaling
render
vending
machine.
This
is
where
this
code
lives.
B
B
B
B
So
I'm
going
to
retrieve
that
from
here
and
I
go
to
my
cloud
formation
stack
and
right
here
it
says
always
use
latest
we're
going
to
just
overwrite
that
with
the
specific
omni
id
and
then
we'll
come
into
gitlab
and
we
go
into
runners,
and
if
we
want
to
register
a
new
runner
to
this
group,
we
would
simply
grab
the
registration
token
and
when
we
go
back
into
our
cloud
formation
stack.
That
is
one
of
the
parameters
it
wants
down.
Here.
B
We
will
see
that
we've
run
it
in
the
past,
and
so
it's
right
here
and
you
can
see
everything
that
it
built.
It
has
the
parameters
and
here's
where
you
would
hit
update
to
say,
update
the
version
of
windows
or
update
the
version
of
the
runner.
We
can
rerun
the
stack
and
even
if
there
was
50
runners
in
there,
it
would
replace
them
all
once
that
stack
is
built,
it
creates
an
asg
and
the
asg
auto
scaling
group
has
various
parameters,
so
in
this
case
we're
not
doing
that.
B
B
B
If
there's
some
sort
of
challenge
that
we're
having
with
with
the
system,
so
that's
kind
of
using
that
image
in
auto
scaling
to
build
an
auto
scaling
group
which
then
builds
our
runner
for
us
and
then
when
we
go
into
our
project,
the
runner
builds
inside
of
here.
One
of
the
things
that
this
infrastructure's
code
does
is
it
exposes
a
lot
of
information
as
tags
for
you,
so
we
can
see
here
that
this
is
a
dotnet
forerunner
and
you
can
actually
tell
it
what
tags
to
to
put
right
here.
B
B
Actually
all
of
them
were
specified
for
me,
except
net4.
So
then
the
compute
type
on
demand
tells
me
that
it's
not
running
on
spot.
The
other
interesting
challenge
that
you
have
when
you
have
large
runner
fleets
is
finding
out
what
amazon
account
is
this
runner
in
or
if
you're
looking
at
the
runner?
Where
is
this
runner
in
gitlab,
and
so
there's
purposely
some
conventions
followed
here
to
help
you
with
that.
B
So
once
we
have
this
runner
running,
then
we
can
process
our
project,
and
so,
if
we
go
over
to
our
project,
oh
I
just
want
to
quickly
show
you.
The
files
for
easy
two
image
builder
are
inside
of
this
particular
project,
so
under
ec2
image
builder.
These
are
the
files
that
you
import
into
ec2
image
builder
in
order
to
use
that
and
that'll
be
in
the
the
final
slide
notes
that
we
share.
B
Our
specific
project
and
this
project
is
not
commerce.
It's
open
source,
it's
been
around
forever,
so
it
has
a.net
for
x
version,
but
it
also
has
a
recent
version.
So
I'm
also
hoping
to
use
this
in
an
assessment
toolkit
that
we're
looking
at
building
to
assess
your.net
for
codebase
and
how
hard
is
it
going
to
be
to
make
it
into
a
newer
version?
B
So
runner
tags
can
be
used
either
informationally
or
for
routing
jobs,
and
you
do
that
by
telling
the
runner
that
it
will
only
take
tag,
jobs
that
matches
tags
or
it
will
take
any
job
regardless
of
tag
matches.
So
you
want
to
be
careful
about
using
a
whole
bunch
of
informational
tags
if
you're
also
using
the
tags
to
route
to
that
that
particular
runner.
B
So
in
this
case,
this
is
how
we
make
sure
this
job
runs
on
that
exact
runner,
that
we
talked
about
and
showed
you
and
then
one
cool
trick
here
is
the
build
binary
so
finding
the
latest
ms
build
exe
in
the
dot
net
framework,
4x
that's
on
the
local
system.
So
when
you
install
a
lot
of
tool
kits
and
runtimes,
you
might
end
up
with
more
than
one
directory
at
this
level
within
your
dot
net
framework
directory.
B
B
A
previously
run
job,
so
this
one
was
run
just
yesterday
and
within
this
job
there
is
a
lot
of
information.
The
job
log,
when
a
job
log
is
too
long
to
display.
Here
you
can
click
this
icon
to
show
the
complete
file
in
a
raw
browser
format.
So
it's
built
a
lot
of
assemblies
and
then
we
just
grab
a
specific
one
of
those
and
emit
its
uh.net
attributes
version
attributes.
B
B
So,
there's
a
lot
of
a
lot
of
the
effort
at
this
software
as
a
service
company
was
based
on
lifting
and
shifting
legacy
workloads,
and
it
turned
out
that
a
lot
of
those
would
obviously
be
lifted
and
shifted
directly
at
first
before
being
modernized.
So
because
of
that
we
had
to
accommodate
for
both
operating
systems.
B
But
with
image
builder,
I
found
that
there
are
a
few
challenges
if
you're
a
windows
builder,
whether
you're
experienced
or
not
with
building
windows
images.
So
I
have
a
bunch
of
the
first
time
gotchas
here,
one
of
them,
for
example,
that
is
very
specific
to
visual
studio.
Build
tools
is
visual
studio,
build
tools
when
you
call
them
through
chocolatey.
If
you
run
out
of
disk
space,
it's
not
easy
to
find.
You
have
to
dig
really
deep
into
the
visual
studio
installer
logs
to
find
out.
B
Oh
I'm
just
out
of
disk
space,
and
so
I
found
that
out
the
hard
way,
and
so
I
make
mine
large
get
the
build
running
successfully,
and
if
I
want
to
tune
it,
I
can
down
scale
in
a
bit.
So
in
this
case
it
was
750
gigs.
Now
you
have
to
be
careful
too,
that
that's
going
to
be
used
for
runner
temporary
space
during
build,
so
you
don't
want
to
run
it
so
tight
that
you
only
have
extra
10
gigs
or
something
like
that.
You
want
to
leave.
B
You
know
a
couple
hundred
gigs
at
least
free
for
large
builds.
That
might
happen,
but
so
you
can
reference
this
for
some
of
the
things
to
keep
in
mind
it's
a
long
list,
but
it
also
is
very
detailed
to
the
experience
that
I
have
had
with
building
windows
in
the
past
and
then
another
challenge
with
a
hanging
sysprep.
That
was
what
was
solved
by
taking
a
reboot
if
needed,
before
allowing
sysprep
to
run.
B
B
So
that's
another
benefit
here,
all
right.
So
let's
switch
back
to
our
slides
here.
I
just
wanted
to
talk
through
a
few
of
the
benefits
that
may
not
have
been
self-evident
of
the
runner
vending
machine,
so
it
is
creating
runner
infrastructure
as
production
grade.
So
if
you
think
about
developers,
sometimes
we
think
about
their
tools
as
not
needing
to
be
production
ready,
but
if
you're
trying
to
patch
your
software
for
a
zero
day,
vulnerability
and
your
runner
system
isn't
working
quite
right.
B
It
becomes
very
quickly
evident
that
if
you're
supporting
production
grade
stacks
with
your
software,
then
your
devops
needs
to
be
production
grade
and
that's
what
this
endeavors
to
do.
It
is
also
self-serviceable
because
it's
written
in
cloud
formation,
you
can
plug
this
into
service,
catalog
or
control
tower
service.
Catalog
lets
your
developers
go
vend.
Their
own
runners
and
control
tower
allows
you
to
run
a
gitlab
vendor
with
each
new
amazon
account
you
create.
B
So
if
you're
large
enough,
where
you're
actually
vending
amazon
accounts
for
various
purposes,
you
can
wire
a
gitlab
runner
to
be
available
as
soon
as
the
account
is
up
and
running
it
uses
asg
for
scalability,
and
it
is
multi-platform
capability
capable
maintainability
built
in
is
another
aspect
of
this
patching.
The
underlying
instances,
as
well
as
patching
they're
upgrading
the
gitlab
runner
binaries
themselves
when
needed
is
built
in.
So
you
just
rerun
the
cloud
formation.
B
B
In
fact,
if
you
dig
in
the
repo
we
created
a
build
x,
runner
docker,
build
x,
which
will
allow
you
to
build,
say
a
power
pc,
docker
image
or
system
390
power,
docker
image
on
top
of
gitlab
running
on
amazon
linux
on
arm
so
docker
can
do.
Cross
architecture
builds
and
we've
already
put
a
runner
extension
in
there
for
that
into
this
infrastructure's
code.
There's.