Why Use Ortelius
Why Use Ortelius
Migrating to microservices breaks the way we assemble and configure software. With a microservice implementation, we no longer manage a complete software solution, or Application Version. Instead we manage many moving parts that communicate at run-time based on APIs. The loss of the ‘Application Version’ disrupts the core of software delivery. It impacts most of our standard software practices. After all, everything is based on an Application Version from tracking changes request, determining differences, tracking relationships and supporting users.
While microservices are a big improvement over monolithic practices, we still need a method of tracking the collection of services delivered to an end-user. Ortelius facilitates the move to microservices by giving you back your Application but in a ‘logical view.’
Ortelius is a SaaS based central ‘hub’ for cataloging, versioning, sharing and deploying microservices and other Components across Kubernetes, cloud, virtual and physical Environments. An on-premise download is also available.
Ortelius is not a ‘microservice registry’ or ‘API Gateway." Instead, Developers interact with Ortelius to ‘check-in’ or publish microservices to a Domain Catalog before they are deployed to any cluster. Ortelius serves as an internal market place for finding, tracking and deploying microservices and relating them to the Applications that consume them. The publishing catalog is based on a Domain structure to support a Domain Driven Design.
Microservices are independently deployable and require a solution that can support the coordination of many independent moving parts. Our backend version control database accurately tracks and deploys many moving parts of a microservice implementation, producing Application maps and Component dependencies.
If you have not moved to a microservice architecture, Ortelius can help you visualize and continuously deploy your monolithic Application based on Components. A Component can be anything from a microservice to a .Jar file, a DB update to an environment variable update. So while you begin digesting a new modern architecture, Ortelius starts shifting the way you conceptualize your monolithic Application and prepares you for a service based architecture.
Ortelius versions both microservices (Components) and ‘logical’ Applications. When versioning Components, it tracks changes to their critical metadata needed for deployments including:
- GitHub, Jira Change Request (DeployHub Pro)
- Git repo
- Git Commit (Tag and branch)
- CI/CD Build Number
- Container SHA
- Docker Registry
- Environment Variables
- Deployment Script (Helm Chart, Ansible Playbook, etc.)
- Any Attributes (DB Name for example)
Application Versions are based on the collection of Component Versions. If a new version of a Component is pushed out to the environment, Ortelius auto increments the Component version and the consuming Application version. Dashboards are provided for each new Application version showing:
- A full map of all the microservices, or Components, the Application version is consuming (your new Bill of Material - BOM report).
- The specific changes that created the new Application version (your new diff report).
- The audit history
- Log history
- Where it is running
- Trends (Deployment time, success failure rates)
This level of information can also be viewed from the Component level showing similar information to the Application, but instead showing the Applications that are dependent on the microservice (Component).
Ortelius supports working in a hybrid environment, for both microservices and monolithic applications. In fact, you will be able to decompose a monolithic application, as you break it down into Components - which is the beginning of a microservice journey.
Our core features are critical to a successful implementation of microservices.
First and most important is the Domain structure for cataloging and sharing microservices. This feature organizes your microservice in a method to facilitate reuse and sharing across development teams.
Once you begin sharing microservices, you need to track who is using the microservice. Dependency maps show you the ‘logical’ view of your application and which microservices, or Components, it consumes. An Application is a logical collection of Components that make up an entire software solution.
A backend relational database versions your microservice. A change to any of the microservice attributes (container repository SHA, Helm Chart, etc.) initiates a new version of the microservice and a new version of the Applications that consumes it. Tracking these updates gives you uncompromised visibility of your Application and microservice usage.
Ortelius independently deploys microservices and records critical release information about the end target locations. This provides DevOps and Site Reliability Engineers the ability to make data-driven decisions when something goes wrong.
Ortelius integrates into your CD pipeline to continuously version your microservice configurations just prior to release at any state (Dev,Test, Prod). Your existing CI/CD solution can be enhanced to support independent microservice releases without a major re-tooling.
The Secret Sauce
Ortelius is the only configuration management and deployment solution with a built-in version control engine. Ortelius supports incremental releases as well as canary or blue/green deployments with fast rollbacks, roll forward, or version jumps. Our backend version control database is designed specifically for tracking independently deployed Components. Every software release configuration is based upon a collection of Components and their critical deployment attributes. A Component is a microservice, executable, database update or configuration, and is part of a complete software Application. Components change over time creating Component Versions and therefore Application Versions.
Ortelius supports continuous configuration versioning of:
- web components
- database updates
- environment variables
- application binaries
- infrastructure components
Unlike others, Ortelius’ engine for pushing Components to your Endpoints (Clusters, Cloud, etc.) uses an agentless architecture. The deployment engine supports mixed environments from monolithic systems to microservices and is particularly useful for database updates. No Endpoint agents are required.
This agentless technology works for both cloud native and legacy architectures including:
- AWS, Google Compute, Azure
- Cloud Foundry
- Kubernetes, Docker
- Windows 2008, Windows 2012
- Solaris, HP-UX, AIX, Linux
- Microsoft Azure
- Ubuntu, Redhat, SuSe, Debian
- Tandem, Stratus, IBM iSeries, OpenVMS, Unisys, IBM 4690
- Jetty, Tomcat, WebSphere
- Microsoft IIS, Microsoft SQL Server, Oracle, Sybase
- Request Routers and Appliances
Free Version with Optional Pro Upgrade
Our free version is based upon the Ortelius open source project. Ortelius can be used from the hosted site or installed on premise. It is a strategic and fully open source microservice management solution that integrates with common continuous delivery and DevOps tools. It supports unlimited endpoints, versions, deployments and users. Sign-up at Ortelius.com.
For additional security features and support, DeployHub Pro includes extended Users and Group access controls as well as more granular Domains.
Unique to DeployHub Pro are “Divisional Domains.” These Domains allow you to expand and model your environments based on your organizational top-down structure. It also gives you the ability to restrict microservice read/write access to only certain Groups of Users.
DeployHub Pro also provides integration to tools such as Bugzilla, GitHub Issues and Jira for tracking your complete value stream from change request to final endpoint. It also includes ‘smart’ calendars for scheduling deployments.
Ortelius Open Source Project
Ortelius is based on the Ortelius Open Source Project. Learn more at Ortelius.io.