►
From YouTube: Slicing and Dicing with PowerShell on GitLab CI
Description
All the ways to use PowerShell on GitLab CI - including Windows PowerShell and PowerShell Core 7 on Linux and Windows.
Companion working example project: PowerShell Pipelines on GitLab CI - https://gitlab.com/guided-explorations/gitlab-ci-yml-powershell-tips-tricks-and-hacks/powershell-pipelines-on-gitlab-ci
If you find this helpful, please give the video a thumbs up and "star" the project :)
Join Darwin (DarwinJS) to see the many ways you can run PowerShell on Windows and Linux in GitLab CI!
Playlists:
- 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 Windows (https://youtube.com/playlist?list=PL05JrBw4t0KqOJeQ1y5wSBxArdTEtmnxb)
- GitLab and PowerShell (https://youtube.com/playlist?list=PL05JrBw4t0KrklJ2kDTl2qXNaGSlzKeoW)
- DarwinTheorizes (https://youtube.com/playlist?list=PL05JrBw4t0KoH74CcAtP0Ze7JXjX7zT6g)
A
Hey
everyone,
its
Darwin
here,
I'm
gonna,
talk
about
slicing
and
dicing
with
PowerShell
and
get
labs,
see
I
want
to
send
a
shout-out
and
a
thank
you
to
at
tanka
underbar
mm
on
twitter,
who
called
out
to
get
lab
and
said:
hey
I'm,
having
a
hard
time
finding
some
powershell
examples
for
get
lab
c.
I
could
you,
could
you
spare
a
few?
So
this
presentation
has
come
about
because
of
that.
A
So
one
of
the
first
ways
you
can
get
your
access
to
power,
shell
and
get
lab
CI
is
through
get
labs.
Shared
runners
and
everything
that
we'll
be
talking
about
here
is
get
lab.
Comm
shared
runners
now,
as
we
go
through
you'll,
see,
there's
certain
defaults
that
have
been
selected
and
you
can
do
different
things
if
you
go
ahead
and
run
runners
as
a
private
self
hosted
affair.
If
you
are
on
get
lab
comm,
you
can
also
still
do
private
self
hosted
runners,
so
the
first
one
we'll
cover
is
a
default
Windows.
Shell
runner.
A
We
recently
added
Windows
shell
runners
as
an
option
and
get
lap.
You
have
to
tag
your
jobs
appropriately
and
then
they'll
be
directed
towards
those
shared
runners.
So
when
you
get
on
those
or
shared
runners,
you
have
elevated
admin
permissions,
and
this
would
be
concerning,
except
that
every
time
you
ask
for
a
Windows
machine,
a
brand
new
VM
is
spun
up.
A
You
get
access
to
it
and
then
it's
destroyed
and
of
course,
this
is
really
important
in
CI,
because
you
may
need
to
install
a
lot
of
tools
and
utilities
and
inability
to
have
admin
rights
would
prevent
you
from
doing
that.
So
these
are
ephemeral
machines,
so
you're
able
to
have
admin
rights
and
then
Windows
PowerShell
is
installed
on
there
by
default.
Now,
when
Windows,
shell,
runner
or
any
type
of
Windows
runner
is
your
default,
runner
PowerShell
is
also
your
default
shell.
A
So
you
don't
have
to
worry
about
starting
up
in
CMD
and
then
having
to
shell
over
to
PowerShell.
If
you
want
to
you
can
install
PowerShell,
7
or
PowerShell
core,
and
then
you
can
call
it
from
the
default
PowerShell.
So
that's
something
that's
still
possible
if
you
need
to
add
that
to
the
mix,
if
you
want
to
see
PowerShell
7
already
pre-installed
in
these
machines
by
all
means,
go
to
get
lab
and
put
in
a
new
issue
and
say
I'm.
A
Now,
when
you
call
another
shell,
such
as
calling
powershell
core
from
powershell
or
if
you
call
any
other
third-party
shell,
the
infusion
of
those
variables
as
regular
variables
does
not
happen.
So,
consequently,
only
environment
variables
are
posed
as
far
as
all
I
get
lab,
CI
information.
So
it
might
be
a
good
practice
to
get
in
the
habit
of
always
using
environment
variables,
and
then
you
won't
have
to
worry
about
whether
or
not
the
shell
you're
using
is
default
or
not.
A
The
next
runner
we'll
talk
about
is
the
docker
executor,
which
is
the
default
runner
on
git
lab,
and
one
of
the
reasons
why
you
might
consider
this
for
PowerShell
is
in
the
case
of
all
clouds,
it's
cheaper
to
run
under
Linux
than
it
is
under
windows,
and
so
because
of
this
you're
able
to
take
advantage
of
that
cheaper
compute
for
your
PowerShell.
Now,
obviously,
you
have
to
have
PowerShell
that
doesn't
have
any
dependencies
on
Windows
and
that
would
include
file
system
references.
A
So
as
long
as
your
PowerShell
is
cleaned
up
a
little
bit
and
it's
just
you're,
basically
using
the
logic
of
PowerShell
to
say,
run
AWS
cly
or
something
like
that.
Then
it's
entirely
doable
that
you
could
potentially
pour
it
over
to
Linux.
Now
this
first
example,
all
the
docker
demons
on
gitlab
have
docker
privileged
mode,
and
this
is
so.
You
can
build
containers
when
you're
doing
docker
builds
darker
and
darker
builds
and
then,
in
this
case
we're
going
to
show
you
taking
Microsoft's
dotnet
core
3.1
container,
which
is
Linux
and
has
PowerShell
7
pre-installed.
A
So
in
that
case
you
just
grab
that
container
you're
good
to
go
with
PowerShell.
It
doesn't
become
your
default
shell
because
in
the
docker
executor
for
Linux,
we
are
always
assuming
that
Bash
is
your
default
shell
and
because
is
Linux
container.
You
do
end
up
in
bash
initially,
but
you
can
shell
over
and
use
PowerShell,
then
the
final
approach
it
will
take
a
look
at
is
using
any
Linux
and
run
time
installing
PowerShell.
A
A
In
reality,
you
aren't
going
to
be
very
likely
to
have
to
combine
all
of
these
things
into
one
pipeline,
but
you
should
be
aware
of
this,
especially
if
you're
coming
from
a
Windows
background,
you
might
be
able
to
use
some
really
cool
tools
and
utilities
that
are
on
linux.
Only.
We
have
some
examples
in
a
subsection
of
gitlab
called
guided
explorations
using
file
templating.
So
you
take
a
bunch
of
variables.
You
grab
a
file
and
you
substitute
those
variables
into
the
file.
A
So,
let's
dive
into
the
code
next
we're
in
a
section
of
gitlab
comm
called
guided
dash
explorations,
and
this
section
actually
is
comprised
of
a
lot
of
working
examples
of
how
get
lab,
and
these
examples
are
provided
in
a
working
format.
Precisely
so
that
the
eases
your
learning,
you
can
see
the
code
see
how
it
works,
see
the
CI
logs
and
you
can
also
grab
a
copy
and
put
it
in
your
own
group
or
in
your
own
MIT
own
instance,
and
use
it
a
starting
point
for
either
your
learning
or
production
projects.
A
So
we're
gonna
dig
down
here
on
the
powershell
section
and
we
have
powershell
pipelines
on
gitlab
CI
now
within
here.
Each
one
of
these
guided
explorations
has
a
readme
document.
That
tells
you
a
lot
of
details
about
the
whole
guided
exploration.
It
tells
you
who
owns
it.
It
tells
you
what
kind
of
features
of
git,
lab
and
or
general
development
patterns
that
it
shows
and
demonstrates.
It
also
might
give
notes
on
how
to
use
this
specific
one
and
if
also,
if
there's
additional
setup
steps,
like
maybe
some
CI
CT
variables.
A
A
So
we
can
see
here
that
we
have
some
calls,
but
these
happen
to
be
Windows
specific,
so
they're
dotnet
calls,
but
they
are
specific
to
Windows.
So
we're
using
this
test
right
here
in
order
to
ensure
that
we
are
on
Windows,
and
so
the
first
part
of
the
test
says
is
a
variable.
Is
windows
missing
because
of
Windows
PowerShell?
The
variable
is
windows
is
not
there
and
then
the
next
one
says
is:
is
windows,
true,
so
on
PowerShell
core
running
on
Windows
is
windows
will
be
true.
It's
important
to
understand
about
PowerShell.
A
If
you
haven't
used
it
a
lot
that
when
it's
doing
tests
like
this
as
soon
as
it
hits
a
failed
test,
it
stops
their
tests.
So
a
lot
of
languages
continue
on
through
the
rest
of
the
tests,
the
things
that
they're
checking
have
to
exist.
But
in
this
case,
if
the
variable
doesn't
exist,
we
fail
the
test
and
we
don't
go
on
further
to
check
the
value
of
them
of
the
actual
variable.
So
this
kind
of
test
works
on
PowerShell.
A
But
when
Windows
PowerShell
is
not
the
default
version
and
you're
using
PowerShell
core,
then
it
only
receives
them
as
environment
variables.
Then
we
collect
this
artifact
that
we
created
it's
just
simply.
A
text
file
with
a
bit
text
in
it
and
we're
going
to
pass
that
artifact
down
through
the
stages
as
we
go,
so
you
can
see
that
not
only
can
we
intermix
the
platforms
and
the
versions
of
PowerShell
in
the
pipeline,
we
can
also
pass
artifacts
between
them
and,
of
course,
the
ability
to
pass
artifacts
is
not
required.
A
You're,
not
necessarily
going
to
be
using
different
versions
of
PowerShell
on
your
pipeline,
but
I
wanted
to
make
sure
that
you
understood
whether
it's
Windows
or
Linux
or
PowerShell,
or
something
else
you
could
mix
and
match
your
stages.
We
have
a
few
plugins
that
are
built
on
Linux
containers
and
you
could
technically
use
them
in
a
Windows
environment.
So
one
of
them
just
templates
files
takes
environment
variables
out
of
your
job
and
sticks
them
into
a
templated
file
format
so
that
those
variables
translate
into
say,
Java
properties
file.
A
Well,
you
could
even,
if
you're,
using
windows
as
your
primary
build
environment,
you
could
technically
use
that
Linux
phase
to
build
out
any
file
templating
you
needed,
so
we're
going
to
take
a
look
at
how
this
first
job
processed.
So
this
is
our
pipeline
and
I'm
gonna
go
back
up
to
the
top
of
the
log,
and
we
can
see
that
it
tells
us
that
we
are
running
admin
and
it
admins.
Okay,
because
we
toss
this
container
or
toss
this
virtual
machine.
A
Every
time
we
do
a
PS
version
table,
so
you
can
see
that
we're
on
PowerShell
5-1
and
then
we
put
print
out
all
of
our
PowerShell
variables
and
later
all
of
our
environment
variables,
so
you're
able
to
see
the
differences
and
see
when
they're
the
same
and
then
at
the
very
end.
We
upload
that
artifact
file
that
we
had
created
so
that
we
get
it
collected
as
an
artifact.
So
that's
the
first
job,
so
you
can
see
that
on
a
shell
runner
running
Windows
PowerShell
on
the
default,
shared
runners
works
just
fine.
A
If
you
were
to
setup
gitlab
as
an
a
self
hosted
private
runner,
then
you
would
be
able
to
do
the
same
thing
with
the
shell
runner.
It's
also
important
to
realize
that
on
even
if
you're,
using
git
lab
comm
SAS
to
store
your
source
code
and
do
all
of
your
activities
for
development,
you
can
have
your
own
self
hosted
runners
in
your
own
environment.
A
So
sometimes
folks
don't
understand
that
even
you're,
even
using
git
lab
hosted,
you
can
do
self
hosting
on
the
runners
to
do
things
like
put
them
in
secure
environments
and
other
things
like
that.
So
all
the
stuff
we're
covering
here
while
I'm
covering
what
goes
on
in
get
lob
comm.
You
could
actually
build
your
own
Runner
and
change
some
of
these
things,
such
as
the
CI
user,
not
having
admin
permissions
or
what
version
of
PowerShell
you
is
on
the
system
already
instead
of
having
to
dynamically
install
it.
A
So
let's
take
a
look
at
our
next
job
here.
This
one
does
the
same
exact
thing,
except
instead
of
calling
inline
script
code,
it
calls
a
script
of
the
repository,
so
some
of
you
will
want
to
build
your
build
scripts
right
into
these.
The
yamo
others
will
want
to
have
them
standalone
in
the
repository,
and
this
is
just
demonstrating
to
you
how
that
would
occur
and
we're
gonna
pick
up
repository
based
script
here
you
can
see
here
it's
telling
us.
A
So
we're
now
going
to
shift
to
a
llamó
embedded
script
on
a
linux
host
with
PowerShell
pre-installed,
and
so
this
is
Microsoft's
actual
dotnet
core
SDK
and
if
you
use
3.1
or
later
of
the
SDK,
it
has
PowerShell
pre-installed
I'll
be
careful
that
the
2x
ones
do
not
have
PowerShell
pre-installed.
So
this
sample
won't
work
with
the
22.2
point
x
containers.
A
So
we
have
the
same
basic
layout.
What
we
do,
though,
is
show
you
that
you
have
to
call
powershell
core,
because
it's
not
the
default
shell,
even
on
this
particular
container,
and
then
we
call
our
embedded
script.
So
you
can
see
that
we
can
how
how
you
would
call
code
that
is
in-line
as
well
as
embedded
when
you're
using
a
non-default
powershell
core,
and
we
also
then
output
the
results
of
the
artifact
file.
So
you
can
see
that
that
is
indeed
moving
between
stages
and
I.
A
Think
I
didn't
show
you
that
result
earlier,
but
here
in
this
one
it
says
this
artifact
was
built
on
PowerShell
for
Windows
in
a
job
named
and
it
gives
the
job
name.
So
if
we
go
up
to
the
top
here,
we
will
see
that
the
if
statement
is
now
saying,
hey
you're,
not
running
on
Windows,
so
I'm
not
going
to
try
to
see
if
you
have
admin
and
then
we
can
also
see
that
in
the
regular
shell
variables
we
do
not
have
our
gitlab
CI
variables.
A
A
Finally,
this
final
stage,
we
are
taking
a
different
Linux,
so
the
Linux
of
our
choice-
I
picked
Amazon
Linux,
simply
because
I
built
this
installer
for
PowerShell
core
to
go
on
Amazon
Linux,
so
want
to
play
with
it,
just
as
a
kind
of
a
out-of-the-box
example,
and
so
you
can
see
here
we
are
simply
bringing
down
the
install
script
from
the
PowerShell
repository
and
then
running
it,
and
once
that's
done,
we
do
the
same
as
we
did
in
the
job.
Above.
Let's
take
a
look
at
what
that
looks
like.
A
So
everything's
basically
the
same
except
now
we
see
this
PowerShell
core
install
happen,
so
you
can
see
that
the
PowerShell
core
install
is
queued
up,
completed
using
yum
and
then
once
PowerShell
is
installed.
We
can
call
it
immediately.
You
can
see
that
we
only
have
our
CI
variable,
so
I
should
have
just
shown
this
real
quick.
A
You
can
see
that
we
run
PowerShell
version
seven
and
what
version
of.net
it
is
backing
it
and
what
OS
were
on
and
then,
as
we
proceed
down
here,
you
can
see
all
the
variables
and
then
finally,
you
can
see
that
artifact
output,
so
that
is
an
example
of
a
lot
of
different
ways
to
run
PowerShell
on
gitlab
CI
and
even
some
magic
of
passing
information
and
artifacts
in
between.
So
let's
do
a
quick,
wrap-up
and
then
we'll
be
done
so
I
hope
walking
through
that
guided
exploration.
A
A
Actually,
URL
for
the
guided
exploration
for
PowerShell
is
right
there
on
the
screen
in
case
you
need
to
reference
that
and
I
really
love
my
job
at
git
lab
as
a
Solutions
Architect
I
get
to
dig
in
with
customers
into
some
of
the
challenges
are
having
and
help
them
overcome
those
challenges
as
they're
looking
at
how
to
use
our
DevOps
tooling
to
accelerate
their
efforts.
So,
if
you'd
like
to
get
in
contact
with
git
lab
sales,
you
might
also
be
able
to
get
a
Solutions
Architect
to
look
at
your
challenges.
A
The
entry
point
to
all
of
that
is
our
sales
URL
there
on
the
screen,
if
you're
having
trouble
with
PowerShell
working
under
get
lab,
CI
feel
free.
To
give
me
a
shout
out
on
social
I'll,
give
you
a
hand
with
whatever
I
can
in
order
to
make
that
journey
easier
for
you
thanks
a
lot
for
your
time
and
attention.
I
hope
this
content
has
been
helpful
to
you.