►
From YouTube: Kui – CLIs With a Graphical Twist - Nick Mitchell, IBM
Description
Don’t miss out! Join us at our next event: KubeCon + CloudNativeCon Europe 2022 in Valencia, Spain from May 17-20. Learn more at https://kubecon.io The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Kui – CLIs With a Graphical Twist- Nick Mitchell, IBM
The kubectl CLI is the "daily driver" for many Kubernetes users. Like other CLIs, kubectl is fast to use, allows succinct expressiveness, and is an ideal way to facilitate sharing, learning, and automation. However, ASCII art only takes us so far. The browser-based consoles offered by cloud vendors allow easier navigation via point and click, and reflect common developer workflows visually. Yet, given the general preference for kubectl, it seems that these benefits are overshadowed by the monumental power of a CLI. We will discus the open source project Kui (https://github.com/kubernetes-sigs/kui), a sub-project of the Kubernetes SIG-CLI. Kui selectively enriches kubectl without masking its expressive power. For example, "kubectl get pods" responds with a table of clickable resources. There is no need to copy and paste, or to remember which command is needed to drill down from one view to another. Kui's core framework enables visual enhancement of any CLI. Thus, we also provide starting points for those interested in using the platform to enhance their favorite CLI. We hope that this is a start of opening the world of CLIs to the imagination of designers.
A
A
As
you
can
maybe
imagine.
The
goal
of
kui
is
to
bring
enhancements
to
the
terminal
experience
to
the
sea
life
centric
experience,
so
the
premise
of
kui
is
that
we
all
love
clies.
In
fact,
as
we
get
more
and
more
expert,
I
think,
as
we
all
find,
with
kubernetes,
we
sort
of
tend
to
gravitate
away
from
the
console
experiences
and
towards
the
awesome,
kukarl
cli,
there's
a
lot
of
reasons
to
love
it
all
the
reasons
I'll
see
that,
generally
you
can
reverse.
A
A
There's
a
lot
of
good
reasons
to
love
it,
the
you
could
pipe
to
together
seal
eyes
in
really
interesting
ways,
a
lot
of
really
cool
stuff.
You
can
do
with
steel
eyes,
but
at
the
same
time,
they're
pretty
much
stuck
in
the
70s
right,
the
ascii
art.
That's
can
be
quite
pretty
cool,
but
it's
pretty
much
limited
to
a
controlled
characters
that
was
that
was
designed
many
decades
ago.
A
So
that
was
a
challenge
that
we
that
we
were
addressing
with
gooey.
Can
we
bring
those
two
worlds
together:
the
world
of
design
and
graphics?
And-
and
you
know
in
the
modern
age,
but
without
really
spoiling
the
core
essence
and
the
reason
why
people
love
clies,
so
the
basic
cool
approach?
Is
it
targets
a
number
of
aspects?
I'll
tell
you
about.
A
A
A
A
We
can
make
that
better
graphically
by
giving
a
richer
way
of
assembling
and
representing
those
hundreds
and
hundreds
of
namespaces
in
a
graphical,
well-designed
fashion,
but
but
once
we
have
that
graphical
component,
then
I
can
click
on
one
of
the
name
spaces
and
have
kubernetes
magic.
Just
switch
the
namespace
for
me
without
having
to
remember
the
long,
complex
commands-
and
that
brings
us
to
the
next
topic.
This
notion
of
of
powered
up
hyperlinks,
the
notion
of
clicking
and
a
terminal
is
pretty
limited
right.
A
I
think
terminology
can
recognize
that
you
have
a
url
that
was
emitted
by
this
cli
and
they
can
turn
it
into
a
clickable
link,
we'd
like
to
generalize
that
so
that,
instead
of
just
being
limited
to
urls,
instead
of
just
being
and
also
instead
of
being
limited
to
just
having
the
click
open
up
a
web
browser
we'd
like
to
generalize
both.
So
I
can
click
on
a
much
more
arbitrary
set
of
things
like
you
would
a
browser,
but
also
make
it
so.
A
A
A
good
example
of
that
is
what
I've
covered
in
the
fourth
topic,
this
notion
of
and
really
enriching
the
notion
and
fully
integrating
the
notion
of
terminal
splitting
into
the
experience.
So
most
terminals
you
can
split
the
terminal.
You
can
go
to
vs,
go
and
click
a
little
split
button
and
nice.
You
can
split
your
terminal
into
two
or
three
separate
side-by-side
views,
so
you
can
do
you
can
get
side-by-side
views?
You
can
see
concurrent
activity
all
simultaneously.
A
So
the
agenda
today,
I'm
going
to
cover
sort
of
try
to
cover
kui
in
three
different
ways.
The
first
is
I'll.
Give
you
a
demo
of
how
you
can
use
kui
today,
just
to
really
make
it
some
of
these
abstract
points
more
real
and
the
cuisinart
for
a
few
years.
You
can
brew,
install
kui
and
use
it
right
away,
and
so
I'll
give
you
a
demo
of
that.
First.
A
A
Repeatability
and
terminals
as
nice
as
they
are,
I
can
copy
and
paste
a
command
and
share
with
somebody,
but,
generally
speaking,
the
the
units
I
need
to
transmit
and
communicate
and
make
repeatable
are
not
just
individual
commands
and
in
a
normal
terminal.
The
only
way
you
can
do
that
is
making
a
script,
but
I
think,
as
python
notebooks
have
shown
us
there's
a
much
better
way.
I
think
much
more
modern
way
of
communicating
and
sharing.
So
I
can
show
you
how
we
can,
with
a
few
minor
changes
to
the
core
cli
experience
we
can.
A
A
So
here's
kui
my
brood,
and
so
I
did
the
bruised
all
ready
to
save
you
from
that
hassle
and
I'm
going
to
show
you
two
ways
to
use
kui.
The
first
is
as
from
it's
versus
from
a
terminal
replacement,
so
I
downloaded
cool
you
brew
installed
it.
I
got
a
double
clickable
application.
I
clicked
on
it
double
click
on
it
and
this
came
up.
It
has
an
icon,
a
kuia
gun
down
there
in
the
dock.
A
A
I
get.
There's
nothing
clickable
here,
there's
some
color
coding,
which
is
cool,
but
it's
it's
not
really.
The
hyperlinks
are
pretty
limited,
so
you
can
see
here.
I
can
click
and
in
this
case
the
ls
controller
and
cui
decides
to
implement
clicks
as
an
ls
of
that
subdirectory-
and
I
can
I
can
start
browsing
around,
I
can
click
around
on
lots
of
different
interesting
things.
I
can
click
on
some
of
the
source
files
and
I
can
get
a
source
preview
of
the
content
of
that
file
and
so
on.
A
So
that's
a
that's
sort
of
a
simple
way
that
we
can
enhance.
We
can
dance
the
experience
clicking
around
different
navigation
of
a
director
hierarchy.
We
can
do
the
same
kinds
of
things
for
kubernetes
resources,
so
I
did
a
k-get
pods.
I
can
do
an
up
arrow
because,
like
it
would
in
a
terminal,
okay,
get
deployed
something
unlike
a
terminal,
because
now
we
have
graphics,
we
can
make
these
things
a
little
richer.
I
can
just
edit
the
previous
command,
okay
name
spaces
oops
or
get
my.
I
spelled
it
or
get
my
replica
sets.
A
I
can
go
back
to
the
deployments,
so
you
can
see
in
both
cases.
In
all
these
cases,
I'm
getting
back
a
tabular
response.
Coulee
has
a
heuristic
whether
if
they're,
if
the
number
of
table
rows
is
small
defaults,
are
presenting
it
as
a
as
a
normal
table.
If
the
number
rows
is
high,
it
defaults
to
showing
it
as
a
this
kind
of
dense
grid
view,
but
I
can
also
just
choose
to
swap
back
to
a
normal
table
view
if
I
want
or
sort
back
to
grid.
A
A
Second
thing
or
the
context
management
so
kind
of
like
an
omacsh.
We
get
some
indication
of
the
current
context
and
the
current
namespace,
but
we
can
do
this.
We
can
have
a
graphical
enhancement,
a
very
selective
graphical
enhancement.
So
here's
a
pop
over
where
I
can
get
a
list
of
all
my
all
my
name
spaces.
I
can
have
some
heuristics
for
distinguishing
system
from
username
spaces.
A
You
can
use
this
component
to
do
type.
It
find
I
can
open
shift.
You
know,
and
the
component
manages
all
this
for
us.
I
can
switch
between
namespaces
at
a
click
of
a
button
and
switch
back
to
default,
and
I
can
do
the
same
thing
for
context.
I
can
switch
to
another
totally
different
cluster
and
I
can
do
a
k
get
product
there
and
you
can
see.
I
have
a
different
set
of
pods
switch
back
to
my
first
con
first
context.
A
A
So
that's
the
context
management,
I'm
just
doing
kind
of
a
whirlwind
tour
of
the
kui
features.
So
now,
let's
think
about
the
the
more
the
richer
hyperlinks
which
are
clicking
and
richer
navigation,
navigations,
a
really
important
part
of
managing
kubernetes
resources,
you're
kind
of
doing
a
lot
of
of
wild
goose
chasing
to
hunt
down
problems,
for
example,
we've
color-coded
these
notice
and
if
one
of
them
were
red,
for
example,
because
the
pod
was
failing,
it
would
show
up
as
a
red
square
instead
of
a
green
square.
A
A
So
I
need
to
cycle
through
to
do
a
little
a
little
bit
of
a
search
right
to
find
the
right
one
so
notice,
I'm
doing
I'm
clicking
through
a
set
of
pods
and
every
time
I
click
I
get
a
new
pod
on
the
right,
but
I
still
get
just
like
a
normal
terminal.
I
get
a
history
of
each
one
of
those
also
notice
that
kui
does.
It
makes
best
effort
to
not
hide
the
details
so
of
the
seal
underlying
cli
commands.
A
So,
while
it's
decorating
with
this
nice
multi-tab
view
kind
of
like
what
you
might
see
in
a
graphical
browser
console
from
openshift
or
google
cloud
or
or
amazon,
we
also
see
the
underlying
command
and
I
can
change
this
command
like
I
was
changing
commands
previously.
If
I
want
to
change
namespace
or
change
the
output
to
be
something
else,
I
can
do
all
that
because
the
command
line
is
right
there,
so
we
haven't
tried
to
keep
the
command
line
as
integral
to
the
experience
as
possible,
so
each
one
of
these
pods.
A
Now
I
can
look
at
the
details
of
it.
So
maybe
I
want
to
see
the
raw
yaml.
I
can
do
that.
Maybe
I
want
to.
I
want
to
delete
it
at
the
click
of
a
button.
I
can.
I
can
delete
the
resource
with
a
prompt,
you
know
so
like
we
can
do
those
kinds
of
enhancements.
I
can
get
a
couple
exec
into
the
pod
like
we
win
a
graphical
console,
but
I'm
doing
this.
You
know
simultaneously,
unlike
in
a
console
where
they
made
a
choice,
to
have
this
kind
of
very
modal
experience.
A
I
can
be
logging
into
a
bunch
of
pods
simultaneously,
so
you
can
see.
I
have
some
logs
showing
up.
I
have
a
terminal
and
into
the
pod.
We
have
some
primitive
filtering
capability
to
do
road
based
filtering,
and
so
that's
so
that's
the
the
experience
of
drilling
down
from
a
table
to
a
pod,
but
once
I'm
there
I'm
drilling
down
from
the
pod
to
the
logs
or
sshing
into
the
pod.
I
can
also
see
related
resources.
Every
pod
runs
on
a
node.
A
A
Notice
these
logs
have
some
antsy
antsy
coloring,
so
cooley
takes
care
of
that
for
free.
I
can
also
drill
down
to
the
the
replica
set
that
manages
that
deployment.
I
can
view
to
click
down
drill
down
to
the
deployment
that
manages
the
replica
set,
and
I
can
also
see
the
events
for
any
of
these
resources.
I
think
these
resources
are
all
pretty
old,
so
the
events
have
all
timed
out,
but
you
would
see
a
table
of
events
as
well,
so
this
is
cooi
as
a
terminal
replacement.
A
And
instead
of
ascii,
I
get
back
a
pop-up
window.
In
this
case,
you
may
see
notice
the
similarity
to
what
we
were
seeing
previously.
It's
just
kui,
but
instead
of
running
in
a
full
terminal
replacement,
it's
running
this
more
pop-up
kind
of
mode,
but
it
has
all
the
same
features.
I
can
click
and
navigate
and
drill
down
get
into
the
logs
and
so
on,
because
it's
treated
more
as
a
pop-up.
You
know,
like
it's
kind
of
run
and
done
right
when
I'm
done
with
this
graphical
exercise,
I
close
the
window
and
return.
A
A
So
underlying
all
that
magic
is
a
framework
for
enhancing
clies
in
a
much
more
general
way.
So
I'll
give
you
some
insight
into
that
now.
The
basic
idea
behind
piankui
is
it.
Has
these
three
main
ways
that
we've
already
seen
for
extending
the
first
is
you
can
listen
for
execution
of
sub
commands
like
couple
get
pods
and
completely
override
what
that
particular
command
returns
to
the
user?
I'll,
give
you
some
examples
of
the
kinds
of
options
you've
seen
some
of
them
tables,
but
there's
a
couple
others.
A
The
second
is
is
more
of
a
decorator
pattern.
So
if
you
wanted,
for
example,
add
a
tab
to
that
multi-tab
view
that
was
showing
for
pods,
maybe
you
want
to
have
a
custom
log,
viewer
and
kui
lets.
You
specify
a
decorator,
you
don't
have
to
override
the
command
entirely.
You
just
want
to
add
a
tab
to
the
existing
response
in
gui.
You
can
do
that
and
you
can
be
very
selective.
You
can
say
one
for
any
kubernetes
resource
I
want
just
for
pods
or
I
wanted
this
for
pods
with
a
certain
label,
for
example.
A
So
you
can
be
very
selective
about
what
kinds
of
resources
you're
decorating
and
you
can
choose
what
the
content
of
that
tab
is
going
to
be
I'm
in
the
in
the
very
same
kind
of
way
you
can
choose
pretty
flexibly.
What
the
command
handler
should
return
and
lastly,
of
course
you
can
add
these
context
widgets
to
the
experience.
A
So
the
basic
idea
is
that
you
would
go
to
our
template.
Repository
click
on
the
generate
and
get
your
clone
start.
The
webpack
watchers
run
npm
run
open,
you'll,
see
a
window
like
that.
Somebody
show
you
quick
examples
of
what
that
might
be
like,
so
I've
already
cloned
and
generated
the
template
for
you.
So
let
me
just
do
the
npm
run
open,
there's
the
window
that
I
promised
so
a
couple
of
things
that
we
did
here.
A
First,
you
can
see
on
the
bottom
there
we
have
a
little
cat
and
dog
thing,
so
there's
a
context,
widget
very
easy
to
do
fun
down
there.
Click
on
that
it
takes
you
to
command,
that's
another
command
that
we
added
there.
We
have
hello
dogs,
we
have
a
chat-
and
these
are
examples
of
simple
commands
that
listen
for
a
particular
subtree
execution,
so
hello,
cat,
hello,
dog
and,
in
this
case
there's
arnowski,
but
of
course
you
can
have
a
lot
of
other
sophisticated
options
for
for
returning
fancy
graphics.
A
You
can
return
a
tabular
model
and
get
views
like
the
grid
I
showed
shown
previously
or
a
sequence
diagram.
If
your,
if
your
tabular
data
has
a
well-defined
notion
of
start
and
end
time
for
every
for
every
row,
you
can
get
source
links
I'll
show
you
an
example
of
that
later.
So,
if
I,
for
example,
if
I
do
a
couple
apply,
dash
f
it'd
be
nice
to
show
the
user
the
content
of
that
source
file
so
that
they
can.
They
can
look
at
it
without
having
to
find
that
download.
A
You
know
go
to
the
website
if
you're
doing
a
f
on
an
http
source,
you
can
return
source
code
that
gets
index
color
like
a
shown
on
lower
right
and
of
course
you
can
return
that
multi-tab
view
and
in
all
these
cases
you
can
choose
to
have
the
content
of
the
tab
or
the
the
response
for
your
command
handler
just
be
a
totally
raw
react
component.
That's
bespoke
of
your
own
design!
A
So
let
me
let
me
give
you
a
quick
sense
of
going
back
to
here
of
how
we
might
do
the
decorator
pattern,
then.
So
what
I've
done
in
this
is
I've
done
a
decoration
of
pods,
so
I've
added
a
cat
tab
that
has
some
some
gmo
on
it.
I've
also
added
a
little
dog
button.
When
I
click
on
the
dock
button,
it
actually
exceeds
the
command
and
you
can
see
I've
added
a
little
badge
up
there
as
well.
So
it's
very
easy
with
three
lines
of
code.
A
You
can
be
adding
these
enhancements
these
decorations
for
existing
kubernetes
resources.
The
podcat
tab
is
pretty.
The
code
is
very,
very
straightforward.
You
write
a
little
filter,
you
say
when
do
when
should
this
this
decoration
apply,
we
have
a
convenience
method
is
pod
that
you
can.
Leverage
we
have
is
deploy,
is
cube,
resource
and
so
on,
and
then
you
specify
what
the
content
of
that
tab
should
be,
in
this
case
we're
using
a
utility
routine
that
converts
the
json
into
yaml
the
ammo
text,
and
then
that's
what
shows
up
here.
A
So
that's
the
decorator,
the
the
framework
very
quickly.
At
the
end,
I
want
to
talk
through
about
how
we
can
sort
of
bring
kui
beyond
being
just
a
way
to
execute
commands
and
have
it
as
a
way
of
capturing
our
experiences
and
communicating
them
in
a
much
more
notebook-like
fashion.
So
here's
some
screenshots
of
the
kinds
of
notebooks
that
we
have
in
cui.
I
think
it
looks
pretty
cool.
We
can
see
in
all
cases
it's
it's
solar,
so
cli
centric
experience
you
can
have
cuddle
commands.
A
A
I
hit
a
command
x
to
copy
that
and
I
paste
it
up
at
the
top.
So
now
I
have
some
introduction
to
this
to
this.
Notebook
second
is:
I
need
to
save
it
to
a
file
and
then
you're
done
now.
You
have
a
notebook,
don't
bother
that
I'll
show
you
some
of
our
pre-recorded
notebooks,
so
here's
one
of
the
ones
I
was
showing
a
screenshot
of
you
can
see
that
kui
notices
that
when
you,
when
you're
replaying
pre-recorded
output,
it
makes
make
tries
to
make
clear
to
the
user.