►
From YouTube: Ops Section Product Walk-Through
Description
Video showcasing some already setup GitLab Ops section features including Kubernetes cluster integration, Auto DevOps, Serverless, Metrics, Pod Logs, Error Tracking and Incident Management.
Additional Ops Section Walk Through Videos:
- Incident Management - https://www.youtube.com/watch?v=10nJb0wzJZM
- GitLab Serverless and ChatOps - https://www.youtube.com/watch?v=Szep4s9kOzs
- Serverless Setup - https://www.youtube.com/watch?v=eP-FPltlR8Q
- GKE Cluster Add and Auto DevOps Setup - https://www.youtube.com/watch?v=GY_XPZiQ6xU
- Error Tracking - https://www.youtube.com/watch?v=y5Bjp2wHXc0&list=PL05JrBw4t0KrX8KzwxOo7axo_PRJ89vO6&index=3&t=0s
- Auto DevOps Setup and Usage - https://www.youtube.com/watch?v=V4NX2j2HQAs&list=PL05JrBw4t0KrX8KzwxOo7axo_PRJ89vO6&index=2&t=0s
A
Hello,
my
name
is
Kenny
Johnson
and
the
director
of
product,
covering
the
ops
section
here
at
gate,
lab
I
wanted
to
record
a
quick
walkthrough
of
some
of
the
ops
section
features
that
we
have
available
today.
This
is
for
the
12.7
released
I'll,
be
largely
using
gitlab
comm
for
my
example
walkthroughs.
So
this
is
live
on
available
features
on
get
lab.
I
want
to
be
walking
through
a
couple
of
different
projects
that
are
already
configured.
A
Many
of
my
co-workers
have
already
recorded
demos
for
how
to
configure
some
of
the
things
that
I'm
going
to
be
showcasing.
This
is
an
example
of
places
where
they're
already
set
up
and
how
you
would
interact
with
them
once
you've
set
up
things
like
our
Auto
dev,
ops
features,
serverless
functions,
incident
management,
metrics,
dashboards,
integration
with
sentry
and
error,
tracking
I'll
showcase,
a
number
of
those
and
then,
as
I
said,
there
are
other
videos
where
we
can
highlight
how
you
actually
would
set
them
up.
Let
me
start
by
showing
my
screen.
A
A
All
right
so
I'm
going
to
start
with
I'm
going
to
show
three
different
projects
through
the
course
of
this.
Actually
one
group
into
projects.
The
first
is:
this
can
see
Johnson
apps
group,
which
is
a
group
that
I've
set
up
that
has
a
couple
of
test
projects
that
I
routinely
use
to
highlight
our
features
and
test
our
features
when
new
functionality
is
available.
A
The
other
one
is
this:
pijamas
design
system,
which
is
a
production
application
that
get
web
uses
to
host
our
design,
get
lab
comm
it
uses
auto
dev
ops
has
much
of
the
monitoring
capability
already
installed,
and
then,
lastly,
this
tanuki
Inc
project.
That
is
what
our
monitored
engineering
team
and
development
team
specifically
uses
to
test
out
new
features
and
showcase
the
ops
features,
so
I
will
be
walking
through
various
components
of
these
I'll.
Try
to
make
sure
I
give
context
when
you're
switching
from
one
to
another.
A
Let's
start
with
this
group-
and
this
will
be
the
book
of
the
the
showcase
usage
that
I
show.
The
first
thing
I
wanted
to
show
is
that
this
is
a
group,
and
one
of
the
great
features
of
get
lab
is
that
you
can
not
just
attach
a
coup.
Ladies
cluster,
in
order
to
run
your
CI
and
deploy
your
application
to
or
multiple
applications
to
in
a
specific
project.
You
can
also
attach
it
at
a
group
level,
and
so
this
is
an
instance
where
there
is
an
attached
kubernetes
cluster
to
this
project.
A
You
can
see
it
here
and
that
cluster
actually
is
where
all
of
the
applications
are
deployed
within
this
group.
So
you
can
see
when
I
have
previously
added
this
cluster
using
get
labs
built
in
add
a
cluster
functionality.
I'll
show
you
that
here,
real
quick
if
I
wanted
to
add
an
additional
cluster.
Let's
say
this:
the
existing
one
was
going
to
become
my
staging
and
development,
cluster
and
I
wanted
to
add
a
production
cluster.
A
So
that
will
allow
you
to
add
something
like
a
openshift
or
any
other
generic
kubernetes
cluster,
where
you
could
get
these
credentials
from
it,
you
can
attach
to
to
get
lab
and
get
that
will
facilitate
the
deployment
of
your
applications
to
that
cluster.
Let's
go
back
to
the
cluster
that
is
attached.
A
So
here
you
can
see
I
at
a
base
domain,
which
means
any
new
app
that
I
deploy
automatically
has
a
URL.
That
is
a
domain
that
I
own.
You
can
immediately
see
some
high-level
overview
of
the
cluster
health,
including
the
memory
and
CPU
usage.
This
is
the
application
give
that
managed
application
menu
where
you
can
install
various
applications
that
help
you
in
the
operation
of
your
applications.
A
So
those
include
things
like
ingress
Prometheus,
which
gave
us
metrics
I,
installed
key
native
in
order
to
use
our
service
functionality
and
Jupiter
hub
in
order
to
showcase
our
notebooks
capability,
the
ability
to
create
and
store
Jupiter
hub
notebooks,
which
are
useful.
We
use
them
also
for
run
books
in
order
to
have
executable
code
that
you
can
run
against
your
cluster
or
other
infrastructure
also
get
some
other
things
that
I've
done
here.
One
interesting
thing
that
we've
added
recently
is
this
ability
to
have
a
separate
project
to
manage
your
cluster.
A
So
I'll
showcase
this
in
a
little
while
but
I've
attached.
Another
a
project
within
this
group
called
infrastructure
to
manage
the
cluster
and,
in
this
case
mostly
gonna,
be
managing
the
cluster
configuration.
What
apps
are
installed
in
the
specific
configuration
of
those
apps
and
I
can
also
clear
the
cluster
cache
and
remove
the
kubernetes
integration
and
we've
recently
added
the
ability
to
when
you
remove
this
integration,
you
can
remove
it
and
remove.
A
It
means
kind
of
detach
it
from
get
labs
per
view
of
knowing
all
the
the
credentials
on
how
to
interact
and
what
applications
are
installed,
but
you
can
also
have
it
remove
any
resources
that
give
up
has
installed,
so
all
those
managed,
apps
or
other
name
spaces
or
deployments
that
give
up
has
performed.
You
can
have
it
kind
of
clear
the
cluster
of
anything
that
you
lab
has
added
to
it.
A
Okay,
one
other
thing
that
you
can
see
here
is
that
because
it's
a
group
level,
cluster
I
have
this
environments
tab.
That
gives
me
a
view
of
all
the
different
environments
across
multiple
projects
that
are
in
use
on
this
cluster
and
how
many
pods
are
deployed
tells
me
total
number
of
pods,
and
this
is
a
we
can
have
a
better
experience
here
in
the
functions
example.
This
is
obviously
deploying
functions
that
scale
to
zero,
so
there
are
no
pods,
but
we
should
probably
highlight
that
functions
is
using
this
cluster
for
its
production
environment.
A
A
Okay,
so
that
was
an
example
of
a
cluster
wide
career.
Hazing
Gatien
I
want
to
show
you
one
of
the
specific
apps
that
I
can
highlight:
let's
start
with
service,
so
this
is
an
app
that
I
created
called
it.
Haikus
are
us
just
as
a
simple
example:
I
ran
this
maybe
five
minutes
ago,
so
it
might
be
a
cold.
This
is
going
to
call
some
service
functions
in
order
to
take
these
inputs
of
season
animal
action
and
fruit
and
create
a
haiku
out
of
it.
When
I
adjust
this.
A
It
might
take
a
minutes
to
cold
boot
that
so
this
is
creating.
In
the
background
we
use
key
native
and
it's
creating
containers
to
respond
to
this
request
live
because
they
were,
they
were
scaled
to
zero
when
it
ran
or
when
I
click.
This
and
then
so
now
it
responded
and
it
adjusted
this
to
walk.
I'll
show
you
exactly
how
I
built
this
function,
the
power
of
these
functions.
A
Actually,
the
power
of
these
functions
are
that
it
was
very
it's
very
easy
to
enable
your
developers
to
quickly
create
functions
and
get
them
deployed
without
a
bunch
of
the
overhead
of
managing
a
kind
of
true
functions
service.
In
this
case
we
use
underlying
K
native.
So
let
me
show
you
the
functions
here.
A
This
is
the
functions
app,
that's
deploying
the
functions
in
in
it
I.
First,
let's
let
me
show
you.
This
is
a
file
that
defines
the
functions
so
I
have
three
functions.
You
can
see
them
all
listed,
echo
flip
and
haiku.
It
have
descriptions
and
whatnot
runtime
they
use
and
where
you
can
find
the
source
for
them.
I'll
quickly,
show
you
flip
or
echo.
There
are
very
simple
functions
that
do
exactly
what
their
titles
are.
So
in
flip
it
just
reverses
any
string.
A
A
It
calls
two
separate
functions
here
itself,
so
this
function
receives
input
and
then
cause
two
separate
functions
to
get
different
input
and
then
compiles
them
together
for
a
response
you
in
creating
these
I
wrote
the
simple
J
out
the
JavaScript,
and
then
I
wrote
the
serverless
kml
file
appropriately
and
then
get
lab
handled
the
rest
from
then
on.
The
that
functions
were
deployed
to
k
native
are
set
up
so
that
if
incoming
response
comes
for
that
endpoint,
that
container
will
be
booted
and
the
response
will
be
provided
based
on
the
function
that
was
defined.
A
A
I'll
adjust
that
just
want
to
invoke
it
a
couple
times,
so
we
can
see
the
invocations
chart
I'm
about
to
show
you
so
here
in
my
operations,
tab
I
have
a
service
option
and
it
shows
me
all
the
different
functions
that
are
defined
for
this
project.
Let's
look
at
this
one:
hi
queues.
It
tells
me
that
I
have
had
some
recent
invocations
just
now.
A
A
A
That
is
an
example
of
our
server
list
capability,
and
the
core
thing
is
that,
while
all
the
user
would
need
to
define
if
they
had
a
group
level
cluster
with
cainy
they've
installed,
and
they
could
create
new
projects
with
various
functions,
all
they
need
to
define.
Are
these
service
yellow
files
and
and
write
their
functions
in
simple
script,
and
then
they
can
easily
create
and
deliver
those
functions.
A
The
other
project
I
want
to
show
you
was
this
artisans.
So
this
is
an
application.
I'll
show
you
the
wide
version
of
it.
That
is
a
simple
Ruby
on
Rails
app.
It
has
the
ability
to
do
basic
crud
operations
on
this
object
called
artisans,
so
you
can
look
at
all
the
artisans.
You
can
create
a
new
artisan
there's
comments
on
existing
Artic
artisans.
A
There
is
also
the
ability
to
you,
random,
artisan,
so
all
of
that
functionality
we're
just
simple
Ruby
objects
that
I
or
Rails
objects
that
I
created.
What
I
wanted
to
showcase
is
that
this
project
is
was
actually
created
using
or
the
CI
CD.
The
deployment
of
it
is
done
with
what
we
call
auto
dev
ops.
A
So
I
wanted
to
quickly
showcase
a
recent
mr2,
this
project
that
had
that
say
that
that
showcases
that
pipeline.
So
this
is
a
merge
request
that
I
created
a
while
ago
that
yeah
it
has
been
merged,
so
I
won't
be
able
to
showcase
their
review
app
functionality,
but
you
can
look
at
the
pipeline
for
this
merge
request.
Well,
actually,
yeah
go
back
real,
quick!
Let
me
show
you
this
just
I
like
what
the
change
is,
changes
a
simple
text.
Adjustments
to
the
the
pipeline
that
has
created
automatically
for
this
merge
request
includes
building
it.
A
As
I
mentioned,
a
suite
of
tests,
including
SATs
and
penisy
scanning
and
container
scanning,
the
creation
of
a
review
app,
which
is
a
live
version
in
a
separate,
isolated
namespace
in
the
kubernetes
cluster
that
enables
the
person
who's
performing
the
merge
request
review
to
get
a
sense
of
the
live
functionality
of
the
test.
It
also
then
allows
us
to
do
which
is
dynamic.
Application
security
testing
against
out
live
app
to
test
the
security
of
the
application
more
robustly.
A
Everyone's
performance
tests
against
that
live,
review
app,
and
then
this
clean
up
it
was
actually
the
stopping
of
that
review
up
environment
the
so
this
is
this
all
comes
I
did
no
configuration.
If
you
look
at
my
project
repository
typically,
you
have
a
Gil
AB
CI
mo
file
here
that
defines
your
complex,
a
complex
pipeline
like
I,
just
showcased,
that
is
the
default
pipeline
that
auto
devops
provides
the
other
thing
that
you
get
when
you
use.
Other
DevOps
is
obviously
because
we're
deploying
to
a
communities
cluster,
that's
attached
to
get
lab.
A
We
know
a
lot
about
the
we
can
showcase.
What's
going
on
in
the
various
environments.
In
this
case,
there's
only
a
production
environment
I've
had
a
staging
environment
that
would
also
show
up
here.
It
also
shows
the
review
app
environments.
So,
as
I
mentioned
that
one
where
we
adjusted
the
application
title
is
still
running,
I
can
stop
those
environments,
the
review
up
environments,
if
they're
I
don't
think
these
have
Wi-Fi
requests.
I
can
easily
stop
those
review
up
environments.
I
can
also
look
at
my
production
environment.
A
The
other
thing
I
wanted
to
showcase
is
that
as
part
of
deploying
this
to
kubernetes
and
having
Prometheus
installed
at
that
group,
cluster
level,
I'm
kind
of
automatically
getting
access
to
metrics
charts,
so
I
can
create
my
own
dashboards.
But
this
is
the
production.
Environment.
I
could
select
different
environments
if
I
have
them
over
the
last
eight
hours,
and
it's
giving
me
these
a
response,
metrics
throughput
and
for
this
specific
application,
because
we're
using
ingress
and
it's
isolated
to
traffic.
For
this
application.
A
Remember
there
are
multiple
applications
hosted
on
this
specific
cluster,
and
then
it
also
gives
me
some
overall
system
metrics
from
kubernetes.
You
can
see
there's
a
little
bit
of
a
spike
I
see
if
I
go
back
a
couple
days.
I
want
to
showcase
that
another
cool
thing
about
this
and
it's
a
really
unique
about
give
app,
is
that
we
can
showcase
the
integrations
between
your
work
as
a
developer
to
creating
and
deploying
the
code
and
its
performance
in
production.
A
So
one
thing
you
would
typically
once
see
is
if
oh
there's
a
recent
spike
of
maybe
a
memory
usage
or
latency
or
error
rate.
You
might
check
to
see
if
there
was
a
recent
deployment.
So
those
deployments
show
up
here
if
I
hover
over
them
and
get
a
little
bit
of
a
issue,
because
they
there
you
go
the
metric
is
you
can
look
at
the
exact
commits
that
was
performed
here
and
what
happened?
A
So
if
there
was
an
issue,
you
could
quickly
see
well
what
changed
for
the
exact
lines
of
code
were
changed
on
that
commit
that
was
recently
deployed.
So
those
I
didn't
say
this.
Those
artifacts
are
representative
of
actual
production
deployments
to
this
environment.
The
other
thing
that
we
get
by
having
this
attached
kubernetes
is
access
to
the
pod
logs
for
this
specific
environment,
so
the
production
environment.
A
For
this
application
again
remember
there
are
pods
from
all
sorts
of
applications
running
in
this
cluster
I
can
kind
of
log
tale
the
logs
of
this
specific
pods
to
see
what's
happening.
One
thing,
you'll
notice
is
there's
a
bunch
of
traffic
coming
in
I'm,
not
visiting
the
page.
At
the
moment,
that's
because
I
I've
used
this
little
application
to
force
some
traffic
to
the
site.
That's
how
we
got
those
metrics
showing
so
don't
normally
have
a
bunch
of
traffic
on
this
toy.
App
I
think
that
I
wanted
to
showcase
was.
A
Let
me
show
you
the
live
up
again.
So
remember.
There's
this
view.
Randa,
all
new,
all
artisans
create
a
new,
artisan
and
and
view
a
random
one.
I
can
also
set
up
a
feature
flag,
and
this
is
actually
outside
of
the
ops
section
features,
but
it's
here
in
this
ops
tab.
So
it's
showcase'
for
you
I,
can
add
a
feature
flag
to
my
code
that
displays
whether
or
not
the
that
determines
whether
or
not
the
random
artisan
link
is
displayed.
So
in
this
case
feature
Flags
turned
on
so
it
was
displaying.
A
Is
it
just
showed
I
turn
it
off
and
it
takes
a
little.
We
use
the
unleash
unleashed
open-source
tool
takes
a
little
bit
for
that
to
navigate
its
way
through
the
unleash
servers.
But
if
I
refresh
my
page
couple
times,
then,
with
the
feature
flag
off
that
feature
was
removed,
maybe
I
can
showcase
for
you
quickly
how
that
happened.
I'm
gonna
look
at
this
is
my
BS
code
for
that
application.
I
think
it's
in
the.
A
As
where
I
set
my
unleash
context,
if
it's
in
the
view
you
yeah
here
is
where
I
asked
hey,
is
random
artisans
enabled,
if
so
at
this
link,
not
that
link
is
not
added.
So
that's
a
simple
code
addition
that
I
make.
That
then
enables
me
to
use
the
feature
flags
in
those
feature.
Flags
immediately
show
up
in
my
git
lab
interface
for
managements.
A
A
I
said:
oh
I'm,
doing
error
tracking
here's,
my
sentry
URL
I
have
a
project
on
century
Daioh
and
here's
the
auth
token
for
it
and
a
project
that
I
want
to
attach
to
so
then,
when
I
look
in
operations
at
error,
tracking
I
get
a
list
of
the
current
errors
that
are
that
have
been
spotted
this
one
was
spotted
a
day
ago
and
have
something
to
do
with
Postgres
connection.
Failure.
A
If
I
look
at
this
error,
you
might
not
have
a
great
stack
trace,
but
it'll
show
me
a
stack
trace
of
where
that
error
came
from
the
specific
events
when
it
was
seen,
and
what
the
release
of
that
application
was.
Then
I
can
also
ignore
it,
resolve
it
or
create
an
issue
from
it
and
typically,
you
would
have
multiple
errors
and
you
can
also
manage
from
this
list
ignoring
or
resolving
I
wants
to
create
an
issue
from
it.
A
Yeah
it's
an
example
of
some
other
issues
that
have
been
created
from
that
same
error,
yeah,
so
I
think
that's
a
showcase
of
what
you
get
directly
out
of
the
box
with
Auto
DevOps
and
again,
there's
a
simple
Ruby
on
Rails
application.
The
other
thing
that
I
wanted
to
showcase
was
a
place
where
we're
using
gitlab
Auto
DevOps
for
a
more
production
like
experience,
and
that
is
with
this
pijamas
design
system.
A
This
is
get
labs,
design
system,
design
framework
that
all
of
our
designers
and
front-end
developers
utilize
in
order
to
share
components
and
make
sure
that
we're
using
the
same
design
language
across
the
application.
This
design,
like
you
comm,
is
posted
and
is
the
content
is
stored
and
is
deployed
using
get
lab
itself.
So
let's
check
that
out.
A
That's
this
one!
So
again,
this
is
an
example
where
there
is
a
group
level
cluster.
This
project
called
get
lab
services.
There
is
too
attached
clusters,
one
for
staging
and
one
for
production.
The
production
one
you
can
see
has
only
the
pajamas
design,
give
up
calm
environment,
yeah
the
production
environment
in
at
the
moment,
but
we're
moving
additional
applications
here.
What
I
wanted
to
showcase
was
what
some
of
these
dashboards
and
experience
looks
like
with
live
metrics
coming
good
in
an
application
that
is
more
regularly
being
deployed
and
interacted
with.
A
A
This
wasn't
through
port
or
latency,
didn't
change
any
other
one
of
these
deploys
and
bi.
You
can
see
when
there's
a
deployment,
the
memory
usage,
resets
and
some
of
the
CPU
spikes
so
again
an
example
of
a
great
integration
between
get
lab
as
a
application
for
creating
in
there
your
code
with
our
great
source
control
NCI.
But
then,
when
using
the
same
tool
for
production,
you
get
a
bunch
of
these
great
integrations
between
the
two
experiences
that
help
of
people
performing
triage
really
quickly.
A
The
speaking
of
triage.
The
last
thing
I
wanted
to
showcase
was
our
incident
management
capabilities
and
remember
of
our
team.
Sara
did
a
great
walkthrough
video
that
I
will
post
a
link
to,
but
just
to
showcase
it
really
quickly.
This
is
a
an
example
app
that
our
monitor
team
uses
on
a
regular
basis
and
you
can
set
up
in
the
metrics
dashboard
alerts.
A
A
A
A
So
this
issue,
that's
created
as
a
result
of
the
alert
firing,
is
Auto
created
by
a
get
that
alert
bot.
It
creates
this
this
primary
summary
information,
and
this
is
the
query
that
was
used
to
determine
whether
the
alert
should
be
fired
at
the
time
that
it
was
fired.
You
can
easily
embed
that
charts
for
the
metric.
That
was
that
fired
right
here
in
the
issue.
A
So
this
is
a
live
chart
that
you
can
interact
with
that
would
update
live,
can
also
be
you
can
scope
it
to
the
specific
time
frame
and
you
can
attach
a
zoom
call
in
order
to
aid
the
team.
That's
firefighting,
this
issue
in
collaborating,
in
addition
to
the
ability
to
collaborate
in
a
kind
of
standard,
give
up
comments
method.
So
the
one
other
thing
that
you
can
do
when
it
comes
to
incident
management
is
I.
A
Don't
have
permissions
on
that
project,
but
I
can,
in
my
operation,
setting
define
a
specific
issue
template
that
is
used
when
creating
those
incidents.
So
that
is
helpful
way.
If
you
wants
to
make
sure
you
assign
certain
labels
or
assign
it
to
a
certain
group
or
team
or
@
mention
a
certain
group
or
team
in
the
issue
when
it's
created
in
this
example,
I
think
there
is
a
project
template
for
a
issued
template
in
this
project.
A
Here's
the
instance
template
that
they're
using
so
it
includes
embedded
metrics
chart
as
well
as
some
of
these
flash
commands
that
add
specific,
quick
actions
to
the
issue
when
it's
created
by
the
bot
after
the
alert
firing.
So
let
me
stop
sharing
those
were
some
quick
examples
of
live
already
set
up
projects
in
groups
showcasing
the
ops
section
features
as
I
mentioned.
There
are
other
videos
that
I'll
link
to
in
the
comments
that
are
also
part
of
the
ops
section,
playlist
that
this
one
will
be
added
to
that
showcase.