What we all know is that the client-server architecture divides communication into two parts: one that takes on all the heavy lifting and provides services, called servers, and those who enjoy these services, called clients.
In a typical client-server communication, the client simply sends a request to the server for a resource or service, and the server responds to that request.
For client-server communication, the client and server need to have libraries that understand the protocols they communicate with. A protocol is a language or set of rules for internet communication. They are transmission mechanisms that follow some guidelines for the transmission of data over the Internet.
The second most important aspect of client communication is the message format that both the client and the server can recognize. This message format follows a format that cannot be communicated without following them. The message format can be similar to XML (a specific form) or a JSON file (which must contain a specific key-value pair). Another important aspect to understand about this type of communication is that it is based on a request-and-response mechanism, which means that the server only communicates when the client initiates a request.
In the early 90s of the 20th century, a popular client-server protocol called SOAP used the XML message format with a hard-coded schema. The schema of this message format is very strict, and it is encoded strictly according to the specified rules, which leads to the gradual abandonment of SOAP and the emergence of REST. The emergence of REST is due to the growing popularity of j**ascript, which also directly leads to the popularity of the json file format. It is simple to understand and convenient. It has only a few key-value pairs in its message format. In simple terms, REST is the transmission of JSON messages using HTTP as the protocol (transport mechanism). With REST, we don't need to worry about how to develop a pattern for messaging.
We've talked about the emergence of REST, and let's take a closer look at its core technology. Let's take a look at the definition, REST is a standardized software architecture style and is a widely used API in the industry.
1. REST is simple and has a set of standards for communication architecture. With REST, we don't have to format messages or data every time.
2. REST is extensible. If your service becomes more complex and requires more functionality, you can easily revamp your server-side without worrying about the REST performance of your server, and you can add new features in complete isolation.
3. REST is stateless. Previously, each request carried some information that was understood by the server, and the server's mechanism allowed the server to remember the information of the request, but in the REST architecture, the session state is stored on the client, which makes the server more efficient and brings less work to the server, so as to achieve better functionality.
4. REST is a high-performance architecture and supports caching.
Imagine you're making a ** for a restaurant. You can **get all the menus, and the food is divided into three categories:
1. Appetizer. 2. Main course.
3. Drinks. Now want to ** see all the drinks. In a REST architecture, we can easily categorize this information and send a GET request to the server to the data that can fetch the drink. In the same way, we can also do all CRUD (Create, Read, Update, Delete), which makes REST suitable for large projects that don't need to hypertransfer data and don't need real-time. REST is most effective for applications that focus on efficient data transfer. Caching is another feature of REST that is useful for standard applications such as food booking apps, hotel booking apps, blogs, forums, etc.
REST is powerful, but it also has some drawbacks.
1. There is no two-way communication, what if the server needs to send some data to the client? In a REST architecture, this is not possible. Of course, there are some tricks you can use, but they are not practical.
2. Imagine achieving a real-time score**. How will you implement this feature of updating scores? We could have the client send a request every 10 seconds, but that's not a good practice. It overloads the server, reducing the efficiency of the server's response.
3. The REST architecture is purely request and response, and does not support data flow (continuous event processing).
4. The REST stateless property has both advantages and disadvantages because we can't tell the state of the data on the REST architecture.
To solve the first problem of REST, the need for bidirectional communication, WebSocket appeared, which allowed the server to initiate communication, but the problem with WebSocket was that it had no format, it could only send bytes and without any restrictions.
There is nothing inherently wrong with websockets, but the real problem is that any type of communication requires a protocol, and each protocol needs a client library (parsing data) that can communicate with that protocol.
If you're creating a Python application on a REST-based architecture, you'll need an HTTP client that can communicate with the server. In most cases, client libraries are developed by third parties. Using third-party libraries may expose your own program details, be insecure, and the entire application will rely on a third party for communication.
For web applications, browsers act like client-side libraries, but for non-web projects, you need third-party client-side libraries. If we develop an app ourselves, it's not that easy, and you'll have the burden of maintaining another app.
So, in order to solve some of the problems with REST as well as the problems with client-side libraries, Google invented GRPC in 2015.
For gRPC, Google maintains a client-side library for almost all popular languages. It uses the HTTP 2 protocol under the hood and uses Protobuf as its message format. We don't need to worry about any client-side libraries because Google is maintaining it for all programming languages. A single, centralized client library is one of the main advantages of grpc.
Another benefit of grpc is the message format it uses. Protobuf is language agnostic, so we can create a client in Python, a server in Go, and still be able to communicate easily.
GRPC is essentially a client library and a protocol that can be used on any device.
GRPC uses Protobuf for communication. It serializes the proto files into binary format and sends them to the server, deserializing them to the original format on the server side. At the same time, GRPC has different forms of communication. You can think of them as a function of the gRPC.
A single request: A simple type of request-response communication where the client sends the original request, and the server waits for some time after receiving the request to perform some process and then returns some response.
Server streaming: When a single request is made, the server responds with a large amount of data. For example, when a certain ** is clicked, a large amount of data related to ** pours out from the server side.
Client-side streaming: Contrary to server streaming. Here the client sends a large amount of data to the server at once. For example, this happens when you share a large file or upload an image or ** to the internet on the internet. The client constantly sends data to the server side.
Bi-directional flow: In this type of communication, the client and the server send multiple messages. Chat is a good example of this.
Based on the functionality of gRPC, let's say you want to make a chat application. We won't be using the REST API because it won't be able to allow fast flows of bi-directional communication. , we'll be using grpc streams, which will provide more benefits than just speed. First, its cross-language behavior is independent of the programming language written by the server or other clients. Communication can still be established until the message format is accepted.
So, with this feature, the Android version of the chat app can communicate with the iOS version and vice versa.
Limited browser support: grpc uses http 2, so it's difficult to call the grpc service directly from the browser. Sometimes it needs to be set up**.
Unreadable form:grpc uses a binary format that is unreadable by humans. In some cases, this is a disadvantage.
Immature: gRPC was developed in 2015, so it's still a bit immature compared to REST, with a lot of bugs and issues to solve.
Onboarding costs:REST and GraphQL use JSON, which is easier to learn. Most people will try to stick with them because protobuf is still a new and complex topic, making it difficult to find a grpc expert.
Data Format:
The message format used by REST is mostly JSON (and sometimes XML), which is a more readable and easier to work with. We don't have to worry about patterns in REST. Whereas, grpc uses protocol buffers to serialize the data. The compressed form is lighter and faster to carry. It is in binary format, so the data is serialized and deserialized during transmission.
http 1.1 vs http 2：
REST APIs typically use HTTP 11 as its protocol, while grpc uses HTTP 2 as its underlying protocol. The REST API can also use HTTP 2, but it will still be limited due to the REST request-response mechanism. GRPC uses HTTP 2 and takes advantage of HTTP 2 support for client response and bidirectional communication. This is another aspect where grPC outperforms REST. It can be like http 11 manages one-way requests, or both two-way requests like HTTP 2.
Delay:
The low latency and high communication speed of the grPC make it ideal for connecting systems consisting of lightweight microservice architectures, resulting in more efficient messaging. In most network cases, REST latency takes 25ms, while grPC latency is much smaller than REST.
Load Limit:
When transferring messages, REST has a maximum load limit of 45MB, while grPC doesn't have any limit, which means that transferring messages can have the desired size.
Security:
In terms of security, REST lags behind because it uses HTTP 11 and JSON format, easy to decrypt and access. grPC, on the other hand, uses HTTP 2, which is more secure, and uses Protobuf in binary format, which is difficult to decrypt.
Speed:
Here, again, grpc wins because it's 10 times faster than REST, and for the same reason, http 2 is used as the protocol and protobuf is used as the message format.
**Generate:
REST doesn't offer built-in generation capabilities, which means developers need third-party applications to generate APIs, while gRPC has native generation capabilities thanks to its ProtoBOF compiler, which is compatible with multiple programming languages. This is another benefit, especially for microservices architectures.
In closing, I would say that REST is still the most commonly used and popular architecture, and it's impossible to give up. REST has a lot of drawbacks, like lack of data flow, no two-way communication, slow speeds, etc., but it is best suited for the standard applications that we see in our daily lives. On the other hand, grPC is still young and difficult to learn, it offers many features such as high data flow on both the client and server side, good bi-directional data flow, fast and compact, and uses HTTP 2. Performance-wise, grPC is best suited for high-workload applications such as streaming, song streaming, gaming, file sharing, and chat applications.
**10,000 Fans Incentive Plan