FaJo XP FSE

FaJo XP FSE — Complete Feature Overview and User GuideFaJo XP FSE is a modular software/hardware platform designed for small to medium enterprises and power users who need a customizable, high-performance solution for edge computing, media processing, and automation. This guide covers its core features, typical use cases, setup and configuration, advanced customization, troubleshooting, and best practices to help you get the most from the platform.

Key Features (At a Glance)

Modular architecture — Swap or add components without replacing the whole system.
High-performance processing — Optimized multi-core scheduling for CPU and hardware-accelerated media tasks.
Flexible I/O and connectivity — Multiple network interfaces, USB, serial, and optional wireless modules.
Robust FSE (Fault-Safe Engine) — Designed to minimize downtime with redundancy and failover.
User-friendly management console — Web-based UI plus CLI for scripting and automation.
Extensible plugin ecosystem — SDK and APIs for third-party integrations.
Enterprise-grade security — Role-based access, encrypted storage, and secure boot options.

1. Typical Use Cases

FaJo XP FSE fits several scenarios:

Edge AI / inference pre-processing: run lightweight models locally for lower latency.
Media encoding/transcoding: real-time processing for live streaming or batch jobs.
Industrial automation: connect sensors and actuators with deterministic I/O handling.
Network appliance: firewall, VPN gateway, and traffic shaping at the edge.
Custom appliances: build specialized devices using the plugin system and I/O modules.

2. Hardware and Software Components

Hardware

FaJo XP FSE platforms vary by model; common components include:

Multi-core CPU (x86 or ARM variants) with optional GPU/accelerator modules.
Expandable RAM and NVMe/SSD storage.
Multiple Gigabit/Ethernet ports and optional SFP.
GPIO, UART, SPI interfaces for industrial sensors.
Optional wireless modules: Wi‑Fi, Bluetooth, LTE/5G.
Redundant power input and battery/UPS support (for models with FSE emphasis).

Software

The software stack typically includes:

Base OS: lightweight Linux distribution optimized for embedded/server use.
FaJo management daemon and Web UI for configuration and monitoring.
Container runtime (Docker/Podman) for deploying services.
SDK and REST/gRPC APIs for integrating plugins and external systems.
Prebuilt images for common services: media server, AI runtime, VPN, etc.

3. Initial Setup and Installation

Unboxing and Hardware Setup

Inspect hardware and accessories.
Install any optional modules (RAM, storage, expansion cards) according to the quickstart guide.
Connect network, power, and console cable (if using a serial console).
Power on and watch initial boot messages on HDMI/serial or wait for network provisioning.

First Boot and Network Provisioning

By default FaJo XP FSE attempts to get an IP via DHCP. Connect to the DHCP-assigned IP or use the serial console to view the address.
The initial admin account is created during first-boot wizard. Choose a strong password and configure time zone and NTP.
Optionally enroll the device in a central management server (if you have a fleet).

Accessing the Management Console

Open a browser to https://:8443 (self-signed certificate by default).
Log in with admin credentials. The console provides dashboards for CPU/RAM/disk, network, and active services.

4. Basic Configuration

Network

Configure static IPs, VLANs, and link aggregation from the Networking section.
Create firewall rules and port forwards for services hosted on the device.
Set up VPN (OpenVPN/WireGuard) profiles for remote administration.

Storage

Format and mount additional storage devices via the Storage menu.
Configure RAID (software-based) for redundancy on supported models.
Enable encrypted volumes for sensitive data.

Users and Access Control

Create users and assign roles (Viewer, Operator, Admin).
Enable MFA for admin accounts and LDAP/AD integration for centralized auth.

5. Deploying Applications

FaJo XP FSE uses containerization for most services.

Using Prebuilt Images

The Console includes an App Marketplace with prebuilt images (media server, ML runtime, reverse proxy, etc.).
Select an app, configure ports/volumes/environment variables, and deploy with one click.

Deploying Custom Containers

Upload your container image to a registry (private registry supported).
In the Console, create a new service: specify image, resource limits (CPU, memory), environment variables, and mounts.
Use restart policies and health checks to ensure resilience.

Example container resource spec:

CPU limit: 2 cores
Memory limit: 4 GB
Restart policy: on-failure (max 5 retries)

6. FSE (Fault-Safe Engine) Details

The FSE provides redundancy and high availability features:

Watchdog monitors: auto-restart misbehaving services.
Service replication: run primary and secondary instances (active-passive) with automatic failover.
Persistent state synchronization: sync configuration and selected data to peer devices or central storage.
Power-fail protection: optional battery-backed storage commit to reduce corruption risk.

Configuration tips:

Use quorum-based failover only when you have at least three nodes to avoid split-brain.
Keep heartbeat intervals tuned to your network conditions — too short causes false failovers; too long delays recovery.

7. Security Best Practices

Enable secure boot and disk encryption where available.
Use role-based access and MFA for administrative accounts.
Keep the device firmware and OS patched; enable automatic security updates if acceptable for your environment.
Limit management access to trusted IPs and use VPN for remote administration.
Regularly export and verify backups; test restores periodically.

8. Monitoring and Logging

Local logging: system logs retained on device with rotation. Configure retention limits to avoid disk fill.
Remote logging: forward logs to a central SIEM or syslog collector.
Metrics: Prometheus-compatible metrics endpoint available for CPU, memory, network, and service health.
Alerts: configure thresholds (CPU > 85% for 5m, disk usage > 90%) and notification channels (email, webhook, Slack).

9. Advanced Customization and SDK

FaJo provides an SDK with C, Python, and Go bindings to interact with system services, manage I/O, and extend the UI.
Plugins run in sandboxed containers and can register UI pages via the management API.
Examples included: GPIO controller, custom media pipeline, and lightweight model-serving plugin.

Example Python snippet (pseudo):

from fajo_sdk import DeviceClient dc = DeviceClient(auth_token="your-token") dc.create_service(image="registry.example.com/myapp:latest", cpus=1, mem_mb=512)

10. Troubleshooting Common Issues

No network on first boot: check link LEDs, ensure DHCP server is active, or set a serial console static IP.
Service failing to start: check container logs, resource limits, and mount permissions.
High CPU usage: identify process in top, check for runaway containers or background jobs.
Disk full: rotate logs, remove unused images/containers, expand storage if supported.

Useful commands via SSH/serial:

systemctl status fajo-daemon
journalctl -u fajo-daemon -f
docker ps -a / podman ps -a
ip addr / ip route

11. Backup, Restore, and Firmware Upgrades

Backup configuration from the Console (full config export).
Schedule periodic backups of important volumes to a remote SFTP/SMB/NFS location.
Test restores on a spare device or VM before applying to production.
Firmware upgrades: apply via the Console or USB image; read the release notes and backup before upgrading. Use staged rollouts for fleets.

12. Example Deployment Scenarios

Scenario A — Edge Media Transcoder:

Hardware: FaJo XP FSE with GPU module.
Software: containerized FFmpeg pipeline, ingress via RTMP, egress HLS/DASH.
FSE usage: run two instances in active-passive for uptime, sync configs to peer.

Scenario B — Industrial Gateway:

Hardware: model with GPIO and serial modules.
Software: container with Modbus/TCP adapter, local database, and MQTT bridge to cloud.
Security: encrypted storage, restricted management VLAN, and enterprise VPN.

13. FAQs

Q: Can I run custom Linux apps natively (not containerized)?
A: Yes—though containerization is recommended for isolation and easier lifecycle management.

Q: Is GPU acceleration supported?
A: Yes, GPU/accelerator modules are supported on supported models.

Q: How many concurrent containers/services?
A: Depends on hardware resources; monitor and set resource limits per service.

14. Resources and Next Steps

Start with the Console quickstart for guided setup.
Explore the App Marketplace for one-click deployments.
Use the SDK examples to build a custom plugin.
For fleet management, configure enrollment to the central FaJo management server.

If you want, I can:

Provide a step-by-step quickstart checklist tailored to a specific FaJo XP FSE model.
Draft configuration snippets (network, containers, firewall) for your target deployment.