►
Description
Topic: How to build and release an Android app to Google Play with GitLab
Prerequisites
* A Google Play developer account https://play.google.com/console
* Ruby https://www.ruby-lang.org/en/
Android Demo Project https://gitlab.com/gitlab-org/incubation-engineering/mobile-devops/demo-projects/android_demo
Example Files
* fastlane/Fastfile https://gitlab.com/gitlab-org/incubation-engineering/mobile-devops/demo-projects/android_demo/-/blob/main/fastlane/Fastfile
* .gitlab-ci.yml https://gitlab.com/gitlab-org/incubation-engineering/mobile-devops/demo-projects/android_demo/-/blob/main/.gitlab-ci.yml
GitLab Docs
* Project-level Secure Files https://docs.gitlab.com/ee/ci/secure_files/
* Google Play integration https://docs.gitlab.com/ee/user/project/integrations/google_play.html
A
Hi
folks,
this
is
the
mobile
devops
showcase
for
March
2023
and
last
month's
showcase.
We
walked
through
how
to
create
a
CI
CD
pipeline
for
an
iOS
application
this
month,
we're
going
to
do
the
same
thing
for
an
Android
app
similar
to
last
time.
This
pipeline
will
build
sign
and
release
the
application
to
Google
Play
using
gitlab
and
Fastlane.
A
Before
we
get
started,
there's
a
couple
prerequisites
that
I'll
go
over.
The
first
thing
that
you'll
need
is
a
Google
Play
account,
so
you
can
sign
up
for
this
at
to
play.google.com
console
and
the
other
thing
that
you'll
need
is
to
have
Ruby
installed
on
your
local
machine.
The
application
that
we're
going
to
be
working
on
is
this
Android
demo
here
that
you
can
get
the
code
for
this
project
here
and
I'll
link
this
in
the
video
description
similar
to
last
time.
It's
just
a
simple
random
image,
generator
so
load
the
app
up
click.
A
The
button
gets
a
new
image,
pretty
simple
get
started
with
setting
up
the
project.
First
thing:
we're
going
to
do
is
add
a
gem
file
here,
gem
file
and
we're
going
to
give
this
a
source,
bgms.org
and
then
we're
just
going
to
add
the
Fastlane
Gem
and
down
here.
I'll
just
run
bundle
install
and
this
is
going
to
go
and
fetch
Fastlane
and
all
of
its
dependencies.
That's
done
so
now
we
can
go
and
get
Fastlane
setup,
so
I'm
going
to
run
a
command
called
bundle,
exec
Fastlane
in
it.
A
A
And
then
it's
going
to
ask
for
a
path
to
a
secret
file.
I
don't
have
that
right
now,
so
I'm
just
going
to
skip
it
and
then
I
don't
want
to
download.
So
then
we'll
just
hit
enter
and
go
through
that.
So
now
we've
got
our
Fastlane
files
generated
over
here
in
the
Fastlane
folder
we
have
two
files.
We
have
an
app
file
which
has
this
configuration
and
then
it's
and
then
a
default
fast
file.
A
We
don't
need
to
worry
about
these
just
yet,
but
we
just
know
that
they're
here
and
we're
going
to
come
back
to
those
in
a
sec.
Okay,
now
that
we've
got
Fastlane
installed.
The
next
thing
we're
going
to
do
is
create
our
keystore
file
to
keep
this
demo
simple,
I'm
just
going
to
create
one
key
store
file
and
a
larger
application.
You
might
want
to
create
different
key
stores
for
your
various
release,
targets
for
things
like
beta
or
staging
or
production.
A
Things
like
that
I'm
going
to
throw
this
command
in
here,
and
this
is
going
to
use
something
called
key
tool
to
generate
an
Android
key
store
file.
That's
going
to
call
the
file
release
keystore
jks,
and
it's
going
to
it's
going
to
set
some
passwords,
so
there's
a
store
password
and
a
key
password
I'm,
just
setting
them
both
to
the
word
password
right.
Now.
It's
also
going
to
set
an
alias
of
release
when
I
run
this
command.
It
prompts
me
to
input
some
information,
and
this
is
going
to
generate
this
keystore.
A
You
can
see
over
here
there's
a
release,
Dash
keystore.jks
file.
The
next
thing
that
we're
going
to
do
is
add
a
release,
a
keystore
properties
file
and
what
this
is
going
to
do
is
it's
going
to
contain
some
information
about
the
keystore
that
we
can
then
use
in
Gradle
when
we
do
our
builds
I'm
going
to
call
this
file
a
release,
eStore
dot
proverbs.
A
So
this
is
going
to
tell
Gradle
where
the
keystore
file
is
what
the
Alias
is
and
those
passwords
that
I
just
talked
about.
Then
the
next
step
in
this
process
is
to
actually
update,
Gradle
and
configure
it
to
use
these
these
configurations
over
in
app
build.gradle
we're
going
to
add
a
few
things
here.
A
A
So
now
we
can
go
over
and
set
up
our
Fastline
build
over
in
our
Fastlane
file,
I've
added
some
code
for
the
build
and
beta
lanes
for
this
app
right
now,
we'll
just
look
at
the
build
configuration.
So
what
this
is
going
to
do
is
it's
going
to
create
and
sign
the
build,
and
this
is
just
calling
into
Gradle
and
it's
going
to
call
these
tasks
clean,
assemble
release
and
bundle
release.
A
What
we're
going
to
do
is
we're
going
to
run
this
and
generate
a
build
locally
and
we're
doing
this,
because
the
way
that
the
Google
Play
console
works,
you
need
to
actually
upload
a
build
when
you
create
the
app
to
give
it
all
the
configuration
for
that
app.
So
we'll
do
that
one
build
and
then
we'll
be
able
to
automate
it
later.
A
Since
we've
got
this
Lane
here,
I
can
just
run
bundle,
exec,
Fastlane
build,
and
what
this
will
do
is
it
will
go
ahead
and
build
the
app
and
then
it
will
use
that
Gradle
configuration
to
pull
in
that
sign
in
key
store
and
then
actually
sign
the
build.
So
now
that
this
is
done,
I
can
go
over
here
in
the
build
directory
and
I
can
see.
There
is
a
file
called
build
outputs
bundle
and
then
release
app
dash
release,
dot
aab.
A
So
that's
the
file
that
Google
Play
is
going
to
want
over
in
the
Google
Play
console
I've
logged
in
here,
and
this
is
my
account
I'm
just
going
to
click
the
create
app
button
and
that's
going
to
ask
for
some
information.
So
I'm
just
going
to
call
my
app
random
image
and
I'm
going
to
say
it's
an
app
and
it's
free
and
I
agree
to
the
terms
so
I
create
the
app
here
and
then
back
in
the
dashboard.
We're
going
to
click
on
create
a
new
release.
A
We'll
just
click
this,
and
what
this
is
going
to
do
is
ask
us
to
upload
that
app
bundle
that
we
just
generated
so
I'm,
going
to
click
upload
here
and
I've
got
the
file
right
there.
So
I'll
just
hit
open,
and
this
will
take
a
few
seconds
to
upload
and
parse
the
file
and
then
once
it's
done.
It
will
pre-fill
these
into
these
fields
down
here.
A
Okay,
great
that
finished,
so
you
can
see
here
that
it
shows
the
app
bundle
shows
the
API
level,
the
target
SDK,
all
this
kind
of
stuff
here
and
then
it's
showing
a
default
version,
a
release
name
and
then
just
the
default
text
in
there.
I'll
just
go
ahead
and
click
next.
It's
going
to
take
me
to
this
page
for
the
overview
of
the
release
back
in
the
all
apps
section
of
the
Google
Play
console
I
can
see
my
image
here
and
what's
important
is
that
I
can
see
that
the
package
name
shows
up
in
here.
A
So
that
means
that
the
build
has
been
uploaded.
Google
is
able
to
parse
it
and
then
recognize
that
package
name,
that's
helpful
because
now,
when
we
go
to
configure
the
integration
it
will
be
able
to
connect
to
the
Google
Play
Store
verify
the
permissions.
The
next
thing
we
want
to
do
is
we
want
to
set
up
our
API
access
into
the
Google
Play
console.
We
want
this
so
that
we're
able
to
configure
the
integration
with
gitlab
so
that
it
can
upload,
builds
to
the
Google
Play
Store
from
RCI
jobs.
A
There's
some
instructions:
Here
In,
the
Fastlane
docs,
which
I'll
link
below
in
the
notes,
but
what
we
want
to
do
is
go
from
our
our
all
apps
section
of
the
Play
Store
to
the
API
access
section
here
and
what
we're
actually
going
to
do.
This
is
going
to
take
us
over
to
gcp,
so
go
Google.
Cloud
platform
is
where
we
actually
create
this
account.
So
I'll
hit
that,
and
it's
going
to
pop
up
another
window
over
here
in
the
Google
Play
console.
A
We
can
go
to
the
IAM
and
admin
section
and
then
from
here
we
can
click
on
service
accounts.
I
can
click
the
create
service
Account
button
here
at
the
top?
I
just
need
to
give
this
a
name
so
I'm
going
to
call
it
random
demo.
App
and
click
continue
and
then
I
need
to
give
it
a
permission.
And
what
we
do
here
is
give
this
a
service
account
user
and
then
click
done
and
now
we've
got
this
service
account
in
our
list
here,
but
it
has
no
key
associated
with
it.
A
A
I
can
reload
this
page
here
and
I
should
see
my
key
in
the
list
here.
So
Random
demo
app
there
we
go
and
now
I
can
manage
the
play
console
permissions.
So
this
is
where
I
give
this
service
account
access
to
the
apps
or
the
app
within
Google
play
in
this
case.
I
can
add
it
to
just
the
app
the
random
demo
app
and
apply
that
and
we'll
give
it
admin
permissions,
I
click
apply
and
then
I
have
to
click
invite
user,
and
it's
going
to
send
an
invite
to
that
account.
A
So
now,
I
can
go
over
to
my
project
in
gitlab
and
I
can
go
to
settings
and
Integrations
and
then
I
can
click
on
the
Google
Play
integration
here
and
I
can
give
it.
My
configuration
so
I'll
activate
this
and
then
I'll
put
in
the
package
name
com.getlab.random
and
then
I've
uploaded.
The
key
file
that
we
just
generated
and
I
can
click
test
settings,
and
we
can
see
that
the
connection
is
successful.
So
now
I
can
save
changes
and
anytime
we
use
the
integration
with
gitlab.
A
Now
it
will
be
able
to
connect
to
the
Google,
Play,
Store
and
upload
those
builds.
The
last
thing
we
need
to
do
in
our
gitlab
project
is
to
upload
the
keystore
and
the
properties
files
into
the
gitlab
secure
files.
So
we
can
do
that
by
going
into
settings
and
going
to
CI
CD
and
then
at
the
bottom
of
the
screen.
Here
we
can
go
to
secure
files
and
then
we'll
go
ahead
and
click
upload
file
and
from
our
project
we
can
do
the
release
keystore.jks
file
and
then
we'll
also
do
the
release
keystore
properties
file.
A
The
reason
that
we're
doing
this
is
because
these
files
contain
sensitive
information.
They
contain
passwords
and
encryption
keys,
and
so
we
can
upload
them
to
secure
files
so
that
they
can
be
preserved
with
the
project
but
they're
outside
of
Version
Control.
So
they're
not
in
the
git
repository
and
then
we
can
pull
those
files
into
our
CI
CD
jobs.
We
need
them,
then,
over
in
our
project,
we're
going
to
make
a
few
more
changes
before
we
commit
all
of
this
and
push
the
build
up
in
the
Fastlane
file.
A
The
Fastlane
fast
file,
there's
a
couple
Lanes
in
here
that
I
want
to
talk
about.
So
this
one
here,
increment
VC.
This
is
a
lane
that
we
can
call
whenever
we're
just
incrementing
our
version
number.
So
this
is
just
a
little
helper
that
helps
us
change
the
version
number
to
increment
it
every
time
we
do
a
build,
we'll
want
to
do
that
when
we
commit
some
changes
and
then
the
beta
Lane
here.
A
This
is
going
to
take
the
artifact
that
gets
built
in
this
step
here
and
it's
going
to
upload
that
to
the
Play
Store
on
the
internal
track,
and
so
I'll
show
you
how
this
works
in
a
minute.
But
that's
what
that
job
is
doing
the
nice
thing
about
this.
The
way
this
Lane
is
set
up
is
we
don't
have
to
build
the
app
again
we
build
it
here.
We
create
a
gitlab
artifact
and
then
we
upload
it
upload
that
artifact
to
the
store
and
then
over
in
here.
A
The
other
thing
that
I
want
to
do
is
in
my
git,
ignore
file
I
want
to
add
those
files
that
we
uploaded
to
secure
files
that
will
make
sure
those
files
don't
get
committed
to
Version
Control
accidentally.
We
have
one
last
step
that
we
need
to
do
before
we
can
hook
this
all
up,
we're
going
to
go
ahead
and
create
the
gitlab
dash
CI
dot
EML
file.
This
is
what's
going
to
hook
all
these
Fastlane
commands
up
to
the
gitlab
CI
Runner
I'll
walk
through
this
real
quick
to
explain.
A
What's
going
on,
we
have
three
stages
in
this
CI
configuration.
We
have
a
test,
a
build
and
a
beta,
and
then
we're
doing
this
caching
here
so
that
we
can
speed
up
the
builds
by
not
having
to
run
bundle
install
if
the
gem
file
hasn't
changed
and
in
our
builds
we're
using
a
Docker
image
that
is
pre-configured
with
the
Android
SDK.
It
has
everything
we
need
there
for
this
job.
We
can
just
run
bundle,
exec,
Fastline,
test
and
that'll
call
into
the
fast
lane
and
run
the
job.
A
Then
the
next
step
here
is
the
build
step,
we're
configuring
this
with
the
secure
files.
So
this
is
what's
going
to
download
the
Android
key
store
in
the
properties
file.
What
we're
doing
here
is
we're
we're
giving
it
a
download
path
which
is
just
going
to
be
the
root
path
of
the
project
and
then
we're
going
to
update
apt
and
then
install
curl
and
then
use
this
curl
command
to
download
a
the
downloader
tool,
which
is
what,
which
is
what
we
need
to
pull
in
those
secure
files.
A
Once
we
have
all
that
in
place,
then
we
can
just
run
bundle
exec
Fastlane
build
like
we
did
before.
Then
this
artifacts
path
here
is
going
to
tell
gitlab
where
to
store
the
artifact
that's
being
built
in
this
job.
So
it's
going
to
go
to
app,
build
outputs
bundle,
release
app
dash
release.ab.
The
next
step
is
the
beta
step
again
same
Docker
image
and
then
we're
just
running
this
bundle
exec
Fastlane
beta
command.
A
What
this
will
do
is
this
will
run
that
same
beta
step
from
the
fast
file
and
it
will
pull
in
the
artifact
and
then
release
it
to
the
Play
Store.
This
is
also
a
manual
step
and
we'll
only
run
this
on
Master.
Actually,
this
should
say
main
with
all
of
that
in
place.
We
can
go
ahead
and
commit
all
of
our
changes
and
let
this
pipeline
kick
off
now.
A
The
release
job
is
finished
and
we
can
see
in
the
build
output
here
that
the
job
is
successful
and
that
the
release
was
uploaded
to
the
Play
Store
and,
as
you
can
see
over
in
the
Play
Store,
the
release
was
successful
and
we
can
see
that
a
new
version
was
created
here
for
our
app.
That's
all
for
today,
as
you
can
see,
there's
still
a
good
amount
of
manual
configuration
involved
in
setting
up
this
pipeline.