System Design Basics for Backend Developers · Lekcja

GraphQL i gRPC

Poznaj alternatywne style API, takie jak GraphQL do elastycznego pobierania danych oraz gRPC do komunikacji o wysokiej wydajności.

GraphQL i gRPC to bezpłatna lekcja System Design Basics for Backend Developers na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej System Design Basics for Backend Developers, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs System Design Basics for Backend Developers zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Beyond REST: GraphQL & gRPC

RESTful APIs are widely used, but they aren't always the perfect fit for every scenario.

Sometimes, you need more control over data fetching or require extremely high performance for inter-service communication.

This lesson explores two powerful alternatives: GraphQL and gRPC.

REST's Data Fetching Hurdles

Traditional REST APIs often lead to two common issues:

Over-fetching: Receiving more data than needed in a single request, wasting bandwidth.
Under-fetching: Needing to make multiple requests to different endpoints to gather all required data.

This can be inefficient, especially for mobile clients or complex UIs.

GraphQL: Query Exactly What You Need

GraphQL is a query language for your API, and a server-side runtime for executing those queries.

It empowers clients to request precisely the data they need, eliminating over-fetching and under-fetching.

Think of it as filling out a form for your data request, rather than accepting a pre-defined bundle.

Defining Data with GraphQL Schema

Every GraphQL API is built around a schema. This schema defines all the types of data and operations (queries, mutations) available.

It acts as a contract between the client and the server, ensuring clients know exactly what they can ask for.

Here's a simple example:

type User {
  id: ID!
  name: String!
  email: String
  posts: [Post]
}

type Post {
  id: ID!
  title: String!
  content: String
  author: User!
}

Fetching Data with GraphQL Queries

Clients use GraphQL queries to fetch data. They specify the exact fields they want from the available types defined in the schema.

This means a single query can replace multiple REST requests.

See how we only ask for name, email, and post titles:

query GetUserAndPosts {
  user(id: "123") {
    name
    email
    posts {
      title
    }
  }
}

Changing Data with GraphQL Mutations

Just as queries fetch data, mutations are used to modify data on the server. This includes creating, updating, or deleting records.

Mutations also return data, often the newly created or updated object, confirming the change.

Here's an example to create a new post:

mutation CreatePost($title: String!, $authorId: ID!) {
  createPost(title: $title, authorId: $authorId) {
    id
    title
  }
}

gRPC: High-Performance RPC

gRPC (Google Remote Procedure Call) is an open-source framework for high-performance communication between services.

Unlike GraphQL, gRPC is more commonly used for internal microservice communication where speed, efficiency, and strict contracts are paramount.

It's built on HTTP/2 for transport and Protocol Buffers for message serialization.

Protocol Buffers: gRPC's IDL

gRPC uses Protocol Buffers (Protobuf) as its Interface Definition Language (IDL) and its underlying message interchange format.

Protobuf defines the structure of your data and the service interfaces in a language-agnostic way.

This definition is then used to generate client and server code in various languages.

syntax = "proto3";

package greeter;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

gRPC: Binary, HTTP/2, Streaming

Key features of gRPC for high performance:

HTTP/2: Enables multiplexing (multiple requests over one connection) and bidirectional streaming.
Binary Serialization: Protobuf serializes data into a compact binary format, which is faster and smaller than JSON.
Code Generation: Automatically generates client and server stub code from .proto definitions, simplifying development.

Choosing Between GraphQL & gRPC

When to use which?

GraphQL: Ideal for flexible, client-facing APIs where clients need to define their data requirements. Excellent for mobile apps and complex UIs.
gRPC: Best for high-performance, low-latency inter-service communication (e.g., microservices), or when strict contracts and efficient data transfer are critical.

They solve different problems and can even be used together in a larger system!

Quick Check: API Styles

Consider a scenario where you are building a new mobile application with a complex UI that needs to fetch varied data from a backend with minimal network requests. Which API style would be most suitable for the client-server communication?

Recap: Flexible & Fast APIs

In this lesson, we explored two powerful API alternatives: GraphQL and gRPC.

GraphQL provides a flexible query language, allowing clients to fetch precisely the data they need, tackling over- and under-fetching issues.
gRPC offers a high-performance, binary communication framework, ideal for efficient inter-service communication using HTTP/2 and Protocol Buffers.

Understanding their strengths helps you choose the right tool for different system design challenges.

Często zadawane pytania

Czy lekcja „GraphQL i gRPC” jest bezpłatna?

Tak — pełny tekst „GraphQL i gRPC” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu System Design Basics for Backend Developers, przejdź na CoddyKit PRO. Kurs System Design Basics for Backend Developers zawiera 4 lekcji w sumie.

Co nauczysz się w „GraphQL i gRPC”?

Poznaj alternatywne style API, takie jak GraphQL do elastycznego pobierania danych oraz gRPC do komunikacji o wysokiej wydajności. Ćwiczysz System Design Basics for Backend Developers z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć System Design Basics for Backend Developers?

Nie wymagamy żadnego doświadczenia. System Design Basics for Backend Developers w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „GraphQL i gRPC”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji System Design Basics for Backend Developers?

Tak. Każda lekcja System Design Basics for Backend Developers zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do System Design Basics for Backend Developers