from Hacker News

Considerations for a long-running Raspberry Pi

by ilikepi on 2/17/24, 8:42 AM with 341 comments

• by haunter on 2/17/24, 4:13 PM

  I started buying Lenovo mini PCs instead, 18cm x 18cm x 3cm so it's still really small.

  And you can get them dirt cheap nowadays, has proper casing and cooling etc https://psref.lenovo.com/syspool/Sys/PDF/ThinkCentre/ThinkCe...

  I have one right next to me, i5-8500T, 32GB RAM, 2x SSDs and currently 5W at idle with powertop auto-tune https://wiki.archlinux.org/title/powertop

• by blacklion on 2/17/24, 9:51 AM

  First advice is to enable journaling mode on FS.

  First advice must be to mount FS in read only mode, mount /var in memory and forward al logs to one nide, which may be not RPi but something with proper UPS and nut running. Power loss becomes absolutely bening if your FSes RO or temporary.

  It is overkill if you have one RPi but author claims that he uses multiple RPis all around a house.

  Also, good idea to have A/B system partitions and upgrade system with full partition rewrite and changing active one. Thus way your system will have one good system partition in any case, even if new version has fatal bugs, and recovery become trivial.

  I'm using several small/single board PCs im different roles in such way for 20+ years with great success.

• by hcfman on 2/17/24, 10:58 AM

  Back in 2011 I made a commercial product that ran on the earliest plug computers from global scale technologies. I only sold 20 of 'em and every single one of them was being returned with SD card corruption problems. I had to quickly pivot to keeping the rootfs read-only. I've been a fan ever since.

  Incidentally, that early commercial product was a home security product with a very small amount of home automation. I released this into open source with a new name in 2021 and now runs on the Jetson series SBCs (https://github.com/hcfman/sbts-install). Except then including high end YOLO models as triggers.

  Because it was intended to be a standalone product it supported https with a GUI wrapper around all of the certificate operations. This still exists in my open source version, making it easy to use self signed certificates for intra-device rest calls.

  But I've kept and expanded upon the multi-partition memory overlayFS approach and the installation of this system first asks you to install the sbts-base system, which installs the multi-partition memory overlayFS so that other's can use this as their own base systems.

• by MPSimmons on 2/17/24, 11:12 AM

  I am urging everyone who wants to do this to see if they can't first do what they need with a small board like an ESP32. Their energy usage is a small fraction, they cost ones of dollars, and they're sufficient for a whole lot. If you're of the Python persuasion, many boards support both MicroPython and CircuitPython.

  It's worth looking into for the cost savings on initial purchase and ongoing power draw.

• by hn8305823 on 2/17/24, 3:25 PM

  > This feels like a hack, but based on hours of reading online discussions, most people seem to settle on a script that periodically checks whether the WiFi connection is good, and restarts the WiFi interface or the whole Pi if it’s not.

  It's not a hack, it's best practice! Just like important servers in a data center should have some kind of out of band connectivity (IPMI, remote controllable RPDU outlets, etc), Important servers in remote difficult to reach locations should have some kind of watchdog script. The script should of course be tuned to the specific use case, considering the impact of a reboot vs downtime until reboot. At the very least it could log adverse events for later investigation.

  A simple bash watchdog script was the very first thing I did when I deployed a remote RPI. Not just for wi-fi issues but for any of the dozens of things that could break and be fixed with a reboot.

• by mvip on 2/17/24, 11:29 AM

  We’ve been running thousands of Pis in production for about a decade now. We’re beginning to shift to x86. The price/performance isn’t what it once was for the Pi. I gave a talk about our experience recently at State of Open Con here (https://youtu.be/vX-qK9mxKZI).

• by rcarmo on 2/17/24, 9:39 AM

  I did exactly zero of any of those things and have had some Pis run for multiple years without any issues until being replaces by a newer model (my HomeKit/Zigbee gateway and data logger is now a Pi 4). I guess it all boils down to good SD cards and stable power supplies.

• by yjftsjthsd-h on 2/17/24, 9:21 AM

  I'm shocked the SD card bit isn't first, and more surprised that the post doesn't suggest USB boot (I have one pi that's been on ~24/7 for years now, and I attribute its lack of problems to 1. using Alpine configured to barely touch disk, and 2. not having an SD card to corrupt - I don't know why USB would be more reliable, but anecdotally it is)

• by lqet on 2/17/24, 10:47 AM

  I have 2 Pis running basically non-stop (2-3 power outages) with the same SD card since 2017 (DNS/print server and Kodi, media is on external NFS). The only thing I did was to disable all logs. Never had a single problem.

  They both have SanDisk 2 GB cards in them. I vaguely remember naively thinking along the lines of "less space => less bit density => better reliability".

• by 1vuio0pswjnm7 on 2/17/24, 7:50 PM

  "Keeping a Raspberry Pi online and working with zero intervention for weeks, months, or years is somewhat of an art form."

  I just boot NetBSD kernel with embedded filesystem, e.g., INSTALL kernel or custom kernel. SDCard can be removed immediately after boot. Optionally chroot to attached storage. This runs for weeks, months or years. Have not experienced any of the issues cited by the blog author. Only issue I find is with the power connector when using a case; the connection can be brittle, e.g., if using a replacement cable. Perhaps this has improved on more recent Pis. (But I could say the same about most computers. The cables and connectors are usually fragile. It's always cheap stuff.) If power is interrupted because of movement, then the Pi reboots automatically.

• by vegabook on 2/17/24, 9:30 AM

    a) Cable ethernet
    b) SSD (via USB3.0 adapter on my RPI4)
    c) Ubuntu Server LTS 22.04. 
    d) cheap UPS.
  

  Mine runs Yggdrasil network, HAproxy, Caddy server, a couple of webservers in containers, and a TMUX instance that I log into almost daily to write code (slow computer reveals bad code much better). Since I put it (and my router) on the UPS, in the last 2 years it has literally never gone offline other than a couple of times I rebooted it for firmware upgrades.

• by HankB99 on 2/17/24, 2:36 PM

  I use some Pis for various things in my house including Zeroes through CM4s and 4Bs.

  The Zeroes run Raspbian configured with the read-only filesystem option. I have found it necessary to uninstall `unattended-upgrades` because the overlayfs employed for read-only root caches disk writes in RAM and the update/upgrade process exhausts RAM. For the same reason I disable swap. It makes no sense to swap to RAM on a 512GB system.

  Upgrades are tedious since they require disabling overlayfs, rebooting, upgrading, rebooting, and enabling overlayfs. I wrote Ansible playbooks to perform these tasks. (https://github.com/HankB/Ansible/tree/main/Pi)

  I have a Pi 4B performing as a file server and running Debian (not Raspbian) It boots from an SD card so that the entire HDDs can be used for a ZFS pool. To reduce wear and tear on the SD card I have mounted `/var` to a ZFS filesystem. I should probably use `tmpfs` for `/tmp`.

  I use a Pi CM4 to run HomeAssistant and that boots and runs from an NVME SSD where durability is less an issue.

• by zh3 on 2/17/24, 10:35 AM

  As someone using many, many Pi's at home and many times that at work, the preferred approach is to boot them all diskless (and for those that actually need an SD card, boot them off a read-only SD card and get everything else off the home server). This is so much easier than having lots of different SD cards/Pi versions etc, and makes them trivial to replace in the event of failure.

• by borlox on 2/17/24, 10:10 AM

  Just read the data sheet of the Sandisk Max Endurance and, oh boy, what a fsck’ing marketing bs language.

  They state the endurance on thousands of hours of FHD video, but what assumptions do they make in bitrate etc?

  Can‘t they state total TB written or drive writes per day or something sensible?

• by psanford on 2/17/24, 5:02 PM

  Switching to gokrazy[0] was the best thing I did for my Raspberry Pi uptimes. I think a lot of that is because it defaults to using read-only partitions so the common issue of SD cards falling over when you run apt upgrade no longer happens.

  But I also think that gokrazy's simplicity and design helps it be just a solid, reliable foundation to build on top of.

  [0]: https://gokrazy.org/

• by ChuckMcM on 2/17/24, 8:00 PM

  The longest running RPi I have has run continuously for over 5 years. The big secret was not to use the SD card at all[1], I mount all file systems over the network to a NAS device (TruNAS from iX systems). It has a "UPS" in the form of a USB battery pack that is both charging from main power and powering the Pi. When power goes out the battery pack takes over, it has about a day of "hold up" time depending on Pi power usage. It is 'hard wired' to the local network (it doesn't use WiFi).

  I got there from having SD cards (nearly[2]) always be the failure point. Everything else has been pretty reliable when used within tolerances.

  [1] It does "boot" from the SD card but that acts kind of like a third stage bootloader which loads and boots the "real" OS (FreeBSD) from the NAS device.

  [2] I have had one fairly spectacular looking "melt down" of a no-name USB power supply wallwart PSU which, to appears to have also put something like 12V directly across the USB power pins (my best guess at what the secondary winding of the xformer in the wall wart was putting out on the 'low' side)

• by sdflhasjd on 2/17/24, 10:32 AM

  This covers the readonly filesystem, but doesn't cover the write protect flag that you can set on the microSD card itself[1]. The flag will configure the card's controller to drop any writes, and is thought to resist the corruption issues that can still occur even when the filesystem is readonly.

  Also, creating a readonly root out of an existing disto is a bit of a pain, my preference is to use a distro (like TinyCore) that's already a readonly root.

  https://github.com/BertoldVdb/sdtool

• by agilob on 2/17/24, 9:16 AM

  Half of the post is about SD cards, wear, data loss and reliability. Just use SSD?

• by FerretFred on 2/17/24, 9:34 AM

  I've been running a bunch of Pi's for years now, and the biggest problem I've had is the Pi itself dying: 24/7 usage is hard on a small device. I've also found that stable power is essential, and to that end I've always used 5v 3a branded power cubes, plugged into a pure sine wave UPS. Choice of micro-SDHC cards is important and I ended up getting ATP industrial cards (https://www.atpinc.com/products/industrial-sd-cards) - expensive but really long-lived. Finally, using RPi-clone (https://github.com/billw2/rpi-clone) on a regular basis has been a life-saver. I clone to Sandisk Extreme micro-SDHCs and can recover from an outage in minutes.

• by userbinator on 2/17/24, 10:31 AM

  It's worth noting that SD card firmware is usually optimised for the FAT32 filesystem, which has a very predictable access (specifically write) pattern, and using filesystems that have a more "free-form" layout can lead to lower performance and higher write amplification:

  https://lwn.net/Articles/428584/

• by cjdell on 2/17/24, 12:10 PM

  I have an original Pi 2012 running buildroot. It's a perfect fit. Need just enough to run a Linux kernel and ser2net for doing RS485 stuff with solar inverters. I think the image size was around 100MB and no volatile filesystem whatsoever.

  Buildroot was surprisingly easy to use. Use a menuconfig to pick what you need and a burnable image for your SD card comes out the other side. Think I only spent an hour on the whole project.

• by archerx on 2/17/24, 12:20 PM

  I have a cluster of 7 SBCs, 1 pi 3b and 6 Tinkerboards of various models. The Pi I got in 2016/17 and ran Gitlab without issue until 2022, something in the SD card got corrupt and linux was no longer able to boot, I was able to salvage all of the data and continued with a new SD card. The tinkerboards, which have various tasks as VPN, Nextcloud, staging servers using docker have never corrupted an SD card.

  I think the tinkerboards are better than Pi’s especially the ones that come with 16gb of onboard flash storage. However you don’t get all the niceness of PiOS but have to use TinkerOS (which was less than barebones when it came out) or Armbian which is nice but not built specifically for the tinkerboard.

  I have a few friends who complained about Pi’s corrupting SD cards and it also happened to my only long running Pi so there is something going on.

• by hcfman on 2/17/24, 9:41 AM

  My sound localizing Raspberry Pi installs a resilient base system as part of its install.

  https://github.com/hcfman/sbts-aru

  https://hackaday.com/2023/12/30/localizing-fireworks-launche...

  With one command it for all Pi’s for both Raspbian and bookworm it:

  * Shrinks the file system (Gee, how does it do that with just one disk ? ;-) )

  * Creates new partitions

  * Installs a memory overlayFS

  * Installs and configures the system as an audio recorder with micro second time accuracy

  * updates /etc/rc to do a forced repair of the data and config portions, in case they were damaged. This avoids system hangs waiting for human interaction with fsck

  For the partitioning scheme it creates a swap partition, not as a wow but as an enabler if you really need it to install some large software.

  It creates a small config partition. The idea here is that you keep it read only and remount it read write if you need to change config then remount it read only again.

  And finally a data partition, which in this projects case is where the audio files are written.

  I maintain a version of an overlayFS boot for the Pi but it needs revisiting for bookworm. The easiest way to use do this is to install the sbts-aru and then just don’t use it. Then everything is done for you in one command. And that version works for all Pi’s.

  I also do this for the Jetson SBCs. But I need to revisit this for the Orin series. I have it working here for myself and friends but need to update the installer. Note, due to kernel behavior changes with Orin the older Pi like overlayFS code will not work. But I solved this and will release it when I release the Orin release of sbts-install soon.

  I’ve been using memory overlayFS like installs for years for long running Pi systems.

• by Namidairo on 2/17/24, 10:07 AM

  I'd consider enabling the hardware watchdog as well.

  While one could argue that you should figure out the source of your device freezing in the first place;

  Nothing is better than having to ask someone to power cycle your Raspberry Pi while you're away.

• by askvictor on 2/17/24, 11:30 AM

  I've been running a Pi 4 as a home server for a few years. When boot-from-USB became available, I moved to that, with a good-quality USB thumb drive for boot/root (I've had had SD card issues in the past) (and also speed, though I doubt it makes much practical difference). A couple of weeks ago I started getting intermittent disk errors. I thought it was the USB drive, so I cloned it (still worked well enough on my laptop) to another drive. Same thing happened. So everything points to the USB controller glitching out. Have gone back to an SD card, and everything seems fine.

• by WaitWaitWha on 2/17/24, 7:46 PM

  It is the the time for mini PCs as many have noted it. I am getting one for one of my offices, instead of building or buying a desktop.

  I used to build my machines and loved it. Some are still chugging along after over 10 years. They were worthwhile before the mini PCs reaching comparable capabilities at lower cost.

  One thing I still cannot seem to find is a good site that compares various vendors in similar fashion as "PC builder" sites do of build components.

  Any suggestions?

• by spintin on 2/17/24, 12:28 PM

  I have been running a Raspberry 2 cluster for 10 years.

  A few weeks back the first SD card to fail got so corrupted it failed to reboot!

  My key learning is use oversized cards, because then the bitcycling will wear slower!

  I'm going from 32GB to 256/512/1024!

  That said "High Endurance" cards are a scam, they fail way quicker than regular cards!

  All SD cards except SanDisk have latency problems. There is no competition.

  If you can get SLC SD cards use them for workload instances = no db or file storage.

• by goodburb on 2/17/24, 9:25 AM

  I'm still using a Sandisk 8GB microSD from 2008 running 24/7: smartphone expansion 6 years -> Orange Pi as a router for 3 years, Pi 4 running Frigate for 3 years.

  I'm guessing it's SLC/MLC.

  Had a Transcend 32GB in 2016 die after a year.

  The biggest issues with set-and-forget setups is software upgrade for security or other reasons, jumping major versions ends up breaking things. Compared to cloud which is (usually) regularly updated.

• by teleforce on 2/17/24, 9:50 AM

  For the life of me I don't really get it why Raspberry Pi Foundation does not include onboard eMMC or SSD storage in their non-compute modules products.

  Yes with the new PCIe expansion in the latest RPi 5 you can have external SSD for example, but if you decided to use it for other purposes as well like extra Ethernet port expansion then you cannot use it for booting anymore.

• by thehias on 2/17/24, 2:02 PM

  And here is me, who is running a Pi1 in my cellar for 10 years straight, which logs all my temperature sensors over 433Mhz + triggers my door openers via physical relay over WIFI, without doing anything special. After some years I only connected it to a UPS, after the sdcard filesystem died after some power outages....

• by cattlepi on 2/17/24, 6:33 PM

  Going to plug my own side project from the past here: https://cattlepi.com/ https://github.com/cattlepi/cattlepi/blob/main/README.md

  Been running pis (mostly 3b+) for eons with this solution and at this point i can say it's bulletproof.

  The key is to minimize the sdcard wear and tear (it uses an overlay filesystem with squashfs as base and tmpfs as write top layer) and to keep zero stare on the device. You can build the image starting from normal raspbian. You can also update it over the network.

  As far as usage in the wild the largest "deployment" (i know about) is at around 1000 pis.

• by planb on 2/17/24, 10:52 AM

  Buy a decent SD card and overprovision the space and wear leveling will take care of the rest. I have a Pi with a 128GB SD card and a 32GB filesystem on it running for 6 years straight without problems now. No need to disable logs, just disable debug logging so you won‘t generate gigabytes a day.

• by demomode on 2/17/24, 9:18 AM

  Also: consider using overlayfs to make root fs read-only

• by tzs on 2/17/24, 3:13 PM

  A few people have mentioned achieving long uptime. What is often overlooked is that it is possible for uptime to be too long.

  It is quite possible for updates to not break a running system but make it so that it will break on the next reboot. E.g., a dynamic library gets updated in a way that breaks a server process. It doesn't affect the running server because it still has the old library loaded.

  Next time you boot your server process doesn't start.

  These kind of problems can be annoying to deal with, especially when your system has an uptime of years and for all you know whatever change broke it could have been in any one of dozens of updates you've applied over that time.

• by lxgr on 2/17/24, 2:48 PM

  > This is unlikely to do anything unless you’re hitting some unusual bug, but it’s worth noting that IPv6 has, in the past, led to all sorts of strange behaviors in different networking contexts.

  This makes me sad. I don't doubt that there are scenarios in which having IPv6 connectivity makes things worse, but these days, the opposite is more common, so I don't think "disable IPv6 just in case" is a good blanket recommendation to make anymore.

  "If disabling IPv6 fixes your issue consistently, consider disabling it" would achieve the same outcome, without potentially causing problems/inefficiencies down the road.

• by masto on 2/17/24, 3:27 PM

  Step 1 is to question why you're using a Raspberry Pi. It's almost never the correct answer.

  If there's a really really good reason, step 2 is to get rid of the SD card. Personally, none of mine even have an SD card inserted (ok, one does). I use network boot/NFS for everything. Some people attach other kinds of SSDs.

  The one I lied about is a reverse telnet server that has been quietly doing its thing for 4 years without a hitch, apart from the time I had to replace the (PiJuice) backup battery because it was looking a little swole. But I should take the time to at least have a backup of the card ready to swap out when it fails.

• by hcfman on 2/17/24, 10:50 AM

  Another nice thing you can do if you use the multi-partitioned memory overlayFS approach I mentioned earlier is you can make /var/docker be a symlink to your read-write data partition. Obviously you are going to have problems using docker with the standard memory overlayFS approach.

  Also nice, is you can make your data or other partitions be encrypted. I've done this before. On the Pi 5 you can use the standard encryption as there's hardware support. On earlier Pi's you can use the encryption used for android. This does means there's a manual step in the startup for you to enter your encryption password.

• by blackfawn on 2/17/24, 1:32 PM

  Their suggestion for log2ram does help for the most part but depending on what the pi is running, even that doesn't completely solve it. I've burnt out a number of microSD cards running a Pi-hole instance. I finally gave up and moved it to a tiny x86 with a SSD.

  Yet I've been feeding ADSB-Exchange and FlightAware from a Pi Zero for years and never had SD card problems.

  I really like Alpine Linux for the Pi, running in it's own read-only mode where changes must be committed to disk. But unfortunately, Pi-hole isn't compatible with Alpine (at least last time I checked)

• by vagab0nd on 2/17/24, 2:34 PM

  I use a USB connected SSD as boot. Been running Home Assistant and Pihole for years with zero issues.

  EDIT: Also, make sure the power supply is sufficient. I was using a cheap adapter and had random errors and reboots.

• by jnaina on 2/18/24, 3:11 AM

  I have a Raspberry PI 1 model B running almost non-stop for over 8 years (except during power outages) serving as my front gate controller. Custom python code uses the GPIO pins to trigger an RF remote to open or close the gate, and does not write to SD for logs/etc (to prevent SD wear)

  I use a USB network card, and a high-quality SD card. Other than that, no other special configs (except for another spare SD card with a full system image clone).

  Rock solid performance and uptime over 8 years.

• by guenthert on 2/17/24, 9:34 AM

  Also no mentioning of the power connector? I have too little experience with USB-C, but the micro USB connector used on early Raspberry Pi's is just asking for trouble. That might be (barely) good enough for charging, but a computing device w/o battery-backup won't take lightly the power interruptions when jiggling the cable a little. I finally got around to replace it with an old-fashioned (time tested!) barrel connector. Easy way to improve the robustness significantly.

• by TacticalCoder on 2/17/24, 1:02 PM

  Anything long running shouldn't happen over that piece of crap that WiFi is. Data centers aren't build over WiFi. My network at home neither.

  I've been running RPi for years (including a VoIP server on a RPi 1!). The two tricks if you want a really long running Pi are: SD cards mounted read-only and ethernet.

  FWIW I ve got a Pi running the unbound DNS resolver and it just works. It is not an art. There s a reason businesses are scooping up millions of Pi: they just work.

  P.S: I ve got an army of NUCs too.

• by jimmyswimmy on 2/18/24, 12:15 AM

  Around early 2019 I set up a raspberry pi 3 running Raspbian. I made the /var/log partition a ramdisk. Haven't touched it since. It goes down for power outages but probably has been out for a couple minutes total over five years (aside from power outages). Most of its job is to translate analog audio to a USB speaker system. Whole house audio for about $150. Anyway, I never touch it, it just works, all the time.

• by anonym29 on 2/17/24, 4:02 PM

  Do people really have such a neurotic aversion to the sight of cables that they'd rather struggle with workarounds to an always-inferior wifi than just using an ethernet cable? It seems unhealthy to get that stressed out over the sight of a 3cm wide cable.

  I've had an RPi4 running continually for close to a year and never had a single network connectivity issue between the RPi4 and my router, connected via a 30m cat5 cable in my 75m² condo.

• by akira2501 on 2/17/24, 9:31 AM

  I got one of those super low profile USB thumb drives and then set the Pi to boot from that. It ran automation here in my house for 2.5 years without a blip.

• by tempaccount1234 on 2/17/24, 9:55 AM

  I have a few long time running Pis - and have been keeping them up for a decade now. No SD Card corruption ever and i got close to 1000 days uptime on one.

  The biggest problem is loss of wifi, after a few months one will lose wifi, but keep working - it’s constantly recording data so a reboot is not a good idea. I’d prefer a solution where I could just reset the wifi, but all attempts to script that reliably so far failed.

• by nodesocket on 2/17/24, 5:32 PM

  I can appreciate the effort and time put into this, but seems completely overkill. I’ve been running 4x Pi 4B’s in a Kubernetes cluster for over 3 years 24/7/365. Only thing I did is disable swap (which you should do for Kubernetes anyway) and used SanDisk Extreme 128GB cards[1].

  [1] https://a.co/d/ipehodH

• by rldjbpin on 2/19/24, 9:40 AM

  having used an original model b (rev 2) since 2013 with running 24/7 for about 80% of the time, i feel that a lot of this depends on how much you want to push your pi.

  for context, my workload was bursty in nature and nowadays it is mostly idle. but i never had any issues with the SD card, and i only upgraded to a new one for getting more capacity all this time (only twice).

  keeping the dust out and managing the temperatures would go most of the way. i have served files directly from the sd card but it is always better to mount an external drive for this, while providing enough power to the board to power usb devices. limiting debug logs for stable applications can also help avoid write cycles, but using sd card on a pi has been a similar workload to using one in older smartphones for storing media.

• by geon on 2/17/24, 8:12 PM

  When I worked with that, we had the SD card entirely read-only, and a usb stick mounted for writing. I think the rpi wouold detect a broken file system on boot and reformat the usb stick. It also made it easy to pull the usb stick and format it in any windows pc to reset it.

• by yokoprime on 2/17/24, 10:19 AM

  I’ve got 2 rPI’s thats been running for 4+ years each. Only thing I do is update them once in a while. Both have workloads running 24/7. no issues. I have however experienced issues in the past but those were due to a faulty power adapter not keeping voltage within spec.

• by Alifatisk on 2/17/24, 9:50 AM

  Haven’t followed any of these tips, yet I have barely stumbled upon any issued with my long running pi

• by not_the_fda on 2/17/24, 1:35 PM

  All the SD problems go away if you get a RPi Compute Module instead. Well worth the additional cost.

• by niederman on 2/17/24, 9:28 AM

  Admittedly, I only have one long-running Raspberry Pi, but it's currently sitting at a few months uptime. And that was an intentional reboot. I've never had to take any measures like these in the four or so years I've had it up.

• by csydas on 2/17/24, 10:38 AM

  i very much so enjoyed these articles even if i don’t use raspberry pi anymore. it has a very much so research notes cleaned up for sharing feel and reminds me of some of my teams internal articles, particularly on research the author wasn’t sure on but wanted to put out there regardless. it was very easy to get their decisions and the limit of their research and knowledge so i had pretty clear idea what i need to still check on my own and what i might adopt if i were to use rpi devices.

  i don’t really get what to use a rpi for but i guess not important, it was just a nice series of articles

• by weinzierl on 2/17/24, 2:03 PM

  As far a I know (and my knowledge inly goes to version 4) the RasPi does not support different power states or sleep modes. It would be interesting how it compares in power consumption to other solutions.

• by tunnuz on 2/17/24, 11:13 AM

  I wonder if Raspberry OS comes configured not to swap on the SD by default …

• by RobotToaster on 2/17/24, 1:16 PM

  Anything long running should have ECC RAM, which the Pi doesn't have.

• by LeoPanthera on 2/17/24, 10:33 AM

  All my home Pis network boot, so there is no card to fail. You can also change what OS they boot into by just renaming a symlink on the server and rebooting them. Very convenient.

• by Temetra on 2/17/24, 10:07 AM

  I've been plagued with the wifi problem since changing routers. Devices on the local network will randomly lose the ability to connect to it, but everything else is fine.

• by tgsovlerkhgsel on 2/17/24, 3:11 PM

  I don't think I took many special precautions and a Pi I had running as a VPN server survived for about 10 years, aside from a power supply failure or two.

• by jokoon on 2/17/24, 3:50 PM

  I don't understand what's hard about adding like 256MB of flash soldered to that thing, I'd pay $5 more if it did.

  Everytime there's a RPI I cry about it.

• by guenthert on 2/17/24, 9:29 AM

  No mentioning of flashybrid? I'd thought that's the obvious solution to SD wear (or rather the danger of SD corruption on sudden power loss).

• by cjfd on 2/17/24, 3:35 PM

  My experience with long-running raspberry pi's is that there are USB problems. One sometimes loses the connection to these devices.

• by Zopieux on 2/17/24, 6:50 PM

  Not a single mention of netbooting the Pi instead of relying on crappy SD cards which wear faster than I can type this.

• by vikmals on 2/17/24, 7:43 PM

  > Your SD card can wear out or completely fill up

  Why is the author not considering using an SSD instead of an SD-Card here?

• by pythonsnake on 2/17/24, 9:43 PM

  Not sure about the SD cards he recommends. Use Swissbit SD cards. But they will cost you.

  Mouser is your friend.

• by exfil on 2/17/24, 12:57 PM

  I run my RPi's 24/7 from initramfs. I can even remove card after boot.

• by husam212 on 2/17/24, 8:39 PM

  I use OpenWrt whenever it's possible, to avoid SD card wear completely.

• by asmor on 2/18/24, 10:35 AM

  Alpine in diskless mode and an ethernet cable solve 2/3 of that.

• by Animats on 2/17/24, 11:24 PM

  Does that have a hardware stall timer?

• by greenie_beans on 2/17/24, 3:57 PM

  eventually you'll think about power outages. i had a pihat battery nearly explode on me. beware!

• by demondemidi on 2/17/24, 10:43 PM

  > Keeping a Raspberry Pi online and working with zero intervention for weeks, months, or years is somewhat of an art form.

  What are you talking about?

  It is literally zero effort. Just set up crontab reboots in case of power outage. That's it.

  I've had a pi running as a BLE gateway / security cam for over 4 years with zero intervention.