Are Agentless Continuous Deployments necessary for Modern Software Architecture?
Agentless continuous deployment is the correct choice for the lean data center pursuing agile DevOps across physical, cloud and Kubernetes platforms. While we have survived for years on agent based technology, it just does not fit into the new modern architecture of containers and microservices. An agentless approach is a new necessity. Most companies own some sort of agent based release solution for moving files from one place to another. After all, Application Release Automation has been around for some time, before containers and Kubernetes rose in popularity. Most of these tools are based on an agent living on the ‘target’ endpoint that executes the logic of the deployment process. While this works for physical machines, and can be transferred to a cloud architecture, it does not support your new containerized applications running in multiple Kubernetes clusters. This is why DeployHub’s transport engine is agentless. DeployHub’s deployment engine spans all platforms allowing you to deploy anywhere at anytime.
Let’s take a dive into what a continuous deployment engine actually does to support safe and fast software releases, regardless of platform.
The most common steps required by a software release scenario are:
- 1. Define the Application and install logic.
- 2. Send artifacts to endpoints.
- 3. Manage and manipulate artifacts on an endpoint.
- 4. Execute remote ‘jobs’ on an endpoint.
- 5. Capture the results and output of a remote script or system command.
- 6. Start/Stop Services on an endpoint.
Also, it’s worth mentioning that 4. can be categorized further as:
- a. Execute a remote script that already resides on an endpoint.
- b. Send a process to the remote endpoint and execute.
- c. Execute a system command on the remote endpoint.
This is standard stuff because mechanisms used to deploy software to endpoints are finite. But what are the merits of agent-based vs. agentless systems? Misunderstanding this can make or break your continuous deployment initiative.
Disadvantages of an Agent-based Release Automation Solution
Although agents can be a reliable way of building connectivity between the deployment server and its endpoints, any agentless system can be deemed equally robust if it is based on SSH/SSL secured connections. In short, the overhead associated with an agent-based solution overwhelmingly eclipses that of an agentless release automation solution.
- Installing Agents to Thousands of Endpoints – Agent-based systems require an agent installed on every endpoint to receive code and system updates. Perhaps not a significant issue in small companies running physical machines or cloud images, but this can be a showstopper for a Kubernetes architecture with microservices and containers. And a ‘side car’ is not the answer. It just creates more stuff to manage.
- Configuration of Agents -Every agent in an agent-based solution requires configuration settings be amended to ensure each endpoint can connect to the solution server. And, each agent may also require that configuration settings be altered based on the role of the agent. Translation: management headache and continuous deployment showstopper.
- Agent Maintenance – Software vendors continually update and improve their solutions. Hence, this means an agent-based solution may require regular software updates. Larger organizations may need to allocate resources for these upgrades, possibly forming dedicated project teams to complete the effort. Therefore, your team spends less time working on your stuff, and more time supporting your vendor’s stuff. Agentless release automation reduces maintenance overhead.
- Firewall and Relay Configuration -Agent-based systems require firewall configuration changes to allow communications between agents and solution server. In addition, relaying instructions and data between numerous domains within large corporate networks is another resource drain.
- Agent Availability -Installing an agent typically requires installing agent software as a service running on the remote server. Hence, as with any service, the service may ‘fail’, require configuration changes, need recycling, fail to be compatible with other services, or worse, require re-installation. In a nutshell, Agents are not very ‘Agile DevOps.’ In fact, they fit better into a waterfall environment.
- Containers & Microservices – Containers and agents are like oil and water. Minimizing what goes on the container reduces the complexity around implementing containers. Your traditional deployment approach was not designed for an elastic or containerized data center. In essence, you need an agentless deployment solution to install your agent-based release automation solution. Extra work and cost.
- Cost – Agent based systems are priced on the number of endpoints you use. If you add a server, you add an agent, you add cost. If you are moving to microservices and containers, you are faced with even more cost. Each container requires an agent.
- Platform Support – Agents are a piece of software built for a specific platform. Therefore, if you want to deploy to Windows, you will need a Windows agent. UNIX will require its own specific agent, as will Linux, and so on. This can mean added risk because many vendors only build agents for broad platforms like Windows, UNIX and Linux. An agentless continuous deployment solution has no platform restrictions. And larger organizations use various platforms designed to address specific needs. For example, financial services firms use fault tolerant and high transaction processing platforms like iSeries, Stratus, OpenVMS and Tandem. In addition, retail organizations are likely to use the IBM4690 platform. It is highly probable that these platforms are not supported by agent-based systems, which prevents organizations from achieving release automation.
Advantages of DeployHub’s Agentless Continuous Deployments
DeployHub is an agentless continuous deployment solution and therefore, all of the above obstacles disappear.
• Availability of Agents – Not Required
• Installation of Agents – Not Required
• Configuration of Agents – Not Applicable
• Agent Maintenance – Not Applicable
• Firewall & Relay Configuration – No difference
• Containers and Cloud – No extra work, no side car
• Cost – No agent based licensing
• Platform Support – DeployHub supports Windows, UNIX, Linux, iSeries, OpenVMS, Tandem, Stratus, IBM4690, Tru64, and more.
In conclusion, agentless solutions place dramatically less demand on the full continuous delivery pipeline. With DeployHub, a standard release automation process can be adopted across all environments so you can release new anywhere and anytime.
DeployHub’s Key Features
- Blueprint your application’s logical view
- Publish and Catalog Microservices
- Version Microservice Configurations
- Release and Track Microservices
- Manage Database Deployments
- Continuous Deployment Blogs
- Understanding a Microservice Pipeline
- Microservice Continuous Integration – Where’s the Build?
- Working with Helm for your Microservices Releases
- Kubernetes Pipeline Challenges
- Managing Embedded Configurations
- Questions and Answers on managing a K8s Pipeline
- Running Safe Blue / Green Deployments
- The DeployHub Jenkins Plug-in
- Setting Up the Jenkins Plug-in
- The DeployHub CircleCI Orb
- Creating a Continuous Feedback Loop
- Release Agents – the Enemy of Continuous Deployments
- DeployHubs Release Architecture
- Why we need Application Packages for CD
- Agentless Deployments with DeployHub’s Engine
- Version Jumps and Tracking
- Blogs on Microservice Configuration Management