Executing Gradle builds on TeamCity
|Top engineering teams using TeamCity have been able to reduce CI build time by up to 90% by using the Gradle Build Cache. Register here for our Build Cache training session to learn how your team can achieve similar results.|
Building Gradle projects doesn’t stop with the developer’s machine. Continuous Integration (CI) has been a long-established practice for running a build for every single change committed to version control to tighten the feedback loop.
In this guide, we’ll discuss how to configure TeamCity for a typical Gradle project.
A command prompt
The Java Development Kit (JDK), version 1.8 or higher
A TeamCity installation (setup steps explained in this guide)
For demonstration purposes, this guide is going to focus on building a Java-based project; however, this setup will work with any Gradle-compatible project. More specifically, a Gradle plugin written in Java and tested with Spek. First, we’ll get the project set up on your local machine before covering the same steps on CI.
Just follow these steps:
Clone the Gradle Site Plugin repository
$ git clone https://github.com/gradle/gradle-site-plugin.git Cloning into 'gradle-site-plugin'... $ cd gradle-site-plugin
As a developer of a Java project, you’ll typical want to compile the source code, run the tests and assemble the JAR artifact. That’s no different for Gradle plugins. The following command achieves exactly that:
$ ./gradlew build BUILD SUCCESSFUL 14 actionable tasks: 14 executed
The project provides the Gradle Wrapper as part of the repository. It is a recommended practice for any Gradle project as it enables your project to built on CI without having to install the Gradle runtime.
JetBrains TeamCity is a powerful and user-friendly Continuous Integration and Deployment server that works out of the box. JetBrains offers several licensing options that allow you to scale TeamCity to your needs. In this setup, we’ll use TeamCity Professional, a free fully functional edition suitable for average projects. In the course of this section, you’ll learn how to set up TeamCity, create a build configuration to pull the source code from GitHub and run the Gradle build.
On the TeamCity website you can pick from a variety of distributions. This post uses TeamCity bundled with Tomcat servlet container and covers the evaluation setup of a TeamCity server and a default build agent running on the same machine.
Make sure you have JRE or JDK installed and the JAVA_HOME environment variable is pointing to the Java installation directory. Oracle Java 1.8 JDK is required.
Download TeamCity .tar.gz distribution. Unpack the
TeamCity<version number>.tar.gzarchive, for example, using the WinZip, WinRar or a similar utility under Windows, or the following command under Linux or macOS:
tar xfz TeamCity<version number>.tar.gz
Start the TeamCity server and one default agent at the same time, using the runAll script provided in the <TeamCity home>/bin directory, e.g.
To access the TeamCity Web UI, navigate to
http://localhost:8111/. Follow the defaults of the TeamCity setup. You will be asked to set up a new administration user.
Next, we can set up the project and run a build in TeamCity.
Setting up a new Gradle build in TeamCity requires just a few clicks: TeamCity comes bundled with a Gradle plugin, so you do not need to install plugins additionally. However, it is recommended that you install the TeamCity Build Scan plugin.
On the Administration | Projects page click Create project,
use the option From the repository URL and enter the URL of the GitHub repository:
Follow the Create Project wizard, it will prompt for the project and build configuration name and automatically detect build steps. Select the automatically Gradle build step and click Use selected:
The build step is added to the build configuration:
Click Edit, on the page that opens click Advanced options.
Using the Wrapper to execute the build is considered good practice with Gradle,
and on automatic detection this option is selected by default.
We’ll want to generate a build scan,
so we’ll enter the
--scan option in Additional Gradle command line parameters field.
Save the settings and we’re ready to run the build.
Click the Run button in the right top corner:
TeamCity will start the build and you’ll be able to view the build progress by clicking Build Configuration Home. When the build is finished, you can review the build results by clicking the build number link:
You can view the tests right here in TeamCity:
The information on parameters and environment of the build is available on the Parameters tab of the build results.
If you installed the TeamCity Build Scan plugin, you will see a link to the build scan in the Build Results view:
Otherwise, the link to the build scan for the given build is available in the build log:
Executing Gradle builds on CI can be set up and configured with just a handful of steps. The benefit of receiving fast feedback clearly speaks for itself. If you are not using TeamCity, no problem, many CI products tightly integrate with Gradle as a first-class citizen.