Scaling Jira 7.6
Determining the scale of a single Jira instance
There are multiple factors that may affect Jira's performance in your organization. These factors fall into the following categories (in no particular order):
- Data size
- The number of issues, comments, and attachments.
- The number of projects.
- The number of Jira project attributes, such as custom fields, issue types, and schemes.
- The number of users registered in Jira and groups.
- The number of boards, and the number of issues on the board (when you're using Jira Software).
- Usage patterns
- The number of users concurrently using Jira.
- The number of concurrent operations.
- The volume of email notifications.
- The number of plugins (some of which may have their own memory requirements).
- The number of workflow step executions (such as Transitions and Post Functions).
- The number of jobs and scheduled services.
- Deployment environment
- Jira version used.
- The server Jira runs on.
- The database used and connectivity to the database.
- The operating system, including its file system.
- JVM configuration.
This page will show how the speed of Jira can be influenced by the size and characteristics of data stored in the database.
Jira 7.6.4 vs Jira 7.2.12 performance
Jira 7.6 Enterprise Release was not focused solely on performance, however we do aim to provide the same, if not better, performance with each release. In this section, we'll compare Jira 7.6.4 to Jira 7.2.12, which was the last release recommended for Enterprise customers. We ran the same extensive test scenario for both Jira versions. The only difference between the scenarios was the Jira version.
The following chart presents mean response times of individual actions performed in Jira. To check the details of these actions and the Jira instance they were performed in, see Testing methodology.
Response times for Jira actions
Each row represents mean response times. The lower the value, the better the performance.
The following sections detail the testing environment, including hardware specification, and methodology we used in our performance tests.
Before we started the test, we needed to determine what size and shape of data set represents a typical large Jira instance.
In order to achieve that, we used our Analytics data to form a picture of our customers' environments and what difficulties they face when scaling Jira in a large organization.
Baseline test Jira data set
|Jira data dimension||Value|
We chose a mix of actions that would represent a sample of the most common user actions. An "action" in this context is a complete user operation like opening of an Issue in the browser window. The following table details the actions that we included in the script for our testing persona, indicating how many times each action is repeated during a single test run.
|Action name||Description||Number of times an action is performed during a single test run|
|View Dashboard||Opening the Dashboard page.||10|
|Create Issue||Submitting a Create Issue dialog.||5|
|View Issue||Opening an individual issue in a separate browser window.||55|
|Edit Issue||Editing the Summary, Description and other fields of an existing Issue.||5|
|Add Comment||Adding a Comment to an Issue.||2|
|Search with JQL||
Performing a search query using JQL in the Issue Navigator interface.
The following JQL queries were used...
Half of these queries are very heavyweight, which explains high average response time.
|View Board||Opening of Agile Board||10|
|Browse Projects||Opening of the list of Projects (available under Projects > View All Projects menu)||5|
|Browse Boards||Opening of the list of Agile Boards (available under Agile > Manage Boards menu)||2|
|All Actions||A mean of all actions performed during a single test run.||-|
The performance tests were all run on a set of AWS EC2 instances, deployed in the
eu-central-1 region. For each test, the entire environment was reset and rebuilt, and then each test started with some idle cycles to warm up instance caches. Below, you can check the details of the environments used for Jira Server and Jira Data Center, as well as the specifications of the EC2 instances.
To run the tests, we used 10 scripted browsers and measured the time taken to perform the actions. Each browser was scripted to perform a random action from a predefined list of actions and immediately move on to the next action (ie. zero think time). Please note that it resulted in each browser performing substantially more tasks than would be possible by a real user and you should not equate the number of browsers to represent the number of real-world concurrent users.
Each test was run for 20 minutes, after which statistics were collected.
|Jira Server||Jira Data Center|
The environment with Jira Server consisted of:
The environment with Jira Data Center consisted of:
Jira Server: 1 node
Jira Data Center: 2 nodes
Jira Data Center:
Jira 7.6 scalability
Jira's flexibility causes tremendous diversity in our customer's configurations. Analytics data shows that nearly every customer dataset displays a unique characteristic. Different Jira instances grow in different proportions of each data dimension. Frequently, a few dimensions become significantly bigger than the others. In one case, the issue count may grow rapidly, while the project count remains constant. In another case, the custom field count may be huge, while the issue count is small.
Many organizations have their own unique processes and needs. Jira's ability to support these various use cases explains the dataset diversity. However, each data dimension can influence Jira's speed. This influence is often not constant nor linear.
In order to provide individual Jira instance users with an optimum experience and avoid performance degradation, it is important to understand how specific Jira data dimensions influence the speed of the application. In this section we will present the results of the Jira 7.6 scalability tests that investigated the relative impact of various configuration values.
How we tested
As a reference for the test we used a Jira 7.6 instance with the baseline test data set specified above and ran the full performance test cycle on it. To focus on data dimensions and their effect on performance, we didn't test individual actions, but instead used a mean of all actions. Next, in the baseline data set we doubled each attribute and ran independent performance tests for each doubled value (i.e. we ran the test with a doubled number of issues, or doubled number of custom fields) while leaving all the other attributes in the baseline data set unchanged. Then, we compared the response times from the doubled data set test cycles with the reference results. With this approach we could isolate and observe how the growing size of individual Jira configuration items affects the speed of an (already large) Jira instance.
Response times for Jira data sets
Each row represents mean response times. The lower the value, the better the performance.
The number of issues affects Jira's performance, so you might want to archive issues that are no longer needed. You may also come to conclusion that the massive number of issues clutters the view in Jira, and therefore you still may wish to archive the outdated issues from your instance.
Backup and Delete - one Jira instance
This is the quickest and easiest of the two methods. You simply take a Jira backup of the entire instance, label the backup with the date and then store it in a secure location. Test that the backup can be restored on a Jira test instance. Once you are satisfied that it all works you can go ahead and delete the projects or issues that are no longer in use. Deleting can also extend to the other dimensions such as custom fields, schemes, etc.
Although quick and easy, the downside to this method is that when you users request to see an archived issue you will need to find the appropriate backup and then restore it to another Jira instance. This is the best method to use if you do not anticipate a large number of archive retrieval requests.
Migrate and Delete - two Jira instances
This method is much more complicated. First, you will initially take a full backup, then restore this into a separate Jira instance. Verify that everything has come across. Once you are happy you will keep the issues you want to archive in this instance and delete everything else. For future archiving sessions you will go to your production instance and create a filter for all the issues you want to archive. Move these issues into a separate project and then take a full backup of your Jira instance. You will then use Jira's project restore to import this project into the archive instance where you can then move these issues into their respective projects.
Although this method takes up a lot more time and resources, the main advantage is that you will essentially have a live archive instance that your users can visit anytime they want to see an archived issue.
For more information, see Backing Up Data.
As your Jira user base grows you may want to take a look at the following:
- Connecting Jira to your LDAP Directory for authentication, user and group management.
- Connecting to Crowd or Another Jira Server for User Management.
- Allowing Other Applications to Connect to Jira for User Management.
Jira Knowledge Base
For detailed guidelines on specific performance-related topics refer to the Troubleshooting Performance Problems article in the Jira Knowledge Base.
Jira Enterprise Services
For help with scaling Jira in your organization directly from experienced Atlassians, reach out to our Premier Support and Technical Account Management services.
The Atlassian Experts in your local area can also help you scale Jira in your own environment.