Running Laravel Projects on Hostinger Shared Hosting

Running Laravel Projects on Hostinger Shared Hosting

Welcome to this comprehensive guide on deploying and running Laravel projects on Hostinger’s shared hosting environment. Laravel, with its elegant syntax and powerful features, is a favorite among PHP developers. Hostinger, known for its affordable and user-friendly shared hosting solutions, often serves as a starting point for many looking to get their applications online.

However, combining the robustness of Laravel with the specific constraints of shared hosting can sometimes present unique challenges. This guide is designed to bridge that gap, offering a step-by-step walkthrough for both beginners and experienced developers. We’ll cover everything from initial project preparation to crucial server configurations and common troubleshooting tips, ensuring your Laravel application runs smoothly on Hostinger.

Ready to get your Laravel project live? Let’s dive in!

Table of Contents

  • Why Hostinger for Laravel? Understanding the Shared Hosting Landscape

  • Prerequisites: What You Need Before You Start

  • Setting Up Your Hostinger Environment

  • Deploying Your Laravel Project

    • Method 1: Using Hostinger File Manager

    • Method 2: Deploying via Git (Advanced)

  • Configuring Laravel on Hostinger Shared Hosting

    • Setting the Correct PHP Version

    • Creating a MySQL Database and User

    • Updating Your .env File

    • SSH Access and Composer Installation

    • Adjusting the Public Folder Structure

    • Configuring the .htaccess File

  • Executing Laravel Artisan Commands

  • Troubleshooting Common Laravel Deployment Issues

  • Optimizing Your Laravel Project on Shared Hosting

  • When to Upgrade: Moving Beyond Shared Hosting

  • Frequently Asked Questions (FAQ)

  • Final Thoughts

Why Hostinger for Laravel? Understanding the Shared Hosting Landscape

Hostinger has carved out a reputation for providing budget-friendly web hosting with a strong emphasis on user experience, primarily through its custom-built hPanel. For many developers starting out or running smaller applications, Hostinger shared hosting presents an attractive option due to its low cost and ease of use.

Advantages of Hostinger Shared Hosting for Laravel:

  • Cost-Effective: Significantly cheaper than VPS or dedicated servers, making it ideal for personal projects, testing, or small business sites.

  • User-Friendly hPanel: Hostinger’s hPanel simplifies many server management tasks, from domain setup to database creation, requiring less technical expertise.

  • Good Performance for its Tier: Hostinger often includes performance-enhancing features like LiteSpeed caching, which can benefit Laravel applications.

  • Scalability (within limits): While shared hosting has limits, Hostinger offers various plans and easy upgrade paths if your project outgrows its current environment.

Limitations to Consider:

While advantageous, shared hosting isn’t without its caveats, especially for a framework like Laravel:

  • Resource Constraints: Shared environments mean resources (CPU, RAM) are shared among many users. This can lead to performance bottlenecks for resource-intensive Laravel applications.

  • Limited Customization: You have less control over the server environment (e.g., specific PHP extensions, server configuration files beyond .htaccess).

  • No Root Access: Shared hosting doesn’t provide root access, which means you cannot install system-wide software or make deep server configuration changes.

  • Potential Security Concerns: While providers implement strong security, the shared nature means a vulnerability on one site could theoretically affect others, though this is rare with reputable hosts.

Understanding these trade-offs is crucial for setting realistic expectations and effectively running your Laravel project. For most typical Laravel applications, Hostinger shared hosting can be a perfectly viable solution with the right setup.

Prerequisites: What You Need Before You Start

Before we dive into the deployment process, ensure you have the following in place:

  1. A Fully Developed Laravel Project: Your Laravel application should be complete and tested locally. Make sure all necessary dependencies are listed in your composer.json file.

  2. Composer: The PHP dependency manager must be installed on your local machine.

  3. Git (Recommended): While not strictly required for basic file uploads, Git is invaluable for version control and deploying updates.

  4. Hostinger Hosting Account: You need an active Hostinger shared hosting plan with a domain or subdomain pointed to it.

  5. FTP Client (Optional but Recommended): Tools like FileZilla can be useful for uploading files, though Hostinger’s File Manager is quite capable.

  6. SSH Client (e.g., PuTTY for Windows, Terminal for Linux/macOS): Essential for running Composer and Artisan commands on the server.

Having these tools ready will ensure a smooth and efficient deployment process.

Setting Up Your Hostinger Environment

Your journey begins in the Hostinger hPanel. If you haven’t already, log in to your Hostinger account and navigate to your hPanel dashboard.

  1. Choose Your Hosting Plan: Ensure you’ve selected the correct hosting plan if you have multiple.

  2. Point Your Domain: Confirm that your domain or subdomain is properly pointed to your Hostinger account. This is usually done through the “Domains” or “Websites” section.

  3. Explore hPanel: Familiarize yourself with hPanel’s interface. Key sections we’ll use include:

    • File Manager: For uploading and managing your project files.

    • Databases: For creating your MySQL database.

    • PHP Configuration: For setting the correct PHP version and extensions.

    • SSH Access: For enabling and managing SSH.

Deploying Your Laravel Project

There are a couple of ways to get your Laravel project files onto Hostinger. We’ll cover the most common ones.

Method 1: Using Hostinger File Manager

This is the simplest method, ideal for smaller projects or if you’re uncomfortable with Git/SSH for the initial upload.

  1. Local Project Preparation:

    • Open your Laravel project locally.

    • Run composer install --no-dev --optimize-autoloader. This installs production dependencies and optimizes the autoloader.

    • Remove the node_modules folder if it exists (unless you absolutely need it server-side, which is rare for Laravel frontends).

    • Compress your entire Laravel project folder (excluding node_modules and any unnecessary development files) into a .zip archive. Make sure .env is updated with local settings or left blank to be filled on the server.

    • Important: Do NOT include the vendor folder in your initial upload if you plan to run composer install via SSH on the server. If you can’t use SSH, then you must include vendor. For shared hosting, it’s often easier to upload the vendor folder rather than dealing with SSH memory limits, but we will assume SSH is available and preferred for Composer.

  2. Upload to Hostinger:

    • In hPanel, navigate to File Manager.

    • Go into your domain’s root directory. This is usually public_html or a folder named after your domain.

    • Click the “Upload Files” icon (cloud with an arrow) and select your .zip archive.

    • Once uploaded, right-click the .zip file and choose “Extract”. Extract it into a new folder, e.g., laravel_app.

Method 2: Deploying via Git (Advanced)

Hostinger supports Git deployment, which is excellent for managing updates and keeping your code versioned.

  1. Initialize Git in hPanel:

    • In hPanel, go to Websites > Git.

    • Choose your domain and click “Auto Deploy” or “Manual Deploy”.

    • Enter your Git repository URL (e.g., GitHub, GitLab, Bitbucket).

    • Specify the branch you want to deploy (e.g., main or master).

    • Choose the “Target Directory” – this is usually a folder outside your public_html, e.g., laravel_app in your home directory, for security.

  2. SSH Key (if private repo): If your repository is private, you’ll need to add Hostinger’s SSH public key to your Git provider’s repository settings. Hostinger will usually display this key during the Git setup process.

  3. First Deployment:

    • Once configured, initiate the first deployment. Hostinger will pull your project files into the specified directory.

    • After the initial pull, you’ll need to SSH into your server to run composer install and other Laravel commands.

Which Method to Choose?

Feature/ConsiderationFile Manager (ZIP Upload)Git Deployment
Ease of Initial SetupVery EasyModerate (Git repo needed)
UpdatesManual re-upload/extractAutomatic on push (if auto-deploy) or manual pull
Version ControlNone built-inExcellent
For BeginnersRecommendedMore advanced
Large ProjectsCan be slow and tediousEfficient and scalable
SecurityLess secure if files are in public_htmlMore secure as project root can be outside public_html

Configuring Laravel on Hostinger Shared Hosting

This is where most of the specific adjustments for shared hosting come into play.

Setting the Correct PHP Version

Laravel projects require a specific minimum PHP version (e.g., Laravel 8 requires PHP 7.3+, Laravel 9 requires PHP 8.0+, Laravel 10 requires PHP 8.1+, Laravel 11 requires PHP 8.2+).

  1. Navigate to PHP Configuration: In hPanel, go to Advanced > PHP Configuration.

  2. Select PHP Version: Choose the PHP version compatible with your Laravel project. Always pick the highest stable version your Laravel version supports.

  3. Enable Extensions: Ensure necessary PHP extensions are enabled. Common ones for Laravel include:

    • pdo_mysql

    • mbstring

    • tokenizer

    • xml

    • ctype

    • json

    • fileinfo

    • bcmath (if using encryption)

    • gd (if handling images)

    • opcache (for performance)

    • zip (for Composer)

    • Save your changes.

Creating a MySQL Database and User

Your Laravel application needs a database to store its data.

  1. Go to Databases: In hPanel, navigate to Databases > MySQL Databases.

  2. Create New Database:

    • Enter a Database Name (e.g., your_app_db). Hostinger will prefix it with your username.

    • Enter a Database Username (e.g., your_app_user). Hostinger will prefix it.

    • Set a strong Password for the database user. Make sure to note this down carefully.

    • Click “Create”.

  3. Assign User to Database: If not automatically assigned, make sure the user you created is linked to the new database with “All Privileges”.

Updating Your .env File

The .env file holds crucial configuration for your Laravel application.

  1. Locate .env: Using the Hostinger File Manager, navigate to your Laravel project’s root directory (e.g., laravel_app).

  2. Create/Edit .env: If you didn’t upload a .env file, create one named .env in the root of your Laravel project. If you did, open it for editing.

  3. Configure Database: Update the following lines with your newly created database credentials:

    ini
    DB_CONNECTION=mysql
    DB_HOST=localhost ; Usually ‘localhost’ on shared hosting
    DB_PORT=3306
    DB_DATABASE=your_hostinger_db_name ; (e.g., u123456789_your_app_db)
    DB_USERNAME=your_hostinger_db_user ; (e.g., u123456789_your_app_user)
    DB_PASSWORD=your_db_password

  4. Configure App URL: Set the APP_URL to your domain name (e.g., https://yourdomain.com).

    ini
    APP_URL=https://yourdomain.com

  5. Generate APP_KEY: If APP_KEY is empty, you’ll generate it via SSH later. If it already has a key, you can leave it.

  6. Other Settings: Adjust any other environment variables as needed (e.g., mail settings, API keys).

    • APP_ENV=production is highly recommended for live applications.

    • APP_DEBUG=false should be set for production to prevent sensitive information exposure.

  7. Save Changes: Save the .env file.

SSH Access and Composer Installation

SSH access is vital for running Composer and Artisan commands.

  1. Enable SSH: In hPanel, go to Advanced > SSH Access. If it’s disabled, enable it. Hostinger will provide your SSH IP, username, and port (usually 22). Note these details.

  2. Connect via SSH:

    • Linux/macOS: Open Terminal and use the command: ssh your_ssh_username@your_ssh_ip -p your_ssh_port (e.g., ssh u123456789@185.185.185.185 -p 65002). Enter your Hostinger password when prompted.

    • Windows: Use PuTTY. Enter the IP address and port, then click “Open”. Enter your SSH username and password.

  3. Navigate to Project Root: Once connected, navigate to your Laravel project’s root directory. If you uploaded it to public_html/laravel_app, you’d do: cd public_html/laravel_app. If you used Git and pulled it to laravel_app in your home directory, it would be cd laravel_app.

  4. Install Composer Dependencies:

    • Hostinger usually has Composer pre-installed globally. You can check its version: composer --version.

    • Run composer install --no-dev --optimize-autoloader. This downloads and installs all production dependencies.

    • Tip: If you encounter memory limit issues, you might need to increase PHP’s memory limit via php -d memory_limit=-1 /usr/local/bin/composer install --no-dev (replace /usr/local/bin/composer with the actual path to Composer if different, which Hostinger support can provide).

  5. Generate Application Key:

    • If your .env file doesn’t have an APP_KEY, run: php artisan key:generate. This creates a unique encryption key for your application.

  6. Set Directory Permissions:

    • Laravel needs write permissions for the storage and bootstrap/cache directories.

    • Run the following commands:
      bash
      chmod -R 755 storage
      chmod -R 755 bootstrap/cache

    • Sometimes, even 775 or 777 might be necessary for certain folders, but try 755 first for security.

    • chown -R your_user:your_group storage bootstrap/cache (Replace your_user and your_group with your Hostinger user and group, which are usually the same as your SSH username). You might not have permission to chown on shared hosting, but chmod is usually sufficient.

Adjusting the Public Folder Structure

This is the most common hurdle for Laravel on shared hosting. Laravel expects its public folder to be the web root, but on shared hosting, your domain typically points to public_html.

Here are two approaches:

Approach A: Move public folder content directly into public_html (Simpler for many)

This method involves placing the contents of your Laravel public folder directly into public_html and adjusting paths in index.php.

  1. Move public_html contents:

    • In Hostinger File Manager, move all files and folders from your Laravel project’s public directory (e.g., laravel_app/public) into your domain’s web root (public_html).

    • Example files to move: index.php, robots.txt, favicon.ico, css/, js/, mix-manifest.json (if present).

  2. Move the rest of the Laravel project:

    • Move the entire remaining Laravel project (e.g., laravel_app without its public folder) one level up, parallel to public_html. So, if your public_html is ~/domains/yourdomain.com/public_html, move laravel_app to ~/domains/yourdomain.com/laravel_app_root. This keeps sensitive files outside the publicly accessible directory.

  3. Edit index.php:

    • Open public_html/index.php for editing.

    • Find these lines (usually near the top):
      php
      require DIR.’/../vendor/autoload.php’;
      $app = require_once DIR.’/../bootstrap/app.php’;

    • Change them to reflect the new path to your Laravel root. Assuming your Laravel root is now ../laravel_app_root relative to public_html:
      php
      require DIR.’/../laravel_app_root/vendor/autoload.php’;
      $app = require_once DIR.’/../laravel_app_root/bootstrap/app.php’;

      (Adjust laravel_app_root to whatever you named your main Laravel folder.)

    • Save index.php.

Approach B: Change Web Root to public folder (Requires support or advanced config)

This is the ideal approach but might not be fully supported on all shared hosting plans without Hostinger’s intervention.

  1. Contact Support: Ask Hostinger support if they can change the document root for your domain to point directly to public_html/laravel_app/public (assuming laravel_app is your project folder inside public_html).

  2. No index.php edits needed: If they do this, you don’t need to modify index.php or move files around. Your public folder simply becomes the web root.

  3. Security: This is more secure as all Laravel core files remain outside the publicly accessible directory.

Given that Approach A is more reliably achievable on shared hosting without direct support intervention, we’ll proceed assuming you’ve followed Approach A.

Configuring the .htaccess File

A .htaccess file is crucial for URL rewriting (pretty URLs) and securing your application.

  1. Ensure Laravel’s default is present: Your Laravel project should have a .htaccess file in its public directory. When you moved the contents of public to public_html (as per Approach A), this file should have been moved too.

  2. Basic Laravel .htaccess (in public_html):
    apache



    SetEnvIf Authorization “(.*)” HTTP_AUTHORIZATION=$1

    RewriteEngine On
    RewriteRule ^(.*)$ public/$1 [L] # This line is NOT for Approach A, this is for root pointing to project folder outside public_html. 
    
                                # If you moved public folder contents to public_html, remove/adjust this.
    # Handle Authorization Header
    
RewriteCond %{HTTP:Authorization} .
    
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
    # Redirect Trailing Slashes If Not A Folder...
    
RewriteCond %{REQUEST_FILENAME} !-d
    
RewriteCond %{REQUEST_URI} (.+)/$
    
RewriteRule ^ %1 [L,R=301]
    # Handle Front Controller...
    
RewriteCond %{REQUEST_FILENAME} !-d
    
RewriteCond %{REQUEST_FILENAME} !-f
    
RewriteRule ^ index.php [L]

  3. Adjusting for Approach A: If you followed Approach A (moved public folder contents into public_html), you likely already have a working .htaccess from your public folder. The RewriteRule ^ index.php [L] at the end is the most critical part, ensuring all requests are routed through Laravel’s index.php. No additional changes usually needed for this specific .htaccess if it’s the one from Laravel’s public folder.

    • Crucial Check: Make sure public_html contains the .htaccess file and index.php from your Laravel project’s public directory.

Executing Laravel Artisan Commands

With SSH set up and Composer run, you can now use Artisan commands.

  1. Connect via SSH: Use your SSH client to connect to your Hostinger account.

  2. Navigate to Project Root: cd into the directory where your main Laravel project files reside (e.g., cd ../laravel_app_root or cd public_html/laravel_app).

  3. Common Commands:

    • Run Migrations: php artisan migrate (creates your database tables).

    • Seed Database: php artisan db:seed (if you have seeders).

    • Link Storage: php artisan storage:link (creates a symbolic link for the storage folder). This command might require specific permissions or might not work reliably on all shared hosting setups if the public folder is not the actual web root. If it fails, you might need to manually create a symlink or adjust your filesystems.php configuration.

    • Clear Caches:

      • php artisan cache:clear

      • php artisan config:clear

      • php artisan route:clear

      • php artisan view:clear

    • Optimize: php artisan optimize (combines various optimizations for better performance).

    • List Routes: php artisan route:list (useful for debugging).

Troubleshooting Common Laravel Deployment Issues

Even with careful setup, you might encounter issues. Here are some common ones and their solutions:

  1. 500 Server Error:

    • Cause: Often due to incorrect file/folder permissions, an error in .env, or a PHP syntax error.

    • Solution:

      • Check storage/logs/laravel.log for specific error messages (via SSH or File Manager).

      • Ensure storage and bootstrap/cache folders have 755 permissions (chmod -R 755 storage bootstrap/cache).

      • Double-check your .env file for typos, especially database credentials.

      • Set APP_DEBUG=true temporarily in .env to see detailed error messages in the browser (change back to false immediately after debugging!).

      • Verify the PHP version.

      • Ensure all Composer dependencies are installed (composer install).

  2. Page Not Found (404 Error) or Broken URLs:

    • Cause: .htaccess issues or incorrect public folder setup.

    • Solution:

      • Make sure mod_rewrite is enabled on the server (Hostinger usually enables this by default).

      • Verify your .htaccess file in public_html is correct and matches Laravel’s requirements (specifically the RewriteRule ^ index.php [L] part).

      • Confirm that your index.php paths to vendor and bootstrap/app.php are correct relative to your Laravel project root (if using Approach A).

  3. Missing Assets (CSS/JS/Images):

    • Cause: Incorrect asset paths or issues with storage:link.

    • Solution:

      • Ensure your APP_URL in .env is correct.

      • Check if you moved mix-manifest.json and other compiled assets to public_html.

      • If using storage:link for user-uploaded files, verify the symlink exists and works. If not, manually create it via SSH: ln -sfn /path/to/your/laravel_app_root/storage/app/public /path/to/your/public_html/storage. Or, adjust config/filesystems.php to use a direct public disk path.

  4. vendor Folder Issues or Composer Errors:

    • Cause: Missing vendor directory, Composer not installed, or memory limits.

    • Solution:

      • Ensure you ran composer install --no-dev --optimize-autoloader via SSH.

      • If composer install fails with a memory error, try php -d memory_limit=-1 /usr/local/bin/composer install or contact Hostinger support to temporarily increase the PHP memory limit for SSH.

  5. Database Connection Issues:

    • Cause: Incorrect credentials in .env or database not properly set up.

    • Solution:

      • Double-check DB_DATABASE, DB_USERNAME, DB_PASSWORD, and DB_HOST in your .env file against your hPanel database details.

      • Ensure the database user is assigned to the database with all privileges.

      • Verify MySQL server is running (Hostinger handles this, but it’s good to check logs).

Optimizing Your Laravel Project on Shared Hosting

To get the best performance from your Laravel application on Hostinger shared hosting, consider these optimization techniques:

  • Caching:

    • Laravel Cache: Utilize Laravel’s caching drivers (e.g., file or database). Configure them in config/cache.php.

    • OPcache: Hostinger usually has PHP OPcache enabled. Ensure it’s active in your PHP configuration for bytecode caching.

    • Route and Config Caching: Run php artisan route:cache and php artisan config:cache in production environments. Remember to clear and re-cache whenever routes or configurations change.

  • Database Optimization:

    • Indexing: Ensure appropriate database indexes are in place for frequently queried columns.

    • Eloquent Optimization: Use eager loading (with()) to prevent N+1 query problems.

  • Asset Minification:

    • If you’re using Laravel Mix or Vite, run your build process with npm run prod locally to minify CSS and JavaScript files before deployment.

  • Image Optimization: Compress images before uploading them to your server.

  • Reduce Dependencies: Only install necessary Composer packages. The --no-dev flag is crucial during composer install on production.

  • Disable Debug Mode: Always set APP_DEBUG=false in your .env file for production.

  • Keep Laravel Updated: Regularly update your Laravel project and its dependencies to benefit from performance improvements and security fixes.

When to Upgrade: Moving Beyond Shared Hosting

While Hostinger shared hosting is a great starting point, there comes a time when your Laravel project may outgrow its capabilities. You might consider upgrading when:

  • Consistent Performance Bottlenecks: Your application experiences frequent slowdowns or 504 Gateway Timeout errors, even after optimization.

  • High Traffic Volume: Your website starts receiving a significant amount of traffic that shared resources cannot handle.

  • Resource-Intensive Tasks: You need to run complex background jobs, heavy computations, or sophisticated queues that demand dedicated CPU and RAM.

  • Specific Software Requirements: You need to install specialized server software or specific PHP extensions not available on shared hosting.

  • Greater Control and Security: You require root access for full server customization, advanced security hardening, or PCI compliance.

When these situations arise, consider moving to Hostinger’s VPS (Virtual Private Server) hosting or even a cloud hosting solution. These options provide dedicated resources, greater control, and better scalability for growing Laravel applications.

Frequently Asked Questions (FAQ)

Q1: Can I use queues (e.g., Redis, database queues) on Hostinger shared hosting?

A1: Using queues like Redis is typically not possible on shared hosting as it requires running background processes that shared environments don’t usually allow. Database queues might be theoretically possible, but running the php artisan queue:work command persistently is not practical without a dedicated server or VPS. For simple delayed tasks, you might use scheduled tasks if they don’t need to run constantly.

Q2: What’s the best way to handle storage:link on shared hosting?

A2: If your public folder is the web root (Approach B), php artisan storage:link should work fine via SSH. If you moved public folder contents to public_html (Approach A), the storage:link command might create the symlink in the wrong place. In this case, manually create the symlink using SSH: ln -sfn /path/to/your/laravel_project_root/storage/app/public /path/to/your/public_html/storage. Ensure public_html/storage doesn’t exist as a regular directory before creating the symlink.

Q3: How do I schedule tasks (cron jobs) for Laravel on Hostinger?

A3: In hPanel, go to Advanced > Cron Jobs. You can set up a new cron job to run php artisan schedule:run every minute. The command would look something like: php /path/to/your/laravel_project_root/artisan schedule:run. Make sure you use the full path to your artisan file.

Q4: My images/files uploaded via Laravel are not showing up. What’s wrong?

A4: This is often related to incorrect permissions on the storage directory or issues with the storage:link not being set up correctly, especially if you’re trying to serve uploaded files publicly. Ensure the storage/app/public directory exists and has write permissions, and that the symlink from public_html/storage to it is correctly established (see Q2).

Q5: Is it safe to put my .env file in public_html?

A5: No, absolutely not. The .env file contains sensitive information like database credentials and API keys. It should always be kept outside the publicly accessible web root. If you followed Approach A, the .env file should be in your main Laravel project directory (e.g., ../laravel_app_root/.env), which is outside of public_html.

Q6: Can I use Git deployment without SSH?

A6: While Hostinger’s Git deployment feature itself doesn’t strictly require you to manually use SSH for the pull, you will need SSH access to run composer install, php artisan migrate, php artisan key:generate, and other post-deployment commands that are essential for a Laravel application to function.

Final Thoughts

Deploying a Laravel project on Hostinger shared hosting is a common and achievable goal. While shared hosting presents certain limitations compared to a VPS or cloud server, by carefully following the steps outlined in this guide – from configuring PHP versions and databases to adjusting the public folder structure and running Artisan commands via SSH – you can successfully get your application online.

Remember to prioritize security by keeping your .env file outside the web root and setting proper file permissions. Optimize your application’s performance through caching and efficient database queries. As your project grows, don’t hesitate to consider upgrading your hosting plan to match your application’s increasing demands.

We hope this guide empowers you to launch your Laravel projects with confidence. If you found this article helpful, please share it with others in the Laravel community and consider leaving a comment below with your experiences or any tips you’ve discovered!