DEV Community

cited
cited

Posted on

I Have 24GB of Free ARM RAM and I Refuse to Waste It on Nginx

#seo #webdev

I spun up an Oracle Cloud free-tier instance, stared at the spec sheet — 4 ARM cores, 24GB RAM, 200 Mbps burst, $0/month — and immediately deployed a WordPress blog. Then I deleted it. That felt criminal.

Here's what I actually run on it now.

The Weird Part About This Spec

ARM + 24GB is an odd combo. Most ARM VMs are tiny. Most 24GB boxes cost money. Oracle accidentally built a machine that's genuinely interesting: enough RAM for in-memory workloads, an architecture that certain tools were built for, and datacenter-grade network latency you'll never get from a Raspberry Pi. You'd be insane to use it as a static file server.

5 Actually Interesting Use Cases

1. LLM Inference Node (Run Mistral 7B Locally-ish)

Mistral 7B quantized to Q4 fits in ~6GB of RAM. You have 24GB. llama.cpp has first-class ARM support and will use NEON SIMD intrinsics on your A1 cores without any flags. You get a private OpenAI-compatible API endpoint for pennies.

Why this spec: 24GB is the magic number — you can load the model and hold 4-8 concurrent request contexts in RAM without swap. 4 ARM cores handle inference at ~8-12 tok/s on Q4_K_M, totally usable for batch tasks.

Tool: llama.cpp + its built-in llama-server

  • wget the GGUF from HuggingFace, run cmake -DLLAMA_NATIVE=ON for ARM tuning
  • Start with ./llama-server -m mistral-7b-q4_k_m.gguf -c 4096 --host 0.0.0.0 --port 8080
  • Point any OpenAI SDK at http://your-ip:8080/v1 — drop-in replacement

Est. usage: ~6-8GB RAM idle, 60-80% CPU per request, drops back to 2% between calls.

2. Distributed Build Cache Server (Bazel / Turborepo)

Your CI pipeline rebuilds the same artifacts 40 times a day. A remote cache server fixes this. 4 cores handle concurrent cache reads/writes fine, and fat RAM means your hot artifact set lives in the page cache.

Why this spec: Build caches are read-heavy and latency-sensitive. Datacenter uplink (not your home ISP) means teammates in three time zones all get fast cache hits. The RAM acts as an enormous buffer — you rarely hit disk.

Tool: bazel-remote (has ARM Docker image) or Turborepo's turbo-remote-cache (Node)

  • docker run --platform linux/arm64 -p 8080:8080 -v /data/cache:/data buchgr/bazel-remote-cache
  • Add --remote_cache=http://your-ip:8080 to your .bazelrc
  • Lock it down with --remote_header=Authorization=Bearer <token>

Est. usage: ~1-2GB RAM, 20-30% CPU during peak CI hours, near idle otherwise.

3. Network-Wide DNS Sinkhole + Recursive Resolver

Pi-hole was designed for ARM. Running it in Oracle's datacenter means sub-5ms DNS resolution for anything pointing at it — faster than your ISP's resolver, no home hardware required. Stack Unbound behind it for full recursion (no upstream DNS logging).

Why this spec: ARM is Pi-hole's native habitat. The 24GB means you can load massive blocklists (10M+ domains) entirely in memory. Bonus: Oracle's network is globally peered, so recursive lookups resolve fast.

Tool: Pi-hole + Unbound

  • Install Pi-hole with curl -sSL https://install.pi-hole.net | bash
  • Install Unbound, configure it as Pi-hole's upstream at 127.0.0.1#5335
  • Point your router's DHCP DNS at the Oracle IP

Est. usage: ~512MB RAM, <5% CPU, essentially free.

4. Headless Browser Farm (Playwright / Puppeteer)

Each Chromium context eats ~200-300MB. With 24GB, you can run 60+ contexts before sweating. This is a serious scraping or E2E testing fleet. ARM-native Chromium builds exist and perform well.

Why this spec: RAM is the bottleneck for browser parallelism, full stop. 4 cores context-switch between browser processes fine — you're not CPU-bound until 30+ concurrent navigations.

Tool: Playwright with playwright-cluster or puppeteer-cluster

  • npx playwright install chromium --with-deps (handles ARM deps automatically)
  • Spin up a cluster: Cluster.launch({ concurrency: Cluster.CONCURRENCY_CONTEXT, maxConcurrency: 20 })
  • Expose over HTTP with a thin Express wrapper

Est. usage: ~8-12GB RAM at 20 concurrent contexts, 70-90% CPU during active crawls.

5. Data Pipeline Orchestrator (Prefect / Dagster)

Self-hosting Prefect server or Dagster's webserver + daemon on this box costs you nothing and replaces a $50-200/mo cloud plan. ARM Docker images are published for both. The RAM handles in-memory run state and the Postgres metadata DB comfortably.

Why this spec: The orchestrator server itself is RAM-hungry (Postgres + UI + scheduler daemon), not CPU-hungry. 24GB gives you room to run the stack and execute lightweight Python tasks locally.

Tool: Prefect 2 / 3 (self-hosted server)

# docker-compose.yml (ARM-native)
services:
  prefect-db:
    image: postgres:15-alpine
    platform: linux/arm64
    environment:
      POSTGRES_PASSWORD: prefect
  prefect-server:
    image: prefecthq/prefect:3-latest
    platform: linux/arm64
    command: prefect server start --host 0.0.0.0
    depends_on: [prefect-db]
    ports:
      - "4200:4200"
    environment:
      PREFECT_API_DATABASE_CONNECTION_URL: postgresql+asyncpg://postgres:prefect@prefect-db/prefect
Enter fullscreen mode Exit fullscreen mode

Est. usage: ~3-4GB RAM for the full stack, 5-10% CPU background, spikes during flow runs.

Top Pick: LLM Inference

Nothing else on this list uses the spec as precisely. The 24GB ceiling is exactly where Mistral 7B becomes viable. The ARM NEON extensions make llama.cpp faster here than on equivalent x86 clock-for-clock. And the practical value is real: a private, API-compatible inference endpoint you control, with no rate limits and no data leaving your infrastructure. Every other use case you can run on a $5 VPS. This one you can't.

Oracle Gotchas (The Unfiltered Version)

  • ARM-only packages. Not everything has an linux/arm64 image. Always pass --platform linux/arm64 in Docker or you'll run x86 via QEMU emulation and wonder why it's slow.
  • Two firewalls. Oracle's VCN Security Lists block ingress independently of iptables. Opening a port in the OS firewall isn't enough — you must also edit the Security List in the console.
  • Idle termination. Oracle has terminated "idle" free-tier instances. Run a cron job that does something measurable (even a weekly apt upgrade) to keep the instance from looking abandoned.
  • Egress pricing. The free tier includes 10TB outbound per month. Beyond that, you pay. The LLM endpoint and browser farm both generate real egress — monitor it.
  • No nested virtualization. ARM A1 doesn't support nested virt. Don't try to run QEMU inside it for anything serious.

Turns out 24GB of RAM in a datacenter is a terrible place to host a blog. It's a great place to run the tools that build the blog, scrape the web, cache your CI, and answer your LLM queries. Use the hardware for what it's actually good at.

tags: cloud, devops, selfhosted, arm

Top comments (0)