In any deployment, you will end up writing a couple of cloud rules that need to be sent to SailPoint Expert Services (ES) for uploading to your tenant.
Typically, we deploy to the sandbox tenant, test the rules, and then move them to the production tenant. Traditionally, this involved emailing ES to request the rule transfer across tenants.
However, there is a quick and easy alternative if you don’t want to wait for ES deployment in the next tenant. I will explain the sp-config API available for moving code across environments.
Many may not be aware that this API can also export and import deployed rules. The number of supported objects has increased since I last wrote my article.
This list is continually growing, but the main object we currently care about is RULE.
Here are the simple steps:
- Get your rule approved and deployed into your sandbox environment
- Export the rule from sandbox environment via sp-configĀ
|
1 2 3 4 5 6 7 8 9 10 |
POST /beta/sp-config/export Authorization: Bearer {token} Content-Type: application/json { "description": "Export Rules", "includeTypes": [ "RULE" ] } |
- Once exported, import the rule into the production environment. It will allow you to move rules so long as you don’t change it in transit or edit the JSON.
This method is great for moving rules across tenants. However, I still recommend deploying the rules via the normal process for consistency.
Tokenisation for Environments
When moving rules across environments, we often need to make changes because there are different values for variables, such as the AD OU structure that might be referenced. How can we make the process seamless, allowing you to copy and deploy the same rule without any changes in all environments?
Let’s go through each cloud rule type and see how we can solve this issue. Please note that this may not work for very complex rules but should be effective most of the time.
- Generic Rule: These rules are always referred to via a transform, so the code inside is easy to maintain. Pass the variables via transform, which can remain the same across tenants.
- Identity Attribute Rule: For example, LCS rules which uses source names to refer to attributes and retrieve their values. Keep the same source name across environments, ensuring that the backend source name remains consistent and can be referred to in the rule. This will also help in transform moves since source names they are referring to are same.
- Manager Correlation / Correlation / Account Profile / Before Provisioning Rule: All of these rule types are attached to a source, which means they have an input of application class. Here’s what I typically do
Let’s say a Before Provisioning (BP) rule is created for the AD connector in the sandbox and needs to be moved to production. There might be some subtle changes in the rule between both environments, such as the AD Disabled OU
AD Dev Disabled OU: OU=Disabled,DC=abc,DC=dev,DC=local
AD Prod Disabled OU: OU=Disabled,DC=abc,DC=local
Rest all your logic may be similar but you need to change these between environments. To handle this, I use the following code within the rule
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
/* Sources - Dev 2f2c0ee46e1d48d7a9de329aa49eb5d7 Active Directory Sources - Prod b8db9359c1b54fdbb70cf599c494fd45 Active Directory */ String AD_SOURCE_ID = application.getId(); String AD_SOURCE = null; String AD_DISABLED_OU = null; if ("2f2c0ee46e1d48d7a9de329aa49eb5d7".equalsIgnoreCase(AD_SOURCE_ID)) { // Dev Environment AD_SOURCE = "SB"; AD_DISABLED_OU = "OU=Disabled,DC=abc,DC=dev,DC=local"; } else if ("b8db9359c1b54fdbb70cf599c494fd45".equalsIgnoreCase(AD_SOURCE_ID)) { // Prod Environment AD_SOURCE = "PROD"; AD_DISABLED_OU = "OU=Disabled,DC=abc,DC=local"; } ..... // Rest of the code |
As you can see, I use the application.getId() method to retrieve the ID of the application the rule is attached to. Since we would have created the source in both the sandbox and production environments, you can obtain the ID via the /v3/sources API and set them accordingly. By knowing which environment my rule is attached to, I can then set the variables for AD_SOURCE and AD_DISABLED_OU (and other logics), allowing me to copy the same rule into both the sandbox and production environments.
This approach minimizes code maintenance for both environments and ensures that the same rule can be easily copied to both environments. As long as we have set the correct variables for each environment, our logic will work when tested in the sandbox and in production. This also eliminates the need to inject such values into the source JSON (an old method).
I hope this explanation makes sense and helps simplify your rule development, maintenance, and deployment across tenants.
Happy coding!!!
