Single Page Application (SPA) menjadi semakin populer dalam pengembangan web modern. SPA menawarkan pengalaman pengguna yang mulus dan interaktif, tetapi juga membawa tantangan tersendiri, terutama dalam hal keamanan autentikasi. Nah, di sinilah Laravel Sanctum Authentication untuk Single Page Application hadir sebagai solusi yang handal dan aman. Dalam artikel ini, kita akan membahas secara mendalam mengapa Sanctum menjadi pilihan terbaik untuk mengamankan SPA Anda yang dibangun dengan Laravel.

Daftar Isi

1. Apa Itu Single Page Application (SPA) dan Mengapa Keamanan Penting?
2. Mengenal Lebih Dekat Laravel Sanctum: Solusi Autentikasi Modern
3. Mengapa Memilih Laravel Sanctum untuk Autentikasi SPA Anda?
4. Konfigurasi Laravel Sanctum untuk Aplikasi SPA: Langkah Demi Langkah
5. Implementasi Login dan Logout dengan Laravel Sanctum pada SPA
6. Mengamankan Rute API Anda dengan Sanctum Middleware
7. Menangani Refresh Token dengan Laravel Sanctum untuk Pengalaman Pengguna yang Lebih Baik
8. Tips dan Trik Optimasi Keamanan Laravel Sanctum pada SPA
9. Studi Kasus: Penerapan Laravel Sanctum pada Proyek SPA Nyata
10. Mengatasi Permasalahan Umum (Troubleshooting) pada Laravel Sanctum SPA Authentication
11. Alternatif Laravel Sanctum: Pilihan Autentikasi Lain untuk SPA
12. Kesimpulan: Laravel Sanctum, Pilihan Utama Keamanan SPA Anda

1. Apa Itu Single Page Application (SPA) dan Mengapa Keamanan Penting?

Sebelum membahas lebih jauh tentang Laravel Sanctum, mari kita pahami dulu apa itu Single Page Application (SPA). SPA adalah aplikasi web yang memuat satu halaman HTML saja dan secara dinamis memperbarui konten halaman tersebut melalui JavaScript. Ini berbeda dengan aplikasi web tradisional yang memuat ulang halaman setiap kali pengguna berinteraksi.

Keunggulan SPA meliputi:

• Pengalaman Pengguna yang Lebih Baik: Transisi halaman yang mulus dan responsif.
• Performa Lebih Cepat: Hanya data yang dibutuhkan yang dikirimkan, bukan seluruh halaman.
• Pengembangan yang Lebih Efisien: Pemisahan frontend dan backend yang jelas.

Namun, dengan keunggulan ini datang pula tantangan keamanan. Karena SPA berinteraksi langsung dengan API backend, penting untuk memastikan bahwa hanya pengguna yang berwenang yang dapat mengakses data sensitif. Jika autentikasi tidak diimplementasikan dengan benar, SPA rentan terhadap serangan seperti:

Related Post

Laravel Queue System untuk Background Processing: Tingkatkan Performa Aplikasi Web Anda

July 25, 2025

Hosting Laravel Terbaik dengan Konfigurasi Mudah: Deploy Aplikasi Laravel dengan Cepat

July 24, 2025

Contoh Project Laravel Sederhana dengan CRUD Operations: Aplikasi Web Interaktif

July 24, 2025

Integrasi Payment Gateway Midtrans dengan Laravel: Transaksi Online Aman dan Mudah

July 24, 2025

• Cross-Site Scripting (XSS): Penyerang menyuntikkan kode berbahaya ke dalam aplikasi.
• Cross-Site Request Forgery (CSRF): Penyerang menipu pengguna untuk melakukan tindakan yang tidak diinginkan.
• Token Theft: Penyerang mencuri token autentikasi pengguna.

Oleh karena itu, keamanan SPA menjadi prioritas utama, dan autentikasi yang kuat adalah fondasinya.

2. Mengenal Lebih Dekat Laravel Sanctum: Solusi Autentikasi Modern

Laravel Sanctum adalah paket autentikasi yang ringan dan dirancang khusus untuk API dan SPA. Sanctum menyediakan cara sederhana dan aman untuk mengautentikasi pengguna yang mengakses API Anda melalui:

• API Tokens: Untuk aplikasi mobile dan client lain yang bukan browser (biasanya disebut “first-party”). Token ini diberikan kepada pengguna dan digunakan untuk mengakses API.
• Cookies: Untuk SPA yang berinteraksi dengan API di domain yang sama. Sanctum menggunakan cookies untuk melacak sesi pengguna, yang lebih aman daripada menyimpan token di localStorage.

Sanctum memanfaatkan fitur-fitur keamanan bawaan Laravel, seperti:

• CSRF Protection: Melindungi aplikasi dari serangan CSRF.
• Encryption: Mengenkripsi data sensitif, seperti token autentikasi.

Dengan menggunakan Sanctum, Anda dapat dengan mudah menambahkan autentikasi ke SPA Anda tanpa harus repot mengimplementasikan mekanisme keamanan yang rumit dari awal.

3. Mengapa Memilih Laravel Sanctum untuk Autentikasi SPA Anda?

Ada banyak solusi autentikasi yang tersedia, tetapi Laravel Sanctum menonjol karena beberapa alasan:

• Sederhana dan Mudah Digunakan: Sanctum sangat mudah diintegrasikan dengan aplikasi Laravel Anda. Dengan beberapa konfigurasi sederhana, Anda sudah dapat mengamankan SPA Anda.
• Aman: Sanctum menggunakan praktik keamanan terbaik, seperti perlindungan CSRF dan enkripsi, untuk melindungi aplikasi Anda dari serangan.
• Ringan: Sanctum tidak membebani aplikasi Anda dengan dependensi yang tidak perlu.
• Laravel-Centric: Sanctum dirancang khusus untuk Laravel, sehingga terintegrasi dengan mulus dengan fitur-fitur Laravel lainnya.
• Mengatasi Masalah CORS (Cross-Origin Resource Sharing): Sanctum secara otomatis menangani konfigurasi CORS yang diperlukan untuk SPA.
• First-Party Authentication: Lebih cocok dan aman untuk aplikasi “first-party” yang berjalan di domain yang sama dengan API backend Anda dibandingkan metode lain seperti JWT. JWT memiliki potensi masalah keamanan jika digunakan dengan localStorage pada browser.

Dengan semua keunggulan ini, Laravel Sanctum adalah pilihan ideal untuk mengamankan SPA Anda dengan aman dan efisien.

4. Konfigurasi Laravel Sanctum untuk Aplikasi SPA: Langkah Demi Langkah

Berikut adalah langkah-langkah untuk mengkonfigurasi Laravel Sanctum pada aplikasi SPA Anda:

1. Instalasi Sanctum:
   Jalankan perintah berikut pada terminal proyek Laravel Anda:

   composer require laravel/sanctum

2. Migrasi Database:
   Sanctum membutuhkan beberapa tabel database untuk menyimpan token API. Jalankan perintah berikut untuk membuat tabel-tabel tersebut:

   php artisan migrate

3. Konfigurasi Middleware:
   Tambahkan middleware Sanctum ke kernel HTTP Anda (app/Http/Kernel.php):

   protected $middlewareGroups = [
       'web' => [
           AppHttpMiddlewareEncryptCookies::class,
           IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class,
           IlluminateSessionMiddlewareStartSession::class,
           IlluminateViewMiddlewareShareErrorsFromSession::class,
           AppHttpMiddlewareVerifyCsrfToken::class,
           IlluminateRoutingMiddlewareSubstituteBindings::class,
       ],
   
       'api' => [
           LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful::class,
           'throttle:api',
           IlluminateRoutingMiddlewareSubstituteBindings::class,
       ],
   ];

   Penting: EnsureFrontendRequestsAreStateful adalah kunci untuk autentikasi berbasis cookies pada SPA.

4. Konfigurasi CORS (Cross-Origin Resource Sharing):
   Pastikan CORS dikonfigurasi dengan benar untuk memungkinkan permintaan dari domain SPA Anda. Anda dapat mengkonfigurasi CORS melalui config/cors.php atau dengan menggunakan paket seperti fruitcake/laravel-cors. Pastikan bahwa domain SPA Anda diizinkan untuk melakukan permintaan. Contoh konfigurasi di config/cors.php:

   return [
       'paths' => ['api/*'],
       'allowed_methods' => ['*'],
       'allowed_origins' => ['http://localhost:3000'], // Ganti dengan domain SPA Anda
       'allowed_origins_patterns' => [],
       'allowed_headers' => ['*'],
       'exposed_headers' => [],
       'supports_credentials' => true,
       'max_age' => 0,
   ];

   Perhatikan supports_credentials harus true agar cookies dapat dikirim dalam permintaan CORS.

5. Konfigurasi .env:
   Pastikan SESSION_DOMAIN diatur dengan benar di file .env Anda. Jika SPA dan API Anda berada di subdomain yang berbeda (misalnya, spa.example.com dan api.example.com), Anda harus mengatur SESSION_DOMAIN ke .example.com agar cookies dapat dibagikan. Jika berada di domain yang sama, biarkan kosong.

   SESSION_DOMAIN=.example.com

   Juga pastikan SANCTUM_STATEFUL_DOMAINS berisi domain SPA Anda. Misalnya:

   SANCTUM_STATEFUL_DOMAINS=localhost:3000,127.0.0.1:8000,example.com

   Restart server Anda setelah mengubah file .env.

5. Implementasi Login dan Logout dengan Laravel Sanctum pada SPA

Setelah konfigurasi selesai, mari kita implementasikan proses login dan logout pada SPA kita.

Login:

1. Buat endpoint login di Laravel:

   use IlluminateHttpRequest;
   use IlluminateSupportFacadesAuth;
   use IlluminateSupportFacadesHash;
   use AppModelsUser;
   
   Route::post('/login', function (Request $request) {
       $request->validate([
           'email' => 'required|email',
           'password' => 'required',
       ]);
   
       $user = User::where('email', $request->email)->first();
   
       if (!$user || !Hash::check($request->password, $user->password)) {
           return response([
               'message' => ['These credentials do not match our records.']
           ], 404);
       }
   
       Auth::login($user); // Penting untuk autentikasi berbasis cookies
   
       $token = $user->createToken('myapptoken')->plainTextToken;
   
       $response = [
           'user' => $user,
           'token' => $token
       ];
   
       return response($response, 201);
   });
   
   Route::get('/user', function (Request $request) {
       return $request->user();
   })->middleware('auth:sanctum');

   Catatan: Perhatikan penggunaan Auth::login($user) setelah verifikasi kredensial. Ini penting untuk autentikasi berbasis cookies oleh Sanctum. Endpoint /user dilindungi oleh auth:sanctum middleware, memastikan hanya pengguna yang terautentikasi yang dapat mengaksesnya.

2. Di SPA Anda (contoh menggunakan Axios):

   import axios from 'axios';
   
   async function login(email, password) {
       try {
           const response = await axios.post('/login', {
               email: email,
               password: password
           }, { withCredentials: true }); // Penting: withCredentials: true
           localStorage.setItem('token', response.data.token)
           return response.data;
       } catch (error) {
           console.error(error);
           throw error;
       }
   }
   
   export default login;

   Perhatikan: withCredentials: true harus diatur pada permintaan Axios agar cookies dapat dikirim ke server.

Logout:

1. Buat endpoint logout di Laravel:

   use IlluminateHttpRequest;
   use IlluminateSupportFacadesAuth;
   
   Route::post('/logout', function (Request $request) {
       $request->user()->currentAccessToken()->delete();
       Auth::logout(); // Hapus sesi pengguna
       return response()->json(['message' => 'Logged out']);
   })->middleware('auth:sanctum');

   Catatan: Endpoint ini juga dilindungi oleh auth:sanctum middleware. Auth::logout() menghapus sesi pengguna.

2. Di SPA Anda:

   import axios from 'axios';
   
   async function logout() {
       try {
           await axios.post('/logout', {}, { withCredentials: true }); // Penting: withCredentials: true
           localStorage.removeItem('token');
           return true;
       } catch (error) {
           console.error(error);
           throw error;
           return false;
       }
   }
   
   export default logout;

   Perhatikan: Sekali lagi, withCredentials: true penting untuk mengirim cookies ke server. Setelah logout berhasil, hapus token dari localStorage.

6. Mengamankan Rute API Anda dengan Sanctum Middleware

Setelah berhasil login dan logout, langkah selanjutnya adalah mengamankan rute API Anda. Ini dilakukan dengan menggunakan Sanctum middleware.

Anda telah melihat penggunaan auth:sanctum middleware pada contoh login dan logout. Middleware ini memeriksa apakah pengguna telah terautentikasi sebelum mengizinkan akses ke rute.

Contoh:

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

Hanya pengguna yang terautentikasi yang dapat mengakses rute /profile. Jika pengguna belum login, mereka akan diarahkan ke halaman login (atau respons error akan dikembalikan, tergantung pada konfigurasi Anda).

Anda juga dapat menggunakan middleware untuk mengamankan seluruh kelompok rute:

Route::middleware('auth:sanctum')->group(function () {
    Route::get('/posts', 'PostController@index');
    Route::post('/posts', 'PostController@store');
    Route::put('/posts/{id}', 'PostController@update');
    Route::delete('/posts/{id}', 'PostController@destroy');
});

Semua rute di dalam kelompok ini akan dilindungi oleh auth:sanctum middleware.

7. Menangani Refresh Token dengan Laravel Sanctum untuk Pengalaman Pengguna yang Lebih Baik

Walaupun Laravel Sanctum tidak memiliki mekanisme refresh token built-in seperti JWT, kita dapat mengimplementasikan strategi serupa untuk memberikan pengalaman pengguna yang lebih baik, terutama jika sesi cookies memiliki waktu kedaluwarsa yang relatif singkat. Ide utamanya adalah memperpanjang masa berlaku sesi cookies sebelum kedaluwarsa.

Salah satu cara untuk mencapai ini adalah dengan membuat middleware kustom yang memeriksa apakah sesi akan segera kedaluwarsa dan memperbaruinya jika perlu.

1. Buat Middleware Kustom:

   <?php
   
   namespace AppHttpMiddleware;
   
   use Closure;
   use IlluminateSupportFacadesAuth;
   use SymfonyComponentHttpFoundationCookie;
   
   class RefreshCookie
   {
       public function handle($request, Closure $next)
       {
           $response = $next($request);
   
           if (Auth::check() && time() > session('expires_at') - 60 * 5) { // 5 minutes before expiry
               session(['expires_at' => time() + config('session.lifetime') * 60]);
   
               // Set ulang cookie sesi agar kedaluwarsa lebih lama (opsional)
               $cookie = new Cookie(
                   config('session.cookie'),
                   $request->session()->getId(),
                   time() + config('session.lifetime') * 60,
                   config('session.path'),
                   config('session.domain'),
                   config('session.secure'),
                   config('session.http_only'),
                   false,
                   config('session.same_site')
               );
   
               $response->headers->setCookie($cookie);
           }
   
           return $response;
       }
   }

2. Daftarkan Middleware:

   Tambahkan middleware RefreshCookie ke app/Http/Kernel.php, misalnya di web middleware group.

   protected $middlewareGroups = [
       'web' => [
           // ... other middleware
           AppHttpMiddlewareRefreshCookie::class,
       ],
       // ...
   ];

Penjelasan:

• Middleware ini memeriksa apakah pengguna telah login (Auth::check()).

• Ia memeriksa apakah waktu saat ini kurang dari 5 menit sebelum sesi kedaluwarsa. session('expires_at') diasumsikan telah diatur ketika pengguna login. Anda perlu mengaturnya saat login (lihat contoh login di atas):

  Auth::login($user);
  session(['expires_at' => time() + config('session.lifetime') * 60]); // Sesuaikan dengan konfigurasi session Anda

• Jika ya, ia memperbarui expires_at di sesi dan juga memperbarui cookie sesi (opsional, tetapi disarankan).

• Dengan cara ini, sesi cookies akan diperpanjang secara otomatis setiap kali pengguna aktif sebelum sesi benar-benar kedaluwarsa.

Keuntungan:

• Pengalaman pengguna yang lebih baik: Pengguna tidak perlu sering login kembali.
• Keamanan yang lebih baik: Tidak perlu menyimpan refresh token di client, yang berpotensi rentan terhadap pencurian.

Keterbatasan:

• Membutuhkan aktivitas pengguna secara teratur untuk memperpanjang sesi. Jika pengguna tidak aktif selama waktu sesi, mereka tetap akan logout.

8. Tips dan Trik Optimasi Keamanan Laravel Sanctum pada SPA

Berikut adalah beberapa tips dan trik untuk mengoptimalkan keamanan Laravel Sanctum pada SPA Anda:

• Gunakan HTTPS: Pastikan semua komunikasi antara SPA dan API Anda menggunakan HTTPS untuk melindungi data dari intersepsi.
• Validasi Input: Selalu validasi semua input yang diterima dari SPA untuk mencegah serangan seperti SQL injection dan XSS.
• Rate Limiting: Implementasikan rate limiting untuk melindungi API Anda dari serangan brute force. Laravel menyediakan fitur rate limiting yang mudah digunakan.
• Monitor Log: Monitor log aplikasi Anda secara teratur untuk mendeteksi aktivitas yang mencurigakan.
• Gunakan Tools Keamanan: Gunakan tools keamanan seperti OWASP ZAP untuk melakukan pengujian penetrasi pada aplikasi Anda.
• Perbarui Laravel dan Sanctum: Selalu perbarui Laravel dan Sanctum ke versi terbaru untuk mendapatkan perbaikan keamanan terbaru.
• Konfigurasi Header Keamanan: Konfigurasikan header keamanan HTTP seperti X-Frame-Options, X-XSS-Protection, dan Content-Security-Policy untuk melindungi aplikasi Anda dari serangan.
• Review Kode: Lakukan code review secara teratur untuk menemukan potensi kerentanan keamanan.
• Jangan Simpan Data Sensitif di localStorage: Hindari menyimpan data sensitif seperti token autentikasi di localStorage. Cookies dengan flag HttpOnly jauh lebih aman.

9. Studi Kasus: Penerapan Laravel Sanctum pada Proyek SPA Nyata

[Di sini, berikan contoh bagaimana Laravel Sanctum diterapkan pada proyek SPA nyata. Jelaskan tantangan yang dihadapi dan bagaimana Sanctum membantu mengatasinya. Misalnya, sebuah aplikasi e-commerce yang membutuhkan keamanan tinggi untuk transaksi dan data pengguna.]

(Karena saya tidak memiliki data proyek nyata yang spesifik, saya akan memberikan contoh hipotetis):

Studi Kasus: Aplikasi Manajemen Proyek Berbasis SPA

Sebuah perusahaan pengembangan perangkat lunak membangun aplikasi manajemen proyek berbasis SPA menggunakan React di frontend dan Laravel di backend. Aplikasi ini menyimpan informasi sensitif mengenai proyek, tugas, dan data karyawan. Keamanan menjadi prioritas utama.

Tantangan:

• Memastikan hanya pengguna yang terautentikasi yang dapat mengakses data proyek.
• Melindungi API dari serangan CSRF.
• Memberikan pengalaman pengguna yang mulus tanpa mengharuskan pengguna untuk sering login kembali.
• Mengamankan transfer data sensitif melalui HTTPS.

Solusi dengan Laravel Sanctum:

• Autentikasi Berbasis Cookies: Mereka memilih menggunakan autentikasi berbasis cookies dari Sanctum untuk memastikan keamanan dan pengalaman pengguna yang lebih baik. Token tidak disimpan di localStorage, sehingga mengurangi risiko pencurian token.
• Middleware auth:sanctum: Semua rute API yang berhubungan dengan data proyek dilindungi oleh middleware auth:sanctum.
• Perlindungan CSRF: Sanctum secara otomatis menangani perlindungan CSRF.
• HTTPS: Aplikasi dikonfigurasi untuk menggunakan HTTPS untuk semua komunikasi.
• Refresh Cookie Middleware: Middleware refresh cookie diimplementasikan untuk memperpanjang sesi cookies secara otomatis saat pengguna aktif.

Hasil:

• Aplikasi berhasil diamankan dari akses yang tidak sah.
• Serangan CSRF berhasil dicegah.
• Pengguna mendapatkan pengalaman yang mulus tanpa harus sering login kembali.
• Data sensitif dilindungi dengan enkripsi HTTPS.

Kesimpulan:

Laravel Sanctum terbukti menjadi solusi yang efektif dan efisien untuk mengamankan aplikasi manajemen proyek berbasis SPA ini. Fitur-fitur keamanannya yang komprehensif, kemudahan penggunaan, dan integrasi yang mulus dengan Laravel membuat Sanctum menjadi pilihan yang ideal.

10. Mengatasi Permasalahan Umum (Troubleshooting) pada Laravel Sanctum SPA Authentication

Berikut adalah beberapa masalah umum yang sering terjadi saat mengimplementasikan Laravel Sanctum pada SPA dan cara mengatasinya:

• Masalah CORS:

  • Penyebab: Konfigurasi CORS yang salah.
  • Solusi: Pastikan allowed_origins di config/cors.php berisi domain SPA Anda dan supports_credentials diatur ke true. Pastikan juga SANCTUM_STATEFUL_DOMAINS di .env diisi dengan domain SPA Anda. Periksa juga apakah browser memblokir request karena CORS.

• Cookies Tidak Dikirim:

  • Penyebab: withCredentials: true tidak diatur pada permintaan Axios.
  • Solusi: Tambahkan withCredentials: true ke konfigurasi permintaan Axios Anda.

• Sesi Tidak Berjalan (Session not working):

  • Penyebab: Middleware EnsureFrontendRequestsAreStateful tidak dikonfigurasi dengan benar, atau SESSION_DOMAIN tidak diatur dengan benar di .env.
  • Solusi: Pastikan middleware EnsureFrontendRequestsAreStateful ada di api middleware group pada app/Http/Kernel.php. Pastikan SESSION_DOMAIN diatur dengan benar di .env.

• Token Mismatch:

  • Penyebab: Cache browser yang bermasalah.
  • Solusi: Bersihkan cache browser atau gunakan mode incognito.

• Logout Tidak Berfungsi:

  • Penyebab: Endpoint logout tidak dilindungi dengan auth:sanctum middleware atau Auth::logout() tidak dipanggil pada endpoint.
  • Solusi: Pastikan endpoint logout dilindungi dengan auth:sanctum dan Auth::logout() dipanggil.

11. Alternatif Laravel Sanctum: Pilihan Autentikasi Lain untuk SPA

Walaupun Laravel Sanctum adalah pilihan yang sangat baik untuk autentikasi SPA, ada beberapa alternatif lain yang perlu dipertimbangkan, tergantung pada kebutuhan spesifik proyek Anda:

• JWT (JSON Web Tokens): JWT adalah standar industri untuk pertukaran token yang aman. JWT dapat digunakan untuk autentikasi tanpa state (stateless). Namun, penggunaan JWT dengan localStorage di browser rentan terhadap serangan XSS. Jika Anda menggunakan JWT, pertimbangkan untuk menggunakan strategi yang lebih aman seperti menyimpan JWT di cookies dengan flag HttpOnly.
• Laravel Passport: Passport adalah paket autentikasi OAuth2 yang lebih lengkap dan cocok untuk API yang ingin Anda ekspos ke pihak ketiga. Passport lebih kompleks daripada Sanctum tetapi menawarkan fleksibilitas yang lebih besar.
• Socialite: Laravel Socialite memungkinkan Anda untuk mengautentikasi pengguna melalui penyedia sosial seperti Google, Facebook, dan Twitter.

Pilihan antara Sanctum, JWT, Passport, dan Socialite tergantung pada faktor-faktor seperti kompleksitas proyek, kebutuhan keamanan, dan apakah Anda perlu mengekspos API Anda ke pihak ketiga. Untuk SPA “first-party”, Sanctum biasanya merupakan pilihan yang paling sederhana dan aman.

12. Kesimpulan: Laravel Sanctum, Pilihan Utama Keamanan SPA Anda

Dalam dunia pengembangan web modern yang semakin kompleks, keamanan menjadi faktor krusial. Laravel Sanctum menyediakan solusi autentikasi yang mudah digunakan, aman, dan ringan untuk Single Page Application (SPA). Dengan fitur-fitur seperti perlindungan CSRF, autentikasi berbasis cookies, dan integrasi yang mulus dengan Laravel, Laravel Sanctum adalah pilihan utama untuk mengamankan SPA Anda dengan aman dan efisien. Dengan mengikuti panduan dan tips yang telah dibahas dalam artikel ini, Anda dapat membangun SPA yang aman dan terpercaya. Pastikan selalu untuk mengikuti praktik keamanan terbaik dan terus memperbarui aplikasi Anda untuk melindungi dari ancaman keamanan terbaru. Selamat mengembangkan!