►
From YouTube: Tutorial: Hands-On Intro to Cloud-Native CI/CD with Tekton - Jan Kleinert & Joel Lord, Red Hat
Description
Don’t miss out! Join us at our upcoming events: EnvoyCon Virtual on October 15 and KubeCon + CloudNativeCon North America 2020 Virtual from November 17-20. Learn more at https://kubecon.io. The conferences feature presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Tutorial: Hands-On Intro to Cloud-Native CI/CD with Tekton - Jan Kleinert & Joel Lord, Red Hat
This hands-on tutorial introduces the key concepts of Tekton, a flexible, Kubernetes-native CI/CD framework that enables the automation of deployments across multiple platforms - including Kubernetes, serverless, and VMs - by abstracting away the underlying details. In this tutorial, participants will: - Learn about fundamental Tekton concepts and benefits and how to use the tkn CLI - Install tasks and learn about task catalogs - Create a pipeline for building, testing, and deploying an application on Kubernetes - Add pipeline resources - Trigger a pipelinerun - Deploy the application using a pipelinerun
Pre-requisites:
Install the following prior to the tutorial:
minikube: https://kubernetes.io/docs/tasks/tools/install-minikube/
tkn CLI: https://github.com/tektoncd/cli
(optional)
VS Code Tekton extension: https://marketplace.visualstudio.com/items?itemName=redhat.vscode-tekton-pipelines
https://sched.co/ZemE
A
Hello,
everyone
and
welcome
to
this
hands-on
lab
with
techcon.
Let
me
start
by
sharing,
so
I
think
you've
got
my
slides
up
and
running,
so
you
should
see
the
first
slide
with
pre-requirements.
If
you
have
just
a
few
minutes,
the
links
are
also
in
the
slack
channel.
So
if
you
want
to
take
a
look
at
these,
if
you
want
to,
if
you
already
have
installed
a
mini
cube,
that
would
be
perfect,
there's
also
the
kubernetes
playground
that
you
can
use.
A
So
this
will
spin
up
a
kubernetes
cluster
that
you
can
try
and
use
for
a
few
seconds
for
a
few
for
an
hour.
I
think
and
there's
also
the
tecton
command
line
that
you
will
need.
There
is
also
a
vs
code
extension
which
you
can
install
if
you'd
like
to
give
it
a
try,
but
I
guess
we're
ready
to
get
started
now.
Let
me
find
my
slides
so
welcome
to
the
hands-on
intro
to
cloud
native
ci
cd
with
techton.
A
My
name
is
joe
lord.
I
work
as
a
developer
advocate
for
the
red
hat
openshift
platform
and
I
came
from
to
this
world
with
a
lot
of
experience.
As
a
software
developer,
so
it
was
kind
of
interesting
for
me
to
learn
about
all
this
ci
cd
and
everything
working
inside
the
the
kubernetes
cluster.
So
I
really
like
this
tekton
tool
and
I'm
really
happy
to
talk
about
it
today
and
I'll.
Let
you
introduce
yourself
jen.
B
All
right
great,
so
I'm
jan
kleinert,
I
lead
the
openshift
developer,
advocacy
team
at
red
hat
and
I'm
also
really
excited
to
be
able
to
co-present
this
workshop.
For
all
of
you
today.
This
is
a
pretty
short
time
frame
for
the
workshop
and
we
want
to
make
sure
that
we
have
plenty
of
time
for
the
hands-on
exercises,
so
we'll
go
ahead
and
get
started.
A
A
definition
to
define
cscd
I've,
looked
up
the
red
hat
website
and
found
a
following
definition,
which
I
thought
really
encapsulates
what
it's
all
about.
So
cicd
introduces
ongoing
automation
and
continuous
monitoring
throughout
the
life
cycle
of
applications
from
the
integration
and
testing
phases
to
delivery
and
deployment.
So
the
acronym
cicd
has
a
few
different
meanings.
Ci
is,
or
pretty
much
always
refers
to
continuous
integration,
which
is
the
automation
pro
process
for
developers.
A
A
Both
are
about
automating
further
changes
for
the
stages
of
the
pipeline,
but
there
are
sometimes
used
separately
to
illustrate
just
how
much
automation
is
happening.
Continuing
this
delivery
usually
means
that
developer
changes
to
an
application
are
automatically
bug
tested
and
uploaded
to
a
repository
where
they
can
be
deployed
to
a
live
production
environment
by
the
operations
team.
It's
an
answer
to
the
problem
of
poor
visibility
and
communications
between
dev
and
business
teams
to
that
and
the
purpose
of
continuous
deliveries
to
ensure
that
it
takes
minimal
efforts
to
deploy
new
code.
B
All
right
thanks
so
now
that
we've
established
what
we
mean
by
ci
cd.
Let's
talk
about
cloud
native,
ci,
cd
cloud
native
is
such
an
overloaded
term.
So
we'll
talk
about
what
we
mean
by
it
in
this
context,
so
containers
what
we
mean
there
is
that
cloud
native
ci
cd
supports
applications
that
run
in
containers
and
that
are
orchestrated
by
kubernetes.
B
So
what
we
mean
there
is
that
these
systems
are
built
with
devops
practices
in
mind
and
they
allow
teams
to
own
their
delivery
pipelines
alongside
the
applications
without
having
to
rely
on
like
a
center
central
center
of
excellence,
team
that
manages
delivery
pipelines
on
other
teams
behalf,
so
it
kind
of
gives
them
that
that
ownership
and
freedom
and
flexibility
so
really
when
it
comes
down
to
it.
With
cloud
native
ci
cd,
we
want
to
be
able
to
build
test
stage,
deploy
everything
all
of
that
with
all
of
these
characteristics
in
mind.
B
Oh
there,
it
is
I'm
looking
at
my
own
screen,
so
there's
many
options
available
for
your
projects
to
choose
from
jenkins
jenkins,
x
spinnaker.
You
may
have
heard
of
these
there's
also
a
lot
more
and
you
can
take
a
look
at
the
continuous
delivery
foundation.
We've
got
the
the
link
there
cd.foundation
to
learn
about
those
and
more
so.
The
one
project
that
we're
going
to
focus
on
today,
though,
is
the
one
with
the
cutest
logo.
B
Techton
is
a
powerful,
flexible,
open
source
framework
for
creating
cloud
native
ci
cd
systems,
so
it
integrates
into
kubernetes
and
allows
developers
to
build
test
and
deploy
across
different
cloud
providers
or
on-premises
systems.
So
it
gives
you
a
lot
of
flexibility
there,
but
if
we
look
at
all
the
existing
tools,
whether
it's
tekton
or
some
of
the
others
that
we
mentioned,
they
all
have
a
few
things
in
common.
B
So
for
example,
they
you
probably
have
inputs
like
your
code,
you
perform
some
kind
of
task
on
that
input
and
then
you
have
an
output
which
might
be
something
like
an
image.
That's
been
that
can
be
deployed,
so
techton
was
built
with.
All
of
that
in
mind
right,
so
it
provides
us
a
set
of
tools
that
are
composable,
declarative,
reproducible
and
cloud
native
in
order
to
make
it
easy
to
build
these
pipelines.
B
So
the
way
that
tecton
does
this
in
such
a
kubernetes
native
way
is
that
it
adds
a
few
crds
or
custom
resource
definitions
into
your
kubernetes
cluster,
and
then
you
can
use
those
pieces.
Those
building
blocks
to
put
your
ci
cd
pipelines
together,
and
I
will
turn
it
over
to
joel
to
talk
about
that.
Some
more
take.
A
A
look
at
those
building
blocks
that
techton
provides
us
with
so
first
first,
there
are
steps,
tasks
and
pipelines.
So
a
step
is
one
of
those
operations
that
you
can
perform
on
your
code,
so
say
you're,
building
a
node.js
application.
It
might
be
running
some
unit
tests.
That
would
be
a
step
or
validating
that
the
code
follows
the
the
coding
standards
that
you
have
in
place.
That
would
be
another
step,
so
tecton
will
perform
each
step
inside
a
container
that
you
provide
for
that
node.js
application.
A
You
can
run
a
rail-based
universal
image
with
nodejs
installed
on
it.
So
steps
are
the
most
basic
task
or
most
basic
building
block
in
tecton.
Now
a
task
is
a
collection
of
steps.
So,
as
you
can
see
in
that
diagram,
we
have
task
a
which
is
a
collection
of
three
steps
that
are
performed
in
order.
Tecton
runs
those
tasks
inside
a
kubernetes
spot
which
allows
you
to
have
a
shared
environment.
A
When
you're
designing
a
series
of
steps
that
are
related,
for
example,
you
can
mount
a
volume
in
a
task
that
would
be
shared
across
each
step
for
a
specific
task,
so
tasks
are
specified
as
custom
resources
in
your
kubernetes
cluster
and
finally,
we
have
the
pipeline.
The
pipeline
is
a
collection
of
tasks
that
can
be
executed
in
a
number
of
different
ways
in
this
diagram.
A
A
For
example,
you
could
use
a
git
repository
just
like
in
this
example,
and
on
which
you
would
perform
a
bunch
of
operations
or
a
bunch
of
tasks,
and
then
you
would
output
an
image
at
the
end
just
like
in
this
diagram,
but
you
could
reuse
that
exact
same
pipeline
for
a
different
code
base.
If
needed,
resources
can
be
many
different
types,
it
could
be
a
git
repositories,
pull
requests,
images,
clusters,
storage,
cloud
events
and
a
few
more
so
they're
also
specified
as
custom
resources.
A
Finally,
we
have
task
runs
and
pipeline
runs,
as
the
name
implies.
There
are
specific
executions,
so
a
task
run
is
a
specific
execution
of
a
task.
You
can
run
tasks
outside
of
a
pipeline
to
help.
You
see
the
specifics
of
a
single
task.
If
you
need
to
that's
what
we'll
do
in
a
few
minutes,
and
the
pipeline
run.
Similarly
is
the
specific
execution
of
a
pipeline,
so
your
task
runs
and
pipeline
runs,
are
also
what
binds
together
your
tasks
and
pipelines
with
the
resources.
A
So
those
runs
can
be
triggered
manually,
as
you
will
see,
or
on
demand
by
using
tecton
triggers
a
pipeline
describes.
The
activities
that
take
place
during
the
execution
via
tecton
tasks.
So
pipeline,
however,
does
not
contain
the
specifics
of
the
git
repository
image
repositories,
openshift
and
kubernetes
cluster
in
order
to
keep
the
pipeline
decoupled
and
reusable
across
environments.
These
coordinates
are
provided
to
the
pipeline
during
execution
through
pipeline
resources,
so
one
could
could,
during
the
execution,
provide
different
sets
of
pipeline
resources
to
execute
the
same
pipeline
against
different
git
repos.
B
A
B
Okay,
so
now
that
we've
kind
of
introduced
these
concepts
to
you,
we
are
going
to
take
a
look
at
what
this
looks
like
in
practice.
So
you
can
go
to
this
url
here
to
get
started
I'll
leave
this!
Oh!
No!
Sorry!
Yes,
I'm
not
in
control
of
that!
That's
right!
So
you
can
go
to
this
url
here
to
open
up
the
tutorial
in
your
browser.
B
B
B
Catego
kubernetes
playground
just
to
show
you
what
it
looks
like
you
click
this
orange
start
scenario
button
and
it's
going
to
spin
up
a
kubernetes
environment,
for
you
may
take
a
minute
if
all
of
you
are
doing
it
at
the
same
time,
but
once
you
have
that
up
and
running,
you
can
work
in
this
top
panel
that
you
kind
of
see
grayed
out
here
in
the
back
and
execute
any
of
the
commands
that
we're
talking
about
there
and
I'm
going
to
close
it
out.
So
I
don't
take
up
any
resources.
B
But
again,
if
you
have
minicube,
that's
that's
a
good
way
to
go
so
you'll
also
need
the
tkn
command
line
tool.
There's
instructions
here
on
how
you
can
go
ahead
and
install
that,
depending
on
your
operating
system,
should
only
take
a
few
seconds
and
then
optional.
You
don't
need
this
for
what
we're
doing
today,
we'll
be
demonstrating
it
for
you.
But
if
you
want
to
get
the
vs
code,
tecton
extension,
you
can
get
it
from
this
link,
all
right
so
with
tkn
installed
in
some
kind
of
environment.
Again,
let
me
just
run
cube.
B
Now,
if
you
are
using
the
kubernetes
playground
and
you're
on
a
windows
machine,
you
may
have
to
do
ctrl
shift
v
in
order
to
paste.
So
if
you
find
yourself
having
some
trouble,
that
might
be
what
you
need
to
try.
Okay,
so
that
applies
a
bunch
of
resources
into
the
cluster.
It
gets
techton
pipelines
installed
for
us.
B
So
the
next
thing
that
you'll
need
to
do
if
you
haven't
already,
is
clone
this
repository
that
we're
working
in
and
then
cd
into
that
hands-on
techdon
directory,
I
am
already
in
there,
so
we're
good
to
go
now.
What
we'll
do
next
is
create
kind
of
a
hello
world
task.
So,
as
joel
may
have
mentioned
earlier
tasks
run,
they
exist
inside
of
a
pod,
and
you
can
use
these
tasks
to
perform
different
operations.
B
Our
task
that
we're
going
to
use
here
is
simply
going
to
echo
out
hello
world
to
us.
So
you
know
this
is
this
first
section
that
we're
going
to
do
here
is
really
kind
of
getting
you
used
to
the
concepts
in
a
hello
world
kind
of
way,
rather
than
using
this,
as
you
would
with
an
application
which
we'll
do
at
the
end.
B
So
let
me
show
you
over
here.
I
have
this
zero
one,
hello,
dot,
yaml
file
and
you
can
see
you
know
it
looks
like
pretty
much
any
other
kubernetes
resource
type.
So
the
kind
is
task.
It's
got
a
name
of
hello
and
then
there's
the
spec
here,
which
has
the
steps
for
our
task.
So,
as
joel
mentioned,
a
task
is
made
up
of
one
or
more
steps.
So
our
step
same
as
what
you
see
here
is
say
hello.
B
We
use
this
red
hat
universal
base
image
and
then
we're
just
running
this
command
here
all
right.
So
let's
try
it.
We've
got
it
set
up
so
that
you
can
copy
and
paste
these
if
you're
in
that
hands-on
techton
directory.
This
should
just
work
for
you,
but
we're
running
cubecuttleapply,
dash,
f
and
passing
in
that
zero.
B
One
dash
hello.yaml
file
and
the
message
we
get
back
is
that
that
task
was
created
next
we're
going
to
run
tkn
task
start
to
start
it,
but
first
I
just
wanted
to
show
you
tkn
task
ls,
which
will
give
you
a
listing
of
any
tasks
that
you've
created.
So
if
you
forget
the
name
of
your
task,
you
can
always
run
that
to
go
back
and
see
what
it
is.
But
let's
run
it
so
to
run
the
task
you
use.
B
B
A
That
I'll
take
this
task,
that
jan
just
created
and
I'll
I'll
try
to
pimp
it
up
just
a
little
bit.
So
we
have
a
task
that
says
hello
world.
So,
let's,
let's
try
to
change
that,
make
it
a
little
bit
complex.
So
when
it,
when
you
create
tasks
and
pipelines,
you'll
probably
want
to
pass
some
parameters
to
it.
It
could
be
things
like
you
know.
B
A
One
thing
that
I
can
see
I
just
forgot
was
to
actually
specify
that
I'm
adding
a
parameter
right
here,
so
we
now
have
our
parameter
and
if
I
try
to
execute
this,
oh
I'll
just
change
our
hello
world
here.
So
instead
of
outputting
hello
world,
we
will
output
one
of
the
params
and
we'll
just
use
the
person
parameter
so
we'll
output,
the
value
of
this
parameter
here.
A
A
I
can
say
joel
and
in
just
a
few
seconds
we
should
be
able
to
see
hello
joel
instead
of
the
the
default
hello
world
that
we
had.
If
I
leave
it
empty,
I
can
still
use
the
default
value
automatically
and
the
same
will
be
done
automatically
for
you
in
your
kubernetes
cluster,
if
you're
not
using
directly
the
command
line
here,
all
right,
so
that's
nice.
So
why
don't
we
try
to
make
this
a
little
bit
more
complex
now
and
add
some
multiple
steps
to
our
operation.
A
So
I've
told
you
already:
a
task
can
be
composed
of
multiple
steps
and
they
can
each
share
a
same
environment.
So,
let's
add
a
first
task
which
will
write
something
into
a
file.
So
we'll
call
okay,
this
first
step
right,
hello
and
we
will
use
the
same
image
so
the
universal
base,
image
from
a
red
hat,
and
I
can
also
specify
a
script
so
instead
of
a
single
command,
I
can
add
a
script.
I
can
pipe
this
in
I'll.
Just
create
a
small
batch
script.
A
There
it
is,
if
I
can
use
a
batch
script,
we
will
just
echo
something
just
so
that
we
can
see
the
progress
here.
Preparing
preparing
greeting
typing
is
hard
so
and
then
we
will
hello
our
parameter,
but
instead
of
just
outputting
it
to
the
standard
out.
We'll
put
this
in
a
text
file
somewhere
now
we'll
sleep
two
seconds
just
to
actually
see
those
steps,
one
after
the
other-
and
I
will
echo
done
now
for
our
say,
hello
fast.
We
will
change
this
a
little
bit.
A
Node
14
we'll
use
a
script
there.
It
is
all
right
and
let
me
just
copy
and
paste
right
here.
So
what
we're
doing
here
is
actually
taking
a
different
script.
So
in
this
case
we're
actually
running
a
node.js
script
and
we
will
be
reading
that
file
from
slash
text
on
slash
home,
slash
hello
text,
so
you
can
see
here
that
I've
used
the
home
folder
so
I'll,
be
writing
something
in
that
for
home,
folder
and
then
I'll
be
reading
from
it.
A
Ask
hello
and
we
will
show
the
logs:
let's
get
again
show
log
for
this.
I
can
use
a
let's
use
gender
time
there.
You
go
hello,
jan,
so
now
what
is
happening
is
that
we
have
that
first
bash
script
that
will
be
running.
It
will
start
by
telling
us
it's
preparing
the
greeting.
It's
writing
to
a
file.
Now
it's
done,
and
we
can
see
that
we
have
our
second
step
right
here
and
we
can
see
how
they
are.
A
B
B
All
right,
so
I'm
back
here,
I
actually
was
following
along
with
joel
and
I'm
waiting
for
my
logs
to
be
available
here.
So
I'll
give
it
a
second
and
then,
if
it's
taking
a
minute
I'll,
just
stop
that
and
we'll
move
on
what
we're
going
to
cover
next
is
pipelines.
So
we've
talked
about
tasks.
Now
you
talked
about
how
you
can
add
multiple
steps
into
a
task
deal
with
parameters,
but
many
times
you're
not
going
to
just
have
one
task
and
pipelines.
B
What
they
really
do
is
give
us
that
opportunity
to
have
multiple
tasks
run
to
accomplish
whatever
it
is
that
you're
trying
to
do
so.
Let's
start
by
doing
some
kind
of
really
generic
task,
that's
going
to
echo
in
whatever
it
receives
from
its
parameters,
so
parameters
are
say
what,
which
is
what
we
should
say
and
then
there's
this
pause
duration
for
how
long
to
wait
before
you
know
providing
that
response
back
we're
going
to
use
that
task
in
order
to
build
our
our
pipeline.
B
B
Is
here,
and
so
pipeline
also
has
a
name,
and
then
it
is
made
up
of
tasks
so
in
this
case
two
tasks
our
first
task
takes
in
you
know
we
give
it
a
pause
duration
of
two
and
then
we
say
what
it's
going
to
say
is
hello.
This
is
the
first
task
and
the
second
one
is
going
to
say-
and
this
is
the
second
task
so
fairly
straightforward-
we're
going
to
use
that
task
multiple
times,
but
use
it
in
different
ways
with
different
input
parameters.
B
B
B
And
now
we'll
be
able
to
run
it.
So,
just
to
you
know,
repeat
what
we
said
before.
If
we
do
tkn
task,
ls
you'll
see
the
tasks
that
we
have
and
then
tkn
pipeline
ls
does
the
same
thing
for
pipelines
all
right.
So
now,
if
we
go
back
and
run,
we
can
pipeline
start
say
things.
It
should
know
about
this
pipeline.
Now
it
exists
all
right.
So
now
that's
running
for
us.
So
let's
wait
and
see
what
the
output
looks
like
before
we
move
on
to
talking
about
the
different
ways.
B
Okay,
so
this
is
interesting.
This
may
look
like
yours
or
yours
might
be
different,
but
in
my
case
the
second
task
is
actually
the
one
that
outputted
output
first
followed
by
the
first
task.
This
happens.
Sometimes
the
reason
that
it
happens
is
that
techton
tries
to
start
them
all
at
the
same
time,
so
they
can
run
in
parallel.
B
So
for
our
say,
things
in
order
pipeline
again
we're
still
referring
back
to
our
say
something
task
several
times
four
times
in
fact,
so
we
have
four
tests
in
the
pipeline
now,
we've
named
them
first
test;
second
tabs
third
task
and
fourth
task
and
here's
here's
how
they're
set
up
so
this
first
one
is
very
similar
to
what
we
had
before
we're
giving
it
the
pause.
Duration
of
two.
B
It
says
hello.
This
is
the
first
task,
but
then
here's
what
we
have
different
for
our
second
for
our
second
task
here,
it's
going
to
say
happening
after
task
1
in
parallel
with
task,
3
and
task
3
is
saying
happening
after
task
1
in
parallel
with
task
2.
and
the
way
that
we
make
that
work
is
we
use
the
run
after
field
here
and
for
both
the
second
and
the
third
task.
We're
saying
run
after
the
first
task,
see
here,
run
after
first
task
run
after
first
task.
B
So
that
means
neither
task
two
nor
task
three
will
be
started
until
the
first
one
completes
and
they
will
be
executing
in
parallel
and
then.
Finally,
we
have
a
fourth
task,
which
says
happening
after
task
two
and
three
that
has
a
run
after
set
to
second
task
and
third
test.
So
this
one,
the
fourth
task,
will
not
execute
until
both
task.
Two
and
task
three
are
complete.
B
Okay,
so
let's
see
if
it
behaves
like
we've
set
it
up
back
to
the
terminal,
I'm
gonna
do
it
clear
so
that
you
can
all
see
my
screen,
maybe
a
little
bit
better,
so
that
zero
six
pipeline
order
file.
We
were
just
looking
at.
Let's
apply
that
okay,
you
should
see
that
new
pipeline
exists
now
right
here,
say
things
in
order.
So
that's
good.
B
B
A
B
B
Now
this
third
and
second
one
are
running.
We
didn't
specify
a
specific
order
for
two
and
three,
so
we
kind
of
just
get
whatever
happens
and
then
there's
the
fourth
task,
which
happened
after
those
two
completed.
So
that's
just
a
very
quick
way
of
showing
how
you
can
have
within
a
pipeline.
Some
tasks
can
run
sequentially.
Others
can
run
in
parallel
parallel,
and
you
have
a
lot
of
control
over
how
to
set
that
up
and
specify
when
things
should
run
all
right.
A
Perfect,
thank
you,
jan
just
before
I
move
on
to
a
resources.
Once
again,
I
have
the
techton
extension
that
is
installed
in
and
I'm
using
vs
code
right
here
and
just
to
kind
of
show
a
little
bit
what
jan
just
presented.
I
thought
it
would
be
interesting
to
introduce
the
vs
code
extension
quickly
at
this
point.
A
So
it's
a
very
visual
way
to
kind
of
see
all
those
those
different
tasks
and
and
those
those
pipelines
are
especially
when
they're
getting
a
little
bit
more
complex,
all
right.
So
I'll
move
on
with
to
the
next
part,
and
I
want
to
introduce
resources
now.
So
we've
already
said
that
pipelines
can
do
multiple
operations,
but
really
what
they
do
is
that
they
will
typically
perform
something
on
a
either
an
input,
and
then
they
will
well.
They
will
perform
something
on
an
input
and
typically
they
would
provide
us
with
an
output.
A
So
you
can
see
here
in
my
spec
that
I
have
a
resource
section
and
I
have
one
input,
and
here
I'm
telling
well
this.
The
name
for
this
input
will
be
repo,
it'll,
be
an
input
of
type
git.
So
it
could
be
multiple
things,
as
I've
mentioned
in
the
introduction
and
our
target
path,
where
is,
will
our
git
repository
get
cloned
will
be
in
the
code
folder
now
for
my
task.
A
My
first
step
is
to
count
so
I'm
giving
it
the
name
count,
I'm
using
the
red
rel
universal
base,
image
again,
I'm
using
a
bash
grip
and
I'll
just
echo
the
number
of
files
in
that
repository
now
I'll
move
on
to
create
my
actual
pipelines.
The
pipeline
will
have
a
single
tasks
and
if
a
single
task-
and
it
will
take
a
resource
as
an
input,
so
it'll
be
the
git
repository
I'll,
give
it
a
task
count
task
or
I'll
name.
My
task
account
task
and
I'll
give
it
and
the
the
files
to
be
run.
A
A
A
There
it
is
okay,
so
now
you
can
see
that
I
have
the
option
to
pick
different,
get
different
resources.
So
in
here
I
have
the
git
repo
that
is
already
created
for
me,
or
I
could
create
a
new
git
resource
if
I
wanted.
So
if
I
want,
if
you
wanted
to
run
this
exact
same
pipeline
on
a
different
git
repository
to
count
the
number
of
files
in
that
repository,
you
could
create
a
new
git
resource
here.
A
A
You
can
see
that
my
git
repo
was
cloned,
so
we
can
see
successfully
cloned
here
and
then
I
have
my
task
that
was
performed
on
it
and
the
actual
count
of
the
file
and
the
output
that
I
specified
in
my
bash
print
right
here.
So
I
can
see
that
I
have
59
files
in
this
git
repository,
which
is
a
lot.
It
doesn't
seem
like
that.
Much
actually,
when
I
look
at
my
my
file
explorer
right
here,
all
right,
so
those
are
nice.
We
we
saw
a
lot
of
different
examples.
A
A
There's
there's
another
thing
that
I
forgot
to
mention
about
pipeline
resources
is
that
they're
still
in
alpha,
so
tecton
or
just
released
the
beta
version
just
a
few
months
ago,
but
pipeline
resources
are
are
still
alpha.
The
core
team
still
questions
whether
they
should
stay
in
the
spec
or
not
in
the
latest
version
of
tekton.
They
also
introduced
workspaces,
so
those
are
added
to
share
file
systems
between
the
different
tasks
of
a
pipeline.
A
I've
added
an
example
here,
and
we
can
take
a
quick
look
at
it
because
I
think
we
still
have
plenty
of
time,
yeah
perfect.
So
in
my
workspace
example,
you
can
see
here
that
I
created
a
persistent
volume.
So
it's
a
little
bit
more
lengthy
to
actually
use
workspaces,
but
if
you're
familiar
with
kubernetes,
this
should
be
fairly
straightforward.
A
So
first
we
start
by
creating
a
persistent
volume.
Then
we
start
a
persistent
volume
claim
just
to
get
this
persistent
volume
and
I'll
give
it
a
name
and
then
in
my
task
I
can
specify
different
workspaces
to
use.
So
in
this
case,
I'm
specifying
the
workspace
that
we'll
call
output
and
I
can
use
that
output
as
with
a
string
extrapolation
right
here.
So
I'm
using
here
I'm
telling
my
task
to
echo
hello
into
the
workspace.output.path.
A
So
instead
of
using
the
home
folder
that
I
used
in
the
previous
example,
I'm
actually
using
the
workspace
here.
The
other
task
does
pretty
much
the
same
thing
as
we
did
earlier.
So
it
just
reads
the
output
of
that
file
or
just
gives
us
the
output
of
the
of
that
file.
So
we
can
see
that
we're
actually
reading
from
the
workspace
again
in
our
pipeline
definition.
A
A
A
Let's
just
try
this
again
we'll
be
using
a
pvc
and
name
of
my
pvc
was
tknpvc
all
right,
so
workspaces
are
not
fully
working
yet
they're
a
little
bit
more
complex
to
use
than
resources
are,
and
I
can't
figure
out.
I
think
it's
my
subpath
right
here,
so
they
are
there
in
the
spec
they're
still
pretty
much
in
alpha
as
well.
A
So
sharing
different
resources
between
the
different
tasks
in
a
pipeline
is
still
is
still
in
alpha
mode,
but
most
of
the
rest
that
we've
shown
you
today
isn't
better
and
should
change
that
much
all
right.
So
that
was
a
lot
of
content
that
we've
seen
so
far,
but
none
of
that
really
makes
sense
right,
you're,
probably
not
gonna,
echo
hello
world
in
your
pipeline.
What
we
want
to
do
here
is
cicd,
so
what
we
really
want
to
do
is
to
take
a
git.
A
A
S2I
all
right,
so
the
first
task
will
be
to
to
run
npm
to
do,
and
this
first
task
will
do
an
npm
install
followed
by
a
linten
linting
process.
So
we
can
start
by
creating
an
object
of
type
kind.
We
will
have
various
parameters,
so
the
first
thing
will
be
the
path
to
the
application
inside
git.
So
say
you
have
a
git
repository
that
has
the
application
in
a
specific
folder.
In
this
case
we
have
an
application
in
the
app
folder,
so
I'll
want
to
be
able
to
specify
that
as
a
parameter.
A
A
And
we
will
have
here
our
first
step,
which
will
be
the
npm
install
and
we'll
use
the
git
repository
resource
here,
we'll
have
our
npm
install,
which
will
run
on
a
node
14
image
and
it
will
run
a
bash
command.
So
we
will
repo.
We
will
cd
into
the
repository
slash
the
path
context.
That
was
one
of
our
parameter
right
here,
so
it
specified
dot
as
default,
but
it
it
will
be
app
in
our
context
and
then
it
will
run
npm
install
and
the
second
step.
A
The
second
task
will
be
an
s2i
task,
so
it
will
actually
take
a
repository
and
build
an
image
out
of
it.
So
it
will
take
a
bunch
of
different
parameters.
I'll
take
a
username,
a
password
from
docker
hub.
I
will
need
a
image
name
as
well
to
create.
We
will
use
a
registry,
in
this
case
we'll
use
docker.io
as
a
image
name
in
order
to
perform
this
task,
we'll
have
multiple
steps,
so
we'll
have
a
generate
step
which
will
use
sty.
A
I
will
have
the
one
resource
I'll
have
an
input
right
here
and
then
I
have
all
of
my
tasks.
So,
first
of
all,
my
linting,
the
second
one,
will
be
the
testing.
So
I'm
reusing
that
I'm
reusing
that
same
task
that
I've
created
in
the
first
part
right
here.
So
you
can
see
the
task
reference
is
npm.
So
it's
the
same
task,
but
in
this
case
I'm
using
run
test
instead
of
run
link.
A
So
you
can
see
how
you
can
reuse
those
different
tasks
as
part
of
the
same
pipeline
here
and
finally,
we
have
our
build
and
deploy
task
which
will
take
care
of
creating
that
image
at
the
end
and
of
course
we
will
run
it
after
lint
and
test
okay.
So
first
thing
I'll
need
is
to
actually
find
my
docker
hub
password,
so
just
bear
with
me
for
one
second
and
I'll
leave
that
out
of
the
screen.
If
you
don't
mind.
A
A
A
A
The
same
repository
here,
the
parameter
for
user
will
be
joel
lord,
which
is
my
docker
hub
username.
My
password
is
the
one
that
I
just
copied
from
dockerhub.
The
image
name
will
be
kubecon
and
let's
see-
and
let's
take
a
look
at
those
logs
right
here,
all
right,
so
we
can
see
that
it
already
cloned
my
repository
successfully
initialized
so
so
far
doing
good,
I'm
actually
nervous
to
see
if
this
will
actually
work
all
right.
So
we
have
our
linting
that
just
worked.
We
have
our
testing.
A
A
A
A
A
So
we're
not
fully
done
we're
not
fully
deployed
here
yet,
but
you
can
see
here
that
my
image
was
actually
pushed
just
a
few
seconds
ago
to
my
docker
hub
to
my
to
my
docker
hub.
So
my
image
was
so
we
took
our
our
code.
We've
we've
deployed
it
tested
it
deployed
it
into
docker
hub
now.
So
in
theory,
I
could
now
do
another
operation
to
deploy
that
into
my
kubernetes
cluster,
just
to
see
that
this
actually
works.
A
Let's
say
I:
I
just
changed
the
results
intentionally
I'll
do
return,
plus
3
here
now
in
theory-
and
I
haven't
checked
this
code
today,
but
in
theory
this
should
not
work,
because
now
it
won't
be
returning
four,
it
will
return
seven.
So
if
I
try
to
run
this
task
or
this
pipeline
again
I'll
use
the
same
defaults
I'll
need
my
password
again.
B
A
I
should
have
copied
it
somewhere.
Actually,
I
think
it's
right
here
and
of
course,
jen.
Please
remind
me
to
delete
that
api
key
at
the
fr
at
the
end
of
our
session.
All
right,
then,
the
name
of
the
image
will
be
kubecon
again,
but
now
what
will
happen
is
that
I
will
be
running
the
application
it
will
all.
Of
course
I
forgot
to
do
a
get
commit
new
changes,
get
bush
origin
master
there
you
go.
A
A
B
A
B
B
B
The
second
link,
I
think,
is
really
cool,
so
this
is
a
preview
version
of
techton
hub,
which
is
kind
of
a
catalog
of
reusable
tasks
and
pipelines
that
you
can
use
we're
going
to
do
q
a
in
a
minute-
and
I
did
see
a
question
come
through
asking.
I
believe
something
about
like
what
other
options
are
there
for
building
images
other
than
s2i,
because
this
person
had
some
legacy
docker
files.
B
B
B
But
to
answer
this
person's
specific
question,
if
you
filter
here
for
image
build,
you
can
find
a
bunch
of
options.
So,
if
you're
using
build
packs,
there's
an
option
for
build
packs
there.
This
is
the
s2i
one
that
we
were
using,
but
to
show
you
what
that
would
look
like
when
you
click
on
it,
you
can
click
install
and
it
will
give
you
that
keep
going
apply
command
that
you
need
in
order
to
be
able
to
use
that
task,
and
then
there's
usually
also
some
good
information
documentation
on
how
to
use
it.
B
Number
one:
okay,
while
you're
doing
that,
I
sorted
through
some
of
the
questions
while,
while
joel
was
doing
the
last
section
and
I
tried
to
enter
answers-
hopefully
made
them
public
for
some
of
the
questions
that
are
there.
I
will
run
through
a
couple
of
those
now
someone
had
asked
what
slack
channel
we're
going
to
be
in
after
this,
it
is
the
so
pound
2
dash
kubecon
cicd
and
that's
in
the
cncf
slack.
B
Someone
else
asked
for
the
github
url.
I
posted
it
as
an
answer
to
one
of
these
questions,
but
again
it
was
github.com
joellord
hands
on
techton
and
then
the
other
kind
of
administrative
question
was
asking
how
to
get
the
slides
either
joel
or
I
will
share
a
link
to
those
on
twitter
sometime
later
today.
So
if
you
follow
us
on,
there,
you'll
be
able
to
get
those,
and
I
put
our
twitter
handles
in
the
links
to
one
of
these
questions
as
well.
B
So
let's
look
at
some
of
the
more
you
know,
topic
specific
stuff,
joel.
If
it's
cool
with
you,
I
can
kind
of
read
through
and
we
can
just
tag
team
if
we
know
that
oops
sorry
I'll
look
at
the
camera,
I'm
looking
at
my
other
screen
here,
I
realize
you're,
looking
at
my
ear
inside
of
my
face,
so
I'll
go
through
and
read,
and
then
we
can
figure
out
ones.
We
can
answer
now
versus
things.
We
might
need
to
research
and
follow
up
on.
B
A
I'm
I'm
not
fully
sure
if
I
understand
the
question,
but
if
I
because
what
we
did
here
was
to
use
the
tekton
cli
a
lot,
the
the
other
way
to
use
it
would
be
to
to
you
either
use
triggers
and
pre-configure
all
of
those
inputs
and
so
on.
So
maybe
that's
because
because
in
our
examples
we
had
to
manually
enter
all
of
our
parameters
here,
but
that's
because
we
were
using
the
cli.
A
B
A
But
very
quickly,
detection
triggers
will
will
just
use
the
github
web
hooks
or
any
web
hook
essentially,
and
it
will
just
create
a
task
run
or
a
pipeline
run
for
you
automatically
behind
the
scene.
So
you
have
a
little
bit
of
configuration
to
do
and
you
can
look
up
take
down
triggers,
but
that's
pretty
much
what
it
does.
B
Okay
next
question:
I
think
we
ended
up
answering
this
one
as
the
tutorial
went
on,
but
there
was
a
question
about:
can
steps
run
in
parallel
or
ali
sequential?
We
did
definitely
walk
through
a
process
where
we
showed
them
doing
both
so
you,
depending
on,
if
you
can
use,
run
after
if
you
want
to
make
sure
that
something
is
completed
before
you
move
on.
But
otherwise,
if
you
have
two
tests,
if
you
have
two
tasks,
they
would
try
to
run
in
parallel.
B
A
No,
I
don't
believe
that
the
container
will
be
shared,
but
there
is
some
workspace
that
is
shared
between
the
steps
and
the
same
tasks.
So
that's
kind
of
what
we
did
in
the
multiple
steps
where
we
wrote
into
the
home
folder
and
then
the
second
container
was
able
to
pick
it
up.
So
those
will
be
shared
as
a
shared
volume,
but
I
don't
believe
the
container
the
actual
container
can
be
shared
across
multiple
steps,
so
it
will
be
a
new
container
every
time.
I
think
I
think
yeah.
B
And
I
think
so
too,
but
we
can
always
if
whoever
has
asked
that
question
pops
into
slack,
we
can.
We
can
confirm
in
there.
Next
question
was
what
happens
to
the
image
after
the
completion
of
tasks
I
mean
in
your
real
world
example.
You
ended
up
pushing
the
image
right.
So
that's
one
thing
you
can
do
with
it,
but
there
any
other
scenarios
you
can
think
of
that
are
worth.
A
Yeah
it
exactly
it's
up
to
you
to
do
what
you
want
to
do
with
it
once
it
actually
it's
completed.
It
will
actually
remove
everything
just
like
any
container
right
once
it's
once
it's
deleted.
It
will
just
destroy
everything
else
with
it,
so
you
actually
need
to
do
something
with
your
image.
So
in
my
case
I
was
pushing
that
to
docker
hub.
You
could
push
that
into
your
your
your
current
workflow
or
into
your
kubernetes
cluster.
A
B
Okay,
let's
see
next
question
here:
is
there
a
way
of
using
secrets
in
tasks-
and
this
is
similar
sort
of
similar
to
another
question
that
was
asking?
If,
if
you
could
pass
in
parameters
via
a
file
or
something
like
that,
so
we
did
a
lot
of
things
on
the
command
line.
What
are
the
other
options
that
are
available
for
things
like
secrets
or
parameters.
A
No
just
always
paste
it
in
front
of
500
people.
That's
probably
posting
your
password.
That
definitely
works.
No,
you
can.
You
can
also
use,
I
I
can't
remember
the
name
of
the
resource,
but
you
can
use
a
kubernetes
the
same
way.
You
would
use
in
any
other
communities
to
share
your
your
secrets.
There.
B
A
B
B
A
B
Very
nice,
oh
here's
one!
So
when
someone
asked
a
question
if
it's
possible
to
have
a
view
like
the
one
with
the
vs
code
plug-in
while
the
pipeline
is
running
one
thing
we
didn't
really
talk
about
at
all,
because
we
were
using
mini
cube
and
just
kind
of
vanilla
kubernetes
here,
but
on
openshift
there
is
something
called
openshift
pipelines,
which
is
basically
kind
of
like
built
upon
tecton
and
part
of
excuse
me
part
of
what
it
offers
is.
B
A
Yeah,
the
vs
code
is
definitely
my
my
favorite
tool
when
you're,
when
you're
dealing
with
tech
contacts,
there's
a
lot
of
visual
representations
and
it's
very
easy
to
see
everything
that
you
have
running
in
your
cluster.
So
you
can
actually
dig
into
it.
It'll
actually
show
you
the
code
for
each
one
of
those
pipelines
or
tasks,
and
so
on
so.
A
B
B
How
okay
here's
here's
a
good
question:
what
happens
when
the
pipeline
fails?
How
would
you
notify
the
developers
like
you
know
where
we
know
if
something
failed,
because
we're
sitting
there
running
the
command
on
the
command
line?
But
let's
say
you
had
this
automated
in
some
way
or
you
know
the
actual
developers
weren't
the
ones
kicking
this
off.
You
know
our
trigger
triggers
an
option
there,
or
would
you
typically
build
this
into
some
other,
no
existing
pipeline
framework
that
you
have
within
your
organization.
A
Yeah,
that's
a
good
question,
I'm
not
sure
about
that
one
as
well
by
because
I'm
using
openshift
most
of
the
time
right,
the
dashboard
right
there
is
very
useful,
so
you
can
actually
have
a
very
you
know,
a
graphical
view
of
everything
and
how
it's
going
on.
So
I'm
not
I'm
not
fully
sure
on
how
to.
Actually,
I
guess
I
guess
you
yeah,
you
could
use
conditions
to
see
what's
going
on
and
to
create
alerts
based
on
what
happened.
A
B
B
Correctly
it
should
you
know,
tasks
and
pipelines
should
basically
operate
the
same
on
any
kubernetes
cluster,
like
it
shouldn't
run
differently
or
or
do
something
differently
from
one
cluster.
One
distribution
of
kubernetes
to
another
and
s2i
works
on
us
to
is
not,
as
we
I
mean,
as
we
saw
here,
is
not
open
so
specific
either.
So.
A
B
A
I
don't
know
it
by
heart,
but
because
I
tend
to
do
a
a
fair
amount
of
presentations
I
like
to
have
funds
that
are
relatively
readable.
So
let
me
take
a
look
preferences,
space
mono
and
it's
an
open
source
font
so
or
maybe
yeah
some
sort
of
open
license
at
least
so.
Space
mono
is
the
one
that
I'm
using
cool.
B
A
B
A
A
B
A
A
So
you
use
it
for
performing
just
just
about
anything
that
you
want
on
your
application,
so
to
run
your
tests
to
do
your
linting
to
install
some
dependencies.
So
you
always
end
up
using
that
same
that
exact
same
tool.
So
what
I
did
here
is
one
task
that
is
called
npm
and
then
I
can
share
that
either
through
the
deckton
hub
or
to
my
whole
team
or
to
various
places,
and
then
anyone
creating
a
pipeline
can
actually
reuse
that
same
task
and
just
instead
of
using
default
start
can
actually
use
it
in
different
ways.
A
So
in
my
pipeline,
if
I
go
back
to
the
actual
pipeline,
you
can
see
that
I
have
two
tasks
right
here.
The
first
two,
the
first
one
is
called
length
and
the
second
one
is
called
test
and
they're
both
using
that
same
task,
the
only
difference
being
that
the
action
that
they
are
performing
is
run
test
in
one
case
and
run
lint
in
the
other
case.
So
I'm
reusing
that
same
task,
so
I
don't
have
to
rewrite
a
full
task
each
time.
So
there's
a
lot
of
reusability
that
you
can
do
right.
There.
B
A
A
That's
a
good
question.
I
I
should
definitely
look
into
that.
I
haven't
played
a
lot
with
conditions
so
so
yeah
when
I
tried
it,
it
didn't
seem
to
work
very
well,
but
that
was
a
few
months
ago
and
techton
evolves
very
very
quickly,
so
it
might
be
a
little
bit
easier
to
use
now.
It's
definitely
something
that
I
want
to
dig
into
a
little
bit
more,
so
I'm
not
sure
if
it
if
it
could
do
such
a
thing.
So
I'm
sorry,
I
can't
answer
that
question,
but
I'll
definitely
try
to
follow
up.
B
All
right
cool,
so,
let's
start
there's
so
many
questions
we'll
never
be
able
to
get
all
of
them
here.
So
I'm
sorry
about.
We
had
about
11
like
over
100
questions.
So
thank
you
all.
First
of
all,
for
all
the
questions
and
for
following
along
with
us
once
more,
the
the
slack
channel
that
we'll
be
in
is
two
dash
cubecon
ci
cd
over
in
the
cncf
slack.
There
is
also
a
six
dash
cube
con
red
hat
slack
channel
and
within
the
you
know,
event
platform.
B
If
you
go
to,
I
don't,
have
it
open
right
now,
so
I
can't
tell
you
exactly,
but
I
think
it's
the
sponsor
showcase.
Under
the
first
link
there
I
think
it's
diamond
sponsorship
you'll
find
the
red
hat
booth.
We
have
a
message
board
in
there,
as
well
as
a
bunch
of
other
resources,
tutorials
demo,
videos.
I
think
you
get
some
kind
of
virtual
swag,
so
you'll
find
us
over
there
as
well.
But
thank
you
everybody.
So
much
for
your
time.
Perfect.