Fuedevs
Complete Development Solutions

Download and Prepare Project Files

Download the Mighty School Laravel backend from your purchase and prepare for deployment.

1. Download the project ZIP file from CodeCanyon or your purchase source
2. Extract the ZIP file to a local directory
3. Locate the Laravel backend folder (usually named laravel-backend or similar)
4. Create a new ZIP file containing only the Laravel backend files
5. Ensure the ZIP contains: app/, config/, database/, public/, routes/, etc.

Access cPanel Control Panel

Login to your hosting provider's cPanel interface.

1. Open your web browser and navigate to your cPanel URL:
• https://yourdomain.com/cpanel
• https://yourdomain.com:2083
• Or use the direct cPanel URL provided by your hosting provider
2. Enter your cPanel username and password
3. Click "Log in" to access the control panel

cPanel Login Interface - Enter your credentials

Verify PHP Version and Extensions

Ensure your hosting environment meets the requirements for Laravel.

1. In cPanel, look for "Select PHP Version" or "PHP Selector"
2. Verify PHP version is 8.1 or higher
3. Enable required PHP extensions:
• BCMath PHP Extension
• Ctype PHP Extension
• Fileinfo PHP Extension
• JSON PHP Extension
• Mbstring PHP Extension
• OpenSSL PHP Extension
• PDO PHP Extension
• Tokenizer PHP Extension
• XML PHP Extension
• cURL PHP Extension
• GD PHP Extension
• Zip PHP Extension
4. Save the changes and wait for them to take effect

Create MySQL Database and User

Set up the database that will store your Mighty School application data.

1. In cPanel, navigate to the Databases section
2. Click on "MySQL Databases"
3. Create a new database:
• Enter database name: mighty_school_prod (or your preferred name)
• Click "Create Database"
• Note the full database name (usually prefixed with your username)
4. Create a database user:
• Enter username: mighty_user (or your preferred name)
• Generate a strong password or create your own
• Click "Create User"
• Important: Save the username and password securely
5. Assign user to database:
• Select the user and database you just created
• Click "Add"
• Grant ALL PRIVILEGES to the user
• Click "Make Changes"

Creating MySQL Database and User in cPanel

Create Subdomain for Backend API

Set up a dedicated subdomain for your Mighty School backend API.

1. In cPanel, navigate to the Domains section
2. Click on "Subdomains"
3. Create the subdomain:
• Subdomain name: api or admin or backend
• Domain: Select your main domain
• Document Root: Will be auto-filled (e.g., public_html/api)
• Click "Create"
4. Wait for the subdomain to be created (usually takes a few minutes)
5. Verify the subdomain works by visiting http://api.yourdomain.com

Creating Subdomain for Backend API in cPanel

Upload Laravel Backend Files

Upload and properly organize your Mighty School Laravel backend files.

1. Access File Manager:
• In cPanel, go to Files section
• Click on "File Manager"
• Navigate to your subdomain folder (e.g., public_html/api/)
2. Upload the ZIP file:
• Click "Upload" in the File Manager toolbar
• Select your Laravel backend ZIP file
• Wait for the upload to complete (may take several minutes)
• Close the upload dialog when finished
3. Extract the files:
• Right-click on the uploaded ZIP file
• Select "Extract" from the context menu
• Choose to extract to the current directory
• Wait for extraction to complete
4. Organize the files:
• If files are extracted to a subfolder, move them to the root of your subdomain
• Ensure you can see folders like: app/, config/, database/, public/, routes/
• Delete the ZIP file after successful extraction

Uploading and Extracting Laravel Backend Files

Install Composer Dependencies

Install the required PHP packages for Laravel to function properly.

1. Access Terminal/SSH (if available):
• If your hosting provides SSH access, connect via terminal
• Navigate to your subdomain directory
• Run: composer install --no-dev --optimize-autoloader
2. Alternative - Manual Upload (if no SSH):
• Run composer install --no-dev --optimize-autoloader locally
• Upload the generated vendor/ folder to your server
• Ensure the vendor/ folder is in the root of your Laravel installation
3. Verify Installation:
• Check that the vendor/ folder exists and contains packages
• Verify vendor/autoload.php file exists

Configure Environment Variables

Set up your production environment configuration file.

1. Create .env file:
• In File Manager, navigate to your Laravel root directory
• Look for .env.example file
• Copy .env.example and rename the copy to .env
2. Edit the .env file:
• Right-click on .env and select "Edit"
• Update the configuration with your production settings
• Use the database information you saved in Step 4
3. Generate Application Key:
• If you have SSH access: php artisan key:generate
• If no SSH: Generate a 32-character random string for APP_KEY

APP_NAME='Mighty School'
APP_ENV=production
APP_KEY=base64:YOUR_32_CHARACTER_KEY_HERE
APP_DEBUG=false
APP_URL=https://api.yourdomain.com

LOG_CHANNEL=stack
LOG_DEPRECATIONS_CHANNEL=null
LOG_LEVEL=debug

DB_CONNECTION=mysql
DB_HOST=localhost
DB_PORT=3306
DB_DATABASE=username_mighty_school_prod
DB_USERNAME=username_mighty_user
DB_PASSWORD=your_secure_password

BROADCAST_DRIVER=log
CACHE_DRIVER=file
FILESYSTEM_DISK=local
QUEUE_CONNECTION=sync
SESSION_DRIVER=file
SESSION_LIFETIME=120

MAIL_MAILER=smtp
MAIL_HOST=mailhog
MAIL_PORT=1025
MAIL_USERNAME=null
MAIL_PASSWORD=null
MAIL_ENCRYPTION=null
MAIL_FROM_ADDRESS='hello@example.com'
MAIL_FROM_NAME='${APP_NAME}'

Set File Permissions

Configure proper file permissions for Laravel to function correctly.

1. Set Directory Permissions:
• In File Manager, select all files and folders
• Right-click and choose "Permissions"
• Set directories to 755 (rwxr-xr-x)
• Set files to 644 (rw-r--r--)
2. Set Special Permissions for Laravel:
• storage/ directory: 775 (rwxrwxr-x)
• bootstrap/cache/ directory: 775 (rwxrwxr-x)
• All subdirectories within storage/: 775
3. If you have SSH access:
• chmod -R 755 .
• chmod -R 775 storage bootstrap/cache
• chown -R www-data:www-data storage bootstrap/cache (if needed)

Run Database Migrations

Set up the database tables and initial data for Mighty School.

1. If you have SSH access:
• Navigate to your Laravel directory
• Run: php artisan migrate --force
• Run: php artisan db:seed --force (if seeders are available)
2. If no SSH access:
• Look for SQL files in the database/ folder
• Import these SQL files through cPanel's phpMyAdmin
• Or use the web-based installation wizard (next step)
3. Verify Database Setup:
• Check your database in cPanel phpMyAdmin
• Ensure tables have been created
• Verify sample data is present (if applicable)

Configure Web Server (Document Root)

Point your subdomain to the Laravel public directory for security.

1. Option 1 - Subdomain Document Root (Recommended):
• In cPanel, go to "Subdomains"
• Edit your API subdomain
• Change document root to: public_html/api/public
• Save changes
2. Option 2 - .htaccess Redirect:
• Create .htaccess file in subdomain root
• Add redirect rules to point to public folder
3. Option 3 - Move Files:
• Move contents of public/ folder to subdomain root
• Move Laravel files one level up
• Update index.php paths accordingly

<IfModule mod_rewrite.c>
    RewriteEngine On
    RewriteRule ^(.*)$ public/$1 [L]
</IfModule>

Run Web-Based Installation Wizard

Complete the installation using the built-in web installer.

1. Access the Installation:
• Open your browser and visit: https://api.yourdomain.com
• The installation wizard should start automatically
• If not, try: https://api.yourdomain.com/install
2. Follow Installation Steps:
• Step 1: Accept the license agreement
• Step 2: System requirements check
• Step 3: Database configuration (should auto-detect from .env)
• Step 4: Create administrator account
• Step 5: Complete installation and initial setup
3. Administrator Account Setup:
• Choose a strong username (avoid 'admin')
• Use a secure password with mixed characters
• Provide a valid email address
• Save these credentials securely

Web-Based Installation Wizard Interface

Configure SSL Certificate (Recommended)

Secure your API with HTTPS encryption for production use.

1. Enable SSL in cPanel:
• Go to "SSL/TLS" section in cPanel
• Click "Let's Encrypt SSL" (if available)
• Select your subdomain and enable SSL
• Wait for certificate generation and installation
2. Force HTTPS Redirect:
• Update your .htaccess file to force HTTPS
• Add redirect rules for security
3. Update .env Configuration:
• Change APP_URL to use https://
• Set FORCE_HTTPS=true if available

RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

Optimize for Production

Apply production optimizations for better performance and security.

1. Cache Configuration (if SSH available):
• php artisan config:cache
• php artisan route:cache
• php artisan view:cache
2. Security Optimizations:
• Remove or secure the .env file from web access
• Ensure storage/ and bootstrap/cache/ are not web accessible
• Remove any test or development files
3. Performance Settings:
• Enable OPcache in PHP settings (if available)
• Set appropriate memory limits
• Configure proper session handling

Final Testing and Verification

Comprehensive testing to ensure everything is working correctly.

1. Basic Functionality Test:
• Visit https://api.yourdomain.com
• Verify the application loads without errors
• Check that HTTPS is working properly
2. API Endpoint Testing:
• Test /api/health endpoint
• Test authentication endpoints
• Verify database connectivity
• Test CRUD operations
3. Admin Panel Access:
• Login with the administrator account you created
• Verify all admin functions work
• Test user management features
• Check system settings and configurations
4. Error Checking:
• Check Laravel logs for any errors: storage/logs/laravel.log
• Verify no PHP errors in cPanel error logs
• Test error pages (404, 500) display correctly
5. Mobile App Connection:
• Configure your mobile app to use the new API URL
• Test login and data synchronization
• Verify all mobile app features work with the production API

Docker Compose Setup

Create a Docker Compose configuration for the application.

version: '3.8'
services:
  app:
    build: .
    ports:
      - '8000:8000'
    environment:
      - APP_ENV=production
    depends_on:
      - mysql

  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: mighty_school
    ports:
      - '3306:3306'

Run Docker Container

Start the application using Docker Compose.

# Start containers in background
docker-compose up -d

# View logs
docker-compose logs -f

# Stop containers
docker-compose down