►
Description
Distribution team members demos debugging steps for tests in the GitLab operator.
A
A
A
A
A
A
Nf
test,
which
is
a
test
environment
and
the
second
one,
is
debugging
gitlab
operator,
while
it
is
running
against
a
fully
functional
cluster,
so
the
second
one
is
actually
more
helpful.
The
first
one
is
helpful
for
development
purposes,
but
the
second
one
is
more
useful
for
finding
the
issues
that's
happening
with
the
deployment
of
gitlab
operator
and
reconciling
the
resources.
A
A
A
A
Let's
see
if
I
can
make
this
bigger,
more
visible,
so
I'm
going
to
use
vs
code,
but
basically
you
can
use
delft
if
you
are
using
another
editor.
The
the
commands
are
the
same
I
just
find
it
easier
and
more
quicker
to
to
work
with,
especially
when
I'm
developing
the
operator
so
to
begin
with
I'm
gonna
start
a
test
environment
and
I'm
going
to
debug
one
of
the
test
cases
that
we
have
for
controllers.
A
This
is
the
main
test
that
we
have
here,
so
just
a
quick
overview
of
the
F
test,
which
is
a
test
environment
for
testing
operator.
This.
This
is
part
of
the
gitlab
operator
framework.
Sorry,
this
is
part
of
the
controller
runtime
framework
that
we
use
and
what
it
basically
does.
It
starts
an
etcd
and
a
cube.
A
Api
server,
wires
them
together
and
offers
them
as
an
API
server
to
the
to
the
operator
that
we
are
developing
to
the
controller
that
we
are
developing
and
we
can
do
very
few
basic
basic
tests
with
the
amp
test
with
this
API
server.
But
the
problem
is
that,
since
it
doesn't
have
a
control
plane-
and
it's
just
only
a
test-
API
can
do
only
API
testing,
not
nothing
further,
and
if
we
want
to
add
more
details,
we
need
to
imitate
what
the
control
plane
does.
A
That's
why
our
tests
are
a
bit
slow
and
difficult
to
expand
and
cut
and
catch
Corner
cases,
but
right
now,
I'm
just
going
to
start
one
of
these
test
cases
and
bring
it
into
bring
it
up
into
debug
mode,
and
then
we
can
check
it
so
well.
The
code
that
I
am
reviewing
right
now
is
is
the
setup
of
the
EV
test
you
can
can
refer
to
the
documentation,
but
basically
what
we
do.
A
A
Operator
sorry
vs
code
configuration,
so
you
just
need
to
start
your
process
in
test
mode,
and
the
program
that
we
are
testing
is
a
test
Suite
test
of
that
particular
package.
So
these
are
the
important
parts
you
need
to
consider
the
program.
This
is
the
main
program
that
we
are
testing
and
this
is
the
home
chart,
the
environment
variable
that
I
am
passing
and
you
can
also
pass
the
key
code
command
line
arguments
actually
I'm
going
to
just
remove.
This
is.
A
A
A
The
background
etcd
is
running
as
well,
and
the
API
Center
is
wired
to
this
one
and
what
this
does
it
creates
a
temp
file,
a
temp
directory,
and
it
contains
all
the
information
that
the
API
server
requires.
So
let's
take
a
look
at
this
directory.
One
of
the
interesting
things
that
is
here
is
the
Q
conflict
file.
A
A
So,
let's
say:
okay:
this
is
a
debugging
environment.
You
can,
of
course,
do
what
you
want
with
the
values
you
can
inspect
them.
You
can
watch
them.
You
can
create
a
conditional.
This
is
a
fully
fledged
debug
environment,
nothing
much
to
it.
The
only
caveat
here
is
that
you
cannot
do
a
lot
of
nested
structures,
basically
any
structures,
the
map,
string,
interface
or
map
of
interfaces.
You
cannot
dig
too
much
into
it.
I
think
a
few
levels
yeah
bill
doesn't
like
it.
A
It
requires
a
bit
of
configuration
of
Dell
and
adding
some
changing
some
buffers.
For
example,
some
of
these
strings
are
cut
short.
These
are
the
parameters
that
you
can
configure
with
little
and
basically,
if
you
are
using
BS
code,
you
can
configure
it
via
vs
code
to
pass
it
to
delve.
So
you
can
get
more.
You
can
read
more
of
the
buffers
or
strings
or
getting
more
nested
picture
of
the
structured
databases,
nested
nested
data
structures,
but
the
foreign.
A
A
A
A
A
A
As
a
debug,
a
snippet
in
the
development
documentation,
these
are
useful.
This
one,
the
first
one.
Actually,
the
first
one
finds
the
tab
directory
of
the
API
server.
That
is
running
the
second
one,
just
grabs
the
tries
to
try
to
locate
the
cube,
Cube,
config
and
I
find
myself
this.
You
know
do
this.
A
The
local
API
server
that
is
running
on
this
amp
test
and
try
to
fiddle
with
these
things
sometimes
I
can
even
change
these
things
and
to
make
sure
that
you
know
the
operator.
Actually,
if
you
see
you
see
that
it
operator
system
creating
these
things,
so
this
is
one
of
the
things
that
is
helpful,
but
not
the
most
interesting
thing
that
you
can
do
so.
Just
let's
start
the
debug.
A
A
A
So,
as
I
said
that
this
is
this
is
limited,
this
doesn't
have
a
control
plane
and
we
just
basically
testing
the
the
the
development
environment.
But
from
time
to
time
we
find
that
we
need
to
actually
have
a
control
plane
and
find
out
what
is
happening.
I
can
give
you
an
example.
A
few
releases
ago
we
had
a
problem
with
hpas
and
we
really
didn't
understand
what
is
happening
with
hpasd.
A
A
A
So
this
is
the
part
that
does
the
request
and
response
after
this
is
dead.
There
is
another
part
to
operator
which
subscribes
to
watches
certain
resources,
in
this
case
or
for
gitlab
operator,
it
watches
the
gitlab
resource.
So
if
a
gitlab
resource
is
created
or
changed
or
deleted,
it
will
be
notified
and
it
will
pick
it
up.
This
is
kind
of
like
a
pooling
rather
than
pushing,
so
it
can
be
from
the
operator
site.
If
you
look
at
look
at
it
from
the
operator,
so
it
pulls
the
changes
from
the
cluster.
A
A
A
A
A
A
A
Okay,
the
reason
that
this
phone
can
connect
to
the
remote
cluster
is
that
we
already
have
a
cubicle
that
can
work
with
the
cluster,
so
it
can
still
pull
the
resources.
It
can
watch
the
resources
and
the
the
fact
that
we
are
importing
all
the
authentication
modules,
including
gcp
in
operator,
so
we
can
authenticate
to
gcp
or
any
other
provider.
A
So
with
the
big
Cube
CTL,
we
can
connect
with
a
valid
qctl
on
our
local
machine
on
our
environment
variable
we
can
connect
our
gitlab
operator
to
a
remote
cluster
and
it
works.
The
problem
that
it
doesn't
work
here
is
that
I
think
we
kind
of
need
to
copy
the
certificates,
because
there
is
a
certificate.
A
A
A
A
A
The
charts
directory
already
contains
633,
despite
the
fact
that
so
my
test
and
what
my
local
environment
wasn't
exactly
the
same
as
the
remote
environment
it
shouldn't
have
been
here.
I
should
have
updated
the
charts
to
reflect
at
the
exact
same
version
that
is
running
on
the
cluster,
but
actually
this
is
not
that,
because
I
can
go
ahead
and
try
this
thing.
A
Let's
say
I
want
to
see
if
resources
is
enabled-
let's
say
yeah,
let's
say
like
we
want
to,
because
I
check
debuggery
consult
with
this
and
just
let
it
go
and
let's
take
a
look
at
parts
it
is.
It
has
started
creating
everything
the
resources
are
running.
This
is
a
real
cluster
and
the
console
Loop
is
running
as
well,
and
I
can
just
say
waiting
for
a
breakpoint
to
reach
and
I
can
tap
into
it
and
just
see
what
happened.
A
B
A
A
A
A
V
for
release
for
the
release,
video,
because
this
one
is
actually
compiled
in
debug
mode.
It
has
the
the
the
debug
signals.
So
if
we
take
a
look
at
here,
there
should
be
yeah.
Sorry,
this
is
the
debug
bin
yeah.
There
is
a
debug
version
of
the
binary
here,
but
this
is
not.
It
doesn't
have
to
be
published
because
we
compile
it
locally
right.
We
just
used
a
feature
that
actually
it
levers
a
feature
that
the
controller
runtime
has
and
that's
pulling
the
changes.
B
B
A
B
B
B
A
B
B
A
A
A
A
A
A
A
Can
increase
that
if
you're
debugging,
but
for
the
cluster
itself?
No,
you
don't
have
you
don't
have
that
kind
of
time
out
really
because
of
the
recent
change
that
we
made
that
instead
of
waiting
blocking
the
weight,
we
just
postpone
and
come
back
to
it
that
basically
we
reach
you
the
request.
If
you
you
finish
what
you
are
debugging
in
this
cycle,
African
style
Loop,
you
will
end
up
doing
it
in
the
next,
so
we
basically
reach
you
instead
of
waiting
in
this
specific
time,
yeah
for
the
second
for
the
for
the
live
cluster.