►
A
So
I've
got
the
issue
here
that
I
create
with
each
one
of
these
updates
each
week
and
you'll
see
a
link
to
this
issue
in
the
video
description
below
as
well.
The
first
thing
we've
got
here
is
a
link
to
our
mission,
so
this
is
what
is
this
group
all
about?
A
A
So
getting
into
this
week's
update
focus
this
week
was
on
code
signing
and
beta
releases
with
fastlane
and
mostly
focused
on
ios
on
the
ios
side
of
that.
So
what
we've
got
here
in
these
first
couple
links
is
a
a
successful
pipeline,
so
functional
pipeline
that
builds
the
app
and
then
releases
it
to
test
flight
in
the
app
store,
and
then
I've
got
an
example
of
the
pipeline
here
as
well.
A
So
I
will
get
into
kind
of
how
all
this
works
in
a
second,
but
I
want
to
talk
about
a
couple
of
the
components
that
we're
using
to
to
make
this
all
work,
so
the
first
thing
is
going
to
be
fastlane
match.
So
this
is
a
component
of
the
fastlane
project.
A
This
is
going
to
make
a
lot
of
sense
for
teams
using
git
lab
to
collaborate
and
build
this
process
out
most
likely
more
than
one
developer
building
those
apps.
So
it
also
works
fine
for
a
single
developer,
building
an
app,
but
if
there's
a
little
more
work
to
getting
it
set
up.
A
A
What
what
it
does
is
it
gives
you
this
project,
so
there's
multiple
different
kinds
of
back
ends.
You
can
use
for
this,
you
can
use
git
or
you
can
use
like
object,
storage,
so
in
google
cloud
or
aws,
or
something
like
that
it
supports
both
of
those
for
us.
Obviously,
it
made
a
lot
of
sense
to
to
use
git,
which
is
kind
of
the
preferred
mechanism
as
well,
and
what
you
get
with
that
implementation
is
a
separate
git
project,
so
a
separate
project
in
gitlab.
A
The
big
difference
between
those
is
that
the
development
profiles
are
limited
in
a
number
of,
or
the
are
limited
in
the
devices
that
they
can
be
provisioned
to.
So
you
have
to
configure
your
device's
device
ids
for
the
development
certificates
for
the
app
store
profiles.
These
are
open
to
any
device
and
that
gets
controlled
either
through
test
flight
or
through
the
app
store
of
you
know,
purchasing
the
app
or
whatever
that
might
be.
So
so
that's
what
that
looks
like,
and
you
can
see,
there's
also
certificates
here
as
well.
A
So
with
this
setup,
then
you
basically
hook
this
into
the
process
and
then
this
is
where
the
match
process
gets.
All
of
its
data
from
the
other
part
of
this
as
well,
is
that
there
is
a
match
password
that
is
used
to
encrypt
the
data
within
the
git
repository.
So
it's
not
just
plain
text.
You
know
unsecured
data
there,
so
there's
actually
a
little
bit
of
extra
security
on
that
and
then
I've
linked
to
the
match
file
here.
So
you
can
see
what
this
looks
like
and
there's
there's
just
a
couple
lines
in
here.
A
We
basically
configured
the
git
url
the
storage
model,
so
this
would
be
git
or
object,
storage
and
then
the
default.
So
the
default
in
here
is
development.
Otherwise
we
would
overwrite
it
with
app
store
or
one
of
the
other
provisioning
types.
If
we
were
doing
that
so
from
there.
So
that's
that's
kind
of
an
overview
of
match.
A
The
next
kind
of
component
that
I
want
to
talk
about
is
the
app
store
connect
api.
So
this
is
a
an
api.
That's
provided
by
apple
to
to
make
it
easier
to
interact
with
the
app
store
through
a
ci
service
or
through
through
an
api.
Essentially
so
there's
a
link
here
to
the
documentation,
and
then
there
is
also
a
this
blog
post
that
talks
about
how
to
set
it
up.
A
It's
actually
a
little
complicated,
but
basically
you
go
through
this
process
and
you
end
up
with
a
few
different
environment
variables
that
you
set
in
your
in
your
ci
configuration,
and
so
those
are
listed
here.
The
issuer
id
the
key
id
and
then
the
actual
key,
and
what
this
allows
us
to
do
then,
is
to
not
be
tied
to
a
specific
user's
account
to
do
the
interactions
with
the
app
store
and
then
it
also
gets
us
around.
The
two-factor
authentication
that
is
is
also
required
in
that
setup.
A
So
with
this
you
can
basically
script
it,
and
then
you
don't
have
to
interact
with
the
the
the
tools
at
all
to
to
do
the
code
signing
the
building
and
the
deployment
and
stuff
like
that.
So
that's
what
the
app
store
connect
api
does
so
then,
down
here,
I've
got
some
details
on
how
this
beta
deploy
process
works.
So
I've
got
the
step
in
the
gitlab
ci
file
and
then
the
fast
fast
file
here,
which
is
the
fastlane
part
of
it,
so
I'll,
walk
through
these
two
bits.
A
A
I
think
we
can
speed
that
up
with
some
caching
and
maybe
more
of
a
customized
docker
image
for
this,
but
I
need
to
spend
a
little
more
time
digging
into
that
and
then
the
this
step
here
is
we're
actually
building
the
app
so
we're
running
the
flutter
build
command,
and
then
this
is
actually
where
we
also
pass
in
our
a
couple
environment
variables
that
we
need
to
set
within
the
apple
build.
So
we
have
a
api
key
for
youtube
for
this
particular
app
and
then
a
channel
id
as
well.
A
So
we
we
set
those
as
part
of
the
build
and
then
we
jump
down
here
to
the
fastlane
command.
Now.
What
actually
happens
here
is
we're
actually
building
the
app
twice,
which
is
not
great.
I
want
to
fix
that
so
I'm
going
to
work
on
that
this
week,
but
I
think
there's
a
way
to
sort
of
combine
these
two
into
one
step.
Obviously,
it's
not
efficient
to
build
the
app
twice,
but
there's
some
bit
of
information.
That's
not
getting
not
getting
built
in
the
secondary,
build
step
that
was
preventing
the
app
from
working.
A
So
so
that's
the
ci
configuration
ideally.
What
we
would
end
up
with
here
is
is
just
like
you
know,
like
a
bundle,
install
a
pod,
install
and
then
a
fast
lane
build
or
a
fastlane
beta,
but
there's
just
a
few
other
steps
that
I
need
to
clean
up
in
here,
so
we'll
get
to
that
as
we
can
and
then
so
down
here
in
the
fastlane
file.
This
is
kind
of
where
the
magic
of
all
this
happens.
A
A
This
is
kind
of
a
special
feature
of
fastlane
that
is,
is
used
in
this
context
to
create
a
temporary
key
chain
on
the
on
the
mac
runner,
and
then
it
also
sets
match
into
read-only
mode.
So
you
could
imagine
a
case
where,
if
match
was
not
in
read-only
mode,
then
your
ci
system
could
be
overriding.
Your
certificates
in
your
git
repo,
and
you
wouldn't
want
that
to
happen.
A
So
so
it
kind
of
sets
up
match
for
this
specific
use
case,
then
the
next
step
here
is
actually
running
the
match
command,
and
this
is
where
we
set
the
type
to
app
store.
If
you
remember
before
it
was
defaulted
to
development.
A
So
this
is
where
we
say
we
want
to
use
the
app
store,
provisioning
profiles
and
certificates,
and
what
this
step
does
is
it
basically
goes
out
to
that
git
repo
and
pulls
down
those
certificates,
so
they
can
be
used
in
later
steps
in
this
process
and
that
sort
of
like
scopes
it
to
the
type
of
distribution
that
we're
building
the
next
step
here
is
the
app
store
connect.
Api
key
is
the
name
of
the
function.
A
Basically,
what
this
does
is
it
loads
those
environment,
variables
and
configures
the
the
fastlane
process
to
to
use
that
as
its
mechanism
to
interact
with
the
with
the
app
store
and
then
there's
just
this.
This
is
a
configuration
option.
The
key
is
base64
encoded.
A
A
Basically,
when
you're
doing
these
builds
you,
you
want
to
have
unique,
build
numbers
or
version
numbers
for
each
one,
that
you
release
and
flutter
has
a
mechanism
by
which
you
set
the
version
of
the
app
within
the
pub
spec
file,
and
so
you
can
configure
that
and
then
this,
like
these
functions
here,
will
flow
that
numbering
scheme
through
to
the
rest
of
the
of
the
ios
app.
A
And
so
what
this
is
doing
is
it's
using
this
increment
version
number
command
to
update
the
version
number
and
the
build
number
within
the
ios
app,
and
then
it's
just
calling
these
attributes
from
the
flutter
pub
spec
file.
So
it
basically
looks
that
up
and
says.
Okay,
I
need
to
get
the
version
number
from
here
and
that's
the
source
of
truth
for
the
version
number
and
then
it
pulls
that
into
the
ios
build.
A
This
would
work,
probably
the
same
for
android.
I
will
test
that
this
week,
but
that's
that's
kind
of
what
that's
all
about.
A
Next
step
is
just
to
build
the
app.
So
this
is
where
we
compile
it.
So
we're
going
to
be
building
the
app
with
the
given
build
number
and
the
provisioning
profile
that
we
got
from
from
match
up
here,
and
so
that's
going
to
create
that
version
of
the
app
for
distribution
to
the
app
store
and,
in
our
case
specifically
test
flight
and
then
the
last
step
here
is
really
just
uploading
that
so
that's
going
to
go.
A
So
from
there
that's
it
then,
once
it
hits
test
plate,
then
it
gets
distributed
out
to
all
the
beta
users
and
they
can
help
download
the
new
version
and
install
it
on
their
phones.
I've
just
tested
this
several
times
and
it
works
really
well,
and
so
it's
it's
cool
to
see
that
whole
that
whole
process
work
so
down
here
in
the
notes.
A
I've
also
included
links
to
each
of
these
steps,
so
you
can
kind
of
see
where
the
documentation
is
at
and
then
this
is
the
the
flutter
version
plugin
that
I'm
using
to
get
that
version
number,
and
then
I
put
a
note
down
here
this
this
one
kind
of
like
confused
me
a
little
bit.
We
need
to
actually
create
a
distribution
certificate
and
that's
done
on
the
local
machine
and
uploaded
to
the
app
store
or
the
developer
apple
portal,
and
this
is
just
some
instructions
on
how
to
do
that.
A
So
then,
down
here
I've
I've
created
a
couple
issues
already,
but
I
want
to
add
to
this
as
we
go,
I
think
there's
several
opportunities
for
us
to
contribute
to
fastlane,
and
I
think
these
are
some
of
the
ideas
I
have
here.
The
one
that
I
wanted
to
call
out
is
the
match
file.
So
in
the
match
file
that
I
I
set
up,
there
is
yeah.
So
this
is
where
we
set
the
git
url.
A
Right
here,
this
is
what
this
is,
how
I'm
going
to
authenticate
that
repo
from
my
gitlab
runner.
So
we
get
our
ci
job
token
here,
which
is
going
to
give
us
access
to
that
gitlab
project,
but
it's
not
automatically
added
into
this,
so
I
have
to
have
to
do
a
little
bit
of
configuration
here
and
then
the
downside
is
like.
If
this
is
not
set
locally,
then
match
is
not
going
to
work
locally
for
me,
so
I
have
to
kind
of
toggle
between
these
two
configurations.
A
I
think
there
would
be
an
easy
way
to
sort
of
hook
into
this
and
make
it
automatic.
So
if
you're
using
gitlab
ci,
then
we
just
try
to
you
know,
add
this
ci
job
token
here
as
part
of
that
configuration.
So
that's
something
I
want
to
look
at,
but
it's
those
type
of
things
that
I
think
we
can
can
add
into
fastlane
to
make
this
a
lot
easier
to
work
with.
A
So
that's
kind
of
the
main
bits
here.
I
found
a
lot
of
resources
while
I
was
kind
of
working
through
this
this
week,
so
I
just
kind
of
captured
some
links
here
about
flutter.
This
is
just
some
various
documentation
and
then
a
few
other
details
on
fast
lane
kind
of
for
future
reference,
but
in
case
anyone
else
wanted
to
to
see
what
I
was
looking
at
there.
A
So
then
up
next
yeah.
Really
the
focus
for
this
week
is
going
to
be
on
improving
that
build
process
and
fixing
the
double
compile
problem
in
that
beta
release
step
and
then
and
then
I
want
to
also
work
on
the
android
version
of
this,
so
getting
a
whole
release
pipeline
to
the
to
the
play,
store
and
and
get
that
out
to
beta
users.
A
A
Please
check
out
the
issue
check
out.
You
know,
provide
any
feedback
you
have
or
just
let
me
know
if
you
have
any
questions.
Otherwise,
I
will
see
you
next
time.
Thanks.