Laravel API: crea y prueba una API en Laravel

Laravel Eloquent es una manera fácil de interactuar con su base de datos. Es un mapeador relacional de objetos (ORM) que simplifica las complejidades de las bases de datos al proporcionar un modelo para interactuar con las tablas.

Como tal, Laravel Eloquent tiene excelentes herramientas para crear y probar API para respaldar su desarrollo. En este artículo práctico, verá lo fácil que es crear y probar API usando Laravel.

En esta demostración, comenzará creando un modelo que puede usar para construir la API y la tabla de la base de datos. Luego, verá cómo agregar un controlador como una capa de lógica de negocios y una ruta para completar la API. Luego, aprenderá a realizar pruebas de API con Postman antes de centrarse finalmente en la autenticación y el manejo de errores.

requisitos previos

Para comenzar, esto es lo que necesitará:

• Laravel versión 8 o 9
• Compositor
• Cartero
• XAMPP
• Conocimientos básicos de APIs y PHP

Conceptos básicos de la API

Comienza creando un nuevo proyecto de Laravel usando <code>composer</code>:

 composer create-project laravel/laravel laravel-api-create-test

Para iniciar el servidor, ejecute el siguiente comando, que ejecuta el servidor de aplicaciones en el puerto 8000:

 cd laravel-api-create-test php artisan serve

Debería ver la siguiente pantalla:

Luego, crea un modelo con un indicador -m para la migración usando el siguiente código:

 php artisan make:model Product -m

Ahora actualice el archivo de migración para incluir el campo obligatorio. Agregue campos de título y descripción para el modelo de producto y estos dos campos de tabla dentro del archivo base de datos/migraciones/{date_stamp}_create_products_table.php .

 $table->string('title'); $table->longText('description');

El siguiente paso es hacer que estos campos se puedan completar. Dentro de app/Models/ Product.php , cree campos que se puedan completar title y description .

 protected $fillable = ['title', 'description'];

Cómo crear un controlador

Ahora, cree un archivo de controlador para el producto ejecutando el siguiente comando. Esto creará el archivo app/Http/Controllers/Api/ProductController.php .

 php artisan make:controller Api\\ProductController --model=Product

Ahora, agregue la lógica para crear y recuperar los productos. Dentro del método index , agregue el siguiente código para recuperar todos los productos:

 $products = Product::all(); return response()->json([ 'status' => true, 'products' => $products ]);

Después de eso, debe agregar una clase StoreProductRequest para almacenar los nuevos productos en la base de datos. Agregue la siguiente clase en la parte superior del mismo archivo.

 public function store(StoreProductRequest $request) { $product = Product::create($request->all()); return response()->json([ 'status' => true, 'message' => "Product Created successfully!", 'product' => $product ], 200); }

Ahora, creará la solicitud, lo que puede hacer ejecutando el siguiente comando:

 php artisan make:request StoreProductRequest

Si desea agregar validaciones, puede usar el archivo app/Http/Requests/StoreProductRequest.php . Para esta demostración, no hay validaciones.

Cómo crear una ruta

El paso final antes de probar la API es agregar una ruta. Para hacerlo, agregue el siguiente código dentro del archivo route/api.php . Agregue la declaración use al principio del archivo y la declaración Route en el cuerpo:

 use App\Http\Controllers\Api\ProductController; Route::apiResource('products', ProductController::class);

Antes de comenzar a probar la API, asegúrese de que la tabla de productos esté en su base de datos. Si no existe, cree uno usando un panel de control como XAMPP. Alternativamente, puede ejecutar el siguiente comando para migrar la base de datos:

 php artisan migrate

Cómo probar una API

Antes de probar la API, asegúrese de que el método <code>authorize</code> dentro de app/Http/Requests/StoreProductRequest.php esté configurado para devolver <code>true</code>.

Ahora, puede crear un nuevo producto usando Postman. Comience presionando una solicitud POST a esta URL: http://127.0.0.1:8000/api/products/. Debido a que es una solicitud POST para crear un nuevo producto, debe pasar un objeto JSON con un título y una descripción.

 { "title":"Apple", "description":"Best Apples of the world" }

Después de hacer clic en el botón Enviar , debería ver lo siguiente:

Ahora, obtenga los productos creados mediante la solicitud GET . La URL es la misma. Los resultados se parecerán a lo siguiente:

Cómo autenticar una API usando Sanctum

La autenticación es crucial cuando se asegura una API. Laravel lo facilita al proporcionar la funcionalidad del token Sanctum, que puede usar como middleware. Asegura la API utilizando tokens generados cuando el usuario inicia sesión con las credenciales correctas. Recuerde que los usuarios no pueden acceder a la API segura sin un token.

El primer paso para agregar autenticación es agregar un paquete de Sanctum usando el siguiente código:

 composer require laravel/sanctum

Luego, publique el archivo de configuración de Sanctum:

 php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"

Después de eso, agregue el token de Sanctum como middleware. Dentro del archivo app/Http/Kernel.php , use la siguiente clase y reemplace middlewareGroups con el siguiente código en la API de los grupos de middleware protegidos.

 use Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful;

 protected $middlewareGroups = [ 'web' => [ \App\Http\Middleware\EncryptCookies::class, \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class, \Illuminate\Session\Middleware\StartSession::class, // \Illuminate\Session\Middleware\AuthenticateSession::class, \Illuminate\View\Middleware\ShareErrorsFromSession::class, \App\Http\Middleware\VerifyCsrfToken::class, \Illuminate\Routing\Middleware\SubstituteBindings::class, ], 'api' => [ EnsureFrontendRequestsAreStateful::class, 'throttle:api', \Illuminate\Routing\Middleware\SubstituteBindings::class, ], ];

El siguiente paso es crear un UserController y agregar el código para obtener el token para autenticar.

 php artisan make:controller UserController

Después de crear el UserController , navegue hasta el archivo app/Http/Controllers/UserController.php y reemplace el código existente con el siguiente código:

 <?php namespace App\Http\Controllers; use Illuminate\Http\Request; use App\Models\User; use Illuminate\Support\Facades\Hash; class UserController extends Controller { // function index(Request $request) { $user= User::where('email', $request->email)->first(); // print_r($data); if (!$user || !Hash::check($request->password, $user->password)) { return response([ 'message' => ['These credentials do not match our records.'] ], 404); } $token = $user->createToken('my-app-token')->plainTextToken; $response = [ 'user' => $user, 'token' => $token ]; return response($response, 201); } }

Antes de poder probar la autenticación, cree un usuario que emplee seeders. El siguiente comando crea un archivo UsersTableSeeder .

 php artisan make:seeder UsersTableSeeder

Dentro del archivo base de datos/sembradoras/UsersTableSeeder.php , reemplace el código existente con el siguiente código para sembrar el usuario:

 <?php namespace Database\Seeders; use Illuminate\Database\Seeder; use Illuminate\Support\Facades\DB; use Illuminate\Support\Facades\Hash; class UsersTableSeeder extends Seeder { /** * Run the database seeds. * * @return void */ public function run() { DB::table('users')->insert([ 'name' => 'John Doe', 'email' => '[email protected]', 'password' => Hash::make('password') ]); } }

Ahora ejecuta la sembradora usando este comando:

 php artisan db:seed --class=UsersTableSeeder

El último paso que queda en el flujo de autenticación es usar el middleware creado para proteger la ruta. Navegue hasta el archivo route/api.php y agregue la ruta de productos dentro del middleware.

 use App\Http\Controllers\UserController; Route::group(['middleware' => 'auth:sanctum'], function () { Route::apiResource('products', ProductController::class); }); Route::post("login",[UserController::class,'index']);

Después de agregar una ruta al middleware, obtendrá un error de servidor interno si intenta recuperar los productos.

Pero una vez que inicie sesión, obtenga un token y lo use en el encabezado, lo autenticará y comenzará a funcionar. Puede enviar una solicitud POST a http://127.0.0.1:8000/api/login con el siguiente cuerpo:

 { "email":"[email protected]", "password":"password" }

Use el token recibido como un token de portador y agréguelo como encabezado de autorización.

Cómo manejar los errores de la API

Cada vez que envía una solicitud al servidor, responde. Con la respuesta, también envía un código de estado según la naturaleza de la respuesta. Por ejemplo, un código de estado 200 indica que la solicitud se realizó correctamente y un 404 sugiere que el servidor no puede encontrar el recurso solicitado.

Sin embargo, un código de estado no es suficiente. Se requiere un mensaje de error legible por humanos. Laravel viene con muchas formas de manejar los errores. Puede usar un bloque try-catch, el método alternativo o enviar una respuesta personalizada. El siguiente código que agregó al UserController demuestra esto.

 if (!$user || !Hash::check($request->password, $user->password)) { return response([ 'message' => ['These credentials do not match our records.'] ], 404); }

Resumen

El Eloquent Model de Laravel facilita la creación, validación y prueba de API. Su mapeo relacional de objetos proporciona un enfoque sencillo para interactuar con la base de datos.

Además, al actuar como middleware, el token Sanctum de Laravel puede ayudarlo a proteger sus API rápidamente.

Y si necesita más optimización, la solución de hospedaje de bases de datos de Kinsta simplifica la configuración y administración de bases de datos para todos sus proyectos web.