Deploying Jelu

Introduction

Jelu is a self-hosted book tracking application that helps you manage what you have read, what you are currently reading, and what you want to read. Acting as a personal Goodreads alternative, Jelu gives you complete control over your reading data while providing a clean, modern interface for organizing your book collection.

Built with Spring Boot and Vue.js, Jelu automatically fetches book metadata including cover images, descriptions, and author information. The application includes an embedded fetch-ebook-metadata utility that can import books based on title, author, or ISBN, making it easy to build your library.

Key highlights of Jelu:

• Reading Tracking: Track books as read, reading, or to-read
• Automatic Metadata: Fetch book info from multiple sources
• Cover Images: Automatically download and display book covers
• Progress Tracking: Record reading progress with dates
• Reviews and Ratings: Rate and review books in your library
• Tags and Shelves: Organize books with custom categorization
• Import Support: Import from Goodreads and other sources
• Statistics: View reading statistics and insights
• Multi-User: Support for multiple users
• API Access: REST API for integrations
• Open Source: Actively maintained on GitHub

This guide walks through deploying Jelu on Klutch.sh using Docker, configuring the application, and setting up your personal book library.

Why Deploy Jelu on Klutch.sh

Deploying Jelu on Klutch.sh provides several advantages for book tracking:

Simplified Deployment: Klutch.sh automatically builds and deploys your Jelu container.

Persistent Storage: Attach persistent volumes for your database and cover images.

HTTPS by Default: Klutch.sh provides automatic SSL certificates for secure access.

GitHub Integration: Connect your configuration repository for automated deployments.

Scalable Resources: Allocate CPU and memory as your library grows.

Environment Variable Management: Securely configure application settings.

Custom Domains: Assign a custom domain for your book library.

Always-On Availability: Your reading tracker remains accessible 24/7.

Prerequisites

Before deploying Jelu on Klutch.sh, ensure you have:

• A Klutch.sh account
• A GitHub account with a repository for your Jelu configuration
• Basic familiarity with Docker and containerization concepts
• (Optional) A Goodreads export for importing existing data
• (Optional) A custom domain for your Jelu instance

Understanding Jelu Architecture

Jelu follows a straightforward architecture:

Spring Boot Backend: Java-based API handling book data, user management, and metadata fetching.

Vue.js Frontend: Modern SPA providing the user interface.

SQLite/PostgreSQL Database: Stores books, users, reading events, and reviews.

Metadata Fetcher: Background service fetching book information from various sources.

Image Storage: Local storage for downloaded book covers.

Preparing Your Repository

Repository Structure

jelu-deploy/
├── Dockerfile
├── README.md
└── .dockerignore

Creating the Dockerfile

FROM wabayang/jelu:latest

# Environment configuration
ENV JELU_DATABASE_PATH=/config/database.db
ENV JELU_IMAGES_DIR=/config/images
ENV JELU_IMPORTS_DIR=/config/imports

# Expose the web interface port
EXPOSE 11111

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
  CMD curl -f http://localhost:11111/actuator/health || exit 1

Creating the .dockerignore File

.git
.github
*.md
LICENSE
.gitignore
*.log
.DS_Store
.env
.env.local

Environment Variables Reference

Variable	Required	Default	Description
JELU_DATABASE_PATH	No	/config/database.db	Path to SQLite database
JELU_IMAGES_DIR	No	/config/images	Directory for cover images
JELU_IMPORTS_DIR	No	/config/imports	Directory for import files
JELU_METADATA_PROVIDERS	No	google,openlibrary	Metadata fetch sources
JELU_INIT_DEFAULT_USER	No	false	Create default admin user
JELU_INIT_DEFAULT_PASSWORD	No	-	Default admin password

Deploying Jelu on Klutch.sh

Push Your Repository to GitHub

Initialize your repository and push to GitHub:

git init
git add Dockerfile .dockerignore README.md
git commit -m "Initial Jelu deployment configuration"
git remote add origin https://github.com/yourusername/jelu-deploy.git
git push -u origin main

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project. Give it a descriptive name like “jelu” or “book-tracker”.

Create a New App

Within your project, create a new app:

1. Connect your GitHub repository
2. Select the repository containing your Dockerfile
3. Configure HTTP traffic on port 11111

Set Environment Variables

Configure optional environment variables:

Variable	Value
JELU_INIT_DEFAULT_USER	true (for first run)
JELU_INIT_DEFAULT_PASSWORD	Your admin password

Attach Persistent Volumes

Add persistent storage for Jelu data:

Mount Path	Recommended Size	Purpose
/config	10 GB	Database, images, and imports

Deploy Your Application

Click Deploy to start the build process.

Access Jelu

Once deployment completes, access your Jelu instance at https://your-app-name.klutch.sh.

Initial Configuration

First Login

Access Jelu for the first time:

1. Navigate to your Jelu instance
2. Log in with the default admin credentials (if configured)
3. Change the default password immediately

User Settings

Configure your profile:

1. Click on your username in the top right
2. Navigate to Settings
3. Set your display name
4. Configure timezone
5. Set reading goals if desired

Metadata Sources

Configure metadata fetching:

1. Navigate to Admin > Settings
2. Configure metadata providers:
   • Google Books
   • Open Library
   • Custom sources
3. Set preferred language for metadata

Managing Your Library

Adding Books

Add books to your library:

By Search:

1. Click “Add Book”
2. Search by title, author, or ISBN
3. Select from search results
4. Metadata auto-populates
5. Save to your library

Manually:

1. Click “Add Book”
2. Enter book details manually
3. Upload cover image if available
4. Save to your library

Reading Status

Track your reading:

Status	Description
To Read	Books you want to read
Currently Reading	Books you’re reading now
Read	Completed books
Dropped	Abandoned books

Recording Reading Events

Log when you read:

1. Open a book
2. Click “Add Reading Event”
3. Set start and end dates
4. Add optional progress percentage
5. Save the event

Writing Reviews

Review your books:

1. Open a book you’ve read
2. Click “Add Review”
3. Set your rating (1-5 stars)
4. Write your review text
5. Mark as public or private

Organization Features

Tags

Organize with tags:

1. Open a book
2. Add tags like “fiction”, “2024”, “favorite”
3. Search and filter by tags
4. Create custom tag hierarchies

Shelves

Create custom shelves:

1. Navigate to Shelves
2. Create new shelf
3. Add books to shelves
4. Use for organization (e.g., “Favorites”, “Book Club”)

Importing Data

From Goodreads

Import your Goodreads library:

1. Export your Goodreads data as CSV
2. Navigate to Import in Jelu
3. Upload the Goodreads CSV
4. Map fields as needed
5. Start import

From CSV

Import from custom CSV:

1. Prepare CSV with book data
2. Required columns: title, author
3. Optional: ISBN, rating, date read
4. Upload and configure mapping

Statistics

Reading Insights

View your reading statistics:

• Books read per year
• Pages read over time
• Average rating given
• Reading streaks
• Genre distribution

Goals

Set and track reading goals:

1. Navigate to Goals
2. Set annual book count goal
3. Track progress throughout the year
4. View completion percentage

Production Best Practices

Security Recommendations

• Strong Passwords: Use complex passwords for all users
• Private Reviews: Keep personal reviews private if desired
• Regular Updates: Keep Jelu updated for security patches
• Access Control: Limit admin access

Backup Strategy

1. Database Backup: Regularly back up the SQLite database
2. Image Backup: Back up the cover images directory
3. Export Data: Use Jelu’s export feature periodically

Performance Optimization

• Image Optimization: Jelu optimizes cover images automatically
• Database Maintenance: SQLite handles maintenance automatically
• Cache Configuration: Adjust caching for large libraries

Troubleshooting Common Issues

Metadata Not Fetching

Symptoms: Books added without covers or descriptions.

Solutions:

• Check internet connectivity
• Verify ISBN is correct
• Try different metadata providers
• Add metadata manually if needed

Import Failures

Symptoms: Goodreads import not working.

Solutions:

• Verify CSV format is correct
• Check file encoding (UTF-8 recommended)
• Import in smaller batches
• Review error logs

Slow Performance

Symptoms: Interface is sluggish.

Solutions:

• Increase container resources
• Optimize large libraries with pagination
• Clear old import files

Additional Resources

• Official Jelu Documentation
• Jelu GitHub Repository
• Docker Installation Guide
• Klutch.sh Persistent Volumes
• Klutch.sh Deployments

Conclusion

Deploying Jelu on Klutch.sh gives you a personal book tracking system with automatic metadata fetching and a modern interface. The combination of Jelu’s comprehensive features and Klutch.sh’s reliable hosting means you can focus on reading while your library manages itself.

With support for Goodreads import, reading statistics, and multi-user access, Jelu on Klutch.sh provides everything needed for a self-hosted reading tracker that you control.