Frequently Asked QuestionsAnswers to the most frequently asked questions (FAQ's) about Intent Based Ops and the Skopos application automation system.
About Intent Based Operations
What is Intent Based Ops?
Intent Based Operations is an advanced form of automation that allows engineers to specify what they want to run along with performance parameters rather than writing procedures for how to start the app, create connections, etc. The system then compiles the input into an intent map defining what the status of all relevant systems/components should be and continuously checks status and takes steps to realign with the intent.
What do you mean by Intent?
Intent is an expression of the outcome the engineer wants to achieve.
How is Intent Based Ops different from other automation?
Traditional automation systems are procedural, meaning that they specify processes. For instance “If X happens take these four steps, etc.” The engineer implementing the system then has to write numerous scripts to be called by the system for each step. Procedural automation has three significant shortcomings. First the automation system can’t do anything the engineer doesn’t already know how to do. Second, in complex systems one script can easily interfere with others causing unexpected outcomes that are difficult to debug. Third, and most important, the engineer is taken away from productive work to write and debug scripts.
What is an intent map?
The intent map is the compilation of the users input on what to run, the parameters for the software, and attributes of performance, etc with the environment definitions. Current status is continuously compared against the intent map to find deviations and the system then plans and executes reconciliation.
What is Skopos?
How does Skopos fit into Intent Based Ops?
Skopos is the first implementation of Opsani’s vision for Intent Based Operations, providing continuous deployment using a declarative application model.
Where does Skopos fit in the DevOps toolchain?
Skopos fills the gap between your continuous integration (CI) system and your production environment. Skopos compiles and executes a plan to deploy containerized applications to Docker CE, Docker EE, Kubernetes and Amazon ECS environments.
What does Skopos do?
- Continuously deploys your application or service using tags in your repository to automatically roll out the right version to the right platform every time.
- Eliminates manual procedures and deployment scripts.
- Enables quality checks in your deployment and automatic rollback.
- Creates deployment plans dynamically for each deployment based on a comparison of current state and desired state.
- Automatically handles roll-out to multiple environments consistently.
- Provides visibility of the deploy progress, shareability of the current state application and clear troubleshooting information should something go wrong.
- Installs and implements in less than 1 hour.
- Runs behind the scenes. Skopos is CLI and API enabled. It does not require training and/or adoption by developers.
What is a Continuous Deployment system?
An automated system that takes completed code from development and puts it into production environments in a predictable, reliable and repeatable way.
What is Continuous Deployment?
Continuous Deployment is the process by which qualified changes in software code or architecture are deployed to production as soon as they are ready and without human intervention.
How are Continuous Delivery and Continuous Deployment different?
In essence, continuous delivery ends with the “release” of the verified artifacts – packages, VM or container images – published onto a download server. Continuous deployment ensures that qualified releases are automatically deployed to production – taken from the download servers and made the currently running version in one or more environments/locations, typically also using rolling upgrades in order to ensure that applications remain available to users during the process.
Skopos Getting Started
How do I get Skopos?
Skopos itself is a small service delivered as a docker image allowing you to install the system in just a few minutes. You can find it here.
Is there a hello-world app I can try with Skopos?
Yes. Here is a step-by-step tutorial for installing Skopos and deploying a spiffed-up version of the Docker pet-voting application. Start by running the command on this page: https://opsani.com/getstarted/
Once Skopos is installed, open the UI (at http://localhost:8090) and select “Use Our Demo App”.
Can I use Skopos to deploy the same application to different environments?
Yes. Since Skopos uses a declarative model (vs. prescriptive pipeline), you can then use the same definition to deploy to various environments. Skopos enables faithful reproduction of the application on a variety of environments from dev to test to production, in the cloud, on premise and to various infrastructures (Docker/Swarm/ECS/K8S).
What is a “Model”?
The Skopos Model is a YAML file that defines application services (components) and their relationships. Unlike deployment pipelines (e.g., Jenkins), Skopos models do not describe a sequence in which components need to be deployed. Instead, they define what applications should look like when they are deployed and operational. In addition, the model defines dependencies between components; these dependencies are used to generate a deployment plan that can bring the application from whatever current state it is in into the desired target state.
Further, Skopos models can define lifecycle-related attributes of components, including additional actions or verification steps (like quality gates) that need to be executed when deploying instances of the component (e.g., adding/removing the component from a service discovery service, checking the instance’s correctness of operation, uploading files, etc.)
Is Skopos a platform? Isn't there a lock-in with Skopos?
No. There is no code or API you need to integrate in your application or provisioning scripts that grow with each change. You do define a model – a brief YAML file that describes the different services that make up your application and how they interact with each other. Skopos then uses this YAML descriptor and any existing state of your app to deploy it and keep it running and up-to-date.
If you decide to not use Skopos any more, this descriptor is still useful – but you can replace its interpretation of Skopos with deployment scripts specific to your application; i.e., you only have to do the work Skopos saved you from doing but you don’t lose anything you have already done.
Can I integrate Skopos with my back-end service X?
Absolutely. Skopos interacts with your runtime environment exclusively through plugins. Plugins are small modules – usually written in Python but can be written in any language – that implement one or more operations that Skopos can call. They range from simple ones, like sending a message to a Slack channel, making a REST API call or checking a performance metric in your monitoring system; they can be a bit more complex, like creating an instance of a service or adding it to a load balancer.
Skopos comes with 9 built-in plugins; all of them are open source and can easily be used as a reference for writing your own. We will also be happy to assist you to create new plugins.
Plugins are executables that can be added to your Skopos instance; for most environments supported by Skopos, they can also be provided and run as containers.