►
From YouTube: Octant Community Meeting - August 26th, 2020
Description
August 26, 2020
Agenda
- Revisting RBAC and restricted access.
- Need for speed updates.
- https://github.com/vmware-tanzu/octant/pull/1242
- Moving to Angular 10
- JavaScript plugin updates.
- Generating TS
- New repo coming soon (octant-ts-lib)
- Yeoman generator updated, but still wrong.
- KinD plugin demo
A
Hello
and
welcome
everybody
to
the
august
26th
octant
community
meeting
today
on
the
agenda.
We
have
a
few
items
and
get
that
shared.
We're
going
to
be
talking
about
some
updates
to
the
kind
of
restricted
our
back
and
and
and
revisiting
our
back
and
restricted
access.
We're
going
to
be
looking
at
some
of
the
updates
that
have
recently
happened
with
our
need
for
speed
changes
and
there's.
There's
gonna
be
some
talks
about
moving
to
angular,
10
and
and
clarity.
A
Four,
I
think
we're
just
announcing
that
we're
doing
it
and
then
we'll
get
into
some
javascript
plugin
updates
and
then
there's
a
demo
on
a
kind
plugin
that
I
believe
sam's
been
working
on
so
I'll
start
with
the
revisiting
are
back
and
restricted
access.
A
This
has
been
a
long
standing
issue
within
octan,
currently
the
the
current
implementation
of
octane.
What
it
does
is,
there's
a
has
access
cache
and
when
it
attempts
to
access
a
resource
it,
it
makes
an
entry
in
that
cache
for
the
the
the
kind,
the
version
and
the
name
space,
and
then
it
keeps
track
of
any
time
that
is
received
in
error
trying
to
access
that
resource.
It
will
then
make
attempts
to
continually
try
to
access
that
resource
with
kind
of
a
logarithmic
back
off.
A
This
works
pretty
well,
if
you
have
like
the
right
set
of
access,
basically
like
if
you
have
very,
very
restricted
access
where
you
so
like
your
your
scope
to
say
a
specific
name
space
with
only
the
ability
to
list
deployment
replica
set
pod
like
list
get
watch
for
those
items,
then
this
starts
to
become
very
slow
as
you're
waiting
for
a
lot
of
things
to
kind
of
back
off
and
and
get
those
errors
from
the
api
server,
and
it's
it's
mostly
slow
in
the
initial
launch
of
octane
and
and
usage
like
as
the
system
settles
into
its
back
off
patterns
and
it
kind
of
knows
what
it
can
get
to
then
there's
less
slowness,
but
the
the
initial
experience
when
you
first
launch
octane
in
a
are
back
restricted
clusters,
is
pretty
bad.
A
There's
a
lot
of
errors
that
just
get
spammed
right
out
into
the
console
and
there's
a
lot
of
loading
indicators
and
waiting
and
waiting
and
and
it's
it's
kind
of
this
unsure
state
of.
Are
things
going
to
work
correctly?
So
I'm
I'm
considering
some
new
ways
to
approach
this,
and
one
of
them
is
to
kind
of
remove
the
the
what
we
do
now,
which
is
like
this
backing
off
and
logging
approach
and
kind
of
switching
to
a
to
a
try
once
and
forget
approach.
A
But
by
forget,
I
mean
put
an
entry
into
a
page
within
octant
so
that
you
can
see
what
was
attempted
and
failed
and
then
be
able
to
go
ahead
and
say
like
retry.
A
These
things
like
I
have
a
new
you
know
I
I
my
cluster
role
has
been
changed
and
and
the
bindings
are
updated
and
I
just
want
to
refresh
this
context
so
go
ahead
and
try
that
stuff
again
we're
trying
to
be
like
really
smart
about
it
and
and
be
like
oh
we'll
watch
for
it
and
we'll
automatically
refresh
and
we'll
do
all
this,
and
it
just
turns
out
that
that's
that's
a
lot
of
work
for
very
little
gain.
A
If
we
just
surface
this
information,
let
you
know
that
it's
happening
and
then
give
you
the
ability
to
kind
of
just
retry
doing
that
manually
is
much
better
than
doing
doing.
That.
Well,
manually
is
much
better
than
doing
it
poor
automatically,
so
we
I'm
gonna,
be
exploring
this
area
and
hopefully
put
up
some
pr's
later
this
week
and
thursday
and
friday
that
will
attempt
to
use
this
new
model
and-
and
we
can
solicit
some
feedback
and
see
what
people
think
about
it.
A
All
right
moving
on
to
the
need
for
speed
updates,
so
this
came
out
of
the
octant
developer
summit
that
we
did.
You
know
as
I
clicked
this.
I
just
thought
man
I
should
really
inspect
the
before.
I
click
on
an
open
document
like
I
should
really
inspect
where
that
link
goes,
I
just
assumed
it
went
to
the,
but
so
this
is
the
dynamic
components,
pr
that
brian
lyles
did
and
and
what
this
does.
A
Is
it
there's
a
whole
suite
of
changes
in
here
that
that
kind
of
move
us
towards
dynamically
loading,
the
content
of
a
component
versus
trying
to
do
them
both
at
the
same
time
previously,
especially
with
data
grids?
We
were
getting
this
getting
into
this
thing.
A
The
experience
on
the
on
the
user
side
is
a
much
faster
feel
of
the
information
being
loaded
and
presented
on
the
page,
and
that's
because
all
of
the
containers
that
are
going
to
have
this
information
in
them
get
presented
almost
immediately
and
then,
as
you
cycle
between
new
tabs
and
and
different
views,
you'll,
the
the
content
in
those
containers
is
what
is
what's
being
updated.
So
this
is
a
great
improvement.
We're
still
going
to
be
doing
work
in
this
area.
There's
some
fixes
that
that
need
to
come
down
from
this.
A
I
think
loading
indicators
have
some
walkiness
to
them
now
and
there's
also.
There
was
something
else
that
that
this
kind
of
broke
or
interrupted.
I
can't
remember.
A
Right
yeah
there
is,
it
can't
fix
that
yeah
right
here,
storybook
for
the
dynamic
components,
so
so
yeah.
So
that's
that's
where
that's
at
we're
going
to
continue
to
make
speed
improvements.
A
We
had
mentioned
in
the
last
community
call
that
that
we
are
going
to
be
going
down
this
road
and
making
some
performance
enhancements
and-
and
most
of
it
will
be
you'll
see
most
of
the
stuff
happening
on
the
front
end
more
so
than
the
back
end,
because
our
the
back
end
is
well,
it's
already
pretty
fast,
and
then
you
know
the
main
limiting
factor
for
the
back-end
is
how
fast
is
the
api
server,
because
once
we
consume
that
information,
we
render
it
out
to
the
stream
relatively
quickly.
A
I'm
sure
there
are
some
optimizations
we
can
make
there,
but
most
of
our
gains
are
going
to
be
seen
on
the
on
the
front
end.
So
this
will
be
in
the
next
release,
which,
hopefully
will
be,
I
think,
we'll
be
doing
one
relatively
soon.
There's
there's
a
lot
of
good
stuff
that
it's
landing
in
and
master
right
now,
so
likely
we'll
be
doing
0.
A
16.,
oh
dot,
16
soon,
yeah
sam's
nod
says
that
I
I
picked
the
right
version
number.
So
that's
good
any
things
I
missed
there
or
stuff
anything.
People
want
to
add.
B
Being
on
that,
that
can
give
a
quick
update.
So,
yes,
it's
happening,
we're
moving
to
angular
10
and
clarity
4.0.
B
A
All
right
is
there
anything
with
moving
to
10
and
angular
10
and
clarity
4
that
we
look
at
like.
Are
there
any
because
I
don't?
I
haven't
really
looked
at
like
the
release,
notes
and
highlights
so
what's
kind
of
like
what's
the
the
high
level
take
of
like
what
do
we
get.
B
Right
so
so
for
angular,
it's
it's
they
they
describe
it
as
a
d
minor
update
because
they
released
nine.
I
think
four
months
ago,
something
like
that.
So
it's
a
there's
not
that
much
stuff
there.
B
Clarity
4.0,
is
upgrading
to
to
the
new
model
where
they
they
have
a
core
and
then
angular
and
react
on
top
of
that,
and
so
that's
the
big
change
there.
It
should
not.
I
think
they
have
some
new
components
too,
but
it
should
not
affect
us
at
this
point
much
along
with
those
changes.
We
are
upgrading
the
versions
of
other
dependent
libraries.
I
forgot
all
of
them
now,
but
I'll
list
them
in
a
pr.
B
So
it's
a
it's.
It's
basically
just
bringing
everything
up
to
the
most
recent.
A
B
Right,
oh
actually,
it
does.
Oh
it
does
it's
the
only
use,
but
I
think
they
they
changed
it
a
little
bit.
So
it's
it's
a
little
more.
I
think
at
some
point
you'll
have
to
the
change
you'll
have
to
do
is
the
clarity.
B
Ui
module
will
will
go
away,
go
away,
got
it
yeah
and
clarity,
icons
too,
so
we
should
probably
look
into
that
right
after
upgrading
just
to
make
sure
I
don't
want
to
do
too
much
at
once,
but
we
may
need
to
remove
those
and
to
eliminate
some
of
the
libraries
we
don't
need.
Hopefully.
A
Update
so
moving
on
to
some
javascript
plug-in
updates.
I
just
want
to
go
over
these
quickly.
So,
as
we
mentioned,
the
javascript
api
for
plugins
is
gonna,
be
continuing
to
get
some
significant
investment.
A
We
it's
still
very
early
for
the
javascript
plug-in
api
and
and
general
like
the
supporting
libraries
and
documentation
around
it,
but
we
are
we're
working
to
actively
improve
those
we're
building
out
some
plug-ins
of
our
own,
using
it
so
we're
kind
of
dog
fooding
it
so
that
we
can
make
those
improvements
and
and
kind
of,
I
think,
as
scott
said
earlier,
you
know
sand
down
some
of
the
rough
edges
around
around
building
javascript
plugins.
A
So
one
of
the
things
that's
that's
there
now
is
is
we're
generating
some
of
the
typescript
code
out
of
octant
from
our
component
models.
So
we
have
these
components
that
are
defined
and
go
we're
and
we
we've
annotated
those
and
now
we're
generating
some
factories
and
helpers
off
of
those
component
models,
so
that
that
that's
something
that
we
will
be
placing
into
a
new
repo
soon,
which
would
be
the
octan
ts
lib
repo.
A
It's
going
to
contain
those
generated
models,
as
well
as
a
set
of
helpers
for
creating
components
working
with
the
dashboard
client
working
with
you
know,
sending
alerts
and
and
and
sending
events
up
into
octane
dealing
with
you
know,
routing
and
path,
handling
and
navigation
and
stuff,
like
that,
we've
we've
slowly
been
kind
of
building
out
this,
this
set
of
helpers
and
and
extending
them
and
trying
to
figure
out
what
all
those
patterns
are
going
to
look
like
and
kind
of
what
we
want.
A
The
shape
of
this
thing
to
be
so
with
that
said,
the
the
the
yeoman
generator
that
is
out
there
for
generating
octane
plugins
has
been
updated.
It's
going
to
have
these
new
automatically
generated
libraries
baked
into
it.
It's
not
the
best
model,
because
you
know
once
you
once
you
generate
your
plug-in
with
the
like.
You
do
yo
octane
plug-in
well
now
you're
pinned
to
this
version
that
came
with
the
generator
you
used.
A
So
that's
kind
of
the
the
motivation
between
behind
getting
that
octant
ts,
lib
library
out
there
is
that
now
npm
and
yarn
can
be,
can
use
that
to
install
those
files
and
then,
even
though
you've
used
the
the
yeoman
generator
to
scaffold
your
plugin,
you
can
easily
update
those
libraries
as
we
continue
to
make
improvements
and
you
don't
have
to
go
and
fetch
a
whole
new
generator
and
regenerate
a
project
and
then
copy
things
over.
A
You
could
just
npm,
update
or
yarn
update
your
your
octa-ts
lib
to
get
the
the
latest
set
of
changes.
So
that's
that's
the
direction
that's
going
in
we've
recently
merged
some
prs
that
now
allow
the
javascript
plugins
to
send
events.
This
was
leverage
the
work
that
sam
did
for
enabling
send
alert
in
the
go
plugin
api.
A
We
took
that
same
approach
for
the
javascript
plugins,
but
being
that
it
was
on
the
javascript
side,
we
were
able
to
actually
be
a
little
less
specific,
which
was
nice
and
so
on
the
javascript
side.
It's
send
event
and
sending
an
event
can
be
any
events
that
the
front
end
currently
supports,
which
right
now
is
only
alerts
anyway.
So
so
yeah
there
is
a
pr
up
from
scott
to
make
the
front
end
support
the
content
path
event,
so
a
plug-in
will
be
able
to
send
a
content
path,
change.
A
Think
of
that,
just
like
you
would
do
a
redirect
after
posting
form
data
or
something
like
that.
This
will
be
very
useful
for
a
lot
of
folks.
I
know
the
there
was
a
helm
plugin
that
wanted
to
do
something
like
that.
There
was
a
jx
plug-in
that
I
wanted
to
be
able
to
redirect
we're
creating
a
plug-in
that
we
want
to
be
able
to
do
redirects
with
so
a
very
common
pattern
that
people
want
to
be
able
to
do
so.
That's
that
that'll
be
there
soon
and
likely
in
the
next
release.
A
I
think
so
they're
moving
quickly
they're
getting
better.
So
if
you
are
writing
one
and
you
run
into
issues,
please
open
them,
reach
out
to
us
in
the
slack
channel
and
that's
it
so
now
there
is
a
kind
plug-in
demo.
I
believe
this.
C
Is
sam,
yep
that'll?
Be
me
this
one
should
be.
D
Fairly
quick
because
it's
still
fairly
in
rough
shape,
but
I
think
it'd
be
kind
of
fun
to
share.
So
this
is
a
plug-in
that
I've
been
working
on.
D
It's
in,
go
not
javascript,
sorry
wayne,
and
the
reason
for
that
is
because,
when
you
have,
I
guess
the
kind
I'm
importing
kind
here
to
create
a
cluster,
and
you
can
have
this
really
nifty
v1
alpha
4
config
and
the
idea
was
that
we'd
have
this
form
that
would
populate
this
object
and
then
kind
has
this
very
nifty
just
provider
create,
and
we
can
hook
that
into
a
plug-in
and
effectively
have
information
that
you
would
have
otherwise
be
doing
with
a
kind
cli
and
do
a
ui
so
effectively.
D
D
If
you
kind
of
run
docker,
you
can
kind
of
see
that
your
client
clusters
are
really
just
these
node
images
of
a
particular
kubernetes
version,
so
I'm
also
importing
docker
to
run
these
commands
in
the
back,
and
it's
looking
for
the
version
of
kubernetes
that
you're
running
and
the
motivation
here
is
that
we'd
eventually
have
this
form,
which
will
either
look
up
or
download
the
image
you
need,
and
it
can
show
you
what
kind
of
what
images
are
available
and
you
can
control
how
many
workers
or
or
nodes
that
you'd
want
in
this
particular
cluster,
and
you
can
kind
of
see
these
configurations
in
the
kind
documentation.
D
So
this
will
construct
this
effectively.
This
cluster
config
file
for
you
behind
the
scenes
and
currently
right
now.
This
does
nothing
because
we
haven't
really.
We
haven't
really
implemented
how
to
pass
data
in
our
stepper
component.
Yet,
but
let's,
but
let's
say
this
is
filled
out-
and
the
second
step
here
is
feature
gates
and
feature
gates
are
interesting.
D
I
think
it's
also
documented
in
here
somewhere
yeah,
you,
you
have
a
particular
feature,
gate
name
and
it
could
be
true
or
false,
and
then
you
would
also
have,
depending
on
what
kind
of
feature
gate
it
is.
You'd
also
actually
have
to
insert
the
name
of
the
feature,
gate
and
other
parts
of
the
config
as
well,
and
there's
a
kind
issue
open
for
that.
D
But
these
would
be
you
check
them
off
and
I
guess
the
interesting
piece
of
this
is
what
if
a
particular
feature,
gate
is
not
enabled
for
a
particular
kubernetes
version,
so
these
some
of
these
might
actually
have
to
be
grayed
out
or
removed
entirely.
So
this
will
be
a
dynamic
stepper,
but
let's
say
we
actually
hit
submit
and
we
create
a
cluster.
This
will
start
spinning
up
and
ideally
the
vision
is
that
we'd
have
this
logger,
that's
going
to
be
provided
right.
Now,
it's
a
cluster.
D
I
don't
know
if
you
can
see
this
in
the
screen
share
right
now:
it's
cluster
provider
with
docker.
Ideally
this
would
be
some
sort
of
logger
that
can
be
provided,
and
this
is
something
you
can
do.
It's
like
cluster
dot.
I
think
it's
what
blogger
provider
with
logger
yeah,
so
you
can
provide
a
logger
and
maybe
there's
some
way
to
show
what's
happening
because
right
now,
what's
gonna
happen,
is
it's
still
creating
this
cluster,
but
you
can't
really
see
it.
D
But
when
the
cluster
is
successfully
created,
we
should
see
a
kind,
oops,
yeah
kind
test
pop
up
and
that's
how
we
know
that
this
new
cluster
is
good
to
go
and
once
it
is,
we
can
kind
of
see
that
if
I
navigate
back
to
maybe
the
path
here,
this
is
just
a
clean
kind
cluster
that
we've
just
made
a
few
seconds
ago
and
other
than
that
it's
also
got
a
delete.
I
haven't
tried
out
the
delete,
yet
I
don't
think
it
works.
D
It
does
not,
but
that's
all
right
yeah.
So
that's
pretty
much
all
I
have
if
y'all
have
any
ideas
or
feedback
with
what
you
might
like
to
see
in
such
a
plug-in
feel
free
to
share.
I
haven't
really
pushed
the
code
up
for
this
mainly.
B
D
A
A
Great
but
yeah,
this
is
really
that's
really
cool.
I
think
that
that'll
be
super
useful
for
a
lot
of
people.
I
should
I'll
mention
this.
I
have
a
kind
plug-in
that
you
might
be
interested
in
which
I
will
link
in
the
chat
here.
A
It
is
it's
very,
very
rough,
but
it's
also
written
in
go.
This
is
specific
around
the
kind
registry
it
lets
you
load.
You
know
when
you're
dealing
with
kind,
you
can
load
from
your
local
docker
registry.
You
can
load
modules
into
this,
the
kubernetes
server
or
into
kind
so
that
they
can
see
it
so
that
it
can
access
those
images.
A
A
It
uses
the
cli
to
perform
all
those
actions,
but
this
might
be
something
that
you
might
want
to
tie
into
the
to
your
kind
plug-in
once
you
get
a
little
further
along
and
because
again
I
didn't
really.
I
just
like,
did
it
and
was
like
hey,
it
worked,
kind
of
and
then
moved
on,
so
it
would
be
good
to
have
a
more
like
a
like.
Yours
seems
like
it's.
A
It's
moving
the
direction
of
being
a
little
more
robust
and
having
like
a
tab
that
exposes
what
I've
done
is
its
own
plugin,
but
just
like
having
a
tab
like
registry
tab
or
something
something
like
that
or
another
menu
item
in
there
registry.
That
could
be
really
neat
too.
D
A
D
Yeah
currently,
no,
because
you
just
can't
even
get
to
that
view-
I
mean
unless
you
actually,
that
might
be
good.
I
haven't
tried.
My
guess
is
probably
no,
because
you
just
really
can't
click
it
like.
Maybe
if
you
just
hit
like
hit
to
the
pad
directly,
but
you
can't
really
get
to
it
from
the
ui.
A
Yeah
yeah
the
way
well
and
the
way
we
the
way
we
do
deal
with
the
routing
when
you
don't
have
a
config,
is
we
load
in
a
a
temporary
handler
so
that
handler
wouldn't
even
have
the
module
routes
on
it?
So
I
wouldn't
even
know
where
to
send
that
traffic.
A
That's
one
where
being
able
to
say
expose
this
plug-in
when
there
is
no
config,
because
it
does
set
up
work,
another
one
is
being
able
to
say
this
plug-in
execs
so
like
we
need
like,
if
you
think,
about
you're,
running
a
plug-in
in
cluster
plug-ins
in
cluster,
can't
just
randomly
exec
they're,
not
designed
like
so
being
able
to
have
a
set
of
capabilities
beyond
our
right.
Now
we
register
a
plugin
will
register
like
I
support
this
stuff,
but
but
similar
to
how
we
right
now
we
say
I
am
a
module.