►
Description
NEW VERSION for 2022: https://youtu.be/7Kmxbf7lVRY
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.
Table of Contents:
00:00 - Intro and agenda
03:23 - What is The GitLab Runner?
06:25 - SaaS and Self-Managed Runners on AWS Compared
12:20 - Mapping Runner Options to Your .NET Workload Runtime Targets
16:15 - EC2 Image Builder for Creating CI AMIs for Legacy .NET Builds
29:57 - Using the GitLab HA Scaling Runner Vending Machine for AWS EC2 ASG to deploy a scaled .NET Framework 4.x GitLab CI Runner
35:34 - Mapping Build Jobs To Your .NET Framework 4.x CI Jobs
37:05 - Calling Windows PowerShell from PowerShell Core (which GitLab Runner Always Requires)
42:44 - Kicking Off a Build and Viewing Evidence That We've Actually Compiled a .NET 4.5 Assembly
40:20 - Summary of What Was Shown and Wrap Up
- 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
A
A
We'll
also,
then,
talk
about
windows
runners
on
the
gitlab.com
sas
offering
as
well
as
self-managed,
and
what
kind
of
things
you
can
and
can't
do
in
those
two
types
of
setups.
We'll
also
talk
about
your
dot
net
stack
journey
on
git
lab
so,
depending
on
your
starting
point.
That
will
inform
a
lot
of
kind
of
your
approach
to
everything.
A
We're
gonna
go
as
far
back
as
dotnet
4x,
and
the
main
reason
for
this
is
there
are
a
lot
of
legacy
workloads
coming
out
of
the
the
woodwork
now
that
want
to
get
on
to
cloud
and
want
to
modernize,
but
very
frequently.
The
first
step
to
that
is
to
lift
and
shift
onto
the
cloud.
So
we
want
you
to
know
how
to
lift
and
shift
your
ci
into
gitlab
running
on
aws,
so
that
you
can
take
those
stacks
forward
and
modernize
them.
We'll
also
talk
about
more
modern.net
stacks
as
well.
A
We'll
talk
a
little
bit
about
ec2
image
builder
for
creating
runner
omnis
with
windows.
Creating
a
windows
prepared
image
can
be
a
pretty
big
challenge.
I've
done
it
two
different
ways
without
using
ec2
image
builder,
both
with
packer
as
well
as
just
straight
cloud
formation
automation-
and
I
can
tell
you
that
the
ec2
image
builder
is
a
lot
easier.
If
you
take
the
time
to
get
the
knack.
A
So
let's
talk
a
little
bit
about
what
exactly
are
get
lab
runners.
First
of
all,
they're
written
in
the
open
source
language
go,
and
that
means
anywhere
where
the
go
lang
run.
Time
works,
you
could
compile
the
code,
so
we
do
have
customers
who
decide
to
go
ahead
and
try
to
adapt
the
runner
to
work
on
platforms
that
are
not
officially
supported
in
our
distributions
and
that's
perfectly
fine.
But
you
should
know
that
if
the
golang
runtime
can
work
on
a
platform,
then
the
runner
can
potentially
be
placed
there.
A
There's
what
I
call
super
crazy
flexible
for
many
different
implementation
permutations.
Just
some
of
those
are
it's
multi-platform,
so
windows
and
linux
are
easily
accommodated.
Other
platforms
that
are
linux-esque
can
be
as
well.
I'm
running
a
runner
on
the
raspbian
raspberry
pi
os.
So
there's
a
lot
of
flexibility
here.
A
A
Just
a
side
note,
gitlab,
ci
yaml
files
are
pipeline
is
code,
which
means
you
define
your
ci
cd
processes
in
another
file,
that's
inside
of
your
source,
repository
for
that
same
repository
or
processing.
Now
this
is
a
more
modern
method
than
some
of
the
ci
services
out
there
that
have
a
legacy
of
storing
your
pipeline
code
somewhere
else
or
in
a
database
or
on
a
local
build
machine.
So
it's
pipeline
is
code,
but
it
processes
those
individual
jobs
and
it's
important
to
realize
that
the
jobs,
not
the
pipelines,
run
on
runners.
A
So
I
can
create
a
pipeline
that
has
five
different
runners
completely
physically
different.
They
can
be
completely
different
as
far
as
their
executor
so
running
on
docker
and
one
and
a
shell
executor
on
another.
They
can
even
switch
os
as
mid-stream.
So
just
keep
that
in
mind
that
runners
technically
process
jobs
and
a
pipeline
knits
those
jobs
together.
A
There
are
some
advanced
aspects
to
it,
I'll
just
touch
on
these.
Technically,
it's
also
a
job
dispatcher.
So
when
you
use
the
docker
plus
machine
executor,
then
there's
a
bit
of
the
get
lab
runner.
That's
actually
dispatching
individual
docker
images
running
to
process
each
job,
so
it
can
also
do
sort
of
a
job
dispatcher.
The
same
is
true
of
eks.
A
So
let's
just
chat
a
little
bit
about
what
is
possible
with
regard
to
sas
and
self-managed.
So
on
the
left
here
we
have
sas
depicted
as
the
cloud,
so
this
would
be
you're
using
gitlab.com
and
you're,
using
the
shared
runners
that
are
up
there
and
then
also
on
self-managed.
So
in
this
case
we're
today
we're
talking
about
running
git,
gitlab
runner,
self-managed
inside
of
aws
in
the
upper
left
corner
of
this
slide.
A
You
can
see
that
we're
talking
about
net
framework
and
so
doing.net
framework
in
containers,
while
doable,
requires
so
much
code,
refactoring
that
it
can
be
a
real
challenge.
You
might
want
to
go
straight
to
net
core,
so
we'll
talk
about
it
in
terms
of
shell,
so
custom
build
agent
dependencies
so
frequently
on
build
machines.
You
have
dependencies
that
are
specific
to
the
software
that's
being
built.
So
in
get
lab
shared
runners,
we
have
a
standardized
vm.
A
We
try
to
load
as
many
tools
as
possible
for
a
modern.net
code
base,
you're,
not
able
to
specify
on
our
sas
infrastructure
a
different
image
than
what
the
standardized
one
is
and,
of
course,
when
you're
self-hosting
you
get
to
pick
your
image.
In
fact,
you
have
to
prep
your
image
for
whatever
you're
going
to
be
running
on
there
runner
spin
up.
So
we
do
a
per
job.
A
Ephemeral
vm,
as
I
mentioned,
because
of
security
constraints,
where
on
a
self-managed
runner,
you're,
usually
pretty
comfortable
with
your
security
boundary,
because
it's
not
shared
tenancy
with
other
completely
different
companies.
So
you
can
have
a
persistent
shell
runner,
which
speeds
some
things
up
and
also
lets
you
do
some
unique
things
in
terms
of
caching
and
then
windows
container
availability.
A
A
We
is
a
custom
executor
on
sas
and
there's
a
very
good
scaling.
It
scales
very
well
and
is
constantly
sre
monitored,
so
it's
very
much
a
managed
service
and
then
over
on
the
amazon
side,
we
would
use
aws
asgs
to
scale
shell
runners
in
order
to
allow
scaling
and
aha
I'm
going
to
take
a
slide
and
break
down
all
the
different.net
journeys
you
might
be
into.
But
if
you've
gone
to.net
core
and
standard
and
have
eliminated
your
windows
dependencies,
then
this
is
kind
of
the
same
comparison.
A
So
custom
build
agent
dependencies
because
we're
dealing
with
linux
containers
then
on
the
on
the
shared
runners.
Then,
of
course
you
can
use
whatever
container
you
want,
one
that
you've
prepared
or
a
standard
one
off
the
shelf,
and
when,
when
doing
self-hosting,
you
can
decide
whether
to
do
linux
containers
as
your
runner
or
shell
runners,
runner,
spin
up
per
job
ephemeral
container
and
that's
the
same
way
if
you're
doing
a
container
runner
even
for
your
on-prem
windows
containers
availability.
A
So
a
lot
of
folks
understand
that
if
you
can
run
your
code
on
gitlab.com
our
sas
offering
and
we
provide
some
shared
runners,
shared
runners-
you,
if
you
exceed
the
minute
allocation
of
your
licensing
level,
you
can
buy
additional
minutes,
and
so,
in
this
case
the
money
you're
spending
for
get
lab
covers
a
sas
offering
so
all
your
compute
and
all
the
management
and
all
the
sre.
Absolutely
everything
when
we
get
into
self-managed.
A
You
would
have
your
own
runner
running
inside
of
your
premises
and
one
of
the
critical
things
that
folks
don't
necessarily
know
about
is
that
we
can
connect
self-managed
runners
to
your
sas
solution.
So
you
don't
have
to
be
doing
gitlab
self-managed
in
order
to
do
your
own
runners.
You'll
see
this
referred
to
on
the
gitlab
website,
as
private
runners,
and
really
we
use
that
as
kind
of
a
handle
for
self-managed
runners,
so
put
your
runner
farm
wherever
you
want
and
point
to
that
gitlab.com
instance.
A
So
this
means
that
you
can
use
gitlab
sas
and
still
do
any
kind
of
windows
build.
You
want
it's
just
that
you
would
have
to
do
your
own
self-managed
runners
for
those
kind
of
windows
builds
that
are
not
appropriate
for
the
sas
runners
in
this
case,
you're
only
paying
compute
and
then,
of
course,
if
you
do
have
an
on-prem
gitlab
instance,
then
you
have
to
use
self-managed
runners
if
you
have
self-managed
gitlab
something
to
be
aware
of,
because
I
constantly
get
questions
about
this
is
with
gitlab
runner.
You
pay
no
licensing
for
the
runner.
A
A
The
other
thing
is,
obviously
you
can
have
net
stacks
that
are
in
completely
different
situations.
So
if
you
have
a
lot
of
dot
net
workloads,
then
you'll
need
to
assess
those
stacks
compared
to
what
we
have
here.
So
the
first
one
is
one
we've
already
talked
about.
If
you
have
net
framework
for
acts,
then
we're
going
to
say,
hey,
you
always
have
windows
dependencies.
A
Your
runner
types
include
the
windows.
Shell
is
the
most
likely
and
option.
I
also
want
to
note
here
that
with
windows,
shell
on
amazon,
you
can
optionally
have
the
full
desktop
experience
installed
on
that
server,
for
teams
that
are
making
the
adjustment
to
having
to
do
problem
diagnosis
from
windows
at
just
a
command
line
environment.
A
This
can
be
helpful.
They
can
still
use
event.
Viewers
is
really
the
big
one
where
the
powershell
commands
to
do
event.
Viewer
stuff.
Are
there
they
work
great.
They
are
the
proper
migration
path
for
moving
this
skill
set
forward,
but
maybe
they
need
a
little
more
time
to
adjust.
If
you
want
to
force
the
issue,
then,
of
course
you
can
create
these
runners
without
the
desktop
experience.
A
So
we
talked
about
that
one,
the
next
one
too,
we've
also
touched
on
which
is
net
core
standard.
Where
you,
where
you
have
eliminated
your
windows
dependencies,
then
you
can
potentially
move
directly
to
a
full
on
linux.
Docker,
for
both
your
runners,
as
well
as
your
deploy
infrastructure,
also
notice
that,
on
these,
the
deploy
infrastructure
does
not
have
to
match
the
ci
infrastructure.
So
let's
say
that
you're
deploying
to
linux
servers
there's
very
likely.
You
could
still
use
linux
containers
to
do
all
of
your
ci.
A
A
The
other
thing
here,
that's
really
important
is
nano,
is
so
different
than
regular
windows.
It's
much
smaller,
but
just
like
linux
is
much
smaller,
because
so
much
is
stripped
out
that
nano
is
so
much
smaller
that
it
starts
being
quite
a
different
beast.
One
small
example
is
that
the
windows
installer
framework
is
not
there
to
install
software.
So
if
you
have
dependencies
that
are
still
packaged
only
in
windows,
installer
you're
going
to
be
out
of
luck
here
anyway,
and
so
just
keep
that
in
mind
that
that
os
is
so
refactored.
A
A
A
Within
this
repository,
I've
created
a
new
subfolder,
so
this
is
the
repository
for
the
gitlab
scaling
running
vendor
machine
which
we'll
actually
use
to
deploy
this
image.
There's
a
new
folder
called
ec2
image
builder.
Now,
within
this
image
builder
folder,
there
is
a
readme
and
it
includes
some
gotchas
for
those
who
are
windows
provisioning
proficient
but
have
not
done
it
using
ec2
image
builder
I'll,
be
mentioning
a
few
of
those
as
we
go
through,
but
just
keep
in
mind.
There's
a
good
documentation
place
to
start
here
as
well.
A
A
First,
one
of
the
things
I've
created
is
I've
used
a
standard
function
that
I
use
a
lot
called
logit,
which
simply
puts
information
on
the
screen
like
write
host,
but
then
also
puts
it
into
the
windows
event.
Log
well
ec2
image
builder
logs
everything
to
cloud
watch
so
that
you
can
go
find
it
that
happened
on
the
individual
instance.
There's
no
record
on
the
instance
left
of
what
it
did,
and
so
here
we're
able
to
record
a
little
bit
of
that.
A
There
are
two
items
that
are
kind
of
table
stakes
for
a
get
lab
windows:
runner
one
is
git,
has
to
be
pre-installed
and
the
other
one
is
powershell
core.
So
whenever
gitlab
runner
is
on
windows,
it
wants
powershell
core.
Even
if
you
are
needing
to
use
powershell
for
windows
on
that
machine,
to
do
certain
things
so
you'd
have
to
call
out
to
it,
but
it
wants
powershell
core
to
be
its
default
shell,
to
keep
things
simple.
A
A
A
A
Commandlet
is
capable
of
finding
regular
executables
on
the
system
if
they're
on
the
path,
so
I
basically
say
get
command
to
find
out
if
git
and
powershell
are
here.
So
it's
taking
this
list
here
and
pushing
it
through
this
for
each
loop
and
then
we
do
it
again
for
these
dependencies
to
understand
if
they're
there.
If
we
get
happy
results
for
all
of
this,
then
the
test
passes
and
our
image
contains
continues.
A
One
of
the
really
cool
things
about
image
builder
is
the
build
phase
happens.
Then
we
create
an
ami.
Then
we
boot
the
ami
and
run
the
test
phase.
So
sometimes
there
are
things
you
do
in
windows
that
are
not
going
to
be
active
and
available
until
after
a
reboot-
and
this
happens
naturally
with
the
build
and
the
test
phases
of
image
builder.
A
A
A
There
is
some
test
pending
reboot
code
here,
which
tests
six
different
conditions
for
when
you
might
need
a
reboot.
It's
loosely
based
on
another
utility
that
tests
for
pending
reboots,
except
I've,
stripped
it
right
down
to
individual
checks
so
that
it's
very
compact,
otherwise
it
could
be
several
pages
long.
I've
also
added
a
check
on
here
for
a
windows
feature
pending
reboot,
which
was
not
in
the
original
code,
so
that
information
is
right
here.
So
these
are
all
the
checks.
A
If
any
of
these
are
true,
then
we
know
we
have
a
pending
reboot,
then
down
here
we
want
to
log
that
information,
and
originally
I
was
rebooting
with
a
technique
of
using
shutdown
and
giving
10
seconds
so
that
this
orchestration
automation
could
close
out
properly
and
say:
hey.
I
ran
the
reboot
if
needed,
job
properly.
A
I
learned
from
the
image
builder
team
that
if
I
do
an
exit
3010,
which
is
a
classic
windows,
installer
exit
code,
indicating
I
need
a
reboot
that
then
the
handler
that
handles
all
of
these
components
will
go
ahead
and
reboot
the
system
for
me.
So
that's
super
useful
because
you
could
technically
insert
this
as
many
times
as
you
want,
wherever
you
need
it
and
it
will
reboot
if
and
only
if
needed.
So
it's
kind
of
item
potent
in
that
way.
The
reboot,
if
needed,
to
if
you've
done
a
lot
of
windows
orchestration.
A
You
know
that
a
lot
of
things
like
chocolatey
packages
or
your
own
packages,
you'll
suppress
reboots
on
purpose,
but
then
you'll
run
into
a
piece
of
software
that
needs
the
previous
software
to
be
registered
as
installed,
which
won't
happen
until
our
reboot.
So
basically,
this
reboot,
if
needed,
lets
you
insert
that
wherever
you
know,
you're
going
to
need
a
reboot
and
it'll
keep
on
orchestrating
the
system
for
you
and
then
the
final
one
that
I
want
to
show.
A
You
is
more
for
an
fyi,
but
git
lab
has
the
shared
runners
that
we
talked
about
on
gitlab.com,
and
so,
if
you've
been
using
those,
you
might
be
like
hey
we're
going
to
do
our
own
runners
now
and
oops
we're
dependent
on
what
that
build.
Runner
looks
like
because
we've
been
using
it
for
six
months
or
whatever,
so
this
one
here
is
the
same
as
gitlab.com.
A
So
this
is
built
to
allow
you
to
build
your
own
custom
images,
but
also
apply
patches,
re-provide
armies
for
your
organization
or
for
your
team
if
you
work
at
a
team
level.
So
if
we
look
through
here
we're
going
to
look,
these
are
our
image
pipelines
and
the
image
pipeline
that
I've
been
working
on
here
is
the
windows
net
framework
ci
and
it's
composed
of
recipes,
which
we
just
looked
at
those
two
recipes,
I'm
going
to
click
into
recipes
and
the
recipes.
A
If
I
take
my
latest
notice,
there's
versioning
throughout
so
anytime,
you
go
to
create
something
in
here
based
on
a
previous
one.
It
says:
hey,
you
got
to
create
a
new
version
which
is
a
great
way
to
keep
a
history,
here's
our
recipe
and
in
our
recipe
we
say
things
like
what
size
should
the
disc
be.
We
also
say
and
that
by
the
way
that
was
one
of
the
gotchas
I
ran
into
was
when
windows,
when
visual
studio
installer
fails
due
to
disk
space.
A
That
error
does
not
bubble
up
very
well
within
within
chocolaty
and
then
subsequently
within
ec2
image
builder.
So
one
of
the
gotchas
I
point
out
is
don't
keep
the
default
of
30
gigabytes
and
run
a
visual
studio
installer,
because
you're
going
to
hit
the
limit
and
it's
going
to
be
hard
to
figure
out.
What's
going
on
so
you
can
see,
I
have
a
750
gigabyte
here.
A
It
shows
just
the
associated
components
and
that
are
used
by
this
image,
but
I'm
going
to
go
into
the
create
interface,
so
it
shows
us
a
more
sensible
organization's
information,
so
we
picked
a
managed
image
of
amazon
in
this
case
windows
2016
server
you
can
tell
it
which
server
os
is.
This
is
valid
to
be
run
on,
so
we
can
pick
several
different
ones.
We
must
install
the
ssm
agent
now
a
lot
of
the
windows.
A
Images
provided
by
amazon
have
it
already
on
there,
but
you
might
be
using
one
that
doesn't
have
it
on
there.
I
always
run
this
bit
of
code
to
make
sure
it's
there
and
that
it
started,
and
this
handles
it
this.
This
is
also
item
potent.
So
if
it's
already
running
it's
not
going
to
run
the
code,
so
you
don't
have
to
worry
about
whether
it's
running
or
not
just
drop
that
code.
In
now.
Let's
look
at
the
build
components
in
the
build
components
we
can
see
amazon
cloudwatch
agent.
A
A
A
If
I
go
down
further,
we
can
see
that
I'm
installing
chocolaty
the
aws
cli
and
then
my
build
tools,
visual
studio,
2019
component,
that
we
looked
at
earlier
and
the
reboot
if
needed,
component
and
then
finally
down
here
in
test.
We
have
the
test
component,
so
this
will
all
run
together
as
part
of
this
recipe
and
we
can
quickly
go
take
a
look
at
the
results.
A
A
A
A
A
So
if
you
wanted
to
do
that,
you
could
go
look
at
it
after
a
successful
install
or
during
a
failed
install
log
into
the
failed
instance
and
check
that
out,
but
you
do
get
a
substantial
amount
of
logging
right
into
cloud
watch
as
part
of
the
regular
process,
so
you
can
diagnose
problems
that
happened
last
week
when
a
given
image
was
created.
I'll
just
briefly
go
into
infrastructure
configuration
here.
So
I
have
this
debugging
configuration
I
normally
use.
A
It's
got
this
one
interesting
setting
terminate
instance
on
failure
disabled,
so
that
makes
sure
that
I
can
find
and
get
into
that
instance
and
dig
deeper
into
any
problems.
I
might
have
had
distribution
settings
solves
a
whole
different
set
of
problems
that
that
people,
sometimes
when
they
start
making
images,
don't
realize
they're
going
to
have
so
you
have
to
copy
images
between
regions.
A
If
I'm
doing
a
public
image,
all
of
that
can
be
easily
managed
here
in
distribution
settings
and
when
you
need
to
update
it,
you
just
go
in
and
add
a
little
bit
of
config
and
on
the
next
run,
it
will
catch
new
accounts
that
you've,
added
or
or
leave
out
accounts
that
you've
dropped.
So
very
handy.
In
terms
of
that
last
mile
of
distributing
your
images.
A
Next,
I
want
to
show
you
using
the
gitlab
scaling
runner
vending
machine
for
aws
ec2asg
to
take
the
image
we
just
made
and
deploy
a
runner.
If
you
look
down
here
in
this
list,
there
are
a
lot
of
features
of
this
particular
automation,
but
one
of
them
is
going
to.
Let
us
take
an
image
of
a
shell
runner
for
windows
and
scale.
It
make
sure
that
it's
if
it
terminates
it'll
it'll
launch
a
new
one.
A
I'm
going
to
pick
my
region
and
we'll
we're
actually
just
going
to
walk
through
this,
as
if
we
were
going
to
set
it
up.
If
I
go
back
to
my
image,
ec2
image
builder
and
click
on
the
image
that
was
generated,
I
can
receive
an
ami
id
right
here,
notice
that
I'm
in
oregon,
so
I'm
going
to
have
to
make
sure
that
when
I
launch
this
template,
I'm
in
oregon
and
I
could
have
deployed
it
to
all
regions
and
it
would
have
had
a
different
omni
id
in
the
various
regions.
A
As
I
go
through
here,
I'm
going
to
have
to
set
for
windows
and
then
right
here
it
says,
peg
the
ami
to
a
specific
one
or
use
the
latest.
So
if
I
left
this
at
latest
and
then
change
this
to
a
windows
based
ssm
parameter,
then
it
would
pick
up
a
windows
image.
I'm
going
to
simply
peg
this
to
the
omni
that
we
just
built
we're
going
to
go
on
gitlab.com,
I'm
going
to
just
put
in
a
runner
token
here.
A
And
then
we'll
run
the
latest
gitlab
runner
the
rest
of
the
items.
We
can
pretty
much
leave
it
default
for
a
simple,
warm,
aha
runner,
which
means
that
if
it
terminates
it'll
be
relaunched
and
we
hit
acknowledge
and
create
stack
now.
I
have
done
this
ahead
of
time
so
that
we
can
show
you
how
that
works
and
within
the
aws
area
of
guided
explorations
here,
I'm
going
to
back
up
one
step
and
we'll
go
to
this.net
workloads
on
aws
2
toolkit
under
this
subsection
is
some
projects.
A
The
getting
started
project
points
you
to
all
the
information
of
today's
session,
as
well
as
many
other
resources,
but
I'm
going
to
click
into
this
building.net
framework
projects
on
aws
and
inside
of
here
we've
been
using
one
of
the
runners
prepared
with
that
automation.
I
was
showing
you
so
let's
take
a
look
at
the
runners
that
this
code
creates
we'll
look
first
in
gitlab
here
and
we
see
available
specific
runners.
So
this
is
a
runner
that
I've
created
with
the
automation
that
we
just
launched.
It's
not
the
exact
same
one.
A
This
is
one
I
created
before
and
in
that
case
I
gave
it
this
tag.
Here.Net
4,
which
helps
me
understand
that
this
is
specifically
targeted
at
running.net
4..
I
can
give
it
any
custom
tags
I
want
it's
also
scheduled,
which
means
that
it
doesn't
run
24
7.,
and
so
I
always
make
sure
that
the
automation
tags
them
as
using
a
schedule
so
that
we
know
that
that's
the
case
here.
A
A
This
also
lets
you
route
the
jobs,
as
we
already
noted
and
then
in
addition,
in
the
case
of
the
asg
vending
machine,
we
put
the
actual
instance
id
in
the
account
id
in
the
region
right
here
and
the
reason
I
do
this
is
when
I
worked
at
a
very
large
organization
before
coming
to
gitlab.
The
question
was
always:
where
is
this
instance
when
you're
in
the
runner
panel,
because
we've
had
literally
hundreds
of
them
and
then
when
you're
in
an
amazon
account
you're
like?
A
If
they're,
if
they're
required,
you
may
not
want
to
put
too
many
informational
tags
here,
or
else
it
gets
burdensome
to
target
them
in
your
jobs
and
then
on
the
amazon
side.
We
see
the
same
runner
right
here,
and
so
this
machine
is
active
and
it's
running
those
jobs.
It's
a
shell
runner.
One
of
the
interesting
things
is
this
automation
also
propagates
the
tags
forward.
So
we've
got
some
helpful
information
in
here
like
the
gitlab
url,
we've
got
the
runner
tags
that
are
in
gitlab,
so
we
reflect
them
back
into
here.
A
So
it's
easier
to
make
sure
you're
identifying
the
same
thing
and
the
compute
type
we
bubble
up
as
well.
There's
api
calls
to
retrieve
this,
but
it's
just
easier.
If
it's
just
here
and
a
heads
up
and
it's
it's
easy
to
see
so
trying
to
apply
some
capabilities
to
keep
those
runners
knit
together
for
you,
but
that's
the
runner
that
will
be
running
the
automation
that
we'll
be
looking
at
in
just
a
minute
for
kicking
off
the
actual
application.
A
A
This
particular
line
here
line
55
is
allowing
me
to
find
the
latest
ms
build
exe
without
knowing
how
many
frame
framework
64
v.4
folders.
I
might
have
on
my
system,
I
don't
even
know
how
many
there
could
be.
They
started
fixing
this
folder
name
even
when
the
version
of.net
inside
of
it
would
change
it.
A
Basically,
just
saying
show
me
all
the
ms
build
exe
versions
sort
them
by
their
full
name,
which
would
then
inherently
the
folder
with
the
version,
and
it
would
be
the
the
one
that
is
the
only
one
that
actually
causes
a
difference.
So
it's
sort
inversion
order,
select
last
and
then
select
object,
expand
full
name
and
I'm
setting
that
into
an
environment
variable.
So
I
end
up
with
the
path
name
to
the
most
recent
ms
build
exe
within
that
folder
hierarchy.
A
A
Since
we're
using
newer
versions
of
visual
studio,
newer
versions
of
windows,
you
know
the
question
would
always
be
well.
How
do
you
know
that
you
didn't
accidentally
get?
You
know
a.net
core
assembly,
so
this
is
what's
going
to
proof.
It
we're
basically
using
a
here
doc
to
write
this
bit
of
code
out,
and
then
we
call
it
with
windows
powershell
right
here
on
this
line
line
77,
and
then
we
simply
emit
that
to
the
screen.
So
this
line
here
that's
commented
was
showing
how
to
upload
nougat
packages.
A
It
ended
up
generating
a
lot
of
activity
because
technically
this
package
doesn't
package
into
nougat,
but
there's
a
whole
bunch
of
nougat
packages
lying
around
that
it
pulled
down
as
dependencies,
and
so
that
was
shoving.
My
nougat
package
registry
pretty
full,
but
if
you
just
want
to
see
hey,
how
would
I
push
nuget
packages
that
I've
created
in
a.net
build
up
into
the
gitlab
nuget
registry,
then
line
80
is
what
you're
looking
for
right
here
very
simple,
build.
A
I
specifically
had
to
make
a
branch
off
of
a
tag
in
this
case,
so
that
I
could
make
sure
that
the
version
of
the
source
code
is
also
going
to
result
in
a
4x
assembly.
So
that's
off
and
running
we'll
check
back
on
it
afterwards.
But
I've
got
one
here
that
already
ran
so
we'll
take
a
look
at
it
and
basically
it
has.
A
A
lot
of
text
generates
a
lot
of
output
to
the
point
where
it's
not
even
all
seeable
in
the
log
here,
unless
I
view
raw,
but
I
just
want
to
show
you
here
at
the
bottom-
you
can
see
that
it's
creating
assembly
directories
and
outputting
them
here.
It's
compiling
this
country,
state,
zip
service,
cs
outputs,
everything
and
then
we
get
to
the
bottom.
We
grab
one
of
those
assemblies
called
purchase,
order
payments
plug-in
and
we
emit
its
values.
A
So
right
here
you
can
see
that
it
is
4.0.30319
is
the
image
runtime
version
and
the
net
framework
version
is
451.
So
that
shows
us
that
it's
building
that
out
and
let's
see,
yep
our
build
already
passed.
So
this
is
a
working
example
that
you'll
be
able
to
access,
as
as
to
take
a
look
at
or
to
make
a
copy
of
to
try
to
do
the
same
thing
yourself.
A
All
right
so
wrapping
up
what
we
covered
today,
what
is
get
lab
runner?
So
we
tried
to
give
you
some
understanding
of
the
flexibility,
the
architecture
kind
of
what's
going
on
under
the
covers
at
least
enough
to
understand
it's
super
flexible
and
should
be
able
to
handle
any
of
your
dotnet
needs
in
terms
of
building
software
and
deploying
it.
We
also
talked
a
little
bit
about
your
options
with
the
sas
runners
on
gitlab.com
for
windows
as
well
as
self-managed.
A
We
dug
into
your.net
stack
journey.
So
where
are
you
with
it
today?
Where
are
you
going
and
what
are
some
of
the
implications
for
building
out
your
runners
on
aws,
we
looked
at
the
ec2
image
builder
for
runner
amis,
so
one
of
the
more
challenging
parts
of
doing
ci
cd
is
prepping
that
baseline
image,
especially
when
you're
dealing
with
shell
runners
and
aren't
working
with
container
runners.
A
A
A
I
mentioned
in
the
session
abstract
that
amazon's
been
doing
this
for
over
a
decade,
bringing
dotnet
workloads
onto
their
platform
and
they
have
a
very
dedicated
and
competent
team.
So
it's
something
to
to
know
that
they've
been
doing
this
for
a
really
long
time
and
have
a
really
top-notch
capability
to
get
your
workloads
onto
their
platform.
A
And
finally,
here
are
my
social
handles
and
blogging
locations.
If
you
need
to
touch
base
on
any
of
this,
as
always,
if
you
want
to
be
using
gitlab
to
be
able
to
deploy
your
network
loads
into
aws,
feel
free
to
reach
out
at
the
url
on
the
screen
to
our
sales
department,
and
we
can
get
you
hooked
up
to
the
right
resources.