Cara Membuat Custom Authentication Guard di Laravel

Indonesian (Bahasa Indonesia) translation by Imam Firmansyah (you can also view the original English article)

Pada artikel ini, kita akan membahas sistem otentikasi pada framework Laravel. Tujuan utama dari artikel ini adalah untuk menciptakan Custom Authentication Guard dengan memperluas core dari sistem otentikasi.

Laravel menyediakan sistem otentikasi yang sangat solid dalam core sistemnya yang membuat implementasi otentikasi dasar menjadi mudah. Sebenarnya, Anda hanya perlu menjalankan beberapa perintah untuk menyiapkan rangka sistem autentikasi.

Selain itu, sistem ini sendiri dirancang sedemikian rupa sehingga Anda bisa mengembangkan dan memasang adaptor otentikasi kustom Anda juga. Itulah yang akan kita bahas secara rinci di seluruh artikel ini. Sebelum kita langsung ke tahap implementasi, kita akan mulai dengan diskusi tentang elemen dasar di sistem pengaman dan penyedia sistem otentikasi Laravel.

Element Utama: Guards dan Providers

Sistem otentikasi Laravel terdiri dari dua elemen yaitu core-guards dan providers.

Guards

Anda bisa menganalogikan guards sebagai cara untuk memasok logika yang digunakan untuk mengidentifikasi pengguna yang diotentikasi. Intinya, Laravel menyediakan guards yang berbeda seperti session dan token. Session Guards menjaga status pengguna di setiap permintaan pada cookies, dan di sisi lain Token Guards mengotentikasi pengguna dengan memeriksa token yang valid pada setiap permintaan.

Jadi, seperti yang Anda ketahui, guards mendefinisikan logika otentikasi, dan hal itu tidak selalu berhubungan dengan mengambil identitas yang valid dari back end. Anda dapat menerapkan guards yang hanya memeriksa keberadaan hal tertentu pada saat permintaan header dan mengotentikasi pengguna berdasarkan hal tersebut.

Kemudian, kita juga akan menerapkan guards yang memeriksa parameter JSON tertentu pada permintaan header dan mengambil data valid user dari back-end MongoDB.

Providers

Jika guards mendefinisikan logika otentikasi, authentication provider bertanggung jawab untuk mengambil data pengguna dari penyimpanan back-end. Jika guards memerlukan pengguna untuk divalidasi terhadap penyimpanan back-end maka penerapan pengambilan data user masuk ke authentication provider.

Laravel mengirimkan melalui dua authentication provider bawaan, yaitu: Database dan Eloquent. Database menangani pengambilan data identitas pengguna secara langsung dari penyimpanan back-end, sementara Eloquent menyediakan lapisan abstraksi yang diperlukan.

Dalam contoh yang diberikan, kita akan menerapkan otentikasi provider MongoDB yang mengambil data identitas pengguna dari back-end MongoDB.

Jadi itu adalah pengantar dasar dari guards dan providers sistem otentikasi Laravel. Dari bagian berikutnya dan seterusnya, kita akan fokus pada pengembangan custom authentication guard and provider!

Sekilas untuk File Setup

Mari kita lihat sekilas daftar file yang akan kita terapkan sepanjang artikel ini.

config/auth.php : Ini adalah file konfigurasi otentikasi dimana kita akan menambahkan entri dari custom guard kita.
config/mongo.php : Ini adalah file yang menyimpan konfigurasi MongoDB.
app/Services/Contracts/NosqlServiceInterface.php : Ini adalah file konfigurasi dimana antarmuka yang akan diterapkan pada database class Mongo kustom yang akan dibuat.
app/Database/MongoDatabase.php : Ini adalah file konfigurasi database class utama pada MongoDB.
app/Models/Auth/User.php : Ini adalah file konfigurasi user model class yang menerapkan aturan otentikasi.
app/Extensions/MongoUserProvider.php : Ini adalah file konfigurasi yang berisi penerapan dari authentication provider.
app/Services/Auth/JsonGuard.php : Ini adalah file konfigurasi yang berisi penerapan dari authentication guard driver.
app/Providers/AuthServiceProvider.php : Ini adalah file yang akan kita gunakan untuk menambahkan service container bindings kita.
app/Http/Controllers/MongoController.php : Ini adalah file pengontrol demo yang akan kita terapkan untuk menguji guards kustom.

Jangan khawatir jika daftar file membingungkan karena kita akan membahas semuanya secara rinci saat kita mengimplementasikannya.

Deep Dive Ke dalam Implementasi

Pada bagian ini, kita akan mengimplementasikan file-file yang diperlukan.

Hal pertama yang perlu kita lakukan adalah menginformasikan kepada Laravel tentang custom guard kita. Silakan lihat dan masukkan rincian kustom guards seperti di file config/auth.php yang ditunjukkan .

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

    'api' => [
        'driver' => 'token',
        'provider' => 'users',
    ],
    
    'custom' => [
      'driver' => 'json',
      'provider' => 'mongo',
    ],
],
...
...

Seperti yang Anda lihat, kita telah menambahkan custom guard pada custom key.

Selanjutnya, kita perlu untuk menambahkan kumpulan provider pada bagian providers.

...
...
'providers' => [
    'users' => [
        'driver' => 'eloquent',
        'model' => App\User::class,
    ],
    'mongo' => [
        'driver' => 'mongo'
    ],

    // 'users' => [
    //     'driver' => 'database',
    //     'table' => 'users',
    // ],
],
...
...

Kita telah menambahkan provider kita pada mongo key.

Terakhir, ubah nilai otentikasi guard bawaan dari web menjadi custom.

...
...
'defaults' => [
    'guard' => 'custom',
    'passwords' => 'users',
],
...
...

Tentu saja, itu belum akan berjalan, karena kita belum menerapkan file yang diperlukan. Dan itulah yang akan kita bahas dalam beberapa bagian berikutnya.

Menyiapkan MongoDB Driver

Pada bagian ini, kita akan menerapkan file-file yang mendasari instance MongoDB

Pertama, kita buat sebuah file konfigurasi config/mongo.php yang menyimpan pengaturan koneksi bawaan MongoDB.

<?php
return [
  'defaults' => [
    'host' => '{HOST_IP}',
    'port' => '{HOST_PORT}',
    'database' => '{DB_NAME}'
  ]
];

Tentu saja, Anda perlu mengganti nilai placeholder sesuai keinginan anda.

Alih-alih langsung menciptakan class yang berinteraksi dengan MongoDB, kita akan membuat sebuah antarmuka terlebih dahulu.

Manfaat membuat antarmuka adalah menyediakan aturan yang harus dipatuhi oleh developer saat menerapkannya. Selain itu, implementasi MongoDB kita dapat dengan mudah ditukar dengan implementasi NoSQL lainnya jika diperlukan.

Lanjutkan dengan membuat file antarmuka app/Services/Contracts/NosqlServiceInterface.phpdengan isi sebagai berikut.

<?php
// app/Services/Contracts/NosqlServiceInterface.php
namespace App\Services\Contracts;

Interface NosqlServiceInterface
{
  /**
   * Create a Document
   *
   * @param string $collection Collection/Table Name
   * @param array  $document   Document
   * @return boolean
   */
  public function create($collection, Array $document);
 
  /**
   * Update a Document
   *
   * @param string $collection Collection/Table Name
   * @param mix    $id         Primary Id
   * @param array  $document   Document
   * @return boolean
   */
  public function update($collection, $id, Array $document);

  /**
   * Delete a Document
   *
   * @param string $collection Collection/Table Name
   * @param mix    $id         Primary Id
   * @return boolean
   */
  public function delete($collection, $id);
 
  /**
   * Search Document(s)
   *
   * @param string $collection Collection/Table Name
   * @param array  $criteria   Key-value criteria
   * @return array
   */
  public function find($collection, Array $criteria);
}

Ini adalah antarmuka yang cukup sederhana yang menyatakan metode dasar CRUD yang harus didefinisikan oleh class yang mengimplementasikan antarmuka ini.

Sekarang, kita akan mendefinisikan class pada app/Database/MongoDatabase.php.

<?php
// app/Database/MongoDatabase.php
namespace App\Database;

use App\Services\Contracts\NosqlServiceInterface;

class MongoDatabase implements NosqlServiceInterface
{
  private $connection;
  private $database;
    
  public function __construct($host, $port, $database)
  {
    $this->connection = new MongoClient( "mongodb://{$host}:{$port}" );
    $this->database = $this->connection->{$database};
  }
 
  /**
   * @see \App\Services\Contracts\NosqlServiceInterface::find()
   */
  public function find($collection, Array $criteria)
  {
    return $this->database->{$collection}->findOne($criteria);
  }

  public function create($collection, Array $document) {}
  public function update($collection, $id, Array $document) {}
  public function delete($collection, $id) {}
}

Tentu saja, saya berasumsi bahwa Anda telah menginstal MongoDB dan ekstensi PHP MongoDB yang sesuai.

method __construct menginisiasikan class MongoClient dengan parameter-parameter yang diperlukan. Metode penting lainnya yang kita perlukan adalah method find, yang mengambil catatan berdasarkan kriteria yang diberikan sebagai method argumen.

Begitulah implementasi driver MongoDB, dan saya mencoba untuk membuatnya sesederhana mungkin.

Mengatur User Model

Dengan mengikuti standar sistem otentikasi, kita perlu menerapkan User Model yang harus menerapkan aturan Illuminate\Contracts\Auth\Authenticatable.

Lalu, buat file app/Models/Auth/User.php dengan isi sebagai berikut.

<?php
// app/Models/Auth/User.php
namespace App\Models\Auth;

use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
use App\Services\Contracts\NosqlServiceInterface;

class User implements AuthenticatableContract
{
  private $conn;
 
  private $username;
  private $password;
  protected $rememberTokenName = 'remember_token';

  public function __construct(NosqlServiceInterface $conn)
  {
    $this->conn = $conn;
  }

  /**
   * Fetch user by Credentials
   *
   * @param array $credentials
   * @return Illuminate\Contracts\Auth\Authenticatable
   */
  public function fetchUserByCredentials(Array $credentials)
  {
    $arr_user = $this->conn->find('users', ['username' => $credentials['username']]);
    
    if (! is_null($arr_user)) {
      $this->username = $arr_user['username'];
      $this->password = $arr_user['password'];
    }

    return $this;
  }

  /**
   * {@inheritDoc}
   * @see \Illuminate\Contracts\Auth\Authenticatable::getAuthIdentifierName()
   */
  public function getAuthIdentifierName()
  {
    return "username";
  }
 
  /**
   * {@inheritDoc}
   * @see \Illuminate\Contracts\Auth\Authenticatable::getAuthIdentifier()
   */
  public function getAuthIdentifier()
  {
    return $this->{$this->getAuthIdentifierName()};
  }

  /**
   * {@inheritDoc}
   * @see \Illuminate\Contracts\Auth\Authenticatable::getAuthPassword()
   */
  public function getAuthPassword()
  {
    return $this->password;
  }

  /**
   * {@inheritDoc}
   * @see \Illuminate\Contracts\Auth\Authenticatable::getRememberToken()
   */
  public function getRememberToken()
  {
    if (! empty($this->getRememberTokenName())) {
      return $this->{$this->getRememberTokenName()};
    }
  }

  /**
   * {@inheritDoc}
   * @see \Illuminate\Contracts\Auth\Authenticatable::setRememberToken()
   */
  public function setRememberToken($value)
  {
    if (! empty($this->getRememberTokenName())) {
      $this->{$this->getRememberTokenName()} = $value;
    }
  }

  /**
   * {@inheritDoc}
   * @see \Illuminate\Contracts\Auth\Authenticatable::getRememberTokenName()
   */
  public function getRememberTokenName()
  {
    return $this->rememberTokenName;
  }
}

Anda seharusnya sudah tahu bahwa App\Models\Auth\User menerapkan aturan Illuminate\Contracts\Auth\Authenticatable.

Sebagian besar metode yang diterapkan di class kita cukup jelas. Karena itu, kita sudah mendefinisikan method fetchUserByCredentials, yang mengambil data pengguna dari back-end yang tersedia. Dalam hal ini, class MongoDatabase yang akan dipanggil untuk mengambil informasi yang diperlukan.

Itulah implementasi dari user model.

Mengatur Authentication Provider

Seperti yang telah kita bahas sebelumnya, sistem otentikasi Laravel terdiri dari dua elemen - guards dan providers.

Pada bagian ini, kita akan membuat sebuah authentication provider yang menangani pengambilan data user dari back-end.

Buat file app/Extensions/MongoUserProvider.php seperti berikut ini.

<?php
// app/Extensions/MongoUserProvider.php
namespace App\Extensions;

use Illuminate\Support\Str;
use Illuminate\Contracts\Auth\UserProvider;
use Illuminate\Contracts\Auth\Authenticatable;

class MongoUserProvider implements UserProvider
{
  /**
   * The Mongo User Model
   */
  private $model;

  /**
   * Create a new mongo user provider.
   *
   * @return \Illuminate\Contracts\Auth\Authenticatable|null
   * @return void
   */
  public function __construct(\App\Models\Auth\User $userModel)
  {
    $this->model = $userModel;
  }

  /**
   * Retrieve a user by the given credentials.
   *
   * @param  array  $credentials
   * @return \Illuminate\Contracts\Auth\Authenticatable|null
   */
  public function retrieveByCredentials(array $credentials)
  {
      if (empty($credentials)) {
          return;
      }

    $user = $this->model->fetchUserByCredentials(['username' => $credentials['username']]);

      return $user;
  }
 
  /**
   * Validate a user against the given credentials.
   *
   * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
   * @param  array  $credentials  Request credentials
   * @return bool
   */
  public function validateCredentials(Authenticatable $user, Array $credentials)
  {
      return ($credentials['username'] == $user->getAuthIdentifier() &&
    md5($credentials['password']) == $user->getAuthPassword());
  }

  public function retrieveById($identifier) {}

  public function retrieveByToken($identifier, $token) {}

  public function updateRememberToken(Authenticatable $user, $token) {}
}

Sekali lagi, Anda perlu memastikan bahwa custom provider harus menerapkan aturan Illuminate\Contracts\Auth\UserProvider.

Kedepannya, ini mendefinisikan dua method penting — retrieveByCredentials dan validateCredentials.

Method retrieveByCredentials method digunakan untuk mengambil data identitas pengguna menggunakan user model class yang telah dibahas di bagian sebelumnya. Di sisi lain, method validateCredentials digunakan untuk memvalidasi pengguna terhadap sekumpulan identitas yang diberikan.

Itu adalah implementasi dari custom authentication provider kita. Pada bagian selanjutnya, kita akan membuat guards yang berinteraksi dengan authentication provider MongoUserProvider.

Mengatur Authentication Guard

Seperti yang telah kita bahas sebelumnya, guard pada sistem otentikasi Laravel menentukan bagaimana pengguna diautentikasi. Dalam hal ini, kita akan memeriksa keberadaan permintaan parameter jsondata yang berisi identitas string pada JSON-encoded.

Pada bagian ini, kita akan membuat guard yang berinteraksi dengan authentication provider yang telah kita buat sebelumnya.

Buat file app/Services/Auth/JsonGuard.php dengan isi sebagai berikut.

<?php
// app/Services/Auth/JsonGuard.php
namespace App\Services\Auth;

use Illuminate\Http\Request;
use Illuminate\Contracts\Auth\Guard;
use Illuminate\Contracts\Auth\UserProvider;
use GuzzleHttp\json_decode;
use phpDocumentor\Reflection\Types\Array_;
use Illuminate\Contracts\Auth\Authenticatable;

class JsonGuard implements Guard
{
  protected $request;
  protected $provider;
  protected $user;

  /**
   * Create a new authentication guard.
   *
   * @param  \Illuminate\Contracts\Auth\UserProvider  $provider
   * @param  \Illuminate\Http\Request  $request
   * @return void
   */
  public function __construct(UserProvider $provider, Request $request)
  {
    $this->request = $request;
    $this->provider = $provider;
    $this->user = NULL;
  }

  /**
   * Determine if the current user is authenticated.
   *
   * @return bool
   */
  public function check()
  {
    return ! is_null($this->user());
  }

  /**
   * Determine if the current user is a guest.
   *
   * @return bool
   */
  public function guest()
  {
    return ! $this->check();
  }

  /**
   * Get the currently authenticated user.
   *
   * @return \Illuminate\Contracts\Auth\Authenticatable|null
   */
  public function user()
  {
    if (! is_null($this->user)) {
      return $this->user;
    }
  }
    
  /**
   * Get the JSON params from the current request
   *
   * @return string
   */
  public function getJsonParams()
  {
    $jsondata = $this->request->query('jsondata');

    return (!empty($jsondata) ? json_decode($jsondata, TRUE) : NULL);
  }

  /**
   * Get the ID for the currently authenticated user.
   *
   * @return string|null
  */
  public function id()
  {
    if ($user = $this->user()) {
      return $this->user()->getAuthIdentifier();
    }
  }

  /**
   * Validate a user's credentials.
   *
   * @return bool
   */
  public function validate(Array $credentials=[])
  {
    if (empty($credentials['username']) || empty($credentials['password'])) {
      if (!$credentials=$this->getJsonParams()) {
        return false;
      }
    }

    $user = $this->provider->retrieveByCredentials($credentials);
      
    if (! is_null($user) && $this->provider->validateCredentials($user, $credentials)) {
      $this->setUser($user);

      return true;
    } else {
      return false;
    }
  }

  /**
   * Set the current user.
   *
   * @param  Array $user User info
   * @return void
   */
  public function setUser(Authenticatable $user)
  {
    $this->user = $user;
    return $this;
  }
}

Pertama, class kita perlu menerapkan interface Illuminate\Contracts\Auth\Guard. Dengan demikian, kita perlu mendefinisikan semua method yang dideklarasikan di interface tersebut.

Hal penting yang perlu diingat disini adalah fungsi __construct memerlukan penerapan dari Illuminate\Contracts\Auth\UserProvider. Dalam hal ini, kita akan melewati contoh dari App\Extensions\MongoUserProvider, yang akan kita bahas di bagian berikutnya.

Selanjutnya, terdapat fungsi getJsonParams yang mengambil data identitas user dari permintaan parameter bernama jsondata. Diharapkan bahwa kita akan menerima JSON-encoded string yang berisi identitas pengguna, kita telah menggunakan fungsi json_decode untuk mendecode data JSON.

Pada fungsi validasi, hal yang harus dicek terlebih dahulu adalah argumen $credentials. Jika tidak ada, kita akan memanggil method getJsonParams untuk mengambil data identitas pengguna dari permintaan parameter.

Setelah itu, kita memanggil fungsi retrieveByCredentials yang merupakan method dari provider MongoUserProvider yang mengambil data pengguna dari database back-end MongoDB. Terakhir, yaitu validateCredentials yang merupakan method dari provider MongoUserProvider yang memeriksa validitas pengguna.

Itu adalah implementasi dari custom guard kita. Bagian selanjutnya menjelaskan bagaimana menyatukan potongan-potongan ini bersama-sama untuk membentuk sistem otentikasi yang berhasil.

Menggabungkan Semuanya

Sejauh ini, kita telah mengembangkan semua elemen dari custom authentication guard yang seharusnya memberi kita sistem autentikasi baru. Namun, tidak akan berhasil karena kita perlu mendaftarkannya terlebih dahulu menggunakan Laravel service container bindings.

Seperti yang Anda tahu, penyedia layanan Laravel adalah tempat yang tepat untuk menerapkan binding yang diperlukan.

Buka file app/Providers/AuthServiceProvider.php yang mengizinkan kita untuk menambah otentikasi service container bindings. Jika tidak terdapat perubahan apapun, Anda bisa menggantinya dengan isi seperti berikut ini.

<?php
// app/Providers/AuthServiceProvider.php
namespace App\Providers;

use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Gate;
use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
use App\Services\Auth\JsonGuard;
use App\Extensions\MongoUserProvider;
use App\Database\MongoDatabase;
use App\Models\Auth\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Config;

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();
    
    $this->app->bind('App\Database\MongoDatabase', function ($app) {
      return new MongoDatabase(config('mongo.defaults.host'), config('mongo.defaults.port'), config('mongo.defaults.database'));
    });
    
    $this->app->bind('App\Models\Auth\User', function ($app) {
      return new User($app->make('App\Database\MongoDatabase'));
    });

    // add custom guard provider
    Auth::provider('mongo', function ($app, array $config) {
      return new MongoUserProvider($app->make('App\Models\Auth\User'));
    });

    // add custom guard
    Auth::extend('json', function ($app, $name, array $config) {
      return new JsonGuard(Auth::createUserProvider($config['provider']), $app->make('request'));
    });
  }

  public function register()
  {
    $this->app->bind(
      'App\Services\Contracts\NosqlServiceInterface',
      'App\Database\MongoDatabase'
    );
  }
}

Mari kita gunakan method boot yang berisi sebagian besar provider bindings.

Untuk memulainya, kita akan membuat binding untuk App\Database\MongoDatabase dan elemen App\Models\Auth\User.

$this->app->bind('App\Database\MongoDatabase', function ($app) {
  return new MongoDatabase(config('mongo.defaults.host'), config('mongo.defaults.port'), config('mongo.defaults.database'));
});

$this->app->bind('App\Models\Auth\User', function ($app) {
  return new User($app->make('App\Database\MongoDatabase'));
});

Sudah lama kita membicarakan provider dan guard, dan sekarang saatnya untuk memasukkan custom guard kita ke dalam sistem otentikasi Laravel.

kita telah menggunakan method provider dari Auth untuk menambah custom authentication provider kita pada mongo. Perlu diingat bahwa key tersebut merupakan pengaturan yang ditambahkan sebelumnya di file auth.php.

Auth::provider('mongo', function ($app, array $config) {
  return new MongoUserProvider($app->make('App\Models\Auth\User'));
});

Dengan cara yang sama, kami akan menyisipkan implementasi custom guardi menggunakan metode extend Auth facade.

Auth::extend('json', function ($app, $name, array $config) {
  return new JsonGuard(Auth::createUserProvider($config['provider']), $app->make('request'));
});

Selanjutnya, ada metode register bahwa kami telah digunakan untuk mengikat interface App\Services\Contracts\NosqlServiceInterface ke implementasi App\Database\MongoDatabase.

$this->app->bind(
  'App\Services\Contracts\NosqlServiceInterface',
  'App\Database\MongoDatabase'
);

Jadi kapanpun kita butuh untuk menyelesaikan dependensi App\Services\Contracts\NosqlServiceInterface, Laravel merespon dengan penerapan dari adapter App\Database\MongoDatabase.

Manfaat menggunakan pendekatan ini adalah dengan mudah bisa menukar implementasi yang diberikan dengan implementasi kustom. Misalnya, misalkan seseorang ingin mengganti implementasi App\Database\MongoDatabase dengan CouchDB adapter. Dalam hal itu, In that case, mereka hanya perlu menambahkan binding yang sesuai dengan method register.

Jadi, itulah penyedia layanan yang Anda inginkan. Pada saat ini, kita memiliki semua yang diperlukan untuk menguji implementasi custom guard kita, jadi bagian berikutnya dan penutup adalah semua hal tentang itu.

Apakah Itu Bekerja?

Anda telah melakukan semua kerja keras untuk menyiapkan custom authentication guard pertama Anda, dan sekarang saatnya untuk menuai keuntungan seperti yang akan kita lakukan selanjutnya dan cobalah.

Mari kita implementasikan file controller dasar dengan cepat app/Http/Controllers/MongoController.php seperti yang ditunjukkan dibawah ini.

<?php
// app/Http/Controllers/MongoController.php
namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use Illuminate\Contracts\Auth\Guard;

class MongoController extends Controller
{
  public function login(Guard $auth_guard)
  {
    if ($auth_guard->validate()) {
      // get the current authenticated user
      $user = $auth_guard->user();
    
      echo 'Success!';
    } else {
      echo 'Not authorized to access this page!';
    }
  }
}

Perhatikan baik-baik dependency pada method login, yang memerlukan implementasi guard Illuminate\Contracts\Auth\Guard. Karena kita telah mengatur custom guard kita sebagai guard default pada file auth.php, yang akan disisipkan pada App\Services\Auth\JsonGuard

Kemudian, kita panggil fungsi validate pada class App\Services\Auth\JsonGuard, yang pada gilirannya memulai serangkaian pemanggilan method:

Memanggil method retrieveByCredentials dari class App\Extensions\MongoUserProvider.
Method retrieveByCredentials memanggil method fetchUserByCredentials dari class pengguna App\Models\Auth\User.
Method fetchUserByCredentials memanggil method find yang merupakan method dari App\Database\MongoDatabase untuk mengambil data identitas pengguna.
Terakhir, metod find yang merupakan method dari App\Database\MongoDatabase mengembalikan respon!

Jika semuanya bekerja seperti yang diharapkan, kita harus mendapatkan pengguna yang terautentikasi dengan memanggil method user dari guard.

untuk mengakses controller, Anda perlu menambahkan rute pada file routes/web.php.

Route::get('/custom/mongo/login', 'MongoController@login');

Cobalah mengakses alamat http://your-laravel-site/custom/mongo/login tanpa melewati parameter apapun dan Anda akan melihat pesan "not authorized".

Di sisi lain, cobalah mengakses http://your-laravel-site/custom/mongo/login?jsondata={"username":"admin","password":"admin"} dan itu akan menampilkan pesan sukses jika pengguna ada di database Anda.

Harap dicatat bahwa ini hanya untuk tujuan tertentu, untuk menunjukkan bagaimana authentication provider bekerja. Anda harus menerapkan solusi yang sangat mudah untuk fitur seperti login. Sebenarnya, saya baru saja memberikan wawasan tentang proses otentikasi; Anda bertanggung jawab untuk membangun solusi yang kuat dan aman untuk aplikasi Anda.

Itu mengakhiri perjalanan kita hari ini, dan mudah-mudahan saya akan kembali dengan hal-hal yang lebih bermanfaat lainnya. Jika Anda ingin saya menulis topik tertentu, jangan lupa memberitahu saya!

Kesimpulan

Framework LaravelThe Laravel framework menyediakan sistem otentikasi solid pada inti sistem yang bisa dikembangkan jika Anda ingin menerapkan yang custom. Itulah topik artikel hari ini untuk menerapkan authentication guard dan memasukkannya ke alur kerja otentikasi Laravel.

Dalam kursus tersebut, Kami terus mengembangkan sistem yang mengotentikasi pengguna berdasarkan muatan JSON sesuai permintaan dan mencocokkannya dengan database MongoDB. Dan untuk mencapainya, akhirnya kami menciptakan custom guard dan implementasi custom provider.

Saya harap latihan ini telah memberi Anda wawasan tentang aliran otentikasi Laravel, dan sekarang Anda seharusnya merasa lebih percaya diri.

Bagi Anda yang baru saja memulai dengan Laravel atau ingin memperluas pengetahuan, situs, atau aplikasi Anda dengan ekstensi, kami memiliki berbagai hal yang dapat Anda pelajari di Envato Market.

Saya ingin mendengar masukan dan saran Anda, jadi silahkan menggunakan feedback di bawah ini!