Continuous Integration Overview

   Journey Platform API Developer resources for building Journey Platform solutions

Continuous IntegrationContinuous Integration (CI) is a development practice that requires developers to integrate code into a shared repository several times a day. Each check-in is then verified by an automated build, allowing teams to detect problems early. (CI) is an essential ingredient in a software development process, which helps improve software quality, provide reliable, repeatable, and well designed automated processes to save time, reduce the chance of human errors, and identify errors early. The Temenos Journey Platform provides the services and tools to facilitate in Continuous Integration of Journey applications.

Continuous Integration is the frequent building and testing of new code changes, assisted by software tools that automate the process. It is often referred to as a pipeline. A typical CI environment includes the following components:

  • Version control systems: Git, Subversion, Visual Studio Team Services
  • Build automation tools: Ant, Gradle
  • Dependency management tools: Maven
  • CI servers: Jenkins, TeamCity, Bamboo, GitLab CI
  • Task automation tools: Ant, Maven, Gradle, Gulp, Make
  • Unit testing frameworks: JUnit
  • Mocking libraries: Mockito
  • Deployment and configuration automation tools: Ansible, Chef
  • In-house APIs: the REST APIs built into Journey Manager

CI environments are implemented using software tools that work alone or together to support the creation of pipelines. Implementation is usually achieved via configuration, rather than a specific development. Sometimes, as is the case with our Transact REST APIs, you might have to provide support services to enable application specific deployment or configuration.

There is often crossover in functionality between tools, which blurs the functional boundaries. In GitLab, for example, version control, build and CI services are all available in a single-source system.

We don't prescribe the use of specific tools to apply CI techniques to the Journey platform application development process. Customers are free to configure their existing Ant-compatible CI systems with Ant tasks from the Transact Fluent SDK to provide the underlying automation.

For customers who don't have existing CI infrastructure, we recommend the following tools:

  • GitLab - for source code version control.
  • Maven - for dependency management of third-party content, and potentially for storing output from the build system.
  • Jenkins - for integration to version control systems and orchestration of builds, dependency management and CI services.

Journey Manager supports Continuous Integration practices through the following three key features:

  • Application packages that contain primary deployable artifacts, such as forms and services.
  • Transact REST APIs references that include services to facilitate the deployment of application packages.
  • Transact Fluent SDK which includes Ant tasks to leverage on the REST APIs

Journey platform implements CI model as shown below.

In this model, application developers, using Maestro, Manager, and other IDEs, collaborate in a development environment. They work with assets including forms, templates, organization properties, delivery channels, services, and service connections. They configure JSON files to define the contents of application packages. Changes in the development environment are committed to the version control system, from where they can be checked out, packaged into application packages and deployed to other environments by Ant tasks interacting with the Transact REST APIs. This is summarized below:

  1. Check assets and supporting files into and out of the version control system
  2. Trigger CI pipelines
  3. Execute Ant tasks that form part of the Transact Fluent SDK
  4. Package assets into application packages
  5. Publish the application packages to Manager services exposed via the Transact REST APIs

Continuous Integration Workflow

The Manager CI workflow involves the following steps:

  1. Download and install the Transact Fluent SDK. The Transact Fluent SDK is a part of the SDK download which you can find in the Release Notes of each Journey Manager release.
  2. Define an application package:
    • Create configuration folder structure.
    • Obtain form version archive files from Manager, if required.
    • Create JSON configuration files to describe application package contents.
  3. Configure your CI server with Ant tasks from the Transact Fluent SDK.
  4. Create your CI workflow:
    • Build the application package.
    • Deploy the application package to one or more servers.
    • Run the remote tests on deployed servers.
  5. Configure the CI server to work with source control.
  6. Check the application package configuration files and resources into source control.
  7. Check the state of the CI workflow on the CI server.

Next, learn about version control systems.