Deploying Wakupator

Introduction

Wakupator is a lightweight Wake-on-LAN (WoL) management tool that provides a simple web interface for remotely powering on computers and servers on your network. With support for multiple devices and a clean interface, Wakupator makes it easy to manage power states across your infrastructure.

Key highlights of Wakupator:

Web Interface: Clean, simple interface for managing devices
Multiple Devices: Configure and wake multiple computers
Device Status: Check if devices are online via ping
API Access: REST API for automation and integrations
Lightweight: Minimal resource requirements
Docker Ready: Easy deployment with Docker
Secure: Authentication support for access control
Self-Hosted: Full control over your WoL infrastructure

This guide walks through deploying Wakupator on Klutch.sh using Docker, configuring devices, and setting up remote wake functionality.

Why Deploy Wakupator on Klutch.sh

Deploying Wakupator on Klutch.sh provides several advantages for Wake-on-LAN management:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds Wakupator without complex orchestration. Push to GitHub, and your WoL manager deploys automatically.

Persistent Storage: Attach persistent volumes for your device configuration. Your device list survives container restarts.

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

GitHub Integration: Connect your configuration repository directly from GitHub. Updates trigger automatic redeployments.

Remote Access: Wake devices from anywhere with an internet connection.

Prerequisites

Before deploying Wakupator 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
Network devices with Wake-on-LAN enabled in BIOS/UEFI
Network connectivity between Klutch.sh and your local network (VPN or similar)

Understanding Wake-on-LAN Requirements

Wake-on-LAN works by sending a “magic packet” to a device’s MAC address. For Wakupator to work effectively:

Target devices must have WoL enabled in BIOS/UEFI
Network path must exist between Wakupator and target devices
Magic packets are typically broadcast on the local network

For cloud-hosted Wakupator to reach local devices, you’ll need:

A VPN connection between cloud and local network
A local Wakupator relay on your network
Port forwarding configured on your router (not recommended)

Preparing Your Repository

Create a GitHub repository containing your Dockerfile for Wakupator deployment.

Repository Structure

wakupator-deploy/
├── Dockerfile
├── config.json
└── .dockerignore

Creating the Dockerfile

FROM node:18-alpine

# Install dependencies
RUN apk add --no-cache python3 make g++

# Set working directory
WORKDIR /app

# Clone Wakupator
RUN apk add --no-cache git \
    && git clone https://github.com/exemple/wakupator.git . \
    && npm install \
    && apk del git

# Copy custom configuration
COPY config.json /app/config/config.json

# Set environment variables
ENV PORT=${PORT:-3000}
ENV NODE_ENV=production

# Expose the web interface port
EXPOSE 3000

# Volume for persistent data
VOLUME ["/app/config"]

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=10s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/ || exit 1

# Start the application
CMD ["npm", "start"]

Creating the Configuration File

Create a config.json file:

{
  "port": 3000,
  "auth": {
    "enabled": true,
    "username": "admin",
    "password": "${AUTH_PASSWORD}"
  },
  "devices": [
    {
      "name": "Office PC",
      "mac": "AA:BB:CC:DD:EE:FF",
      "ip": "192.168.1.100",
      "broadcast": "192.168.1.255"
    },
    {
      "name": "Home Server",
      "mac": "11:22:33:44:55:66",
      "ip": "192.168.1.50",
      "broadcast": "192.168.1.255"
    }
  ]
}

Environment Variables Reference

Variable	Required	Default	Description
`PORT`	No	`3000`	Web server port
`AUTH_PASSWORD`	Yes	-	Admin password for authentication

Deploying Wakupator on Klutch.sh

Configure Network Access

Ensure Wakupator can reach your local network devices. Options include:

Setting up a VPN (WireGuard, OpenVPN)
Deploying a local relay agent
Using Tailscale or similar mesh VPN

Push Your Repository to GitHub

Initialize your repository and push to GitHub with your Dockerfile and configuration.

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project. Give it a descriptive name like “wakupator” or “wol-manager”.

Create a New App

Within your project, create a new app. Connect your GitHub account if you haven’t already, then select the repository containing your Wakupator Dockerfile.

Configure HTTP Traffic

In the deployment settings:

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

Set Environment Variables

Add the following environment variables:

Variable	Value
`AUTH_PASSWORD`	Your secure admin password

Attach Persistent Volumes

Add the following volume:

Mount Path	Recommended Size	Purpose
`/app/config`	100 MB	Device configuration

Deploy Your Application

Click Deploy to start the build process. Klutch.sh will build the container, attach volumes, and provision an HTTPS certificate.

Access Wakupator

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

Managing Devices

Adding a Device

Log in to the Wakupator interface
Click Add Device
Enter device details:
- Name (friendly identifier)
- MAC Address (format: AA:BB:CC:DD:EE:FF)
- IP Address (for status checking)
- Broadcast Address (usually x.x.x.255)
Save the device

Waking a Device

Find the device in your list
Click the Wake button
Wakupator sends the magic packet
Check device status after a minute

Checking Device Status

Green indicator: Device is online (responds to ping)
Red indicator: Device is offline or unreachable
Status updates periodically or on refresh

API Usage

Wake a Device via API

curl -X POST https://your-wakupator.klutch.sh/api/wake \
  -H "Authorization: Basic $(echo -n 'admin:password' | base64)" \
  -H "Content-Type: application/json" \
  -d '{"mac": "AA:BB:CC:DD:EE:FF"}'

List Devices

curl https://your-wakupator.klutch.sh/api/devices \
  -H "Authorization: Basic $(echo -n 'admin:password' | base64)"

Check Device Status

curl https://your-wakupator.klutch.sh/api/status/AA:BB:CC:DD:EE:FF \
  -H "Authorization: Basic $(echo -n 'admin:password' | base64)"

Integration Examples

Home Assistant

Add a REST command for Wake-on-LAN:

rest_command:
  wake_office_pc:
    url: "https://your-wakupator.klutch.sh/api/wake"
    method: POST
    headers:
      Authorization: "Basic BASE64_ENCODED_CREDENTIALS"
    content_type: "application/json"
    payload: '{"mac": "AA:BB:CC:DD:EE:FF"}'

Scheduled Wake

Use cron or external schedulers to wake devices at specific times via the API.

Troubleshooting

Device Not Waking

Verify WoL is enabled in device BIOS/UEFI
Check MAC address is correct
Ensure network path exists to device
Verify broadcast address is correct
Test with local WoL tool first

Status Always Shows Offline

Verify IP address is correct
Check if device allows ICMP ping
Ensure network connectivity exists

Authentication Errors

Verify credentials are correct
Check Authorization header format
Ensure password hasn’t changed

Additional Resources

Conclusion

Deploying Wakupator on Klutch.sh gives you a simple, web-accessible Wake-on-LAN management tool. Combined with proper network connectivity (VPN), you can remotely power on devices from anywhere, enabling energy savings by keeping devices off until needed while maintaining the ability to start them remotely.