►
From YouTube: .NET Conf 2020 - Kerala (2021-01-09)
Description
.NET Conf is a free, three day virtual developer event co-organized by the .NET community and Microsoft. This year .NET 5.0 will launch at .NET Conf 2020! Come celebrate and learn about the new release. We're also celebrating our 10th anniversary and we're working on a few more surprises. You won't want to miss this one.
This session is run by the the MobConf user group (https://www.meetup.com/MobConf/).
B
B
So
before
we
start
with
the
online
sessions,
I
would
like
to
introduce
to
the
speakers
and
what
all
the
topics
we
are
covering
and
how
the
whole
event
will
pan
out
for
the
rest
of
the
day.
The
first
talk
will
be
by
niche
anil
he's
a
senior
program
manager
with
microsoft
on
the
dotnet
team.
He
will
be
taking
the
session
on
microsoft,
visas
in
dot
net.
B
B
B
Swami
will
be
talking
about
how
you
can
make
use
of
a
grpc
and
build
sites
using
grpc
with
full
stack
applications
in
dotnet
file.
So,
regarding
the
session
and
how
you
can
interact
with
the
speakers,
you
can
use
the
chat
box
window
for
sending
your
questions
and
we
would
like
to
make
it
as
an
interactive
session.
So
if
you
have
any
questions
here,
just
shoot
it
in
the
chat
window
and
we
will
answer
it
along
the
way.
B
A
A
I
do
have
a
plan.
I
do
have
some
specific
demos
that
I'm
going
to
cover,
but
if
you
have
questions
on
microservices,
if
your
questions
on.net
feel
free
to
ask
the
questions
drop
in
those
questions
in
the
youtube
chat
window-
and
that
will
come
to
us,
so
it's
about
about
30
seconds
for
it
to
show
up
on
the
stream
yet
for
us
and
then
another
20
30
seconds
to
show
up
on
the
screen.
A
So
so
remember
that
so
we
want
to
keep
this
more
interactive
because
you
know,
I
know,
like
we've,
been
working
from
home
for
a
really
long
time
now,
so
we'll
make
it
more
interactive
because
we're
not
being
able
to
meet
in
in
person.
So
last
time
I
was
at
mob
conf
it
was
while
I
was
working
at
xamarin.
It
was
a
few
years
ago,
so
really
really
excited
to
be
with
you
all
today,
all
right.
So
this
is
about
me.
This
is
my
handle
this
channel.
A
You
can
follow
me
on
twitter
or
instagram
wherever
you
like,
so
I'm
gonna
talk
about
micro
services,
so
this
is
my.
You
know
what
I
do
at
microsoft,
like
I
manage
the
dot
net
architecture
page,
so
we're
going
to
go
into
all
of
those
details,
so
this
is.
This
is
all
the
slide
that
I
have
and
the
rest
of
the
things
will
go
hands-on.
Do
demos
answer
your
queries
and
such
right
all
right?
So,
let's
get
started.
A
This
is
a
great
place
for
all
the
information
that
you
need
from
forum.net
to
get
started
right.
So
here
you
see
something
called
as
micro
services,
so
we
built
this
specific
page
to
get.
You
started
with
micro
services.
So
what
exactly
is
micro
services
like
micro
services,
are
a
design
pattern
in
which
applications
are
composed
of
small
independent
modules
that
communicate
with
each
other
using
well-defined
contracts?
What
does
it
mean?
Well,
you
know
they
are
not
services
which
are
small,
but
they
are
services
which
have
definite
boundary
their
business
boundaries.
A
So
if
you
have
like
an
application,
you
you
actually
bring
that
break
that
into
multiple
smaller
services
managed
by
independent
team.
So
you
can
actually
scale
quickly
so
you've
seen
that
in
all
the
latest
applications
now
they're
able
to
sw,
you
know
ship
things
to
productions,
maybe
100
times
a
day
right.
So
how
do?
How
can
they
do
that
without
breaking
the
entire
application?
And
that's
because
they
follow
this
micro
services
architecture
right?
So
that's
a
design
pattern.
Now
we
talk
about
micro
services
and
containers.
A
Too,
most
often
we
speak
about
dockers,
kubernetes
and
all
kind
of
things.
Well,
microservices
architecture
does
not
tell
you
to
do
dockers
and
containers.
Dockers
and
container
tooling
itself
is
so
amazing
that
it
just
makes
the
simplicity
in
bringing
the
complexity
down.
So
that's
all
about
having
container
something.
So
it's
not
mandatory
to
start
with
dockers
and
kubernetes,
because
microsoft
architecture
is
just
the
architecture
pattern,
but
these
tools
definitely
make
it
easy
to
get
started
right.
A
So
so,
if
you're
just
getting
started
with
microservices
and
that's
what
we're
going
to
do,
we're
going
to
start
with
scratch,
we'll
start
building
a
web
api
and
then
we'll
show
you
some
grpc,
then
I
will
go
into
thai.
We
can
go
into
handling
resiliency
in
microservices
resiliency
and
core
resiliency
using
service
mesh.
So
these
are
the
things
that
is
planned,
but
really
this
is
all
about.
You
know
what
you
want
to
hear
so
feel
free
to
ask
questions
and
we
can
steer
things
out
that
way
right.
A
So
this
is,
you
can
start
from
here
like
if
your
first
time
getting
started
with
micro
services
like
how
did
it
really
get
started
right?
You
need
to
create
a
service
at
some
point,
so
you
will
start
with
something
like
a
web
api.
So
how
do
you
do
that,
like
there
are
really
well
defined
steps
out
there?
You
don't
need
widget
studio.
All
that
you
need
is
just
go
ahead
and
download
this
sdk.
So
we
go
to
this
page.
You
have
this
place
where
you
can
start
downloading,
they
go,
it
started
downloading.
A
You
just
install
it
and
that's
about
it
right
once
you
install
it,
you
just
make
sure
you
run.net,
and
then
that
is
done-
and
you
can
get
started
here
right
here,
so
we're
going
to
do
these
steps
and
you
can
see
that
these
are
running
installing
adding
docker
metadata
and
then
running
the
docker
image
and
things
right.
So
these
are.
This
is
how
you
get
started
right
once
you
are
comfortable
doing
this,
you
can
go
into
the
next
step,
which
is
about
deploying
this
to
kubernetes
right
once
you
have
the
image
ready.
A
You
need
to
ship
it
to
production
right,
so
there
are
steps
listed
out
here.
So
if
you
look
at
to
deploy
to
azure
page,
you
can
see
this
yaml
script.
That
is
that
you
need
to
create
to
make
sure
that
you
know
your.
Your
image
is
actually
available
for
kubernetes
to
consume
right,
so
there
are
well
defined
steps
out
here
and
for
those
of
you
who
are
like,
oh,
I
know
how
to
do
these
things
right
and
I
want
to
get
started
with
just
about
understanding
microservices.
A
Maybe
you
come
from
the
world
of
like
you've,
been
doing
applications
for
I
ages
together,
like
10
15
years
in
production,
and
you
don't
want
to
know
now
the
new
way
of
doing
the
the
architecture
right.
So
then
you
can
actually
choose
this
one
architecture,
guidance-
and
this
is
the
page
which
I
was
talking
about.
You
can
actually
reach
to
this
page
by
dot.net
architecture,
and
this
is
what
I
pm
on
like
we
maintain
architectural
reference
guides
for
you
to
get
started.
A
So
what
we
do
is
basically,
we
understand
from
our
customers
how
dotnet
has
been
used
in
production
and
we
kind
of
build
out
those
best
practices
for
you,
everyone
to
actually
take
and
learn
from.
So
there
are
micro
services,
devos,
modernizing,
literally
they're,
all
books.
Those
books
are
available
online
for
read,
or
you
can
actually
download
this
as
pdf
right.
So
there's
this.
So
if
you
now,
we
are
talking
about
microservices,
let's
get
into
the
microservices
world,
so
this
is
the
book.
A
This
is
one
of
our
popular
books
called
called
microservices
dotnet
microservice
architecture
for
containerize.net
applications
written
by
cesar
a
few
years
ago,
and
now
we
maintain
it.
So
if
you
go
into
this,
it
basically
talks
about.
You
know:
how
do
you
architect,
microservices?
How
do
you
do
domain
driven
design
right?
How
do
you,
you
know
start
with
docker?
How
do
you
take
care
of
security?
How
do
you
do
cqrs?
A
How
do
you
build
resiliency,
so
it
talks
about
everything.net
and
the
microservices
architecture
now
once
you're
comfortable
with
this,
and
if
you
want
to
go
and
learn.
Okay,
now
you're
ready
to
build
on
production,
and
you
want
to
choose
something
like
azure
for
your
cloud
platform.
Technically,
you
can
actually
use
any
cloud
platform,
but
we
specifically
wrote
a
book
on
azure
so
that
you
know
if
you're,
actually
looking
for
services
on
azure
like
how
do
I
actually
do
radish
on
on
azure,
then
we
actually
have
written
those
things
in
this
book
too.
A
So
you
can
actually,
as
I
said
like
you
know,
these
are
living
documentation.
So
if
you
any
point
of
time,
you
feel
that
okay,
I
think,
there's
something
here,
there's
something
wrong.
I
need
to
fix
this.
You
can
actually
go
into
this
play
this
one
called
edit
and
go
to
edit
this
document
and
feel
free
to.
A
They
are
all
in
github,
they're
all
open
source
so
feel
free
to
go
and
edit
and
send
us
the
pr,
and
we
will
be
happy
to
merge
them
right
or
if
you
have
any
suggestions,
you
know
things
feel
free
to
drop
in
the
feedbacks
nothing.
So
what
I
wanted
to
say
is
like
you
know,
this
is
a
living
documentation,
so
we
always
update
it.
We
keep
it
current
now.
The
other
thing
is
like
you
know.
I
know
when
you
start
learning.
A
You
also
want
to
get
the
big
picture
right,
so
we
also
built
something
called
as
a
reference
sample,
which
is
called
the
eshop
and
containers.
So
if
you
open
this,
this
is
the
page
github
page
where
you
have
the
eshop
and
container.
So
this
is
nothing
but
a
simple
e-commerce
application.
I
mean
it
could
be
anything.
Microservice
is
not
specific
to
e-commerce,
but
generally
you'll
see
people
talking
about
e-commerce
application
because
it's
easy
to
understand
when
you
start
learning,
because
you
know
the
domain
little
fairly
better
than
any
other
domain.
A
So
so,
as
you
see
that
you
know,
this
is
the
micro
service
architecture,
and
what
I
wanted
to
point
you
to
is,
let
me
just
increase
the
screen
a
little
bit.
Look
at
the
look
at
the
architecture
for
this
application
right.
So
you
have
the
client
application
connecting
there
is
a
web
spa.
There
is
a
general
mvc
application
and
there's
also
a
mobile
client.
They
connect
with
the
backend
services,
and
I
wanted
to
wanted-
want
you
to
pay
attention
to
the
services
how
they
are
built
up
right.
A
So
there
is
identity,
catalog
ordering,
so
you
basically
split
up
the
large
application
and
go
into
focused
micro
services.
The
most
important
aspect
about
it
is
like,
if
you
notice,
they
all
have
their
own
databases,
so
they
don't
share
a
data,
but
I
mean
database
at
all,
like
you
know,
if
you've
been
building
monolith,
applications
and
one
of
the
bottlenecks
of
the
model
model,
the
application
when
it
comes
to
scaling
is
that
you
know
database
is
common
and
you
actually
reference
data
in
terms
of
relational
tables.
A
Now
that's
a
challenge,
because
now,
when
you
want
to
ship
it
to
production,
you
want
to
make
sure
the
other
service
is
not
breaking.
So
that's
a
bottleneck
and
that's
why
you
need
to
make
sure
the
microservice
is
not
about
just
the
endpoints.
It's
all
about
the
entire
business
right
it.
You
have
to
consider
itself
as
a
independent
business
unit
itself.
So
it's
most
often
in
larger
large
companies.
They
even
actually
split
the
team
accordingly
right,
so
you
have
independent
services
so,
for
example,
catalog
service.
It
uses
sql
server
database
right.
A
So
when
you
go
to
basket
markets
microservice,
it
could
be
a
completely
different
team.
They
have
a
different
endpoint
and
they
will
decide
for
data
store
to
be
used
right
as
cache
so
that
you
know
that
autonomous
aspect
that
comes
into
this
thing.
That's
the
most
important
thing,
so
you
get
to
choose
what
technology
you
want
and
what
database
data
store
that
you
want
to
use
right
now.
A
How
do
you
communicate
with
each
other
like
service
to
service
communication
and
that's
where
you
define
well-defined
contracts
right,
so
one
service,
a
service
b
connecting
you
know,
you
may
have
a
rest
endpoint,
you
may
connect
with
a
grpc
or
you
may
completely
go
with
something
like
an
asynchronous.
You
know
messaging
patents
like
pub
submodel
and
things,
and
you
may
use
something
like
rabbitmq
or
in
production,
something
like
azure
service
bus
right.
So
you,
when
the
order
is
placed,
I'm
sure
if
you're
shopping
these
days
on
the
e-commerce
sites.
A
They
say:
okay,
thank
you
for
the
order
we'll
get
back
to
you,
because
you
know
it's
not
the
same
same
synchronous
service
so
because
there
may
be
a
notification
for
another
service
to
pick
up
and
respond,
then
you'll
see
another
notification
coming
up
like
okay,
this
has
been
processed.
We
are
shipped
and
I
think
so
that
way,
every
single
service
is
independent
right
and
how
these
services
communicate
with
each
other,
because
these
are
independent
services.
A
They
can
exist
within
the
same
cluster
or
maybe
somewhere
else,
but
how
do
they
connect
with
the
world
right?
How
are
how
do
the
clients
connect
to
this
world
is
by
using
api
gateways?
So
we
define
api
gateways
so
that
those
are
the
only
endpoints
that
are
exposed
to
the
clients
and
then
they
they
help.
You
connect
to
the
the
microservices
behind
the
scenes
right,
there's
so
many
patterns
out
here.
So
we
explain
a
lot
of
these
things.
A
So
if
you
find
information
here
which
is
not
you
know
sufficient,
you
can
actually
go
to
wiki
and
we
also
define
certain
specific
information
in
wiki.
Like
you
know,
what
is
the
pff
implementation,
for
example,
in
this
case
in
api
gateway,
we
kind
of
use
the
on
voip
proxy.
Now
earlier
we
were
using
ocelot.
Now
we
use
onboard
proxy
so
like
those
design
decisions
that
we
make
it's
also
available
for
you
to
see
in
the
wiki.
A
Now
the
other
things
that
you
probably
want
to
take
a
look
at
is,
like
you
know,
one
of
the
one
of
the
key
anti-pattern
I
would
say
for
a
micro
services
architecture
is
that
you
will
not
have
everything
in
a
single
repo,
because
right
now
in
this
repo,
if
you
go
to
srs
src
folder,
you
will
see
a
lot
all
the
services
out
here.
So
these
are
the
services
within
the
services
section.
So
these
are
the
services
independently
in
using
their
own
cs
products.
A
So
that's
why
we
made
it
into
a
single
repo
so
that
you
can
have
that
visual
studio,
experience
of
running
fi
and
all
the
services
bringing
up,
and
then
they
work
with
each
other
but
they're,
independent
in
in
terms
of
even
ci
cd
pipelines.
So
even
though
they
are
in
single
repo,
their
pipelines
are
different.
So
if
you
check
in
something
or
sorry
commit
something
into
a
catalog
folder,
only
the
catalog
api
is
built
and
pushed
to
docker
hub
right.
So
those
pipelines
are
well
defined
in
this
all
right.
A
So
we
I
think
we
got
into
too
much
of
information
right
now,
but
let's
get
back
and
we'll
talk
about
how
to
get
started
right.
So,
let's
start
with
a
simple
application.
So
right
now
I
have
dot
net
installed.
So
if
you
just
click
on
hit
on
dot
net,
you
will
see
that
you
know
there
is.
You
can
actually
go
and
say
dot
net
version.
So
I'll
tell
you
what
version
I'm
running
on
right.
A
So
now,
if
you
want
to
get
started,
you
can
actually
hit
dot
net
new
and
say
hit,
and
this
is
what
we're
good
with
right.
We
give
you
templates
to
get
started
so
that
you
don't
have
to
do
everything
from
scratch.
So
in
my
case
for
every
micro
service,
you
need
an
end
point
for
the
services
to
connect
either.
The
client
connects
to
you
or
another
service
connects
to
you
right.
So
there
are
multiple
endpoints
I
can
create.
A
A
So
that's
going
to
create
a
template
for
you
with
web
api.
So
if
I
open
that
and
register
your
code,
you
can
see
that
I
have
this
hello,
kerala
application
right
here.
There's
a
startup.cs
there's
a
program.cs
right
and,
most
importantly,
there's
a
weather
forecast
controller
right
here.
A
Let
me
add
this
yeah,
so
this
is
where
it's
like.
This
is.
This
is
something
which
comes
free
right,
which
is
basically
a
random
value
of
weather,
because
we
want
to
show
you
how
to
write
it.
So
you
write
a
controller
and
then
you
have
the
get
method
exposed
as
a
http
get
and
then
it
just
you
know,
runs
as
an
endpoint.
Now,
let's
run
this.
So
if
I
go
into
run
command,
so
you
can
see
that
it
says
start
debugging.
A
So
it's
going
to
run
so
I
did
not
do
any
code.
I
just
simply
run
so
it
just
opened
up
here,
so
you
can
see
that
all
right,
there's
nothing
on
here.
That's
because
this
is
an
endpoint
and
we
only
have
a
weather
forecast
endpoint
right,
but
you
know
we
can
also
have
a
swagger
definition,
so
you
can
actually
go
to
any
application
that
you
create
now
using
web
api,
basically
the
dot
net
web
api.
We
add
swagger
by
default
to
your
application.
A
So
that
way
you
don't
have
to
really
worry
about
adding
this
to
yours
yourself.
So
this
is
the
weather
forecast
endpoint
I
was
talking
about,
so
we
can
hit,
try
out,
execute
and
there
you
go.
That's
the
random
weather!
That's
coming!
That's
a
json
data!
That's
coming
back!
We
can
actually
run
this
directly
as
well
on
the
browser.
So
I
can
copy
this
code
from
here
and
hit
on
the
browser
there.
You
go.
That's
the
random
value!
Every
time
I
refresh
this,
there's
a
new
value
that
comes
up
right.
So
that's
a
simple
pair!
A
Now,
let's
take
this
to
the
next
step,
so
how
I
want
to
dockerize
this
or
before
that
doing
that.
Let
me
show
you
something
like:
where
am
I
executing
this
right
so
because
acetone
gives
this
nice
dependency
injection?
So
we
also
inject
the
logger
when
you
need
it,
so
we
can
actually
log
this
information.
I'm
going
to
use
this
logger
dot
log
information
here
and
basically
we
want
to
know.
Where
is
this
thing
running
so
I
couldn't
say:
enronment
voice
version
dot
watching
string.
A
So
I
want
to
see
where
am
I
running
this
application
right,
so
I
can
now
put
a
breakpoint
in.
I
want
to
see
how
start
not
running
this.
So,
let's
hit
the
button.
Now
I
go
to
the
weather
forecast
and
there's
a
breakpoint
hit
and
there
you
go
so
the
washing
stream
says
microsoft,
windows,
nt,
10.0,
nothing,
fancy
here!
This
is
great.
You
know
that
is
running.
On.Net
is
running
on
windows,
but
now,
let's
take
it
to
the
next
level
right.
So
now
we're
going
to
add
it
add
docker
to
this
you
so
anytime.
A
You
want
to
actually
kind
of
like
create
an
image
out
of
it
and
then
ship
it
to
production,
something
like
kubernetes.
You
want
to
create
a
docker
image
out
of
this,
so
to
do
that
now,
how
do
we
go
and
do
it?
There
are
multiple
ways
to
do
that,
but
the
easiest
way,
if
you're
using
vs
code
is
use,
ctrl
shift,
p,
add
docker
files
to
workspace.
That's
all
you
need
to
do
and
now
it'll
ask
you:
okay,
what
what's
the
platform
that
you're
running
on
so
that's
dot
net
core
and
now
you
can
choose.
A
Do
you
want
to
run
on
linux
and
windows?
You
know
that
dot
net
is,
you
know,
cross
platform.
It
works
on
all
these
operating
systems.
So
now
I
can
choose.
I
want
to
run
this
on
linux
and
it'll.
Tell
you,
okay,
what
posts
do
you
want
to
expose?
I
will
go
just
keep
it
default.
Atn
443,
which
is
http
and
https,
just
leave
it
there
and
then
it'll.
A
Ask
me:
okay
do
do
I
want
to
include
docker
compose
file
which
in
my
case,
no
because
I'm
just
working
with
a
single
service
right
now,
but
in
if
you
want
to
use
like
you
know,
run
multiple
services.
You
can
actually
use
docker
compose
as
well.
So
what
this
is
going
to
do
is
it's
going
to
do
only
two
things:
one:
it's
gonna
involve
a
docker
file
and
then
it'll
also
add
a
docker
ignore
file
to
the
folder.
So,
basically,
what
docker
file
defines
is,
basically
it
tells
docker.
A
How
does
this
project
build
it
into
an
image?
So
that's
what
we
define
so
by
default.
Everything
is
generated
for
you,
so
these
are
commands
to
docker.
So
we
say
okay
in
in
darker
generally,
what
happens?
Is
you
create
an
image
right?
So
in
your
image,
you
can
say:
what's
your
base
image
like
you
can
say,
okay,
this
is
my
base
image
from
this
image.
A
I
want
to
create
my
image,
so
that's
why
you
don't
have
to
literally
explicitly
say
what
operating
system
you
want
to
use,
because
the
base
image
would
have
already
had
them
at
as
their
their
reference
in
that
image.
So,
right
now,
in
this
case
I'm
having
the
runtime,
which
is
asp.net
5.0,
I'm
also
doing
one
more
thing
is
I
don't
want
to
build
this
image
right
here,
so
I
want
to
build
it
right
inside
the
docker
image
itself.
A
So
I
want
to
have
this
darker
docker
container
and
I
want
to
build
my
source
code.
I
want
to
copy
the
source
code
into
the
container
and
then
build
it
right
inside
that
right.
So
these
are
the
commands
that
will
do
that.
Now,
we'll
not
go
into
the
details
of
it.
You
can
see
that
you
know
it's
just
simple.netbuild.netrestore.netbuild.net
and
then
basically,
when
you
want
to
execute
it
like,
like,
you
know
something
like
a
docker
host
when
it
has
to
run
your
application.
A
It
needs
an
entry
point,
so
we
are
going
to
say
okay
dot
net
and
this
dll
that
just
created
that's
going
to
be
my
entry
point
to
this
application.
Fine,
so
we
will
leave
it
there
now.
What
we're
going
to
do
is
we're
going
to
run
this
right
so
now,
if
you
go
to
the
run
command
now,
instead
of
docker,
I'm
going
to
say
sorry
instead
of.net
core,
I'm
going
to
use
this
something
called
docker.net
code
launch.
So
that's
the
run
time.
I'm
going
to
use
I'm
going
to
say
start
debugging
all
right!
Remember!
A
I
also
put
a
breakpoint
and
before
doing
that,
make
sure
you
have
docker
running
so
in
my
case,
I
do
have
the
docker
running.
You
can
see
this
so
docker
is
running
so
now
it's
the
browser
should
be
up,
so
you
can
see
that
this
now
it's
no
more
from
the
5001
port.
This
is
the
random
port
generated.
A
And
hit
my
break
point,
see
I'm
able
to
debug
right
inside
the
docker,
and
you
can
see
the
version
string
now.
It
says
unix
4.19,
because
now
we
are
running
it
on
the
docker
image,
which
is
running
unix
under
the
hood.
That
is
cool
right,
so
you
can
see
how
your
code
is
cross-platform
now,
which
is
great.
So
if
you
there
are
a
few
more
toolings
that
I
I'll
show
you
how
things
are
working.
B
A
So
here
it
is,
there
are
nice
storing,
so
you
go
and
install
this
docker
extension
in
vs
code
and
it'll.
Give
you
these
nice
tooling,
and
there
are
there,
are
tooling
in
via
visual
studio
as
well
that
you
can
use
right.
So
these
are
individual
containers.
Let
me
see,
where
is
my?
What
did
we
name?
It.
A
A
I
think
I
just
need
to
run
it.
Maybe
so
let's
go
and
run
this
file
for
now,
so
that
I
know
exactly
which
one,
because
sometimes
it
just
puts
this
sha
values,
and
I
have
no
idea
what
it
is.
Okay,
there,
it
goes
yeah
there
you
go
this
one,
so
you
can
see
inside
this
there
is
files
and
whatever
we
wrote
in
the
docker
file
we
have
this
app
and
which
is
where
we
actually
asked
it
to
copy
it
and
from
the
bin.
A
Folder
is
when
it'll
run
the
dot
net
run,
not
this
one,
this
one
and
then
there's
also
source
folder,
where
we
actually
copied
it
to
build
it
right.
So
that's
also
there,
okay,
so
that's
pretty
cool.
Now,
once
you
build
it,
let
me
stop
this
once
you
build
it,
how
does?
How
do
you
actually
ship
it
to
production?
So
now
the
image
is
because
it
becomes
immutable.
So
now
it
has
to
be
kept
somewhere,
something
in
in
real
time.
A
Like
I
mean
if
you
have
used
ftp
servers
and
things
before
during
the
olden
days
when
we
used
to
ship
application
web
application
using
an
ftp,
we
could
deploy
there
right
now
with
docker.
You
basically
have
a
container
registry,
so
you
have
to
do
a
docker
push
to
continuously.
A
In
my
case,
I
have
docker
hub,
so
I
can
go
and
use
commands
like
docker
push
name
it
like
basically
tag
it
and
push
it,
and
in
my
case
I
have
this
my
personal
one,
which
is
national,
and
this
is
where
we're
going
to
push.net
sorry
docker
push,
and
we
will
have
this
image
running
right
inside
this
now
within
your
kubernetes
file.
You
can
say
this
is
my
docker
hub
or
the
container
registry
and
then
the
image
name
with
the
tag
and
it'll
it'll
know
how
to
pull
that
image.
A
So
that's
how
things
work
right,
so
that
makes
this
building
making
it
immutable
and
shipping
easier
right.
Okay,
this
is
this
is
fine.
So
let's
go.
I
have
to
the
next
step.
A
Do
I
have
any
questions
now?
Okay,
nothing
right!
Now,
all
right!
So
that's
about
getting
started!
Docker
containerizing!
Just
about
getting
started
with
micro
services
right
now,
there
are
a
few
things
like
you
know.
Web
api
is
basically
the
standard
way
of
doing
things.
Everybody
uses
it
and
it's
it's
very
well
known,
but
the
newest
form,
in
terms
of
you
know,
services
or
creating
service
endpoints
is
grpc
right.
It's.
Basically,
there
are
many
rpc
framework.
This
remote
procedure
called
frameworks
out
there,
but
grpc
has
become
the
popular.
A
It's
cross-platform,
it's
part
of
the
cncf
foundation,
so
it
has
become
the
de
facto
kind
of
like
you
know,
rpc
framework
out
there,
so
everyone
works
on
grpc
they
these
days
because
it
has
profile
as
a
contract
and
service
to
service
communication
happens
easily
with
the
profile
it's
cross-platform,
so
that
you
are
something
built
on
go.
It
can
work
with
something
on
built
using.net,
so
it's
pretty
straightforward
and
and
and
the
protocol
I
mean.
A
Basically,
the
entire
data
is
being
transmitted
in
binary,
so
it's
much
more
faster
than
the
json
and
the
text
and
serialization
on
the
on
the
rest,
client,
they're,
more
readable
for
humans.
But
when
it
comes
to
you
know,
grpc
they
are
more
machine
oriented.
So
it's
for
not
human!
So
that's
why
you
need
great
tooling
support
to
get
started
with
grpc
and
that's
pretty
much
what
I'm
going
to
show
you
today.
A
So
I'm
going
to
create
a
new
project
and
start
with
grpc,
so
you
can
actually
come
here
and
search
for
grpc.
So
this
is
the
grpc
service
click
next,
so
yeah,
pc
service
4
is
fine.
I'm
going
to
leave
it.
There
start
creating
it,
I'm
going
to
use
dotnet
5.0
to
start,
that's
also
good.
Let's
hit
create,
and
this
is
going
to
start
creating
the
web
project.
There.
C
A
Yeah
very,
very
good
question
and
I'll
get
to
that
jason
I'll
park.
Your
question
for
some
time
because
we're
just
getting
started
space
and
we'll
go
into
the
details
of
you
know
managing
transactions
saga
pattern.
There
is
so
many
things
like
that.
Actually,
actually
let
me
show
you
that,
like
you
know,
I
suggest
you
to
see
how
we
do
that
too.
Like
eshop
and
containers
is
a
good
example
like
you
know,
it
has
a
couple
of
things
like
that.
You
know
doing
a
transaction,
compensating
transactions
and
other
things
like
that.
A
So
I'll
show.
You
remind
me
to
show
this
to
you
at
the
end
of
the
end
of
the
talk
like
we
do
have
written
these
things
in
the
in
our
documentations
and
guidances.
A
So,
okay,
let's
talk,
let's
come
back
to
grpc
and
the
reason
why
I
did
not
want
to
take
that
question
is
because
you
know
a
lot
of
you
who
are
getting
started.
Probably
can
get
confused
with
the
transaction
statement,
because
it's
slightly
on
the
advanced
side
of
things
all
right.
So
so
that's!
This
is
grpc
service
that
gets
generated
here.
So
you
can
see
that
there's
a
profile
which
is
create,
and
this
is
what
defines-
and
this
is
basically
language
neutral.
This
is
not
c
sharp.
A
You
can
see
in
the
startup.cs
we
have
this
configure
endpoints,
so
we
just
now
we
have
with
5001,
let's,
let's
go
and
hit
this
page
right.
So
if
you
go
into
the
browser
with
this
page
that
says
communication,
the
grp
is
in
points
must
be
made
through
grpc
client.
That's
what
I'm
saying
it's
not
for
human
readable,
so
we
don't
have
any
swagger.
We
don't
have
any
endpoints
that
we
can
see,
so
it
has
to
communicate
with
the
client
using
well-defined
profiles.
A
So
now
I'll
show
you
the
tooling
involved
in
this
to
how
to
create
this
right.
So
now
we'll
go
and
create
a
new
application
as
a
grpc
client,
new
project,
I'll
just
create
a
console
application.
You
can
pretty
much
create
anything
and
because
I'm
using
grpc
service
for
I'm
going
to
copy
this
and
make
this
into
a
client.
A
So
now
I
have
this
grpc
client.
What
I'm
going
to
do
is
I
want
to
reference
this
right,
so
the
multiple
ways
to
do
that
is
like
telling
the
client
to
actually,
basically,
you
know,
build
my
service
client
from
a
profile,
so
I
can
actually
point
it
to
this
profile.
So
I'm
going
to
add
service
ref,
I'm
going
to
click
on.
I
click
on
the
project
and
say
add
service
reference,
so
add
service
reference.
A
Right
now
here
and
now,
I'm
going
to
say
grpc
by
the
way
you
can
do
this,
for
even
the
you
know,
open
api
like
the
swagger
like
as
long
as
there's
a
swagger
definition,
it
can
also
create
a
client
for
you
from
there
from
that.
So
right
now
this
is
grpc.
So
here's
file.
So
if
I
have
a
url,
a
general
one,
one
of
the
things
that
we
do
that
in
eshop
and
containers
is
basically
we
also
expose
protofile
as
a
endpoint
like
you
know,
you
hit
slash
proto
and
it
gives
you
the
protofi.
A
That's
a
good
way
to
actually
expose
it
as
well,
so
that
you
know
what
contract
you
want
to
work
with,
but
in
this
case
I'm
going
to
use
the
file.
So
I'm
just
going
to
navigate
to
the
grpc
service
for
produce
greet.proto,
open
and
then
now
I
want
to
choose
what
I'm,
what
are
my
generating,
I'm
actually
generating
a
client.
So
I'm
from
this
protofile
I
want
to
define
a
client
from
it
right.
So
I
click
on
finish.
So,
what's
going
to
do?
A
A
Okay,
so
I
just
changed
the
main
method.
Now
you
can
see
that
there's
grpc
channel,
so
I
need
the
grpc
net
client.
I
can
see
greater
what
is
greater
right.
So
if
you
go
into
the
definition
of
it-
and
this
is
what
I
wanted
to
show
you-
this
is
an
auto
code.
So
from
the
protobuf
file,
we
actually
created
a
client
code
for
you
and
that's
why,
and
this
is
a
generated
code,
so
you
don't
have
to
worry
anything
about
it,
don't
go
and
edit
it
you
can.
A
It
gets
regenerated
whenever
you
just
basically
go
and
change
the
profile
all
right,
so
that
becomes
easy
now,
when
you're
actually
connecting
it
has
this
method.
So
if
you
go
to
the
grid.proto,
it
has
this
method
called
say:
hello.
It
which
accepts
hello
request
and
it
responds
with
a
hello
reply,
so
these
are
hello
requests
in
our
response
right.
This
is
defined
to
us
by
the
service.
A
So
when
we
created
the
client
it
auto
automatically
knows
you're
actually
connecting
you
know,
you
want
to
connect
because
basically
it's
a
method,
so
it
becomes
a
method
right
and
then
you
have
the
channel.
You
basically
say
what
channel
in
this
case,
I'm
hard
coding
it
to
5001
because
we
are
running
it.
Otherwise,
you
can
actually
run
it
from
the
configuration
or
you
can
inject
it
during
your
ci
process
and
that
kind
of
things.
A
So
you
have
the
greedy
client,
say
hello,
async
and
now
it
remember
it.
It
takes
a
parameter
which
is
the
hello
request,
so
we're
actually
defining
it,
and
now
we
basically
want
to
go
to
console.writeline
and
response
message
now.
What
exactly
is
response
message
and
that's?
Why
that's
why
we
want
to
go
back
to
the
services
go
to
the
greater
service
here,
so
this
is
what
it
does
basically
takes
a
request,
and
it
just
adds
hello
to
that
request.
That's
that's
all
it
does
right.
A
So
now
you
can
see
that
you
know
how
I'm
pretty
sure
if
you're
coming
from
the
wcf
world,
it
will
look
very
very
familiar
to
you,
but
wcf
was
very
specific
to
windows,
but
grpc
is
not
grpc's
platform
and
that's
why,
if
you
have
applications
running
on
wcf,
we've
written
a
specific
book
on
how
to
put
your
wcf
application
to
grpc.
So
I
should
I
mean
I
encourage
you
to
go
check
that
out
all
right.
So
now
this
is
all
working.
So
let's
run
this,
I
hope
it's
working.
A
We
build
the
client
bill.
Okay,
so
it's
client.
A
A
A
A
Code
because
the
target
machine
actually
refused
it
that's
funny.
Why
is
that?
Okay,
that's
probably
because
it
was
using
the
port.
Let's
see,
or
did
I
make
any
mistake,
I
think
I
made
some
mistake.
Hang
on,
let's
see
what.
A
And
okay,
there
you
go
response:
hello.net
conf,
so
that's
working,
fine
cool,
so
you
got
the
message
right.
So
how
do
you
build
grpc?
The
great
tooling
support
that
you
have
so
let's
switch
gears
and
we'll
talk
about
thai
now,
so
you
know
when
you
build
like
microservices
you're,
technically,
not
working
with
single
services
right,
that's
where
we're
going
to
the
next
step,
which
is
when
you
want
to
work
with
multiple
services.
So
let
me
go
back.
I
have
this
the
code
which
has
the
backend
and
front
end.
A
So
if
I
want
to
basically
have
a
backend,
which
is
nothing
but
this
weather
api-
and
I
also
built
a
front
end
for
it,
so
that
it
connects
and
shows
those
displays,
those
things
right.
So
if
I
want
to
run
this,
I
can
go
to
cd
backend
dot
net
run,
which
is
what
is
going
to
happen
now
and
I
will
open
another
page.
A
So
another
tab
go
to
the
front
end
and
then
just
say
dot
net
run
they
both
will
be
running.
So
this
is
running
on
finance:
zero,
zero,
zero,
one,
zero
one
port
so
front
end!
That's
what
I'm
concerned
about
so
let's
go
to
the
con
finance
zero
three.
So
I'm
just
going
to
copy
this,
go
to
my
browser.
A
Put
that
then
there
you
go
so
we
have
the
frontend
page.
I
go
refresh
so
every
time
I
hit
refresh
you
can
see
that
how
it's
going
and
connecting
to
the
backend
and
getting
the
data
from
the
backend
services
right.
So
that's
the
same
weather
forecast
that
you
saw
and
it's
just
putting
a
nice
ui
to
it.
A
A
tie
is
amazing
because
it
ties
things
together.
So
all
that
I
need
to
do
is
let
me
clear
this
page.
So
this
is
my
back-end
and
content.
I
have
a
solution
file,
so
I
can
just
say,
tie
run,
that's
all
you
need
to
do
right,
so
it
just
goes
and
actually
looks
at
your
solution
file
and
then
actually
find
cs
projects
and
it's
going
to
run
it
for
you,
and
it
also
gives
you
this
nice
dashboard.
When
you
talk
about
microservices,
it's
all
about
amazing
dashboards
right.
A
So
we
get
we
get
this
nice
dashboard
with
which
yes
make
this
bigger
less
likely.
A
So
you
have
the
logs.
So
you
can
see
that
you
know.
If
you
go
to
the
front
end,
it
also
gives
you
the
metric.
What's
your
net
code
looks
like
it'll
also
give
you
logs
like
when
it
started.
These
are
the
logs
that
hash
now,
and
it
also
gives
you
urls.
Now
you
see
that
it's
no
more,
the
finance
zero
one
or
financial,
two
that
we
created
it's
actually
completely
different
one.
A
That's
because
tie
is
looking
at
your
port
in
your
in
your
system
and
giving
you
a
port
that
is
available
to
you
right.
So
now
I
can
go
and
hit
the
front
end
application
and
let's
see
what
happens
there,
you
go.
It's
aired
out
right.
Why
is
that?
Because
it's
actually
trying
and
looking
for
localhost
finance
zero
one
which
is
no
more
available
right.
So
let's
go
and
fix
this,
and
you
can
easily
fix
this
by
stop
hard
coding
right.
So
let
me
open
this.
A
Okay
open
this
code
in
code
folder
and
while
I'm
doing
that,
I
can
also
do
a
tie
run
use
watch
so
that
I
don't
have
to
redo
this
all
the
time.
Okay,
now
I
have
the
back
end
and
front
end.
Remember
it
was
actually
connecting
to
the
front
end,
so
you
can
go
and
look
at
the
place
where
actually
it's
hard
coded.
So
here
we
go
so
it's
actually
hardcoded
to
finance
zero
one.
So
I'm
going
to
comment
this
out
and
then
uncomment
something
called
as
configuration
that
gets
service
uri
back-end.
Now.
A
What
is
this
back-end
remember
when
we
went
back
to
the
dashboard
which
I'm
going
to
open
this
here
again,
so
this
service
name
that
you
have
by
default?
Actually
thai
is
using
your
cs
project
name.
So
that's
what
you
need
to
define.
So
that's
why
it
says
backend
right
to
enable
this
get
service.
Url
method,
which
is
an
extension
method,
you
will
also
need
another
thing
in
the
cs:
proj
file,
which
is
microsoft,
tyextensions.configuration,
and
that
will
ensure
that
you
know
it
will
pick
up
the
right.
A
You
know
value
from
your
configuration
of
time,
which
we
will
see
it
in
a
bit.
So
I
just
saved
that
now.
If
I
go
to
the
dashboard
and
then
go
back
and
there
you
go,
we
are
back
in
the
application
it
started
building
now
right,
so
we
fixed
the
service
discovery.
Now
now,
let's
go
and
add
a
few
things
right:
every
single
service
out
there
will
work
with
some
data
store.
A
A
You
don't
have
to,
because
you
can
actually
also
work
with
docker.
You
can
work
with
redis
containers
right.
So
that's
what
I'm
going
to
do,
but
for
that
I
need
to
tell
tai
that
I
need
radish
and
how
do
I
define
that?
So
I
just
all
that
you
need
to
do,
is
use,
tie
and
then
use
this
command
called
tie
init.
You
can
actually
very
well
do
this
much
before
what
this
is
going
to
do
is
actually
going
to
give
this
yaml
file,
which
is
the
configuration
time
so
by
default.
A
This
was
given
to
you
when
you're
doing
tire,
and
it
was
looking
it's
sln
file
and
it
knows
what
cs
plots
to
run.
It
is
doing
that,
but
now
we're
actually
decorating
it
explicitly
saying
what
you
know:
services
that
we
want
to
work
with
right.
So
now
I'm
going
to
copy
and
paste
some
code
because
we
want
to
work
with
redis.
So
let
me
just
quickly
go
into
my
notes
here.
A
So
I'm
gonna
add
this.
This
is
all
I'm
saying.
Is
it's
gonna
to
be
redis
and
you
see
it's
no
more
cs
proj!
It's
not
I'm
not
saying
project.
It's
now,
I'm
just
going
to
say
I
need
an
image
called
radish
and
what
port
do
I
want
to
run
on
6379,
that's
all
and
then
the
cli
for
some
debugging
purposes.
So
let
me
leave
that
there
and
how
we're
going
to
connect
to
is
basically
host
name
and
the
port
name.
What
will
happen
is
redis.
A
Colon
6379
will
be
your
end
point
that
your
application
is
going
to
connect
to
now
when
you're
running
it.
If
you
just
when
the
docker
image
is
running,
you
can
actually
say
redis,
colon,
6379
and
you'll
be
connect
you'll,
be
able
to
connect
to
radius.
Now
what
I'm
doing
is
I'm
actually
implementing
in
implementing
this
in
my
back-end.
So
if
we
go
into
my
startup.cs,
so
you
can
see
that
right
now,
I'm
picking
the
connection
string
from
redis.
So
I
do
have
this
thing.
Ins
written
already
add
stack,
exchange
radius
cache.
A
So
this
is
what
you
would
be
using
if
you
want
to
use
reddishwith.net
for
that.
You
also
need
a
nuget
package
called
microsoft,
extensions,
caching,
dot
stack
exchange
radish,
so
you
can
use
that
and
I'm
also
going
to
implement
this
right
so,
instead
of
actually
having
this
random
get
string
that
gets
generated,
I'm
gonna
stop
this
and
sorry
comment.
This
I'm
gonna
have
a
new
method,
so
you
can
see
that
this
is
my
new
method.
So
this
is
another
demo
we'll
keep
this
commented
for
now.
A
This
is
the
same
get
method,
but
I'm
actually
actually
taking
the
cash
implementation
into
it.
So
because
we
added
the
ad
ready
stack
cache,
we
will
also
populate
this.
I
distributed
cache
to
be
redis
cache
right,
so
now
what
it
does
is.
Basically,
it
basically
creates
a
caching
technique
where,
for
five
seconds
it's
gonna
keep
the
cache
and
when,
after
five
seconds,
the
cache
will
be
expired
and
it'll
just
go
and
just
generate
this
random
number
again
great
right.
That's
all
I
need
to
do
and
let's
hope
this
all
works.
A
A
Here
refresh
this,
so
you
can
see
that
now
not
just
tie
build
the
backhand
front
end,
but
it
also
pull
the
radius,
but
look
at
this
redis
is
basically
a
container,
so
it's
running
inside
a
container.
So
it
knows
how
you
need
to
connect
to
this,
so
this
is
the
port
that
is
exposed.
Now,
if
you
go
to
this
application
as
long
as
you
widen
up
the
code
correctly,
so
you
can
see
that
now
it
directly
works
with
the
radius.
So
wouldn't
wasn't
it
easy
doing
that?
A
So
basically
time
makes
you
know
development
easy
with
whenever
you're,
starting
with
microsoft
bases,
because
you
will
have
bunch
of
micro
services
that
you
have
to
work
with.
All
that
you
need
to
do
is
just
just
tie,
run
and
define
entire
email
right.
So
let's
do
one
more
thing
on
this
thai
ammo
right,
we'll
go
and
add
something
called
an
extension.
So
let's
say:
if
I
want
to
work
with
some,
you
know
extensions
like
zipkin
for
distributed
tasting.
A
A
And
I'm
going
to
add
name
and
I'm
just
going
to
say:
zipkin,
that's
all!
Okay,
let's
see
if
this
is
going
to
work,
because
sometimes
it
could
be
the
yaml.
If
you
don't
do
it
properly,
it
can
actually
create
mess.
Okay,
so
you
can
see
that
there
is
zipkin
also
has
been
pulled,
which
is
great
and
let's
go
back
to
the
dashboard
here
refresh
this
page
there
you
go
there's
zipkin
as
well
right,
which
was
very
cool.
A
So
now,
if
I
just
go
to
the
zipkins
endpoint
941
by
default,
run
query
you
can
see
how
our
application
is
running
right,
so
it
can.
It
can
also
show
you
how
long
does
it
take?
You
know
front
end
has
connected
to
back
in.
You
can
see
this
information,
which
is
very,
very
useful,
and
we
didn't
do
anything
we
just
added
zipkin
to
it.
There's
one
more
thing
by
the
way.
A
A
The
program.cs
yeah,
this
is
the
code.
You
have
to
set
the
default
id
format
to
the
w3c.
That's
all
you
need
to
do.
You
need
to
know,
and
rest
of
all
is
taken
care
for
you,
so
zip
can.
When
this
zip
can
measure
it,
it
will
basically
send
those
values
into
this
into
zipkin
all
right.
So
that
was
easy,
so
we
did
that
too.
So
how
much
time
do
we
have?
We
do
have
10
minutes
and
do
we
have
any
more
questions.
C
A
Yeah,
so
it
is
again,
you
know
using
database
data
is
not
shared
it.
Basically,
one
service
is
querying
the
data
to
the
another,
so
you
can
actually
one
service
can
connect
to
the
other
service
and
ask
for
the
data
what
it
needs
to
process
it.
So
that's
how
you
work,
you
don't
share
data.
You
will
never
share
databases,
so
that's
the
key
thing.
So
the
way
to
do
that
is
two
things
we
have
endpoints,
so
you
can
use
synchronous
call.
A
So,
for
example,
when
the
basket
is
play
you're
making
an
order
and
from
the
basket
you
basically
can
tell
order.
Hey
here
is
the
data
that
I
need
to
process
it.
So
give
me
this
information,
or
you
can
actually
synchronously
send
in
case
of,
for
example,
when
the
order
is
placed,
the
order
can
actually
say
basket,
hey
basket.
This
order
has
been
placed
just
remove
it
from
your
basket
and
basket
will
go
and
do
the
removal
thing
so
that
that
is
how
it
works,
and
you
won't
share
the
data
between
the
services.
A
Sometimes
you
probably
want
to
keep
the
data
like,
for
example,
a
search
service
right.
So
a
searching
service
will
have
to
work
with
multiple
services
to
get
these
queries,
so
instead
it
can
also
keep
a
materialist
data,
like
a
meticulous
view,
pattern
right.
So,
where
you
have
all
the
data
you
know
cqrs.
Basically,
so
you
basically
create
all
the
data
that
is
needed
for
your
service.
You
don't
which
you
don't
have
to
query.
A
You
can
keep
it
in
your
databases
that
that
means
it's
a
duplication
of
data
and
which
is
totally
okay
because
from
the
distributed
computing
world,
it's
about
you
know,
availability
of
data.
It
is
so
you
should
always
have
the
data.
So
you're,
not.
You
know
worried
about
the
network
and
the
breaking
kind
of
things.
You
basically
have
the
local
data
and
you
will
find
a
figure
way
to
actually
synchronize
the
data
either.
You
know
when
the
data
has
been
added
or
updated.
A
C
Yes,
okay,
so
we
have
another
one
from
jason.
Do
we
need
to.
A
A
No,
so
the
thing
is
die
is
basically
for
it
is
going
to
make
your
you
know.
Development
easy,
so
time
is
basically
simply
a
tool
that
is
installed
on
a
developer
machine
which
makes
easier
to
build.
You
can
die.
Has
this
deploy
option
so
when
you
say
tightly,
which
I
think
I
can
show
you
in
a
bit
tie
deploy
and
it
can
actually
deploy
to
kubernetes
and
install
everything
that
is
needed.
A
So,
whatever
you
define
in
thai
yaml,
it's
very
similar
to
if
you're
a
work
with
docker
compose
right,
so
you
will
define
these
services
and
then
you
do
docker
compose
up.
Everything
comes
up
all
the
docker
images
get
pulled
and
works.
Similarly,
in
thai
as
a
dot-net
developer,
I
didn't
even
create
a
docker
file
in
this
case.
If
you
don't
notice,
like
I,
don't-
have
docker
file
in
my
thing
right,
it's
still
running
as
a
container,
it's
creating
the
network
for
you.
A
A
You
can
still,
if
it's
a
small
project,
something
you
still
can
use
thai
deploy
and
then
and
and
deployed
to
production,
because
tai
has
that
option
to
do
that,
but
I
would
suggest
you
know
if
you
are,
if
you're
like
a
really
large
micro,
you
know
so
a
large
company
with
hundreds
of
microsoft,
that's
when
the
microservices
will
make
sense.
You
would
have
this
individual
ci
cicd
pipeline,
which
will
take
care
of
that
good
question.
Jason.
A
I
guess
know
the
question
right
now:
okay,
so,
let's
get
back
so
since
we
I
answered
the
question
jason
on
kai
with
production.
I
want
to
show
you
one
more
thing
which
is
basically
deploying
right,
so
I
can
go
if
I
want
to
install
deploy
this.
All
that
I
need
to
do
is
get
my
cube
cdl,
which
is
kubernetes
by
the
way.
If
you
are
working
at
docker
here,
a
few
some
tips
and
tricks,
you
can
use
kubernetes
that
comes
from
docker
itself,
which
is
what
I've
been
using.
A
It's
great
for
local
testing
deployment,
it's
a
single
node
thing,
so
it
just
works
straightforward.
Another
thing
about
docker
use
this
thing
use
wsl
to
base
engine
so
install
wsl
2
and
then
make
sure
enable
that
so
that
way,
I
basically
don't
have
a
vm
and
a
kind
of
thing
set
up,
because
it's
running
on
wsl
too.
So
that's
that's
also
a
simple
trick.
All
right
since
I
have
this
kubernetes
configured,
so
let's
say
config.
A
This
is
my
docker
desktop,
that's
running,
so
this
is
where
my
kubernetes
config
is
so
once
we
define
that
you
can
actually
from
the
folder
where
you
have
the
pi
yaml,
you
can
actually
say
thai,
deploy,
interactive
and
then
go
back
and
then
hit
n
enter
and
you
can
go
define
the
services.
So
this
will
take
some
time
what
it
does
is.
A
Basically
it
basically
creates
an
image
like
you
didn't
even
specify
a
docker
file,
but
it
looks
as
your
cs
draws
and
creates
the
right
docker
file
for
you
and
then
it
creates
the
image
and
push
it
so
right
now
I
do
have
it
and
and
and
by
default
it
it
deploys
to
the
kubernetes
thing.
So
now,
if
you
see
I
have
already
already
installed
in
my
kubernetes
and
you
can
see
that
there
is
back
end
in
front
and
now
things
so
I
can
basically
let's
let's
do
this
put
forward.
A
A
Everything
is
seamless
right,
so
I
can
do
the
tie
deploy
as
well.
Now,
while
doing
this
there's
another
thing
that
I
wanted
to
show
you,
depending
on
how
much
time
we
have,
I
think
about
six
seven
minutes
so,
like
you
know,
resiliency,
I
want
to
talk
about
resiliency
a
little
bit,
because
when
you
are
doing
service
to
service
communication,
let's
go
back
to
this
architecture
document
a
little
bit.
A
So
when
you
have
this
service
to
service
communication
right,
so
you
can
see
the
databases
separate.
So
when
you're,
connecting
with
multiple
services,
there
are
chances
like
you
will
connect
with
multiple
services,
maybe
connecting
to
catalog
and
catalog
is
actually
fetching
the
data.
Sorry,
if
you're
connecting
the
basket
basket
is
fetching
the
data
from
catalog,
it
could
be
a
synchronous
call
and
something
goes
wrong
in
catalog.
It
can
actually
create
a
cascading
failure
down
in
the
scale
right.
A
Why
do
I
say
that
is
because
you
know
in
terms
of
kubernetes
world
and
things
there
could
be
chances
for
kubernetes
trying
to
change
your
images
pulling
something
new.
You
are
actually
updating
in
the
production.
Something
can
intermittently
fail.
In
such
cases,
your
code
has
to
be
very
smart
enough
to
handle
resiliency
and
the
way
you
can
do
that
is
basically
implementing
two
patterns.
A
One
is
the
retry
pattern
and
the
circuit
breaker
I'll
quickly
show
you
if
I
can
show
you
that
in
the
code
first
so
go
to
the
controller
and
let's
create
and
create
this
error.
So
I'm
just
going
to
create
this
here
for
now.
So
this
is
my
random
random
value,
whenever
this
exception
just
creating
this
right.
This
is
not
in
real
time.
You
won't
do
that
so
when,
when
you
do
that,
let's
do
a
tie
run.
A
On
the
front
end
it's
working
now,
but
sometimes
you
can
see
that
there's
an
error,
but
if
you
refresh
again
it
will
go
so
it's
a
very
random
error
right.
So
in
such
cases,
it's
a
good
pattern
to
implement
to
handle
resiliency.
So
how
do
you
do
that?
The
two
ways
to
do
that
one
is:
you
can
actually
directly
write
this
code
right
into
the
code,
for
example,
in
my
case
I'm
actually
connecting
with
the
weather
controller.
So
here
this
is
my
frontend
code,
which
is
actually
working
with
the
backend.
A
A
So
what
it
is
doing
is
within
this
code
you
have
this
http
poly
extensions
dot,
handle
transient
http
error
and
it
is
going
to
do
simply
retry
and
it's
going
to
do
an
exponential
retry,
which
means,
like
you,
make
a
connection.
It
is
failing.
So
the
next
connection
may
not
be
almost
immediate,
because
if
you
do
that,
then
there
could
be
dos
denial
of
service.
So
we
don't
want
that.
So
you
want
to
wait
for
some
time
and
then
connect.
So
once
when
you
do
that,
what
happens
is
the
calling
code
will
not
fail?
A
Because
it's
still
waiting
on
the
response,
so
we
can
magically
make
that
error
go
away.
So
I
just
enable
that
now,
let's
I
should
start
using
thai
watch.
I've
been
doing
that.
A
A
So
now,
if
I
go
back
to
my
dashboard
refresh
this
and
go
to
this
page
and
refresh
it
multiple
times,
you
can
see
what
is
happening.
Is
it's
it'll,
never
fail
or
it'll,
never
show
the
failure.
It
is
actually
failing
behind
the
scenes
because
we
go
to
the
locks.
What
it
is
doing
is
basically
it's
waiting
and
retrying
and
that's
what
it
does
so.
The
other
pattern
that
you
can
use
is
basically
a
circuit
breaker,
which
is
basically
you
know
like
a
circuit,
there's
an
open
circuit
and
closed
circuit
concept.
A
So
whenever
there
is
an
open
circuit,
there's
no
more
connections
made.
That
means
there'll
not
be
any
calls
made
when
the
circuit
is
closed,
which
means
the
connections
will
be
made,
so
you
can
decide
after
how
many
tries
do
you
want
to
keep
the
circuit
open
for
how
long?
So
that
way,
you
don't
keep
hitting
it
and
kind
of
handle
this
thing.
So
these
you
can
see
that
these
these
kind
of
code
is
basically
written
right
inside
your
business
logic.
Now
like
this
is
your
service.
This
is
how
this
is
where
you're
writing
it.
A
Another
way
to
do.
That
is
basically
using
a
service
mesh.
So
in
my
case
I
have
the
link
d
installed
and
let
me
show
you
this.
Let
me
instead
of
because
I
don't
have.
I
only
have
two
minutes
and
I
can
take
questions
meanwhile,
so
I
encourage
you
to
go
check
this
code
out.
I
actually
have
written
this,
so
if
you
go
to
github.com
national,
that's
my
handle
github
twitter
instagram,
wherever
you
want
to
follow
me,
so
there's
a
thing
called
on.net
and
I
actually
showed
this
in
the
undocking
show.
A
So
here
it's
the
same
code
that
I'm
showing
you
right
now
within
the
main
readme.
I
basically
show
you
tell
you
how
to
do
this.
Like
you
know,
this
is
the
way
to
do
it
in
code,
but
you
don't
have
to
do
it
in
code,
it's
better
to
do
in
the
infrastructure
because
you
can
handle
resiliency
in
infrastructure.
A
The
advantage
of
infrastructure
resiliency
is
that
you
know
you're,
avoiding
all
these
kind
of
cross-counting
code
from
your
business
logic
and
you're,
actually
focusing
on
the
on
business
logic
and
let
this
let's
something
like
a
service
mesh
handle
for
it.
What
service
mesh,
what
the
service
mesh
tool
basically
attaches
another
part
within
along
with
your
service,
and
it
will
take
care
of
all
the
network
thing
for
you
right.
So
it'll
do
all
the
networking
you
know
I
think
so.
A
A
So
here
you
go
so
you
do
a
link
id
check
pre
once
you
install
the
link
id,
do
that
to
check
if
your
kubernetes
is
capable
of
doing
it
most
like
if
you're
working
on
the
latest
linked
sorry
kubernetes,
and
I
think
it's
gonna
just
straightforward
work,
and
then
you
do
a
link
to
install
onto
your
cluster
where
you
want
to
install
the
service
mesh
right.
A
So
once
you
install
that
you
can
go
to
the
dashboard
and
see
you
also
need
to
what
you
need
to
do
is
because
I
deployed
using
tie.
I
did
not
have
any
kubernetes
files
available
to
me
to
edit
and
what
kind
of
things
so
I
can
use
something.
Some
commands
like
this,
like
you
know,
kubernetes
get
deployed.
Get
me
the
deployment
of
front
and
whatever
I
deployed
give
me
the
output
in
the
aml
and
I'll.
A
A
What
it
does
is
basically
so
this
is
the
dashboard,
so
you
can
see
there's
something
called
as
meshed.
So
if
you
don't
mesh,
if
you
don't
apply
that
command
in
this
meshed,
it
would
not
be
so
you
can
it's
again
a
you
know,
opt-in
feature,
so
you
can
decide
you
want
to
mesh
what
other
systems
you
want
to
mesh
right.
You
can
choose
those
things
so
here
if
you
go
into
my
grafana
dashboard
like
for
example.
In
my
case
I
don't
have
anything
right
now.
I
can.
A
I
can
run
it,
but
but
I
think
we'll
run
out
of
time.
So
I'm
just
going
to
leave
it.
You
know:
okay,
there's
some
from
the
previous
runs,
so
you
can
see
that
you
know
the
success
rate
like
how
are
we
working
with
and
things
like,
so
it
gives
you
all
these
nice
dashboards
and
things
once
you
install
it
and
it'll.
A
Also,
it
now
will
watch
how
it's
working
with
like
you
may
not
need
zipkin
anymore
yeah,
you,
you
have
those
recipes
tracking
enabled,
so
these
tracings
will
also
pop
up
in
your
other
dashboards
like
prometheus
and
grafana
as
well.
A
Okay,
so
that's
oh
yeah,
one
more
thing
that
you
need
to
do.
B
A
If
I
go
to
link
id
so
this
is
what
I
was
planning
to
show,
but
since
we
are
running
out
of
time
and
just
leave
that
so
you
can
actually
enable
this
is
retriable
equals
true
retract
budget
retry
ratio.
Once
you
set
this
up,
you
know,
service
machine
will
take
care
of
doing
the
retries
and
you
don't
have
to
write
that
poly
code
at
all.
So
yeah
few
things
like
that,
there's
so
much
of
so
many
things
in
the
cloud
native
world.
A
So
if
you
simply
go
to
landscape
dot,
cncf
dot,
io
you'll
see
that
so
many
things
so
many
tools
and
things
like
available-
and
this
is
what
we
do
we
kind
of
like
you
know,
look
at
this.
We
explore
this.
We
work
with
customers,
understanding
how
they
are
using
it,
and
then
we
bring
that
into
the
documentation
that
you
see
here.
So
I
will
encourage
you
to
go
check
that
out.
So
if
you
have
any
questions,
I
can
take
that
up
now.
A
Yeah,
so
it
is,
it
is
basically
in
a
service
discovery.
We
are
making
use
of
the
the
kubernetes
services
curve
itself
because
we
configure
that
while
we
deploy
it,
so
we
pick
pick
it
up
from
that
you,
if
you
want
to
use
something
like
console
and
other
things.
You
could
do
that
too,
like
it's
again
up
to
you
if
you
want
to,
but
we
don't
need
any
other
features
from
it.
So
we
were
straightforward
in
working
with
this
microservice
and
it
is
still
configurable
in
in
in
a
lot
of
ways.
B
A
I
guess
the
question
is
for
thai
yeah,
okay,
yeah
yeah.
It
is,
I
mean
it's
a
dev.
It's
it's
it's
into
your
developer
tools.
So
it's
it
has
nothing!
It's
not
going
to
bother
any
of
your
production
scenarios.
I
would
encourage
you
to
start
it
and
give
us
feedback
so
that
we
can
make
this
tool
better,
because
you
know
it
just
works.
A
I
mean
I've
been
using
it
for
a
couple
of
months
now
like
from
the
beginning
of
time,
and
it
has
improved
a
lot
and
we
are
actually
listening
to
feedback
to
see.
How
can
we
make
this
better
because
in
microservices
world
there's
like
hundreds
and
thousands
of
services-
and
you
may
not
be
working
with
everything
at
a
time
in
your
in
your
developer?
You
know
machines,
so
we
want
to
understand
how
what's
your
scenario
like,
and
how
can
we
help?
A
So,
if
you
look
at
what
happened
with
tires,
I
don't
have
docker
files,
I'm
not
working
with
docker
compose
files,
it's
just
straightforward.
As
a
document
developer,
we
wanted
to
focus
on
the
your
business
logical.net
code
rather
than
looking
at
infrastructure,
and
that
kind
of
thing.
So
I
would
encourage
you
to
start
clicking
it
still
in
the
preview
and
stages.
A
B
A
Yeah
so
yeah
there
are
multiple
things
like
com,
so
compensating
transactions.
So
let
me
just
find
transaction
pattern.
I
think
we
have
it
here.
A
You
can
actually
use
this.
Basically,
you
know
you
it's
nothing
but
okay.
This
is
all
explained
here.
So
if
you
go
to
dot.net
sorry,
docs.microsoft.com
azure
architecture
and
look
at
patterns
and
then
look
at
this,
so
basically
what
happens
is
like
you
basically,
like
kind
of
like
start,
not
a
transaction
scope,
kind
of
a
thing,
but
you
basically
start
a
transaction
in
terms
of
like.
A
If
something
fails,
you
basically
send
a
compensating
transaction
to
roll
back
the
previous
thing,
so
those
decisions
that
you
can
you
can
actually
make
yourself
and
a
few
more
things.
Actually,
you
can
go
to
the
dot
dot.
Sorry,
docs,
there's
another
thing.
A
Documentation
there
you
go
so
this
is
another
page.
I
think
I'll
I'll
do
one
thing
right
off
this
call
I'll
ping
you
these
urls
directly,
so
read
about
this
like
how
you
can
actually
implement
this
and
yeah.
That's
that's
the
way
to
go.
B
B
A
Yeah,
that's
a
very
good
question.
I
mean
yeah
just
because
you
went
and
attended
a
micro
services
session
does
not
mean
that
every
next
service
that
you
start
building
is
a
micro
service
right.
So
I
think
the
most
important
aspect
here
is:
you
know
the
moment
you
say:
database
per
microsoft
database
is
different
for
every
service.
A
It
just
blows
away
people's
mind
because
the
complexity
that
is
going
to
bring
in
it's
going
to
be
huge.
So
unless
you
are
a
team
that
large
size-
and
you
know
that
independent
teams
can
be
spin
spin
out
from
that
and
ship
multiple
services
at
a
time.
That
is
the
time
when
you
want
to
stick
up
micro
services,
so
complexity
and
scale
and
making
use
of
cloud.
Those
are
the
important
aspects.
If
then
go
ahead,
monolith
is
not
bad.
A
Monolith
is
not
about
old
versus
new,
like
monolithic
vessels,
microservices
people
say
like
okay,
everything
is
now
micro
services.
No,
it's
just
an
architectural
design
pattern
just
like
how
you
would
design
decide
a
particular
design
pattern
right.
Every
design
pattern
exists
to
solve
a
particular
problem,
so
it's
not
that
you
jump
into
it
and
then
just
start
using
it
everywhere
right.
So
as
long
as
you
know,
large
services-
and
you
want
to
make
use
of
the
cloud
ship
100
times
a
day-
you
can
do
that
now.
A
The
thing
is:
like
people
get
confused
with
dockers
and
kubernetes
to
be
micro
services.
No,
you
can
actually
take
a
monolith
application.
You
can
containerize
it.
You
can
still
ship
it
as
moderate
application
right.
So
you
can
still
make
use
of
dockers
and
kubernetes
and
that
kind
of
things,
but
micro
services,
large
schemes,
large
applications,
large
problems,
you
know,
then
it
was.
It
will
be
the
right
time
to
do
that.
A
Yeah
there
are
many
and
that's
why
we
wrote
a
whole
book
about
it,
which
is
like
architecting
cloud
native
apps
for
azure,
so
this
book
talks
about
what
are
the
services
on
azure,
that
you
can
use
writing
from
kubernetes,
and
we
also
talk
about
how
we
actually
do
the
shopping
containers
like
mapping
those
services
directly
to
how
we
use
api
gateway
and
and
so
on
right.
So
I
would
yeah
it's
a
lot
of
things,
so
I
would
suggest
you
to
it's
all
well
documented,
just
go
and
check
this
out.
B
A
On
the
microsoft
side,
good
yeah,
thank
you
so
much
for
bringing
this.
I
should
have
called
this,
so
this
is
something
that
I've
been
working
on
with
cam
and
scott
aka.ms
asp.net
hyphen
microservices,
please
bookmark
this
link.
This
is
a
great
link
for
you
to
do
hands-on
and
azure
without
having
visual
studio
without
having
any
ids
installed.
You
can
actually
run
this
on
ipad,
so
this
is
create
and
deploy.
So
there
are
like
much
bunch
of
it.
We
are
actually
building
a
couple
of
more
ones
which
is
in
the
making.
A
So
we
talk
about
how
to
do.
How
do
you
start
with
cloud
native
right
being,
as
you
said,
you
know,
like
you
know,
when
do
you
decide?
How
do
you
decide
micro
services?
So
we
show
you
this
particular
application
where
you
get
to
you
know,
build
a
new
micro
service
called
coupon
and
attach
to
this
existing
ecommerce
site.
So
what
are
the
things
that
is
involved
in
it?
How
do
you
decide
databases?
All
those
things
are
actually
here.
It
takes
about
one
hour
to
finish
this
course.
A
You,
all
that
you
need
is
an
azure
subscription.
If
you
don't
have
it
just
create
one,
it's
free
for
12
months.
Take
that
plan
just
learn.
It's
hands-on.
Like
you
know,
we
wrote
this.
You
can
actually
completely
type
it
inside
your
browser
because
we
have
the
azure
cli
we
make
use
of
it.
A
bunch
of
investments
have
gone
into
this.
So
please
make
use
of
this.
So
the
thing
that
I
talked
about
resiliency
it's
right
here.
A
You
can
actually
create
resiliency
in
not
just
in
the
sampler,
but
in
the
production
app
like
how
do
you
do
a
resiliency
in
a
production
app
right?
So
that's
here,
there's
github
actions.
There
is
instrumentation,
which
is
about
logging.
Another
things
there's
also
feature
flags.
How
do
you
enable
feature?
Let's
say
you
ship
the
new
feature,
but
you
don't
want
to
enable
it
yet
you
want
to
enable
to
certain
people
right.
You
can
do
those
things
using
azure
feature
flags,
so
you
have
hands-on
models
for
all
those
things
so
do
check
it
out.
A
A
B
B
B
B
Okay,
so
let's
get
started,
my
name
is
amardee.
I
am
a
microsoft
mvp
in
developer
technologies.
I
work
for
kpmg
as
an
architect.
I
have
a
blog
called
techrepository.10,
where
I
blog
about
this
and
the
things
I
was
working
on,
and
this
is
my
tutor
handle
where
you
can
contact
me
for
anything
regarding
the
session
or.
B
B
Azure.Net
so
jumping
into
the
topic
we
have
today
hosting
static
websites
in
azure.
So
many
of
us
in
some
point
of
time
we
should
have
hosted
a
samp,
simple,
html
website
on
a
dedicated
server
on
a
web
hosting
service
or
on
azure.
So
what
it's
a
plain,
simple,
static,
html
website,
where
we
don't
need
these
high
availability
or
high
resources,
or
these
huge
resources
provided
by
these
hosting
providers
or
cloud
providers
itself
right.
B
We
just
want
to
host
a
simple
website
and
serve
it
to
condensate,
assume
that
I
am
hosting
an
event,
and
I
am
I
need
a
website,
so
I
will
create
a
sample
html
website.
I
will
host
it
somewhere
and
use
it
that
for
the
duration
of
the
event
and
just
done
with
it
right.
So
in
that
case
I
don't
need
these
hyphen
features
that
are
available
from
these
properties.
B
I
just
want
to
host
these
static
sites
somewhere,
so
in
azure
there
are
two
options
until
now,
where
we
can
do
that,
it's
using
one
is
using
azure
storage
and
another
was
using
azure
app
service,
all
right,
so
in
azure
storage.
What
we
are
doing
that
we
will
create
a
storage
account
and
from
that
storage
account
we
host
our
web
application.
B
So
there
is
no
other
thing
that
was
needed
there
just
create
a
storage
account,
put
your
static
files
there
and
host
the
website
from
there
and
by
the
way,
this
was
the
cheapest
option
available
in
azure
for
hosting
a
static
website.
B
So
there
are
certain
limitations
there
for
static
websites
like
we
cannot
set
a
default
document.
We
cannot
set
custom
error
pages.
We
doesn't,
there
is
no
option
to
save,
set
some
authorization
or
authentic
authorization,
etc.
So,
if
you
want
just
a
place
where
you
want
to
show
the
site
say
show
the
simple
html
pages.
This
was
a
good
enough
solution,
so
the
other
option
we
had
was
in
azure
is
azure
app
service.
This
is
a
pass
offering
from
azure
for
hosting
websites.
B
It's
basically
primarily
used
by
hosting
dynamic
websites,
say
the
website's
created
in
dotnet
or
java
azure
app
service
is
used.
B
It
provides
you
additional
facilities
like
load,
balancing
automatic
scaling,
advanced
authorization
techniques
and
all
those
stuff
that
you
expect
from
a
normal
web
server
is
available
in
azure
app
service,
but
for
hosting
our
static
website.
These
things
are
not
needed
and
it's
also
a
course
layer
option.
B
So
until
now,
these
two
options
were
available
in
azure
to
host
these,
but
they
have
now
introduced
a
new
service
called
azure
web
static
web
apps.
It's
still
in
preview,
it's
not
available
for
available
in
general,
ga,
it's
still
undergoing
what
you
say,
publishing
the
latest
features
and
also
it
will
be
soon
available
for
public.
B
The
preview
is
available
public,
but
the
general
availability
will
be
soon
later
this
year.
So
what
it
does
is
that
it
gives
you
the
ability
to
automatically
build
and
deploy
to
azure
directly
from
your
github
repository
okay.
B
So
it
supports
modern
frameworks
such
as
vue.js,
sorry,
there's
a
typo,
that's
react
is
angular
blazer
and
more
all
these
modern,
full
stack
frameworks
based
on
javascript
are
supported
in
azure
static
web
apps,
so
not
only
plain
static,
html
website,
so
the
sites
developed
using
angular
and
all
these
stuff
are
supported,
and
so
there
is
one
more
additional
functionality
which
the
static
web
app
supports
is
the
back-end
api
support.
So
sometimes,
when
you
create
a
sub
website
right,
say
an
even
website.
B
In
that
case
you
will
have
a
list
of
speakers
or
the
event
schedules
or
the
session
agenda
that
needs
to
be
created
or
faced
dynamically
from
a
backend
data
store.
In
that
case,
what
we
can
use
is
that
we
can
make
use
of
the
backend
api
support
provided
by
static
web
apps
to
interact
with
a
cosmos
db
or
a
flat
file.
You
can
go
and
fetch
the
data
from
there
return
that
back
to
your
static
application
and
show
it
there
so,
thereby
we
can
have
some
sort
of
dynamic
nature.
B
We
can
add
some
sort
of
dynamic
nature
to
this
kind
of
static
web
applications,
which
is
not
possible.
If
you
are
going
with
an
actual
storage
of
a
storage
option,
as
in
azure
app
service,
it
is
possible,
but
again
that
is
a
costlier
option
so
again
other.
It
also
supports
static
size
generators
like
jk,
gatsby,
hugo
and
vio
press.
So,
if
you
are
using
any
of
this,
you
can
host
your
applications
in
azure
static,
web
apps
too.
B
So
what
all
the
features
it
have?
It
has
a
first
class
github
integration.
So
at
this
stage
only
github
is
not
support.
Github
is
supported,
not
other
source
providers
like
azure,
devops
and
or
only
github
is
supported.
So
what
it
internally
do
is
that
it
nearly
uses
azure
cdn,
to
host
your
static
content.
So
that
means
the
content
is
available
nearer
to
the
person
who
who
are
browsing
or
who
are
using
your
sites,
and
that
is
done
automatically
by
azure,
so
it
globally
distributed
the
content
using
the
cd
azure
cdn.
B
So,
even
though
you
are
not
specifying
that
explicitly,
while
creating
the
website,
it
is
managed
automatically
by
ashu.
It
also
provides
free,
ssl
certificates,
custom
domains.
So
you
you
have
a
different
domain
or
you
have
a
top
level
domain
and
you
want
to
use
that
you
are.
You
can
do
that
using
extra
static
web
apps,
there
is
no
restriction,
such
as
you
will
need
to
use
only
the
url
provided
by
azure
and
also
it
supports.
B
It
also
gives
you
a
staging
environment
where
you
can
stage
your
changes
preview,
your
features,
and
after
that,
once
you're
satisfied
with
the
changes
all
changes
you
are
made
in
your
code.
You
can
automatically
promote
that
your
production
environment,
the
other
feature
it
also
support
authentication
providers
like
azure,
ready,
facebook,
twitter.
You
can
implement
that
also
too,
and
also
you,
if
you
have
want
to
have
some
sort
of
authorization
to
handle
the
content
or
the
content
or
restrict
the
content
to
a
specific
type
of
users.
B
You
can
use
that
using
customizable
authorization,
definitions
and
also
you
can
provide
back-end
routing
rules
also.
So
if
you,
if
you
want
to
have
a
specific
url
that
needs
to
be
shown
in
your
address
bar
and
server
different
page,
you
can
create
your
own
routing
rules
and
use
that
to
serve
your
content.
B
So
basically,
this
is
the
flow
for
an
actual
static
web
app.
Where
we'll
first,
we
will
need
to
create
a
repository
in
github,
and
you
will
clone
that
repository
in
your
local
machine.
You
work
on
your
code
changes.
Then,
after
you
push
or
create
a
pull
request
to
the
repository
the
I
should
ask
when
you
create
a
natural
static
weber,
what
happens
is
that
it
will
automatically
create
a
github
action
in
your
repository.
B
Github
action
serves
workflows
available
in
github,
which
can
do
a
set
of
jobs
automatically
for
you
in
a
specified
manner.
So
when
you
create
a
static
web
app
and
hook
your
github
repository,
it
will
automatically
create
a
github
actions
and
using
that
you
have
actions,
it
will
build
and
deploy
your
code
to
azure.
So
again,
there
is
no
need
for
you
to
create
the
actions
itself.
B
It
will
created
automatically
for
you,
but
you
will
have
the
option
to
edit
the
actions
from
github
and
then
it
goes
deployed
to
azure
static
web
apps,
and
I
so
suppose,
if
you
have
your
friend
and
part
in
angular
or
view
orbit,
it
will
be
deployed
into
that
particular
directory.
And
if
you
have
a
backend
function,
azure
functions,
it
will
be
deployed
separately
and
the
communication
that
will
is
going
to
happen
between
your
front
end
and
back
end
is
automatically
handled
by
azure.
B
B
B
So
let
me
browse
that
solution
and
show
it's
like
a
simple
website
where
it
has
got
a
content
where
it
has
a
speaker
section.
It
has
an
event
schedule
section:
all
of
them
are
static,
site
or
static
content.
You
can
see
here
all
are
specified
in
this
html
code
and
it
is
being
served
to
the
browser.
So
let's
see
how
we
can
create
a
assure
static
web
app
in
azure
and
then
pull
push.
These
changes
from
my
local
box
into
the
github
repository
how
it
is
automatically
deployed
in
azure.
B
D
B
B
I
will
provide
a
name
for
my
web
app.
I
will
see
the
region
so
as
of
now
only
free
sku
is
available
since
it's
in
preview,
and
so
whatever
you
create,
it
is
free
of
charge.
Only
the
storage
account.
You
will
be
a
charge
only
for
the
storage
account
only
and
when
it
nears
the
regional
availability,
you
will
get
more
skills
and
more
enhanced
hosting
options.
Okay,
so
this
is
for
the
website.
B
Now
I
need
to
hook
my
github
repository
to
this
particular
web
app,
so
you
can
go
and
sign
in
with
github.
Here
you
can,
you
can
address
application.
B
B
I'll
choose
I'll,
choose
the
branch
and,
if
you
scroll
down
below
it
will
have
a
build
detail
section.
This
is
where
I
will
specify
what
type
of
application
is
I
am
going
to
host.
So
if
you
are
a
angular
or
a
react
or
a
blazer
application,
you
can
choose
that
and
it
will
give
you
appropriate
apps
option
for
that.
Where
to
where
is
your
artifacts
folder
and
all
those
stuff?
You
need
to
specify
them.
So,
since
I
am
using
a
plain,
simple,
html
website,
I
am
not
going
to
create
anything.
B
You
can
see
that
it
has
automatically
created
the
github
actions.
So
if
you
go
to
the
actions
tab,
so
it
has
created
an
action
and
it
is
already
running
a
github
action.
So
since
there
is
nothing,
if
you
go
and
browse
the
site,
it
will
say
that
your
static
web
app
is
live
because
the
repository
is
empty
right.
So
let's
go
back
to
our
repository
folder.
B
C
B
B
B
There,
what
basically
it
does,
is
that
it
creates
a
docker
image.
It
build
your
application
and
then
runs
that
application
for
you
using
that
image
all
right.
B
All
right,
so
it
has
now
completed
the
deployment.
So
if
I
go
back
here,
you
can
see
that
my
static
website
is
now
hosted
in
azure.
This
is
the
domain
it
it
created
under
azure,
app
staticapps.net.
If
you
have
a
different
or
if
you
have
a
custom
domain,
you
can
go
here
to
custom
domains.
You
can
add
the
cname
record
under
with
your
dns
provider,
and
then
it
will
use
your
top
level
or
your
sub
domain
for
accessing
the
website.
So
you
can
specify
that
here.
B
All
right,
so
that
was
a
basic
cube
demo
on
how
to
create
an
actual
static
web
app
service,
how
to
push
the
repository
into
static
service
and
how
it
is
hosted
in
the
azure
cloud.
So
any
questions
you
have.
C
We
have
one
question
yeah
from
jason,
so
under
the
hood
static
web
app
is
just
storage
of
the
static
content.
B
No,
I
can
say
it's
not
only
a
storage,
it
have
this
additional
functionality
to
implement
the
authentication
and
authorization,
and
it
also
implements
a
back-end
api
internally.
It
creates
azure
functions
for
that
and
it
hosts
that
functions
and
it
handles
that
communication
from
your
front
end
to
the
back
and
then
it's
no
totally
specific
storage
count.
It
do
some
additional
sort
of
things
too.
C
Okay,
we
got
another
one,
so
from
fun
salute
can
I
use
die
to
create
mixed
service,
including
this
is
for
the
for.
C
C
C
B
Okay,
so
what
let's
move
on?
Let's
move
continue
with
our
demo.
What
I'm
going
to
do
is
now
suppose
if
I
go
to
this
site
and
I'm
typing
in
some
invalid
url,
it
is
showing
me
a
custom
generic
static
404.
Now
I
need
to
override
this
with
my
own.
I
need
to
have
a
custom
error
page,
which
is
in
line
with
my
design,
language
of
the
site.
So
what
I
can
do
is
that
for
that
I
can
create
a
files
called
routes.json.
B
B
B
B
Website
I
need
to-
I
am
telling
that
you
need
to
serve
this
particular
page,
so
for
404,
I'm
saying
that
you
need
to
serve
this
custom
404,
for
that
I
will
need
to
create
a
new
file
called
custom.
B
B
B
B
B
All
right,
so
let
me
go
back
to
the
static
web
maps
and
I'll
show
you
the
environment.
So
if
you
go
to
the
environment
section,
you
can
see
that
there
are
two
sections
here:
one
is
for
production
and
one
is
for
stg,
so
the
production
slot
will
have
our
latest
running
website
that
is
serving
to
the
users.
It
will
be
automatically
deployed
to
this
particular
slot.
B
What
we
can
do
is
that
we
can
have
a
staging
section
and
we
can
actually
create
a
pull
request
in
github
repository
when
you
do
that
it
will
automatically
deploy
this
staging
environment,
where
you
will
be
able
to
browse
that
website
in
that
staging
environment.
You
can
see
how
it
actually
looks
in
your
azure
app
service
and
you
can
go
through
the
changes
once
you
are
satisfied
with
that,
you
will
go
to
github.
You
will
merge
your
changes,
then
it
will
automatically
push
from
staging
to
the
production
environment.
B
B
B
B
File
cold
schedule,
which
is
basically
a
subset
of
our
event
website,
which
will
have
only
the
even
schedule,
part
okay.
So
now
what
I'm
doing
is
that
I
am
directly
taking
the
website
from
my
web
application.
B
B
B
B
B
B
D
B
Okay,
so
you
can
see
now
right.
There
are
two
versions
of
my
site.
The
main
branch
is
having
the
latest
production
version,
whereas
the
staging
environment
is
running
from
my
dev
branch,
which
will
has
the
latest
changes.
So
if
you
have,
if
you
go
to
this
browse,
you
can
see
that
url
itself
is
different
right
one.
For
again,
this
is
automatically
created
by
the
azure.
B
B
B
B
So
when
you
create
the
message,
it
will
again
automatically.
A
B
Build
and
it
will
what
it
does
is
that
once
the
build
is
completed,
it
will
go
here.
It
will
come
here
and
it
will
remove
this
from
the
staging
environment
and
whatever
changes
was
there,
it
will
be
promoted
to
a
production
environment
all
right.
B
So
I
will
show
you
how
you
can
do
that
in
natural
web
statics
preview,
okay,
so
the
back-end
api
support
is
provided
in
azure
static
web
apps
using
azure
functions,
so
you
need
to
create
azure
functions
for
implementing
your
backend
api
logic
for
creating
the
azure
function.
C,
you
can
do
that
in
c,
sharp
python
or
nodejs.
As
of
now
all
right,
all
these
azure
functions
will
be
implemented
as
http
triggers
with
input
and
output
binding.
That
means
these
functions
can
accept
input
from
the
front
end
and
it
can
return.
D
B
Values
back
to
different
applications,
so
one
restriction
we
have
right
now
is
that
all
the
functions
you
define
or
you
create
should
be
should
be
routed
under
the
prefix
called
api.
You
can't
give
any
other
prefix
for
doing
that.
As
of
now
and
for
doing
your
logging
in
your
back-end
api
functions,
only
application
insights
are
supported.
So
if
you
want
to
log
that
to
a
file
in
your
storage
account
or
somewhere
else,
that
is
now
not
possible,
it
will
be
coming
when
it
nears
the
general
availability.
B
So
this
is
with
the
route.json,
so
in
the
prior
demo
I
showed
you
how
you
can
define
routes
in
your
whole
routes
or
json
file,
so
it
is
executed
in
the
order,
as
is
defined
in
that
particular
array.
B
So
if
the
if
a
match
is
found
for
the
at
the
first
instance
or
the
first
element
itself,
it
won't
execute
the
rest
of
the
things
it
will
return
from
that
and
it
will
serve
that
route
and
the
location
of
the
routing
route.json
file
is
different
for
different
framework,
so
in
angular
it
should
be
under
the
assets
holder
for
react
as
well.
It
should
be
under
public
for
blazer.
It
should
be
under
wwe
route.
B
So
as
again
as
we
saw
in
the
demo,
you
can
specify
the
route
you
can
specify
the
content
that
needs
to
be
served
for
this
particular
route.
What
should
be
the
status
code
that
needs
to
be
returned?
So
if
you
are,
if
you
having
some
endpoints
for
your
api,
you
need
to
return
a
different
static
code,
then
you
can
specify
that
and
also,
if
you
say,
implement
rpc
error
rule
based
authentication
for
the
your
routes.
Then
you
can
do
that.
B
You
can
specify
the
role
names
and
all
those
stuff
and
you
you
will
implement
the
custom
authorization
logic
to
handle
that.
So
you
can
specify
that
to
in
your
routing
array,
again
for
authentication
and
authorization
you
can
make
use
of
these
third-party
providers
for
authentication
like
active
directory,
github
facebook,
google
and
twitter
has
supported
as
of
now
and
for
authorization.
There
are
two
methods,
one
is
anonymous,
so
that
means
everyone
can
access
everything
and
there
is
an
authenticated
method.
B
B
So
let
me
again
go
back
to
the
demo,
so
what
I
am
going
to
do
is
now.
I
am
going
to
create
a
new
static
web
application
for
an
angular
application.
So
I
will
go
here.
C
B
Okay,
main
branch,
so
so
now
what
I
am
going
to
do
is
that
I
will
say
my
framework
is
angular
the
moment
you
choose
angular,
you
will
get
you,
it
will
give
you
additional
locations.
So
what
should
be
the
location?
What
should
be
your
root?
Folder?
You
can
specify
slash
or
if,
if
it's
residing
in
some
folder
under
your
root
folder,
you
can
specify
the
path
here.
This
is
the
api
location,
and
this
is
your
artifact
location.
B
B
B
C
B
C
B
All
right,
so
this
is
my
angular
application.
I
have.
I
have
promoted
my
static
html
content
page
into
an
angular
application,
and
I
have
created
the
necessary
component
and
all
those
stuff,
and
also
I
created
a
couple
of
azure
functions,
called
get
schedule
and
get
speakers.
So
what
I'm
doing
here
is
that,
instead
of
using
the
static,
html
content
for
showing
my
schedule
and
speakers,
I
am
using
this
speaker
this
function,
endpoints
for
the
time
being
so
I
have
created
an
in-memory
data
store.
B
I
am
when
I
call
this
get
speakers
function
from
my
angular
application.
It
will
come
here.
It
will
then
return
this
content
back
to
my
application.
So,
similarly
for
schedule,
I
have
created
a
sample
store
and
I
am
returning
that
back
to
the
api
okay.
So
what
I
am
doing
here
is
that
if
you
go
back
to
my
angular
application,
go
back
to
my.
B
B
All
right,
so
I
have
a
added
link
for
event:
schedule
page
where
it
will
be
redirected
to
the
schedule
page,
and
it
will
show
that
eventually,
so
that
is
here
in
the
speaker.
You
can
see
that.
B
Where
I
am
using,
the
http
client
object
to
interact
with
my
api.
It
will
call
the
get
speaker's
endpoint.
It
will
get
that
information
from
there
and
it
will
then
respond
return
that
response
back
to
my
front-end
application,
and
it
will
show
it
there
rather
than
relying
on
my
web
application.
So
let
me
create
a
new
web
application.
B
B
B
B
C
C
B
B
B
B
B
B
B
B
All
right,
so
what
I
said
is
that
for
the
route
I
said,
only
the
admin
should
be
able
to
access
right.
So
since
I
am
using
an
anonymous
login
to
use
my
application,
I
no
table
the
api.
Endpoints
won't
be
hit
and
that's
why
no
data
is
coming
here.
So,
let's
add
an
user
who
is
authenticated.
So
what
you
can
do
is
that
under
role
management,
you
can
click
on
this,
invite
you
can
specify
the
authentication
provider
I
can
give
my
name.
B
B
You
can
generate
this
invite
link.
I
will
get
this
invite
this
expiration
is
only
for
this,
invite
the
role
assignment
will
be
there,
so
it
will
generate
an
url
where
you
can
go,
you
can
send
your
send
the
send
to
the
person
who
are
trying
who
you
are
trying
to
add.
I
can
use
that.
I,
since
I
have
already
granted
the
access
earlier,
it
didn't
ask
me
for
username
and
password.
B
Suppose,
if
you
want
to
give
a
different
role,
you
can
assign
that
different.
You
can
assign
multiple
roles
for
a
user
say
you
want
to
have
a
control.
Note
that
pin
roll
you
have
to
have
a
contributor
enterprise
role.
You
can
give
it
as
a
comma
separated
values.
So
whatever
routes
require
these
particular
routes
roles,
it
will
be
honored
for
that
particular
user.
That's
how
we
can
handle
authentication
and
authorization
in
the
static
websites.
B
Okay,
so
that's
pretty
much
the
demos
I
had
for
this.
So
right
now
what
you
are
seeing
that
I
was
using
virtual
studio
code.
I
was
using
the
command
prompt
to
push
that
application,
create
the
web
app
in
azure.
I
was
going
into
the
portal
and
I
was
creating
the
web
apps
manually
right.
There
are
other
ways
you
can
do
that
you
can
always
use
azure,
cli
or
cloud
shell
for
creating
your
web
application
actual
web
apps.
B
If
not,
if
you
want
a
integrated
feeling,
you
want
to
create
that
right
from
your
visual
studio
code,
you
can
install
this
particular
extension
in
visual
studio
code.
Then
you
don't
need
to
go
out
of
visual
studio
code.
For
doing
any
of
this,
you
can
write.
B
Do
write
that
right
inside
visual
studio
code
itself,
the
publishing
to
the
application,
creating
the
websites
web,
apps,
etc
and
actual
everything
can
be
done
inside
the
visual
studio
itself
by
using
this
extension,
these
are
some
of
the
references
we
where
you
can
get
started
on,
creating
your
web
application
on
github
actions
and
all
those
stuff
anyway,
I'll
I'll
be
sharing
this
slide.
Once
the
session
is
controlled
once
event
is
concluded,
you
can
go
through
this
to
get
started
with
azure
web
static
web
apps.
B
B
B
D
Hey,
thank
you
so
much
amel
and
thank
you
guys
for
joining
us
in
this
session.
Today
we
are
going
to
discuss.
How
can
we
create
a
full
stack
application
in
grpc,
web
and
blazer
version?
So
what
do
we
do
first?
So
let
me
share
my
screen:
real,
quick
and
we'll
discuss
on
that.
D
Context,
so
if
you
you
can
see
this
here
here
is
the
code
for
this
entire
exercise,
whatever
we
are
working,
so
we
will
be.
I
just
mentioned
the
software
tools
and
basic
knowledge
and
assumptions,
and
the
technology
stack
we
use
and
what
do
we
build
today?
D
So,
let's
assume
that
we
already
have
an
existing
micro
service,
which
is
a
web
api
and
the
new
micro
services
are
using
grpc
web.
So
how
can
you
integrate
blazer
basm,
the
single
page
application
with
both
these
micro
services,
so
communicating
with
the
rest
web
bpa
and
communicating
with
grpc
web
okay?
That
being
said,
so
just
give
me
one
moment.
Let
me
open
up
the.
D
Okay,
so
let's
go
step
by
step
on
that,
so
let
me
give
the
url
also
of
the
this,
so
that
you
know
you
guys
can
keep
it
handy
to
try
this
after
the
session.
D
Okay,
thanks,
that's
that's
done
so,
let's
start
with
this,
my
name
is
vishwanath
swami.
I
work
at
applied
information
sciences
and
these
are
the
prerequisites
I
mentioned.
I'm
working
on
os
windows,
10
os
dot,
net
phi
and
I'm
working
on
visual
studio,
2019
professional,
but
you
can
use
community
also,
so
I'm
using
postman,
sql
server
and
azure
data
studio,
and
this
is
one
of
the
tool
which
I
really
like
it
very
much
this
we
can
use
it
to
communicate
with
with
the
sql
server,
maybe
from
within
your
any
anywhere.
D
Wherever
you
have
the
sql
server,
you
can
go
ahead
and
communicate
with
that
sql
server.
So
we
have
couple
of
tables
here.
Just
let's
have
a
quick
glance
of
those
tables.
We
have
professors
and
students
table,
so
I'm
using
instead
of
sql
server
management
studio,
I'm
using
this,
and
this
is
a
cross
platform
tool.
D
Also,
I
really
like
it
very
much
and
that's
one
piece
and
the
next
thing
is:
I
already
provisioned
all
the
scripts
here
under
the
scripts
folder
you
can
find
the
creation
of
database
and
the
tables
and
the
data
population-
everything
I
just
created,
so
you
guys
can
go
grab
and
create
it.
D
Okay,
so
so,
let's
start
building
this
one.
So
what
we
already
have.
So
we
have
this
college
score.
So
all
the
things
which
are
common
will
be
moved
into
this
application
core
library,
and
what
do
we
have
here
is
we
have
one
of
this
constant,
so
this
constants
file-
and
this
is
data-
store,
I'm
using
this
connection
string
and
for
weather
forecast
web
api.
This
is
one
of
the
constants.
D
Okay
and
we
have
couple
of
interfaces,
one
is
professor
data
access
layer,
so
get
all
professors
get
professor
by
id,
and
we
have
professor
business
logic
layer
that
is
get
professors
and
get
professors
by
id.
So
that's
related
to
the
application
core,
and
what
do
we
have
in
the
data
access
layer
that
access
layer
is
a
persistence?
D
Is
one
folder.
It
contains
the
simple
db
context
and
we
we
are
exposing
two
db
sets.
So
if
you
see
the
things
on
the
left
side,
so
that
is
coming
from
the
entities
folder.
So
these
two
are
entities
which
are
one-on-one
map
with
these
fields
on
the
tables
and
what
are
these?
On?
The
right
side
of
the
db
set
the
professors
and
students
that
is
the
table
name
itself.
If
you
see
this
table
names,
so
the
professors
and
students
it
should
have
the
exact
spelling,
if
not,
will
get
exception
right.
D
So
that's
one
one
thing
and
in
this
professor's
dal
is
where
we
are
implementing
those
interfaces
where
we
retrieve
all
those
professors
for
get
all
professors
get.
Professor
ids,
we
are
retrieving
a
particular
professor
id.
That's
one
one
different
thing.
So,
while
we
are
here
quickly,
I
want
to
give
one
tip,
so
one
of
the
tip
is
that
we
are
doing
the
dependency
injection,
so
the
professor
dal
depends
upon
the
db
context,
as
well
as
the
logger,
so
we'll
see
in
depth.
How
does
this
dependency
injection
container
gets
loaded?
D
How
we
get
how
we
get
these
dependencies
in
our
code,
we'll
we'll
look
into
that
in
depth,
but
I
just
want
to
give
a
quick
tip.
So
what?
If,
if
I
add
a
new
dependencies,
let's
assume
that
I
only
have
this
one
dependency
and
suddenly
I've
added
only
the
college
db
context
was
one
dependency.
Now
I
want
to
add
the
logger
also
as
part
of
my
dependencies.
D
So
what
I
can
do
is
I
can
very
well
do
a
copy
paste
of
this
and
come
here
and
modify
this
and
again
go,
and
do
this
one
all
like
logger
equal
to
this
logger
and
do
all
these
things.
So
we
don't
need
to
sweat
at
all.
So
whenever
you
are
adding
something
new,
you
can
remove
the
existing
constructor
and
then
do
alt
enter
so
the
moment
you
do
alt
enter
you'll.
Get
this
generate
constructor
and
just
click
on,
add
null
check
and
then
that's
it.
So
you'll
get
a
beautiful
constructor.
D
So
whenever
you
have
any
constructor
assuming
that
you
are
not
writing
anything
else,
apart
from
these
kind
of
dependencies,
you
can
do
that
and
if
you
have
any
any
other
code
apart
from
these
dependencies,
then
please
be
little
careful.
D
So
whatever
I
am
giving,
this
tip
is
only
when
you
are
having
only
these
kind
of
dependencies
you
can
auto
generate
alt
enter
generate
constructor,
okay,
so
that
being
said,
let's
go
and
see
what
is
there
in
the
business
logic,
layer,
business
logic
layer
is
directly,
it
has
got
a
dependency
on
the
data
access
layer
and
it's
going
to
get
the
data
from
this
data
access
layer
right.
So
let
me
quickly
go
and
undo
these
changes,
because
I
don't
want
to
do
any
changes
there.
D
Okay,
so
that's
the
common
libraries,
what
whatever
we
have,
and
by
doing
that,
what
is
advantage
of
moving
this
code
to
response
respective
libraries?
The
intention
is,
these
libraries
should
be
part
of
the
nougat
packages
like
if
anyone
else
has
got
a
similar
functionality.
Most
of
the
times,
what
happen
is
the
database
will
be
common
team.
A
will
be
talking
to
one
database,
and
team
b
will
also
be
talking
to
the
same
database
might
be
with
the
same
tables.
Also
like
team.
A
is
pumping
in
the
data,
and
team
b
is
utilizing.
D
It
and
team
three
is
writing
like
it
could
be
multiple
reasons
all
and
the
entire
entire
organization
might
use
it
or
partially
they
might
use
it.
So
in
that
case,
these
are
the
right
candidates
to
be
as
a
nougat
package,
because
I
don't
want
to
reinvent
the
wheel
somebody
someone
would
have
already
written
this
code.
I
just
go,
grab
it
so
these
technically,
these
are
nougat
packages
should
be
no
get
packages.
Okay.
Now,
if
you
see
this
the
web
api,
it
is
very
very
slim.
D
It
doesn't
worry
about
anything
because
all
those
worries
we
have
moved
to
those
respective
libraries
now
our
webpage
is
only
focused
on
what
should
it
expose.
So
it
has
got
one
controller
and
this
controller
has
got
the
two
methods,
get
retrieves
all
the
professors
and
get
professor
by
d.
So
we
have
these
these
two
and
a
couple
of
other
tips
in
this.
While
we
are
here,
we
are
using
this
user
secrets.
So
how
do
you
go
with
the
user
secrets?
D
Is
right,
most
click
on
this
project
and
you
can
add
this
user
secrets
and
once
you
add
it,
you
click
on
this
manage
user
secrets.
We'll
come
back
to
that
real
quick.
So
if
you
see
this
app
settings
app
settings,
is
we
just
mentioned
that?
What
all
the
information
you
want
this
to
be
in
your
app
settings?
D
So
so
what
happen?
Is
anyone
who's
using
this
project
or
is
working
on
this
project?
He
knows
that
what
all
the
dependencies
for
this
project
to
be
executed.
So
we
know
that
the
connection
string
is
here.
This
app
settings
is
being
checked
into
the
source
code
repository,
but
we
are
not
going
to
store,
even
if
it
is
local
or
wqa
stage
broad
you
at
any
environment.
We
are
not
going
to
store
any
credentials
inside
the
app
settings.
D
All
we
have
to
do
is
so
that
rest
of
the
developers
in
our
team
or
across
team
or
the
devops
team.
They
know
that
what
all
the
things
which
they
have
to
provision,
so
how
do
you
know
that?
What
are
the
connection
strings
which
are
coming
in
you
use
this
manage
user
secrets
and
here
this
connection
string?
Is
there,
so
even
let
it
be
my
local
or
somewhere
whatever
is
the
connection
string?
It
is
safe
with
me,
so
why
do
I
say
that
it
is
safe?
D
Now
entire
world
knows
that
now,
okay,
so
let's
see
that
the
dependencies
will
we'll
we'll
look
into
the
dependencies
when
once
we
come
into
the
grpc
grpc
web,
so
or
else
while
we
are
here
also
we
can.
We
can
look
into
this
dependencies.
So
here,
let's
see
that,
how
does
the
dependency
injection
happens?
Let
me
place
the
debugger
over
here
inside
the
db
context
and
I'll
place.
D
Another
debugger
inside
the
data,
access
layer
and
I'll
place,
one
more
debugger
inside
the
business
logic
layer,
so
the
dependencies
will
get
loaded
how
it
gets
loaded,
how
it
gets
injected.
We'll
see
that
in
a
moment.
So
what
happens
is
when
when
the
dependencies
are
there,
so
it
goes
and
tries
to
create
the
instance
of
this,
and
it
sees
that
it
has
got
a
dependency
on
professor
vl
and
logger.
So
then
it
comes
to
this.
Professor
bl
tries
to
create
this,
and
then
it
finds
that
it
has
got
professor
dal
and
logger.
D
So
then
it
goes
to
the
professor
dal.
Then
it
finds
the
professor
dal
has
got
a
dependency
on
the
db
context
and
the
logger.
Then
it
goes
here
here.
It
has
got
a
parameter
is
constructor,
but
it
doesn't
have
any
dependency
getting
injected
as
part
of
the
constructor,
so
it
can
create
the
call
hdp
context.
So
in
this
way
what
happen
is
the
last
man
standing
doesn't
have
any
dependency
that
gets
created
and
it's
been
given
to
the
dal
and
then
business
logic
layer.
Then
to
the
controller,
so
that's
all!
So
what
is
this
dependencies?
D
Who
holds
all
this?
It's
considered
it's
like
an
atm
machine,
your
bank
account
and
your
credit
card.
These
are
the
three
pieces,
so
you
deposit
money
in
in
your
bank
account
and
you
have
an
atm
card.
You
go
and
insert
in
insert
into
any
atm
and
withdraw
money,
and
if
you
don't
have
anything
deposited
into
your
account
and
you
go
and
try
to
withdraw
money,
you
will
get
the
transaction
decline
similarly
inside
the
startup.
So
one
of
the
method,
what
we
have
to
focus
is
on
the
configure
services.
D
So
this
is
the
one
which
holds
the
service
container,
so
all
the
dependencies,
whichever
we
need
it
or
whichever
are
the
application
dependencies.
We
have
to
load
it
here.
So
if
you
see
that
the
college
db
context,
the
professor
business
logic,
layer
and
the
professor
dal
are
the
application
dependencies
which
we
are
loading,
so
one
more
question
anyone
will
might
ask
is
mommy.
You
said
that
these
are
the
application
dependencies.
But
where
is
this?
I
logger
coming
from.
D
Let's
look
at
that
in
a
moment,
so
some
of
the
dependencies
which
comes
out
of
the
box,
okay,
some
of
the
dependencies
which
is
application
dependent.
We
have
to
add
it.
Okay,
let's
click
on
execute
and
let's
see
that,
how
does
this
dependencies
container
gets
loaded
and
what
all
the
dependencies
which
are
coming
out
of
the
box?
D
Okay,
so
this
is
the
first
one:
it's
hitting
so
right,
most
click
on
that
and
go
to
that
quick
watch
and
you
see
that
there
are
79
dependencies
now.
If
I
expand
this
result
view
over
here,
you
can
see
that
the
I
logger
it's
over
here,
so
the
I
logger
is
coming
out
of
the
box,
whether
you
without
doing
anything,
I
logger
is
coming
as
part
of
the
dependencies,
so
there
were
79
and
I.
D
D
I
do
81
plus
3.,
it
will
add
three
dependencies
on
this.
Let's
go
and
do
a
quick
watch.
81
plus
3
is
184.
You
can
expand
this
view
and
we
can
scroll
down
to
check
that
our
application
dependencies
are
also
loaded.
You
can
see
that
the
call
hdb
context
these
three
dependencies
are
our
application
dependencies.
We
just
loaded
and
after
that
we
are
loading
two
more
dependencies.
D
Those
dependencies
are
those
dependencies
are
also
our
application
dependencies,
so
one
for
the
so
181
plus
3
184,
plus
2
186.
So
totally
we
have
186
dependencies
in
this.
So
let's
check
that
those
dependencies.
So
you
can
see
this.
Professor
bal
and
professor
dal
are
also
got
injected
in
this
one.
So
I
am
removing
this
now.
I
click
on
continue
so
now
the
application
loads
and
that's
being
executed
in
this
5002
port.
Okay,
I
can
use
this
or
I
can
go
to
this
postman
and
I
click
on
get.
D
I
do
have
the
break
points.
Yes,
I
do
have
the
break
points,
so
I
click
on
send.
So
now
you
can
see
this.
The
last
man
standing
is
the
college
db
context,
who
doesn't
have
any
more
dependencies
that
guy
will
get
created
and
then
gets
injected
here
you
can
see
this
the
call
sdb
context
that
is
completely
populated
right.
So
now
I
remove
this
and
then
come
to
the
business
logic
layer.
D
Now,
if
you
come
and
see
this,
the
college
db,
con
context
has
been
injected
and
it
has
got
the
logger
and
the
db
context
right.
So
I
remove
this
here
and
then
come
to
this
controller
and
inside
this
controller
you
can
see
this.
The
professor
bell,
which
has
got
logger
as
well
as
the
professor
dal
and
the
professor
dal,
has
got
the
college
db
context,
so
the
entire
hierarchy
has
been
properly
injected
because
we
have
already
loaded
that
inside
the
in
inside
this
startup
class.
So
what
what?
If
I
miss
something?
D
Okay,
what
if
I
miss
something
in
my
dependencies?
Okay,
let's
see
this
scenario
so
similarly,
when
you
get
this
kind
of
exception,
it
will
help
us
to
identify.
This
might
be
one
of
the
reason
why
you
are
getting
it
so
it
tries
to
load
these
dependencies
and
it
will
give
you
saying
that
unable
to
resolve
the
service
dependencies.
D
So
when
you
get
this
unable
to
resolve
the
service
dependencies,
that
one
of
the
reason
is
that
you
might,
we
might
have
forgotten
to
have
these
dependencies
right.
So
that's
the
quick
walkthrough
of
our
existing
existing
solution
where
we
have
the
reusable
component
and
web
api
and
other
couple
of
tips,
we
have
seen
how.
How
can
we
create
the
constructor
when
we
have
the
dependency
injection,
and
then
we
saw
what
the
dependency
injection
is,
how
the
dependency
injection
container
gets
loaded,
how
the
dependencies
are
resolved.
D
So
we
have
seen
that
in
in
this
quick
tour,
so
let's
go
and
and
one
more
thing
what
we
have
seen
is
when
we
move
this
logic,
logic
or
the
functionality
to
different
libraries.
Our
web
api
is
very
slim
and
it
it
focuses
only
on
the
controller,
what
controller,
what
endpoints
it
has
to
expose,
and
only
only
related
to
this
controller.
So
it's
not
worrying
about
anything
else.
D
So
all
the
responsibilities
has
been
given
to
different
libraries
now
we'll
create
the
grpc
service
and
we'll
test
it
with
a
client
and
then
we'll
add
the
grpc
web
capability.
Also,
so
we'll
see
the
benefit
of
doing
this
one
right,
so
let
me
quickly
go
and
create
I
have
created.
I
have
given
the
startup
starter
files,
also,
so
that
that
will
help
you
guys
to
recreate
whatever
I'm
doing
at
this
point
of
time.
It
will
help
you
to
recreate
all
the
things
whatever
I'm
doing
here
right
now.
Let's
start
working
on
this.
D
Jrpc
web,
it's
on
this
one
and
I
click
create
and
this
dotnet
5
and
I'm
not
enabling
anything,
no
authentication,
nothing,
that's
a
simple
one:
let's
go
ahead
and
create
it,
okay,
so
now
what
all
the
things
which
we
have
it
at
this
point
of
time,
so
we
have
the
same
program
where
we
have
the
start
main
method
and
it
is
the
startup
type
is
startup,
and
here
there
are
two
important
methods
which
we
have
already
seen.
One
is
this
configure
services
which
builds
this
service
container
dependence
injection
container
and
the
http
pipeline?
D
Is
this
configure
configure
method
and
the
next
big
piece?
What
we
have
here
is
this
app
settings
where
we
can
go
and
have
our
configuration
injected
over
here
and
and
next
thing
is-
I
will
go
and
make
this
as
a
startup
class
and
the
next
big
piece.
What
we
have
is
the
grpc
server
and
we
have
the
launch
settings
where
we
can
go
and
change
the
port
numbers.
D
So
if
you
come
and
see
what
what
all
the
port
numbers
there
are,
multiple
ways
to
do,
some
of
the
ways
is
either
my
personal
choice
or
either
that's
how
I
know
how
to
do
it.
So
let
me
show
that
so
you
can
come
in
here
and
you
can
modify
those
things
from
here.
Also
and
my
personal
choice
is,
I
just
go
and
modify
it
from
here,
so
I
can
modify
this
and
also
when
you
come
to.
Let
me
select
this
as
a
startup
project.
D
When
you
come
and
select
this
project
and
go
to
this
launch
settings
over
here,
you
can
see
that
whatever,
whatever
the
two
profiles
which
we
are
seeing
here
are
there
here,
you
can
see
this
iis
express
and
college
vpn,
so
similarly
in
in
here
also
in
this
grpc
web.
Also
we
have
that
we
have
that
launch
settings
file
and
it
has.
It
has
only
the
project
one,
so
it
runs
only
in
the
project.
It
doesn't
run
in
ios
express
as
of
now.
D
So
here
is
this
one
port,
so
it
runs
on
5000
and
5001,
and
this
port
is
5002
and
5003,
so
the
ports
are
little
different
and
there
is
something
known
as
a
dot
protofile.
There
is
a
google
port
profile
where
you
will
have
the
service
definition
and
you
will
have
the
rpc
methods,
what
all
the
rpc
methods
which
we
are
exposing
here
and
each
of
this
rpc
method
can
take
one
or
more
parameters.
If
there
are
no
parameters,
it
will
be.
D
D
And
that
being
said,
let's
see
that
implementation
of
that
is
over
here.
So
we
have
this
grpc
service
and
it's
coming
from
greeter
base.
So
what
is
this
base
class?
Who
is
creating
all
these
things?
So
we
should
get
that
as
our
query.
So,
let's
see
that
you
can
expand
this
and
go
to
the
obj
and
debug
dot
net
5
and
inside
this
protos
you
can
see
this
gr
pc
and
the
greet
grpc
and
greet
cs.
D
So
this
name,
which
has
whichever
is
greet,
has
been
derived
from
this
over
here
gi
greet
dot
proto,
so
it
will
get
greed
grpc.cs
greet
cs
so
greet.
Grpc.Cs
is
a
one
which
will
have
this
service
definition,
so
you
can
come
inside
and
you
can
expand
this
and
you
can
see
that
the
namespace,
whatever
the
namespace
is
coming
in
from
here.
What
are
the
namespace,
which
we
specify
over
here
or
here
in
this
proto,
will
be
the
name
space,
and
you
can
see
this
greater.
D
The
the
service
name
is
a
greater,
so
that's
the
one
which
is
here
the
partial
class
and
greater
is
a
partial
class.
If
you
scroll
down
little
bit
down
what
you
can
see
is
you
can
see
that
there
will
be.
There
is
an
abstract
class
and
that
class
is
called
as
a
greater
base
and
inside
that
abstract
class.
We
have
the
say,
hello
method.
D
Now
you
can
come
and
correlate
that
so
the
clo
method
is
a
rpc
method
which
we
have
defined
inside
the
service,
and
that
has
been
marked
as
a
virtual
method
inside
this
greeter
base.
So
now
you
can
correlate
that
okay.
So
what
who
is
this?
Creating
this
greater
base
is
the
tools
the
grpc
tools
is
creating
this
for
us,
so
we
are
implementing
that.
So
that's
one
of
the
other
tip.
So,
let's
come
in
here
in
this
grid.cs
and
we'll
expand
this
the
moment
you
see
reflection,
you
need
to
understand
that.
D
Okay,
some
kind
of
transformation
is
happening.
So
what
happen
is
the
here?
The
inputs
and
output
whatever
is
coming
is
an
object
and
that
has
to
be
transferred
into
binary
and
that
binary
will
get
travis
are
sent
to
and
fro
in
a
binary
form,
so
that
clearly
shows
that
the
one
without
the
grpc
that's
for
this
messages
or
the
classes,
I'm
calling
it
as
a
classes
in
a
plain,
vanilla
terms.
D
So
if
you
come
and
scroll
little
bit
down,
you
can
see
that
the
field
number,
whatever
the
number
we
specify
over
here.
This
is
not
the
value
assignment.
This
is
the
ordinal
position.
That
means
we
are
telling
that
we
are
telling
that
in
this
message
or
in
this
class,
this
field
has
got
this.
That
means
it
is
the
first
field
which
has
to
come,
so
it
helps
in
identifying
from
which
location
to
which
location
I
need
to
do
transformation
from
object
to
binary
and
binary
to
object.
D
For
that
reason,
we
need
to
know
that,
so
that's
one
one
other
tip,
okay,
so
that's
pretty
good.
So,
let's
start
building
our
let's,
let's
start
building
our
grpc
whatever
we
want
to
do
now.
Okay,
so
for
that
reason,
what
I'll
do
is
I'll
place
these
two
side
by
side?
So
it
will
help
me
move
little
faster
speaker
series.
D
This
one
source-
okay,
we
are
here
in
this
jpc
web
okay,
so
there
is
a
proto
file.
So
let
me
copy
this
grpc
proto
from
here
to
here
and
we'll
look
into
that.
So
what
does
this
protofile
contains?
This
protofile
contains.
Similarly,
we
have
one
service.
We
have
two
rpc
methods
set
of
messages
right,
so
one
new
thing
whatever
we
are
seeing
in
here
is
the
empty.
That
means
void.
We
are
not
sending
any
inputs
to
this
service
method
and
it
returns
all
professor's
response.
Another
one
to
concentrate
is
timestamp.
D
So
what
is
this
timestamp?
Let's
see
that
in
a
moment-
and
let's
come
back-
and
let's
see
this
so
you
can
see,
google
timestamp
is
made
up
of
two
component.
D
D
D
Let's
let
me
come
in
here
and
right.
Most
click
on
this
go
and
manage
nougat
packages,
and
you
can
see
this
at
this
point
of
time.
We
have
one
nougat
package
and
that
nokia
package
is
called
as
meta
package
right.
So
meta
package
is
like
when
you
get
a
invitation,
it's
like
family
and
friends,
so
the
meta
package
is
it
brings
in
itself
and
the
packages
on
which
it
depends
and
any
third-party
packages
on
which
those
dependent
packages
are
there.
D
So
that's
the
meta
package,
let's
quickly
look
into
this
for
a
moment,
and
here
is
one
and
then
you
go
and
click
on
that.
So
it's
dependencies
is
it's
it's
a
meta
package,
so
you
can
go
and
check
this.
What
does
meta
package
means?
It
has
got
a
dependency
on
a
google
port,
buff
and
server
client
and
grpc
tools.
So
grpc
tools
is
a
guy
who
creates
who
generates
all
those
all
those
resources
whatever
we
need.
D
It
may
be
the
client
components
or
the
server
component,
so
we
expect
our
once
we
built
everything
perfectly.
We
expect
that
there
should
be
the
files
whatever
we
have
dropped
it.
So
there
are
no
files.
We
see
that
we
perfectly
dropped
it
here.
The
call
is
proto,
but
it
didn't
generate
anything.
So
let's
do
one
more
probing.
D
What
did
we
miss
so
right?
Most
click
on
that
go
to
properties.
So
when
I
go
to
properties,
it
is
clearly
telling
that
build
action
is
port,
buff
compiler
and
it
is
creating
the
server
only
component.
You
can
create
server
and
client
client
only
or
server
components.
So,
at
this
point
of
time
it
is
creating
the
server
components
with
it
recognize
that
it's
a
server
server
side.
Now
I
do
a
right
most
click
and
properties,
and
I
don't
see
that
it
says
the
build
action
is
none.
D
So
the
project
is
not
recognizing
this
as
a
as
what
what
it
should
do.
We
didn't
give
the
instruction.
So
one
of
the
way
to
do
is
we
need
to
come
into
this
cs,
broad
and
write
down
that
college
right
and
do
a
build
and
then
we'll
go
into
this
guy,
and
you
see
that
boom
we
have
our
college
grpc.
D
So
all
those
now
now
you
understand
that
where
is
this
name
space
coming
in
from?
And
where
is
this?
This
is
the
name
of
the
service,
and
this
is
the
one
it
creates
the
service
dot
base
and
it's
an
abstract
class
and
we
had
two
methods:
all
professors.
D
We
have
two
methods.
Those
two
methods
has
been
defined
here,
get
all
professors
get
professor
baidi
as
a
virtual.
Now
you
guys
have
pretty
good
strong
foundational
blocks,
what
this
grpc
files
are
and
what
is
this
proto
file
and
how
does
it
creates
it?
So
we
have
to
inform
the
tooling
that
what
is
our
intention,
what
kind
of
artifacts
we
need?
So
that's,
that's
that's
pretty
much!
So
let's
go
and
build
the
build
the
service,
so
the
service
is
just
an
implementation
of
the
base
class,
so
we
have
seen
that
abstract
class
over
there.
D
I'm
just
dropping
it
over
here
and
let's
have
a
quick
glance
at
this
and
do
we
need
sql
server.
We
will
get
those
dependencies.
We
need
those
two
dependencies.
Let's
come
in
here.
I
just
mentioned
all
the
steps
guys
here.
So
what
all
the
things
which
we
are
going
to
do
everything
I
just
mentioned
it
steps
what
packages,
what
changes
we
need
to
do
everything
I
mentioned
it
here,
okay,
so
the
the
next
important
thing
is.
We
need
to
bring
in
those
project
dependencies.
D
Technically,
these
will
be
the
nougat
packages,
I'm
bringing
in
these
three,
and
apart
from
that,
I
need
to
bring
in
the
auto
mapper.
Also
I
need
to
bring
in
that
out
of
my
dependencies.
So
there
are
multiple
ways
guys
again,
I
just
want
to
show
one
this
way
and
one
the
other
way,
the
personal
choice
of
mine.
So
I
go
here.
I
get
the
I
get
this
dependencies
and
I
did
that.
I
can
do
that
way.
D
Okay,
that
dependencies
got
it
and
the
other
way
is.
I
just
double
click
this
it
opens
up
and
if
I
have
a
existing
project
which
is
already
referencing,
I
just
copy
this
and
observe
over
this
on
the
left
side
on
the
extreme
left
bottom.
The
moment
I
come
and
I
paste
it
and
do
a
control
save.
We
can
see
this.
This
guy
go
and
gets
the
you
see
this.
It
restored
this
package
so
either
way
I
do
you
can
do
that
or
this
I
mean
this
is
my
personal
choice.
D
I
do
it
to
save
time
for
some
reason.
Okay,
now
you
can
come
and
see
this.
We
have
all
those
dependencies
whatever
we
need
it.
We
have
it
here,
okay,
so
now
the
moment
we
had
those
dependencies,
all
this
issues
has
been
resolved.
Okay,
one
thing
is
for
that
auto
mapper.
I
need
to
create
a
mapping,
so
let
me
go
and
grab
this
guy
mappings
from
here.
Let
me
drop
that
guy
into
this
project.
The
mappings.
D
D
So
for
that
we
need
the
map
auto
mapper
in
instead
of
if,
if
not,
what
we
have
to
do
is
we
have
to
do
like
one
by
one
transformation
from
one
field
to
another
field,
one
field
to
another
field,
so
just
to
avoid
all
these
things,
I'm
just
having
this
auto
mapper
and
one
thing
as
I
was
mentioning
initially,
the
difference
between
the
source
is
the
c
sharp
type
and
the
destination
should
be
the
destination
should
be
the
google
port
buff
timestamp,
and
that
is
made
up
of
nanos
and
seconds
so
from
daytime.
D
So
we
need
to
transfer
that
this
datetime
of
system.datetime
object
to
timestamp.
So
that's
one
tip
here:
okay,
so
that's
pretty
good.
After
doing
all
these
things,
so
are
we
good
one
other
thing
we
are
not
at
good.
We
have
to
do
few
other
changes
over
here.
So
what
are
those
changes?
Let's
do
that.
I
just
mentioned
it
everything
over
here,
but
let
me
go
and
do
that.
The
first
thing
is
we,
let
me
go
grab
this
app
settings
and
then
we'll
talk,
there's
nothing
in
this
app
settings.
D
Okay,
so
I'm
grabbing
these
three
and
that's
for
I'm
allowing
the
cars
also
because,
instead
of
coming
back
to
a
white
delay,
I'm
just
doing
this
microsoft
extensions,
that's
the
configuration
which
we
have
to
read
it
and
that's
the
configuration-
and
we
spoke
about
that
user
secrets.
You
can
click
on
this
user
secrets,
because
I'm
I'm
using
that
user
secrets
over
here.
D
So
I
don't
need
to
do
something
new
okay,
so
we
are
doing
that
and
after
doing
that,
what
we
have
to
do
is
we
have
to
enable
the
cars-
and
this
is
for
the
auto
mapper
and
the
other
one
is
for
the
application
dependencies.
We
have
seen
that
how
the
dependency
services
are
getting
loaded.
We
have
seen
that
in
depth
if
needed,
we
can
see,
but
it
might
be
the
overkill.
D
So
so
I'm
just
resolving
all
these
squigglies
tv
context.
D
Good,
so
all
the
squigglies
are
gone
so
right,
mouse
click
and
remove
for
some
reason.
I
don't
like
those
unused
usings,
even
though
they
don't
hurt
me.
So
the
other
important
things
is.
We
need
to
expose
the
grpc
web
so
that
you
know
we.
We
can
be
communicated
using
this
windows,
client
or
any
kind
of.net
core
clients,
as
well
as
the
spa
applications,
let
it
be
the
react.js
or
angular
or
laservasm.
For
that
communication.
D
We
need
to
have
this
okay,
so
these
two
things
we
need
to
add
it
over
here
after
routing
specifically,
I
have
added
the
comment.
Also,
that
should
be
between
the
routing
and
use
end
points,
and
one
more
thing
is
here:
okay,
so
if
you
don't,
if
you
don't
enable
this
grpc-
and
you
do
like
this-
that
means
you're
exposing
the
grpc
service,
but
they
have
to
come,
communicate
in
a
different
channel.
So
we'll
see
that
in
a
moment
I
will
come
in
here.
I
don't
know.
For
some
reason,
this
was
not
working.
D
D
Okay,
so
that
grpc
service
is
being
executed.
So
what
do
we
do
to
test
this?
We
will
need
couple
of
grpc
clients
which
I
have
already
created.
So
this
is
one
of
the
console
client.
I
had
an
existing
project,
so
let
me
go
here.
D
Let's
go
grab
the
windows
client,
so
just
to
be
sure
that
we
are
bringing
in
the
content
from
from
this
guy
I'll
place
the
debugger
over
here,
so
that
we'll
know
that
we
are
retrieving
the
content
from
the
jrp
service.
Okay,
I
just
start
this
grp
service.
We
are
not
coming
through
the
web
channel
guys
we
are
coming
through
the
regular
grpc
service
channel.
We
are
not
at
there,
okay,
so
what
we
can
do
is
I
can
start
this
windows
forms
client.
It's
a
simple
windows
forms
client.
D
Let
me
place
this
guy
over
here
and
the
windows
forms
is
here.
So
let
me
go
grab
one
of
the
id
I'll
grab
idf
methodnire
and
let
me
quickly
come
in
here
and
place
this
over
here
and
then
I
will
delete
all
this
content
can
leave
it
there.
I
just
click
on
find
professor,
so
you
can
see
that
the
call
has
come
in
here
and
it
is
going
and
grabbing
the
content.
So
that
shows
that
we
are
communicating
with
the
grpc
service
and
I
do
continue
and
that
you
can
see
this.
D
The
mithun
nyers
information
is
here,
so
a
lot
of
those
debug
is
coming
in,
so
the
one
difference.
What
we
can
see
here
is
when
we
do
a
request
here.
It
clearly
says
that
it
is
grpc
service,
it's
it
when
we
are
coming
through
the
grpc
web
channel.
At
that
time
it
says
that
the
grpc
web,
so
here
it
is
just
mentioning
grpc.
That
means
we
are
not
coming
through
the
web
channel
so
to
do
the
web
channel.
We
have
to
do
something
else.
D
So
dotnet
run
this
I'm
running
the
grpc
web
again
and
this
time,
what
I
do
is
I
will
come
and
mention
this
okay.
I
just
need
to
give
a
couple
of
other
tips.
So
how
do
we
create
these
clients?
That's
what
we
do.
What
we
do
is
I
just
for
the
sake.
I
just
delete
this
okay,
so
we
just
need
to,
and
also
I
will
come
in
here
and
delete
all
these
things.
D
Also,
I
will
delete
all
these
things,
one,
two,
three,
okay,
I
I
delete
all
these
references
also
or
what
we
have
to
do
is
we
have
to
come
in
into
this.
This
is
one
of
the
way
guys.
This
is
one
of
the
way,
whatever
I'm
showing
come
and
click
on
this
connected
services,
click
on
add
and
select
this
grpc
and
then
click
on
next
and
go
and
browse
the
file.
D
The
file
is
over
here:
the
protos
select
the
college
proto
and
the
moment
you
select.
This
is
little
intelligent.
It's
selected
that
we
want
the
client,
but
let
stay
little
focused
and
careful
when
we
try
to
do
the
same
in
blazervasm,
it
selects
the
server
because
it
we
are
hosting
that
so
it
assumes
that
we
want
to
create
blizzard
wasm
or
expose
this
grpc
from
the
blazer
version
project.
You
do
the
same
in
web
api
when
you
try
to
reference
this
protofile
again.
It
selects
that
so
be
little
careful.
D
When
you're
doing
this,
we
have
to
select
that
and
click
on
finish
the
moment.
You
click
on
finish.
You.
It
identifies
what
all
the
dependencies
are
there.
It
itself
will
go
and
bring
in
all
the
dependencies.
Okay,
that's
the
one
one
thing
we
do:
we
do
it,
okay,
so
I
just
do
a
save
of
that
and
minimize
this
and
another
thing
is
the
helper:
it's
pretty
straightforward,
very
simple:
just
create
a
channel
for
the
service
url
and
the
service
client
and
again,
who
does
create
the
service
client.
D
We
have
already
seen
that
in
depth,
but
let's
spend
quick
10
seconds
on
that.
I
can
come
back
to
this
debug
and
go
to
this
college
grpc
and
inside
this
college
grpc
see
the
difference.
The
grpc
is
the
service
or
client,
and
only
the
college
without
any
suffix
that
is
related
to
the
messages.
So
if
you
scroll
down
here,
it
creates
the
grpc
client.
So
previously
it
created
the
the
service
name
base
and
the
service
name.
Client
means
it
is
creating
the
client
components.
So
we
we
create
that.
D
So
that's
only
only
difference
when
we
are
creating
either
the
server
components
or
the
client
components.
The
tool
takes
care
of
that.
But
what
do
you
do?
Okay,
so
let's
do
one
more
quick
round
of
testing,
so
let
me
the
grpc
server
is
being
executed.
D
Yes,
the
jrpc
server
is
running
in
here
I'll
just
place
it
over
here
and
then
quickly
come
in
and
check
the
debug
and
start
a
new
instance,
and
let's
see
that
real,
quick
I'll
place
this
and
this
side
by
side,
you
can
see
that
it's
asking
to
enter
the
name.
So
let
me
go
and
grab
scott
rudy's
id
and
oh,
this
is
jrpc.
Okay,
you
see
this.
The
request
has
come
and
we
have
seen
it
has
executed
this
and
it
is
mentioning
that
it
is
grpc
call.
D
D
D
Project
create
a
new
project
and
that's
a
blazarbasm
single
page
application
in
in
future
episode.
I
will.
I
will
do
one
session
on
grpc
web
with
angular,
but
for
today
we'll
stick
to
blaze
of
asm
and
there
are
multiple
types:
it's
dotnet
file,
it's
not
a
server
app.
I
want
to
have
this
blazer
web
assembly
app,
it's
not
being
hosted
under
core,
no
progressive,
nothing
else,
except
this
configure
this
one
okay
boom.
So
let's
start
this,
let
it
create-
and
I
will
come
back
over
here.
D
D
D
D
D
Okay,
let's
wait
for
one
minute:
it
takes
little
bit
time
for
the
first
time
execution.
I
do
ctrl
shift.
I
and
let
me
place
this
here
so
please
focus
on
that.
So,
let's
see
in
the
network
tab
what
all
the
things
which
are
getting
downloaded
for
the
first
time.
D
You
see
that
okay,
so
everything
you
see
that
all
the
dlls,
the
entire
libraries
whatever
is
needed.
Everything
is
getting
downloaded
to
the
client,
so
it
will
not
happen
from
the
next
time
onwards.
It
once
it
gets
downloaded.
It
will
start
using
also
our
blazerbasm
and
also.net
vasm,
the
web
assembly.
Everything
will
gets
downloaded
at
the
first
time
now.
We
see
that
I
will
do
right.
Most
click
empty
cache
and
hard
reload.
Now
it's
not
downloading
anything
because
those
guys
are
already
in
so
it
will
not
do
that.
D
That
happens
only
for
the
first
time,
guys
so
be
little
careful
whenever
you
do
but
rest
of
the
things
everything
is
here
now.
If
I
come
to
fetch
data
and
it's
going
and
bringing
in
from
the
call
it's
a
server
side
call-
and
you
see
this-
the
button
click
technically
the
button
click.
We
don't
see
any
action
or
any
flickering.
D
D
Is
happening
on
the
client
side
until
unless
you
go
to
bring
in
some
content
from
the
network,
you
see
this
anything.
I
do
travis
over
here
or
click.
This
button
do
anything
until
unless
I
want
to
go
grab
the
content
from
the
server,
except
that
all
the
things
will
happen
on
the
client
side
itself,
that's
one
one
particular
trick
okay.
So
the
next
thing
is:
let's
work
on
the
beautification
for
some
time.
The
beautification
is,
I
just
created
those
files
and
let's
go
grab
this
wherever
I
am.
D
C
D
God-
and
I
will
always
copy
so
all
I
have
is
here
the
path
right.
So
that's
one
thing,
and
the
next
thing
is:
if
you
come
and
see
here
we
have
few
css
files,
so
we
have
bootstrap
iconic
and
app.css.
This
guy
has
got
pretty
much
all
the
stylings,
whatever
we
see
is
coming
in
from
here
and
another
thing.
What
we
have
is
this
in
the
main
layout,
so
that
mean
that
main
layout
is
there
and
you
can
see
some
of
the
stylings
are
coming
from
this
css
over
here.
D
D
Okay,
and
that's
one
thing
and
the
next
thing
what
I
want
to
do
is
I
want
to
create
this
shade,
shared
folder,
which
has
got
a
menu
option.
So
at
this
point
of
time
we
have
only
three
menu
options
over
here.
We
have
many
options
for
home
counter
and
fetch
data,
so
we
don't
have
any
other
thing
for
here
now.
What
does
this
fetch?
Data
is?
If
you
come
in
here,
we
will
discuss
about
this
in
length
shortly,
but
that's
the
at
the
rate
page.
D
D
So
I
will
go
to
the
css
file
and
drop
this
guy.
Okay,
that's
done,
and
the
next
thing
what
I
need
is.
I
need
to
have
this
shared
and
inside
that
shared.
Let
me
bring
in
all
these
guys,
so
at
least
we'll
see
that
the
components
are
component
and
an
extra
menu
item
and
then
we'll
make
some
more
changes.
First,
let's
see
the
ui,
how
the
visual
look
and
feel
has
changed.
D
D
Okay,
now
you
you
see
this,
the
some
of
the
visual
look
and
feel
has
changed.
Some
of
the
things
will
will
be
changed
one
in
a
moment.
So
sometimes
what
happen
is
it
doesn't
load
that
so
we
need
to
do
do
this,
okay,
so
after
that
is
changed
once
again,.
D
A
D
Okay,
so
we
don't
have
that,
so
let
me
do
mtp
load
the
cache,
so
actually
it
has
got
the
px
iphone
4
that
I
removed
it,
but
for
some
reason
it's
not
taking,
but
let's
park
that
aside
we'll
come
and
check
about
the
look
and
feel
a
little
later
and
the
first
thing
what
we
can
do
is
anyone
who
worked
in
web
forms.
They
know
that
at
this
point
of
time,
if
you
see
this
fetch
data,
it
is
having
the
markup
and
also
it
has
got
the
code.
Also
it
has
got
both.
D
It
has
got
the
markup
as
well
as
the
code.
So
we
are
not
stuck
to
this.
We
can
have
the
similar
similar
thing
where
we
can
create
a
cs
file
and
move
all
the
back
end
or
move
all
the
back
end
code
to
that.
So,
let's
see
that,
how
can
we
create
so
what
we
need
to
do
is
we
need
to
create
a
same,
a
file
with
the
same
name
and
cs,
and
that
should
be
the
partial
class
that
will
do
the
parcel
class.
So
I
create
that
so
it
should
be.
D
D
D
Dependencies,
I
need
to
bring
in.
Let
me
go
grab
this
dependencies.
Okay,
these
these
things
are
dependencies.
Okay,
here
I
faced
whatever
I
faced
is
one
small
thing
which
I
want
to
show:
I'm
going
and
grabbing
the
protofile.
D
So
here
see
this,
it
is
considering
it
as
a
server,
so
I
said
I
want
client
and
it
is
bringing
in
this
client
and
for
some
reason,
it's
not
bringing
in
this
package.
So
as
we
have
seen
in
the
previous
clients
when
you
go
and
check
the
previous
clients,
the
dependencies
are
these
three
dependencies
for
any
client.
So
that's
what
I'm
going
to
do,
I'm
going
to
come
into
this
blazer
as
a
project
and
then
nuke
this
off
and
go
grab
these
these
things.
D
Okay,
I
think
I'm
good
now,
so
I
just
grabbed
it,
and
it
takes
time
you
can
focus
on
here.
It
will
bring
all
those
packages.
Let
it
bring
those
packages
in
the
meanwhile,
while
it
is
bringing
in
the
packages,
we
can
wait
or
do
something.
Let's
wait.
Okay,.
B
D
D
D
D
Okay,
that's
quickly
is
gone
and
this
quickly
is
gone
and
this
quickly
is
gone.
Okay,
so
jason,
so
everything
is
always
well,
so
we
have
resolved
all
the
things.
So
let
me
close
this
up
and
do
one
build
so
that
you
know
we
can
see
the
same
fetch
data
whatever
it
was
happening.
It
was
happening
from
single
file.
Now
it
is
happening
with
two
different
files.
We
have
the
back
end
like
a
c
sharp
and
the
markup
the
razor,
so
the
component
entire
functionality.
We
have
divided
into
two
different
things.
D
Only
for
the
first
hit
it's
going
to
take
a
little
bit
time.
Okay,
so
see
this
now
it
has
come
now.
You
can
see
this.
This
is
a
markup
okay,
and
what
I
will
do
is
to
speed
up
the
time.
I
will
go
and
copy
rest
of
those
pages,
so
that
will
be
under
pages
folder,
all
those
razor
markups.
Everything
should
be
under
the
pages
folder,
so
I
will
go
grab
those
components
and
put
it
over
here.
What
did
I
do?
What
did
I.
D
D
Okay,
I
just
dropped
those
and
the
next
important
thing.
What
we
have
to
do
is
let's
discuss
about
this
shortly.
I
will
minimize
this.
I
will
minimize
this
and,
as
we
have
seen
it
here
and
the
visual
look
also
okay,
we'll
discuss
about
the
web
api.
How
are
we
bringing
the
webpage
the
same
concept?
So
we
have
the
we
need
this
professors.
The
professors
is
coming
in
from
the
common
library.
D
So
let
me
go
grab
this
guy.
The
data
co,
the
application
core,
so
it
should
come
from
the
application
code.
That's
quickly
is
gone,
so
we
are
invoking
this,
the
http
client
method
and
we
are
deserializing
the
content,
whatever
we
are
receiving
to
this,
this
guy.
Okay,
so
that's
one
thing
which
we
are
doing
in
here
and
for
the
grpc
web.
D
There
is
one
piece
we
need
to
add
it
so
that
piece
we
will
add
it
right
now
so
in
we
can
go
to
this
program,
dot,
cs
and
copy
this,
and
let
me
drop
that
dependency.
You
can
see
this.
The
http
client
is
already
added.
Now
we
need
we
are
adding
the
grpc
related
dependencies.
I
am
clicking
on
that
and
resolving
all
those
nougats
right,
mouse
click
and
remove
some
reason.
I
do
that
and
after
that,
when
we
come
in
here,
the
grpc
the
channel
is
getting
injected.
D
That's
the
only
difference,
and
we
have
we
have
this.
We
have
this
code
over
here.
So
technically
we
have
everything
I
assume.
So
what
do
we
do?
Is
we
will
go
ahead
and
start
dotnet
run.
This
is
a
web
api,
I'm
executing
in
one
command
and
I'm
coming
to
another
command,
and
I
do
dotnet
run
so
you
can
see
this.
The
web
ap
is
running
in
5002
and
this
is
running
in
in
5001.
D
So
as
I
was
mentioning
it
downloads
only
for
the
first
time,
okay,
so
let
me
do
a
clean
now,
that's
an
server-side
call,
except
that
nothing
is
happening.
Boom
boom
boom.
Okay!
So
now
what
we
do
is
we
go
and
grab
retrieve
the
content
from
the
web
api
see
at
this
point
of
time.
The
web
api
is
running,
see
that
it's
going
and
bringing
in
the
content,
so
you
can
come
and
verify
that
we
were
able
to
hit
the
5002
slash
api,
slash
professors,
it's
the
same
end.
D
We
verified
it
in
postman,
so
this
guy
is
going
and
grabbing
the
content
from
from
this
web
api.
Now,
let's
do
the
grpc
fingers
crossed
yep.
Let's
do
that.
I
do
grpc,
so
it's
going
and
bringing
in
the
content.
You
can
see
that
the
route
whatever
is
the
route
it
does.
It
does
http
for
get
professors
in
the
college
service.
So
you
can
see
that
here
as
I
was
mentioning
it
says,
grpc
iphone
web
and
if
I
come
into
this
guy
and
exude
this
console
for
a
moment.
D
Content:
let's
let
me
execute
this
and
then
come
back
and
show
you
guys.
The
channel
see
that
the
channel
is
grpc.
The
channel
is
grpcs
that
differentiates
whether
from
which
channel
you
are
coming.
So
when
you
are
coming,
this
is
a
grpc
channel.
So
if
you
scroll
a
little
bit
up,
you
see
that
that's
a
grpc
web
channel,
so
anything
non-web.
You
can
come
in
through
regular
grpc
and
anything
the
web.
You
have
to
come
in
through
the
web.
B
D
So
this
one
small
difference
I
want
to
highlight
over
here.
If
you
see
the
the
content
in
this
preview
and
here
in
in
this
preview,
this
will
be
little
bit
the
transformation
we
need
to
ensure
if
you're
getting
the
proper
one.
Maybe
this
is
how
I
did
it.
I
had
to
do
little
bit
of
transformation,
except
that
nothing
else,
and
I
want
to
show
you
the
final
piece
someone
can
ask
say
swami.
What
is
why
do
we
need
to
use
jrpc?
D
I
can't
answer
that,
but
I
will
show
you
one
important
thing
which
I
observed
is
see.
The
number
of
rows
are
same
because
we
are
hitting
the
same
database.
The
number
of
rows
is
this
same,
and
here
also
the
number
of
rows
is
same.
So
let
me
come
back
over
here,
so
it
took
70
milliseconds
and
it
took
eight
milliseconds.
D
So
the
one
which
is
coming
in
binary
is
will
travis
it's
it's.
It
will
be
smaller,
comparatively
and
also
the
grpc
is
on
http
2,
so
it
will
get
the
benefits
of
http
2..
So
the
entire
code
is
here
guys
in
this.
D
In
this
repository
as
I
was
mentioning
I've,
given
you
the
url,
also
and
also
I've,
given
the
steps
also
step
by
step
and
what
changes
you
have
to
do
and
how
can
you
verify
what
files
you
have
to
do
everything
I've,
given
you
and
also
the
you,
have
the
startup
starter
folder
also,
but
you
don't
need
to
depend
on
the
starter
folder,
because,
whatever
the
complete
exercise,
which
we
did
it
I'll
check
in
in
next
five
to
ten
minutes,
next,
five
minutes
I'll
check
in
so
you
will
have
the
entire
code
here,
but
you
can
walk
through
this
documentation.
D
Try
react
recreating
using
the
starter
file.
Okay,
that's
it
from
me
swami
and
thank
you
so
much
for
joining
this
afternoon.
B
B
Please
let
me
know
when
you
see
my
screen
a
couple
of
things
you
need
to
do.
You
need
to
go
to
the
share
feedback
url
and
share
your
feedback
around
again
about
the
event,
so
that
we
can
improve
further
and
bring
much
many
more
events
for
you
and
also
all
the
sessions
will
be
there
on
the
youtube
channel
itself.
It
will
be
in
the
dot
and
foundation
channel
the
exactly
the
same
url,
which
you
are
using
right
now.
B
You
can
always
come
back
and
watch
the
recordings
during
your
free
time
if
you
have
missed
anything
in
between.
So
I
would
like
to
thank
nish
and
swami
for
the
wonderful
sessions
and
also
I
want
to
bring
in
couple
of
people
who
were
helping
us
with
conducting
this
event.
Please
update
if
you
can
bring
your
video
feed.
B
Yeah,
these
are
the
producers
behind
the
scenes
who
are
helping
us
with
the
video,
the
content
and
the
layout
you're,
seeing
on
the
screen
and
with
the
chat
and
the
motivation
and
all
big
thank
you
to
them
also,
and
also
for
dave
who
helped
us
setting
this
up.
Thank
you
and
last
but
not
least,
thank
you
all
these
for
joining
us
on
this
saturday,
just
pleasure
hosting
you
all.