Lewati ke konten utama

Install .NET 8 Runtime

# Installation Guide - Neuron ERP

Home / Operations & Governance / Installation

This guide provides step-by-step instructions for installing and configuring Neuron ERP in your environment.

Table of Contents​

System Requirements​

Server Requirements​

Minimum Requirements​

  • OS: Windows Server 2019 or later, Linux (Ubuntu 20.04+)
  • CPU: 2 cores, 2.4 GHz
  • RAM: 4 GB
  • Disk Space: 20 GB
  • .NET: .NET 8 Runtime
  • Database: PostgreSQL 17 or later
  • OS: Windows Server 2022, Linux (Ubuntu 22.04 LTS)
  • CPU: 4+ cores, 3.0+ GHz
  • RAM: 8+ GB
  • Disk Space: 50+ GB (SSD recommended)
  • .NET: .NET 8 SDK (for development)
  • Database: PostgreSQL 17

Database Server​

  • PostgreSQL 17 or later
  • Minimum 10 GB database size
  • Backup storage capacity
  • Network connectivity to application server

Client Requirements​

  • Browser: Latest version of Chrome, Edge, Firefox, or Safari
  • Screen Resolution: Minimum 1024x768 (1920x1080 recommended)
  • Internet Connection: Stable broadband connection
  • JavaScript: Enabled
  • Cookies: Enabled

Pre-installation Checklist​

Before beginning installation, ensure you have:

  • Administrator access to server
  • PostgreSQL 17 installed and configured
  • .NET 8 Runtime installed
  • IIS installed (for Windows) or web server configured (for Linux)
  • Firewall rules configured for required ports
  • SSL certificate (for HTTPS)
  • Database connection string
  • License key or credentials (if applicable)

Required Software​

For Windows Server:​

# Install .NET 8 Runtime
winget install Microsoft.DotNet.Runtime.8

# Install IIS (if not already installed)
Install-WindowsFeature -name Web-Server -IncludeManagementTools

# Install PostgreSQL 17 (if needed)
# Download installer from https://www.postgresql.org/download/windows/
# Or use chocolatey:
choco install postgresql17 --params '/Password:YourPostgresPassword'

# After installation, add to PATH
$env:Path += ";C:\Program Files\PostgreSQL\17\bin"
[Environment]::SetEnvironmentVariable("Path", $env:Path, [EnvironmentVariableTarget]::Machine)

For Linux Server:​

# Install .NET 8 Runtime
wget https://dot.net/v1/dotnet-install.sh -O dotnet-install.sh
chmod +x ./dotnet-install.sh
./dotnet-install.sh --channel 8.0

# Install dependencies
sudo apt-get update
sudo apt-get install -y aspnetcore-runtime-8.0

# Install PostgreSQL 17
# Add PostgreSQL APT repository
sudo apt install -y postgresql-common
sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh

# Install PostgreSQL 17
sudo apt-get install -y postgresql-17 postgresql-client-17

# Start PostgreSQL service
sudo systemctl start postgresql
sudo systemctl enable postgresql

# Verify installation
psql --version

Installation Steps​

Step 1: Download Application Files​

  1. Obtain the latest Neuron ERP release package
  2. Extract files to deployment directory:
    • Windows: C:\inetpub\NeuronERP
    • Linux: /var/www/neuronerp
NeuronERP/
|-- wwwroot/
|-- appsettings.json
|-- Neuron_ERP.dll
|-- web.config (for IIS)
|-- ... (other files)

Step 2: Database Setup​

Create Database​

-- Connect to PostgreSQL as superuser (postgres)
-- Create database
CREATE DATABASE neuronerp
    WITH 
    OWNER = postgres
    ENCODING = 'UTF8'
    LC_COLLATE = 'en_US.UTF-8'
    LC_CTYPE = 'en_US.UTF-8'
    TABLESPACE = pg_default
    CONNECTION LIMIT = -1
    TEMPLATE = template0;

-- Add comment
COMMENT ON DATABASE neuronerp IS 'Neuron ERP Application Database';

Create Database User​

-- Create user/role
CREATE ROLE neuronerp_user WITH
    LOGIN
    NOSUPERUSER
    NOCREATEDB
    NOCREATEROLE
    INHERIT
    NOREPLICATION
    CONNECTION LIMIT -1
    PASSWORD 'StrongPassword123!';

-- Grant privileges
GRANT ALL PRIVILEGES ON DATABASE neuronerp TO neuronerp_user;

-- Connect to the database
\c neuronerp

-- Grant schema privileges
GRANT ALL ON SCHEMA public TO neuronerp_user;
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO neuronerp_user;
GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO neuronerp_user;

-- Set default privileges for future objects
ALTER DEFAULT PRIVILEGES IN SCHEMA public
GRANT ALL ON TABLES TO neuronerp_user;

ALTER DEFAULT PRIVILEGES IN SCHEMA public
GRANT ALL ON SEQUENCES TO neuronerp_user;

Run Database Scripts​

  1. Execute schema creation scripts (provided separately)
  2. Run stored procedures and functions scripts
  3. Load initial data/seed data
  4. Verify database objects created successfully
-- Verify installation
-- Check tables
SELECT COUNT(*) AS TableCount 
FROM information_schema.tables 
WHERE table_schema = 'public' AND table_type = 'BASE TABLE';

-- Check functions/procedures
SELECT COUNT(*) AS FunctionCount 
FROM pg_proc 
WHERE pronamespace = 'public'::regnamespace;

-- Check views
SELECT COUNT(*) AS ViewCount 
FROM information_schema.views 
WHERE table_schema = 'public';

Step 3: Configure Application​

Edit appsettings.json​

{
  "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Port=5432;Database=neuronerp;Username=neuronerp_user;Password=StrongPassword123!;SSL Mode=Prefer;Trust Server Certificate=true;"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ApplicationSettings": {
    "CompanyName": "Your Company Name",
    "ApplicationTitle": "Neuron ERP",
    "SessionTimeout": 30,
    "EnableTwoFactorAuth": false
  }
}

Configure Authentication (Optional)​

For Google OAuth, add:

{
  "Authentication": {
    "Google": {
      "ClientId": "your-client-id.apps.googleusercontent.com",
      "ClientSecret": "your-client-secret"
    }
  }
}

Configure Firebase (Optional)​

For push notifications:

{
  "Firebase": {
    "ProjectId": "your-project-id",
    "CredentialPath": "path/to/firebase-credentials.json"
  }
}

Step 4: Deploy to Web Server​

For IIS (Windows):​

  1. Create Application Pool

    # Create app pool
    New-WebAppPool -Name "NeuronERPPool"

    # Configure app pool
    Set-ItemProperty IIS:\AppPools\NeuronERPPool -name "managedRuntimeVersion" -value ""
    Set-ItemProperty IIS:\AppPools\NeuronERPPool -name "enable32BitAppOnWin64" -value $false

  2. Create IIS Website

    # Create website
    New-Website -Name "NeuronERP" `
      -PhysicalPath "C:\inetpub\NeuronERP" `
      -ApplicationPool "NeuronERPPool" `
      -Port 80

    # Add HTTPS binding
    New-WebBinding -Name "NeuronERP" -Protocol "https" -Port 443

  3. Configure SSL Certificate

    • Import SSL certificate
    • Bind to website on port 443

  4. Set Permissions

    $acl = Get-Acl "C:\inetpub\NeuronERP"
    $permission = "IIS AppPool\NeuronERPPool","ReadAndExecute","Allow"
    $accessRule = New-Object System.Security.AccessControl.FileSystemAccessRule $permission
    $acl.SetAccessRule($accessRule)
    Set-Acl "C:\inetpub\NeuronERP" $acl

For Linux (with Nginx):​

  1. Create Systemd Service
sudo nano /etc/systemd/system/neuronerp.service
[Unit]
Description=Neuron ERP Application
After=network.target

[Service]
WorkingDirectory=/var/www/neuronerp
ExecStart=/usr/bin/dotnet /var/www/neuronerp/Neuron_ERP.dll
Restart=always
RestartSec=10
SyslogIdentifier=neuronerp
User=www-data
Environment=ASPNETCORE_ENVIRONMENT=Production
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false

[Install]
WantedBy=multi-user.target
  1. Configure Nginx
sudo nano /etc/nginx/sites-available/neuronerp
server {
    listen 80;
    server_name your-domain.com;
    
    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen 443 ssl;
    server_name your-domain.com;
    
    ssl_certificate /path/to/certificate.crt;
    ssl_certificate_key /path/to/private.key;
    
    location / {
        proxy_pass http://localhost:5000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
  1. Enable and Start Service
sudo systemctl enable neuronerp
sudo systemctl start neuronerp
sudo systemctl status neuronerp

sudo ln -s /etc/nginx/sites-available/neuronerp /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Step 5: Configure Firewall​

Windows Firewall:​

# Allow HTTP
New-NetFirewallRule -DisplayName "Neuron ERP HTTP" -Direction Inbound -LocalPort 80 -Protocol TCP -Action Allow

# Allow HTTPS
New-NetFirewallRule -DisplayName "Neuron ERP HTTPS" -Direction Inbound -LocalPort 443 -Protocol TCP -Action Allow

Linux Firewall (UFW):​

sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw reload

Application Configuration​

Initial Setup​

  1. Access Application

    • Navigate to https://your-domain.com
    • You should see the login page

  2. Default Credentials (if provided)

    • Username: admin
    • Password: admin123 (change immediately)

  3. Initial Configuration Wizard

    • Company Information
    • Branch Setup
    • Fiscal Year
    • User Configuration

Company Setup​

  1. Navigate to Master Data > Company > Branch
  2. Create your company branch
  3. Set fiscal year
  4. Configure organizational structure

User Management​

  1. Go to Administrative Tools > User Management
  2. Create user accounts
  3. Assign roles and permissions
  4. Set up approval workflows

Chart of Accounts​

  1. Navigate to Financial > General Ledger > Account
  2. Import or create chart of accounts
  3. Set up cost centers
  4. Configure fiscal periods

Post-Installation Tasks​

1. Security Hardening​

// appsettings.Production.json
{
  "AllowedHosts": "your-domain.com",
  "DetailedErrors": false,
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  }
}

2. Performance Tuning​

Application Performance​

  • Configure connection pooling in connection string 
    "DefaultConnection": "Host=localhost;Port=5432;Database=neuronerp;Username=neuronerp_user;Password=StrongPassword123!;Pooling=true;Minimum Pool Size=5;Maximum Pool Size=100;"
  • Set up caching
  • Configure CDN for static assets (if applicable)

PostgreSQL Performance Tuning​

Edit postgresql.conf for optimization:

# Memory Settings (adjust based on available RAM)
shared_buffers = 256MB                  # 25% of RAM (for dedicated server)
effective_cache_size = 1GB              # 50-75% of RAM
work_mem = 16MB                         # Per operation memory
maintenance_work_mem = 128MB            # For maintenance operations

# Checkpoint Settings
checkpoint_completion_target = 0.9
wal_buffers = 16MB

# Query Planner
random_page_cost = 1.1                  # For SSD storage
effective_io_concurrency = 200          # For SSD storage

# Connection Settings
max_connections = 100

# Logging for monitoring
logging_collector = on
log_directory = 'pg_log'
log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'
log_statement = 'mod'                   # Log modifications
log_duration = on
log_min_duration_statement = 1000       # Log queries > 1 second

# After changes, restart PostgreSQL
# Linux: sudo systemctl restart postgresql
# Windows: Restart-Service postgresql-x64-17

Database Indexes​

  • Create indexes on frequently queried columns
  • Monitor and optimize slow queries 
    -- Enable pg_stat_statements extension
    CREATE EXTENSION IF NOT EXISTS pg_stat_statements;

    -- Find slow queries
    SELECT query, mean_exec_time, calls
    FROM pg_stat_statements
    ORDER BY mean_exec_time DESC
    LIMIT 10;

3. Backup Configuration​

# PostgreSQL Backup using pg_dump

# Full database backup (custom format - recommended)
pg_dump -U neuronerp_user -F c -b -v -f "/backups/neuronerp_full_$(date +%Y%m%d_%H%M%S).backup" neuronerp

# SQL format backup
pg_dump -U neuronerp_user -F p -f "/backups/neuronerp_$(date +%Y%m%d_%H%M%S).sql" neuronerp

# Directory format (for parallel restore)
pg_dump -U neuronerp_user -F d -f "/backups/neuronerp_dir_$(date +%Y%m%d_%H%M%S)" neuronerp

# Restore from backup
pg_restore -U neuronerp_user -d neuronerp -v "/backups/neuronerp_full.backup"

# Schedule automated backups (using pg_cron extension or OS scheduler)
# For Linux cron:
# 0 2 * * * pg_dump -U neuronerp_user -F c -f "/backups/neuronerp_daily.backup" neuronerp

# For Windows Task Scheduler, create a .bat file:
# @echo off
# set PGPASSWORD=StrongPassword123!
# pg_dump -U neuronerp_user -F c -f "C:\Backups\neuronerp_%date:~-4,4%%date:~-10,2%%date:~-7,2%.backup" neuronerp

4. Monitoring Setup​

  • Configure application logging
  • Set up health checks
  • Configure alerts for critical errors
  • Monitor database performance 
    -- PostgreSQL monitoring queries

    -- Check database size
    SELECT pg_size_pretty(pg_database_size('neuronerp')) as db_size;

    -- Check table sizes
    SELECT schemaname, tablename, 
           pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) AS size
    FROM pg_tables
    WHERE schemaname = 'public'
    ORDER BY pg_total_relation_size(schemaname||'.'||tablename) DESC
    LIMIT 10;

    -- Check active connections
    SELECT count(*) FROM pg_stat_activity WHERE state = 'active';

    -- Check long running queries
    SELECT pid, now() - query_start AS duration, query, state
    FROM pg_stat_activity
    WHERE state != 'idle'
    ORDER BY duration DESC;

    -- Check cache hit ratio (should be > 95%)
    SELECT 
      sum(heap_blks_read) as heap_read,
      sum(heap_blks_hit) as heap_hit,
      sum(heap_blks_hit) / (sum(heap_blks_hit) + sum(heap_blks_read)) * 100 AS cache_hit_ratio
    FROM pg_statio_user_tables;

5. Testing​

  • Test login functionality
  • Verify all modules accessible
  • Test creating sample transactions
  • Test report generation
  • Verify email notifications (if configured)
  • Test approval workflows

Verification Checklist​

After installation, verify:

  • Application accessible via browser
  • Users can log in successfully
  • All modules load without errors
  • Database connection working
  • Reports generate correctly
  • File uploads working
  • Email notifications working (if configured)
  • Backup jobs configured
  • SSL certificate valid
  • Performance acceptable

Troubleshooting​

Common Issues​

Application Won't Start​

Problem: Application fails to start or shows error page

Solutions:

  1. Check .NET Runtime installed correctly
  2. Verify database connection string
  3. Check application pool/service status
  4. Review error logs in Event Viewer (Windows) or systemd journal (Linux)
# Linux: Check logs
sudo journalctl -u neuronerp -n 50 --no-pager

# Windows: Check Event Viewer
eventvwr.msc

Database Connection Errors​

Problem: Cannot connect to database

Solutions:

  1. Verify PostgreSQL service running 
    # Linux
    sudo systemctl status postgresql
    sudo systemctl start postgresql

    # Windows
    # Check Services (services.msc) for "postgresql-x64-17"
    # Or use PowerShell:
    Get-Service -Name "postgresql-x64-17"
    Start-Service -Name "postgresql-x64-17"
  2. Check connection string syntax
  3. Verify user credentials 
    -- Connect as postgres superuser
    psql -U postgres

    -- Check if user exists
    \du neuronerp_user

    -- Reset password if needed
    ALTER USER neuronerp_user WITH PASSWORD 'NewStrongPassword123!';
  4. Check firewall rules 
    # Linux - Allow PostgreSQL port
    sudo ufw allow 5432/tcp

    # Windows - Add firewall rule
    New-NetFirewallRule -DisplayName "PostgreSQL" -Direction Inbound -LocalPort 5432 -Protocol TCP -Action Allow
  5. Ensure PostgreSQL configured for TCP/IP 
    # Edit postgresql.conf
    # Set: listen_addresses = '*'  # or specific IP

    # Edit pg_hba.conf to allow connections
    # Add line: host all all 0.0.0.0/0 md5
    # Or for specific IP: host all all 192.168.1.0/24 md5

    # Restart PostgreSQL
    sudo systemctl restart postgresql
-- Check PostgreSQL connectivity
SELECT * FROM pg_stat_activity;

Performance Issues​

Problem: Application running slowly

Solutions:

  1. Check server resource usage (CPU, RAM, Disk)
  2. Optimize database queries
  3. Increase database connection pool size
  4. Review and optimize slow queries
  5. Consider adding indexes

Authentication Issues​

Problem: Users cannot log in

Solutions:

  1. Verify user exists in database
  2. Check password hasn't expired
  3. Ensure cookies enabled in browser
  4. Clear browser cache
  5. Check authentication configuration

Getting Help​

If you encounter issues during installation:

  1. Check the Troubleshooting Guide
  2. Review application logs
  3. Contact your system administrator
  4. Refer to the FAQ
  5. Contact Neuron support with:
    • Error messages
    • Log files
    • Steps to reproduce
    • Environment details

Next Steps​

After successful installation:

  1. Complete initial setup and configuration
  2. Train users on system usage
  3. Set up regular backup schedule
  4. Configure monitoring and alerts
  5. Review security settings
  6. Start with pilot department
  7. Gradually roll out to all users

Related Documentation:

Last Updated: January 2026