►
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
Kustomize: Template-Free Configuration Customization for Kubernetes - Jeffrey Regan, Google
Managing configuration in Kubernetes is a common task and usually quite challenging as the application scales up. Numerous tools have been developed, but seldom leverages the power of native Kubernetes APIs. Kustomize is a new tool for customizing manifests of Kubernetes application in a declarative way. In this talk, attendees will learn the basic concepts of Kustomize and workflows to customize a real world application like MySQL-Wordpress for different scenarios. Attendees will also learn the best practices for managing Kubernetes manifests.
To learn more click here: https://sched.co/FvBK
A
Okay,
hello,
it's
11:30,
let's
get
started!
Thank
you
for
coming.
First
off
I
know,
there's
a
lot
of
stuff
going
on
at
coop
con
and
I
love
coming
to
these
things.
This
is
my
second
one.
I'm
gonna
talk
today
about
kubernetes
configuration
customization.
My
name
is
Jeff.
Reagan
I
have
been
working
on
open
source
kubernetes
for
about
a
year
and
a
half
now
I
work
on
the
apps
lifecycle
team
at
Google,
and
we
concern
ourselves
with
things
like
how
do
we
do
updates?
How
do
we
make
developer
tools?
A
How
do
we
write
controllers
and
how
do
we
configure
clusters?
So
the
gentleman
in
the
lower
right
is
Brian,
grant
he's
a
principal
engineer
at
Google
and
he's
one
of
the
cofounders
of
kubernetes,
and
he
maintains
this
spreadsheet.
That
shows
tools
that
are
used
to
configure.
Kubernetes
he's
been
maintaining
this
for
a
couple
years
now,
I,
don't
know
if
he
still
keeps
doing
it,
it's
intentionally
too
small
to
read,
and
it
goes
down
below
the
page
here,
there's
actually
a
link
to
it
if
you're
interested
up
at
the
top.
A
This
shows
you
that
configuring
kubernetes
is
not
a
done
deal.
It's
not
something
that
everybody
agrees
on
and
people
are
still
writing
new
tools
to
help
manage
it.
But
if
you
look
at
all
these
tools,
you
see
they
have
features
and
long
various
dimensions.
Okay,
so
some
of
them
talk
about
applications.
Some
of
them
talk
about.
You
know
what
is
an
application
taking
a
bunch
of
resources
calling
an
application
describing
it,
and
maybe
you
have
a
maintainer
of
that
app.
Then
there's
going
to
be
things
like
app
discovery
like
an
app
store.
A
If
you
have
an
application,
maybe
you
need
a
place
to
go,
get
it
download
it
so,
on
package
management,
you've
got
a
bunch
of
resources.
How
do
I
bundle
it
up?
How
do
I
describe
the
dependency
of
this
bundle
on
this
other
bundle
over
here?
Dashboard
stuff,
whoo,
that's
loud,
dashboard
e
stuff,
which
apps
am
I
running?
How
long
have
they
been
running?
Are
they
healthy
life
cycle
management,
rollouts,
roll
up
roll
backs
and
upgrades
and
customization,
given
some
set
of
some
configuration?
How
do
I
adapt
it
to
my
needs
right?
A
A
That
directory
looks
like
this
I'll
do
a
little
toy
example.
There's
three
conventional
resources
in
there,
a
config
map
deployment
and
a
service
there's
nothing
weird
about
those
things
just
standard
yeah
mo
and
you
drop
in
another
file
called
customization
yeah
mo
right,
which
also
looks
like
a
kubernetes
resource.
A
Here
is
a
toy
example
of
what
the
customization
file
looks
like.
So
in
this
case
there
is
a
resource
of
stanza.
That's
that
gives
a
list
of
files
below
it.
There's
one
file
here:
service,
dog
ammo
and
there
is
a
name
free
fix
specified.
It
says
demo.
Okay,
all
this
is
doing
is
saying
open
the
service
demo
file.
Reading
the
information
there
find
the
name
change
the
name
by
putting
a
prefix
in
front
of
it
and
then
send
that
to
standard
out.
That's
it
toy
example.
A
This
tool
is
about
kubernetes,
aware
patching.
Okay,
it's
just
patching,
so
the
customization
file
has
two
things
in
it
generally
operands.
These
are
the
things
that
you
want
to
include
in
your
output
and
some
of
those
things
are
gonna
get
patched
and
it
has
operations.
These
are
the
ways
you're
going
to
patch
those
operands.
Yo
I
saw
one
example,
which
was
appended
name
prefix
to
all
of
the
names
it
works.
Sort
of
like
this
you've
got
a
cluster
out
there.
A
You're
gonna
send
a
stream
of
amyl
to
that
cluster
via
coop
cuddle,
apply,
there's
gonna
be
a
bunch
of
operands
coming
in
from
the
from
the
left.
These
are
the
resources
that
you're
the
that
you're
operating
on
and
then
you're
gonna
like
operate
on
them,
you're
gonna
patch
them.
In
this
case,
you
did
a
name
prefix
change.
A
Now
it's
possible
since
customized,
weeds
and
yeah
MO
and
write
see
mo
out
to
send
the
output
of
customized
into
customized
again
for
further
customization
and
there's
practical
reasons
to
do
this,
which
we'll
discuss
in
the
next
in
the
first
example
here.
So
just
want
to
pause
and
mention
again
or
emphasize.
Customized
input
is
cabaña
GMO
you
can
coop
cuddle,
apply
that
yeah
more
without
customized
to
start
customizing.
You
just
add
a
customization
file.
A
Ok,
everybody
has
a
use
case.
That's
similar
to
this.
You
have
multiple
variants,
multiple
and
environments
that
you
want
to
maintain,
and
those
environments
have
most
most
things
are
in
common.
You've
got
in
this
case
we're
going
to
talk
about
three
environments
or
three
variants:
development,
staging
and
production.
So
development
is
something
where
you're
going
to
send
say
an
hourly
build
of
your
server
to
the
cluster
every
hour
and
staging
is
where
you're
going
to
say.
I'm
going
to
take.
A
One
of
those
QA
builds
one
of
the
one
of
the
builds
from
development
that
have
been
modified
or
that
have
been
signed
off
by
QA
and
I'm
gonna,
send
it
to
staging
and
staging
as
a
place
where
we're
going
to
test
it
with
real
traffic,
maybe
1%
of
traffic,
and
then,
if
that
works
well
we're
going
to
take
that
image
and
all
of
its
configuration
and
send
it
to
production
so
managing
3
variants
that
Hottel
have
a
lot
of
things
in
common.
That's
what
customized
is
good
at
ok,.
A
A
So
you
could
do
this
with
the
following
setup.
You
have
one
customization
final
here,
that's
listing
all
of
the
resource
yamo
that
you're
going
to
use
in
all
of
your
environments,
and
then
you
have
three
more
customization
files,
one
for
each
variant,
production,
staging
and
development.
Now
at
the
top
is
development
that
specifies.
Let's
do
a
name
prefix
of
dev
right.
That's
all
we're
gonna!
A
Do
there
I'll
explain
the
basis
line
in
a
second
staging,
we're
going
to
have
a
different
prefix
and
we're
going
to
say:
let's
use
the
image
tagged
with
QA,
because
it's
been
qualified
by
QA
and
in
production
we're
going
to
use
a
name
prefix
prod.
So
that's
going
to
distinguish
those
resources
from
all
the
other
staging
and
development
resources
and
we're
going
to
use
a
specific
image
because
this
production,
we
want
to
know
exactly
what
we're
running
and
that's
it.
You've
got
three
variants:
what
does
that
look
like
on
disk
and
what
does
that?
A
Dot,
dot,
slash,
dot,
dot,
slash
base
main
okay.
The
file
layout
is
like
this.
Let's
imagine
the
app
is
called
WordPress
WordPress
and
it
describes
it
subscribed
by
it
like
just
these
two
resource
files,
a
deployment
and
a
service.
So
in
the
directory
up
there
we
have
a.
We
have
a
directory
called
WordPress
that
holds
our
app.
We
have
a
subdirectory
called
base
in
the
base
as
two
files.
A
There
are
two
resource
files
and
there's
also
a
small
file
in
V
dot
txt
that
has
some
name
value
pairs
that
we're
going
to
use
to
generate
a
config
map.
Now
the
customization
file
in
that
directory
is
saying,
use
deployment
news
service
and
generate
a
config
map
from
this
simple
text
file.
That's
it
that's!
What's
in
that
directory
now,
how
do
we
generate
production?
A
Now?
Look
on
the
right
in
the
there's!
Another
sibling
directory
to
base
called
overlays
inside
overlay,
those
three
sub
directories-
production,
staging
and
development
in
the
production
directory
of
another
customization
file.
This
file
is
going
to
say
this
file
is
going
to
get
all
of
its
it's
going
to
use
the
base,
which
is
the
sibling
directory.
It's
going
to
get
the
deployment
and
the
the
service
and
the
config
map
that
are
in
that
directory,
and
it's
going
to
apply
to
patches.
A
A
So
how
does
this
work?
Let
me
run
you
through
all
of
the
source
code
for
customize.
Now
it's
just
these
seven
steps.
When
you
run
customize
world-first
customize
has
to
understand
how
to
read:
kubernetes
objects,
so
it
weaves
in
some
information
or
it
uses
hard
coded
information
so
that
it
understands
what
the
deployment
is
understands.
What
a
service
is
what
a
pod
disruption
budget
is,
etc.
A
Let's
step
one
step,
two,
it's
gonna
read
the
customization
file
from
the
target
that
you
specified
on
the
command
line
step
three,
it's
going
to
look
in
that
customization
file
for
the
basis
line
and
it's
going
to
customize
all
the
bases.
So
this
is
a
recursive
step
that
customization
is
going
to
come
in
and
be
customized
again
based
on
what
you're,
seeing
in
the
target
directory.
The
fourth
step
is
it's
going
to
load
the
files
that
are
in
the
target
directory
that
are
specified
in
the
customization
file
at
that
level?
A
I
can
end
the
talk
right
there,
but
let
me
go
on
and
give
you
a
few
more
tricks
that
customizes
does
for
you.
Here
is
an
example.
Sometimes
you
have
a
situation
where
you
have
a
server
that
depends
on
another
service.
So
in
this
case,
WordPress
depends
on
my
sequel.
It
needs
to
know
where
my
sequel
is.
It
needs
to
know
what
my
sequel
is
called
in
the
kubernetes
namespace,
so
you
can
define
in
a
customization
file.
A
You
can
defined
a
variable
VARs,
the
Vivaro
stanza
that
says,
let's
make
an
environment
variable
called
my
suit,
not
an
environment
variable,
but
a
customized
variable
called
my
sequel
service
and
it's
going
to
take
on
the
value
of
whatever
is
in
the
resource
service,
with
the
name,
my
sequel,
API
version,
1
v1
in
the
name
field,
and
then
it's
going
to
be
able
to
put
that
in
other
places.
So
in
this
case
it's
going
to
go
sticking
in
the
deployment
in
the
the
command
to
the
image,
make
an
environment
variable
for
it,
etc.
A
A
Another
trick
that
you
can
do
calling
it
a
trick
is
generate
config
maps
and
you
can
generate
config
maps
by
merging
data
from
multiple
environmental
files.
So
this
common
commonly
the
case
where
you
as
the
web,
app
developers,
say
you've,
got
some
some
properties
that
say
set
up
how
control
how
the
web
page
maybe
looks
and
over
you
know,
down
the
hallway.
There's
the
dev,
ops,
team
and
they've
got
properties
that
control
how
ingress
works
or
things
that
they
want
to.
A
They
want
to
maintain
under
their
control
database,
passwords
and
whatnot,
and
you
can
generate
a
config
map
from
both
of
these
things
that
merges
this
data
together
and
gives
it
a
unique
name.
So
in
this
case
our
base
has
a
generator
stanza
in
the
customization
file.
That
says,
look
in
this
particular
file
and
make
a
config
map
from
these
things.
A
And
then,
when
you
do
the
overlay
remember
you're,
gonna
customize,
this
stuff,
that's
coming
in
from
the
base,
you
can
add
a
name
prefix,
a
prod
and
you're
gonna,
throw
in
some
more
you're
gonna
merge
in
the
data
from
this
other
file
and
that's
gonna.
On
the
right
hand,
side
generally
the
config
map,
with
the
name
prod
the
original
name
that
was
in
the
base
and
then
a
hash
of
the
contents
of
the
file.
A
Okay.
So
this
is
all
just
patching
again.
Customize
is
just
a
means
to
manage
kubernetes
targeted
patching,
see
that
these
are
some
of
the
things
you
might
want
to
patch
namespaces
names,
labels,
annotations
and
so
forth.
In
the
container
you're
gonna
you're
gonna
want
to
modify
the
image
tags,
the
arguments
to
the
image
tags
and
so
on.
You're
gonna
worry
about
the
budgets.
The
CPU
resources
are
using
the
memory,
the
replicas
and
and
policies
anything
that
you
can
specify
in
our
llamo
file.
A
Basically,
another
trick
is
you:
can
kubernetes
customize
really
works
well
with
git,
so
you
can
customize
the
contents
of
a
git
repo
and
this
example
underscores
the
fact
that
you're
not
modifying
the
input
at
all
in
place
you're
only
patching
it
after
you
take
a
look
at
it,
so
you
were
going
directly
from
a
git
repo
into
the
cluster
and
applying
customizations
as
we
go.
Likewise,
you
can
specify
that
your
base
is
all
the
resources
off
over
in
this
directory
in
this
particular
git
repo.
A
So
what
does
a
rollback?
Look
like
you
make
a
change.
You
send
it
out
to
production.
Something
goes
wrong.
You
CD
into
the
target
directory
where
you're
working
you
just
step,
one
make
one
step
backwards
and
you
were
in
your
git
log
and
you
go
back
to
where
you
change
say
you
activated
a
flag
or
whatever,
whatever
you
did,
to
make
a
change
that
broke
production,
and
then
you
build
it
again
and
you
send
it
out
to
to
your
cluster.
A
You
verify
it
with
ku
cuddle
diff,
which
is
one
of
my
colleagues,
has
been
working
on
that
or
you
can
look
at
the
annotations
on
your
resources
now
another
thing
that
is
important
when
you're
using
other
people's
configurations,
whether
it's
somebody
who's
over
in
Italy
or
somebody,
who's
down
the
hall
who's,
maintaining
the
original
source
material
source
material.
Every
configuration
is
keeping
up
with
the
changes
that
those
folks
make
right.
A
So
the
general
approach
is
you
fork
their
config.
You
can
do
many
variations
on
this,
but
the
idea
is
for
that.
Config
drop
in
a
customization
file
to
adapt
that
configuration
to
your
needs
periodically
get
rebase
to
keep
up.
Okay
and
the
nice
thing
about
this
rebase
is
since
you're
not
modifying
the
source
material
at
all.
It's
always
going
to
work.
There's
never
going
to
be
a
stage
where
you
have
to
do
a
human
is
going
to
have
to
merge
the
data
right.
A
You
won't
have
to
resolve
conflicts,
so
that
means
it
could
be
upgraded
automatically.
It
could
just
be
done
automatically
so
get
repo
of
resources
with
customizations.
Describing
your
variants
is
a
simple,
powerful
way
to
manage
shared
configuration
patching,
so
here's
where
I
would
normally
do
a
demo
of
something,
but
this
stuff
is
just
too
boring
to
demo.
So
I'm
not
going
to
do
that.
I
would
just
have
a
mole
coming
out
to
standard
out.
A
Nobody
wants
to
see
that
there's
a
lot
of
examples
on
our
git
repo
site
that
are
part
of
it
that
are
tested
as
part
of
our
end-to-end
and
I
know
they
work,
I
hate
it
when
I
go
somewhere
and
the
examples
don't
work.
So
these
work
talk
is
almost
over
I
just
want
to
mention
a
couple
of
things
about
the
philosophy
behind
this.
Why
we
decided
to
do
this.
The
design
goals
were
make
some
things
composable
make
it
compact
in
Cooper
ninties
style,
so
the
actual
customization
Fowler's
could
be
used
as
a
resource.
A
We
wanted
to
work
really
well
with
git
and
we
wanted
to
be
simple
composable.
That
means
we
want
it
to
be.
Work
in
pipes,
be
work
with
plain
text.
Do
one
thing
and
do
it
well
and
you
know,
send
any
errors
to
standard
error,
and
just
if
there's
no
input,
there
should
be
no
output.
This
guy
here
on
the
left,
is
Doug
McIlroy
I
like
to
imagine
that
he
gave
that
beer
to
Ken
Thompson
to
get
him
to
put
pipes
into
Unix.
A
We
want
this
thing
to
work
with
pipes,
so
he
was
kind
of
our
patron
saint
community
style
means
we
want
to
understand
how
to
patch.
We
want
to
know
how
to
patch
raw
resource
files.
We
want
to
be
able
to
work
with
CDs.
We
want
it
to
be
extensible.
We're
gonna
target
cout
cuddle,
apply,
cool
apply,
is
the
main
API
for
kubernetes
and
we're
gonna
use
patch
concepts
they
already
familiar
with
them.
A
We
want
it
to
be
simple,
so
there's
no
templating,
there
is
no
new
language
to
learn
that
doesn't
have
any
unit
testing
or
has
no
idea
for
you
to
use,
there's
no
unintentional
API
and
so
there's
nothing
layered.
On
top
of
the
community's
resources,
they're
just
broad
resources,
that's
what
you're
working
with
and
you
know,
there's
no
forced
notion
of
a
package
or
application.
A
So
these
are
examples
of
what
we're
not
doing.
This
is
a
template.
That's
a
Lua
script.
The
thing
on
the
left
is
board
config,
stuff
that
we
use
inside
Google
and
all
of
those
things
are
difficult
to
maintain
because
they
have
logic
in
them.
Templates
have
logic
in
them
and
when
you
make
changes
to
them,
you
have
to
merge.
A
Okay.
So,
coming
soon
in
Co,
cuddle,
1.13
Cooper
Nate
is
1.13.
We're
going
to
have
customization
integrated
into
coop
cuddle,
which
was
always
the
plan.
It
closed,
coop
cuddle
bugs
that's
why
we
wrote
it
and
when
that
happens,
when
you
type
cout
cuddle
apply
on
a
directory.
If
there's
a
customization
file
present,
it
will
honor
that
if
there
is
no
customization
file,
present
it'll
just
do
what
it
always
did.
A
A
So
thanks,
thanks
to
all
the
contributors
that
are
actually
working
on
customize
and
replicate,
is
a
company
in
in
the
u.s.
that
made
this
nice
website
and
customized
that
IO
to
help
people
learn
about
customized
SIG's
CLI
sponsored
the
work
here
and
Brian
grant,
wouldn't
call
him
out.
He
wrote
this
nice
document
called
declarative
application
management
and
that's
kind
of
the
foundational
document
for
this
work.
The
inspiration.
A
This
is
the
variables
right,
the
variables
okay,
so
that's
a
situation
where
you're
you're,
generating
that
particular
case
was
WordPress,
depends
on
my
sequel
and
in
the
command
line
and
the
deployment
for
running
WordPress.
You
have
to
tell
it
on
the
command
line
where
WordPress
is,
and
that
may
involve
using
the
name
of
the
kubernetes
object,
the
name
of
the
service
right.
So
you
need
to
go
in
find
that
name
in
the
in
the
resource
in
the
in
the
service.
In
this
case,
and
then
stick
it
there
on
the
command
line.
B
C
D
A
A
Should
just
work?
Yes,
oh
and
except
in
this
case,
because
in
this
particular
case
we
have
arguments
on
the
container
image
the
command
that
you're
running.
We
don't
know
what
that
format
is.
It
could
be
anything
right,
it
could
be
a
coral
blah
blah.
You
know,
and
then
some
name
customize
can't
understand
the
structure
of
that
command.
So
we
can't
patch
it
really
so.
B
E
A
You're
speaking
about
the
config
map
generation,
so
the
config
Maps
get
generated
from
data.
That's
on
disk,
like
an
environment
file.
This
is
one
of
the
bugs
that
we're
closing
actually
one
of
the
issues.
That
was
one
of
the
features
that
was
requested.
So
you
can
just
generate
the
config
map
on
the
fly.
Now,
if
you
edit,
a
config
map,
you've
changed
the
constants,
the
config
map,
and
you
don't
change
the
name,
and
you
push
that
config
mint
out
to
production
the
deployments
not
going
to
read
it.
A
It's
not
going
to
know
that
the
values
inside
the
config
map
have
changed
best
practice
says:
modify,
create
a
new
config
map
with
a
new
name.
Then
tell
your
deployment
edit,
your
deployment
Patrick
to
point
at
that
new
config
map
with
a
new
name
that
will
trigger
a
rollout
right
and
and
it'll
capture.
The
the
old
replica
set
will
start
fading
away
and
the
new
replica
set
will
look
at
that
new
config
map
with
a
new
name.
The
hash
is
there
too.
F
Hello,
I
have
a
two
question.
First
days,
I
only
sees
a
modification
in
your
example,
so
sometimes
I
may
need
to
add
some
add
or
remove
some.
We
saw
our
parameter
in
my
deeper
memo,
so
I'm
not
sure
can
just
to
help
me
to
add
some
ID
all
removed
some
parameter
to
murdered
to
our
to
our
deployment
llamo
and
what.
A
F
A
So
the
question
is
about
name
conflicts.
If,
when
you
run
customize
build
it's
not
always
going
to
work,
sometimes
you
make
it
a
name
conflict
and
it
will
fail.
So
it
checks
in
kubernetes.
All
the
objects
have
to
have
a
unique
group
version,
kind
name,
and
so
that's
verified
before
the
output
is
generated,
so
you're
safe.
It's.
F
C
Thank
you
for
presentation.
I
saw
a
pain
in
your
person.
She
that
sees
you,
you
use
calico
to
right
Department,
and
it
is
exactly
what
I'm
doing
now
after
I.
Listen
to
your
talk,
I'm
thinking,
it
is
possible
to
in
my
program
or
coda,
to
use
your
customized
to
generate
Yama
to
northern
use
command
line.
A
A
So
what
it
does
it
customized
weeds
in
llamo?
The
only
llamo
that
it
generates
from
scratch
is
for
at
the
moment,
is
for
secrets
and
config
Maps
and
takes
raw
data
and
will
roll
that
up
into
a
secret
or
a
config
map
for
you,
and
then
it
emits
yamo.
So
it
has
to
start
with
the
ammo
and
it
patches
that
llamo
and
then
spits
it
out
to
standard
out.
Yes,.
A
You
can
provide
the
base,
yes,
that's
the
X,
but
that's
the
expectation
you
provide
raw
ammo
or
somebody
else
does
and
then
you're
only
adding
rules
to
how
you
want
to
modify
it
to
your
for
your
own
purposes,
because
and
the
reason
you
want
to
have
that
in
a
separate
file.
This
customization
file
is
because
you
don't
want
to
edit
the
source
material,
because
you
do
you
occasionally
want
to
rebase
and
capture
new
source
material.
C
D
A
A
Okay,
so
helm.
What
does
home
do
helm?
Has
a
template
command
to
generate
yamo,
customized,
reads:
llamo
and
write
CMO,
so
just
use
home
template
to
take
your
chart,
squeeze
all
the
go
template
stuff
and
the
values
out
of
it
emit
pure
llamo,
and
they
can
use
a
customization
file
to
then
modify
that
that
llamo,
you
you
you.
G
A
Don't
know
I'm
sure
people
are
gonna
continue
to
use
home.
This
is
just
an
alternative.
There's
not
always
one
answer,
there's
no
silver
bullet
to
anything
right.
This
provides
you
with
a
so
home,
takes
a
template
approach
and
values
and
helm
v3
is
going
to
introduce
the
possibility
doing
Lua
scripting
as
much
as
I
understand
it.
So
that's
one
way
to
manage
shared
configuration
right.
D
A
Way
to
manage
it,
the
customized
approach
is
to
do
patching
so
and
the
advantage
there
is
that
you're
you're
not
really
modifying
the
source
material,
and
you
can
apply
these
layers
of
patching
to
help.
You
manage
your
different
environments.
So,
from
the
beginning,
we
thought
about.
How
are
you
going
to
manage
multiple
environments?
Multiple
variations
right,
that's
a
little
bit
trickier
with
home.
G
I
was
thinking
about
that.
Here's
a
situation
if
we
have
a
application
with
a
deployment
llamo
and
we
might
add
a
parameter
like
my
SoCo
endpoint
right
when
we
edit
the
other
custom
lights,
yamo
won't
know
we
were
at
a
Mexican
point,
so
they
will
use
it
in
every
environment
and
they
they
won't
know
it
if
the
original
for
sure
tell
them
by
person
right
so.
A
G
A
G
In
some
situations
they
might,
but
just
I
was
thinking
that
with
him,
when
we
have
a
template
and
the
we
should
write
a
value
term
value,
llamo
rank
and
when
well
llamo
miss
some
miss
some
variables.
They
were
warning
you
that,
like
I,
read
a
template
with
my
security
and
point,
but
but
if
you
thought,
write
a
variable
like
mr.
A
A
Name,
references
aren't
going
to
hook
up
these
linting
things
can
always
get
better.
You
you
want
the
the
ammo,
that's
spit
out
to
be
correct
and,
of
course
that's
what
we
aspire
to
and
and
we
can
always
use
people
that
are
improving
our
linting
code.
Okay,
I
think
we're
out
of
time.
Thank
you
very
much.