Docs Menu
Docs Home
/ /

Autenticación de usuarios

En esta guía, puedes aprender a autenticar a los usuarios de MongoDB utilizando la funcionalidad nativa de autenticación de Laravel.

Laravel proporciona una plataforma nativa Auth Módulo que incluye servicios de autenticación, como guardias que definen cómo se autentican los usuarios y proveedores que definen cómo se recuperan. Para obtener más información sobre estos servicios, consulte Autenticación en la documentación de Laravel.

De forma predeterminada, Laravel genera el modelo Eloquent User en el directorio App/Models. Para habilitar la autenticación de los usuarios de MongoDB, el modelo User debe extender la clase MongoDB\Laravel\Auth\User.

Para ampliar esta clase, navegue a su archivo app/Models/User.php y reemplace la declaración use Illuminate\Foundation\Auth\User as Authenticatable con el siguiente código:

use MongoDB\Laravel\Auth\User as Authenticatable;

A continuación, asegúrese de que su clase User extienda Authenticatable, como se muestra en el siguiente código:

class User extends Authenticatable
{
...
}

Después de configurar su User modelo, cree el controlador correspondiente. Para saber cómo crear un controlador, consulte la sección "Crear el controlador de usuario" en esta página.

El siguiente código muestra un archivo User.php que extiende la clase MongoDB\Laravel\Auth\User:

<?php
namespace App\Models;
use MongoDB\Laravel\Auth\User as Authenticatable;
class User extends Authenticatable
{
protected $connection = 'mongodb';
protected $table = 'users';
protected $fillable = [
'name',
'email',
'password',
];
protected $hidden = [
'password',
'remember_token',
];
}

Para almacenar funciones que administran la autenticación, cree un controlador de autenticación para su modelo User.

Ejecute el siguiente comando desde la raíz de su proyecto para crear un controlador:

php artisan make:controller <filename>

El siguiente comando crea un archivo de controlador llamado AuthController.php:

php artisan make:controller AuthController

El archivo AuthController.php puede almacenar funciones login() y logout() para administrar la autenticación del usuario, como se muestra en el siguiente código:

<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Validation\ValidationException;
use function response;
class AuthController extends Controller
{
public function login(Request $request)
{
$request->validate([
'email' => 'required|email',
'password' => 'required',
]);
if (Auth::attempt($request->only('email', 'password'))) {
return response()->json([
'user' => Auth::user(),
'message' => 'Successfully logged in',
]);
}
throw ValidationException::withMessages([
'email' => ['The provided credentials are incorrect.'],
]);
}
public function logout()
{
Auth::logout();
return response()->json(['message' => 'Successfully logged out']);
}
}

Puede personalizar sus archivos de autenticación para alinearlos con las necesidades de su aplicación y habilitar funciones de autenticación adicionales.

En esta sección se describe cómo utilizar las siguientes funciones para personalizar el proceso de autenticación de usuarios de MongoDB:

Laravel Sanctum es un paquete de autenticación que gestiona las solicitudes de API y la autenticación de aplicaciones de una sola página. Para gestionar las solicitudes de API, Sanctum emite tokens de API que se almacenan en la base de datos y autentica las solicitudes HTTP entrantes mediante el encabezado Authorization. Para autenticar aplicaciones de una sola página, Sanctum utiliza los servicios de autenticación basados ​​en cookies de Laravel.

Puedes instalar Laravel Sanctum para gestionar el proceso de autenticación de tu aplicación. Ejecuta los siguientes comandos desde la raíz del proyecto para instalar Laravel Sanctum y publicar su archivo de migración:

composer require laravel/sanctum
php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"

Para usar Laravel Sanctum con la integración de Laravel, modifique el modelo PersonalAccessToken proporcionado por Sanctum para usar el atributo DocumentModel del espacio de nombres MongoDB\Laravel\Eloquent. El siguiente código modifica el modelo PersonalAccessToken para habilitar MongoDB:

<?php
namespace App\Models;
use Laravel\Sanctum\PersonalAccessToken as SanctumToken;
use MongoDB\Laravel\Eloquent\DocumentModel;
class PersonalAccessToken extends SanctumToken
{
use DocumentModel;
protected $connection = 'mongodb';
protected $table = 'personal_access_tokens';
protected $keyType = 'string';
}

A continuación, ejecute el siguiente comando para modificar el esquema de la base de datos:

php artisan migrate

Ahora puedes indicarle a Sanctum que use el PersonalAccessToken modelo personalizado llamando al usePersonalAccessTokenModel() método en uno de los proveedores de servicios de tu aplicación. Para obtener más información, consulta "Anulación de modelos predeterminados" en la guía de Laravel Sanctum.

Tip

Para obtener más información sobre el rasgo DocumentModel, consulte Amplíe las clases de modelos de terceros en la guía de clases de modelos de Eloquent.

Laravel Passport es una implementación de servidor OAuth 2.0 que ofrece autenticación API para aplicaciones Laravel. Usa Laravel Passport si tu aplicación requiere compatibilidad con OAuth2.

Tip

Para obtener más información sobre Laravel Passport y el protocolo OAuth 2.0, consulte los siguientes recursos:

Para instalar Laravel Passport y ejecutar las migraciones de base de datos necesarias para almacenar los clientes OAuth2, ejecute el siguiente comando desde la raíz de su proyecto:

php artisan install:api --passport

A continuación, navegue a su modelo User y agregue el atributo Laravel\Passport\HasApiTokens. Este atributo proporciona métodos auxiliares que le permiten inspeccionar el token de autenticación y los ámbitos de un usuario. El siguiente código muestra cómo agregar Laravel\Passport\HasApiTokens a su archivo app\Models\User.php:

<?php
namespace App\Models;
use MongoDB\Laravel\Auth\User as Authenticatable;
use Laravel\Passport\HasApiTokens;
class User extends Authenticatable
{
use HasApiTokens;
...
}

A continuación, define un guard de autenticación api en tu archivo config\auth.php y establece la opción driver en passport. Esto instruye a tu aplicación para que use la clase TokenGuard de Laravel Passport para autenticar las solicitudes de la API. El siguiente ejemplo añade el guard de autenticación api al arreglo guards:

'guards' => [
'web' => [
'driver' => 'session',
'provider' => 'users',
],
'api' => [
'driver' => 'passport',
'provider' => 'users',
],
],

Después de instalar Laravel Passport, debe habilitar la compatibilidad de Passport con MongoDB definiendo modelos de integración de Laravel personalizados que extiendan los modelos de Passport correspondientes. Para extender cada clase de modelo de Passport, incluya el rasgo DocumentModel en los modelos personalizados. Puede definir las siguientes clases de modelo de integración de Laravel:

  • MongoDB\Laravel\Passport\AuthCode, que se extiende Laravel\Passport\AuthCode

  • MongoDB\Laravel\Passport\Client, que se extiende Laravel\Passport\Client

  • MongoDB\Laravel\Passport\PersonalAccessClient, que se extiende Laravel\Passport\PersonalAccessClient

  • MongoDB\Laravel\Passport\RefreshToken, que se extiende Laravel\Passport\RefreshToken

  • MongoDB\Laravel\Passport\Token, que se extiende Laravel\Passport\Token

El siguiente ejemplo de código extiende la clase de modelo por defecto Laravel\Passport\AuthCode al definir una clase MongoDB\Laravel\Passport\AuthCode e incluye el trait DocumentModel:

class MongoDB\Laravel\Passport\AuthCode extends Laravel\Passport\AuthCode
{
use MongoDB\Laravel\Eloquent\DocumentModel;
protected $primaryKey = '_id';
protected $keyType = 'string';
}

Después de definir los modelos personalizados que extienden cada clase Laravel\Passport, indique a Passport que use los modelos en el método boot() de la clase App\Providers\AppServiceProvider de su aplicación. El siguiente ejemplo agrega cada modelo personalizado al método boot():

<?php
namespace App\Providers;
use Illuminate\Support\ServiceProvider;
use MongoDB\Laravel\Passport\AuthCode;
use MongoDB\Laravel\Passport\Client;
use MongoDB\Laravel\Passport\PersonalAccessClient;
use MongoDB\Laravel\Passport\RefreshToken;
use MongoDB\Laravel\Passport\Token;
class AppServiceProvider extends ServiceProvider
{
/**
* Register any application services.
*/
public function register(): void
{
}
/**
* Bootstrap any application services.
*/
public function boot(): void
{
Passport::useAuthCodeModel(AuthCode::class);
Passport::useClientModel(Client::class);
Passport::usePersonalAccessClientModel(PersonalAccessClient::class);
Passport::useRefreshTokenModel(RefreshToken::class);
Passport::useTokenModel(Token::class);
}
}

Luego, puedes usar Laravel Passport y MongoDB en tu aplicación.

Para agregar compatibilidad con recordatorios de contraseña basados ​​en MongoDB, registre el siguiente proveedor de servicios en su aplicación:

MongoDB\Laravel\Auth\PasswordResetServiceProvider::class

Este proveedor de servicios modifica el DatabaseReminderRepository interno para habilitar recordatorios de contraseña.

El siguiente código actualiza el archivo providers.php en el directorio bootstrap de una aplicación Laravel para registrar el proveedor PasswordResetServiceProvider:

return [
App\Providers\AppServiceProvider::class,
MongoDB\Laravel\MongoDBServiceProvider::class,
MongoDB\Laravel\Auth\PasswordResetServiceProvider::class
];

Para obtener más información sobre la autenticación de usuarios, consulte Autenticación en la documentación de Laravel.

Para obtener más información sobre los modelos Eloquent, consulte la guía de clases de modelos Eloquent.

Volver

Time Series

En esta página