►
Description
In this video, @Steviecoaster from the Research Triangle PowerShell User Group (RTPSUG) shows you how to use Swagger to explore and test APIs. You will learn how to use different HTTP methods, handle errors, and create custom PowerShell commandlets based on API functionality. You will also see a coding example of using Invoke-RestMethod to interact with a NuGet API and manipulate the output data.
To learn more about RTPSUG, visit their website: https://rtpsug.com/
To join their Meetup group, go to: https://www.meetup.com/Research-Triangle-PowerShell-Users-Group/
To follow @Steviecoaster on Twitter, check out: https://twitter.com/steviecoaster
To see his GitHub profile, click here: https://github.com/steviecoaster
A
Hey
everyone
and
welcome
to
another
meeting
of
the
Research
Triangle
Powershell
User
Group.
My
name
is
Mike
kanakis,
my
co-host
this
evening,
Mr
Phil
Bossman,
hello
Phil.
How
are
you
good
evening
come
doing?
Well,
I'm!
Absolutely
excited!
Yes,
hey
Phil!
Well,
tonight
we're
going
to
be
talking
about
what
what's
our
topic
tonight,
we'll.
B
Be
talking
about
apis,
you
know
application
programming
interfaces
and
we
have
Stevie
coaster,
also
known
as
Stephen
valdi.
Here
is
he's
going
to
give
us
a
quick
little
intro
on
working
with
apis
and
he's
gonna.
You
know
share
some
knowledge
how
you
doing
Stevie,
pretty
good
you're
good
yeah,
glad
to
be
back
yeah.
A
Stevie,
thank
you
for
joining
us
tonight.
So,
ladies
and
gentlemen,
just
to
give
you
a
little
intro
here,
Stevie
is
going
to
be
doing
an
intro
on
apis
tonight
and
in
about
45
to
60
days.
We're
gonna
have
him
back
and
he's
going
to
do
a
deeper
dive
on
apis.
So
this
is
like
a
part
one
and
part
two,
and
so,
if
you're
watching
this
at
home,
make
sure
you
check
out
the
part
two
version
of
this.
If
you
are
watching
it
at
home,
you
can
always
join
us
in
person.
A
C
Alrighty
guys
well
again,
thanks
for
having
me
back.
It's
always
a
good
time
to
present
to
this
group
very
thankful
that
yeah
you're
going
to
let
me
set
up
some
disappointment
for
the
next
60
minutes
or
so
no,
as
I
said
kind
of
coming
into
this
last
minute.
So
I
kind
of
cobbled
this
together,
so
I'm
flying
by
the
seat
of
my
pants
a
little
bit
but
yeah,
who
am
I
as
I've
said:
I'm
Steve,
baldinger,
AKA,
Stevie
coaster
across
all
the
socials
Twitter
Discord
GitHub,
et
cetera
Etc.
C
You
can
find
me
there
support
manager
at
chocolate.
Software
is
what
I
do
in
my
day
job
so
I
do
a
lot
of
package
management,
Powershell,
some
API
stuff,
a
lot
of
automation,
related
activities
go
on
in
my
day-to-day.
So
it's
always
always
a
good
time,
always
excited
to
wake
up
and
go
to
work
and
really
looking
forward
to
diving
into
this
with
you
guys
so
without
further
Ado
I
hate
slides.
So
we're
done
with
them,
as
mentioned
apis.
What
are
they?
They
are
application
programming
interfaces.
C
What
does
that
actually
mean
it's
a
wave
for
one
system
to
talk
to
another
say:
you've
got
one
system,
that's
written
in
c-sharp.
That
has
the
need
to
receive
data
from
another
system
that
might
be
in
Python.
Well,
those
two
systems
are
written
in
two
different
languages,
right,
C,
sharp
Python
and
then
there's
this
thing
that
sits
up
here,
that
they
both
need
to
talk
to.
What
is
that
universal
language
that
both
c-sharp
and
python
can
speak?
That's
an
API,
that's
an
application,
programming
interface.
That
means
that
C
sharp
can
perform
requests
against
that
API.
C
The
same
way
that
python
can,
even
though
the
language
that
you
write,
the
requests
and
and
the
code
in
is
different,
it
looks
very,
very
different
when
you
go
between
the
two.
The
data
that
you
get
back
is
the
same.
Now
it
might
be
different
types
coming
back
in
terms
of
what
c-sharp's
data
structure
will
look
like
coming
back
to
you,
as
opposed
to
python,
or
in
this
case
we're
going
to
be
talking
about
Powershell
and
getting
Powershell
objects
back.
C
But
at
the
end
of
the
day,
when
you
send
a
request
in
whatever
language
to
the
API,
the
API
is
programmed
in
such
a
way
that
it
has
a
very
structured
data
tree
behind
it
that
allows
that
stuff
to
come
back.
You
you
always
get
the
same
properties
Etc
coming
back
from
that
API
Powershell
really
makes
working
with
apis
easy,
we'll
dive
into
that
a
little
bit
later.
C
A
D
A
Then,
whatever
you're
meeting
that
with
in
this
case,
Powershell,
is
going
to
transform
that
into
the
tool
that
you're
using
to
read
that
API
right.
So
if
it's
python,
it's
python
data,
if
it's
Powershell,
it's
Powershell
that
comes
back,
but
the
data
that
comes
back
from
the
API
is
sort
of
it's
basic.
It's
not
it's
not
configured
to
the
program
right.
The
program
does
the
conversion
when
it
gets
the
data
correct.
C
Exactly
and
typically
in
90
of
use
cases
that
that
data
is
going
to
come
back
to
the
come
back
to
you
as
Json,
and
then
it's
up
to
the
programming
language
to
interpret
that
as
something
and
it
might
come
back
to
you
as
plain
text.
It
might
come
back
to
you
as
as
X
and
L.
It
just
depends
on
the
API.
C
A
And
so
the
benefit
there
so
the
benefit
there
is
when
stuff
comes
back
and
you're
using
Powershell
Powershell
does
quite
a
bit
of
work
behind
the
scenes
to
make
that
into
an
object
that
we're
used
to
with
Powershell
when
you're
using
another
language.
It
may
not
be
that
convenient.
You
may
have
to
do
some
work,
correct.
C
It's
make
model
collar
door
number
whatever
you
would
receive
that
Json
and
then
set
those
properties
based
on
the
response
of
the
Json
and
then
do
something
with
it.
Powershell
is
super
awesome
in
that.
If
you
do
an
invoke
rest
method
against
an
API,
it
automatically
takes
that
Json
and
turns
it
in
to
a
Powershell
object
for
you.
So
you
get
all
these
properties
back,
etc,
etc.
D
E
C
Yeah
absolutely
absolutely
and
there's
nothing
stopping
you
inside
a
Powershell
too
of
doing
some
work
to
capture
that
response
from
invoke
rest
method
and
then
taking
that
data.
Creating
your
own
PS
custom
object.
That's
got
strongly
typed
data
inside
of
it
and
just
returning
that,
maybe
you
let
the
web
server,
send
you
everything
and
then
you
send
back
to
the
user
a
PS
custom
object.
That's
only
got
three
or
four
things
on
it,
whereas
the
web
server
sent
you
12
Etc,
so
it
is
very,
very
flexible
inside
a
Powershell
as
well.
C
But
yes,
you
are
correct.
C
sharp
is
very,
very
type
type
safe
and
you
kind
of
need
to
use
the
language
that
makes
the
most
sense
to
you.
This
is
a
Powershell
group.
We're
going
to
do
it
all
in
Powershell,
but
if
you've
got
other
developers
on
your
team
that
or
other
areas
of
your
business
that
use
other
programming
languages,
they
can
still
leverage
this
stuff
because
an
API
is
universal,
but
not
to
digress
too
much.
A
C
Yeah
sure
yeah
we'll
dive
into
that
stuff,
a
little
bit
a
little
bit
later,
because
I'd
like
to
show
the
difference
rather
than
while
I'm
talking
through
it.
So
this
is
a
Swagger
dock.
So
if
you
look,
we've
got
this
link
here
that
says
swagger.json.
You
can
see
this
in
its
raw
Json
format,
but
Swagger
is
so.
This
is
the
schema
for
this
particular
API,
and
this
is
a
sonotype
Nexus
repository
server.
C
C
C
If
the
request
was
okay-
and
this
is
the
type
of
data
that
it's
going
to
send
me
back
so
that
I
know
for
my
programming
perspective
when
I
go
to
wire
this
up
and
write
a
Powershell,
commandlet
or
whatever
to
to
interact
with
this.
This
is
the
data
that
I'm
going
to
get
back
and
if
I
want
to
look
at
this
in
a
little
bit
more
detail,
I
can
click
on
model
and
expand
this
out,
and
it
gets
a
little
hairy
trying
to
expand
this
out
a
little
bit.
C
But
you
can
then
more
clearly
see
that
name
is
a
string.
Type
is
a
string.
Unavailable
is
a
Boolean.
We
have
some
integers
in
here,
etc,
etc.
So
Swagger
really
cleanly
defines
well.
The
Json
clearly
defines
the
schema
through
the
API,
but
Swagger
gives
you
a
really
nice
UI
on
top
of
it
to
expose
it
and
the
nice
thing
with
Swagger.
Is
you
get
these
little?
Try
it
out
buttons.
C
It
always
seems
to
be
curl,
it's
very,
very
rare
that
you
get
a
Powershell
Centric
big
sample
here,
but
it
gives
me
the
the
curl
command
that
I
would
need
to
do
the
same
exact
thing.
It
gives
me
the
exact
request,
URL
that
I
sent
it
to,
and
then
it
gives
me
the
actual
response
from
the
API.
So
in
this
case,
I
only
have
one
blob
store
on
the
server,
and
these
are
the
properties
of
that
blob
store
returned
from
the
Json.
C
C
So
it
allows
you
to
craft
a
body
which
is
in
Powershell
will
be
nothing
more
than
a
hash
table
with
these
properties.
So,
if
I
wanted
to,
for
example,
create
a
new
file,
blob
store,
I
could
say:
hey
I
want
to
do
a
post
request
to
this
endpoint
with
a
content,
type
of
application.json
or
application.
Slash
Json
and
my
body
needs
to
have
these
these
properties
inside
of
it
and
if
I
get
everything
right
and
I,
send
that
request.
C
I
will
get
a
new
file,
blob
sort
created,
for
example,
and
there's
other
methods
in
here
too,
we've
got
some
puts,
which
is
hey.
Here's
here's
some
data
I
want
to
update
a
record.
It's
going
to
update
that
record
now
and
a
put
will
say:
here's
all
of
the
stuff
for
this
schema
if
I
don't
fill
all
of
this
stuff
out.
C
The
put
will
allow
nulls
into
some
of
those
fields
which
may
not
be
what
you
want.
There's
no
there's
no
patch
types
in
this
particular
API,
but
there's
a
very
there's,
a
very
important
difference
between
a
put
and
a
patch.
A
patch
will
update
only
this
stuff
in
the
body
that
you
gave
it
so
say:
you've
got
a
a
schema,
that's
name
ID
and
telephone
number,
for
example,
and
you
do
a
put
request
with
name
of
Bob
and
an
ID
of
three
and
a
telephone
number
of
some
seven
digit
telephone
number.
C
The
put
requests
will
update
all
of
those
things.
Now
you
do
the
same,
put
request
again
to
update
Bob
by
changing
his
name
from
Bob
to
Bill,
and
then
that's
all
you
put
in
there.
You
say:
hey,
send
this
Bill
request
in
there
it's
not
going
to
work,
it's
you're
going
to
get
a
new
record
with
Bill,
with
nulls
for
everything
else,
or
an
error
depending
on
the
API
spec
rap.
C
But
rather,
if
you
did
a
patch
and
you
sent
a
request,
it
would
only
update
the
field
that
you
had
in
the
body
very,
very
important
difference.
Some
and
you
have
to
watch
out
for
the
apis
too,
because
puts
and
patches
can
be
implemented
to
where
a
put
does
a
patch
or
a
patch
does
a
put
or
they're
just
raw.
C
Hopefully
the
the
people
that
wrote
the
API
kind
of
know
what
they're
doing
and
have
done.
The
right
thing
in
terms
of
this
is
a
put
request,
so
you
expect
a
certain
thing
to
happen
in
a
patch
request.
You
expect
a
certain
thing
to
happen
and
they've
got
it
right,
but
if
nine
times
out
of
ten,
not
not
very
many
people
deal
with
with
patches
you'll
see
puts
an
awful
lot
more
and
then,
of
course,
you
have
your
deletes,
which
does
exactly
what
it
says
on
the
10.
C
If
you
send
a
request
to
this
endpoint,
it
will
delete
whatever
is
in
the
body
a
good
one.
To
give
you
an
example
of
that,
do
we
have
a
blobs
throwing
yeah?
So
if
you
send
me
a
blob
store-
and
you
put
the
name
in
the
URL,
so
this
is
another
type
of
request
and
we
can
dive
into
this
a
little
bit
too.
If
we
hit
try
it
out
here
and
I
just
put
like
default
in
here
and
hit
execute
bad
things,
that
would
happen.
I
don't
want
to
do
that.
C
You
don't
necessarily
have
to
have
a
body
for
a
request.
You
can
do
an
API
that
has
query
strings
in
it
as
well,
which
is
when
you
see
that,
like
Ampersand
and
then
question
marks
around
stuff.
That's
that's
query.
String
parameters!
That's
another
way
that
you
can
interact
with
apis,
it's
Hit
or
Miss,
whether
an
API.
Does
it
that
way
or
not.
C
C
What
else
is
inside
of
here?
That
might
be
interesting.
I
think
that
covers
everything
that
I
wanted
to
look
at
in
terms
of
a
Swagger
dock.
Just
to
show
you
a
couple
of
other
things
and
show
you
how
vastly
different
API
stuff
can
be.
This
is
a
Swagger
dock,
API
reference.
This
is
the
API
reference
for
Twitter.
As
you
can
see,
it's
not
really
as
neat
it's
neat,
but
it's
it's
different
than
Swagger.
C
So,
if
you
wanted
to,
you
could
like
get
all
your
like
tweets
or
whatever,
and
if
you
go
in
here,
you
can
see
here's
the
endpoint
URL,
here's
all
the
authentication
methods,
here's
the
the
path,
parameters,
etc,
etc.
Here's
the
query,
parameters
and
then
here's
some
example.
Code
stuff
in
different
languages
is
not
as
easy
to
read
this
and
understand.
What's
going
on
as
it
is
in
a
Swagger
dock.
C
You
can
kind
of
write
your
documentation,
however,
you
want
to
so
it's
it's
kind
of
up
to
up
to
you.
What
you
use
I
prefer
Swagger
for
everything,
but
yeah
you'll
you'll,
as
you
get
started
playing
with
apis
and
trying
to
figure
out
how
to
wrap
things,
be
prepared
for
a
little
bit
of
confusion
and
a
lot
of
red
text
and
a
lot
of
staring
at
the
screen
wondering
what
the
hell's
going
on
as
you're
trying
to
figure
things
out
these.
A
Yeah
Stevie
I
was
also
going
to
mention,
as
you
were
talking
here,
that
apis
can
vary
in
complexity
of
it.
I
can,
and
so,
when
you're
starting,
it's
a
lot
easier
to
start
with
a
really
simple
API,
maybe
one
that
doesn't
even
require,
like
any
actual
authentication
and
just
oh,
yes,
getting
and
putting
100.
You
know
and
posting
and
and
before
you
move
to
the
Twitter
API.
That
has
probably
a
very
specific
way
of
dealing
and
getting
back
lots
of
different
types
of
information.
C
Yes,
absolutely
100,
but
Postman
is
a
great
Tool.
It
is
it's
pretty
easy
to
at
least
poke
things
in
this
before
you
go.
Writing
any
Powershell
code.
It's
pretty
fun,
so
the
param
section
you
can
do
like
that.
Query.
String
nonsense!
That
I
was
talking
about
the
body,
can
do
the
body
stuff
that
I
was
talking
about
any
assets.
People
are
saying
in
the
chat
you
can
choco
install
Postman
and
it
will.
C
You
can
also
do
this
kind
of
stuff
with
the
web
browser
as
well,
so
just
to
show
you
that
let
me
do
a
get
request
on
this.
One
and
I
can
do
an
F12
here
and
just
to
show
you
what
this
looks
like.
If
I
do
an
f
x
kit
on
this,
we
can
see
this
request
come
through
and
if
we
look
at
the
headers
you
can
see
here
are
my
request,
headers
and
then
here's
my
preview
of
other
response.
C
C
Trace
on
and
let's
do
a
method
of
a
get
which
is
default,
behavior
for
invoke
rust
method.
If
you
just
do
invoke
rust
method,
URI,
it's
going
to
assume
you
may
get
and
try
that
anything
else.
You
definitely
want
to
specify
the
method,
but
by
default
it's
a
get,
but
you
can
see
the
invoke
rest
method
way
of
doing.
Things
is
quite
a
bit
simpler
than
all
this
nonsense.
That
Chrome
devtools
gave
you,
but
if
you
are
just
getting
started
and
want
to
really
do
something
quickly,
it's
there.
C
C
Let's
look
at
one
more
API
example
before
we
start
having
a
little
bit
more
fun,
so
we've
got
the
clouds
layer
API
as
well.
Just
to
give
you
yet
another
example
of
what
API
documentation
could
look
like
this
one's
a
little
bit
easier
to
read
in
my
opinion
than
the
Twitter
one,
but
still
not
as
good
as
a
regular
Swagger
dock.
C
Is
it
gives
you
the
required
parameters
so
for
this
one
you
need
an
API
key,
you
need
an
email
or
you
need
a
user
service
key
depending
on
what
what
authentication
method
you're
going
to
use
with
a
specific
header.
So
you
can
either
send
an
x-off
key
header
with
your
API
key
or
an
auth
email
with
an
email
address
or
a
service
key,
and
it
might
need
to
have
one
the
other,
both
all
three,
it
kind
of
depends
on
the
API.
C
C
There
is
a
module
out
there
from
the
Posh
woof
called
Corona
PS,
which
will
take
that
curl
string.
That
we
just
copied
so
if
we
were
to
come
in
here
and
say,
CS
equals
and
then
let's
do
a
here
string
and
paste
this
in
and
close
this
off,
we
can
then
do
convert
to
oops,
convert
to
irm
and
then
my
Cs
and
we
get
a
hash
table
back
with
everything
we
need
to
Splat
that
to
Iran.
C
So
if
we
were
to
do
like
Splat
equals
that
and
then
do
irm
at
splat,
it's
going
to
fail,
because,
obviously
that's
not
right
data
in
that
example
request,
but
that
would
work
and
it
would
allow
you
to
really
quickly
say:
hey
here's
a
curl
example
from
this
documentation.
I
want
to
really
quickly
use
this
with
rust
method.
Well,
you
can
do
that
with
that.
C
With
that
module,
It's
relatively
accurate,
you
might
have
some
cases
where
the
curl
doesn't
quite
100,
convert
correctly
into
the
Splat,
but
it's
it's
pretty
good
and
it
does
speed
you
up
quite
a
bit.
So
just
so,
you
guys
are
aware,
aware:
curl
the
PS
is
out
there.
It's
available.
You
can
install
it
from
the
gallery:
install
module.
A
C
Let's
have
some
fun
now,
let's,
let's
put
some
of
this
into
practice,
now,
I've
already
done
a
ton
of
work
with
this
API,
because
I've
already
got
a
Powershell
module
called
Nexus
shell,
which
wraps
almost
100
of
this
API
as
Powershell
modules,
but
we'll
kind
of
break
it
down
a
little
bit
and
show
you
what
it
looks
like
to
actually
attempt
something
like
this
yourself.
So
we
are
definitely
going
to
need
some
authentication
for
this.
F
D
C
C
C
If
you
do
a
session
variable
that
that
saves
a
cookie
basically
and
then
in
inside
of
that
session,
variable
there's
a
cookie
that
is
your
authentic
authentication
cookie
and
then
you
can
use
a
web
session
to
pass
that
back
and
forth.
So
that's
how
our
Central
management
does.
It
is
via
that
cookie.
C
F
C
C
In
this
example,
we
take
the
name
of
the
server,
so
in
this
case
it
would
be
chocolate
server.stvcoaster.dev.
We
give
it
the
credentials
of
the
user
that
you
want
to
authenticate
to
the
API.
In
this
case,
we'll
use
the
admin
account
on
server,
because
that's
the
only
one
that
exists,
because
it's
a
demo
box
the
path
which
could
potentially
be
different
depending
on
the
server
you
hit,
because
in
this
particular
case,
Nexus
has
the
concept
of
a
context
path.
C
So
this
could
be
something
like
eight
four,
four
three
slash
Nexus
to
get
to
the
root
of
the
server
instead
of
just
hanging
off
of
the
port.
Here,
for
example,
so
we
take
into
account
that
you
might
have
a
contacts
bath
and
we
provide
you
with
parameters
to
tell
me
whether
or
not
this
is
an
SSL,
backed
instance
of
Nexus,
and
what
the
SSL
Port
is
by
default
by
default.
C
C
C
Otherwise
we
set
the
protocol
to
http
and
the
port
to
81,
because
that's
the
defaults
for
a
regular
non-sl
instance
of
of
Nexus
and
typically
that
doesn't
change
when
I've
never
seen
a
Nexus
instance
run
on
Port
80,
for
example,
say
always
run
on
8081.
That
could
probably
be
improved,
but
whatever,
and
then
we
set
the
hostname
variable
to
a
script
scope
again,
just
so
that
we
can
reuse,
it
other
places
across
the
module.
And
then
we
set
our
contacts
path
to
whatever
that
path.
C
Variable
was
and
then,
very
importantly,
we
get
into
different
types
of
authorization
inside
of
headers,
in
this
case
we're
going
to
use
basic
authorization,
which
is
just
hey
the
word
basic
and
then
a
space
and
then
a
base64,
encoded,
username
and
password
pair.
So
it's
username
colon
password,
a64
encoded
now
I
did
it
this
way
for
compatibility
reasons
if
you're
just
straight
up
using
Powershell,
seven
or
Powershell
six
and
newer
I
think
it
does
have
the
authentication
and
token
stuff
baked
into
it.
C
So,
if
you're
going
to
do
anything
with
apis,
pretend
that
Windows
Powershell
is
dead,
just
use
Powershell,
seven,
it's
so
much
better
in
Powershell
7,
when
you're
working
with
apis
the
way
the
the
data
is
formatted
and
Returns
To
You
by
The
commandlet
is
amazing.
There's
all
this
additional
authentication
stuff
baked
into
it.
There's
a
ton
of
extra
stuff
on
invoke
rest
method
now
and
actually,
if
we
do.
D
C
C
C
C
We
do
keep
that
credential
hanging
around
for
a
very
special
reason
in
this
particular
module.
Pretend
that
doesn't
exist,
though,
and
then
we
make
a
request
to
an
endpoint.
I
I've
picked
the
status
endpoint
here
to
just
use
that
header
just
to
make
sure
that
it
worked.
So
we
can
say,
error
action
stop
and
then,
if
that
request
works,
we
get
connected
to
the
host
name
and
then,
if
it
didn't
work
it
it
throws
an
exception
message.
So
if
we
were
to
take.
F
C
F
F
F
C
C
C
It
definitely
want
it
to
be
mandatory.
We
want
it
to
be
a
string
and
we
want
to
call
it
repository
name
so
that
it
matches
not
just
a
parameter
here
now.
It
doesn't
have
to
really
match
100
like
if
you
wanted
to
just
call
it
repository.
You
could
but
I
like
to
be
as
close
to
what
the
actual
parameter
is
in
the
schema
of
the
Json
as
possible,
so
that
when
I'm,
looking
at
the
code
here
and
looking
at
the
schema,
they
match
kind
of
one
to
one
and
then
what
do
we
need?
C
That's
all
the
parameters
for
this
API.
So
what
we
need
is
a
process
block
and
then
we
need
a
URL.
So
if
we
look
we're
going
to
cheat
a
little
bit
and
just
grab
this
URL
here,
because
I
know
that's
what
it
is,
it's
a
little
bit
different
in
Nexus
show
how
I've
done
things,
but
that's
more
for
part.
Two,
because
I'm
doing
some
weird
things
over
there,
so
I'm
just
going
to
define
a
URI
variable
equals
and
we're
going
to
put
this
in
here.
F
C
Right
here,
so
that,
because
this
is
in
double
quotes
that
variable
will
expand
out
and
that
you
are
will
be
correct.
Based
on
that,
if
I
were
to
do
this
in
single
quotes,
that
variable
would
not
expand
and
you
would
try
to
get
a
repository
literally
named
dollar
repository
name
and
you
would
have
a
bad
time
and
you
would
pull
your
hair
out
because
you're
like,
why
is
it
happening?
C
C
So
what
I
like
to
do
to
keep
my
lines
really
short,
because
your
brain
Scrolls
this
way
a
lot
better
than
it
Scrolls
this
way,
so
keep
your
line
short
if
you
can,
and
what
that
might
do
here,
like
you
might
even
make
this
a
little
bit
short
shorter,
yet
and
break
this
apart,
but
I
also
realized
that
I'm
zoomed
in
a
little
bit
farther
than
I
normally
would
be.
So
this
is
fine.
C
C
And
then
we
also
need
to
tell
it
the
content
type
of
application
Json.
So
that
invoke
Russ
method
knows
what
kind
of
beta
is
expected
from
the
response.
So
it
can
do
the
right
thing
to
format
it
and
give
it
back
to
us,
and
then
we
need
to
splat
it
so
invoke
rest
method
at
irm,
params,
that's
a
whole
lot.
Better
splatted
and
readable
I've
been
doing
invoke
best
method,
URI
method
get
prompt
to
type
blah
blah
you
kind
of
get
the
point.
C
C
C
There's
a
question:
is
it
okay
to
use
PS
credential
instead
of
typing
all
that
out?
Absolutely
that
one
will
probably
be
fine.
I
just
know
that
I've
been
bitten
in
the
ass
before
by
assuming
that.net
will
find
the
write
type
for
me,
where
the
ending
type
might
be
the
same
in
two
or
three
different
classes,
and
the
only
way
to
get
the
right
one
is
to
fully
qualify
it
and
best
practice.
Is
the
fully
quiet
fully
qualify
this
stuff
anyways
in
terms
of
the
these
kind
of
things?
C
C
F
B
F
C
You
didn't
have
to
do
anything
magic
to
to
get
that
object
back.
You
just
got
a
one-to-one
whatever
was
defined
in
the
schema
of
the
API,
as
something
that
would
be
returned
is
what
you'll
get
back
via
the
API.
So
in
this
result,
object
if
I
wanted
to
I
could
just
the
new
DOT
name
and
get
name
I
could
do
dot
storage
and
give
me
all
the
information
about
the
storage.
C
So
for
this
we've
got
a
blob
surname
of
default
content,
type
validation
of
true
and
write
policy
of
allow
et
cetera,
Etc.
It's
all
there.
I
didn't
have
to
do
any
extra
work.
It
just
magically
happened
for
me,
it's
great,
but
let's
say
that
perhaps
result
had
too
much
data
inside
of
there
I,
don't
really
care
or
I
want
to
do
something
different.
For
example,
we
could
go
out
and
go
off
into
the
weeds
and
change
this
a
bit.
C
Blobs
or
name,
for
example,
is
equal
to
result,
dot
name,
and
let's
say
we
know
that
the
format
is
nuget,
because
the
commandlet
was
get
Nexus.
Nuget
hosted
repository,
so
I
don't
care
about
that.
One
I,
don't
care
about
the
URL
either
I
do
care
about
whether
it
was
online
or
not
so
I'm
going
to
say
online
equals
result,
Dot,
online
and
I
care
about
cleanup
policy
stuff,
so
cleaner
policy
equals
result,
dot
cleanup
and
that's
all
I
want,
because
I
know
the
type
is
hosted.
C
I
get
just
just
the
data
back
I
cared
about
I
manipulated
it
inside
of
the
function
to
control
exactly
what
it
looked
like
to
the
end
user.
So
just
because
the
API
schema
dictates
that
this
endpoint
is
going
to
give
me
back.
This
information
doesn't
mean
that's
gospel
when
you're
wrapping
an
API
and
giving
it
back
to
the
end
User.
It's
it's
just
going
to
to
me
that
you,
you
have
flexibility
there
right.
If,
if
you
want
to
change
things
around,
you
can
yes,
this
is
a
PS
custom
object.
C
C
Maybe
you
want
this
to
be
returned
such
that
you
could
do
something
like
a
nougat
hosted,
repo
type
like
that,
gets
really
into
the
weeds
of
using
classes
of
Powershell
and
then
wrapping
apis.
That's
that's
for
down
the
road
come
to
Summit,
but
you
can
do
all
kinds
of
cool
stuff
with
apis
inside
of
Powershell
I'm
going
to
stop
there
because
I've
been
talking
for
a
while
and
not
paying
attention
to
the
chat
and
it's
been
quiet.
A
D
C
So
this
I
use
the
result
out
of
habit.
I
could
have
used
it
in
all
here,
because
this
API
endpoint
that
I'm
using
to
send
a
a
header,
just
just
so
I
craft,
a
header
and
build
it
like
technically
I.
Don't
even
have
to
do
this
technically.
All
I
would
have
to
do
to
make
this
work
is
something
like
this.
So
if
I
go
to
just
like
Steve
coaster,.
C
C
C
That's
because
I
typed,
my
password
wrong
I
didn't
want
to
create
a
header
with
the
wrong
password
and
not
know
it
after
I
use
the
connect
function
and
everything
looked
good
and
then
I
moved
on
and
I
used
another
function
and
then
all
of
a
sudden
it
blow
up
in
my
face
with
the
401
unauthorized
I'm,
calling
this
particular
endpoint
here,
because
it
gives
some
sort
of
a
simple
Json
response
back
that
I.
Don't
care
about
so
I
just
null
it
I.
C
Don't
care
I,
just
care
that
the
invoke
press
message
worked,
so
that
I
can
wrap
that
in
a
try
catch
with
error
action
stop.
So
if
it
worked
great,
if
not
throw
a
message
in
this
case
for
one
unauthorized,
but
that's
why
I
used
to
result.
I'm,
just
used
to
typing
result
equals
because
I'm
burying
the
response,
I
don't
want
to
see
whatever
the
output
of
this
was.
C
A
H
Yeah
I'm
kind
of
curious
I
guess
if
you
have
like
a
best
practice
for
this
scenario,
if
you're
building
a
module,
you
know
writing
several
commandlets
within
that
module
to
interact
with
an
API.
You
know
a
lot
of
times.
You
look
at
situations
like
well
like
Azure.
You
know,
connect
Dash,
whatever
right
log
in
dash,
whatever
you
know,
they're
they're
logging
in
once.
H
Getting
that
that
token,
that
Bearer
token
and
they're
stuffing
it
somewhere
and
then
and
then
after
that,
subsequently
you're
not
having
to
stick
a
credential
on
every
single
Command
right
correct.
Do
you
have
a
best
practice
for
sharing
that
credential
between
your
different
commandlets
in
that
module.
C
In
this
particular
look
at
the
easiest
thing
to
do
is
script
scope
because
that
locks
it
into
that
module.
So
if
you
were
to
say
next
to
cell
Nexus,
shell
is
a
really
good
example:
it
uses
a
script.
Scoped
header
variable,
that's
that
is
available
to
all
the
functions
in
that
module,
but
if
I
were
to
use,
invoke
rest
method
outside
of
that
module
and
try
to
pass
header
to
it,
it
wouldn't
know
what
the
hell
I
was
talking
about.
That
doesn't
exist,
so
it
lives
inside
of
the
scope
of
that
module.
C
Can
you
get
to
it
with
Powershell?
Yes,
you
can
what's
the
likelihood
of
somebody
knowing
how
to
do
that.
It
depends
on
your
team
if
your
team
is
full
of
really
really
smart,
Powershell
people
using
a
script
scope
variable
is
probably
something
that
you
could
do
better,
but
it's
it's
pretty
safe.
So
that's
one
way
to
do
it.
C
Another
way
to
do
it
is
to
rely
on
secret
management
module
and
just
have
your
authentication
pull
from
a
vault
like
Azure
key
Vault,
for
example,
or
whatever
again
you're
going
to
have
to
authenticate
to
that
stuff.
Somehow,
but
secret
management
is
a
really
good
good
way
to
retrieve
that
stuff
and
then
pass
that
along.
E
As
another
module
author
I'll,
throw
out
my
opinion
that
using
the
script,
scope
is
typically
a
great
way
to
go,
works
very
well.
If
it's
something
that
doesn't
need
to
be
just
a
single
instance,
then
yeah
using
Secrets
management
is
fantastic.
If
you
do
have
an
instance
where
you
need
to
have
only
one
credential
or
one
object
in
the
entire
system,
for
whatever
reason
then,
using
something
like
a
name
to
mutex
is
a
fantastic
way
to
go
as
well.
Yeah.
A
G
G
So
so
in
your
example,
the
dollar
sign
result
is
there
actually
something
in
there
and
the
only
way
that
I
could
figure
out
how
to
do
that
reliably
was
using,
and
this
seems
wrong,
which
is
why
I'm
asking
is
using
the
string
is
null
or
empty
method
on
result
and
that
returns
either
true
or
false.
If
invoke
breast
method
returns
something
or
doesn't.
If
I
did
a
a
result,
the
measure
object,
dot,
count
or
result.count
those
all
returned,
one.
Even
no
results
were
returned,
and
so
I
was
wondering
what
your
thoughts
on
that
were.
C
Typically,
what
I
do
is
I
just
do
something
like
this
and
let
Powershell
handle
it
for
me
if
a
result
else
something
else,
because
if
this
didn't
give
me
anything
back,
this
is
going
to
be
empty
and
this
is
going
to
be
false.
So
it's
quick
and
dirty
it
doesn't
work.
A
hundred
percent
of
the
time
checking
if
this
is
null
is
really
good.
So,
if
not
all
naughty
cool
result,
for
example,.
C
Exactly
yeah,
it
depends
on
the
end
point.
It
depends
on
the
end.
Point
too,
like
there
are
cases
where
invoke
rest
method,
no
matter
what
it's
going
to
have
something
returned
from
the
API
I've
seen
that
a
time
or
two
where
that
something
is
junk,
it's
completely
worthless,
but
in
bulk
rest
method
got
something
so
there's
something
in.
G
G
F
C
H
I
I
So
once
you
did
your
connect
command,
it
created
that
object
and
then
what
built
within
the
connect
command
I
had
a
variable
of
with
the
token
there
lifetime
would
be
the
chicken
getting
from
the
docks
you
know
and
I
always
added
like
a
pad
to
it.
You
know
like
minus
a
minute
or
minus
five
minutes
or
or
whatever
so
that
you
know
it
technically
never
really
runs
out
and
then
within
my
module,
I
had
one
generic
command,
so
each
sub
command
like
say
get
some.
I
Some
record
would
just
set
the
splatting
parameters
for
then
a
single
do
the
Dirty
Work
command
and
then
the
duty
Dirty
Work
command
checks.
The
the
global
object
looks
for
the
you
know
to
see:
hey,
see,
Bears
still
alive
or
did
it
expire,
if
not
it
just
reruns
the
connect
command
and
if
not,
then
it
just
does
the
you
know
the
needful,
if
you
will
so
that
that's
kind
of
how
I
did
and
it
actually
worked
really
well.
D
C
D
C
Sorry,
this
is
why
I
say
that
a
Powershell
core
is
the
only
way
you
should
be
interacting
with
abis
the
the
web
command
lists
inside
of
Powershell,
seven
slash,
Powershell
core
or
whatever
you
want
to
call
it
Powershell
our
light
years
ahead
of
of
the
windows,
Powershell
stuff
and
the
windows.
Powershell
stuff
isn't
going
to
get
any
of
these
Advanced
features
and
and
new
functionality.
That's
in
in
Powershell
today,.
H
F
C
I
F
J
B
I
Yeah
that
yeah
I
figured
as
much
but
I
didn't
know
how
to
get
the
to
be
able
to
actually
parse
the
error
code
out
of
it.
At
least
you
know,
I
was
just
trying
to
do
it
100
miles
an
hour
and
build
something
that
worked
to
solve
a
problem.
Real,
quick
and
ended
up
writing
a
fully
functional
module.
Instead.
C
C
A
A
Why
don't
we
want
to
put
a
nice
bow
on
this,
so
for
those
of
people
have
been
watching
at
home,
may
not
be
understanding.
What
we're
talking
about
Stevie
helped
a
group
out
tonight
with
a
last
minute
change
of
scheduling
and
jumped
in
and
extended
a
demo
that
he's
going
to
do
for
us
in
a
month
and
a
half
into
basically
a
two-parter,
and
so
tonight
he
put
together
this
demo
with
about
90
minutes
or
two
hours
of
prep
time,
and
so
he
did
an
amazing
job,
and
that's
why
I
was
saying
wow.
A
This
is
what
you
put
in
a
intro
and
so
as
as
we
mentioned,
we'll
be
coming
back
in
about
six
weeks,
so
maybe
less
and
middle
middle
of
March
he'll
be
presenting
on
essentially
the
part
two
of
this
which
will
be
a
deeper
dive,
and
so
what
I
really
appreciated
tonight
was
a
lot
of
useful
examples
and
lots
of
great
input
from
the
community.
Lots
of
great
questions,
lots
of
good
examples
in
the
chat.
A
Unfortunately,
if
you're
watching
at
home,
you
may
not
see
the
chat,
because
that
doesn't
come
along
with
the
recording
and
so
that's
why
I
always
encourage
people
to
come
and
join
us
in
person
if
possible,
but
Stevie
fantastic
job
and
I'd
like
to
ask
everybody
if
they
could
to
give
Stevie
a
round
of
applause
for
stepping
us
stepping
in
for
us
last
minute.
That's
a
really
wonderful
thing
you
did
for
us
tonight
and
we
appreciate
that
so
much,
no,
not
a
problem
yeah,
and
so
with
that
folks.
A
We're
gonna
wrap
this
one
up
tonight,
as
I
was
just
saying.
This
group
meets
in
person
on
the
first
and
third
Wednesday
of
the
month
and
we'd
love
to
have
you
come
and
join
us,
so
you
can
participate
in
the
discussions
in
person
and
live
to
do
that.
You
can
visit
us
at
meetup.com
and
look
for
RTP
Sugg
or
you
can
go
to
rtpsug.com
and
get
information
on
how
to
join
us
at
the
next
meeting
Phil
anything
you
want
to
wrap
up
with
here
before
we
finish
this.