The internet today is crawling with bots—some helpful, most not. Whether it’s AI scrapers harvesting public data or malicious bots launching DDoS attacks, websites are under constant pressure to defend their content. Enter Anubis: a clever, open-source web firewall that uses Proof-of-Work (PoW) to filter out bots while letting real users through with minimal friction.

Let’s unpack how it works—and how to deploy it with Docker and Nginx.

What Is Anubis?

At its core, Anubis is a PoW gateway. It sits in front of your website and challenges each visitor with a lightweight computational puzzle before letting them through.

The concept is simple but effective: bots that don’t execute JavaScript (like most scrapers or AI crawlers) can’t pass the challenge. Even those that do will find it expensive to scale.

How It Works (Step by Step)

Here’s what happens when someone visits a site protected by Anubis:

1. User requests a page.
2. Anubis intercepts the request as a reverse proxy.
3. It serves a small HTML page with embedded JavaScript containing a Proof-of-Work challenge.
4. Browser solves the challenge in a second or two, generating a token.
5. The browser resubmits the request with the token, and Anubis lets them through.

This slows down bots significantly while being nearly invisible to human users.

Why It Works

Bots and crawlers typically skip JavaScript. That means:

• They can’t pass the PoW challenge.
• Even if they try, solving the challenge repeatedly becomes computationally expensive.

For humans: it’s just a couple of seconds. For bots: it’s a serious headache.

Real-World Adoption

Anubis is already being used by high-traffic, open-source projects like:

• Arch Wiki
• GNOME
• WineHQ
• FFmpeg
• UNESCO

These communities needed something robust, lightweight, and self-hosted. Anubis delivered.

Quick Start with Docker

Anubis is available as a Docker image at:

ghcr.io/techarohq/anubis

Available Tags

Docker Compose Example

Here’s a quick way to run Anubis using Docker Compose:

services:
  anubis:
    image: ghcr.io/techarohq/anubis:latest
    container_name: anubis
    restart: unless-stopped
    ports:
      - "8080:8080" # Anubis listens on port 8080 by default
    volumes:
      - ./config:/etc/anubis
    environment:
      - ANUBIS_CONFIG=/etc/anubis/anubis.toml
    user: "1000:1000"

Important: Make sure the mounted ./config directory is owned by UID/GID 1000, or is writable by that user.

System Requirements

Anubis is very efficient:

• ~128MiB RAM is enough for many use cases.
• Ideal for HTTP traffic.
• May not be suited for long-lived connections like WebSockets (TBD in real-world use).

Nginx Reverse Proxy Config

Once Anubis is running, you’ll want to route traffic through it. Here’s a basic Nginx config to pass requests through Anubis and then upstream to your real site:

server {
    listen 80;
    server_name yoursite.com;

    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

You can also put Anubis in front of another reverse proxy (like Nginx ➜ Anubis ➜ App), depending on your network layout.

Why Choose Anubis?

• Open-source and fully self-hostable
• No CAPTCHAs, no third-party cloud services
• Blocks scrapers and AI bots reliably
• Works great with Docker, Nginx, and minimal hardware
• Community-tested and battle-hardened

Final Thoughts

In an age of aggressive AI scraping and relentless bots, Anubis offers a refreshingly simple and effective shield. By making abuse computationally expensive and annoying for bots—but nearly invisible to humans—Anubis flips the script and puts the burden back where it belongs.

You can try a live demo at anubis.techaro.lol or start deploying right away using the official GitHub repo.

The post How Anubis Works: Fighting Bots with Proof-of-Work appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

What Is code-server?

code-server is an open-source project developed by Coder that allows you to run VS Code on a remote server and access it through a web browser. This setup provides a consistent development environment that can be accessed from any device, be it a laptop, tablet, or even a smartphone. By leveraging the power of cloud servers, code-server enables faster tests, compilations, and downloads, all while preserving your local device’s resources.

Key Features of code-server

• VS Code in the Browser: Experience the full functionality of VS Code, including IntelliSense, debugging, and Git integration, all within your browser.
• Remote Development: Develop on powerful cloud servers, reducing the load on your local machine and enabling resource-intensive tasks.
• Consistent Environment: Maintain a uniform development setup across different devices, ensuring consistency and reducing the “it works on my machine” problem.
• Extension Support: Install and use most VS Code extensions, enhancing your development workflow.
• Secure Access: Access your development environment securely from anywhere, with options for HTTPS and authentication.

Installation Guide

Setting up code-server is straightforward. The easiest way to install code-server is to use the official install script, which automates most of the process. This script attempts to use the system package manager if possible.

For Linux, macOS, and FreeBSD:

Run the following command in your terminal:

curl -fsSL https://code-server.dev/install.sh | sh

After installation, you can start code-server by running:

code-server

By default, code-server will be accessible at http://127.0.0.1:8080, and your password will be stored in ~/.config/code-server/config.yaml.

For Docker Users:

You can also run code-server in a Docker container:

docker run -it --name code-server -p 127.0.0.1:8080:8080 \
  -v "$HOME/.local:/home/coder/.local" \
  -v "$HOME/.config:/home/coder/.config" \
  -v "$PWD:/home/coder/project" \
  -u "$(id -u):$(id -g)" \
  -e "DOCKER_USER=$USER" \
  codercom/code-server:latest

This command mounts your current directory into the container and forwards your UID/GID so that all file system operations occur as your user outside the container.

Securing Your code-server Instance

To expose code-server securely to the internet, consider the following methods:

• Port Forwarding via SSH: If you have an SSH server on your remote machine, you can forward local ports to access code-server securely.
• Using Let’s Encrypt with Caddy or NGINX: For a more robust solution, you can set up HTTPS using Let’s Encrypt with web servers like Caddy or NGINX.
• Self-Signed Certificates: For internal use or testing, you can generate and use self-signed certificates to enable HTTPS.

These methods ensure that your code-server instance is accessible securely from anywhere.

Keeping code-server Up-to-Date

To ensure you have the latest features and security patches, it’s important to keep code-server updated. You can check for the latest releases on the GitHub Releases Page. To update, simply run the install script again:

curl -fsSL https://code-server.dev/install.sh | sh

This will download and install the latest version of code-server.

Final Thoughts

code-server empowers developers by providing a powerful, browser-based development environment that can be accessed from anywhere. Whether you’re working from a laptop, tablet, or smartphone, code-server ensures that you have a consistent and secure development setup at your fingertips.

By leveraging cloud servers, code-server enables faster development cycles and reduces the load on local machines, making it an ideal solution for modern development workflows.

The post code-server: Unlocking the Power of VS Code in Your Browser appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In the landscape of modern software development and IT operations, Docker has emerged as a game-changer. Whether you’re a developer, system administrator, or a DevOps engineer, Docker empowers you to build, ship, and run applications seamlessly — across your laptop, on-premise servers, or the cloud. This blog post will dive deep into Docker’s origin, its practical uses, key commands you need to know, advantages, and provide a hands-on example to get you started.

The Origin and History of Docker

Docker’s roots trace back to 2010 when a company named dotCloud, a platform-as-a-service (PaaS) provider, started experimenting with Linux container technology to better isolate and manage applications.

• March 2013: Docker was launched as an open-source project by Solomon Hykes, the CTO of dotCloud.
• Why it stood out: Docker made Linux containers accessible to developers through simple commands, standard image formats, and tooling that abstracted away complex underlying tech like LXC, cgroups, and namespaces.
• Growth: Docker quickly captured the attention of the tech community and companies worldwide. It transformed from an internal tool to the foundation of a whole ecosystem involving container registries (Docker Hub), orchestration tools (Docker Swarm, Kubernetes), and developer workflows.

Today, Docker Inc. continues to innovate with products designed for enterprise container management, security, and cloud-native development.

What Is Docker and Why Should You Care?

At its core, Docker is a containerization platform that packages your application and all its dependencies — libraries, system tools, and settings — into a single container. This container can run consistently across any environment that supports Docker, eliminating the infamous “it works on my machine” problem.

Why containers?

Before containers, virtualization was the go-to method to isolate applications — think Virtual Machines (VMs). But VMs require a full guest OS, which consumes more disk space, memory, and CPU.

Containers are lightweight:

• Share the host OS kernel.
• Start almost instantly.
• Require less storage.

Use cases for Docker include:

• Development environment standardization: Developers can replicate production environments on local machines.
• Microservices deployment: Each service runs in its own container, independently scalable and maintainable.
• CI/CD pipelines: Automate builds and tests in isolated containers.
• Legacy app modernization: Containerize old apps to run on modern infrastructure.
• Cloud migration: Easily move workloads across public clouds or hybrid setups.

Essential Docker Commands You Must Know

Here’s a handy list of Docker commands that cover basic to intermediate tasks:

Advantages of Using Docker

1. Portability and Consistency

Docker containers encapsulate everything needed to run your app, ensuring consistent behavior across development, staging, and production — regardless of where the container runs.

2. Lightweight

Containers share the OS kernel and don’t require running a full guest OS, saving CPU, memory, and storage compared to VMs.

3. Faster Deployment

Containers start almost instantly (in seconds), accelerating development cycles and scaling capabilities.

4. Isolation and Security

Containers provide process-level isolation, which helps prevent conflicts between apps running on the same host.

5. Simplified Dependency Management

No need to install or configure software dependencies on your host; they’re baked into the container image.

6. Vibrant Ecosystem

With Docker Hub, users have access to thousands of ready-to-use container images. The active community continually develops tools and resources.

7. Improved Resource Utilization

Multiple containers can run efficiently on a single host, making better use of hardware resources.

A Simple Docker Example: Running a Hello World Web Server

Let’s walk through a practical example so you can experience Docker firsthand.

Step 1: Install Docker

Make sure Docker is installed on your system. You can find official installation guides on docker.com.

Step 2: Run a prebuilt web server container

Open your terminal and run:

docker run -d -p 8080:80 --name hello-web nginx

What this does:

• docker run — Run a container.
• -d — Detached mode (runs container in the background).
• -p 8080:80 — Map port 8080 on your host to port 80 in the container.
• --name hello-web — Assign a name to the container.
• nginx — Use the official nginx web server image from Docker Hub.

Step 3: Access your web server

Open your browser and navigate to http://localhost:8080. You should see the default Nginx welcome page, meaning your container is up and running.

Step 4: Inspect the container

Check running containers:

docker ps

View container logs:

docker logs hello-web

Access the container shell:

docker exec -it hello-web /bin/bash

Inside, you can browse files, for example:

cat /usr/share/nginx/html/index.html

Step 5: Stop and remove the container

To stop:

docker stop hello-web

To remove:

docker rm hello-web

Conclusion

Docker has revolutionized software development and IT operations by making container technology accessible, portable, and scalable. It simplifies dependency management, accelerates deployment, and ensures your applications behave the same everywhere — a crucial advantage in today’s fast-moving development world.

This example only scratches the surface of Docker’s power. From building your own container images to orchestrating complex multi-container applications with Docker Compose or Kubernetes, Docker opens up a world of possibilities.

If you want to master modern software workflows, learning Docker is a must.

The post Docker: The Container Revolution That Changed Software Development Forever appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.