API REST en Laravel 8 con autenticación JWT

Laravel es un framework de PHP increible, pero tal vez te has preguntado como usarlo de Backend para que otras aplicaciones puedan obtener información de nuestra aplicación, o simplemente, deseas crear un Frontend que consuma los recursos de la API REST.

De ahí que surja la duda, ¿Cómo hago para autenticar los usuarios?

La solución es JWT.

Si todavía no conoces como funciona Laravel o qué es Laravel, te recomiendo ver el Curso de PHP con Laravel.

JWT te permite retornar un token de autenticación que te identificará como usuario del sistema, que se guardará del lado del navegador (localStorage, sessionStorage, cookies, Redux, etc…).

Una vez que ya entendiste la idea, manos a la obra.

NOTA: No es necesario realizar estos pasos si tu proyecto de Laravel ya está creado.

Lo primero que debemos hacer es tener instalado el gestor de dependencias de PHP composer.

Aquí te dejo un link para que puedas instalarlo sin problemas, en la versión de Ubuntu.

Para otras sistemas operativos, te recomiendo la página oficial de Composer

Una vez lo tengamos instalado, comprobamos que funcione correctamente, escribiendo en nuestra terminal:

composer --version

Tendrás un resultado similar a este:

Composer version 1.10.15 2020-10-13 15:59:09

Si no tienes instalado Laravel, lo instalamos de esta forma en Ubuntu:

composer global require laravel/installer

Para otros sistemas operativos, les recomiendo leer el Manual de instalación de Laravel

Una vez, tengamos nuestras dependencias listas, nos movemos a nuestro directorio donde vamos a crear una carpeta para guardar nuestro proyecto. y ejecutamos el siguiente comando para crear nuestro proyecto de Laravel:

composer create-project --prefer-dist laravel/laravel nombre-proyecto

Una vez creado nuestro proyecto, accedemos a el:

cd nombre-proyecto/

Ahora vamos a probar si funciona la aplicación correctamente, iniciando el servidor de desarrollo:

php artisan serv

Nos mostrará un enlace a nuestro servidor local, algo parecido a esto:

Starting Laravel development server: http://127.0.0.1:8000

Copiamos el URL en nuestro navegador y nos debe mostrar esta vista:

Y ya estaría configurado nuestro proyecto correctamente.

Es necesario configurar nuestras variables de entorno de conexión a nuestra base de datos en el archivo .env, para esto puedes usar tu editor de texto de confianza (Vim, Nano, VS Code, Sublime Text, etc…)

Debemos tener nuestra base de datos creada sin tablas para ejecutar la migración por defecto de Laravel, que permite crear la tabla users

php artisan migrate

Si quieres personalizar tu tabla usuarios, puedes personalizar esto en config/auth.php y app/Models/User.php

Vamos a instalar las dependencias de JWT:

composer require tymon/jwt-auth:dev-develop --prefer-source

Debes incluir la siguiente línea en el archivo config/app.php dentro del array de providers

Tymon\JWTAuth\Providers\LaravelServiceProvider::class,

En el mismo archivo, en el array aliases agregamos las siguientes líneas:

'JWTAuth' => Tymon\JWTAuth\Facades\JWTAuth::class,
'JWTFactory' => Tymon\JWTAuth\Facades\JWTFactory::class,

Comprobamos que funcione correctamente con el siguiente comando:

php artisan jwt:secret

Ahora en la clase User, implementamos los siguientes 2 métodos:

public function getJWTIdentifier()
{
	return $this->getKey();
}

public function getJWTCustomClaims()
{
	return [];
}

Es necesario que esta clase implemente JWTSubject

use Tymon\JWTAuth\Contracts\JWTSubject;

class User extends Authenticatable implements JWTSubject {

Crearemos un middleware para JWT con el siguiente comando:

php artisan make:middleware JwtMiddleware

Modificamos el nuevo Middleware con las siguientes líneas de código:

<?php

namespace App\Http\Middleware;

use Closure;
use JWTAuth;
use Exception;
use Tymon\JWTAuth\Http\Middleware\BaseMiddleware;

class JwtMiddleware extends BaseMiddleware
{

    public function handle($request, Closure $next)
    {
        try {
            $user = JWTAuth::parseToken()->authenticate();
        } catch (Exception $e) {
            if ($e instanceof \Tymon\JWTAuth\Exceptions\TokenInvalidException){
                return response()->json(['status' => 'Token is Invalid']);
            }else if ($e instanceof \Tymon\JWTAuth\Exceptions\TokenExpiredException){
                return response()->json(['status' => 'Token is Expired']);
            }else{
                return response()->json(['status' => 'Authorization Token not found']);
            }
        }
        return $next($request);
    }
}

Para finalizar este paso, añadimos el nuevo Middleware al Kernel, agregando la siguiente línea al archivo en app/http/Kernel.php en routeMiddleware:

'jwt.verify' => \App\Http\Middleware\JwtMiddleware::class,

Ahora procedemos a crear UserController para crear los métodos de registro y autenticación:

php artisan make:controller UserController

Una vez creado en la app/Http/Controllers, procedemos a modificarlo para que quede de la siguiente forma:

<?php   
namespace App\Http\Controllers;

    use App\Models\User;
    use Illuminate\Http\Request;
    use Illuminate\Support\Facades\Hash;
    use Illuminate\Support\Facades\Validator;
    use JWTAuth;
    use Tymon\JWTAuth\Exceptions\JWTException;

class UserController extends Controller
{
    public function authenticate(Request $request)
    {
    $credentials = $request->only('email', 'password');
    try {
        if (! $token = JWTAuth::attempt($credentials)) {
            return response()->json(['error' => 'invalid_credentials'], 400);
        }
    } catch (JWTException $e) {
        return response()->json(['error' => 'could_not_create_token'], 500);
    }
    return response()->json(compact('token'));
    }

    public function getAuthenticatedUser()
    {
    try {
        if (!$user = JWTAuth::parseToken()->authenticate()) {
                return response()->json(['user_not_found'], 404);
        }
        } catch (Tymon\JWTAuth\Exceptions\TokenExpiredException $e) {
                return response()->json(['token_expired'], $e->getStatusCode());
        } catch (Tymon\JWTAuth\Exceptions\TokenInvalidException $e) {
                return response()->json(['token_invalid'], $e->getStatusCode());
        } catch (Tymon\JWTAuth\Exceptions\JWTException $e) {
                return response()->json(['token_absent'], $e->getStatusCode());
        }
        return response()->json(compact('user'));
    }


    public function register(Request $request)
    {
            $validator = Validator::make($request->all(), [
            'name' => 'required|string|max:255',
            'email' => 'required|string|email|max:255|unique:users',
            'password' => 'required|string|min:6|confirmed',
        ]);

        if($validator->fails()){
                return response()->json($validator->errors()->toJson(), 400);
        }

        $user = User::create([
            'name' => $request->get('name'),
            'email' => $request->get('email'),
            'password' => Hash::make($request->get('password')),
        ]);

        $token = JWTAuth::fromUser($user);

        return response()->json(compact('user','token'),201);
    }
}

Lo siguiente es indicarle a nuestro aplicación cuales son las rutas a las que se accederán para registrarse e iniciar sesión. Para esto modificaremos el archivo routes/api.php.
Debemos comentar las siguientes lineas:

Route::middleware('auth:api')->get('/user', function (Request $request) {
    return $request->user();
});

// Route::middleware('auth:api')->get('/user', function (Request $request) {
//     return $request->user();
// });

Y escribir las siguientes líneas:

Route::post('register', 'App\Http\Controllers\UserController@register');
Route::post('login', 'App\Http\Controllers\UserController@authenticate');

Creamos un group para indicar cuales son las rutas que necesitan autenticación:

Route::group(['middleware' => ['jwt.verify']], function() {

    Route::post('user','App\Http\Controllers\UserController@getAuthenticatedUser');

});

NOTA: Las rutas que guardemos en api, tendrán por defecto la ruta /api

Ya tenemos todo listo para poder registrar usuarios y hacer login.

Podemos usar Postman para realizar una petición en formato JSON con POST hacia la ruta /api/register:

{
    "name" : "randomusername",
    "password" : "strongkey123",
    "password_confirmation" : "strongkey123",
    "email" : "randommail@mail.com"
}

Se puede ver como se registró correctamente nuestro usuario.
El inicio de sesión consiste en enviar las credenciales de acceso y obtener un token, que nos permitirá acceder a rutas que se necesita autenticación. La ruta de login es /api/login usando el método GET

{
    "email" : "randommail@mail.com",
    "password" : "strongkey123"
}

Como último paso es acceder a una ruta protegida con nuestro token de autenticación.
Nuestro token se debe enviar con el header Authorization y colcando la palabra Bearer antes de nuestro token

Authorization: Bearer <nuestroToken>

La ruta para obtener los datos de usuario es /api/user mediante el método POST

Ahora sí, está todo listo.

Ya estás listo para crear tu backend en Laravel 8 para comunicarte con cualquier aplicación que quieras desarrollar.

Te invito a escribir en la caja de comentarios y, NUNCA PARES DE APRENDER