►
Description
Docker has become an increasingly important subject when we talk about containers. However, it's made to be used by humans. What if we needed containers to be controlled by other applications? Is it possible to do it by using JavaScript? In this talk, we'll build a container control application that will communicate with a container runtime through gRPC and will manage all our containers. Welcome to the new era of container management!
A
Hello,
everyone,
my
name
is
lucas
and
I'm
thrilled
to
be
here
to
be
presenting
you
on
this
awesome
event.
Well,
let's
get
started
to
it,
so
we
don't
lose
any
more
time.
Okay,
so
today
we're
going
to
be
talking
about
integrating
containers
into
javascript
in
several
ways.
I've
been
doing
this
and
how
did
I
get
to
this
and
how
we
can
leverage
this
power?
Okay.
So
basically,
these
are
my
social
networks.
This
is
my
email.
My
name
is
lucas
santos.
A
I
am
a
developer
advocate
from
sao
paulo
brazil
here,
a
microsoft
and
if
you
wanna
get
in
touch
with
me
in
any
way,
just
put
my
social
network
dot.
L
from
lucas
l,
centers,
dot,
dev.
Okay.
So
if
you
want
to
know
anything
about
me
at
all,
if
you
want
to
know
any
other
social
networks
just
go
to
info.alsantos.dev,
okay,
then
let's
get
started
right
so
containers
they
are
a
thing
now
right,
they
are
containers.
Containers
are
widely
used
for
a
lot
of
things.
They're
used
in
several
areas
with
several
technologies.
A
Kubernetes
is
here
dockers,
docker's,
dockers
here
and
there's
like
a
lot
of
stuff
that
actually
uses
containers
and
it's
something
that's
been
really
active
and
really
hot
in
the
technology
area,
but
containers
in
a
new
dx
is
like,
since
the
80s
or
something
like
that
they
started
in
linux
and
we
are
not
actually
telling
the
whole
story
of
containers
here
today.
What
I'm
going
to
show?
You
is
just
how
we
can
make
this
work
with
javascript,
and
why
did
I
choose
to
do
that
right?
It's
easy
to
control
containers
right!
It's
pretty
easy!
A
Docker
is
here
to
show
you
to
show
you
that
we
can
actually
control
the
via
like
a
cli
or
something,
and
basically
docker
does
most
of
the
work
for
us.
You
don't
need
to
understand
how
the
underlying
infrastructure
actually
works,
because
this
is
basically,
you
know
not
important
for
you
to
get
your
work
done.
So
controlling
containers
mostly
have
been
done
by
using
clies
or
other
graphical
user
interfaces,
or
something
like
that.
A
But
it's
easy
if
you're
human
right
most
of
the
clies
and
most
of
everything
we
use
now
they're
made
for
human
beings
they're
made
for
people
right
so
doctor
cli
is
awesome.
It
allows
you
to
do
a
lot
of
things
and
there
are
other
toolings
that
are
actually
pretty
good
in
what
they
do
to
allow
us
to
spin
up.
Containers.
A
Kubernetes
is
here
to
show
you
that
we
can
have
a
good
cli
with
control
and
a
lot
of
other
things,
but
the
point
of
all
that
is
that
we
we
need
to
create
things
as
if
they
didn't
were
they
didn't
were
created
for
humans
right.
So
all
this
tooling
has
been
created
to
be
used
by
humans
in
the
command
line
interfaces
instead
of
programmatically
through
an
api
or
something
like
that.
A
But
what
happens
if
you're,
not
a
human,
if
you're
like
a
program,
an
api
or
an
operator,
or
something
like
that,
you
might
face
a
hard
time
by
you
know
doing
that
for
a
lot
of
reasons
that
I'm
going
to
show
you
and
now
we
are
going
to
just
understand
what
is
what
we're
actually
working
with
right.
So,
to
present
this
to
you,
we're
going
to
use
a
technology
called
container
g.
It's
actually
a
tool
that
was
built
by
oci
oci
is
a
the
open
container
initiative.
A
It's
built
up
by
like
a
lot
of
companies,
including
docker
and
microsoft,
and
a
lot
of
other
companies
and
the
the
basic
idea.
The
goal
of
the
oci
is
to
create
a
standard
interface
for
all
containers
and
all
images
that
we
use
today.
So
container
d
is
a
high
level
runtime.
Actually
it's
more
like
a
runtime
manager
because
it
controls
something
called
called
run
c
inside
a
linux
machine.
A
So
what
we're
gonna
do
today
is
that
we're
going
to
spin
up
a
linux
machine
right,
so
I'm
going
to
use
a
linux
machine
with
container
installed
and
run
c
installed.
So
we
can
run
our
demos
and
our
examples
here.
So
basically,
this
is
why
containers
are
actually
widely
used
in
linux
and
not
so
much
in
other
os's
right
it
powers,
docker,
so
docker
actually
uses
container
d
underlying
its
implementation
infrastructure.
A
It
was
part
of
docker
in
the
beginning
and
then
was
split
up
into
several
other
stuff
and
continue
d
differently
from
docker
or
other
building.
It
was
created
to
be
manipulated
through
an
api
or
an
sdk
client
or
whatever
right,
despite
container
d,
also
has
a
cli
interface
called
ctr,
because
it's
actually
pretty
easy
to
manipulate
containers
using
the
cli
and
basically
container
d.
Actually
does
that
for
you?
If
you
have
like
a
cli
or
something
you
don't
need
docker
installed
in
your
machine
and
you
don't
need
anything
else
installed.
A
So
it
has
a
cli.
Have
you
know,
despite
being
created,
to
be
used
programmatically,
but
this
is
not
important
actually
having
the
cli
is
one
of
the
parts
that
will
allow
us
to
control
it
a
bit
better,
but
that
was
one
of
the
attempts,
but
container
d
is
actually
widely
used.
Most
of
the
container
run
times
uses
container
d
in
underlying
infrastructure
or
run
c
in
some
way,
but
it's
not
so
easy
for
javascript
developers.
A
So
if
you
go
google
or
whatever
search
engine
or
whatever
documentation,
you
might
find
you're
gonna
see
that
most
of
the
container
things
are
done.
Using
go
container
d
is
actually
built
using
gold,
docker
is
built
using
go
run
c,
is
built
using
go
and
there's
like
a
lot
of
other
things
that
we
can
do,
but
they
are
mostly,
you
know,
aimed
to
golang
developers.
This
is
one
of
the
examples.
A
But
then
I
actually
came
across
a
article
that
made
me
think
of
it.
This
is
actually
not
wrong
right.
It's
not
actually
wrong
to
be
written
in,
go
it's
programmatic
and
it's
a
great
code,
but
it's
not
intuitive.
It's
not
that
intuitive.
For
those
who
doesn't
know
goaling
or
whatever
other
language,
so
I
came
across
this
awesome
article
by
marcos
how
to
get
a
browser
to
communicate
with
container
d
through
grpc.
A
A
I
know
how
to
do
this
using
the
javascript
command
line,
and
I
know
how
to
use
this
on
javascript
itself
that
we
have
like
a
lot
of
libs
that
allows
us
to
create
a
javascript,
a
plain
javascript
job,
pc
interface,
and
that
are
very
actually
good
to
do
this,
so
I
tried
a
first
attempt.
Okay,
so
the
first
attempt
I
did
was
sometimes
good,
mostly
bad,
but
it
kind
of
worked
and
it
was
ugly
at
all.
A
But
the
first
thing
this
first
attempt
is
just
a
proof
of
concept
to
show
us
that
our
two
actually
actually
there
are
two
ways
or
even
more
ways
that
we
can
integrate
continuity
into
node.
It's
actually
a
simple
way
to
you
know
avoid
being
so.
You
know,
verbose
and
trying
actually
not
to
know
all
the
concepts
you
don't
need
to
know
all
the
concepts
behind
container
d
to
make
this
work,
so
the
first
attempt
was
to
use
chat
process.
A
So
basically,
what
I
did
was
that
I
created
a
child
process
and
I
spawned
this
chart
process
to
actually
create
instances
of
the
ctr
container
interface
and
well.
This
worked
very,
very
well
right,
so
container
d
has
this
cli
called
ctr,
which
I
already
told
you,
and
it's
able
to
do
like
a
lot
of
stuff,
maybe,
like
everything
that
container
d
can
do,
is
able
to
do.
You
were
able
to
do
via
the
ctr
command
line
interface.
A
So
what
I
did
was
just
I
put
all
these
commands
into
a
node.js
process
and
try
to
build
something
out
of
it.
I'm
going
to
show
you
the
code,
but
let's
talk
about
the
pros
and
cons
of
this
first
right,
so
you
might
be
thinking
well.
This
is
easy.
I
can
do
this
at
home.
Of
course
you
can
do
this
at
home
and
I
encourage
you
to
do
so.
It's
actually
very,
very
nice
to
see
these
things
working,
but
the
pros
of
this
is
that
it's
super
easy.
A
It's
very
easy
to
integrate,
using
a
command
line
interface
and
using
ctr
using
chat
process.
Chat
process
is
actually
amazing
to
use,
and
you
have
like
a
lot
of
tooling.
On
top
of
that
that
you
can
indeed
use
and
well.
This
is
one
of
the
the
pros.
The
other
thing
is
that
it
takes
advantage
of
all
the
implementation.
That's
already
done
in
the
ctr
in
the,
so
you
don't
actually
need
to
be
so
into
containers
or
you
don't
need
to
know
how
container
d
actually
works.
So
you
can
make
everything
work
inside
javascript.
A
You
just
need
to
know
how
to
call
a
process,
and
you
just
need
to
know
how
to
control
that
and
well
it's
a
faster
implementation.
So
basically
you
can
do
things
very
very
fast.
I
did
this
and
I
did
this
container
decline
in
like
one
hour
or
so
right
and
can
be
integrated
into
any
api.
Basically,
if
you
can
manipulate
this
through
the
code,
you
can
integrate
this
using
the
apis.
So
it's
actually
so
simple
that
I
did
this.
A
I
did
this
amazing
container
the
api,
which
is
basically
a
you,
know,
vanilla,
javascript,
running
es
modules
in
the
browser
and
it
doesn't
need
anything
else,
just
some
css
and
some
html
and
it
kind
of
works.
So,
as
you
can
see,
I
can
create.
I
can
list
images,
so,
let's
jump
to
the
code-
and
I
can
show
you
this
actually
working.
A
So
this
is
our
code
and
basically,
what
I'm
going
to
show
you
is
this
small
server
it's
built
using
coa.
So,
as
you
can
see,
it's
just
a
few
routes,
a
delete
route,
a
boot
route
and
so
on.
So
we
can
create
containers.
This
is
our
course,
and
we
have
a
body
parser
and
allowed
methods
and
so
on.
So
this
is
a
base
kpi,
and
this
only
calls
the
ctr
okay.
So
ctr
is
a
container
d
client
that
I
called
container
deep
because
of
obvious
reasons-
and
this
is
actually
everything
that
does
the
work.
A
A
Web
server,
so
this
is
all
the
same
just
to
serve
the
html
and
basically,
what
you
can
see
here
is
that
I
have
my
implementation
of
continuity,
basically
using
just
child
process
promises-
and
this
is
actually
it.
So
we
have
these
actions
that
I
freeze.
We
have
the
list
name
space
action,
so
I
just
exact
a
sync,
so
I
just
run
an
execution,
a
sync
execution
of
ctr
client.
This
is
really
really
just
the
proof
of
concept
right,
so
we
have
a
list.
A
If
we
have
a
standard
error,
then
we
just
error
out.
If
we
have
a
another
thing,
that
is
not
a
standard
error.
We
can
pause
this
string
output.
So
basically,
this
is
the
idea,
so
I
can
parse
the
string
output.
I
can
run
everything
that
I
need
into
this
thing.
So
basically,
this
is
the
amazing
container
api.
As
you
can
see,
I'm
a
backend
developer.
I
don't
have
a
lot
of
experience
and
I
can't
do
good
front
ends,
so
I
can
change
the
phone
name.
A
Space
container
is
based
on
namespaces,
so
I
can
change
the
phone
name
space,
but
I
won't
do
this.
I'm
going
to
download.
I
have
this
network
manager
here
open
on
devtools,
so
I'm
just
going
to
show
you
how
these
things
are
working,
but
I'm
going
I'm
going
to
pull
this
image,
so
I'm
going
to
pull
the
go
volt
api,
which
is
a
simple
image.
It
looks
like
it
weighs
more
like
5
megabytes
or
something
like
that.
A
Then
I
can
create
a
container
from
this
image
and
I
have
this
website
already
open
for
for
api.
This
runs
on
8080.
So,
as
you
can
see,
nothing
actually
happens
here
because
the
container
is
not
running,
but
I
can
actually
run
a
task
to
run
this
container.
So
once
once
I
create
this
task,
my
container
is
gonna
run
here
and,
as
you
can
see,
I
can
actually
use
my
api
and
I
didn't
need
to
integrate
anything
into
anywhere.
So
I
just
can.
A
I
can
just
kill
my
task
delete
my
container
delete
my
image
and
everything
is
gonna,
be
back
to
what
we
had
before
okay.
So
this
was
my
first
attempt
of
creating
something
that
was
going
to
be
used
as
an
integration
for
container
d
right.
So
this
is
not
it's
pretty
good,
but
we
have
some
cons,
as
you
may
have
seen
on
that.
The
first
thing
we
have
is
that
it's
heavily
dependent
on
the
environment
you
have
so
whatever
you
were
doing
you
just
need
to.
A
You
can
just
run
this
client
if
you
have
it
installed
in
the
same
machine
as
your
container
d
binary.
So
if
you
have
like
on
you
have
a
machine
with
container
d
inside
it
and
you
need
to
run
this
api
in
somewhere
else.
Basically,
you
can
do
it
because
it
needs
to
be
installed
in
the
same
machine
as
the
api.
Of
course,
you
can
actually
run
continuously
around
this
api
and
then
run
a
reverse
proxy
or
something
on
top
of
it
to
communicate
externally
or
remotely
to
this
api.
A
A
So
if,
by
any
chance,
the
ctr
runs
into
a
problem
or
something
that
we
haven't
anticipated
and
being
honest,
it's
really
really
difficult
to
anticipate
any
sort
of
errors
that
happen
in
a
command
line
interface,
because
it's
not
meant
to
be
giving
you
all
details
of
the
error,
because
it's
basically
built
to
be
used
by
humans
right,
not
machines.
So
you
can
control
all
the
process.
A
You
just
control
its
inputs
and
you
receive
all
these
outputs,
and
this
is
everything
that
it's
bad
about
it
because
you
receive
a
output,
that's
basically
a
giant
string
and
you
need
to
parse
this
string
to
you
know
figure
out
whatever.
If
you
had
any
errors
or
something
some
of
the
clients
like
container
decline,
ctr,
they
have
a
quiet
mode
that
doesn't
output,
headers
or
something.
But
it's
you
know
poor.
A
I
can't
actually
get
the
container
status
or
the
image
status
or
task
status,
because
these
these
informations
are
actually
hidden
behind
a
parsing
or
a
table
like
structure.
Something
like
that
and
basically
what
you
have
to
do.
What
we
have
to
do
is
to
parse
this
giant
string
and
use
string,
parsers
and
so
on.
A
We
can
use
whatever
thing
that
we
can,
but
this
is
basically
running
all
the
errors
in
one
place
and
trying
to
figure
out
how
to
parse
everyone
using
regex
and
using
you
know,
every
sort
of
hacking
that
we
can
do
in
strings,
so
this
is
really
really
bad.
This
is
one
of
the
reasons
why
this
api
and
this
front
end
doesn't
actually
return
a
good
error
handling.
A
Sometimes
when
we
run
into
an
error
like
the
image
red
exists
or
the
image
doesn't
exist,
it
returns
like
a
chorus
error
or
something
like
that,
and
I
can
actually
return
this
because
I'm
marrying
this
out-
and
this
doesn't
return
my
error
properly
right.
You
need
sudo
to
be
run.
Although
this
is
actually
possible
to
be
removed,
you
can
configure
it.
You
can
configure
its
container
d
to
run.
This
in
is
as
another
user
okay.
So
there
is
a
config
file
in.
A
I
think
it's
slash,
cdc,
slash
container
d
config.tamal
that
allows
you
to
change
the
default
user
id
and
the
file
group
id
the
container
is
going
to
create
its
sockets
and
it's
going
to
create
all
this
process.
So
you
can
actually
change
this
to
allow
you
to
run
continuity
without
sudo,
but
it
requires
extra
configuration
right
and
actually
this
is
the
most
important
part
we
had
the
the
error
strings.
A
So
if
we
run
into
any
attacks
or
if
we
run
any
into
any
hackers
or
something,
we
need
to
sanitize
all
user
inputs
for
api,
because
this
otherwise
can
be
passed
on
to
our
container
decline,
and
this
can
run
some
things
that
we
don't
want
to
run
inside
our
machine
right.
So
you
actually
have
to
be
very
careful
on
that.
A
So
the
conclusion
is,
we
can
integrate
containers
into
javascript.
This
is
the
first
way.
This
was
the
proof
of
concept
that
I
needed
to
make
sure
that
this
was
actually
possible,
but
I
wanted
to
do
this.
A
real
integration
like
I
wanted
to
integrate
this
without
manipulating
external
stuff
and
manipulating
things
that
are
already
there,
so
I
wanted
to
actually
create
something
that
was
going
to
be
native
okay,
but
not
so
native,
because
it's
just
jrpc
right.
A
So
the
second
attempt
I
did
was
to
read
on
to
the
container
the
jpc
interface,
so
continuity
was
meant
to
be
extended,
you
can
extend
continuity
and
it
has
a
grpc
interface
that
allows
you
to
do
so.
So
if
you
have
like
this
is
these
are
all
the
proto
files
and
you
can
see
these
are
all
the
concepts
that
container
d
actually
has
containers,
content,
dips
events,
images,
introspection,
leases
and
namespaces
snapshots
tasks
and
whatever
thing
else
that
you
want
to
do-
and
this
is
like
the
image
service.
A
Okay,
so
we
have
a
gather
list
to
create
an
update
image
and
so
on.
The
problem
is,
you
need
to
know
how
to
do
it,
because
the
interface
needs
you
to
control.
Every
aspect
of
a
container
creation
pipeline
from
downloading
images
to
downloading
blobs
reading
manifests
creating
containers
creating
an
oci
spec
for
both
the
image
and
the
container,
creating
all
the
bindings.
You
need
from
the
file
system
to
the
container,
creating
all
the
flags
needed
and
everything
else.
A
A
So
in
every
aspect
of
the
container
creation
and
every
aspect
of
how
containers
actually
work
for
this,
you
might
need
to
you
know,
read
the
oci
specs
for
image,
the
oc
aspects
for
distribution
or
the
oci
specs
for
the
artifacts
or
containers
and
whatever
okay,
the
run
times
back,
for
instance.
So
this
is
the
the
example.
I
want
to
show
you
if
you
need
to
create
an
image
like
the
list.
A
A
The
image
type
is
just
a
descriptor,
so
basically
the
descriptor
is
just
a
name
and
some
set
of
labels,
a
descriptor,
a
uci
descriptor,
a
timestamp
for
creation
and
update,
and
basically
the
image
is
just
a
pointer
to
a
set
of
blobs,
actually
the
blobs
pointer
to
a
set
of
images,
but
the
image
interface
itself.
I
can't
create
an
image
without
even
downloading
that,
so
I
can
create
this
image.
It's
going
to
be
there,
but
there's
nothing
behind
it.
There
is
no
root
file
system.
There
is
no
file
system
at
all.
A
A
If
I
run
like
ctr
content
list,
we're
gonna
see
that
we
have
all
the
layers
from
our
image
like
it's
just
three
layers,
but
those
are
the
blobs
that
I
downloaded
when
I
pull
the
image
and
in
other
words,
you
need
to
understand
all
the
flux
of
how
to
download
an
image
which
is
not
that
difficult,
but
this
is
not
very
well
documented.
The
documentation
is
a
sparse,
it's
actually
scattered
everywhere
right,
so
it's
possible
to
do
it.
This
is
what
I
did.
A
I
integrated
with
the
gipps
interface,
so
let's
jump
into
the
code,
so
you
can
actually
see
this
working
okay,
it's
not
that
immense
example
or
something
that's
gonna
take
your
breath
away,
but
in
other
words
it
shows
you
that
it's
actually
possible
to
do
so.
So
what
I'm
going
to
do
here
is
just
I'm
loading,
the
proto
files,
so
the
profiles
are
here.
They
are
completely
descripted
and
they
are
completely
downloaded
into
this
thing.
A
Basically,
what
I'm
doing
I'm
loading
these
proto
files
using
the
default
jrpc
module
from
node.js.
So
this
is
it's
a
bit
laggy
because
I'm
using
x
to
execute
visual
studio
code
outside
of
my
linux
vm.
So
this
is
running
inside
the
linux
vm.
So
it's
a
bit
laggy,
but
I'm
using
jpcgs
in
the
product,
loader
to
load
an
image
definition
and
the
content
definition
here
down
below.
A
As
you
can
see,
so
I'm
just
loading
the
content.proto
and
I'm
loading
the
images
proto
file,
I'm
creating
a
client,
so
I'm
creating
this
image,
client
from
the
container
d
services,
images,
v1
images
and
I'm
binding
it
to
the
unix
socket.
So
this
is
the
address
that
we're
going
to
bind
to
our
jrpc
server.
Okay
container
d
actually
allows
you
to
expose
this
as
a
tcp
and
over
http
server,
and
I
can't
create
this
without
any.
A
You
know
jpc
requires
you
to
have
a
certificate
because
it
uses
http
2
under
the
hood,
so
we
can
actually
create
an
empty
certificate
using
this,
and
we
can
add
this
metadata.
It's
just
a
header
base.
Basically,
so
it's
a
header
named
container
the
namespace
and
we
are
going
to
use
this
namespace
jsctr
right,
so
js
continuity,
and
this
is
the
payload
that
I
can
use
to
create
an
image.
So
it's
the
name
of
the
image
the
target.
A
This
is
the
descriptor,
the
oci
descriptor,
which
is
a
basically
a
size,
a
digest
and
a
media
type
and
the
creation
dates.
So
I
can
create
this
image
using
this
payload
and
that
namespace
and
I
can
list
all
the
images
using
a
filter
which
I'm
just
not
going
to
use
for
the
creation,
I'm
just
going
to
use
the
content
definition
right.
So
in
order
to
do
this
first,
I'm
gonna
run
this
for
you
down
below
here,
npm
start
and,
as
you
can
see,
I
can
download
this
image.
A
A
So,
as
you
can
see,
we
have
a
code,
you
have
details,
you
have
a
lot
of
other
things
and
if
I
execute
this
on
my
amazing
container
api
here,
but
changing
the
namespace
to
jsctr,
we
are
going
to
see
that
this
is
actually
what
we
just
did,
but
I
cannot
create
a
container
from
this
image
because
it's
just
a
pointer
right.
So
this
is
what
I
did
right
now.
This
is
what
I
had
the
time
to
create
for
this
presentation,
because
these
two
content
definitions
does
not
need
actually
any
inputs.
A
So
this
is
the
output
from
the
container
as
the
content
definition.
As
you
can
see,
this
is
just
a
blob
file
that
is
put
into
json
and
basically
this
is
what
we
have
when
we
download
images.
Okay,
so
now
back
to
our
presentation
over
here
we're
running
out
of
time.
This
is
the
pros.
Oh
every
every
of
these
every
one
of
those
two
attempts
have
pros
and
cons.
Okay,
so
the
first
pro
is.
Actually
we
have
proper
error
handling.
A
As
you
could
see,
we
have
a
basically
a
basic
interface
for
errors
and
a
basic
interface
for
handling
these
images
and
these
messages
and
everything
else.
Okay,
so
we
can
actually
return
a
proper
error
to
the
user.
We
have
proper
return
codes,
so
we
can
actually
return
proper
errors
to
the
user
and
allows
you
to
fully
control
all
the
aspects
of
the
pipeline.
A
So
if
you
have
anything
that
you
want
to
be
better
or
optimized,
you
have
caching,
you
can
do
whatever
you
want
from
this
pipeline,
like
you,
can
download
the
manifest
and
put
them
into
cache
and
then
download
this
for
further
downloads.
You
can
just
look
into
the
cache
and
then
download
all
the
blobs
again
or
whatever
you
can
optimize
it.
If
you
can
like
find
blobs
into
different
images
that
have
the
same
digest,
you
can
just
use
them
mutually
or
you
can
add
whatever
future.
A
Whatever
features
you
want,
okay,
so
it's
basically
the
whole
control
the
best
of
the
control
you
have
and
does
not
need
to
be
in
the
same
machine.
You
can,
as
I
said,
config
container
g
to
output,
the
jpc
interface
into
a
tcp
port,
but
it
needs
you
to
have
a
crt
certificate,
so
you
need
to
have
a
certificate
file
both
for
the
you
have
to
actually
have
to
have
a
certificate
file
in
a
private
key
file
to
be
able
to
do
that.
A
But
once
you
has
once
you
have
this,
you
can
connect
to
your
grpc
api
for
from
whatever
external
machine
you
have,
so
it
doesn't
require
sudo,
because
you
are
actually
connecting
straight
to
continuity
and
it's
practically
native
okay,
so
you're
just
using
a
native
module
non-native
module
you're
using
a
native
protocol,
you
can
actually
extend
this.
This
is
the
standard
way
to
extend
container
d
okay,
so
the
cons
are
that
it
requires
a
lot
of
knowledge.
A
I
don't
even
know
how
to
start
describing
this,
because
I
didn't
even
discovered
how
to
actually
execute
this
in
a
pipeline
completely.
I'm
doing
this
job,
I'm
to
tell
you
about
this
by
the
end
of
this
talk,
which
is
already
in
hand.
The
documentation
is
a
sparse
both
for
jrpc
in
javascript
and
container
d.
So
you
don't
find
this
very
easily.
You
need
to
actually
read
the
source
code
for
go
or
not
for
google,
but
for
continuity
and
ctr
to
actually
learn
how
these
things
work
and
how
to
build
the
ocr
spec.
A
It's
way
harder,
as
you
can
see
and
might
be
a
problem
to
connect
external
servers,
since
you
need
these
certificate
files
right
and
you
need
everything
to
actually
connect
to
external
servers.
So
what
are
the
next
steps
we
can
do
to
this?
Actually,
this
opens
up
a
very
good
opportunity
to
integrate
javascript
into
containers
and
make
like
ci
interfaces
or
whatever.
Actually
you
want
to
do
using
containers.
A
So
what
I
did
is
that
I'm
starting
a
project
as
you
can
see,
you
can
actually
go
into
my
github
account,
and
you
can
help
me
do
this,
because
it's
really
really
in
the
start
of
this
project,
it's
container
djs
it
there
isn't
anything
that
is
actually
like
it.
So
I'm
building
this
from
scratch.
I'm
going
to
use
everything
that
I've
been
learning
so
far,
and
everything
that
I
can
find
on
documentations
to
build
a
very
native
and,
very
you
know,
useful
client
for
continuity.
A
So
if
you
know
how
to
do
it,
create
more
documentation
post
about
it
blog
about
it
and
actually
share
this
knowledge,
so
we
can
create
a
better
ecosystem
both
for
containers
and
both
for
the
javascript
folks
and
both
for
those
who
actually
love,
containers
and
love
javascript
like
me.
So
basically,
this
is
what
this
is.
What
my
goal
is
to
create
more
documentation
into
microsoft,
docs
and
whatever
other
platforms.
A
We
have
to
make
more
people
able
to
create
containers
and
to
understand
containers
and
to
show
them
that
containers
are
not
that
hard
as
it
seems
to
be
right.
So
these
are
the
refs
that
I
took
so
basically
all
the
github
files
and
all
the
repositories
that
you're
gonna
see
here
all
the
code
that
I
showed
you
is
in
these
repositories.
So
this
is
the
integration
example
using
just
golang
and
continuity
with
a
client.
This
is
this.
A
Is
the
js
container,
the
example
that
I
showed
you
right
here,
and
this
is
the
ongoing
work
to
the
container
djs
client
right.
This
is
mark's
article
about
jpc
web
interfaces
and
he
has
a
lot
of
good
articles
in
his
medium.
I
really
suggest
you
to
go
there
and
read
it:
it's
amazing
how
he
can
integrate
this
into
several
other
languages
like
java.
He
can
do
this
using
grpc
web.
A
It's
amazing
and
well
mark's,
actually
one
of
the
people
that
gave
me
this
idea
to
try
to
integrate
this
into
javascript
and
make
it
work.
So
I
can
share
these
things
with
you.
If
you
want
these
slides,
it's
on
slides.also.dev,
slash,
integrating
containers
into
javascript,
so
I'm
just
gonna
leave
this
here
and
thank
you
so
much
and
it's
a
pleasure
to
be
here.