►
From YouTube: Fluent Talks | 002 | First Mile Observability
Description
Please join us for Fluent Talks! Our weekly webinar and office hours, on Fridays at 2PM Central. Streaming live on YouTube.
This week we 1) Define First Mile Observability, 2) Talk About Fluent Linter, Github Actions, 3) Discuss Fluent Bit and Go
A
Perfect,
hey
everyone.
Welcome
to
the
second
episode
of
fluent
talks,
go
ahead
and
share
my
screen
here
we
got
a
pretty
fun
agenda
here:
hey
everyone
welcome
to
the
second
episode
of,
and
so
for
those
who
are
joining
us
for
the
first
time
we're
gonna
be
chatting
about
what
is
coming
in
in
the
fluent
community.
What's
going
on
questions
users
have
just
any
discussions
that
are
useful
in
that
scenario.
A
A
Okay,
perfect
all
right:
let's
talk
a
bit
about
first
metal
observability,
so
you
know
for
us
as
calyptia.
We
really
talk
a
little
bit
about
first
model
observability
all
the
time,
and
you
know
what
what
that
is,
and
I
I
think
it's
important
to
just
kind
of
explain:
hey
what
are
we?
What
are
we
thinking
about.
B
A
A
How
does
it
fit
with
the
observability
journey
that
we
see
in
total,
but
before
we
jump
into
that,
let's
start
with
some
news
updates,
so
we
just
announced
the
fluentd
plugin
for
open
search,
so
that
was
announced.
Yesterday
again,
we
we
announced
a
big,
broader
partnership
with
open
search.
This
is
really
the
first
step.
There
have
some
plugins
already
seeing
a
bunch
of
folks
use
the
rubygem,
which
is
great
about
7000
rubygem
downloads,
which
is
which
is
awesome
so
keep.
A
We
had
a
pr
merge
from
the
community
in
that
too,
which
was
great
I've
gotten
some
user
reports
saying
hey
this
thing
is
working
well
or
hey:
we're
able
to
now
use
open
search
which
we
had
hadn't
been
able
to
before
with
fluentd.
So
all
really
good
positive
feedback.
Keep
it
coming,
also
bring
the
the
negative
feedback,
we're
open
to
you
know,
making
sure
we
keep
building
and
delivering
the
right
stuff
instead
of
just
anything
so
yeah
you
can
go
there
to
the
open
search
blog,
get
a
quick
getting
started.
A
It's
like
a
two
to
three
minute.
Article
read
really
quick
to
just
showcase
some
of
the
use
cases
that
we
typically
see.
How
do
you
get
started?
How
do
you
download
it
two
ways
there?
One
gem
install
and
the
other
is
the
clip
different
d
package,
okay
and
then
some
other
exciting
news
that
that
came
out
was
the
cncf
survey.
So
I
I
don't
know
if
folks
read
that
every
year
I
I
love
to
it's
a
great
way
to
see.
What's
going
on
with
the.
A
A
And
so
within
within
fluentd,
specifically
that
was
about
53
percent
year-over-year.
That's
a
that's
a
pretty
remarkable
stat,
which
is
great
and-
and
I
think
the
other
part
there-
that's
that's
really
interesting
to
see.
Is
you
know
when,
when
you're
looking
at
fluentd,
there's
also
a
lot
of
fluid
bit
out
there
too,
and
we're
seeing
fluid
bit
just
continue
to
have
a
ton
of
momentum
so
having
folks
that
are
using
more
and
more
fluent
d
and
half
and
bit
that
I
think
observability
is,
is
definitely
really
really
key.
So
I.
A
Recommend
checking
out
the
full
annual
survey.
I
think
there's
a
ton
of
goodies
there,
and
especially
you
know
for
folks
who
are
trying
to
figure
out
hey
what
tools
should
we
use,
or
you
know
what
what's
the
cloud-native
way.
This
survey
isn't
going
to
give
you
the
exact
answers,
but
at
least
it
will
showcase.
This
is
what
a
lot
of
folks
are
doing.
A
So
it's
it's
a
nice
way
to
to
do
that,
and
then
part
of
that
was
some
surveys
from
other
folks.
You
know
I
liked
the
new
relic
survey
a
lot
and
one
of
the
the
big
stats
that
I
saw
there
that
was
interesting,
was
observability
becoming
a
critical,
daily
data-driven
practice
so
that
that
be
becoming
really
really
critical
in
in
any
business.
A
I
think
I've
I
heard
a
quote
once
that
I
like
to
share
is:
like
all:
businesses
are
becoming
software
businesses
and
as
software
busines
as
any
company
transitions
to
a
software
business,
you
have
to
make
sure
that
software
works.
It's
reliable
it's
available,
and
how
do
you
do
that
observability
as
the
the
practice
that
can
can
make
sure
that
everything
is
up
and
running
so
another
really
kind
of
cool
cool
survey
there?
A
A
Okay,
so,
let's
jump
into
first
smile,
observability,
and
I
think
the
first
question
that
comes
to
mind.
All
the
time
is
what
is
first
mile
observability,
and
really
I
like
to
think
of
observability
in
in
a
couple
of
different
ways.
Instead
of
it
just
being
a
series
of
data
types
which
I
think
is
what
it
really
has
gotten
to,
is
you
got
logs,
you
got
metrics,
you
got
traces
and
yeah,
that's
great!
I
think
it's
it's
awesome
to
have
these
different
data
types,
but
I
like
to
think
of
observability
as
a
long
journey.
A
This
is
something
where
you
as
an
organization
or
you
as
a
person,
are
trying
to
figure
out.
How
can
I
make
sure
that
my
application
is
performing
the
the
critical
business
functions
that
it's
supposed
to
be
doing,
and
so
for
that
I
like
to
think
of
it
in
this
journey?
You
have
to
do
a
number
of
things
so
say
from
a
developer
side.
You
have
to
understand
what
you
want
to
look
at.
What
do.
A
To
understand
how
do
I
go
out
and
actually
get
this
data?
Where
does
this
data
exist?
What
data
do
I
even
have,
and
that
first
part
is
really
the
collection?
How
do
I
collect
that
data?
How
do
I
retrieve
it?
How
do
I
bring
it
into
a
place
where
I
can
then
get
it
to
some,
maybe
more
back
in
analytical
tools,
so
I
have
these.
A
Is
my
are
my
services
running?
Are
they
flowing
properly?
Are
they
performing
exactly
what
they're
supposed
to
and
as
you
try
to
answer
these
questions,
we
then
have
to
go
collect
that
data.
Now
after
you
collect
it,
there's
a
other
series
of
pieces
there
one
is:
can
I
store
that
data?
Can
I
retrieve
that
data
is?
Is
there
a
way
to
enrich
that
data?
Make
make
answering
these
questions
easier?
Do
I
have
to
grab
certain
information
from
one
side
and
merge
it
with
information
that
might
exist
somewhere
else?
A
good
example
of
that
is
hey.
A
If
I'm
running
in
kubernetes-
and
I
want
to
see
if
an
application
in
kubernetes
is
running
properly
or
is
performing
properly.
I
want
to
know
which
application
I
might
have,
because
in
today's
modern
infrastructure
I
have
50
versions
of
that
application
running
in
kubernetes.
So,
instead
of
just
saying
hey,
this
is
the
application.
Here's
what
it's
outputting!
We.
A
A
So
now
your
alert
gives
you
faster
context,
so
you
can
debug
and
understand
what
what
happened,
where
it
happened,
how
it
happened
and
that
first
part
of
this
journey
is
really
where
first
mile
is
and
that's
where
you're
analyzing
the
data
you're
monitoring
it
it's
where
it's
created
and
collected
and
what
we
find
is
like,
as
folks
are
always
doing
this
observability
journey,
they
really
focus
on
the
backend
piece.
Let
me
collect
the
data,
send
it
somewhere
centralized
and
do
all
my
immediate
insights,
and
I
think
that's
great-
that
works
really
well.
A
A
Two
is
you're
also
paying
to
ship
all
that
data
out,
and
that
might
not
mean
so
much
in
say
a
private
data
center,
but
as
we
move
to
more
cloud
environments,
kind
of
get
hit
with
these
egress
charges-
and
I
don't
know
if
folks
have
looked
at
the
the
most
recent
egress
charges
from
cloud
providers,
but
they
can
be,
they
can
be
pretty
substantial.
It's
like
nine
cents,
a
gig
if
you're
shipping
over
public
internet.
A
So
instead
of
just
shipping
all
this
data,
which
might
not
be
useful.
Why
not
just
look
at
it
ahead
of
time
and
get
rid
of
it?
You
know
maybe
archive
it
into
something:
that's
not
going
to
cost
you
nine
cents
per
gig,
and-
and
this
is
where
the
ability
to
perform
first
mile
observability
is
really
useful,
and
I
think
you
know
that
we
we've
tried
to
bring
up
this
term
multiple
times,
but
there's
also.
A
A
Log
stash,
these
are
all
ways
that
you
can
collect
that
data
today.
The
unfortunate
part,
though,
is
those
are
vendor
locked
right.
You
know
you,
they
are
really
only
catered.
You
can't
take
a
data
dog
agent
and
route
it
to
to
elasticsearch
or
splunk,
and
likewise
you
can't
take.
You
know,
beats
and
then
send
that
data
over
to
splunk.
B
A
So
you're
kind
of
stuck
with
that
full
and
then
tool
chain-
and
I
think
the
the
growing
thing
that
we
see
as
well
is
the
back
ends
continually
change.
You
might
have
splunk,
you
might
have
s3,
you
might
have
kafka
and
there's
a
need
to
ship
this.
This
data
that's
collected
once
into
many
locations,
and
so
the
the
first
mile
and
owning
the
first
mile
really
allows
you
to
do
that
at
a
much
higher
skill,
be
vendor
agnostic
as
more
and
more
back-ends
arrive
right.
A
B
A
And
so
yeah,
I
think
this
is
this
is
how
we
think
about
first
model
observability
and
really
on
top
of
that,
just
trying
to
prove
out
like
hey
this.
This
is
something
that
people
are
already
doing
right.
We
just
reached
a
billion
fluent
bit
deployments
over
over
docker
hub,
so
that
was
very,
very
exciting
and
we've
reached
about
30
000
github
stars
across
the
entire
fluent
ecosystem
and
we've
seen
folks
do
about.
A
You
also
have
more
flexibility
with
being
able
to
get
to
get
to
those
higher
skills.
So
what
do
I
mean
by
all
that
is,
you
know,
as
things
keep
getting
more
distributed
as
you
get
more
cloud
adoption
as
we
get
more
commoditized
in
storage,
you
want
to
have
something:
that's
super
flexible,
that's
open
source!
You
don't
have
to
worry
about
licensing,
you
can
ship
it
with
their
product,
and
these
are
other
places
where
first
mile
observability
comes
into
play.
A
As
we
mentioned,
we
use
our
open
source.
We
also
have
our
enterprise
piece
here
too,
which
is
clip
to
enterprise
for
flint
bit
and
really
what
this
product
does
is
make
it
really
simple
to
operate
this
at
scale,
so
you're
deploying
in
kubernetes,
you
might
be
using
operators,
you
might
be
using
helm,
charts
fantastic.
A
But
how
do
you
get
some
of
the
niceties
I
would
say
of
kubernetes
without
having
to
fully
understand
every
single
piece,
so,
instead
of
having
to
understand
how
a
deployment
works
and
having
to
mount
a
service
to
it
and
get
the
load
balancer
situated,
which
is
a
great
way
to
do
all
this?
We
can
just
kind
of
automate
all
that
for
you,
so
you
can
kind
of
take
your
single
operations
and
and
really
scale
that,
so
you
can
provide
logging
as
a
service
to
multiple
teams
or
or
whatnot
so
yeah.
A
You
want
to
be
able
to
build
these
pipelines.
You
want
to
be
able
to
test
them.
You
want
to
be
able
to
figure
all
of
these
things
out.
I
actually
have
goggle
here
who
heads
our
developer
experience
clipped
yet
to
kind
of
talk
me
through
some
of
the
dev
tools
and
specifically
the
fluent
linter.
So
let
me
hand
it
off
to
you:
gago
talk
a
little
bit
about.
B
What
is
the
backpack
that
you
have
to
carry
on
in
order
to
get
to
where
you're
going
and
devtools
becomes
just
a
cornerstone
of
this
practice
like?
How
do
we
simplify?
So
you
don't
have
to
be
an
expert
on
every
detail
of
everything
that
you
have
to
do
to
accomplish
the
processing
of
data
and
and
at
such
higher
volumes.
B
So
our
we
started
looking
at.
How
can
we
still
play
something
that
will
be
useful
for
everyone,
and
the
first
thing
that
we
thought
about
and
it
was
outlining,
was
flow
and
bit
configurations
could
be.
We
have
80
more
than
80
plugins
you
as
an
individual
learning
and
knowing
all
the
nitty
gritty
to
get
to
where
you're
going
on
the
plugins,
and
it's
only
going
to
keep
it
growing.
It's
going
to
be
really
unattainable.
It's
going
to
be
really
hard,
so
we
thought
all
right.
B
Why
don't
we
build
a
tool
that
helps
everybody?
Do
that,
so
we
start
playing
with
it
a
couple
weeks
ago,
and
we
have
something
that
we
want
to
show
everyone
that
might
catch
the
stream
and
just
you
know,
try
to
socialize
this
idea
of
these
tools
that
that
we
deserve
them.
We
it's
a
great
piece
of
tool.
We
deserve
to
be
accompanied
by
tooling
around
it
that
allow
us
to
use
it
better.
So
let
me
see
if
I
can
share
a
little
bit
of
it
of
this.
Hopefully,
you
can
see
my
screen.
A
B
All
right,
so
you
were.
If
anyone
was
guessing
this,
you
can
see
fluently
interaction
by
kalitia.
This
is
pretty
much
what
it
reads
and
it's
in
the
market
already
we
are
gonna,
we're
gonna
release
it
in
a
couple
of
weeks,
but
for
now
we
would
like
to
just
show
you
well
show
you.
What
is
the
experience
right
now?
Sorry,
I'm
getting
some
weird
signs
there.
B
B
B
Yeah
I
mean
we
worked
so
hard
on
it.
So,
like
I
was
saying
it's
a
it's
a
link
for
it,
it's
an
action,
it's
in
github
and
the
first
thing
when
people
talk
to
me
at
the
things
it's
like.
Why
do
I
care
well
again
a
new
thing?
So
hopefully
we
can
test
that
out
and
we
can
show
you
why
this
is
interesting
and
we're
really
excited
to
use
it,
because
we
we
we
use
it
internally.
B
So
what
is
a
github
action
just
to
begin
with
right?
So,
as
many
of
you
know,
github
started
developing
this
new
ecosystem
around
github,
like
core
review
and
pull
requests,
and
how,
where,
where
you
do
your
iterations
when
you
develop
and
review
and
they
create
an
entire
ecosystem
about
actions
and
actions,
are
units
that
you
can
run
against
your
code
and
validate
them.
The
same
thing
that
you
will
do
in
the
computer
right,
so
you
will
link
your
code.
You
will
run
tests
on
your
code.
B
You
will
do
some
other
exotic
things
like
having
preview
links
to
deploy
that
in
a
private
network
and
see
what
you
have
done
and
if
it
works
or
not,
all
these
elements
are
really
useful.
Now
that
are
fully
integrated
in
your
code
and
we
thought
that
the
best
way
of
getting
this
in
everybody's
hands
is
integrating
the
linting
capability
of
configuration
for
fluid
within
the
github
ecosystem
in
intercase,
right
away
your
repositories
to
just
a
couple
of
clicks
and
you're
there.
B
So
why
do
you
need
this?
This
is
always
like.
Why
do
I
need
this
thing?
The
important
thing
is
like
we
said,
validations
are
really
hard
on
a
configuration
that
has
more
than
80
plugins.
You
have
outputs
inputs
filters
and
who,
who
knows
what
is
in
store
for
us
in
the
future?
With
fluid
it's
green,
it's
growing
like
crazy,
so
we
want
to
be
ahead
of
the
of
of
the
way
here
and
say:
how
do
we
provide
something
that
is
going
to
simplify
your
configuration?
B
We
have
a
couple
use
cases
that
if
you're
someone
that
works
with
swimbait,
you
are
gonna,
remember
and
it's
gonna
hurt
somewhere
because
you
had
it
before,
and
these
are
kind
of
the
things
that
you
are
gonna
be
able
to
enjoy
when
you
use
the
linter
so
and
you-
and
I
tell
me
you-
you
are
a
avid
user
of
fluent
bit.
So
probably
this
have
been
in
you
in
the
past.
So
let's
see,
let's
see
which
one
strikes
gold
here.
So
what
about
using
the
wrong
properties
in
a
in
a
section?
B
So
something
simple:
let's,
let's
see
this
simple
nugget
here
you
have
an
input
and
you
give
it
a
name
and
right
away.
You
say
this
is
not
a
real
value,
we're
being
obvious
here,
so
everybody
can
tell,
but
this
is
literally
a
property
that,
of
course
it
will
make
everything
blow
into
pieces
right
yeah.
So
this
is
so
just
just
to
put
everybody
on
the
same
page.
This
is
what
fluency
will
do
for
you.
B
B
This
is
not
real
if
you
have
a
bigger
configuration,
if
this
were
instead
of
the
one
that
we
saw
here,
something
that
has
300
lines
of
configurations
because
you
are,
you
are
doing
real
stuff
with
it
you're
going
to
find
out
that
this
is
really
hard
to
parse
visually
and
you're,
going
to
have
to
call
that
that
person.
That
knows
every
possible
thing
about
the
logs
influence
to
just
even
get
there.
So
this
is
not
ideal
right.
So
what
about
this?
What?
If
what
happens?
B
A
What
about
I
was
going
to
add,
you
know
like
I,
I
think,
probably
I've
spent
hours
you
just
like
try
to
get
a
docker
container
running
with
flint
bit,
and
you
know
it's.
It
always
feels
like
it's
going
to
take
five
minutes
to
go
check
this,
like.
Let
me
go
check
config.
Let
me
run
the
docker
container,
but
for
some
reason
it's
almost
like
I
forgot
how
to
do
the
mountain
file.
Oh,
I
forgot
to
mount
the
file.
Why
is
this
working?
A
Why
is
this
being
perfect
and
just
like
getting
the
environment
set
up
to
even
just
do
this
test?
Is
that
is
so
tedious
and
I
think,
if
I'm
having
a
ton
of
trouble
like
every
time
I
want
to
go.
Do
this.
I'm
sure
folks
who
are
using
this
in
production
are
probably
running
into
this
way
way
more
so
yeah.
That's.
B
B
B
If
you
have
done
any
sort
of
fluent
bit
and
you
wanna
you're
gonna,
you
wanna
get
cued
with
your
configuration
because
you
like
things
that
are
organized
you
end
up
with
some
levels
of
nesting
just
to
to
have
your
outputs
in
some
place,
and
you
have
your
you
know,
segmentation
for
maintainability
purposes.
So
you
end
up
with
something
you
end
up
with
something
really
nested
and
you
might
have
something
like
include
nested,
include
one
and
include
two
two
files,
and
this
is,
as
I
said,
really
naive.
B
B
We
just
have
one
configuration
and
next
to
it,
we
have
an
sd
file
that
we're,
including
that
is
included
in
the
third
one,
but
fluent
bit
when
you
include
two
and
the
same
configuration
the
same
file
twice
like
we
are
doing
these
two
files,
including
clue
one
include
two
are
including
both
the
valid.conf
fluentbit
is
gonna
complain
it
doesn't
let
you
do
that
for
singular
dependencies
and
other
another
issues.
So
this
is
what
fluent
will
tell
you,
it
will
say:
hey
I'm
trying
to
open
the
valid
file
and,
and
then
I
cannot
open
it.
B
That
is
it.
That
is,
that
is
the
actual
issue
that
you're
having
that
doesn't
tell
you
much
does
it.
It
is
a
bit
like.
I
don't
really
know.
What's
going
on
so
what
about
this?
What
about
a
message
that
says
you
are
trying
to
include
this
file
and
you
can
see
a
path,
but
that's
the
path
of
the
action
itself
in
github
and
what
the
rest
of
the
message
says
fluent
does
not
allow
you
to
include
the
same
file
twice
and,
as
you
can
see
in
the
snippet
that
I've
taken.
B
A
B
It's
also,
it's
also
a
limitation
sometimes
to
grow
in
a
controlled
way,
because
the
include
is
really
it's
a
mechanism
to
to
grow
your
configuration
without
having
a
generous
file.
The
problem
is,
if
you
start
doing
too
many
includes
you
need
more
intelligence
in
your
tooling
to
be
able
to
manage
it.
So
you
know
we
have
to
solve
one
to
get
to
the
other,
and
this
is
kind
of
one
of
our
point
of
views
with
the
tooling,
and
we
have
solved
many
things
in
the
includes
that
gives
you
a
lot
of
information.
B
When
you
cannot
find
a
file,
it
will
tell
you
so
there's.
No,
I
included
something
relatively,
and
I
don't
know
where
it
is.
We
have
fixed
all
that
in
the
in
the
link
right
now
and
lastly,
one
that
is
a
nugget
that
we
found
it
and
it
was
like
we
should.
We
have
to
share
it
with
other
with
other
people
just
to
just
it's
an
oddity.
B
If
you
run
this
particular
one
that
is,
it's
like
the
developer
here,
got
confused
and
forgot
how
what
is
an
assign
and
and
how
to
use
it,
because
it's
using
it,
it
is
assigning
it
like
you.
It
were
exposing
it
like
you
see
in
the
dummy
underneath
this
will.
If
you
see
what
fluent
b
will
do,
this
is
the
output
of
limbic
and
you
can
see
the
first.
The
very
first
line
of
the
log
says:
variable
dollar
sign,
curly
braces
a
is
used
but
not
set,
but
wait.
We
we
had
the
dummy
there.
B
That
is
exposing
it
there's.
No
way
you
can
access
the
variable,
it
will
allow
you,
it
will
allow
you
to
declare
it,
but
there's
no
way
for
you
to
use
it,
but
there's
no
way
for
you
to
reach
it
this.
It
is
not
a
bug
because
it's
syntactically
allowed
by
the
configuration
it's
just
that
you
cannot
reach
it.
So
we
decided
that
this
is
a
food
gun
like
they
say,
and
we
have
to
prevent
things
to
happen.
So
we
just
decided
that
this
in
the
linters
will
be
like
a
parsner.
B
It
should
not
allow
you
to
even
try
this
because
it's
gonna,
it's
gonna,
make
you
really
sad
in
production,
so
we
did
that
we
put
the
inline
exactly
next
to
it
and
we
say
hey,
you
have
to
find
interactive.
That
cannot
be
parsed
and
we
show
you
the
directive.
That
is
there
and
we
tell
you.
Where
are
the
support
directives
and
you
can
go
to
google,
the
directors
and
you
can
see
how
you
do
it
correctly
in
the
future.
We
can
expand
this
message
to
have
a
more
meet
like
here's.
B
B
This
is
just
a
little
glimpse
of
of
how
how
to
use
it,
but
we
wanted
to
move
to
if
you
saw
that
this
is
useful,
we
have
much
more
in
store
for
you,
but
let's
see
how
you
use
it
because
the
important
is
like
these
are
the
things
that
solves
now
you
care
now
you
need
it.
So
how
do
I
use
it?
And
here
you
can
see
homer
how
you
might
feel
the
same
like
relation
with
this
is
so
confusing.
B
So,
let's
see,
let's
see
how
and
I'm
gonna
go
fast
through
this,
their
documentation.
We
have
the
condition.
We
will
share
this
widely
at
the
end
of
the
podcast,
if
you
wanna,
just
you
know
at
the
end
of
the
stream,
if
you
wanna
just
check
on
this
or
in
a
couple
weeks
when
we
are
in
a
stable
in
a
more
stable
version,
we
are
doing
really
really
fast
right
now
with
the
linter.
B
But
let
me
show
you
a
bit
of
how
you
do
it
if
you're
familiar
with
marketplace
and
actions
in
github.
This
is
something
that
you
have
done
before,
but
if
not,
it
is
just
going
to
the
actual
marketplace
action,
and
you
will
see
you
will
see
this.
You
are
going
to
be
able
to
copy
these
two
lines
are
the
ones
that
enable
you
to
create
a
workflow
for
the
action
to
be
used
in
your
repo.
B
So
once
that
you
do
that,
something
that
we
require
is
calipia
gives
a
lot
of
intelligence
to
the
linter.
So
it's
actually
running
a
lot
of
fluid
in
the
cloud
to
allow
you
to
get
the
most
up-to-date
and
refined
issues
that
you
can
find
in
your
configuration
directly
into
your
into
your
pull
request,
and
for
that
you
have
to
just
visit
caliptia.
B
You
can
log
in
with
github,
and
you
can
generate
an
api
key
copy
because
you
need
it
and
you
can
store
that
as
a
secret
in
your
repository
and
once
that
you
are
there,
you
just
have
to
create
the
workflow
like
in
github.
This
is
full
of
documentation
everywhere.
So
it's
easy
to
to
to
walk
you
through
that.
But
the
workflow
at
the
end
looks
like
this.
This
is
the
entire.
The
entirety
is
only
executed
on
pull
request.
B
You
can
do
it
on
push
or
whatever
you
want
and
as
you
can
see,
it
is
giving
you
you
have
to
put
the
calypsia
api
that
if
you
save
it
as
a
secret
in
your
repo,
you
will
have
it
there
and
you
have
to
point
out
to
the
configuration
that
you
are
having.
This
is
a
glob,
so
you
can
point
out
to
many
many
entries
of
configuration
or
just
by
commas,
it's
a
globe,
so
you
can
just
do
what
you
will
do
normally
in
a
globe
and
once
you
have
that
you
have
it.
A
So
awesome
yeah-
this
is
great,
so
folks
can
go,
get
get
the
github
action
today
in
the
marketplace.
If
you
want
to
try
it
out
note
the
alpha
alpha
tag
next
to
it,
it's
continually
being
a
ball
but
yeah
it
should
it
should
help,
and
especially
you
know,
we
see
this
trend
where
folks
are
going
more
and
more
into
things
like
it,
ops
and-
and
everything
is
tracked,
so
you
can
understand
hey
who
made
this
change?
A
Why
did
we
make
this
change
and
gets
a
great
place
to
do
that
and
then
have
that?
Go
and
push
this
type
of
configuration
into
down
to
your
pipelines
into
say
your
helm,
charts
or
whatnot?
So
these
things
can
really
really
help
speed
up
that
process
right,
so
you
can
say
hey.
Why
did
you
push
this
live
if
it
was
failing
the
linter
versus
you
push
it
live,
you
wait.
A
A
A
Well,
folks,
yeah!
That's
a
majority
of
what
we
had
to
cover
today,
so
I
think
we
can.
We
can
depart
a
little
early
on
on
friday
afternoon
we
talked
a
little
bit
about
first
model
observability,
what
it
is
some
of
the
github
actions
dev
tools
next
week.
I
think
we
have.
We
have
a
couple
of
fun
topics
already
lined
up
with
kafka
and
open
telemetry,
so
we'll
run
into
those,
but
otherwise
you
know
folks
have
a
great
great
friday.
You
can
reach
us
on
slack.