Automate app development infrastructures with GitLab and Relution
What it's all about
When you are working in a bigger company or agency which develops and ships a lot of apps, the release process can be very time-consuming. In such a scenario, a lot of people are involved like the IT department, the app owner, testers and of course the developers themselves. Additionally, all these people use different tools for development, testing and distribution which leads to a fragmentation of the IT infrastructure and spread credentials across all of these tools. Another important thing to keep in mind is the responsibility for these tools and the infrastructure which is rarely clear.
As a developer, for example, I do not want to be responsible for the management of the source code repositories and continuous integration infrastructure. As a responsible IT infrastructure manager, I do not want to deal with problems in the code of the business app and how the app is built by the CI tool. While the demand for fast delivery is growing, why isn't there an infrastructure which can solve these problems once and for all? Let's anticipate - there is a solution!
The whole app release process, from setting up new app projects and the needed infrastructure to shipping apps to your enterprise or public app stores, can be simplified and automated.
Feature-rich, open and widely used
There is no need to prove that the use of code repositories and continuous CI/CD tools (Wikipedia) help development teams in software projects. GitLab is one of the three big players out there (together with GitHub & BitBucket) and finds a lot of use, especially in enterprises and agencies (according to the GitLab website, it is used by more than 100,000 organizations). It has a rich feature set which covers the whole development lifecycle and a huge community alongside a lot of possibilities for extensions and scripting possibilities. One of the great things about GitLab is the combination of Git repositories and continuous delivery build jobs. Developers can check in their code, define a so-called .yml file which has all the commands to compile, build and release an app and the integrated continuous delivery mechanism builds the app automatically on every new commit.
App management from A to Z
Relution is a mobile app lifecycle management tool which has a specific angle on app projects in general. It supports the release lifecycle of different app versions and provides an infrastructure for app management.
After an app has been uploaded to Relution (of course, this step can be automated), it allows app owners to release the app in different stages. You can define permissions for developers, testers and app owners, so the app can be reviewed in different stages. Additionally, Relution can manage metadata of apps like descriptions and screenshots and also automatically re-sign apps. This, especially, helps enterprises with a lot of external app agencies to not spread their signing credentials to people outside the company and ensures that every app is re-signed correctly with the chosen enterprise certificates.
Relution also lets companies benefit from an own app store which is used for company apps. This feature is mainly used for company apps which should not be distributed through the public app stores - like internal apps, CRM apps or other business workflows.
The combination is the solution!
Coming back to the problem described in the introduction, we want to show you a solution which consists of a setup of both tools. Here is how a workflow could look like in reality:
- Alice is the Head of Sales in company X. She has the idea for a new app which speeds up a sales workflows for her team members. After a few meetings and a lot of work, she knows what she needs. She is responsible for the new app, so she has the role 'app owner'. She logs into her Relution account and requests a new 'development environment' - CLICK.
- Bob is an IT employee, responsible for mobile infrastructure and receives an email which says "Alice has requested a development environment for a new app - Please approve!". So he does - CLICK.
- In the meantime, Alice, the app owner, found an external app agency which is going to develop the app because she knows that the internal IT has no developer resources. She invites developers to the approved 'development environment' - CLICK.
- Carl and Carol, the app developers, receive an email about where their Git repository and build job is located and how to configure it. They start developing the app - HACK HACK HACK.
- Suddenly Alice receives a push message "Your app can be reviewed." from the Relution Enterprise App Store app on her phone - CLICK.
- Alice is surprised how fast this happened, checks the app, is happy and presses the 'release' button in her Relution app.
- From this moment on, the app is distributed to the whole sales team and the efficiency boost happens right away.
How do you like this workflow? You certainly have questions, right?
Where the 'magic' happens - background activities
Relution uses a lot of GitLab's great features in the background. If a 'development environment' is approved by the IT department, a new project repository is created. It is pre-filled with two important files: the .yml file and an upload script. The .yml file is used to set up a build job and the upload script is used for uploading the build app artifacts into Relution for further processing. Additionally, the developer permissions are set automatically on the GitLab server on the repository, so the defined developers can use their SSH key to work with the repository.
GitLab can (but doesn't have to) stay in the background since the developers can define their build parameters in the .yml file. The built apps can be distributed to the developers through the Relution app (so, in fact, the developer commits something, and after a while, he receives the built app on his mobile device for testing). Of course, the developers need to upload their public SSH key to Relution before cloning the repository. By default, a new build on the Continuous Integration server is triggered when a developer pushes changes to the master branch. The build artifacts (apps) created by a successful build will be uploaded to Relution and are linked to the corresponding Development Environment. Uploaded apps are visible in the App Store view or via the Development Hub by selecting the appropriate Development Environment in the Relution Portal.
- Save at least a week per new app project for requesting and setting up a development environment (source code repository & build job)
- Get a first working version of a new app faster into the field
- Get new versions tested and ready for production faster than ever before with the automated review workflow
- No dealing with IT infrastructure topics app owners don't know anything about
- An easy possibility to install, review and release apps from a mobile phone
- Unified app project development infrastructure
- No dealing with new tools and setups for every new app project
- A simple and organized process for every developer, app owner, tester and user
- Stay informed about new app requests and development environments
- Prepared Git repository and CI job - no setup needed
- Easy build job configuration in a .yml file
- Easy testing through Relution enterprise app store app
- Quick release mechanism from state 'development' to 'review'
Setting up app development infrastructures can be a pain for app owners, the IT department and developers. With the combination of GitLab and Relution, this problem can be solved for all future app projects, giving additional benefits for all stakeholders. Check it out for free with the FREE edition of Relution and your GitLab setup.
Start now with Relution and connect to your GitLab
Free for up to 10 users. No payment information necessary.