Deploying LinkAce

Introduction

LinkAce is a self-hosted bookmark manager that goes beyond simple link saving. With features like automatic link archiving, dead link monitoring, and robust organization tools, LinkAce ensures your bookmarks remain accessible and organized for years to come.

Built with Laravel and designed for personal or small team use, LinkAce provides a clean interface for managing your web collection. The application automatically archives pages through the Wayback Machine, monitors for broken links, and offers comprehensive tagging and categorization.

Key highlights of LinkAce:

Bookmark Management: Save, organize, and search your links
Automatic Archival: Integration with Wayback Machine for archiving
Link Monitoring: Check for dead links and receive alerts
Tagging System: Organize links with flexible tags
Lists: Group related bookmarks into collections
Notes: Add personal notes to any link
Search: Full-text search across all bookmarks
Import/Export: Migrate from browsers and other services
Browser Extension: Quick bookmarking from any page
API Access: Programmatic access to your bookmarks
Private Links: Keep certain bookmarks private
Multi-User: Shared or individual bookmark collections

This guide walks through deploying LinkAce on Klutch.sh using Docker.

Why Deploy LinkAce on Klutch.sh

Deploying LinkAce on Klutch.sh provides several advantages:

Simplified Deployment: Klutch.sh automatically builds LinkAce from your Dockerfile. Push to GitHub, and your bookmark manager deploys.

Persistent Storage: Attach persistent volumes for your database and archives. Your bookmarks survive restarts.

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

GitHub Integration: Connect your repository for automatic redeployments.

Scalable Resources: Allocate resources based on your collection size.

Environment Variable Management: Configure settings securely.

Custom Domains: Assign a custom domain for your bookmark archive.

Always-On Availability: Your bookmark manager remains accessible 24/7.

Prerequisites

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

A Klutch.sh account
A GitHub account with a repository for your configuration
Basic familiarity with Docker and containerization concepts
A MySQL/MariaDB or PostgreSQL database
Redis for caching and queue management
(Optional) A custom domain

Understanding LinkAce Architecture

LinkAce uses a Laravel-based architecture:

PHP Application: Laravel framework handling web requests and business logic.

Database: MySQL/MariaDB or PostgreSQL for bookmark storage.

Redis: Queue management and caching.

Scheduler: Background tasks for link checking and archival.

File Storage: For imported data and cached content.

Preparing Your Repository

Repository Structure

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

Creating the Dockerfile

FROM linkace/linkace:latest

# Environment configuration
ENV APP_ENV=production
ENV APP_DEBUG=false
ENV APP_KEY=${APP_KEY}
ENV APP_URL=${APP_URL:-https://localhost}

# Database configuration
ENV DB_CONNECTION=${DB_CONNECTION:-mysql}
ENV DB_HOST=${DB_HOST:-mysql}
ENV DB_PORT=${DB_PORT:-3306}
ENV DB_DATABASE=${DB_DATABASE:-linkace}
ENV DB_USERNAME=${DB_USERNAME:-linkace}
ENV DB_PASSWORD=${DB_PASSWORD}

# Redis configuration
ENV REDIS_HOST=${REDIS_HOST:-redis}
ENV REDIS_PORT=${REDIS_PORT:-6379}

# Queue configuration
ENV QUEUE_CONNECTION=redis

# Expose port
EXPOSE 80

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

Creating the .dockerignore File

.git
.github
*.md
LICENSE
.gitignore
*.log
.DS_Store
.env
.env.local
vendor/
node_modules/

Environment Variables Reference

Variable	Required	Default	Description
`APP_KEY`	Yes	-	Laravel application key (generate with `php artisan key:generate`)
`APP_URL`	Yes	-	Public URL for LinkAce
`DB_HOST`	Yes	mysql	Database hostname
`DB_DATABASE`	No	linkace	Database name
`DB_USERNAME`	Yes	-	Database username
`DB_PASSWORD`	Yes	-	Database password
`REDIS_HOST`	Yes	redis	Redis hostname

Deploying LinkAce on Klutch.sh

Generate Application Key

Create a secure Laravel application key:

php artisan key:generate --show

Or generate a random 32-character string with base64: prefix.

Set Up MySQL/MariaDB Database

Deploy MySQL and create a database for LinkAce.

Set Up Redis

Deploy Redis for queue management and caching.

Push Your Repository to GitHub

git init
git add Dockerfile .dockerignore README.md
git commit -m "Initial LinkAce deployment configuration"
git remote add origin https://github.com/yourusername/linkace-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 named “linkace” or “bookmarks”.

Create a New App

Within your project, create a new app. Connect your GitHub account and select your LinkAce repository.

Configure HTTP Traffic

In the deployment settings:

Select HTTP as the traffic type
Set the internal port to 80

Set Environment Variables

Add the following:

Variable	Value
`APP_KEY`	Your generated key
`APP_URL`	`https://your-app.klutch.sh`
`DB_HOST`	Your MySQL hostname
`DB_DATABASE`	`linkace`
`DB_USERNAME`	Your database username
`DB_PASSWORD`	Your database password
`REDIS_HOST`	Your Redis hostname

Attach Persistent Volumes

Mount Path	Recommended Size	Purpose
`/app/storage`	5 GB	Application storage
`/app/backups`	10 GB	Database backups

Deploy Your Application

Click Deploy to start the build process.

Run Database Migrations

After deployment, run migrations through the container:

php artisan migrate

Create Admin Account

php artisan user:create

Initial Configuration

General Settings

Configure your instance:

Log in as administrator
Navigate to Settings
Configure site name and preferences
Set up mail for notifications

Archive Settings

Enable automatic archiving:

Go to Settings > Archive
Enable Wayback Machine integration
Configure archival frequency

Link Checking

Set up dead link monitoring:

Navigate to Settings > Link Check
Enable automatic checking
Set check frequency
Configure notification preferences

Import Bookmarks

Migrate existing bookmarks:

Go to Import
Upload HTML export from your browser
Review and confirm imports
Organize with tags and lists

Using LinkAce

Saving Bookmarks

Add new links:

Click “Add Link” or use browser extension
Enter URL or paste from clipboard
Add title, description, and tags
Assign to lists if desired
Save

Organization

Keep bookmarks organized:

Create lists for topics or projects
Apply consistent tagging
Use notes for context
Mark important links as starred

Searching

Find saved links:

Use the search bar
Filter by tags, lists, or status
Search notes and descriptions
Sort by date or title

Production Best Practices

Security Recommendations

Keep APP_KEY secret and backed up
Use strong passwords
Enable HTTPS
Regularly update LinkAce

Performance Tips

Enable Redis caching
Run queue workers for background tasks
Configure appropriate memory limits

Backup Strategy

Back up database regularly
Back up the storage directory
Export bookmarks periodically

Troubleshooting

Links Not Archiving

Check Wayback Machine connectivity
Verify queue workers are running
Review job logs

Search Not Working

Rebuild search index
Check database connectivity
Verify Redis is running

Import Failures

Check file format
Verify file size limits
Review import logs

Additional Resources

Conclusion

Deploying LinkAce on Klutch.sh gives you a robust, self-hosted bookmark manager with automatic archiving and link monitoring. Never lose an important link again with LinkAce’s comprehensive preservation features.

With automatic builds, persistent storage, and secure HTTPS access, you can build and maintain your personal web archive with confidence.