►
Description
Topic: How to build and release an iOS app to Test Flight with GitLab
Prerequisites
* Apple Developer Program https://developer.apple.com/programs/enroll/
* GitLab SaaS runners on macOS https://docs.gitlab.com/ee/ci/runners/saas/macos_saas_runner.html#access-request-process
* Ruby https://www.ruby-lang.org/en/
iOS Demo Project https://gitlab.com/gitlab-org/incubation-engineering/mobile-devops/demo-projects/ios-demo
Workaround for Apple certificate limit https://about.gitlab.com/handbook/engineering/incubation/mobile-devops/guides.html#how-to-generate-a-development-provisioning-profile-from-an-existing-certificate
Example Files
* fastlane/Fastfile https://gitlab.com/gitlab-org/incubation-engineering/mobile-devops/demo-projects/ios-demo/-/blob/main/fastlane/Fastfile
* .gitlab-ci.yml https://gitlab.com/gitlab-org/incubation-engineering/mobile-devops/demo-projects/ios-demo/-/blob/main/.gitlab-ci.yml
GitLab Docs
* Project-level Secure Files https://docs.gitlab.com/ee/ci/secure_files/
* Apple App Store integration https://docs.gitlab.com/ee/user/project/integrations/apple_app_store.html
A
Hi
folks,
this
is
the
mobile
devout
showcase
for
February
2023
in
this
month's
update,
we're
going
to
walk
through
how
to
create
a
CI
CD
pipeline
for
an
iOS
application.
This
pipeline
will
build
sign
and
release
the
application
to
test
flight
using
gitlab
and
Fastlane.
Before
we
get
started.
There's
a
few
prerequisites.
You'll
need
to
work
through
this
demo.
A
First
of
all,
we'll
need
to
have
a
developer
account
with
Apple,
so
you
can
sign
up
for
that.
Developer.Apple.Com
next
you'll
need
access
to
the
SAS
Runner
Mac
OS
beta
on
gitlab
follow
the
instructions
on
this
page
to
get
access
to
the
beta
and,
lastly,
you'll
need
to
have
Ruby
installed
on
your
local
machine
in
order
to
run
Fastlane.
A
We'll
use
this
iOS
application
that
I've
created
as
a
demo
right
now,
there's
just
the
basic
files
that
have
been
created
from
an
IOS
app,
and
just
so
you
know
what
we're
working
with
we've
got.
It's
just
a
little
photo
randomizer
app,
so
this
will
just
change
out
the
photo
every
time.
I
click
this
button
here.
The
first
thing
that
I
want
to
do
is
add
a
gem
file
and
install
Fastlane
I'll.
Do
a
new
file
called
gem
file
and
in
here
I'm
just
going
to
give
it
a
source
which
is
rubygems.
A
A
The
first
thing
that
it
says
is
what
would
you
like
to
use
Fastlane,
for
we
want
to
distribute
the
test
flight,
so
I'm
going
to
hit
number
two,
so
I
was
able
to
log
in
successfully,
and
it
shows
here
that
the
app
identifier
that
I
want
to
use
so
com.getlab.ios
demo
is
available
in
the
developer
portal
and
in
app
store
connect.
So
everything
is
ready
to
go.
We
can
go
into
our
app
and
see
what
it
did.
A
There
is
a
new
folder
called
Fastlane,
and
it's
created
two
files
here:
the
app
file
and
the
fast
file.
So
the
app
file
is
basically
what
configures
everything
about
the
application.
This
is
the
app
identifier,
the
Apple
ID,
that
it
wants
to
use
and
App
Store
connect,
a
team
ID
and
then
the
developer
portal
team
ID.
So
these
are
the
configuration
options
that
it
needs
to
interact
with
the
Apple
App
Store.
A
The
fast
file
is
where
you
define
the
actions
that
you
want
Vaseline
to
take
for
various
steps
in
your
pipeline.
I'll
explain
how
this
works
in
a
minute,
but
for
now
we
can
just
see
that
the
file
was
created.
The
next
thing
that
we
want
to
do
is
we
want
to
configure
our
signing
certificates.
Fastlane
has
another
component
called
Fastlane
match.
Fastline
match
is
the
part
of
Fastlane
that
does
all
of
the
things
related
to
signing
certificates
for
iOS
applications.
A
You
start
this
one
up
in
a
similar
way,
so
we're
going
to
say,
bundle
exec,
fast
lane
match
in
it,
and
it's
going
to
ask
us
some
questions.
First
thing
it's
going
to
ask
us
is
which
storage
mode
do
we
want
to
use
and
we
want
to
use
gitlab
secure
files,
so
we're
going
to
hit
four
and
what
is
the
project
we
want
to
use?
A
This
is
going
to
be
the
project
path
in
gitlab
I'll,
just
copy
and
paste
gitlab.org
incubation
engineering,
mobile
devops
demo
projects,
iOS
demo,
that's
going
to
configure
it
for
that
specific
project
in
gitlab,
all
right,
so
that's
done,
and
now
you
can
see.
We
have
another
file
over
here
called
the
match
file,
which
is
how
to
get
that
project,
the
storage
mode
and
then
the
type
which
is
development
by
default.
This
is
the
different
types
of
distribution
you
can.
A
You
can
do
through
the
Apple
App
Store,
so
you
can
say:
I
want
to
build
for
development
or
for
the
App
Store
or
these
other
distribution
mechanisms.
The
next
thing
we're
going
to
do
is
we're
going
to
have
Fastlane,
generate
our
signing
certificates
and
upload
them
to
gitlab
what
we
need
to
do.
First,
for
this
is
we
need
to
generate
an
access
token.
This
is
so
that
Fastlane
can
interact
with
with
our
gitlab
project.
What
I
want
to
do
is
create
a
project
access
token
and
this
access
token
will
be
just
scoped
to
this
project.
A
A
What
I'm
going
to
do
is
I'm
going
to
set
this
in
my
console,
export
private
token
assign
it
to
that
value.
This
is
going
to
do
a
set
this
value
in
my
environment,
so
I
don't
have
to
set
it
with
each
command
that
I
run
since
that's
all
set
up
now
we
can
go
ahead
and
run
Fastlane
match,
so
we're
going
to
say,
bundle,
exec,
Fastlane,
Edge,
and
what
this
is
going
to
do.
A
A
This
is
going
to
do
very
similar
process
to
generate
the
certificates
and
then
upload
them
to
gitlab.
Okay,
that's
all
done
so.
Let's
go
back
over
to
our
gitlab
project
and
we'll
reload
this
page
and
now
we
can
see,
we've
got
our
development
certificates
and
then
we
have
our
app
store
distribution
certificates.
Something
to
note
there
is
a
limit
to
the
number
of
certificates
you
can
generate
for
a
apple
developer
account.
A
So
if
you
run
into
an
error,
what
you
might
see
here
is
that
you've
hit
your
limit
on
the
number
of
certificates
for
development
or
distribution.
There's
a
couple
ways
to
get
around
that
and
I'll
link
to
that
in
the
the
notes
Below
in
the
video
description.
There's
one
final
step:
that's
needed
to
configure
our
application
to
use
the
signing
certificates
we
just
generated
over
an
xcode
and
in
my
project
and
under
project
targets.
There's
several
tabs
up
here.
A
There's
the
signing
and
capabilities
tab
and
when
you
click
into
here,
you'll
see
this
default
option
check
to
automatically
manage
signing
from
xcode
we're
going
to
go
ahead
and
uncheck
that
and
then
we
will
select
our
profiles
for
the
debug
and
release
distributions
over
in
debug.
We're
going
to
hit
match
development
that
set
certificate
we
just
generated
and
then
in
release
we'll
do
the
same
thing:
we'll
choose
the
match,
app
store
and
now
that
we've
got
this
configured,
we're
all
set
with
our
signing
certificates.
A
The
next
thing
that
we
want
to
do
is
configure
our
Apple
App
Store
connect
integration
and
gitlab.
So
if
we
go
over
to
our
project
we'll
see
under
the
Integrations
tab,
there
is
a
Apple
App
Store
connect
integration,
we'll
click
on
this
and
there's
a
few
inputs
that
we
have
here.
What
we
need
for
this
is
going
to
require
that
we
go
over
to
App
Store
connect
we'll
go
over
to
App
Store
connect
and
under
the
users
and
access
section
we're
going
to
generate
a
new
key.
A
So
the
way
we
do
this
is
just
click
that
button
here
and
we
give
it
a
name
so
we're
going
to
say
iOS
demo
and
then
our
access
level,
we'll
just
say
admin,
and
this
will
generate
everything
we
need.
If
we
go
back
over
here,
let's
see
we
need
our
issuer
ID,
our
key
ID
and
then
the
private
key.
So
our
issuer
ID
is
actually
this
value
up
here.
So
we
can
copy
that
and
paste
it
in
here.
The
key
ID
is
going
to
be
this
field
here.
A
That
is
just
generated,
so
we'll
copy
that-
and
we
can
paste
that
into
here
and
then
the
the
key
itself
is
actually
this
file
here.
So
we'll
download
the
key,
and
we
can
paste
it
in
here
right
from
this
screen,
we
can
hit
test
settings
to
make
sure
that
this
works
make
sure
that
everything
configured
correctly
we
can
see
the
connection
was
successful.
We
can
go
ahead
and
save
this,
and
we
know
that
our
integration
will
work
now
that
we
have
everything
in
place,
we
can
go
ahead
and
get
our
fast
file
set
up.
A
A
This
is
only
going
to
be
triggered
when
you're
running
in
CI.
So
if
you're
in
gitlab
it's
going
to
set
up
a
temporary
keychain
for
the
signing
certificates,
then
once
we
have
that
we
can
go
ahead
and
run
Fastlane
match
and
what
that's
going
to
do
is
it's
going
to
pull
those
certificates
from
gitlab,
install
them
in
the
runner
and
make
them
available
for
the
build
job?
A
And
then
it's
going
to
set
it
to
read-only
mode
when
we're
in
CI,
so
that
we
don't
accidentally
overwrite
the
certificates
and
then
the
last
step
here
is
just
to
build
it.
So
it's
going
to
build
our
app
and
we
can
say
the
iOS
demo
project,
the
debug
configuration
the
development
export
method.
One
thing
that's
kind
of
nice
is
we
can
test
this
locally,
so
we
can
go
ahead
and
run
bundle
exec,
Fastlane
bill.
A
This
will
run
all
the
steps
in
this
job
and,
if
it
completes
successfully,
then
we
know
that
the
the
build
step
works
that
worked,
and
we
can
see
that
there
is
a
demo
IPA
file
here
that
it's
created
beta
step
is
pretty
similar.
We're
going
to
set
up
our
CI
we're
going
to
do
match,
except
in
this
case
we're
going
to
do
the
App
Store
distribution.
So
this
is
going
to
pull
a
separate
set
of
certificates,
so
we
can
use
it
in
the
app
store.
A
Then
we're
going
to
call
this
app
store,
connect,
API,
key
method.
This
is
going
to
use
that
integration
in
gitlab
to
make
the
connection
to
the
App
Store
and
get
an
API
key
for
this
session,
and
that
allows
us
to
do
the
rest
of
the
steps
that
we
need.
The
next
step
here
is
to
increment
the
build
number
chest.
Flight
requires
a
unique
build
number
for
each
deployment,
so
we're
going
to
do
that.
A
This
is
just
a
simple
incrementer
and
you
probably
wouldn't
want
to
use
this
for
a
production
release
or
App
Store
release,
but
it
works
fine
for
test
flight.
Once
we
do
that,
then
we
can
go
ahead
and
build
the
app
same
thing
as
before,
except
for
reusing
release
and
App
Store
here
and
then.
Finally,
now
that
we've
got
that
built,
we
can
just
upload
its
test
flight
and
once
we
do
that
the
app
will
be
available
in
test
flight
and
sent
out
to
our
testers.
A
What
this
is
going
to
do
is
give
us
two
stages
in
our
build
pipeline:
a
build
and
a
beta
stage,
in
both
cases
we're
using
this
Mac
OS
Runner
image
and
there's
different
versions
available,
but
depending
on
what
your
application
needs,
you
can
choose
a
different
version
of
xcode
and
then
all
we
do
in
our
script
is
bundle
check.
So
this
is
going
to
do
a
bundle,
install
and
it's
going
to
get
fast
lane
and
all
those
dependencies.
A
And
then
we
just
run
that
command
like
we
did
before
bundle
exec
Fastlane
build,
and
that
will
build
the
app
this
tags
here.
This
is
just
something
that's
needed
for
the
Mac
OS
shared
Runners,
same
thing
on
the
beta
step,
we're
just
setting
up
the
runner,
we're
doing
bundle,
install
and
then
we're
running,
Fastlane
beta.
This
is
a
manual
step
and
we
only
run
this
on
master.
A
So
you
can
do
all
of
your
tests
in
an
MR,
and
then
this
will
be
a
manual
step
that
then
gets
run
on
the
master,
we'll
go
ahead
and
commit
all
of
this
upload
it
and
we'll
kick
off
some
pipelines.
This
pipeline,
as
I
was
shown
earlier,
has
two
steps
to
build
and
the
beta
step
and
the
build
job
brand
and
the
beta
has
not
yet
run
we'll,
go
ahead
and
kick
off
this
beta
step
and
once
that
completes
we'll,
be
able
to
see
our
release
and
test
plate.
A
Now
the
job
has
finished,
and
we
can
click
into
here
and
see
that
the
job
is
run
successfully
and
that
our
app
has
been
successfully
distributed
to
internal
testers.
What
we
can
do
from
here
now
is
jump
over
into
App
Store
connect
and
if
we
go
into
our
app
and
then
into
the
test
flight
section,
we
can
see
this
the
section
on
builds
and
and
testing
groups
you
can
ignore.
These
older
builds
that
I
have
in
here.
A
The
one
that
we
just
ran
is
build
number
seven,
and
you
can
see
that
it
was
sent
to
one
test
group
over
here
is
where
you
can
control
the
groups
that
you
send
to.
So,
if
you
wanted
to
create
another
internal
group,
you
could
create
one
here
and
then
within
a
group
you
can
go
ahead
and
choose
the
individuals
that
you
want
to
send.
Invites
to
once
you've
created
a
test
group
and
added
internal
testers.
A
Those
folks
will
get
emails,
asking
them
to
accept
the
invite
and
then
to
install
the
test
flight
app
on
their
phones
unless
they
have
the
test
flight
app
installed
on
their
phones,
they'll
be
able
to
download
the
new
versions
of
the
app
as
they're
released.
So
that's
it.
In
about
15
minutes,
we
were
able
to
create
a
CI
pipeline
that
will
build
and
release
our
mobile
app
view
test
flight.
A
As
you
can
see,
there's
still
a
lot
of
manual
steps
in
manual
configuration
necessary,
so
the
next
things
I
want
to
focus
on
are
adding
the
automations
to
remove
as
much
of
the
manual
work
as
possible.
That's
all
for
today,
I've
added
links
to
all
the
items
I've
covered
in
the
video
description
below
thanks
for
watching.