►
From YouTube: Remote Development Architecture Spike walkthrough
Description
A walkthrough of the architectural spike of the Remote Development feature with https://gitlab.com/cwoolley-gitlab. See the Merge Request https://gitlab.com/gitlab-org/gitlab/-/merge_requests/105783 and associated Merge Requests for more details.
Corrections:
- https://youtu.be/5T4gQFYOwXM?t=351 (I should have said "Services Tier", not "State Tier")
- https://youtu.be/5T4gQFYOwXM?t=413 (There's an error in the diagram, the Workspace updates should also be going all the way to the right to ActiveRecord)
- https://youtu.be/5T4gQFYOwXM?t=598 (Don't pay too much attention to the descriptions of these MRs, they have some outdated info).
(Fun trivia: the number of times I say "Workspation" is greater than 1).
A
Looks
like
this
is
Chad
Wooley
with
gitlab
and
I
wanted
to
catch
everyone
up
on
the
status
of
the
remote
development,
architectural
Spike
and
I've
been
working
on
this
for
the
past
several
days
over
the
holidays
and
I
wanted
to
demo
where
it's
currently
standing
and
give
some
background
information,
and
that
should
hopefully
set
us
up
for
the
next
steps
of
being
able
to
split
up
this
work
and
parallelize.
Everything
else
that
we
have
to
do.
A
The
spike
is
in
a
pretty
good
spot
and
I
think
close
to
being
considered
successful
in
terms
of
proving
out
the
architecture.
So
I'll
start
by
not
marrying
the
lead.
I'll
give
a
demo
of
what
we
currently
have,
which
is
a
working
State,
reconciliation
of
the
state
of
workstations
on
in
the
rails,
database
and
workspaces
in
the
rails
database
and
in
the
kubernetes
cluster
via
the
dev
workspace
operator.
A
So
I'll
start
there's
a
I'm
going
to
explain
all
of
this
in
detail
later,
but
I'm
just
going
to
demo
it
first
there's
a
helper
script.
Scripts
remote
development
create
workspace.
If
you
run
and
over
here
on
the
left.
What
you'll
be
watching
for
is
this
is
going
to
show
all
of
the
the
state
of
the
Rails
of
the
work
spaces
in
the
rails
database.
This
is
going
to
show
the
state
of
the
workspaces
in
the
in
kubernetes.
A
A
It's
like
that
got
a
little
confused,
so
here
we
go
so
create
workspace
and
up
here
on
the
upper
left,
we
should
see
yep,
so
you've
got
the
the
state
here.
The
desired
state
is
running
the
actual
status
creation
requested
you
can
see
over
here
in
kubernetes.
It
got
that
request
and
the
phase
is
started,
and
now
it's
already
running,
it's
got
a
URL.
If
you
go
back
over
here
and
wait
for
the
next
polling
Loop,
it
will
get
updated
shortly.
A
There
we
saw
it
go
through
so
now
the
desired
State
and
the
actual
State
have
been
reconciled.
We
have
a
URL
and
we've
got
the
the
workspace
resource
version.
If
you
click
in
these
things,
they
get
kind
of
confused,
so
we
saw
that
the
creation
worked.
So
let's
try
updating
it
as
well.
So
you
can
see
if
I
do
a
quick
control,
git
workspaces
I
can
grab
the
name
of
this.
I
can't
copy
it
from
over
there,
because
that
sort
of
messes
up
this
little
watch
output.
A
But
then
this
helper,
you
can
set
an
environment
variable
for
the
workspace
name
in
this
scripts.
Remote
development
update
workspace
paste
that
in
there
and
have
the
desired
state.
So
this
is
it's
currently
running,
so
let's
set
it
to
stopped,
and
these
match
the
the
official
phases
that
are
sent
over
from
the
devworks
Network
space
operator.
A
We
don't
really
have
a
state
machine
for
now.
We
might
at
some
point
in
the
future,
but
we're
just
going
directly
off
of
the
state
that
gets
sent
over
free
short
space.
So
if
we
click
that
we
can
see,
if
we
look
over
here,
this
should
change
to
desired.
State
stopped
there.
It
is,
and
it
stopped
almost
immediately.
You
can
see
on
that
pole
over
here
on
the
kubernetes
side
and
then
that
actual
State
got
that
code
back
here.
A
Yep
there's
one
with
a
with
a
second
name
creation
requested,
and
we
see
that
second
one
show
up
here,
waiting
for
deployment
waiting
for
Editor
to
start
and
that
window
a
little
bit
a
little
bit
bigger
and
there
we
go
it's
that
one
is
now
running
and
if
we
were
to
so
you
see
the
URL
is
over
here.
If
we
were
to
click
on
that
URL
and
go
into
it.
A
This
is
just
a
minimal
proof
of
concept
ttyd,
so
we're
running
can't
find
a
group
or
something
whatever
the
workspace
is
successfully
running
and
there's
what
we
have
so
now,
I'll
dig
into
a
little
bit
of
of
what
we're
doing
so.
Looking
at
the
the
architecture
here,
the
so
the
rest
of
this
architecture,
Doc
Page,
maybe
out
of
date,
we
need
to
update
it.
The
part
I've
been
focusing
on
is
all
of
the
logic
for
the
rails.
Workspace
updates,
processing
logic.
A
This
reflects
what
is
going
on
here,
so
you
can
see
here,
there's
a
it's
very
thin
layer.
At
the
great
rest,
the
API
level,
the
the
state
tier,
is
actually
very
thin
as
well.
It's
pretty
much
just
taking
the
params
and
pulling
them
out
the
the
workspace
and
infos.
This
is
what
we
call
them.
That's
the
the
configs
that
are
coming
over
from
kubernetes
and
all
of
the
business
logic
lives
here
in
this
lib
layer
and
that's
what
it's
doing.
A
Some
of
the
the
bigger
chunks
have
been
pulled
out
into
sort
of
loosely
coupled
and
cohesive
things
like
the
parsing
of
the
the
actual
workspace
info
out
of
the
just
the
Json,
the
raw
Json.
That's
sent
into
this
data
object,
type
thing,
and
then
that's
then
passed
around
with
some
logic
in
it,
the
generating
of
the
the
config
the
desired
config
that
we're
going
to
end
up
sending
back
over
to
well
that
got
big
to
send
back
to
the
agent
K
side.
That's
pulled
out
and
the
this
represents.
A
You
know
the
places
where
we're
interacting
with
active
record,
where
we
load
the
workspace
objects
and
then,
where
we
update
them
again
and
also
this
workspace
States
is
up
to
date.
So
these
these
states
right
here
are
the
actual
ones
that
the
dev
workspace
phase
that
are
officially
come
over
from
Dev
workspace
operator.
You
know
this
was
not
a
terminated
one,
so
we'll
we'll
have
to
figure
out
how
to
handle
how
to
handle
that,
but
that's
okay
and
the
the
actual
state.
So
these
ones
over
here
the
ones
that
are
really
supported.
A
There's
this
one
called
creation
requested
which
represents
this
has
been
created
in
rails
database,
but
we
haven't
sent
it
over
to
kubernetes
so
like
it
doesn't
even
exist
there.
So
as
soon
as
we
get
the
first
poll
back
to
this
with
the
name
of
this
workspace-
and
it
says
we
know
it
exists-
then
we-
you
know
we
have
a
phase
of
starting
and
it
and
it
gets
automatically
synced
to
whatever
phase
is
sent
back
from
the
Informer
on
the
kubernetes
side
and
then
there's
the
desired
state.
A
So
this
is-
and
both
of
these
are
some
properties
of
The
Works
base
in
the
database.
This
is
a
smaller
subset,
because
this
is
just
what
I
want
it
to
reconcile
to
so
like
you,
don't
you
wouldn't
have
a
desired
state
of
starting
you
just
you
either
run
it
running
or
stopped
and
again
in
the
future,
we'll
we'll
figure
out
how
to
deal
with
terminated.
There's
some
more
lives
like
it
needs
to
happen
on
the
the
agent
side.
For
that
and
then
there's
a
special
case
which
is
restart
requested
and
this
isn't
implemented.
A
But
it's
basically
that
we
have
to.
You
know
it's
already
running,
but
we
want
it
to
stop
and
restart
again,
so
that
will
be
implemented
by
sort
of
looking
at
some
other
metadata.
If
it's
sent
and
like
if
it's,
if
it's
already
running
it'll,
you
know
send
the
config
to
stop
it
and
then
once
it
stopped,
then
it
will
put
it
back
into
running
State
and
then
automatically
flip
over
the
desired
state
to
running
and
just
wait
for
it
to
eventually
get
in
running
and
which
it
may
never
get
to.
A
A
Even
though
this
is
a
spike,
I
tried
to
make
it
fairly
disciplined
and
clean,
and
it's
100
test
coverage
of
everything
that
I've
written
here,
because
the
CI
won't
go
green.
If
it's
not,
you
can
look
here.
Here's
the
the
latest
CI
build.
You
can
see
it's
completely
green.
No,
no
under
coverage
I
just
pushed
another
little
fix,
so
it's
shaking
another
one
off
the
Mr.
A
The
main
Mr
that
this
is
for
is
this
one:
the
the
805
in
get
live
agent,
we're
sort
of
using
it
to
drive
this
and
there's
two
sides.
There's
the
the
rail
side,
which
is
where
all
of
this
code
that
I
just
showed
you
lived
and
then
there's
a
corresponding
Mr
on
that
the
gitlab
agent
side,
which
is
all
of
the
stuff
over
here
on
the
Go
Side.
Almost
all
that
logic
lives
here
in
worker
dot
go
and
you
can
see
the
structure
like
workspace
and
agent
info
and
the
request
payload.
A
This
is
what's
going
from
the
Asian
over
to
the
rail
side
and
then
the
weren't
face
rails
info
and
the
response
payload.
This
is
the
structure
of
the
things
that
come
back
and
over
on
the
rail
side.
These
have
all
corresponding
structures
right,
so
you
can
see
that
corresponds
to
the
the
actual
workspace
info,
that's
coming
and
then
in
the
the
process,
or
what
we're
sending
back
is
this
sort
of
down
here
this
structure
that
is
going
back
to
the
agent
K
side
to
get
parsed
by
go
and
the
100
coverage.
A
A
A
Models,
ee,
remote
development
and
I
realized
all
of
this
stuff
has
to
live.
If
one
thing
lives
under
the
Enterprise
namespace
everything
does
the
services
the
lib,
the
the
factory
is
everything
or
things
just
the
classes
cannot
be
found.
So
you
see
here,
it's
got.
The
associations
belongs
for
now,
it's
owned
by
a
user
and
a
group,
so,
like
a
user,
is
the
person
who's
using
the
workspace.
A
The
group
for
lack
of
more
product
Direction
at
this
point
is
what
is
the
billing
and
that's
groups
are
actually
single
table
inheritance
of
namespaces
right
and
then,
of
course,
it
has
to
be
assigned
to
an
agent
the
the
git
lab
agent
for
kubernetes
cluster
agent.
So
that's
all
tracked
validates
those
associations
and
then
it
also
validates
the
the
valid
desired
states
that
we
have
over
here.
So,
as
we
saw
this,
this
matches
the
the
dire
the
architecture
diagram
exactly
these
actual
States
and
desired
States.
A
The
the
service
layer
is
very
thin
here.
All
it
does,
is
you
know
validate
that
the
message
hype
we
got
is
good.
The
only
one
that's
currently
supported
is,
you
know,
workspace
updates,
and
then
it
pulls.
This
works
based
agent
info
is
out
of
the
params,
and
this
is
the
again
corresponding
exactly
to
this.
That
gets
sent
over
an
array
of
these
in
the
payload
from
the
agent
K
side,
we
parse
those
out
and
we
send
them
to
the
processor
and
then
all
of
this
rest
of
this
stuff
lives
under
the
lib.
A
You
can
use
the
fast
spec
helper
for
these
and,
if
you
were
to
run
these,
they
run
in
extremely
fast
right,
three
milliseconds,
as
opposed
to
the
other
ones
where
you're
working
in
rails.
You,
when
you
don't
have
that
fast,
spec,
the
it's
a
lot
slower
and
there's
also
this
context.
So
the
State
reconciliation.
A
There
is
a
spec
for
the
the
service
I
started
with
this
one,
and
it's
really
testing
a
lot
more
than
it
needs
to
now
that
I
went
ahead
and
refactored,
most
of
the
all
of
the
real
logic
to
live
under
the
lib
folder.
But
this
is
still
testing
and
there's
this
pretty
much
just
the
happy
path
case
and
there's
this
set
of
shared
contexts
that
are
shared
across
as
multiple
specs
that
have
the
representation
of
the
yaml
and
sort
of
parameterized
sort
of
object.
A
So
that
is
a
little
tour
of
the
code
there
and
if
you
look
at
this
process,
respect
here's
where
most
of
the
the
guts
of
what
it
is
testing
the
various
scenarios
here
right.
So
we've
got.
You
know
when
receiving
updates
when
the
state
matches
the
actual
State
when
it
doesn't
match
when
the
phase
is
not
present,
which
what
drives
stays
when
the
phase
is
not
valid.
A
When
a
workspace
doesn't
exist.
You
know
we
rails
doesn't
know
about
it,
but
somebody
manually
created
a
workspace
on
the
vehicle
control
on
the
kubernetes
side,
like
we
don't
blow
up,
it
just
prints
an
error
message
for
now
and
then,
when
this
case
is
when
we've
just
created
a
new
one
and
kubernetes
doesn't
know
about
it
yet.
So
this
is
testing
that
it
sends
all
of
the
right
information
over
and
the
this
desired.
A
Config
generator,
like
I
said,
is
the
the
part
that
builds
the
configs
that
we're
sending
back
to
kubernetes,
which
will
we
can
pull
more
of
this
logic
in
here.
This
is
sort
of
a
big
method
and
I
went
but
is
pulled
out
to
a
little
bit
of
stuff.
We
can
pull
out
more
cohesive
modules,
but
the
one
that
made
sense
to
make
more
decoupling
cohesive.
A
Now
was
this
config
generator,
which
is
the
part
that
is
responsible
for
building
the
dev
workspace
operator,
configs
and
config
map
configs
that
we
send
over
and
for
now
we
we
don't
have
a
way,
there's
no
graphql
hooked
up
to
this.
Yet
we
just
sort
of
have
the
dev
work.
The
dev
file
hard-coded
here
under
the
spec
and
just
hard
coded
to
a
ttyd.
A
We
can
once
we
hook
graphql
up,
that
would
be
like
a
string
field
or
something
that
they
could
pass
in
whatever
the
actual
Dev
file
that
they
wanted
to
provision
the
what's
another
little
tour,
those
scripts,
the
here's
one
thing
so,
there's
two
Services
the
state
reconciliation
service,
which
is
all
we've
been
looking
at.
It's
the
one
that
accepts
the
the
input
from
the
grape
API
call,
which
is
just
in
the
the
same
internal
module
with
all
of
the
other
kubernetes
agent
stuff.
Like
starboard,
starboard
vulnerability.
A
You
don't
need
to
look
at
that.
It's
just
a
standard
API,
but
there's
this
create
service.
This
is
what's
responsible
for
creating
the
workspace
in
the
database
initially,
so
this
would
again
be
hooked
up
to
a
graphql,
create
type
of
action
and
a
little
bit
of
business
logic
in
here
like
we
have
to
come
up
with
a
random
name
for
the
agent
and
for
the
the
namespace
or
at
least
a
unique
one.
So
the
way
we
come
up
with
it
on
the
name
is
workspace.
A
Dash,
the
ID
of
the
agent,
the
ID
of
the
user
and
then
a
random
six
digit
has
to
be
lowercase
or
it
gets
rejected
on
the
kubernetes
side
and
then
for
now,
there's
not
support
for
dynamic
we're
creating
namespaces
on
the
the
agent
side.
So
we're
just
have
this
temporary
flag
to
override
it
to
be
default
and
it's.
The
namespace
is
just
GL
Dash
Asian,
ID
Dash,
the
user
ID,
and
that
should
be
unique
like
we're.
Assuming
no
user
is
ever
going
to
have
more
than
one
namespace
on
a
given
agent.
A
A
That
coverage
is
annoying,
then
we
have
under
Scripts
remote
development.
We've
got
these
four
things.
There's
the
watch
rails,
workspaces,
which
is
that's
what
the
separate
left
wing
is
here.
It's
just
looping
through
and
printing
out
the
the
active,
the
objects
of
the
active
record,
weren't
space
objects
in
the
database
and
then
there's
this
and
it's
just
a
while
loop
that
Loops
over
it
and
clears
it
every
second
there's
this
same
sort
of
thing,
but
it
does
a
crew
control,
get
divorce
spaces,
which
is
here.
A
There
is
an
option
to
dash
watch
for
Coupe
control,
but
it
seems
to
get
confused
and
like
spam,
a
bunch
of
stuff
on
the
screen
and
not
clear
it.
So
this
little
helper
script
is
a
little
better
because
it
explicitly
clears
it,
and
then
these
are
the
two
that
I
ran
before
it's
just
that
I
ran
with
you
can
do
bin
spring.
If
you
want
it'll,
be
faster,
then
spring
rails,
Runner
and
then
run
the
script.
A
You
could
directly
execute
it.
If,
maybe,
if
you
want
but
I
always
want
to
run
it
with
springs,
so
it'll
be
faster,
then
it
just
looks
up
the
the
group,
the
user.
An
agent
creates
it
with
that.
Here's
a
little
thing
where
we
pass
this
temporary
slide
to
override
it
to
default,
and
then
that's
what
created
it
and
as
far
as
the
update,
this
fetch
without
a
second
parameter,
will
will
blow
up.
A
If
you
don't
pass
the
workspace,
if
you
don't
have
the
workspace
name,
environment
variable
specified
and
then
the
desired
State
defaults
are
stopped,
but
that
could
be
running
again.
It's
the
restart
request
is
not
supported
yet,
and
then
we
just
find
it
set
the
desired
state
with
update
with
the
bang
to
ensure
that
the
validation
of
the
states,
the
desired
and
actual
stator
happening,
and
then
it
works
and
I
think
that's
about
it.
I
can
stop
there.
A
The
the
next
steps
would
be
like,
as
you
can
see,
there's
plenty
of
laughs
to
use
across
here,
and
we
need
to
split
this
work
up
and
start
parallelizing
and
implementing
it
for
real.
We
have
a
good
basis
for
the
the
unit
tests
of
it.
It's
a
level
of
quality
that
we
should
be
able
to
start
pulling
parts
of
this
out
and
making
individual
Mrs
and
getting
them
merged
in
on
both
the
Asian
git
live
agent
side
and
the
rail
side
to
get
to
a
point
of
parity
of
functionality.