►
From YouTube: Git-push Workflows (using git hooks) for Deploying Applications - Tanmai Gopal & Vamshi Surabhi Rao
Description
Want to view more sessions and keep the conversations going? Join us for KubeCon + CloudNativeCon North America in Seattle, December 11 - 13, 2018 (http://bit.ly/KCCNCNA18) or in Shanghai, November 14-15 (http://bit.ly/kccncchina18)
Git-push Workflows (using git hooks) for Deploying Applications on Kubernetes - Tanmai Gopal & Vamshi Surabhi Rao, Hasura (Intermediate Skill Level)
Tanmai will start with a motivation of why git-based tooling is useful for teams and then cover a set of functional requirements (secrets, templating for mutiple-envs, existing CI/CD integration etc.) that dev teams need for a good git-based deployment workflow. Then after a brief review of current tooling, Tanmai will propose an architecture for a DIY tooling setup that will allow developers to setup their own git-push based workflow for kubernetes. The talk will delve into step-by-step implementation detail and touch upon how git-hooks works. Vamshi will go into more detail regarding the pre-push and the pre-receive hooks. Tanmai will then wrap up with a demo (if possible/recorded), followed by links to boilerplates and resources for the attendees.
About Tanmai
Tanmai runs a startup, Hasura, where they've built a PaaS on Kubernetes. They were early adopters in the container ecosystem (pre-1.0 adopters for both Docker and Kubernetes) and have grown and contributed to the ecosystem as a company especially in India. Before this, Tanmai ran a small and successful consulting and services agency where their work included everything from MVPs for startups to helping one of the largest banks in the world migrate from legacy monoliths to containerised microservices. Tanmai has been building applications for over 8 years now with a variety of frameworks. He is a firm advocate of democratising the power to develop applications and proudly teach the largest tech MOOC in India, imad.tech! Tanmai is a frequent speaker at conferences, events/meetups in India & Singapore. Most of his recent talks/presentations/demos have been around kubernetes. Some conferences he's been spotted speaking at include: ContainerConf, FunctionalConf, IEEE CCEM.
About Vamshi
Vamshi heads engineering at Hasura. He was instrumental in leading Docker and Kubernetes adoption at Hasura and spotted its opportunity and utility to the dev-community in its nascent stages. Although Vamshi's Masters work was with JVM internals and compiler optimisations, he has since built expertise in the Haskell and kubernetes ecosystem. In fact, he was one of the first people in the community to write a Kubernetes operator (which now powers the Hasura platform). Vamshi's latest work at Hasura is setting up a declarative infrastructure provisioning system. Vamshi is an occasional speaker at niche meetups and conferences (FunctionalConf), especially his experiences and work with Haskell.
Join us for KubeCon + CloudNativeCon in Barcelona May 20 - 23, Shanghai June 24 - 26, and San Diego November 18 - 21! 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.
A
Hi
folks,
so
I'll
get
started.
Maybe
have
people
can
keep
coming
in
as
they
come
in
I'm
gonna
be
talking
about,
building
get
push
workflows
for
kubernetes
I
am
Tanmay,
I
am
one
of
the
founders
at
thora
and
where
we've
been
kind
of
building
tools
to
make
kubernetes
easier
for
application
developers,
and
one
of
the
things
that
we
do
is
provide
developers
get
push
workflows
so
that
they
can
kind
of
use
kubernetes
more
easily.
A
We
started
using
kubernetes
and
occurred
back
before
they
were
thing
before
1.0
we've
done
all
the
wrong
things
that
you
could
with
docker
and
perhaps
with
kubernetes
too.
We
used
to
have
multiple
processes
in
a
single
container
or
I.
Don't
know
if
anybody
remembers
fusion
base
invention
which
would
have
like
SS
running
any
tanks.
Well,
we
also
started
using
I
mean
the
way
we
construct.
An
entire
platform
is
basically
an
operator,
and
this
was
before
the
term
operator
was
there.
A
So
we
used
to
have
config
Maps
and
then
you
would
listen
to
changes
on
the
config
map
and
that's
kind
of
how
our
operators
would
work,
which
is
now
custom
resources.
I,
come
from
I'm
a
developer
I'm,
not
a
I'm,
not
a
sysadmin
person
or
an
ops
person
and
and
the
first
time
that
we
started
using
kubernetes
and
the
first
time
I
looked
at
kubernetes
and
played
with
it.
A
That
kind
of
make
that
narrative
happen
for
the
developer,
where
I,
just
as
a
single
developer,
can
build
something
fairly
complicated,
fairly
easily
right.
One
of
the
things
that
that
changed,
the
life
of
developers
when
they
started
approaching
Ops
concepts
was
the
git
push
workflow
right.
So
you
write
code
and
with
Heroku
you
would
do
git
push
coup
master
and
you
just
go
live,
and
this
was
this
was
just
mind-blowing
right.
A
This
is
super
mind-blowing,
because
I
only
work
with
kid
and
I'm
only
using
kid-
and
this
is
my
source
code
and
I-
do
a
git
push
and
the
source
gets
deployed
right.
There's
no
unnecessary
abstractions
for
me
as
a
developer
right,
because
Haruko
has
to
do
certain
ops
things.
So
you
know
their
back-end
does
ops
things
and
it
just
happens.
A
Well,
then,
you
can
build
your
own,
get
push
workflows
and
and
if
you're
building
and
the
main
idea
behind
building
these
git
push
workflows,
that
does
like
a
git
push,
cluster
master
or
git
push
to
your
github
or
bitbucket
or
wherever
is
that
you
can
kind
of
simplify
DevOps
and
pipelines
for
the
developer.
The
developer
doesn't
have
to
think
about
DevOps
or
pipelines.
Right
I,
just
think
about
get
push,
and
my
work
gets
done.
A
So,
let's
kind
of
dive
in
with
a
supremely
simple
example,
which
is
the
most
basic
thing
that
you
want
to
do,
the
most
basic
DevOps
tasks
that
you'd
ever
want
to
do,
which
is
build
and
deploy
so
I
have
source
code
on
my
machine.
I
can
test
it
locally
and
then,
wherever
my
source
code
of
the
current
commit
is
I
just
want
this
to
be
deployed.
This
is
a
fairly
straightforward
thing.
To
do.
A
I
would
do
a
docker
build
pack
it
with
my
registry
name,
my
image,
my
tag
I
would
push
it
to
the
registry,
wait
for
the
push
to
happen
because
hey
and
then
and
then
finally,
when
the
push
is
done,
I
would
use
cube,
CTL
and
I
would
patch
the
deployment
or
whatever
demon
said
that
I
was
using
with
this
new
image
right.
This
goes
away
into
just
one
command,
which
is
get
push,
dev
master
right
and-
and
this
is
the
kind
of
tool
that
we
want
to
build
out.
This
is
the
these.
A
A
So
when
you're
doing
so,
when
you
run
any
git
command,
it
offers
you
the
ability
to
kind
of
add
scripts
or
hooks
to
any
particular
command
that
before
or
after
whatever
get
does
in
that
command,
and
that
kind
of
allows
you
to
tweak
behavior
or
add
extra
behavior,
and
so
when
you
do
get
push,
there
are
three
specific
hooks
that
are
of
interest.
The
first
is
a
hook
that
runs
in
the
client
side.
A
So
there's
me,
which
has
my
machine,
who
has
my
machine
and
then
I
have
a
git
installed
my
machine,
and
that
is
the
client.
So
if
I
do,
whenever
I
do
a
git
push,
there
is
a
client
side
hook
that
is
executed,
called
a
pre
push
hook.
The
pre
push
hook,
if
it
succeeds,
will
allow
the
push
to
continue.
If
it
fails,
we'll
ask
the
push
to
get
about
it.
A
Similarly,
there's
a
server
side
hook
and
the
idea
with
the
server
side
hook
is
that
you
have
a
pre
receive
which
executes
before
the
objects
are
taken
and
put
inside
the
git
repo.
So
that's
the
pre
receive
and
then
once
the
objects
are
taken
and
put
onto
the
get
wrap
or
put
onto
the
filesystem,
the
post
receive
hook
executes
and
the
post
receive
hook.
Even
if
it
doesn't
work
cannot
abort
the
bush
process
that
started
hooks
are
super
simple
to
use.
A
You
probably
already
have
hooks
in
your
wrapper
if
you've
not
tried
it
out,
if
you
just
go
to
dot
git,
if
you
go
to
any
key
trap
or
go
to
dot,
git
slash
hooks
you'll
find
a
bunch
of
sample
hooks,
just
remove
the
dot
sample
from
the
name
and
those
hooks
will
start
working
for
you.
You
might
have
to
chmod
text
m
or
or
item
or
maybe
not,
and
so,
if
you
want
to
build
the
system,
the
most
obvious
architecture
I
should
run
animations
on
these,
but
the
most
obvious
architecture
that
would
emerge
is
hey.
A
You
need
to
have
a
git
remote
agent
on
the
server
that
you
can
actually
push
to
right,
and
then
that
is
the
agent
that
is
actually
going
to
do
the
docker
build
and
then
do
the
cube.
Ctl
apply
image.
Those
two
commands
that
we
wanted
to
run
three
commands
that
we
want
to
run
and
then
this
git
remote
agent
will
obviously
need
some
configuration,
so
the
configuration
it
would
need
is
the
SH
key
so
that
you
can
push
to
it.
A
It
would
need
the
Baka
file
path
so
that
it
knows
where
the
docker
file
is
so
that
can
build
it
in
your
repo
and
then
once
you
have
a
configuration
file,
you
obviously
need
something
that
will
apply
the
configuration
files
to
the
agent
right
and,
if
you're
not
consuming
something
as
a
config
map,
then
the
only
other
way
or
the
best
way
to
do
it
is
to
use
a
custom
resource
and
to
use
an
operator
or
a
controller
that
kind
of
sinks.
Those
changes
with
the
gatorman
region
right.
A
So
that's
kind
of
what
the
architecture
looks
like
at
a
high
level.
You
have
your
computer,
you
do
a
git
push.
It
goes
to
the
git
remote
we
get
remote,
does
a
docker
build
and
then
patches
the
deployment
right.
So
the
setup
that
I
would
need
to
do
as
a
developer
in
this
kind
of
a
workflow
is
I
would
create
a
custom
resource
called
a
remote
and
in
that
remote
I
would
specify
that
this
is
the
docker
file.
This
is
the
deployment
that
you
that
you
should
batch.
A
This
is
the
docker
file
that
you
should
use
from
a
git
repo,
and
these
are
the
authorized
keys
of
people
that
are
allowed
to
push.
Excuse
me
and
so
I'm
gonna
do
a
quick
demo.
I
shall
pray
to
the
demo
gods
old
and
new.
We
are
in
the
home
of
Loki,
so
so
I
have
a
super
simple
nginx
deployment
setup.
Oh.
A
A
Right
and
what
I
want
to
do
is
when
I
do
a
git
push
I
want
I
want
all
of
those
things
to
happen
right
so
fairly
straightforward.
If
I
go
into
side,
my
HTML
directory
to
index.html
I'm
just
going
to
take
this
off
and
make
a
change
and
that's
git
commit
a
changes.
This
is
the
worst
commit
message:
don't
do
this
directly
on
master
but
and
then
I'm
just
going
to
apply
this
with
a
git
push,
dev
master
right
and
then
I
can
show
you
how
that
got
set
up
in
the
first
place.
A
So
that's
the
docker
build
that's
happening,
it's
nginx,
so
it's
super
fast
because
it
just
copying
files
over
and
then
it
does
a
kubernetes
rollout
right
and
now,
if
I
refresh
this,
that's
that's
me
with
right
and
and
that's
kind
of
it,
that's
kind
of
it
as
a
developer,
because
you
have
get
you
can
do
simple
things.
I
can
do
simple
things
like
I,
don't
like
this
deployment
that
I
just
made,
and
so
what
I'm
gonna
do
is.
A
And
so
the
idea
is
that
hey
I
have
my
code
code
is
committed,
I'm,
just
gonna
do
a
git
push
and
it
should
work
right.
That
is,
there
is
nothing
more.
There
is
nothing
more
or
less
that
I
that
I
want
to
think
about,
and
and
the
way
this
works
is
that
I
have
remotes
that
are
set
up
here,
and
this
is
the
dev
remote
I'm
going
to
come
to
the
other
remotes
later
right
and
I'm
pushing
to
this
remote.
So
that's
the
IP
of
my
cluster,
that's
where
they
get
remote
agent
is
sitting.
A
So
that's
the
custom
resource
of
the
remote,
that's
the
custom
resource
that
I
set.
So
you
know,
cube
CTL,
create
F
remote
and
you
create
this
remote
I
can
even
do
a
get
remotes
to
show
you
that
this
was
the
custom
resource
that
captures
that
remote
and
then
and
then
this
kind
of
remote
gets
applied
and
whenever
I
do
okay
get
remote
dev.
A
Oh
yeah
Mel,
the
operator
that
is
sitting
there,
that
is
sinking
these
changes
with
the
git
remote
agent
with
the
remote
agent
that
kind
of
publishes
that
remote
URL.
So
that's
the
remote
that
I
add
to
my
git
repo,
so
I
do
a
git,
remote,
add
dev.
Is
this
and
then
I
can
do
a
git
push
to
F
master
I'm
fairly
fairly
straightforward
right?
The
nice
thing
is
the
nice
thing
about
the
simple
setup
is
that
it's
powered
by
just
a
pre
receive
hook?
The
previous
evoke
is
doing
all
the
work.
A
And
that's
that's
essentially,
the
pre
receive
code
that
is
powering
this,
which
is
basically
just
taking
the
deployment
name
and
then
doing
a
docker
build
and
then
doing
a
cube.
Ctl
apply
right.
That's
that's!
That's
all
of
the
that's
required
to
make
this
work.
What
what
we
did
was
we
kind
of
took
this
and
we
put
this
into
a
small
package
called
get
Q,
which
is
a
package
that
you
can
run,
which
comes
with
the
controller,
a
remote
definition.
You
can
customize
the
controller.
A
You
can
customize
the
kitchen
mote
agent
as
well,
and
you
can
just
take
this
and
then
run
this
on
any
kubernetes
cluster
on
the
good
thing
about
running
on
a
kubernetes
cluster.
Is
that
you
can
our
back
it
to
do
only
the
things
that
you
wanted
to
do
and
you
can
and
you
can
access
kubernetes
resources
as
well.
That's
the
next
demo
that
I'm
gonna
try
to
show
you
so
the
benefit
for
the
developer
is
fairly
obvious.
A
I
just
need
to
use,
get
the
benefit
for
the
ops
people
or
if
the
developer
is
doing,
an
ops
task
is
that
I
can
kind
of
use.
My
hooks
to
use
kubernetes
resources
directly
right
now
and
one
of
the
resources
that
become
useful
when
you're
writing.
These
small
obstacles
is
access
to
secrets
that
are
stored
locally
on
the
communities
cluster.
A
You
see
that
I
have
a
slack
secret
right
and
that's
essentially
the
secret
that
I
want
my
hope
to
use
and
then
make
an
API
call
to
slack
saying
that
something
has
happened
right
and
again.
All
that
you
kind
of
need
to
do,
for
this
is
I'm
going
to
load
up
our
slack
and
hope
that
nobody
says
anything
embarrassing
and
then
all
I
need
to
do
is
write
a
hook,
and
so
that's
what
a
post
receive.
Who
could
look
like
you
zoom
out
a
little
bit.
A
And
so
this
is
going
to
run
not
just
the
docker
build
and
the
kubernetes
patch,
but
it's
also
going
to
run
the
post
receive
hook
and
the
post
receive
hook
is
what
is
executing
right
now,
which
should
give
me
a
slack
notification
saying
that
he
deployed
this
particular
comment
on
master
right,
so
so
that's
kind
of
how
the
how
you
could
kind
of
customize
this
to
add
whatever
hooks.
You
would
want
to
add
to
that
later.
A
If
you,
if
you
take
a
step
back,
this
is
this-
is
kind
of
interesting,
because
what
if
we
could
extend
the
same
idea
to
do
more,
DevOps,
stuff,
right
and
I'm
sure
you
guys
are
all
ready
or
you
all
are
fairly
aware
of
the
different
kinds
of
things
that
you
can
do
when
things
are
decorative,
but
as
a
developer,
you
would
want
to
do.
You
would
want
to
build
and
run
unit
tests.
A
A
A
You
use
a
docker
file.
You
don't
need
anything
else.
It
is
completely
decorative,
contains
your
entire
set
of
dependencies
that
you
need
to
capture
for
that
particular
micro
service.
If
you
want
to
do
a
production,
build
you
again,
don't
need
to
do
anything.
You
just
use
a
multi
stage
rocket
file.
You're
pretty
much
done.
You
don't
need
any
external
tooling.
If
you
want
to
deploy
configuration,
let's
say:
you're,
changing
an
API
gateway
or
changing
ports.
That's
just
updating.
Kubernetes
manifests,
that's
also
pretty
straightforward.
A
So
custom,
resources
or
custom
resource
definitions
become
the
only
way
to
kind
of
operationalize
these
stateful
tasks,
and
they
should
also
just
execute
without,
depending
on
any
external
notion
of
a
sequence
for
integration
test,
you
would
have
jobs
and
you
could
just
have
an
init
container
that
checks
if
the
dependent
micro
services
are
ready
and
then
kind
of
run
run
whatever
tests.
You
need
to
run
so
so,
for
example.
So
so
what
this
would
mean
is
that
maybe
maybe
we're
kind
of
reaching
a
place
where
you
don't
need
to
have
pipelines
anymore?
A
A
A
This
subdomain
www,
which
is
just
running
a
simple
engine
export
and
now
what
I'm
gonna
do,
is
I'm
gonna
change
the
subdomain
right
and
as
a
developer,
I
have
a
route
Satya
Mel,
which
is
a
custom
resource.
I,
have
the
subdomain
here
I'm,
going
to
change
that
subdomain
to
app
and
then
I'm
going
to
write
another
hideous,
comet
message.
A
And
this
is
kind
of
all
it
would
all
it
should
take
for
running
for
making
that
change
happen
right
and-
and
you
can
imagine
that
the
back
on
the
back
of
this,
what
happens
is
actually
fairly
straightforward.
All
you're
doing
is
you're
updating
a
custom
resource
and
your
operator
is
going
and
restarting
the
deployment
of
the
API
gateway
and
saying
hey.
A
This
is
the
new
subdomain
or
new
route
configuration
that
you
need
to
have
right,
and
so,
if
I
head
to
this
you'll
see
that
it's
down
and
if
I
go
to
app,
you
see
that
this
now
lives
it
up
right.
So
this
is
a
super
simple
name
of
again
saying
that
how
how
life
can
again
become
one
level
easier
for
the
developer,
but
just
by
just
having
this
kind
of
tiny
automation
that
you
build
in
a
slightly
harder
example,
is
database,
migrations
and
so
I'm
going
to
show
you
that.
A
So
there
is
a
migrations
folder
that
I
have,
and
this
is
built
to
work
with
post
cache
migrations,
or
this
is
kind
of
like
a
slight
weight
migration
framework
on
top
of
Postgres,
and
so,
as
you
can
see
right
now,
my
migrations
directory
is
empty.
I,
don't
have
anything
in
it.
I'm
just
going
to
open
up
the
SQL
so
that
we
can
see
the
changes
as
they
happen.
A
So
I,
don't
have
any
tables
in
here.
I
just
have
a
table.
Call
schema
migrations,
it's
kind
of
like
a
rails
like
migration
framework
right,
so
you
have
a
schema.
Migration,
stable
and
I.
Don't
have
any
I,
don't
have
any
tables
in
it.
What
I'm
going
to
do
is
I'm
going
to
declaratively
copy
those
I'm
gonna
copy,
those
kind
of
declarative,
migrations,
CP.
A
I'm
going
to
show
you
what
those
migrations
are,
so
it's
a
bunch
of
different
tables.
It
even
contains
some
sample
data,
which
is
just
like
an
SQL
file.
I'm
gonna
open
up
a
few
of
them,
so
that
this
is
just
typical
database
migrations
that
any
application
would
have.
So
that's
the
create
table.
I
have
some
sample
data
here
as
well,
just
to
show
you
that,
and
so
that's
some
sample
data
I.
Just
a
copy
statement.
Ordinance
bunch
of
insert
statements
and
now
all
I
need
to
do
is
get
add
and
get.
A
A
What
the
hook
that
you're
writing
is
essentially
the
same
bash
script
that
you
would
have
written
if
you
were
trying
to
automate
your
workflow
and
wherever
you
are,
and
if
you
had
direct
access
to
the
database
as
well
so
select
star
from
author
shows
either
these
these
kind
of
data
has
been
imported
as
well.
So
that's
kind
of
what
get
pushed
can
let
you
do
right
and
and
and
it's
so
easy-
and
you
can
just
kind
of
do
this
for
yourself
or
whatever
tooling.
A
You
need
to
have
whatever
application
or
whatever
framework
or
whatever
database
you
have,
and
you
can
you
don't
need
to
have
any
more
abstractions
on
top
of
this
right,
cube.
Ctl,
get
writing
your
own
scripts
is
is
just
more
than
enough
for
these
kind
of
simple
use
cases.
There
are
a
few
things
that
are
not
easy
to
do
with
this
idea
of
making
everything
declarative,
even
if
it's
possible
to
run
stateful
things
with
operators.
A
One
of
them
is
secrets,
which
is
that
you
cannot
commit
them
to
get
obviously,
and
so
you
need
to
apply
or
manage
secrets
external
to
this
workflow.
So
that's
something!
That's
never
going
to
become
a
part
of
this
get
ops
kind
of
movement,
that's
happening.
The
other
thing
that's
also
a
little
cumbersome
is
templating,
which
is
that
if
you're
templating
kubernetes
objects,
they're
not
actually
kubernetes
objects
anymore
right.
So
this
is.
A
This
is
one
of
the
painful
things
about
about
templating
tools
today,
which
is
that
if
you
have
a
deployment
at
Yama,
the
deployment
that
yeah
Mel
is
not
actually
a
kind'
deployment
right.
It's
actually
templated
with
these
random
things,
and
so
so
we
don't
know
what
a
kubernetes
tentative
kind
of
templating
would
look
like
where
the
templating
would
kind
of
happen
on
the
server
side.
But
the
only
tool
that
you
need
is
cube,
CTL
or
cube
control.
A
A
There
is
so
so
again
the
values
that
your
templating
the
values
document
file.
These
will
again
not
be
a
part
of
your
get
rebel
because
you
might
want
to
have
these
configurations
that
are
stored
outside
the
git
repo,
so
that
becomes
another
piece
that
doesn't
get
handled
very
neatly
with
the
Kitab
a
kind
of
idea.
A
There
is
another
problem
which
is
fairly
common
here,
and
that
is
the
idea
of
like
how
do
you
say
that
I
need
to
scale
this
deployment
up
or
down,
or
this
needs
to
kind
of
auto
scale
right?
Where
does
that
configuration
go
or
does
that
go
in
the
deployment
or
yeah
Mel?
Is
that
also
declarative?
And
there
is
school
of
thought
which
says?
Yes,
let's
just
make
that
decorative
too.
So,
if
you
want
to
want
to
scale
things
up
or
down
to
a
fixed
value,
then
you
use
deet-based
tooling
to
make
that
happen.
A
But
the
other
thing
that's
also
happening
is
that
when
you
say
things
are
auto
scaling,
the
fact
that
a
deployment
is
auto
scaling
is
also
declarative,
and
so
that
handles
at
least
some
kind
of
min
max
use
case
by
being
declarative
right.
So
you
don't
need
to
keep
changing
or
get
rapid
to
make
that
happen.
There's
this
conversation
around
releases
and
doing
can
read
Bluegreen
deployments,
which
is
also
something
that
is
traditionally
just
a
completely
ops
task.
Not
so
much
not
something
that
developer
has
to
worry
about,
and
then
you
should
go.
A
Look
at
the
gate.
Ops
talk
with
this
TO
WEAR
is.
She
also
runs
with
this
idea
of
having
a
controller
and
having
manifests,
and
you
can
kind
of
change
those
policies
declaratively
and
the
operator
will
make
it
happen.
For
you
saying
that
a
90%
traffic
here
10%
traffic
here,
which
gives
you
your,
can
Rio
Bluegreen
deployment,
so
that
kind
of
covers
a
set
of
things
that
I
want
to
talk
about
with
get-ups
you
guys,
y'all
should
check
out
the
get
cube
repo
which
will
just
help.
A
A
Also,
a
UI
to
see
what
your
past
pushes
are
like
we're
kind
of
hoping
that
this
doesn't
turn
into
a
full-fledged
CI
CD,
but
does
does
work
for
certain
small
use
cases
and
then
we'll
also
kind
of
make
this
case
of
making
the
git
push.
That
is,
synchronous
become
equivalent
to
an
asynchronous
vendor
webbook.
So
having
a
git
push
to
your
github
and
having
that
asynchronously
apply,
there's
a
small.
A
The
small
caveat
with
making
git
push
work
for
the
developer
is
that
things
should
be
synchronous
right.
So,
if
you
look
at,
if
you
look
at
the
deployments
that
I
was
making
when
I
was
doing
it,
push,
this
actually
waits
for
the
rollout
to
finish,
which
is
fine
for
small
use
cases
which
is
not,
which
is
not
good
if
you're
running
a
large
battery
of
tests
or
if
it's
a
long-running
task.
A
But
this
is
good
feedback
for
the
developer
because,
as
I'm
doing
a
git
push,
I
would
like
to
know
if
something's
working
or
something
is
failed
like
if
migrations
did
not
get
applied.
I
don't
want
the
push
to
happen
at
all,
because
I
know
that
migrations
are
critical.
For
my
application,
so
making
that
equivalent
is
also
a
bit
of
a
task
which
will
kind
of
try
to
make
happen.
That
is
all
from
my
side
and
we
are
also
hanging
out
at
suc
30.
A
So
please
do
come
and
talk
to
us
about
developer,
workflows
on
kubernetes.
We're
also
doing
a
lot
of
interesting
work
with
multi-tenant
kubernetes
to
kind
of
do
the
zero
to
one
scaling
so
that
if
a
particular
namespace
is
not
active,
it
gets
scaled
down
and
scaled
up
automatically.
So
if
you
have
any
of
those
kinds
of
things
to
talk
to
us,
to
do
you
want
to
talk
about
them,
do
drop
by
our
booth
and
do
checkout
get
cube,
and
let
me
know
what
you
guys
think
thank
you
for
having
me
I.