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.

Introducing Krustlet, the WebAssembly Kubelet

Krustlet is designed to run as a Kubernetes Kubelet. It’s similar in design to Virtual Kubelet. It listens on the Kubernetes API event stream for new pods. Based on specific Kubernetes tolerations, the Kubernetes API will schedule pods onto Krustlet, which in turn runs them under a WASI-based runtime (more specifically, either wasmtime or waSCC, depending on which Runtime Provider they choose).

https://deislabs.io/posts/introducing-krustlet/

https://github.com/deislabs/krustlet

Krustlet acts as a Kubelet by listening on the event stream for new pods that the scheduler assigns to it based on specific Kubernetes tolerations.

Ship Happens: Episode 6 | Tammy Butow Talks SRE and On-Call Training

In episode 6 of Ship Happens, Tammy Butow joins Benton to talk all about SRE, availability and training on-call teams. Tammy is a Principal Site Reliability Engineer and executive team member at Gremlin, software dedicated completely to chaos engineering. Tammy is an industry leader in SRE and chaos engineering and brings loads of valuable experience from the National Australia Bank, Digital Ocean, Dropbox and Gremlin. Learn from Tammy’s interesting history with skateboarding and how she’s learned to apply these lessons to SRE and software development.

https://victorops.com/podcast/ship-happens-episode-6-tammy-butow/

GitHub is now free for teams
Article, Comments

Researchers show the relevance of IP addresses for user tracking [pdf]
Article, Comments

Falcon is a free, open-source SQL editor with inline data visualization
Article, Comments

NPM Has Joined GitHub
Article, Comments

Wekan: Open-source, trello-like kanban
Article, Comments