Azure Cobalt 200 Arm VMs and NC RTX PRO Blackwell VMs — New Compute Options for AI and Cost Optimization

Azure just gave us two very different but equally compelling reasons to rethink our VM choices. The Cobalt 200 Arm-based VMs are now in preview, delivering up to 50% better CPU performance than their Cobalt 100 predecessors while maintaining aggressive cost advantages. Meanwhile, the NCv6 series powered by NVIDIA RTX PRO 6000 Blackwell GPUs just hit general availability in West US 2 and Southeast Asia, bringing a new class of converged AI and visualization compute to Azure.

If you're an Azure-first enterprise team in Southeast Asia — or anywhere — these two VM families represent a fork in the road: one path optimizes for cost and scale on CPU-bound workloads, the other unleashes GPU-accelerated AI inference and visual computing. Understanding when to use each, and how to migrate, will directly impact your cloud spend and your AI ambitions.

Let me walk through both, with real numbers, real CLI commands, and practical guidance on making the switch.

Azure Cobalt 200: The Next Generation of Arm at Scale

Microsoft's custom Arm silicon has come a long way since the first Cobalt 100 instances shipped. The Cobalt 100 is now deployed across 32 Azure regions, and early adopters reported up to 45% better performance while using 35% fewer compute cores. Cobalt 200 builds on that momentum with a significant generational leap.

What's Under the Hood

The Cobalt 200 SoC is built on Arm Neoverse V3 compute subsystems, fabricated on TSMC's 3nm (N3P) process with a modern chiplet architecture. The cache hierarchy is where it gets interesting:

• 3 MB of L2 cache per core — this is substantial and directly benefits database and caching workloads
• 192 MB of system-level L3 cache — a massive shared pool that reduces memory latency for scale-out applications
• Memory encryption enabled by default via a custom memory controller, with negligible performance impact

The result? Real-world performance gains that go well beyond synthetic benchmarks:

Those numbers are not theoretical. Microsoft's own Azure SQL Database and Dataverse teams are validating Cobalt 200 right now, with the Dataverse team reporting up to 60% better performance for their base workload.

The New VM Families

Cobalt 200 expands the portfolio across multiple optimized SKUs:

Networking and storage throughput are equally impressive, with most families supporting up to 85 Gbps network bandwidth and 70 Gbps remote storage throughput — all backed by Azure Boost for distributed application performance.

Cost Comparison: Cobalt 200 vs x86

This is where Arm VMs really shine for enterprise teams watching their cloud bills. Historically, Azure's Arm-based instances have been priced 20–40% lower than comparable Intel or AMD instances. While specific Cobalt 200 pricing will settle as general availability approaches, here's the illustrative historical pattern from Cobalt 100 — not current list rates — to give a sense of the relative savings band:

The figures above are illustrative historical Cobalt 100 / Intel Dv5 numbers from prior comparison articles, not verified against the current Azure Pricing Calculator as of August 2026. Always confirm live pricing via the Azure Pricing Calculator before committing to a migration plan.

For workloads that run 24/7 at scale, this compounds quickly. A fleet of 50 general-purpose web servers saving 25–30% on compute adds up to meaningful budget relief — money you can redirect toward GPU instances for AI workloads.

Migration: Easier Than You Think

If you're already on Cobalt 100, migration to Cobalt 200 is a non-event. It's the same Arm64 architecture, same OS, same binaries. Microsoft describes it as "a change of hardware, not a change of platform."

For teams migrating from x86 to Arm for the first time, the ecosystem has matured significantly:

# Check if your current workload runs on Arm-compatible images
az vm image list --publisher Canonical --offer 0001-com-ubuntu-server-jammy \
  --sku 22_04-lts-arm64 --all --output table

# Create a Cobalt 200 VM (once you have preview access)
az vm create \
  --resource-group myResourceGroup \
  --name cobalt200-web-01 \
  --image Canonical:ubuntu-24_04-lts:server:latest \
  --size Standard_D16psv7 \
  --admin-username azureuser \
  --ssh-key-values ~/.ssh/id_rsa.pub \
  --generate-ssh-keys

# Verify Arm64 architecture
az vm run-command invoke \
  --resource-group myResourceGroup \
  --name cobalt200-web-01 \
  --command-id RunShellScript \
  --scripts "uname -m && cat /proc/cpuinfo | head -20"

Key migration considerations:

1. Container workloads are the easiest win. If you're running Docker or Kubernetes, most base images (Ubuntu, Alpine, Debian) have mature Arm64 variants. Rebuild your images with --platform linux/arm64 and you're done.
2. Language runtimes are well-supported. Python, Java, .NET, Node.js, Go, and Rust all have production-ready Arm64 builds. Over 95% of the Ubuntu archive is built and tested for Arm.
3. Database engines work out of the box. PostgreSQL, MySQL, MongoDB, Redis — all have official Arm64 binaries. Check for any x86-specific extensions or native modules in your application dependencies.
4. Test before you commit. Run your CI/CD pipeline against Arm64 targets. Tools like Docker's buildx make multi-architecture builds straightforward:

# Build and push multi-arch image
docker buildx build --platform linux/amd64,linux/arm64 \
  -t myregistry.azurecr.io/myapp:latest \
  --push .

5. The Linux kernel supports transparent page size migration, and Ubuntu on Cobalt 200 includes Kernel Livepatch from Ubuntu 26.04 LTS onward, so you can patch without downtime.

Azure NCv6: NVIDIA RTX PRO 6000 Blackwell for AI and Visualization

If Cobalt 200 is about cost-efficient CPU scale, the NCv6 series is about raw GPU power. Microsoft positions these VMs as a "dual engine" — capable of handling both industrial visualization (digital twins, rendering) and AI inference on a single platform.

The Hardware

At the heart of the NCv6 is the NVIDIA RTX PRO 6000 Blackwell Server Edition GPU:

The 96 GB of GDDR7 memory is the headline feature. That's enough VRAM to run 30B-class models in FP16 or 70B-class models in 4-bit/8-bit quantized format — without needing to split across multiple GPUs. For teams in Southeast Asia building RAG pipelines, deploying small-to-medium LLMs, or running agentic AI workloads, this is a very practical amount of memory.

Note: 1,597 GB/s is the Server Edition spec; NVIDIA's Workstation Edition lists 1,792 GB/s. Azure NCv6 uses the Server Edition.

Multi-Instance GPU (MIG) support means you can carve a single RTX PRO 6000 into smaller fractional GPUs. This is critical for cost optimization — you don't need to rent a full GPU for a small inference endpoint or a VDI session.

When to Choose NCv6 over Cobalt 200

This is the practical question. Here's a decision framework:

Choose Cobalt 200 when:
- Your workload is CPU-bound (web servers, APIs, microservices, databases)
- You're running Linux-based scale-out services
- Cost optimization is the primary driver
- You need high memory density at low cost (Mpsv4 for in-memory workloads)
- Your AI involvement is limited to data preprocessing or orchestration (not inference)

Choose NCv6 with RTX PRO 6000 when:
- You need GPU-accelerated AI inference (LLM serving, RAG, embeddings, fine-tuning)
- You're running visualization workloads (digital twins, Omniverse, 3D rendering)
- You need real-time video processing or encoding at scale
- Your workload demands both GPU compute and high CPU throughput (the Granite Rapids CPU prevents bottlenecks)
- You need MIG for multi-tenant GPU sharing

The hybrid architecture is where most enterprise teams will land:

Client → Load Balancer
  ├── Cobalt 200 Dpsv7 (API Gateway, Web Tier, Auth) — cost-optimized
  ├── Cobalt 200 Epsv7 (Redis Cache, Session Store) — memory-optimized
  └── NCv6 Standard_NC144ds_xl_RTXPRO6000BSE_v6 (AI Inference, Embeddings, RAG) — GPU-accelerated

This pattern gives you the best of both worlds: Arm-powered cost savings on the CPU-heavy tiers, and Blackwell GPU power where it matters for AI.

Deploying an NCv6 Instance

# List available NCv6 SKUs in Southeast Asia (now GA there as of mid-2026)
az vm list-sizes --location southeastasia \
  --query "[?contains(name, 'RTXPRO6000BSE')].{Name:name, vCPUs:numberOfCores, MemoryMB:memoryInMb}" \
  --output table

# Create an NCv6 GPU VM (Windows)
az vm create \
  --resource-group myResourceGroup \
  --name ncv6-inference-01 \
  --image MicrosoftWindowsServer:WindowsServer:2022-datacenter-gpu:latest \
  --size Standard_NC144ds_xl_RTXPRO6000BSE_v6 \
  --admin-username azureuser \
  --generate-ssh-keys

# For Linux GPU workloads
az vm create \
  --resource-group myResourceGroup \
  --name ncv6-inference-linux-01 \
  --image Canonical:ubuntu-24_04-lts:server:latest \
  --size Standard_NC144ds_xl_RTXPRO6000BSE_v6 \
  --admin-username azureuser \
  --ssh-key-values ~/.ssh/id_rsa.pub \
  --generate-ssh-keys

# Install NVIDIA drivers (Linux) — NCv6 uses GRID/vGPU drivers, not the
# standard CUDA driver path. Follow Microsoft's NCv6 driver guide:
# https://learn.microsoft.com/azure/virtual-machines/linux/n-series-driver-setup
#
# NOTE: The apt-get command below is ILLUSTRATIVE ONLY. NCv6 officially ships
# with NVIDIA GRID/vGPU driver v20.x (R595) as of Apr 23 2026, not the standard
# CUDA driver. For production deployments, follow Microsoft's N-series driver
# setup guide and use the GRID driver (vGPU) install path — not nvidia-driver-550.
az vm run-command invoke \
  --resource-group myResourceGroup \
  --name ncv6-inference-linux-01 \
  --command-id RunShellScript \
  --scripts "sudo apt-get update && sudo apt-get install -y nvidia-driver-550 nvidia-utils-550"

# Verify GPU availability
az vm run-command invoke \
  --resource-group myResourceGroup \
  --name ncv6-inference-linux-01 \
  --command-id RunShellScript \
  --scripts "nvidia-smi"

GPU Pricing Context

NCv6 instances will carry the premium you'd expect for Blackwell-class GPUs. As of August 2026, Azure lists the Standard_NC144ds_xl_RTXPRO6000BSE_v6 (single GPU, 144 vCPUs, 516 GiB) at $6.38/hr on-demand in West US 2 and $8.93/hr in Southeast Asia (Linux, on-demand). That puts the single-GPU effective rate higher than AWS g7e (~$3.36/hr/GPU on g7e.2xlarge) and GCP g4-standard-48 (~$4.50/hr/GPU), but Azure's regional availability in Southeast Asia and the included 96 GB of VRAM per GPU make the comparison more nuanced than the headline rate suggests. Azure Spot pricing on NCv6 is region-dependent and generally does not drop below ~$2/hr for this SKU.

For teams comparing against older NCv3 or NVv5 series, the NCv6 offers a clear upgrade path. The MIG capability means you can start with fractional GPU slices (1/4 GPU on NC36ds or 1/2 GPU on NC72ds) for development and testing, then scale to full GPU allocation for production inference.

Practical Migration Strategy: A Step-by-Step Approach

Here's how I'd approach adopting these new VM families in a real enterprise environment:

Phase 1: Assess (Week 1–2)

# Audit your current VM fleet
az vm list --query "[].{Name:name, Size:hardwareProfile.vmSize, ResourceGroup:resourceGroup}" --output table

# Identify Arm-eligible workloads (Linux, no x86-specific dependencies)
az vm list --query "[?contains(storageProfile.imageReference.publisher, 'Canonical') || contains(storageProfile.imageReference.publisher, 'RedHat')].{Name:name, OS:storageProfile.imageReference.offer}" --output table

Phase 2: Pilot (Week 3–4)
- Deploy 2–3 non-critical workloads on Cobalt 200 Dpsv7 instances
- Compare performance metrics (response time, throughput, CPU utilization) against current x86 VMs
- For AI workloads: provision a single NCv6 instance and benchmark your inference pipeline

Phase 3: Migrate (Month 2–3)
- Move web/API tiers to Cobalt 200 (usually the easiest migration)
- Migrate database tiers to Cobalt 200 memory-optimized instances (Epsv7/Mpsv4)
- Stand up GPU inference endpoints on NCv6

Phase 4: Optimize (Ongoing)
- Right-size instances based on actual utilization data
- Apply Reserved Instances or Savings Plans for predictable workloads
- Use MIG on NCv6 to consolidate smaller inference workloads onto fewer GPUs

Common Pitfalls to Watch For

1. Windows workloads need x86 for now. Cobalt 200 is Arm64. If your application stack requires Windows, you'll need to stay on Intel/AMD VMs. The good news: most cloud-native Linux workloads migrate cleanly.
2. Don't assume GPU is always needed for AI. Many inference workloads — especially smaller models, embeddings generation, and preprocessing — run perfectly well on CPU. Start with Cobalt 200 and upgrade to NCv6 only when GPU acceleration demonstrably improves latency or throughput.
3. Network topology matters. Cobalt 200 supports up to 85 Gbps and NCv6 up to 180 Gbps. If your AI inference pipeline involves large data transfers between compute and storage, make sure your architecture accounts for this bandwidth differential.
4. Memory encryption is free on Cobalt 200. It's enabled by default with negligible performance overhead. This is a security win — especially relevant for regulated industries in Southeast Asia handling sensitive data.
5. Preview ≠ GA (Cobalt 200). Cobalt 200 is currently in preview in 8 regions (West US 3, East US 2, Central US, Sweden Central, East US, West US 2, Spain Central, and Indonesia Central). Availability is limited and pricing may shift. Plan your migration but don't commit production workloads until general availability is confirmed for your target region. (NCv6 is GA in West US 2 and Southeast Asia, so it is production-ready today.)

Conclusion

The Azure compute landscape is evolving fast. Cobalt 200 gives CPU-bound workloads a compelling reason to move to Arm — better performance, lower cost, and a mature ecosystem that makes migration straightforward. NCv6 with RTX PRO 6000 Blackwell gives AI teams a practical, cost-effective GPU option for inference and visualization without the HPC-grade price tag of H100/B200 instances.

For enterprise teams in Malaysia and across Southeast Asia, the playbook is clear: audit your fleet, pilot on Cobalt 200, benchmark AI workloads on NCv6, and build an architecture that uses both where they make sense. The cost savings from Arm can fund the GPU investment for AI. That's a trade worth making.

Key Takeaways

1. Cobalt 200 delivers 50% better CPU performance than Cobalt 100 with up to 135% improvement for database workloads — and Arm instances are typically 20–40% cheaper than comparable x86 VMs.
2. NCv6 with RTX PRO 6000 Blackwell is a practical AI GPU with 96 GB GDDR7 memory, MIG support for fractional allocation, and Azure on-demand list pricing around $6.38/hr per single-GPU VM in West US 2 (Aug 2026).
3. Migration from x86 to Cobalt 200 is a deployment decision, not an engineering project for most Linux workloads. Containerized applications with multi-arch images are the lowest-risk starting point.
4. The optimal architecture uses both: Cobalt 200 for CPU-intensive tiers (web, API, cache, database) and NCv6 for GPU-accelerated AI inference — letting Arm cost savings fund GPU investment.
5. Start with a pilot. Deploy non-critical workloads on Cobalt 200 to validate performance, then expand. For AI, benchmark your inference pipeline on NCv6 before committing to full production deployment.