To correctly configure Nginx to run Laravel applications, you must 1. Set document root to the public directory; 2. Use try_files to implement URL rewrite; 3. Configure PHP-FPM to process PHP files; 4. Disable access to sensitive files and directories. The specific steps are: first set root to /var/www/laravel/public to ensure that the entry file is public/index.php to avoid exposure of sensitive files such as .env; then use try_files $uri $uri/ /index.php?$query_string in location / to implement front-end controller mode, forward the request to Laravel routing; then configure the location ~ \.php$ block, point to the PHP-FPM socket through fastcgi_pass (such as unix:/var/run/php/php8.2-fpm.sock), and set SCRIPT_FILENAME to $realpath_root$fastcgi_script_name to avoid symbolic link problems; finally add multiple denys All rules prevent access to .env, .git, ~ backup files and storage, bootstrap and other directories. After the complete configuration, you need to run sudo nginx -t to test syntax and overload the Nginx service. At the same time, HTTPS should be enabled, www-data permissions should be set and Laravel cache should be cleared to ensure normal operation.
Configuring Nginx for a Laravel application is straightforward once you understand the key requirements: routing all requests through public/index.php
, securing sensitive files, and setting proper document root. Here's how to do it correctly.

? Set the Correct Root Directory
Laravel's entry point is the public/
folder. Your Nginx server block must point to this directory as the root.
server { listen 80; server_name your-domain.com; root /var/www/laravel/public; index index.php index.html index.htm; }
? Never point the root to the Laravel project root (where
artisan
is). That would expose sensitive files like.env
.
? Handle URL Rewriting (Front Controller Pattern)
Laravel uses the front controller pattern — all requests should be routed through public/index.php
. Use the try_files
directive to achieve this:
location / { try_files $uri $uri/ /index.php?$query_string; }
This tells Nginx:

- First, try serving the actual file or directory.
- If not found, pass the request to
index.php
with the query string intact (so Laravel can route it).
?? PHP-FPM Configuration
You need PHP-FPM to execute PHP files. Make sure PHP-FPM is installed and running (eg, PHP 8.1 or 8.2). Configure Nginx to pass .php
files to PHP-FPM:
location ~ \.php$ { fastcgi_pass unix:/var/run/php/php8.2-fpm.sock; # Adjust version as needed fastcgi_index index.php; fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name; include fastcgi_params; }
? Using
$realpath_root
instead of$document_root
avoids path resolution issues with symlinks (eg, when usinggit
orenvoyer
).
? Block Access to Sensitive Files
Prevent direct access to Laravel-specific files and directories:
location ~ /\.(env|git|htaccess) { deny all; } location ~ ~$ { deny all; }
You can also explicitly block access to the storage
and bootstrap
directories:
location /storage/ { deny all; } location /bootstrap/ { deny all; }
? Full Example Configuration
server { listen 80; server_name your-domain.com; root /var/www/laravel/public; index index.php index.html index.htm; location / { try_files $uri $uri/ /index.php?$query_string; } location ~ \.php$ { fastcgi_pass unix:/var/run/php/php8.2-fpm.sock; fastcgi_index index.php; fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name; include fastcgi_params; } location ~ /\.(env|git|htaccess) { deny all; } location ~ ~$ { deny all; } location /storage/ { deny all; } }
After saving, test and reload Nginx:
sudo nginx -t sudo systemctl reload nginx
? Additional Tips
- Use HTTPS : Always enable SSL (via Let's Encrypt) in production.
- Set proper permissions :
sudo chown -R www-data:www-data /var/www/laravel/storage sudo chown -R www-data:www-data /var/www/laravel/bootstrap/cache
- Clear config cache if Laravel isn't responding:
php artisan config:clear php artisan route:clear
That's it. With this setup, your Laravel app will run securely and efficiently under Nginx. Just make sure PHP-FPM is running and file permissions are correct.
The above is the detailed content of How to configure Nginx for a Laravel application?. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

There are three ways to add custom validation rules in Laravel: using closures, Rule classes, and form requests. 1. Use closures to be suitable for lightweight verification, such as preventing the user name "admin"; 2. Create Rule classes (such as ValidUsernameRule) to make complex logic clearer and maintainable; 3. Integrate multiple rules in form requests and centrally manage verification logic. At the same time, you can set prompts through custom messages methods or incoming error message arrays to improve flexibility and maintainability.

The core methods for Laravel applications to implement multilingual support include: setting language files, dynamic language switching, translation URL routing, and managing translation keys in Blade templates. First, organize the strings of each language in the corresponding folders (such as en, es, fr) in the /resources/lang directory, and define the translation content by returning the associative array; 2. Translate the key value through the \_\_() helper function call, and use App::setLocale() to combine session or routing parameters to realize language switching; 3. For translation URLs, paths can be defined for different languages ??through prefixed routing groups, or route alias in language files dynamically mapped; 4. Keep the translation keys concise and

ToworkeffectivelywithpivottablesinLaravel,firstaccesspivotdatausingwithPivot()orwithTimestamps(),thenupdateentrieswithupdateExistingPivot(),managerelationshipsviadetach()andsync(),andusecustompivotmodelswhenneeded.1.UsewithPivot()toincludespecificcol

Laravelprovidesacleanandflexiblewaytosendnotificationsviamultiplechannelslikeemail,SMS,in-appalerts,andpushnotifications.Youdefinenotificationchannelsinthevia()methodofanotificationclass,andimplementspecificmethodsliketoMail(),toDatabase(),ortoVonage

ServiceProvider is the core mechanism used in the Laravel framework for registering services and initializing logic. You can create a custom ServiceProvider through the Artisan command; 1. The register method is used to bind services, register singletons, set aliases, etc., and other services that have not yet been loaded cannot be called; 2. The boot method runs after all services are registered and is used to register event listeners, view synthesizers, middleware and other logic that depends on other services; common uses include binding interfaces and implementations, registering Facades, loading configurations, registering command-line instructions and view components; it is recommended to centralize relevant bindings to a ServiceProvider to manage, and pay attention to registration

Dependency injection automatically handles class dependencies through service containers in Laravel without manual new objects. Its core is constructor injection and method injection, such as automatically passing in the Request instance in the controller. Laravel parses dependencies through type prompts and recursively creates the required objects. The binding interface and implementation can be used by the service provider to use the bind method, or singleton to bind a singleton. When using it, you need to ensure type prompts, avoid constructor complications, use context bindings with caution, and understand automatic parsing rules. Mastering these can improve code flexibility and maintenance.

Laravel performance optimization can improve application efficiency through four core directions. 1. Use the cache mechanism to reduce duplicate queries, store infrequently changing data through Cache::remember() and other methods to reduce database access frequency; 2. Optimize database from the model to query statements, avoid N 1 queries, specifying field queries, adding indexes, paging processing and reading and writing separation, and reduce bottlenecks; 3. Use time-consuming operations such as email sending and file exporting to queue asynchronous processing, use Supervisor to manage workers and set up retry mechanisms; 4. Use middleware and service providers reasonably to avoid complex logic and unnecessary initialization code, and delay loading of services to improve startup efficiency.

The core methods for handling exceptions and recording errors in Laravel applications include: 1. Use the App\Exceptions\Handler class to centrally manage unhandled exceptions, and record or notify exception information through the report() method, such as sending Slack notifications; 2. Use Monolog to configure the log system, set the log level and output method in config/logging.php, and enable error and above level logs in production environment. At the same time, detailed exception information can be manually recorded in report() in combination with the context; 3. Customize the render() method to return a unified JSON format error response, improving the collaboration efficiency of the front and back end of the API. These steps are
