DEV Community: Reginald F. Johnson

Keep your Ubuntu‑based VPN Server Updated

Reginald F. Johnson — Tue, 30 Dec 2025 20:10:57 +0000

🔄 Automate Monthly System Updates on Ubuntu 24.04

A simple, reliable way to keep your Ubuntu‑based VPN server fully updated.

This guide shows you how to create an update script, schedule it to run monthly, optionally reboot afterward, and verify everything is working.

📝 Step 1: Create the Update Script

First, create the script file:

sudo nano /usr/local/bin/auto-update.sh

Paste the following into the file:

#!/bin/bash
# Update package lists and upgrade everything
apt-get update && apt-get dist-upgrade -y

# Clean up old files
apt-get autoremove -y
apt-get autoclean

# Log completion time
echo "Full system update completed on $(date)" >> /var/log/sys_update.log

Make the script executable:

sudo chmod +x /usr/local/bin/auto-update.sh

⏱️ Step 2: Schedule Monthly Updates with Cron

Open the root crontab:

sudo crontab -e

Add this line at the bottom:

0 3 1 * * /usr/local/bin/auto-update.sh

This runs the update script at 3:00 AM on the 1st day of every month.

🔁 Step 3 (Optional): Enable Auto‑Reboot

If you want the server to reboot after updates:

Open the script again:

sudo nano /usr/local/bin/auto-update.sh

Add this line at the very bottom:

/sbin/reboot

Save and exit.

✅ Step 4: Verify Everything

Check your scheduled cron jobs:

sudo crontab -l

Check the update log:

cat /var/log/sys_update.log

If you see timestamps, your automated updates are working correctly.

🎉 Done!

Your Ubuntu 24.04 VPN server will now stay updated, clean, and low‑maintenance with almost no effort.

Step‑by‑Step Ubuntu Linux Installation Guide

Reginald F. Johnson — Tue, 30 Dec 2025 19:15:28 +0000

🧭 Full Environment Shift: Step‑by‑Step Ubuntu Installation Guide

You’re doing a full environment shift here, so this guide is intentionally explicit and linear. Even “obvious” steps are included so nothing gets skipped.

1. Decide What Kind of Install You Want

Before touching anything, decide:

1. Install Type

Erase Windows and use only Ubuntu (simpler)
Install Ubuntu alongside Windows (dual‑boot, more complex)

This guide notes differences where they matter.

2. Data Backup

If erasing Windows: Back up all files (Documents, Desktop, Downloads, browser data, etc.) to an external drive or cloud.
If dual‑booting: Still back up important data — partition changes always carry risk.

3. Free Space Requirement

Recommended: 30–50 GB free for Ubuntu.
If dual‑booting, check Windows free space: Win + E → This PC → Local Disk (C:)

2. Prepare a USB Drive & Downloads (Windows 10/11)

2.1. Get a USB Drive Ready

USB size:
- Use an 8 GB or larger USB flash drive.
- All data on it will be erased.
Plug in USB:

Insert the USB drive into your laptop.
Optional: Format USB (clean start):
- Win + E → right‑click USB drive → Format…
- File system: FAT32 or NTFS
- Click Start → confirm.

2.2. Download Ubuntu ISO

Open a browser (Edge, Chrome, Firefox).
Go to Ubuntu download page:

https://ubuntu.com/download/desktop
Choose version:
- Download the latest LTS version (e.g., Ubuntu 24.04 LTS or 22.04 LTS).
- Wait for the .iso file to finish downloading.
Verify download location:
- Win + E → Downloads
- Look for something like: ubuntu-24.04-desktop-amd64.iso

2.3. Download Rufus

Go to: https://rufus.ie
Scroll to Download section.
Download Rufus x.xx Portable or the latest version.
Save it (usually in Downloads).

3. Create the Ubuntu USB with Rufus

3.1. Run Rufus

Win + E → open Downloads
Double‑click the Rufus .exe (e.g., rufus-4.5.exe)
Approve the Windows UAC prompt if it appears.

3.2. Select USB Drive & ISO

Inside Rufus:

Device:
- Select your USB drive from the dropdown.
Boot selection:
- Click SELECT
- Choose the Ubuntu .iso file.
Partition scheme & target system:
- GPT for most modern laptops
- MBR for older BIOS‑only systems
- Target system adjusts automatically.
Volume label:
- Optional: name it UBUNTU
File system:
- Leave default (FAT32 for UEFI).

3.3. Rufus Ubuntu‑Specific Prompts

ISOHybrid image detected:
- Choose Write in ISO Image mode (Recommended) → OK
Data warning:
- Confirm that all USB data will be destroyed.

3.4. Create the USB

Click START
Wait 5–20 minutes
When complete, Rufus will show READY
Click CLOSE
Leave the USB plugged in

4. Prepare Your Laptop BIOS/UEFI

You need to ensure the laptop can boot from USB.

4.1. Enter BIOS/UEFI

Restart Windows:

Start → Power → Restart
Press the firmware key repeatedly during boot:

Manufacturer	Key(s)
Dell	F2 or F12
HP	Esc → F9 or F10
Lenovo	F1, F2, or Novo button
Acer	F2
ASUS	F2 or Del
MSI	Del

If Windows boots normally, restart and try again earlier.

4.2. Adjust Boot Options

Inside BIOS/UEFI:

Find boot menus:

Look for Boot, Boot Options, or Startup.
Enable USB boot:

Ensure USB/Removable boot is Enabled.
Secure Boot:
- Ubuntu can boot with Secure Boot ON, but if issues occur:
  - Set Secure Boot → Disabled
- Ensure Boot Mode is UEFI (not Legacy).
Boot order:
- Move the USB drive to the top of the boot priority list.
Save & exit:
- Usually F10 → Yes

🖥️ Ubuntu Laptop Home Server + Personal VPN (Tailscale Exit Node)

Reginald F. Johnson — Sat, 27 Dec 2025 18:55:47 +0000

🖥️ Ubuntu Laptop Home Server + Personal VPN (Tailscale Exit Node)

This guide walks you through converting a laptop with Ubuntu Linux installed into a reliable home server and a personal VPN using Tailscale.

You’ll configure the laptop to stay awake with the lid closed, then set it up as a secure VPN exit node accessible from anywhere.

🔧 Phase 1: Prepare the Hardware

Keep the Laptop Awake With the Lid Closed

Ubuntu suspends when the lid is closed — not ideal for a server.

Disable this behavior:

Open your terminal.
Edit the logind configuration file:

sudo nano /etc/systemd/logind.conf

Find this line:

#HandleLidSwitch=suspend

Remove the # and change it to:

HandleLidSwitch=ignore

Save and exit (Ctrl+O, Enter, Ctrl+X).
Apply the changes:

sudo systemctl restart systemd-logind

Your laptop will now stay awake with the lid closed.

🌐 Turn the Laptop Into a Personal VPN Server

Using Tailscale, you can turn your laptop into a secure VPN server that routes your internet traffic through your home network.

This uses a feature called an Exit Node.

🚀 Step 1: Install Tailscale on Ubuntu

Install Tailscale:

open TERMINAL:

curl -fsSL https://tailscale.com/install.sh | sh

Start and authenticate:

sudo tailscale up

Follow the URL provided to log in with Google, Microsoft, or GitHub.

🔁 Step 2: Enable Exit Node Mode

1. Enable IP Forwarding

echo 'net.ipv4.ip_forward = 1' | sudo tee -a /etc/sysctl.d/99-tailscale.conf
echo 'net.ipv6.conf.all.forwarding = 1' | sudo tee -a /etc/sysctl.d/99-tailscale.conf
sudo sysctl -p /etc/sysctl.d/99-tailscale.conf

2. Advertise as an Exit Node

sudo tailscale up --advertise-exit-node

🛡️ Step 3: Approve the Exit Node in the Admin Console

Open the Tailscale Admin Console: https://login.tailscale.com/admin/machines
Find your Ubuntu laptop.
Click the three dots (…) → Edit route settings.
Enable Use as exit node.
Save.

Your laptop is now a fully functional VPN server.

📱 Step 4: Connect From iOS or Android

iPhone / iPad (iOS)

Install Tailscale from the App Store.
Log in with the same account.
Tap Exit Node.
Select your Ubuntu laptop.
Toggle the VPN switch to Active.

Android

Install Tailscale from the Play Store.
Log in and accept the VPN permission.
Tap Exit Node.
Select your laptop.
Toggle the connection on.

Your mobile device now routes all traffic through your home server.

🔒 Why This Beats a Commercial VPN

Privacy: You own the server — no third‑party logging.
Local Access: Reach home files, printers, or cameras from anywhere.
Zero‑Config: Tailscale handles NAT, dynamic IPs, and firewall rules automatically.

✔️ Summary

You now have:

A laptop that stays awake with the lid closed
A secure, self‑hosted VPN server
Global access to your home network
A privacy‑focused alternative to commercial VPNs

My Simple Docker Project

Reginald F. Johnson — Sat, 27 Dec 2025 18:48:54 +0000

🐳 Building a Simple "Hello World" Docker Project

🚀 In this guide, we'll create a containerized Python web application that displays a "Hello World" message. This tutorial works on Ubuntu/Debian-based Linux distros

🔹 System Preparation

Before we start, update and upgrade your system packages:

sudo apt update
sudo apt upgrade -y

Install Docker and other required dependencies:

sudo apt install ca-certificates curl gnupg

Add Docker’s Official GPG Key

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo tee /etc/apt/keyrings/docker.asc > /dev/null
sudo chmod a+r /etc/apt/keyrings/docker.asc

Add Docker Repository

echo "deb [signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Install Docker

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Verify installation:

docker --version

Start and enable Docker:

sudo systemctl enable --now docker

Check Docker status:

sudo systemctl status docker

🔹 Install Docker Compose Plugin

Ubuntu now uses the Docker Compose plugin instead of the standalone binary:

sudo apt install docker-compose-plugin -y

Verify installation:

docker compose version

Install Python Pip for dependencies:

sudo apt install python3-pip
python3 -m pip install --upgrade pip

🔹 Create Project Directory

Set up the directory structure:

mkdir docker-projects
cd docker-projects

🔹 Create Python Web Application

Create the app.py file:

touch app.py
nano app.py

Copy & paste the following Python Flask app:

from flask import Flask
import redis

app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)

def get_hit_count():
    try:
        return cache.incr('hits')
    except redis.exceptions.ConnectionError:
        return 1

@app.route('/')
def hello():
    count = get_hit_count()
    return f"Hello World! You have visited {count} times."

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Save the file (CTRL + X, then Y).

🔹 Define Dependencies

Create the requirements.txt file:

touch requirements.txt
nano requirements.txt

Add dependencies inside requirements.txt:

Flask
redis

Save (CTRL + X, then Y).

🔹 Create Dockerfile

Create a Dockerfile:

touch Dockerfile
nano Dockerfile

Paste the following Dockerfile configuration:

FROM python:3.9

WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["python", "app.py"]

Save (CTRL + X, then Y).

🔹 Configure Docker Compose

Create the docker-compose.yml file:

touch docker-compose.yml
nano docker-compose.yml

Paste the Docker Compose config:

version: '3'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - redis

  redis:
    image: "redis:alpine"

Save (CTRL + X, then Y). ⚠ YAML files are sensitive to indentation—validate them before running!

🔹 Build and Run the Project

Ensure you're in the docker-projects directory:

cd docker-projects

Start the containers:

sudo docker-compose up --build

🔹 Test the Web App

Open a browser and go to http://localhost:5000.

You should see:

Hello World! You have visited 1 times.

Refreshing the page will increase the visitor count.

🔹 Stop Containers

Shut down the containers when you're done:

sudo docker-compose down