►
From YouTube: Bonus Content: ScriptRunner Making PowerShell a Real Solution in 5 Steps with Heiko Brenn
Description
We all love PowerShell because it’s an outstanding framework for automating recurring tasks. But there some aspects of PowerShell automation that are a challenge to work around.
For example, wouldn’t it be great if you could take your code and delegate the script execution to help desk teams and end users in a secure, straightforward way? That’s where ScriptRunner can step in and make your life easier!
Join our speaker, Heiko Brenn, for a look at the how ScriptRunner can simplify the way you develop, manage and delegate PowerShell scripts for Active Directory, Exchange, Office 365, Azure and others.
Heiko is a product expert at ScriptRunner, longtime PowerShell enthusiast who has over 25 years’ experience as a sysadmin, consultant and product manager. You can also catch Heiko playing drums at the ScriptRunner offices from time to time!
Join Heiko for a look at how ScriptRunner can help you simplify the management of 5 key areas that often a challenge for many admins:
- Centralizing your PowerShell scripts
- Manage credentials and permissions management, including password server support
- Automatically create web GUI’s and portal widgets
- Monitor PowerShell activities with a central dashboard
- Delegating script execution to helpdesk teams and end users
A
Hey
everybody
thanks
for
joining
us
again.
This
is
mike
and
phil
from
the
research
triangle,
powershell
user
group,
and
we
got
a
little
bonus
content
here
from
you
with
haiku
from
script
runner.
We
finished
up
our
meeting
and
we
had
a
pretty
active
discussion
going
on
and
haiku
offered
to
show
us
some
more
information
about
the
product.
This
is
going
to
be
specifically
rated
to
queries.
So
if
you
watch
the
first
video
and
you
want
to
see
more,
join
us,
hey
haiku,
thank
you
for
joining
us
again.
B
These
are
all
things
that
are
coming
that
are
implemented
based
on
the
queries
and
queries
can
be,
can
be,
can
be
come
in
different
types,
so
we
have
active
directory
queries.
We
have
azure
queries,
which
also
includes
using
ms
craft,
for
example.
You
can
have
scripted
queries,
you
can
have
static
queries
and
you
can
have
a
list
of
entries
which
is
basically
kind
of
a
csv
file.
B
Now,
in
the
the
simplest
form,
the
thing
that
that
we
just
saw
where
we
said:
okay,
what
kind
of
azure
locations
somebody
can
select
when
they
spin
up
a
new
vm,
is
simply
a
a
list
where,
on
the
left
side,
we
see
we,
we
see
what
is
actually
visible
to
the
user
and
on
the
right
side.
That's
the
that's
a
technical
information
and
this
concept
goes
throughout
all
the
queries
on
the
left
side.
B
This
is
what
we
saw
the
specification
of
the
of
dvms
and
on
the
right
side.
That's
the
technical
information
in
this
case
very
simple,
because
it's
a
static
information.
If
we
look
at
things
like
active
directory,
it
could
be
okay.
I
want
to
have
a
list
of
all
my
mailboxes
or
of
all
my
ou's,
for
example,
so
I
can
decide
what
kind
of
object
this
I
want
to
have
in
my
queries
in
this
case.
It's
also
okay,
where
I,
where
do
I
start
to
search
for?
B
What's
what's
the
search
base,
what
should
be
visible
again?
The
display
value
common
name
or
it
could
be
some
some.
Whatever
information
helps
the
user
to
select
the
right
things
and
then
the
value
which
is
the
information
that
really
is
being
used
when
we
technically
run
the
scripts
with
the
parameters,
and
then
you
can
have
the
same
thing
for
for
for
azure
active
directory,
and
here
I
have
an
example.
B
Which,
in
this
case,
I
have
a
machine
actually
running
in
azure,
as
you
can
see
right
here,
and
here
I
have
a
query
that
uses
azure,
active
directory
information
and
it's
not
just
a
single
parameter.
It's
one
of
what
I
want
to
have
is
a
complete
json
object,
so
I
can
really
take
all
the
information
from
this
json
object
to
further
use
it
in
my
scripts,
and
I
can
test
this
query
right
here
and
so.
B
Like
this
one
here,
this
one
here
is
a
directly
integrated
into
a
script
runner.
Of
course,
you
can
always
have
a
script.
That
does
your
azure
query
as
well.
That's
actually
what
what
was
the
option
before
that
version
that
came
two
months
ago
and
now
to
more
simplify
the
azure
scenario.
We
implemented
a
a
specific
azure
query
type,
so
you
don't
have
to
write
it
in
your
scripts,
but
you
can
still
do
it
and
implement
it
as
a
as
a
scripted
query.
So
you.
C
You've
established
some
kind
of
you
know
integrated
queries
so
that
you
can
directly
interface
with
that
and
so
you've
kind
of
massaged
that
so
it's
more
beautified
kind
of
term.
But
the
idea
is
that
previously
or
if
it
doesn't,
you
could
certainly
write
a
powershell
script
and
actually
have
that
query
do
work
for
you
and
there
is
some
structure
that
kind
of
says:
hey:
here's
available
parameters:
here's
not
available
parameters;
here's
stuff,
I'm
going
to
do
the
behind
the
scenes
here,
someone
showed
me
a
user
or
the
admin.
B
Yes,
absolutely
so
so,
let's
say
we
provide
this
built-in
functionality
and
I
will
show
you
a
little
bit
of
the
details.
If
that's
not
enough
for
you,
because
you
want
to
be
more
specific,
then
you
always
can
switch
to
having
your
own
scripted
query
where
you
can
exactly
control
what
kind
of
objects
you
want
to
look
for
what
kind
of
parameters
you
need.
So
it
fits
to
your
use
case.
So
in
this
case
here
I
have
a
couple
of
of
users
here
and
it
come
back
it's
com.
B
It
comes
back
here
with
the
with
the
json
data
that
that
the
azure
active
directory
is
allow
me
to
to
get
back
in
this
case
and
if
I'm
going
to
the
edit
mode
you
can
see
here
again
we
looked
for
the
for
the
users
but,
as
I
said,
it
could
be
a
graph
query.
It
could
be
resource,
grace
grave,
grave
graph,
query
and
and
again
it's
the
same
concept
of
okay.
B
What
is
the
information
that
you
want
to
display
and
what
is
the
actual
technical
information
that
we
want
to
use
when
we
execute
the
scripts?
So,
coming
back
to
the
query,
the
the
scripted
query
that
we
just
talked
about,
of
course,
that's
then
the
the
other
way
of
using
the
the
queries
here
you
can
have
any
kind
of
script,
so
in
this
case
it
is
actually
going
to
the
azure
active
directory
to
come
back
with
the
list
of
my
office
65
users.
B
Quickly,
I
think
this
is
the
one
what
what
you
can,
what
you
see
here
is
and
that
again
comes
back
to
this
concept
of
okay.
We
have
display
names
and
we
have
technical.
Do
we
have
the
parameter
values?
Is
we
have
this
srix
environment
variable
result
list
and
result
list2
result
list,
that's
the
value,
the
technical
information
that
we
use
and
again
this
is
the
one.
That's
that's
the
this
in
this
case
the
display
name
that
we
actually
show
to
the
user
to
so
that
they
can
select
the
the
right
data.
B
B
C
B
Well
it
it
it
is
well
it's
actually,
it's
actually
one
list
with
two
columns
right.
So
so
that's
that's
actually
what
it
is
right
here
and
so
so
because
it's
all,
of
course,
it's
always
related
right.
So
the
the
the
information
that
you
want
to
show
to
the
user
and
the
one
that
we
are
using
when
we're
actually
then
later
on,
actually
execute
the
scripts,
and
this
gives
you
the
control
about
what
is
the
right
information,
the
right
value
that
we
should
use
when
when
the
script
gets
executed,
the.
C
B
In
the
query
saying:
okay,
I
want
to
enable
the
the
cascading
the
cascading
option
right
here
and
what
it
does
in
the
interface
is
that
then
you
see
the
search
base
from
depending
on
the
on
the
on
the
previous
selection
of
a
of
a
query,
so
that
that's
what
it
actually
does
right
here,
other
than
that,
it's
really
it's!
It's
really
just
a
query,
but
it
enables
you
to
really
have
multiple
queries
working
so
to
speak.
On
top
of
each
other.
C
B
Yeah,
so
you
could,
you
could
kind
of,
maybe
you
could
kind
of
jump
back
to
a
maybe
just
the
two
or
three
levels
up
depending
on
what
what
again,
what
search
base
you're,
selecting
from
the
from
the
previous
from
the
previous
queries
that
are
part
of
this
action.
So
but
typically
it's
really
kind
of
this.
This
step-by-step
approach,
where
coming
from
you
know
like
a
funnel
coming,
okay
from
the
or
to
selecting
all
the
necessary
properties,
so
that,
once
everything
is
put
together
now,
okay,
we
can
run
the
script.
C
B
Absolutely,
and-
and
so
it
could
another
example
just
to
go
back
to
this-
to
this,
to
this
static
list
as
well
could
be
okay,
if
I'm
having
this
out
of
office
scenario,
which
kind
of
is
really
it
sounds
simple,
but
it's
really
interesting
for
many
organizations
where
they
say.
Okay,
I
want
to
enable
somebody
in
hr
to
if
somebody
calls
in
sick
to
enable
the
out
of
office
notification
without
giving
you
know
having
all
this
hassle
of
who
has
access
to
the
mailbox
and
stuff
like
that.
B
You
can
also,
of
course,
have
a
list
of
the
templates
of
notifications,
which
could,
of
course,
include
html
and
which
also
can
include
variables
like
the
start
date
and
end
date,
for
example.
So
you
could
you
could
work
with
this
information
to
have
to
make
sure
that
you're
not
just
changing
the
the
date
of
an
out
of
office
notification,
but
really
also
the
content.
So
it's
not
coming
out
of
sync,
for
example,
and
so,
and
to
order
to
use
the
the
queries
in
in
in
the
actions
on
each
for
each
parameter.
B
You
can
select
where
you
want
to-
let's-
let's
maybe
go
for
this
example
here,
like
this
one
grading,
creating
a
team.
Why
not
where
you
can
say
okay,
somebody
should
be
able
to
select
the
users
which
which
comes
back
to
this-
to
this
listed
scripted,
query
right
here,
where
you
say:
okay,
instead
of
somebody
which
would
be
crazy
anyway,
to
type
in
the
name
of
the
of
the
users.
B
This
is
a
scripted
query
that
provides
me
with
the
list
of
my
users,
in
this
case
all
my
users,
but
again
coming
back
to
this
scenario
with
delegation
where
maybe
this
list
might
look
totally
different.
If,
if,
if
it's
a
user
help
desk
in
europe
or
in
north
america
and
again,
it
would
be
the
same
script
in
the
background,
but
just
the
query
that
you
that
you
select
in
this
action
for
the
north
america
scenario
and
for
the
european
scenario
would
be
just
different.
B
C
So
I
wanted
to
point
out
here
like
what
you're
saying
is
that
so
effectively
you'd
create
two
queries
in
this
fashion
and
if
you
had
like
north
america,
which
they
want,
you
know
last
comma,
first
name
in
this
fashion,
but
the
you
know,
sam
account
name
in
this
fashion,
should
be
the
same.
So
the
the
result,
one
would
be.
I
guess
the
same
account
name
and
then
the
result
two
would
be
the
the
name
and
then
in
europe
it's
just
a
different
thing
or
same
thing.
C
B
So
that's
exactly
what
would
happen
so
I
would
I
would
I
I
copied
the
action
and
then
in
the
in
this,
in
this
new
created
action.
I
would
exactly
do
what
you
just
mentioned.
I
would
say:
okay,
I'm
just
switching
from
from
the
from
this
query
to
another,
one
that
that
helps
me.
That
comes
back
with
the
right
information
and
then
no
nothing
has
to
be
changed
in
the
script.
B
This
should
be
for,
oh,
maybe
it
should
be
for
b
b
for
emir,
and
then
that
would
be
the
group
of
people
who
who
is
able
to
use
that
action,
and
so
that
gives
you
the
the
complete
flexibility
here
and
so
that
that's
really
what
what
the
queries
are
are
are
all
about.
It's
really
simplifying
the
the
usage
for
the
user
and
it's
to
keep
you
in
control
about
what
is
actually
selectable
for
these
users
and.
C
It
becomes
very
valuable.
The
idea
that
you
know
you
can
customize
what
the
user
sees
along
with
customizing
the
forms
in
which
they
see
those
forms,
and
so
that
becomes
very
valuable,
especially
the
dynamic
point
of
view,
and
so
I
certainly
appreciate
this
almost
deep
dive
and
kind
of
talking
through
it,
and
even
you
know
I
was.
I
was
kind
of
asking
leading
questions
in
the
regard,
because
I
was
watching
looking
at
some
of
the
and
the
github
thing
and
looking
at
the
the
structure
and
there's
queries
there
and
looking
going.
C
What
is
this
doing
and
it's
just
returning
those
two
variables
the
result
set
one
and
results
at
two
and
going
yes
now
I
understand
it.
So
it's
fairly
straightforward
to
follow
what
you're
trying
to
accomplish.
You
can
use
other
stuff
as
examples,
but
this
was
very
valuable
to
me
and
I
appreciate
that
the
kind
of
deep
dive
here.
B
But
yeah
thanks
yeah,
so
just
just
because
I
also
missed
that,
because
you
had
the
beginning
the
answer,
the
question
at
the
beginning
about
powershell
seven,
so
you
could
just
switch
a
in
action
from
using
windows
powershell
to
powershell
seven,
given
that
you
have
installed
the
right
modules
also
for
windows,
powershell,
seven
and
stuff,
like
that
and
the
scripts
are
kind
of
compatible
with
powershell
seven.
So
this
is
something
that
you
can
do
here.
B
Another
thing
that
I
just
quickly
want
to
also
show
you
is
the
the
functionality
here
of
library
scripts,
which
means
if
you
have
centralized
functions
and
you
could
you
would
say:
okay
whenever
I
want
to
do
something
with
an
action.
I
I
need
some
some
functions.
You
could
just
configure.
You
can
activate
this
functionality
here,
saying:
okay
prior
to
starting
the
main
script.
B
Here
the
same
could
be
done
also
with
modules,
but
we
see
that
more
happening
actually
with
this
with
scripts.
I
think
the
reason
is
because
everything
happens
behind
the
scenes.
It
doesn't
it.
It's
not
really
a
security
issue
about
having
these
functions
being
available
in
the
script,
because
you
don't
give
it
to
your
users.
That's,
I
think,
one
of
the
motivations
to
put
things
into
a
module,
so
it's
kind
of
hidden
so
to
speak,
but
you
could
still
do
it
as
well.
A
All
right
so
there
we
have
it.
So
we
have
some
bonus
information,
a
deep
dive
into
queries
and
a
little
peek
behind
the
scenes
and
how
script
one
script
runner
works
under
the
covers
again,
thank
you
for
joining
us
tonight.
Thank
you
to
haiku
for
giving
us
this
really
great
in-depth
view
of
how
script
run
works
phil
any
closing
thoughts.
C
No,
I
think
it's
great
and
one
of
the
examples,
especially
with
some
of
these
queries,
is
that
you
know
I
think
in
the
previous
talk
we
talked
about
using
the
github
channel
2d,
you
can
see
their
code
and
so
the
code
is
available
there
and
you
can
kind
of
use
that
as
a
framework
to
build
your
own
libraries
and
functions
and
queries,
and
so
it
is
certainly
there
available
to
you.
So
it's
good
to
go.