►
Description
How cool is it that my code repository can store, test, and deploy my code?
GitHub actions can be used to perform a series of steps against a code base making it so the only thing your team has to do is push code and the pipelines handle everything afterwards from testing to even deploying!
This OpenShift Commons Briefing will start from Day 0, Red Hat's Ryan Cook will introduce and design workflows that will test, merge, and deploy an application on OpenShift and we will do it LIVE together!
Live Q/A
Guest Speaker: Ryan Cook (Red Hat)
Hosted by Karena Angell (Red Hat)
A
B
Hello,
everyone
welcome
back
to
another
openshift
commons
briefing,
and
today
we
have
another
in
our
github
series.
So
today
we'll
be
talking
about
github,
workflows
and
we're
here
with
ryan
cook.
Brian
is
out
of
our
emerging
technologies
team
in
the
office
of
cto,
at
red
hat
and
myself.
I'm
karina
angel,
I'm
one
of
the
openshift
product
managers
and
so
github
is
very
important
to
openshift,
and
we're
really
excited
to
have
you
here
ryan.
Would
you
like
to
give
a
brief
introduction
and
dive
right
in.
A
Yeah
so
ryan
cook
I've
been
with
red
hat
for
seven
years
now
and
done
various
automation
along
the
way.
I
stumbled
into
github
actions
thanks
to
a
project
called
scribe,
which
you
also
saw
on
openshift
commons
a
few
months
ago.
So
I
kind
of
want
to
tell
that
story.
Just
to
hopefully
get
people
excited
about
it
and
kind
of
get
them
started.
A
A
A
So
what
actually
are
github
actions?
The
easiest
simplest
way
to
kind
of
dumb
it
down
is
to
make
it
presentable.
The
fact
that
you
can
provide
github
a
series
of
workflows
series
of
steps
to
do
and
kind
of
an
end
result.
So
I
can
have
github
manipulate
my
code.
I
could
have
it
build
an
image
for
me.
I
could
have
it
push
the
image
to
a
registry.
I
can
have
it
build
a
binary,
save
the
binary,
give
the
binary
to
someone
else,
and
then
it's
just
like
it's
unimaginable
what
you
can
do.
A
A
We're
going
to
create
a
binary
and
we're
actually
going
to
test
it
and
then
from
there
we'll
do
some
prs
against
it
and
then
we're
going
to
move
into
like
an
openshift
space
where
we're
going
to
build
an
image,
push
it
to
quay
and
then
deploy
it
on
that
open
shift
environment.
So
this
is
our
kind
of
simple
diagram,
but
you'll
see
it
again
later,
because
that's
actually
we're
going
to
use
for
open
shift.
A
A
So
this
is
just
such
a
beautiful
thing
because
you
think
about
you,
know
these
startup
projects
or
these
college
projects,
or
you
know,
countries
where
computers
and
technology
aren't,
as
you
know,
there's
not
a
ton
of
stuff
laying
around
like
we
have
you
know
today,
and
it
gives
them
the
ability
to
create
these.
These
projects
build
mature
workflows
that
can
get
the
engagement
with
others,
and
it's
just
it's
such
a
nice
thing.
A
A
A
It
goes
straight
into
your
code
and
can
provide
a
lot
of
functionality
where
you
don't
have
to
actually
code
all
of
these
things,
so
the
integration
and
marketplace
will
do
a
lot
of
the
hard
work
for
you
and
then
finally,
the
gate
repository.
I
know
that
everyone's
probably
asking:
why
is
getting
policy
on
on
the
list?
It's
probably
a
key
concept.
We
already
know
with
the
idea
of
actions,
and
you
know
everything
around
actions.
A
A
The
version
of
the
software
within
the
pod
and
the
image
was
too
new
to
use
the
version.
So
if
you
actually
host
your
own
runner,
you
could
be
very
strict
with
the
versioning
that
you
use
so
going
over
to
the
other
side.
The
self
hosted-
and
this
is
the
github
provided
infrastructure,
so
by
default
today,
if
you
were
to
click
on
actions
and
create
a
workflow,
these
are
automatically
provided
to
you.
The
the
interesting
thing
is
that
github
provides
all
the
infrastructure
for
you.
A
So
you
can
ensure
that
you
kind
of
keep
yourself
safe.
You
know
the
whole
time
and
it
makes
a
really
nice
process
and
then
it
allows
you
to
get
community
contributions
on
your
workflow
actions.
It's
not
a
hidden
thing
and
I
bring
up-
and
I
want
to
go
back
to
that
hidden
thing
previously
back
in
my
other
positions
at
red
hat.
I'd
use
jenkins
back
in
the
jenkins.
A
It
makes
it
kind
of
difficult
to
understand
the
workflow
of
what
actually
it
takes
to
kind
of
build
the
project
if
there
was
anything
special
that
had
to
kind
of
occur-
and
I
guess
the
the
nice
part
about
github
actions
is-
is
that
you
can't
really
hide
it,
there's
no
like!
Well,
you
got
to
turn
the
wheel
this
way
just
slightly
to
get
it
to
run.
A
And
then
the
last
item
is
secrets.
Secrets
are
you
know
similar
to
what
we
kind
of
see
with
kubernetes
secrets
you
can
save
specific
blurbs
of
text
or
so
on
within
your
git
repository,
and
this
actually
allows
you
to
use
those
as
environment
variables
or
runtime
variables
for
your
github
actions,
which
is
really
nice.
So
that
way,
you
don't
have
to
worry
about,
like
obfuscating,
a
password
or
doing
that
it
actually
handles.
All
of
that
for
you,
which
is
incredibly
nice.
A
So
I
covered
a
lot
of
stuff
and
I
actually
want
to
take
the
time
now
to
explore
a
repository.
So
hopefully
we
are
seeing
a
repository
right
now.
This
is
one
for
the
get
ops,
primer,
project
and
kind
of
just.
What
I
want
to
show
is
a
few
things
here.
So
the
nice
thing,
I
will
go
back
one
step
and
say
that
this
green
check
mark
is
the
most
stressful
thing
in
the
entire
world.
A
Once
you
have
it
and
your
project
is
passing
happily
and
working
as
it
should.
You
will
do
anything
in
the
world
to
maintain
that
happy
little
check
mark,
because
it's
almost
like
a
seal
of
approval
that
hey
my
stuff's
working.
I
promise
you,
and
so
that's
one
of
the
beautiful
things
a
little
check
mark.
So,
let's
take
a
look
at
like
the
last
run
that
I
have.
This
is
kind
of
advanced
run,
but
I
just
wanted
to
kind
of
show
the
fact
that
you
know
you
can
do
multiple
steps.
A
So
that's
just
a
high
level
actions
we're
going
to
go
back
to
beginner
actions
in
just
a
moment,
so
that
don't
stress
too
hard
is
one
kind
of
show
where
things
are
and
then
going
and
looking
in
settings.
I
had
talked
about
those
secrets
and
the
project
that
we'll
show
today
that
we'll
do
later
on
has
secrets
as
well.
A
But
as
you
see
here,
you
define
the
secrets
key
registry,
whatever
whatever
you
decide,
and
they
provide
a
nice
way
to
update
it.
You
can
just
plop
in
a
value
here
and
the
nice
thing.
Is
you
can't
really
it's?
You
can't
really
see
your
current
value,
so
it
kind
of
makes
it
nice.
You
can't
hack
it
that
way.
I
guess
if,
if
somebody
were
to
see
that
or
try
to
get
into
that,
so
go
back
to
the
presentation.
A
A
A
A
A
At
run
time,
I
can
provide
a
that's
a
stock
ticker
such
as
gme
or
ibm,
and
it
will
give
me
the
value
of
that
stock
at
the
time.
So
it's
kind
of
a
cool
thing
like
if
you're
just
sitting
in
a
computer
and
your
previously
this
year,
if
you're
following
the
gme
stuff,
you
could
get
the
quote
instantly
and
be
able
to
operate.
A
We're
going
to
push
straight
to
maine
because
we
live
dangerously
and
so
go
ahead
to
our
stock
application
here
enter
okay,
so
here
you
see
our
stock
application
and
I
accidentally
uploaded
the
binary
as
well
so
off
to
a
great
start,
ryan,
all
right
that
won't
affect
anything.
But
let's
go
straight
into
actions
and
our
workflow.
A
So,
just
by
clicking
the
actions
button,
it
will
give
you
a
series
of
potential
options
that
you
can
actually
apply
straight
to
your
your
project
and
it
will
automatically
you
know,
set
up
the
workflow
for
you,
though,
looking
here,
this
workflow
is
made
for
your
go
repository,
which
is
exactly
what
we
just
created.
So
I
can
just
one
button
click.
This
verify
that
it
looks
good,
go,
build,
go
test
which
are
the
exact
items
that
I
needed
for
my
project
and
then
go
ahead
and
do
a
commit.
A
A
A
So
when
you're
thinking
about
this
grand
scheme
of
a
really
large
team,
if
you
can
build
this
in
this
workflow
and
the
setup
to
be
fairly
confident
in
the
results
of
what
you're
going
to
get
out
of
it,
you
can
actually
take
this
and
your
team
is
not
pulled
off
to
manually
hand
test
these.
These
new
features
these
new
functionalities.
A
A
A
So
run
it
again
and
then
we
see,
do
you
mean
able
to
actually
see
the
52
week
high
and
lows
now,
so
we
added
that
functionality.
I
didn't
actually
have
to
test
it
on
my
system.
I
just
wrote
code
through
it
to
get
and
let
it
handle
the
hard
parts
of
you
know.
Building
the
binary
testing
it,
and
so
really
cool
thing
about
this
is
as
well.
A
Is
that
if
you
think
about
the
possibilities
here
as
an
example,
last
week,
I
was
sitting
in
the
middle
of
traffic
in
the
passenger
seat
of
a
car
in
chicago
writing
code
against
my
application
on
my
phone
and
the
nice
part
about
that
was.
Is
that
I
could
just
fire
and
forget
and
know
that
all
of
the
testing
was
going
to
take
place.
I
just
have
to
worry
about
writing
the
code
and
if
it
was
successful,
then
I
knew
that
any
of
my
changes
were.
A
A
A
A
A
A
A
A
A
A
A
A
So
let's
go
ahead
and
get
into
these
jobs.
So
what
we're
going
to
do
is,
like
I
said
earlier,
we're
going
to
do
a
build,
we're
going
to
run
this
on
ubuntu
latest
and
we're
going
to
check
out
our
source
code
for
market
repository.
This
action
slash
checkout
at
v2.
This
is
automatically
I
guess
known
or
built
into
github
we're
going
to
see
a
couple
more
of
these
as
we
go
actually
the
next
step,
the
next
step
we're
going
to
build
an
image
and
you're
going
to
see
this
here.
A
In
regards
to
setting
up
your
environment
and
then
with
our
source
image
stuff,
as
you
see
we're
going
to
provide
our
kind
of
image
that
we're
going
to
create
source
image
off
of
so
that
we're
going
to
use
the
php
application,
the
php
base
and
then
anytime,
that
we
create
this
image.
We
want
to
tag
it
as
the
image
name
of
uploader
and
with
the
tags
of
the
github
sha.
A
The
nice
thing
about
this
is
is
that
we
can
take
that
that
tag
and
image,
and
we
can
either
update
a
deployment
with
it
and
roll
out
the
latest
deployment
within
openshift.
We
could
just
shove
this
into
a
deployment
yaml
which
our
good
off
system
could
take
over.
At
that
point,
it
gives
us
a
lot
of
a
lot
of
good
starting
points,
and
the
nice
thing
is:
is
that
it's
a
unique
image
name
that
allows
us
to
be
able
to
trigger
and
do
events
off
of.
A
So
if
we
go
into
our
github
actions,
we
see
one's
already
ran,
but
we're
going
to
run
one
anyway.
This
was
that
line
that
I
was
talking
about
that
workflow
dispatch.
So
we're
going
to
go
ahead
and
run
the
workflow
from
our
branch,
we'll
wait
for
it
to
kick
off
and
again
we're
using
that
infrastructure
provided
by
github.
A
A
And
then
upon
success,
it
is
done
because
right
now
we're
only
building
the
image.
So
at
this
point
we
need
to
add
some
more
functionality
to
it.
This
would
be
a
great
thing
to
have.
If
you
had
multiple
open
shift
environments,
you
can
do
this
step
to
push
your
image
to
quay
and
then,
when
each
of
those
remote
environments
or
test
environments
or
various
environments
or
ready,
they
could
just
grab
the
image
they
would
have
it
from
quay
so
time
to
move
on
to
the
quiz
steps.
A
A
A
So
we're
building
the
image
now
and
then
we
are
logged
into
clay
and
we
are
pushing
that
to
the
repository
now
and
we
got
our
happy
green
check
mark.
We
have
officially
taken
and
done
a
source
to
image
with
christian's
code
taken
that
packaged
it
up
in
an
image
using
github
actions
and
then
sent
that
to
clay
to
be
able
to
be
used
by
multiple
openshift
clusters.
A
A
All
right-
and
so
this
is
the
standard
token
display
token
page-
we
will
come
back
just
in
a
second.
I
will
probably
pull
this
across
as
well
just
to
keep
the
token
it,
but
I
will
show
you
what
we're
going
to
do
with
the
token
in
a
second
we're
going
to
use
that
token,
as
well
as
the
server
address
the
server
url
and
a
namespace
to
deploy
that
image.
So
let's
go
ahead
and
write
that
deploy
code,
and
then
we
will
do
our
secrets.
A
A
Then
I'm
going
to
pull
this
across
real
quick
so
that
I
can
put
in
my
actual
secrets
and
server
name
and
the
secret
that
I'm
actually
loading
right
now
is
the
open
shift
token.
This
is
just
the
one
that
when
you
request
the
oauth
values,
it
provides
you
the
token
and
it's
good
for
x,
number
of
hours
or
whatever
your
administrator
provides
at
the
time
and
then
lastly
I'll
be
doing
my
openshift
server.
A
A
A
Though
I
am
using
just
kind
of
a
quick
way
to
do
this,
this
would
be
something
that
you've
maybe
used
in
a
test
environment,
an
environment
that
doesn't
use
get
ops,
but
I'm
actually
just
going
to
deplete,
delete
the
deployment,
delete.
The
routes,
delete
the
service
and
then
use
oc
new
app
to
create
a
new
deployment
based
off
of
the
image
that
I
created
in
the
steps
above
and
then
we're
going
to
expose
it.
A
A
A
If
the
build
does
not
pass,
we
will
never
get
to
the
deploy
steps
and
then
the
last
part
we're
not
going
to
add
in
here.
Is
this
this?
If
statement,
and
what
this,
if
statement
is
going
to
do,
is
that
even
if
it's
a
pr,
it
will
not
execute
this
this
step
here,
unless
the
branch
itself
is
master,
unless
there's
a
push
to
the
master
branch,
and
what
this
is
going
to
do?
A
Is
it's
going
to
kind
of
save
us
from
pushing
when
we're
not
ready
or
deploying
we're,
not
ready
or,
for
example,
if
you're
doing
a
like
testing
of
multiple
images,
you
don't
want
to
just
send
those
to
acquire
processor
to
take
up
space
or
to
not
be
potentially
used.
So
we
can
put
this
in
and
only
upon
our
master
branch
merging.
A
A
So
that's
just
a
nice
little
like
stopper,
just
to
kind
of
keep
you
a
little
bit
safe
and
make
it.
So
when
we
verify
that
this
image
is
good
and
ready,
then
we
merge
it
and
then
our
default
action
that
we
initially
set
up
will
take
place
just
here
in
a
moment
and
as
you
see,
we
merged
it,
and
this
is
actually
going
to
do
our
step
of
pushing
it
to
our
openshift
environment.
A
So
I'm
gonna
actually
take
now
go
back
to
the
slides
and
kind
of
wrap
things
up
and
leave
some
time
for
questions.
So
I
have
a
couple
links
here.
The
first
link
is
to
a
presentation
done
by
red
hat
and
github.
Both
the
johns
show
a
very
in-depth,
open
shift
and
github
action
scenario
much
deeper
than
this,
showing
all
of
those
integrations
in
the
the
marketplace
that
we
showed
earlier.
They
were
the
brains
behind,
creating
that
the
second
link
you'll
see,
is
a
link
to
introduction
to
github
actions.
A
This
is
just
a
nice
starting
point
that
if
I
missed
anything
or
if
there's
anything,
you
kind
of
have
questions
on
it
provides
that
really
detailed
write
up
on
how
to
kind
of
get
this
off
the
ground
and
then.
Finally,
if
you
would
like
to
kind
of
get
a
hold
of
me,
if
you
have
any
questions
that
you
didn't
get
to
answer
chat
or
if
you
watch
this
at
a
later
date,
here's
my
twitter
handle
as
well
as
my
email
address.
B
B
A
B
B
A
So
you
can
re-kick
off
the
jobs.
I
do
not
think
that
you
can
do
them
that's
out
of
order.
I
can
jump
back.
Let's
go
back
to
our
demo
here
and,
let's
see,
let's
see
what
we
can
do.
If
I'm
in
the
second
part
of
this
yeah,
it
looks
like
there's
just
a
rerun
all
option
I
can't
seem
it
doesn't
seem
like
I
can
segment
off
and
just
do
one
job
out
of
the
collection.
A
A
B
I
just
really
realized.
I
was
muted,
sorry,
everyone
all
right,
ryan,
since
you're
in
the
emerging
technologies
office.
What
else
have
you
been
looking
at?
You
look
at
things
before
we
do.
You
know
we
take
what
you're
doing
and
try
to
make
the
product
better
right.
So
what?
What
can
you
share
with
us.
A
So
there's
been
a
couple
projects
that
have
been
really
kind
of,
in
my
opinion,
game,
changers
and
they're
actually
already
in
motion
to
be
hopefully
brought
into
products.
Productized
soon
describe
project
that
I
mentioned
earlier,
the
spread
project.
What
it
does
is
it
allows
you
to
replicate
data
from
replicate,
persistent
data
that
is
from
one
openshift
cluster
to
another
or
one
openshift
cluster.
To
many.
A
For
example,
I
found
this
jar
file.
It's
going
to
throw
it
into
the
developer,
console
and
see
if
it
benefits
our
group
and
then
from
there.
I
can
click
a
few
buttons
and
then
download
all
of
that
object,
gml
and
then
use
that
to
either
deploy
into
a
development
cluster
or
put
into
a
get
ops
tooling.
A
A
B
B
A
I
mean,
I
think,
it's
just
an
amazing
part
of
technology.
I
do
really
like
the
fact
that
it
is
so
forward-facing
I
feel
like
it
lowers
the
barrier
of
understanding
and
figuring
how
to
run
something,
because
people
can
kind
of
see
it.
People
will
be
able
to
understand
what
it
runs
on
or
how
it
runs
it's
just,
and
that
green
check
mark
really
makes
you
feel
good
at
the
end
of
the
day,
because
you
know
that
it's
going
to
successfully
deploy
if
you
follow
the
kind
of
steps
in
the
repository.