REST API vs GraphQL vs gRPC: Elegir el Protocolo Adecuado para Aplicaciones Móviles

Elegir el protocolo API adecuado para aplicaciones móviles es crucial para el rendimiento, la duración de la batería y la experiencia del usuario. Comprender tanto los fundamentos de testing móvil como el dominio del testing de APIs es esencial para tomar las decisiones arquitectónicas correctas. En esta guía completa, compararemos REST, GraphQL y gRPC para ayudarte a tomar una decisión informada.

Comprendiendo los Tres Protocolos

REST (Representational State Transfer)

REST ha sido el estándar de facto para APIs web durante más de dos décadas. Utiliza métodos HTTP (GET, POST, PUT, DELETE) y devuelve datos en formato JSON o XML.

Características clave:

Arquitectura basada en recursos
Comunicación sin estado
Herramientas y ecosistema bien establecidos
Mecanismos de caché simples

GraphQL

Desarrollado por Facebook (ahora Meta) en 2012 y de código abierto en 2015, GraphQL proporciona un lenguaje de consulta para tu API, permitiendo a los clientes solicitar exactamente lo que necesitan.

Características clave:

Endpoint único para todas las operaciones
Obtención de datos dirigida por el cliente
Sistema de tipado fuerte
Reducción de sobre-fetching y under-fetching

gRPC

Creado por Google, gRPC (gRPC Remote Procedure Call) utiliza Protocol Buffers (protobuf) para serialización y HTTP/2 para transporte.

Características clave:

Protocolo binario (más eficiente que JSON)
Generación de código incorporada
Soporte para streaming bidireccional
Aplicación estricta de contratos

Comparación de Rendimiento

Tamaño de Carga de Red

Escenario: Obtener perfil de usuario con 10 campos

Respuesta REST JSON: ~850 bytes
{
  "id": 12345,
  "username": "juan_perez",
  "email": "juan@ejemplo.com",
  "firstName": "Juan",
  "lastName": "Pérez",
  "avatar": "https://cdn.ejemplo.com/avatar.jpg",
  "bio": "Ingeniero de software",
  "location": "Madrid",
  "joinedDate": "2020-05-15T10:30:00Z",
  "followers": 1234
}

Respuesta GraphQL (campos selectivos): ~420 bytes
{
  "data": {
    "user": {
      "username": "juan_perez",
      "avatar": "https://cdn.ejemplo.com/avatar.jpg",
      "followers": 1234
    }
  }
}

Respuesta gRPC Protobuf: ~180 bytes (formato binario)

Tabla Comparativa de Protocolos

Característica	REST	GraphQL	gRPC
Formato de Carga	JSON/XML	JSON	Binario (Protobuf)
Tamaño Promedio	Línea base	30-50% menor	60-80% menor
Número de Peticiones	Múltiples (problema N+1)	Única	Única (streaming)
Seguridad de Tipos	Tiempo de ejecución	Basado en esquema	Tiempo de compilación
Impacto en Batería Móvil	Moderado	Bajo-Moderado	Bajo
Curva de Aprendizaje	Fácil	Moderada	Pronunciada
Soporte de Navegador	Completo	Completo	Limitado (gRPC-Web)

Consideraciones Específicas para Móviles

Consumo de Batería

Los dispositivos móviles tienen batería limitada, haciendo crítica la comunicación de red eficiente.

Impacto de REST en Batería:

// Ejemplo Android: Múltiples llamadas REST
class UserRepository {
    suspend fun getUserData(userId: String): UserData {
        // 3 peticiones de red separadas = 3 activaciones de radio
        val profile = api.getUserProfile(userId)     // ~300ms
        val posts = api.getUserPosts(userId)         // ~250ms
        val followers = api.getUserFollowers(userId) // ~200ms

        // Total: ~750ms de tiempo de radio activo
        return UserData(profile, posts, followers)
    }
}

Impacto de GraphQL en Batería:

// Una consulta GraphQL reduce las activaciones de radio
class UserRepository {
    suspend fun getUserData(userId: String): UserData {
        val query = """
            query GetUserData(${"$"}userId: ID!) {
                user(id: ${"$"}userId) {
                    profile { name, avatar }
                    posts { id, title }
                    followers { count }
                }
            }
        """
        // Petición única = 1 activación de radio (~400ms)
        return graphqlClient.query(query, mapOf("userId" to userId))
    }
}

Impacto de gRPC en Batería:

// gRPC streaming mantiene conexión abierta eficientemente
class UserRepository {
    fun getUserUpdates(userId: String): Flow<UserUpdate> {
        return grpcClient.getUserUpdateStream(userId)
            // Multiplexación HTTP/2 reduce overhead
            // Formato binario reduce uso de CPU en parsing
    }
}

Resiliencia de Red

Las redes móviles son poco fiables. Diferentes protocolos manejan la conectividad pobre de manera diferente.

Lógica de Reintentos REST:

// Ejemplo iOS: Implementación de reintentos REST
class APIClient {
    func fetchData<T: Decodable>(
        endpoint: String,
        retries: Int = 3
    ) async throws -> T {
        var lastError: Error?

        for attempt in 1...retries {
            do {
                let (data, response) = try await URLSession.shared.data(
                    from: URL(string: endpoint)!
                )

                guard let httpResponse = response as? HTTPURLResponse,
                      (200...299).contains(httpResponse.statusCode) else {
                    throw APIError.invalidResponse
                }

                return try JSONDecoder().decode(T.self, from: data)
            } catch {
                lastError = error
                if attempt < retries {
                    try await Task.sleep(nanoseconds: UInt64(pow(2.0, Double(attempt)) * 1_000_000_000))
                }
            }
        }

        throw lastError ?? APIError.unknown
    }
}

Reintentos Integrados en gRPC:

// gRPC tiene políticas de reintento integradas
let channel = ClientConnection
    .insecure(group: eventLoopGroup)
    .withConnectionRetryPolicy(
        .exponentialBackoff(
            initial: .seconds(1),
            maximum: .seconds(30),
            multiplier: 2
        )
    )
    .connect(host: "api.ejemplo.com", port: 50051)

Recomendaciones de Casos de Uso

Elige REST cuando:

Operaciones CRUD simples: Patrones de acceso a datos directos
APIs públicas: Máxima compatibilidad y facilidad de integración
Requisitos de caché pesado: Aprovechar cabeceras de caché HTTP
Familiaridad del equipo: Experiencia existente en REST

Ejemplo: Catálogo de productos e-commerce

GET /api/productos?categoria=electronica&pagina=1&limite=20
GET /api/productos/123
POST /api/carrito/items
DELETE /api/carrito/items/456

Elige GraphQL cuando:

Requisitos de datos complejos: Relaciones anidadas y obtención selectiva de campos
Múltiples tipos de clientes: Diferentes apps móviles necesitan diferentes subconjuntos de datos
Iteración rápida: Equipos frontend necesitan flexibilidad sin cambios en backend
Optimización de ancho de banda: Crítico para mercados emergentes con datos caros

Ejemplo: Feed de redes sociales

query GetFeed($userId: ID!, $limit: Int!) {
  user(id: $userId) {
    feed(limit: $limit) {
      posts {
        id
        author {
          username
          avatar
        }
        content
        likes {
          count
        }
        comments(limit: 3) {
          text
          author { username }
        }
      }
    }
  }
}

Elige gRPC cuando:

Comunicación de microservicios: Llamadas internas servicio-a-servicio
Características en tiempo real: Chat, actualizaciones en vivo, streaming de datos
Aplicaciones críticas de rendimiento: Requisitos de baja latencia
Necesidades de tipado fuerte: Validación de contrato en tiempo de compilación

Ejemplo: Aplicación de chat en tiempo real

service ChatService {
  rpc SendMessage(Message) returns (MessageAck);
  rpc StreamMessages(ChatRoom) returns (stream Message);
  rpc TypingIndicator(stream TypingStatus) returns (stream TypingStatus);
}

message Message {
  string message_id = 1;
  string chat_room_id = 2;
  string user_id = 3;
  string content = 4;
  int64 timestamp = 5;
}

Ejemplos de Implementación

Implementación REST (Swift/iOS)

import Foundation

struct Product: Codable {
    let id: String
    let name: String
    let price: Double
    let imageURL: String
}

class RESTClient {
    private let baseURL = "https://api.ejemplo.com"

    func fetchProducts(category: String) async throws -> [Product] {
        let url = URL(string: "\(baseURL)/productos?categoria=\(category)")!
        let (data, _) = try await URLSession.shared.data(from: url)
        return try JSONDecoder().decode([Product].self, from: data)
    }

    func fetchProductDetails(id: String) async throws -> Product {
        let url = URL(string: "\(baseURL)/productos/\(id)")!
        let (data, _) = try await URLSession.shared.data(from: url)
        return try JSONDecoder().decode(Product.self, from: data)
    }
}

Implementación GraphQL (Kotlin/Android)

import com.apollographql.apollo3.ApolloClient
import com.apollographql.apollo3.api.Optional

class GraphQLClient {
    private val apolloClient = ApolloClient.Builder()
        .serverUrl("https://api.ejemplo.com/graphql")
        .build()

    suspend fun fetchUserFeed(userId: String, limit: Int): FeedData {
        val response = apolloClient.query(
            GetFeedQuery(
                userId = userId,
                limit = Optional.present(limit)
            )
        ).execute()

        return response.data?.user?.feed ?: throw Exception("Sin datos")
    }
}

// Consulta GraphQL
"""
query GetFeed($userId: ID!, $limit: Int) {
  user(id: $userId) {
    feed(limit: $limit) {
      posts {
        id
        content
        author {
          username
          avatar
        }
      }
    }
  }
}
"""

Implementación gRPC (Kotlin/Android)

import io.grpc.ManagedChannelBuilder
import kotlinx.coroutines.flow.Flow

class GrpcClient {
    private val channel = ManagedChannelBuilder
        .forAddress("api.ejemplo.com", 50051)
        .useTransportSecurity()
        .build()

    private val chatStub = ChatServiceGrpc.newStub(channel)

    fun streamMessages(chatRoomId: String): Flow<Message> = flow {
        val request = ChatRoom.newBuilder()
            .setChatRoomId(chatRoomId)
            .build()

        chatStub.streamMessages(request).collect { message ->
            emit(message)
        }
    }

    suspend fun sendMessage(
        chatRoomId: String,
        userId: String,
        content: String
    ): MessageAck {
        val message = Message.newBuilder()
            .setChatRoomId(chatRoomId)
            .setUserId(userId)
            .setContent(content)
            .setTimestamp(System.currentTimeMillis())
            .build()

        return chatStub.sendMessage(message)
    }
}

Consideraciones de Testing

Testing REST

Mocking HTTP fácil con herramientas como WireMock, MockWebServer
Amplio soporte de Postman/Insomnia
Testing de contratos simple con OpenAPI/Swagger
Para estrategias completas de testing REST API, explora las mejores prácticas de REST Assured

Testing GraphQL

Introspección de esquema para validación
Análisis de complejidad de consultas
Herramientas: GraphQL Playground, Apollo Studio

Testing gRPC

Validación de contrato Protobuf en tiempo de compilación
Herramientas: grpcurl, BloomRPC
Interceptores para testing de middleware
Aprende más sobre técnicas y herramientas de testing gRPC

Benchmarks de Rendimiento

Mediciones de app móvil real (Android, red 4G):

Test: Cargar perfil de usuario + 20 posts + comentarios

REST API:
- Peticiones: 3 (perfil, posts, comentarios)
- Tiempo total: 1,240ms
- Datos transferidos: 145KB
- Consumo de batería: 0.8% por 100 peticiones

GraphQL:
- Peticiones: 1
- Tiempo total: 680ms
- Datos transferidos: 68KB
- Consumo de batería: 0.4% por 100 peticiones

gRPC:
- Peticiones: 1 (streaming)
- Tiempo total: 420ms
- Datos transferidos: 38KB
- Consumo de batería: 0.3% por 100 peticiones

Conclusión

No hay una solución única para todos:

REST sigue siendo excelente para APIs públicas simples y cacheables
GraphQL sobresale cuando la flexibilidad frontend y la optimización de ancho de banda son prioridades
gRPC es ideal para arquitecturas críticas de rendimiento, tiempo real o microservicios

Considera la experiencia de tu equipo, infraestructura y requisitos específicos del caso de uso. Muchas aplicaciones modernas usan un enfoque híbrido, aprovechando diferentes protocolos para diferentes características.

Marco de Decisión:

Comienza con REST para MVP y APIs públicas
Migra a GraphQL cuando la complejidad de datos aumenta
Usa gRPC para características en tiempo real y servicios internos
Monitorea métricas: tamaño de carga, número de peticiones, impacto en batería

El mejor protocolo es el que equilibra rendimiento, experiencia del desarrollador y carga de mantenimiento para tu aplicación móvil específica.