REST, RPC y GraphQL
- Lección 20 de 40
- 11 min
- Inicial
- 10 pasos
Tu app necesita datos que viven en tus servidores. Cómo se los pide decide cuántos viajes hace, cuántos bytes baja y qué se rompe cuando la API cambia.
- Viajes por pantalla
- 1
- KB descargados
- 4
- Pantalla lista
- 125 ms
- Datos sin usar
- 0%
- petición
- respuesta
- petición lenta
- esperando en cola
Paso 1 de 10
Concepto
Dos programas necesitan un acuerdo
Tu app móvil abre la pantalla de un perfil: nombre, foto, las tres últimas publicaciones y cuántos seguidores tiene. Esos datos están en tus servidores, así que la app tiene que pedirlos.
Una API es el acuerdo sobre cómo pedirlos: qué direcciones existen, qué se envía y qué forma tiene la respuesta. Aquí viaja como JSON sobre HTTPS.
Paso 2 de 10
Técnica
REST: recursos con dirección y verbos HTTP
REST organiza los datos como recursos con su propia URL (/users/42, /users/42/posts) y usa los verbos de HTTP sobre ellos: GET lee, POST crea, PUT o PATCH modifican y DELETE borra.
Lo entiende cualquier herramienta, y los navegadores y las CDN pueden cachear las respuestas de GET. Además GET, PUT y DELETE son idempotentes: repetirlos deja el mismo resultado. POST no lo es, y eso importa cuando el cliente reintenta.
En una red rápida (≈ 40 ms por ida y vuelta, más ≈ 20 ms de servidor por llamada) la pantalla tarda 3 × 60 = 180 ms. Las cifras de esta lección son valores de ejemplo.
Qué cambió
- Tres endpoints para la pantalla de perfil
Paso 3 de 10
Problema
Demasiados viajes y demasiados bytes
En el móvil cada ida y vuelta cuesta unos 100 ms. La app hace sus tres llamadas en fila, a menudo porque una necesita un dato de la anterior: 3 × (100 + 20) = 360 ms antes de pintar nada.
Y cada endpoint devuelve el objeto completo: bajan 60 KB para mostrar unos 4 KB, así que el 93 % no se usa. Recibir de más se llama over-fetching; necesitar varias llamadas para una pantalla, under-fetching.
Qué cambió
- Red: 4G, ≈ 100 ms por ida y vuelta
- Pantalla lista: 180 → 360 ms
- El 93 % de lo descargado no se usa
Paso 4 de 10
Solución
GraphQL: describe la forma exacta que quieres
Con GraphQL la app manda una sola consulta que describe los campos que necesita. El servidor GraphQL reparte el trabajo entre los servicios que tiene detrás y devuelve solo esos campos.
Sigue el paquete: sale del móvil, se divide hacia Users y Posts en paralelo y vuelve como una única respuesta. Un viaje de 100 ms más ≈ 40 ms en el servidor: 140 ms y ≈ 4 KB.
Qué cambió
- API REST → endpoint GraphQL
- Servicios Users y Posts detrás
- 3 viajes → 1
- 60 KB → 4 KB
Paso 5 de 10
Compromiso
Una consulta flexible puede salir carísima
El cliente puede pedir todo lo que permita el esquema, también los seguidores de los seguidores con sus publicaciones. Con 150 seguidores por persona son 150 + 22.500 perfiles y 22.500 listas de posts: unas 45.000 consultas para una sola petición.
Además las consultas suelen ir por POST a una única URL, así que las cachés HTTP y las CDN no ayudan sin trabajo extra, como las consultas persistidas.
Qué cambió
- Una consulta anidada tres niveles
- Servicio Users al 98 %
Paso 6 de 10
Técnica
Dentro del centro de datos: RPC
Detrás de la API, los servicios se llaman entre sí todo el tiempo. Ahí lo habitual es RPC (llamada a procedimiento remoto): invocar una función de otra máquina como si fuera local. Hoy suele ser gRPC.
El contrato es un esquema tipado en Protocol Buffers; de él se genera el código de cliente y servidor, y los mensajes viajan en binario compacto sobre HTTP/2. En el ejemplo, las llamadas internas bajan de ≈ 40 a ≈ 25 ms: 100 + 25 = 125 ms.
Qué cambió
- API → servicios: gRPC + Protocol Buffers
Paso 7 de 10
Técnica
Caso: una lista de 3 millones
Una cuenta famosa tiene 3 millones de seguidores. Con unos 100 bytes por seguidor, devolverlos de golpe serían ≈ 300 MB. Las listas largas se sirven por páginas.
Con offset=30000 y limit=20 (la página 1.501), la base de datos lee y descarta 30.000 filas antes de dar las 20 que pides. Con un cursor («los 20 siguientes a c81e») salta directa por el índice, y no repite ni se salta elementos cuando entran seguidores nuevos.
Qué cambió
- Seguidores de 20 en 20
- Paginación con cursor
Paso 8 de 10
Problema
Caso: renombrar un campo rompe apps viejas
Alguien ordena el esquema y renombra name a fullName. La app nueva funciona, pero miles de móviles siguen con la versión 4.1 y su pantalla de perfil se cierra al no encontrar name.
No puedes obligar a nadie a actualizar. Por eso las APIs crecen sumando: añade el campo nuevo, conserva el viejo y retíralo cuando casi nadie lo use. En GraphQL se marca con @deprecated; en REST, un cambio incompatible va en una versión nueva (/v2) que convive con /v1.
Qué cambió
- Las apps antiguas se cierran
- Arreglo: conservar name y añadir fullName
- /v2 para cambios incompatibles
Paso 9 de 10
Compromiso
¿Cuál usar y dónde?
El panel resume dónde encaja cada estilo y qué vigilar. No compiten: se combinan.
Lo habitual es REST o GraphQL hacia fuera, para las apps y los clientes, y gRPC hacia dentro, entre servicios.
Paso 10 de 10
Resumen
Resumen
Una API es un contrato entre programas.
REST: recursos y verbos HTTP; simple y cacheable, pero con muchas llamadas en pantallas ricas.
GraphQL: una consulta con los campos exactos; limita la profundidad y el coste.
gRPC: llamadas rápidas y tipadas entre servicios internos.
Pagina las listas largas con cursores y haz crecer la API sumando, sin romper.
← → paso · R repetir · Espacio pausa
Aprenderás
- Entender una API como un contrato (visto)
- Diseñar recursos y verbos con REST (visto)
- Pedir solo los campos que necesitas con GraphQL (visto)
- Conectar servicios internos con RPC (visto)
- Paginar listas largas y evolucionar una API sin romperla (visto)