Skip to main content
Kofax

Kofax RPA Quick Start Guide - Robot Lifecycle Management (git)

308724

Summary: 

This article contains the general steps to follow to configure Robot Lifecycle Management with Git.

More Information: 

1. Introduction

Robot Lifecycle Management has been introduced in v10.4 of Kofax RPA and, at this time, only Git is supported.

To accomplish the data synchronization between the Management Console and the Git repository, we use an executable (supplied with the installation files) called Synchronizer.exe.

This is the general diagram of the data flow:

 

clipboard_e0b347a9f3578e69a38cb6d78072858b2.png

 

  • Developers create/edit robots in DesignStudio (DS) and upload them to the Management Console (MC). ①
    This is a bidirectional synchronization - the users can download and upload robots to MC (as long as they have rights)
  • Synchronizer will keep the MC and central repository synchronized by pulling and pushing data. ② ③
    • Note1: Synchronizer has its own local repository that is a clone of the central repository. This is created when the Synchronizer starts (if it doesn't exist) and is located in the Application Data folder of the user running Synchronizer under /[Kapow | Kofax RPA]/<version>/Data/Synchronizer.

      The folder name is in this format projectName_machine_repositoryName_branchName
       
    • Note2: This is a bidirectional synchronization as well - Synchronizer will pull data from the central repository and push data it gets from the MC project(s). This is very important because the central repository could allow multiple people to change data and this could end up on the Management Console project.
       
  • The central repository can be on an online service (e.g. github) or in a folder located on the same machine as the Management Console.
  • A git admin can create a local clone of the central repository and use a Git client GUI to perform admin actions (e.g track changes, revert commits, create branches etc) ④
    For more detail information about these actions, please check the Git documentation (or the documentation supplied by the online repository service), this guide contains a few basic actions only.
  • To promote robots to production, you can create a new branch ("prod") that is synchronized to the Production MC. In the diagram above we have two MCs (dev and prod) but this is also possible with just one MC but two different projects (one for "dev" synchronizing the "test" branch and one for "prod" synchronizing the "prod" branch) ⑤ ⑥


    clipboard_ea80a0c39bfbd1403d0bc203e7abdfaf4.png

2. Configuration

2.1. Configuration - Central Repository in a folder

Note: In the steps below we will use Git GUI client. However, there are multiple other clients (see this link); their UI and options might be different.

2.1.1 Creating the Central Repository and Branch
  1. To create the new repository, create a new folder on the machine where the Management Console is running.
  2. To initialize it as a bare central repository you can follow one of the options below:
    1. use Git bash to navigate to the folder and then run
          git init --bare
    2. start Synchronizer.exe (see section 2.1.3 below for instructions to start this executable)
  3. Create a clone of the repository using Git GUI or Git Bash (this will be the git admin's repository).
    clipboard_e0b58d147296cf10ed3b680a0af312bb4.png
  4. Open this repository in Git GUI and create a new branch ("test")

    clipboard_ef9f5ad9b408ba084062662e6cc401a3d.png
  5. Push changes to the central repository
2.1.2. Configuration on the Management Console
  1. In Management Console > Admin > Projects, open the Project Settings of the project that will be synchronized to the "test" branch and go to the "Repository" tab.
  2. Enable configuration and enter the central repository path and branch name:
    clipboard_ee47adfed05017d10865ce72b3f569b5d.png
     
  3. Save the settings.
2.1.3. Configuring Synchronizer

Note: All Synchronizer command like options are in the Admin Guide > Configure Robot Lifecycle Management

  1. Create SSH keys by running the Synchronizer.exe with the -g option
    e.g.  Synchronizer.exe -g F:\Git\Keys
     
  2. Save Synchronizer settings with the -s parameter. This saves the settings (mcUrl, credentials, keys in a file so on the next runs none of the parameters are needed in the command)
    e.g. 
    Synchronizer.exe -c --mc-url http://localhost:8080/ManagementConsole --username admin --password pass --interval 1 --no-host-key false --private-key F:\Git\Keys\id_rsa -s

    Note: --no-host-key and the --private-key parameters don't affect this case (central repository in a folder). But at least --private-key is a required parameter.
  3. Start Synchronizer
    Since the settings were saved at the previous step, the only command needed is

    Synchronizer.exe
2.1.4. Check synchronization
  1. From Design Studio upload (at least) one robot/type/snippet, create a schedule in the project
    clipboard_eb7f64013b75386d17b4aaae650ebf1f7.png
     
  2. You can't see the files in the central repository (since it's a bare repository). But the git admin can pull the changes to their local standard repository and see the files:

    clipboard_eb72d8e75e55f8cb48b3ae7fb09ba072d.png
    They can also see the files in Git GUI (browse branch files)
    clipboard_e2bac944de722364e2967d573b63ac3e7.png
  3. To check for errors, verify the Synchronizer's logs. By default they are in Application Data folder of the user running Synchronizer under /[Kapow | Kofax RPA]/<version>/Data/Logs (all files enf with "Synchronizer.log"). For help troubleshooting Synchronizer errors, contact Technical Support.
2.1.5 Basic git actions and their effect on the MC project

Checking more information about objects synchronized

Use the admin's git repository and the git client (Git GUI) for this. Online guides for git have more information about the options that can be used.

E.g. to check information about a robot, view the file itself in Git GUI (browse branch files)

clipboard_ed06d828530a42486d2f88a1fa2f10388.png

or a schedule:

clipboard_e79c6d119be5be987738b2f3b1de6d923.png

Schedules are saved as XML so their content has more information about the schedule itself (what robots they run, when they run etc)

This is why it's very important to know who can access these files in the repository because if they are modified (e.g. change the times they run, the robots they execute) these changes will be synchronized back to MC if they are pushed to the central repository.

Recovering a deleted object

If an object is deleted from the Management Console, this change will be synchronized to the central repository (the interval depends on how often the Synchronizer checks for changes - the -interval parameter in the Synchronizer command line).

A git admin can revert this operation:

  1. Open the local admin repository in Git GUI
  2. Pull changes from the central repository. As this is done, we can see the delete operation

    clipboard_e7bcd3c15e84846b4d4346c949d460480.png
  3. view the history of the branch

    clipboard_ee1bddcea1c0bb24bc87188ac76ecca59.png
     
  4. Revert the commit

    clipboard_e6262fa76bdf0f55ff608deec2afc8bd1.png
  5. Push changes back to central repository

    clipboard_e953ae4599beb51db1235d4eba30057bd.png
  6. next time Synchronizer runs it will pull the new robot from the central repository so we'll see it back on the Management Console:

    clipboard_eb76017bfe3bcbcfcb94fadbd19d268cf.png
    Note the "Modified By" user (this is the user from the Git GUI options, it's not a Management Console user) and the "Commit message"

 

2.2. Configuration - Central Repository on an online service (e.g. github)

Note: All screenshots below are using github, as example.

2.2.1 Creating a repository and branch

Follow the instructions of the online service to create a new repository and branch

clipboard_e72a4aae95af7757df3098844873f2f94.png

2.2.2. Configuration on the Management Console

To synchronize to a remote repository on an online service, Synchronizer needs the SSH url of the repository

clipboard_e6e999d38f4116da3ddf490cdcae4d6b4.png

This should be entered in the Management Console > Admin > Projects on the Repository tab of the Project that will be synchronized:

clipboard_e12a46fce9d6e3586d4c3d6eba3adda7a.png

Note: HTTP url can be used as well, but this works with anonymous repositories. For repositories that require authentication, use SSH.

2.2.3. Configuring Synchronizer

Note: All Synchronizer command like options are in the Admin Guide > Configure Robot Lifecycle Management

  1. Create SSH keys by running the Synchronizer.exe with the -g option
    e.g.  Synchronizer.exe -g F:\Git\Keys

    Note: Always use this method to create keys that will be used by Synchronizer, do not use a different tool.
  2. Add the public key into your git account (on the online service page) under SSH Keys.
  3. Save Synchronizer settings with the -s parameter. This saves the settings (mcUrl, credentials, keys in a file so on the next runs none of the parameters are needed in the command)
    e.g. 
    Synchronizer.exe -c --mc-url http://localhost:8080/ManagementConsole --username admin --password pass --interval 1 --no-host-key false --private-key F:\Git\Keys\id_rsa -s
     
  4. Start Synchronizer
    Since the settings were saved at the previous step, the only command needed is

    Synchronizer.exe
2.2.4. Check synchronization
  1. From Design Studio upload (at least) one robot/type/snippet, create a schedule in the project
    clipboard_e2d416f5c4d93d723078bd55279d177ee.png
     
  2. You should see the objects synchronized to the online repository

    clipboard_e2730e1643eb2089964f6e5b5533219b4.png
     
  3. To check for errors, verify the Synchronizer's logs. By default they are in Application Data folder of the user running Synchronizer under /[Kapow | Kofax RPA]/<version>/Data/Logs (all files enf with "Synchronizer.log"). For help troubleshooting Synchronizer errors, contact Technical Support.
2.2.5 Basic git actions and their effect on the MC project

The web interface in github offers a few options (viewing information about objects). The desktop utilities can also be used.

E.g. recovering a deleted robot:

  1. the robot is deleted on the Management Console. This is reflected on github (as soon as Synchronizer starts)

    clipboard_edb8209b0f3de76a031d04d67417cea3d.png
     
  2. In github Desktop, revert the commit:

    clipboard_e334b4f6d27d38fb9fdbdf87afa1a2e40.png
     
  3. Push changes. The file will be restored

    clipboard_e17a93293a345850325edb34bc57cceab.png
     
  4. And synchronized back to the Management Console

    clipboard_ed1345d4c0bff5f4f2d070f282e18ecac.png

 

Applies to:  

Product Version Category
RPA 10.4 and later Robot Lifecycle Management

 

Author:  Delia Milchis