First, you need a hypervisor, then a compatible ISO file, followed by VM configuration, partitioning, Windows installation, driver setup, and so on. In short: It’s doable, but not exactly pleasant.

But what if I told you that you could launch a full Windows installation inside a Docker container—with shared storage, RDP access, and optional VLAN support? Sounds crazy? It kind of is. But it works.

The Idea Behind the Project

A developer named Kroese published a GitHub project that makes this possible. A Docker container that automatically sets up a fresh Windows installation—no manual setup required. Just start the container, wait a few minutes, and you get a fully functional Windows environment. Access it via your browser or RDP.

And the best part? You don’t even have to install Windows yourself. The container handles the entire process—from fetching the image to finalizing the setup.

How Does It Work Technically?

If you look closely at the Docker command, you’ll notice the flag passing through /dev/kvm—Linux’s kernel-based virtualization mechanism. In short: This isn’t a "true" Windows container but rather a Linux container running a KVM-based VM. So, no magic here—just clever automation built on proven technology.

The catch? Hardware virtualization must be available and enabled—otherwise, nothing will work.

The Biggest Advantage: Convenience

What makes this special isn’t technical innovation but the massive gain in convenience. The most tedious aspects of a Windows installation—partitioning, initial setup, language, and keyboard selection—are completely automated.

Yet, you still get all the benefits of a "normal" KVM-based VM: USB and SATA passthrough, adjustable CPU cores and RAM allocation, and even optional PCIe passthrough (though that’s probably better suited for dedicated VMs).

Everyday Use: RDP Instead of VNC

The container’s web interface uses VNC, which is fine for quick access—but it’s slow and doesn’t support audio. RDP is the better option here. The container forwards the RDP port by default, allowing easy remote access from macOS, Linux, or even another Windows machine.

With shared folders, you can also mount directories from the host system, making file transfers between Windows and Linux seamless. The default container allocates 2 CPU cores, 4 GB of RAM, and 64 GB of storage—all adjustable via environment variables.

Multiple Windows Versions? No Problem!

The container supports not just Windows 11 but older versions too—from XP to Server 2022. You can even use stripped-down variants like Tiny11 or Tiny10—or supply your own ISO. In one test, five Windows versions ran simultaneously: XP, Vista, 7, 10, and 11—all on an Intel N100 system drawing just 18W.

(Windows 8.1 refused to cooperate—but who misses it anyway?)

What About Licensing?

The Windows images come either directly from Microsoft (for newer versions) or from open sources like Bob Pony. Fresh installations are unactivated but run without restrictions for 30 days. For longer use, you’ll need a valid license key. According to the developer, the project itself contains no proprietary code and relies entirely on open-source components.

Verdict: Simple, Practical, Brilliant

Whether you need to quickly test Windows software, tinker with legacy systems, or run specialized tools like BIOS editors—this Docker project offers a sleek, hassle-free solution without major compromises. Of course, it’s no replacement for a high-performance VM with a dedicated GPU, but that’s not the goal.

What remains is an impressive example of what’s possible today with a bit of creativity and open standards—no installation headaches required.

And who knows? Maybe Windows XP will save your day yet again.

The post Windows in einem Docker-Container? Ja, wirklich! appeared first on Rhein-Ruhr-Informatik.

When using Cloudflare as a CDN and DDoS protection service, it acts as an intermediary between your website and its visitors. This means that by default, the IP address visible to your web server is the one belonging to Cloudflare, not the original visitor. This can create issues for logging, analytics, and security policies based on IP addresses. In this article, we will walk through the steps necessary to configure your Nginx server to properly log and use the real IP addresses of visitors when using Cloudflare, even within a Dockerized environment.

Understanding the Problem

When a visitor connects to your website through Cloudflare, the original IP address is masked by Cloudflare’s own IP. This helps in protecting your server from direct attacks, but it makes it difficult to identify the true visitor IP. To solve this issue, Cloudflare includes headers like X-Forwarded-For and CF-Connecting-IP , which contain the original IP of the client. Nginx, by default, does not use these headers, so additional configuration is needed.

Prerequisites

Before starting, ensure you have:

1. On Nginx server installed with the ngx_http_realip_module module enabled. This module is necessary to correctly handle the real IP headers.
2. A basic understanding of Nginx configuration and Docker.
3. Access to your server’s configuration files.

Step 1: Configuring Nginx to Use Real IP Headers

To make Nginx recognize the real IP from the headers provided by Cloudflare, you need to modify the configuration. First, ensure that the ngx_http_realip_module module is installed. This module is usually included in most Nginx installations by default.

Next, create a file named Cloudflare in the /etc/nginx/ directory with the following content:

set_real_ip_from 103.21.244.0/22;
set_real_ip_from 103.22.200.0/22;
...
real_ip_header CF-Verbindungs-IP;

http {
     include /etc/nginx/cloudflare;
     ...
}

This ensures that the real IP configuration is applied globally across all your server blocks.

Step 3: Logging Real IP Addresses

To include the original visitor IP in your logs, modify the log_format directive in your nginx.confto use the variables $http_cf_connecting_ip and $http_x_forwarded_for . For example:

log_format main '$remote_addr - $http_cf_connecting_ip [$time_local] "$request" '
    '$status $body_bytes_sent "$http_referer" '
    '"$http_user_agent" "$http_x_forwarded_for"';

This allows you to see both the Cloudflare IP and the original visitor IP in your logs.

Step 4: Applying the Changes

To apply the changes, test the Nginx configuration:

• For CentOS/RHEL:

nginx -t

• For Ubuntu:

service nginx restart

Step 5: Verifying the Configuration

Check your website and inspect the Nginx access and error logs (e.g., /var/log/nginx/access.log) to verify that the real visitor IPs are being logged correctly. This step is crucial to ensure that your configuration is working as expected.

Optional: Handling Real IP in a Dockerized Environment

If your web application runs inside a Docker container, you need to pass the real IP to the containerized application. Add the following line in your Nginx configuration, right after the fastcgi_pass directive:

fastcgi_param REMOTE_ADDR $http_x_real_ip;

This sets the $_SERVER['REMOTE_ADDR'] variable to the original IP in PHP-based applications.

Common Issues and Troubleshooting

1. Incorrect IP in Logs: Double-check that the Cloudflare IP ranges are up-to-date and that the real_ip_header directive is correctly set.
2. Nginx Configuration Errors: Use nginx -tto check for syntax errors in the configuration files before restarting Nginx.
3. Docker Networking Issues: Ensure that Docker’s network mode allows for correct IP forwarding.

Conclusion

By following the steps outlined in this article, you can ensure that your Nginx server, even when running inside Docker, correctly logs and uses the original visitor IP addresses provided by Cloudflare. This is essential for accurate logging, security configurations, and analytics. With proper configuration, you can leverage the benefits of Cloudflare’s protection without sacrificing the visibility of real user data.

The post Wie man eine echte IP über Cloudflare erhält – Nginx Reverse Proxy – Docker appeared first on Rhein-Ruhr-Informatik.