To integrate JumpCloud with Atlassian for asset management. For a dedicated AM scope, you'll typically leverage Jira Service Management (JSM) with its "Assets" feature (formerly Insight), and potentially a third-party application that bridges JumpCloud's device data with Jira's asset capabilities.
Here's a breakdown of the approach and steps:
JumpCloud:
Cloud Directory Platform: Your central source of truth for users, groups, and devices.
Device Management (UEM): JumpCloud can manage various endpoints (laptops, desktops) across different operating systems. It gathers system insights and can push policies.
SSO & SCIM: Essential for user synchronization and authentication with Atlassian products.
Atlassian Cloud:
Jira Service Management (JSM): The primary Atlassian product for IT Service Management (ITSM).
Assets (formerly Insight): A powerful Configuration Management Database (CMDB) built into Jira Service Management. This is where you'll define and store your asset information (laptops, monitors, software licenses, etc.). It allows you to create object schemas, object types, and individual objects, and link them to service requests.
Atlassian Guard: Required for configuring SSO and SCIM with JumpCloud across your Atlassian Cloud products.
Key Integration Methods/Applications:
JumpCloud's Native Atlassian Cloud Integration (SSO & SCIM): This handles user and group provisioning and authentication, ensuring your JumpCloud users can seamlessly log into Atlassian. This is foundational for any other integration.
Third-Party Integration Apps (from Atlassian Marketplace): This is often the key to truly bridging JumpCloud's device data with Jira Service Management's "Assets" for comprehensive asset management. Examples include:
Multiplier: This app can automate JumpCloud workflows from JSM, including user management (provisioning, group assignment, password resets) and potentially app access requests. While its primary focus isn't directly syncing device attributes to Assets, it plays a role in connecting user-related actions.
BlueTally, AssetSonar: These are dedicated IT Asset Management (ITAM) tools that offer JumpCloud integrations and often have direct integrations or strong capabilities to connect with Jira, allowing for unified device management and asset tracking. They can pull device data from JumpCloud and populate their own asset databases, which can then be synchronized with Jira Assets.
Custom Integrations/APIs: For advanced or highly specific needs, you might explore using JumpCloud's API and Atlassian's APIs (Jira/Assets) to build custom scripts or connectors.
Phase 1: Foundational User & Group Sync (JumpCloud to Atlassian Cloud)
This establishes the core identity management.
Prerequisites:
A JumpCloud administrator account.
JumpCloud SSO Package or higher.
Your domain verified with Atlassian.
Atlassian Guard enabled in your Atlassian Cloud organization.
Ensure email addresses match between JumpCloud and Atlassian for SAML workflow.
Configure Atlassian Cloud Application in JumpCloud:
Log in to the JumpCloud Admin Portal.
Go to USER AUTHENTICATION > SSO Applications.
Click (+) and search for "Atlassian Cloud" or select it.
Provide a display label.
Configure SSO in JumpCloud:
Within the Atlassian Cloud application in JumpCloud, go to the SSO tab.
Replace YOUR_ORG_NAME (or similar placeholder) with your Atlassian Cloud organization name in the IdP Entity ID (if applicable).
Save.
Download the x509 certificate from the SSO tab (Actions > Download certificate).
Configure Atlassian Guard for SSO:
Log in to your Atlassian Admin Console.
Go to Security > SAML single sign-on.
Click Add SAML configuration.
Enter the Identity provider Entity ID and Identity provider SSO URL from JumpCloud.
Paste the content of the downloaded x509 certificate into the Public x509 certificate field.
Copy the SP Identity ID and SP Assertion Consumer Service URL (ACS URL) displayed in Atlassian.
Finish Configuring JumpCloud SSO Application:
Go back to the Atlassian Cloud application in JumpCloud.
In the SSO tab, for SP Entity ID, paste the SP Identity ID from Atlassian.
For ACS URL, paste the ACS URL from Atlassian.
Save.
Set Up User Provisioning (SCIM) in Atlassian and JumpCloud:
In the Atlassian Admin Console, ensure your domain is verified.
Go to Security > Identity providers.
Select your JumpCloud Identity Provider Directory (you might need to add it if not already present).
Select Set up user provisioning.
Copy the SCIM base URL and API key (secret) provided by Atlassian.
In the JumpCloud Atlassian Cloud application, go to the Identity Management tab.
Enable management of User Groups and Group Membership.
Paste the SCIM base URL into SP Base URL.
Paste the API key into SP API Token.
Click Activate and then Save.
Connect user groups in JumpCloud to this application to provision and sync users and groups to Atlassian.
Phase 2: Integrating JumpCloud Device Data with Jira Service Management Assets
This is where you bridge device information for asset management.
Enable Assets in Jira Service Management:
In your Jira Service Management project, ensure the "Assets" feature is enabled.
You can access Assets from the top navigation bar.
Define Your Object Schemas and Object Types in Assets:
In Jira Assets, create or utilize existing object schemas (e.g., "IT Assets").
Within the schema, define object types for your assets (e.g., "Laptops," "Monitors," "Software Licenses," "Mobile Devices").
For each object type, define attributes relevant to the asset (e.g., Serial Number, Model, Manufacturer, Purchase Date, Assigned User, OS, RAM, Storage, Last Seen, IP Address).
Choose Your Integration Method for Device Data:
Option A: Using a Dedicated ITAM Tool (Recommended for comprehensive ITAM)
Identify a tool: Research ITAM tools that integrate with both JumpCloud and Jira Service Management. BlueTally and AssetSonar are good examples.
Integrate ITAM tool with JumpCloud: Follow the specific documentation of your chosen ITAM tool to connect it with JumpCloud. This typically involves using JumpCloud's API to pull device data (System Insights, inventory data, etc.).
Integrate ITAM tool with Jira Service Management Assets: Configure the ITAM tool to push or synchronize asset data into your Jira Assets object schemas. This might involve direct integrations or using CSV/JSON imports.
Map attributes: Carefully map the device attributes from JumpCloud (via the ITAM tool) to the corresponding attributes in your Jira Assets object types.
Option B: Using Multiplier (for automating workflows and some data visibility)
Install Multiplier: Install the Multiplier app from the Atlassian Marketplace into your Jira instance.
Integrate Multiplier with JumpCloud: Configure Multiplier with your JumpCloud API Key (obtained from your JumpCloud Admin Portal: Click your initials in the top right corner > My API Key).
Leverage Multiplier for user-centric asset actions: While Multiplier primarily focuses on automating user-related actions (onboarding, app access, group assignment), it can display some JumpCloud user attributes in Jira. You might be able to use Multiplier's custom fields or post-functions to link users to their devices if that data is available in JumpCloud and can be pulled.
Manual or semi-automated asset population: For the actual device assets in Jira Assets, you might still need a separate process (manual import, other integrations, or a more direct API approach) to populate the detailed device information into Assets if Multiplier doesn't directly support this.
Option C: Custom API Integration (for advanced users/developers)
JumpCloud API: Explore JumpCloud's API documentation to programmatically extract device information (Unified Endpoint Management data, System Insights).
Atlassian Jira/Assets API: Explore the Jira Service Management API and Assets API to understand how to create, update, and manage objects (assets) programmatically.
Develop a custom script/connector: Write a script (e.g., Python) that fetches device data from JumpCloud via its API and then uses the Atlassian APIs to populate/update your Jira Assets database. This provides the most flexibility but requires development resources.
Populate Assets with Device Data:
Initial Import: Perform an initial import of your existing device data from JumpCloud (or your chosen ITAM tool) into Jira Assets. This can often be done via CSV import for initial setup, but automated sync is preferred for ongoing management.
Ongoing Synchronization: Set up scheduled synchronizations (daily, hourly, etc.) to keep your Jira Assets up-to-date with changes in JumpCloud's device data. This is crucial for accurate asset tracking.
Link Assets to Users and Service Requests:
Assign Assets to Users: In Jira Assets, link individual assets (e.g., a specific laptop) to the JumpCloud-synced users. This allows you to see who has which device.
Utilize Assets in JSM Workflows: Configure your Jira Service Management request types and workflows to leverage the asset data. For example:
When a user reports an issue with their laptop, they can select their specific laptop from a field populated by Jira Assets.
IT agents can quickly see the details of the affected asset (model, serial number, assigned user, recent activity from JumpCloud insights) directly within the Jira ticket.
Automate actions based on asset status (e.g., if a laptop is marked "lost" in Assets, trigger a wipe command in JumpCloud).
Considerations and Best Practices:
Data Mapping: Carefully plan how attributes from JumpCloud will map to fields in Jira Assets. Consistency is key.
Data Freshness: Determine the frequency of synchronization needed to ensure your asset data is up-to-date.
Permissions: Configure appropriate permissions in both JumpCloud and Atlassian to ensure the integration has the necessary access.
Error Handling and Logging: Implement robust error handling and logging for any custom integrations to troubleshoot issues effectively.
Scope: Start with a clear scope for your asset management needs. Do you need to track hardware, software, licenses, or all of the above?
Reporting and Dashboards: Leverage Jira's reporting and dashboard capabilities to gain insights into your asset inventory, lifecycle, and related incidents.
Testing: Thoroughly test the integration in a non-production environment before deploying to production.
By combining JumpCloud's identity and device management capabilities with Jira Service Management's powerful "Assets" feature, and potentially a specialized ITAM tool, you can achieve a robust asset management solution that streamlines your IT operations.
Next we have a more deep dive into the Option C of the previous text, in which we will breakdown how to achieve this ITAM integration.
Granular Control: You dictate exactly what data is pulled, how it's transformed, and where it lands in Jira Assets.
Specific Data Points: JumpCloud's Device Management and System Insights provide a wealth of data (OS version, hardware specs, installed software, IP address, last check-in, etc.). You can cherry-pick the most relevant attributes for your asset records.
Automated Workflows: Beyond just syncing data, you can trigger actions based on asset changes (e.g., if a device status in JumpCloud changes to "offline" for too long, automatically create a Jira Service Management incident).
Bi-directional Sync (Advanced): While the primary flow is often JumpCloud to Jira Assets, you could potentially update certain JumpCloud device attributes from Jira Assets (e.g., "assigned user" in Jira Assets updates the associated user in JumpCloud for that device).
Cost-Effective for Niche Needs: If commercial integrations are too expensive or overkill for your precise requirements, a custom script can be a more economical solution.
Programming Language: Python is an excellent choice due to its readability, extensive libraries (for HTTP requests, JSON parsing), and ease of scripting. Other options include Node.js, PowerShell, or Go.
JumpCloud API:
Purpose: To extract device information, user details, and potentially other relevant data from your JumpCloud directory.
Key Endpoints for Asset Management:
/api/v2/systems: Retrieves a list of all managed devices (systems). You can filter and expand results. This is your primary source for device attributes like hostname, OS, manufacturer, model, serial number, IP address, etc.
/api/v2/systeminsights: This is where JumpCloud provides real-time, detailed system-level data. You can query for hardware information, installed applications, network interfaces, last seen times, and more. This is crucial for rich asset data.
/api/v2/users: To link devices to their assigned users.
Authentication: Requires an API Key. You generate this in the JumpCloud Admin Portal (Settings > API Keys or similar, depending on current UI).
Rate Limits: Be aware of JumpCloud's API rate limits to avoid getting temporarily blocked. Implement exponential backoff for retries.
Documentation: Refer to the official JumpCloud API documentation for detailed endpoint specifications, request/response formats, and examples.
Atlassian Jira/Assets API (Jira Service Management Cloud):
Purpose: To create, update, and query asset objects within Jira Service Management's "Assets" (CMDB). Also, potentially to create/update Jira issues.
Key APIs:
Jira Cloud Platform REST API (v3): This is the general Jira API for managing issues, projects, users, custom fields, etc. You'll use this to get information about your Jira instance and potentially link assets to issues.
Jira Service Management Assets REST API (formerly Insight API): This is the specific API for interacting with Assets objects, object schemas, object types, and attributes. This is the core API for asset management.
Endpoints for Assets:
/rest/assets/1.0/objectschemas: To list your existing object schemas.
/rest/assets/1.0/objecttypes: To list object types within a schema.
/rest/assets/1.0/objects: To create, retrieve, update, or delete individual asset objects. This is where you'll be performing most of your operations.
/rest/assets/1.0/aql/objects: Allows querying Assets objects using Asset Query Language (AQL), which is very powerful for finding existing assets.
Authentication:
API Token: For custom scripts, the recommended method is to use an API token generated from your Atlassian account. You'll use this token along with your email address for basic authentication.
Permissions: The Atlassian account associated with the API token must have the necessary permissions to create, update, and read objects in your Assets schemas.
Data Structure: Assets uses an object-oriented structure. You'll need to know your objectSchemaId, objectTypeId, and objectTypeAttributeId values to manipulate asset data.
Rate Limits: Atlassian APIs also have rate limits. Implement robust retry mechanisms.
Documentation: Consult the Atlassian Developer documentation for Jira Cloud Platform REST API and especially the Jira Service Management Assets REST API for detailed information.
Phase 1: Planning and Setup
Identify Data Points:
From JumpCloud, what specific device attributes (hostname, serial, OS, IP, MAC address, installed software, assigned user, last seen, etc.) do you want to track?
From Jira Assets, define your Object Schemas (e.g., "Hardware," "Software," "Network Devices").
Within each schema, define Object Types (e.g., "Laptop," "Monitor," "Printer," "Windows Server," "macOS Device").
For each Object Type, define the corresponding Attributes (e.g., "Serial Number," "Model," "Operating System," "Assigned To," "Last Seen (JumpCloud)"). Map the JumpCloud data points to these Jira Assets attributes. Note down the objectTypeAttributeId for each.
API Key & Token Generation:
JumpCloud API Key: Log into JumpCloud Admin Portal, go to Settings (or similar), then API Keys, and generate a new key. Keep it secure!
Atlassian API Token: Log into id.atlassian.com/manage/api-tokens, click "Create API token," give it a label, and copy the generated token. Store it securely.
Choose Your Environment:
Local Machine: For initial development and testing.
Cloud Function/Serverless: For scheduled, automated execution (e.g., AWS Lambda, Google Cloud Functions, Azure Functions).
Containerized Application: For more complex deployments (Docker, Kubernetes).
Install Libraries (Python Example):
Bashpip install requests # For making HTTP requests
pip install atlassian-python-api # A community-maintained wrapper for Atlassian APIs (optional but can simplify things)
# You might also use the JumpCloud's unofficial Python SDK or just direct 'requests'Phase 2: Developing the Script
Let's assume a Python script for this example.
Configuration:
Store API keys/tokens and other sensitive information securely (environment variables, a separate config file not committed to version control, or a secret management service).
Define your Jira Cloud URL, Assets schema IDs, object type IDs, and attribute IDs.
Python# config.py (example - DO NOT hardcode sensitive info in production)
JUMPCLOUD_API_KEY = "YOUR_JUMPCLOUD_API_KEY"
JIRA_CLOUD_URL = "https://your-domain.atlassian.net"
JIRA_EMAIL = "your-jira-admin-email@example.com"
JIRA_API_TOKEN = "YOUR_ATLASSIAN_API_TOKEN"
# Assets specific IDs (these will be unique to your Jira Assets configuration)
JIRA_ASSETS_SCHEMA_ID = "1" # Replace with your Assets Schema ID
JIRA_ASSETS_OBJECT_TYPE_LAPTOP_ID = "100" # Replace with your Laptop Object Type ID
JIRA_ASSETS_ATTR_SERIAL_NUMBER_ID = "200" # Replace with your Serial Number Attribute ID
JIRA_ASSETS_ATTR_HOSTNAME_ID = "201"
JIRA_ASSETS_ATTR_OS_ID = "202"
JIRA_ASSETS_ATTR_ASSIGNED_USER_ID = "203"
JIRA_ASSETS_ATTR_LAST_SEEN_ID = "204"
# ... define other attribute IDs as neededJumpCloud API Interaction (GET Device Data):
Use the requests library (or jcapi-python SDK if you prefer) to make GET requests to JumpCloud's /api/v2/systems and /api/v2/systeminsights endpoints.
Handle pagination to retrieve all devices.
Parse the JSON response to extract the desired device attributes.
Pythonimport requests
import json
from config import JUMPCLOUD_API_KEY
def get_jumpcloud_devices():
headers = {
"x-api-key": JUMPCLOUD_API_KEY,
"Content-Type": "application/json",
"Accept": "application/json"
}
devices = []
url = "https://console.jumpcloud.com/api/v2/systems"
skip = 0
limit = 100 # Max results per page
while True:
params = {"limit": limit, "skip": skip}
response = requests.get(url, headers=headers, params=params)
response.raise_for_status() # Raise an exception for HTTP errors
data = response.json()
devices.extend(data)
if len(data) < limit:
break # No more pages
skip += limit
return devices
def get_jumpcloud_system_insights(system_id):
headers = {
"x-api-key": JUMPCLOUD_API_KEY,
"Content-Type": "application/json",
"Accept": "application/json"
}
# Example: Query for hardware info
url = f"https://api.jumpcloud.com/insights/systems/{system_id}/system_info?sort=timestamp&limit=1"
response = requests.get(url, headers=headers)
response.raise_for_status()
return response.json() # Returns a list of insights, usually take the latest
# Example usage:
# all_jc_devices = get_jumpcloud_devices()
# for device in all_jc_devices:
# device_id = device.get('id')
# hostname = device.get('hostname')
# os = device.get('os')
# serial_number = device.get('serialNumber')
# user_id = device.get('agentOwnedByUserId') # or look up from agentOwnedByUsername
# last_seen = device.get('lastContact')
#
# # Fetch more detailed insights if needed
# # insights = get_jumpcloud_system_insights(device_id)
# # hardware_info = insights[0].get('hardwareInfo') if insights else NoneAtlassian Jira Assets API Interaction (CREATE/UPDATE Assets):
For each JumpCloud device, check if an equivalent asset already exists in Jira Assets (e.g., by serial number or hostname). Use the Assets AQL API (/rest/assets/1.0/aql/objects) for efficient lookup.
If it exists, update the asset. If not, create a new one.
Construct the JSON payload for creating/updating objects. This is critical. You'll use objectTypeId and objectTypeAttributeId to set values.
Pythonimport requests
import json
from config import (
JIRA_CLOUD_URL, JIRA_EMAIL, JIRA_API_TOKEN,
JIRA_ASSETS_SCHEMA_ID, JIRA_ASSETS_OBJECT_TYPE_LAPTOP_ID,
JIRA_ASSETS_ATTR_SERIAL_NUMBER_ID, JIRA_ASSETS_ATTR_HOSTNAME_ID,
JIRA_ASSETS_ATTR_OS_ID, JIRA_ASSETS_ATTR_ASSIGNED_USER_ID,
JIRA_ASSETS_ATTR_LAST_SEEN_ID
)
def get_jira_assets_headers():
return {
"Authorization": f"Basic {base64.b64encode(f'{JIRA_EMAIL}:{JIRA_API_TOKEN}'.encode()).decode()}",
"Accept": "application/json",
"Content-Type": "application/json"
}
def find_asset_by_serial(serial_number):
headers = get_jira_assets_headers()
aql_query = f"objectType = {JIRA_ASSETS_OBJECT_TYPE_LAPTOP_ID} AND 'Serial Number' = '{serial_number}'"
url = f"{JIRA_CLOUD_URL}/rest/assets/1.0/aql/objects"
params = {"qlQuery": aql_query}
response = requests.get(url, headers=headers, params=params)
response.raise_for_status()
data = response.json()
return data['objects'][0] if data['objects'] else None
def create_or_update_asset(jumpcloud_device, jira_asset_data=None):
headers = get_jira_assets_headers()
# Extract relevant data from JumpCloud device
jc_serial = jumpcloud_device.get('serialNumber')
jc_hostname = jumpcloud_device.get('hostname')
jc_os = jumpcloud_device.get('os')
jc_user_id = jumpcloud_device.get('agentOwnedByUserId') # Or convert to Atlassian Account ID if needed
jc_last_seen = jumpcloud_device.get('lastContact')
# Prepare attributes for Assets object
attributes = [
{
"objectTypeAttributeId": JIRA_ASSETS_ATTR_SERIAL_NUMBER_ID,
"objectAttributeValues": [{"value": jc_serial}]
},
{
"objectTypeAttributeId": JIRA_ASSETS_ATTR_HOSTNAME_ID,
"objectAttributeValues": [{"value": jc_hostname}]
},
{
"objectTypeAttributeId": JIRA_ASSETS_ATTR_OS_ID,
"objectAttributeValues": [{"value": jc_os}]
},
# Map JIRA_ASSETS_ATTR_ASSIGNED_USER_ID to Atlassian Account ID for user linking
# This might require an additional API call to Jira's user API to resolve email to account ID
# For simplicity, let's assume we map to a text field for now, or resolve JIRA user by email.
# {
# "objectTypeAttributeId": JIRA_ASSETS_ATTR_ASSIGNED_USER_ID,
# "objectAttributeValues": [{"value": resolved_jira_user_account_id}]
# },
{
"objectTypeAttributeId": JIRA_ASSETS_ATTR_LAST_SEEN_ID,
"objectAttributeValues": [{"value": jc_last_seen}]
}
]
payload = {
"objectTypeId": JIRA_ASSETS_OBJECT_TYPE_LAPTOP_ID,
"attributes": attributes
}
if jira_asset_data: # Update existing asset
object_id = jira_asset_data['id']
url = f"{JIRA_CLOUD_URL}/rest/assets/1.0/object/{object_id}"
response = requests.put(url, headers=headers, data=json.dumps(payload))
print(f"Updating asset {object_id}: {response.status_code}")
else: # Create new asset
url = f"{JIRA_CLOUD_URL}/rest/assets/1.0/object/create"
response = requests.post(url, headers=headers, data=json.dumps(payload))
print(f"Creating new asset: {response.status_code}")
response.raise_for_status()
return response.json()
# Main synchronization logic
# import base64 # needed for base64 encoding
# all_jumpcloud_devices = get_jumpcloud_devices()
# for jc_device in all_jumpcloud_devices:
# serial_num = jc_device.get('serialNumber')
# if serial_num:
# existing_asset = find_asset_by_serial(serial_num)
# create_or_update_asset(jc_device, existing_asset)
# else:
# print(f"Skipping device {jc_device.get('hostname')} due to missing serial number.")Error Handling and Logging:
Implement try-except blocks for API calls to catch requests.exceptions.RequestException (network errors, HTTP errors).
Log successes, failures, and relevant data to a file or a logging service (e.g., Splunk, ELK stack).
Handle rate limits by implementing exponential backoff with retries.
Scheduling:
Cron Job (Linux/macOS) or Task Scheduler (Windows): For simple, on-premise scheduling.
Cloud Scheduler (e.g., Google Cloud Scheduler, AWS EventBridge/CloudWatch Events): To trigger cloud functions or containers on a schedule.
Orchestration Tools (e.g., Apache Airflow, Prefect): For more complex workflows, dependency management, and monitoring.
Phase 3: Deployment and Maintenance
Secure Credentials: Never hardcode API keys/tokens in your script. Use environment variables, a secrets manager (AWS Secrets Manager, Azure Key Vault, Google Secret Manager), or a secure configuration file.
Version Control: Store your script in a version control system (Git) for tracking changes, collaboration, and rollbacks.
Testing:
Thoroughly test with a small subset of data first.
Test edge cases (missing data, malformed data, API failures).
Test the full cycle: initial creation, subsequent updates, and deletion (if applicable).
Monitoring and Alerts:
Monitor the script's execution.
Set up alerts for failures, high error rates, or prolonged run times.
Monitor the state of your assets in Jira Service Management to ensure accuracy.
Documentation: Document your script, its dependencies, the API endpoints it uses, the data mapping, and deployment instructions.
User Linking: If you want to link a JumpCloud device to a specific Jira user in the "Assigned To" field (which is often a User Picker custom field in Jira), you'll need to:
Get the accountId of the Jira user. The Jira API has endpoints to search for users by email address.
Use that accountId when updating the "User" type attribute in Jira Assets.
Decommissioning Assets: Implement logic to mark devices as "decommissioned" or "inactive" in Jira Assets if they are no longer reported by JumpCloud.
Change Detection: To optimize API calls, you might implement a way to only process changes. This could involve:
Storing the lastContact timestamp from JumpCloud and only fetching devices updated since the last run.
Comparing current JumpCloud data with existing Jira Asset data and only pushing updates for changed attributes.
Webhooks (More Real-time): If JumpCloud offers webhooks for device updates (check their documentation), you could set up a webhook listener that triggers your script or a cloud function immediately when a device event occurs, providing near real-time synchronization. Similarly, Jira can trigger webhooks on asset changes.
Asset Lifecycle Management: Integrate with other Jira Service Management features like lifecycle statuses in Assets to reflect the actual state of the device (e.g., "In Stock," "Assigned," "Repair," "Retired").