►
From YouTube: Custom Connector as Code Using Power Platform CLI
Description
In this 15 minute demo, we are showing the evolution of the command line tools to create connectors and the fact that is part of the overall Power Platform effort. Developers can now have a single point of entry when working with connectors, solutions, PCF controls and other such power platform experience in a consistent way. You can download the Power Platform CLI at aka.ms/PowerPlatformCLI to try out and give us feedback. This video was taken from the December 14, 2022 Power Platform Integrations / Connectors LABs Call.
Kartik Kanakasabesan (Microsoft) | @kkanakas, linkedin.com/in/kartikka/
Supporting materials
https://learn.microsoft.com/en-us/power-platform/alm/devops-github-actions
https://learn.microsoft.com/en-us/power-platform/alm/devops-build-tools
https://www.youtube.com/watch?v=NkoWGF8a4aQ
Learn more about Power Platform Connectors
https://github.com/microsoft/PowerPlatformConnectors
https://learn.microsoft.com/en-us/connectors/
A
A
B
B
Right
so
I
I,
you
know,
as
Justin
mentioned,
I'm
I'm
well
one
of
the
PMS
responsible
for
a
lot
of
the
dev
tooling
capability
that
we
provide
within
par
platform,
specifically
making
sure
that
code
first
developers
and
citizen
developers
are
able
to
go
ahead
and
and
collaborate
in
meaningful
fluid
ways.
So
those
are
the
kind
of
experiences
that
I
that
I
focus
on
and
as
Jocelyn
mentioned,
my
focus
tends
to
be
on
building.
One
of
the
key
developer.
Experiences
is
around
the
Power
Platform
CLI.
B
So
the
first
question
they
usually
get
asked
is:
why
do
we
have
a
Power
Platform
CL?
Well,
if
you
were
a
developer
that
wanted
to
go
build
anything
with
with
with
part
platform
in
particular
or
for
that
matter
with
d65,
you
had
a
plethora
of
tools
and
it's
great
when
you
have
a
Swiss
army
knife
of
things.
It's
just
that
when
you
need
to
use
it
for
a
particular
utility,
you
don't
know
which
blade
to
go
use.
B
So
the
question
usually
is
how
do
I
get
started
and
when
we
looked
at
that
and
each
of
these
things
you
know
it's
wonderful
that
10
different
things
can
do
the
same
thing,
which
is
the
one
that's
optimal.
You
know
so
what
we
said
was:
okay,
let's
take
a
step
back
and
figure
out
what
is
the
right
way
to
kind
of
move
forward
here
right?
Yes,
there's
Powershell
scripts
that
are
there.
Yes,
there's
the
SDK,
that's
all
there's
and
things
of
that
nature.
B
So
our
goal
was
to
focus
primarily
on
the
developer,
use
cases
and
make
it
easy
for
the
developer
to
get
started
all
right.
That
was
the
sole
intention
around
this,
and
the
key
thing
is
it's
not
just
you
know
when
data
when
the
when
the
Power
Platform
C
live
C
live
first
started.
It
was
mostly
around
PCF
and
everything
else,
but
it's
now
morphed
on
to
being
the
central
clearing
or
the
central
integration
Hub.
If
you
will
for
a
lot
of
the
developer
experiences
that
we're
bringing
into
Bear
all
right.
B
B
These
are
all
based
on
the
Power
Platform
CLI
and
under
the
covers
it
does
things
you
can
actually
pull
and
pull
down
part
Pages,
artifacts,
PCF
components
where
now
we're
bringing
in
custom
connector
development
directly
in
so
we're
actually
in
the
process
of
consolidating
a
lot
of
the
PA
con
work
directly
into
the
Power
Platform
CLI.
So
we
have
one
CLI
across
the
board
for
developers.
Instead
of
these
multiple
bespoke
experiences
packages
and
applications
installs
many
of
such
capabilities
as
such
one
of
the
key
areas.
B
Now
when
you,
when
you
interact
with
the
CLI,
as
you
can
see,
it's
pretty
rich
when
it
comes
to
some
of
the
commands
that
are
available
there
right,
but
the
Paradigm
usually
is,
is
the
fact
that
it
is
pack
solution
and
then
export
and
that's
one
of
the
other.
Things
too
is
the
fact
that
Power
Platform
CLI
is
multi-platform
out
of
the
gate.
It
is
available
on
Windows.
B
Obviously,
it's
available
on
Mac
and
it's
also
available
in
Linux,
and
it's
the
reason
why
I
emphasize
a
little
bit
more
an
Linux
primarily
is
because,
when
you're
using
things
like
Ci
CD
Pipelines,
you
want
to
be
able
to
go
run
it
on
your
Linux
Runners
to
be
able
to
go,
build
artifacts
that
way.
So
so
that's
the
other
thing
there
out
of
the
covers.
B
What
it's
actually
using
is
something
called
as
the
dataverse
service
client,
all
right,
so
without
further
Ado
I'm,
going
to
show
you
a
very
quick
example
of
how
the
experience
this
is
a
lot
of
us
when
we
start
using
GitHub,
for
example,
we
usually
clone
the
repo.
Do
things
like
that
within
GitHub.
Now
it's
available
for
everyone
is
code
spaces,
and
what
code
space
essentially
is
is
that
it's
a
vs
code
instance
inside
the
browser
that
is
backed
by
the
GitHub
file
system
or
the
git
file
system.
B
The
solutions
that
I
can
go,
look
at
all
right,
so
here
I'm
going
to
look
at
my
test
solution.
All
right
and
again,
my
git
repository
is
empty
right
now,
because
I
haven't
done
anything
so
I'm
going
to
create
two
folders
one
for
Solutions
and
I'm,
also
going
to
add
some
custom,
PCF
powerapps
component
framework
components
here,
all
right,
so
I'm
going
to
go
into
my
Solutions
folder
and
then
use
commands
like
pack
solution
clone
now.
This
is
my
favorite
command
pack
solution
clone.
B
It
is
doing
a
solution
to
export
under
the
covers,
but
what
it's
also
doing
is
rendering
it
as
a
as
a
cc
plus
plus
project
or
a
visual
studio
project.
Rather
so
you
can
do
things
like
dot
net
build
and
generate
the
solution,
zip
file
for
import
all
right,
so
here
I've
gone
ahead
and
now
imported
or
exported
the
solution.
So,
if
I
go
into
my
solution,
folder
I
can
see
all
this
I'm
not
going
to
impress
you
with
my
typescript
skills
but
I'm
now
going
I'm,
adding
a
custom
control
directly
into
my
solution.
B
B
Actually,
if
you
want,
you
can
now
package
stuff
directly
into
the
certification
repo,
build
your
stuff
and
just
check
it
right
in
there
for
Jocelyn
team
to
come
in
and
kind
of
start,
taking
a
look
but
I've
gone
ahead
and
now
just
committed
everything
directly
there.
In
addition,
I
can
also
use
it
on
my
machine.
So
if
you're
using
Windows
services
for
Linux
or
locally
in
your
Windows
machine,
you
can
actually
now
use
the
same
experience
again.
This
is
the
developer
experience.
I
was
talking
about.
B
I
can
do
a
net
build
and
I'm
building
on
a
Linux
container
here,
but
that's
the
experience
that
we're
talking
about
from
a
Power
Platform
CLI
and
that's
what
we
expose
directly
there
now
for
a
lot
of
you
who
are
who
are
used
to
building
custom
connectors
like
Troy
right
all
right.
This
may
not
be
a
news,
a
lot
of
news
for
you.
What
we
decided
was
the
fact
that
you
know
going
back
to
our
our
initial
foundations
and
trying
to
minimize
confusion
for
developers
all
right.
B
We
realize
look,
there's
there's
a
significant
amount
of
user
community
in
the
Groundswell
on
the
Pax
CLI
side,
and
this
is
a
significant
amount
of
user
community
on
the
PA
con
side.
Why
don't
we
just
go
ahead
and
figure
out
a
way
to
integrate
the
experience
and
also
fix
some
of
the
things
that
we
wanted
to
go
fix
in
the
first
place.
B
So
for
those
of
you
who
may
not
know
the
fact
that
the
way
PA
cons
command
line
works,
it's
a
python
command
line,
obviously,
but
it
talks
directly
to
the
par
automate
of
RP
and
what
is
the
RP
in
this
case?
That
is
the
workload
running
on
top
of
the
running.
On
top
of
the
part
platform
infrastructure
and
one
of
the
things
that
we
decided
is,
as
we
were,
trying
to
go
and
improve
the
broader
Alm
experience
or
the
application
lifecycle
management
experience.
B
We
realized
that
we
have
to
bring
in
some
of
that
logic
directly
into
dataverse
all
right.
So
one
of
the
big
difference
between
the
par
platform
CLI
implementation
of
connectors
versus
the
PA
con
one-
is
that
the
Power
Platform
CLI
talks
to
dataverse
and
dataverse.
Only
it
does
not
talk
to
the
the
RP,
in
this
case
the
the
bar
automate
RP.
In
this
context,
all
right.
The
other
thing
was
that
the
pacon
RP
was
not
necessarily
amenable
for
CI
CD.
B
So
if
I
wanted
to
go
ahead
and
build
things
like
you
know,
incorporate
create
a
connector,
build
it
and
then
push
it
directly
into
a
Target
environment.
Piacon
was
not
necessarily
amenable
for
that.
So
if
let's
say
today,
you
wanted
to
go,
build
something
and
have
a
CI
CD
process
to
put
it
push
it
into
the
certification,
git
repo,
you
didn't,
have
a
tool.
B
You
didn't
have
a
way
you
had
to
manually,
go
and
upload
things
now,
with
now
with
the
pa
Pax
CLI
capability
you're,
now
able
to
bring
some
of
those
components
directly
into
the
picture
in
that
context.
So
that
was
the
key
thing
that
we
wanted
to
go.
Do
one
was
to
melded
into
a
proper
developer
experience
as
in
integrated
inside
vs
code
or
whatever,
or
for
that
matter
you
can
even
run
a
terminal
inside
whatever
other
hacky
IDE
that
you
may
have
all
right.
B
In
addition
to
that,
you're
able
to
generate
all
the
relevant
property
files
and,
at
the
same
time,
you're
able
to
use
the
proper
CI
CD
pipeline
to
go,
deploy
in
the
various
different
environments.
Now
it
is
in
preview
and
I
I'm
going
to
probably
let
the
cat
out
of
the
bag
here,
because
we're
going
ahead
and
addressing
a
lot
of
this
stuff
on
the
dataverse
side.
B
We're
also
going
ahead
along
with
my
colleague,
Samir,
which
most
of
you
probably
know
we're
working
on
actually
bringing
in
the
notion
of
connections
also
into
dataverse,
and
we're
going
to
be
doing
a
private
preview
around
that
early
next
year.
So
this
again
further
simplifies
the
whole
idea
of
actually
deploying
connectors
and
connections.
B
So
the
reason
why
that's
exciting
is
because,
in
our
first
Incarnation
the
private
preview,
when
you
have
connections
that
don't
require
interactive
consent,
you
can,
if,
if
the
connection
does
not
exist
in
your
target
environment,
when
it
runs
through
your
CI
CD
pipeline,
it
will
create
the
connection
as
well.
For
the
connector.
B
Those
are
the
kind
of
things.
Those
are
the
kind
of
experiences
that
we're
trying
to
go
light
up
as
part
of
this
experience
and
the
PAC
CLI
is
going
to
be
the
enabler
to
go.
Do
that
all
right?
So
here's
an
example
just
like
the
the
last
one
I'm
going
to
go
ahead
and
play
this.
So
this
is
the
again
experience
as
you
can
see.
I'm
sitting
inside
my
vs
code
experience
I
have
a
Dev
and
a
test
folder.
B
So
in
this
case
one
of
my
colleagues
Marcel
he's
the
developer
in
this
case
of
a
connector.
All
right
and
I
am
the
tester,
so
to
speak,
so
I
can
go
ahead.
So
Marcel
goes
into
his
Dev
folder
does
something
called
as
Pac
connector
in
it
all
right,
and
what
that
does
is
creates
the
basic
set
of
foundational
files
that
you
need
to
kind
of
get
going.
In
this
case,
all
it
does
is
initialize
with
the
current
directory
and
creates
the
api's
properties
a
Json
file,
as
it
is.
B
If
you
have
the
API
definition
file,
whether
you
can
download
it
directly
from
the
connector
custom,
connector
you've
created
on
the
UI
or
you've
picked
up
Swagger
from
someplace,
you
can
go.
Do
that
and
then
you
can
do
a
pack
connector
create
with
the
API
properties.
We
are
going
to
add
another
property
for
the
c-sharp
code
as
well,
so
you'll
be
able
to
go.
Do
that?
That's
that's
an
update
that
we'll
probably
do
early
next
year.
B
In
this
context,
all
right
now
I've
gone
ahead
and
pushed
that
connector
directly
into
my
Power
Platform
environment.
So
now
it
shows
up,
under
my
custom,
connectors
under
dataverse.
All
right
I
have
to
still
go
create
my
connection
right.
This,
hopefully,
will
not
have
to
be
the
case
in
the
future.
All
right
we
can
test
the
operation.
As
you
can
see
the
connector,
the
connector
works
all
right
now.
What
we're
gonna
go
do
is
go
and
make
this
thing
or
go
into
our
test
environment.
B
So
this
time
around,
when
I
go
into
my
test,
folder
all
right.
What
I'm
my
test
folders
to
get
empty
I'm
not
going
to
do
a
connector
in
it
anymore?
What
I
am
going
to
do
is
I'm
just
going
to
go
download
the
connector
from
the
connector
ID,
so
I'm
just
going
to
go,
say
pack
connect
or
download
with
the
connector
ID,
and
it
will
download
the
artifacts
from
my
Dev
environment.
Remember
the
thing
that
we're
trying
to
do
is
make
sure
everything
is
consistent
across
the
board.
B
So
we
get
the
same
set
of
API
properties
and
definitions.
The
only
different
difference
that
we're
going
to
have
is
when
you
go
into
the
API
property
or
definition
rather
we're
going
to
change
the
url,
because
the
API
Gateway
that
we're
going
to
talk
to
is
actually
not
going
to
be
our
Devin
Moore.
It's
going
to
be
our
test
all
right,
because
it's
a
test.
B
We
want
to
make
sure
that
the
test
environment
maps
to
the
proper
test,
API
Gateway
in
this
case
this
happens-
to
be
the
API
endpoint-
happens
to
be
running
on
API
management.
Here,
okay,
so
I'm
now
going
to
do
something
called
this
pack.
Org
select
select
my
test
environment
URL.
Now
this
could
either
be
the
environment
URL
or
it
could
be
the
environment
ID.
B
If
you
have
access
to
either
one
of
those
things
you
can
pass
that
and
it
will
resolve
it
automatically
for
you
all
right
so
now
I'm
going
to
go
ahead
and
do
a
create
using
the
same
property
in
Json
file
in
my
test,
environment,
okay.
So
now
what
Marcel's
gone
ahead
and
done
is
connected
into
his
test
environment
and
then
created
the
same
connector
directly
in
that
context
there.
B
So
if
I
now
do
a
pack
connector
list,
I
now
get
the
list
now
again,
if
you've
gone
ahead
and
created
a
connector
with
PA
con,
remember
it's
created
in
the
RP,
so
it
will
not
should
open
path,
connector
list
until
you
add
that
into
a
solution.
Okay,
so
again
in
this
UI
we're
going
back
into
our
test
environment
here
you,
you
know
making
sure
that
the
connector
works
and
everything
seems
to
be
working
now,
there's
one
more
little
step
so
now
this
is
where
Marcel
goes
away
and
I
come
in
all
right.
B
I'm,
now
logged
into
Marcel's
test
environment.
All
right,
yes,
I'm
there
on
through
my
UI,
for
my
want
to
do
a
pack
or
goo
all
right,
I'm
now
going
to
do
a
pack
connector
list
to
see
hey.
Let
me
just
see
what's
happening
here
and
I
can
see
the
connector
ID
showing
up
here
now
within
Pac
CLI
I
have
a
canvas
command
that
can
now
create
a
dummy
application
with
that
connector
ID.
B
So
now
I
can
go
and
do
a
pack
canvas
create
and
it
will
create
an
MS
app
file
right
with
the
connector
ID.
So
now
it'll
go
ahead
and
create
this
inventory
management
app.
This
is
just
to
kind
of
get
started
to
see
how
exactly
the
connector
May
behave
in
an
app
context.
Okay,
so
now
it's
gone
ahead
and
created
that
and
it
creates
that
msap
file
locally
on
my
machine.
B
B
Show
you
the
fact
that
you
can
do
so
many
different
ways,
so
I'm
just
going
to
go,
create
an
inventory
management
app
and
instead
of
offering
something
I'm
just
going
to
suck
in
the
newly
created
msap
file.
On
my
on
my
desktop
all
right,
so
I'll
just
go
ahead
and
say:
open
browse
files,
select
that
new
Inventory
management
app
all
right
and
there
we
go,
and
now
it
shows
up
here
the
UI
gets
refreshed
and
it
creates
this
dummy
app.
B
That
I
can
you
know
I
can
either
use
this
I
can
build
upon
it,
but
the
intent
is
to
show
you
an
app
that
actually,
you
know,
shows
how
the
API
or
the
connector
would
work.
So
here
I'll
go
ahead
and
add
the
this
is
one
piece
that
we're
still
fixing
all
right,
but
you
still
have
to
go.
Add
the
connector
into
the
app
after
the
fact
after
you've
imported
it
all
right.
Once
that
is
done,
you
play
the
app
in
this
case
and
you
again
the
same
testing
that
we
were
doing
now.
B
We
get
a
much
cleaner,
nice
looking
app
rendered.
Merely
out
of
a
connector
that
we
just
created
just
just
moments
ago,
but
this
is
the
example
of
the
kind
of
experiences
that
we're
now
lighting
up
by
consolidating
a
lot
of
the
developer
experiences
going
forward,
all
right,
additional
resources
that
are
available
for
you.
There
are
plenty
of
resources
available
around
this
there's
also,
including
we
also
have
an
app
in
a
day,
exercise
that
covers
a
heck
of
a
lot
more
than
just
the
custom
connector
piece
there.
B
You
can
actually
build
PCF
controls,
do
application
registrations
and,
and
things
of
that
nature
there
as
well.
That's
pretty
much
it
from
what
I
had
from
from
my
deck.
I
know.
There
are
very
few
today:
I
can
see
the
holiday,
but
I
did
have
a
session
around
questions,
but
so
yeah
open
the
questions
otherwise
I'll
hand
it
back
over
to
Jocelyn.
D
C
B
Some
point
going
forward
going
forward.
Everything
is
so
the
reason
why,
by
by
putting
everything
inside
dataverse,
it
is
already
being
solution
aware
right.
That
was
one
of
the
things
that
was
not.
You
know
flexible
enough
in
the
RP
side.
That's
so
that
there's
a
reason
why
we
hold
kind
of
a
very
non-negotiable
stance,
saying
you
know:
paxila
will
only
work
against
dataverse
because
at
the
end
of
the
day,
for
us
to
do
things
like
Ci
CD
and
all
that
stuff
Solutions
enable
that
to
make
it
happen,
better
yeah.
A
B
So
this
is
also
setting
things
up
so
that
when
you
do
go
build
those
kind
of
custom
connectors
that
you
can
package
things
up
as
connectors
and
dump
it
into
a
catalog.
So,
for
example,
let's
say-
and
this
is
a
very
common
scenario-
that
we
see
there's
a
system
integrator,
that's
working
in
for
a
customer
all
right
and
they've
built
a
custom
connector
for
that
Customer
because
of
their
project.
B
They
can't
put
it
up
into
app
Source
or
anything
of
that
sort,
so
they
want
to
be
able
to
put
it
into
a
common
place
where
not
only
ever,
not
only
that
one
particular
customer,
but
everyone
in
that
customer
account
is
able
to
download
it.
That's
the
notion
of
the
part
catalog,
so
the
experiences
that
we're
building
here
on
the
PAC
C
live
for
even
connectors
and
PCF,
we'll
eventually
add
other
capabilities
on
Virtual
agents
and
so
on
and
so
forth
is
to
make
that
function.
A
lot
easier,
so
you'll
see
more
solution.
B
B
B
B
We
are
going
to
be
looking
at
ways
to
bring
in
your
existing
stuff,
that's
in
GitHub
to
be
able
to
make
sure
that
it
works
well
with
the
PAC
CLI
interfaces,
so
I
might
be
reaching
out
to
you
guys
to
kind
of
be
the
first
set
of
Tire
kickers
to
kind
of
give
us
feedback
so
stay
tuned.
I
have
your
names
now
so
I
will
be
reaching
out.
But
thank
you.
Thank
you
all
thank
you
so
much
and
and
merry
Christmas
happy
holidays
and
and
happy
New
Year.