Navigating Through the Container Orchestration Jungle with Your webMethods Deployments

Reading time: 6m

Introduction to Container Orchestration Technologies

In the world of software development, containers have revolutionized how applications are deployed and managed, encapsulating applications’ code, configurations, and dependencies. As the number of containers grows, efficient container orchestration becomes crucial for managing these containers’ lifecycle across different environments.
Container orchestration tools like Kubernetes have become essential for automating the deployment, scaling, and operations of application containers. The landscape is rich with options, including cloud-native solutions and tools tailored for development phases.

Docker Compose: A Development-centric Tool

Docker Compose facilitates local development and testing by allowing developers to define and run multi-container Docker applications easily. It’s particularly suited for development workflows but doesn’t scale to the complexities of production environments, where tools like Kubernetes take precedence.

Kubernetes

Kubernetes, developed by Google and now under the Cloud Native Computing Foundation CNCF, automates containerized applications’ deployment, scaling, and management. Variants like OpenShift, Rancher, and cloud-managed services provide additional features or integrate deeply with cloud infrastructures, tailoring Kubernetes to different operational needs and environments.
Kubernetes aims to provide a uniform operating model across different environments, so ideally a k8s application should be mobile across its different variations and hosting types. However, the migration process requires careful planning and execution to address the differences between Kubernetes offerings.

Kubernetes Variants Explained

There are numerous K8s variants certified by CNCF, we’ll have a brief look at the most popular ones:

Rancher

Rancher is an open-source platform that simplifies Kubernetes cluster deployment and management across various environments. Its multi-cluster management capabilities and intuitive graphical interface are suited for organizations managing multiple Kubernetes clusters, offering an easy-to-use management interface for both operators and developers.

OpenShift (Red Hat)

Developed by Red Hat, OpenShift extends Kubernetes with additional security features, developer tools, and operational efficiencies, making it a powerful platform for enterprise applications. Its enhanced security and developer productivity tools, such as automated container scanning and Source-to-Image (S2I), make it ideal for large enterprises looking for a secure, robust, and developer-friendly environment.

Cloud Managed Kubernetes Services

Google Kubernetes Engine (GKE)

Google’s GKE is a managed service that simplifies the deployment, management, and scaling of Kubernetes applications, leveraging Google Cloud’s infrastructure. With features like auto-scaling and managed updates, GKE is best for businesses already using Google Cloud services, looking for a scalable and managed Kubernetes solution.

Amazon Elastic Kubernetes Service (EKS)

EKS from Amazon Web Services facilitates the deployment, management, and scaling of containerized applications on AWS, integrating tightly with AWS services for enhanced security and scalability. It’s ideal for AWS-centric organizations, offering EKS Anywhere for flexibility to run Kubernetes clusters on-premises or in the cloud, providing a consistent experience across environments.

Azure Kubernetes Service (AKS)

Microsoft Azure’s AKS provides simplified cluster management, integrated CI/CD experiences, and built-in monitoring tools. With deep integration with Azure DevOps, GitHub, and Azure services, AKS is a great choice for organizations deeply integrated into the Microsoft ecosystem, requiring seamless development and deployment workflows.
Each variant of Kubernetes brings unique features and benefits, tailored to different operational needs, environments, and organizational preferences, showcasing the adaptability of Kubernetes as a platform for modern application deployment and management.

Cloud native container orchestrators

While Kubernetes offers a flexible and powerful system, it also comes with a steep learning curve and a big operational overhead, making it less ideal for teams with limited DevOps resources or for simple applications. This opened the gap for simpler container orchestrations offered as cloud-native solutions by the hyperscalers.

Azure Container Instances (ACI)

Azure Container Instances (ACI) is a service provided by Microsoft Azure that offers a streamlined and efficient way to run containers in the cloud without the need to manage virtual machines or adopt additional container orchestration services. ACI is designed for simplicity and speed, enabling developers to deploy containers directly on Azure with just a few clicks or commands, making it an excellent option for scenarios that require quick deployments and short-lived containers. ACI is particularly suited for batch processing jobs, event-driven applications, and development/test environments where control over the underlying infrastructure is not a necessity.

Amazon ECS

Amazon Elastic Container Service (ECS) enables developers to run containers in the cloud without managing servers or clusters, streamlining deployment and scaling of applications. It integrates deeply with AWS services. ECS supports Docker and allows for automatic scaling, simplified service updates, and robust security, making it suitable for a wide range of applications, from microservices to batch processing.

AWS Fargate: Serverless Containers

AWS Fargate is a serverless compute engine for containers that allows developers to run containers without managing servers or clusters on EC2 VM instances. Fargate integrates with Amazon ECS and EKS, offering a simple, scalable, and secure way to run containerized applications, with billing based on the actual compute and memory resources your containers use. In contrast, the alternative is to assign EC2 virtual machines and prepare them with infrastructure that would allow running containers – container engines, k8s node instances, etc. Fargate is ideal for applications with variable workloads or for those seeking to streamline operational management while maintaining scalability and control. However, the convenience comes at a price, with Fargate’s cost based on the compute and storage resources consumed by the containerized applications, typically higher than managing containers on EC2 instances directly.

On-Premise Container Orchestrators vs. Hyperscale’s Services

When deploying container orchestration solutions, organizations must choose between on-premises installations and hyperscaler platforms. On-premises solutions allow complete control over the infrastructure but come with significant operational complexity and overhead. Installing and managing a Kubernetes cluster, for instance, requires deep expertise and ongoing maintenance, from network configuration to storage management and security updates.
Hyperscaler platforms like AWS, Google Cloud, and Azure abstract much of this complexity, offering managed services (EKS, GKE, AKS) that handle much of the operational burden. These platforms provide scalability, reliability, and a range of integrated services at a cost. Pricing models vary, with expenses tied to compute, storage, and network resource usage, potentially leading to higher operational costs compared to on-premises solutions where the infrastructure is already sunk cost.

Costs and Considerations

The choice between on-premises, hyperscalers, and complete serverless solutions like Fargate hinges on a balance between operational complexity, control, and cost. On-premises installations offer the most control but require significant investment in hardware and expertise. Hyperscalers reduce operational complexity and offer scalability at the expense of higher and variable operational costs. Serverless options like Fargate offer the highest simplicity and scalability but can be the most expensive choice for large-scale applications due to their usage-based pricing models.

The webMethods Container World

Transitioning to container orchestration for on-premise webMethods products presents a solid interim solution to migrating to webMethods.io IPaaS, allowing deployments on both private and public clouds while retaining most of the existing code. This approach offers significant advantages over traditional on-premise setups, including built-in high availability, the ability to scale stateless components easily, rapid disaster recovery capabilities, and zero downtime during upgrades and immediate rollbacks.
Yet, these benefits necessitate substantial modifications to development and deployment processes. Tools like the wM Deployer become obsolete in a containerized environment, where putting assets on running ephemeral containers is not working. Moreover, to maximize the advantages of containers, it’s advisable to break monolithic on-premise applications into individual integration flows deployed as separate microservices. Such a strategy minimizes the disruption caused by updates, whether they are minor fixes or major version changes, ensuring minimal impact on the system.

Use Cases

When we use webMethods products with containers, we see several common ways they are used. These examples show how using containers is different and often better than the old way of setting things up directly on computers (on-premise architecture):

• Stateless Integration : MSR functioning as a microservice, enabling efficient, scalable interactions without a persisting state between requests.
• Stateful Integration : Utilizing MSR as a microservice with database storage to manage and persist state across sessions.
• Publish/Subscribe (Pub/Sub) Integration: Leveraging Universal Messaging or alternative JMS providers for asynchronous communication between microservices, facilitating a decoupled, scalable architecture.
• Granular Security Policy Enforcement: The API Gateway as a microservice can play a crucial role in applying security policies specifically for integration microservices, ensuring secure data handling and compliance.

What webMethods products are supported on containers?

Not all webMethods products can be run in containers. However, you can find the ones that can on the company’s public container registry at https://containers.webmethods.io . When it comes to working together smoothly, these webMethods containers are designed to fit well with Kubernetes, which is managed by the CNCF. If a Kubernetes version is approved by CNCF, it will work well with webMethods products. You can see a list of these certified versions at Certified Kubernetes Software Conformance | CNCF.

Please note, that this compatibility doesn’t cover specific services from different cloud providers, like unique identity management systems, databases, or storage solutions. You’ll need to check the documentation for each webMethods product for details on these services.

OpenShift, although a certified CNCF distribution, has strict security requirements for the containers deployed on it. The webMethods products don’t fully comply with those requirements. Deployment on OpenShift would require altering the product containers.

Currently, we do not officially support AWS ECS for webMethods containers, but since ECS can run OCI-compliant containers, there shouldn’t be any technical issues using webMethods products with it.

AWS Fargate, which works seamlessly with both AWS EKS and ECS, is compatible with any OCI container. This means Fargate is a suitable environment for running webMethods containers.

Conclusion

Choosing the right container orchestration solution involves considering the application’s lifecycle from development to production. Docker Compose is invaluable for development, while Kubernetes and its variants scale to production needs. The decision between deploying on-premises or on hyperscaler platforms involves trade-offs in control, complexity, and cost, with serverless options like AWS Fargate offering an alternative for those prioritizing simplicity and scalability. Those factors have to be considered along with the container capabilities of the webMerhods products, so your teams can select the most appropriate technologies to efficiently manage their containerized webMethods applications across the entire lifecycle.

This article is part of the TECHniques newsletter blog - technical tips and tricks for the Software AG community. Subscribe to receive our quarterly updates or read the latest issue.