Tech with Jagmeet

SOAP(Simple Object Access Protocol)

SOAP is a protocol for exchanging structured information in the implementation of web services. It uses an XML data format to declare its request and response messages and typically uses application layer protocols such as SMTP, HTTP/HTTPS, FTP for message negotiation and transmission. It is independent of platform and programming used; and proves valuable in certain contexts like strict standards, strong typing, high security features and reliability. It is mostly used in financial services, healthcare, government sectors, payment gateway, etc. where data integrity and compliance are important. Main features of SOAP can be

• Its ability to define set of rules for exchanging info between applications. These are defined in WSDL. WSDL contain format of SOAP message and operations that can be performed on it.
• Its support for advance security mechanism like digital signatures, encryption. Data can not be accessed by unauthorized user.

These SOAP features makes it little complex than other APIs

Example:

Request

POST /services/userService HTTP/1.1
Host: example.com
Content-Type: text/xml; charset=utf-8

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ser="http://example.com/services"> <soapenv:Header/> <soapenv:Body> <ser:getUser> <ser:id>1</ser:id> </ser:getUser> </soapenv:Body> </soapenv:Envelope>

Response

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> <soapenv:Header/> <soapenv:Body> <ser:getUserResponse> <ser:User> <ser:id>1</ser:id> <ser:name>John Doe</ser:name> <ser:email>john.doe@example.com</ser:email> </ser:User> </ser:getUserResponse> </soapenv:Body> </soapenv:Envelope>

REST (Representational State Transfer)

REST is an architectural style for building web services that can be consumed by any applications. It uses JSON and XML data format to declare request and response and is based on HTTP(GET, POST, PUT, DELETE) to perform operations on resources. It follows stateless client server model i.e. server does not store any client’s state information between requests. However, SOAP considered stateful, as it can maintain state through sessions. It is simple, scalable, easy to maintain, good for CRUD operations and top pick for Web APIs. It is used apps that requires real time communication like streaming services and chat applications. Companies like Twitter, Youtube, etc. use it. However, Each resource has its own URL. Due to which there can problem of over fetching and under fetching for example: if we need related data, we end up making multiple requests which increases latency and really slow things down.

Image source

Example

Request

GET /api/v1/users HTTP/1.1<br>Host: example.com<br>Accept: application/json

Response

[ { "id": 1, "name": "John Doe", "email": "john.doe@example.com" }, { "id": 2, "name": "Jane Smith", "email": "jane.smith@example.com" } ]

GraphQL

It is opensource, flexible and efficient alternative. GraphQL is API protocol as well as a query language. It is strongly typed and you can easily query whatever you want no matter how complex it is and this gives front end more control over what data to fetch. GraphQL uses mutation for write operations like create, remove, add. The precise data retrieval solves the problem of over fetching, under fetching and reduce network overloads.

Image source

As front end has more control over what to query so overload on the backend increases. Due to its dynamic nature, caching becomes trickier. When it comes to optimizing performance, its hard to do in GraphQL as compared to REST. Companies like github, shopify use it

Example

Request

POST /graphql HTTP/1.1<br>Host: example.com<br>Content-Type: application/json<br><br>{<br>"query": "query { user(id: 1) { id name email } }"<br>}

Response

{ "data": { "user": { "id": 1, "name": "John Doe", "email": "john.doe@example.com" } } }

WebSocket

Web Socket APIs is TCP based computer communication protocol that enable bidirectional, full-duplex communication between servers and clients, using a pair communication model. WebSocket uses HTTP/1.1. Unlike traditional communication methods like REST, etc., this API does not need a new connection to be established for each message. Once the connection is initialized, messages can be seamlessly sent and received without interruption in the form of packets. It’s a stateful protocol i.e. the connection won’t break until either party decides to discontinue data exchange. It does not have any in built security features.

These WebSocket APIs are well-suited for IoT applications, live chat applications, bitcoin trading and gaming with low latency or high throughput demands.

Image source

gRPC(Remote Procedure Call)

It is an open-source, modern high-performance universal RPC framework initially developed by Google. Utilizing HTTP/2 for transport and Protocol Buffers (protobuf-platform & language independent) as the interface description language(service methods and message formats), gRPC generates cross-platform client and server code. Messages are light-weight as they are stored and processed in binary form whereas Websocket can be in multiple formats like JSON, MQTT, etc. gRPC allow services to expose custom methods, much like any other programming language. This framework typically includes built-in features such as authentication, load balancing, and more. gRPC used for inter communication, good for distributed systems in data centers, communication between high performance microservices and supports bidirectional streaming between client and server. gRPC is token-based and supports SSL/TLS encryption, API security is certain with this option. Companies like Netflix, google use it.

Image source

Protobuf Definition:

syntax = "proto3";

service UserService {
rpc GetUser (GetUserRequest) returns (GetUserResponse);
}

message GetUserRequest {
int32 id = 1;
}

message GetUserResponse {
int32 id = 1;
string name = 2;
string email = 3;
}

Request

import grpc
import user_pb2
import user_pb2_grpc

#Assuming the server is running on localhost:50051channel = grpc.insecure_channel('localhost:50051')

stub = user_pb2_grpc.UserServiceStub(channel)
response = stub.GetUser(user_pb2.GetUserRequest(id=1))
print(response)

Response

class UserService(user_pb2_grpc.UserServiceServicer):<br>def GetUser(self, request, context):<br>return user_pb2.GetUserResponse(id=1, name="John Doe", email="john.doe@example.com")<br><br>Server setup<br><br>server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))<br>user_pb2_grpc.add_UserServiceServicer_to_server(UserService(), server)<br>server.add_insecure_port('[::]:50051')<br>server.start()<br>server.wait_for_termination()

Webhook

Webhooks are custom HTTP callbacks triggered by specific events within application. This enables real time, async and event driven communication between the systems. This saves computing power and bandwidth efficiently. This supports decoupled architecture which enhances modularity and scalability of an app.

In Webhooks, data request is not required. Data is sent from server to client at some interval or change.

More info.