►
Description
Ballerina is an open-source programming language that mainly focuses on building cloud-native applications. Ballerina offers network primitives in the language to simplify developing and deploying services in the cloud, making it easier to use, combine, and create network services. Services with resource and remote functions, clients, and interactions are higher-level concepts in the language designed to hide the complexities of working over the network. In this demo, I will talk about the Ballerina language, the gRPC support in Ballerina Language, and show how easy to write a gRPC service and client application in Ballerina.
A
So
a
little
bit
about
me,
I
started
working
with
grpc
protocol
since
2018
when
we,
when
I'm
trying
to
build
grpc
library
in
melanin
language
and
since
then
we
I
came,
we
came
a
long
way
and
now
we
have
like
a
stable
library
where
we
can
build
grpc
like
live
application
very
smoothly
and
along
this
journey
we
I
also
have
privilege
to
write
a
book
around
crpc
with
the
experience
we
get
with
kasumi
in
the
city
and
that's
about
me.
Let
me
jump
into
the
agenda
of
this
talk.
A
First,
I'm
talking
about
what's
the
ballerina
languages
and
what's
the
uniqueness
about
ballerina,
and
then
I
will
discuss
about
grpc
supporting
by
lavina,
so
this
and
I'll
jump
into
the
live
demo.
So
this
talk
mainly
focus
up
on
the
demo,
so
I
will
quickly
go
through
the
slide,
deck
and
jump
into
the
teamwork.
A
Okay,
talking
about
pelvina
balarina
is
a
new
programming
language
we
designed
and
built
for
cloud
native
engineering
when,
when
we
are
talking
about
cloud
native
application,
it's
all
about
bunch
of
apis,
it
can
be
internal
or
internal
or
external
apis
which
bundle
together
integrated
together
to
build
an
application.
A
So
when
we
are
building
a
ballet
in
a
programming
language,
we
thought
about
this.
We
we
designed
in
a
way
that,
when
we
even
have
when
a
cloud
native
developer
develops
an
application,
how
we
can
make
it
make
their
life
easier
so
and
we
introduced
set
of
high
level
abstraction
into
the
language
and
some
features
where
it
makes
those
development
easier.
A
So
so
I
will
talk
about
those
features
in
later
slides
and
so
in
high
level.
This
language
is
mainly
focused
about
writing
services
and
cloud
native
applications.
A
This
this
language
is
not
just
a
language.
It's
a
it's
a
platform.
We
all.
We
already
have
a
lot
of
libraries
have
in
this
language,
and
also
we
have
this
tooling
support
all
these
are
under
open
source
and
party
to
license.
So
if
you,
if
you
are
interested,
you
can
go
and
check
on
ballerina
platform,
guitar
people,
all
the
source
codes
are
there
in
the
organization
and
when
it
comes
to
ballerina
syntaxes,
it's
very
familiar
with
other
scene
family
languages.
A
So
if
you
are
familiar
with
other
languages,
like
c
c,
plus
plus
java,
you
will
be
it's
very
easy
for
you
to
read
and
understand,
but
in
a
court
even
write
well
in
a
court.
A
Okay,
talking
about
the
features
of
ballerina
here
I
listed
only
six
area,
which
I
think
it's
important
to
talk
about
when
it
comes
to
reducing
the
complexities
of
writing
cognitive
applications.
There
are
much
more
than
this,
so
I
will
quickly
go
through
these
things.
For
now
the
let
me
talk
about
the
data
orient
part.
They
the
orient
part.
So
when
it
comes
to
network
applications,
network
interactions,
the
things
that
we
that
we
can
send
over
the
network
is
from
one
place
to
another.
A
Is
data
pure
data,
so
object
but
object.
Orient
current
object,
oriented
orientation,
bundles
data
with
code
to
me
it's
with
strong
approach
when
it
comes
to
native
network
interactions,
so
in
ballerina
we
focus
more
about
this
and
we
heavily.
A
We
make
it
easy
for
you
to
model
the
data
that
program,
manipulates
and
the
program
send
back
and
forth
over
the
network.
So
if
you
you
can
see
in
this
example,
in
ballerina,
we
have
this
record
types.
A
The
record
type
is
nothing
much
it's
a
map
with
any
data,
any
pure
data
so
and
we
have
the
we
have
the
in
ballerina.
We
have
this,
firstly,
support
to
conversation
directly
into
the
ballerina
records,
and
vice
versa,
so,
and
also
when
it
comes
to
data
type,
when
we
define
data
types
in
ballerina,
that's
represents
the
data
which
are
saved
in
the
memory
and
also
it
also
represents
the
data
which
are
transferred
over
the
wire
so
and
also
in
record
types.
A
We
have
close
record
and
open
record
open
records
are
one
who
one
it's
not
limited
to
the
fields
which
is
defined
in
the
record.
It's
it
can
handle,
it
can
hold
other
fields
as
well.
This
is
important
because,
let's
say
when
it
comes
to
consuming
an
api
which
returns
a
big
json
value,
but
we
in
our
application.
We
only
need
to
need
to
set
up
fields
for
the
for
our
logic,
so
we
can
define
only
the
fields
which
which
we
are
in.
A
So
those
data
mapping
is
very
straightforward
when
it
comes
to
well
known
data
types
like
types
like
js
and
xml,
etc.
So
the
other
powerful
features
in
ballerina
is
when
it
comes
to
working
with
data.
We
have
this
integrated,
query
syntaxes.
So
its
query
syntaxes
is
more
like
sql
like
syntaxes,
so
you
can
define
so.
Let's
say:
let's
focus
on
the
code
example,
so
we
have
this
employee
record
added.
So
if
you
want
to
sort
the
things
we
can
have
xql,
we
can
write
xql,
type,
4
and
sort
it
out.
A
So
even
we
have
we
are
closest
to
field
out
and
those
are
very
easy
to
read
and
understand,
and
in
and
also
we
have
this
tabular
data
we
have
ballerina
tables.
Spell
down
stream
types,
etc
or,
and
all
the
primitive
data
type
which
is
needed
to
to
write
a
good
program,
good
program
and
also
we
have
this
xml
support
which
integrate
this
functionalities,
which
is
very
similar
to
xquery.
A
So
those
database
ma
data
manipulation
features
are
embedded
in
the
language.
So
you
don't
need
to
worry
about
data
mapping
between
adjacent
to
the
balance,
etc.
It
will
handle
by
the
language
itself.
A
The
other
important
part
is
concurrency.
In
ballerina
we
have
a
main
concurrency
concept
called
strands.
It
is
lightweight
and
cheap
doesn't
require
oil
straight.
So
it's
more
like
go
routines
in
golang.
A
So
and
also
we
within
the
function
we
can
define,
we
can
group
set
of
codes
and
loop
them
into
a
worker,
a
conceptual
worker
that
worker
will
run
on
a
new
strand
from
currently.
So,
if
you
are
looking
at
the
code,
if
we
have
within
the
function,
we
have
two
workers
called
tnl
and
they
run
parallel.
You
can
run
concurrently
and
then
the
output
we
can
again
assign
it
to
the
main
thread.
A
So
this
kind
of
a
thinking
function
can
be
simply
right
using
ballerina
language,
so
other
so
once
we
have
this
data
manipulation
support
in
ballerina.
The
other
aspect
is
the
network
interaction.
So
when
it
comes
to
network
interaction,
we
have
two
parts.
We
are
the
producing
network
services
and
consumer
network
services
when
it
comes
to
produce
network
services.
We
have
this
listener
and
service
concept.
A
So
listener
is
the
one
who
listen
to
the
incoming
messages
and
dispatching
to
the
service
objects,
and
we
have
the
service
concept
where
it
supports
two
interface
types
like
as
resource
functions
and
the
remote
functions.
So
in
ballerina.
We,
though
we
have
a
overall
service
concept.
We
have,
we
define
different
service
types
for
each
network
protocol,
for
example
for
http.
We
have
http
service
where
it
has
the
characteristics
of
http
service
like
http,
work,
http
resources
and
so
forth.
A
So
the
service
which
defines
insert
http
service
industrial
service
is
contains
resource
function
like
in
this
slide.
That
slide
we
mentioned
like
we
have
the
resource
function
and
we
we
mentioned
the
http
verb
and
also
the
resources,
and
when
it
comes
to
gi,
rpc
style,
grpc
protocols,
we
have
our
service
object,
contains
remote
functions
and
we
have
the
action
solver.
A
So
by
looking
at
the
service
in
looking
at
the
service
written
in
ballerina,
you
can
interpret
the
interface
description
from
the
language
itself
and
also
we
support
generating
the
interface
descriptions
like
open
api
graphql,
but
in
grpc
we
are
not
supporting
generating
the
protobuf
file.
We
we
always
going
with
contract
for
support.
A
The
other
one
is
consuming
network
services
in
network
consume
services.
We
have
the
concept
called
client
objects.
The
client
object
have
remote
fun
methods
that
represent
the
outbound
interaction
with
the
remote
systems,
so.
A
The
point
here
is
when,
when
we
have
a
client
object,
we
can
call
the
remote
function.
Those
remote
calls
are
represented
as
arrow
side,
so
you
can
see
in
the
code
we
this
when
we
are
calling
send
email,
but
by
calling
by
having
an
error
sign
that
represent
a
network
call
so
for
local
force.
We
have
this
dot
sign,
so
we
have
this
differentiation
because
we
can
easily
draw
a
sequential
diagram
from
the
code.
A
So
one
thing
we
need
I
need
to
mention
here
is
in
ballerina
program.
We
can
have
two
representations,
one
is
textual
representation.
We
are,
we
have
the
source
code,
the
other
one
is
the
graphical
representation
we
have,
which
we
have
the
graphical
sequence
that
so
every
function
written
in
ballerina.
Has
these
two
representations.
A
So
in
my
in
my
demo
I
will
show
you
what's
the
graphical
representation
of
my
code,
written
in
later
part,
okay,
the
next
feature
is
go
to
cloud.
We
are
in
cognitive
applications.
A
The
main
thing
is
we
need
to
once
you
create
services,
you
need
to
create
cloudant
cloud
artifacts
and
then
deploy
in
the
cloud
environment.
So
in
ballerina
we
have
compiler.
We
have
this
option
called
cloud
where
you
can
pass
the
pass
which
artifact
you
need
to
build
once
you
build
the
ballerina
project,
so
we
supports
generating
kubernetes
and
docker
artifacts,
and
we-
and
we
also
have
this
cloud.thermalconfig
file-
you
can
override
any
configuration
which
need
to
pass
into
the
artifacts.
You
create.
A
A
Gm
ballerina
also
support
all
the
features
and
all
the
operation
which
supports
in
grpc,
like
tooling,
support
to
generate
source
code
using
a
protobuf
file
and
authentications
error
handling
and
communication
patterns.
All
the
communication
patterns
are
supported
and
metadata,
which
rpc
call
related
informations
are
passed
into
as
key
value
pass.
A
Next,
one
is
deadline.
Deadline
also
supports
on
top
of
evaluate.
A
Okay.
Let
me
quickly
go
through
one
by
one.
First
is
the
tooling
support
like
in
other
languages?
We
als
in
ballet
now
also
we
have
a
special
cli
tool
to
generate
source
code
from
the
protobuf
file,
so
we
have
this
grpc
command.
We
can
give
the
input
for
file
name,
protocol
file
path
or
file
directory,
and
we
can
specify
which
the
place
where
we
need
to
generate
the
source
files,
and
we
have
this
another
additional
parameter
called
mode.
A
If
you
specify
a
service,
it
will
additionally
generate
a
skeleton's
bell
file
where
all
the
remote
functions
embedded
there
and
it's
easy
for
you
to
program
from
from
the
skeleton
okay,
I
will
show
you
in
the
demo
in
detail
how
we
use
the
other.
One
is
authentication
authentication
we
have
so
like
I
said
earlier,
we
in
ballerina,
we
have
a
listener
listener
and
the
service,
so
listener
is
supposed
to
connect
with
the
network
and
so
the
trial.
A
So
in
grpc
we
support
whole
bunch
of
security
features
from
transport
level,
security
to
application
level,
security,
the
transport
level,
security
or
the
channel
predictions
are
configured
at
listener,
level
and
application
level.
Securities
are
attached
to
the
service
via
service
annotation
configurations.
A
Next
one
is
error:
handling
grpc,
error
handling
is
very
important,
so
they
have
these
error
status
codes
predefined
and
they
are,
they
are
using
many
terminating,
the
connections
etc.
So
in
ballerina
also
we
define
the
error,
predefined
data
types
for
each
and
every
error
code.
A
Okay,
let's
jump
into
the
demo,
so
all
the
communication,
the
communication
patterns-
I
show
it
in
the
demo
itself,
so
I
took
the
example
in
the
grpc
website
the
route
guide
example.
A
Okay,
let
me
move
it
to
the
vs
code,
I'm
using
vs4
for
my
develop
my
demo,
because
ballerina
has
a
very
good
plugin
for
the
vh
code.
It
shows
all
the
syntax
highlighting
and
citizens
and
etc,
and
I
I
already
installed
ballerina
this
latest
melbourne
distribution.
So
if
you
want
to
want,
you
can
go
into
the
ballerina
io
website
and
you
can
get
the
distribution
and
install
installation
is
very
easy.
A
So
this
is
the
protofile
I'm
going.
This
is
the
rocket
protofile
I'm
going
to
use
in
my
demo.
This
is
taken
from
the
grpc
github
repo.
Let
me
open
the
terminal,
so
we
all-
and
we
also
have
a
json
file
where
we
have
these
all
the
features.
So
I
will.
I
will
load
this
in
the
service
application
and
use
it
in
my
application.
A
A
Once
you
create
it,
you
can
see
a
new
directory
is
generated
and
within
that
we
have
this
main.bell
file,
it
spins
the
hello
world,
and
this
is
the
modules.
So
we
buy
your
module.
We
import
that
io
module
and
use
the
printer
length
functions
to
print
there
print
the
message.
A
So
we
don't
need
this
done
file,
so
I
go
and
remove
this
for
now
and
we
all
we
also
have
ballerina.thermal
file
where
all
the
manifest
all
the
metadata
manifest
of
this
project
is
contained
there.
So,
let's
keep
that
and
let
me
generate
the
sub
files.
A
A
If
you
use
the
protoc
compiler
and
generate
the
bytecode
and
convert
those
bytecode
into
the
source
code,
so
this
is
the
stop
file.
This
is
the
generic
subfile
which
choose
for
all
bit
or
in
client
and
server
side.
This
is
the
client
code.
I
will
discuss
this
in
later.
This
is
the
template
file.
A
Skeleton
file
we
generated,
so
it
has
this
service
object
and
we
have
this
listener
and
it's
initialized
into
1990
port
and
we
are
listening
in
1994
there
and
this
service
is
named
as
route
guide
and
it's
the
end
point
is
now
attached
service.
So
this,
whenever
the
message
come
into
the
listener,
it
will
dispatch
it
to
this
service
and
we
have
these
four
remote
functions.
A
So
if
you,
if
you
compare
with
the
protofile
generator
with
the
source
code,
you
can
see
very
similarities
looking
by
and
by
looking
in
the
service
you
can,
you
can
derive
all
the
informations,
so
first
I'll
be
looking
into
I'll,
implement
the
get
feature
remote
function,
which
is
the
simple
rpc
one
for
now.
I
will
return
on
supported
error
messages
here,
so
temporarily
we
can
once
we
implemented,
we
can
remove
them.
A
Okay,
now
we
only
we
need
to
implement
this
get
feature
function.
The
trigger
function
is
it's,
we
get
a
location
and
we
need
to
check
what
are
the
features
attached
to
that
point
and
return
that
field
feature.
If
not,
we
will
return
and
feed
switched
with
name
for
that.
We
first
need
to
populate
the
json
json
file.
A
Okay,
so
when
you
look
at
the
api
docs
it
keep
file
with
json
returns
an
error
and
json
value.
So
you
you
can
either
handle
the
error
inside
the
function
or
you
can
return
it.
I
choose
the
option
to
return
it,
so
in
ballerina
we
have
this
check
command.
If
you
check
it,
it
will
written
the
error,
so
we
don't
need
to
finally
inside
the
function.
A
So
now
we
have
this
json
file
and
we
need
to
convert
these
json
files
to
the
right
way.
We
are
interested
which
is
array
of
features,
and
then
let's
call
file
pages
and
variable
and
let's
say
another
type,
so
it's
very
easy.
We
we
can
just
convert
the
json
file
into
the
ballerina
type
and
then
we
can
we
just
let's
return
the
features
here.
A
A
So
we
need
to
initialize
it.
We
can
initialize
it
using
unique
function,
it's
same
like
the
constructor
in
java,
so
it
will
be
called
when
we
initialize
in
the
service.
So
let's
me.
A
A
A
Okay.
Now
we
have
done
the
first
remote
function,
so
we
can
go
and
run
so
in
ballerina.
We
have
the
command
call
bell
run
once
it
runs.
It
comprise
the
code
and
run
it.
A
Meanwhile,
while
it's
running,
I
will
go
and
create
a
client
application
as
well.
Let's
call
brand
new
client.
A
A
Okay,
so
here
we
have
this
client
client
object
generated
and
that
client
object
have
all
these
remote
functions,
and
so
we
are
initializing
the
client
using
endpoint
url
and
from
the
end
point
we
can
call
this
remote
function
using
this
arrows
network
sign
and
pass
the
values
and
it
will
return
a
response.
A
A
Okay,
all
compile
is
successful
and
I'll
get
a
correct
feature
with
new
jersey
address.
So
let
me
go
and
quickly
do
the
server
streaming
one
also
so
server
streaming.
We
will
get
a
range
and
we
need
to
filter
out
all
the
features
which
is
there
in
the
range
and
then
return
that
back
so
for
that
we
first
need
to
set
the
boundaries
of
the
range.
So
let
me
use.
A
It
as
the
input
value,
so
it
will
be
at
high.
A
A
Now
we
set
the
boundaries
now
we
need
to
iterate
to
the
features
back
again
and
build
out
the
features
for
that.
Let
me
use
a
query:
expression,
query,
syntaxes,.
A
A
A
So
here
we
now
we
have
done
the
service
part
for
client
side.
I
just
copied
the
copy
the
code
to
to
save
some
time,
so
I
just
need
to
type
two
other
outputs.
A
A
A
Okay,
perfect
I'll,
get
the
correct
output.
I
get
the
list
of
features
which
in
the
range
which
it's
in
the
in
with
defining
here
so
now
we
have
done
both
client
streaming
and
server
streaming,
and
I
said
I
will
show
you
the
graphical
representation
of
this.
So
let
me
click
on
this
diagram.
A
So
here
you
can
see.
This
is
the
graphical
representation
we
just
write
down.
So
so
we
have
the
start,
and
this
end
point
is
the
is
the
an
actor
in
the
sequence
diagram
and
that
sequence.
That
is
the
end
point
we
are
trying
talking
about
and
we
we
are
calling
to
remote
network
calls
a
gate
feature
and
this
feature
and
that
and
all
the
logics
created
are
shown
in
these
boxes.
A
A
Okay,
now,
let's
go
ahead
quickly,
I'll
quickly,
copy
this
kind
streaming
part
and
the
by
direction
the
streaming
part
to
save
some
time.
So
let
me
copy
the
client
stream
in
one
client
streaming.
One
means
we
will
get
a
stream
of
stream
of
point
stream
and
we
need
to
calculate
the
route
summary
from
it.
A
Okay,
let
me
go
through
the
code
that
you
call
on
client
streaming
code
from
route
report
route.
What
we
are
doing
here
is
we
will
get
a
stream
of
points
which
travels
and
that
we
and
we
at
the
end
of
the
stream.
We
need
to
return
a
route
summary
for
the
client.
So
when
we
go
to
the
route
summary
definition
you
can
see,
you
have
point
count,
feature
counts,
distance
and
the
elapsed
type.
A
So
I
I
initialize
the
local
variables
here
and
we
I'm
iterating
it
through
this
stream,
and
I
increment
the
point
count
so
that
we
get
the
point
count
and
then
we
I
either
already
do
the
features
and
that
see,
and
then
we
check
whether
there's
a
feature
attached
to
that
point.
If
it
does,
we
will
implement
the
feature
code
as
well,
and
then
we
have.
A
We
check
whether
the
last
point
is
a
valid
point
and
if
it
is,
does
we
will
calculate
the
distance
between
the
last
point
and
the
current
point,
and
we
replace
the
last
point
with
the
current
point
and
so
in
client
streaming,
one
you,
you
can
get
an
error
from
from
the
client
client
can
terminate
the
connection
at
any
time
and
by
sending
an
error.
So
if
we,
if
the
client
terminates
the
error
it
it
will,
will
exit
from
the
stream
and
return
it
as
an
error.
A
A
So
there's
one
point
to
mention
here
so
here
you
can
see
I
didn't
when
we
are
creating
the
value
we.
I
didn't
mention
the
field
name
here.
It
is
because
the
field
names
and
the
variable
name
I
created
in
the
here
is
same.
A
If,
if
the
field
name
and
the
variable
names
are
same,
you
don't
need
to
mention
the
field
name
field
name
and
assign
the
value
there.
You
can
just
pass
the
variable
name
variables
so
that
the
compiler
level
it
mapped
to
the
correct
phase.
A
Okay,
let
me
just
quickly
move
it
to
the
client
by
direction
streaming.
Exam
remote
function
as
well
before
we
move
to
the
client
side
when
it
comes
to
bi-direction
streaming.
I
need
to
mention
one
point
here.
So
in
all
our
scenarios,
we
have
the
response,
all
the
messages
which
need
to
send
it
to
the
clients
and
we
send
it
as
one
go,
but
that's
not
the
use
case
for
all
all
the
other
scenarios.
There
can
be
situation
where
we
have
messages
are
all
the
messages
are
not
available
at
one
go.
A
A
Those
are
already
also
generated
at
stops,
so
we
can
use
the
code,
we
can
edit
the
remote
function
and
add
a
call
additional
input
parameter
called
caller.
This
caller
is
same
like
stream
observer
in
java
and
stream
means
poland.
A
A
Okay,
so
since
so
we
have
this
route
notes
coming
as
a
stream
route
notes,
is
a
location
plus
location
plus
the
message
and
those
messages
are
coming
as
a
stream
here,
so
we
are
iterating
it
through
the
stream
and
we
general
we.
We
are
storing
all
these
key
route
nodes
in
maps.
Let
me
initialize
map
here.
A
Okay,
so
map
here,
so
we
check
we
first
compute
the
key
and
check
whether
there
are
there
already
exists
route
nodes.
If
this
does,
we
will
send
it
to
the
caller.
If
not,
we
will
edit
it
in
the
route
note
map
and
similar
to
client
stream.
We
will.
We
can
get
an
error
from
the
client.
If
it
does.
I
will
log
that
data
here,
so
we
have
done
the
server
service
part
now
and
let
me
quickly
go
and
copy
the
client
code
as
well.
A
So
in
the
client
code,
first
client
streaming
use
cases
we
have.
We
have
two
points
defined
in
the
array
and
when
we
are
calling
the
endpoint
like
in
other
one
unlike
another
one,
it
returns
a
streaming
client
it's
because
for
client
streaming
and
bi-directional
caches.
We
need
to
send
multiple
messages
to
the
server.
In
order
to
facilitate
that
we
have
a
client
streaming
client
from
the
client
streaming
client.
We
can
call
this
function
to
send
message
one
by
one.
A
Once
you've
done
all
the
send
all
the
messages
you
can
call
complete
method
to
say
to
server
that
we
have
done
with
sending
all
the
message
of
the
messages
and
we
are
crossing
it
at
our
site
and
then
we
can
call
the
receive
method
to
receive
the
response
from
the
server
and
I'm
just
printing
that
here
let
me
copy
the
pass
by
direction
streaming
as
well,
so
I
will
quickly
go
through
because
I'm
running
out
of
time,
if
you
have
any
question
I
will,
I
can
explain
it.
A
Okay,
so
let
me
quickly
go
through
the
bi-direction
streaming
thing
as
well,
so
we
have
this
route
nodes
added
defined
with
all
the
values
we
need
to
send
it
to
the
server
and
similar
to
the
client
streaming.
When
we
call
the
remote
function,
it
will
return
a
streaming
client.
There's
there's
one
thing:
one
point
I
need
to
mention
this
receiving
and
sending
is
asynchronous.
It
can
happen
simultaneously.
A
So
so
we
need,
we
cannot
handle
it
by
one
trait.
So
what
I'm
doing
here
is
we?
I
create
a
new
function
and
inside
the
function
I
call
the
receive
my
meth
detriment
method
and
receive
the
nodes
and
iterate
it
to
the
nodes
and
call
the
receive
function
of
it
and
pin
the
message
and
that
function
is
we
start
a
new
trade.
A
In
start
from
the
start
keyword,
we
can
start
a
new
trade,
it
will
return
a
future
and
in
the
meantime
I
will
send
iterate
to
the
doubt
notes
and
send
it
to
the
cell,
and
once
it's
completed,
we
can
wait
till
this.
All
the
server
responses
are
coming
back
to
the
client.
A
Okay.
Now,
that's
it
from
that's
it
from
the
implementation
side.
We
have
completed
both
grpc
server
application
and
the
client
application,
so
we
can
run
and
see
so,
let's
run
the
server
and
also,
let's
run
the
client
as
well.
A
A
Okay,
everything
is
perfectly
fine,
so
this
is
the
fin
route
summary
we
get
it
from
the
server
side,
and
these
are
the
messages
in
the
bi-directional
streaming
case.
So
we
are
done
writing
both
server
and
client.
Before
we
wind
up.
I
need
one
thing
to
mention
about
this
generating
cloud
artifacts.
A
So
since
we
have
this
server,
I
will
quickly
go
and
demonstrate
how
we
can
generate
these
build
art
facts
in
battlefield
grammar.
We
have
this
background
command
which
generate
the
ballerina
artifacts,
and
we
have
another
option
called
cloud
yeah.
We
can
give
whether
we
need
to
generate
additional
docker
artifacts
or
the
kubernetes
artifacts.
A
A
A
Json
file
to
populate
the
data,
so
I
just
asked
them
to
copy
those
json
file
also
into
the
container.
Those
configuration
can
be
done
through
the
thermal
file.
So
once
you
run
this
run
valve
build
by
passing
docker,
it
will,
in
addition
to
building
the
ballerina
artifacts.
We
also
built
docker
images
and
puts
it
into
the
local
repository.
A
A
A
Okay,
so
you
can
kubernetes
are
these
traps
is
generated
so
in
the
target
directory?
You
can
see
this
server
dml
file.
You
can
change
this
configuration
through
the
terminal
file,
so
you
can
you
can
just
once
it's
created,
you
can
just
need
to
apply
this
command
to
apply,
generate
the
deployments
and
also
using
the
deployment.
You
can
create
a
service
with
notepod
and
then
you
are
done
so
that's
it
from
the
demo.
So
let
me
go
to
the
slide
deck
again.
A
So,
okay,
that's
it
from
the
communication
pattern
in
ballerina,
we
support
all
the
communication
patterns
and
you
can
write
it
very
easily
and
the
other
one
is
metadata.
Meta
data
means
the
rpc.
Related
information
has
key
value
pass,
sent
with
the
message.
A
So
we
give
the
support
to
add
those
key
value
pairs
in
the
message
and
send
it
to
us,
send
it
as
like
this
message
and
for
streaming
one
we
are
since
the
edison
should
be
at
at
the
beginning
of
the
stream,
so
whether
if
we
send
the
headers
later,
if
you
are
going
to
ignore
that
and
for
deadlines
thing
deadline,
we
always
support
deadline
through
headers.
So
once
you
we
have
this
api
called
set
headline.
A
Okay,
that's
it
from
the
demo
and
the
presentation.
In
summary,
ballerina
is
modern
programming,
language
optimized
for
writing,
education
and
the
cognitive
environment,
and
the
type
system
is
designed
to
make
the
network
data
processing
easier,
and
it
has
the
first
class
services,
support
and
function
with
objects
and
grpc
also
supported
that
balance.