Skip to content
Klutch.sh Docs

Deploying CoreShop

Introduction

CoreShop is a powerful, flexible e-commerce platform built on top of Pimcore that empowers businesses to create sophisticated online stores without the limitations of traditional e-commerce platforms. It combines a robust product management system with a complete shopping experience, from browsing to checkout.

CoreShop transforms how companies approach e-commerce. Rather than being confined by the capabilities of fixed platforms, CoreShop provides the infrastructure to build uniquely tailored shopping experiences while maintaining professional-grade reliability, security, and scalability.

Core Strengths of CoreShop:

Flexible Product Management: Organize unlimited products with customizable attributes, variations, and relationships. Build product hierarchies that match your business exactly rather than forcing your business into predefined structures.

Sophisticated Catalog: Create rich product catalogs with detailed descriptions, images, videos, and specifications. Filter, search, and organize products in ways that help customers find what they need.

Multi-Currency and Multi-Language: Reach global customers with support for multiple currencies, languages, and regional configurations. Prices, shipping, and tax rules adjust automatically per region.

Shopping Cart and Checkout: Professional shopping cart with persistent storage, saved items, and cart recovery. Streamlined checkout process that minimizes cart abandonment.

Order Management: Complete order lifecycle from creation through fulfillment. Track inventory, manage shipments, handle returns, and generate invoices automatically.

Payment Integration: Support for major payment gateways including Stripe, PayPal, and others. Secure payment processing with proper PCI compliance.

Shipping Management: Configure shipping methods, calculate rates, print labels, and track shipments. Support for real-time carrier integration.

Tax Calculation: Automatically calculate taxes based on customer location, product type, and local regulations. Support for complex tax scenarios.

Discount and Promotion Engine: Create powerful promotion rules. Offer discounts based on cart value, product type, customer segments, or time periods.

Customer Management: Build customer profiles with order history, preferences, and loyalty information. Segment customers for targeted marketing.

Admin Dashboard: Intuitive interface for managing products, orders, customers, and reports. No technical expertise required for day-to-day operations.

Extensible Architecture: Built for flexibility. Add custom features, integrate with external systems, or modify behavior through plugins and customization.

Whether you’re a small online shop, a growing brand with complex product needs, or an enterprise managing multiple stores, CoreShop provides the foundation for sophisticated e-commerce.

This guide walks you through deploying CoreShop on Klutch.sh. You’ll learn how to set up a complete e-commerce platform with persistent storage for products and orders, configure payment and shipping systems, implement security best practices, optimize performance for customer traffic, and troubleshoot common issues in production.

Prerequisites

Before deploying CoreShop to Klutch.sh, ensure you have:

  • A Klutch.sh account with dashboard access
  • A GitHub account for repository hosting
  • Docker installed locally for testing (optional but recommended)
  • Basic understanding of e-commerce operations
  • Familiarity with product management concepts
  • Knowledge of payment and shipping integrations
  • A domain name for your store (required for customer access)
  • Understanding of database management and backups

Understanding CoreShop Architecture

Technology Stack

CoreShop is built on proven, enterprise-grade technologies:

Core Platform:

  • PHP 8.0+ for server-side logic
  • Symfony framework for robust architecture
  • Pimcore PIM for product data management
  • Doctrine ORM for database abstraction
  • MySQL or PostgreSQL for persistent storage

Frontend:

  • Twig templating for flexible page rendering
  • Vue.js or React for dynamic components
  • Bootstrap for responsive design
  • Progressive web app capabilities

E-Commerce Features:

  • Product catalog with attributes and variations
  • Shopping cart and checkout system
  • Order management and fulfillment
  • Customer accounts and profiles
  • Payment processing integration
  • Shipping calculation and management

Content Management:

  • CMS for marketing pages and content
  • SEO tools and optimization
  • Analytics and reporting
  • Email marketing integration

Integrations:

  • Payment gateways (Stripe, PayPal, etc.)
  • Shipping providers (FedEx, UPS, DHL)
  • Email services
  • Accounting systems
  • CRM platforms

Core Components

Web Server: Apache or Nginx serving PHP and handling requests

Product Database: MySQL/PostgreSQL storing all product data

Order Management: System for processing and tracking orders

Payment Engine: Secure payment processing integration

Shipping System: Calculating and managing shipments

Customer System: User accounts and profile management

Admin Interface: Dashboard for store operations

Cache Layer: Redis for performance optimization

Installation and Setup

Step 1: Create Your Project Directory

Start with a dedicated directory for your CoreShop deployment:

Terminal window
mkdir coreshop-deployment
cd coreshop-deployment
git init

Step 2: Create Directory Structure

Set up the necessary directories for a production-ready deployment:

Terminal window
mkdir -p var logs public uploads config docker

Your project structure will look like:

coreshop-deployment/
├── Dockerfile
├── docker-entrypoint.sh
├── .env.example
├── .dockerignore
├── .gitignore
├── config/
│   └── packages/
├── public/
│   └── (static files)
├── var/
│   ├── cache/
│   ├── log/
│   └── sessions/
└── uploads/
    └── (product images)

Step 3: Create the Dockerfile

Create a Dockerfile for a production-ready CoreShop deployment:

# Build stage
FROM php:8.2-fpm-alpine as builder


RUN apk add --no-cache \
    git \
    curl \
    libzip-dev \
    libpng-dev \
    libjpeg-turbo-dev \
    freetype-dev \
    libmcrypt-dev \
    imagemagick-dev \
    postgresql-dev


RUN docker-php-ext-configure gd \
    --with-freetype \
    --with-jpeg


RUN docker-php-ext-install -j$(nproc) \
    pdo_mysql \
    pdo_pgsql \
    gd \
    zip \
    bcmath \
    intl \
    opcache


RUN pecl install imagick && docker-php-ext-enable imagick


RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/bin --filename=composer


WORKDIR /app


COPY . .


RUN composer install --no-dev --optimize-autoloader


# Runtime stage
FROM php:8.2-fpm-alpine


RUN apk add --no-cache \
    nginx \
    postgresql-client \
    mysql-client \
    curl \
    supervisor \
    dumb-init \
    libpng \
    libjpeg-turbo \
    freetype \
    imagemagick


RUN docker-php-ext-install -j$(nproc) \
    pdo_mysql \
    pdo_pgsql \
    gd \
    zip \
    bcmath \
    intl \
    opcache


RUN pecl install imagick && docker-php-ext-enable imagick


RUN addgroup -g 1000 www && \
    adduser -D -u 1000 -G www www


WORKDIR /app


COPY --from=builder --chown=www:www /app .


RUN mkdir -p var/cache var/logs var/sessions uploads && \
    chown -R www:www var uploads public


COPY docker/nginx.conf /etc/nginx/
COPY docker/php.ini /usr/local/etc/php/
COPY docker/supervisor.conf /etc/supervisor/conf.d/


EXPOSE 8080


HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
    CMD curl -f http://localhost:8080/health || exit 1


ENTRYPOINT ["dumb-init", "--"]


CMD ["supervisord", "-c", "/etc/supervisor/conf.d/supervisor.conf"]

Step 4: Create Environment Configuration

Create .env.example for CoreShop configuration:

Terminal window
# Application configuration
APP_ENV=prod
APP_DEBUG=0
APP_SECRET=your-secret-key-change-this


# Database configuration
DATABASE_URL=postgresql://coreshop:password@localhost:5432/coreshop
DATABASE_POOL_SIZE=20


# Redis configuration (optional, for caching)
REDIS_URL=redis://localhost:6379/0


# Server configuration
SERVER_NAME=example-app.klutch.sh
APP_URL=https://example-app.klutch.sh


# Store configuration
STORE_NAME=Your Store
STORE_EMAIL=orders@example.com
STORE_CURRENCY=USD


# Payment configuration
STRIPE_PUBLIC_KEY=pk_live_...
STRIPE_SECRET_KEY=sk_live_...
PAYPAL_MODE=live
PAYPAL_CLIENT_ID=...
PAYPAL_CLIENT_SECRET=...


# Shipping configuration
SHIPSTATION_API_KEY=...
SHIPSTATION_API_SECRET=...


# Email configuration
MAILER_DSN=smtp://user:password@smtp.example.com:587?encryption=tls


# Security
CORS_ALLOW_ORIGIN=*
TRUSTED_HOSTS=example.com


# File uploads
UPLOAD_MAX_SIZE=52428800
UPLOAD_DIR=/app/uploads


# Session configuration
SESSION_LIFETIME=86400
SESSION_PATH=/app/var/sessions


# Cache configuration
CACHE_TTL=3600
CACHE_WARMUP_ON_DEPLOY=true


# Logging
LOG_LEVEL=error
LOG_CHANNEL=stack


# Optional: S3 storage
S3_ENABLED=false
S3_BUCKET=coreshop-uploads
S3_REGION=us-east-1

Step 5: Create Nginx Configuration

Create docker/nginx.conf:

user www;
worker_processes auto;
error_log /app/var/logs/nginx-error.log warn;
pid /var/run/nginx.pid;


events {
    worker_connections 1024;
}


http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;


    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';


    access_log /app/var/logs/nginx-access.log main;


    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;
    client_max_body_size 100M;


    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types text/plain text/css text/xml text/javascript
               application/json application/javascript application/xml+rss;


    upstream php-fpm {
        server 127.0.0.1:9000;
    }


    server {
        listen 8080;
        server_name _;


        root /app/public;
        index index.php index.html;


        location / {
            try_files $uri $uri/ /index.php$is_args$args;
        }


        location ~ ^/index\.php(/|$) {
            fastcgi_pass php-fpm;
            fastcgi_split_path_info ^(.+\.php)(/.*)$;
            include fastcgi_params;
            fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
            fastcgi_param DOCUMENT_ROOT $realpath_root;
            fastcgi_intercept_errors on;
        }


        location ~ \.php$ {
            return 404;
        }


        location ~* ^/uploads/ {
            expires 30d;
            add_header Cache-Control "public, immutable";
        }


        location ~* \.(css|js|svg|jpg|jpeg|png|gif|ico)$ {
            expires 30d;
            add_header Cache-Control "public, immutable";
        }
    }
}

Step 6: Create PHP Configuration

Create docker/php.ini:

memory_limit = 512M
upload_max_filesize = 100M
post_max_size = 100M
max_execution_time = 300
max_input_time = 300
date.timezone = UTC


opcache.enable = 1
opcache.memory_consumption = 256
opcache.max_accelerated_files = 20000
opcache.validate_timestamps = 0
opcache.revalidate_freq = 0


realpath_cache_size = 4096K
realpath_cache_ttl = 600

Step 7: Create Supervisor Configuration

Create docker/supervisor.conf:

[supervisord]
logfile=/app/var/logs/supervisord.log
pidfile=/var/run/supervisord.pid
nodaemon=true


[unix_http_server]
file=/var/run/supervisor.sock


[supervisorctl]
serverurl=unix:///var/run/supervisor.sock


[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface


[program:php-fpm]
command=/usr/local/sbin/php-fpm
stdout_logfile=/app/var/logs/php-fpm.log
stderr_logfile=/app/var/logs/php-fpm-error.log
autorestart=true


[program:nginx]
command=/usr/sbin/nginx -g "daemon off;"
stdout_logfile=/app/var/logs/nginx.log
stderr_logfile=/app/var/logs/nginx-error.log
autorestart=true

Step 8: Create Docker Entry Script

Create docker-entrypoint.sh:

#!/bin/sh


set -e


# Wait for database if configured
if [ ! -z "$DATABASE_URL" ]; then
    echo "Waiting for database..."
    if [[ "$DATABASE_URL" == *"postgresql"* ]]; then
        until pg_isready -h localhost -U coreshop &>/dev/null; do
            printf '.'
            sleep 1
        done
    else
        until mysqladmin ping -h localhost -u coreshop -p"$MYSQL_PASSWORD" &>/dev/null; do
            printf '.'
            sleep 1
        done
    fi
    echo "Database ready!"
fi


# Wait for Redis if configured
if [ ! -z "$REDIS_URL" ]; then
    echo "Waiting for Redis..."
    until redis-cli -u "$REDIS_URL" ping > /dev/null 2>&1; do
        printf '.'
        sleep 1
    done
    echo "Redis ready!"
fi


# Create necessary directories
mkdir -p var/cache var/logs var/sessions uploads


# Set permissions
chmod -R 755 var uploads public


# Run migrations if needed
if [ "$RUN_MIGRATIONS" = "true" ]; then
    echo "Running database migrations..."
    php bin/console doctrine:migrations:migrate --no-interaction
fi


# Warm up cache
if [ "$CACHE_WARMUP_ON_DEPLOY" = "true" ]; then
    echo "Warming up cache..."
    php bin/console cache:warmup
fi


echo "Starting CoreShop..."
exec "$@"

Make it executable:

Terminal window
chmod +x docker-entrypoint.sh

Step 9: Create .dockerignore

Create .dockerignore:

.git
.gitignore
.env
.env.local
.env.*.local
.DS_Store
node_modules
npm-debug.log
yarn-error.log
var/cache/*
var/logs/*
var/sessions/*
.vscode
.idea
README.md
docs/
tests/
coverage/

Step 10: Create .gitignore

Create .gitignore:

# Environment
.env
.env.local
.env.*.local


# Dependencies
vendor/
node_modules/
composer.lock


# Logs
var/logs/*
*.log


# Cache
var/cache/*


# Sessions
var/sessions/*


# Uploads
uploads/*


# IDE
.vscode/
.idea/
*.swp
*.swo


# OS
.DS_Store
Thumbs.db


# Testing
coverage/
.phpunit.result.cache

Step 11: Commit to GitHub

Push your CoreShop configuration to GitHub:

Terminal window
git add Dockerfile docker/ .env.example .dockerignore .gitignore
git commit -m "Add CoreShop e-commerce platform Docker configuration for Klutch.sh deployment"
git branch -M main
git remote add origin https://github.com/yourusername/coreshop-deployment.git
git push -u origin main

Deploying to Klutch.sh

Now let’s deploy CoreShop to Klutch.sh with proper configuration and persistent storage for products and orders.

Deployment Steps

  1. Access Klutch.sh Dashboard

    Navigate to klutch.sh/app and sign in with your GitHub account. This is where you’ll manage your CoreShop deployment.

  2. Create a New Project

    In the Projects section, click “Create Project” and name it something like “Online Store” or “E-Commerce Platform”.

  3. Create a New App

    Within your project, click “Create App” to begin configuring your CoreShop deployment.

  4. Connect Your Repository
    • Select GitHub as your Git source
    • Choose the repository where you pushed your CoreShop Dockerfile
    • Select the branch to deploy (typically main)

    Klutch.sh will automatically detect the Dockerfile in your repository root.

  5. Configure Traffic Settings
    • Traffic Type: Select HTTP (CoreShop is a web application)
    • Internal Port: Set to 8080 (Nginx port in container)

    This allows customers to browse and purchase through your online store via HTTPS.

  6. Configure Environment Variables

    Add the following environment variables to configure your CoreShop instance:

    Application Configuration:

    APP_ENV=prod
    APP_DEBUG=0
    APP_SECRET=generate-a-strong-random-secret-here
    SERVER_NAME=example-app.klutch.sh
    APP_URL=https://example-app.klutch.sh

    Store Configuration:

    STORE_NAME=Your Store Name
    STORE_EMAIL=orders@yourstore.com
    STORE_CURRENCY=USD
    TIMEZONE=America/New_York

    Database Configuration:

    For PostgreSQL (recommended):

    DATABASE_URL=postgresql://coreshop:password@hostname:5432/coreshop
    DATABASE_POOL_SIZE=20

    For MySQL:

    DATABASE_URL=mysql://coreshop:password@hostname:3306/coreshop?serverVersion=8.0
    DATABASE_POOL_SIZE=20

    Redis Configuration (for caching and sessions):

    REDIS_URL=redis://hostname:6379/0
    CACHE_TTL=3600
    CACHE_WARMUP_ON_DEPLOY=true

    Payment Gateway Configuration:

    For Stripe:

    STRIPE_PUBLIC_KEY=pk_live_...
    STRIPE_SECRET_KEY=sk_live_...

    For PayPal:

    PAYPAL_MODE=live
    PAYPAL_CLIENT_ID=...
    PAYPAL_CLIENT_SECRET=...

    Shipping Configuration:

    SHIPSTATION_API_KEY=...
    SHIPSTATION_API_SECRET=...

    Email Configuration (for order notifications):

    MAILER_DSN=smtp://username:password@smtp.gmail.com:587?encryption=tls

    Security and CORS:

    CORS_ALLOW_ORIGIN=https://yourstore.com
    TRUSTED_HOSTS=yourstore.com

    File Upload Settings:

    UPLOAD_MAX_SIZE=52428800
    UPLOAD_DIR=/app/uploads

    Session and Cache:

    SESSION_LIFETIME=86400
    LOG_LEVEL=error

    Security Notes:

    • Generate a strong APP_SECRET using a cryptographic generator
    • Use payment provider live keys only in production
    • Keep database credentials secure
    • Use app-specific email passwords
    • Restrict CORS_ALLOW_ORIGIN to your domain only
  7. Configure Persistent Storage

    CoreShop needs persistent storage for products, orders, and customer data:

    Volume 1 - Application Data:

    • Mount Path: /app/var
    • Size: 10-50 GB (depends on database and cache size)

    Volume 2 - Product Uploads:

    • Mount Path: /app/uploads
    • Size: 20-100 GB (depends on product images and media)

    Guidelines for volume sizes:

    • Small store (< 1000 products, < 100 orders/month): 10 GB var, 20 GB uploads
    • Medium store (1000-10000 products, 100-1000 orders/month): 25 GB var, 50 GB uploads
    • Large store (10000+ products, 1000+ orders/month): 50+ GB var, 100+ GB uploads

    Data stored:

    • Product catalog and attributes
    • All orders and transactions
    • Customer accounts and addresses
    • Product images and media
    • Cache and session data
    • Application logs

    Critical: Without persistent storage, all products, orders, and customer data is lost on container restart.

  8. Configure Compute Resources

    Choose appropriate resources based on expected traffic:

    Small Store (< 100 concurrent visitors):

    • CPU: 2 cores
    • RAM: 2 GB
    • Suitable for: Small boutiques, niche shops

    Medium Store (100-500 concurrent visitors):

    • CPU: 4 cores
    • RAM: 4 GB
    • Suitable for: Growing online retailers

    Large Store (500-2000 concurrent visitors):

    • CPU: 8 cores
    • RAM: 8 GB
    • Suitable for: Popular brands, high-volume sellers

    Very Large Store (2000+ concurrent visitors):

    • CPU: 16+ cores
    • RAM: 16+ GB
    • Suitable for: Enterprise retailers, seasonal traffic

    Note: E-commerce platforms are memory and CPU-intensive during checkout and payment processing. Monitor actual metrics and scale accordingly.

  9. Deploy the Application

    Click “Create” to start the deployment. Klutch.sh will:

    1. Clone your repository from GitHub
    2. Build the Docker image with CoreShop and PHP
    3. Configure all environment variables
    4. Set up persistent storage volumes
    5. Start the CoreShop application
    6. Assign a public URL (e.g., store.klutch.sh)
    7. Configure automatic HTTPS with SSL certificates

    Initial deployment typically takes 10-15 minutes.

  10. Monitor Deployment Progress

    Track your deployment:

    • Go to the Deployments tab
    • View real-time build logs
    • Wait for status to show “Running”
    • Verify environment variables are correctly set
    • Check that persistent storage is mounted

    Ensure the CoreShop service starts without errors.

  11. Test Your Deployment

    After deployment, verify CoreShop is working:

    1. Access the Store Frontend: Open your browser to your deployment URL (e.g., https://example-app.klutch.sh)

    2. Access Admin Dashboard: Navigate to /admin and log in with your admin credentials

    3. Add Test Product:

      • Go to Products section
      • Create a test product
      • Add images and pricing
      • Publish the product

    4. Test Shopping Cart:

      • Browse to product on storefront
      • Add product to cart
      • View cart and checkout flow

    5. Check Logs:

      • View application logs in Klutch.sh dashboard
      • Look for PHP or Nginx errors
      • Verify database connectivity

    6. Health Check:

      Terminal window
      curl https://example-app.klutch.sh/health
  12. Configure Your Domain

    Add your custom domain for your online store:

    1. In Klutch.sh dashboard, go to Domains
    2. Click “Add Custom Domain”
    3. Enter your domain (e.g., store.example.com)
    4. Update DNS with CNAME record pointing to example-app.klutch.sh
    5. Wait for DNS propagation and SSL certificate provisioning

    Update CoreShop Configuration:

    1. Update APP_URL environment variable
    2. Update CORS_ALLOW_ORIGIN
    3. Update TRUSTED_HOSTS
    4. Update email sender domain if applicable
    5. Test store access from custom domain
  13. Complete Initial Store Setup**

    After first deployment, complete these essential steps:

    1. Configure Payment Gateways:

      • Set up Stripe or PayPal
      • Test payment processing with test mode
      • Configure webhook endpoints

    2. Set Up Shipping Methods:

      • Define shipping zones and rates
      • Integrate with carrier APIs if available
      • Configure tax rules by region

    3. Add Products:

      • Create your product catalog
      • Add product images and descriptions
      • Set pricing and inventory

    4. Configure Email Notifications:

      • Set order confirmation emails
      • Configure shipping notification templates
      • Test email delivery

    5. Security Configuration:

      • Enable SSL certificate (automatic with Klutch.sh)
      • Configure payment security settings
      • Set up regular backups

Getting Started with CoreShop Admin

Creating Products

Products are the foundation of your store:

  1. Navigate to Products:

    • Log in to admin dashboard
    • Click Products in main menu

  2. Create New Product:

    • Click “Add Product”
    • Enter product name and SKU
    • Set price and cost

  3. Add Product Details:

    • Upload product images
    • Write product description
    • Add specifications and attributes

  4. Configure Variants (if applicable):

    • Add sizes, colors, or other options
    • Set different prices per variant
    • Configure inventory per variant

  5. Publish Product:

    • Set availability
    • Configure SEO settings
    • Publish to store

Managing Orders

Handle customer orders efficiently:

  1. View Orders:

    • Navigate to Orders section
    • See all customer orders
    • Filter by status or date

  2. Process Order:

    • View order details
    • Confirm payment received
    • Generate invoice

  3. Ship Order:

    • Pack order items
    • Print shipping label
    • Update tracking information

  4. Handle Returns:

    • Process return requests
    • Issue refunds
    • Manage inventory updates

Performance Optimization

Caching Strategy

Implement Redis for better performance:

REDIS_URL=redis://your-redis-server:6379/0
CACHE_TTL=3600

Caches:

  • Product catalog data
  • Category listings
  • Customer session data
  • Checkout progress

Database Optimization

Create Indexes for faster queries:

  • Product searches
  • Order lookups
  • Customer filters

Connection Pooling:

DATABASE_POOL_SIZE=20

Reuses connections for efficiency.

Image Optimization

Optimize product images for web:

  • Compress images (75-85% quality)
  • Generate thumbnails
  • Use modern formats (WebP where supported)
  • Implement lazy loading

PHP Optimization

opcache.enable = 1
opcache.memory_consumption = 256
realpath_cache_size = 4096K

Enables opcode caching for faster PHP execution.

Security Best Practices

Payment Security

PCI Compliance:

  • Never store raw card numbers
  • Use payment provider tokenization
  • Implement SSL/TLS encryption
  • Regular security audits

Payment Processing:

  • Use official payment gateway integrations
  • Validate all payment responses
  • Log all transaction attempts
  • Monitor for fraudulent activity

Customer Data Protection

Data Encryption:

  • All data in transit uses HTTPS
  • Consider encryption at rest for sensitive data
  • Secure backup of customer information

User Accounts:

  • Enforce strong passwords
  • Implement password reset securely
  • Two-factor authentication option
  • Session security

Regular Maintenance

Security Updates:

  • Monitor CoreShop/Pimcore releases for patches
  • Update PHP and dependencies regularly
  • Test updates in staging environment
  • Deploy updates promptly

Audit Logging:

  • Log all admin actions
  • Track product changes
  • Monitor order modifications
  • Review suspicious activity

Troubleshooting

Issue 1: Products Not Showing on Store

Symptoms: Product catalog is empty, nothing displays on homepage

Solutions:

  1. Verify Products Created:

    • Check admin Products section
    • Confirm products are published
    • Check visibility settings

  2. Review Category Configuration:

    • Ensure categories are created
    • Assign products to categories
    • Check category visibility

  3. Clear Caches:

    • Clear application cache
    • Clear Redis cache if using
    • Rebuild search indexes

  4. Check Logs:

    • Review PHP error logs
    • Check database connectivity
    • Look for query errors

Issue 2: Checkout Failing or Incomplete

Symptoms: Customers can’t complete purchases, checkout fails partway

Solutions:

  1. Verify Payment Gateway:

    • Check payment gateway credentials
    • Verify API keys are correct
    • Test payment in sandbox mode

  2. Check Order Creation:

    • Verify database is accessible
    • Check order table permissions
    • Review database logs

  3. Review Logs:

    • Check PHP error logs
    • Look for payment gateway errors
    • Review session data issues

  4. Test Checkout Flow:

    • Walk through checkout manually
    • Check form validation
    • Verify all required fields

Issue 3: Slow Page Load Times

Symptoms: Product pages load slowly, customer timeouts during browsing

Solutions:

  1. Enable Caching:

    • Configure Redis for caching
    • Set appropriate cache TTL
    • Warm cache on deployment

  2. Optimize Images:

    • Compress product images
    • Use appropriate image formats
    • Implement lazy loading

  3. Database Optimization:

    • Ensure proper indexes exist
    • Monitor slow queries
    • Consider query caching

  4. Upgrade Resources:

    • Increase CPU for request processing
    • Add more RAM for caching
    • Monitor peak traffic times

Issue 4: Payment Processing Failures

Symptoms: Payments fail, customers report payment errors

Solutions:

  1. Verify Payment Provider:

    • Check payment gateway status
    • Verify API keys and credentials
    • Review provider documentation

  2. Check SSL Certificate:

    • Verify HTTPS is working
    • Check certificate validity
    • Test secure connection

  3. Review Logs:

    • Check payment gateway logs
    • Review PHP error logs
    • Monitor transaction attempts

  4. Contact Payment Provider:

    • Verify account limits
    • Check fraud detection settings
    • Review transaction history

Issue 5: Order Data Lost

Symptoms: Orders disappeared, order history empty

Solutions:

  1. Verify Persistent Storage:

    • Confirm volume is mounted at /app/var
    • Check volume has sufficient space
    • Verify mount path in deployment

  2. Check Database:

    • Verify database is running
    • Test database connectivity
    • Check order table data

  3. Restore from Backup:

    • Access backup files
    • Restore database from backup
    • Verify data integrity

Issue 6: High Memory Usage

Symptoms: Server sluggish, memory warnings, application crashes

Solutions:

  1. Monitor Memory:

    • Track memory usage over time
    • Profile for memory leaks
    • Check cache sizes

  2. Optimize Settings:

    • Reduce cache TTL
    • Implement periodic cache clearing
    • Optimize database queries

  3. Upgrade Resources:

    • Increase RAM allocation
    • Add more CPU cores
    • Consider horizontal scaling

Custom Domain Setup

Using your own domain builds customer trust and professionalism.

Step 1: Add Domain in Klutch.sh

  1. Go to your CoreShop app in Klutch.sh dashboard
  2. Navigate to Domains
  3. Click “Add Custom Domain”
  4. Enter your domain (e.g., store.example.com)
  5. Save

Step 2: Update DNS

Update your domain provider’s DNS records:

Type: CNAME
Name: store
Value: example-app.klutch.sh
TTL: 3600

Step 3: Verify SSL Certificate

Klutch.sh automatically provisions SSL certificates:

  1. Wait for DNS propagation (up to 1 hour)

  2. Test HTTPS access:

    Terminal window
    curl -I https://store.example.com

  3. Certificate is automatically renewed (no action needed)

Step 4: Update CoreShop Configuration

Update environment variables and application settings:

  1. Update APP_URL to your domain
  2. Update TRUSTED_HOSTS
  3. Update CORS_ALLOW_ORIGIN
  4. Update MAILER_DSN sender domain
  5. Test store from new domain

Production Best Practices

Backup Strategy

What to Back Up:

  1. Database (products, orders, customers)
  2. Product images and uploads
  3. Application configuration
  4. SSL certificates

Backup Schedule:

  • Daily: Full automated backups
  • Weekly: Backup verification
  • Monthly: Archive backups

Backup Commands:

For PostgreSQL:

Terminal window
pg_dump postgresql://coreshop:password@host/coreshop | gzip > /backup/coreshop-$(date +%Y%m%d).sql.gz

For MySQL:

Terminal window
mysqldump -u coreshop -p database_name | gzip > /backup/coreshop-$(date +%Y%m%d).sql.gz

Backup Storage:

  • Store offsite (cloud storage, NAS)
  • Encrypt backup files
  • Document recovery procedures

Monitoring and Alerting

Key Metrics:

  • Page load times
  • Order processing time
  • Payment success rate
  • Inventory levels
  • CPU and memory usage
  • Database query performance

Alerts:

  • Page load time > 3 seconds
  • CPU > 80% sustained
  • Memory > 90% capacity
  • Failed payments
  • Backup failures

Scaling for Growth

Vertical Scaling (larger server):

  • Increase CPU for request processing
  • Add RAM for caching
  • Use faster storage

Horizontal Scaling (multiple servers):

  • Load balancer for multiple instances
  • Dedicated database server
  • Redis cluster for distributed caching
  • Object storage for product images (S3)

When to Scale:

  • Page load times degrading
  • CPU consistently > 70%
  • Payment processing delays
  • Traffic during peak seasons

Conclusion

You now have a production-ready CoreShop e-commerce platform running on Klutch.sh. Your online store is ready to process orders, manage inventory, and serve customers reliably.

CoreShop brings sophisticated e-commerce capabilities to businesses of any size. From small boutiques to growing retailers, CoreShop provides the flexibility to build a store that matches your business exactly.

The deployment you’ve built handles product catalogs, shopping carts, payment processing, and order management reliably. Scale it as your business grows, backup your data regularly, and monitor performance to keep your store running smoothly.

Whether you’re launching your first online store or migrating from another platform, CoreShop provides the foundation for e-commerce success.

For additional help, check out the CoreShop documentation, explore Pimcore features, and join the community for support and best practices.

Happy selling!