CasaOS Deployment - Web Scrapping Hub

Deploy Web Scrapping Hub to CasaOS for a streamlined home server experience. This guide covers installation, configuration, and management through the CasaOS interface.

What is CasaOS?

CasaOS is a simple, easy-to-use home server operating system designed around Docker. It provides a web-based interface for managing containers, storage, and applications.

Perfect for: Home media servers, Raspberry Pi deployments, NAS systems, and personal cloud setups.

Prerequisites

Before you begin, ensure you have:

CasaOS installed on your server (Installation Guide)
Docker support enabled (included by default)
Network access to your CasaOS instance
Port 1234 available (or configure an alternative)

Architecture Support

Web Scrapping Hub is optimized for multiple architectures:

✅ AMD64 (x86_64) - Standard servers and PCs
✅ ARM64 (aarch64) - Raspberry Pi 4/5, modern ARM devices
✅ ARMv7 - Raspberry Pi 3, older ARM devices

Deployment Methods

Method 1: Using Pre-built Docker Image (Recommended)

The fastest way to deploy is using the pre-built image from Docker Hub.

Access CasaOS App Store

Open your CasaOS web interface
Navigate to App Store or Apps
Click Install a customized app or Custom Install

Configure the application

Use the following docker-compose configuration:

docker-compose.yml

services:
  anxerstudios-streaming:
    image: zlosttk/anxerstudios-streaming:latest
    container_name: anxerstudios-streaming
    hostname: anxerstudios-streaming
    
    # Resource configuration
    cpu_shares: 90
    deploy:
      resources:
        limits:
          memory: 3369M
    
    # Environment variables
    environment:
      - PGID=1000
      - PUID=1000
      - TZ=America/Bogota
      - FLASK_ENV=production
      - FLASK_DEBUG=false
    
    # Network ports
    ports:
      - "1234:1234"
    
    # Persistent storage
    volumes:
      - /DATA/AppData/anxerstudios-streaming/app/config:/app/config
      - /DATA/AppData/anxerstudios-streaming/logs:/app/logs
    
    restart: unless-stopped
    
    # Health monitoring
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:1234/api/secciones || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    
    networks:
      - anxerstudios-streaming
    
    # CasaOS labels
    labels:
      - "https://github.com/UnfairAdventage/Web-Scrapping/blob/main/frontend/project/public/icono.png?raw=true"
      - "casaos.description=AnxerStudios Streaming - Plataforma de streaming de películas y series"
      - "casaos.category=Entertainment"

networks:
  anxerstudios-streaming:
    name: anxerstudios-streaming
    driver: bridge

Customize settings

Adjust the following settings for your environment:Environment Variables:

PUID and PGID: Set to your user/group ID (find with id command)
TZ: Your timezone (e.g., America/New_York, Europe/London)

Storage Paths:

volumes:
  - /your/path/config:/app/config
  - /your/path/logs:/app/logs

Memory Limit: Adjust based on your system (minimum 1GB recommended):

limits:
  memory: 2048M  # 2GB

Deploy the application

Paste the configuration into CasaOS
Click Install or Deploy
Wait for the container to download and start
The app will appear in your CasaOS dashboard

Method 2: Building from Source

For customization or development, build the image locally on your CasaOS server.

Connect to your CasaOS server

ssh user@casaos-server-ip

Clone the repository

cd /DATA/AppData  # Or your preferred location
git clone <repository-url>
cd Web-Scrapping/docker

Build the Docker image

docker build -t web-scrapping-hub .

Building on ARM devices (Raspberry Pi) may take 10-20 minutes due to compilation of native dependencies.

Create docker-compose.yml

Create a simplified compose file:

docker-compose.yml

services:
  web-scrapping-hub:
    image: web-scrapping-hub
    container_name: web-scrapping-hub
    ports:
      - "1234:1234"
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - ./config:/app/config
      - ./logs:/app/logs
    restart: unless-stopped

Deploy via CasaOS

Open CasaOS web interface
Go to App Store > Custom Install
Upload your docker-compose.yml
Click Install

CasaOS-Specific Configuration

Application Labels

The docker-compose includes CasaOS-specific labels for better integration:

labels:
  - "casaos.description=AnxerStudios Streaming - Movie and series streaming platform"
  - "casaos.category=Entertainment"

Extended Configuration (x-casaos)

x-casaos:
  author: ZLostTK
  category: Entertainment
  icon: https://icon.casaos.io/main/all/anxerstudios-streaming.png
  index: /
  port_map: "1234"
  scheme: http
  title:
    custom: "AnxerStudios Streaming"
    en_us: "AnxerStudios Streaming"
  description:
    en_us: "Plataforma de streaming para películas, series y anime con interfaz React y backend Flask"

This provides:

Custom app icon in CasaOS dashboard
Proper categorization (Entertainment)
Direct launch from dashboard
Metadata for app store listing

Accessing Your Application

Local Network Access

Once deployed, access the application from any device on your network:

http://<CASAOS_IP>:1234

Find your CasaOS IP:

ip addr show | grep "inet "

Example URLs

Home page: http://192.168.1.100:1234/page/1
Search: http://192.168.1.100:1234/page/1?search=action
Player: http://192.168.1.100:1234/ver/pelicula/movie-name

Access from Mobile/TV

The frontend automatically detects your server IP. Simply navigate to http://<CASAOS_IP>:1234 on any device connected to your network.

Managing the Application in CasaOS

Through CasaOS Dashboard

Start/Stop: Click the app tile to view controls
Logs: Click Logs to view application output
Terminal: Access container shell for debugging
Settings: Modify environment variables and volumes
Uninstall: Remove the application and optionally delete data

Command Line Management

# View running containers
docker ps

# View logs
docker logs -f anxerstudios-streaming

# Restart container
docker restart anxerstudios-streaming

# Update container
docker-compose pull
docker-compose up -d

Resource Management

Memory Configuration

The default configuration allocates 3.3GB of memory. Adjust based on your system: For Raspberry Pi 4 (4GB):

deploy:
  resources:
    limits:
      memory: 1536M  # 1.5GB

For Raspberry Pi 4 (8GB) or better:

deploy:
  resources:
    limits:
      memory: 2048M  # 2GB

CPU Shares

cpu_shares: 90  # Lower priority (default: 1024)

Adjust CPU priority:

1024: Normal priority
512: Lower priority (good for background services)
2048: Higher priority

Storage and Persistence

Default Volume Paths

volumes:
  - /DATA/AppData/anxerstudios-streaming/app/config:/app/config
  - /DATA/AppData/anxerstudios-streaming/logs:/app/logs

Creating Volume Directories

sudo mkdir -p /DATA/AppData/anxerstudios-streaming/app/config
sudo mkdir -p /DATA/AppData/anxerstudios-streaming/logs
sudo chown -R 1000:1000 /DATA/AppData/anxerstudios-streaming

Updating the Application

Via CasaOS Dashboard

Open the app settings
Click Update if available
Wait for the update to complete
Container will restart automatically

Via Command Line

cd /path/to/docker-compose
docker-compose pull
docker-compose down
docker-compose up -d

Verify the update

Check the application version in the interface or logs:

docker logs anxerstudios-streaming | grep "Version"

Current version: 1.4.8

Health Monitoring

The application includes automatic health checks:

healthcheck:
  test: ["CMD-SHELL", "curl -f http://localhost:1234/api/secciones || exit 1"]
  interval: 30s
  timeout: 10s
  retries: 3
  start_period: 40s

What this does:

Checks /api/secciones endpoint every 30 seconds
Marks container unhealthy after 3 failed attempts
Allows 40 seconds for initial startup
CasaOS will show health status in dashboard

Troubleshooting

App not accessible from network

Check firewall on CasaOS server:

sudo ufw status
sudo ufw allow 1234/tcp

Verify container is running:

docker ps | grep streaming

Check port binding:

docker port anxerstudios-streaming

Test locally first:

curl http://localhost:1234

Container won't start

Check logs for errors:

docker logs anxerstudios-streaming

Common issues:

Port 1234 already in use (change in docker-compose.yml)
Insufficient memory (reduce limit or upgrade RAM)
Permission issues with volumes (check ownership)

Slow performance on Raspberry Pi

Optimize for ARM devices:

Reduce memory limit:

limits:
  memory: 1024M

Lower CPU priority:

cpu_shares: 512

Consider overclocking your Raspberry Pi (Pi 4 only)

Health check failing

Check if Flask is running:

docker exec anxerstudios-streaming curl http://localhost:1234/api/secciones

Increase start_period for slower devices:

healthcheck:
  start_period: 60s  # Increase from 40s

Advanced Configuration

Custom Port

Change the external port (1234) if needed:

ports:
  - "8080:1234"  # Access via http://<IP>:8080

Reverse Proxy (Nginx/Traefik)

For HTTPS and custom domains:

labels:
  - "traefik.enable=true"
  - "traefik.http.routers.streaming.rule=Host(`streaming.local`)"
  - "traefik.http.services.streaming.loadbalancer.server.port=1234"

Custom Network

Integrate with existing CasaOS networks:

networks:
  default:
    external:
      name: casaos-network

Resources and Support

CasaOS Documentation

Official CasaOS setup and configuration guides

Docker Documentation

General Docker deployment information

Local Setup

Development environment setup guide

Architecture

System architecture and design

Next Steps

Now that your application is running on CasaOS:

Configure content sources in the application settings
Set up automatic updates using Watchtower or similar
Configure backups for your config and logs directories
Explore the API for integration with other services

Get Started

Installation

Core Features

Architecture

Configuration

​What is CasaOS?

​Prerequisites

​Architecture Support

​Deployment Methods

​Method 1: Using Pre-built Docker Image (Recommended)

​Method 2: Building from Source

​CasaOS-Specific Configuration

​Application Labels

​Extended Configuration (x-casaos)

​Accessing Your Application

​Local Network Access

​Example URLs

​Access from Mobile/TV

​Managing the Application in CasaOS

​Through CasaOS Dashboard

​Command Line Management

​Resource Management

​Memory Configuration

​CPU Shares

​Storage and Persistence

​Default Volume Paths

​Creating Volume Directories

​Updating the Application

​Health Monitoring

​Troubleshooting

​Advanced Configuration

​Custom Port

​Reverse Proxy (Nginx/Traefik)

​Custom Network

​Resources and Support

CasaOS Documentation

Docker Documentation

Local Setup

Architecture

​Next Steps

Build docs developers (and LLMs) love

What is CasaOS?

Prerequisites

Architecture Support

Deployment Methods

Method 1: Using Pre-built Docker Image (Recommended)

Method 2: Building from Source

CasaOS-Specific Configuration

Application Labels

Extended Configuration (x-casaos)

Accessing Your Application

Local Network Access

Example URLs

Access from Mobile/TV

Managing the Application in CasaOS

Through CasaOS Dashboard

Command Line Management

Resource Management

Memory Configuration

CPU Shares

Storage and Persistence

Default Volume Paths

Creating Volume Directories

Updating the Application

Health Monitoring

Troubleshooting

Advanced Configuration

Custom Port

Reverse Proxy (Nginx/Traefik)

Custom Network

Resources and Support

Next Steps