The latest edition of Technology Radar — Volume 30

```
The themes are:

- AI-assisted software development teams
- Open-ish source licenses
- Dragging pull requests closer to proper continuous integration
- Emerging architecture patterns for large language models (LLMs)
```

#study #radar

```
Defining clear Incident Severity levels is a key component to an efficient Incident Management process that helps Engineering teams quickly respond to outages and mitigate customer impact.

Operating an online platform with multiple nines of availability is a complex task, modern websites depend on thousands to hundreds of thousands of individual moving parts all of which need to work correctly in order to provide a satisfactory user experience. When any one of those parts fails then an Incident Management process is needed to coordinate mitigation efforts and resolve the impact as quickly as possible getting the system back into working order.

Incident Management starts by answering a seemingly simple question: How bad is the problem? Knowing how big the issue is that we are dealing with is crucial to understanding the appropriate response to that particular problem. When the problem is small we probably don’t need to notify our C-suite level leadership or send a notice to all customers … but if it is really big then we absolutely need a communication strategy that notifies relevant stakeholders.

```
Link
#observabilty

Medium

Incident severity levels for online platforms

Defining clear Incident Severity levels is a key component to an efficient Incident Management process that helps Engineering teams quickly…

```
With the upcoming deprecation and subsequent removal of Pod Security Policies (PSPs) in Kubernetes, the time is near to find suitable alternatives. Those alternatives, it seems clear at present anyway, will need to be sourced from outside the Kubernetes project itself as there will be no replacement provided (edit: Pod Security Admission is the new, albeit incomplete, successor). The two leading CNCF projects which are prime candidates for PSP replacement are Open Policy Agent (OPA) via Gatekeeper and Kyverno, each with their own strengths and weaknesses. But it is confusing and daunting to compare and contrast them given that no comparisons presently exist. Not only are these projects viable replacements for PSPs, they are vastly more capable than simply acting on Pods alone--they are full Kubernetes policy engines. The goal of this article is to provide a neutral and impartial comparison between Gatekeeper and Kyverno so users may make the most informed selection decision for themselves. It will be an evaluation of each project's merits assuming only the Kubernetes angle.

```

Link

#architecture #k8s

neonmirrors.net

Kubernetes Policy Comparison: OPA/Gatekeeper vs Kyverno

An impartial comparison between leading Kubernetes policy engines OPA/Gatekeeper and Kyverno.

```
Beyla is a vendor agnostic, eBPF-based, OpenTelemetry application auto-instrumentation tool, which lets you easily get started with Application Observability. eBPF is used to automatically inspect application executables and the OS networking layer, allowing us to capture essential application observability events for HTTP/S and gRPC services. From these captured eBPF events, we produce OpenTelemetry web transaction trace spans and Rate-Errors-Duration (RED) metrics. As with most eBPF tools, all data capture and instrumentation occurs without any modifications to your application code or configuration.

```
Link

#observabilty #tools

GitHub

GitHub - grafana/beyla: eBPF-based autoinstrumentation of web applications and network metrics

eBPF-based autoinstrumentation of web applications and network metrics - grafana/beyla

```
Robusta KRR (Kubernetes Resource Recommender) is a CLI tool for optimizing resource allocation in Kubernetes clusters. It gathers pod usage data from Prometheus and recommends requests and limits for CPU and memory. This reduces costs and improves performance.

```
Link

#observabilty #tools

GitHub

GitHub - robusta-dev/krr: Prometheus-based Kubernetes Resource Recommendations

Prometheus-based Kubernetes Resource Recommendations - robusta-dev/krr

Slow Down! Rate Limiting Deep Dive

Now, why should you care about rate limiting? Well, consider a situation where your API is hit with a massive number of requests in a short span. This could be due to a surge in user traffic, a glitch causing repeated requests, or even an attempt to overwhelm your system using DDOS attack. Without rate limiting, your system could get overwhelmed, leading to slow responses or, worse, a complete service disruption.

#study #architecture

CodeReliant

Slow Down! Rate Limiting Deep Dive

In this article we will review different types of rate limiting algorithms and provide a sample implementation using Java.

Best Practices for Java Apps on Kubernetes - Piotr's TechBlog

In this article, you will read about the best practices for running Java apps on Kubernetes. Most of these recommendations will also be valid for other languages. However, I’m considering all the rules in the scope of Java characteristics and also showing solutions and tools available for JVM-based apps. Some of these Kubernetes recommendations are forced by design when using the most popular Java frameworks like Spring Boot or Quarkus. I’ll show you how to effectively leverage them to simplify developer life.

#java #k8s

Piotr's TechBlog

Best Practices for Java Apps on Kubernetes - Piotr's TechBlog

In this article, you will read about the best practices for running Java applications on Kubernetes with tools and code examples.

Grafana Beyla

eBPF-based auto-instrumentation of HTTP/HTTPS/GRPC Go services, as well as HTTP/HTTPS services written in other languages (intercepting Kernel-level socket operations as well as OpenSSL invocations).

#tools #beyla #observability

GitHub

GitHub - grafana/beyla: eBPF-based autoinstrumentation of web applications and network metrics

eBPF-based autoinstrumentation of web applications and network metrics - grafana/beyla

Technology Radar #29
The themes are:

- AI-assisted software development
- How productive is measuring productivity?
- A large number of LLMs
- Remote delivery workarounds mature

Radar#radar

Technology Radar #28
The themes are:

- The meteoric rise of practical AI
- Accessible accessibility
- Lambda quicksand
- Engineering rigor meets analytics and AI
- To declare or program?

Radar#radar