Ivan on Containers, Kubernetes, and Server-Side

I want to share my very recent experience with agentic coding.

Saim Safdar from the Cloud Native Islamabad community generously invited me to his channel to conduct a Kubernetes 101 workshop.

The recent post by DHH regarding their decision to drop TypeScript support in Turbo 8 has suddenly made everyone eager to express their opinion on the TypeScript vs.

Today, I came across a true gem: Akin's Laws of Spacecraft Design.

Debugging even simple containerized applications is challenging.

The only "official" way to publish a port in Docker is the `-p|--publish` flag of the `docker run` (or `docker create`) command.

If you're dealing with containers regularly, you've probably published ports many, many times already.

Slim containers are faster (less stuff to move around) and more secure (fewer places for vulnerabilities to sneak in).

A container image is a combination of layers where every layer represents some intermediary state of the final filesystem.

Many of us these days seem to be in pursuit of better container images.

"How to start programming in Go and for Kubernetes?"

Last week at KubeCon, there was a talk about Kubernetes ephemeral containers.

A short one today.

When you are new to Docker (or Podman, or nerdctl, or alike), the number of commands to study might be truly overwhelming.

Here is a little exercise to deepen your understanding of containers... through toying with them 🧸 The goal is to show that containers aren't just Linux processes, they are also Linux files!

There are many ways to extend Kubernetes with custom functionality, starting from writing kubectl plugins and ending with implementing scheduler extensions.

I strive to produce concise but readable code.

The official Kubernetes Go client comes loaded with high-level abstractions - Clientset, Informers, Cache, Scheme, Discovery, oh my!

There are plenty of reasons to call the Kubernetes API using a CLI (like curl) or GUI (like postman) HTTP client.

This is the first post in the series of articles on how to work with the Kubernetes API from code.

For a long time, serverless has been just a synonym of AWS Lambda for me.

When I started using containers back in 2015, my initial understanding was that they were just lightweight virtual machines with a subsecond startup time.

Containers could have become a lightweight VM replacement.

There are many resources for people who want to learn Linux, Containers, or Kubernetes.

These mysterious HTTP 502s happened to me already twice over the past few years.

containerd is a high-level container runtime, _aka_ container manager.

Even when you have just one physical or virtual server, it's often a good idea to run multiple instances of your application on it.

Go standard library makes it super easy to start an HTTP server: ```go package main import "net/http" func main() { http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { w.Write([]byte("Hello there!

I use a (rather oldish) MacBook for my day-to-day development tasks.

I compiled this thread on Twitter, and all of a sudden, it got quite some attention.

When I was a kid, I used to spend days tinkering with woodworking tools.

Here we focus on the most basic Prometheus concepts - metrics, labels, scrapes, and time series.

Working with real metrics is hard.

Misconception - the right word to explain my early Prometheus experience.

I've been working on my new Rust side-project for several months now, and I've got some learnings to share.

I often find myself staring at Nginx or Envoy access logs flooding my screens with real-time data.

When you have a long series of numbers, such as server memory consumption scraped 10-secondly, it's a natural desire to derive another, probably more meaningful series from it, by applying a moving window function.

PromQL looks neat and powerful.

I was hacking containers recently and noticed, that Docker started featuring the `docker scan` command in the `docker build` output.

I spent the last couple of months writing code in Rust.

The difference between these two networking devices has been an unsolvable mystery to me for quite some time.

As a software engineer, I need to deal with networking every now and then - be it configuring a SOHO network, setting up container networking, or troubleshooting connectivity between servers in a data center.

From time to time I use kind as a local Kubernetes playground.

Maybe the scenario I'm going to describe is just a silly bug no seasoned Go developer would ever make, but it is what it is.

I've been using Kubernetes for almost a year now and, to be honest, I like the experience so far.

I've been trying to wrap my head around the tremendous growth of the Cloud Native zoo for quite some time.

Before jumping to any Kubernetes specifics, let's talk about the service discovery problem in general.

Even though HTTP is an application layer (i.e.

Working with containers always feels like magic.

Traefik is ~~The Cloud Native Edge Router~~ yet another reverse proxy and load balancer.