Just wrapped up the PoC for the new SD-WAN orchestration module. It's... fine. The intent is solid—centralized overlay management, path selection, zero-touch for branches—but the execution feels bolted-on.
My main gripes:
* The Terraform provider doesn't support the SD-WAN objects yet. Had to use a mix of `local-exec` provisioners calling their REST API, which is messy.
* Path selection is basic (latency/jitter). No easy way to inject custom health check logic.
* Cost adds up fast per gateway. Hard to justify if you already have a mature IaC pipeline.
Anyone actually integrated this into a fully automated pipeline? Specifically:
* How are you handling dynamic node registration from IaC?
* Any workarounds for the missing Terraform resources?
* Is the QoS reporting actually useful, or just another dashboard?
Example of the hacky REST call I had to make:
```hcl
resource "null_resource" "provision_sdwan_node" {
provisioner "local-exec" {
command = <<EOT
curl -X POST -H "Content-Type: application/json"
-d '{"name": "${var.node_name}", "publicIp": "${aws_eip.branch_gw.public_ip}"}'
https://${var.barracuda_orbital_url}/api/v1/nodes
EOT
}
}
```
—cp
—cp
I'm a help desk lead at a regional bank, ~1500 employees. We've been running the base SD-WAN for about two years, and our security team tested the new orchestration module in a pilot with 10 branch gateways.
Some quick points from our pilot:
**Cost reality:** The add-on was quoted at ~$180/month per gateway. For 50+ sites, that's a new six-figure annual line item on top of the base licensing.
**Integration gap:** You're right, the Terraform gap is real. We had the same REST API workaround. Their roadmap said Q4 for provider support, but that's slipped before.
**Performance ceiling:** Path selection is simple. It works for basic failover but couldn't handle our specific need to route video conferencing based on packet loss *and* Zoom region. We capped at about 500 Mbps throughput per gateway node in testing.
**Actual win:** The zero-touch deployment for new branches was flawless. We shipped a pre-configured appliance to a new office and it was live in 15 minutes. That alone might justify it if you're scaling fast.
My take is skip it unless you're opening a lot of new locations and your network team is small. The automation doesn't yet match what a mature shop can build with their API and a dedicated engineer.
If you have to choose, tell us: how many sites are you managing, and is your primary goal to reduce manual config time or to get smarter traffic routing?
You've precisely identified the core integration dilemma with bolt-on orchestration layers. That `local-exec` pattern with curl is exactly what we had to implement, and it creates a critical state synchronization problem. The provider's eventual support won't retroactively manage the state of objects created via API calls, so you're looking at a messy migration or a dual-state management nightmare.
On your question about dynamic node registration, we built a small intermediary service using the vendor's webhooks. When a Terraform apply creates a new gateway (e.g., in AWS), it tags the instance with a deployment ID. A listener catches the `gateway-up` event from the cloud provider, then calls the SD-WAN orchestration API to register the node, passing that ID. It's more plumbing, but it avoids the null_resource pattern. The QoS reporting, in my assessment, is useful only if your downstream monitoring system can consume its metrics via API. The dashboard itself is a lagging indicator.
The real cost isn't just the per-gateway license. It's the operational debt of maintaining these bespoke integration workflows until their automation fabric matures.
Single source of truth is a myth.