When developing web applications locally, we often need to map custom domains to specific port numbers (like 127.0.0.1:3000). The standard hosts file doesn't support port specification in its entries, leading developers to seek alternative solutions.

The /etc/hosts file (or Windows equivalent) only handles hostname-to-IP resolution at the DNS level. Port specification belongs to the application layer, which is why this format fails:

127.0.0.1:3000 example.dev  # Doesn't work

1. Reverse Proxy Setup

Configure Nginx or Apache to route traffic based on hostname:

# Nginx configuration example
server {
    listen 80;
    server_name example.dev;
    
    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
    }
}

2. Local DNS Server

For advanced setups, run a local DNS server like dnsmasq:

# dnsmasq configuration
address=/example.dev/127.0.0.1
server=/example.dev/127.0.0.1#3000

3. Browser Extensions

Tools like "Redirector" for Chrome can rewrite URLs:

• Pattern: ^http://example.dev/*
• Redirect to: http://example.dev:3000$1

Docker-Compose Approach

version: '3'
services:
  app:
    image: your_app_image
    ports:
      - "3000:3000"
    networks:
      - app-network

  nginx:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

Hosts File + Port Forwarding

On Unix-like systems, use socat for port forwarding:

socat TCP-LISTEN:80,fork TCP:localhost:3000 &

For public-facing applications, consider these DNS record types:

• SRV records (for service discovery)
• CNAME with port specification (limited support)
• API Gateway configurations

Always verify your configuration works with:

nslookup example.dev
curl -v http://example.dev
telnet example.dev 80

---

When developers need to redirect traffic to specific ports (like localhost:3000 during development), they often face limitations with standard DNS resolution. The /etc/hosts file doesn't support port specifications in its basic form, requiring alternative approaches.

The traditional hosts file format only supports IP-to-hostname mapping:

# Basic format (no port support)
127.0.0.1   example.com

1. Using Reverse Proxies

Configure Nginx to handle port redirection:

server {
    listen 80;
    server_name example.com;
    
    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
    }
}

2. Local DNS Server with SRV Records

For advanced local development setups:

; BIND zone file example
_http._tcp.example.com. IN SRV 0 0 3000 localhost.

3. Browser Extensions for Development

Extensions like "Redirector" for Chrome can modify requests:

Pattern: ^http://example.com/*
Redirect to: http://localhost:3000$1

MacOS Network Extension

Create a network location with custom resolver:

scutil << EOF
get State:/Network/Service/generated/resolver
d.add ServerAddresses * 127.0.0.1:3000
set State:/Network/Service/generated/resolver
EOF

Windows Hosts File Alternative

Using netsh for port forwarding:

netsh interface portproxy add v4tov4 listenport=80 listenaddress=127.0.0.1 connectport=3000 connectaddress=127.0.0.1

Example Node.js script to handle dynamic routing:

const http = require('http');
const httpProxy = require('http-proxy');

const proxy = httpProxy.createProxyServer({});

http.createServer((req, res) => {
    if(req.headers.host === 'example.com') {
        proxy.web(req, res, { target: 'http://localhost:3000' });
    }
}).listen(80);

• Always use proper reverse proxies in production
• Consider cloud load balancers for port-based routing
• Implement proper health checks when routing between ports