This week's news: KubeCon NA in review and cloud repatriation

Every Wednesday, Nick Chase and Eric Gregory from Mirantis go over the week’s cloud native and industry news on the Radio Cloud Native podcast.

This week, Eric and Cloud Native & Coffee host John Jainschigg looked back on KubeCon NA 2022 and discussed:

• Cilium and Grafana stack integrate for eBPF-powered observability

• Repatriation from public cloud takes off

• Linux and Rust milestones

• And other stories on the podcast, including observations from the show floor, new Kubecost releases, the CNCF's new Istio course, the ko project for containerized Go apps, and much more

You can watch the entire episode below or download the podcast from Apple Podcasts, Spotify, or wherever you get your podcasts. If you'd like to tune into the next show live, follow Mirantis on LinkedIn to receive our announcement of the next broadcast.

Eric: Grafana Labs announced a new integration between their dashboards and the Cilium network overlay. The really interesting thing about Cilium is the way it builds on eBPF, or extended Berkeley packet filter, the Linux kernel functionality that was really only fully unlocked recently by the cgroups v2 hitting general availability. eBPF lets code run in a sandbox at the kernel level, and that opens up a lot of interesting possibilities, just one of which is facilitating sophisticated observability without the need for sidecar containers.

Now a partnership between Isovalent, the creators of Cilium, and Grafana Labs is aiming to leverage eBPF for more sophisticated connectivity observability through Grafana Labs tools like Loki, Grafana, Tempo, and Mimir. This aims to help solve the problem of getting fine-grained data on connectivity issues in what might be a complex, sprawling applications environment with who knows how many replicas of who knows how many microservices running across who knows how many nodes. In the constant IP churn of Kubernetes, it’s challenging to follow a problem to a specific culprit. Traditionally, one of the better ways to accomplish this has been through a service mesh that adds a sidecar to your containers, but that obviously imposes a performance tax, especially at scale. The idea here is to use eBPF and Cilium, which gives you a whole new connectivity fabric as an alternative to iptables, to create stable service identities that come with a much lighter performance cost. The way the Grafana blog explains it:

“Cilium generates in-kernel eBPF programs based on the identity of the workload. These eBPF programs export observability data to the Grafana Labs LGTM stack.”

If you’re interested in playing around with this yourself, there’s a hands-on demo available at https://github.com/isovalent/cilium-grafana-observability-demo.

Cilium had a big show beyond the Grafana stack integration. They applied for CNCF graduated status live on stage, and Microsoft’s AKS announced that they were using Cilium for their CNI (Container Network Interface) data plane, giving Cilium the hat trick with all three of the big public cloud providers using them for CNI.

John: According to InfoWorld and the Wall Street Journal, a decade or more into the “cloud revolution,” initial hopes for public cloud – that promised paradise of platforms-on-demand, simplified operations, and pay-by-use cost efficiencies – have failed to materialize for most users. In fact, costs and complexity of public cloud services are rising fast. And fully-burdened costs of public cloud efforts (e.g., for AWS- or Azure-certified engineers in a highly-competitive labor market) are rising as well.

Andreessen-Horowitz agrees. In a report published last year, titled The Cost of Cloud: A Trillion-Dollar Paradox, analysts Sarah Wang and Martin Casado point out that for heavy public cloud users, cloud costs are increasingly insupportable – private cloud is looking like a much-more-affordable bet. They note that as early as 2017, Dropbox had already reported (on their S-1) a $75M savings from “repatriating” workloads to private cloud from public cloud hyperscalers. In general, organizations will see a minimum of around 40% savings for a given VM by putting it on private cloud (including proportional costs for block storage and bandwidth).

All this is summarized beautifully in a recent article by Basecamp and HEY’s David Heinemeyer Hansson, titled “Why we’re Leaving the Cloud.” Hansson says, straight up, that public cloud is great for two use-cases: simple, singular, low-traffic apps with no customers yet (where you do save some on complexity and cost of entry vs. on-premises solutions) or popular apps with insanely bursty traffic (where you never know if you need ten servers or 100).

For customers who need to maintain diverse IT estates with more predictable traffic, public cloud complexity remains burdensome, and you pay a huge premium for resources and services you actually need (versus VMs you forget to turn off, which you pay for as well).

Eric: Over in Linux world, Linus Torvalds recently announced that version 6.1 of the Linux kernel has its first release candidate, with a final release targeting early or mid-December. The big news here is a scrappy early implementation of Rust in the kernel—after being pushed from version 6.0, we’re getting a sort of baby’s first step in 6.1, nowhere near production-ready but available for poking and prodding. Version 6.1 is available at kernel.org right now.

And Rust has its own milestone coming up. A few days ago, Jack Huey, writing on behalf of the Rust Types team, posted a blog announcing that Generic Associated Types will be stable in Rust 1.65, which is expected to hit full release on November 3rd—tomorrow, at the time of recording. 

According to Huey:

“As of Rust 1.65…generic associated types (GATs) will be stable — over six and a half years after the original RFC was opened. This is truly a monumental achievement; however, as with a few of the other monumental features of Rust, like async or const generics, there are limitations in the initial stabilization that we plan to remove in the future.”

In short, this update will allow for more comprehensive usage of generics in Rust. As the blog post says,

“In general, GATs provide a foundational basis for a vast range of patterns and APIs. If you really want to get a feel for how many projects have been blocked on GATs being stable, go scroll through either the tracking issue.”

If you want to get a more detailed understanding of the possibilities and limitations, check out the Rust team’s blog post at https://blog.rust-lang.org/.

Check out the podcast for more of this week's stories.