Be careful when pulling images by short name

Your own Kubernetes controller - Improving and deploying

Extending Kubernetes with Operators

Having attended the last two European KubeCon events (2018 and 2019), it’s become increasingly obvious that operators are becoming a hot topic within the community.
There were zero sessions on operators in 2018, whereas there were 9 in 2019. There’s even a dedicated OperatorCon hosted by Loodse at this year’s (unfortunately postponed) KubeCon!
I also had the pleasure of attending the Operator Framework Workshop session delivered by Red Hat. This was an excellent session which covered the basics of Operators and how to create them using the Operator Framework.

Controlling outbound traffic from Kubernetes

Late last year, we wrapped up a major networking project which let us control internal traffic in our platform (read about it here). This gave us a lot of confidence that malicious code or an intruder compromising an individual microservice wouldn't be able to hurt our customers.

Developer workflow - accelerated development and deployments on Kubernetes with Skaffold (101)

Provisioning cloud resources (AWS, GCP, Azure) in Kubernetes

Comparison of Joins: MongoDB vs. PostgreSQL
Article, Comments

De-risking custom technology projects
A handbook for state grantee budgeting and oversight

This handbook is designed for executives, budget specialists, legislators, and other "non-technical" decision-makers who fund or oversee state government technology projects that receive federal funding and implement the necessary technology to support federal programs. It can help you set these projects up for success by asking the right questions, identifying the right outcomes, and equally important, empowering you with a basic knowledge of the fundamental principles of modern software design.

https://github.com/18F/technology-budgeting/blob/master/handbook.md

How we do GitOps @ Mettle
At Mettle we fully leverage GitOps to deploy everything into our clusters, we chose to use Flux CD as our GitOps controller of choice.

https://itnext.io/how-we-do-gitops-mettle-4cc771a6c029

Impact Analysis of Puppet Modules
Have you ever wondered who’s using your Puppet modules? Or have you hesitated before changing a class parameter because you don’t really know how many people will be affected downstream? Maybe you hesitated before deprecating a barely supported and almost certainly unused subclass because… well, you didn’t really know for sure that it was unused.

https://binford2k.com/2020/04/06/rangefinder/

https://github.com/puppetlabs/puppet-community-rangefinder

Predicts downstream impact of breaking file changes

Scaling containers in AWS

This all started with a tech curiosity: what’s the fastest way to scale containers on AWS? Is ECS faster than EKS? What about Fargate? Is there a difference between Fargate on ECS and Fargate on EKS?

https://www.vladionescu.me/posts/scaling-containers-in-aws.html

Accelerating with Serverless!
As you browse through LEGO.com, please remind yourself that the backend business services of LEGO.com run as serverless services on AWS cloud. Of course, there are SaaS platforms that these serverless microservices interact with and the frontend layer that runs on Fargate consumes these services and so on so forth. But the focus for us here in about those backend serverless services.

https://medium.com/lego-engineering/accelerating-with-serverless-625da076964b

Kubernetes: A Rusty Friendship
A few days ago, we introduced Krustlet, a WebAssembly focused Kubelet implementation in Rust. If you are not familiar with Rust, it is a systems programming language focused on safety, speed, and security. We chose to use Rust for two main reasons: 1) Rust has some of the best support for WebAssembly compilation (more on this later) and 2) We wanted to demonstrate Rust and its strengths could be applied to the Kubernetes ecosystem. This post is meant to show what we learned and why we think Rust is a great (and sometimes better) choice for writing a Kubernetes focused application.

https://deislabs.io/posts/kubernetes-a-rusty-friendship/

Docker Compose Spec
Crafting the YAML to install applications on Kubernetes can be time consuming. Not just to do but to learn. There are a lot of Kubernetes objects and the each have a lot of options. If you were to print the API documentation (you can find v1.18 here) that describes the objects it would be well over 1,000 pages. This only includes the latest version of APIs and only the objects you might use when deploying an application rather than everything. This doesn’t include documentation detailing how to connect these objects together to deploy applications.

https://codeengineered.com/blog/2020/docker-compose-spec/

https://www.compose-spec.io/

A specification for developer-centric application definition used in Cloud Native Applications
The Compose Specification is a developer-focused standard for defining cloud and platform agnostic container-based applications.

Collecting Kafka performance metrics
If you’ve already read our guide to key Kafka performance metrics, you’ve seen that Kafka provides a vast array of metrics on performance and resource utilization, which are available in a number of different ways. You’ve also seen that no Kafka performance monitoring solution is complete without also monitoring ZooKeeper. This post covers some different options for collecting Kafka and ZooKeeper metrics, depending on your needs.

https://www.datadoghq.com/blog/collecting-kafka-performance-metrics/

Monitoring Kafka performance metrics
Kafka is a distributed, partitioned, replicated, log service developed by LinkedIn and open sourced in 2011. Basically it is a massively scalable pub/sub message queue architected as a distributed transaction log. It was created to provide “a unified platform for handling all the real-time data feeds a large company might have”.

https://www.datadoghq.com/blog/monitoring-kafka-performance-metrics/

https://github.com/windmilleng/tilt-extensions

This is the official Tilt Extensions Repository. Read more in docs.