Earlier this month we released Skopos 0.14 adding some key features requested by our community. From autopilot for models and environments to GitHub integration and Amazon ECS support, Skopos 0.14 drives transparency for infrastructure-as-code while adding confidence to your container deployment pipeline.
Here’s a quick review of the features and the benefits they bring to those using Skopos for continuous deployment.
Editing Model and Environment Descriptors in the Skopos Web UI: We’ve been talking about building out the web UI for Skopos to include some more control over both the underlying models and the picture of the architecture itself. In this first step, we now allow the user to edit the model and environment YAML files right in the Skopos UI. Though this is only an in-place change (changes aren’t saved automatically into the original files) it can be used when testing out quick, temporary changes to your system. This enhancement not only streamlines the workflow within Skopos but is useful for troubleshooting new configurations, e.g., add an instance, remove an instance or change scale or a port for debugging.
Github Integration: Model and Environment files can now be obtained by reference directly from Github. This coupled to the Auto-pilot for Architecture Changes feature below, completes the autopilot feature of Skopos. Skopos model and environment files are now directly integrated into your existing workflow or CI/CD toolchain so when you place a new model into your GitHub repo, Skopos will automatically pick it up. This integration also works with HTTP/HTTPS (such as Amazon S3) and local files (file://) in the case you’re not using GitHub to house your artifacts.
Auto-pilot for Architecture Changes: Auto-pilot now monitors both model and environment files and will deploy them if there is a change. Originally autopilot only detected changes to code (i.e. an updated container) and now we’ve included changes to architecture such as scaling the application or changing the location of where it should be deployed (update of the environment file). Combined with the Github integration, this feature enables direct Architecture-as-Code workflow.
AWS EC2 Container Service (ECS) Support: Skopos can automatically deploy your application to Docker (local or hosted), a Docker Swarm cluster, and now to Amazon ECS, allowing more choices for platforms as well as the ability to easily switch between platforms. Skopos provides “faithful reproduction” of your application architecture meaning your deployment artifacts don’t change based on environment. This makes it simple for your dev team to work on the same application locally and then easily deploy to dev, staging or production on Amazon ECS. Skopos automatically creates the ECS task definition and service objects for each service on the fly making your deployment both fast and accurate. This provides you an easy way to try your application on Amazon ECS as well without having to rebuild your deployment artifacts.
Support for Accessing Insecure Registries with Docker and Docker-Swarm Plugins: A small but necessary feature, Skopos now supports the use of Docker registries without requiring the complicated SSL setup for use with developers working with local Docker registries or in air-gapped environments (IoT, Gov’t/Military).
Visibility into Future Environment Prior to Deployment: Imagine a case where you have a specific application model and a few different environments to which you want to consider deploying that application. When you load the application in Skopos, you can specify the model and a list of various environment files you want to consider. When we load the application, we can merge the model and specific environment, substituting all the variables and sharing with you the final environment that will be deployed. This provides clear visibility into what your future deployment will look like allowing for testing and troubleshooting prior to deploy to production.
Post Deployment Application Configuration in Swarm: The swarm-exec plugin allows you to define arbitrary commands to be run inside a service container after deployment to Docker Swarm. For example, when you deploy a container you sometimes need to run a few commands within that container to get the application running (e.g., post-startup login and configuration of a web server). With this plugin you can execute such commands as part of the post-deployment steps for a service so that there is no manual work to be done to have your application up and running after deployment. Skopos will automatically add these steps to the deployment plan every time so you don’t have to remember to add them. You can download this plugin here: https://github.com/datagridsys/skopos-plugin-swarm-exec
Automatic Deployment/Teardown on Branch Create/Destroy (Jenkins/CI Integration): When working with Jenkins or other CI tools, it’s a best practice to create a new deployment workflow for each branch so that each branch can be deployed for each developer. When moving to continuous deployment, this scenario becomes a nightmare for ops teams. Branches need to be deployed automatically giving each developer a ready-made sandbox and someone has to remember to take down the app when the branch is destroyed. Many times ops tries to script this out, but instead ends up becoming a bottleneck in the development process. With Jenkins (or another CI tool) and Skopos, this workflow can be automated; allowing the deployed app to appear and disappear when triggered by a developer creating/deleting a branch. Now, as soon as they create a branch, they already have a sandbox with the application running and we don’t fall into the “leaky apps” scenario since as soon as they delete a branch, Skopos removes the application as well. A Docker Compose –make or Compose -up will run the build and deploy automatically but it’s then up to you to remember to take the application down when you’re done.