►
From YouTube: Commit Brooklyn 2019: Creating a CI/CD Pipeline with GitLab and Kubernetes in 20 Minutes
Description
GitLab and Kubernetes provide everything you need to build, test, deploy, and run your app at scale. In this session you'll learn how to transform a fresh Kubernetes cluster into a CI/CD bastion for your GitLab projects in 20 minutes starting from scratch through live demo.
Speaker:
Eddie Zaneski, Manager, Developer Relations at Digital Ocean
A
Going
everyone,
my
name
is
Eddie's
an
esky
and
I
serve
the
developer
community
at
a
company
called
digital
ocean.
You
can
find
me
on
the
Internet
at
anything.
That's
also
my
email.
If
you
want
to
reach
me
today,
I'm
actually
here
to
talk
about
my
brand
new
startup
I'd
like
to
introduce
everyone
to
a
screaming
chicken
dot,
Club,
and
so
my
co-founder
and
I
aren't
really
sure
you
know
what
our
monetization
plan
is
or,
frankly,
what
we're
doing
at
all,
we
just
kind
of
winging
this
hahahahaha
winging
it.
A
It
I'll
try
it
again.
It
makes
a
really
awesome
rubber
chicken
sound
right,
so
you
click
the
chicken
head.
You
get
a
rubber
chicken,
sound
yeah,
so
that
that
is
what
the
V
C's
are
gonna
care
about.
Is
our
cool
little
features
there?
The
other
thing
the
VCS
are
going
to
care
about
is
the
technology
of
their
application
is
built-in,
and
so
that
is
why
we've
chosen
to
build
our
application
and
react
j/s,
which
is
the
greatest
javascript
framework
of
all
time.
A
Don't
at
me,
and
so
you
know
I'm
trying
to
raise
money
right
now
and
these
things
are
caring
about
my
tech,
an
easy
way
to
score
cred
with
VCS
about
having
a
super,
secure
and
well-thought-out
DevOps
pipeline,
and
so
that's
where
gitlab
really
comes
into
play
here
and
so
I've
got
my
application
pushed
up
into
a
git
lab
a
project.
Here,
it's
just
a
very
brink
blank
project
with
just
initial
commit
in
there.
A
I
got
to
get
that
VC
money
and
so
I
need
to
set
this
up
with
a
end
to
end
a
CI
CD
pipeline
to
really
land
that
VC
cred,
so
gala
actually
makes
this
super
easy.
And
so,
if
you
take
a
look
at
this
part
top
right
here,
you'll
see
a
reference
to
auto
dev,
ops.
I
think
see
it
mentioned
earlier.
How
many
people
are
using
auto
dev
ops
wow,
you
guys
are
in
for
a
treat.
A
You
got
to
check
this
out,
so
Auto
dev,
ops,
abstracts
away
all
the
complex
bits
and
pieces
of
putting
together
a
CI
CD
pipeline
building
your
application
into
a
container
checking
it
for
vulnerabilities,
checking
it
for
dependencies
checking
it
for
licenses,
deploying
that
to
a
kubernetes
cluster,
setting
up
host
names,
DNS
TLS,
certs
automatically
renewing
them
for
you
and
doing
performance,
testing
and
Sid
mentioned
earlier.
They're
gonna
be
do
load,
load
testing
and
a
bunch
of
really
cool
stuff
right.
A
So
all
this
is
bundled
into
a
very
simple
git
push
you
don't
actually
have
to
configure
it
really
just
push
it
up,
turn
it
on
and
it
works
out
of
the
box
magically.
There's
a
few
little
caveats
there
you
have
to
like:
have
your
application
buy
into
port
5,000,
though
that's
all
configurable,
if
you
want,
and
so
what
I've
realized,
while
working
with
CIC
a
lot
is
that
these
pipelines
are
really
just
like
a
bunch
of
janky
shell
scripts,
grouped
together
nicely
right.
A
A
If
you
don't
have
one
or
pick
one
from
a
list
that
shows
up
works
really
well,
if
you're,
using
a
different
cloud
provider
or
if
you're,
using
an
on-prem
solution,
you're
not
left
out
at
all,
there's
a
way
to
add
an
existing
cluster
here.
So
I'm
gonna
work
with
a
digital
oceans
manage
kubernetes
service
and
so
we'll
just
start
by
creating
a
cluster
real,
quick,
I'm
gonna
pick
a
datacenter.
A
Let's
pick
some
really
fat
notes
that
I'm
gonna
get
yelled
at
for
using
and
there
you
go
$960
a
mother,
that's
cool
and
I.
Just
like
that,
we
got
a
kubernetes
cluster
provisioning
as
to
probably
take
around
like
three
to
five
minutes.
So
I'm,
just
gonna
fill
a
little
cooking
show
and
use
one
that
I.
You
know
baked
a
little
earlier
today
and
so
I've
got
that
configured
and
pulled
down
with
the
cube
config
here
and
to
get
this
integrated
into
my
project.
I
just
have
to
fill
out
a
couple.
A
Your
strings
in
here
right,
so
I
gotta
grab
the
API
server
URL
of
my
kubernetes
api
server.
I
got
to
grab
my
cluster
CA
cert
I
have
to
create
a
service
account
buying
that
to
a
cluster
role,
binding
of
a
cluster
admin
and
then
grab
the
service.
Token.
That's
generated
right
so
that
that's
a
lot
of
stuff
to
do
by
hand.
A
I
got
really
tired
of
doing
that
over
and
over
again,
while
rehearsing
this
so
I
built
a
pretty
nifty
little
cube
control
plug-in
that
everyone
should
go
check
out
it's
on
like
a
lab
page
here,
and
so
this
is
actually
going
to
automatically
boot.
Strap
a
kubernetes
cluster
into
your
git
lab
project,
create
all
the
service
account,
make
all
the
gitlab
API
requests
and
take
care
of
everything
under
the
hood.
So
let's
get
started
using
that,
so
we
have
to
come
back
here.
A
All
we
have
to
do
is
grab
our
project
ID
for
get
lab
project,
so
I'm
gonna
copy
that
and
then
I
can
run
cube
control,
get
lab,
bootstrap
and
paste
in
that
project.
Id
I
have
the
get
lab
API
token
configured
an
environment
variable,
so
you
all
can't
hack
my
account,
and
it's
done
so.
It's
done
everything
I
just
have
to
go
to
this
little
URL
and
follow
up
here
yeah,
and
this
is
actually
get
labs.
A
Building
an
API
to
control
all
this,
so
it'll
take
care
of
that
eventually,
and
so
I'm
gonna
click
a
couple
buttons
here.
Anyone
who's
using
kubernetes
right
now,
a
couple
folks,
who's
using
helm,
yep
same
amount
of
folks
cool,
and
so,
if
you're
not
familiar
with
what
helm
is
it's
a
package
manager
for
kubernetes?
It
works
with
a
concept
called
charts,
which
is
basically
a
package
that
you
know
a
templated
yamo
file
that
gets
sub
studio
and
plugged
in,
and
so
the
first
step.
A
All
we
have
to
do
is
install
the
server
side
component
of
helm
called
tiller.
This
is
actually
going
away
in
the
next
version
of
helm,
so
you
don't
need
anything
running
in
your
cluster,
but
so
after
we
install
tiller,
we
can
go
through
and
then
get
lab
provides
us
a
bunch
of
awesome
applications
that
we
can
also
install
it's
one
click,
so
I've
started
off
the
process
of
installing
two
of
them.
The
first
is
the
ingress
controller.
A
This
is
gonna,
make
it
real
easy
for
us
to
configure
those
DNS
routes
and
hostname
routes,
it'll
math
everything
and
basically
do
all
the
routing
into
my
cluster
works.
Really
well.
It
spins
up
a
load
balancer
behind
the
scenes,
so
we'll
grab
that
IP
in
a
second
and
then
the
next
thing
I
installed
is
the
cert
manager.
This
is
an
awesome
project
by
the
folks
at
jet
stack.
It
works
with,
let's
encrypt
and
a
bunch
of
other
things,
to
take
care
of
the
TLS
search.
So
this
will
automatically
provision
them
for
me.
A
Rotate
them
update
them.
Renew
them
right,
so
get
labs
going
to
leverage
the
two
of
these
in
our
auto
dev
ops
pipeline,
a
couple
other
cool
ones,
the
Prometheus
exporter.
So
you
get
some
metrics
out
of
your
cluster
right
in
your
dashboard
here
and
then,
of
course,
the
the
awesome
get
lab
runner.
Anyone
using
runners
right
now,
yeah
if
you
haven't
worked
with
the
runner
before
it's
like
super
well
done,
it's
real
easy
to
get
started
with,
and
it's
like
really
fast.
A
When
you
put
it
on
your
own
hardware,
so
you
should
absolutely
check
out
the
runner.
If
you're
not
familiar
it
lets
you
run
your
CI
CD
builds
on
your
own
host
or
whatever
you
want
to
do.
You
can
run
them
inside
your
own
kubernetes
cluster,
which
is
really
cool,
so
we'll
just
wait
for
the
fluid
balancer
to
spin
up
might
take
another
minute
or
so,
but
let's
get
started
writing
our
manifest
file
here.
A
So,
like
I
said
you
can
just
use
the
auto
DevOps
out-of-the-box
fit
showed
all
of
those
I
think
it's
like
ten
or
twelve
different
features
and
parts
of
Auto
DevOps
right
now.
The
great
thing
about
get
lab
being
open
source
is
nothing
is
magic
right.
All
this
stuff
is
source
code
that
we
can
all
go,
look
up
and
read.
So
this
is
the
it
might
be
really
hard
to
read.
I'm
sorry,
this
is
the
manifest
file
for
Auto
DevOps
right.
So
this
is
what's
gonna
be
used
by
default.
A
When
you
turn
on
auto
dev
ops,
it's
a
bunch
of
imported
other,
manifest
files,
a
couple
declared
stages
here
if
you're
not
familiar
with
stages.
These
are
like
your
steps
to
your
jobs
and
your
CI
City
pipeline,
and
then
here
are
all
the
pieces
of
auto
dev
ops
that
are
configured
they're,
all
linked
out
to
write
so
they're,
all
individual
templates
and
components
that
we
can
pull
into
ours
that
we
want
to
use
so
I'm
gonna
grab
two
of
these
because
the
other
ones
are
gonna.
A
They
take
a
little
longer
to
run
so
we're
just
gonna
grab
the
build
and
the
deploy
ones,
and
so
switching
back
to
my
terminal.
Let's
create
that
file,
so
we
need
to
get
labs
CI
mo
file
I'm
going
to
do
a
little
snippet
here.
So
these
are
all
the
stages
that
those
templates
reference
and
you
just
have
to
declare
them
because
the
templates
reference
them
and
so
then,
to
type
out
our
imports.
We
just
use
this
little
include
block
here
and
then
we
can
include
a
template.
A
This
is
an
array
and
we
got
to
grab
the
jobs
and
the
build
dot,
get
lab
CI
that
yeah
mo
and
then
the
deploy
one
right.
So
these
are
actually
included
in
every
deploy
of
gate
lab,
so
you
don't
have
to
import
them
or
anything.
They
just
come
with
your
Gil
AB
install
even
if
you're
running
on
from
so
cool.
So
that's
it.
So
that
is
my
full
DevOps
pipeline.
Very
simple,
straightforward
I
didn't
need
to
write
this,
but
again,
I
only
want
to
use
those
two
pieces
there.
A
Cool
I
got
that
I'm
just
going
to
configure
DNS
to
point
at
that,
so
I'm
gonna
use
this
k-8.
That's
creamy
chicken,
dot,
Club
DNS
here
update
these
records
cool
and
then
I
just
have
to
declare
a
base
URL
inside
of
my
cluster
configure.
So
this
is
what
gate
Labs
going
to
use
for
the
ingress
controller,
and
that's
it
so
now.
I
can
push
this
up.
A
A
So
the
first
step
to
build
step,
it's
going
to
take
care
of
a
lot
of
stuff
behind
the
hood
for
us.
It's
gonna
use
a
pretty
cool
service
called
docker
and
docker
that
lets
you
build
docker
containers
inside
of
docker
yo
dog
and
the
first
thing
it's
gonna
do.
Is
it's
gonna
log
into
our
cluster
reg,
our
container
registry
for
us
so
get
lab
or
automatically
provides
you
a
container
registry
for
your
project.
A
It's
gonna
substitute
in
a
whole
bunch
of
environment
variables
and
handle
all
the
log
in
and
generate
like
the
token
and
all
that,
so
we
don't
actually
have
to
think
about
anything
and
then,
after
that's
done,
it's
gonna
pull
down
my
base
image
I
have
a
docker
file
to
find
in
my
project.
Here
it's
just
a
very
simple
goaling
app
that
has
a
static,
folder
voltage
stage.
Rocker
build
very
straightforward.
If
you
not
familiar
with
docker
and
you
don't
have
like
a
complex
setup,
you
can
you
don't
even
have
to
write
this.
A
The
gitlab
build
a
component
will
figure
out
what
kind
of
project
you're
running
using
like
Heroku
build
packs,
and
it
will
generate
you
a
docker
file
with
best
practices
and
build
your
container
for
you.
So
again,
you
don't
have
to
know
anything
about
how
this
works.
So
my
project
is
building
compiling,
pushing
up
my
layers
to
the
container
registry
and
then
my
build
job
should
finish
real,
quick
and
then
my.
A
Deployment,
and
so
this
is
going
to
spin
up
the
deploy
job,
it's
gonna
pull
down
a
Helms
art
that
has
a
bunch
of
same
can
defaults
in
there.
It's
gonna
template
in
with
my
container
ID
my
host
name
names
face
all
that
jazz
get
lab,
injects
all
the
environment
variables,
don't
have
to
do
anything
and
then
it's
gonna
deploy
it.
It's
gonna
create
a
ingress,
so
it'll
be
my
like
the
default
one.
A
It's
gonna
be
like
Eddie
vein,
screaming
chicken
club
and
then
like
the
project,
ID
page
that
shark
codes
so
yeah,
it's
just
really
smart
and
so
I
guess
I
guess
my
job
is
done.
You
know
this
is
this
is
deploying
we
just
gotta
wait
for
the
rollout
to
finish
and
let's
see,
I'm
gonna
copy
that
open
in
tab
here.
So
we
gotta
wait
for
the
cert
manager
takes
a
little
time
to
rotate
the
cert
out.
So
it'll
take
probably
like
two
or
three
minutes
actually
provision
this
POS
cert.
A
So
we'll
skip
the
scary
warning
for
now.
I
got
my
app
deployed
right,
and
so
you
see
the
host
names
configured.
Everything
worked,
I
don't
have
to
do
any
of
that
real
simple.
It's
been
about,
probably
like
eight
or
nine
minutes
for
me
talking
through
that,
but
you
could
get
this
done
and
like
under
to
probably
and
so
cool,
so
I'm
gonna
go
slack
off
now
and
I'm
gonna
read
some
hacker
news,
because
that's
what
I
like
to
do
when
I'm,
you
know
done
what's
work.
So,
let's,
let's
see
what's
going
on,
we
got
we.
A
What
is
this
trash
fire?
J
s,
a
brand
new
JavaScript
framework?
That's
way
better
than
react.
Oh
my
god!
This
is
three
seconds
old
and
we
all
know
what
I
need
to
do
right.
I
need
to
immediately
roll
this
out
to
production.
So
let's
do
that.
Let's
rewrite
my
entire
application
using
trash
fire
J
s,
which
obviously
is
the
latest
and
greatest
JavaScript
framework.
So
I've
got
another
project
set
up
here.
A
This
is
deployed
to
a
nother
kubernetes
cluster,
so
everything
we
just
walked
through
is
set
up
and
done.
I
have
what
do?
I
have
I
have
a
a
gitlab
file
here
for
a
manifest
and
this
so
instead
of
using
Auto
dev
ops
I'm
going
to
show
you
how
to
write
out
your
own
pipeline
real
quick,
it's
not
much
more
work,
it's
gonna
be
very
straightforward
stuff
here,
so
we
I
have
two
stages
defined
up
here:
build
and
deploy.
So
let's,
let's
define
the
build
one.
A
It's
just
gonna
look
like
this,
so
you
can
arbitrary
name
it
whatever
you
want
and
then
tie
it
to
a
stage
up
there
and
then
I
have
to
declare
the
image
so
I'm
gonna
use
the
docker
latest
image
and
then
I
need
to
define
some
services.
These
are
just
kind
of
like
sidecars
and
I
want
the
docker
a
doctor
and
docker
again
yo
dog
service,
and
then
you
know
it's
just
like
complete
the
rest
of
this
right.
A
So
I'm,
gonna
log
into
my
docker
registry
environment
variables
are
injected
I'm
gonna
build
up,
docker,
billdocker,
Porsche
Rio,
that's
taken
care
of
cool
and
then
the
last
thing.
I'm
gonna
have
a
simple
deploy
job
here.
Let's
look
at
that
one.
This
is
gonna
use.
A
very
simple,
like
you,
cube,
control,
manifest
shooter
here,
I'm
gonna
run
through
it's
gonna
use
a
cool
tool
called
M.
Subs
I'll
show
you
how
that
works
in
a
second
and
that's
it.
So
this
is
gonna
deploy
to
my
kubernetes
cluster.
So
let's
add
that
in.
A
Alright,
so
push
that
up
get
a
kick
off
another
bill.
I'll
show
you
what
that
manifests.
Look
like
so
and
substance,
a
really
cool
to
anyone
used
it
before
you
might
see
in
a
bunch
of
CI
CD
tutorials
out
there.
It
basically
takes
your
environment
variables
and
a
standard
input
stream
or
a
file,
and
it
just
substitutes
them
and
writes
to
standard
out.
So
all
I
have
to
do
is
call
em
subs
in
pipe
in
this
file
and
these
two
lines
right
here.
This
just
gets
substituted
with
the
environment
variable
and
that's
it.
A
So
this
is
going
to
plug
in
my
brand
new
image.
That's
built
real,
simple,
real
rudimentary,
but
like
really
powerful,
so
check
out
subs,
instead
of
like
trying
to
figure
out
how
to
write
a
bunch
of
templates
and
that's
it,
and
so
it's
got
a
service
in
a
deployment.
So,
if
we
flip
back
over
to
my
project,
we
can
see
my
pipelines
in
progress.
You
know
what,
let's,
let's
pull
up
hacker
news
to
get
that
side-by-side?
There's
some
pretty
good
headlines
here!
Go
releases!
Generics
I,
never
thought
that
would
happen.
A
All
the
Googlers
are
laughing
cool.
So
this
is
this
built
and
let's
look
at
the
deploy.
Oh
deploys
done
already.
So
I
took
a
minute
in
four
seconds.
So
I've
got
my
app
deployed.
There's
trash
fire,
je
s,
that's
really
cool
the
latest
and
greatest
JavaScript
framework.
You
know
maybe
fast
forward,
I,
don't
know
what
do
you
give
it
like
two
days
before
I
realized
I
made
a
grave
mistake
and
everything's
broken
and
they
find
a
terrible
bug
inside
trash
fire
Jay
s.
A
A
I
can
just
come
back
to
my
deploy
job,
and
you
know
maybe
I
just
want
to
rerun
this
and
that's
it.
I
have
a
rollback
started.
This
will
probably
take
like
20-30
seconds
and
it's
gonna
roll
back
from
my
grave
mistake
of
investing
in
brand-new
javascript
technology
to
using
the
stain
and
stable
trusted
react
AAS,
which
is
still
the
greatest
JavaScript
framework
of
all
time
and
don't
at
me,
I
just
started
saying
that
there
you
go
so
it's
refreshed
and
we
go
back
right.
A
So
we've
rolled
back
right,
so
very
simple,
very
straightforward,
I've
shown
you
two
ways
to
do:
a
DevOps
pipeline
with
gitlab
the
first
using
auto
devops,
very
awesome,
very
straightforward:
again,
you
don't
have
to
pull
in
those
components,
but
it's
worth
reading
through
the
again
all
open
source
is
amazing.
All
this
is
documented
and
well-defined
here
so
check
out
all
the
components
you
can
pull
in.
If
you
don't
want
to
use
everything,
you
can
also
disable
a
bunch
of
these
with
environment
variables.
So
you
don't
have
to
write
your
own
manifest.
A
You
can
just
add
some
environment
variables
to
your
project
that
will
disable
them,
and
this
is
definitely
headed
in
the
right
direction.
Like
your
lab,
is
you
know,
they're
really
looking
at
getting
people
to
adopt
these
practices
without
having
to
write
a
bunch
of
llamó,
because
if
you're
doing
kubernetes
you're
already
writing
a
tunnel,
you
don't
want
to
write
a
bunch
of
animals.
For
you,
see,
I,
see
a
lot
of
heads
nodding,
yeah.
So,
just
like
check
out
the
docs
bind
to
port
5000
that
that's
really
the
only
requirement
there.