标签：#dev

Originally published on bckinfo.com Redis with Docker Compose: Persistence, Security, and Production-Ready Configuration Table of Contents Why Redis Containers Lose Data RDB vs AOF: Choosing a Persistence Strategy Basic Setup with Docker Compose Full Persistence Configuration Securing Redis in Docker Setting Resource Limits Redis in a Multi-Service Stack Backing Up and Restoring a Redis Volume Common Issues and Quick Fixes Closing Notes Redis is one of the most common services to run in Docker — it's fast to spin up, lightweight, and perfect for caching, session storage, and queues. But that same simplicity hides a trap: by default, Redis in Docker stores everything in memory, and the moment a container is removed, all of that data disappears . This guide walks through setting up Redis with Docker Compose the right way — covering persistence, authentication, resource limits, and the health checks you need before putting it anywhere near production. Why Redis Containers Lose Data A Docker container is meant to be disposable. That's a feature for stateless services, but it's a liability for a database like Redis. If you start a plain Redis container without a mounted volume, here's what happens: The container writes its dataset only inside its own writable layer. docker compose down or docker rm removes that layer entirely. The next time the container starts, Redis initializes with an empty dataset. This single oversight accounts for a large share of "we lost our session data" incidents in small teams running Redis in containers for the first time. The fix is straightforward once you understand the two persistence mechanisms Redis offers. RDB vs AOF: Choosing a Persistence Strategy Redis supports two persistence models, and production setups typically combine both: RDB (Redis Database snapshots) Point-in-time snapshots of the dataset, saved at intervals you define. Fast to restore, but you can lose any writes that happened after the last snapshot. AOF (Append Only Fil

Imagine if there were a way for us to somehow ship a full-stack package that you could plug into your...

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is...

Last month, I had a problem with a popular mobile banking app in Southeast Asia. Nothing exotic. A transaction didn't go through, and my support ticket had been sitting untouched for two weeks. So I opened the app's chatbot. It greeted me warmly, asked how it could help, and then couldn't do a single useful thing. It couldn't look up my transaction. It couldn't check the status of my ticket. It couldn't tell me why my issue was unresolved. It could answer FAQ questions, and that was it. I called the hotline instead. Spent an hour navigating prompts, got bounced between menus, and every path ended the same way: "Please contact our chatbot or check your existing ticket." The system was built for deflection, not resolution. The ticket that nobody had touched for fourteen days. I gave up. And somewhere in that company's dashboard, my interaction counted as a successful AI chatbot deflection. The uncomfortable part: if you shipped a deflection-optimized bot this quarter, a customer somewhere is living this exact loop right now. Your dashboard is calling it a win. The Deflection Metric Everyone Loves (and Nobody Questions) Deflection rate measures the percentage of customer contacts handled without a human agent. It's cheap to track, easy to celebrate, and it maps directly to cost savings. Industry benchmarks citing McKinsey's 2026 service operations data put AI resolutions at $0.62 per ticket versus $7.40 for human agents. That's a 12x cost difference. Of course executives love this number. But deflection doesn't measure whether the customer's problem got solved. It measures whether the customer stopped asking. Those are very different things. This is Goodhart's Law applied to customer experience: when a measure becomes a target, it ceases to be a good measure. Deflection is cheap and easy to optimize. Resolution is hard and expensive to track. So companies optimize the proxy and stop looking at the goal. Gartner data, as reported by Forbes , confirms the gap: only 14% o

Over the past year, one concept has fundamentally changed how I think about AI applications. Not larger language models. Not better prompts. Not even AI agents. It's Model Context Protocol (MCP) . For a long time, most AI applications lived inside a closed environment. They could generate text, answer questions, or write code, but they couldn't easily interact with external systems. MCP changes that. It provides a standardized way for AI models to communicate with tools, databases, APIs, and applications. Instead of building custom integrations for every project, developers can expose capabilities through MCP servers. After experimenting with different workflows, these are five MCP servers that have had the biggest impact on how I build AI applications. 1. GitHub MCP Server If you're building software with AI, GitHub integration is one of the most valuable capabilities you can add. Imagine asking an AI assistant to: Read a repository Review pull requests Search issues Create commits Open new issues Inspect project structure Instead of manually copying files into ChatGPT, the AI can interact directly with your repository. For developers, this dramatically improves productivity. Typical workflow: Developer Request ↓ GitHub MCP Server ↓ Repository ↓ LLM ↓ Action or Response This is far more scalable than copying snippets of code into prompts. 2. Filesystem MCP Server Almost every AI workflow eventually needs access to local files. Examples include: Reading documentation Editing Markdown Creating reports Refactoring code Updating configuration files Without an MCP server, these tasks often require multiple manual steps. With a Filesystem MCP server, an AI application can safely interact with project directories. For example: Read: /docs/api.md Update: /src/routes.py Create: /reports/summary.md This makes AI assistants feel much more like development partners. 3. PostgreSQL MCP Server One limitation of traditional chatbots is that they don't know your data. Connecting an

We're upgrading Crawlberg to a new version: Crawlberg v1.0.0. It builds on the previous kreuzcrawl. It declares the public API frozen under the new project name. All technical features below shipped in v0.3.0 (2026-06-23); v1.0.0 is a stability declaration and rename, not a new feature release. The four production-facing changes most likely to require operational action: Package and env var rename - every artifact identifier has changed; see the migration table. SSRF defense is now on by default - internal crawl targets (localhost, RFC 1918, cloud metadata) will fail without CRAWLBERG_ALLOW_PRIVATE_NETWORK=1 . CrawlError::WafBlocked is now a struct variant - exhaustive match arms will not compile until updated. max_retries semantics changed - off-by-one fixed; max_retries=3 now produces exactly 3 retries. Precompiled binaries cover Linux (x86_64/aarch64), macOS (ARM64 and x86_64), and Windows x64. Homebrew bottles and Docker images on GHCR are also available. What Is Crawlberg? Crawlberg is a web crawling engine written primarily in Rust that exposes a single consistent API across 14 language runtimes. It handles HTTP transport, JavaScript rendering, robots.txt compliance, per-domain rate limiting, SSRF safety, and structured extraction. Extension points ( Frontier , RateLimiter , CrawlStore , EventEmitter , ContentFilter , WafClassifier , ProxyProvider ) are injectable traits; wire in your own frontier, storage backend, or proxy pool without forking the engine. A single scrape() call returns text, metadata, links, images, assets, JSON-LD, Open Graph tags, hreflang, favicons, headings, response headers, and clean HTML→Markdown. When a site requires JavaScript, the optional headless browser tier handles it transparently. v1.0.0 promotes v1.0.0-rc.2 and freezes the public API under the new project name. The features described in the sections below represent the platform that 1.0.0 declares stable; they shipped in v0.3.0. What v1.0.0 Declares Stable These capabilities

I spend a lot of time in the AI space -- reading papers, building things, talking to engineers who are actually shipping. And there is a gap between what the demos show and what production systems actually look like that nobody is being fully honest about. So here is my honest take on where things actually are. The Problem With How We Talk About AI Agents Everyone is calling everything an "agent" right now. A function that calls a tool? Agent. A chatbot with memory? Agent. A script with a loop? Agent. This dilution is not just semantic. It is causing real engineering mistakes. When you do not have a precise definition for what you are building, you end up over-engineering simple pipelines and under-engineering genuinely complex ones. I have seen teams spend weeks adding "agentic" orchestration to workflows that would have been fine as a single well-structured prompt. Here is the definition I keep coming back to: an agent is a system that has an objective, not just an instruction. It decides what to do next. It handles failure. It knows when it is done. Everything else is just a fancy function call. 🟢 If your system needs a human to tell it each step, it is not an agent. It is a chat interface. 🔵 If your system can recover from a failed tool call and try a different approach, you are getting somewhere. ✅ If your system can decompose a goal into subtasks and delegate them, that is the real thing. What Is Actually Happening in Production Right Now The honest picture from teams I follow and talk to: Most real agent deployments are narrow. They do one thing well. Customer support triage. Document extraction. Code review on a specific codebase. They are not general-purpose reasoning engines. They are purpose-built pipelines with some intelligence in the decision layer. The teams getting good results are not chasing the latest model release. They are obsessing over: ☑️ Tool design -- what can the agent actually call, and how clean is the interface ☑️ Failure handling -- wh

I use my SSH manager every day. I also use a separate monitoring tool every day. For a long time I just accepted that these were two different things. Then one day I was SSH'd into a server that was behaving weird. I wanted to check if it was CPU or memory, but I had to open a different app, find the server in there, and wait for the dashboard to load. It took maybe 15 seconds. Not a huge deal. But it broke my flow every single time. I already had an SSH connection open to that server. Why was I opening a second thing just to see what was happening to it? That's what pushed me to build server monitoring directly into Termique, the SSH manager I've been working on. The interesting part: reusing the existing SSH connection SSH connections aren't just for terminals. The protocol supports multiple channels over a single TCP connection. You can have a terminal session running in one channel while sending short exec commands through another channel on the same connection. That's how the monitoring feature works. When you open the metrics panel for a server, Termique creates a separate exec channel on the existing SSH connection and polls /proc/stat for CPU, /proc/meminfo for RAM, and /proc/loadavg for system load. Short-lived commands, called on an interval, over the connection you already have open. No second SSH handshake. No separate auth. Just another channel on the same pipe. The tradeoff: you do need an agent I want to be upfront about this. The monitoring feature requires a small agent installed on each server. It's not agentless. I considered going agentless, relying entirely on /proc reads through exec channels. That works fine on most Linux servers. But the agent makes it easier to handle edge cases properly and opens the door for future features like alerts and longer history retention. Without it, I'd be fighting a lot of fragile shell parsing. If you're managing Linux servers, it's a one-command install. Non-Linux systems aren't supported yet. That's a real l

I log commutes in a spreadsheet because mobility apps smooth over the ugly legs. Last week I added a column I should have tracked years ago: carry seconds ? time from curb to platform when stairs replace ramps. The hidden leg My one-wheel leg is fine on paper. Three metro exits on my route have no elevator during maintenance. Carrying a 14 kg wheel down 22 stairs does not show up in trip duration. It shows up in whether I arrive annoyed enough to skip coffee. What I logged (one week) Exit Stairs Carry time (s) Mood after (1-5) North gate 22 38 2 Side ramp (control) 0 8 4 East stairs 16 29 3 Battery delta on those days? Within noise. Mood delta? Not noise. A cheap decision rule I turned this into a go/no-go check before leaving: if stairs > 15 AND carry_weight_kg > 12: prefer transit-only or locker elif stairs > 0 AND wet_floor: walk the wheel (no riding in station) else: ride It is blunt. It works better than pretending every leg is rideable. Assumptions up front Wheel weight includes pads and charger pouch (~14 kg for my commuter setup). I am not timing competitive carries ? just whether I can do this daily without hating it. Your threshold differs if every exit has elevators. What I would do differently I would log carry seconds from day one, same tab as distance and battery percent. Range math without carry math is incomplete for anyone who mixes metro and one-wheel. I work around personal EVs and sometimes cross-check specs on the official Kingsong catalog. https://www.kingsong.com/collections/electric-unicycle

Comparing the most feature-rich React data grids in 2026, from pivot tables and tree data to...

Two things happened this month and they tell you everything about where AI is actually going. Coinbase quietly cut its AI bill nearly in half. Open models, smarter routing, better caching. No drama. A finance footnote that happens to be a glimpse of the future. And Dario Amodei published another essay. Not a tweet. An essay. The kind of sprawling, twenty-thousand-word civilizational scripture he keeps handing down from the mount. This one is called "Policy on the AI Exponential," and the gist is that AI is about to hand humanity "almost unimaginable power," that our institutions are too immature to hold it, and that therefore the government should be able to test, gate, and block frontier models before mere mortals get hurt. One of these is a price cut. The other is a prophecy. I want to talk about the prophecy. The robes Let me be fair before I am not. Dario is not a dumb man and he is not a fraud. He runs one of the best labs in the world. The safety concerns are not all imaginary. Misuse is real. I am not the guy arguing that anyone should be able to download a bioweapon recipe for a laugh. If that is the bar, sure, regulate it. Nobody serious disagrees. But watch the move he keeps making. Every few months the prophet descends with a new text. The stakes are always civilizational. The language is always biblical. "Unimaginable power." A "decent possibility" of "significant enduring job loss." Disruption that will be "unusually painful." Humanity handed a force it is not mature enough to wield. He is not describing a product roadmap. He is describing a flood. And conveniently, he is also selling the ark. That is the part that should make you tilt your head. Read the actual proposal Strip the poetry off "Policy on the AI Exponential" and here is the machinery underneath. Mandatory third-party testing for any model above a compute threshold. Authorized evaluators. Security standards. Incident reporting. Government authority to block or reverse a deployment that fail

When Logs and Metrics Aren't Enough You have great dashboards. Your log aggregation is solid. But when a user reports "the checkout page is slow," you still spend 30 minutes jumping between services trying to find the bottleneck. That's the gap distributed tracing fills. What Tracing Actually Shows You A trace is a complete picture of a single request as it flows through your system: User Request → API Gateway → Auth Service → Product Service → DB → Cache → Response 5ms 12ms 45ms 120ms 3ms ^ This is your bottleneck Without tracing, you'd see: API Gateway: latency looks fine Auth Service: latency looks fine Product Service: latency is HIGH but why? With tracing, you see the exact DB query inside Product Service that's taking 120ms. Getting Started with OpenTelemetry OpenTelemetry is the standard. Here's a minimal setup: # Python example with Flask from opentelemetry import trace from opentelemetry.instrumentation.flask import FlaskInstrumentor from opentelemetry.instrumentation.requests import RequestsInstrumentor from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchSpanProcessor from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter # Setup provider = TracerProvider () provider . add_span_processor ( BatchSpanProcessor ( OTLPSpanExporter ( endpoint = " http://otel-collector:4317 " )) ) trace . set_tracer_provider ( provider ) # Auto-instrument everything FlaskInstrumentor (). instrument_app ( app ) RequestsInstrumentor (). instrument () SQLAlchemyInstrumentor (). instrument ( engine = db . engine ) That's it. Three auto-instrumentations cover 80% of what you need. Custom Spans for the Other 20% Auto-instrumentation gives you HTTP calls and DB queries. Add custom spans for business logic: tracer = trace . get_tracer ( __name__ ) def process_order ( order ): with tracer . start_as_current_span ( " process_order " ) as sp

I got laid off in March 2026. The day HR handed me the 30-day notice, I had a small panic attack, then opened my laptop and started building things. Here's the deal: I had 30 days before severance ran out, and I wanted to see how much I could ship with AI tools before the money (and motivation) ran dry. I gave myself a single rule — every project gets a 7-day deadline, otherwise I kill it. I built 6 things. One has real users. One broke in production. Two I never opened again. This is what happened, in the order I built them. 1. AI Buddy (Chrome sidebar) — shipped, 15 users A Chrome extension that puts an AI assistant in a sidebar. Select text on any page, hit a keyboard shortcut, it goes to the AI, reply shows up without you leaving the page. Works with GPT-4, Claude, Gemini, DeepSeek. No login, no credit card. Time: 11 days (April 1–11). Status: Live on Chrome Web Store. 15 real users as of June 28, 2026. Rating 4.2. What I used AI for: 90% of the code (500 lines of JavaScript, written in Cursor). The README, the Chrome Web Store description, the marketing tweets — all AI-drafted, then I rewrote the parts that sounded like AI. What went wrong: The first version had a Stripe integration. AI wrote 90% of the webhook signature verification. I had to rewrite it from scratch. Also the model-picker UI went through 5 revisions because AI kept proposing what looked right but didn't work. → Chrome Web Store 2. Weekly report generator — personal use only Every Friday at 4pm, a script grabs my git commits, Slack messages, and Linear ticket changes, throws them at GPT-4, and asks for a "manager-readable" weekly report. I review, tweak, send. Time: 2 days. ~200 lines of Python. Status: Running for 11 weeks. Has 1 user. Me. Cost is $0.12/week. What I used AI for: The prompt. It's surprisingly tricky to get GPT-4 to write a weekly report that doesn't sound like a robot. The single most useful line: "if you don't have data, write 'no progress this week' — don't make things up." T

Circuit breakers and bulkheads are design patterns — their numbers are operational weapons. Failure ratio 50% or 30%? Max concurrent calls 25 or 100? During an outage the right answer changes hourly . Code the pattern once; tune thresholds live . Kiponos.io separates resilience structure (in Java) from resilience parameters (in live config tree). Pattern in code, numbers in Kiponos public boolean allowCall ( String downstream ) { var cfg = kiponos . path ( "resilience" , downstream ); return breaker ( downstream ) . failureRateThreshold ( cfg . getFloat ( "failure_rate_threshold" )) . waitDurationInOpenState ( cfg . getInt ( "open_seconds" )) . permittedInHalfOpen ( cfg . getInt ( "half_open_calls" )) . tryAcquire (); } Ops opens circuit sensitivity during brownout — dashboard edit, not redeploy. Resilience tree resilience/ payments-api/ failure_rate_threshold : 0.5 open_seconds : 30 half_open_calls : 5 bulkhead_max_concurrent : 40 inventory-api/ failure_rate_threshold : 0.35 open_seconds : 60 bulkhead_max_concurrent : 25 global/ force_open_all : false Extreme: coordinated degradation Platform SRE sets force_open_all: false normally. During regional disaster, flip selective open_seconds sky-high on non-critical downstreams — bulkhead by configuration , Java still executes pattern logic. Performance Breaker checks are per-call — getFloat() must be local. See rate limits article . Getting started Externalize Resilience4j YAML values to resilience/* Incident drill: tighten failure_rate_threshold live Resources: github.com/kiponos-io/kiponos-io Kiponos.io — resilience patterns with live numbers. Breakers that bend during the outage.

you've felt it. you type a prompt, hit send, and the response starts streaming in under a second....

Dealing with vendor invoices usually means someone is sitting there manually opening PDFs and typing...

Aprenda a substituir o velho Cron por systemd timers para ganhar logs nativos, controle de dependências e maior robustez.

Like most developers, I have a set of tools I use every day. Most of them work great, and I don't...

Angular has signals now - and as of 19.2, even a signal-based way to fetch: httpResource, built on...

Last night I was deep in a build session with an AI assistant. We picked it back up tonight. At some point I mentioned it had been a day and a half since we last spoke — and the model had no idea. None. As far as it knew, it was still the previous session. The gap was invisible to it. That tiny moment is one of the most underrated problems in AI systems right now. So let's talk about it. The model doesn't know what time it is An LLM gets a rough sense of "now" at the start of a conversation — a single timestamp, handed to it once. That's why it can greet you with "good morning." But that stamp is frozen. It doesn't update as the conversation runs, and it definitely doesn't travel into the next conversation. Each session starts cold. On its own, that's a curiosity. It becomes a real problem the moment the model reasons over retrieved context — search results, documents, database rows, another agent's output. Staleness is invisible Here's the dangerous part. When a model reads a retrieved document, that document usually carries no trustworthy signal about when it was true . So the model treats it as present-tense. It produces a confident answer from six-month-old data with nothing flagging that the data is old. A few places this bites: Pricing — quoting a number that changed last quarter. Availability — "in stock" from a cached page. Compliance — citing a policy that was superseded. People — stating someone's job title from two years ago. For a human reader, a slightly stale search result is fine — you see the date and judge for yourself. For an LLM, the staleness is silent. The wrong answer looks exactly like a right one. Why "just add a clock" doesn't fix it The instinct is: give the model the current time. But knowing it's 9 PM doesn't help if the document you're citing went stale in 2023 and nothing told you. The missing piece isn't the model's clock — it's the context's freshness . Two different things: What time is it now? — easy, a now() call solves it. How old