►
Description
Between running unit tests, validating machine learning models, and deploying projects there are numerous tasks outside of writing code which often involves interacting with external tools. This takes developers out of the flow, slows development, and increases the likelihood of mistakes. Automating these processes with a toolkit which meets developers where they are ensures consistency and improves velocity. Join us as we explore how GitHub Actions can automate tedious tasks
Chapter Markers
01:40 - Introduction/Importance of automation
05:45 - GitHub Actions
14:27 - Creating an Actions workflow
54:20 - Other features/Closing
Stay up-to-date on all things GitHub by subscribing and following us at:
YouTube: http://bit.ly/subgithub
Blog: https://github.blog
Twitter: https://twitter.com/github
LinkedIn: https://linkedin.com/company/github
Instagram: https://www.instagram.com/github
TikTok: https://www.tiktok.com/@github
Facebook: http://fb.com/github
About GitHub
It’s where over 100 million developers create, share, and ship the best code possible. It’s a place for anyone, from anywhere, to build anything—it’s where the world builds software. https://github.com
A
But
in
the
meantime
Let's
let's
get
rocking
and
rolling
looks
like
everything
is
good
so
good
morning,
good
afternoon
good
evening,
depending
on
where
in
the
world
you
happen
to
be,
my
name
is
Christopher
Harrison
I'm,
a
senior
Enterprise
Advocate
at
GitHub,
and
today
we're
going
to
see
how
we
can
automate
tasks
with
GitHub
actions
good
morning
good
morning.
So
we
are
live
here.
A
This
session
is
going
to
be
recorded
and
shared
out
later,
but
we
are
live
so
please,
by
all
means,
feel
free
to
go
ahead
and
ask
questions
in
the
chat
down
below.
If
you
see
me
looking
down,
that's
because
that's
where
my
my
screen
is
for
for
all
of
chat,
so
that's
sort
of
what
I'm
doing
down
there,
but
I'll
be
keeping
an
eye
on
that
and
doing
my
absolute
best
to
to
answer
questions
so
without
any
further
Ado.
A
A
The
way
that
they're
done
is
we'll
just
go
ahead
and
have
some
external
tool
and
somebody
will
go
off
and
they'll
do
it
on
their
own
and
that
really
winds
up
costing
us
an
awful
lot
of
productivity.
It
costs
us
an
awful
lot
of
money
because
it's
going
to
mean
that
those
checks
could
be
bypassed.
We're
going
to
take
developers
out
of
the
Zone
Etc,
and
so
automation
really
does
become
key
to
success.
A
That
again,
you
know
we
just
continue
to
see
this
that,
depending
on
how
good
your
automation
process
are
you're
going
to
be
faster
to
Market
you're,
going
to
see
improved
product,
Innovation
and
you're
also
going
to
increase
customer
satisfaction,
because
you're
going
to
reduce
the
amount
of
time
that
it's
going
to
take
to
respond
to
customer
requests.
So
the
tldr
on
all
of
that
is
basically
automation.
Good
automation
move
faster.
A
So
how
do
we
do
this
then?
And
when
we
look
out
onto
the
landscape,
what
we're
going
to
see
is
the
fact
that
there
are
a
ton
of
tools
that
are
out
there.
That
will
allow
you
to
automate
this
that,
obviously
this
is
a
problem
space
that
many
people
are
aware
of,
and
many
people
have
gone
out
to
try
and
solve
the
catch
is,
though,
that
a
lot
of
organizations
when
they
go
out
and
they
start
kind
of
piecing
all
of
this
together?
Is
they
wind
up
with
exactly
that?
A
They
wind
up
with
a
piecemeal
approach,
and
so
now
I've
got
to
go
to
this
tool
to
do
this
and
this
tool
to
do
this
and
this
tool
to
do
this,
and
that
leaves
us
with
a
complicated
stack.
It
leaves
us
with
developers
needing
to
figure
out
how
to
use
brand
new
tools,
and
it's
also
in
turn
going
to
mean
that
we're
going
to
both
increase
the
maintenance
overhead,
but
also
increase
the
chances
that
steps
are
going
to
be
missed.
Steps
are
going
to
be
bypassed.
A
Steps
are
going
to
be
skipped
because
if
my
developer
needs
to
go
off
and
use
this
tool
over
here,
they're
going
to
be
a
little
less
likely
to
do
that.
They
want
to
stay
right
where
they
are,
they
want
to
keep
writing
code
and
that's
where
GitHub
actions
comes
into
play
is:
let's
meet
our
developers
right
where
they
are,
and
so
with
GitHub
actions.
What
we're
going
to
notice
is
that
all
of
that
automation
is
literally
a
tab
away.
A
All
of
the
definitions
that
we're
going
to
have
for
all
of
our
workflows
are
going
to
become
part
of
the
repository.
So
now
my
developers
don't
need
to
leave
now
my
developers
don't
need
to
learn
a
full
new
set
of
tools
that
they
can
keep
doing.
What
it
is
that
they're
doing.
Where
does
they're
doing
it
and
take
advantage
of
this
automation
so
what's
built
into
GitHub
actions?
How
is
it
that
we
are
focused
on
creating
this
product?
A
Let's
kind
of
kick
through
a
couple
of
slides,
real,
quick
and
then
we'll
get
into
a
little
bit
more
technical,
which
I
think
is
probably
what
most
people
are
going
to
be
here
for
number
one
is
looking
for
that
best
developer
experience,
and
this
is
true
for
I-
think
really
everything
that
we
do
at
GitHub,
that
we
want
to
make
sure
that
developers
love
the
tools
that
they
have
access
to,
that
we
have
a
a
slide.
We've
got,
you
know
100
million.
This
is
actually
true.
A
Sorry,
we
do
have
100
million
developers
on
GitHub
and
you
don't
reach
100
million
by
solely
focusing
in
on
business
customers
that
you
hit
that
number
by
having
developers
that
choose
GitHub,
that
look
at
the
tools
that
we
have
and
go
hey.
That's
what
I
need
and
that's,
because
we
focus
in
on
making
sure
that
we
have
that
best
developer
experience.
We
talked
already
about
having
that
automation,
Right,
Where,
You
code,
you'll
notice,
it's
going
to
be
a
tab
away,
you'll,
also
notice.
A
Those
definitions
will
become
part
of
the
Repository
one
of
the
other,
very
big
things.
One
of
my
favorite
phrases
is
we're
not
launching
Rockets
here
and
the
point
that
I'm
making
when
I
say
that
is
whatever
it
is,
that
we're
doing
somebody
else
is
already
done,
and
so,
rather
than
us
going
off
and
recreating
everything
from
scratch.
A
And
you
can
actually
do
this
in
a
couple
of
different
ways
that
you'll
have
the
ability
to
run
things
on-prem?
If
you
so
desire-
or
you
can
run
in
the
cloud
run
on
our
cloud
and
we
can
scale
out
with
you
as
well-
and
we
can
also
ensure
that
when
you
go
to
do
deployment
that
you're
able
to
do
that
securely,
okay,
so
that's
all
of
that.
Let's
go
ahead
and
take
a
real,
quick
sip
of
coffee.
Here,
always
important.
A
And
then,
let's
kick
on
into
GitHub
actions
and
how
we're
going
to
do
this?
Where
we're
going
to
do
this
and
a
couple
of
of
different
examples,
so
first
up
is
to
access
all
of
your
workflows.
So
my
workflows
are
going
to
be
some
defined
set
of
automated
tasks
that
I
want
to
access.
All
of
them
see
all
the
ones
that
are
defined,
see
the
history
Etc.
All
of
that's
going
to
be
right
there
off
of
the
actions
tab,
so
I
can
just
open
up.
A
A
Now
I
got
to
be
honest
with
you
here:
I'm,
not
necessarily
the
biggest
fan
of
yaml
I'll
I'll
openly
admit
that
and
I
know,
there's
a
lot
of
people
that
get
a
little
bit
kind
of
funny
about
yaml
and
I
get
it
because
of
the
fact
that
it's
It's
So
based
on
white
space,
and
it
can
sometimes
be
tricky
to
know
exactly
where
it
is
that
things
need
to
be
tabbed
into
and
and
so
forth.
That
being
said,
though,
I
actually
do
find
for
defining
workflows.
That
yaml
actually
feels
pretty
natural
here.
A
So
I
actually
do
like
yaml
in
in
this
situation,
which
is
not
something
that
I
often
say,
but
it's
very
true
here.
So
all
of
that's
going
to
be
inside
of
that
workflow
folder
and
then
last
but
not
least,
when
you
go
to
create
a
brand
new
workflow
you'll
notice
that
there's
a
set
of
ones
that
will
be
suggested
for
you,
that's
provided
both
by
us
and
also
you
can
create
your
own
starter,
workflows
as
well,
and
these
can
be
filtered
based
on
the
type
of
project.
A
So
if
I
do
a
net
project,
it's
going
to
show
me
one
thing:
if
I
do
a
node
project,
it's
going
to
show
me
something
different
and
in
this
example
here
it's
got
a
Java
project
and
that
is
then
showing
you
that
so
we
provide
those.
But
you
can
also
provide
your
own
starter
as
well
cool.
So
there's
a
question
here
is:
is
there
a
way
that
I
as
an
organization,
could
publish
private
actions
and
workflow
templates
to
specific
orgs
to
specific
GitHub
orgs
or
your
customers.
A
A
A
I
think
so,
but
I
honestly
don't
know
the
answer
to
that
question.
I'm
gonna
be
totally
honest
here.
So
let
me
let
me
give
like
a
little
bit
of
of
a
little
bit
of
background
there.
So
you
can
obviously
create
your
own
actions
and
you
can
do
this
by
writing.
Javascript.
You
can
do
this
by
creating
shell
scripts
and
do
a
whole
host
of
other
things
to
create
your
own
actions
and
then
you
can
actually
publish
them.
I
know
for
certain
in
one
of
a
couple
of
different
ways.
A
So
one
of
the
ways
that
you
could
do
that
is
to
push
that
out
to
the
marketplace,
make
it
available.
It
is
also
possible
for
you
to
publish
out
to
your
own
Enterprise
and
the
way
that
you
do.
That
is
really
just
by
making
a
repository
someplace
inside
of
an
org
inside
your
Enterprise
and
then
when
a
workflow
needs
to
call
that
they
just
simply
reference
it
just
like
they
would
something
inside
of
the
marketplace.
A
Now,
when
you
leave
your
Enterprise
that
I
don't
know
the
answer
to
that
I
think
the
answer
is
yes,
but
I'm,
not
100.
Certain
Garrett
I
know
is
is
on
the
call
so
I'm
going
to
test
Garrett
here.
If
he
wants
to
take
a
real,
quick
note
and
I
can
follow
up
with
you
on
that,
you
can
also
just
drop
me
an
email.
Let
me.
A
Up
right
into
in
the
chat
here,
you
can
just
drop
me
an
email
and
I'll
get
back
to
you
on
that
I
I
want
to
say
the
answer
is
yes,
but
I,
don't
know
for
100
certainty
and
and
I
also
don't
know
how
to
do
it.
But
I'll
get
back
to
you.
That's
a
great
question,
though.
Okay,
but
it
is
possible.
You
want
to
make
sure
that
I
highlight
that
it
is
possible.
A
A
Next
JS
react
application
and
right
now,
I
don't
have
any
actions
to
find,
and
so,
when
I
come
over
here
to
my
actions,
what
I'm
going
to
notice
is
it
just
gives
me
the
list
of
suggested
starters
and
I
could
go
ahead
and
choose
one
of
these.
If
I
want
or
I
can
create
my
own
workflow
and
when
I
create
my
own.
A
A
A
So
I'm
going
to
start
with
kind
of
a
basic
and
then
we'll
get
into
a
a
real
world,
one
after
that.
So
first
thing:
here's
a
name
just
like
that.
I
I
think
this
is
kind
of
pretty
well
known,
but
naming
things
always
going
to
make
your
life
that
much
easier,
especially
because
when
I
go
into
that
actions,
tab
that
name
that
I
specify
here.
A
A
I
can
Define
all
of
my
jobs
by
giving
them,
of
course,
names
which
I'm
going
to
do
in
a
second.
But
the
big
thing
we
want
to
remember
about
jobs
is
that
by
default,
your
jobs
are
going
to
run
asynchronous
they're,
going
to
run
in
parallel,
they're
all
going
to
run
at
the
same
time.
So
this
can
be
a
great
way
that
if
I
know
I
need
three
or
four
things
all
to
happen.
One
shot
I
can
go
ahead
and
do
that
right
here.
A
But
what
happens
if
I
want
to
use
my
jobs
to
kind
of
break
something
down
into
smaller
chunks
and
I
need
to
make
sure
that
this
one
runs
first,
and
this
one
runs
second,
and
this
one
runs
third,
not
a
problem.
You
can
create
relationships
between
your
jobs,
so
what
I
can
basically
do
is
I
can
create
a
job
here
and
then
I
can
create
a
job
down
below
that
says.
Hey
depend
on
that
first,
one
in
order
to
run
successfully
okay.
A
So
let
me
give
this
a
name,
and
this
will
be
a
display
greeting
like
that
and
then
now
I
can
indicate
where
it
is
that
I
want
this
to
run.
So
all
jobs
need
a
runner,
because
after
all,
this
is
going
to
do
something.
This
is
going
to
run
some
code.
It's
going
to
run
a
bash
script.
It's
going
to
run
one
of
the
actions
from
the
marketplace.
It's
going
to
do
something
so
I
need
to
identify
where
this
is
going
to
run
and
by
default.
A
You'll
have
access
to
Windows,
to
Mac
OS
and
to
Linux.
Now
you
can
also
go
in
and
create
your
own
custom
runners
in
the
cloud
and
one
of
the
biggest
reasons
that
you'll
do.
That
is
to
choose
the
sizing
of
that.
So
if
you
want
to
get
a
bigger
Runner
and
you
need
that
to
run
a
little
bit
faster,
you
can
do
that
and
you
also
have
the
ability
to
self-host
your
Runners
as
well.
So
if
you
want
to
run
that
internal,
maybe
you've
got
specialized
Hardware
that
it
needs
to
run
on
you.
A
A
It
runs
correct,
I
meant
run
there.
We
go
okay,
nice,
having
that
little
bit
of
of
a
helper
there
to
help
point
me
in
the
right
direction,
and
so
now
this
is
just
going
to
run
a
bar
script,
and
that
is
one
of
the
nice
things
here
is
that
you've
got
full
flexibility,
so
you
can
use
an
action.
You
could
also
just
run
bass
scripts.
You
can
run
JavaScript,
you
can
sort
of
really
do
whatever
it
is
that
you
want
to
do
here.
A
All
right,
so
I've
got
my
little
hello
world.
We've
got
our
Basics,
let's
go
ahead
and
Commit
This
directly
to
Main
chugga,
chugga
chugga,
and
now
it's
right
there
and
now,
if
I
go
over
to
my
actions
now,
I
can
see
that
display
hello.
World
I
can
run
my
workflow
hit,
run
workflow
and
then
just
give
this
a
moment.
A
There
we
go,
and
now
I
can
open
up
my
my
screen
here
and
then
I
can
see
this
run.
So
what
I'm
doing
here?
What
I've
got
here
is
this
is
now
the
log
of
that
workflow.
So
I
can
watch
this
running.
I
can
see
a
visual
breakdown
of
all
the
jobs
that
are
inside
of
here
and,
if
I
open
this
one
up,
I
can
now
see
everything
that
happened
behind
the
scenes.
There's
the
little
setup,
there's
that
little
run
Echo
and
now
I
can
see
my
hello
world.
So
there
is
our
first
action
cool.
A
Now
that's
cute
and
all,
but
how
about
something?
That's
going
to
be
a
little
bit
more
real
world!
Okay,
I
hear
you!
So
let's
go
back
over
here
to
my
code
and
let's
explore
my
project
a
little
bit
more
and
what
you're
going
to
notice
inside
of
my
project
is
that
if
I
open
up
my
source,
folder
I'm
gonna
have
a
Cypress
folder
and
if
I
open
up
my
Cypress
folder
I've
got
some
e2e
or
some
end-to-end
tests.
A
So
if
you're
not
already
familiar,
Cyprus
is
a
testing
framework
for
web
applications.
It
does
end-to-end
tests,
so
what
I
can
do
is
actually
have
it
run
the
page
and
then
I
can
explore
the
page
looking
for
certain
elements
and
certain
behaviors
and
so
forth,
so
I
could
script
out.
For
example,
hey
punch
this
into
a
text
box
hit
submit.
Make
sure
that
the
next
page
that
comes
up
is
what
we
want
it
to
be,
or
I
can
like.
A
A
Running
tests
is
going
to
be
a
big
part
of
that
and
when
we
again
sort
of
step
back
and
get
a
little
bit
more
into
definitions
here,
one
of
the
biggest
phrases
that
you're
going
to
hear
is
CI
CD
and
sometimes
those
two
terms
are
used
interchangeably.
But
they
really
do
mean
different
things.
That
CI
continuous
integration
is
the
process
of
me.
Bringing
code
into
my
code
base
CD
continuous
delivery.
A
Bringing
this
back
to
CI
when
we're
running
CI
we're
typically
going
to
be
looking
at
some
form
of
a
build
process.
We're
going
to
be
looking
at
running
unit
tests,
we're
going
to
be
running
Security
checks
or,
in
this
case
we're
going
to
be
running
our
end-to-end
tests.
So
I've
already
got
this
defined
as
part
of
the
repository.
The
question
now
becomes.
How
do
I
make
sure
that
that
is
going
to
be
automated
and
the
answer
for
that
is
going
to
be
doing
that
with
an
action
now,
I
could
go
back
to
the
actions.
A
Tab
and
I
could
create
a
new
workflow
from
here,
but
this
action
is
going
to
be
a
little
bit
more
complex,
so
I
want
a
slightly
better
editor,
so
you're
going
to
get
a
bonus
tip
as
part
of
this.
So
I've
got
my
repository
right
here
and
I'm
going
to
hit
dot
on
my
keyboard,
and
what
this
will
do
is
this
will
now
open
up
a
very
lightweight
version
of
Visual
Studio
code
right
here
inside
of
my
browser.
A
This
is
completely
free.
This
is
built
right
in
if
you
are
using
GitHub
Cloud.
This
is
available
to
you.
Everything
that's
running
here
is
going
to
be
in
the
browser.
Now.
What
that
does
mean
is
that
I'm
going
to
have
relatively
limited
support
for
extensions
and
things
like
that,
but
if
all
that
I
need
is
a
lightweight
editor
with
a
bit
of
intellisense,
this
is
perfect
for
the
job.
This
is
exactly
what
I
want
for
that,
and
so
what
I
can
see
right
here
is.
A
Tests
dots
yaml
like
that,
okay
and
now
I'm
just
going
to
do
all
of
that
right
here.
So
let
me
get
that
off
to
the
side.
Let
me
make
this
a
little
bit
bigger.
There
we
go
and,
let's
start
creating
it
so
again,
name
and
we'll
say,
run
Cypress
tests
and
then
we'll
go
ahead
and
specify
our
on
now,
when
we're
talking
about
a
situation
like
this,
where
I'm
going
to
be
running
unit
tests
and
I
want
this
as
part
of
my
CI
I
want.
This
is
part
of
my
continuous
integration.
A
A
So
now
this
is
only
going
to
run
on
pull
requests
and
I
can
also
then
specify
that
I
only
wanted
to
look
at
specific
branches.
So,
for
example,
I
only
want
this
to
run
on
the
main
branch.
So
when
somebody
makes
a
pull
request
into
main,
this
set
of
tests
is
now
going
to
run
excellent
and
I'm
going
to
come
back
in
a
little
bit
and
take
a
look
at
how
we
can
enforce
that.
A
A
Okay.
So
let's
talk
about
this
for
a
second
and
let's
sort
of
like
kind
of
break
this
down.
So
what
I
want
to
do
is
I
want
to
run
some
end-to-end
tests
and
those
are
end-to-end.
Tests
are
defined
as
typescript
files
inside
of
the
project.
So
in
order
to
do
this,
I'm
really
going
to
need
two
things.
The
first
thing
that
I'm
going
to
need
is
I'm
going
to
need
the
code
and
then
the
second
thing
that
I'm
going
to
need
is
the
tests
themselves.
A
I,
don't
know
why
you
are
bugging
me
about
my
iPhone.
In
any
event,
we'll
get
rid
of
that.
Let's
keep
on
moving
okay,
so
two
steps,
I'm
gonna,
need
to
to
go,
grab
my
code
and
then
I'm
going
to
need
to
actually
run
the
tests,
and
if
we
remember
back
to
something
that
I
mentioned
a
couple
of
minutes
ago,
these
are
common
tasks.
A
So
the
first
thing
that
I
need
to
do
is
check
out
my
code,
I
say
check
out
sure
enough,
there's
an
action
right
there
and
then
the
next
thing
is,
if
I
do
a
search
for
Cypress,
but
I
also
see
that
there's
a
Cypress
action
as
well,
so
both
of
those
are
right
there
and
I
can
now
just
take
advantage
of
them
and
you'll
even
notice.
They
give
you
some
nice
little
examples
as
well
on
how
to
do
all
of
this,
so
I'm
actually.
A
A
Yes,
it
is.
We
need
to
go
check
out
our
code
and
so
we're
going
to
take
advantage
of
that
actions.
Checkout
and
then
you'll
also
notice,
right
here
at
the
end
that
little
V3.
What
we're
doing
here
is
we're
pinning
this
to
a
specific
version
of
the
action,
and
that
allows
us
to
know
then
what
the
code
is.
That's
going
to
be
running
as
part
of
that
action
that
we're
using
so
best
practice,
pin
it
to
a
particular
version.
A
Then
you're
going
to
notice
down
below
we've
got
our
next
step
right.
Here,
that's
going
to
do
Cypress,
Run,
and
that's
now
going
to
use
that
Marketplace
action
to
do
our
run
now,
for
my
end
to
end
tests,
there's
actually
a
couple
of
things
that
I
need
to
confirm
for
here
then
I
need
to
make
sure
that
my
project
builds
correctly.
I
need
to
make
sure
that
things
start
correctly
and
I
also
need
to
make
sure
that
things
are
configured
correctly,
because
this
application
uses
a
database.
A
So
how
do
I
set
all
of
that
up?
Well,
each
action
is
going
to
typically
have
some
set
of
parameters
that
you're
going
to
be
able
to
specify.
So
if
I
scroll
on
down,
in
the
case
of
like
the
end
to
end
test
you're
going
to
notice
that
you
can
specify
a
browser
of
Chrome
or
Firefox.
If
you
want
to
do
specific
testing
for
one
particular
browser,
you
have
that
ability.
A
You
also
have
the
ability
to
specify
environment
variables
which
we'll
get
to
in
in
just
a
couple
of
seconds
here
and
if
I
keep
scrolling
on
down
I
want
you'll
notice.
We
have
the
ability
to
specify
where
the
tests
are
and
that's
going
to
be
done
with
project
and
there's
also
the
start
in
the
build
which
are
down
here
eventually,
which
we
can
get
to
okay.
A
So,
let's
specify
those
so
I'm
going
to
do
that
by
doing
with
and
then
we'll
say
our
start
command,
which
will
be
npm,
Run
start
or
build
command
which
will
be
npm,
run,
build
and
then
the
project
which
is
going
to
be
where
our,
where
our
tests
are
going
to
be
located,
is
going
to
be
inside
of
SRC
I
want
to
slash
on
that.
Let
me
go
back
and
I'm
just
going
to
double
check
here.
A
A
I
could
if
I
wanted
to
hard
code
a
connection
string
here,
but
that's
typically
not
something
I
want
to
do
for
two
reasons.
Number
one
is
because
that's
going
to
make
this
less
usable
later
on,
but
also
because
number
two
later
on
at
some
point,
I
might
want
to
run
this
with
a
different
connection.
String
and
I.
Don't
want
to
have
to
come
back
to
this
workflow
and
update
this
that
this
is
pretty
true
universally,
that
anything,
that's
external,
anything
that
might
change.
A
A
Now,
with
a
secret,
what
we're
going
to
see
is
that
I'll
be
able
to
Define
this
on
the
repository
and
that
will
now
be
protected
from
viewing
eyes
from
basically
anywhere
that
will
be
passed
into
the
action,
but
that
is
then
going
to
be
it
so
now,
I've
got
this
full
action
defined.
So
I've
got
my
name
up
top,
it
says
hey.
This
is
going
to
run
anytime,
there's
a
pull
request
into
Main
and
then
what
it's
going
to
do
is
it's
going
to
go
check
out
my
code.
A
It's
going
to
run
that
Cypress
action
by
doing
a
start,
a
build!
It's
going
to
find
all
my
tests
in
slash
source
and
then
last
but
not
least,
is
we're
passing
in
that
environment
variable
cool.
Let
me
push
this
up
into
main
from
here.
Add
e2e
tests
beautiful
and
then
push
that
up,
and
now
that
is
inside
of
my
Repository.
A
And
we
can
see
that
right
here,
all
right
now.
What
we're
going
to
notice
if
I
come
over
here
to
actions
is
that
this
hasn't
run
yet
and
you're
also
going
to
notice
I,
don't
have
an
ability
to
run
this,
and
the
reason
for
that
is
that
the
trigger
is
based
on
a
pull
request.
So
we'll
come
back
and
make
a
pull
request
in
a
couple
of
minutes
there,
but
I
want
to
highlight
our
little
secret,
so
I
brought
up
the
settings
for
my
repository
here
went
over
to
settings.
A
A
So
we
can
it'll
walk
through
creating
a
brand
new
one
and
I'm
going
to
say
new
repository
Secret
and
we'll
give
this
a
name,
mongodb
URI
and
then
we'll
give
this
a
secret
of
in-memory
and
by
the
way
in
memory
inside
the
application
itself
there's
a
flag,
and
so
it
will
look
for
this.
As
the
connection
string
and
if
it
sees
that,
then
it
will
use
an
in-memory
version
of
mongodb.
A
So
this
is
going
to
be
right.
Only
I'm,
not
even
able
to
read
this
value.
It
will
be
passed
into
the
action,
so
the
action
will
be
able
to
use
it,
but
I'm
not
going
to
be
able
to
see
that
from
here
cool
all
right.
So
now
let's
go
ahead
and
create
a
pull
request.
So
let
me
come
over
here
to
my
my
source
control.
Let
me
create
a
brand
new
branch
and,
let's
say
update
code
because
I'm
very
creative
in
my
naming
switch
over
to
that
branch.
A
If
you
pick
up
nothing
else
from
today,
coffee
helps
all
right.
So
now
let
me
open
up
my
app.js.
Let's
go
find
my
header
and
currently
that
has
the
correct
value
in
that.
Currently,
that
says,
pets
and
let's
give
that
a
bad
value.
So,
let's
say
wrong
header
exactly
Collins
got
the
right
idea,
all
right
wrong,
header
cool!
A
A
Let
me
go
over
to
my
actions
taboo
and
we
can
actually
watch
this,
and
this
is
going
to
take
it
a
couple
of
minutes
here
to
to
do
its
thing,
because
what
it's
going
to
need
to
do
is
to
do
a
fair
amount
of
like
installing
before
it
finally
gets
to
a
point
where
it
can
run
the
tests.
So
this
is
probably
going
to
take
it
about
like
three
or
four
minutes
here.
A
While
this
is
doing
its
thing,
it
gives
me
an
opportunity
to
kind
of
mention
a
couple
of
things.
Thank
you.
Javier
I
appreciate
that
number
one
is.
You
do
have
an
ability
to
specify
larger
runners
and
there's
a
little
bit
of
of
sort
of
like
a
I,
don't
necessarily
want
to
say
Catch
22,
but
there's
a
little
bit
of
a
trade-off
there
that
when
we
think
about
using.
A
Larger
Runners
we're,
of
course,
gonna
have
to
pay
for
that
and
the
the
bigger
the
runner
then
the
more
money
you
wind
up
having
to
to
spend
on
that.
But
on
the
flip
side
your
larger
Runner
is
going
to
run
faster
and
in
the
long
run
it
can
actually
save
you
money,
because
it's
then
less
downtime
in
having
to
wait
for
and
having
to
wait
for
for
that
to
run.
Okay,
let's
see
timed
out.
A
That
timeout,
why
is
that?
Oh
I,
wonder
hold
on
I,
might
have
I
might
have
a
I
might
have
made
a
mistake,
hold
on
one
sec
hold,
please.
Let
me
just
double
check.
It
is
mongodb.
It
is
in
memory,
okay,
all
right
that
air
just
doesn't
look
like
the
right
error.
That
error
does
not
look
like
the
one
that
I
was
expecting
so.
A
You
know
what
I'm
going
to
do:
I'm
just
going
to
use
this
as
an
opportunity
to
kind
of
highlight
a
couple
of
other
things.
So
let
me
just
go
back
to
my
secrets
here
and
let
me
kind
of
refresh
that
and
make
sure
that
that
looks
good.
So
mongodb
you
are
I,
no,
don't
remove
it.
We
can
just
edit
it
and
let's
in
memory,
update
pretty
sure,
I
typed,
that
correctly
all
right
and
now,
let's
come
back
over
here
all
right.
A
But
let's
say
that
I've,
you
know
made
an
update
somewhere
like
I
just
did,
and
now
all
I
want
to
do
is
just
rerun
that
right
here,
I
always
have
an
ability
to
re-run
the
job,
and
so,
when
I
hit
this
little
drop
down,
you'll
notice
that
you
can
rerun
all
jobs
or
just
the
fail
job.
So
if
I've
got
like
three
or
four
jobs
and
a
couple
of
them
are
really
big,
but
they
all
ran
successfully,
then
I
can
just
go
to
rerun,
fail
jobs
and
have
that
run
there?
A
And
moving
your
mouse
makes
it
go
faster
and
by
all
means,
if
you've
got
questions
along
the
way
feel
free
to
ask.
Can
I
spin
them
up
in
document
container,
run
it
on
the
VM?
So
I
could
run
these
tests
manually
myself
and
confirm
that
they
work
absolutely
right.
Now
there
is
not
an
ability
to
run
actions
locally,
so
the
engine
is
only
going
to
be
available
on
on
GitHub,
but
otherwise
yeah.
A
Okay,
I'm
gonna,
just
trust
that
that
is
the
right
error
message:
I'm,
just
going
to
trust
that
that's
the
right
one,
okay,
we'll
just
we'll
go
with
that.
All
right
I
am
going
to
leave
it
in
a
failing,
State
here
for
a
minute
and
we're
going
to
go
back
and
we're
gonna
make
a
fix
in
a
minute.
But
let's
do
this,
so
we
were
talking
about
continuous
integration
and
with
continuous
integration
again
build
run
tests.
A
Etc
I
want
to
make
sure
all
that
works
correctly
before
we
allow
that
code
in
so
what
I
want
to
do
is
I
want
to
protect
my
Branch,
my
main
branch
from
allowing
any
of
that
code
in,
and
this
is
where
brand
protection
rules
come
into
play.
So,
with
a
branch
protection
rule,
what
I
can
do
is
I
can
specify
hey
for
my
main
branch
or
for
my
deploy,
Branch
or
if
you've
got
some
form
of
a
naming
pattern.
A
So
maybe
all
of
your
deploy
branches
start
with
deploy,
Dash
and
I
can
say,
deploy
Dash
and
Then
star,
and
so
now
this
protection
rule
would
apply
to
all
of
those.
So
anything
that
starts
with
a
star
or
it
starts
with
deploy
Dash
in
my
case,
I'm
just
going
to
apply
this
to
Main
before
our
main
branch.
What
do
we
want?
A
So
the
first
thing
is
I
want
to
require
pull
request
before
merging
next
thing
is
you
can
choose
whether
or
not
you
want
to
require
approvals
and
I'm
going
to
take
that
check
away,
just
because
I'm
the
only
developer
right
now,
but
normally,
of
course,
you
would
want
to
require
approvals
now,
there's
a
lot
of
other
options
that
are
available
in
here
and
I'm
not
going
to
go
through
each
one
of
them.
But
there's
a
couple
I
do
want
to
call
out.
A
A
Folder,
that's
now
going
to
be
owned
by
me
as
geek
trainer.
So
any
updates
to
that
folder
require
approval
from
me,
or
let's
say
that
there's
some
other,
like
special
folder
that
you
have
where
you
always
need
to
make
sure
that
somebody
reviews
that
code,
then
you
can
specify
that
right
there,
and
so
this
allows
you
to
ensure
that
for
any
of
the
more
sensitive
files
that
they
always
get
approval
from
the
correct
person
and
where
this
becomes
really
important.
A
A
A
Okay,
so
there's
that
the
next
one
that
I
want
to
highlight
is
right
here
on
our
status
checks,
so
we
now
have
a
status
check.
That's
our
run
tests
right
here.
These
are
our
Cypress
tests
and
so
before
we
merge
code
in
I
want
to
make
sure
that
that
runs.
So
let
me
just
sneak
in
here
and
say,
run
tests,
and
now
that
is
going
to
be
required
in
order
for
this
to
run
if
I
had
implemented,
GitHub
Advanced
security
doing
code
scanning.
A
A
A
I
know
the
answer
to
that
question
is
yes,
I,
don't
know
how
far
along
that
is,
but
I
know
that
that
is
something
that
is
in
development
of
giving
some
level
of
additional
control
over
who
it
is
that's
able
to
run
those
workflows
and
a
little
bit
more
finite
control
over
over
exactly
when
so.
The
answer
to
that
is
yes,
I.
Don't
have
a
release
date
on
that,
though,.
A
A
Here's
what
we're
going
to
notice
is
when
I
go
back
into
my
pull
requests
and
I
go
back
to
that
updates
header,
because
I
updated
that
code
that
refreshes
the
pull
request,
and
this
now
automatically
reruns
that
check
so
I,
don't
have
to
manually
go
back
and
rerun
this.
If
I've
updated
the
code,
then,
when
I
just
update
the
code,
that's
part
of
that
pull
request.
It
will
automatically
rerun
that
check
for
me
and
I
can
also
see
the
details
here.
A
There
we
go
okay,
that's
funny!
That
error
message
was
not
the
one
that
I
expected,
but
I
guess
it
was
the
right
one.
That's
all
right:
it
works
cool.
So
let
me
open
up
my
Cypress
Run
and
what
you
will
now
notice.
My
little
light
is
green.
Everything
has
now
passed
so
that
ran
the
test
successfully
I
scroll
down.
A
All
of
that
looked
good,
and
now,
when
I
come
back
to
the
pull
request,
what
we're
going
to
see,
let
me
just
refresh
the
page
is
that
now
all
of
that
is
green
and
then
I'm
able
to
go
ahead
and
merge
that
from
here,
and
that's
also
one
of
the
things
that
I
really
like
about
using
actions
for
things
like
this
is
that
everything
is
now
going
to
be
right
here
inside
the
pull
request.
So
I
can
kind
of
see
the
full
history.
A
A
I
can
see
the
fact
that
that
test
second
test
run,
succeeded
Etc,
so
I
get
my
full
history
right
here
and
going
back
to
something
that
we
were
discussing
earlier
is
again
that
fact
of
I
now
don't
have
to
go
somewhere
else
to
go.
Look
up
all
that
information!
I
can
see
all
of
that
right
here
right
where
I
am
already
coding.
A
A
And
I
sort
of
sort
of
demoed
my
way
through
the
remainder
of
the
slides
here,
so
I'm,
actually
just
going
to
kind
of
Kick
ahead
real
quick
and
highlight
just
a
couple
of
other
last
second
features
here
and
I'm.
Also
going
to
bring
my
bring
my
head
back
out,
can
I
share
the
slides
yeah.
If
you
just
draw
me
a
line.
A
Here
we
go
just
drop
me.
A
line
and
I
can
export
these
out
to
PDF
and
yeah
you
can.
You
can
have
have
at
them
from
there
all
right.
A
couple
of
other
nice
little
features
that
I
want
to
mention
number
one.
On
those
starter
templates.
You
have
the
ability
to
create
your
own
starter
templates
as
well.
So
in
the
case
of
let's
say,
like
node
applications
that
you
always
want
to
ensure
that
some
particular
workflow
is
going
to
be
available.
You
can
do
that.
A
You
also
have
the
ability
to
create
your
own
reusable
workflows,
which
is
really
basically
a
way
to
create
your
own
internal
actions
Library.
So
you
can
just
Define
what
the
workflow
is
and
then
you
can
have
additional
workflows
point
to
that
and
then
right
along
those
same
lines,
you
can
also
create
required
workflows.
A
A
Excellent
I
mentioned
already
that
ability
to
create
larger
Runners
you've
got
that
there
and
I've
done
my
done.
My
demo
check
out
github.com
GitHub
roadmap
to
to
see
the
roadmap.
All
right.
Where
do
we
go
from
here
so
number
one
is
well
create
some
workflow
on
on
GitHub
actions
that
think
about
some
of
the
things
that
you
could
automate
and
chances
are.
A
A
So
if
you
don't
want
to
use
any
of
the
marketplace
actions,
you
can
say,
hey,
don't
allow
it
or
if
you
only
want
to
allow
ones
from
verified
vendors
say
like
Microsoft,
Amazon,
Google,
GitHub
Etc,
you
can
do
that
or
if
you
only
want
to
allow
specific
ones
that
you
list,
you
can
do
that
as
well.
So
you
get
complete
control
over
the
use
of
those
Marketplace
actions
and
then
last
but
not
least,
is
create
that
centralized
library
of
starter,
reusable
workflows.
A
More
than
happy
to
answer
your
questions
from
from
there
and
to
to
help
you
out.
This
is
a
series
that
we're
going
to
continue
to
do
every
every
month.
So
we'll
have
a
a
topic
next
month.
I,
don't
remember
what
the
topic
is,
but
we
will
have
a
topic
next
month
that
we'll
get
in
and
and
talk
about
something
cool.
Any
last
questions
at
all
that
you
might
have
on
on
actions
on
automation,.