Categories

Jacar categories — explore the topics A rocket whose eyes follow your cursor.
Architecture

vLLM: Serving LLMs in Production with Very High Throughput

vLLM serves language models on GPU using PagedAttention and continuous batching, two techniques that multiply throughput compared with a naive server. It exposes an OpenAI-compatible API, so migrating an existing application only requires changing the base URL and deploying the right binary.

Architecture

Kubecost and OpenCost: Native FinOps in Kubernetes

Kubecost and OpenCost map real costs to namespaces, deployments, and labels in Kubernetes. OpenCost, the Apache 2.0 open-source core, covers essentials for free. Kubecost adds multi-cluster visibility and advanced cloud billing. For clusters spending over $5,000/month the ROI is clear: identified savings typically exceed software cost within the first month.

Architecture

Litestream: Near-Real-Time Replication for SQLite

Litestream is an open-source tool that replicates a SQLite database to an S3 bucket in near real time by reading the WAL SQLite already writes. It offers point-in-time recovery, overhead of only 1 to 3% CPU, and replaces the need for a separate database server in small apps.

Architecture

Cloudflare Workers in 2024: KV, D1, and the New Edge Stack

Cloudflare Workers is no longer an isolated edge function. In 2024, together with KV, D1, R2, and Durable Objects, it forms a complete platform that matches AWS on latency and drops egress fees, though it still falls short on long-running compute and the mature managed databases AWS offers.

Architecture

Kubernetes 1.31: the stabilisations that matter day to day

Kubernetes 1.31 brings no fireworks, but it closes old debts: AppArmor reaches GA, native sidecars now run enabled by default on their way to stable in 1.33, and DRA moves through alpha toward beta. A practical review from the perspective of someone operating clusters in production.

Architecture

Service Mesh in 2024: Istio Ambient and Cilium Mesh

In 2024, the sidecar-or-not debate has an answer: Istio Ambient Mesh and Cilium Service Mesh bring sidecarless architecture to production, while Linkerd keeps ultra-light Rust sidecars. The right choice depends on your current CNI, the features you need, and the size of your ops team, not on which project wins in the abstract.

Architecture

Valkey: The Open Fork After Redis’s License Change

Redis moved to dual SSPL/RSAL licensing in March 2024, no longer meeting the OSI open-source definition. Valkey emerged as a BSD 3-Clause fork backed by AWS, Google Cloud, Oracle, and the Linux Foundation, fully protocol-compatible with Redis 7.2. Migrating is almost always trivial: swap the binary or the Docker image.

Architecture

Container Monitoring: Beyond cAdvisor

cAdvisor is still embedded in kubelet and covers surface metrics, but falls short for production Kubernetes. The modern minimum stack pairs it with kube-state-metrics, node-exporter, Prometheus, and Grafana as a base, eBPF for deep network and syscall visibility, and OpenTelemetry for application context.

Architecture

PostgreSQL 17: The Novelties That Show Promise

PostgreSQL 17, released in September 2024, cuts vacuum memory use by up to 20x, adds slot synchronization so logical replication survives a failover without a full resync, ships JSON_TABLE as standard SQL:2023 syntax, and introduces streaming I/O to speed up sequential scans. Teams running Postgres in production should start testing it in staging.

Architecture

PostgreSQL 16: Logical Replication That’s Now Practical

PostgreSQL 16 closes the historical gaps in logical replication: parallel apply near 2x faster, logical slots served from physical standbys, and the scaffolding for bidirectional replication. The result is a first-line tool for cross-version migrations and CDC pipelines.

Architecture

Modern SCADA in Containers: Advantages and Risks

Containerising SCADA makes sense for the upper architecture layers: HMI, historians, and data gateways. PLCs still control hardware with hard determinism. The biggest risk is cultural: applying DevOps patterns without adapting to OT context causes incidents. NIS2 requires managing containers as any other critical infrastructure asset.

Architecture

Cilium Service Mesh: When You Don’t Need Sidecars

Cilium Service Mesh replaces Istio or Linkerd sidecars with eBPF in the kernel: it handles policy, WireGuard encryption, and Hubble observability without a per-pod proxy, cutting memory overhead from roughly 100 GB to about 5 GB in a 100-node cluster. It suits large clusters with teams comfortable with eBPF.

Architecture

SQLite in Production: Not Just for Mobile

SQLite in production is more viable than most teams assume. WAL mode removes read contention, Litestream replicates the WAL to S3 in near-realtime, and LiteFS adds multi-node replication. Without a separate database server, apps like Tailscale and PocketBase already do this in production. This article explains when it makes sense and its real limits.

Architecture

Linkerd: The Pragmatic Service Mesh Alternative

Linkerd is the pragmatic service mesh for Kubernetes, prioritizing simplicity over feature catalogues. Its Rust proxy uses ~10 MB RAM per sidecar versus 50-100 MB for Envoy under Istio. This comparison explains when adopting it pays off, what it costs to operate, and when Istio makes more sense.

Architecture

How to Install PostgreSQL with pgvector Step by Step

This guide installs PostgreSQL 16 with pgvector on Debian or Ubuntu using the official PGDG repository, creates a dedicated role and database, tunes memory for production, and explains when the HNSW index beats IVFFlat depending on vector volume and the available maintenance window.

Architecture

Backstage, Port and Cortex: Three Paths to the IDP

An Internal Developer Platform (IDP) centralises service discovery, provisioning and observability in a single portal, so developers stop depending on stale wikis and Slack channels. Backstage, Port and Cortex dominate the market: Backstage is open source with a dedicated team, Port is fast low-code SaaS, and Cortex focuses on scorecards for measurable technical discipline based on team size.

Architecture

pgvector in 2024: HNSW Indexes and Real Scaling

pgvector matured in 2023-2024 with the HNSW index type and parallel construction that arrived in version 0.6. For projects already running PostgreSQL, a dedicated vector database is not needed in most cases: this guide explains when PostgreSQL is enough, how to configure the index, and where it starts to fall short.

Architecture

SQLite and DuckDB: When Each Is the Right Choice

SQLite and DuckDB are both embedded databases that work from a single file, no server needed. Their architecture differs: SQLite stores rows and excels at short transactions (OLTP); DuckDB stores columns and shines at large-scale analytics (OLAP). Choosing the right one, or combining both, delivers a genuine technical edge.

Architecture

GitOps With ArgoCD: From Hype to Stable Production

ArgoCD has established GitOps as the standard deployment practice for Kubernetes: the Git repository is the single source of truth for the desired state, and the agent continuously reconciles the cluster. This guide covers the four formal GitOps principles, sync policies, common production mistakes, and a comparison with Flux.

Architecture

Service Mesh in 2023: Istio, Linkerd, and the Cilium Option

A service mesh adds mTLS, uniform observability, and traffic management between microservices without modifying application code. The ecosystem has consolidated: Istio is the most complete and complex, Linkerd prioritises simplicity with Rust proxies, and Cilium delivers sidecarless service mesh via eBPF.

Architecture

containerd: The Runtime Underpinning Kubernetes

containerd is the runtime that runs containers in most modern Kubernetes clusters, and almost nobody notices. It manages the full container lifecycle: pulling the image, starting it, networking, and mounting the filesystem. It became the default runtime after Kubernetes 1.24 removed dockershim in May 2022.

Architecture

Event-Driven Architecture: When and How to Adopt It

Event-driven architecture decouples services through message brokers. Each component publishes events when something changes, instead of calling other services directly. It reduces coupling and improves resilience. It adds real value in domains with multiple consumers and natural asynchronous processing, but introduces operational complexity worth evaluating before adoption.