We're thrilled to announce the release of Inmanta Service Orchestrator 8, a major upgrade packed with powerful new features and significant architectural enhancements designed to streamline and scale your service orchestration like never before. This release focuses on improved user experience, enhanced performance, and greater flexibility in managing service lifecycles.
Key Features at a Glance:
- Revamped Web Console
- Next-gen Deployment Subsystem
- Multi-version Service Catalog
- General Updates
Revamped Web Console
The Inmanta's UI has been completely refreshed with a modern design that is based on PatternFly 6, providing a cleaner and more intuitive experience.
Starting with the service inventory, we've introduced a new method for inspecting service instance details. You can now generate instance documentation directly from the model displayed in the Web Console (more details on this feature will be shared in a later post). For those working directly with service instance attributes, we've made improvements to the attribute view. It now offers both table and JSON formats, and crucially, allows you to compare attributes across different sets and versions. This simplifies the process of understanding changes and identifying potential issues. A corresponding history view provides a clear audit trail, for easier troubleshooting purposes. The improved expert mode provides a JSON editor for bulk attribute editing, further streamlining complex changes. Diagnostics have also been enhanced, to support control over lookback depth during root cause analysis, making it easier to pinpoint the source of problems.
The Smart Service Composer has received many improvements as well. These include side panels for selecting new entities and editing properties, an integrated inventory browser for creating relations to other services, simplified canvas blocks that display only key attributes, and a persistent canvas layout.
Next-gen deployment subsystem
The Inmanta Service Orchestrator's deployment subsystem has been completely rewritten from scratch to implement a new architecture. This redesign unlocks significant scalability improvements and opens up future possibilities. While the goal for version 8.0 was feature parity and the same performance as version 7.4, the team surpassed this, achieving at least a tenfold increase in resource capacity and doubling the deployment throughput.
The new architecture splits the server/agent processes from previous version in:
- API server that hosts all the northbound APIs and the orchestration layer that decomposes the service intent into per resource intent.
- A scheduler process per environment that coordinates the enforcement of intent, compliance checking and repair, dry-run, ... on all resources. By centralizing the coordination, we can implement complex policies and respond much faster to events during deployment.
- One or more executor processes. These short-lived processes are created on-demand. This allows us to load multiple versions of active adapters and reduce resource usage. The on-demand creation also removes the need for code reload and all the associated issues. Additionally, it makes it trivial to use more than a single CPU core during deployment. However, the deployment process is rarely CPU bound.
Multi-version service catalog
The service catalog allows you now to register multiple API versions for the same service type. This feature makes it much easier to evolve your service definitions over time. By default, every service type remains unversioned. When required, multiple definitions can be registered with different version identifiers, including different service lifecycles. Service instances can be upgraded when required, in batches or all at the same time. The documentation shows an extensive example on how to use this feature. We also provided API endpoints to perform migration of instances.
binding = lsm::ServiceBinding(
service_entity_name="service_simple",
default_version=0,
versions=[
lsm::ServiceBindingVersion(
service_entity="__config__::InterfaceIPAssignment",
lifecycle=lsm::fsm::service,
version=0,
),
lsm::ServiceBindingVersion(
service_entity="__config__::InterfaceIPAssignment",
lifecycle=lsm::fsm::simple,
version=1,
),
lsm::ServiceBindingVersion(
service_entity="__config__::InterfaceIPAssignmentV2",
lifecycle=lsm::fsm::simple,
version=2,
)
]
)
for instance in lsm::all(binding, min_version=1, max_version=2):
InterfaceIPAssignmentV2(
instance_id=instance["id"],
entity_binding=lsm::get_service_binding_version(binding, instance["service_entity_version"]),
…
description=instance["service_entity_version"] == 1 ? "old version" : instance["attributes"]["description"])
end
for instance in lsm::all(binding, max_version=0):
InterfaceIPAssignment(
instance_id=instance["id"],
entity_binding=lsm::get_service_binding_version(binding, instance["service_entity_version"]),
**instance["attributes"]
)
end
General updates
Yang:
In networking many devices can be reconfigured using YANG with NETCONF, RESTCONF or gNMI. We've further improved our support to reduce memory usage by optimizing how we handle YANG schemas. We've also enhanced state comparison, providing clear textual diffs to make it easy to understand the changes the orchestrator will make.
System requirements:
We now use Python 3.12 and require PostgreSQL 16. Version 8 continues to support RHEL 8 and 9 via RPM packages, as well as other Linux distributions when using our container with Docker or Podman. Containers are now generated from source based on our RPM packages. This change leverages the official Python project container, decoupling Inmanta from Python support available in RHEL, which allows for more timely updates.
Fine-grained log configuration:
This feature provides full control over log output and location (file, syslog, etc.), with the key benefit of enabling debug-level logging for specific libraries during diagnostics.
Inmanta Insights and Roadmap
We hosted our first customer event, Inmanta Insights and Roadmap, where our CTO & co-founder, Bart, had the pleasure of unveiling these new features to a select group of engineers from our customers. Thank you to everyone who joined us for the event.
A special shout-out to Nova Catering for providing the delicious refreshments that fueled our discussions.
This release marks a significant step forward for us to provide the most robust and scalable service orchestration platform on the market. We're excited about the future of Inmanta Service Orchestrator, and you can stay informed about all our upcoming plans by subscribing to our newsletter and following our LinkedIn.