old-laptop-to-server

KO | EN

gitlite — search

#typescript #ai-agents #ai #dsh-plugin #deepseek-harness #open-source #cli #claude-code #codex #developer-tools #react #windows

old-laptop-to-server

★ 30 Open GitHub ↗

This guide walks you through converting an old laptop into a usable Linux server for development projects and game servers

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Turning an Old Laptop into a Linux Server (Step by Step)

This guide walks you through converting an old laptop into a usable Linux server for development projects and game servers (like Minecraft).
It's written as a practical extension to the video, so you can follow everything step by step.

---

## 1. Installing Ubuntu Server

First, download **Ubuntu Server** from the official website:

[https://ubuntu.com/download/server](https://ubuntu.com/download/server)

Create a bootable USB using any tool you prefer (Balena Etcher, Rufus, etc.), boot from it, and follow the installer steps.

During installation:

* Use **English** as the language
* Connect to the network during setup
* Keep most options as default unless you know exactly what you're changing

Once the installation is finished, reboot and log in using the username and password you created.

---

## 2. Getting Your Network Interface Name

Before configuring a static IP, you need to know your network interface name.

### Option 1: Using `ip route`

```bash
ip route
```

This will show your active interface and gateway.

### Option 2: Using `ifconfig`

First, install net-tools:

```bash
sudo apt install net-tools
```

Then run:

```bash
ifconfig
```

Look for the interface that has an IP address assigned (for example: `wlp2s0` for Wi-Fi or `enp3s0` for Ethernet).

---

## 3. Making Your IP Address Static

To prevent your server's IP from changing, we'll assign a static IP using Netplan.

Edit the Netplan configuration file:

```bash
sudo nano /etc/netplan/00-installer-config.yaml
```

### For Wi-Fi Devices

```yaml
network:
  version: 2
  renderer: networkd
  wifis:
    wlp2s0:
      dhcp4: no
      addresses:
        - 172.16.0.100/24
      gateway4: 172.16.0.1
      nameservers:
        addresses:
          - 8.8.8.8
          - 1.1.1.1
      access-points:
        "YOUR_WIFI_SSID":
          password: "YOUR_WIFI_PASSWORD"
```

### For Ethernet Devices

```yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    enp3s0:
      dhcp4: no
      addresses:
        - 172.16.0.100/24
      gateway4: 172.16.0.1
      nameservers:
        addresses:
          - 8.8.8.8
          - 1.1.1.1
```

### For Both Wi-Fi and Ethernet

```yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    enp3s0:
      dhcp4: no
      addresses:
        - 172.16.0.100/24
      gateway4: 172.16.0.1
      nameservers:
        addresses:
          - 8.8.8.8
          - 1.1.1.1
  wifis:
    wlp2s0:
      dhcp4: no
      addresses:
        - 172.16.0.101/24
      gateway4: 172.16.0.1
      nameservers:
        addresses:
          - 8.8.8.8
          - 1.1.1.1
      access-points:
        "YOUR_WIFI_SSID":
          password: "YOUR_WIFI_PASSWORD"
```

Important:

* Replace `wlp2s0` and `enp3s0` with **your actual interface names**
* Replace `YOUR_WIFI_SSID` and `YOUR_WIFI_PASSWORD` with your network credentials
* Change the IP address to the one you want to assign
* You can find your gateway using:

```bash
ip route
```

Save the file:

* `Ctrl + X`
* Press `Y`
* Press `Enter`

Apply the configuration:

```bash
sudo netplan apply
```

Reboot the system:

```bash
sudo reboot
```

After reboot, check if the IP is still the same. If yes, everything is set correctly.

---

## 4. Installing Docker

You can follow the official documentation:

[https://docs.docker.com/engine/install/ubuntu/](https://docs.docker.com/engine/install/ubuntu/)

Or install Docker directly using these commands.

### Add Docker's GPG Key

```bash
sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
```

### Add Docker Repository

```bash
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF
```

Update package list:

```bash
sudo apt update
```

Install Docker:

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

Check Docker service status:

```bash
sudo systemctl status docker
```

If it's not active:

```bash
sudo systemctl start docker
```

---

## 5. Installing Docker Compose

Official documentation:

[https://docs.docker.com/compose/install/linux/](https://docs.docker.com/compose/install/linux/)

Or install directly:

```bash
sudo apt-get update
sudo apt-get install docker-compose-plugin
```

Verify installation:

```bash
docker compose version
```

If you see a version number, Docker Compose is installed correctly.

---

## 6. Granting Permission to Run Docker Without sudo

```bash
sudo usermod -aG docker $USER
sudo systemctl restart docker
newgrp docker
```

This allows your user to run Docker commands without `sudo`.

---

## 7. Installing and Configuring UFW Firewall

Install UFW:

```bash
sudo apt install ufw
```

Enable it:

```bash
sudo ufw enable
```

Allow SSH access:

```bash
sudo ufw allow OpenSSH
sudo ufw allow ssh
```

SSH runs on port 22 by default.

Allow any application ports you need.
For Minecraft (default port):

```bash
sudo ufw allow 25565
```

---

## 8. Setting Up a Minecraft Server

You can find all Minecraft server versions here:

[https://gist.github.com/cliffano/77a982a7503669c3e1acb0a0cf6127e9](https://gist.github.com/cliffano/77a982a7503669c3e1acb0a0cf6127e9)

### Install Java

```bash
sudo apt install default-jre
```

Verify Java installation:

```bash
java --version
```

### Run the Minecraft Server

Place the server JAR file in a directory, then run:

```bash
java -Xmx2G -Xms1G -jar server.jar nogui
```

Where:

* `-Xms` → Minimum RAM
* `-Xmx` → Maximum RAM

On first run, the server will stop and generate files.
Edit `eula.txt` and change:

```
eula=false
```

to:

```
eula=true
```

Run the server again, and it should start normally.

---

## 9. Exposing Your Server to the Internet

There are three main methods to make your local server accessible from the internet.

### Method 1: Port Forwarding (Traditional Method)

This method requires access to your router settings and opens ports directly to your server.

**Steps:**

1. Access your router's admin panel (usually at 192.168.1.1 or 192.168.0.1)
2. Log in with your router credentials
3. Find the Port Forwarding section (location varies by router model)
4. Create a new port forwarding rule:
   * External Port: 25565 (or your desired port)
   * Internal Port: 25565
   * Internal IP: Your server's static IP (e.g., 172.16.0.100)
   * Protocol: TCP/UDP or Both
5. Save the settings

**Find your public IP:**

```bash
curl ifconfig.me
```

**Advantages:**

* Full control over your network
* No third-party dependencies
* Best performance

**Disadvantages:**

* Requires router access
* Security risk if not configured properly
* Difficult if you're behind CGNAT
* Public IP may change if not static

---

### Method 2: Tailscale VPN

Tailscale creates a secure peer-to-peer VPN network between your devices without opening ports or changing router settings.

Official website: [https://tailscale.com/](https://tailscale.com/)

**Installation:**

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

**Authenticate and connect:**

```bash
sudo tailscale up
```

This will display a URL. Open it in a browser and authenticate with your Tailscale account (you can use Google, GitHub, or Microsoft to sign in).

**Get your Tailscale IP:**

```bash
tailscale ip -4
```

This IP (usually starts with 100.x.x.x) is how other devices on your Tailscale network will connect to your server.

**Allow other devices to connect:**

Install Tailscale on any device you want to access your server from (Windows, Mac, Linux, Android, iOS all supported).

Once connected to the same Tailscale network, use the Tailscale IP to access your server.

**Disable Tailscale (if needed):**

```bash
sudo tailscale down
```

**Check Tailscale status:**

```bash
tailscale status
```

**Advantages:**

* No port forwarding required
* Encrypted peer-to-peer connections
* Works behind CGNAT and restrictive firewalls
* Easy to set up and manage
* Free for personal use (up to 100 devices)

**Disadvantages:**

* Only devices on your Tailscale network can access your server
* Not suitable for public-facing services
* Requires Tailscale client on all devices
* Slight performance overhead due to encryption

---

### Method 3: Cloudflare Tunnels

Cloudflare Tunnels allow you to expose your server to the internet without opening ports or changing router settings. The server connects to Cloudflare, and Cloudflare handles all incoming traffic.

Official documentation: [https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/)

There are two ways to use Cloudflare Tunnels.

#### Case 1: Without a Domain (Temporary URL)

This method gives you a temporary URL that works as long as the tunnel process is running. The URL will change every time you restart the tunnel.

**Important limitations:**

* The URL is temporary and will change on restart
* Cloudflare may terminate the session at any time
* Not suitable for production or permanent use
* Designed for testing and development only

**Installation:**

Download and install cloudflared:

```bash
wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb
sudo dpkg -i cloudflared-linux-amd64.deb
```

Verify installation:

```bash
cloudflared --version
```

**Start a Quick Tunnel:**

For a service running on port 80:

```bash
cloudflared tunnel --url http://localhost:80
```

For a service on a different port (e.g., 3000):

```bash
cloudflared tunnel --url http://localhost:3000
```

After running the command, you'll see output like:

```
Your quick Tunnel has been created! Visit it at:
https://random-name-random.trycloudflare.com
```

This is your temporary public URL. Share it with anyone who needs access to your server.

**Run tunnel in the background:**

Using nohup:

```bash
nohup cloudflared tunnel --url http://localhost:80 > /tmp/cloudflared.log 2>&1 &
```

Using screen:

```bash
screen -S cloudflare-tunnel
cloudflared tunnel --url http://localhost:80
```

Press `Ctrl+A` then `D` to detach from screen.

To reattach:

```bash
screen -r cloudflare-tunnel
```

**Stop the tunnel:**

Find the process:

```bash
ps aux | grep cloudflared
```

Kill it:

```bash
kill [PID]
```

---

#### Case 2: With a Domain (Permanent Solution)

This is the proper way to use Cloudflare Tunnels for production. Your server will be accessible via your own domain, and the connection will persist across restarts.

**Requirements:**

* A domain registered and added to your Cloudflare account
* Free Cloudflare account

**Installation:**

If not already installed:

```bash
wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb
sudo dpkg -i cloudflared-linux-amd64.deb
cloudflared --version
```

**Authenticate with Cloudflare:**

```bash
cloudflared tunnel login
```

This will display a URL. Open it in your browser and log in to your Cloudflare account. Select the domain you want to use. The authentication file will be saved automatically.

**Create a tunnel:**

```bash
cloudflared tunnel create my-tunnel
```

Replace `my-tunnel` with any name you prefer.

You'll see output like:

```
Created tunnel my-tunnel with id: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
```

Save this Tunnel ID.

**Create configuration file:**

```bash
sudo mkdir -p /etc/cloudflared
sudo nano /etc/cloudflared/config.yml
```

Add the following configuration:

```yaml
url: http://localhost:80
tunnel: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
credentials-file: /root/.cloudflared/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.json
```

**Important:**

* Replace `url` with your service port (e.g., `http://localhost:3000`)
* Replace `tunnel` with your actual Tunnel ID
* Replace `credentials-file` with the actual path shown during tunnel creation

Save the file with `Ctrl+X`, then `Y`, then `Enter`.

**Route DNS to your tunnel:**

```bash
cloudflared tunnel route dns my-tunnel app.yourdomain.com
```

Replace:

* `my-tunnel` with your tunnel name
* `app.yourdomain.com` with your desired subdomain

Example:

```bash
cloudflared tunnel route dns my-tunnel server.example.com
```

**Test the tunnel:**

```bash
cloudflared tunnel run my-tunnel
```

If it works, stop it with `Ctrl+C` and proceed to set it up as a service.

**Install as a system service:**

```bash
sudo cloudflared service install
```

**Start the service:**

```bash
sudo systemctl start cloudflared
```

**Enable automatic startup:**

```bash
sudo systemctl enable cloudflared
```

**Check service status:**

```bash
sudo systemctl status cloudflared
```

**View logs:**

```bash
sudo journalctl -u cloudflared -f
```

**Manage your tunnel:**

List all tunnels:

```bash
cloudflared tunnel list
```

Get tunnel info:

```bash
cloudflared tunnel info my-tunnel
```

Delete a tunnel:

```bash
cloudflared tunnel delete my-tunnel
```

**Update cloudflared:**

```bash
wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb
sudo dpkg -i cloudflared-linux-amd64.deb
sudo systemctl restart cloudflared
```

**Advantages:**

* No port forwarding required
* Works behind CGNAT and restrictive firewalls
* Free HTTPS certificates automatically
* DDoS protection from Cloudflare
* Can use your own domain
* Persistent and reliable

**Disadvantages:**

* Requires a Cloudflare account
* Requires a domain for permanent use
* All traffic goes through Cloudflare servers
* Temporary URLs unreliable for production

---

## 10. Additional Tools and Services

### Tailscale

A mesh VPN service that creates secure connections between your devices without complex configuration.

Official website: [https://tailscale.com/](https://tailscale.com/)
Documentation: [https://tailscale.com/kb/](https://tailscale.com/kb/)

Use Tailscale when you want to securely access your server from your personal devices without exposing it to the public internet.

---

### Coolify

An open-source, self-hostable alternative to platforms like Heroku, Netlify, and Vercel. It allows you to deploy and manage applications, databases, and services on your own server with a web interface.

Official website: [https://coolify.io/](https://coolify.io/)
Documentation: [https://coolify.io/docs/](https://coolify.io/docs/)

**Installation:**

```bash
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
```

After installation, access Coolify at:

```
http://your-server-ip:8000
```

Coolify provides:

* One-click deployment for applications
* Built-in support for Git repositories
* Database management (PostgreSQL, MySQL, MongoDB, Redis)
* SSL certificate automation
* Resource monitoring
* Docker container management
* Support for multiple frameworks and languages

Use Coolify when you want a user-friendly interface to manage multiple applications and services on your server without manually configuring Docker containers.

---

## Final Notes

At this point, you have:

* A static-IP Ubuntu Server
* Docker and Docker Compose installed
* Firewall configured
* A working Minecraft server
* Multiple methods to expose your server to the internet
* Knowledge of additional tools like Tailscale and Coolify

This setup works not only for games, but also for development projects, self-hosted services, and experiments.

Choose the exposure method that fits your needs:

* **Port Forwarding** for maximum control and performance
* **Tailscale** for private, secure access between your devices
* **Cloudflare Tunnels** for public-facing services without port forwarding

Feel free to extend this setup based on your requirements.

old-laptop-to-server

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README