Latest / The Edge Computing Podcast with Fexingo: Local Compute, CDNs, and Distributed Infrastructure / Why Your Edge Compute Needs a Zero Trust Network
Transcript
- Lucas: So Luna, quick question: when you think about edge computing — the servers sitting inside a factory, a cell tower, a retail store — what's the first security image that comes to mind? Luna: Honestly? A locked closet. Maybe a VPN tunnel back to headquarters. That's the old-school mental model. Lucas: Right. And that model is precisely what's breaking right now. Because the whole premise of edge is that you push compute and data closer to where it's generated. That means you've got dozens, hundreds, sometimes thousands of physical nodes scattered across geographies, each one a potential entry point. Luna: And those nodes aren't sitting inside a corporate data center with a moat and a drawbridge. They're in a warehouse run by a third-party logistics provider, or mounted on a pole in a parking lot. Lucas: Exactly. So the perimeter model — build a strong wall around your network, then trust everything inside — just evaporates. The industry has been talking about zero trust for years, but I think edge computing is what finally makes it unavoidable. And there's a concrete case that proves it: the Okta breach from late 2023. Luna: Okta — the identity and access management company. That one hurt a lot of people. Lucas: It did. The attackers got in by stealing credentials for a service account that had access to Okta's customer support system. That one account gave them visibility into 134 customer environments. And the real kicker: the credential itself wasn't even particularly privileged — it was just trusted because it was inside the corporate network. Luna: So the perimeter failed. The attacker got past the wall, and everything inside was treated as safe. Lucas: Precisely. Zero trust says: never trust, always verify, regardless of where the request originates. Every device, every user, every API call has to authenticate and authorize before it touches anything. For edge infrastructure, that means every node — whether it's a Raspberry Pi running inference or a full 2U server in a base station — has to prove its identity every time it talks to anything else. Luna: And that's a totally different engineering challenge from a traditional data center. You can't just slap a VPN on it and call it a day. Lucas: Right. A VPN creates a tunnel, but once you're inside that tunnel, you're usually on the trusted network. Zero trust breaks that assumption into three core principles for edge: first, never trust the network — always authenticate. Second, microsegmentation — carve the infrastructure into tiny zones so a breach in one node can't cascade. Third, least-privilege access — every node gets exactly the permissions it needs, nothing more. Luna: Microsegmentation sounds great on paper, but in practice, how do you segment a fleet of 10,000 distributed nodes that need to talk to each other and to the cloud? Lucas: That's where software-defined perimeters come in. You use identity-based policies, not IP addresses. So instead of saying 'allow traffic from 10.0.1.0/24', you say 'allow only the node with certificate ID X to write to the edge database Y'. And you enforce that at the network layer, not just at the application layer. Luna: It feels like that requires a lot of orchestration. Is there a standard protocol for this yet? Lucas: The closest we have is the IETF's work on Zero Trust Network Access — ZTNA, which is basically the framework behind products like Cloudflare Access or Zscaler. But the challenge is that edge nodes often have intermittent connectivity. They might be offline for hours, then batch-sync. So how do you enforce zero trust when the node can't reach the policy engine? Luna: That's the really hard part. You need local policy caching, and you need tamper-proof attestation — the node has to prove its integrity even when it's disconnected. Lucas: Exactly. And that's where hardware-backed security comes in. Intel's Software Guard Extensions — SGX — and AMD's Secure Encrypted Virtualization — SEV — let you run code in secure enclaves. The node can attest to its own state using a hardware root of trust, and then enforce policies locally without phoning home. It's not bulletproof, but it's a lot better than trusting the OS alone. Luna: So let's talk about a concrete failure case that didn't use any of this. The 2021 Microsoft Exchange hack — that was a zero-day in on-premises servers that gave attackers access to email accounts globally. Those were not edge nodes per se, but they were distributed servers with a perimeter mindset. Lucas: Great example. Microsoft Exchange servers were treated as trusted internal infrastructure. Once the attackers found the vulnerability — CVE-2021-26855, if I remember the number correctly — they could bypass authentication entirely because the server implicitly trusted requests from within the network. With microsegmentation, even if one server was compromised, the lateral movement would have been much harder. Luna: And that's the thing: most edge deployments today are still built on the Exchange model — trust the network, trust the device. Gartner released a report earlier this year predicting that by 2027, 60% of enterprises will phase out VPNs for edge access in favor of ZTNA. That's a big shift. Lucas: 60% is a lot. But I wonder if that timeline is aggressive. Because there's a real tension between zero trust and latency — the whole point of edge is speed. If every request has to hit an authorization server before it's processed, you're adding milliseconds that might matter for a robot arm or a fraud-detection model. Luna: Yeah, latency is the elephant in the room. Some edge use cases — like real-time video analytics — can't tolerate a round trip to a centralized policy engine. So does zero trust break edge's value proposition? Lucas: Not if you push the policy engine to the edge too. You can run a lightweight authorization service on the same local cluster or even on the same node. The key is that the policy decision doesn't have to go back to the cloud — it just has to be based on a verifiable identity and a set of rules that are cryptographically signed. That's doable with something like Open Policy Agent or SPIFFE, which is a universal identity standard for workloads. Luna: SPIFFE — the Secure Production Identity Framework for Everyone — I've seen that in Kubernetes environments. It issues short-lived certificates to every workload, so if a node is compromised, the certificate expires quickly and can't be reused. Lucas: Exactly. And that's the kind of architecture that scales to thousands of nodes without a central bottleneck. Each node gets an identity, each service gets an identity, and they authenticate to each other using mutual TLS. No VPN tunnel, no static IP whitelists, no firewall rules that need constant updating. Luna: But what about the cost? All of this — hardware attestation, policy engines, certificate rotation — adds complexity and operational overhead. For a startup deploying edge sensors, is it worth it? Lucas: I'd argue it's cheaper than the alternative. One breach can wipe out years of margin. Look at what happened to Colonial Pipeline — one compromised VPN password led to a ransomware shutdown that cost millions. Granted, Colonial wasn't an edge play, but the principle applies: a single weak point in a distributed system can bring everything down. Luna: And for edge, the weak points are everywhere. A node in a retail store might have physical access risks — someone could plug in a malicious device. Zero trust doesn't solve physical security, but it does limit what an attacker can do once they're on the network. Lucas: Right. Physical security is a separate layer. But zero trust combined with hardware attestation can detect if a node's firmware has been tampered with. Intel's Trusted Execution Technology and AMD's Platform Security Processor can measure the boot process and report to a remote verifier. If the hash doesn't match, the node is denied access to the network. Luna: So you're basically creating a chain of trust from the silicon up to the application. That's a lot of engineering, but it's becoming more accessible. Cloud providers like AWS and Azure already offer zero trust services for their edge offerings — AWS Outposts, Azure Stack Edge — they include hardware security modules. Lucas: And that's the trend: the security is being baked into the infrastructure, not bolted on after. I think in five years, we'll look back at VPNs and perimeter firewalls for edge the same way we look at floppy disks — a technology that made sense for its time but is fundamentally incompatible with the new model. Luna: One last thing: where does the human factor fit in? The Okta breach started with a stolen credential. Zero trust policies can't prevent an employee from typing their password into a phishing site. Lucas: No, they can't. But they can limit the blast radius. If that credential only authorizes a single API call from a specific device, the attacker can't use it to pivot. That's the difference between 'you're in the building' and 'you're in room 3B, and only during business hours'. Zero trust makes the attacker's job much harder, even if it doesn't stop every initial compromise. Luna: So the bottom line: edge computing forces us to abandon the castle and moat mental model. Zero trust isn't just a security fad — it's the architectural response to a world where your infrastructure lives outside your walls. Lucas: Exactly. And the sooner engineers embrace that, the fewer headlines we'll see about breaches originating from a forgotten IoT device in a factory. The edge is where the data lives — we just have to make sure the bad guys can't live there too.