►
From YouTube: GitLab SaaS Runners for macOS Demo
Description
In this step-by-step demo, we will explore how to configure your .gitlab-ci.yml file on GitLab SaaS to run jobs on the GitLab SaaS Runners for macOS (limited availability).
A
A
A
A
Let's
break
it
down.
First
we're
establishing
some
defaults,
and
then
once
we
establish
those
defaults,
we're
configuring
this
changes
in
a
pipeline,
then
for
each
stage
we
define
the
job
we
want
to
run
as
you're.
Looking
in
this
file,
you'll
notice
a
few
common
elements,
the
most
important
element.
I
need
to
draw
your
attention
to
in
this
case,
and
that's
specific
to
you
being
able
to
have
your
jobs
run
on
the
github
sensor.
Runners
for
mac
os
is
the
fact
that
we're
using
the
extends
keyword.
A
A
And
then
below
that
we
specify
the
image
type.
This
notation
here
then
reuse
later
on
by
the
by
the
use
of
the
extended
keyword,
tells
each
job
in
this
pipeline
that
hey
this
job
needs
to
be
executed
or
needs
to
be
run
only
run
and
matching
that
tag
the
runners
match.
Those
tags
are
our
gitlab
science
runners
for
mac
os.
So
the
first
thing
to
call
is
that
if
you
will
be
using
all
mac,
os
runs
on
github
sas.
The
thing
that
you
need
in
your
pipeline
definition
file
is
to
have
the
right
tag.
A
Definition
applied
whether
the
global
configuration
level,
as
well
as
the
image
applied
as
well,
that
you
want
to
use.
So
this
first
notation
says:
hey
your
job
is
going
to
run
on
a
mac,
os
runner
and
then
the
second
notation
specifies
the
version
of
our
version
of
the
mac
os
operating
system,
the
version
of
xcode,
basically,
the
image
type
that
we
use
within
the
mac
os
execution
environment.
A
A
Job
right
we're
going
to
in
this
demo
unit
test
job
we're
actually
going
to
be
using
an
app
called
fastlane
to
run
some
automated
tests
of
the
ios
application
and
fastlane
is
basically
on
this
great
open
source
solution
that
is
aimed
at
simplifying
mobile
app
development
and
fastlane
is
pre-installed
on
our
mac
os
via
images,
if
you're
not
familiar
with
fastlane
I'll
just
pop
over
here
and
quickly
show
it
to
you.
The
url
is
fastlane.
A
The
tools
and
they've
got
a
great
bunch
of
documentation
here
in
terms
of
how
you
get
going
using
fast
lane
on
your
local
environment,
as
well
as
within
your
ci
application,
in
this
case
gitlab.
Okay.
So
let's
go
ahead
and
kick
off
a
pipeline.
In
this
case,
we'll
kick
one
off
manually
that
we've
set
up
to
demonstrate
now:
the
use
of
the
mac
os
runners
to
execute
this
unit
test
job.
A
A
Okay,
now
we're
back
and
what
we're
noticing
is
that
the
environment's
been
stood
up.
Some
configuration
stuff
has
happened
in
the
background
and
we're
not
actually
executing
our
test
job
using
fast
lane
on
the
mac
os
runners.
So
you
can
see
a
bunch
of
stuff
that's
happening
here
in
the
background
right
now.
The
job
is
executing.
It's
kicking
things
off,
be
right
back
in
a
second
and
we'll
finish:
wrapping
up
the
demonstration,
video,
okay,
we're
back.
So
let's
take
a
look
at
what
happened
here.
So
the
job
is
completed.
A
A
All
of
this
one
other
thing
to
call
out
here
as
well:
it's
that
it's
building
virtual
machine
creation,
stuff
right
here,
where
it's
creating
a
virtual
machine
for
the
job
just
want
to
call
that
out,
because
each
job
that
runs
on
the
gitlab
sas
runs
for
mac
os
will
run
in
a
clean
new
virtual
machine.
That's
automatically
deleted
on
job
completion
so
from
a
security
perspective
and
job
activation
perspective.
A
That's
great
news
just
wanted
to
have
you
be
aware
of
that,
because
the
more
complex
jobs
you
have
to
be
aware
that
we'll
be
creating
a
virtual
machine
each
time
and
if
you're
installing
app
dependencies,
for
example
like
in
this
job,
then
that
has
to
be
installed
on
the
vm
each
time.
But
what
it
gives
you
in
terms
of
security.
Isolation
is
a
much
better
experience,
so
you
can
be
assured
from
a
compliance
perspective,
that
your
job
environment
is
completely
isolated
just
to
a
specific
job
in
your
pipeline,
and
so
they
have.
A
So,
let's
recap
what
we've
done
now
that
that
overview
is
complete.
What
we've
done
is
we've
managed
started
the
unit
test
job
right,
reviewing
the
review
the
to
get
that
yammer
file,
that's
used
for
the
shop,
I'm
gonna
go
back
to
that,
so
we
can
have
one
more
look
at
it
all
right.
We're
calling
the
mac
os
runner
type,
we
added
the
image
type
we're
going
to
use
again
in
this
particular
example.
We
run
the
unit
test
job
manually
and
the
only
thing
that
we
had
to
do
here.
A
We
use
the
extend
skill
to
simply
specify
that
hey
that
unit
says
john
will
in
fact
be
running
on
this
new
runner.
With
the
share
dash
macos,
that's
ama64
tag.
We
set
the
job
through
on
manually.
We
set
it
up.
If
I
upload
path,
artifact
directory
path,
I
should
say,
and
then
the
only
command
that
we
had
to
call
to
execute
that
automated
testing
suite
that
you
saw
in
the
logs
was
this
line
right
here.
Bundle
exec
fast
lane
test.
So
in
this
very
simple
job
definition.