Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.

ModelOp Center seamlessly integrates with existing ticketing systems, such as JIRA, to allow enterprises to leverage existing IT investments.

Table of Contents

Table of Contents

Introduction

<lorem ipsum>ModelOp Center provides the ability for the Model Life Cycle to create tickets within the existing Jira ticket system. The Model Life Cycle can create tickets corresponding to the manual steps and tasks required. This includes items such as approvals, reviews, tasks, and other activities in the Model’s Life Cycle. This guide details the steps to enable the integration.

Jira Integration Setup

Here are the steps to integrate with an existing Jira instance:

– Find the external IP and port of the jira service using kubectl get svc 
– Go to http://<externalIP>:<port> for Jira and complete the setup process
– Choose “I’ll set it up myself”
– For Database setup, pick “Built In”
– For “Set up application properties”:
– Application title: Jira
– Mode: Public
– Base URL: This should match http://<externalIP>:<port> for the jira service
– For “Specify your license key”, click the link to create a Jira trial license
– For “Set up administrator account”:
– Username: demo 
– Password: modelop
– Everything else can be whatever you want
– Set up email notifications: Later
– At the welcome screen, choose “Create a project” and “Basic software development” and set it’s name as “Demo” (key DEMO)

Prerequisites

This guide assumes moc-builder has been installed. Please request download instructions for moc-builder here. Before configuring moc-builder, the Jira instance will need a service account created and configured to use an API token. To create an API Token, follow the documentation at https://confluence.atlassian.com/cloud/api-tokens-938839638.html. This example assumes that the service account uses the email "jira@modelop.com".

moc-builder Jira Configuration

The integration requires the ModelOp Center Gateway url and the url of the Jira instance to be integrated.

First, determine the external-ip of the Gateway. Set the Kubernetes context to the cluster and namespace that has ModelOp Center deployed. Run the following command:

Code Block
languagebash
kubectl get svc

The command will return an output like this:

Code Block
[johncarter@Johns-MacBook-Pro moc-builder (John@modelop-eks-test.us-east-2.eksctl.io:mocaasin)]$ kb get svc
NAME                TYPE           CLUSTER-IP       EXTERNAL-IP                                                               PORT(S)                                                 AGE
engine-1            ClusterIP      10.100.72.22     <none>                                                                    8003/TCP                                                23h
engine-2            ClusterIP      10.100.31.255    <none>                                                                    8003/TCP                                                23h
engine-test         ClusterIP      10.100.215.6     <none>                                                                    8003/TCP                                                23h
gateway             LoadBalancer   10.100.126.106   foo1.us-east-2.elb.amazonaws.com   8090:31166/TCP                                                                                 23h
jupyter             ClusterIP      10.100.242.107   <none>                                                                    8888/TCP                                                23h
kafka               ClusterIP      10.100.113.242   <none>                                                                    9092/TCP                                                23h
minio               ClusterIP      10.100.82.143    <none>                                                                    9000/TCP                                                23h
mlc-manager         LoadBalancer   10.100.145.82    foo3.us-east-2.elb.amazonaws.com    8085:31741/TCP                                                                                23h
model-manager       ClusterIP      10.100.205.30    <none>                                                                    8086/TCP,8088/TCP                                       23h
mongodb             ClusterIP      10.100.45.49     <none>                                                                    27017/TCP                                               23h
postgres            ClusterIP      10.100.77.22     <none>                                                                    5432/TCP                                                23h
registry            ClusterIP      10.100.138.128   <none>                                                                    8761/TCP                                                23h
reporting-service   ClusterIP      10.100.38.87     <none>                                                                    8091/TCP                                                23h

The important value is the external-ip and port corresponding to the ModelOp Center Gateway. In this example, it’s foo1.us-east-2.elb.amazonaws.com:8090.

NOTE: If the environemnt using ingresses instead of load balancers, run kubectl get ing and obtain the address corresponding to the ingress that points to gateway. Do not append the port number to the end of the address. That is only required if you are using the external IP from a service of type LoadBalancer.

Next, open the config.json file within moc-builder’s config directory and navigate to the mlc-manager section. It will contain the following:

Code Block
languagejson
"mlc-manager": {
  ...
  "env": {
    ...
    "modelop.gateway-url": "http://gateway:8090",
    ...
    "mlc.jira-task-monitor.url": "http://jira:8086",
    ...
  },
  ...
},

Change the value of the modelop.gateway-url env variable to be the location of gateway from above and change the value of the mlc.jira-task-monitor.url to be the location of the Jira instance. In this example, the Jira instance is located at "https://foo.atlassian.net".

Here is the example config.json:

Code Block
"mlc-manager": {
  ...
  "env": {
    ...
    "modelop.gateway-url": "http://foo1.us-east-2.elb.amazonaws.com:8090",
    ...
    "mlc.jira-task-monitor.url": "https://foo.atlassian.net",
    ...
  },
  ...
},

Go ahead and save the config file and open up the file located in moc-builder at data/secrets.json. Here is how the file looks:

Code Block
languagejson
{
  ...
  "JIRA_USERNAME": "demo",
  "JIRA_PASSWORD": "modelop",
  ...
}

Change the JIRA_USERNAME value to be the email associated with the service account and the JIRA_PASSWORD to be the API token that was generated by Atlassian in the prerequisites step.

Here is the example:

Code Block
languagejson
{
  ...
  "JIRA_USERNAME": "jira@modelop.com",
  "JIRA_PASSWORD": "API token goes here",
  ...
}

Next, create a new project in the Jira instance and note the key. Now update the key within the BPMN to be uploaded in ModelOp Center. For example, update the NotficationToITSM.bpmn BPMN within moc-builder to use the Project Key within the delegate:

Code Block
languagejson
notificationAssignment.setJiraProjectKey("YOUR PROJECT KEY");

Next, run the moc-builder compose and deploy commands to bring up the instance of ModelOp Center integrated with Jira.

Note: by default ModelOp Center's BPMN files only require the use of a "Task" issue type, so please confirm the Jira project has the Issue Type available.