Today started with a fairly simple question about remote access and ended with something much more tangible: I proved that I can sit at one Linux laptop, securely reach my main Debian workstation through a private Tailscale network, operate hardware physically connected to that remote computer, and bring the resulting file back to the laptop.
More importantly, I did not merely configure a collection of tools and assume they worked. I tested the entire chain.
By the end of the session, I had remotely triggered my Logitech C930e webcam attached to my Debian desktop, captured a 1920×1080 photograph, transferred that photograph across my private network to my second HP laptop, and opened it there.
There I was.
That small photograph represented something considerably larger: a working foundation for accessing my home Linux lab while I am thousands of miles away in Spain.
The Larger Goal
I have been thinking about what it would mean to leave my main Debian workstation running at home in Hawaii while traveling in Spain.
I don’t simply want remote access for its own sake. My Debian desktop has become the center of a growing homelab. It contains my development projects, security tools, programming environments, storage, virtual machines, and experiments.
Rather than trying to duplicate that entire environment on a travel laptop, I realized that the better model is:
MY PRIVATE TAILSCALE NETWORK
Spain Hawaii
HP Laptop #2
Debian 13
│
│
│ Encrypted Tailscale connection
│
▼
Main Debian Desktop
│
├── Projects
├── Rust
├── Python / Jupyter
├── Julia
├── Wazuh
├── VMs
├── Storage
└── USB hardware
│
└── Logitech C930e
The laptop does not have to become my desktop.
It can become my doorway into it.
1. My Private Tailscale Network
Before the webcam experiment, I had already connected my machines through Tailscale.
My main Debian desktop has the Tailscale address:
100.66.230.106My second HP laptop, which is running Debian 13, also joined the same tailnet.
This meant the two computers could communicate through their private Tailscale addresses even though they could eventually be on completely different physical networks.
That distinction became important to me.
Normally, my computers sitting at home communicate over my home LAN. That does not help much when one computer is in Hawaii and I am sitting in Spain.
Tailscale gives me another network layered on top of the Internet.
Conceptually:
Physical network:
HP Laptop → Hotel Wi-Fi → Internet → Hawaii ISP → Home Network
Private overlay:
HP Laptop ───────── Tailscale ───────── Debian DesktopI don’t need to expose SSH directly to the public Internet, and I don’t need to configure a public SSH port on my home router merely to accomplish what I tested today.
2. Establishing SSH Between the Computers
Tailscale gave the computers a private route to one another.
SSH gave me a way to actually operate them.
I installed and enabled the OpenSSH server on the machines and verified that the service was running.
From HP Laptop #2, I could connect to the main Debian desktop with:
ssh lvydvy@100.66.230.106The significance of the prompt change became very clear during today’s experiments.
Before connecting, I was looking at:
ny2honolulu@ommarchy:~$That meant commands were executing on HP Laptop #2.
After SSH:
(base) lvydvy@Debian:~$I was still physically sitting at the HP laptop, but my terminal was now operating the main Debian desktop.
That is an important mental distinction.
Keyboard in front of me
│
▼
HP Laptop #2
│
SSH
│
▼
Debian Desktop
│
▼
Command executes HERERunning hostname during an earlier test provided a simple sanity check for which computer I was actually controlling.
3. What This Could Mean While I’m in Spain
Once SSH was working through Tailscale, I began thinking about what I could actually do with it while traveling.
Potentially, quite a lot.
I could enter my projects directory:
cd ~/ProjectsI could compile Rust programs:
cargo checkI could inspect disk usage:
df -hI could examine memory:
free -hI could check services:
systemctl status wazuh-managerI could inspect logs:
journalctlIn other words, I wouldn’t merely be retrieving files.
I would be operating the Debian workstation.
And because the computation occurs on the desktop, the travel laptop doesn’t necessarily need the same processing power, storage, development environments, or collection of virtual machines.
That changes how I think about this second HP laptop.
It can be a lightweight travel terminal into the larger laboratory sitting at home.
4. The Question That Immediately Followed: What Could Break This?
Remote access is useful only if the remote computer remains reachable.
So I began looking at failure modes.
There are several.
The desktop could lose Internet connectivity.
Tailscale could fail to start.
SSH could fail to start.
The computer could shut down.
A Hawaii power outage could turn the computer off while I am thousands of miles away.
But one failure mode immediately stood out:
What if Debian simply goes to sleep?
A perfectly functioning desktop that has suspended itself is not much use as a remote machine.
So I checked it.
On my main Debian desktop I ran:
systemctl status sleep.target suspend.target hibernate.target hybrid-sleep.target --no-pagerThe result was better than I expected.
All four were masked:
sleep.target masked
suspend.target masked
hibernate.target masked
hybrid-sleep.target maskedThat was an important discovery.
masked means these systemd units have deliberately been prevented from being started normally.
My desktop is therefore already configured at this level not to automatically disappear into sleep, suspend, hibernation, or hybrid sleep.
That is exactly what I want from a machine intended to remain remotely accessible.
The monitor can turn itself off.
The computer itself needs to remain awake.
5. The Remaining Power Problem
Preventing suspend does not solve everything.
There is an important difference between:
Computer awakeand:
Computer has electricity.If Hawaii experiences a power outage while I’m in Spain, the machine can still turn off.
So one of my future pre-travel tasks will be investigating the ASUS BIOS/UEFI power-recovery setting.
I want the sequence following a power failure eventually to look something like:
Power fails
│
▼
Desktop shuts down
│
▼
Power returns
│
▼
ASUS automatically powers on
│
▼
Debian boots
│
├── Network starts
├── Tailscale starts
└── SSH starts
│
▼
Remote access restoredThat is a project I still need to complete before depending on this setup overseas.
6. Then I Asked About the Webcam
At that point another thought occurred to me.
My Logitech webcam is physically attached to the Debian desktop.
Could I access that remotely too?
That question turned today’s networking exercise into a hardware experiment.
I first checked Debian’s video devices:
ls -l /dev/video*Debian reported:
/dev/video0
/dev/video1So Linux was definitely seeing a video device.
I installed the Video4Linux utilities:
sudo apt install v4l-utilsThen I asked Linux to identify the device:
v4l2-ctl --list-devicesThe answer was:
Logitech Webcam C930e
/dev/video0
/dev/video1
/dev/media0Now I knew exactly what Debian was seeing.
7. Examining the Logitech C930e
Next I examined the formats available from /dev/video0:
v4l2-ctl -d /dev/video0 --list-formats-extThe camera exposed both raw YUYV and compressed Motion-JPEG capture modes. The output showed that the MJPEG interface could provide 1920×1080 at 30 frames per second.
That was more than enough for my experiment.
I wasn’t trying to build a surveillance system.
I simply wanted to answer a very specific question:
Can I remotely tell a physical camera attached to my Hawaii workstation to capture an image?
8. First I Tested the Camera Locally
FFmpeg was already installed on the Debian desktop.
I captured one frame from the camera:
ffmpeg -f v4l2 \
-input_format mjpeg \
-video_size 1920x1080 \
-i /dev/video0 \
-frames:v 1 \
~/webcam-test.jpgFFmpeg reported a 1920×1080 MJPEG input and wrote:
/home/lvydvy/webcam-test.jpgI verified the file:
ls -lh ~/webcam-test.jpgIt existed.
Then I opened it:
xdg-open ~/webcam-test.jpgThe camera worked.
But that was merely the control experiment.
I was still operating the computer locally.
Now came the test I actually cared about.
9. I Moved to HP Laptop #2
I went to my second HP laptop.
Its prompt showed:
ny2honolulu@ommarchy:~$From there I connected through Tailscale to my main Debian desktop:
ssh lvydvy@100.66.230.106The prompt changed:
(base) lvydvy@Debian:~$This time that change had special significance.
I was sitting at one physical computer while issuing commands to another.
And the second computer had the Logitech camera plugged into it.
10. I Triggered the Hawaii Webcam Remotely
From the SSH session initiated on HP #2, I executed:
ffmpeg -f v4l2 \
-input_format mjpeg \
-video_size 1920x1080 \
-i /dev/video0 \
-frames:v 1 \
-update 1 \
~/spain-test.jpgFFmpeg successfully captured one frame.
The file was created on the remote Debian desktop, not on the HP laptop:
/home/lvydvy/spain-test.jpgThis distinction is important.
The flow was now:
HP Laptop #2
│
│ SSH command
▼
Debian Desktop
│
│ Video4Linux
▼
Logitech C930e
│
│ 1920×1080 frame
▼
spain-test.jpg
│
▼
Debian Desktop filesystemI had remotely controlled a physical USB device attached to another Linux machine.
11. But the Photograph Was Still in Hawaii
Capturing the photograph was only half of the experiment.
If I were actually in Spain, I would want the photograph on the laptop sitting in front of me.
So I exited the SSH session and returned to:
ny2honolulu@ommarchy:~$Then I used SCP:
scp lvydvy@100.66.230.106:~/spain-test.jpg ~/The transfer completed:
spain-test.jpg 100% 82KBNow the file existed on HP Laptop #2.
I opened it:
xdg-open ~/spain-test.jpgAnd there I was.
The resulting file was the 1920×1080 spain-test.jpg now being viewed locally from the HP laptop.
That completed the experiment.
12. What I Actually Proved
This wasn’t merely a webcam test.
I proved an entire chain:
HP LAPTOP #2
│
│
Tailscale
│
▼
SSH
│
▼
DEBIAN DESKTOP
│
│
Video4Linux
│
▼
LOGITECH C930e
│
│
1920×1080 capture
│
▼
spain-test.jpg
│
│
SCP
│
▼
Tailscale
│
▼
HP LAPTOP #2
│
▼
IMAGE VIEWER
Every major part was actually tested.
Tailscale connectivity worked.
SSH remote control worked.
Linux recognized the USB webcam.
Video4Linux exposed the camera to FFmpeg.
FFmpeg remotely captured an image.
SCP transferred the image between the machines.
The image opened successfully on the laptop.
That is substantially different from saying, “This should work.”
It worked.
13. What I Like Most About This Architecture
One of the most interesting lessons for me is that I don’t have to carry my entire homelab with me.
My HP laptop doesn’t need hundreds of gigabytes of virtual machines.
It doesn’t need to duplicate every development environment on my desktop.
It doesn’t need to become a miniature version of my main workstation.
Instead:
The laptop can be the console. The Debian desktop can remain the laboratory.
That is a much cleaner model.
My travel machine can remain relatively lightweight while my more capable computer stays at home performing the actual work.
14. Security Matters
There is another aspect of this setup that I particularly like.
I did not accomplish this by exposing my webcam to the public Internet.
I did not configure some arbitrary public camera webpage.
I did not open an SSH port on my router for the world to probe.
The remote connectivity was carried through my Tailscale network, while SSH provided authenticated remote shell access.
That doesn’t eliminate the need for good security practices. Before relying on this while traveling, I still want to configure and thoroughly test SSH keys, review Tailscale access, verify startup behavior after reboots, and make sure the desktop is prepared for unattended operation.
But the architecture itself is appealing:
Public Internet
│
│
Tailscale
│
▼
Private tailnet
│
├── HP Laptop
├── Debian Desktop
├── Other HP Laptop
├── iPhone
└── iPadThe services I am using for this experiment do not need to become generally accessible Internet services.
15. What Still Needs to Be Done Before Spain
Today’s test was successful, but I would not call the travel setup finished.
Before leaving Hawaii, I want to address several remaining items.
SSH keys are high on the list. Password authentication worked for today’s experiment, but key-based SSH authentication would make routine remote access both more convenient and easier to harden appropriately.
I also want to verify that both SSH and Tailscale automatically return after a full reboot.
Then there is the BIOS power-recovery question. I want to determine whether my ASUS desktop can automatically power itself back on after electricity is lost and restored.
And perhaps most importantly, I want to perform a genuine outside-the-house rehearsal.
The obvious way is to disconnect HP #2 from my home Wi-Fi, connect it through my iPhone hotspot, and repeat the test.
That would remove my home LAN from the equation.
If I can sit on a cellular connection and successfully:
SSH → Debian
capture → webcam
SCP → laptopthen I will have reproduced the essential Spain scenario while still sitting in Hawaii.
16. A Live Camera Can Wait
Today’s experiment naturally leads to another possibility: a private live video feed from the Logitech camera over my Tailscale network.
That would be an interesting Linux networking and multimedia project.
But I am deliberately leaving that for another day.
Today’s experiment already accomplished what I wanted.
In fact, keeping this as a sequence of small, understandable projects is part of what makes the homelab valuable to me.
I didn’t install a packaged “remote camera solution” and call it finished.
I learned the pieces:
Linux device
↓
Video4Linux
↓
FFmpeg
↓
filesystem
↓
SSH
↓
SCP
↓
TailscaleNow when I eventually build something more sophisticated, I will understand what is happening underneath it.
Final Reflection
What began as a conversation about whether I could reach my desktop from Spain became one of those deceptively simple homelab exercises that teaches several concepts at once.
I learned that remote access is not merely about remote desktop software.
A Linux shell can become an extraordinarily powerful remote-control interface.
Through SSH, I wasn’t just reading files on another computer. I was executing programs there.
Those programs could interact with hardware.
The hardware could produce data.
And SCP could bring that data back to me.
The photograph made the entire idea concrete.
I sat at HP Laptop #2.
I connected privately to my Debian workstation.
I instructed a Logitech webcam physically attached to that workstation to capture a photograph.
The Debian machine created the image.
I copied it back across the private network.
Then I opened it on the laptop.
There I was.
Someday the laptop may be sitting on a desk in San Sebastián or Madrid while the Debian workstation is still sitting at home in Hawaii.
The commands won’t fundamentally care.
That’s when today’s little webcam photograph becomes more than a photograph.
It becomes proof that my homelab is beginning to transcend the room it’s sitting in.