devopsy.kinsta.cloud

Tag: microservices

  • Hooked on Service Metrics

    Hooked on Service Metrics

    We live in an increasingly “as-a-service” world. From software as a service (SaaS) and platform as a service (PaaS) to functions as a service (FaaS) and SaaS-delivered applications, service delivery has become paramount to business goals and practices.

    In today’s DevOps landscape, microservices—the cloud-native approach to designing scalable, independently delivered services—allow teams to prioritize each individual service rather than many services simultaneously, enabling agility and continuous delivery. However, even with all their benefits, microservices come with their fair share of challenges, specifically with observability, monitoring and security. Service metrics are therefore more important now than ever before, as mitigating the challenges and seizing the opportunities introduced by microservices helps DevOps teams create a high-quality end user experience.

    With service delivery so integrated into the overall business and customer experience, it’s crucial to ensure that service performance always remains at its peak. How can tech pros ensure that service-level agreements are met, services run smoothly and end user expectations are met and exceeded? The answer is simple: become hooked on service metrics.

    Getting Hooked

    In this piece, we’ll explore service metrics in respect to microservices. Due to the observability, monitoring and security challenges that microservices can introduce, managing and controlling microservices and their traffic requires an additional layer of tooling: a service mesh. Implementing a service mesh architecture helps facilitate traffic management, service identity and security, policy enforcement and more, which ultimately brings reliability, security and manageability to container and microservice management. Important metrics such as request volume, request duration, latency and request size can be gathered automatically across a service mesh, which helps facilitate successful microservice deployment.

    However, despite service mesh tooling helping to mitigate risks, failures such as RPC timeouts and exception propagation can occur. Failures in the microservices space often occur during the interactions between services, so a clear view into those transactions enables DevOps teams to better manage architectures and avoid said failures. A service mesh provides observability, which enables DevOps teams to easily see what is happening when services interact with each other, making it easier to build a more resilient, secure and efficient microservice system. Additionally, service meshes provide a developer-driven, services-first network—a network that runs without application developers having to build network concerns into their application codes. Service meshes create a network that empowers operators with the ability to define network behavior, node identity and traffic flow through policy.

    Tips for Success: What You Need to Know

    So, how does a DevOps team implement a service mesh architecture for service metrics? Following a few best practices can help ensure success:

    • Know When to Implement: If a DevOps team does not plan to run an excess of microservices, a service mesh may not be necessary; fewer than 10 microservices likely could be managed with existing tools and security tools. But once a team starts running more than 10, a service mesh becomes essential.
    • Understand Your Use Case: After confirming the necessity of a service mesh architecture, you must understand how it will interact with the other types of infrastructure you’re running, as this will help determine what service mesh to leverage. For example, some work well with Kubernetes or Docker Swarm, but if you’re not running services inside containers, you would only benefit from the security or observability pieces of a service mesh. Depending on your use case, you might want to implement a highly capable service mesh such as Istio or a simpler tooling such as Linkerd 2.0.
    • Focus on the Network: With a service mesh architecture, you have several microservices that are communicating over a new network. As such, it’s important to understand the network’s criticality: What would you want out of a network that connects your microservices? You want your network to be as intelligent and resilient as possible; to route traffic away from failures to increase the aggregate reliability of your cluster; and to avoid unwanted overhead such as high-latency routes or servers with cold caches. You want your network to ensure that the traffic flowing between services is secure against trivial attack. And you want your network to provide insight by highlighting unexpected dependencies and root causes of service communication failure.

    Conclusion

    Becoming hooked on service metrics is key to ensuring successful delivery of services and meeting end user experiences. With the value service delivers to a business, it’s crucial to ensure that services are always running at their prime. For microservices, implementing a service mesh architecture and following corresponding best practices help ensure successful service delivery.

    — Adam Hert

  • Kong Applies AI to API Management

    Kong Applies AI to API Management

    Kong today announced today two offerings that rely on artificial intelligence (AI) to automate the management of application programming interfaces (APIs).

    The first offering, dubbed Kong Brain, collects data from any existing platform to auto generate documentation, which can then be used to automate the configuration of the Kong Enterprise API management platform.

    The second offering, dubbed Kong Immunity, leverages machine learning algorithms to analyze traffic patterns to first define normal traffic and then train models to automatically detect any anomalies and issue alerts when those anomalies are detected.

    Kong CTO Marco Palladino said Kong Brain is intended to make it easier to manage APIs across a modern IT environment by making it possible to continuously reconfigure APIs as new code is added to any platform connect to Kong Enterprise.

    In addition, Kong Brain makes it simpler to visually map services and their endpoints to provide deeper visibility into API traffic and the health of any given service, said Palladino.

    Kong Immunity, meanwhile, enhances the overall security of the IT environment by identifying potential threats before they proliferate across the API ecosystem, he notes.

    Available under an early access program, Kong Brain and Kong Immunity represent the first steps toward employing AI to layer a central nervous system that automates governance, security ad documentation while increasing the reliability of the overall API ecosystem, Palladino said.

    As microservices specifically and IT in general continue to evolve, the number of dependencies that will exist across the IT environment will far exceed the ability of any IT staff to manage manually. That issue will become especially acute as more organizations embrace applications based on microservices, Palladino said, because each microservice within that application has its own set of APIs that need to be managed. While Kong Enterprise can support both microservices and traditional monolithic applications, Palladino expects the proliferation of microservices across multiple cloud platforms to force the need to adopt API management platforms infused with AI.

    Obviously, the introduction of AI into IT environments will have a profound impact on API management and associated DevOps processes. While developers typically create APIs, responsibility for managing APIs has been shifting to IT operational teams. By adding AI to API management platforms such as Kong Enterprise it should become significantly easier for any enterprise to manage APIs at scale. Of course, AI models don’t work out of the proverbial box. But as the machine learning algorithms that drive those AI models become more familiar with the IT environment, the more automated the management of the APIs distributed across that IT environment becomes.

    What impact AI will have on DevOps processes remains to be seen. But it’s increasingly clear that AI will be applied across the IT operations spectrum. In theory, the more automated IT operations becomes the more resources any organization should be able to shift toward developing more applications, which naturally generates more APIs to be managed. It may take a little more time before most organizations have enough confidence in AI to make that transition. But at this point, it’s not so much a question of whether AI will be applied to IT operations as much as it is to what extent.

    — Mike Vizard

  • Accelerating MVP Development Performance Through DevOps

    Accelerating MVP Development Performance Through DevOps

    The core concept of minimum viable product (MVP) is to get maximum learning and understanding regarding what customers want about a product. Learning and understanding is a continuous process requiring a development process that is incremental in nature. That makes DevOps a favorite for CIOs and everyone else who dabbles with MVP development.

    How can DevOps help in accelerating MVP development?

    Continuous Updates

    Any MVP is built with assumptions about customer preferences in mind. Developers may have a deep understanding of what customers want, but they have no solid proof. The MVP “tests the waters” and measures the depth of the customer reaction. Developers then can develop and refine the application further, depending on the customer responses.

    Building an MVP that can be easily updated is no easy task, however, especially if the MVP juggles too many APIs that collect data from heavy databases. Traditional application development tactics may not work here. It is here that DevOps makes a difference. Its continuous integration and continuous delivery (CICD) tools ensure that any application or MVP can be easily updated according to dynamically changing scenarios.

    In other words, DevOps can help accelerate MVP development.

    Microservices

    Microservices is a concept in DevOps where the application is broken down into several loosely held parts. For instance, when a social media app is being built, its various components such as a newsfeed, stories, chabot, etc., are built separately as microservices.

    The prime benefit of microservices is that the updating, maintenance and bug-fixing process is simplified and easy to manage. For MVP, this translates into easier editing of feature sets to meet changing customer preferences. Also, it breeds an organizational culture of collaboration in which developers as well as applications have to mingle with each other to perform better. Such a collaborative environment is key to accelerated development of MVP.

    Extensive Automation

    DevOps and automation go hand in hand. In fact, zero-touch automation is deemed to be the future of DevOps. Right from continuous business planning to feedback optimization, there is plenty of scope in MVP for automation.

    Needless to say, automation drives operational agility. It also quickens the pace at which routine tasks are done. DevOps adoption for MVP development means developers can make more features and deployments faster within a short span of time.

    A Scalable Foundation

    Infrastructure as code, or IAC, is a key DevOps practice. It works by configuring servers automatically, especially cloud-based servers. IAC works by creating a single configuration file for all the servers. It is like a single template of configuration that can be cloned easily for several servers.

    As a result, DevOps allows applications to quickly ramp up their server capacity in a flash. The same goes for MVP: When the MVP gets the nod of consent and is mature for advanced development, the same server setup can be used as a foundation for upscaling the resources. Also, the same configuration file can be used to set up as many as servers as you want. What is the result? Cloud servers up and ready to use without loss of time.

    DevOps and MVP Development — A Formidable Combination

    Deploying a MVP is an integral part of the development process. DevOps, with its microservices and IAC approach, can help accelerate the pace at which applications are developed and deployed. Additionally, CI/CD tools ensure wide-scale collaboration among teams.

    Integrating a DevOps culture right from the MVP stage of an application will help in the development of a final product that is bespoke to customer requirements. Even if the customer requirements are different, microservices help to quickly modify them and update the application without significant downtime. To sum it up, DevOps is the perfect approach to accelerate MVP development.

    — Dhaval Sarvaiya

  • CA Technologies Report Highlights App Modernization Paradox

    CA Technologies Report Highlights App Modernization Paradox

    The rush to modernize IT environments using microservices, application programming interfaces (APIs) and containers may very well turn out to represent something of a double-edged sword.

    A survey of 1,087 IT and business professionals conducted by Frost & Sullivan on behalf of CA Technologies, a unit of Brocade, finds that organizations that have modernized their application environment are eight times more likely to achieve key performance indicators (KPIs) for the business. Four out of five respondents also said agile practices are helping them build what customers really need to improve overall customer satisfaction.

    On the downside, however, the study also finds more than half of respondents (56 percent) claimed that software issues can negatively affect the achievement of KPIs. A full 69 percent of all respondents say the pressure to release new applications or updates negatively affects quality and security, and 67 percent admit that their organization sometimes trades off security for application development and deployment speed.

    Nine out of 10 respondents who claimed to widely utilize modern application architectures also concede it’s challenging to manage and monitor APIs, microservices and containers, and that APIs and microservices add new risks for their organizations. A total of 80 percent of respondents also say they view continuous application security testing and DevSecOps as critical components of their strategy to help resolve those issues.

    Ashok Reddy, general manager for DevOps at CA Technologies, said that while organizations are clearly seeing a business benefit after embracing DevOps to modernize their application environments, the process hasn’t always been easy. The challenge they now face is that the rate at which digital business transformation projects are being launched has substantially increased. Most organizations are not going to achieve those goals in a timely fashion unless they modernize their application development and deployment processes, said Reddy, noting that only then can IT become flexible enough to meet the needs of the business versus continuing to try and force the business to bend to the way their applications work.

    The paradox many organizations find themselves wresting with is that making the business more agile requires a more complex approach to IT. In theory, each microservice deployed is easier to manage than a monolithic application. But as thousands of microservices get deployed, the number of dependencies between services becomes more than the average IT organization can track. In fact, all those dependencies is one reason more organizations are starting to investigate applying machine and deep learning algorithms within the context of an artificial intelligence (AI) model to automate IT management at scale. Clearly, most IT organizations are now on a journey that starts with a simple set of microservices and ends up fundamentally transforming enterprise IT, regardless of whether anyone likes it.

    It may take a while longer before the future of IT becomes a completely settled question. But for now, it’s apparent microservices in some regards are too much of good thing. The challenge is that from a digital business perspective, those microservices have become something most organizations can’t do without.

    — Mike Vizard

  • Humio Drives Real-Time Observability for Lightbend Fast Data Platform

    Streaming Log Management Solution Integrated with Fast Data Platform Enables Customers to Ingest Large Data Volumes Efficiently On- Prem

    London – October 22, 2018 – Humio, the only log management solution offering real-time, limitless logging capabilities with instant accessibility to users, today announced integration with Lightbend Fast Data Platform. Humio’s dynamic log engine provides immediate observability for application and infrastructure level data for Lightbend Fast Data Platform.  With the Humio and Lightbend integration, users can aggregate, interact and gain visibility with live log data in one solution by querying, developing dashboards and creating custom alerts. Humio’s streaming, real-time dashboards, alerting and high data volume ingest capabilities now provides customers the flexibility to scale up.

    Lightbend Fast Data Platform is a curated distribution of open source and commercial technologies for designing, building, and deploying streaming fast-data applications and microservices.  Humio’s integration with Lightbend provides a complimentary on-premises log management solution to provide deeper context, visualization and real-time analysis.  Lightbend users can easily send logs from a variety of sources such as their streaming applications, microservices, Apache Spark, Apache Flink, and Apache Kafka for aggregation and analysis in one view.  Lightbend users often generate large, multi TB/Day volumes of data and Humio’s ability to conduct further analysis, visualization and retention of the data easily and immediately provides unprecedented value for incident management, troubleshooting, audit scenarios as well as enabling an overall understanding of organizations’ systems.

    “Customers depend upon Lightbend Fast Data Platform to deliver streaming applications which impact the bottom line. The applications are distributed by nature with many moving parts generating large amounts of operational data.  This data requires aggregation and analysis in real-time to prevent business disruptions,” said Craig Blitz, Lightbend Senior Product Director. “At the heart of Humio’s solution is a time-series database engine that is optimized as an efficient, on-premises solution, and we are thrilled to extend these capabilities to Fast Data Platform customers to ensure system insights are efficient, fast and scalable for large data volumes.”

    “Lightbend continues to provide solutions to unleash customers’ ability to take advantage of streaming applications and data and we are thrilled to announce the Humio integration with the Fast Data Platform,” said Geeta Schmidt, Humio CEO. “Organizations we are servicing through this partnership require an on-premises solution and generate massive amounts of log data and we are excited to make it possible for them to aggregate all their data into one solution – Humio.”

    By providing an on-prem log management solution integrated with Lightbend Fast Data Platform, customers now gain real-time streaming, dashboard and query capabilities from system and application log data.  Humio’s efficiency allows Lightbend customers to ingest large multi TB/day data volumes efficiently, resulting in a significantly increased hardware TCO versus other solutions on the market.

    About Humio:

    Humio is a solution for aggregating, exploring, reporting, and analyzing log data in real-time. It gathers log data from a range of sources and can be deployed in both Cloud and On-Premises environments. Humio’s innovative data storage and in-memory search/query engine technologies provide a cost-competitive log management and analysis solution that requires significantly less hardware, engineering resources, and licensing costs vs. competing solutions. Humio has offices in London, San Francisco, and Aarhus, DK. For more information visit https://www.humio.com/or follow @MeetHumio.

     About Lightbend:

    Lightbend (Twitter: @Lightbend) provides the leading Reactive application development platform for building distributed applications. Using microservices and fast data on a message-driven runtime, enterprise applications scale effortlessly on cloud computing architectures. Many of the most admired brands around the globe are transforming their businesses with our platform, engaging billions of users every day through software that is changing the world.

  • NGINX Unveils Hybrid Application Delivery Controller Platform

    NGINX Unveils Hybrid Application Delivery Controller Platform

    NGINX this week announced it has developed a common framework for managing application delivery that can be applied across both monolithic and microservices-based applications.

    Announced at the NGINX Conf 2018 conference, the NGINX Application Platform has been rearchitected to provide traditional load balancing capabilities and a web application firewall (WAF), as well as a built-in service mesh for managing microservices and an integrated application programming interface (API) management platform.

    Sidney Rabsatt, vice president of product management at NGINX, said an update to NGINX Controller is at the heart of a much more comprehensive to approach to integrating load balancing, service mesh technologies and API management. Due out later this year, NGINX Controller 2.0 is based on a modular architecture that enables additional functions to be added via plug-in modules. The module for API management is slated for release in the fourth quarter, while the service mesh module is scheduled to become available in the first half of 2019.

    Rabsatt said it’s become clear IT organizations don’t want to replicate existing application delivery controllers just to manage microservices. There will never be such a thing as an enterprise IT environment this is made up entirely of microservices. The latest release of the NGINX Controller makes it possible to manage application delivery across the broad spectrum of applications that need to be addressed within modern IT environments, he said, noting that in effect, it’s a one-size-fits-all approach to managing application delivery via a single fabric.

    As part of that effort, NGINX this week also revealed that NGINX Plus R16, an enterprise-grade version of the core NGINX load balancing software, has been updated to apply load balancing algorithms to microservices running on Kubernetes clusters, in addition to support for Amazon Web Services (AWS) PrivateLink integration.

    Finally, NGINX announced version 1.4 of Unit, an open source web and application server that support TLS encryption, dynamic reconfiguration via an API and experimental support for JavaScript with Node.js to extend existing support for Go, Perl, PHP, Python and Ruby languages support. Full support for JavaScript and Java is planned for 2019.

    In general, Rabsatt said it’s clear organizations that have embraced DevOps are the most advanced when it comes to the need to unify management of application delivery. In fact, much of the recent success NGINX has enjoyed as of late starts with developers downloading an open source instance of NGINX to embed within their applications. As those instances of NGINX start to proliferate across the enterprise, more IT operations teams become exposed to the rest of the NGINX platform.

    It may take a while for microservices-based applications to achieve enough critical mass to force organizations to rethink their approach to application delivery. But it’s now a matter of time before organizations need to decide the degree to which they want to deploy standalone application delivery controllers and service meshes for microservices applications instead of pursuing a more hybrid approach. NGINX is clearly betting on the latter, given the number of legacy monolithic applications that will be running for years.

    — Mike Vizard

  • Software AG Acquires Built.io to Advance Integration Strategy

    Software AG Acquires Built.io to Advance Integration Strategy

    Software AG has acquired Built.io as part of an effort to provide a multitier approach to application integration designed for different classes of developers.

    Subhash Ramachadran, senior vice president for product management at Software AG, said Built.io adds a low-code approach to integration in the form of a platform-as-a-service (iPaaS) environment developed using Node.js to a portfolio of technologies that include the webMethods platform.

    Ramachadran said the low-code approach will appeal more to so-called citizen integrators who are trying to integrate business processes with minimal intervention on the part of an IT team. Many of those capabilities are now expected to be delivered in a software-as-a-service (SaaS) model that citizen developers can invoke on demand. Built.io, for example, already provides built-in support for more than 300 applications and services. Those tools, however, don’t replace the need for a set of integration frameworks aimed at more complex tasks that require professional developers, Ramachadran said.

    Increasingly, there are large numbers of use cases for integration that simply don’t require a professional developer to accomplish, he noted. In fact, the number of use cases that can be addressed by tools such as Built.io might be substantially larger than the use cases requiring a platform the size and scale of webMethods.

    Software AG’s goal is to create a single platform to provide organizations with multiple classes of integration frameworks that can be applied to different personas within an organization, Ramachadran said. A common platform eventually would make it possible for integrations of varying skill levels to collaborate more easily.

    Those frameworks could then be plugged into any continuous integration/continuous development (CI/CD) platform to enable various Software AG integration platforms to be natural extensions of a DevOps environment, he added. The webMethods integration platform already supports Kubernetes clusters and Docker containers as a runtime environment.

    As DevOps processes continue to evolve, Ramachadran said Software AG is betting that organizations will want to make it easier for different classes of developers working with multiple types of tools to collaborate.

    To facilitate that transition, Software AG now enables everything from sharing code via GitHub to deploying micro gateways for managing application programming interfaces (APIs) within the context of a set of microservices, he noted, adding those capabilities will only become more important as organizations begin to build highly distributed internet of things (IoT) applications running on a wide variety of platforms.

    Microservices, however, create something of a paradox when it comes to integration. On the one hand, frameworks such as Built.io will make it simpler for more organizations to integrate multiple microservices and legacy monolithic applications. On the other hand, microservices are making integration more challenging for many professional developers as they continue to expand across the enterprise.

    The challenge facing most organizations will be striking the right balance between microservices and existing monolithic applications, many of which don’t naturally lend themselves to being re-engineered into a series of microservices. In fact, in many cases it may be difficult to distinguish from an integration standpoint what constitutes a microservice versus a monolithic application, so long as both can be invoked using a simple API.

    — Mike Vizard

  • Kong Inc. Defines Services-Centric Approach to Integration

    Kong Inc. Defines Services-Centric Approach to Integration

    Kong Inc. has released a feature-complete version of its namesake services broker for legacy and microservices-based applications that promises to eliminate the need for legacy application programming interface (API) management platforms.

    Company CTO Marco Palladino said traditional API management platforms, for all intents and purposes, are now dead. Formerly known as Mashape, the core technology developed by Kong Inc. has been widely employed to manage APIs. But the time has come to focus on managing services at a much higher level, he said.

    Despite Kong having been downloaded more than 45 million times, the latest version is being labeled a 1.0 release because the open source service broker has now been deemed to be feature-complete, which includes support for service mesh patterns, Kubernetes Ingress controller and backward application programming interface (API) compatibility to future releases, Palladino said.

    Kong is being positioned as a microservices API gateway capable of supporting sub-millisecond response times in a way that would not be possible to achieve using legacy API management platforms that reside in the cloud or in a local data center. Kong can be deployed on-premises or in public clouds based on virtual machines, Kubernetes or bare-metal servers. That approach makes it possible to employ Kong to manage services regardless of where they run. Kong has also developed a “Kong Brain” function that employs machine learning algorithms to optimize the flow of data traffic between services that has increased dramatically in the last few years, Palladino said.

    Palladino noted that while service meshes exist specifically for Kubernetes clusters, most enterprise IT organizations will require an approach to managing services across legacy monolithic applications and emerging microservices-based applications that are based on multiple types of runtime environments and serverless computing frameworks. Over time, Kong will integrate with various platform-specific service meshes as they emerge to further enable a more comprehensive approach to services lifecycle management, he said, adding that Kong automatically configures itself to serve traffic to new applications as they are deployed and new services are created.

    In addition, organizations can migrate from one service to another based on a different databases schema without incurring any downtime.

    When it comes to managing services, Palladino said there’s still too much focus on tribes that have emerged around specific platforms that wind up polarizing the IT industry. IT organizations clearly need a means to broker services regardless of where they run or might have originated, he said, noting API management could be viewed as a stepping stone toward achieving that goal.

    It’s not clear yet whether legacy approaches to API management are truly dead or simply in the process of transforming into a means for managing services at higher levels of abstraction. Regardless of the outcome, it’s clear that a less brittle approach to managing integration in the age of microservices will be required. Many forget, however, that in most cases a monolithic application is now just another type of service.

    — Mike Vizard

  • Fusing iPaaS with DevOps: Synergistic Potential of Continuous Zero Code Integration

    Fusing iPaaS with DevOps: Synergistic Potential of Continuous Zero Code Integration

    DevOps and integration platform as a service (iPaaS) are two dominant trends that together have cutting-edge use cases. Zero code integration could bring significant improvements to the DevOps life cycle, enabling efficient movement of applications from development to production. Implemented in the right way, both technologies can rewrite the way applications are developed.

    DevOps is a Paradigm Shift 

    DevOps is a development approach based on continuous development and continuous integration to unify development and operations. The power of this approach has enabled behemoths such as Amazon and Netflix to leapfrog other players in their domains and set up an entirely new industry.

    DevOps enables enterprises to manage the complete life cycle of applications from development to production in a faster and efficient way. In this way, teams can significantly accelerate the speed of application development life cycle.

    In traditional ways of software development, IT and operations teams work in silos. To develop something, development needs to build codes, package everything and hand them over to a release manager. In the next stage, the release manager delivers the developed code to a test environment, where QA teams test the code and report the errors back to the development team. Developers again make changes and process them to the test environment. Then, again, the project is handed over to the development environment. This process entails a lot of handovers across organizational departments. Teams show resistance to changes coming down the road. Red-tape administration and the overhead involved in these activities slow down the development process.

    All these hassles can be circumvented with the help of DevOps. In DevOps methodology, the development and testing teams work as one single team for the development of assets. The combined Development and Operations team achieves a balance to ensure that no efficiency is lost during the development process. All aspects of development testing, unit testing, integration testing, acceptance testing and production happen in a single environment. Small iterations are used to deliver usable products at the end of each sprint.

    iPaaS for Transforming Monolithic Applications 

    iPaaS is an ingenious innovation for breaking down silos and ensuring operational efficiency and agility. It is a modern-day approach to automating integration between applications and marshaling them in an order. iPaas platforms bundle connectors, maps, and transformations to enable zero code integrations that are thrice more durable and efficient than conventional integrations. This unique advantage enables business teams to build integrations and lets IT teams to assume the governance role.

    iPaaS solves a critical IT problem holding back organizations from leveraging their digital technologies: IT complexity. This problem was not present 15 or 20 years back, when enterprises had only three or four business systems. Enterprises used developer tools to combine applications and move data between source and target systems. They hand-coded connections for electronic data interchange. However, this method is not ideal for a scenario in which thousands of cloud and on-premises applications run in parallel. A lot of coding is required to build these integrations between these applications. Developers don’t have visibility to what other team members are building, and they create independent “islands of automation” and silos. Another relevant problem is updating integrations that remain in a constant flux.

    All these challenges can be circumvented if integration becomes codeless and manageable by everyone involved. iPaaS provides custom development kits and pre-built accelerators to build ground-to-cloud integrations or cloud-to-ground integrations in a hybrid environment. Without writing a single line of code, teams can build integrations and establish a smoother symbiosis between differentiated applications. Zero code integration of iPaaS helps on four fronts: Integrate, Design, Monitor and Govern.

    Harnessing the Vantage Point: Continuous Zero Code Integration

    Real-time integration resides at the heart of both iPaaS platforms and DevOps methodologies. IPaaS can further strengthen the continuous integration muscle of DevOps. Teams can fuse iPaaS with DevOps for a transformative technological advancement called continuous zero code integration. This step can take continuous integration even one step closer to continuous integration.

    IT and business teams can break down IT silos down the road and turbocharge the development process. Start-to-end integration between DevOps tools for other developers can fast forward the process of code development and code testing. A single intelligent mesh enables developers to integrate codes of developers and run them on a common build. Automated reporting ensures that developers are not stepping on each other’s code. Teams are able to make code updates or deliver things right into production hundreds or thousands of times a day.

    Version control integration can be updated with the command center to provide fully automated provisioning. It further can be used to automate the entire standing. Development can be connected seamlessly with the version control system for a shared development environment in which shippable products can be developed. Individuals get a better look at their assets while working on them. This allows automation to run automation test units for frictionless development.

    A microservices-based DevOps architecture is the most interesting part of DevOps and iPaaS fusion. This model has the potential to accelerate productivity significantly. Teams can deliver solutions much more quickly and access many business benefits downstream. Shorter build and deploy cycles improve deployability. It delivers the scalability to incorporate service-specific security, replication and monitoring in the build process.  Fault-tolerant systems can be set up in which an error in one service affects only that respective system and not all services. Developers don’t have to use brute computational force for releasing new versions of a service. Loosely coupled microservices provide a greater degree of elasticity in the cloud. New frameworks, libraries, data sources and modular components support dynamic discovery and binding.

    Any type of DevOps model can be driven by an iPaaS and their fusion should not be perceived as an enigma. Surely, there can be many more use cases out there. Melding the two for power and positive force is worth a closer look. This fusion can transcend application development in ways that are hard to imagine right now.

    — Jitesh Banga

  • Netifi Rises to Microservices Integration Challenge

    Netifi Rises to Microservices Integration Challenge

    Netifi this week launched an integration platform based on the open source RSocket communications protocol to replace HTTP ad REST application programming interfaces (APIs) as the mechanism for connecting microservices. RSocket was originally created by Netflix and is now being strengthened via contributions from Netifi, Facebook and Pivotal Software for use within enterprise IT organizations.

    Fresh off raising $2 million in seed funding, Netifi is also committing to support a community edition of RSocket later this year.

    Company CEO Robert Roeser said the Netifi platform is designed to make it easier to build microservices and interconnect them. Most of those microservices are being built using Docker containers, but Roeser said that, as part of a polyglot approach to integration, Netifi is leveraging RSocket to connect microservices built using a variety of runtimes as well as provide access to legacy monolithic applications. The Netifi platform can be deployed on-premises, in a public cloud or in a hybrid fashion.

    Roeser said RSocket was born of necessity at Netflix because the number of microservices that needed to be interconnected at scale was simply too complex a task using HTTP and REST APIs. Soon after, Facebook also started employing RSocket and now Netifi and Pivotal are making contributions designed to make Rocket more accessible for traditional enterprise developers. In the case of Netifi, that means providing mechanisms to both discover and advertise microservices and provide a layer of abstraction that shields developers from the underlying complexity of the network underlay, he said.

    As applications based on microservices become more widely distributed, enterprise organizations tend to become more intimidated by the challenges associated with managing them at scale. Traditional enterprise IT organizations don’t have access to a small army of software engineers to solve the problem. As a result, many of them retreat to building monolithic applications in which all the services that need to be accessed are baked into the application itself. They typically sacrifice scale and flexibility in favor of a construct that is both familiar and easier for them to navigate, Roeser said.

    The challenge Netifi and other supporters of RSocket will face is the considerable amount of inertia surrounding REST APIs and HTTP. Several generations of developers now consider REST APIs to be the default mechanism for connecting various applications together. The issue many of them will need to wrestle with is the extent to which the rise of microservices breaks that integration construct. A shift away from REST APIs also could have significant implications regarding how services are exposed externally, how pipelines are constructed within DevOps environments and other factors.

    It remains to be seen whether integration platforms based on RSocket or some other approach ultimately makes microservices more accessible to enterprise IT organizations. But significant resources now are being poured in to solve the problem, many of which leverage contributions of companies, such as Netflix and Facebook, that already rely on thousands of microservices to deliver a broad range of cloud-native applications.

    — Mike Vizard