Develop faster—with stability & control
Keep adding microservices while keeping control of them with webMethods.
Microservices take advantage of the agility and scalability of the cloud. Only more changes to your applications mean more microservices. When an application stops working, how will you know which microservice is at fault? With webMethods, you’ll know the who, where and what of every microservice you use. And you’ll stay in control—apply one policy to control hundreds of microservices.
Scaling As Required
Manage microservices and cloud native applications with precision and increase cloud usage in real time with increased demand. Scale microservices with industry-standard tools like Docker®, Kubernetes® and Red Hat® OpenShift.
Making Fast Updates
Adapt in real time. Quickly create and publish microservices to scalable cloud and hybrid environments. Add new services and capabilities to your application without changing a line of code.
Give your applications another layer of security—with advanced access control and private data protection.
Cloud Native Applications, Simplified
Microservices make applications easier to change and scale. But it’s easy to lose track of which microservices do what. Avoid the mega-complication with visibility and control at the application level. webMethods gives you deep visibility and metrics into what’s happening with your microservices-based applications.
- Connect anything using an open, standards-based integration platform that can run anywhere
- Deliver innovative products faster using modular integration building blocks
- Plug into industry-standard service meshes out of the box
- Build in the language of your choice
- Change your services quickly and easily using policies
- Pre-built APIs and services, an event bus and in-memory data make implementation faster and more flexible
- Manage microservices as applications
- Know which microservices are used in your app—how they’re running, who’s using them and exactly what they are doing
- Launch advanced user ID and security policies using web-friendly authentication and to protect sensitive user PII data
- Self-healing services control cascading failures
- Add a new capability to an application without having to redeliver it
- webMethods is rich with built-in services, integrations and DevOps tools to build apps faster and better
- Share services through a service mesh architecture regardless of the underlying technology
- Control API access to microservices with a fast-to-deploy, small-footprint microgateway
Deliver integrations as microservices that are fault-tolerant, are highly scalable and interact securely using lightweight messaging or APIs. Ensure reliability with built-in fault tolerance and recovery. Manage infrastructure with a health check based on Prometheus™ and recovery capability.
React quickly to market and consumer needs while being in control of microservices. Change your services quickly and easily using policies, not code. Policies are like rules. You decide which microservices need to follow them.
With webMethods, you can expose microservices as public or private APIs and secure them. Bring your microservices into a unified control plane and manage them like you do your APIs. In fact, you can manage them alongside your APIs from the same UI.
Freedom of Choice
Choose your language, deployment pattern and cloud provider. webMethods is pre-integrated with the best industry tools like Docker, Kubernetes and OpenShift and supports several programming languages for service development: Java, C, C++ and native FLOW. Run webMethods runs on a variety of operating systems.
A test-driven development methodology helps you achieve reliability and quality in a continuous integration/continuous delivery environment. Design test cases before starting development, and automate those tests to run in the DevOps lifecycle.
Avoid interruptions with webMethods. Simply plug in service registry support so that applications look up endpoint information at runtime. That way, users always get a response.
Control cascading failures with webMethods support for a “circuit breaker” architectural pattern. Set up custom health checks with out-of-the-box indicators like disk space, JDBC® pools, memory, Java® Message Service (JMS) connections and adapter connections.
Deploy webMethods Microservices Runtime with Docker and Kubernetes for packing, distributing and managing your applications automatically. Out-of-the-box Docker scripts simplify deployment, and built-in readiness and liveness checks enable Kubernetes to manage your containers.
On-the-fly Docker deployment
Dynamically inject the right configuration at runtime using Docker variables without rebuilding the container. Select versions of services or packages that constitute the microservice at deployment. Rather than prebuilding static Docker images, deploy what you need, when you need it, by isolating the elements of your microservices runtime and building it on the fly.
webMethods supports different levels of granularity and service patterns by enabling you to easily add modules for event routing, RDBMS support, flat file handling and more—up to and including all functionality in webMethods Integration Server.
Connectivity to data and apps
A full range of connectors support modern standards, such as OData, REST and the full complement of SOAP-based web service support. Save time with pre-built adapters—simply drag, drop and interface with dozens of commercial applications, both inside and outside the firewall.
webMethods comes preconfigured for high-performance, low-latency messaging within the enterprise and for web and mobile connections. For distributed microservice architectures, reliable, secure and scalable messaging supports asynchronous communication.