►
Description
PnP Shorts Guidance video around how to update your SharePoint Framework solutions with a new version and how to ensure that all instances of client-side web parts are impacted by the update. Update process applies also on the SharePoint Framework Extensions.
A
Welcome
to
the
SharePoint
p.m.
page
short
video.
This
time
we
have
a
look
on
how
to
update
your
shape
and
frame
resolution
and
all
of
your
report,
instances
which
have
been
deployed
within
your
tenant
using
that
solution,
all
the
web
parts
and
included
in
the
SharePoint
framework
solution.
So
let's
actually
get
on
going
on
this
one.
So
what
we
have
here
is
an
existing
solution
which
such
as
created-
and
this
is
a
basically
doris-
the
box-
getting
started
with
part
solution.
A
So
what
you
get
out
of
the
yeoman
templates,
if
you
generate
the
solution
and
what
we
actually
want
to
do
is
quickly
do
a
mod
small
modification
here.
So
let
me
actually
update
that
theme,
so
you
can
actually
say
that
I'm
not
or
the
changes
what
we
are
doing
as
part
of
the
update,
so
I'm
updating
this
a
theming,
chloroquine
dark
and,
at
this
point
we're
ready
to
test
that
the
web
part
is
working
properly.
A
So
let
me
flip
back
on
my
command
line
and
we
can
do
a
cold
serve
and
double-check
how
the
web
part
is
looking
before
we
get
it
deployed
on
the
SharePoint
Online.
So
there
we
go
we're
starting
our
localhost,
we're
able
to
see
then
at
the
local
work
bench
to
start
and
if
I
put
my
web
part
on
a
page,
we
can
say
that
the
background
color
is
green
and
the
button
is
blue
and
we're
going
to
play
around
with
the
ceiling.
A
A
So
this
is
going
to
act
as
my
office
365
public's
data
allocation,
so
I'm
going
to
serve
my
static
files,
not
the
content,
just
static
files
through
the
Stadion
and
I've
already
created
the
folder
here,
which
is
going
to
host
my
JSON
manifest
file
and
also
the
JavaScript
files
for
my
web
part.
So
how
do
we
actually
make
this
then
happen
so
how
do
border
we
need
to
do
now
to
get
the
first
version
out
in
the
sharepoint
online
within
the
site
as
well.
A
This
is
where
we
define
our
CDN
URL,
so
I'm
going
to
update
that
URL
and
because
it's
a
public
CDN
configured
in
my
office,
365
that
tenant
it's
going
to
have
the
public,
CDN
prefix
and
then
my
tenant
name
and
then
the
location
to
the
folder,
which
was
the
location.
What's
it
so
within
my
tenant
good.
So
now
our
basic
setup
is
essentially
done
and
now
we
need
to
start
packaging
our
solution
for
deployment.
So,
let's
click
back
on
my
comment
line.
Let's
stop
that
coop
serve.
A
Let's
do
some
cleanup
and
let's
do
call
up
desta
ship,
so
this
essentially
makes
the
solution
ready.
It's
essentially
the
same
as
called
bundle
ship.
So
we
make
our
solution
ready
for
packaging,
and
here
we
go
we're
actually
having
that
solution
ready
to
be
getting
packaged.
The
following
step
is
to
run
gulp
package
solution
and
the
stash
ship-
and
this
is
going
to
then
essentially
take
the
URL
from
the
my
flight
manifest
and
update
that
accordingly
and
to
the
manifest
file
and
back
it's
not
to
the
SB
pkg
for
a
package.
A
So
let's
have
a
look
on
that
one.
So
how
do
I
confirm
that
I'm
ready
to
go
that
my
configurations
are
ready
and
not
sure
if
you
noticed-
and
there
was
a
SharePoint
folder
created
automatically
within
the
folder
structure
and
in
here,
if
you
extend
the
debug
folder,
you
can
actually
see
all
of
the
assets
which
are
getting
packets
on
the
SPP
katieb
file,
which
is
the
solution
packet
form
and
in
here.
A
If
I
explain
this,
one
I
can
actually
see
the
web
part
manifest
and
the
content,
and
we
can
see
that
the
internal
module
base
URL
is
pointing
to
that
CDN
URL,
which
was
updated
to
the
write
manifest
chasten.
So
this
way
we
know
that
we
are
actually
configuring
this
properly
and
we're
pretty
much
ready
to
go
to
deploy
the
initial
version.
So
food
two
things
have
to
happen.
So,
first
of
all
we
can
well.
We
can
do
these
steps
in
either
either
order
order.
A
So
let's
actually
go
back
on
our
site
and
there's
our
CDN
web
part
location.
So
we
need
to
get
the
assets
here,
so
it's
JavaScript
files
and
everything
else
in
here
and
what
are
those
files?
So
let
we
actually
go
to
my
folder
structure,
so
this
is
where
I
actually
created
the
solution
and
then
I'm
going
to
extend
at
the
temp
folder,
and
then
we
have
a
diploid
folder
here
and
these
other
assets
which
I
need
to
get
to
the
CDN.
A
So
three
assets
at
this
case
because
it's
a
relatively
simple
web
part
so
I'm
going
to
track
and
drop
those
to
be
available
within
the
CDN
and
there
we
go
now.
Our
CDN
is
essentially
ready
to
go
and
we're
able
to
start
moving
good
now.
What's
going
to
happen
next
is
that
we
need
to
get
the
amp
file
to
be
deployed
on
the
App
Catalog,
so
let's
actually
get
here
and
to
the
folder
structure
and
go
back
on
the
root
of
the
of
the
solution
in
the
SharePoint
folder
solution.
A
So
this
is
at
10:00
on
the
admin
operator
operation
or
if
the
NAVADMIN
has
given
permissions
for
somebody
else
to
access
that
catalog
to
deploy
the
assets
and
as
you
can
see,
the
URL
is
pointing
to
our
CDN
a
URL.
So
let's
click
deploy.
So
now
we
are
ready
to
go
with
the
initial
version
of
the
solution,
so
let's
double
check
that
it's
working
properly.
So
here
we
go.
I
have
a
classic
theme
site
which
is
using
the
modern
pages,
so
I'm
going
to
actually
create
or
install
the
solution
to
the
site.
A
So
let's
go
in
here
and
add
a
new
app
so
adding
an
app
from
my
catalogue.
I
can
see
that
I've
been
available
from
a
catalogue
clicking
that
one
and
that's
then
getting
this
installed
on
the
side.
So
now
this
section
might
take
a
while.
It
slightly
depends
how
the
time
jokes
are
getting
executed
on
the
server
side,
but
it
shouldn't
take
too
long
and
we're
looking
into
making
this
faster
in
the
future
as
well.
A
There
we
go
that
was
super
fast
with
the
one
refresh,
so
our
VP
updates,
as
client-side
solution,
has
been
deployed
to
this
particular
site.
Now
now
we
can
actually
use
this
webpart.
So,
let's
add
a
page
on
a
site.
Let's
call
this
page,
for
example,
update
update
demo
and
I'm,
going
to
add
that
instance
of
the
web
part
to
the
site
to
update
demo
and
there
we
go.
A
We
can
see
that
the
web
part
is
Queen
with
a
blue
button,
so
all
working
and
as
you
can
see,
I'm
just
jumping
in
the
back
of
my
comment
line,
we're
not
hosting
that
from
localhost
we're
hosting
that
actually
from
the
CDN.
So
let's
say
that
one
as
the
web
part
is
ready.
Obviously,
I
could
create
additional
pages
and
we
could
have
multiple
instances
of
this
webpart
cross,
the
tenant
and
then
mm
of
site
collections,
and
all
of
that
and
now
the
question
goes.
A
Okay,
now
I
need
to
update
this,
so
I
need
to
do
modifications
on
this
web
part.
How
do
I
make
sure
that
all
of
these
instances
which
are
available
from
the
undersides
are
getting
reflected
by
that
update?
So
let's
first
do
the
update
so
I'm
going
to
move
back
in
to
visitors
to
their
code.
Let's
actually
close
the
manifest.
That's
the
right
manifest.json.
We
don't
need
to
update
that.
That
is
correct,
but
there's
our
web
part
code.
A
So
let's
slightly
modify
this
so
I'm
going
to
just
update
the
theme
color
from
cream
different,
so
you
can
actually
save
the
change
being
reflected
whenever
the
update
is
fully
completed
and
again
we
need
to
package
the
solution.
So
essentially,
let's
go
to
the
comment
line.
Let's
run
Gollop
does
that
ship,
so
that's
going
to
again
repackage
the
solution
and
then
call
up
a
package
called
package
solution
there.
We
go
package
solution
and
star-shaped
as
well,
so
getting
a
new
version
of
the
solution
being
created.
A
Now,
let's
actually
move
into
the
folders
and
have
a
look.
What
actually
happened-
and
this
is
now
the
important
thing
to
realize.
So
let
me
go
back
on
my
root
of
the
folder
structure
tent
and
then
deploy
a
folder
and,
what's
not
interesting
is
that,
as
you
can
see,
I
have
now
four
individual
files
here,
so
you
have
three
and
the
reason
for
that.
A
So
the
clients
aren't
caching
and
all
of
that
in
a
browser,
do
not
affect
on
the
subject
and
we
will
get
served
by
the
latest
version
of
the
web
part
good.
So
now
we
need
update
these
fellows
to
our
CDN
on
our
CDN
is
in
our
web
part
in
our
tenant.
So
let's
actually
go
to
the
CDN
location.
Here
we
go.
There's
the
tree
files
and
I'm
going
to
track
and
drop
all
of
those
four
files
in
I
don't
want
to
actually
get
rid
of
any
of
the
existing
files.
A
A
So
the
next
step,
what
we
need
to
do
is
to
ensure
that
we
deploy
the
new
version
of
the
app
in
the
App
Catalog.
So
let's
actually
do
that.
So
let
me
go
back
on
my
file
system.
Let's
go
back
on
the
SharePoint
folder
solution
and
there's
my
new
version,
which
is
just
create
it
and
drag
and
drop
that
in
replace
the
existing
version
of
the
web
part
and
there
we
go.
We
are
we
have
a
new
version
available
from
the
site
and
it
is
asking
me
to
confirm
the
trust
operation.
A
Yes,
we
do
trust
not,
and
there
we
go
now
we
have
a
new
version
available
in
the
app
catalog.
So
at
this
point,
all
of
the
instances
of
that
clients
are
web
part
are
being
reflected
because
in
the
page,
we're
referencing
that
solution
packets
from
app
catalog.
So
when
we're
rendering
the
page
the
page
rendering
engine
is
realizing
the
day,
there's
client-side
web
part
available
this
web
part.
The
manifest
is
in
app
catalog
computed
reference,
the
JavaScript
files,
which
are
mentioned
in
the
Meneses,
manifest
section
and
voila.