# Laravel pentru începători: de la zero la primul proiect live

> Învață Laravel de la zero: instalare, structură, rute, controllere, Blade, baze de date, Eloquent, formulare, autentificare, securitate, Git și publicarea primului proiect live.

- **Autor:** GabrielDev
- **Publicat:** 2026-08-14
- **Actualizat:** 2026-10-12
- **Categorie:** Web & Programare
- **URL:** https://inonline.ro/web-programare/laravel-pentru-incepatori-de-la-zero-la-primul-proiect-live

---

Laravel este unul dintre cele mai populare framework-uri PHP pentru dezvoltarea aplicațiilor web moderne. Dar dacă vii direct din HTML, CSS și puțin PHP, începutul poate părea complicat: apar Composer, Artisan, routing, controllere, Blade, middleware, migrations, Eloquent, `.env`, Vite și multe alte concepte.



Vestea bună este că nu trebuie să le înveți pe toate deodată.



În acest ghid vei construi mental și practic drumul complet de la **„nu am mai lucrat cu Laravel”** până la **„am un proiect Laravel funcțional și îl pot publica online”**.



Vom trece prin instalare, structura proiectului, rute, controllere, Blade, baze de date, migrations, Eloquent, formulare, validare, autentificare, securitate, Git, optimizare și deployment.



Exemplele sunt gândite pentru Laravel modern și pentru modul în care se lucrează în proiecte reale, nu doar pentru un tutorial care afișează „Hello World”.




## Ce este Laravel și de ce merită să îl înveți


Laravel este un framework pentru PHP care oferă o structură coerentă pentru construirea aplicațiilor web.



În loc să scrii fiecare componentă de la zero, Laravel îți oferă deja soluții pentru lucruri precum:




- routing;

- controllere;

- template-uri Blade;

- accesul la baza de date;

- migrations;

- ORM prin Eloquent;

- validarea datelor;

- autentificare și autorizare;

- middleware;

- session-uri;

- cache;

- queue-uri;

- mail;

- notificări;

- API-uri;

- testing;

- logging;

- task scheduling.




Ideea importantă este că Laravel nu înlocuiește PHP. **Laravel este construit peste PHP.**



Dacă înțelegi PHP, HTML, CSS și conceptele de bază ale web-ului, Laravel devine mult mai ușor de înțeles.




### Laravel nu este un limbaj de programare


O confuzie frecventă la început este să consideri Laravel un limbaj.



Nu este.



**PHP** este limbajul de programare.



**Laravel** este framework-ul care îți oferă o arhitectură, componente și instrumente pentru dezvoltarea aplicațiilor PHP.




### Ce poți construi cu Laravel


Laravel poate fi folosit pentru proiecte foarte diferite:




- site-uri corporate;

- platforme SaaS;

- magazine online;

- marketplace-uri;

- platforme de rezervări;

- CRM-uri;

- dashboard-uri;

- platforme de administrare;

- API-uri pentru aplicații mobile;

- aplicații web complexe;

- platforme cu abonamente;

- servicii B2B;

- automatizări și sisteme interne.




Laravel poate funcționa atât ca framework full-stack, folosind Blade sau tehnologii precum Livewire și Inertia, cât și ca backend API pentru aplicații JavaScript sau mobile. Documentația oficială Laravel tratează explicit ambele direcții.




## Ce trebuie să știi înainte să începi


Nu ai nevoie să fii expert PHP pentru a începe Laravel, dar anumite noțiuni îți vor face viața mult mai ușoară.




### HTML și CSS


Trebuie să înțelegi cel puțin structura unei pagini HTML, formularele, linkurile și elementele de bază CSS.




### PHP de bază


Ar fi bine să cunoști:




- variabile;

- array-uri;

- if / else;

- for și foreach;

- funcții;

- clase;

- obiecte;

- namespace-uri;

- include / require;

- principiile OOP.





### Baze de date


Nu trebuie să fii administrator MySQL, dar ar trebui să înțelegi ce sunt:




- tabelele;

- coloanele;

- cheile primare;

- relațiile;

- INSERT;

- SELECT;

- UPDATE;

- DELETE.




Dacă acestea îți sunt încă neclare, Laravel poate fi învățat în paralel cu PHP și SQL.




## De ce ai nevoie pentru primul proiect Laravel


Pentru un proiect Laravel modern ai nevoie de câteva componente principale:




- PHP;

- Composer;

- Laravel Installer;

- Node.js și npm sau Bun;

- un editor de cod;

- o bază de date, atunci când proiectul are nevoie de una.




Laravel 13 necesită în prezent PHP 8.3 sau mai nou. Documentația oficială recomandă instalarea PHP, Composer și Laravel Installer și indică Node/NPM sau Bun pentru compilarea asset-urilor frontend.




### Ce editor de cod să folosești


Poți folosi VS Code, Cursor, PhpStorm sau un alt editor compatibil.



Pentru un începător, VS Code este suficient. Dacă lucrezi mult cu Laravel și PHP, PhpStorm poate deveni foarte util datorită suportului dedicat pentru framework.




## Cum instalezi Laravel


După ce ai PHP și Composer instalate, poți instala Laravel Installer prin Composer:




```
composer global require laravel/installer
```


Apoi poți crea un proiect nou:




```
laravel new primul-proiect
```


Intră în directorul proiectului:




```
cd primul-proiect
```


Instalează dependențele frontend:




```
npm install
```


Construiește asset-urile:




```
npm run build
```


Pentru dezvoltare locală, Laravel oferă și scriptul:




```
composer run dev
```


În configurația standard actuală, aplicația poate fi accesată local la:




```
http://localhost:8000
```


Acesta este fluxul recomandat în documentația oficială actuală pentru crearea unei aplicații Laravel.




### O alternativă: Laravel Herd


Dacă lucrezi pe Windows sau macOS și vrei un mediu Laravel mai simplu de administrat, poți folosi Laravel Herd.



Herd include componentele necesare pentru dezvoltarea Laravel și poate simplifica configurarea PHP și a serverului local.




## Cum arată structura unui proiect Laravel


După instalare vei vedea mai multe directoare. La început nu încerca să înțelegi fiecare fișier.



Concentrează-te pe acestea:




```
app/
bootstrap/
config/
database/
public/
resources/
routes/
storage/
tests/
vendor/
```



### app/


Aici se află mare parte din codul aplicației.



Vei lucra frecvent cu:




```
app/Models/
app/Http/Controllers/
app/Http/Requests/
app/Policies/
app/Services/
```



### routes/


Aici definești rutele aplicației.



Una dintre cele mai importante este:




```
routes/web.php
```



### resources/


Aici vei găsi view-urile Blade și asset-urile frontend.




```
resources/views/
resources/css/
resources/js/
```



### database/


Aici găsești migrations, seeders și factories.




### public/


Este directorul public al aplicației.



În producție, serverul web trebuie configurat astfel încât aplicația să fie servită prin directorul public al Laravel, nu prin rădăcina proiectului. Servirea greșită poate expune fișiere sensibile ale aplicației.




### vendor/


Aici sunt instalate dependențele Composer.



Nu edita manual fișierele din `vendor/`.




## Ce este fișierul .env


Fișierul `.env` conține configurații care diferă între mediul local și producție.



De exemplu:




```
APP_NAME=Laravel
APP_ENV=local
APP_DEBUG=true
APP_URL=http://localhost

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD=
```


Aici pot ajunge și credențiale pentru baze de date, servicii externe, mail, API-uri sau alte componente.



**Nu pune `.env` în repository-ul public Git.**



Documentația Laravel avertizează explicit că fișierul `.env` nu trebuie comis în source control deoarece poate conține informații sensibile.




## Prima ta rută Laravel


Deschide:




```
routes/web.php
```


Poți defini o rută simplă astfel:




```
use Illuminate\Support\Facades\Route;

Route::get('/salut', function () {
    return 'Salut din Laravel!';
});
```


Accesează:




```
http://localhost:8000/salut
```


Și vei primi:




```
Salut din Laravel!
```


Ai creat deja primul endpoint al aplicației.




### Ce înseamnă GET


Metoda GET este folosită în general pentru a solicita o resursă.




```
Route::get('/produse', function () {
    return 'Lista produselor';
});
```



### POST, PUT și DELETE


În aplicații reale vei lucra și cu:




```
Route::post('/produse', ...);

Route::put('/produse/{product}', ...);

Route::delete('/produse/{product}', ...);
```


Nu trebuie să memorezi toate variantele. Important este să înțelegi că ruta leagă o cerere HTTP de o acțiune din aplicație.




## De ce ai nevoie de controllere


La început poți scrie logică direct în route closures, dar într-o aplicație reală aceasta devine rapid greu de întreținut.



Controllerele separă logica aplicației de definirea rutelor.



Poți crea un controller:




```
php artisan make:controller ProductController
```


Apoi:




```
use App\Http\Controllers\ProductController;

Route::get('/produse', [ProductController::class, 'index']);
```


În controller:




```
namespace App\Http\Controllers;

class ProductController
{
    public function index()
    {
        return 'Lista produselor';
    }
}
```


În proiectele reale, controllerul devine punctul în care cererea este preluată și coordonată către restul aplicației.



Laravel recomandă organizarea logicii de request în clase controller, mai ales pe măsură ce aplicația crește.




## Ce este Blade


Blade este motorul de template-uri inclus în Laravel.



Un fișier Blade are extensia:




```
.blade.php
```


De exemplu:




```
resources/views/home.blade.php
```


Poți afișa o variabilă:




```
{{ $title }}
```


Din controller:




```
return view('home', [
    'title' => 'Primul meu proiect Laravel'
]);
```



### Condiții în Blade



```
@if ($user)
    Bine ai venit!


@else
    Trebuie să te autentifici.


@endif
```



### Liste în Blade



```
@foreach ($products as $product)

## {{ $product->name }}

@endforeach
```


Blade este unul dintre motivele pentru care Laravel este atât de plăcut pentru aplicații full-stack: poți construi frontend-ul direct în ecosistemul Laravel fără să ai nevoie de un framework JavaScript separat pentru fiecare proiect.




## Layout-uri și componente Blade


Dacă fiecare pagină își repetă header-ul, meniul și footer-ul, codul va deveni greu de întreținut.



În schimb, poți avea un layout comun:




```



    {{ $title ?? 'Site' }}



    
        Site-ul meu
    

    
        {{ $slot }}
    



```


Componentele Blade sunt foarte utile pentru elemente reutilizabile precum:




- butoane;

- input-uri;

- carduri;

- alerte;

- modale;

- navigație.




Cu cât proiectul crește, cu atât reutilizarea componentelor devine mai importantă.




## Cum conectezi Laravel la MySQL


În `.env` configurezi conexiunea:




```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD=
```


Apoi rulezi:




```
php artisan migrate
```


Laravel suportă mai multe tipuri de baze de date. Pentru proiectele web clasice, MySQL și PostgreSQL sunt alegeri foarte comune.



Într-un proiect nou, configurația implicită poate folosi SQLite, dar poți trece la MySQL sau PostgreSQL prin configurația din `.env`.




## Ce sunt migrations și de ce sunt importante


O migration descrie structura unei modificări în baza de date.



De exemplu, poți crea tabela `products`:




```
php artisan make:migration create_products_table
```


În migration:




```
Schema::create('products', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->decimal('price', 10, 2);
    $table->text('description')->nullable();
    $table->timestamps();
});
```


Apoi:




```
php artisan migrate
```


Avantajul este enorm: structura bazei de date devine parte din codul proiectului și poate fi recreată sau modificată controlat.




### Rollback


Dacă trebuie să revii asupra ultimei migrări:




```
php artisan migrate:rollback
```


Nu trata migrations ca pe niște fișiere temporare. În proiectele reale, ele fac parte din istoricul aplicației.




## Ce este Eloquent ORM


Eloquent este ORM-ul Laravel.



Pe scurt, îți permite să lucrezi cu datele din baza de date prin modele PHP.



Creezi modelul:




```
php artisan make:model Product
```


Modelul va reprezenta, în mod obișnuit, tabela `products`.



Poți obține produsele:




```
$products = Product::all();
```


Poți căuta un produs:




```
$product = Product::find(1);
```


Poți crea un produs:




```
$product = Product::create([
    'name' => 'Laptop',
    'price' => 3500,
]);
```


Eloquent devine foarte puternic atunci când începi să lucrezi cu relații.




### Relații între modele


De exemplu:



Un utilizator poate avea mai multe comenzi:




```
public function orders()
{
    return $this->hasMany(Order::class);
}
```


Iar comanda aparține unui utilizator:




```
public function user()
{
    return $this->belongsTo(User::class);
}
```


Acesta este unul dintre conceptele pe care trebuie să le stăpânești dacă vrei să treci de la tutoriale la aplicații reale.




## Primul CRUD Laravel


CRUD înseamnă:




- **Create** — creezi date;

- **Read** — citești date;

- **Update** — modifici date;

- **Delete** — ștergi date.




Un exemplu simplu de controller poate avea:




```
public function index()
{
    return Product::latest()->get();
}

public function store(Request $request)
{
    // validare și creare
}

public function show(Product $product)
{
    return $product;
}

public function update(Request $request, Product $product)
{
    // validare și actualizare
}

public function destroy(Product $product)
{
    $product->delete();
}
```


Laravel poate genera rapid un resource controller:




```
php artisan make:controller ProductController --resource
```


CRUD-ul este un punct foarte bun pentru primul proiect practic deoarece te obligă să înțelegi relația dintre route, controller, model, database și view.




## Formulare și validarea datelor


Niciodată nu ar trebui să presupui că datele trimise de utilizator sunt corecte.



Laravel oferă validare integrată.




```
$validated = $request->validate([
    'name' => ['required', 'string', 'max:255'],
    'email' => ['required', 'email'],
]);
```


Dacă datele nu respectă regulile, Laravel poate redirecționa utilizatorul și poate face erorile disponibile în view.



În Blade:




```
@error('email')
    {{ $message }}
@enderror
```


Pentru formulare mai complexe, este recomandată folosirea Form Request-urilor:




```
php artisan make:request StoreProductRequest
```


Laravel include un sistem complet de validare, inclusiv reguli pentru stringuri, numere, emailuri, fișiere, parole, array-uri și date unice în baza de date.




## CSRF și securitatea formularelor


Când lucrezi cu formulare POST, Laravel oferă protecție CSRF.



Într-un formular Blade vei folosi de regulă:




```

    @csrf

    ...

```


Nu elimina protecția CSRF doar pentru că formularul „merge și fără ea”.



Securitatea trebuie proiectată din start, nu adăugată după ce aplicația a ajuns online.




## Route Model Binding


Una dintre funcțiile care fac Laravel foarte plăcut este Route Model Binding.



În loc să cauți manual produsul:




```
$product = Product::findOrFail($id);
```


poți avea:




```
Route::get('/products/{product}', [ProductController::class, 'show']);
```


iar controllerul:




```
public function show(Product $product)
{
    return view('products.show', compact('product'));
}
```


Laravel rezolvă automat modelul pe baza parametrului rutei.



Acesta este un exemplu foarte bun de ce framework-urile pot reduce cantitatea de cod repetitiv pe care trebuie să o scrii.




## Artisan: comanda pe care trebuie să o înveți


**Artisan** este CLI-ul Laravel.



Este una dintre comenzile pe care le vei folosi constant.



Pentru a vedea comenzile disponibile:




```
php artisan list
```


Comenzi pe care merită să le cunoști:




```
php artisan serve
php artisan migrate
php artisan migrate:rollback
php artisan make:model Product
php artisan make:controller ProductController
php artisan make:migration create_products_table
php artisan make:request StoreProductRequest
php artisan route:list
php artisan tinker
php artisan optimize:clear
```



### php artisan tinker


Tinker îți permite să interacționezi cu aplicația direct din terminal.



De exemplu:




```
php artisan tinker
```


Apoi poți testa:




```
Product::count();
```


Este extrem de util pentru debugging și pentru a înțelege cum funcționează Eloquent.




## Ce este Vite în Laravel


Laravel folosește Vite pentru procesarea asset-urilor frontend.



În proiect vei întâlni:




```
resources/css/
resources/js/
vite.config.js
```


În dezvoltare poți folosi:




```
npm run dev
```


Iar pentru build:




```
npm run build
```


Dacă modifici CSS sau JavaScript și nu înțelegi de ce browserul nu vede modificările, verifică dacă Vite rulează și dacă asset-urile sunt încărcate corect.




## Cum adaugi autentificare în Laravel


Un proiect real ajunge frecvent să aibă:




- login;

- register;

- logout;

- resetarea parolei;

- profil de utilizator;

- roluri și permisiuni.




Nu este recomandat să construiești manual fiecare componentă de autentificare dacă nu ai un motiv clar.



Laravel oferă starter kits oficiale care pot porni un proiect cu autentificare și structura necesară.



În prezent, starter kit-urile oficiale includ variante pentru React, Vue, Svelte și Livewire, cu autentificare și componente moderne incluse.




### Când să alegi Livewire


Livewire este foarte interesant dacă vrei să construiești interfețe interactive păstrând o mare parte din logica aplicației în ecosistemul Laravel și PHP.




### Când să alegi React sau Vue


Dacă ai nevoie de o interfață frontend mai complexă sau ai deja experiență cu JavaScript/TypeScript, React sau Vue pot fi alegeri mai potrivite.



Nu trebuie să alegi cea mai complicată arhitectură. Alege ceea ce se potrivește proiectului.




## Ce este middleware-ul


Middleware-ul poate fi privit ca un filtru între request și aplicație.



Exemple:




- verificarea autentificării;

- verificarea permisiunilor;

- limitarea request-urilor;

- verificarea anumitor condiții înainte de accesul la o rută.




De exemplu, o zonă de administrare poate fi protejată astfel:




```
Route::middleware('auth')->group(function () {
    Route::get('/admin', function () {
        return view('admin.dashboard');
    });
});
```


Middleware-ul este unul dintre mecanismele fundamentale pentru controlul accesului într-o aplicație Laravel.




## Cum funcționează MVC în Laravel


Laravel este construit în jurul unor concepte care seamănă cu arhitectura MVC.



**Model** — lucrează cu datele și regulile asociate lor.



**View** — afișează interfața.



**Controller** — coordonează request-ul și logica necesară pentru a produce răspunsul.



Un flux simplificat arată astfel:




```
Browser
   ↓
Route
   ↓
Controller
   ↓
Model / Service
   ↓
Database
   ↓
Controller
   ↓
View
   ↓
Browser
```


Nu orice aplicație Laravel trebuie să respecte MVC într-o formă rigidă, dar acest model mental este foarte bun pentru început.




## Când să scoți logica din controller


Una dintre cele mai frecvente greșeli ale începătorilor este să transforme controllerul într-un fișier uriaș.



La început poți avea:




```
public function store(Request $request)
{
    // 100+ linii de logică
}
```


Pe măsură ce aplicația crește, este mai sănătos să separi responsabilitățile.



Poți introduce:




- Form Requests pentru validare;

- Services pentru logică complexă;

- Policies pentru autorizare;

- Jobs pentru operațiuni asincrone;

- Events și Listeners pentru fluxuri decuplate;

- Resources pentru răspunsurile API.




Nu trebuie să creezi câte un Service pentru fiecare metodă banală. Abstracția este utilă atunci când rezolvă o problemă reală.




## Cum construiești un API în Laravel


Laravel poate fi folosit și ca backend pentru aplicații mobile sau frontend-uri JavaScript.



Un API poate returna JSON:




```
return response()->json([
    'success' => true,
    'message' => 'Produs creat',
    'data' => $product,
]);
```


Poți avea endpoint-uri precum:




```
GET    /api/products
POST   /api/products
GET    /api/products/{product}
PUT    /api/products/{product}
DELETE /api/products/{product}
```


Laravel poate servi astfel ca backend pentru:




- React;

- Vue;

- Flutter;

- aplicații native;

- alte servicii;

- integrări externe.




Documentația oficială Laravel prezintă explicit utilizarea framework-ului ca backend API pentru aplicații JavaScript sau mobile.




## Securitatea unui proiect Laravel


Un framework modern nu face automat o aplicație invulnerabilă. Modul în care scrii și configurezi aplicația contează enorm.



Regulile de bază sunt:




- nu expune `.env`;

- nu păstra parole în cod;

- nu folosi parole hardcodate;

- validează input-ul;

- folosește autorizare pentru operațiunile sensibile;

- protejează formularele;

- ține Laravel și dependințele actualizate;

- nu activa debug în producție;

- folosește HTTPS;

- limitează accesul administrativ;

- folosește politici și middleware;

- verifică permisiunile fișierelor și directoarelor.





### APP_DEBUG în producție


În dezvoltare poți avea:




```
APP_DEBUG=true
```


În producție trebuie să fie:




```
APP_DEBUG=false
```


Debug-ul activ în producție poate expune informații despre aplicație și configurație. Documentația Laravel tratează explicit dezactivarea debug-ului în mediul de producție ca o măsură importantă de securitate.




## Laravel și Git


Nu construi un proiect serios fără version control.



Inițializează Git:




```
git init
```


Adaugă fișierele:




```
git add .
```


Fă primul commit:




```
git commit -m "Initial Laravel project"
```


Într-un repository trebuie să ai codul proiectului, dar nu secretele mediului de producție.



Verifică întotdeauna că `.env` este ignorat și că ai `.env.example` pentru variabilele necesare.




## De ce trebuie să testezi aplicația


Un proiect care „merge pe calculatorul meu” nu este neapărat un proiect bun.



Testele te ajută să verifici că funcționalitatea continuă să funcționeze după modificări.



Poți testa:




- rute;

- validare;

- autentificare;

- permisiuni;

- operații CRUD;

- API-uri;

- componente ale aplicației.




Pentru proiectele noi, ecosistemul Laravel pune un accent important pe testing automatizat. Pentru browser testing, documentația actuală notează că Pest 4 include capabilități de browser testing și recomandă Pest pentru proiecte noi în anumite scenarii.




## Cum faci debugging în Laravel


Debugging-ul este o abilitate mai importantă decât memorarea comenzilor.



Începe cu:




```
storage/logs/laravel.log
```


Poți verifica și rutele:




```
php artisan route:list
```


Pentru testarea rapidă a codului:




```
php artisan tinker
```


Și când apar probleme după modificări de configurație:




```
php artisan optimize:clear
```


Nu rezolva fiecare eroare prin „șterg cache-ul și încerc din nou”. Învață să identifici cauza reală.




## Primul proiect Laravel pe care ar trebui să îl construiești


Dacă ești complet începător, nu începe cu un marketplace de 50 de module.



Construiește o aplicație suficient de mică încât să o poți termina, dar suficient de complexă încât să te oblige să folosești conceptele importante.



O variantă foarte bună este un **mini CMS pentru articole**.



Aplicația poate avea:




- login;

- dashboard;

- lista articolelor;

- creare articol;

- editare articol;

- ștergere articol;

- categorii;

- autori;

- status draft/publicat;

- slug;

- imagine;

- validare;

- căutare;

- paginare.




Cu un astfel de proiect înveți aproape tot ce ai nevoie pentru a trece de la tutoriale la dezvoltare practică.




### Structura aproximativă



```
Article
 ├── belongsTo User
 ├── belongsTo Category
 └── hasMany Comments
```


Poți adăuga ulterior:




- SEO fields;

- media library;

- REST API;

- roluri;

- permissions;

- notifications;

- queue-uri;

- cache;

- audit logs.




În acest moment nu mai ai doar un tutorial. Ai început să construiești un produs real.




## Cum publici primul proiect Laravel online


Aici mulți începători fac greșeala de a copia pur și simplu toate fișierele pe hosting. Pașii corecți (build, .env, migrații, rollback) sunt exersați în [cursul de deploy pentru aplicații web](https://inonline.ro/academy/deploy-pentru-aplicatii-web).



Un deployment Laravel trebuie făcut controlat.



În primul rând, serverul trebuie să îndeplinească cerințele versiunii Laravel folosite și să aibă extensiile PHP necesare.



Apoi:




```
git pull

`composer install --no-dev --optimize-autoloader`

`php artisan migrate --force`

php artisan optimize
```


În funcție de proiect, vei avea și pași pentru frontend:




```
npm ci
npm run build
```


Documentația Laravel recomandă optimizarea autoloaderului Composer și folosirea cache-urilor de configurație, route și view în deployment-urile de producție, în funcție de aplicație și fluxul de deployment.




### Document root


Un aspect critic este ca serverul web să servească aplicația prin:




```
/public
```


și nu prin rădăcina proiectului.



Nu vrei ca directoare precum `app`, `config`, `storage` sau fișierul `.env` să fie accesibile direct prin browser.




## Laravel pe VPS


Pentru proiecte mai serioase poți rula Laravel pe un VPS cu Linux. Dacă alegi această variantă, vezi [cum compari ofertele de VPS](https://inonline.ro/hosting-vps/cele-mai-bune-vps-uri-in-2026-comparatie-pret-performanta) după cost total și teste reproductibile.



Într-un setup tipic poți avea:




```
Internet
   ↓
Cloudflare / CDN
   ↓
Nginx
   ↓
PHP-FPM
   ↓
Laravel
   ↓
MySQL / PostgreSQL
   ↓
Redis
```


Pe măsură ce aplicația crește, pot apărea și:




- queue workers;

- scheduler;

- Redis;

- object storage;

- monitorizare;

- backup-uri;

- load balancing.




Nu ai nevoie de toate acestea pentru primul proiect. Important este să înțelegi că Laravel poate crește odată cu aplicația.




## Cum faci un proiect Laravel mai rapid


Performanța nu înseamnă doar „server mai puternic”.



Trebuie să te uiți la:




- query-uri SQL;

- indexuri;

- N+1 queries;

- cache;

- queue-uri;

- dimensiunea asset-urilor;

- imagini;

- JavaScript;

- răspunsurile API;

- configurația serverului.





### Problema N+1


Un exemplu clasic este să încarci o listă de produse și apoi să faci câte un query pentru fiecare categorie.



În loc de asta, folosești eager loading:




```
$products = Product::with('category')->get();
```


Nu optimiza prematur fiecare linie. Măsoară mai întâi unde este problema.




### Cache


Dacă aceeași informație este calculată repetat și nu se schimbă frecvent, cache-ul poate reduce semnificativ costul operației.



În aplicațiile mai mari, Redis poate deveni o componentă importantă.




## Laravel și AI în 2026


Laravel este interesant și pentru dezvoltarea asistată de AI.



Structura sa convențională face mai ușor pentru agenții de coding să identifice unde trebuie create controllere, modele, migrations, requests și alte componente.



Laravel oferă și **Laravel Boost**, un instrument conceput pentru a oferi agenților AI context specific aplicației și versiunii Laravel folosite. Documentația oficială spune că Boost poate furniza agenților informații despre pachetele instalate, documentație Laravel, database access, logs, testing și alte instrumente.



Important însă: AI-ul nu înlocuiește înțelegerea framework-ului.



Dacă nu înțelegi routing, middleware, Eloquent, validarea și securitatea, poți genera foarte repede un proiect mare pe care nu îl poți întreține.



Folosește AI pentru:




- boilerplate;

- refactoring;

- teste;

- debugging;

- documentare;

- explorarea API-urilor;

- generarea de componente repetitive.




Dar verifică întotdeauna codul generat.




## Cele mai frecvente greșeli ale începătorilor



### 1. Începi cu un proiect prea mare


Un marketplace complet nu este primul proiect ideal.




### 2. Copiezi cod fără să îl înțelegi


Dacă nu știi ce face codul, vei avea probleme când apare primul bug.




### 3. Pui toată logica în controller


Controller-ele foarte mari devin dificil de testat și întreținut.




### 4. Ignori validarea


Datele utilizatorului trebuie tratate ca date nesigure până când sunt validate.




### 5. Expui `.env`


Aceasta poate deveni o problemă gravă de securitate.




### 6. Activezi debug în producție


Este o configurație potrivită pentru dezvoltare, nu pentru site-ul live.




### 7. Nu folosești Git


Fără version control, fiecare modificare importantă devine un risc.




### 8. Nu faci backup


Un proiect live are nevoie de backup pentru baza de date și fișierele importante.




### 9. Instalezi zeci de package-uri fără motiv


Fiecare dependență adaugă complexitate și trebuie întreținută.




### 10. Optimizezi înainte să măsori


Nu transforma proiectul într-un puzzle de optimizări fără să știi unde este problema.




## Roadmap: ce să înveți după primul proiect


După ce ai construit primul CRUD complet, poți urma această ordine:




- PHP OOP;

- Laravel routing;

- controllers;

- Blade;

- migrations;

- Eloquent;

- relationships;

- validation;

- authentication;

- authorization;

- middleware;

- service container și dependency injection;

- queues și jobs;

- events și listeners;

- notifications;

- mail;

- API development;

- testing;

- cache și Redis;

- performance;

- deployment;

- monitoring;

- scaling.




Nu încerca să le înveți într-o singură săptămână.



Cel mai eficient mod este să construiești proiecte din ce în ce mai complexe.




## Checklist pentru primul proiect Laravel


Înainte să consideri primul tău proiect terminat, verifică:




- □ PHP este configurat corect;

- □ Composer funcționează;

- □ Laravel este instalat;

- □ proiectul pornește local;

- □ înțelegi structura proiectului;

- □ ai creat cel puțin câteva rute;

- □ ai folosit un controller;

- □ ai creat Blade views;

- □ ai conectat baza de date;

- □ ai creat migrations;

- □ ai creat modele Eloquent;

- □ ai lucrat cu relații;

- □ ai construit un CRUD;

- □ ai validat formularele;

- □ ai folosit CSRF;

- □ ai înțeles middleware-ul;

- □ ai implementat autentificarea;

- □ ai folosit Git;

- □ `.env` nu este public;

- □ `APP_DEBUG=false` în producție;

- □ ai configurat HTTPS;

- □ ai backup pentru baza de date;

- □ ai testat aplicația;

- □ serverul servește Laravel prin `/public`;

- □ ai făcut deployment controlat.





## Concluzie: cum ajungi de la zero la primul proiect live


Laravel poate părea foarte mare la început pentru că include foarte multe componente.



Dar nu trebuie să le înveți pe toate înainte să construiești ceva.



Începe cu fluxul fundamental:




```
Route
  ↓
Controller
  ↓
Model
  ↓
Database
  ↓
View
```


Apoi adaugă treptat:




```
Validation
Authentication
Middleware
Authorization
API
Testing
Cache
Queues
Deployment
Monitoring
```


Dacă poți construi singur un CRUD complet, cu autentificare, validare, relații Eloquent și deployment pe un server, ai trecut deja de nivelul de „am urmărit câteva tutoriale Laravel”.



De acolo începe partea cu adevărat interesantă: construirea de aplicații care rezolvă probleme reale.



Laravel nu este important doar pentru că îți permite să scrii mai puțin cod. Este important pentru că îți oferă o structură în care un proiect poate crește fără să devină haotic.



**Obiectivul nu ar trebui să fie să înveți Laravel pe de rost.**



Obiectivul este să înțelegi suficient de bine framework-ul încât să poți deschide un proiect gol, să știi unde trebuie să lucrezi și să poți construi prima aplicație reală de la zero.




## Întrebări frecvente despre Laravel



### Este Laravel greu pentru un începător?


Poate părea dificil la început deoarece introduce multe concepte noi, dar dacă ai bazele PHP și înveți progresiv, Laravel este unul dintre framework-urile PHP potrivite pentru a construi aplicații reale.




### Trebuie să știu PHP înainte de Laravel?


Da, este recomandat să ai cel puțin cunoștințe de bază PHP. Laravel nu înlocuiește PHP, ci îl organizează într-un framework modern.




### Ce versiune de Laravel ar trebui să învăț în 2026?


Pentru un proiect nou, Laravel 13 este versiunea majoră curentă. Laravel 13 necesită PHP 8.3 sau mai nou. Dacă lucrezi pe un proiect existent, trebuie însă să folosești versiunea compatibilă cu proiectul respectiv.




### Laravel este bun pentru proiecte mari?


Da. Laravel poate fi folosit pentru aplicații de la proiecte mici până la platforme complexe. Arhitectura aplicației, infrastructura, baza de date, caching-ul și modul în care este scris codul sunt esențiale pentru scalare.




### Pot folosi Laravel pentru un API?


Da. Laravel poate funcționa ca backend API pentru aplicații web, mobile sau alte servicii.




### Pot folosi Laravel cu React?


Da. Laravel poate servi ca backend, iar React poate fi folosit pentru interfața frontend. Laravel oferă și starter kit oficial pentru React.




### Pot folosi Laravel cu Vue?


Da. Vue este, de asemenea, disponibil în ecosistemul oficial de starter kits Laravel.




### Pot folosi Laravel cu Flutter?


Da. Laravel poate furniza API-ul și partea de backend, iar Flutter poate fi aplicația mobilă care consumă acel API.




### Laravel este mai bun decât WordPress?


Nu există un răspuns universal. WordPress este foarte eficient pentru anumite tipuri de site-uri și publishing, în timp ce Laravel este mult mai potrivit atunci când ai nevoie de logică personalizată, aplicații web, platforme, API-uri sau sisteme construite special pentru business.




### Cât timp durează să înveți Laravel?


Poți învăța bazele în câteva săptămâni dacă lucrezi constant, dar dezvoltarea unui nivel profesional necesită proiecte reale și experiență cu arhitectura, securitatea, testarea, performanța și deployment-ul.




### Este Laravel potrivit pentru freelancing?


Da. Este foarte potrivit pentru proiecte custom, platforme, dashboard-uri, API-uri, aplicații SaaS și sisteme interne unde clientul are nevoie de funcționalități care depășesc ceea ce oferă un CMS standard.




### Ce proiect ar trebui să fac după ce termin acest tutorial?


Construiește un CMS simplu cu autentificare, articole, categorii, utilizatori, CRUD, validare, căutare și paginare. După aceea poți trece la un proiect mai complex, precum un sistem de rezervări, un CRM sau o platformă SaaS.

## Criterii de acceptare pentru primul proiect Laravel
Pentru catalogul demonstrativ de servicii, verifică trei trasee: vizitatorul citește o pagină, formularul valid salvează o cerere, iar alt utilizator nu poate edita un serviciu fără permisiune. Un formular cu email invalid trebuie să afișeze eroarea și să nu creeze înregistrare. Un titlu care conține caractere HTML trebuie afișat ca text în Blade. Înainte de deploy verifică document root, configurația de producție, asset-urile și health check-ul. Nu modifica baza activă pentru exercițiu. Acest checklist verifică comportamentul proiectului, în loc să confunde instalarea framework-ului cu finalizarea aplicației.

## Continuă cu un pas practic
- [Cum structurezi un proiect Laravel care crește sănătos](/web-programare/cum-structurezi-un-proiect-laravel-care-creste-sanatos)
- [Cum muți un site pe alt hosting fără downtime: ghid complet](/hosting-vps/cum-muti-un-site-pe-alt-hosting-fara-downtime)

Pentru lucru ghidat:

[Laravel de la zero: primul tău site profesionist — lecții de probă și fișă de proiect](/academy/laravel-de-la-zero-primul-tau-site-profesionist).