En esta ocacion les traigo un tutorial que pienso que es muy importante para todas aquellas personas que están en el mundo de la programación web. Aprenderemos a crear un sistema de autenticación mediante el uso de Laravel Passport.
Las API normalmente usan tokens para autenticar a los usuarios y no mantienen el estado de la sesión entre solicitudes. Laravel simplifica la autenticación de API con Laravel Passport, que proporciona una implementación completa del servidor OAuth2 para su aplicación Laravel en cuestión de minutos.
Lo primero que tenemos que hacer es crear nuestro proyecto laravel ejecutando el siguiente comando en la consola.
composer create-project --prefer-dist laravel/laravel MyProject.
A continuación entramos a la carpeta del proyecto.
cd MyProject
Lo siguiente que haremos es instalar Laravel Passport ejecutando el siguiente comando.
composer require laravel/passport
El siguiente paso es migrar la base de datos. Aqui Las migraciones de Passport crearán las tablas que su aplicación necesita para almacenar clientes y acceder a tokens.
Pero antes de ejecutar las migraciones agreguemos dos columnas mas a la tabla de usuarios que viene por defecto en un proyecto de laravel, para eso iremos a database/migrations/create_users_table.php.
<?phpuse Illuminate\Support\Facades\Schema; use Illuminate\Database\Schema\Blueprint; use Illuminate\Database\Migrations\Migration;class CreateUsersTable extends Migration { /** * Run the migrations. * * @return void */ public function up() { Schema::create('users', function (Blueprint $table) { $table->increments('id'); $table->string('first_name'); $table->string('last_name'); $table->string('email')->unique(); $table->timestamp('email_verified_at')->nullable(); $table->string('password'); $table->rememberToken(); $table->timestamps(); }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::dropIfExists('users'); } }
Ahora necesitamos cambiar los valores de las variables de la base de datos en el archivo .env . Actualice ese archivo con su Nombre de base de datos, Nombre de usuario, Contraseña, etc. Para que podamos ejecutar nuestras migraciones.
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=MyDataBase
DB_USERNAME=MyUser
DB_PASSWORD=MyPassword
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=MyDataBase
DB_USERNAME=MyUser
DB_PASSWORD=MyPassword
Ahora si ejecutamos el comando para las migraciones.
php artisan migrate
Si revisamos nuestra base de datos veremos las siguientes tablas creadas.
A continuación, tenemos que crear las claves de cifrado necesarias para generar tokens de acceso seguro. Además, el comando creará clientes de "acceso personal" y "concesión de contraseña" que se utilizarán para generar tokens de acceso. Ejecute el siguiente comando para hacer eso.
php artisan passport:install
Luego de haber hecho estos pasos debemos hacer algunas modificaciones en varios archivos.
Primero editaremos el archivo User.php que se encuentra en App/User.php donde agregaremos la siguiente linea de código.
use Laravel\Passport\HasApiTokens;
El archivo quedaría así.
<?phpnamespace App;use Laravel\Passport\HasApiTokens; use Illuminate\Notifications\Notifiable; use Illuminate\Contracts\Auth\MustVerifyEmail; use Illuminate\Foundation\Auth\User as Authenticatable;class User extends Authenticatable { use HasApiTokens, Notifiable; /** * The attributes that are mass assignable. * * @var array */ protected $fillable = [ 'name', 'email', 'password', ]; /** * The attributes that should be hidden for arrays. * * @var array */ protected $hidden = [ 'password', 'remember_token', ]; }
El siguiente archivo a editar es AuthServiceProvider.php, este se encuentra en app/Providers/AuthServiceProvider.php. Debemos hacer el llamado al método Passport::routes dentro del metodo de arranque, quedando el archivo de la siguiente manera.
<?phpnamespace App\Providers;use Laravel\Passport\Passport; use Illuminate\Support\Facades\Gate; use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;class AuthServiceProvider extends ServiceProvider { /** * The policy mappings for the application. * * @var array */ protected $policies = [ 'App\Model' => 'App\Policies\ModelPolicy', ]; /** * Register any authentication / authorization services. * * @return void */ public function boot() { $this->registerPolicies(); Passport::routes(); } }
Procederemos a editar el archivo auth.php, debemos configurar la opcion del driver de la protección de autenticacion, esto le indicará a su aplicación que use TokenGuard de Passport al autenticar las solicitudes API entrantes.
<?phpreturn [ 'defaults' => [ 'guard' => 'web', 'passwords' => 'users', ], 'guards' => [ 'web' => [ 'driver' => 'session', 'provider' => 'users', ], 'api' => [ 'driver' => 'passport', 'provider' => 'users', ], ], 'providers' => [ 'users' => [ 'driver' => 'eloquent', 'model' => App\User::class, ], // 'users' => [ // 'driver' => 'database', // 'table' => 'users', // ], ], 'passwords' => [ 'users' => [ 'provider' => 'users', 'table' => 'password_resets', 'expire' => 60, ], ],];
El próximo paso a seguir es establecer las rutas API. Para esto buscamos el archivo api.php, este se encuentra en la siguiente ruta. routes/api.php.
Copie el siguiente código en routes / api.php . Crearemos rutas para iniciar sesión, registrarse, cerrar sesión y mostrar datos del usuario logueado.
<?phpuse Illuminate\Http\Request;Route::group([ 'prefix' => 'auth' ], function () { Route::post('login', 'Auth\AuthController@login')->name('login'); Route::post('register', 'Auth\AuthController@register'); Route::group([ 'middleware' => 'auth:api' ], function() { Route::get('logout', 'Auth\AuthController@logout'); Route::get('user', 'Auth\AuthController@user'); }); });
seguimos creando el controlador AuthController para definir y darle funcionalidades a los metodos descritos anteriormente. Para esto ejecutemos el siguiente comando.
php artisan make:controller Auth/AuthController
Procederemos con abrir el archivo AuthController.php ubicado en app/Http/Controllers/Auth/AuthController.php y agregue el siguiente código.
<?phpnamespace App\Http\Controllers\Auth;use App\User;
use Carbon\Carbon;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;class AuthController extends Controller
{
public function login(Request $request) {
$request->validate([
'email' => 'required|string|email',
'password' => 'required|string',
]);
$credentials = request(['email', 'password']);
if(!Auth::attempt($credentials))
return response()->json([
'message' => 'Unauthorized'
], 401);
$user = $request->user();
$tokenResult = $user->createToken('Personal Access Token');
$token = $tokenResult->token;
if ($request->remember_me)
$token->expires_at = Carbon::now()->addWeeks(1);
$token->save();
return response()->json([
'access_token' => $tokenResult->accessToken,
'token_type' => 'Bearer',
'expires_at' => Carbon::parse(
$tokenResult->token->expires_at
)->toDateTimeString()
]);
} public function register(Request $request)
{
$request->validate([
'fName' => 'required|string',
'lName' => 'required|string',
'email' => 'required|string|email|unique:users',
'password' => 'required|string'
]); $user = new User;
$user->first_name = $request->fName;
$user->last_name = $request->lName;
$user->email = $request->email;
$user->password = bcrypt($request->password); $user->save(); return response()->json([
'message' => 'Successfully created user!'
], 201);
} public function logout(Request $request)
{
$request->user()->token()->revoke();
return response()->json([
'message' => 'Successfully logged out'
]);
}
/**
* Get the authenticated User
*
* @return [json] user object
*/
public function user(Request $request)
{
return response()->json($request->user());
}
}
Ahora lo que tenemos que hacer es agregar los CORS para poder hacer peticiones desde un cliente. Para esto debemos crear un middleware. Ejecute el siguiente comando para crear un nuevo Middleware
php artisan make:middleware Cors
Se creará un nuevo archivo en app/Http/Middleware/Cors.php. Copiemos el siguiente código.
<?phpnamespace App\Http\Middleware;use Closure;class Cors
{
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
public function handle($request, Closure $next)
{
return $next($request)
->header('Access-Control-Allow-Origin', '*')
->header('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS')
->header('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With, X-XSRF-TOKEN');
}
}
Por ultimo debemos ir al archivo Kenel.php, ubicado en app/Http/Kernal.php. y copiar el siguiente código.
<?phpnamespace App\Http;use Illuminate\Foundation\Http\Kernel as HttpKernel;class Kernel extends HttpKernel { /** * The application's global HTTP middleware stack. * * These middleware are run during every request to your application. * * @var array */ protected $middleware = [ \App\Http\Middleware\CheckForMaintenanceMode::class, \Illuminate\Foundation\Http\Middleware\ValidatePostSize::class, \App\Http\Middleware\TrimStrings::class, \Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class, \App\Http\Middleware\TrustProxies::class, \App\Http\Middleware\Cors::class, ];...
Perfecto ahora estamos listos. Ejecute el siguiente comando para ejecutar.
php artisan serve
Ahora puede consumir esta API con las siguientes url.
http://localhost:8000/api/auth/register
http://localhost:8000/api/auth/login
http://localhost:8000/api/auth/user
http://localhost:8000/api/auth/user
y eso es todo.
ConversionConversion EmoticonEmoticon