►
From YouTube: Knative Community Meetup # 6
Description
This virtual event is designed for end users, a space for our community to meet, get to know each other, and learn about uses and applications of Knative.
In this meeting, we will hear working group updates. There will be 1 demo: "Building Custom Event Sources for Knative” - Murugappan Chetty, Principal Engineer at Optum
A
Great,
so
we
are
off
welcome
everybody
to
the
creative
meetup.
Today
we
have
a
few
working
group
updates.
We
have
some
project
updates
and
we
will
also
have
a
demo,
so
I
think
we're
going
to
go
ahead
and
start
with
the
updates.
I
wanted
to
give
you
all
a
reminder
that
yesterday
we
launched
the
canadian
steering
committee
election
process,
and
this
is
the
first
election
process
for
this
group,
so
yay
success.
A
A
You
have
more
information
on
github
and
I
think
I
can,
I
will
add,
the
the
link
to
the
agenda
in
second
election
process.
Okay,
someone
told
me
that
it
was
the
first
one.
I
thought
it
was
the
second
one
but
yeah
that
was
right.
It's
the
first
one
for
steering
right,
okay,
cool
great,
so
I
think
we
have
a
an
update
from
eventing
working
group.
A
grant.
You
know
an
ahmed.
B
Sure,
thanks
maria
I
can
start
so.
The
first
thing
we
want
to
mention
here
for
the
eventing
working
group
is
that
google
launched
google
cloud
run
for
anthoc
events,
which
is
quite
a
mouthful,
but
basically
it
means
that
google
has
a
product
now
that
will
install
k
native
events
for
you
and
it
runs
the
gcp
broker
and
other
gcp
specific
sources
that
are
all
built
in
the
google
slash
k-native-gcp
repo,
but
otherwise
it's
entirely
k-native
eventing,
it's
in
public
preview
right
now.
B
C
Yes
thanks.
Why
so?
I
did
also
a
link,
so
I
somewhere
some
kind
of
a
small
announcement
here
is
like
we
for
ibm
code.
Engine
has
been
launched
as
a
better
product
recently,
and
there
is
a
little
bit
of
eventing
in
there
and
I
added
a
link
in
here
in
the
in
the
document.
So
we
support
currently
two
sources
and
one
is
the
the
pink
source
and
another
one
is
a
cos
source
that
consume
event
coming
from
the
ibm
object,
stop.
C
Right,
so
that's
for
the
code
engine.
Maybe
we
can
move
on
on
the
release.
So,
as
you
know,
the
eventing
release
0.18
came
out
like
a
month
ago,
so
I
call
this
like
a
stability
release.
There's
not
much
many
features
in
it.
It's
we've
been
fixing
lots
of
work.
A
lot
of
work
has
been
done
on
fixing
like
a
flicky
test
and
thanks
villa
and
others,
and
so
really
the
focus
being
like
stability
and
and
getting
to
inventing
d1
version.
C
Another
thing
we've
been
doing
is
we
split
displayed
eventing
contrib,
so
into
multiple
sub
repository
or
multiple
repo.
I
moved
the
repo
over
to
a
connective
sandbox,
and
that
was
we've
done
this
for,
like
mostly
for
mentability
issue
right,
it
was
start
to
be
vending
country
started
to
be
like
not
manageable,
and
one
thing
to
I
want
to
say
is
this
like
this
misconception
that
kennedy's
sandbox
is
for
experimental
project?
Because
that's
that's
not
the
case
in
there.
C
C
E
Yes,
thanks,
we
have
been
doing
some
retrospecting
inside
event,
working
group
and
one
of
the
directions
that
we
want
to
focus
on
is
collecting
feedback
from
the
community,
because
I've
been
doing
the
work
so
far
until
reaching
v1,
based
on
some
initial
feedback
that
we
collected,
whether
from
users
from
vendors
or
from
the
open
source
community
and
right
now
we
want
to
revisit
whatever
we
collected
before
so
we're
going
to
work
on
the
eventing
use
cases.
There
is
a
link
in
the
agenda
to
the
old
use
case
document.
E
It's
even
mark
2019,
because
I
was
the
main
use
case
document.
At
that
time
we
would
like
to
have
a
shout
out
to
any
product
involved
people
or
people
in
the
open
source
community
who
are
interested
in
product
aspects
of
things
to
give
their
feedback
on
the
eventing
use
cases
they
want
out
of
eventing.
E
The
other
document
is
about
the
roadmap
for
eventing
and
all
the
eventing
related
working
groups.
There
is
an
initial
dock
that
we
started.
We
didn't
finish
that
yet,
but
also
feedback
is
welcomed
and
one
of
the
apis
that
are
moving
towards
v1
right
now
is
the
sources
api
and
we
wanted
to
collect
the
feedback
from
users
who
are
using
the
sources
about
the
api
shape
that
you
have
used
so
far.
E
A
F
D
Sure,
although
I
went
near
my
prop,
I
usually
have
a
little
raspberry
pi
I
can
hold
up
but
yeah,
so
co
now
supports
multi-arch
and
the
distro-less
bass
images
that
we
based
most
of
our
stuff
on
it's
fort
multiarch.
So
I
believe
that
these
days
our
nightly
build
should
be
building
there.
You
go
yeah
bilay's
got
one
our
nightly
build
should
be
building
for
mb64,
obviously
arm64,
as
well
as
power
and
z.
D
Unfortunately,
envoy
only
ships,
official
images
for
now
md64
and
arm64,
but
for
things
like
event,
sources
and
stuff
that
you
know
are,
can
be
written
relatively
standalone.
You
know
they
can
run
on
any
of
those
maps,
so
I've
only
tried
it
on
arm.
So
I
I
would
love
feedback
from
folks
about
power
and
z,
but
yeah
those
should
be
starting
to
appear
in
nightly
builds
and
if
you
don't
see
them,
let
me
know.
F
A
Great,
thank
you
so
much
for
these
updates
and
if
you
were
wondering
about
what
am
I
talking
about
with
these
links
because
you
you
arrived
a
little
bit
later,
I
just
shared
the
agenda
and
you
can
find
all
the
links
to
follow
up
with
this.
With
this
update
as
well
great,
so
I
think
without
any
further
ado,
I
am
going
to
give
the
floor
to
murugapan,
who
is
going
to
present
to
them
all.
G
G
G
G
The
only
additional
thing
that
we
have
is
a
set
of
apis
that
we
have,
on
top
of
k,
native
and
kubernetes,
just
to
make
the
barrier
of
entry
really
simple
for
the
new
users
who
are
not
familiar
with
k,
native
and
kubernetes,
and
we
find
a
lot
of
users
take
advantage
of
that.
Okay
and
we
are
currently
in
production,
running
about
like
more
than
500
services.
G
Now
most
of
the
use
cases
that
I
could
see
are
atomic
apis.
Some
automation
functions,
etl,
processing
and
popular
sources.
Since
I'm
going
to
talk
about
source
today,
a
kafka
source
with
kafka,
binding
and
followed
by
ping
source
and
sync
bindings.
We
also
have
some
custom
resources
and
some
domain
specific
resources
which
I
cannot
share,
but
I'm
going
to
share
some
of
the
custom
resources
that
we
built
along
with
helping
run
this
cluster.
I
also
do
some
contribution
to
canadian
and
regularly
attend
the
client
working
group
meeting
and
hackie
hour
on
friday.
G
G
The
only
change
that
I
had
to
do
was
like,
as
matt
mentioned,
change
the
on-white
to
116
from
115
one
okay,
so
that
is
the
deck
that
I
have
so
whatever
I'm
going
to
present
today,
I
wrote
it
as
a
blog,
so
it's
kind
of
easy
to
share.
Then
I
did
so,
let's
start
so
what
is
the
k
native
eventing
source?
According
to
the
native
documentation?
G
That
could
that
you
could
use
to
find
out
that
reciprocals
and-
and
you
can
also
here-
you
can
see
the
list
of
k
native
sources
that
have
been
already
supported
by
k
native
here.
That's
in
the
there's,
a
creative
dev
documentation,
so
building
a
source
boils
down
to
building
the
link
which
is
called
adapter
within
k
native
and
how
you
build
the
adapter
and
how
you
ship
it,
how
you
distribute
it
with
your
teams.
So
that
is
what
is
like.
G
Building
the
even
source
and
the
main
job
of
the
adapter
is
to
reach
out
to
the
producer,
get
the
events
construct
it
as
a
cloud
event
and
send
it
to
a
sink
white
cloud
events.
There
are
like
a
lot
of
advantages,
but
the
main
advantage
that
we
could
see
is
like
the
consumers
that
we
built
are
interoperable
and
can
be
used.
I
would,
while
showing
the
demo
I'll,
show
an
example
of
that
and
so
for
building
this
even
sources.
Currently
kennedy
provides
three
options.
G
One
is
a
controller
approach.
Second,
is
a
sync
binding
approach
and
third
is
a
container
source
approach.
Controller
approach
is
the
approach
mostly
used
by
all
the
in-house
k
native
eventing
sources,
and
it
it
is
a
it
is
a
kubernetes
controller,
and
these
are
the
components
that
you'll
be
building
on
that
an
adapter,
a
controller
and
a
web
book.
G
Adapter
is
the
one
that's
going
to
produce.
The
events
and
controller
is
one
that's
going
to
operate.
The
adapter
web
book
is
optional.
Suppose
if
you
want
to
do
some
validation
or
some
defaulting,
you
would
need
the
web
book.
Otherwise,
so
building
a
controller
can
be
a
cumbersome
process,
but
fortunately
there
is
a
template
project
created
by
k-nature
called
the
k-native
sandbox
and
there's
a
k-net
sorry
here,
native
sample
source
in
the
canada
sandbox.
You
can
just
take
this
template
project
and
get
started
from
here.
G
G
What
it
does
is
like
graphql,
as
we
know,
graphql
server,
as
you
know,
supports
three
operations
querying
mutation
and
subscription
using
the
subscription
option
you
can
subscribe
to
a
graphql
server
endpoint
and
whenever
there's
a
change
in
that
particular
entity,
the
server
sends
out
that
information
to
the
whoever
subscribes
to
it.
So
the
source
will
subscribe
to
the
graphql
server
and
get
the
changes,
and
whenever
there's
a
change,
it
will
push
it
down
to
the
sync
using
that
information
syncs
can
do
some
action.
G
I'll
also
show
an
example
of
like
how
this
can
be
used
so
before
that,
how
I
built
this
controller
using
the
sample
source
controller,
just
give
some
steps.
I
cannot
go
into
the
details,
of
course,
but
first
step
always
in
the
api
section.
After
defining
the
version
go
and
define
the
types
that
you
want
and
then,
along
with
that,
there
are
some
information
about
the
license
elements
and
all
these
things
you
can
create.
So
once
you're
done
with
that,
you
just
need
to
change.
G
You
know
change
the
boilerplate,
that's
already
given
next
step
is
to
generate
the
code,
so
this
part
generates
most
of
the
code.
For
you,
there
is
a
kubernetes
code
gen
and
a
k
native
code
gen,
which
is
going
to
be
used
by
the
reconcilers
and
and
the
client.
This
is
the
client
package
which
is
going
to
have
all
these
information
that
was
generated
by
this
code.
G
Okay,
so
once
the
code
gen
is
completed,
the
next
thing
is
to
write
the
reconcilers,
and
for
this
also
there's
a
controller,
you
just
need
to
confirm
to
the
k,
natives
controller
interface.
So
once
you
confirm
to
the
k,
natives
controller
interface
and
write
the
controller
and
the
reconciler
logic,
the
advantage
that
you
get
is
you
can
make
use
of
the
shared
name.
So
this
is
the
entry
point,
and
this
is
all
the
code
that
you
have.
Everything
is
like
injected
with
this
shared
mine
and
there's
a
lot
of
work
going
on
there.
G
It's
like
a
gold
mine.
There
is
a
lot
of
libraries
there
suppose
we
are
building
something
for
k.
Native
and
kubernetes
always
check
out
this
libraries
in
the
canadian
package.
There
are
a
lot
of
supporting
functions
there.
Okay,
so
that's
about
the
controller
and
in
the
controller
you
can
see
here,
all
you're
doing
is
like
you
can
you're,
reconciling
and
then
building
a
receiver,
adapter
and
the
receiver.
Adapter
is
nothing
but
just
a
docker
image.
So
technically
it
can
be
written
in
any
language.
G
You
just
need
the
controller
just
needs
a
darker
image,
but
if
you
have
a
I
mean,
if
you
write
in
go,
you
can
take
advantage
of
the
libraries
that
k
native
gives.
Okay.
So
that's
about
the
controller.
Our
next
step
that
we
do
is
to
build
that
up
similar
to
the
kna2
controller
interface,
there's
an
adapter
interface
that
they
have,
and
once
you
confirm
to
the
adapter
interface,
all
you
have
to
do
is
have
the
start
method
and
then
write
a
logic
from
here.
G
You
can
make
use
of
the
adapter
main,
so
this
adapter
main
just
like
the
shared
main,
a
lot
of
code
being
done
for
you.
You
just
need
to
follow
that
interface
and
then
supply
that
adapted
to
the
adapter
main.
So
this
builds
the
controller
and
adapter.
I
have
not
built
the
web
book
in
this
process.
I
didn't
need
to
so
once
you
are
done
with
these
things.
The
next
thing
is
the
easier
thing
like
you
go
inside
the
config
folder.
There's
a
list
of
your
fails.
G
G
So
to
do
this,
I
created
a
graphql
source,
so
this
graphql
sources
will
subscribe
on
two
queries,
so
one
is
on
the
menu
items
and
second
one
is
on
the
info
items,
and
this
is
the
graphical
endpoint
it's
going
to
listen
to
and
then,
whenever
there's
a
info,
whenever
there's
a
event
that
it
needs
to
send,
it
will
be
sending
to
this
knitting
service.
That's
our
sync!
Okay,
so
I
have
all
these
things
deployed
and
I
also
have
sm
but
min
scale
to
one
so
that
you
want
to
save
time.
G
G
G
G
G
And
in
most
in
some
cases
you
wouldn't
need
the
controller
approach.
In
some
cases,
you
would
want
the
k
native
service
itself
to
send
out
an
event
or
kubernetes
job
itself
to
send
an
event.
In
those
cases
you
don't
need
a
controller.
So
that's
when
you
get
the
sync
binding
you
can
make
use
of
this
inventory.
Sync
binding
is
a
custom
resource
again
provided
by
kennedy.
Everything
it's
managed
by
the
knitting
event
controllers
and
all
it
does
is
like.
G
Whenever
you
create
a
sync
binding
custom
resource,
it
injects
two
environmental
variables
into
the
desired
part.
Speckable
k,
kubernetes
resource
a
part,
speckable
kubernetes
resource
is
one
which
has
pod
spec
in
its
definition
like
a
kubernetes
job
or
a
deployment
or
k
native
service,
and
the
injection
is
based
on
the
labels
and
its
name,
space
scope.
G
If
I'm
not
okay
and
you
can
make
use
of
the
k
native
libraries
to
to
fetch
the
casing
information
and
create
a
cloud
events
client.
So,
from
from
a
developer
standpoint,
all
you
need
to
do
is
like
build
your
events
in
cloud,
even
format,
and
then
you
can
make
use
of
the
client
that
is
injected
by
native
and
then
send
the
information
out.
So
using
this
approach
build
a
source
called
as
s3
source.
G
Okay,
what
this
the
goal
of
this
source
is
to
reach
out
to
s3
object,
store
any
s3
compatible
store
like
mineo
or
aws
three.
It
can
reach
out
to
that
by
any
bucket
and
get
the
file
that
was
specified
and
it
will
send
each
line
or
multiple
lines
as
a
cloud
event
through
the
sync
okay.
This
will
be
helpful
for
enterprises,
which
process
a
lot
of
flat
files
and
in
a
flat
file
each
line.
G
Each
position
and
a
line
has
a
meaning,
and
so
all
they
need
is
to
process
single
lines.
So
this
source
would
take
the
job
of
like
going
to
the
bucket
and
fetching
the
file
and
then
taking
the
data
and
sending
it
to
the
sync
okay.
So
here
the
main
component
is
the
kubernetes
job
and
the
sink
is
getting
injected
into
the
kubernetes
job.
And
that's
what
is
like
sending
the
data
out.
G
We
chose
the
kubernetes
job
because
these
files
can
be
really
big
like
it
can
be
like
5,
gb,
5gb
10gb,
or
something
like
that.
So
we
don't
want
the
canadian
servers
to
be
running
that
long,
but
at
the
same
time
the
kubernetes
job
is
like
a
one
time.
You
cannot
reuse
it
right.
So
that's
where
we
we
had
a
container
image
that
could
be
run
as
k
native
service
will
create
these
jobs
on
the
fly
so
based
on
the
bucket
information
and
the
file
information,
it
will
create
a
job.
G
It
will
have
some
static
information.
Also,
like
the
connection
information
to
the
s3
bucket
and
using
this
information,
the
knight
of
service
creates
a
kubernetes
job
and
the
kubernetes
jobs
will
send
the
information
to
the
scene.
So
the
k-nato
service
has
two
end
points.
One
is
to
create
the
kubernetes
job.
Second,
one
is
to
check
the
status
of
the
code
register
so
once
it
does,
this,
the
knative
service
will
scale
to
zero
and
kubernetes
job
will
also
completely
run
to
completion
okay.
G
So
an
example
of
like
how
you
would
specify
these
okay,
how
you
specify
is
like
this
is
a
canadian
service
definition.
Nothing
special-
and
this
is
the
image
you'll
be
using
the
static
image
you'll
be
using,
and
this
is
the
kubernetes
job
image
which
will
be
passed
as
an
environmental
variable
called
job
spec.
G
Maybe
you
create
it
as
a
secret
and
mount
it
as
a
environmental
variable,
mainly
the
bucket
information
and
the
file
information
is
the
one
that's
going
to
keep
on
changing
that
will
be
passed
as
a
query
parameter.
Okay,
so
where
does
the
sync
binding?
Comes
here
to
explain
that
I'll
take
an
example
in
this
example.
What
we're
trying
to
do
here
is
like
process
a
drug
file.
Okay,
so
this
drug
file
is
a
csv
file.
G
It
has
a
list
of
drugs
based
on
anatomy
and
have
two
k
native
services
to
process
it.
One
service
will
split
these
file
based
on
anatomy
and
upload
it
back
into
the
s3
bucket,
and
second
one
is
just
a
cloud
events:
viewer
it'll
show
it
on
the
screen
so
based
on
based
on
the
sync
binding
labels,
we
can
see
how
we
can
send
the
data
to
two
separate
kinetic
sensors.
G
Next
thing
is
to
you
need
to
create
a
role
binding
so
that
the
k
native
service
can
create
the
kubernetes
job.
Third,
one
is:
you
need
to
have
k
native
event
in
core
for
the
sync
binding
to
be
injected,
and
finally,
you
deploy
this
s3
source.
This
is
one
time
process.
You
have
the
k
native
service
now
up
and
running.
Okay.
Now,
the
next
step
is
to
run,
I
mean,
create
the
k
native
services
which
are
going
to
process
this
drug
information
okay.
G
What
I,
as
I
told
earlier,
it's
going
to
just
split
the
file
based
on
anatomy
and
upload
it
back
into
an
s3
bucket
and,
as
you
can
see
it,
it
will
inject
into
the
job,
which
has
this
label
drop
file
source,
okay,
and
it
will
be
sending
to
this
sync.
Okay
and
second
file
that
I
have
is
like
to
send
a
cvs
cloud
events
viewer,
it's
just
an
ui
and
the
match
label
for
this.
G
Okay,
first
before
that,
I
just
want
to
show
I'm
not
going
to
how
how
to
run
kn
with
co-publish
everything
in
a
single
line.
So
I
don't
know
I'm
not
going
to
wait
for
it
to
complete,
because
this
will
be
running
in
the
default
namespace.
Okay,
so
you
can
see,
there's
a
co-published
platform
sequel
to
all
or
you
can
have
a
amd64
or
linux,
slash
arm64,
whatever
you
want.
G
G
And
now
this
is
creating
the
kinetic
source,
so
I
don't
want
to
wait
for
this.
To
do
this
will
work
okay,
so,
okay,
first
one
is
I'm
going
to
this.
This
is
my
endpoint
to
call
the
s3
file
source
and
in
the
query
parameters
I
passed
this
label
direct
file
source
and
whatever
is
the
bucket
information
and
whatever
is
the
file
information.
G
Okay
and
currently
you
can
see
here,
the
k
native
the
s3
file
source
server
is
not
running
okay,
so
now,
when
I
run
it,
it's
going
to
start,
and
once
this
is
done,
it's
running
the
job.
Now,
okay
and
it's
calling
the
direct
processor,
can
it
says
okay,
so
simultaneously
I'll
run
the
view
one
also
so
there's
a
this
is
view
drug
file,
source.
G
So
this
is
my
s3
okay,
so
currently
it
had
just
the
now.
You
can
see
the
other
files
that
got
created
just
based
on
anatomy
and
it
got
uploaded
back
into
this
s3
bucket
earlier.
Only
this
drug
users
files
were
there
okay.
Now
this
is
the
cloud
events
viewer.
So
now
all
the
events
that
were
there
got
sent
to
the
ui
okay.
G
So
here
you
can
see
the
advantage
of
sync
binding
there.
So
with
you
don't
need
to
change
any
of
the
k
native
deployments.
You
don't
need
to
change
the
destination
in
order
to
change
the
source.
Just
by
changing
the
labels,
you
can
send
it
to
like
two
different
destinations:
okay,
okay,
so
with
the
first
option
and
second
option,
you
should
be
able
to
do
most
of
the
things,
but
the
main
disadvantage
that
I
would
see
with
sync
binding
is
like
I
mean
that's
the
way
it
is.
G
You
wouldn't
be
able
to
sorry,
so
this
is
the
way
that
you
distribute
this
even
source
to
other
people
like
this
is
a
canadian
service
and
it's
like
people
can
fat
finger
and
make
some
mistakes
here.
It's
not
like.
There's
no
crd
to
do
a
validation
or
something
like
that,
but
at
the
same
time
a
lot
of
people
don't
want
to
create
a
controller
because
they
don't
have
the
expertise
to
do
that,
but
still
if
they
want
to
have
a
controller
who's
which
is
managed
by
somebody
else.
G
Then
that's
when
you
choose
choose
the
contain
resource
option.
Okay,
so
the
only
job
that
you
need
to
do
is
to
create
the
adapter,
and
you
expect
the
container
source
to
do
the
work
for
you.
So
for
this
I'm
going
to
use
the
ftp
source
by
vlay
okay.
So
this
is
the
container
source,
and
this
is
the
only
image.
This
is
the
adapter
image
that
it
needs
and
is
the
only
responsibility
of
the
user.
Everything
else
is
managed
by
the
canadian
eventing
controllers.
G
You
pass
all
the
args
that
you
need
to
process
and
all
these
environmental
variables
in
the
args
will
be
created
as
a
deployment
and
whatever
sync
information
that
you
create
will
be
created
as
a
sync
binding.
Okay,
so
it's
same
as
the
sync
bending
only,
but
the
canadian
eventing
controller
is
going
to
create
the
deployment
and
sync
binding
for
you.
Okay,
so
he
I
don't
want
to
go,
show
it
in
a
terminal.
G
There
is
a
ui
called
graph
by
scott,
so
you
can
use
this
to
display
all
the
k
native
services
and
sources
within
your
namespace,
and
it
also
shows
the
connection
between
the
source
and
the
destination
right.
So
this
was
the
advantage.
I
was
saying
about
cloud
events
you
can
see
like
three
connections.
Are
there
three
sources
sending
information
here
and
I
have
a
single
consumer
to
consume
it,
so
that
is
made
possible
by
cloud
events
and,
as
I
was
saying,
it
creates
a
deployment
and
sync
binding
for
the
container
source.
G
Here
you
can
see
there
is
a
container
source
also
pointing
to
the
destination
and
also
a
single
binding
for
the
sftb
watcher
pointing
to
the
sync
binding
okay.
So
what
the
sftb
watcher
does
is
like
it's
going
to
watch
for
a
ftp
location
and
it
will
be
polling
there
whenever
there's
a
new
file,
it's
going
to
send
the
information
to
the
sync.
So
I
have
an
ftp
server
within
that
has
very
big,
I'm
going
to
just
upload
an
information
using
the.
G
It
will
take
some
time
for
the
yeah
here.
You
can
see
the
information
so
whenever
the
file
was
added,
you
can
see
the
information
here,
so
it
keeps
track
of
the
latest
time
and
whenever
there's
a
mo
a
file
after
this
timestamp
it
keeps
sending
to
the
canadian
sync
and
this
file
at
this
time
is
stored
in
a
config
map.
So
you
don't
lose
it
when
there
is
a
crash
or
something
like
that.
G
Okay,
so
these
are
the
three
options
that
we
have
to
build
the
source
and,
as
I
told
earlier,
I
explained
the
concept
of
the
source,
but
apart
from
this
option,
if
you
have
a
different
pattern,
you
can
use
attachable
and
then
compare
these
three
options
might
be
debatable.
So
I
don't
want
to
discuss
here
so
you
can
go
through
the
I'll
share
this
link
and
if
you
have
any
comments,
please
let
me
yeah.
That's
all
I
have
thanks
for
this
opportunity.
A
A
I
A
A
So
please
do
send
that
our
way
and
we
always
love
to
see
new
applications
of
creative,
and
I
think
we
also
have
a
survey.
So
please
do
let
us
know
what
you
think
about
this
meetup
and
if
you
would
like
you
want,
you
have
any
ideas
or
any
proposals
for
change.
We
are
also
open
to
that,
and
this
is
the
survey
link
we
there
we
go.
Please
do
fill
that
out.
We
we
read
that
and
we
take
that
into
consideration
and
as
always
thank
you
for
joining
the
community
meetup.
A
I
hope
you
had
a
great
time.
I
hope
that
you
learned
something
new.
I
hope
that
you
met
somebody
that
you
didn't
know
before,
and
I
will
see
you
next
month
next
month
and
we
are
doing
the
community
meetup
I
aligned
with
cubicle
north
america
to
that
end.
We
are
doing
it
a
week
earlier,
so
this
will
be
on
the
third
wednesday
instead
of
the
fourth
and
we're
doing
this,
to
try
and
get
some
some
of
the
participants
from
kubecon
to
join
the
meetup
as
well.
A
F
No,
no,
I
was
just
gonna
go
ahead
and
say,
put
a
plug
in
for
the
friday
hacker
day.
So,
if
you're
meeting
the
community
joining,
you
just
want
to
chat
at
chat
and
all
of
that
there's
a
very
low
key
event
hosted
every
friday,
it's
in
a
very
europe
unfriendly
time
zone.
So
if,
if
you
all
want
to
do
it
for
the
next
couple
of
weeks,
while
I'm
in
the
europe,
let
me
know
we
can
we
can
chitty
chat,
but
if
not
then
join
the
join.
The
other
one
yeah
fine.
J
H
A
That's
awesome,
and
just
in
case
you-
you
haven't
seen
this
yet
this
the
hacky
hours
on
friday
afternoon
afternoon
for
pacific
time
is
on
the
canadian
calendar.
So
if
you
don't
know
where
the
canadian
calendar
is,
please
go
to
canadian.dev
community
and
you
will
find
it
there
and
yes,
and
if
you
really
like
hack
hours
and
you're
in
europe,
consider
making
yourself
the
host
of
europe
friendly
hours.