Sau 49 bài, chúng ta đã đi từ những khái niệm đầu tiên của Laravel đến việc xây dựng một Blog CMS hoàn chỉnh.
Trong bài cuối cùng này, chúng ta sẽ không học thêm một tính năng mới.
Thay vào đó, chúng ta sẽ nhìn lại toàn bộ dự án:
Đã học những gì?
Các thành phần kết nối với nhau như thế nào?
Source code cần tối ưu ra sao?
Cần kiểm tra gì trước khi đưa website lên Internet?
Một dự án Laravel 13 hoàn chỉnh cần có những thành phần nào?
Đây cũng là bước chuyển từ:
"Học Laravel"
sang:
"Có thể tự xây dựng và triển khai một ứng dụng Laravel thực tế."
1. Dự án Blog CMS đã xây dựng
Trong suốt khóa học, chúng ta xây dựng một hệ thống Blog CMS có các chức năng chính:
BLOG CMS
│
┌──────────────┼──────────────┐
│ │ │
FRONTEND ADMIN API
│ │ │
▼ ▼ ▼
Blog list Dashboard REST API
Post detail Categories Sanctum
Category Posts Resources
Search Users Authentication
│ │ │
└──────────────┼──────────────┘
│
DATABASE
│
┌────────────┼────────────┐
▼ ▼ ▼
Users Categories Posts
Các thành phần chính gồm:
Authentication
Authorization
Users
Categories
Posts
Relationships
Validation
Upload Image
Search
Pagination
DataTables
Soft Delete
Events
Listeners
Queue
Mail
Notification
Cache
Storage
Logging
REST API
API Resource
Sanctum
Deployment
Nginx
Queue Worker
Scheduler
Production
Đây không còn là một ví dụ CRUD đơn giản.
Nó đã gần với cấu trúc của một ứng dụng web thực tế.
2. Nhìn lại toàn bộ khóa Laravel 13
PHẦN 1 — Làm quen với Laravel
Chúng ta bắt đầu bằng những thành phần cơ bản:
Laravel
│
├── Composer
├── Artisan
├── MVC
├── Routing
├── Controller
└── Blade
Ví dụ một request:
Browser
│
▼
Route
│
▼
Controller
│
▼
Model
│
▼
Database
│
▼
Controller
│
▼
Blade
│
▼
HTML
│
▼
Browser
Đây là flow quan trọng nhất cần hiểu.
3. Database và Migration
Chúng ta sử dụng Migration để quản lý cấu trúc database.
Ví dụ:
Schema::create('categories', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->string('slug')->unique();
$table->text('description')->nullable();
$table->boolean('is_active')->default(true);
$table->timestamps();
});
Thay vì tạo bảng thủ công bằng phpMyAdmin, cấu trúc database được lưu trong source code.
Điều này rất quan trọng khi làm việc nhóm hoặc triển khai lên server.
4. Seeder và Factory
Seeder giúp tạo dữ liệu ban đầu:
php artisan db:seed
Factory giúp tạo dữ liệu giả:
Post::factory()->count(50)->create();
Nhờ đó chúng ta có thể nhanh chóng tạo:
100 Users
100 Categories
1000 Posts
để kiểm tra:
Pagination
Search
DataTables
Performance
Relationship
5. Eloquent ORM
Eloquent là một trong những thành phần quan trọng nhất của Laravel.
Ví dụ:
$posts = Post::latest()->get();
Thay vì viết SQL trực tiếp:
SELECT *
FROM posts
ORDER BY created_at DESC;
Eloquent giúp code dễ đọc hơn.
Ví dụ:
$post = Post::find(1);
$post->update([
'title' => 'Laravel 13'
]);
Xóa:
$post->delete();
6. Relationship
Blog CMS sử dụng nhiều Relationship.
Ví dụ:
User
│
└── hasMany()
│
▼
Posts
Category
│
└── hasMany()
│
▼
Posts
Và:
Post
│
├── belongsTo(User)
│
└── belongsTo(Category)
Trong Model:
public function user()
{
return $this->belongsTo(User::class);
}
public function category()
{
return $this->belongsTo(Category::class);
}
Sau đó:
$post->user->name;
$post->category->name;
Đây chính là sức mạnh của Eloquent Relationship.
7. Request và Validation
Không nên tin dữ liệu từ người dùng.
Ví dụ:
$request->validate([
'title' => ['required', 'string', 'max:255'],
'content' => ['required'],
'category_id' => ['required', 'exists:categories,id'],
]);
Validation giúp đảm bảo dữ liệu trước khi đưa vào database.
Đối với upload:
'image' => [
'nullable',
'image',
'mimes:jpg,jpeg,png,webp',
'max:3072',
],
Validation phải được thực hiện ở server.
JavaScript phía client chỉ nên đóng vai trò hỗ trợ trải nghiệm người dùng.
8. Authentication
Breeze giúp chúng ta xây dựng:
Register
Login
Logout
Password
Session
Authentication
Sau khi đăng nhập:
auth()->user()
có thể lấy thông tin user hiện tại.
Ví dụ:
$user = auth()->user();
echo $user->name;
9. Authorization
Authentication trả lời:
Người này đã đăng nhập chưa?
Authorization trả lời:
Người này có quyền thực hiện hành động này không?
Ví dụ:
User
├── xem bài viết
└── không được quản lý user
Admin
├── xem bài viết
├── quản lý category
├── quản lý post
└── quản lý user
Đây là lý do chúng ta sử dụng:
Middleware
Policy
Gates
Role
Không nên chỉ ẩn nút bằng HTML.
Quyền phải được kiểm tra ở server.
10. CRUD Categories
Category là module CRUD đầu tiên của dự án.
Create
Read
Update
Delete
Ngoài ra còn:
Search
Pagination
Validation
Active / Inactive
Model có Scope:
#[Scope]
protected function active(Builder $query): void
{
$query->where('is_active', true);
}
Sau đó:
Category::active()->get();
Đây là một ví dụ về việc đưa logic truy vấn vào Model thay vì lặp lại trong Controller.
11. CRUD Posts
Post là module trung tâm của Blog CMS.
Một Post có:
title
slug
excerpt
content
image
status
published_at
view_count
user_id
category_id
Quan hệ:
User
│
└── Posts
Category
│
└── Posts
Post
├── User
└── Category
Controller xử lý:
Create
Edit
Update
Delete
Publish
Upload
Validation
Relationship
12. Blog Frontend
Phần frontend của Blog sử dụng:
BlogController
│
├── index()
├── show()
└── category()
Ví dụ danh sách bài viết:
Post::published()
->whereHas('category', fn ($query) => $query->active())
->with(['user', 'category'])
->latest('published_at')
->paginate(10);
Đây là một câu query đã kết hợp:
Local Scope
Relationship
Eager Loading
Sorting
Pagination
13. Eager Loading và vấn đề N+1
Một trong những lỗi performance phổ biến:
$posts = Post::all();
foreach ($posts as $post) {
echo $post->user->name;
}
Có thể dẫn tới rất nhiều query.
Thay vào đó:
$posts = Post::with('user')->get();
Hoặc:
$posts = Post::with([
'user',
'category'
])->get();
Nguyên tắc:
Khi biết trước sẽ sử dụng Relationship, hãy cân nhắc eager loading.
14. Search và Pagination
Không nên lấy toàn bộ database:
Post::all();
rồi xử lý bằng PHP khi dữ liệu lớn.
Thay vào đó:
Post::query()
->where('title', 'like', "%{$keyword}%")
->latest()
->paginate(10);
Database xử lý phần lớn công việc.
Ứng dụng chỉ nhận số lượng dữ liệu cần thiết.
15. Soft Delete
Chúng ta đã thêm:
use SoftDeletes;
vào Model.
Khi:
$post->delete();
Post không nhất thiết bị xóa khỏi database.
Nó được đánh dấu bằng:
deleted_at
Có thể lấy lại:
$post->restore();
Xóa vĩnh viễn:
$post->forceDelete();
Đây là cơ chế rất hữu ích cho CMS.
16. Events và Listeners
Event giúp tách các hành động phụ khỏi logic chính.
Ví dụ:
User Register
│
▼
Registered Event
│
▼
Listener
│
├── Send Email
├── Log
└── Notification
Controller không nhất thiết phải xử lý tất cả mọi việc.
17. Queue
Một số công việc không cần thực hiện ngay trong HTTP request.
Ví dụ:
Gửi email
Xử lý ảnh
Tạo báo cáo
Gửi notification
Import dữ liệu
Có thể đưa vào Queue:
Request
│
▼
Dispatch Job
│
▼
Response ngay
│
│
▼
Queue Worker
│
▼
Process Job
Nhờ đó website phản hồi nhanh hơn.
18. Mail và Notification
Laravel cung cấp hệ thống:
Mail
Notification
cho nhiều hình thức thông báo.
Ví dụ:
User đăng ký
│
▼
Notification
│
├── Mail
├── Database
└── các channel khác
Trong dự án thực tế, các tác vụ gửi mail số lượng lớn nên được kết hợp với Queue.
19. Cache
Cache dùng để giảm số lần truy vấn hoặc xử lý dữ liệu.
Ví dụ:
$categories = Cache::remember(
'blog.categories',
3600,
fn () => Category::active()->get()
);
Flow:
Request
│
▼
Cache?
┌─┴─┐
Có Không
│ │
▼ ▼
Data Database
│
▼
Cache
Nhưng cache phải có chiến lược invalidation.
Ví dụ khi Category thay đổi:
Cache::forget('blog.categories');
Không nên cache mọi thứ một cách máy móc.
20. Storage
File upload nên được quản lý thông qua Laravel Storage.
Ví dụ:
$path = $request->file('image')
->store('posts', 'public');
File có thể được lưu trong disk:
storage/app/public
và tạo symbolic link:
php artisan storage:link
Không nên tự xây dựng hệ thống upload bằng cách xử lý đường dẫn file một cách tùy tiện.
21. Logging và Debug
Khi production, log rất quan trọng.
Ví dụ:
Log::info('Post published', [
'post_id' => $post->id,
'user_id' => auth()->id(),
]);
Khi xảy ra lỗi:
Log::error('Post publish failed', [
'post_id' => $post->id,
]);
Development có thể sử dụng:
dd($data);
hoặc:
dump($data);
Nhưng production phải tránh để debug information xuất hiện cho người dùng.
Laravel 13 cũng cung cấp health route /up, hữu ích cho monitoring và kiểm tra ứng dụng đã boot thành công hay chưa.
22. REST API
Blog CMS của chúng ta không chỉ có giao diện HTML.
Chúng ta còn xây dựng API:
GET
POST
PUT / PATCH
DELETE
Ví dụ:
GET /api/posts
GET /api/posts/{id}
POST /api/posts
PUT /api/posts/{id}
DELETE /api/posts/{id}
API trả về JSON thay vì HTML.
23. API Resource
Không nên trả trực tiếp toàn bộ Model:
return $post;
Đối với API thực tế, nên kiểm soát dữ liệu trả về bằng:
PostResource
Ví dụ:
return new PostResource($post);
Danh sách:
return PostResource::collection($posts);
Resource giúp API có cấu trúc rõ ràng và tránh vô tình trả những dữ liệu không nên public.
24. Sanctum
Sanctum cung cấp cơ chế xác thực cho API.
Flow:
Client
│
│ email + password
▼
API Login
│
▼
Sanctum
│
▼
Token
│
▼
Client
Các request tiếp theo:
Authorization: Bearer TOKEN
Route private:
Route::middleware('auth:sanctum')->group(function () {
Route::get('/user', function (Request $request) {
return $request->user();
});
});
25. API Authentication
Một API thực tế cần có:
Register
Login
Logout
Current User
Token
Validation
Authorization
Và phải phân biệt:
401 Unauthorized
với:
403 Forbidden
Hiểu đơn giản:
401
→ Chưa xác thực / token không hợp lệ
403
→ Đã xác thực nhưng không có quyền
Đây là nền tảng để xây dựng API cho:
Mobile App
SPA
Frontend JavaScript
Third-party integrations
26. Deploy
Sau khi hoàn thành source code, ứng dụng phải được đưa lên server.
Kiến trúc phổ biến:
Internet
│
▼
Domain
│
▼
Nginx
│
▼
PHP-FPM
│
▼
Laravel 13
│
├── MySQL
├── Redis / Cache
├── Storage
└── Queue
Laravel 13 yêu cầu PHP tối thiểu 8.3. Khi dùng Nginx, web server phải trỏ vào thư mục public, không phải root của project.
27. Production Environment
Một production .env cơ bản có thể có:
APP_ENV=production
APP_DEBUG=false
APP_URL=https://example.com
Database:
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=blog
DB_USERNAME=blog_user
DB_PASSWORD=********
Mail:
MAIL_MAILER=smtp
MAIL_HOST=...
MAIL_PORT=587
MAIL_USERNAME=...
MAIL_PASSWORD=...
MAIL_ENCRYPTION=tls
Không commit .env vào Git.
Đặc biệt:
APP_KEY
DB_PASSWORD
MAIL_PASSWORD
API_KEY
TOKEN
đều phải được bảo vệ.
28. Tối ưu Laravel trước khi Deploy
Laravel cung cấp:
php artisan optimize
để cache các thành phần phù hợp cho production.
Có thể xóa cache bằng:
php artisan optimize:clear
Laravel 13 cũng cung cấp các lệnh cache riêng cho:
php artisan config:cache
php artisan event:cache
php artisan route:cache
php artisan view:cache
Các cache này nên được thực hiện trong quy trình deployment, không phải tùy tiện trong lúc development.
29. Composer Production
Khi deploy:
composer install --no-dev --optimize-autoloader
Không cần mang theo các package chỉ phục vụ development nếu chúng không cần thiết trên production.
Sau đó:
php artisan optimize
30. Frontend Assets
Nếu project sử dụng Vite:
npm install
Sau đó build production:
npm run build
Không nên sử dụng development server để phục vụ production.
31. Database Migration
Production migration:
php artisan migrate --force
--force cho phép migration chạy trong môi trường production mà không yêu cầu xác nhận tương tác.
Trước migration quan trọng:
Backup Database
│
▼
Run Migration
│
▼
Check Application
│
▼
Monitor Logs
Đừng biến production database thành nơi thử nghiệm.
32. Storage và Permission
Sau deployment:
php artisan storage:link
Laravel cần quyền ghi vào:
storage/
bootstrap/cache/
Đây là những thư mục quan trọng đối với hoạt động runtime và cache của ứng dụng.
33. Queue Worker
Nếu Blog CMS sử dụng Queue, production phải có worker chạy liên tục.
Ví dụ:
php artisan queue:work
Không nên chỉ chạy thủ công trong terminal rồi đóng terminal.
Production thường cần:
Supervisor
hoặc
systemd
hoặc
một process manager tương đương
để worker tự khởi động lại khi gặp lỗi.
Sau khi deploy code mới, các process chạy lâu như queue worker cần được reload/restart để sử dụng code mới. Laravel 13 cung cấp:
php artisan reload
cho mục đích này.
34. Scheduler
Nếu project có scheduled tasks, server cần gọi:
php artisan schedule:run
thường xuyên theo cơ chế scheduler của Laravel.
Ví dụ:
00:00
│
▼
Scheduler
│
├── Clean old logs
├── Send reports
├── Publish scheduled posts
└── Cleanup temporary files
Đây là phần rất dễ bị quên khi chuyển từ localhost lên VPS.
35. Checklist trước khi Deploy
Trước khi đưa Blog CMS lên Internet:
[ ] APP_ENV=production
[ ] APP_DEBUG=false
[ ] APP_URL chính xác
[ ] APP_KEY tồn tại
[ ] Database production chính xác
[ ] Database đã backup
[ ] .env không commit Git
[ ] composer install --no-dev
[ ] npm run build
[ ] migrate --force
[ ] storage:link
[ ] storage permission
[ ] bootstrap/cache permission
[ ] php artisan optimize
[ ] Nginx root = public/
[ ] PHP-FPM hoạt động
[ ] HTTPS hoạt động
[ ] Queue Worker hoạt động
[ ] Scheduler hoạt động
[ ] Mail hoạt động
[ ] Upload hoạt động
[ ] Login hoạt động
[ ] Authorization hoạt động
[ ] API hoạt động
[ ] /up hoạt động
[ ] Logs hoạt động
36. Checklist bảo mật
Một Blog CMS production tối thiểu cần kiểm tra:
[ ] APP_DEBUG=false
[ ] Không public .env
[ ] HTTPS
[ ] Password được hash
[ ] Validation
[ ] Authorization
[ ] CSRF protection
[ ] Mass Assignment protection
[ ] SQL Injection protection
[ ] XSS protection
[ ] Upload validation
[ ] File permission
[ ] Rate limiting nếu cần
[ ] API authentication
[ ] Token được bảo vệ
[ ] Database backup
[ ] Server update thường xuyên
Đặc biệt:
Đừng nhầm việc ẩn một nút trên giao diện với việc bảo vệ quyền truy cập.
Ví dụ:
@if(auth()->user()->role === 'admin')
<a href="/admin/users">
Users
</a>
@endif
chỉ là UI.
Controller hoặc Policy vẫn phải kiểm tra quyền.
37. Tối ưu Database
Khi project lớn dần, database thường trở thành một trong những điểm cần quan tâm đầu tiên.
Không nên:
Post::all();
nếu database có hàng triệu record.
Nên:
Post::latest()->paginate(20);
Không nên lấy toàn bộ column nếu chỉ cần một số field:
Post::select([
'id',
'title',
'slug',
])->get();
Sử dụng index cho những column thường xuyên:
WHERE
ORDER BY
JOIN
UNIQUE
Ví dụ:
$table->string('slug')->unique();
đã tạo unique index cho slug.
38. Tối ưu Source Code
Một source code tốt không phải source code có nhiều file nhất.
Mục tiêu là:
Dễ đọc
Dễ sửa
Dễ test
Dễ debug
Dễ deploy
Dễ mở rộng
Controller không nên trở thành:
God Controller
Ví dụ không nên để một Controller xử lý:
Database
Email
Upload
Payment
Notification
Report
API
tất cả trong một method khổng lồ.
Hãy chia trách nhiệm hợp lý.
39. Cấu trúc tư duy khi xây dựng Feature
Khi thêm một tính năng mới, có thể đi theo flow:
Requirement
│
▼
Database?
│
▼
Migration
│
▼
Model
│
▼
Relationship
│
▼
Request / Validation
│
▼
Controller
│
▼
Route
│
▼
View / API
│
▼
Authorization
│
▼
Test
│
▼
Deploy
Đây là workflow rất đáng ghi nhớ.
40. Git và Deployment
Một workflow đơn giản:
Local Development
│
▼
Git
│
▼
Git Repository
│
▼
VPS
│
▼
composer install
│
▼
npm run build
│
▼
migrate
│
▼
optimize
│
▼
reload services
Ví dụ:
git add .
git commit -m "Update blog CMS"
git push
Trên server:
git pull
composer install --no-dev --optimize-autoloader
npm install
npm run build
php artisan migrate --force
php artisan optimize
php artisan reload
Tất nhiên quy trình thực tế có thể khác tùy hạ tầng.
41. Cấu trúc Blog CMS sau khóa học
Một cấu trúc khái quát:
blog/
│
├── app/
│ ├── Http/
│ │ ├── Controllers/
│ │ ├── Middleware/
│ │ ├── Requests/
│ │ └── Resources/
│ │
│ ├── Models/
│ ├── Policies/
│ ├── Events/
│ ├── Listeners/
│ ├── Jobs/
│ ├── Mail/
│ └── Notifications/
│
├── bootstrap/
│
├── config/
│
├── database/
│ ├── factories/
│ ├── migrations/
│ └── seeders/
│
├── public/
│
├── resources/
│ ├── css/
│ ├── js/
│ └── views/
│
├── routes/
│ ├── web.php
│ └── api.php
│
├── storage/
│
├── tests/
│
├── .env
├── artisan
├── composer.json
└── package.json
Cấu trúc Laravel có thể được tổ chức thêm tùy dự án, nhưng các thư mục cốt lõi được framework cung cấp nhằm tạo nền tảng cho cả ứng dụng nhỏ và lớn.
42. Toàn bộ kiến thức sau 50 bài
Có thể tóm tắt khóa Laravel 13 thành:
PHP
│
▼
Laravel
│
├── Routing
│
├── Controller
│
├── Blade
│
├── Database
│ ├── Migration
│ ├── Seeder
│ └── Factory
│
├── Eloquent
│ ├── CRUD
│ ├── Query
│ └── Relationship
│
├── Form
│ ├── Request
│ ├── Validation
│ └── Upload
│
├── Authentication
│ ├── Login
│ ├── Register
│ ├── Middleware
│ └── Authorization
│
├── Advanced
│ ├── Scope
│ ├── Observer
│ ├── Event
│ ├── Queue
│ ├── Mail
│ ├── Notification
│ ├── Cache
│ ├── Storage
│ └── Logging
│
├── REST API
│ ├── Resource
│ ├── Sanctum
│ └── Authentication
│
└── Production
├── VPS
├── Nginx
├── Queue Worker
├── Scheduler
└── Optimization
Đó chính là toàn bộ hành trình của khóa học.
43. Laravel 13 và PHP
Laravel 13 tiếp tục chu kỳ phát hành hàng năm của Laravel.
Theo tài liệu chính thức, Laravel 13 yêu cầu PHP 8.3–8.5; Laravel 13 được phát hành ngày 17/03/2026, với bug fixes đến Q3/2027 và security fixes đến 17/03/2028. Laravel 13 không phải bản LTS.
Vì vậy, nếu xây dựng khóa học hiện tại theo Laravel 13 thì nên ghi:
Laravel 13.x — 2026
thay vì:
Laravel 12 LTS
44. Người học đã đạt được gì?
Sau khi hoàn thành khóa học, người học không chỉ biết:
Route::get(...);
hay:
Post::all();
Mà đã hiểu được cách một ứng dụng web thực tế được xây dựng:
User
│
▼
Browser
│
▼
Nginx
│
▼
Laravel
│
├── Middleware
├── Route
├── Controller
├── Validation
├── Model
├── Database
├── Cache
├── Queue
└── Storage
│
▼
Response
Đây mới là mục tiêu chính của khóa học.
45. Sau Laravel có thể học gì?
Sau Blog CMS, có thể tiếp tục theo nhiều hướng.
Hướng 1 — Backend
Laravel
↓
REST API
↓
Redis
↓
Queue
↓
WebSocket
↓
Microservices
Hướng 2 — Frontend
Laravel API
↓
Vue
React
Livewire
Hướng 3 — DevOps
Linux
↓
Nginx
↓
Docker
↓
CI/CD
↓
Cloud
Hướng 4 — Database
MySQL
↓
Index
↓
Query Optimization
↓
Redis
↓
Database Scaling
Hướng 5 — Testing
PHPUnit
↓
Feature Test
↓
API Test
↓
Integration Test
46. BONUS — PHPUnit
Phần Bonus của khóa học chỉ cần tập trung vào những khái niệm cơ bản:
Test
Feature Test
API Test
assertOk()
assertStatus()
assertJson()
Ví dụ:
$response = $this->get('/blog');
$response->assertOk();
API:
$response = $this->getJson('/api/posts');
$response->assertStatus(200);
Kiểm tra JSON:
$response->assertJson([
'data' => [],
]);
Mục tiêu của phần Bonus không phải biến người học thành chuyên gia testing.
Mục tiêu là giúp người học hiểu:
Code có thể được kiểm tra tự động thay vì chỉ test bằng tay.
47. Dự án cuối khóa — Blog CMS
Đây là danh sách chức năng hoàn chỉnh:
BLOG CMS
│
├── Authentication
│ ├── Register
│ ├── Login
│ └── Logout
│
├── Dashboard
│
├── Categories
│ ├── Create
│ ├── Read
│ ├── Update
│ ├── Delete
│ ├── Search
│ └── Pagination
│
├── Posts
│ ├── Create
│ ├── Read
│ ├── Update
│ ├── Delete
│ ├── Publish
│ ├── Upload Image
│ ├── Search
│ └── Pagination
│
├── Users
│ ├── List
│ ├── Role
│ ├── Active / Inactive
│ └── Password
│
├── Soft Delete
│
├── Roles & Permissions
│
├── Events
│
├── Queue
│
├── Mail
│
├── Notification
│
├── Cache
│
├── Storage
│
├── Logging
│
├── REST API
│
├── API Resource
│
├── Sanctum
│
└── Deployment
├── Shared Hosting
├── VPS
├── Nginx
├── Queue Worker
└── Scheduler
48. Checklist cuối cùng của Project
Trước khi gọi project là hoàn thành:
Function
[✓] Register
[✓] Login
[✓] Logout
[✓] Categories
[✓] Posts
[✓] Users
[✓] Upload
[✓] Search
[✓] Pagination
[✓] Soft Delete
[✓] Roles
[✓] API
[✓] Sanctum
Code
[✓] Validation
[✓] Relationship
[✓] Scope
[✓] Authorization
[✓] Error handling
[✓] Logging
[✓] Cache
[✓] Queue
Production
[✓] .env
[✓] APP_DEBUG=false
[✓] HTTPS
[✓] Database
[✓] Storage
[✓] Nginx
[✓] PHP-FPM
[✓] Queue Worker
[✓] Scheduler
[✓] Backup
[✓] Monitoring
49. Từ học Framework đến làm dự án
Đây là điểm quan trọng nhất của toàn bộ khóa học.
Học Laravel không nên dừng ở:
Biết Route
Biết Controller
Biết Model
Biết Blade
Mà phải tiến đến:
Nhận Requirement
↓
Thiết kế Database
↓
Thiết kế Architecture
↓
Viết Code
↓
Validation
↓
Authorization
↓
Testing
↓
Debug
↓
Optimization
↓
Deployment
↓
Monitoring
Đó mới là quy trình làm một ứng dụng thực tế.
50. Kết thúc khóa học Laravel 13
Chúng ta bắt đầu từ:
PHP
sau đó:
Laravel
rồi:
Database
tiếp tục:
Eloquent
sau đó:
Authentication
rồi:
CRUD
tiếp tục:
API
và cuối cùng:
Production
Toàn bộ hành trình có thể tóm tắt bằng một dòng:
PHP
↓
Laravel 13
↓
Blog CMS
↓
REST API
↓
Authentication
↓
Queue / Cache / Storage
↓
VPS / Nginx
↓
Production
Nếu đã hoàn thành toàn bộ dự án Blog CMS, người học đã có một nền tảng đủ để bắt đầu xây dựng những ứng dụng Laravel lớn hơn.
Điều quan trọng từ đây không còn là:
"Laravel có bao nhiêu tính năng?"
mà là:
"Tôi có thể dùng Laravel để giải quyết bài toán gì?"
Framework chỉ là công cụ.
Kỹ năng quan trọng hơn là khả năng:
Phân tích vấn đề
↓
Thiết kế giải pháp
↓
Viết code
↓
Kiểm tra
↓
Tối ưu
↓
Triển khai
↓
Bảo trì
Và đó cũng chính là mục tiêu cuối cùng của khóa học:
Từ PHP ZERO → Laravel 13 → Xây dựng Blog CMS thực tế → Sẵn sàng triển khai ứng dụng Web.
🎓 HOÀN THÀNH KHÓA LARAVEL 13
┌─────────────────────────────────────────┐
│ │
│ PHP → LARAVEL 13 → CMS │
│ │
│ 50 BÀI HỌC + BONUS PHPUnit │
│ │
│ Database │
│ Eloquent │
│ Authentication │
│ CRUD │
│ API │
│ Sanctum │
│ Queue │
│ Cache │
│ Storage │
│ Deployment │
│ │
│ BLOG CMS │
│ │
└─────────────────────────────────────────┘
Hết phần Laravel 13.
Bước tiếp theo không phải học thêm thật nhiều syntax.
Hãy lấy Blog CMS này làm nền tảng và bắt đầu xây dựng project của riêng mình.
Không có nhận xét nào:
Đăng nhận xét