7.2.3: Beyond REST- Web Services in Modern Cloud Applications

Introduction to Cloud Computing · LibreTexts

0%

Contents

    Text

    Size
    100%
    Theme
    Typeface
    Line length
    Spacing

    Read aloud

    How

    Speed: 1×
    Light up
    Highlight

    Symbols: Mulberry Symbols, © 2018–2026 Steve Lee, CC BY-SA 4.0 (licence, the set), the site's own copies.

    From LibreTexts, under CC BY 4.0, as the source states it; its equations are written in TeX, which the PDF shows typeset. This page at LibreTexts.

    7.2.3: Beyond REST- Web Services in Modern Cloud Applications

    While SOAP and REST were the initial web service paradigms, modern cloud computing has further evolved how services communicate. Some developments and technologies include:

    • JSON as Default: JSON has effectively become the lingua franca for web APIs due to its lightweight nature and JavaScript friendliness. Even SOAP-based services sometimes offer JSON these days (though not using SOAP protocol, they might offer a REST/JSON alternative). JSON’s schema-less nature (no need for explicit WSDL) makes evolving APIs easier.
    • gRPC: This is a high-performance RPC framework that could be seen as “RPC 2.0” for cloud-era. Developed by Google (and now open source), gRPC uses Protocol Buffers (a binary serialization format) to define service interfaces and exchange messages [3]. It runs on top of HTTP/2, which allows for multiplexing, bi-directional streaming, and efficient binary transport. Unlike SOAP or REST, gRPC is not human-readable (the messages are binary), but it is highly efficient and suitable for microservices communicating in a data center or cloud environment. Google’s own internal systems used a predecessor of gRPC called Stubby for over a decade to connect thousands of microservices. By open-sourcing it as gRPC, they enabled other companies to benefit from the approach. One of gRPC’s key design principles is “Services not Objects, Messages not References”, explicitly avoiding the pitfalls of earlier distributed object systems by making RPC calls coarse-grained and message-driven. gRPC fits well in cloud-native scenarios where performance is critical – e.g., communication between latency-sensitive services – and is gaining popularity in projects with polyglot microservices (since Protocol Buffers allow code generation in many languages). It’s used in systems like etcd, and supported in Kubernetes for some internal APIs, etc.
    • OpenAPI (Swagger): One challenge with RESTful/JSON services is the lack of a formal interface definition like WSDL. OpenAPI (formerly known as Swagger) has emerged as the standard solution. OpenAPI Specification is a machine-readable format (YAML or JSON) for describing RESTful APIs: it documents the available endpoints, operations, parameters, request/response schemas, authentication methods, and more. An OpenAPI document serves a similar purpose to WSDL – it allows humans and computers to understand what the API offers and how to interact with it. Tools can generate client code or server stubs from OpenAPI definitions, and also interactive documentation (like the popular Swagger UI where you can try out API calls from a browser). Most public APIs today publish OpenAPI specs. This has helped bring some of the benefits of strongly-defined interfaces to the REST world, without the overhead of SOAP. For example, if you are building a client integration with the Twitter API, you could use Twitter’s OpenAPI spec to auto-generate a client library, rather than hand-coding HTTP calls. In essence, OpenAPI is to REST what WSDL was to SOAP, but more flexible and geared towards JSON/HTTP usage.
    • GraphQL: Though not explicitly asked in the chapter, it’s worth mentioning GraphQL as a modern alternative to REST for certain use cases. GraphQL (from Facebook) lets clients query an API with a flexible request, getting exactly the data they need. It addresses some perceived shortcomings of REST (like under/over-fetching of data). It’s not a replacement for REST or SOAP per se, but an alternative style (with its own schema definition language). In cloud-native applications, GraphQL is often used for client-facing APIs (especially where front-end developers want more control over queries), while microservices behind the scenes might still use REST or gRPC.
    • Async APIs & Event-Driven Services: Traditional web services (SOAP, REST, gRPC) are request-response (synchronous) models. Modern cloud systems also rely on asynchronous communication patterns – message queues, publish/subscribe, streaming (e.g., Apache Kafka, AWS SNS/SQS). While these aren’t called “web services” in the classic sense, they are part of the broader integration landscape. Standards like AsyncAPI (analogous to OpenAPI but for event-driven APIs) are emerging to document such interfaces.

    In summary, web services have evolved from the heavy SOAP/WSDL approach to lighter REST/JSON approaches, and now to high-performance RPC (gRPC) and other specialized API styles. Each has its place: SOAP for legacy and strict enterprise scenarios, REST/JSON for broad interoperability and ease of use, and gRPC for internal efficiency and type-safe contracts in microservices. Next, we will discuss how these services actually operate in cloud environments – specifically, how services discover each other, are load balanced, and made reliable.


    This page titled 7.2.3: Beyond REST- Web Services in Modern Cloud Applications was last modified on Sat, 12 Sep 2026 08:40:50 GMT and is shared under a CC BY 4.0 license and was authored, remixed, and/or curated by Felix Amoruwa.