►
Description
This module introduces you to the development of SharePoint Online Webhooks and Microsoft Graph Notifications as a replacement for the SharePoint Add-in model Remote Event Receivers.
This video is part of a series in a playlist about "Transform SharePoint Add-in model solutions to modern development pattern": https://www.youtube.com/playlist?list=PLR9nK3mnD-OXJLA29Q0Xk7psbAUqzQZwe
➡️ Next video on this series - https://www.youtube.com/watch?v=NOy2O1VCs9M&list=PLR9nK3mnD-OXJLA29Q0Xk7psbAUqzQZwe&index=13
⬅️ Previous video on this series - https://www.youtube.com/watch?v=a1snL_hc94k&list=PLR9nK3mnD-OXJLA29Q0Xk7psbAUqzQZwe&index=11
#Microsoft365 #AzureAD #MicrosoftGraph #Webhook #SharePointOnline
In this video, you will learn about
- Upgrading Remote Event Receivers to SharePoint Online Webhook
- Scalable webhook architecture
- Microsoft Graph Notifications
📖 All guidance content including code samples can be found here: http://aka.ms/sp/add-in/modernize/samples
✨ Presenter
• Paolo Pialorsi (PiaSys.com)
📃 Agenda
0:00 Introduction
3:06 Demo
9:25 Synchronous processing of SharePoint Online Webhooks
13:13 Asynchronous processing of SharePoint Online Webhooks via queue
17:25 SharePoint Online Webhook registration
21:05 Microsoft Graph Notifications
📝 Learn more
• YouTube playlist for this video series - https://www.youtube.com/playlist?list=PLR9nK3mnD-OXJLA29Q0Xk7psbAUqzQZwe
• SharePoint Add-in modern transformation guidance - https://aka.ms/sp/add-in/modernize
• Overview of SharePoint webhooks - https://learn.microsoft.com/en-us/sharepoint/dev/apis/webhooks/overview-sharepoint-webhooks
• Get started with SharePoint webhooks - https://learn.microsoft.com/en-us/sharepoint/dev/apis/webhooks/get-started-webhooks
• SharePoint webhooks sample reference implementation - https://learn.microsoft.com/en-us/sharepoint/dev/apis/webhooks/webhooks-reference-implementation
• SharePoint list webhooks - https://learn.microsoft.com/en-us/sharepoint/dev/apis/webhooks/lists/overview-sharepoint-list-webhooks
• Set up notifications for changes in resource data - https://learn.microsoft.com/en-us/graph/webhooks
💡 Learn more about the Microsoft 365 & Power Platform community
• Microsoft 365 Unified Sample gallery - https://aka.ms/community/samples
• Microsoft 365 & Power Platform Community in YouTube - https://aka.ms/community/videos
• Microsoft 365 & Power Platform - http://aka.ms/community/home
Sharing is caring! You are awesome! 🧡
A
A
Let
me
set
the
context
in
the
SharePoint
Elite
model
we
used
to
have
the
remote
Avid
receiver
development
model
to
intercept
events
and
happenings
on
the
SharePoint
side.
It
was
a
model
based
on
a
WCF
Windows
communication,
Foundation
endpoint,
really
tied
to
dot
NET
Framework
and
based
on
Windows
and
Microsoft
only
platform.
It
was
a
model
we
used
to
use
in
order
to
intercept
events
happening
on
the
SharePoint
side
with
a
quite
complex
implementation
technique,
because
we
had
to
know
quite
a
bit
about
how
WCF
works.
A
It
was
able
to
create
and
manage
synchronous
or
asynchronous
events.
The
synchronous
events
were
also
called
the
ing
events
because,
where
those
happening,
while
we
get
notified
and
the
asynchronous
one
was
also
called
Ed
event,
because,
where
the
events
that
were
happening
after
something
happened
already
in
a
remote
event,
receiver,
whenever
you
get
a
trigger,
you
also
get
data
and
information
about
the
target
item
for
the
event
that
got
triggered
nowadays.
A
A
You
can
create
asynchronous
events
only
so
we
can
only
be
notified
about
something
that
already
happened,
and
you
need
to
retrieve
the
data
about
the
target
items
of
the
event
by
yourself
for
security
reasons.
So
you
will
not
get
all
of
the
information
about
the
item,
but
you
will
simply
get
a
notification
that
something
happened
on
the
SharePoint
side
and
then
it
will
be
up
to
you
to
contact
SharePoint
online
and
to
retrieve
the
actual
new
data
that
you
are
interested
in.
A
This
model
is
really
heavily
scalable
and
faster
and
secure
compared
to
the
remote
event
receiver
model,
and
if
you
want,
you
can
also
use
the
micrograph
notifications
which,
from
an
architectural
point
of
view,
work
almost
like
the
SharePoint
online
workbooks,
but
with
the
micrograph
multiplication,
you
can
also
get
notifications
about
additional
items
and
not
only
about
SharePoint
related
items.
So
let
me
move
to
the
new
environment
and
let
me
show
you
how
you
can
transition
from
the
old
remote
event
receivers
to
the
SharePoint
online
workbooks.
A
So
in
this
demo
we
are
going
to
create
a
SharePoint
Online
Web
book
using
an
Azure
function
built
in
Visual
Studio
code
right
now,
I'm
in
Visual,
Studio
code
and
I'm,
going
to
show
you
how
you
can
create
such
initial
function.
So,
first
of
all,
Ctrl
shift
p
to
activate
the
common
palette
and
you
will
choose
to
create
a
new
Azure
function
project.
So
let
me
type
function
and
I
will
create
an
Azure
function.
New
project
once
I
select
this
option.
I
need
to
Target
a
specific
folder.
A
So
in
my
scenario
it
will
be
under
my
temp
folder
in
the
SPO
webbook
sample
folder,
and
then
I
want
to
use
C
sharp
as
the
language
and
just
to
make
an
example.net6
isolated,
which
is
the
long
term
supported
version.
Now,
I
have
to
choose
what
kind
of
azure
function
I
want
to
create
and
in
my
scenario
a
webwork
will
be
an
HTTP
triggered
function.
So
I
will
select
this
option
and
the
name
of
my
function
will
be
process
event
because
it
will
process
any
Web
book
event
triggered
by
SharePoint
online.
A
Then
I
will
have
to
provide
a
namespace
for
my
generated
code,
which
can
be
just
to
make
an
example,
contoso
dot
functions
and
then
I
need
to
define
the
authentication
method
for
my
function,
which
will
be
anonymous
because
we
will
authenticate
the
request
in
the
webbook
implementation,
not
relying
on
a
function
or
admin
key
in
the
query
string,
but
just
relying
on
the
actual
message
received
by
SharePoint
online,
so
select
anonymous,
now
I'm
going
to
create
in
the
current
window
disk
folding
of
the
project.
So
it
will
take
a
while
any
matter.
A
In
a
matter
of
few
seconds.
We
will
have
the
Azure
function
created,
and
here
we
are.
We
have
a
process
event
with
the
out
of
the
box
code,
just
scaffolded
now,
in
order
to
properly
Implement
them
initial
function,
which
will
handle
a
SharePoint
Online
Web
book.
We
need,
first
of
all,
as
you
can
find
in
the
article
associated
with
this
video.
You
need
to
define
a
validation
rule
which
will
take
care
of
validating
the
endpoint
of
the
webbook
when
the
registration
process
goes
on.
A
A
Whenever
you
make
a
major
function
or
in
general,
whenever
you
build
a
Web
book
for
SharePoint
online,
you
will
need
to
take
care
of
a
validation
token,
which
will
be
provided
in
the
query
string,
because
when
you
register
the
workbook
SharePoint
online
initially
will
make
a
request
targeting
your
endpoint,
providing
a
decreasing
evaluation.
Token!
That's
why,
in
the
signature
of
my
function,
I
have
not
only
the
HTTP
trigger
with
authorization,
Anonymous
and
get
and
post
supported,
but
I
also
have
the
HTTP
request
and
optionally.
A
string,
validation.
A
Token
input
argument
so
that
if
there
will
be
a
validation,
token
query
string
argument,
I
will
find
its
value
in
this
variable
inside
my
Azure
function.
Then,
if
I
have
a
value
for
the
validation
token,
what
I
simply
need
to
do
is
to
reply
back
to
SharePoint
online,
with
a
status
code,
200,
okay
and
providing
as
a
text
plane
content
the
validation
token
that
I've
just
got
from
SharePoint,
so
really
simple
and
straightforward,
and
that's
it.
We
just
reply
back
to
SharePoint
and
SharePoint
is
happy
because
the
endpoint
is
replying
back
as
expected.
A
On
the
contrary,
if
we
get
another
request
which
will
be
a
post
request
without
a
validation
token
requesting,
it
means
that
our
Azure
function
has
been
triggered
by
a
real
notification
by
SharePoint.
So
we
need
to
take
care
of
reading
the
body
of
the
request
like
I'm
doing
right
here
and
I
get
the
whole
Json
text
of
the
request,
so
that
I
can
deserialize
the
content
into
a
complex
object
which
I
defined
as
a
Web
book
notification
object.
It
will
book
notification.
A
Object
represents
how
SharePoint
will
notify
us
about
are
the
events,
so
the
webbook
notification
is
made
of
a
value
which
is
an
array
of
events,
because
the
workbooks
in
SharePoint
online
can
notify
you
more
than
one
event
at
once
with
just
one
request.
That's
why
I
have
every
single
webbook
notification
event,
which
is
made
by
a
set
of
properties,
including
the
subscription
ID
of
the
notification
and
eventual
client
state,
which
will
be
a
string
which
the
webbook
can
register
in
its
registration
and
give
me
back
whenever
it
will
invoke.
A
My
webbook
endpoint
I
will
have
information
about
the
expiration
date
time
or
the
book
The
targeted
resource,
so
the
resource
where
the
event
that
has
been
notified
happened,
the
tenant,
ID,
the
URL
of
the
site
and
the
web
ID.
So
a
bunch
of
information
to
understand
what
happened
and
where
and
mainly
where,
because
we
just
get
the
resource,
then
the
information
about
what
actually
changed
on
the
SharePoint
online
either
would
be
up
to
us
to
retrieve
it
with
a
specific
request
which
we'll
see
shortly
so
here,
I
get
my
request.
A
A
A
We
still
have
the
validation
of
the
validation
token,
which
is
always
the
same,
but
now
in
the
processing
of
the
request
body,
rather
than
just
writing
in
the
output,
the
notification
that
we
get,
we
actually
go
through
all
of
the
notification
items
and
using
the
PMP
core
SDK
Library,
which
you
can
find
properly
described
in
another
article
of
this
series
of
Articles.
We
use
the
get
changes
method
which
allows
us
to
get
all
of
the
changes
that
happened
on
a
Target
resource
since
a
specific
point
in
time.
A
Now
again.
This
is
a
good
approach,
but
there
is
a
huge
limitation
in
this
approach.
Well,
what?
If
the
processing
of
all
of
the
changes
will
take
longer
than
the
time
expected
by
the
web
books
to
run
well,
all
the
web
books
need
to
be
executed
and
need
to
give
a
response
back
to
SharePoint
online
within
a
predefined
amount
of
time,
and
if
they
will
fail,
then
the
Web
book
will
be
considered
not
affordable.
A
That's
why
you
should
not
do
processing
of
your
web
books
right
after
you
get
the
notification,
but
you
should
actually
send
the
request
to
process
the
changes
to
a
back-end
environment
which
will
do
the
actual
processing
and
in
the
webbook
by
itself.
You
should
only
process
the
notification
and
trigger
a
backend
infrastructure
to
do
the
actual
processing.
That's
why
I
am
going
to
show
you
yet
another
option,
which
is
the
most
complete
one
in
this
last
scenario,
that
I'm
going
to
show
you
the
process
event.
A
Azure
function
has
been
slightly
updated
so
that
we
still
have
the
validation.
We
still
have
the
processing
of
the
body
and
we
get
all
of
the
notifications,
but
rather
than
doing
the
actual
processing
of
all
of
the
notification
right
inside
the
Azure
function
that
got
triggered
by
SharePoint
online.
Here,
we
simply
send
a
message
in
a
queue.
A
It
will
be,
for
example,
a
blob
storage
queue
or
it
could
be
in
Azure
service
bus
queue,
but
we
enqueue
a
message
in
an
asynchronous
queue
so
that
the
endpoint
processing
the
book
would
be
really
fast
and
lightweight,
and
then
there
will
be
a
backend,
the
processing
of
all
of
the
requests.
So
here
we
have
another
Azure
function
that
I
created
in
my
function.
App.
This
Azure
function
is
called
Q
process
event
and
it
will
be
Q
triggered
and
not
any
more
HTTP
triggered.
A
It
will
look
into
a
queue
in
the
Azure
storage
account
and
as
soon
as
there
will
be
new
messages
in
the
Azure
storage
queue,
this
function
will
be
triggered
and
will
process
those
messages.
So
what
it
will
do
will
be
to
get
from
the
queue
the
message
to
deserialize
the
message
to
get
back
the
webbook
notification.
A
So
in
the
process
event,
we
simply
enqueue
as
a
base64
string
encoded
the
message
as
the
notification
that
we
get
from
SharePoint
online
and
in
the
Q
process
event
we
get
back
the
notification
and
if
we
have
it,
we
do
the
actual
processing.
So
right
here
in
the
back
end
Q
triggered
function.
We
do
the
get
changes
that
we
used
to
do
before.
In
the
previous
example.
A
Now
this
is
a
safe
way
of
working,
because
here
we
can
take
as
much
time
as
we
need,
because
we
are
running
in
background
and
we
don't
need
to
reply
back
to
SharePoint
within
a
certain
amount
of
time.
We
simply
need
to
process
the
request,
so
we
do
the
get
changes
and
we
process
the
actual
request
Plus
in
this
sample.
You
will
also
find
how
to
save
and
restore
the
change
token
so
that
you
can
actually
process
your
request
on
the
go
while
running
on
a
daily
basis,
new
changes
and
new
notifications.
A
So
every
single
time
you
will
get
a
notification
processed
by
the
back
end,
a
q
triggered
function.
You
will
get
the
last
or
the
latest
change
token,
from
a
repository
which
will
be
a
container
in
the
storage
account
in
which
we
have
also
the
queue
and
then,
once
you
are
done
with
the
get
changes
you
save
the
new
and
updated
and
latest
latest
change
token
back
into
the
Azure
storage
account
so
that
the
Azure
account
will
be
the
repository
for
the
last
and
latest
change
token.
A
How
can
we
manage
the
solution?
How
can
we
test
the
solution?
Well,
first
of
all,
I
can
run
this
project
by
pressing
F5
and
it
will
start
listening
locally
on
localhost,
because
I'm
running
it
locally
on
my
machine
and
if
we
start
monitoring,
The
Blob
storage
queue
for
new
events
to
process.
In
the
background
it
will
take
a
while
to
start
the
solution
and
as
soon
as
it
will
be
ready
here,
we
are,
it
will
be
listening
on
localhost.
However,
SharePoint
is
not
able
to
send
a
message
to
localhost.
A
Moreover,
in
order
to
do
the
actual
registration,
I
can
show
you,
for
example,
how
to
do
that
using
Postman
here,
I
have
the
syntax
you
should
use.
You
should
make
a
post
request
targeting
the
specific
site
collection.
You
want
to
register
the
webbook
on
underscore
API
web
lists,
and
you
will
provide
the
ID
of
the
list
that
you
want
to
Target.
In
my
scenario,
it
will
be
a
library
slash
subscriptions
by
making
a
post
request
to
this
endpoint
and
providing
the
reference
to
the
resource.
A
You
want
to
subscribe
to
the
notification
URL
and,
as
you
can
see,
this
is
the
public
URL
that
I
have
on
NG
rocker
rather
than
the
localhost
one,
which
will
not
work
an
expiration
date
time
for
my
book
and
eventually
a
unique
string
value
that
I
want
to
provide
back
to
my
webbook
whenever
it
will
be
triggered.
By
doing
this,
I
can
create
a
registration,
as
you
can
see
right
here.
I've
got
back
a
registration
response
here.
I
have
my
registration
for
that
specific
resource.
A
If
we
go
back
to
my
visual
studio
code
project,
we
can
see
that
right
here
we
have
the
endpoint
listening
and
there
will
be
a
validation
of
my
endpoint,
using
the
validation
key
in
the
query
string.
Moreover,
I
can
also
check
in
the
list
of
web
books
making
a
get
rather
than
a
post
request.
If
I
have
my
webbook
registered,
and
here
we
can
see
that
we
have
something
related
to
power
automate,
and
then
we
have
our
own
Web
book
already
registered
right
here.
A
So
now,
if
I
go
to
SharePoint
online,
to,
for
example,
upload
a
new
file
in
this
document,
Library,
which
is
the
one
for
which
we
registered
the
webbook
I,
can
go
here
and
I
can
upload
a
new
file
into
this
Library.
The
file
will
be
uploaded
and
within
one
minute
or
so
we
will
see
the
notification
triggered
on
the
Azure
function
side
for
the
sake
of
saving
some
time,
I
will
fade
out
and
fade
in
waiting
for
the
message
to
come,
and
here
we
are
the
message
just
came
in.
A
We
can
see
that
we
have
got
a
message
in
the
process,
event
function
and
right
after
that
we
got
the
execution
of
the
queue
process
event,
which
was
triggered
by
the
queue
message,
and
we
were
able
to
process
our
request
so
really
really
simple
and
straightforward.
What
we
get
the
message
through
the
HTTP
3,
grad,
webbook
and
Azure
function,
and
we
forward
the
request
to
the
backend
function,
which
will
do
the
actual
processing.
Now,
how
can
we
process
the
messages?
How
can
we
make
the
get
changes
and
how
can
we
get
the
context?
A
The
PMP
context,
targeting
the
set
collection?
Well,
of
course,
in
order
to
being
able
to
manage
the
solution
and
again,
if
you
want
to
dig
into
this
topic,
there
are
other
articles
in
this
series
of
articles
that
explain
you
how
to,
but
you
need
to
register
in
Azure
active
directory
application,
which
I
have
right
here.
A
If
you
want,
you
can
also
consider
implementing,
rather
than
a
SharePoint
Online
Web
book,
a
micrograph
notification.
If
that
is
the
case,
the
logic
is
almost
the
same.
This
is
yet
another
Azure
function,
project
in
visual
studio
and
in
the
Azure
function
project.
Here
we
have
the
notify
function
and
the
notify
function.
We
still
get
from
the
request.
A
In
the
query,
string
of
the
request,
evalidation
token
query
string
argument,
and
if
there
is
such
an
argument,
we
will
simply
have
to
response
back
to
graph
as
like,
as
we
did
with
SharePoint
online,
with
the
value
with
the
content
of
the
valuation
token.
On
the
contrary,
if
we
don't
have
a
validation
token,
we
need
to
process
the
request
body
and
again
as
like
as
it
was
with
SharePoint
online.
A
We
should
do
the
processing
in
a
background
task
queue
triggered,
for
example,
and
we
should
just
get
the
notification
and
forward
it
back
to
the
back
end
from
within
the
Azure
function.
Then
registering
the
Microsoft
graph
notification
is
almost
the
same
as
register
ignition
point
Online
Web
book.
So
you
need
to
call
an
API
endpoint
of
micrograph
to
register
your
subscription,
whether
you
created
a
Microsoft
graph
notification
or
ration
Point
online.
The
book
in
both
the
scenarios,
your
registration
will
also
have
an
expiration
date
time.
That's
why?
A
So,
for
example,
this
is
the
ID
we
should
Target
and
then
in
the
body
of
the
patch,
you
will
have
to
specify
an
updated
date
and
time
so
I
can,
for
example,
do
that
right
here.
I
can
specify
the
ID
of
the
registration
and
I
can
say
that
my
new
expiry
date
time
will
be
in
a
couple
of
days
from
now.
Let's
do
that,
and
here
we
are
I've,
got
back
a
tool
for
no
content,
so
the
registration
has
been
updated
and
extended.
So
you
have
to
create
a
Web
book
as
an
Azure
function.
A
That's
an
option.
Of
course
you
can
use
whatever
technology
you
like,
but
if
you
are
in
the
Microsoft
ecosystem,
it
will
most
likely
be
an
easier
function.
You
make
an
HTTP
trigger
function.
You
register
the
function
as
a
SharePoint,
Online
Web
book
or
as
a
Microsoft
graph
notification.
Then
you
can
extend
the
expired
date
time
on
the
go
when
needed,
and
whenever
you
will
get
a
notification
in
your
webbook
or
micrograph
subscription.
You
will
always
have
to
handle
just
the
basic
information
and
forward
the
actual
processing
to
a
backend
system.
A
If
the
notification
is
for
SharePoint
online
in
the
backend
system,
you
will
have
to
use
the
get
changes
functionality
to
get
the
actual
changes
to
process
in
your
backend
logic.
Here
you
can
find
additional
links.
If
you
want
to
dig
into
the
topics
we
covered
in
this
video
and
like
always
thank
you
for
watching
foreign.