Distributed environments, central control
Opereto deployment comprises a central control center (offered both as an on-prem server/cluster or SaaS) and one or more remote agents. Opereto agents are simple, lightweight Java executables that retrieve process requests from the center, execute them on the device or host they reside and send all execution logs back to the center. Agents listen to Opereto center directives via secured and authenticated HTTPS. Based on this approach, there is no need to handle firewall policies or network configurations, a simple internet connectivity (e.g. wifi) is all needed. Agents can quickly and securely connect to Opereto center anywhere, anytime.
- Install & Run Agents
- Agent Configuration & Properties
Microservices: executables running on remote agents
Utilizing a collaborative automation approach, Opereto enables Developers, QA and DevOps engineers to wrap existing or new automation components (tools, scripts, interfaces..) as shared and reusable microservices. Microservices are self-contained executable software programs written in any language and packaged with any technology that the device they run on can handle. For example, Python based micro services can run on any device supporting Python, microservices written in bash may run on Linux/Unix devices, etc. Once created and uploaded to Opereto center, microservices can be invoked and manipulated using Opereto REST API. We will elaborate more about it later in this document when discussing automation flows.
Any automation activity can be a microservice. For example:
OS service actions:
- Stop/Start a service
- Run shell command
- Find an entry in log (based on regexp)
- Replace text in a file
- Create cloud formation stack on AWS
- Create resource group on Azure
- Start a new VM in VSphere
- Stop a VM in VSphere
- Any particular SUT (software under test) action
Tagging/grouping of agents and services
Opereto supports two types of agents classifications: agents tagging and environments. Agent tagging means adding one or more user defined properties to any given agent. An environment is grouping one or more agents under a given logical name, providing each agent a unique member role and attributes. Following are few examples of test environment and service agent mappings:
The real power lies in the ability to map also micro services to specific tags of agents or specific environment types. This way, it is possible to guarantee that a particular microservice will only run on specific valid agents. A good example is separating test flows and test activities. Test flows must operate outside of the test environment so that it will keep running even if the software/device under test fails or crashes. Test actions, however, must run on the appropriate agent within the test environment. We can map the test flow to run on dedicated execution servers while mapping test operations to run on the relevant test agent.
Services-agents mapping and test environments are essential for scaling too. Using agent tags, you may create a cluster of workers for tools, test flows, and other operational services. Using environments, you can write, for instance, a multi-tier logical test flow that is compatible with a given logical test topology and then runs it on various configurations of physical environments in parallel (read about Cycles for more details).
Workflows as code
Opereto lets workflows be written in code as services allowing the strength of programming to be used for orchestrating processes: conditions flows, loops, exception handling and any other mechanism that modern programming languages offer. The orchestration is made by communicating with the Opereto cluster via REST which makes it very flexible and accessible from any programming language. The developer can start and terminate processes on one of the distributed agents, parse execution outputs and run complex search patterns from a single short script written in his favorite programming language.
Learn more about automation flows:
Finally, Opereto let you organize everything in cycles. A cycle is a complete specification of a repetitive automation set of test flows running on one or more test environments in parallel. Opereto's cycle state machine reads that specification and acts like a conductor orchestrating and synchronizing all automation tasks. It sets up and configures test environments, manage shared pool of automation tools, runs 1000x of system tests in parallel, collects and indexes all logs, produces coverage reports & cause analysis of failures, sends notifications and tears down environments at the end.