https://github.com/sidhyaashu/order_management_service

Learn how to build scalable micro-services in Golang with gRPC by building a practical real-world production project (order management system).
https://github.com/sidhyaashu/order_management_service

go grpc-go

Last synced: about 1 month ago
JSON representation

Learn how to build scalable micro-services in Golang with gRPC by building a practical real-world production project (order management system).

• Host: GitHub
• URL: https://github.com/sidhyaashu/order_management_service
• Owner: sidhyaashu
• License: bsl-1.0
• Created: 2024-12-06T17:54:36.000Z (about 1 month ago)
• Default Branch: sidhya
• Last Pushed: 2024-12-08T13:37:58.000Z (about 1 month ago)
• Last Synced: 2024-12-08T14:30:18.226Z (about 1 month ago)
• Topics: go, grpc-go
• Language: Go
• Homepage:
• Size: 8.79 KB
• Stars: 0
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# GOgRPC

Learn how to build scalable micro-services in Golang with gRPC by building a practical real-world production project (order management system).

gRPC (short for **g**eneral-purpose **R**emote **P**rocedure **C**all) is a modern, high-performance, open-source framework developed by Google for enabling efficient communication between distributed systems and services. It uses **protocol buffers (protobuf)** as its interface definition language and serialization mechanism, making it both fast and compact.

### Key Features of gRPC:

1. **Cross-Language Support**:

   - gRPC supports multiple programming languages, including C++, Java, Python, Go, Node.js, Ruby, and more.

   - This enables the creation of heterogeneous systems where different components can be implemented in different languages.

2. **Efficient Serialization**:

   - Uses protocol buffers (protobuf) for compact, high-performance serialization.

   - This makes gRPC well-suited for systems requiring low-latency and high-throughput communication.

3. **Bidirectional Streaming**:

   - Supports four types of communication:

     1. **Unary RPC**: Single request and single response.

     2. **Server-Streaming RPC**: Single request and a stream of responses.

     3. **Client-Streaming RPC**: Stream of requests and a single response.

     4. **Bidirectional Streaming RPC**: Both client and server can exchange a stream of messages.

4. **HTTP/2-Based Transport**:

   - gRPC uses HTTP/2 as its transport protocol, providing benefits such as multiplexing, flow control, and built-in support for TLS encryption.

5. **Code Generation**:

   - Developers define the service interface and message structures in `.proto` files.

   - gRPC automatically generates client and server stubs in the desired programming language.

6. **Interoperability**:

   - Enables seamless communication between microservices, making it a popular choice for microservices-based architectures.

7. **Advanced Features**:

   - Built-in support for authentication, load balancing, and pluggable middleware.

   - Enables streaming, retries, and deadlines.

### Common Use Cases:

- **Microservices Communication**:

  Facilitates communication between microservices in distributed systems.

  

- **Real-Time Applications**:

  Its streaming capabilities are ideal for real-time applications like chat apps, live monitoring systems, and video streaming.

- **IoT Applications**:

  Provides efficient communication for resource-constrained IoT devices.

- **Inter-Platform Systems**:

  Allows components written in different languages to communicate effectively.

### Example Workflow:

1. Define the service in a `.proto` file.

2. Generate code for client and server stubs using gRPC's tools.

3. Implement the server and client logic.

4. Deploy and use the gRPC service.

### Advantages:

- High performance and low latency.

- Cross-platform and cross-language support.

- Compact serialized data format.

- Rich feature set for modern distributed systems.

### Disadvantages:

- Slightly steeper learning curve due to its reliance on protocol buffers and the need for generated code.

- Limited native support for browsers (requires gRPC-Web).

### Comparison with REST:

| Feature         | gRPC                         | REST                        |

|-----------------|------------------------------|-----------------------------|

| Protocol        | HTTP/2                       | HTTP/1.1                    |

| Data Format     | Protocol Buffers (binary)    | JSON (text-based)           |

| Performance     | Faster, compact              | Slower, larger payloads     |

| Streaming       | Yes (bidirectional)          | Limited                     |

| Browser Support | Requires gRPC-Web            | Native                      |