---
title: "Automate your Android Deployment | Clarive"
description: "Today we're going to see how to deploy an application in Google Play Store with Clarive."
url: "https://clarive.com/blog/automate-your-android-deployment"
published: "2018-02-22"
author: "Rodrigo Gonzalez"
---

# Automate your Android Deployment

Today we're going to see how to deploy an application in **Google Play Store** with **Clarive**.

In the following post we'll see how to automate the compilation of our applications, as well as making its subsequent upload to the Play Store from a mobile app completely **automatic**. Clarive will be the only tool we'll use throughout the whole process. All of this will **save** you costs, as you will avoid the costs of manually carrying out the compilation and deployment each time a new version of an application is launched.

To develop this, we install a 30-day trial Clarive instance. Through the use of Docker containers we will be able to compile and deploy an Android application in Google Play Store by using the rulebook that we will explain below. The whole process will be managed through what we have configured in the file **.clarive.yml** that is in the root folder of our repository.

### Requirements

In order to complete this process there are some requtirements, which are as follows:

- The Play Store .json file in order to be able to upload the application automatically.
- The application ready to be compiled and signed automatically.
- A Clarive instance installed, which you can get here

### Designing our .clarive.yml

The .clarive.yml file will be where we will define the steps that should be followed for the compilation and deployment process.

#### Defining our variables

First we will declare the **variables** that will be used throughout our pipeline process.

```text
`vars:
artifact_path: http:///artifacts/repo/
# Root path to our artifact repository.

artifact_repo: "public"
# Name of repository

artifacts_store_path: "android/app/app-release-{{ ctx.job('change_version') }}.apk"
# Path inside the repository where the generated APK will be stored

json_file: "clarive-rulebook.json"
# Name of our JSON file for its uploading to Play Store

workspace: "{{ ctx.job('project') }}/{{ ctx.job('repository') }}"
# Workspace where our development files will be stored

package_name: codepath.apps.demointroandroid2clarive
# Pack name for our app in the Play Store
`
```

#### Building our application

Next is the **BUILD** phase, and here we are going to **compile** the application and save the generated file in our **artifact** repository.

Our _build.gradle_ file must be prepared for the automatic digital signing of the application and and its subsequent uploading to the Play Store. In the same way, we must have also previously manually uploaded a first version of the application to the Pl\*\*ay Store.

An image with gradle and the SDK source of Android should be enough to make the compilation.

After specifying the **Docker** image that we will use, we will execute the gradle command within our working directory, so that the compilation and signature of the application can be carried out.

In our particular case, we should use the **root** user and the **sh** shell of the image we are using in order to perform the compilation of the application.

```text
`build:
do:
- image:
name: 'knsit/gradle-android'
user: 'root'
runner: 'sh'

- shell [Compile application]: |
cd {{ workspace }}/Application_code/app/
gradle AssembleRelease
`
```

To complete the **BUILD** phase, in which we have compiled the application, we need to save the generated APK file, where the compiled application is located, in our artifact repository:

```text
`    - artifact_repo = publish [Store APK in artifacts repository]:
repository: Public
to: '${artifacts_store_path}'
from: '{{ workspace }}/Application_code/app/build/outputs/apk/app-release.apk'
- log:
level: info
msg: Application build finished
`
```

Once the file has been saved and stored we will have terminated our **BUILD** phase, and we will now move on to the DEPLOY phase in order to carry out the deployment of the file.

#### Deploying to Play Store

In this phase, we need our **APK** file with the compiled application, and our .json Play Store authentication file in order to carry out the upload **automatically**.

In this case, the image that we need to make the deployment will be a **Docker** image using the installed **Fastlane**, and here we are going to prepare the command we need to execute in order to deploy our application in Play Store. In this case we will be uploading it to the **Alpha** phase of the applications.

Our _.json_ file is located within our development files where the application is, which means we can place it within our wo\*\*rkspace.

```text
`deploy:
do:
- image:
name: 'levibostian/fastlane'

- shell [Upload application with Fastlane]: |
fastlane supply --apk .artifacts/{{ artifact_repo }}/{{ artifacts_store_path }} -p {{ package_name }} --json_key {{ workspace }}/{{ json_file }} -a alpha

- log:
level: info
msg: The app has been deployed to the Play Store
`
```

In this way, if we carry out the **push** to our repository, **Clarive** will automatically run a deployment (CI) and our application will be **uploaded** onto our Play Store.

#### Notifications

Finally, in the **POST** step **we will email** the user that has launched the deployment to inform them that it has been completed, and in order for them to check the results.

```text
`post:
do:
- log:
level: info
msg: Deploy finished
- email:
body: |
Hello {{ctx.job("user") }},
<b>{{ ctx.job('name') }}</b> has finished and your app has been deployed. Check it out in <a href= "https://play.google.com/">your Play Console</a>.

Also your apk file has been stored in your artifacts repository:
${ artifact_path }${artifact_repo}/${artifacts_store_path}.

subject: Application deployed to Play Store
to:
- ${ctx.job("user")}
`
```

### To conclude

Now with our .yml file already prepared, we can use Clarive's interface to visualize the steps that will follow the finalizing of the rulebook. To start the deployment, we only need to perform the push on the repository, just as we have seen before in other posts. When performing the push, Clarive automatically creates a deployment (Continuous Integration) and executes all the code found in the .yml.

If everything has run correctly, we should be able to see on the **monitor** how our deployment is being executed.

Job succesfully finished

By doing all of this, we have carried out the whole process of compiling and uploading our application to Google Play Store through the use of Clarive's rulebooks and different Docker containers. If we look at our page on the Play Store console, we'll be able to see a message indicating that we have an application ready and waiting.

APK v2 deployed

APK details

This is a brief example that can serve as a reference. You can configure different environments to deploy on. You can also change the type of operation to be carried out in each phase in a completely customizable way, in such a way that it adjusts to what each person needs for their development work and deployments.

Visit \*\* our documentation\*\* to learn more about the features of Clarive.