Uncategorized

Saving Energy in Self-Hosting, Wake-on-LAN, and Rust

Saving Energy in Self-Hosting: A Personal Journey with Wake-on-LAN and Rust

A story of how I reduced my energy consumption while self-hosting services

I still remember the day I started exploring the world of self-hosting. It was like a whole new world opened up, and I found myself constantly thinking about which new services I could host. I had a pretty simple machine, an Intel i3 (4th gen) with an RTX 1650 4GB GPU, which wasn’t too power-hungry. However, as I delved deeper into self-hosting, I realized that my GPU was underused, and I decided to install Ollama, a tool that allows running AI models locally.

After testing Ollama, I quickly realized that 4GB wasn’t enough to run the latest models. This led me to upgrade my machine, and after a lot of research, I managed to get a good deal on an RX 7900 XTX. With 24GB of memory, I could finally run the latest models, but I was surprised by its power consumption, which was around 45 watts in idle mode. This raised a red flag: keeping this machine on 24/7 would be far from energy-efficient.

The Initial Idea

What if I had a way to power on the machine only when I needed it? I’d need another device to manage it, and a Raspberry Pi would be perfect, as I could leave it running 24/7 with minimal power draw, and it could turn the power-hungry machine on and off. This idea led me to explore ways to remotely turn my machine on, and that’s when I discovered Wake-on-LAN, or simply WoL.

After configuring my motherboard and operating system, I was able to power on my machine remotely with a simple command: wakeonlan <MAC_ADDRESS>. Because of how WoL works, it sends a “magic packet” over the local network, meaning I need to be on the same LAN to wake the machine. This was fine, one less problem to worry about. Now I could turn the machine on remotely, which led to the next question: when do I need to power it on? The answer was simple: whenever I needed to access services running on it, like Ollama or any other self-hosted service.

Intercepting Traffic

Most services use a specific port, such as 11434 for Ollama, where it opens a TCP connection. I thought of using a reverse proxy to intercept the traffic and, when necessary, wake the server. Once the server was online, the proxy could redirect the traffic to it. This seemed like the perfect solution, and I created a sequence diagram to illustrate the process:


participant User as User
participant Proxy as Reverse Proxy (Wakezilla)
participant Server as Server (Ollama – port 11434)
User–>>Proxy: TCP Request (port 11434)
Proxy–>>Server: Check if online
alt Server OFF
Proxy–>>Server: Send Wake-on-LAN (power on server)
Server–>>Proxy: Server initialized
end
Proxy–>>Server: Redirect traffic
Server–>>Proxy: Response
Proxy–>>User: Return data

When to Shut Down the Server?

Now that I could remotely power on the server, I also needed to decide when to shut it down. I didn’t want it running 24/7, so I thought, since I’m already intercepting traffic, why not monitor it? When no more requests come in, the server can be shut down. By adding a requests-per-minute threshold, if no requests are made, the server can be turned off.

How to Do This?

After some research, I didn’t find many tools that did exactly what I wanted, so I decided to build my own solution. Since the target machine would need some software anyway to receive the shutdown command, I kept it simple: a CLI that starts a small web server. When it receives an unauthenticated HTTP request (for now), it shuts down the machine. I also added a health check so the reverse proxy can verify whether the machine is online.

Wakezilla

With that in mind, I built Wakezilla, a simple tool that does exactly this: it intercepts traffic, wakes the server with WoL when needed, and powers it down when there’s no more traffic. All of this in a straightforward way, written in Rust, packaged as a single binary with no external dependencies, making it easy to use anywhere. The project is available on GitHub, and contributions are welcome, whether to add new features or improve documentation.

If you’d like to try it out, just follow the instructions in the project’s README. If you have any questions, feel free to open an issue, and I’ll be happy to help. Here’s the project link: Wakezilla

Oszczędzanie Energii w Samo-Hostingu: Moja Własna Historia z Wake-on-LAN i Rust

Historia o tym, jak zmniejszyłem zużycie energii podczas samo-hostingu usług

Nadal pamiętam dzień, kiedy zacząłem eksplorować świat samo-hostingu. Było to jak nowy świat, który się otworzył, i znalazłem się w ciągłym myśleniu o tym, które nowe usługi mogę hostować. Miałem dość prostą maszynę, Intel i3 (4. generacji) z kartą graficzną RTX 1650 4GB, która nie była zbyt żarłoczna. Jednak, gdy zagłębiłem się głębiej w samo-hosting, zdałem sobie sprawę, że moja karta graficzna była niedostatecznie wykorzystywana, i postanowiłem zainstalować Ollamę, narzędzie, które pozwala uruchamiać modele AI lokalnie.

Po przetestowaniu Ollamy, szybko zorientowałem się, że 4GB nie było wystarczające, aby uruchomić najnowsze modele. To skłoniło mnie do uaktualnienia mojej maszyny, i po długich poszukiwaniach, udało mi się kupić dobrą ofertę na kartę graficzną RX 7900 XTX. Z 24GB pamięci, mogłem wreszcie uruchomić najnowsze modele, ale byłem zaskoczony jej zużyciem energii, które wynosiło około 45 watów w trybie czuwania. To podniosło czerwoną flagę: pozostawienie tej maszyny włączonej przez 24/7 byłoby daleko od efektywności energetycznej.

Początkowa Myśl

Co, jeśli miałbym sposób, aby włączyć maszynę tylko wtedy, gdy jej potrzebuję? Potrzebowałbym innego urządzenia, aby ją zarządzać, i Raspberry Pi byłby idealny, ponieważ mogłem go zostawić włączonego przez 24/7 z minimalnym zużyciem energii, i mógłby włączać i wyłączać głodną energią maszynę. Ta myśl skłoniła mnie do zbadania sposobów, aby zdalnie włączyć moją maszynę, i to wtedy odkryłem Wake-on-LAN, czyli WoL.

Po skonfigurowaniu mojego płyty głównej i systemu operacyjnego, mogłem zdalnie włączyć moją maszynę za pomocą prostej komendy: wakeonlan <MAC_ADDRESS>. Ponieważ WoL wysyła “magiczny pakiet” przez sieć lokalną, muszę być na tej samej sieci LAN, aby obudzić maszynę. To było w porządku, jeden mniej problem do rozwiązania. Teraz mogłem zdalnie włączyć maszynę, co skłoniło mnie do następnego pytania: kiedy powinienem ją włączyć? Odpowiedź była prosta: zawsze, gdy potrzebuję dostępu do usług uruchomionych na niej, takich jak Ollama lub inne usługi samo-hostowane.

Przechwytywanie Ruchu

Większość usług używa specyficznego portu, takiego jak 11434 dla Ollamy, gdzie otwiera połączenie TCP. Pomyślałem o użyciu serwera proxy odwrotnego, aby przechwycić ruch i, gdy jest to konieczne, obudzić serwer. Gdy serwer jest już włączony, serwer proxy może przekierować ruch do niego. To wydawało się idealnym rozwiązaniem, i stworzyłem diagram sekwencji, aby zilustrować ten proces:


participant Użytykownik as Użytykownik
participant SerwerProxy as Serwer Proxy (Wakezilla)
participant Serwer as Serwer (Ollama – port 11434)
Użytykownik–>>SerwerProxy: Żądanie TCP (port 11434)
SerwerProxy–>>Serwer: Sprawdź, czy jest włączony
alt Serwer wyłączony
SerwerProxy–>>Serwer: Wyślij Wake-on-LAN (włącz serwer)
Serwer–>>SerwerProxy: Serwer zainicjowany
end
SerwerProxy–>>Serwer: Przekieruj ruch
Serwer–>>SerwerProxy: Odpowiedź
SerwerProxy–>>Użytykownik: Zwróć dane

Kiedy Wyłączyć Serwer?

Teraz, gdy mogłem zdalnie włączyć serwer, również musiałem zdecydować, kiedy go wyłączyć. Nie chciałem, aby był włączony przez 24/7, więc pomyślałem, że skoro już przechwytuję ruch, to czemu nie monitorować go? Gdy nie ma już żądań, serwer może być wyłączony. Dodając próg żądań na minutę, jeśli nie ma żądań, serwer może być wyłączony.

Jak to Zrobić?

Po przeprowadzeniu badań, nie znalazłem wielu narzędzi, które robiłyby dokładnie to, czego potrzebowałem, więc postanowiłem stworzyć własne rozwiązanie. Ponieważ docelowa maszyna będzie potrzebować oprogramowania, aby otrzymać polecenie wyłączenia, trzymałem to prosto: CLI, który uruchamia mały serwer internetowy. Gdy otrzyma nieuwierzytelnione żądanie HTTP (na razie), wyłącza maszynę. Dodatkowo dodałem sprawdzenie stanu, aby serwer proxy mógł zweryfikować, czy maszyna jest włączona.

Wakezilla

Z tym na myśli, stworzyłem Wakezilla, proste narzędzie, które robi dokładnie to: przechwytuje ruch, budzi serwer za pomocą WoL, gdy jest to konieczne, i wyłącza go, gdy nie ma już ruchu. Wszystko to w prosty sposób, napisane w Rust, zapakowane jako pojedynczy plik wykonywalny bez zewnętrznych zależności, co sprawia, że jest łatwe w użyciu wszędzie. Projekt jest dostępny na GitHub, i zachęcam do współpracy, czy to przez dodawanie nowych funkcji, czy poprawianie dokumentacji.

Jeśli chcesz wypróbować, wystarczy postępować zgodnie z instrukcjami w pliku README. Jeśli masz jakieś pytania, nie wahaj się otworzyć issue, i będę szczęśliwy, aby pomóc. Oto link do projektu: Wakezilla

Leave a Reply

Your email address will not be published. Required fields are marked *

WordPress Appliance - Powered by TurnKey Linux