►
A
Okay,
so
a
victory
I'd
ask
for
a
call,
but
now
I
think
picture
it's
not
a
plane,
but
let's
discuss
so
as
I
understand
the
issue.
There
is
some
consideration
for
today
when
we
provision
a
cluster,
do
the
attach
a
cluster
interface
in
gitlab
you,
the
the
definition
of
how
we
do
that
is
stored
in
Ruby
code
and
then
is
kind
of
like
executed
within
the
Ruby
part
of
the
application.
There's
a
question
about
whether
or
not
we
should
just
kind
of
similar
to
what
we're
doing
with
the
ability.
A
Once
you
have
a
cluster
to
manage
the
configuration
of
that
cluster
in
terms
of
the
managed
apps
that
are
installed
and
there's
specific
configuration
in
a
separate
cluster
configuration
project,
should
we
do
the
same
thing
and
have
a
similar
experience
for
the
actual
deployment
of
the
infrastructure
of
the
cluster
using
something
like
terraform
so
that
their
summary
may
be?
Yes,.
B
A
B
A
Gotcha,
so
that
is
this:
create
new
cluster.
Not
add:
that's
right,
closer
okay!
So
when
you
choose
one
of
these
there's
a
provisioning
process
and
the
question
is:
should
we
use
terraform
and
then
one
of
the
pain
points
that
that
would
solve
is
then
you
would
and
explicitly
and
have
defined
explicitly
how
the
cluster
was
created.
And
presumably,
if
you
wanted
to
adjust
that
configuration,
you
could
do
it
and
get
less
source
control.
Okay,
cool
I.
B
Yes,
I
think
that
there's
a
couple
of
things
right
so
there's
first,
the
whole
workflow
right.
If
you
come
across
any
error,
it's
no
longer
going
to
be
a
good
lab
error
that
we
have
control
over,
but
it's
going
to
be
a
tariff
one
thing
that
you
may
or
may
not
understand
so
kind
of
that
that
dead
experience
in
my
mind,
is
vastly
different.
B
Then
this
the
second
thing
I
think
that,
as
terms
of
tear
goes,
our
coop
disintegration
is
kind
of
a
part
of
our
core
tier
and
I
think
that
it
would
have
to
continue
to
be
the
same
way
right
like
if
you're
saying
the
only
way
you
can
provision
a
cluster
on
a
cloud
provider
is,
if
you're,
an
unpaid
tier,
that's
kind
of
not
the
intent.
That'll
be
kind
of
taken
away
from
what
we
have
today.
Yeah.
A
A
So
the
experience
that
I'll
liken
this
to
is
today
what
I
can
do
in
the
configuration
in
my
cluster
is
add
this
extra
infrastructure
project
we're
talking
about
doing
this
by
default.
The
idea
would
be
well,
we've
created
an
cluster
provisioning,
or
maybe
it's
something
other
than
the
word
M
structure,
a
cluster
project
that
manages
the
configuration
of
the
cluster
itself
and
the
kind
of
resources
of
the
cluster
itself.
Yeah
is
my
interaction
with
that,
once
I
have
it
created,
or
would
we
suggest
that
any
like
merge
requests
to
this?
That
would
update.
B
So,
there's
something
there
for
sure
that
if
we're
saying
you
know
provision
clusters
with
your
terraform
setup-
and
that
is
a
paid
feature
that
may
be
very
valuable
and
I
can
think
of
use
cases
where
we've
come
across
like
very
large
customers
that
have
created
tools
like
this
with
their
own
tooling.
So
we
had
one
specific
customer
in
the
financial
sector
that
created
a
jupiter
notebook
as
a
portal
for
their
developers
to
log
in
and
specify
the
details
of
the
cluster
and
in
the
backend.
B
They
had
some
tooling
to
create
that
that
that
cluster,
so
I
could
imagine
a
bureau
an
unpromoted
customer
and
your
developers
are
basically
provisioning
infrastructure
on
either
on-prem
or
your
private
cloud
that
this
could
serve
as
a
way
of
you
are
saying.
Well,
I,
don't
want
to
use
gzp
or
AWS,
but
I'm
going
to
owe
the
customer
out
and
offer
this
cluster
creation
experience
to
my
developers
and
in
the
back
end,
is
going
to
use
terraform.
B
A
But
I
do
think
sorry
and
I'm
more
this
via
explicit.
My
argument
is
that
for
the
first
iterations
we're
going
to
be
talking
about
I,
think
of
it
in
a
very
similar
model
to
what
we've
just
been
doing
with
moving
from
non
CI
to
see
I
get
lab,
managed
apps,
you
would
be
doing
the
same
thing:
moving
from
CI
to
non
CI,
a
cluster
creation
or
cluster
management.
A
Where
we've
provision
it,
we
gave
you
the
stock
convention,
if
you
want
to
break
out
of
that,
you
can
and
that
those
will
deploy
with
CI
and
that
will
likely
use
terraform
or
we
might
choose
to
use.
Terraform
I
would
argue
that
that
still
remains
in
core
the
things
that
are
that
might
move
up
into
your
are
some
of
the
other
experiences
around
terraform
management.
A
So
you
know
whether
that's
managing
multiple
projects
of
terraform
and
understanding
changes
across
different
infrastructures
or
some
of
the
collaboration
tools
around
reviewing
terraform
state
changes
that
Victor
has
been
proposing
and
the
team
is
working
on.
Those
seem
like
more
appropriate
higher
tier
ones,
rather
than
the
thing
that
strikes
me
as
not
compatible
with
our
tier
structures.
Is
the
notion
that,
just
because
I
want
to
not
use
git
Labs
stock
convention,
that
means
I'm
in
a
higher
tier
and
that
doesn't
flow
with
the
rest
of
our
other
are
tearing
philosophies
today,
yeah.
B
So
that's
that's
a
fair
point.
I
I
think
that
one
vastly
different
comparison
between
gitlab
manage
tabs
that
are
ci
based
and
cluster
creation.
That's
telephone
based
is
that
we
are
using
git
lab
and
a
good
lab
Anna.
You
know
a
good
lab,
primitive
and
a
good
lab
feature
to
provision
or
install
those
applications,
whereas
here
we
would
be
using
a
tool-
that's
external,
to
get
lab,
so
we
couldn't
count
on
users
having
to
have
kind
of
the
same
experience
with
it.
B
Or
even
you
know,
there
are
other
things
like
overhead
in
an
eponymous
type
of
installation
or
even
a
helmet
art
type
of
installation.
If
you're
installing
good
lab
now
you're,
adding
that
overhead
of
you
must
provision
terraform
for
this
feature
to
work-
and
you
know
that's
also
kind
of
a
consideration
right
so
yeah.
There
are
all
these
things
that
are
kind
of
analogous,
but
not
really
well.
A
And
I
think
that
is
a
that
argument
is
maybe
not
about
tearing
right.
That
is
just
about.
Should
we
do
this,
because
if
we
replace
the
existing
experience,
but
it
requires
more
overhead,
deeper
understanding
something
else
before
you
could
create
a
cluster
that
does
seem
like
a
steep
step
backwards.
If
we
could
completely
obscure
that
from
users
in
the
experience
was
literally
the
exact
same,
that
should
be
what
we're
after,
but
that
I
think
is
independent
of
what
here
it
goes
in
right.
A
The
tearing
one
is
the
one
that
I
wanted
to
make
sure
we
had
a
dialogue
about
and
we're
Victor's,
not
here
so
I'm,
not
necessarily
sure
I'm
representing
his
side
of
the
argument
but
I.
If
we
I'm,
probably
presuming
that
we
would
go
down
the
path
of
doing
this,
and
if
we
do
and
it
would
be
opaque
I
would
suggest
it's
still
remains
in
core
I
totally
agree
that
there's
still
a
bunch
of
validation
both
on
problem
and
solution
about
whether
or
not
this
is
the
right
thing
to
go.
Do.
B
A
A
A
Is
there
a
pain
point
here,
and
can
we
solve
it
in
a
way
that
doesn't
add
even
more
complexity,
because
it
does
seems
like
we
would
be
doing
this
in
order
to
allow
for
some
additional
customization
and
infrastructure
management?
But
it
comes
with
preventing
people
from
getting
started.
It
might
come
with
preventing
people
from
getting
started
with
adding
a
cluster
and
creating
a
cluster
quickly.