In this guide, we will discuss the need to integrate ServiceNow Incidents with Jira Issues.
We will cover why admins set up the ServiceNow Jira integration in the first place. How to choose the right technology to configure the integration. And we will cover the step-by-step process on how to set it up.
Note: in this tutorial, we will be using an integration tool called Exalate to set up the integration. You will learn more about this, as well as other integration options, throughout this guide.
Here is an overview of what we will cover:
- Why Integrate ServiceNow and Jira
- How to choose the right technology for setting up the integration
- How to set up the ServiceNow Jira integration (step-by-step process)
Why integrate ServiceNow with Jira
Thinking of IT Service Management, ServiceNow has become a mainstream choice for CIO’s & the head of IT departments to consider.
Started as an innovative niche cloud platform to manage ITSM processes based on ITIL best practice, ServiceNow has gained enormous traction in recent years. They currently have more than 20.000 customers world-wide & are growing rapidly.
On the other hand, when thinking of Agile Software development, Jira sprints in mind immediately.
As part of the Atlassian product offering, Jira manages issues & projects for Software teams. And it integrates nicely with other Software development tools of Atlassian. In short, for many Software teams, Jira is the natural choice for Issue/Project management. This is especially true when other Atlassian products are used for Software Development too.
With the above positioning of ServiceNow & Jira in the IT Service Management & Software development space in mind, the need for integration becomes obvious.
Here I’ve summed up two examples of possible scenarios:
- A company’s IT department uses ServiceNow to provide users a One-Stop-Shop portal for all IT services. This includes reporting issues on Software. In-house Software teams use Jira to manage Issues/Projects. They generally prefer the Atlassian suite because it is used for Coding/Collaboration.
- Incidents reported by a user on ServiceNow need to be forwarded to Jira as an issue to be solved by the Software team
- When the Software team encounters infrastructure issues, they need to be forwarded to ServiceNow as an Incident
- A company uses ServiceNow for ITSM and one or several Software packages are provided by an external Software vendor. The software vendor tracks issues on the Software from all customers with Jira. Then the incident in ServiceNow needs to create an Issue on Jira and get status updates.
How to choose the right technology for setting up your integration
When designing an integration between two ticketing tools, three aspects always need to be considered:
- Autonomy: The ticketing tools at each end of the integration has the means to control what information is sent to the other side and how incoming information is interpreted. Changes in the ticketing tools shouldn’t break the integration. Rather they should be easily reflected in the integration.
- Reliability: A reliable integration is one that always works for the user – even when the other side is not available for whatever reason (such as maintenance). Operational maintenance capability is important to ensure an always-on integration.
- Flexibility in configuration: The integration is able to bridge the differences in the two systems. To be able to effectively attribute mapping is a first mandatory step. Having the flexibility to align the process differences between the teams/organizations – a second
- For this guide, we’ll set up the integration using Exalate. Precisely because Exalate was built to fulfill the above requirements. And it meets the criteria for the described ServiceNow Jira integration scenarios.
In the chapters below I will show you how Exalate addresses the above aspects in more detail. But first, let’s go through the step-by-step process on how to set up the integration!
How to set up a ServiceNow Jira integration (a step-by-step process)
Step 1: Install the Exalate app on your ServiceNow instance
To install Exalate on your ServiceNow instance, you’ll have to use an “update set”.
You can find the step-by-step instructions of Exalate agent installation for ServiceNow on the following Exalate documentation page:Installing the Exalate app on your ServiceNow instance
Step 2: Install the Exalate app on your Jira instance
In order for Exalate to work, it needs to be installed on both sides of the integration.
This means you’ll also have to install Exalate on Jira. This will be the straight forward process as installing a jira app.
You can find the step-by-step instructions of installing the Exalate agent on your Jira instance here:
Step 3: Have a quick look at the Exalate console
The Exalate console provides a user interface for System administrators to configure & maintain the Integration.
After installing, the Exalate console should be directly accessible as an Application on the ServiceNow instance:
At the Jira side, similar configuration options are provided as an Application as well:
With the Exalate console you can, on the one hand, create/maintain your configuration. On the other hand, you can also view Sync Queues and check/resolve errors.
These capabilities will help to maintain the integration efficiently.
But, let’s move on to setting up a connection between your Jira and ServiceNow instance.
Step 4: Establish a connection between Jira and ServiceNow
1. Send an invitation code
Once the Exalate agent is installed on both ServiceNow & Jira, you need to set up connections between the two Exalate agents.
Either side can initiate the Connection or else accept the Connection invitation from the other side.
Below you have step-by-step instructions to set up the connection between the two systems:
- Configure Connection on Exalate ServiceNow agent
- Configure Connection on Exalate Jira Cloud
- Configure Connection on Exalate Jira Server
But here’s a recap of what it boils down to.
You’ll first have to Initiate a connection in the Connections tab.
You’ll then have to choose the connection type. That’s either connecting with the other side that’s accessible or not accessible.
Then you’ll have to choose between the pre-existing sync rules templates. Don’t worry about configuring this or selecting the wrong one. You’ll be able to edit this later. We’ll get back to this in step 6.
The only thing left to do here is to pick a connection name and “Initiate Connection”.
Quick note: you can toggle the Active option on and off, which means you can prepare a connection before you have a need for it.
This will generate an invitation code. You’ll have to copy this so the other side can Accept the invitation.
2. Accept the invitation code
That code you’ve just generated is what you will use to accept the invitation on the other side. So, move over to the other side, go to Connections and Accept Invitation.
Go ahead and past the code there:
The code will validate automatically once you’ve clicked Next.
Your connection type will be set automatically based on the invitation.
You’ll be able to configure the sync rules for this side separately, from the other side. This has been done on purpose, so each side will remain autonomous.
However, you do not have to configure this here yet. We’ll configure this later in Step 6.
After you’ve accepted the invitation and a connection has been established, we can move on to setting up a rule that will serve as a trigger for the synchronization.
Step 5: Configure your synchronization triggers to determine when to sync
Once a connection between ServiceNow and Jira is established, the main work of integration can start.
Have both sides agree on synchronization rules
At this stage, close cooperation between the Incident/Issue manager are needed to determine when an Incident at the ServiceNow side needs to create an Issue at the Jira side, or vice versa.
The agreement can be defined on ServiceNow Exalate & Jira Exalate independently, allowing all possible scenarios. However, it’s also possible that you’re an admin on both sides.
Set up an automated synchronization trigger
If the process managers have determined that whenever an Incident is assigned to an Assignment group called Jira ServiceDesk, an Issue needs to be created at the Jira side.
The Trigger defined in Exalate ServiceNow looks like the following:
If, at the same time, they also agree that whenever an Issue at the Jira has IssueType ServiceNow, it will create an Incident at ServiceNow for teams on ServiceNow to solve.
The Trigger defined in Exalate Jira looks like the following:
Step 6: Configure your connection to determine the information to send
Once an Incident on ServiceNow fulfills the conditions defined by the Trigger, the ServiceNow Exalate will receive access to the Incident through the REST API.
Configure the outgoing sync
What information is sent to the Jira Exalate is defined in the Connection Sync Rules -> Outgoing sync.
Here’s a screenshots of what it looks like:
- replica.<attributes> represents the message attributes. In our case it represents Jira Exalate.
- issue.<attribute> represents the local record attributes. In our case it represents Servicenow Incidents.
The above example is an out-of-box, straightforward mapping. However more complex mapping can be defined using groovy scripts in this section as well. Exalate provides a number of Script Helpers tot reduce the effort to script yourself.
Configure the incoming sync
The incoming sync will determine how to interpret the information received.
The rules on how to interpret the incoming data is configured in the Connection Sync Rules as well.
On the ServiceNow Exalate, there is a distinction for when an Incident is created or updated.
In the example shown below, it is defined to store the Link to Jira Issue to the ServiceNow Incident correlation_id attribute. Incident correlation_name is set to Exalate.
Just like with outgoing sync rules, more complex mappings can be scripted.
Below is an example of mapping the ServiceNow Incident States with the Jira Issue Status. (Again Exalate Script Helpers can help reduce the scripting effort.)
Additional information on Exalate as an integration solution
Since we used Exalate to set up the Jira ServiceNow integration, you might have some questions about this solution.
Here I’ll explain a bit more about Exalate’s architecture and security.
On autonomy in architecture
The basic architectural setup of Exalate as integration enabler between two system is depicted below:
In our scenario Tracker (Blue) would be your ServiceNow instance, Tracker (Red) would be the Jira Server or Cloud instance.
Tracker(Blue) and Tracker(Red) have a separate Exalate Agent dedicated to your ServiceNow/Jira.
- Letters A -F depicts the information flow between the systems. ServiceNow and Jira communicate with each other through the dedicated Exalate agent, keeping the autonomy of your system
- Your (ServiceNow connected) Exalate Agent controls what information are sent and how incoming information is mapped.
- Exalate agent is available for ServiceNow instance, Jira Cloud, Jira On Premise, HP ALM/QC, Github, Zendesk and more to come
Exalate is an intelligent middleware that transports data between ServiceNow & Jira.
The Security consideration is described in great details in the following whitepaper, free for download: “Exalate Security and Architecture Whitepaper”.
The below image explains the different deployment models Exalate is supporting.
Exalate for ServiceNow can be deployed either in the cloud or on-premise.
Comparison between Exalate and the Integration Hub with the Jira Scope
ServiceNow itself has a capability called IntegrationHub that allows reusable integrations with third-party systems and call them from anywhere in the ServiceNow platform.
Using the IntegrationHub requires you to get a separate subscription.
The Standard package of IntegrationHub includes a Jira Spoke with a (limited) number of Actions that allows ServiceNow to manage issues, users, stories, and groups in Jira. And it retrieves Jira data to use in a flow.
Jira spoke V2.5 uses bi-directional webhooks and subscribes to Jira with a ServiceNow callback URL.
So, why use a third-party tool, like Exalate, to set up the integration?
Below I’ve added some considerations:
- Use Exalate when
- The integration is bi-directional. Then both sides will be able to trigger the integration and decide on the information to be exchanged.
- The integration is point-to-point between the two systems.
- Use IntegrationHub when
- ServiceNow has the orchestration role to create an automated flow, involving several systems.
- ServiceNow controls the trigger of integration, remote system (in our case Jira) is the receiver of the commands
Many ITSM-teams adopt ServiceNow as a best-in-class solution. While development and Project Management teams still widely consider Jira as the ideal solution.
As efficient collaboration is crucial for any effective organization, integrations between these systems are increasingly common.
When considering the right technology to set up the integration, it’s import to keep into account the following three aspects:
- Does each side have autonomy over outgoing and incoming information and how it is interpreted?
- Is the solution reliable enough to continue working, independently from changes to the other side of the integration?
- Is the solution flexible enough to cover a wide variety of use cases and evolve with your way of working?
In this guide we’ve set up the integration using Exalate. And we’ve described the step-by-step process on how to complete this integration.