CNCF Blog

SEEKING WORK | Remote (Tucson, Arizona)

I'm a full-service writer who helps open source && cloud native startups inspire devs and engineering leads to `commit`.

For those still forming value propositions and fine-tuning websites, I uplevel the messaging you already have with my unique experience with these technical communities. And for those ready to distribute their proven messaging with content, I write opinionated and technical articles on Kubernetes, GitOps, IaC, pre commit validation and shift left, trace-based testing, APIOps, and much more. I recently authored a report in association with CNCF on end user adoption of cloud native tooling, which gave the unique opportunity to pick the brains of 20 tech leaders at major orgs on platform engineering, tool choice, Kubernetes provisioning, and much more.

How can I make this know-how for you?

- Initialize a messaging strategy that differentiates your open source project and commercial product as commit-worthy

- Load balance your copywriting tasks so you can return to being a founder, leader, and maintainer

- Deploy content (both strategy and execution) that builds trust and authority with your strongest opinions backed by your technical prowess

If you feel like you can't reach the right people because you don't have the right copy/content, or know where you're headed but can't scale, shoot me an email and we'll find the paved road you've been after.

--

- Book a call:…

IMO transparent proxies for observability are not the best pattern. And I speak from experience, we developed the Postgres plugin for Envoy [1], [2] and we use it in StackGres [3], among others, for this very same reason, observability.

There's two main problems with said proxies:

* Latency. Yes, yes, yes, they add "microseconds" vs "milliseconds for queries", and that's true, but just part of the story. There's an extra hop. There's two extra sets of TCP layers being traversed. If the hop is local (say a sidecar, as we do in StackGres) it adds complexity in its deployment and management (something we solved by automation, but was an extra problem to solve) and consumes resources. If it's a network hop, then adds milliseconds, and not microseconds.

* Performance. It's not that hard to write a functioning PG wire proxy (it's not trivial either). But it is extremely hard to make it perform well under high load scenarios. Most of the proxies I have seen crack down under moderate to high performance.

What's the solution then? The Postgres extension model to capture the metrics (we also experimented with eBPF, but it causes too many kernel-user space context switches when you can do the same in an extension without them), and a small sidecar to push the metrics out via a standardized protocol like OTEL.

[1]: https://www.envoyproxy.io/docs/envoy/latest/configuration/listeners/network_filters/postgres_proxy_filter

[2]:…

Following projects seem promising:

* OpenCompute[1]: A Facebook lead initiative to build and design open source hardware, mainly for data centers but also for enterprise.

* RISC-V[2]: An open source ISA and alternative to x86 and ARM.

* Cloud Native Computing Project[3]: An industry collaboration for building cloud infrastructure.

* Teleoperations[4]: Remotely operating machines where humans take over in situations where AI is not sure of the correct action to take. For example, before humans get self-driving vehicles, we may get vehicles that are operated remotely. The vehicle will have cameras that stream the data to operators who could be sitting at an office who in turn send control signals wirelessly to the vehicles. This model could also be applied to drones, humanoid robots etc. More jobs could be sent to low wage economies and workers there could perform work that previously required physical presence in high wage economies.

[1] https://www.opencompute.org/

[2] https://riscv.org/

[3] https://www.cncf.io/

[4] https://en.wikipedia.org/wiki/Teleoperation

> Fortunately K8s is _not_ a Google owned project. Yes, there are a lot of Google people involved, but it really is a community project.

It was created by Google and then "donated" to CNCF.

Conveniently, CNCF doesn't even list its members: https://www.cncf.io/about/members/

According to Wikipedia, though, "Founding members include Google, CoreOS, Mesosphere, Red Hat, Twitter, Huawei, Intel, Cisco, IBM, Docker, Univa, and VMware." [1]

Ah yes. I just love that free community spirit. Top 10-15 contributors are all paid money to work on this by Google, RedHat, Microsoft, VMWare, Goldman Sachs (and I couldn't bother to check others).

That is, 18 billion net income last quarter, 15 billion net income last quarter, 141 million net income last quarter, 6 billion last quarter...

These ginormous corps solve their own problems under the guise of open source, and gullible developers fall for the community promise.

[1] https://en.wikipedia.org/wiki/Cloud_Native_Computing_Foundation

> A better question would be what is the point of CNCF?

I ask myself that every time I happen to stroll past CNCF things. I just can't avoid feeling that it's a big cloud complexity racket - and not even a classy one. A constant barrage of expensive conferences, vague memberships [1], and over-the-top certification schemes [2]. Not to even mention the obvious self-interests of hyperscalers of setting up this org in the first place.

[1] "The CNCF Silver Membership offers unmatched value across your entire organization. Whether a startup, scale-up, or mid-sized company, get ready to lead, learn, grow, and be recognized in the cloud native ecosystem." https://www.cncf.io/about/join/silver/

[2] "Individuals who have successfully passed every CNCF certification (currently CKA, CKAD, CKS, KCNA, KCSA, PCA, ICA, CCA, CAPA, CGOA, CBA, OTCA, KCA) and LFCS, will receive the title of Golden Kubestronaut for life [...]" https://www.cncf.io/training/kubestronaut/

> I don't think anyone wants to use Helm.

Here is why everyone should use Helm:

Helm 2.0 introduced package as a first-class concept for Kubernetes and created the standard to distribute applications, thanks to Helm thousands of people could discover and collaborate on cloud-native deployments of the open source software https://github.com/helm/charts/tree/master/stable published and managed by organizations and contributors all over the world.

Helm 3.0 keeps innovating, it adopts the most forward-thinking approach to package management and Kubernetes config management by using higher level domain specific language based on Lua to create expressive package management system:

https://sweetcode.io/a-first-look-at-the-helm-3-plan/

Helm is also backed by CNCF[1] and is the best choice so far for organizations to create a reproducible CI/CD pipeline in a Kubernetes cluster.

[1] https://www.cncf.io/blog/2018/06/01/cncf-to-host-helm/