Frequently Asked Questions
What is Skopos?
Skopos is a continuous deployment system for container-based services, especially for those using microservice architectures. DevOps teams can use Skopos to complete their CI/CD toolchain development-to-production cycle.
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 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.
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 forking or cloning the app at https://github.com/datagridsys/skopos-sample-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.