Puntos clave:
- La función de limitación de tasa de Laravel te permite controlar el número de peticiones que un usuario puede hacer a tu aplicación en un plazo determinado, protegiendo contra el abuso y garantizando la disponibilidad para los usuarios legítimos.
- Puedes implementar la limitación de velocidad utilizando el middleware de aceleración, especificando el número máximo de peticiones y la ventana de tiempo (por ejemplo, aceleración:3,10 para 3 peticiones cada 10 minutos).
- La limitación dinámica de velocidad te permite establecer límites en función de los atributos del usuario (como el nivel de suscripción), proporcionando un control granular sobre el acceso a los recursos de tu aplicación.
Una vez que el tráfico a tu API Laravel comienza a aumentar, se hace necesario poner límites a la frecuencia con la que los usuarios pueden acceder a tus puntos finales. Sin controles, una oleada de peticiones puede sobrecargar tu aplicación, abrir la puerta al abuso y ralentizarlo todo para todos.
Aquí es donde tiene sentido aplicar la limitación de velocidad. En Laravel, puedes enfocar esto de varias formas: estableciendo límites generales para todo el tráfico, aplicando reglas a rutas específicas o limitando las peticiones en función de cada usuario.
En este blog, veremos más de cerca cómo configurar cada uno de ellos en una aplicación Laravel.
Comprender la limitación de velocidad
La limitación de velocidad ayuda a controlar la frecuencia con la que los usuarios pueden acceder a tu API. Sin ella, un usuario -o un bot- podría inundar tu servidor con peticiones sin parar, consumiendo recursos y haciendo que el servicio no sea fiable para todos los demás. Establecer límites justos te permite mantener la estabilidad, evitar abusos y asegurarte de que tu API sigue respondiendo bajo carga.
¿Cuál es la diferencia entre acelerador y límite de velocidad?
El acelerador y la limitación de velocidad son dos conceptos estrechamente relacionados que se utilizan para controlar el flujo de peticiones en las aplicaciones Laravel, pero funcionan de formas distintas. El acelerador se centra en gestionar cómo se gestionan las solicitudes a lo largo del tiempo, mientras que la limitación de velocidad define límites específicos para el número de solicitudes permitidas.
La tabla siguiente ofrece una comparación clara para ayudarte a comprender sus finalidades y aplicaciones únicas.
| Acelerador | Límite de velocidad | |
| Definición | Mecanismo para controlar el flujo de peticiones a una aplicación. | El número concreto de solicitudes permitidas dentro de un plazo definido. |
| Finalidad | Garantiza un tráfico controlado y evita abusos aplicando límites de velocidad. | Establece el límite máximo de peticiones que puede realizar un usuario o IP. |
| Ámbito | Amplio: aplica límites de velocidad dinámicamente en función de la lógica de la aplicación. | Estrecho: define reglas fijas para los límites de solicitudes por usuario o dirección IP. |
| Configuración | Configurada mediante middleware (ThrottleRequests). | Definido mediante reglas específicas de limitación de velocidad en RateLimiter o middleware. |
| Ejemplo | El acelerador permite hasta 10 peticiones por minuto por usuario/IP. | El límite de velocidad establece el límite exacto de 10 peticiones por minuto. |
| Flexibilidad | Proporciona una lógica personalizable para distintos tipos de usuarios o puntos finales. | Se centra principalmente en aplicar límites estáticos o predefinidos. |
| Uso en Laravel | Implementado mediante middleware ThrottleRequests o lógica personalizada. | Configurado mediante la clase RateLimiter o el middleware por defecto de Laravel. |
¿Cómo implementar la limitación de tarifas en Laravel?
Esta guía explica cómo implementar la limitación de velocidad en Laravel, empezando por la limitación básica basada en IP y avanzando hasta la limitación de velocidad basada en usuario con autenticación Sanctum. Utilizaremos el símbolo del sistema para todas las operaciones, con dos ventanas:
Hosting Gestionado Laravel: Tu impulso al rendimiento de Laravel
Mejora tu experiencia Laravel con el hosting gestionado Laravel de Cloudways: donde la experiencia se une a un rendimiento excepcional.
- Ventana 1: Ejecución de Laravel (php artisan serve)
- Ventana 2: Ejecutar pruebas de la API (comandos curl)
Requisitos previos
Antes de empezar, asegúrate de que tienes:
- PHP 8.2+ y Composer instalados.
- Laravel 10 (instalar mediante composer global require laravel/installer).
- Una base de datos (MySQL, SQLite, etc.).
- (Opcional) Postman o cURL para probar los puntos finales de la API.
Parte 1: Limitación global de la velocidad
Crea un nuevo proyecto Laravel ejecutando el siguiente comando. Nombra tu proyecto como quieras.
laravel new laravel-rate-limiting-project
Ahora dirígete a: cd laravel-rate-limiting-project
Ahora inicia el servidor de desarrollo ejecutando este comando:
php artesano servir
A continuación, crea una ruta API de prueba
Abre routes/api.php y añade:
Route::get('/hello', function () {
return response()->json(['message' => 'Hello, World!']);
});
Ábrelo con el Bloc de notas o cualquier otro editor de texto y añade la ruta API de prueba en cualquier lugar después de las definiciones de ruta existentes en tu routes/api.php.
Guarda el archivo.
Pruébalo con cURL (en un nuevo terminal):
rizo http://127.0.0.1:8000/api/hello
Salida esperada: {«mensaje»: «¡Hola, mundo!»}
También puedo ver el mismo mensaje si visito«http://127.0.0.1:8000/api/hello» en mi navegador.
Si sigo actualizando esta URL, puedes ver que no hay limitación de velocidad aplicada a esta ruta.
Ahora vamos a ver cómo añadir la limitación de velocidad, empezando por el límite de velocidad global que se aplica a todas las rutas API.
Antes de empezar…vamos a ver todos los endpoints de nuestro proyecto laravel ejecutando:
php artisan ruta:lista
En la captura de pantalla anterior, puedo ver la nueva ruta API que hemos creado, «api/hola«.
En Laravel, la limitación de velocidad para las rutas API se define en el archivo Kernel.php.
Para establecer un límite de velocidad global para todas las rutas API, edita app/Http/Kernel.php y actualiza el grupo api middleware a:
'api' => [ \Illuminate\Routing\Middleware\ThrottleRequests::class.':3,1', ],
Esto permitirá 3 peticiones por minuto por dirección IP.
Sustituye el código que te he proporcionado arriba por el código por defecto del archivo, como en la imagen. No olvides guardar el archivo.
Ahora, si actualizo«http://127.0.0.1:8000/api/hello » más de 3 veces rápidamente, veré un error de «Demasiadas solicitudes».
Pero recuerda que la limitación de velocidad que hemos implementado es global, por lo que se aplica a todas las rutas. Así que si creo otra ruta en el archivo routes/api.php y pruebo la nueva ruta, también me dará el error «Demasiadas solicitudes».
Ésta es la nueva ruta que declaré:
Route::get('/second', function () {
return response()->json(['message' => 'second route']);
});
Y ahora, si visito«http://127.0.0.1:8000/api/second» y actualizo rápidamente 4 veces, veo el error.
Libera el potencial de Laravel con el hosting Laravel de Cloudways
Alojamiento Laravel llevado al siguiente nivel – El alojamiento gestionado de Cloudways ofrece una velocidad y fiabilidad insuperables.
Parte 2: Limitación de la velocidad específica de la ruta
Para aplicar un límite personalizado en una ruta concreta, utiliza el middleware de aceleración directamente en routes/api.php:
Por ejemplo:
Route::middleware('throttle:3,1')->get('/limited', function () {
return response()->json(['message' => 'You can only call this 3 times per minute!']);
});
Esto permite 3 peticiones por minuto a /api/limited por IP.
Abre routes/api.php y añade lo siguiente al final (o en cualquier parte dentro del archivo):
Route::middleware('throttle:3,1')->get('/limited', function () {
return response()->json(['message' => 'You can only call this 3 times per minute!']);
});
Así:
Podemos probarlo con: curl http://127.0.0.1:8000/api/limited
Si ejecutas el mismo comando 4 veces, aparecerá este mensaje «Demasiados Intentos».
Como vemos, ahora la limitación de velocidad se aplica a la ruta «/limitada».
Ahora vamos a ver cómo aplicar la limitación de tarifa a un usuario concreto.
Parte 3: Limitación de la tarifa basada en el usuario
Hasta ahora, hemos configurado un proyecto Laravel, hemos cubierto los límites de tarifa globales y específicos de ruta, y hemos puesto en marcha lo básico. Ahora, vamos a subir el nivel y controlar cuántas solicitudes puede hacer cada usuario autenticado, lo que resulta especialmente útil cuando quieres ofrecer acceso por niveles (como usuarios gratuitos frente a usuarios premium).
A diferencia de los límites basados en la IP, que estrangulan el tráfico independientemente de quién lo envíe, el estrangulamiento basado en el usuario rastrea el uso por cuenta autenticada. Esto es perfecto cuando quieres, por ejemplo, que a un usuario gratuito sólo se le permitan 3 llamadas a la API por minuto, mientras que un usuario premium puede hacer 60.
Configurar una tabla de usuarios simple
Para este tutorial, estoy utilizando SQLite porque es rápido, está basado en archivos y no necesita configuración del servidor. También puedes utilizar MySQL o Postgres, sólo tienes que actualizar tu .env en consecuencia.
Primero, configura el archivo .env:
DB_CONNECTION=sqlite
Asegúrate de eliminar cualquier otra línea DB_* relacionada con el host, el puerto, el nombre de usuario, etc.
A continuación, crea el archivo de la base de datos:
type nul > database\database.sqlite
Esto creará un archivo database.sqlite vacío en la carpeta de la base de datos.
Y ejecuta las migraciones para crear las tablas por defecto:
php migrar artesano
Añadir un par de usuarios mediante Tinker
Utilizaremos Laravel Tinker para insertar un par de usuarios: uno normal y otro premium.
php artesano calderero
Entonces corre:
User::create([ 'name' => 'Test User', 'email' => '[email protected]', 'password' => bcrypt('password123') ]); User::create([ 'name' => 'Premium User', 'email' => '[email protected]', 'password' => bcrypt('password123') ]);
Sal del Tinker utilizando Ctrl + Ct.
Instalar Sanctum para la autenticación API
Necesitaremos autenticación para distinguir entre usuarios. Laravel Sanctum es perfecto para la gestión ligera de tokens de API.
composer require laravel/sanctum
A continuación, publica los archivos de configuración y migración de Sanctum:
php artisan vendor:publish –provider=»Laravel\Sanctum\SanctumServiceProvider»
php migrar artesano
A continuación, conecta Sanctum a tu pila de middleware de API. Abre app/Http/Kernel.php y busca el grupo api middleware. Sustitúyelo así
'api' => [ \Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful::class, 'throttle:api', \Illuminate\Routing\Middleware\SubstituteBindings::class, ],
Definir límites de tarifa basados en el usuario
Abre app/Providers/RouteServiceProvider.php y busca el método configureRateLimiting(). Si no está ahí, créalo dentro de la clase.
Añade la siguiente lógica:
protected function configureRateLimiting() { // Default API rate limit (can keep or adjust as needed) RateLimiter::for('api', function (Request $request) { return Limit::perMinute(60)->by($request->user()?->id ?: $request->ip()); }); // Standard user: 3 requests per minute RateLimiter::for('user', function (Request $request) { return Limit::perMinute(3)->by(optional($request->user())->id ?: $request->ip()); }); // Premium user: 6 requests per minute RateLimiter::for('premium', function (Request $request) { return $request->user() && $request->user()->email === '[email protected]' ? Limit::perMinute(6)->by($request->user()->id) : Limit::perMinute(3)->by(optional($request->user())->id ?: $request->ip()); }); }
Esta lógica establece 3 peticiones/minuto para los usuarios normales y 6 peticiones/minuto para los usuarios premium.
Puedes sustituir todo el código de tu archivo por esto si no sabes cómo añadir este código a tu archivo:
<?php
namespace App\Providers;
use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Foundation\Support\Providers\RouteServiceProvider as ServiceProvider;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\RateLimiter;
use Illuminate\Support\Facades\Route;
class RouteServiceProvider extends ServiceProvider
{
/**
* The path to the "home" route for your application.
*
* Typically, users are redirected here after authentication.
*
* @var string
*/
public const HOME = '/home';
/**
* Define your route model bindings, pattern filters, and other route configuration.
*
* @return void
*/
public function boot()
{
$this->configureRateLimiting();
$this->routes(function () {
Route::middleware('api')
->prefix('api')
->group(base_path('routes/api.php'));
Route::middleware('web')
->group(base_path('routes/web.php'));
});
}
/**
* Configure the rate limiters for the application.
*
* @return void
*/
protected function configureRateLimiting()
{
// Global API rate limit (fallback)
RateLimiter::for('api', function (Request $request) {
return Limit::perMinute(60)->by($request->user()?->id ?: $request->ip());
});
// Standard user rate limit (3 requests/minute)
RateLimiter::for('user', function (Request $request) {
return Limit::perMinute(3)->by($request->user()?->id ?: $request->ip());
});
// Premium user rate limit (6 requests/minute)
// Premium user rate limit (6 requests/minute)
RateLimiter::for('premium', function (Request $request) {
return $request->user() && $request->user()->email === '[email protected]'
? Limit::perMinute(6)->by($request->user()->id)
: Limit::perMinute(3)->by($request->user()?->id ?: $request->ip());
});
}
}
Ahora que has configurado los limitadores de velocidad, puedes aplicar la nueva lógica de limitación de velocidad a tus rutas API. Para ello, utiliza el middleware de aceleración en tu archivo routes/api.php.
Modificar routes/api.php
Utilizarás el middleware throttle:user para los usuarios normales, y el middleware throttle:premium para los usuarios premium.
Ejemplo de cómo aplicar limitadores de tarifa a las rutas:
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Route;
// Public route (no rate limit)
Route::get('/public', function () {
return ['message' => 'Unlimited access'];
});
// Login route
Route::post('/login', function (Request $request) {
$credentials = $request->validate([
'email' => 'required|email',
'password' => 'required'
]);
if (!Auth::attempt($credentials)) {
return response()->json(['error' => 'Unauthorized'], 401);
}
return [
'token' => $request->user()->createToken('api')->plainTextToken
];
});
// Protected route with user-based rate limiting (3 requests/minute)
Route::middleware(['auth:sanctum', 'throttle:user'])->get('/protected', function () {
return [
'message' => 'Protected content (3 requests/min)',
'user' => auth()->user()->only(['id', 'name', 'email'])
];
});
// Premium route with premium user-based rate limiting (6 requests/minute for premium users)
Route::middleware(['auth:sanctum', 'throttle:premium'])->get('/premium', function () {
return [
'message' => 'Premium content (6 requests/min)',
'user' => auth()->user()->only(['id', 'name', 'email'])
];
});
No dudes en copiar y pegar todo el código siguiente en tu archivo:
<?php
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
/*
|--------------------------------------------------------------------------
| API Routes
|--------------------------------------------------------------------------
|
| Here is where you can register API routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| is assigned the "api" middleware group. Enjoy building your API!
|
*/
// Public route (no rate limit)
Route::get('/hello', function () {
return response()->json(['message' => 'Hello, World!']);
});
// Another public route (no rate limit)
Route::get('/second', function () {
return response()->json(['message' => 'second route']);
});
// Route for user details (requires authentication)
Route::middleware('auth:sanctum')->get('/user', function (Request $request) {
return $request->user();
});
// Protected route with user-based rate limiting (3 requests/minute)
Route::middleware(['auth:sanctum', 'throttle:user'])->get('/protected', function () {
return response()->json(['message' => 'Protected content (3 requests/min)', 'user' => auth()->user()]);
});
// Route for premium users with higher rate limiting (6 requests/minute)
Route::middleware(['auth:sanctum', 'throttle:premium'])->get('/premium', function () {
return response()->json(['message' => 'Premium content (6 requests/min)', 'user' => auth()->user()]);
});
// Test route with custom rate limit (3 requests/minute for normal users)
Route::middleware('throttle:3,1')->get('/limited', function () {
return response()->json(['message' => 'You can only call this 3 times per minute!']);
});
Esto es lo que ocurre en el archivo:
- Las rutas públicas /hola y /segundo que hemos creado antes están abiertas a todo el mundo, sin inicio de sesión ni límites.
- /protegido utiliza throttle:usuario → 3 peticiones/minuto para usuarios normales.
- /premium utiliza throttle:premium → 6 peticiones/minuto para usuarios premium.
Prueba la limitación de velocidad
Después de añadir las rutas, puedes probarlas para asegurarte de que la limitación de velocidad funciona correctamente. Primero, consigue tokens para ambos usuarios:
Para usuarios normales ([email protected]):
Después de añadir las rutas, puedes probarlas para asegurarte de que la limitación de velocidad funciona correctamente. Primero, consigue tokens para ambos usuarios:
Para usuarios normales ([email protected]):
curl -X POST http://127.0.0.1:8000/api/login ^
-H "Content-Type: application/json" ^
-d "{\"email\":\"[email protected]\",\"password\":\"password123\"}"
Para usuario premium ([email protected]):
curl -X POST http://127.0.0.1:8000/api/login ^
-H "Content-Type: application/json" ^
-d "{\"email\":\"[email protected]\",\"password\":\"password123\"}"
Ejecutar ambos me da dos fichas:
Ahora vamos a probar la limitación de velocidad para ambos usuarios, «estándar» y «premium». Recuerda, 3 peticiones/min para estándar y 6 peticiones/min para premium.
Para ver nuestro limitador de velocidad basado en el usuario en acción, podemos modificar nuestro archivo Handler.php de la siguiente manera para obtener un mensaje de error en JSON en lugar de HTML.
He aquí cómo hacerlo:
Edita app/Exceptions/Handler.php:
<?php
namespace App\Exceptions;
use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
use Illuminate\Http\Exceptions\ThrottleRequestsException;
use Throwable;
class Handler extends ExceptionHandler
{
// ... other code ...
public function render($request, Throwable $exception)
{
// Convert throttle exceptions to JSON responses
if ($exception instanceof ThrottleRequestsException) {
return response()->json([
'error' => 'rate_limit_exceeded',
'message' => 'Too many requests. Please try again later.',
'retry_after' => $exception->getHeaders()['Retry-After'] ?? 60,
'limit' => $this->getRateLimitFromException($exception),
], 429);
}
return parent::render($request, $exception);
}
protected function getRateLimitFromException(ThrottleRequestsException $exception)
{
// Extract rate limit info from exception message
if (preg_match('/\d+/', $exception->getMessage(), $matches)) {
return (int)$matches[0];
}
return null;
}
}
Guarda el archivo.
Ahora prueba el límite de velocidad para el usuario estándar ejecutando el comando que aparece a continuación 4 veces. Al 4º intento, obtendrás un error que dirá Demasiadas peticiones. Vuelve a intentarlo más tarde.
rizar http://127.0.0.1:8000/api/standard ^
-H «Autorización: Portador 16|tCDoWhoAVI4YfjRJIZHNyOr0svCADEEFYfzIILYq70a259b6»
Para el usuario Premium, verás el mismo error en tu 7ª solicitud.
rizar http://127.0.0.1:8000/api/premium ^
-H «Autorización: Portador 17|9pBNtUebEeZPKCKti6xaRdFZPdLFXazI18Jl5RKrd91e43f0»
Y ya está. Así funciona la limitación de la tasa API basada en el usuario.
Deja de perder el tiempo con los servidores
Cloudways se encarga de gestionar los servidores por ti para que puedas centrarte en crear grandes aplicaciones y mantener contentos a tus clientes.
¡Terminando!
Añadir una limitación de velocidad a tu API de Laravel es una forma inteligente de mantener la fluidez sin dejar que el tráfico intenso colapse tu aplicación. Es como poner una regla de «uno a la vez» para que todos tengan un turno justo.
Esto es lo que repasamos:
Límites básicos de tarifa – Establecer un tope sencillo para todas las solicitudes API
Límites personalizados por ruta – Permitir que ciertos puntos finales tengan sus propias reglas
Controles específicos de usuario – Dar diferentes niveles de acceso a los usuarios normales frente a los premium
Estos pasos ayudan a equilibrar la carga, frenar el abuso y garantizar que tu API siga siendo rápida para todos.
¿Estás atascado en algún sitio? Deja un comentario: ¡te ayudaré encantado!
Abdul Rehman
Abdul es un experto en tecnología, aficionado al café y al marketing creativo al que le encanta estar al día de las últimas actualizaciones de software y aparatos tecnológicos. También es un hábil escritor técnico capaz de explicar conceptos complejos de forma sencilla para un público amplio. Abdul disfruta compartiendo sus conocimientos sobre el sector de la Nube a través de manuales de usuario, documentación y entradas de blog.
