►
From YouTube: Cloud Native Live: Telegraf Kubernetes Operator
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
Hello,
everyone
and
welcome
to
cloud
native
live
where
we
dive
into
the
code
behind
cloud
native.
I
am
your
host
itai
shakuri.
I
am
the
director
of
open
source
at
aqua
security,
I'm
also
a
cncf
cloud
native
ambassador
and
the
host
of
today's
show.
So
every
week
we
bring
a
new
set
of
presenters
to
show
you
how
to
work
with
cloud
native
technologies.
They
will
build
things
and
break
things
and
answer
your
questions.
A
This
week
we
have
the
influx
db
team
to
talk
with
us
about
telegraph,
kubernetes
operator.
We
have
quite
a
crew
today,
so
they
will
introduce
themselves
in
a
minute.
I
just
want
to
remind
everyone
first,
that
this
is
an
official
live
stream
of
the
cncf
and,
as
such
is
subject
to
the
cncf
code
of
conduct.
So
please
don't
add
anything
to
the
chat
or
questions
that
would
be
in
violation
of
that
code
of
conduct,
basically
just
be
nice
to
each
other
and
the
presenters
as
well.
A
So
with
that
I'll
hand
it
over
to
pat
to
kick
off
the
round
of
introductions.
B
Cool
so
we'll
go
around
and
do
a
quick
round
of
introductions.
So,
first
I'll
start
with
me:
I'm
pat
gone
engineering
manager
at
influx
data
of
the
deployments
team,
so
we're
the
team
responsible
for
continuously
deploying
our
product
into
kubernetes
in
the
cloud
and
with
that
voice
check,
you
want
to
introduce
yourself.
C
B
B
E
Hello,
I'm
bad.
I
beat
chess
pass
at
chess
once
and
she's
salty
about
it.
I'm
alan
also
known
as
popey
I'm
a
developer
advocate
on
the
telegraph
team
and
I'm
based
in
the
rainy
united
kingdom.
B
B
Cool,
so
so
voice
is
going
to
actually
work
on
the
telegraph
operator
he's
going
to
share
his
screen
and
he's
going
to
do
that
and
before
he
does,
that
I'm
going
to
I'm
here
to
quickly
introduce
a
couple
of
things
that
will
be
relevant
to
his
live
coding
section
session.
B
So
what
voytek
is
going
to
be
working
on
today
is
the
open
source
telegraph
operator,
which
is
hosted
at
github.com
influx
data
telegraph
operator
I'll
leave
it
to
him
to
describe
what
changes
he's
got
planned
today,
but
I
wanted
to
quickly
explain
what
telegraph
is
and
why
the
heck
we
want
a
kubernetes
operator
for
it.
We've
got
a
couple
members
of
our
telegraph
team,
which
we've
already
introduced
here
to
answer
questions,
but
I'll
keep
it
light
for
now
and
leave
room
for
questions
or
conversation
during
our
session
today.
So
please
do
ask
questions.
B
I
think
you
get
the
idea,
there's
a
lot
of
choices
here,
so
I
checked
earlier
and
there
are
close
to
250
plugins
now
so
jess
your
team
has
been
busy
and
your
community
has
been
busy,
so
telegraph
can
collect
metrics
from
a
lot
of
different
sources,
but
for
today's
discussion
the
focus
is
going
to
be
the
the
input
is
kubernetes
on
the
output
side.
There
are
also
a
lot
of
different
options,
but
internally
in
flux,
I
don't
want
to
shock
y'all,
but
we
tend
to
use
the
influx
db
output
plug-in.
B
So
so
that's
what
we're
gonna!
That's.
I
think
what
we're
gonna
show
today
I
do
want
to
mention
you
can
there's
a
lot
of
different
out
output
plugins
that
are
available.
If
you
don't
wanna
use
influx
tv,
the
telegraph
operator
packages,
the
operational
aspects
for
deploying
a
telegraph
agent
on
kubernetes,
it's
deployed
as
a
sidecar
container
based
on
annotations
and
provides
a
telegraph
configuration
to
scrape
the
exposed,
metrics
all
defined
declaratively.
B
It
allows
you
to
find
common
output
destinations
for
all
your
metrics.
So
in
one
place
you
can
say
where
you
want
all
of
your
kubernetes
metrics
to
go
on
all
your
application
metrics.
So
that's,
I
think,
really
quite
useful.
The
outputs
are
called
classes.
It
generates
telegraph
configuration
by
combining
all
the
different
pieces,
the
configuration
outputs
assigned
as
classes
along
with
the
pod
annotations
that
describe
what
data
to
scrape
and
how
and
yes,
I
did
read
that.
I
I
because
I
wanted
to
prepare
for
you
all
ahead
of
time.
B
So
so
I'm
hoping
that
when
voice
is
waiting
for
something
to
build
or
start,
we
can
press
him
on
some
of
the
details
of
what
I've
just
described
and
with
that
I
hand
it
over
to
you
voice
to
do
as
iche
said,
to
build
and
break
things
so
go
forth
and
build
and
break
things
voice.
C
Thanks
a
lot
for
the
introduction
part.
Yes,
so
what
I'm
hoping
to
be
doing
today,
assuming
nothing
breaks,
is,
is
to
extend
the
telegraph
operator
that
we
talked
about
to
allow
hot
reloading
of
configuration
changes.
So
there's
been
a
recent
pr
and
I'm
just
going
to
throw
it
out
here
for
a
few
seconds
that
allows
detecting
and
reloading
of
telegraph
itself.
That,
I
believe,
is
either
released
as
of
today
or
will
be
released
soon.
But
that
has
been
a
quite
a
recent
change
which
allows
telegraph
itself
to
detect
the
changes.
C
What
we
want
to
do
now
is
for
those
of
us
that
use
the
telegraph
operator
to
do
to
our
to
inject
the
telegraph
into
into
kubernetes
deployments
so
that
we
could
take
it
to
the
next
step
that,
if
you
change
a
configure
class
as
but
I
mentioned
in
a
telegraph
operator-
configuration
that
this
change
gets
propagated.
All
the
way
to
all
of
your
telegraph
site
containers
so
I'll
start
by
explaining
and
that's
in
the
contributing
documentation.
C
So
I'll
show
that
I'll
start
by
explaining
how
we
develop
a
telegraph
operator
and
how
what
I'm
going
to
be
using
today.
So
obviously
we
have
a
lot
of
tests
and
these
are
really
important,
but
the
the
the
most
important
things
is
being
able
to
run
the
code.
We're
going
to
run,
live
in
a
kubernetes
cluster.
C
So
for
that
we
have
a
pretty
much
ready
to
use
setup
of
using
kubernetes
in
docker,
so
kind,
and
I
just
happened
to
have
kubernetes
a
kind
cluster
deployed
already,
and
I
happen
to
have
a
build
of
of
telegraph
with
that.
Pr
that
I
just
showed,
which
is
important
because
again
it
may
not
have
been
released
yet,
and
I
didn't
decide
to
try
the
last
minute.
So
I
I
came
prepared
with
my
own
tribute
image
so
right
now.
What
I'm
going
to
do
is
this
I'll
explain
what
the
change
will
be.
C
The
way
telegraph
works
is
it
has
a
config
file
and
the
way
telegraph
operator
uses
it
is
we
have
a
secret,
a
kubernetes
secret
that
has
all
of
its
con.
That
has
the
final
configuration
generated
and
then
that's
mounted,
as
a
volume
for
telegraph
and
telegraph
operator
works
in
a
similar
way
that
we
have
a
secret
with
with
with
the
classes
definition,
and
that
is
also
mounted
so
in
order
to
do
this
end-to-end.
My
goal
would
be.
C
So
that
is
the
plan
I'll
start
by
creating
the
two
different
parts
of
the
change
that
I
think
I
will
need.
So
I
think
I'm
going
to
need
something
like
a
watcher
which
is
going
to
be
watching
the
file
system.
The
reason
is
because
telegraph
operator
is
reading
the
files
as
the
mounted
volume,
so
the
natural
way
of
interacting
with
it
would
be
would
be
to
just
use
to
just
use
the
the
file
system
and
what
we're
going
to
be
using
and
I'll
just
import
it
for
now.
C
Just
so
it's
there,
and
I
can-
and
I
can
have
it
in
here
already
so
we're
going
to
use
a
a
package
called
fs
notify,
which
is
a
cross
platform
package
to
get
notifications
for
file
system
changes.
So
that's
going
to
be
the
first
part
that
I
that
I
want
and
I'm
going
to
make
a
comment
of
what
we'll
be
building.
So
it's
so
it's
always
visible,
so
logic
that
monitors
telegraph
classes
directory
because
it's
a
directory
that
just
mounts
the
secret
and
calls
a
function
when
it
changes.
C
So
this
is
what
will
be
in
this
file
and
we
will
also
create
another
file
which
I
will
call
updates
to
go
and
this
observer
and
this
file
will
have
logic
to
find
all
secrets,
managed
managed
by
telegraph
graph
operator
and
update
them.
So
that
is
the
first
thing
that
I
want
to
do,
but
while,
but
I
also
want
to
show
how
what
I
need
to
do
to
have
to
have
the
changes,
because
that
will
allow
me
to
explain
the
development
workflow
of
telegraph
operate,
which
I
think
is
quite
interesting.
C
I
kind
of
really
believe
yes,
so
there
is
a
make
target
that
just
builds
and
maybe
I'll
simply
show
this
kind
field
that
builds
the
image
and
then
we
use
a
feature
of
kubernetes
in
docker
called
side
loading
that
will
load
the
images
speed
locally
into
docker
into
the
kind
cluster.
So
when
I'm
going
to
be
deploying
the
telegraph
operator,
I
am
going
to
be
providing
my
local
image.
There's.
C
Also
one
thing
that
I
have
prepared,
I
prepared
so
we,
the
repository,
provides
a
ready
to
deploy
yaml
file
that
allows
developing
that
allows
running
telegraph
operator
for
development
purposes.
So
it
has
a
static
self-signed
set
of
certificates
for
which
are
needed,
because
telegraph
operator
is
using
mutating
web
hooks
and
I
will
get
to
that
in
a
bit.
C
But
we
have
that
ready
to
use.
I
simply
modified
this,
so
it
passes
some
settings
to
the
to
the
telegraph
operator,
specifically
using
my
image
that
my
kind
cluster
already
has
loaded
and
to
tell
telegraph
to
monitor
the
the
file
system
for
changes,
because
that's
not
enabled
by
default
at
this
as
of
as
of
now,
since
the
latest
telegraph
doesn't
support
it.
Yet
so
now
that
I've
built
it,
I
can
just
apply
my
deploy,
dev
deploy
watch.
C
So
I
can
deploy
my
telegraph
operator
and
I
can
see
that
it's
that
it's
running
already
so
the
way
telegraph
operator
works
and
I'm
going
to
deploy
an
example
of
redis,
so
we
can
get
started
with
how
it
works.
I
have
my
simple
radius
deployment.
It
has
some
annotations
specifically
how
to
get
the
input,
and
this
is
a
snippet
of
telegraph
configuration
and
it
mentions
the
class,
which
is
the
type
of
application
deficit,
I'm
going
to
create
a
namespace
test,
which
is
where
this
gets
deployed
and
I'm
going
to
deploy
my
redis
example.
C
So
this
is
how
telegraph
works
today,
and
but
now
what
I'm
really
interested
in
is
is
doing
the
reloading
logic.
So
in
order
to
get
bootstrapped
with
this,
we're
going
to
be
cheating
ourselves
a
bit
initially,
so
I'm
going
to
create
a
structure
for
the
watcher
which
we'll
be
using,
and
now
I
can
actually
do
this,
which
will
be
using
a
watcher.
C
And
we
will
be,
I
think
that
may
be
all
that
we
need
for
now,
and
we
can
oh,
we
also
want
to
have
the
the
callback
which
you
can
say
which,
which
you
can
define
as
a
type.
C
C
We're
going
to
be
cheat,
oh,
we
also
want.
We
also
want
is
a
logger.
That's
what
would
be
nice
if
we
have
that
for
some
reason
mike
okay,
so
we
want
to
get
the
logger
and
also
okay.
This
is
what
we
really
want.
Okay,
so
what
we
want
to
get
is
the
logger
and
the
telegraph
classes
directory
and
the
unchange,
and
obviously
this
would
return
my
structure
or
an
error.
C
So
let's
create
this.
I
need
to
copy
the
logger
into
well.
We
don't,
probably
we
don't
need
a
directory,
but
let's,
let's
keep
it
in
here.
We
can
clean
it
up
later
and
unchange.
Okay.
So
for
now,
there's
not
much
logic
in
here.
That
should
be
fine,
except
I
don't
know
why.
My
oh
okay,
I
need
to
go,
get
go,
get
calm!
C
So
fs
fs
notify
is
a
package
for
detecting
changes
in
the
file
system.
Okay,
so,
as
I
mentioned,
we
since
we
mount
okay,
I'll
also
show
the
classes,
so
we
have
the
classes
which
are
the
which
are
the
outputs
that
we
talked
about.
So
we
have
the
classes,
and
this
is
a
kubernetes
secret
and
then
in
the
deployment
of
our
telegraph
operator,
this
is
mounted
as
a
as
a
path
for
in
the
telegraph
operator.
So
because
this
is
mounted
as
a
file
system,
we
want
to
watch
whenever
this
changes.
C
So
one
of
the
things
one
of
the
nice
things
about
mounting
secrets
as
volumes
instead
of
using
environment
variables,
is
that
whenever
the
secret
changes
it
takes
a
few
seconds
or
up
to
a
minute
from
my
experience,
but
the
change
gets
propagated
to
the
pod.
So
we
want
to
monitor
this
directory
to
see
the
changes,
but
we're
going
to
start
a
bit
smaller.
C
Okay,
so
we
we're
doing
this,
but
instead
of
actually
watching
the
file
system.
For
now,
as
I
mentioned,
we're
going
to
be
cheating
a
bit,
so
we're
going
to
write,
of
course,
going
to
write
a
dummy
function
which
is
just
going
to
be
sleeping
and
calling
the
callback
every
10
seconds.
So
the
reason
why
we're
doing
it
this
way
is
because
now
we
don't
have
to
implement
the
whole
logic
for
the
watcher
to
implement
the
other
part,
which
is
the
updates.
A
I
see
we
have
a
couple
of
newcomers
that
have
joined,
possibly
after
we
did
the
introduction.
So
could
you
just
very
quickly
recap
the
context
for
everyone
who
joined
recently
what
these
were
doing
and
yeah.
C
We
want
to
support
the
case
that
we,
if
I
go
and
change
my
settings,
which
we
call
and
change
to
what
we
call
classes
so
one
of
the
types
of
applications
that
could
be
monitoring.
If
I
change
something
in
here,
I
want
that
update.
Just
updating
the
secret
will
end
up
in
in
telegraph
operator
and
telegraph
getting
to
the
point
where
they
transparently
get
the
latest
configurations.
They
just
applied
and
reload
the
configuration.
C
So
telegraph
starts
using
the
new
settings
instead
of
the
old
settings
and
the
rational
is
that
when
we
can,
we
don't
need
to
mention
it
previously.
The
rational
is
that,
if
you're
monitoring
a
lot
of
odds
and
systems-
and
we
do-
we
use
serious
trigraph
operator
in
anger.
So
after
we
have
one
of
the
issues
we
had
is,
if
we
ever
change
settings
like
we
want
to
change
the
token
or
where
the
data
is
sent
or
like.
We
want
to
send
the
data
to
multiple
databases.
C
We
can
have
a
mirror
of
the
data
to
before
the
feature
that
we're
going
to
be
implementing.
We
would
have
to
go
in
and
force
a
restart
of
all
of
the
diesel
of
the
telegraph
containers,
and
often
this
meant
restarting
all
of
the
pots,
and
what
we
want
to
get
to
is
that
all
of
these
configuration
changes
happen
transparently
and
as
as
an
operator
of
a
cluster.
I
could
just
go
edit,
the
edit
the
settings
for
telegraph
operator
and
it
gets
propagated
to
all
of
the
parts
that
that
need
to
change
applied.
B
I
know
we're
pretty
excited
about
using
this
internally,
because
this
is
something
like
because
we
use
this
operator
in
our
in
our
product
and
we'll
make
a
change
and
we're
like.
Okay,
now
we're
waiting
for
it
to
be
seen.
So.
C
Yes,
this
is
actually
a
feature
that
came
up
from
our
internal
issues
that
we're
having.
So
this
is
an
improvement
that
we
think
the
community
would
benefit
from,
but
this
is
something
we
would
definitely
benefit
from.
Okay.
So
now
that
I've
created
my
thing,
my
my
changes
to
well
watcher-
I
can
I
can
initialize
this
so
new
telegraph
classes
watcher.
C
Yes
in
here,
so
it
defaults
to
exactly
how
we
mount
the
volume.
But
if
someone
wants
to
use
telegraph
operator
differently,
it
can
be
changed.
So
we
want
to
pass
that
and
then
we
want
to
pass
our
callback,
which
will
be
nil
for
now,
because
we
need
to
implement
our
callback
as
well.
C
C
Let's
call
it
updater,
actually,
which
would
mean
that
I
need
to
update
the
docker
file.
But
somehow
I
don't
like
the
name
updates,
okay
secrets:
let's
call
it
secret
updater
and
what
will
we
need
for
that?
So
we'll
definitely
need
client
set
because
we're
going
to
be
talking
to
kubernetes.
So,
let's,
let's
just
cover
this
client.
C
C
This
this
is
an
object
that
this
is
a
part
of
existing
part
of
the
telegraph
operator.
That's
handling
generate
that's
handling,
adding
the
secrets
managing
the
secret,
so
we
need
that
to
call
some
of
that
logic
to
update
the
secrets.
So
we
have
our
structure
and
we
also
need
a
function
that
can
create
it.
So
we're
going
to
also
take
the
logger
the
car
and
I
don't
think
we
need
anything
else
also.
Yes,
this
should
be
a
point
handler
and
we
will
return
the
secrets,
updater
or
a
point
to
a
security
or
an
error.
C
Okay,
so
now
we
need
to
initialize
the
kubernetes
configuration
because
telegraph
operator
is
running
within
the
cluster.
We
could
just
initialize
this
by
default,
so
let's
just
config
get
config,
oh
okay
and
I'm
happy
to
see
that
vs
code
did
all
of
that
in
its
own.
I
didn't
have
to
think
too
much
about
the
names
of
packages.
Last
time
I
tried
it
that
didn't
work
so
smoothly,
for
me
at
least
with
generating
the
confidence
but
okay,
so
we
have
the
config.
Now,
let's
create
the
client
set
from
config
config.
C
C
C
Make
sure
that
things
that
we
that
we
see
that
log
just
just
to
just
also
show
how
to
deploy
a
new
version
of
telegraph
operator,
and
I
can
actually
start
to
implement
the
changes
while
that's
happening
so
in
order
to
find
all
this.
So
what
we
want
to
do
right
now
is
find
our
namespaces
and
find
our
secret
telegraph
operator
managed
secrets
in
each
namespace.
So
that's
what
we're
going
to
be
doing
telegraph
operator
already.
C
So,
let's
just
just
okay,
let's
just
before
I
continue
with
that-
let's
let's
update
it.
So,
even
though
the
make
kind
built
so
I
run
the
make
kind
build
which
builds
the
image
and
side
loaded
it
into
kind.
But
in
order
to
update
the
deployment
of
telegraph
operator,
I
have
to
go
in
and
first
delete
it.
So
let
me
deploy
my
level.
Let
me
deploy
telegraph
operator
again
and
hopefully
somewhere
in
my
history.
I
have
this
and
I
can
keep
my
logs
of
telegraph
operator
below
and
we
should
see
every
10
seconds.
C
C
We
want
to
create
a
context,
and
let's
add
a
to
do
this
time
out
to
the
context,
so
this
would
be
useful
that
we
could
deal
with
timeouts
in
the
future,
but
okay
for
now,
we
just
want
to
list
it
give
it
the
context,
and
I
believe
you
want
to
do
this,
and
there
is
one
thing
that
I
always
that
visual
studio
always
does.
Visual
studio
always
does
for
me
and
I
keep
on
renaming
it.
C
I
always
prefer
to
be
just
to
be
called
meta
v1,
because
then
the
next
inputs
for
v1
gets
a
bit
more
complex,
so
we
we
don't
have
the
the
watcher
handle
error.
So
in
this
case
we
will
do
something
like
this.
If
error
isn't
new,
we'll
just
log
it
and
and
exit
error,
give
it
the
error,
and
then
we
say
unable
to
list
namespaces.
C
So
if
the
namespaces
were
listed
properly,
we
can
we
can
get,
we
can
iterate
all
items
and
now
what
we
could
do
is
we
could
call
a
function
that
will
implement
update
secrets
in
namespace
space
name
and
oh
okay,
update,
spreads,
namespace,
okay,
let's
do
this
namespace,
so
the
way
the
way
the
logger
works
is
that
you
can
pass
on
a
list
of
key
value
list
after
the
message.
So
I
can
say
this
is
my
message
and
then
I
can
see
this
is
the
namespace
and
it's
going
to
be
included
in
the
logs.
C
C
C
Yes,
namespace
and
we
want
to
list
them
give
the
context.
So
if
you
want
these
options,
but
now
in
the
options
we
want
to
say,
label
selector
and
let
me
check
the
label
so
we
have.
As
I
mentioned,
we
have
two
labels
in
each
of
the
secrets:
we're
going
to
find
the
secret
that
has
the
class
name
set.
We
could
be
using
the
other
label
and
it
would
be
the
same.
C
D
C
Yes,
okay,
so
the
way
it
works
is
that
we
have
a
single
key
called
telegraph.conf,
which
is
the
the
exact
configuration
for
telegraph.
You
can
even
show
this.
I
have
this
visual
studio
called
plugin
that
allows
decoding
and
encoding
base64
for
an
extracted
text,
which
is
super
useful
for
dealing
with
kubernetes
secrets,
because
that
you
have
to
do
this
a
lot.
So
you
can
see
this
is
the
configuration
this
was
in
the
annotation.
C
This
was
in
the
in
the
class,
and
telegraph
also
injects
gathering
internal
metrics
of
telegraph
if
by
default
and
it's
a
it's
a
setting
that
can
be
changed
but
okay.
This
is
the
contents
of
the
secret
and
the
sidecar
handler
that
we
wanted
to
have
in
this
studio
that
we
wanted
to
be
passed.
The
secrets
updater
can
generate
that.
So
there
is
a
method
called
assemble
conf,
which
takes
a
positive
that
we
don't
have
and
takes
the
class
data,
which
is
the
contents
which
is
this.
This
is
class
data.
C
So
now
we
need
to
do
two
things.
First
thing
is:
we
want
to
get
the
pod
so
again,
client
set
core
v1
ports
in
our
namespace
want
to
get
one
the
name.
We
could
use
the
labels
from
the
secrets.
You
could
do
secret.
C
C
C
C
I
believe
it
also
can
return
an
error.
Yes,
so
let's
just
make
it
a
bit
cleaner.
Okay,
so
now
we
have
the
telegraph
configuration,
which
is
the
string
that
we've
seen
in
that
secret,
which
is
just
it's
just
concatenating
all
of
the
settings
validating
this
this.
This
is
a
valid
tumble
file,
which
is
the
syntax
from
telegraph.
C
C
If
it's
not
equal,
then
let's
lock
something
so
we
actually
use
the
logger
and
for
updating
secret
and
let's
lock
something
so
namespace
is
namespace.
Odd
name
is
okay,
so
name,
let's
log,
the
name
of
the
secret
name.
What
name
is
what
name
and
class
is
class
name?
Let's,
let's
load
this
as
well.
This
will
be
quite
variable,
but
it's
useful.
C
C
The
kubernetes
okay,
let's
carve
one
secret
namespace.
Actually
we
could
do
this
we're
using
this.
We
could
just
keep
it
this
way
so
update
and
we
call
an
update
on
the
secrets.
We
need
context,
the
secret
and
the
up
and
empty
options,
so
we're
not
interested
in
the
result,
but
we're
interested
in
the
error.
It
happens.
We
return
it
and
I
think
the
error
isn't
any
variable
anyway
and
if
there
were
no
changes,
let's
just
lock
something.
C
C
C
C
B
C
Okay
right,
so
the
reason
we
chose
to
do
it
as
a
as
a
sidekick
container
is
that
for
some
of
the
for
some
of
the
input
plugins
of
the
means
of
getting
the
data
that
that
data
could
be
retrieved
only
from
the
same,
the
same
part
that
the
actual
application
is
running
in
so
for
redis.
This
is
using
networking,
so
it
would
be
possible
to
run
it
as
a
daemon
set.
C
We
don't
have
the
functionality
in
telegraph
operator
to
do
this,
but
it
would
be
possible
to
do
this,
but
we've
chosen
to
use
sidecar
containers
because
telegraph
isn't
that
large
of
a
process
in
some
cases
it
is
easier
to
get
or
more
information
could
be
gathered
from
within
the
same
pod,
and
we
found
this
to
be
also
more
manageable.
If
there
is
a
if
there
is
a
sidecar
container,
because
there
is
also
the
matter
of
of
watching
and
then
batching
small
sets
of,
because
telegraph
isn't
always
sending
the
data
right
away.
C
But,
for
example,
if
if
it's
trying
to
send
data
to
a
database
like
an
influx
db
database,
that's
not
available
at
this
point,
it
will
keep
it
in
memory
and
send
it
later
on,
and
then
in
that
case
it
is
better
to
have
more
smaller
instances
of
telegraph.
I
understand
that
this
could
be
somewhat
more
resource,
some
using
some
so
much,
some
somewhat
more
resources,
but
we
found
this
to
be
more
reliable
and
potentially
well.
C
C
Well
before
that
happens,
the
telegraph
operator
gets
receives
a
an
api
call,
which
is
called
our
admission
request
where,
where
the
type
of
request
and
the
object
gets
passed,
so,
for
example,
in
our
logic
we
check.
If
this
is
a
delete,
then
we
then
we,
then
we
delete
the
secret
that
would
be
associated
with
this
specific
pod.
So
if
someone,
for
example,
deleted
that
deployment
and
this
to
give
the
deletion
of
a
pot,
then
before
this
spot
gets
deleted,
we
also
delete
the
secret
the
telegraph,
the
secret
of
the
telegraph
configuration
in
other
cases.
C
We
call
the
site
handler
to
check
if
it
should
be
skipped
and
then
to
inject
the
to
generate
the
secret
to
then
we
add
the
secret
to
kubernetes
by
api
calls,
and
then
we
returned
a
modified
hot
pot
spec.
So
at
some
point
we
create
a
secret
and
we
also
patch
it
with
the
with
the
updated
pot
definition.
So
that's
what
happens.
Okay,
so
it
builds.
So
let
me
delete
the
deployment
now.
Let
me
apply
this
and
we
can.
C
C
So
we
can
see
the
message
that
the
updater
got
was
called
and
then
it
checks
every
secret.
I
could
at
this
point
I
could
deploy
somewhere
up
some
more
examples,
so
we
have
for
developing
purposes.
We
have
a
few
examples.
I
deployed
the
redis
example,
which
is
a
stateful
set,
but
let
me
also
deploy
a
deployment
which
I
believe
is
an
ingress
deployment.
C
Yes,
and
that
deployment
has
three
parts,
because
the
number
of
replicas
is
set
to
free
in
that
example-
and
we
can
see
now
that
telegraph
operator
is
updating
the
three
secrets,
one
secret
for
each
of
these
parts
and
the
fourth
secret,
for
that
is
so,
let's
modify
this.
Let's
call
this
classes
updated
and
let's
say
so,
and
maybe
I
will
show
this
as
well,
so
in
the
up
section
we
can
see
that
the
telegraph
should
we'll
be
trying
to
send
it
to
influx
db,
which
I
may
even
have
in
that
cluster.
C
I
don't
really
remember,
but
it's
also
writing
to
standard
out.
So
if
I
were
to
do
capital
logs
ready,
zero
in
the
test
name
space
and
let's
just
take
the
last
20
lines,
we
can
see
that
telegraph
was
reporting
a
lot
of
metrics
to
standard
output.
By
the
way
this
is
line
protocol,
which
is
a
a
protocol
for
sending
metrics
to
inflex
db
and
I
believe,
some
other
applications.
Let's
use
it
and
that's
just
because
we
told
telegraph
to
lock
the
standard
out.
C
C
So
now,
if
I
take
a
look
at
the
logs
from
telegraph
operator
and
we
can
skip
not
updating
because
we
know
we
know,
there's
a
lot
of
things
in
there
as
soon
as
the
as
soon
as
this,
the
mounted
volume
that's
based
on
the
secret
gets
updated.
The
graph
operator
will
pick
it
up,
so
you
can
see
now
the
telegraph
operator
picked
it
up.
It
said
updating
secret
and
it's
only
updated
the
secret
for
redis,
because
the
one
for
nginx
didn't
change.
So
now
we
could
try
to
get
the
logs
for
the
telegraph
for
reddit.
C
It
takes
around
one
minute
for
the
volume
change
to
get
propagated,
but
I'm
quite
sure
that
this
that
this
has
happened,
so
I'm
not
going
to
go
and
check
the
rope
secret
on
my
own.
I'm
assuming
I
didn't
make
any
mistakes,
if
I
believe
in
that.
But
while
this
is
happening
and
hopefully
we'll
see
the
change
soon,.
D
C
C
C
If
error
isn't
new,
then
it's
an
error.
So
a
watcher
on
its
own
doesn't
do
a
lot
of
things.
It's
just
a
mechanism,
but
what
we
need
to
do
now
is
we
need
to
add
all
of
the
paths
that
should
be
monitored
so
in
in
the
perfect
world.
This
is
what
I
would
need
to
do
and
also
let
me
just
watch
it
around
right
in
the
perfect
world.
C
This
is
what
I
would
need
to
do,
but
because
of
the
way
in
which
secrets
are
handled,
let's,
okay,
let's,
let's
exaggerate
into
the
red
spot
and
I'll
explain
so
first
thing
is:
let's:
let's
take
a
look
at
the
log
file,
we
can
see
it's
happening
and
I
mean
it's
there
and
I
suppose
it's
growing.
You
can
check
it
in
a
bit,
but
what
I
really
wanted
to
show
is
how
secrets
are
mount
as
mounted
as
volumes,
because
that
determines
how
the
monitoring
should
be
happening.
C
This
is
something
we
also
had
to
understand
for
the
for
the
telegraph
for
the
monitoring
of
the
trigraph
config.
So
just
monitoring
the
directory
would
not
be
enough
because
the
way
volumes
get
mapped
is
there
is
a
directory
starting
with
dot
dot.
That
is
the
current
contents
of
the
of
the
secret.
So
if
I
list
this
directory,
I
will
see
this
is
the
telegraph
conf.
Then
we
have
dot
data
which
is
assembling
to
that
directory,
and
then
we
have
the
actual
file
linking
to
dot
data.
C
So
if
I
would
be
trying
to
monitor
the
directory
or
just
the
specific
files
it
may
not
be,
it
may
not
always
be
enough,
and
it's
so
we're
going
to
have
to
do
something
a
bit
more
than
that,
so
we're
going
to
be
listing
all
of
the
items
in
that
directory
and
again,
if
there's
an
error,
let's
just
return
it
and
let's
and
we're
going
to
be
iterating
over
this.
This
is
more.
This
is
less
cloud
native.
This
is
more
just
fire
system,
but
still
something
we
need
to
be
doing.
C
So
what
we
want
to
do
is
we
want
to
monitor
the
data
all
of
the
all
of
the
assemblings,
but
we
want
to
skip
all
of
the
data
folders
and
the
parent
and
current
directory,
because
this
is
not
really
interesting.
So
let's
do
this,
let's
get,
let's
get
the
name,
so
I
don't
have
to
call
the
name
method
all
the
time.
C
So
if
the
name
is
dot
data,
then
we're
interested
in
that
or
if
the
name
isn't
a
single
dot.
So
we
want
to
ignore
that,
and
what
we
want
to
ignore
is
all
of
the
other
paths
that
start
with
double
dots.
So
that's
prefix,
okay,
not
name,
doesn't
have
prefix
two
dots
so
list
all
halves,
except
for
current
previous
secret
contents
and
okay.
C
C
C
All
of
the
entire
contents
of
the
volume
monitored,
so
we
can
get
rid
of
our
dummy
monitor
at
this
point,
monitor
for
changes.
C
C
C
So
whenever
we
get
this
event,
we
could
just
color
or
unchange,
but
we
could
also
log
event
received
okay
now,
so,
let's,
let's
just
check
that
the
okay
set
to
yes-
and
I'm
pretty
sure
I
put
something
in
here-
that's
what
happens
during
the
live
coding,
but
no
it
should
be
okay,
it's
this!
Yes,
obviously,
but
okay!
So
and
oh
right,
okay,
so
I
think
we
don't
even
need
the
four,
which
is
another
thing,
so
I
think
that's
that
should
be
enough
to
get
the
the
events
and
this
should
trigger
the
changes
later
on.
C
So,
let's
build
this
and
in
the
meantime,
let's
try
to
let's
try
to
do
the
batching,
so
the
idea
I
have
for
batching
is
quite
simple.
What
you
really
want
is
use
another
go
routine,
notify
on
change
which
I'm
going
to
implement
right
now
and
use
a
very
simple
mechanism.
Maybe
there
could
be
a
other
way
to
do
this,
but
we
don't
have
a
lot
of
time
anymore,
so
this
would
be.
C
C
C
Let's
see
that
it
started
so
now,
the
last
time
we
applied
classes,
it
was
the
updated
version
so
to
apply
a
change.
We
need
to
apply
the
original
ones
and
let's
keep
the
logs
in
here
to
see
if
anything
happens,
but
in
the
meantime
I
could
continue
with
figuring
out
my
code.
So
what
we
want
to
do
is
we
want
to
get
event
to
actually
event
channel,
so
we
want
to
get
so.
What
we
want
to
do
here
is:
let's
keep
this,
but
instead
of
what
we
had
there
before.
Let's
do
something
like
this.
C
This
is
how
I
often
handle
basic
handling
of
synchronization.
So
every
time
we
get
an
event
we're
going
to
be
increasing
the
event
count
by
one
also,
we
should
create
a
channel
which
is
another
thing,
but
we
will
send
a
throw
to
the
event
channel,
but
obviously
we
also
need
to
initialize
the
channel
here
so
event
channel.
C
C
C
So
you,
you
could
be
getting
multiple
events
in
this
case
we
only
received
one
and
we
could
see
that
it
worked.
So
we
could
see
that
we
have
basic
logic
without
the
batching,
but
I've
seen
fs
notify,
send
a
lot
of
notifications
in
many
cases.
So
it's
it
is
a
good
idea
to
have
the
batching
on
top
of
it.
C
D
D
C
C
A
So,
let's
try
to
summarize
what
we've
done
so
far.
If
you
can
just
do
a
recap
of
what
we've
achieved,
I
think
we've
achieved
quite
a
lot.
I
mean
I'm
I'm
watching
here,
it's
fascinating!
We
don't
get
a
lot
of
sessions
that
did
at
this
level
in
the
show,
so
I'm
very
happy
that
we
get
an
opportunity
to
watch
how
things
are
being
made
and
not
just
how
to
use
them.
A
C
Yes,
okay,
so
what
we've
achieved
is
we
are
at
the
point
a
kubernetes
operator
can
can
have
a
can.
Trans
can
change
settings
in
the
telegraph
operator
classes,
so
the
global
settings
for
telegraph
operator
and
how
things
should
be
monitored
so
such
as
a
typical
case
could
be.
I
want
to
send
my
monitoring
data
to
multiple
sources,
to
multiple
outputs.
C
I
could
just
update
my
global,
my
secret,
that's
global
to
the
cluster
and
we've.
Actually,
we've
arrived
at
the
point
where
telegraph
operator,
along
with
telegraph,
would
have
the
hot
reload
of
all
of
this.
So
I
just
update
the
secret
and
a
few
minutes
later.
All
of
the
telegraph
containers
in
my
cluster
would
have
the
updated
configuration
would
start
sending
the
data
to
different
or
multiple
sources.
I
would
be
handing
the
data
differently,
so
I
don't
have
to
go
and
send
signals
and
kill
signals
or
do
other
things
to
restart
all
of
the
telegraphs.
A
Yeah
definitely
really
nice,
and
if
someone
wants
to
follow
up
and
and
watch
the
complete
feature,
where
would
they
be
able
to
do
that?.
C
Yes,
so
telegraph
is
on
github.
Let
me
just
open
a
browser
and
pull
it
to
my
other
screen,
so
we
have
a
github
repository
called
telegraph
operator
and,
as
you
can
see,
I
was
the
last
contributor
here.
So
this
is
an
open
source
project.
We
have
we're
actively
maintaining
it
all
of
the
we
have
a
ci
in
place.
A
Cool
if
anyone
in
the
audience
has
any
questions
on
what
we've
seen
feel
free
to
pop
them
in
the
chat
or
in
slack
while
we
still
have
some
time.
I
see
that
there
there
was
a
question
unrelated
to
what
you
were
implementing,
but
just
a
general
question
about
a
telegraph.
So
maybe
we
can
address
that
it
was
so
the
first
one
we
addressed
already
about
a
demonstrative
versus
a
sidecar.
A
There
was
a
just
a
general
question
about
the
comparison
over
prometheus
operator.
If
you
can
address
that
as
well,.
C
So
compared
to
tell
you
to
prometheus
operator,
I
I
suppose
that
the
main
difference
is
that
telegraph
operator
was
meant
most
meant
to
well.
The
the
primary
goal
for
us
is
to
gather
the
metrics
into
an
influx
db,
and
influx
db
has
well
with
telegraph.
C
A
Yeah,
so,
if
anyone's
in,
like
you
already
using
influx
debate,
obviously
they
would
want
to
check
this
out
and
if
they
have
any
questions
about
whether
they
should
choose
prometheus
or
influx
db.
Where
can
they
learn
about
that.
C
I
believe
that
we
have
a
lot
of
articles
where
we
try
to
compare
this.
I'm
not
really
sure
if
there
is
a
single
one
I
could
point
to,
but
I'm
pretty
sure
that
just
going
to
our
website
and
going
to
our
blog.
C
B
Check
out
more
information
about
the
just
about
telegraph,
and
I
think
that
will
like,
I
think
the
big
benefit
to
using
this
versus
the
prometheus
operator
like
you
can
you
can
interact
and
telegraph
supports
prometheus,
so
you
can
do
that,
but
it's
like,
I
think,
quite
powerful,
like
you
can
that's.
A
C
And
one,
and
one
of
the
things
that
I
think
is
interesting
is
prometheus,
focuses
on
prometheus
metrics
and,
as
you
mentioned,
telegraph
has
a
lot
of
plugins,
so
I
was
able
to
get
metrics
from
redis
by
just
using
the
the
reddit
input
plugin
and
as
as,
as
part
mentioned,
we
have
around
250
plugins.
So
for
a
lot
of
things
that
don't
expose
metrics
as
prometheus
metrics
telegraph
can
also
most
probably
get
those
those
metrics
and
get
the
data
for
you.
A
Got
it
thanks?
I
do
not
see
any
more
questions
coming
up
and
we
are
just
at
the
top
of
the
hour.
So
just
another
reminder:
the
link
is
on
the
screen.
If
anyone
wants
to
go
check
out
telegraph
operator
and
probably
very
soon,
a
new
pull
request
should
pop
up
with
some
of
the
code
that
we've
seen
here.
If
someone
wants
to
take
a
look
at
the
complete
product,
thank
you
wojciech
and
team.
It
was
really
really
unique
stream.
A
A
And
just
a
quick
reminder
that
we
have
kubecon
north
america
coming
up
if
anyone
is
interested,
it's
going
to
be
both
in-person
and
virtual,
so
go
ahead
and
register
for
that.
A
This
has
been
cloud
natively
we're
here.
Every
wednesday
come
meet
us
again
next
wednesday
to
learn
about
the
latest
in
cloud
native,
so
again
influx
team.
Thank
you
very
much
and.