DEV Community: HostnExtra Technologies

Introducing HostnExtra CLI: An Open Source Toolkit for Linux Server Management

HostnExtra Technologies — Fri, 07 Aug 2026 05:19:15 +0000

Managing Linux servers often involves a collection of commands, scripts, and configuration files spread across multiple tools. While each tool serves its purpose, switching between them can slow down routine administration tasks.

HostnExtra CLI was created to bring these everyday operations together into a single, extensible command-line toolkit. Built with TypeScript and designed around a plugin architecture, it helps system administrators, DevOps engineers, developers, and hosting providers manage infrastructure more efficiently from the terminal.

GitHub Repository: https://github.com/hostnextra/cli

Why We Built HostnExtra CLI

At HostnExtra, we work with Linux servers every day. Whether we're deploying new infrastructure, managing SSH access, monitoring server health, or creating secure tunnels, we rely heavily on the command line.

Over time, we noticed that many administrative tasks followed the same workflow:

Configure SSH connections
Verify server health
Access internal services securely
Organize server configurations
Perform routine maintenance

Instead of creating isolated utilities for each task, we built a modular CLI that brings them together under one consistent interface.

Our goal is simple:

Build an open source toolkit that makes Linux server management faster, cleaner, and more organized.

Built Around Plugins

HostnExtra CLI uses a plugin-based architecture. Each plugin focuses on a specific area of server administration while maintaining a consistent user experience across the entire CLI.

This design allows the project to grow naturally while keeping commands easy to discover and use.

Current plugins include:

SSH Configuration Management
Server Monitoring
Secure SSH Tunnels

More plugins are already planned for future releases.

SSH Configuration Management

Managing SSH configurations manually works well for a few servers, but as infrastructure grows, keeping everything organized becomes increasingly important.

The SSH plugin simplifies common operations such as:

Creating new SSH hosts
Editing existing configurations
Listing saved hosts
Testing SSH connections
Connecting directly from the CLI
Importing and exporting configurations

Instead of manually editing ~/.ssh/config, the CLI provides a structured workflow for managing server access.

Example:

hostnextra ssh add

hostnextra ssh list

hostnextra ssh connect production-server

Server Monitoring

Understanding the health of a server should be quick and straightforward.

The Monitor plugin collects important system information and presents it in a clean, easy-to-read report.

It analyzes areas such as:

CPU usage
Memory utilization
Swap usage
Disk usage
Operating system information
Overall server health

This makes it useful for routine maintenance, troubleshooting, and verifying server performance after deployments.

Example:

hostnextra monitor

Within seconds, you receive a comprehensive overview of your server's current state.

Secure SSH Tunnels

SSH tunneling is one of the most useful tools available to Linux administrators. It enables secure access to services running on remote machines without exposing them publicly.

The Tunnel plugin simplifies the process of creating and managing SSH tunnels.

Example:

hostnextra tunnel open \
  --from web-prod-01:3306 \
  --to localhost:3306

Once the tunnel is no longer needed:

hostnextra tunnel close

The plugin manages the tunnel lifecycle, making it easy to open, monitor, and close secure connections.

Designed for Developers and System Administrators

HostnExtra CLI is suitable for anyone who works with Linux infrastructure, including:

System Administrators
DevOps Engineers
Backend Developers
Hosting Providers
Platform Engineers
Home Lab Enthusiasts

Whether you're managing one server or an entire fleet, the CLI is designed to simplify everyday operations.

Built with TypeScript

HostnExtra CLI is developed using modern TypeScript, providing:

Strong type safety
Modular architecture
Cross-platform compatibility
Easy plugin development
Improved maintainability

The project follows modern development practices to ensure reliability and long-term growth.

Open Source from Day One

HostnExtra CLI is fully open source.

We believe infrastructure tools become stronger through community collaboration. Developers are welcome to explore the codebase, report issues, suggest improvements, and contribute new features.

Every contribution helps improve the experience for Linux users around the world.

GitHub Repository:

https://github.com/hostnextra/cli

Getting Started

Install HostnExtra CLI globally using npm:

npm install -g hostnextra

Or run it directly using npx:

npx hostnextra

To view all available commands:

hostnextra --help

What's Next

HostnExtra CLI is actively evolving, with several new plugins already in development.

Future areas of focus include:

Container management
Backup utilities
Deployment automation
Additional networking tools
Infrastructure productivity plugins

Our vision is to build a comprehensive command-line toolkit that supports the daily workflow of Linux professionals while remaining lightweight, modular, and easy to extend.

Join the Community

We're excited to continue building HostnExtra CLI alongside the open source community.

If you're passionate about Linux, DevOps, server management, or open source software, we'd love to have you involved.

⭐ Star the project on GitHub

🐞 Report issues and suggest features

💡 Share ideas for new plugins

🤝 Contribute to the codebase

GitHub Repository:

https://github.com/hostnextra/cli

Thank you for being part of the journey. We look forward to building the future of Linux server management together.

Introducing Two Open Source CLI Tools from HostnExtra

HostnExtra Technologies — Wed, 29 Jul 2026 11:51:28 +0000

At HostnExtra, we believe the best developer tools solve real problems without adding unnecessary complexity.

Working with Linux servers, SSH, and infrastructure automation every day exposed the same repetitive tasks across projects. Instead of solving those problems internally, we decided to build reusable tools and release them as open source so developers, DevOps engineers, and system administrators can benefit from them as well.

Today, we're excited to introduce the first two projects in the HostnExtra Open Source ecosystem.

HostnExtra CLI

HostnExtra CLI is a modern command-line toolkit built for infrastructure workflows.

Our goal is to create a consistent and extensible CLI experience that helps simplify common server management tasks while providing a strong foundation for future infrastructure tools.

Whether you're managing one server or hundreds, the CLI is designed to be fast, intuitive, and easy to extend.

HostnExtra SSH Config

Managing SSH hosts often means manually editing ~/.ssh/config, searching through configuration files, or maintaining scripts for common tasks.

HostnExtra SSH Config provides a cleaner workflow by allowing you to manage SSH configurations directly from the command line.

Current capabilities include:

Add and organise SSH hosts
Edit existing configurations
Connect to servers quickly
Test SSH connectivity
Import and export configurations
View connection history
Maintain a structured SSH configuration without manual file editing

The focus is on improving everyday productivity while keeping the experience familiar for developers and system administrators.

Engineering Principles

Every project we release follows a few core principles:

Open source from day one
Built with TypeScript
Cross-platform compatibility
Clean and maintainable architecture
Consistent command design
Minimal dependencies where practical
Built for real production workflows

We believe developer tools should stay out of the way and let engineers focus on solving problems instead of managing repetitive tasks.

Available on npm

HostnExtra CLI

https://www.npmjs.com/package/hostnextra

HostnExtra SSH Config

https://www.npmjs.com/package/hostnextra-ssh-config

Building an Open Source Ecosystem

These projects mark the beginning of HostnExtra's open source journey.

Our vision is to build a growing ecosystem of practical tools that simplify infrastructure management, automation, and developer workflows. Every new project will be guided by the same principles: solve real problems, keep the developer experience simple, and make the tools freely available to the community.

We're actively developing new projects, and this is only the first step.

If you explore these packages, we'd love to hear your thoughts. Feature requests, bug reports, discussions, and contributions all help shape the future of these tools.

Open source thrives through collaboration, and we're excited to build that future together.

How to Host Docker Apps on Ubuntu 26.04 with Caddy and Docker Compose

HostnExtra Technologies — Thu, 23 Jul 2026 07:17:30 +0000

Deploying your own applications doesn't have to be complicated. Docker Compose makes it easy to manage containers, while Caddy automatically handles HTTPS using Let's Encrypt. Together, they provide a simple and reliable setup for hosting websites, APIs, and self hosted applications.

In this guide, you'll create a basic production ready setup that includes:

Docker Compose for managing containers
Caddy as a reverse proxy and web server
Automatic HTTPS with Let's Encrypt
A simple test page before deploying your own application

Prerequisites

Before getting started, make sure you have:

Ubuntu 26.04 dedicated server
A domain name pointing to your server
Docker installed
Docker Compose plugin installed

Verify the installation:

docker --version
docker compose version

Step 1: Create the project directory

Create a directory for your project.

mkdir -p ~/apps/myapp/site
cd ~/apps/myapp

Your project structure should look like this:

myapp/
├── compose.yml
├── Caddyfile
└── site/
    └── index.html

Step 2: Create the Docker Compose file

Create a file named compose.yml.

nano compose.yml

Add following content:

services:
  caddy:
    image: caddy:2
    container_name: caddy
    restart: unless-stopped

    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"

    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - ./site:/srv
      - caddy_data:/data
      - caddy_config:/config

volumes:
  caddy_data:
  caddy_config:

The caddy_data volume stores your SSL certificates, so they remain available even after updating the container.

Step 3: Configure Caddy

Create a file named Caddyfile.

nano Caddyfile

Add following content:

example.com {

    root * /srv
    file_server
}

Replace example.com with your own domain name.

Step 4: Create a test page

Inside the site directory, create an index.html file.

nano index.html

Add following content:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Caddy Test Page</title>
</head>
<body>
    <h1>🎉 Caddy is Working!</h1>
    <p>Your Ubuntu 26.04 server is serving this page securely with HTTPS.</p>
</body>
</html>

This page helps confirm that your DNS, Docker, Caddy, and SSL certificate are all working correctly.

Step 5: Start Caddy

Launch the container.

docker compose up -d

Check that it is running.

docker compose ps

If your domain is already pointing to the server, Caddy will automatically request and install an SSL certificate.

Visit:

https://example.com

You should see the test page.

Step 6: View logs

If you need to troubleshoot, check the container logs.

docker compose logs -f

Hosting your application

Once everything is working, you can replace the test page with your own application.

Update your compose.yml.

services:
  app:
    image: ghcr.io/yourusername/myapp:latest
    restart: unless-stopped

  caddy:
    image: caddy:2
    restart: unless-stopped

    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"

    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
      - caddy_config:/config

    depends_on:
      - app

volumes:
  caddy_data:
  caddy_config:

Update the Caddyfile.

example.com {

    reverse_proxy app:3000
}

Replace 3000 with the port used by your application.

Apply the changes.

docker compose up -d

Your application will now be available through Caddy with automatic HTTPS.

Caddy and Docker Compose are a great combination for hosting modern applications on Ubuntu 26.04. Caddy automatically manages HTTPS, while Docker Compose keeps your deployment simple and easy to maintain.

You can use this same setup for Node.js, Next.js, Go, Laravel, Python, or any application running inside a Docker container by simply updating the reverse_proxy target in your Caddyfile.

Secure SSH on Ubuntu 26.04 with SSH Keys and Fail2ban

HostnExtra Technologies — Thu, 23 Jul 2026 07:04:49 +0000

If your server is connected to the internet, automated bots are already trying to access it.

One of the easiest ways to improve server security is to stop relying on passwords and switch to SSH keys. Combined with Fail2ban, this can drastically reduce the risk of brute force attacks.

In this guide, we'll secure SSH on Ubuntu 26.04 by:

Using SSH key authentication
Disabling root login
Disabling password authentication
Installing Fail2ban

Introduction

Password based SSH logins are a common target for automated attacks.

Even strong passwords can eventually become a liability, especially when attackers can attempt thousands of logins from different IP addresses.

SSH keys provide a much stronger authentication method, while Fail2ban automatically blocks repeated login failures.

Step 1: Update the Server

sudo apt update
sudo apt upgrade -y

Step 2: Generate an SSH Key Pair

On your local computer:

ssh-keygen -t ed25519 -C "ubuntu-server"

Accept the default location and optionally set a passphrase.

This creates:

~/.ssh/id_ed25519
~/.ssh/id_ed25519.pub

Step 3: Copy the Public Key to the Server

ssh-copy-id username@server_ip

Example:

ssh-copy-id admin@203.0.113.10

Step 4: Verify Key Authentication

Open a new terminal window and connect:

ssh username@server_ip

If login works without asking for the server password, SSH keys are working correctly.

Keep your existing SSH session open until testing is complete.

Step 5: Create a Custom SSH Security Configuration

Ubuntu 26.04 supports configuration snippets through the sshd_config.d directory.

Create a new file:

sudo nano /etc/ssh/sshd_config.d/99-security.conf

Add:

Port 52525
PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
ChallengeResponseAuthentication no

Note: Above

Step 7: Validate the Configuration

Before restarting SSH:

sudo sshd -t

If no output appears, the configuration is valid.

Step 8: Restart SSH
sudo systemctl restart ssh

Verify status:

sudo systemctl status ssh

Test SSH access from another terminal:

ssh username@server_ip

Password authentication should no longer work.

Step 9: Install Fail2ban

Install Fail2ban:

sudo apt install fail2ban -y

Enable and start the service:

sudo systemctl enable fail2ban
sudo systemctl start fail2ban

Check status:

sudo systemctl status fail2ban
Step 10: Configure Fail2ban

Create a local configuration file:

sudo nano /etc/fail2ban/jail.local

Add:

[sshd]
enabled = true
port = ssh
backend = systemd
maxretry = 5
findtime = 10m
bantime = 1h

Restart Fail2ban:

sudo systemctl restart fail2ban
Step 11: Verify Protection

View active jails:

sudo fail2ban-client status

View SSH jail details:

sudo fail2ban-client status sshd
Monitoring SSH Activity

View SSH logs:

sudo journalctl -u ssh -f

View Fail2ban activity:

sudo journalctl -u fail2ban -f
Final Checklist

Before considering your SSH setup secure, verify:

SSH keys are working
Root login is disabled
Password authentication is disabled
SSH configuration validates successfully
Fail2ban is running
Updates are installed regularly
Conclusion

SSH is one of the most exposed services on a Linux server, making it a frequent target for automated attacks.

By switching to SSH keys, disabling password authentication, and deploying Fail2ban, you add several layers of protection with very little effort.

These changes take only a few minutes to implement but can significantly improve the security of any Ubuntu 26.04 server.

Secure SSH on Ubuntu 26.04 with SSH Keys and Fail2ban

HostnExtra Technologies — Thu, 04 Jun 2026 07:11:18 +0000

If your server is connected to the internet, automated bots are already trying to access it.

One of the easiest ways to improve server security is to stop relying on passwords and switch to SSH keys. Combined with Fail2ban, this can drastically reduce the risk of brute force attacks.

In this guide, we'll secure SSH on Ubuntu 26.04 by:

Using SSH key authentication
Disabling root login
Disabling password authentication
Installing Fail2ban

Introduction

Password based SSH logins are a common target for automated attacks.

Even strong passwords can eventually become a liability, especially when attackers can attempt thousands of logins from different IP addresses.

SSH keys provide a much stronger authentication method, while Fail2ban automatically blocks repeated login failures.

Step 1: Update the Server

sudo apt update
sudo apt upgrade -y

Step 2: Generate an SSH Key Pair

On your local computer:

ssh-keygen -t ed25519 -C "ubuntu-server"

Accept the default location and optionally set a passphrase.

This creates:

~/.ssh/id_ed25519
~/.ssh/id_ed25519.pub

Step 3: Copy the Public Key to the Server

ssh-copy-id username@server_ip

Example:

ssh-copy-id admin@203.0.113.10

Step 4: Verify Key Authentication

Open a new terminal window and connect:

ssh username@server_ip

If login works without asking for the server password, SSH keys are working correctly.

Keep your existing SSH session open until testing is complete.

Step 5: Create a Custom SSH Security Configuration

Ubuntu 26.04 supports configuration snippets through the sshd_config.d directory.

Create a new file:

sudo nano /etc/ssh/sshd_config.d/99-security.conf

Add:

Port 52525
PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
ChallengeResponseAuthentication no

Note: We have set PermitRootLogin no be caution with that. You need to have normal user access. We are changing SSH port number, add it in firewall first.

Step 6: Validate the Configuration

Before restarting SSH:

sudo sshd -t

If no output appears, the configuration is valid.

Step 7: Restart SSH

sudo systemctl restart ssh

Verify status:

sudo systemctl status ssh

Test SSH access from another terminal:

ssh username@server_ip

Password authentication should no longer work.

Step 8: Install Fail2ban

Install Fail2ban:

sudo apt install fail2ban -y

Enable and start the service:

sudo systemctl enable fail2ban
sudo systemctl start fail2ban

Check status:

sudo systemctl status fail2ban

Step 9: Configure Fail2ban

Create a local configuration file:

sudo nano /etc/fail2ban/jail.local

Add:

[sshd]
enabled = true
port = ssh
backend = systemd
maxretry = 5
findtime = 10m
bantime = 1h

Restart Fail2ban:

sudo systemctl restart fail2ban

Step 10: Verify Protection

View active jails:

sudo fail2ban-client status

View SSH jail details:

sudo fail2ban-client status sshd

Monitoring SSH Activity

View SSH logs:

sudo journalctl -u ssh -f

View Fail2ban activity:

sudo journalctl -u fail2ban -f

Final Checklist

Before considering your SSH setup secure, verify:

SSH keys are working
Root login is disabled
Password authentication is disabled
SSH configuration validates successfully
Fail2ban is running
Updates are installed regularly

Conclusion

SSH is one of the most exposed services on a Linux server, making it a frequent target for automated attacks.

By switching to SSH keys, disabling password authentication, and deploying Fail2ban, you add several layers of protection with very little effort.

These changes take only a few minutes to implement but can significantly improve the security of any Ubuntu 26.04 server.

Originally published on HostnExtra.

We regularly publish practical guides on Linux administration, dedicated servers, networking, infrastructure security, and hosting performance.

Read the full version here:

Secure SSH on Ubuntu 26.04 with Key Authentication and Fail2ban - HostnExtra

Learn how to secure SSH on Ubuntu 26.04 using SSH key authentication and Fail2ban. Disable password logins, block brute force attacks, and strengthen your server security.

hostnextra.com

Switzerland Datacenters Explained: Power, Connectivity, and Infrastructure Design

HostnExtra Technologies — Thu, 04 Jun 2026 04:53:53 +0000

Developers often spend significant time optimizing application code while overlooking the infrastructure layer underneath it.

Yet infrastructure decisions can have a larger impact on performance, availability, and reliability than many software optimizations.

Datacenter location is one of those decisions.

Switzerland has become a popular European deployment location for dedicated servers, private cloud environments, virtualization platforms, and business-critical workloads. Understanding why requires looking beyond hardware specifications and examining the underlying infrastructure itself.

Datacenters Are More Than Server Racks

When evaluating hosting environments, it's easy to focus on CPU models, RAM capacity, and storage performance.

Those components matter.

However, production infrastructure depends equally on facility engineering.

Modern datacenters are built around multiple supporting systems:

Power distribution
Cooling infrastructure
Environmental monitoring
Physical security
Fire suppression
Network connectivity

Each subsystem contributes to overall service availability.

The server itself is only one part of the equation.

Understanding Power Redundancy

Power infrastructure is one of the most important elements inside any datacenter.

A typical enterprise facility includes multiple layers of protection.

Utility Power

This is the primary electrical feed supplied by the regional power grid.

Switzerland benefits from a highly developed electrical infrastructure that supports dependable service availability.

UPS Systems

Uninterruptible Power Supply systems sit between utility power and customer equipment.

If utility power fails, UPS batteries immediately continue supplying electricity.

This transition occurs fast enough that servers remain operational without interruption.

Backup Generators

UPS systems are designed to bridge short interruptions.

For longer events, backup generators take over.

Once generators reach stable operating conditions, they assume the electrical load while UPS systems continue providing protection.

Redundant Power Paths

Many facilities deploy multiple independent power paths.

If a failure occurs within one distribution path, the alternate path can continue supplying power.

The goal is eliminating single points of failure wherever possible.

Network Connectivity Matters More Than Most Buyers Realize

Hardware performance often receives most of the attention during server procurement.

In reality, network quality frequently has a greater impact on user experience.

Connectivity affects:

Application responsiveness
API performance
Replication traffic
Backup operations
End-user latency

Swiss datacenters benefit from strong connectivity toward major European markets including Germany, France, Italy, Austria, the Netherlands, Belgium, and the United Kingdom.

This makes Switzerland an attractive location for workloads serving distributed European audiences.

Carrier-Neutral Facilities And Route Diversity

One important concept many developers encounter only after operating production infrastructure is carrier diversity.

A carrier-neutral datacenter allows multiple network providers to operate within the same facility.

This creates several advantages:

Redundancy

If one carrier experiences issues, traffic can potentially utilize alternate providers.

Routing Flexibility

Infrastructure operators can select carriers based on performance, cost, or geographic reach.

Reduced Dependency

Organizations avoid becoming overly reliant on a single upstream network.

Carrier diversity is often a stronger indicator of infrastructure quality than raw bandwidth numbers.

Latency And Geographic Positioning

Physics still applies to networking.

Data cannot travel instantly.

The further traffic must travel, the higher the potential latency.

Switzerland's central European location helps provide balanced reachability toward several major markets.

This can be particularly useful for:

SaaS platforms
API services
Enterprise applications
Development infrastructure
Monitoring systems

Rather than optimizing solely for one country, organizations can often achieve broader regional coverage from a centrally positioned deployment.

Why Dedicated Servers Still Matter

Despite the growth of cloud platforms, dedicated servers continue to solve specific problems effectively.

Common reasons organizations choose dedicated infrastructure include:

Predictable Performance

Resources are not shared with unrelated tenants.

Hardware Control

Customers can select storage, CPU, memory, and networking configurations that fit workload requirements.

Virtualization Platforms

Dedicated servers are frequently used as hypervisor hosts for internal infrastructure.

Large Databases

Database management often benefit from dedicated resources and consistent performance characteristics.

For many organizations, dedicated servers remain a practical complement to cloud deployments rather than a replacement.

Evaluating Infrastructure Beyond Marketing

When selecting a hosting provider, technical teams should look beyond hardware specifications.

Important questions include:

How many carriers are available?
What power redundancy model exists?
What monitoring systems are implemented?
How are incidents handled?
What operational procedures exist for maintenance and failures?

These factors often determine long-term service quality more than processor generation alone.

Final Thoughts

Switzerland's datacenter industry has built its reputation through infrastructure quality rather than marketing noise.

Strong facility engineering, dependable power systems, extensive connectivity, and disciplined operational practices make it a compelling location for dedicated servers and critical workloads.

For developers, infrastructure teams, and businesses deploying services across Europe, understanding these fundamentals can lead to better hosting decisions and more reliable applications.

Because ultimately, users don't care where your servers are located.

They care whether your application works when they need it.

Infrastructure determines how often that happens.

Originally published on HostnExtra.

HostnExtra focuses on dedicated server infrastructure, networking, and performance-focused hosting across multiple global locations.

Read the full version:

Switzerland Datacenter Infrastructure: Facilities, Power, and Connectivity - HostnExtra

Learn how Switzerland's datacenter infrastructure delivers reliable power, strong connectivity, and modern facilities for dedicated servers, cloud platforms, and business-critical applications.

hostnextra.com

Why London Remains a Top-Tier Dedicated Server Location for Developers and Infrastructure Teams

HostnExtra Technologies — Mon, 01 Jun 2026 15:01:13 +0000

When evaluating dedicated server locations, it's easy to get distracted by hardware specifications.

CPU generation, storage type, RAM capacity, and bandwidth allocations are easy to compare.

Network topology is harder to see.

But once applications reach scale, routing quality often becomes just as important as the hardware itself.

London is a good example.

The city hosts one of the world's most important interconnection ecosystems through LINX (London Internet Exchange), where more than 950 networks exchange traffic directly. Aggregate traffic has exceeded 12 Tbps during peak periods, making London one of the most connected internet hubs in Europe.

Why does this matter?

Because every unnecessary network hop introduces additional latency and routing complexity.

Direct peering relationships allow traffic to move between networks more efficiently, which can improve:

API response times
SaaS platform performance
CDN delivery efficiency
Multiplayer gaming latency
Replication between distributed systems
Hybrid cloud connectivity

London is also strategically positioned for organizations serving both European and North American users.

Many transatlantic routes intersect through London's carrier ecosystem, allowing providers to maintain strong connectivity in both directions.

From an infrastructure perspective, London offers several practical advantages:

Dense carrier availability
Mature data center ecosystems
Extensive peering opportunities
Strong cloud connectivity
Multiple transit options
Well-established international routing paths

One thing worth noting is that good infrastructure isn't only about where a server is physically located.

It's also about who surrounds that server.

A server sitting inside a highly connected ecosystem often delivers better real-world performance than similar hardware deployed in a less connected region.

That's the reason London continues to remain relevant despite the rapid growth of other European markets.

For developers, sysadmins, SaaS operators, and infrastructure teams, London is still one of the strongest locations available when network quality is a primary consideration.

Originally published on HostnExtra.

We regularly write about network architecture, dedicated server deployments, latency, routing, peering, and global hosting infrastructure.

Read the full article:

https://hostnextra.com/learn/blog/london-dedicated-server-connectivity

Running Multiplayer Game Servers in Germany: Real-World Latency Across Europe

HostnExtra Technologies — Fri, 29 May 2026 04:46:34 +0000

When developers deploy multiplayer infrastructure in Europe, Germany is usually one of the first locations considered.

There is a practical reason for that beyond simple geography.

Germany, particularly Frankfurt, sits near a dense concentration of European carrier networks and internet exchange ecosystems. That creates relatively efficient routing paths across large portions of Europe.

For multiplayer workloads, this often produces balanced latency profiles for mixed regional player bases.

Typical European Latency Behavior

Actual latency depends on:

ISP routing
Transit providers
Congestion
Peering quality
Mitigation systems
Physical distance

But in general, properly connected German infrastructure often looks roughly like this:

Region Approximate Latency
Germany / Netherlands / Belgium 5-20ms
France / UK 20-35ms
Scandinavia 25-45ms
Southern Europe 35-60ms

These numbers vary significantly depending on the provider.

People underestimate how much routing quality affects gameplay. Two servers inside Frankfurt can behave completely differently under real traffic conditions.

Why Stable Routing Matters More Than Low Ping Marketing

A lot of hosting advertisements obsess over “ultra-low latency.”

In practice, multiplayer performance depends more on:

Jitter consistency
Packet delivery stability
Congestion handling
Upstream quality
Mitigation behavior under load

A stable 40ms connection is usually preferable to unstable low-latency routes with spikes and packet loss.

This becomes very noticeable in:

FPS games
Tickrate-sensitive workloads
Voice-heavy environments
Real-time PvP synchronization

Average ping alone does not tell the whole story.

Dedicated Servers vs VPS for Game Hosting

Smaller communities often begin on VPS infrastructure, which is fine initially.

Problems usually appear when workloads become sustained or player counts increase.

Shared environments can introduce:

CPU contention
Disk variability
Resource throttling
Scheduling inconsistencies

Dedicated servers avoid many of these issues by giving workloads isolated hardware access.

This becomes especially useful for games like:

Minecraft
Rust
ARK
CS2
FiveM
Factorio

Many of these workloads are heavily sensitive to single-core performance and sustained CPU availability.

DDoS Mitigation Is Mandatory

Public game servers eventually attract attack traffic.

Good mitigation systems should preserve routing stability while filtering malicious packets. Poor mitigation can actually worsen gameplay through excessive filtering overhead or unstable rerouting behavior.

Important considerations include:

Always-on filtering
Upstream mitigation capacity
Clean packet forwarding
Low additional latency overhead
Stable routing during attacks

Final Thoughts

Germany remains one of the strongest European deployment locations because it balances reachability across multiple regions reasonably well.

But location alone does not create good multiplayer performance.

Infrastructure quality ultimately depends on:

Network engineering
Transit quality
Hardware consistency
Routing stability
Operational discipline

The networking layer is usually where good multiplayer hosting succeeds or fails.

Originally published on HostnExtra.

If you're working on latency-sensitive infrastructure, multiplayer hosting, or dedicated server deployments, we publish deeper infrastructure-focused articles here:

https://hostnextra.com/blog

Install NetBox on Ubuntu 22.04 - HostnExtra

HostnExtra Technologies — Wed, 19 Oct 2022 13:01:08 +0000

In this article, we'll explain how to install NetBox on Ubuntu 22.04. This will guide you with the installation and configuration process.

NetBox is an infrastructure resource modeling (IRM) application designed to empower network automation. NetBox was developed specifically to address the needs of network and infrastructure engineers. It is intended to function as a domain-specific source of truth for network operations.

NetBox runs as a web application atop the Django Python framework with a PostgreSQL database.

Prerequisites:

A Ubuntu 22.04 installed KVM VPS or dedicated server.
A root user access or normal user with administrative privileges

Install NetBox on Ubuntu 22.04

1. Keep the server up to date

# apt update -y && apt upgrade -y

2. Install and Configure PostgreSQL Database

We'll install and configure a local PostgreSQL database.

Note: NetBox requires PostgreSQL 9.6 or higher. Please note that MySQL and other relational databases are not currently supported.

Install PostgreSQL database using following command:

# apt install -y postgresql libpq-dev

Next, we need to create a database for NetBox and assign it a username and password for authentication.

# sudo -u postgres psql

postgres=# CREATE DATABASE netbox;

CREATE DATABASE

postgres=# CREATE USER netbox WITH PASSWORD 'r5t6^7$%gyuuyt4';

CREATE ROLE

postgres=# GRANT ALL PRIVILEGES ON DATABASE netbox TO netbox;

GRANT

postgres=# \q

3. Install Redis

Redis is an in-memory key-value store which NetBox employs for caching and queuing. Use following command to install Redis:

# apt install redis-server -y

Use the redis-cli utility to ensure the Redis service is functional:

# redis-cli ping

PONG

4. Install and Configure NetBox

There are two ways to install NetBox.

Download a Release Archive
Clone the Git Repository

We'll install NetBox by cloning the Git repository.

First, install required packages and its dependencies:

# apt install -y python3 python3-pip python3-venv python3-dev build-essential libxml2-dev libxslt1-dev libffi-dev libpq-dev libssl-dev zlib1g-dev

Update pip (Python's package management tool) to its latest release:

# pip3 install --upgrade pip

Create the base directory /opt/netbox for the NetBox installation.

# mkdir -p /opt/netbox/ && cd /opt/netbox/

Next, clone the master branch of the NetBox GitHub repository into the current directory.

# git clone -b master https://github.com/netbox-community/netbox.git .

Create a system user account named netbox. We'll configure the WSGI and HTTP services to run under this account. We'll also assign this user ownership of the media directory.

# adduser --system --group netbox

# chown --recursive netbox /opt/netbox/netbox/media/

Move into the NetBox configuration directory and make a copy of configuration.example.py named configuration.py.

# cd /opt/netbox/netbox/netbox/

# cp configuration_example.py configuration.py

Create a symbolic link of Python binary.

# ln -s /usr/bin/python3 /usr/bin/python

Generate a random SECRET_KEY of at least 50 alphanumeric characters.

# /opt/netbox/netbox/generate_secret_key.py

Above command will create a secret key, store it so that we can use it in the configuration.py.

Open and edit the configuration file configuration.py.

# nano /opt/netbox/netbox/netbox/configuration.py

The final file should have the following configurations.

ALLOWED_HOSTS = ['*']

DATABASE = {
'NAME': 'netbox', # Database name you created
'USER': 'netbox', # PostgreSQL username you created
'PASSWORD': 'r5t6^7$%gyuuyt4', # PostgreSQL password you set
'HOST': 'localhost', # Database server
'PORT': '', # Database port (leave blank for default)
}

SECRET_KEY = 'YOUR SECRET KEY'

Note:

You can add your domain or server IP in ALLOWED_HOSTS = [''] or you can simple enter "*" for all.

Once NetBox has been configured, we're ready to proceed with the actual installation.

We'll run the packaged upgrade script (upgrade.sh) to perform the following actions:

Create a Python virtual environment
Install all required Python packages
Run database schema migrations
Aggregate static resource files on disk

# /opt/netbox/upgrade.sh

Enter the Python virtual environment created by the upgrade script:

# source /opt/netbox/venv/bin/activate

Create a superuser account using the createsuperuser

# cd /opt/netbox/netbox

# python3 manage.py createsuperuser

Output:

Email address: admin@example.com

Password:

Password (again):

Superuser created successfully.

Note:

Remember the username and password. It will require once we finish the installation process to login.

5. Configure Gunicorn

NetBox ships with a default configuration file for gunicorn. To use it, copy /opt/netbox/contrib/gunicorn.py to /opt/netbox/gunicorn.py.

# cp /opt/netbox/contrib/gunicorn.py /opt/netbox/gunicorn.py

Copy contrib/netbox.service and contrib/netbox-rq.service to the /etc/systemd/system/ directory and reload the systemd dameon:

# cp -v /opt/netbox/contrib/*.service /etc/systemd/system/

# systemctl daemon-reload

Start and enable the netbox and netbox-rq services:

# systemctl start netbox netbox-rq

# systemctl enable netbox netbox-rq

6. Configure Nginx Web Server

Install Nginx web server using following command:

# apt install -y nginx

Copy the nginx configuration file provided by NetBox to /etc/nginx/sites-available/netbox.

# cp /opt/netbox/contrib/nginx.conf /etc/nginx/sites-available/netbox

Edit the netbox configuration file and remove all the content and copy paste below contents:

# nano /etc/nginx/sites-available/netbox

Remember to change server_name.

server {
listen 80;

# CHANGE THIS TO YOUR SERVER'S NAME
server_name 127.0.0.1;

client_max_body_size 25m;

location /static/ {
alias /opt/netbox/netbox/static/;
}

location / {
proxy_pass http://127.0.0.1:8001;
proxy_set_header X-Forwarded-Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-Proto $scheme;
}
}

Then, delete /etc/nginx/sites-enabled/default and create a symlink in the sites-enabled directory to the configuration file you just created.

# rm /etc/nginx/sites-enabled/default

# ln -s /etc/nginx/sites-available/netbox /etc/nginx/sites-enabled/netbox

Note:

Above Nginx code will give you error if you use as it is, because it mentioned SSL configuration too. You need to install SSL after the above commands.

Please refer our How to Install Let’s Encrypt on Nginx Ubuntu article to install SSL certificate.

Now test Nginx configuration and restart the Nginx service:

# nginx -t

# systemctl restart nginx

That's it we have successfully completed with the installation and configuration process.

Navigate to your browser and access NetBox with using either server IP or domain name.

In this article, we've seen how to install NetBox on Ubuntu 22.04.

Install Caddy on Ubuntu 22.04 - HostnExtra

HostnExtra Technologies — Tue, 18 Oct 2022 17:26:33 +0000

In this article, we’ll explain you how to install Caddy on Ubuntu 22.04. This article will guide you with the installation process and host a website.

The Caddy web server is an open-source web server written in Go. It is designed around simplicity and security that comes with a number of features that are useful for hosting websites. Caddy is both a flexible, efficient static file server and a powerful, scalable reverse proxy.

Prerequisites

A Ubuntu install dedicated server or KVM VPS.
A root user access or normal user with administrative privileges.

Install Caddy on Ubuntu 22.04

1. Keep the server up to date

# apt update -y && apt upgrade -y

WWWW2. Install Caddy

Following command will install and automatically starts and runs Caddy for you as a systemd service named caddy using our official caddy.service unit file.

Install dependencies:

# sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https

First, add GPG key using following command:

# curl -1sLf ‘https://dl.cloudsmith.io/public/caddy/stable/gpg.key’ | sudo gpg –dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg

Next, add repository and update it:

# curl -1sLf ‘https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt’ | sudo tee /etc/apt/sources.list.d/caddy-stable.list

# apt update

Finally, install Caddy using following command:

# apt install caddy

Now, navigate to your browser and enter your server IP or domain name:

http://Server-IP

http://example.com

Install Caddy on Ubuntu

3. Configure Domain with Caddy

Before moving following, first set up domain’s A/AAAA DNS record at your registrar or control panel.

Note: Replace hostnextra.com with your domain name

Create a directory for your website files

# mkdir -p /var/www/html/hostnextra.com

Next, if you are using SELinux than you need to change the file security context for web content. (Optional)

# chcon -t httpd_sys_content_t /var/www/html/hostnextra.com -R
# chcon -t httpd_sys_rw_content_t /var/www/html/hostnextra.com -R

Now, open Caddy’s configuration file and add your domain name and change website’s root directory.

# nano /etc/caddy/Caddyfile

Change the site root to /var/www/html/hostnextra.com (write your website path) as

install Caddy HostnExtra

Note:

If you want to use SSL, you need to mention :443 SSL port and also install SSL certificate.

You can run caddy trust command to install SSL local certificate. We’ve not tested it yet. If we perform it in future, we’ll update the tutorial. You can check the official document about Automatic HTTPS for more information.

Once you done with the changes reload the caddy.service to reflect the changes.

# systemctl reload caddy

Now, create a index.html file in /var/www/html/hostnextra.com using following command:

# echo ‘<!doctype html><head><title>Hello from Caddy!</title></head><body><h1 style=”font-family: sans-serif”>This page is being served via Caddy</h1></body></html>’ | sudo tee /var/www/html/hostnextra.com/index.html

Finally, refresh the page in your browser and you will see our newly created index.html.

In this article, we have seen how to install Caddy on Ubuntu 22.04.

Install Snipe-IT on Ubuntu 22.04 - HostnExtra

HostnExtra Technologies — Mon, 17 Oct 2022 12:14:14 +0000

In this article, we'll explain how to install Snipe-IT on Ubuntu 22.04.

Snipe-IT was made for IT asset management, to enable IT departments to track who has which laptop, when it was purchased, which software licenses and accessories are available, and so on. Snipe-IT is a open-source IT asset management and it eliminates the need for complex IT asset tracking spreadsheets.

Prerequisites:

An Ubuntu 22.04 installed dedicated server or KVM VPS.
A root user access or normal user with administrative privileges.

Install Snipe-IT on Ubuntu 22.04

1. Update the server and install dependencies:

# sudo apt update -y && apt upgrade -y

Install unzip dependency

# sudo apt-get install unzip git -y

2. Install Apache Webserver

# sudo apt install apache2 -y

In case, you enabled firewall and firewall block requests of the apache web server, open a port in the firewall.

# sudo ufw allow 80/tcp

# sudo ufw allow 443/tcp

# sudo ufw reload

Now, let's verify the Apache installation. Open browser and test default page.

http://[SERVER IP]

Enable Apache's mod_rewrite module. Snipe-IT requires this extension to rewrite URLs more cleanly.

# sudo a2enmod rewrite

Restart your Apache web server to apply the changes.

# sudo systemctl restart apache2

3. Install MariaDB

# sudo apt install mariadb-server mariadb-client -y

The default configuration of the MariaDB will not be secured. Let's secured the installation using the following command:

# sudo mysql_secure_installation

Once the script gets executed, it will ask multiple questions.

It will ask you to enter the current password for root (enter for none):

Then enter yes/y to the following security questions:

Set a root password? [Y/n]: y
Remove anonymous users? : y
Disallow root login remotely? : y
Remove test database and access to it? : y
Reload privilege tables now? : y

4. Install PHP and PHP Composer

Here we are installing the default PHP version 8.1 and other modules for web deployments using the following command:

# sudo apt install php php-common php-bcmath php-bz2 php-intl php-gd php-mbstring php-mysql php-zip php-opcache php-intl php-json php-mysqli php-readline php-tokenizer php-curl php-ldap -y

Install PHP Composer, which is a PHP dependency management tool to install and update libraries in your Snipe-IT.

Download the Composer installer.

# sudo curl -sS https://getcomposer.org/installer | php

Move the composer.phar executable to /usr/local/bin/.

# sudo mv composer.phar /usr/local/bin/composer

5. Create a Database

Create a database and database user for Snipe-IT. First login into MySQL/MariaDB as a root user.

# sudo mysql -u root -p

Run following commands to perform this task:

CREATE DATABASE snipe_it;
CREATE USER 'snipe_it_user'@'localhost' IDENTIFIED BY 'EXAMPLE_PASSWORD';
GRANT ALL PRIVILEGES ON snipe_it.* TO 'snipe_it_user'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Note: Replace snipe_it_user to your choice username and replace EXAMPLE_PASSWORD to you choice password.

6. Install Snipe-IT

Navigate to the root directory of your web server.

# cd /var/www/

Use git to clone the latest Snipe-IT repository from the https://github.com/snipe/snipe-it URL and copy the downloaded files to a snipe-it directory.

# sudo git clone https://github.com/snipe/snipe-it snipe-it

Switch to the snipe-it directory.

# cd snipe-it

Snipe-IT ships with a sample configuration file. Copy it to /var/www/snipe-it/.env.

# sudo cp /var/www/snipe-it/.env.example /var/www/snipe-it/.env

Edit the configuration file.

# sudo nano /var/www/snipe-it/.env

In the Snipe-IT configuration file, locate these settings.

APP_URL=null
APP_TIMEZONE='UTC'

Set APP_URL to your server's Fully Qualified Domain Name, or it's public IP address. If you use a time zone other than UTC, change the timezone to a PHP-supported timezone, and enclose it in single quotes.

APP_URL=example.com
APP_TIMEZONE='America/New_York'

Locate these settings.

DB_DATABASE=null
DB_USERNAME=null
DB_PASSWORD=null

Change those values to the database information you set up in Step 3.

DB_DATABASE=snipe_it
DB_USERNAME=snipe_it_user
DB_PASSWORD=EXAMPLE_PASSWORD

Save and close the file.

Install the Snipe-IT dependencies with Composer. You'll receive a warning not to run this as root on each command. It's okay to continue as root for the Snipe-IT install, so type yes and hit ENTER.

# composer update --no-plugins --no-scripts

# composer install --no-dev --prefer-source --no-plugins --no-scripts

Set the correct ownership and permission for the Snipe-IT data directory.

# sudo chown -R www-data:www-data /var/www/snipe-it
# sudo chmod -R 777 storage

Once the Composer finishes running, generate a Laravel APP_Key value in the /var/www/snipe-it/.env configuration file you created earlier. Type yes and hit ENTER when prompted to continue.

# sudo php artisan key:generate

7. Create a Virtual Host File

First we'll disable default Apacheconf file and create new vhost conf file.

Disable the default Apache configuration file.

#sudo a2dissite 000-default.conf

Create a new Apache configuration file.

# sudo nano /etc/apache2/sites-available/snipe-it.conf

Paste the information below and replace example.com with your server's domain name or public IP address.

<VirtualHost *:80>
ServerName example.com
DocumentRoot /var/www/snipe-it/public
<Directory /var/www/snipe-it/public>
Options Indexes FollowSymLinks MultiViews
AllowOverride All
Order allow,deny
allow from all
</Directory>
</VirtualHost>

Save and exit the file.

Enable your new configuration file.

# sudo a2ensite snipe-it.conf

Restart your Apache web server to apply the changes.

# sudo systemctl restart apache2

8. Run the Setup Wizard

Navigate to your browser and access the setup wizard using your server IP or domain name you have mentioned in vhost conf file.

Once you complete the setup wizar your will redirect to dashbord

In this article, we have seen how to install Snipe-IT on Ubuntu 22.04.

Install CouchDB on Ubuntu 22.04 - HostnExtra

HostnExtra Technologies — Thu, 13 Oct 2022 13:47:32 +0000

In this article, we'll explain how to install CouchDB on Ubuntu 22.04 and configure it with Nginx proxy server and Certbot SSL.

Apache CouchDB is an open-source document-oriented NoSQL database, implemented in Erlang. Seamless multi-master sync, that scales from Big Data to Mobile, with an Intuitive HTTP/JSON API and designed for Reliability. Store your data safely, on your own servers, or with any leading cloud provider. Your web- and native applications love CouchDB, because it speaks JSON natively and supports binary data for all your data storage needs.

Prerequisites:

A Ubuntu 22.04 installed dedicated server or KVM VPS with root or non-root access (for non-root, use "sudo").
A DNS A record that points your domain to the public IP address of the server.

Let's start with the installation process

Install CouchDB on Ubuntu

1. Update the server and install dependency

# sudo apt update && sudo apt install -y curl apt-transport-https gnupg

2. Configure the CouchDB repository and key.

# curl https://couchdb.apache.org/repo/keys.asc | gpg --dearmor | sudo tee /usr/share/keyrings/couchdb-archive-keyring.gpg >/dev/null 2>&1
# echo "deb [signed-by=/usr/share/keyrings/couchdb-archive-keyring.gpg] https://apache.jfrog.io/artifactory/couchdb-deb/ ${VERSION_CODENAME} main" | sudo tee /etc/apt/sources.list.d/couchdb.list >/dev/null
# sudo apt update

Note:

If you get following error, edit couchdb.list and add jammy before main. It will resolve it.

E: Malformed entry 1 in list file /etc/apt/sources.list.d/couchdb.list (Component)
E: The list of sources could not be read

3. Install CouchDB

# sudo apt install -y couchdb

The installation will ask few question.

1. standalone 2. clustered 3. none
General type of CouchDB configuration: 1

Choose according to your choice. We have select 1 for this demonstration purpose.

A CouchDB node has an Erlang magic cookie value set at startup.

This value must match for all nodes in the cluster. If they do not match, attempts to connect the node to the cluster will be rejected.

CouchDB Erlang magic cookie: monkey

Set the Erlang Magic Cookie. This is a unique identifier to authenticate for your cluster, all nodes must have the same cookie. Here we have wrote monkey. You can write anything you want.

The default is 127.0.0.1 (loopback) for standalone nodes, and 0.0.0.0 (all interfaces) for clustered nodes. In clustered mode, it is not allowed to bind to 127.0.0.1.

CouchDB interface bind address: 0.0.0.0

Add bind address as 0.0.0.0

A pre-existing admin user will not be overwritten by this package.

Password for the CouchDB "admin" user:

Repeat password for the CouchDB "admin" user:

Here add admin password as per your choice.

The installation has been completed successfully. Navigate to browser and open http://:5984/_utils/

4. Configure Nginx

Now, let's configure Nginx proxy. Install Nginx using following command:

# sudo apt-get install -y nginx apache2-utils

Remove default Nginx config file, we'll create our own config file.

# sudo rm -rf /etc/nginx/sites-enabled/default

Now create a new config file

# nano /etc/nginx/sites-available/couchdb-site

Add following content:

server {
listen 80 default_server;
server_name coachdb.local;

location / {
proxy_pass http://localhost:5984;
proxy_redirect off;

proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;

}

}

Note:

For security reason, you can change the default http 80 port to something else like 5000. So to access it you need to mention 5000 port at the end of website name. But it may create conflict with SSL. We've not test different port with SSL.

Now, create a symbolic link and restart Nginx service using following command:

# ln -s /etc/nginx/sites-available/couchdb-site /etc/nginx/sites-enabled/
# nginx -t
# systemctl restart nginx

5. Configure Firewall

Enable UFW if its not enabled.

# ufw enable

Add following ports:

# ufw allow 22/tcp

# ufw allow 80/tcp

# ufw allow 443/tcp

# ufw allow 5984/tcp

Check the status:

# ufw status

Note:

Your SSH port might be different.
If you have custom Nginx web server port, add that port also.

6. Install certbot's nginx package

# apt install certbot python3-certbot-nginx -y

7. Obtaining a Certificate

Obtain a certificate using certbot command. The Nginx plugin will take care of reconfiguring Nginx and reloading the config.

# certbot --nginx -d yoursite.com -d www.yousite.com

By running certbot first time, you will be prompted to enter an email address and agree to the terms of service.

That's it, we have successfully install CouchDB on Ubuntu 22.04 and configured it with Nginx proxy server and Certbot SSL.