A Scalable Solution to DevOps Integrations
- Manual changes lead to inconsistency and introduce risk
- Manual changes can lead to outages
- Manual changes involve multiple steps with forced workflows
- Learning curve for DevOps tools and integrations is steep
- Turn repetitive actions into simple commands
- Workflows allow for multi-stage changes
- Workflows allow for quick rollbacks
- Responsibility for deployments can be decentralized among teams
The cloud introduced more of everything. More resources. More reach. More capability.
But all of that came with more configurations, more complexity, and more time spent maintaining more infrastructure. Not to mention, your enterprise doesn’t end at infrastructure -- your engineers must interact with a variety of different tools across the dev ops lifecycle, and Gyro can serve as a framework to integrate other tools and tasks.
Holistically, the DevOps lifecycle can be defined as four phases, each with its own challenges and applications. These are 1) creating and updating resources, 2) configuring resources, 3) deploying application code, and 4) maintenance.
Creating and Updating Resources
Creating and updating is either done manually using a cloud provider's web console, or a tool such as Gyro.
During this phase, DevOps engineers are creating and updating the core resources used by their infrastructure such as virtual machines, load balancers, or CDNs.
The Challenge: The challenges when creating and updating resources using traditional approaches are many. The process is time consuming, and risks introducing mistakes. Plus, changes and updates made through a cloud provider’s web console are hard to validate, hard to roll back, and hard to audit.
The Gyro Solution: At its very core, Gyro’s feature set solves the challenges of creation and updating resources. Using Gyro, your config files are written in human-readable terms -- which promotes consistency, which helps to reduce errors. Furthermore, Gyro uses simple commands that then allow configuration files to be reviewed prior to execution. That verification helps avoid errors, and Gyro’s text-file approach to configuration files allows you to apply version control using GitHub,Mercurial, or others, which helps during auditing and rollback scenarios.
Configuration of virtual machines typically uses a configuration management tool such as Ansible, Chef, or Puppet.
During this phase, DevOps engineers are installing and configuring software such as web-servers, databases, or container orchestration software.
The Challenge: The challenge at this phase is learning how to invoke another tool for a specific host to update its configuration.
The Gyro Solution: Gyro solves these problems with a simple, logical, and scalable solution -- Gyro wraps those complex underlying systems with simple commands that step users through each phase. In essence, you can extend your cloud management capabilities by using Gyro as a framework to integrate other tools.
What’s more, the Gyro command-based approach is extensible -- you can use Gyro to scale your efforts by writing extensions to integrate other cloud management tools and further simplify your daily workload.
Deploying Application Code
Deployment of application software has the most variation of tooling due to the unique nature of each application that is built. There are many options available here, including CI/CD tools (i.e. Jenkins/TravisCI/CircleCI), Elastic Beanstalk on AWS, Nomad, or custom scripts.
The Challenge: The major challenge of the deployment phase of the DevOps lifecycle is integrating and learning another tool (or a number of tools) for blue / green deployments.
The Gyro Solution: Gyro is built to handle blue/green deployments in a logical way. When using Gyro workflows, you get built-in rollback capability, built-in preview of the changes that will be made, and a verification step is simple to implement. The driving goal behind Gyro’s approach to blue/green deployments is to make them so easy, and so safe, that anyone in your organization can do it.
Finally, after the infrastructure is created, configured, and the application is deployed, there is the maintenance phase. This can include patching machines, logging into machines to debug, updating SSL certificates, or replacing faulty virtual machines.
This phase of the DevOps lifecycle is typically dominated by manual processes and custom scripts. When in maintenance, the stakes are even higher -- because now your team is working on an existing set of resources, ones that are likely taking traffic from front-end site visitors, introducing risk of a service outage.
The Challenge: Again, when updating configurations -- traditional approaches are time consuming, introduce risk, and are difficult to validate, audit, and roll back. What’s more, logging into machines in the cloud is more difficult than on-premise had been in the past, because the resources are coming and going -- meaning that their hostname and IP are changing, and as a result making it difficult for you to find the host you want.
The Gyro Solution: Some infrastructure updates may require multiple steps to complete -- plus integration with other tools -- all without outages.
Take a common use case for example -- imagine you have a configuration using three resources, one of which is in need of maintenance. Traditional approaches force you to create a new resource, delete the old resource, and reroute the traffic to the new resource -- but this leads to timeout errors on the front end of your site. Gyro can use workflows to codify these changes. This is huge. In this example, using Gyro, you could create the new resource, reroute traffic to the new resource, and then delete the old resource. Much more logical.
Leveraging the Gyro SSH plugin, Gyro allows you find and log into hosts by declaring what type of host you want to log into. Then, Gyro will present all available options for a given Gyro project. No more guessing games, just a logical solution.