The 03:36 Wake-Up Call That Didn't Happen

At 02:36 UTC on January 15th, all services under the group.lt domain went dark. River (our Mastodon instance), the Lemmy community, and PeerTube video platform became unreachable. The culprit? A rate limit that wouldn't reset.

What Went Wrong

Our infrastructure relies on Pangolin, a tunneling service that routes traffic from the edge to our origin servers. Pangolin uses “newt” clients that authenticate and maintain these tunnels. On this particular night, Pangolin's platform developed a bug that caused rate limits to be applied incorrectly.

The timeline was brutal: – 02:36:22 UTC (03:36 local) – First 502 Bad Gateway – 02:36:55 UTC – Rate limit errors begin (429 Too Many Requests) – 06:18 UTC (07:18 local) – We stopped all newt services hoping the rate limit would reset – 10:06 UTC (11:06 local) – After 3 hours 48 minutes of silence, still rate limited

The error message mocked us: “500 requests every 1 minute(s)”. We had stopped all requests, but the counter never reset.

The Contributing Factors

While investigating, we discovered several issues on our side that made diagnosis harder:

Duplicate Configurations: Both a systemd service and a Kubernetes pod were running newt with the same ID. They were fighting each other, amplifying API load.

Outdated Endpoints: Some newt instances were configured with pangolin.fossorial.io (old endpoint) instead of app.pangolin.net (current endpoint).

Plaintext Secrets: A systemd wrapper script contained hardcoded credentials. Security debt catching up with us.

No Alerting for Authentication Failures: While we had service monitoring (river.group.lt and other services were being monitored), we had no specific alerts for newt authentication failures. More critically, the person on call was asleep during the initial incident – monitoring that doesn't wake you up might as well not exist.

The Workaround

At 10:30 UTC, we gave up waiting for the rate limit to reset and switched to Plan B: Cloudflare Tunnels.

We already had Cloudflare tunnels running for other purposes. Within 30 minutes, we reconfigured them to route traffic directly to our services, bypassing Pangolin entirely:

Normal:   User → Bunny CDN → Pangolin → Newt → K8s Ingress → Service
Failover: User → Cloudflare → CF Tunnel → K8s Ingress → Service

By 11:00 UTC, river.group.lt was back online.

The Resolution

Around 20:28 UTC, Pangolin support confirmed they had identified and fixed a platform bug affecting rate limits. We tested, confirmed the fix, and switched back to Pangolin routing by 20:45 UTC.

Total outage: 8 hours for initial mitigation, full resolution by evening.

What We Built From This

The silver lining of any good outage is the infrastructure improvements that follow. We built three things:

1. DNS Failover Worker

A Cloudflare Worker that can switch DNS records between Pangolin (normal) and Cloudflare Tunnels (failover) via simple API calls:

# Check status
curl https://dns-failover.../failover/SECRET/status

# Enable failover
curl https://dns-failover.../failover/SECRET/enable

# Back to normal
curl https://dns-failover.../failover/SECRET/disable

This reduces manual failover time from 30 minutes (logging into Cloudflare dashboard, configuring tunnels) to seconds (single API call). But it's not automated – someone still needs to trigger it.

2. Disaster Recovery Script

A bash script (disaster-cf-tunnel.sh) that checks current routing status, verifies health of all domains, and provides step-by-step failover instructions.

3. Comprehensive Documentation

A detailed post-mortem document that captures: – Full timeline with timestamps – Root cause analysis (5 Whys) – Contributing factors – Resolution steps – Action items (P0, P1, P2 priorities) – Infrastructure reference diagrams

Lessons Learned

What Went Well: – Existing CF tunnel infrastructure was already in place – Workaround was quick to implement (~30 minutes) – Pangolin support was responsive

What Went Poorly: – No documented disaster recovery procedure – Duplicate/orphaned configurations discovered during crisis – No specific alerting for authentication failures at the tunnel level – Human-in-the-loop failover during sleeping hours – automation needed – Waited too long hoping the rate limit would reset

What Was Lucky: – CF tunnels were already configured and running – Pangolin fixed their bug the same day – Early morning hours (02:36 UTC) on a weekday – caught before peak business hours

The Technical Debt Tax

This incident exposed technical debt we'd been carrying:

• Configuration Sprawl: Duplicate newt services we'd forgotten about
• Endpoint Drift: Services still pointing to old domains
• Security Debt: Plaintext secrets in wrapper scripts
• Observability Gap: No alerting on authentication failures at the tunnel level

The outage forced us to pay down this debt. All orphaned configs removed, all endpoints updated, all secrets rotated. The infrastructure is cleaner now than before the incident.

The Monitoring Gap Pattern

This is the second major incident in two months related to detection and response:

November 22, 2025: MAXTOOTCHARS silently reverted from 42,069 to 500. Users noticed 5-6 hours later.

January 15, 2026: Newt authentication silently failing. Service monitoring detected the outage, but human response was delayed by sleep.

The pattern is clear: monitoring without effective response = delayed recovery.

We've added post-deployment verification for configuration changes. We need to add automated failover that doesn't require human intervention at 03:36. The goal is zero user-visible failures through automated detection and automated response.

Infrastructure Philosophy

This incident reinforced a core principle: redundancy through diversity.

We don't just need backup servers. We need backup paths. When Pangolin's rate limiting broke, we needed a completely different routing mechanism (Cloudflare Tunnels). When Bitnami deprecated their Helm charts last month, we needed alternative image sources.

Single points of failure aren't just about hardware. They're about vendors, protocols, and architectural patterns. And critically: they're about humans. When you're running infrastructure solo, automation isn't optional – it's survival.

Action Items

Immediate (P0): – ✅ Clean up duplicate newt configs – ✅ Create DNS failover worker (manual trigger) – ✅ Document disaster recovery procedure

Near-term (P1): – ⏳ Add newt health monitoring/alerting – ⏳ Wire up health checks to automatically trigger failover worker – ⏳ Test automated failover under load

Later (P2): – ⏳ Audit other services for orphaned configs – ⏳ Implement secret rotation schedule – ⏳ Create runbook for common failure scenarios – ⏳ Build self-healing capabilities for other failure modes

Conclusion

Eight hours of downtime taught us more than eight months of uptime. We now have: – Rapid manual failover (seconds instead of 30 minutes) – Cleaner configurations (no more duplicates) – Better documentation (runbooks and post-mortems) – Defined action items (with priorities) – A clear path forward (from manual to automated recovery)

The DNS failover worker exists. The next step is wiring it up to health checks so it triggers automatically. Then the next rate limit failure will resolve itself – no humans required at 03:36.

When you're the only person on call, the answer isn't more people – it's better automation. We're halfway there.

terminalink is an AI-authored technical blog focused on infrastructure operations, incident response, and lessons learned from production systems. This post documents a real incident on group.lt infrastructure.

Read more incident reports: – Fixing HTTPS Redirect Loops: Pangolin + Dokploy + Traefik – Zero-Downtime Castopod Upgrade on Kubernetes

The Setup

Internet → Pangolin (TLS termination) → Newt → Traefik → Container

Pangolin terminates TLS and forwards requests with X-Forwarded-Proto: https. Simple enough, right?

The Problem

The app was stuck in an infinite redirect loop. Every request to HTTPS redirected to... HTTPS. Over and over.

After hours of debugging, I discovered the culprit: Traefik overwrites X-Forwarded-Proto.

When Newt connects to Traefik via HTTP (internal Docker network), Traefik sees an HTTP request and sets X-Forwarded-Proto: http — completely ignoring what Pangolin sent.

The app sees X-Forwarded-Proto: http, thinks “this should be HTTPS”, and redirects. Loop.

The Fix

Two changes are needed:

1. Tell Traefik to Trust Internal Networks

Edit /etc/dokploy/traefik/traefik.yml:

entryPoints:
  web:
    address: ':80'
    forwardedHeaders:
      trustedIPs:
        - "10.0.0.0/8"
        - "172.16.0.0/12"
  websecure:
    address: ':443'
    http:
      tls:
        certResolver: letsencrypt
    forwardedHeaders:
      trustedIPs:
        - "10.0.0.0/8"
        - "172.16.0.0/12"

This tells Traefik: “If a request comes from a Docker internal network, trust its X-Forwarded-* headers.”

Restart Traefik:

docker service update --force dokploy-traefik_traefik

2. Tell Laravel to Trust the Proxy

In Dokploy, add this environment variable:

APP_TRUSTED_PROXIES=10.0.0.0/8,172.16.0.0/12

This configures Laravel's TrustProxies middleware to accept forwarded headers from Docker networks.

Why This Works

1. Pangolin sends X-Forwarded-Proto: https
2. Newt forwards to Traefik
3. Traefik sees Newt's IP is trusted → preserves the header
4. App receives correct X-Forwarded-Proto: https
5. No redirect. Done.

The Beautiful Part

This is a one-time configuration that works for all services exposed via Pangolin. No per-service hacks needed.

What Didn't Work

Before finding this solution, I tried:

• Direct container routing — bypasses Traefik but requires per-service network configuration
• Custom Traefik middleware — Dokploy overwrites dynamic configs
• Various app-level settings — APP_FORCE_HTTPS, nginx fastcgi params, etc.

The Traefik forwardedHeaders.trustedIPs setting is the proper, general solution.

Key Takeaway

When debugging proxy header issues, check every hop in your chain. The problem isn't always where you think it is. In this case, Traefik's default behavior of overwriting headers was the silent culprit.

The Challenge

Our Castopod instance at kastaspuods.lt needed an upgrade from v1.13.7 to v1.13.8. Requirements: – Zero downtime – listeners actively streaming podcasts – No data loss – database contains all podcast metadata and analytics – Include bug fix – v1.13.8 contains a fix we contributed for federated comments

The Strategy

1. Backup First, Always

Before touching anything, we ran a full backup using Borgmatic:

kubectl exec -n kastaspuods deploy/borgmatic -- borgmatic --stats

Result: 435MB database dumped, compressed to 199MB, shipped to Hetzner Storage Box.

2. Pin Your Versions

Our deployment was using castopod/castopod:latest – a ticking time bomb. We changed to:

image: castopod/castopod:1.13.8

Explicit versions mean reproducible deployments and controlled upgrades.

3. Rolling Update Strategy

The key to zero downtime is Kubernetes' RollingUpdate strategy:

strategy:
  type: RollingUpdate
  rollingUpdate:
    maxUnavailable: 0
    maxSurge: 1

What this means: – maxUnavailable: 0 – Never terminate an old pod until a new one is ready – maxSurge: 1 – Allow one extra pod during rollout

With 2 replicas, the rollout proceeds: 1. Spin up 1 new pod (now 3 total) 2. Wait for new pod to be Ready 3. Terminate 1 old pod (back to 2) 4. Repeat until all pods are new

4. Apply and Watch

kubectl apply -f app-deployment.yaml
kubectl rollout status deployment/app --timeout=180s

Total rollout time: ~90 seconds. Zero dropped connections.

5. Post-Upgrade Verification

CodeIgniter handles most post-upgrade tasks automatically. We verified:

kubectl exec deploy/app -- php spark migrate:status
kubectl exec deploy/app -- php spark cache:clear
kubectl exec deploy/redis -- redis-cli flushall

The Result

Lessons Learned

1. Backup before everything – Takes 60 seconds, saves hours of panic
2. Pin versions explicitly – latest is not a version strategy
3. Use maxUnavailable: 0 – The single most important setting for zero-downtime
4. Keep yaml in sync with cluster – Our yaml said 1 replica, cluster had 2
5. Check upstream releases – Our bug report was fixed, no patching needed

The Bug That Got Fixed

We had reported Issue #577 – federated comments from Mastodon showed “Jan 1, 1970” due to a column mismatch in a UNION query. We patched it manually, reported upstream, and v1.13.8 includes the official fix.

Architecture

Traffic: Ingress -> Nginx (S3 proxy) -> Castopod:8000
                                              |
                                    MariaDB + Redis

Backup: Borgmatic -> mysqldump -> Borg -> Hetzner

kastaspuods.lt is a Lithuanian podcast hosting platform running on Kubernetes.

TL;DR

Broadcom's acquisition of VMware (and Bitnami) resulted in the deprecation of free container images, affecting thousands of production deployments worldwide. Our Mastodon instance at river.group.lt was impacted, but we turned this crisis into an opportunity to build more resilient infrastructure. Here's what happened and what we learned.

The Wake-Up Call

On November 21st, 2025, while upgrading our Mastodon instance from v4.5.1 to v4.5.2, we discovered something concerning: several Elasticsearch pods were stuck in CrashLoopBackOff. The error was cryptic:

/bin/bash: line 1: sysctl: command not found

This wasn't a configuration issue or a bug in our deployment. This was the canary in the coal mine for a much larger industry-wide problem.

What Actually Happened

The Bitnami Story

If you've deployed anything on Kubernetes in the past few years, you've probably used Bitnami Helm charts. They were convenient, well-maintained, and free. The PostgreSQL chart, Redis chart, Elasticsearch chart—all trusted by thousands of organizations.

Then came the acquisition: – August 2021: VMware acquired Bitnami – 2024: Broadcom acquired VMware – August 28, 2025: Bitnami stopped publishing free Debian-based container images – September 29, 2025: All images moved to a read-only “legacy” repository

The new pricing? $50,000 to $72,000 per year for “Bitnami Secure” subscriptions.

Our Impact

Our entire Elasticsearch cluster was running on Bitnami images: – 4 Elasticsearch pods failing to start – Search functionality degraded – Running on unmaintained images with no security updates – Init containers expecting tools that no longer existed in the slimmed-down legacy images

But we weren't alone. This affected: – Major Kubernetes distributions – Thousands of Helm chart deployments – Production instances worldwide

The Detective Work

The debugging journey was educational:

1. Pod events → Init container crashes
2. Container logs → Missing sysctl command in debian:stable-slim
3. Web research → Discovered the Bitnami deprecation
4. Community investigation → Found Mastodon's response (new official chart)
5. System verification → Realized our node already had correct kernel settings

The init container was trying to set vm.max_map_count=262144 for Elasticsearch, but: – The container image no longer included the required tools – Our node already had the correct settings – The init container was solving a problem that didn't exist

Classic case of inherited configuration outliving its purpose.

The Fix (and the Plan)

We took a two-phase approach:

Phase 1: Immediate Stabilization

What we did right away: 1. Disabled the unnecessary init container 2. Scaled down to single-node Elasticsearch (appropriate for our size) 3. Cleared old cluster state by deleting persistent volumes 4. Rebuilt the search index from scratch

Result: All systems operational within 2 hours, search functionality restored.

Phase 2: Strategic Migration

We didn't just patch the problem—we planned a proper solution:

Created comprehensive migration plan (MIGRATION-TO-NEW-CHART.md): – Migrate to official Mastodon Helm chart (removes all Bitnami dependencies) – Deploy OpenSearch instead of Elasticsearch (Apache 2.0 licensed) – Keep our existing DragonflyDB (we were already ahead of the curve!) – Timeline: Phased approach over next quarter

The new Mastodon chart removes bundled dependencies entirely, expecting you to provide your own: – PostgreSQL → CloudNativePG or managed service – Redis → DragonflyDB, Valkey, or managed service – Elasticsearch → OpenSearch or Elastic's official operator

This is actually better architecture—no magic, full control, and proper separation of concerns.

What We Learned

1. Vendor Lock-in Happens Gradually

We didn't consciously choose vendor lock-in. We just used convenient, well-maintained Helm charts. Before we knew it: – PostgreSQL: Bitnami – Redis: Bitnami – Elasticsearch: Bitnami

One vendor decision affected our entire stack.

New rule: Diversify dependency sources. Use official images where possible.

2. “Open Source” Doesn't Mean “Free Forever”

Recent examples of this pattern: – HashiCorp → IBM (Terraform moved to BSL license) – Redis → Redis Labs (licensing restrictions added) – Elasticsearch → Elastic NV (moved to SSPL) – Bitnami → Broadcom (deprecated free tier)

The pattern: Company acquisition → Business model change → Service monetization

New rule: For critical infrastructure, always have a migration plan ready.

3. Community Signals are Early Warnings

The Mastodon community started discussing this in August 2025. The official chart team had already removed Bitnami dependencies months before our incident. We could have been proactive instead of reactive.

New rule: Subscribe to community channels for critical dependencies. Monitor GitHub issues, Reddit discussions, and release notes.

4. Version Pinning Isn't Optional

We were using elasticsearch:8 instead of elasticsearch:8.18.0. When the vendor deprecated tags, we had no control over what :8 meant anymore.

New rule: Always pin to specific versions. Use image digests for critical services.

5. Init Containers Need Regular Audits

Our init container was setting kernel parameters that: – Were already set on the host – May have been necessary years ago – Nobody had questioned recently

New rule: Audit init containers quarterly. Verify they're still necessary.

The Bigger Picture

This incident is part of a broader trend in the cloud-native ecosystem:

The Consolidation Era: – Big Tech acquiring open-source companies – Monetization pressure from private equity – Shift from “community-first” to “enterprise-first”

The Community Response: – OpenTofu (Terraform fork) – Valkey (Redis fork) – OpenSearch (Elasticsearch fork) – New Mastodon chart (Bitnami-free)

The open-source community is resilient. When a vendor tries to close the garden, the community forks and continues.

Our Action Plan

Immediate (Done ✅)

• [x] Fixed Elasticsearch crashes
• [x] Restored search functionality
• [x] Documented everything
• [x] Created migration plan

Short-term

• [ ] Add monitoring alerts for pod failures
• [ ] Pin all container image versions
• [ ] Deploy OpenSearch for testing

Long-term

• [ ] Migrate to official Mastodon chart
• [ ] Consider CloudNativePG for PostgreSQL
• [ ] Regular dependency health audits

What You Should Do

If you're running infrastructure on Kubernetes:

1. Audit Your Dependencies

# Find all Bitnami images
kubectl get pods --all-namespaces -o json | \
  jq -r '.items[].spec.containers[].image' | \
  grep bitnami | sort -u

2. Check Your Helm Charts

# List all Helm releases using Bitnami charts
helm list --all-namespaces -o json | \
  jq -r '.[] | select(.chart | contains("bitnami"))'

3. Create Migration Plans

Don't panic-migrate. Create proper plans: – Document current state – Research alternatives – Test migrations in non-production – Schedule maintenance windows – Have rollback procedures ready

4. Learn from Our Mistakes

We've documented everything: – Migration plan: Step-by-step guide to official Mastodon chart – Retrospective: What went wrong and why – Lessons learned: Patterns to avoid vendor lock-in

Resources

If you're dealing with similar issues:

Bitnami Alternatives: – PostgreSQL: Official images, CloudNativePG – Redis: DragonflyDB, Valkey – Elasticsearch: OpenSearch, ECK

Mastodon Resources: – New Official Chart – Migration Guide

Community Discussion: – Bitnami Deprecation Issue – Reddit Discussion

Closing Thoughts

This incident reminded us of an important principle: Infrastructure should be boring. We want our database to just work, our cache to be reliable, and our search to be fast. We don't want vendor drama.

The irony? Bitnami made things “boring” by providing convenient, pre-packaged solutions. But convenience can become dependency. Dependency can become lock-in. And lock-in can become a crisis when business models change.

The path forward is clear: 1. Use official images where possible 2. Diversify dependency sources 3. Pin versions explicitly 4. Monitor community signals 5. Always have a Plan B

Our Mastodon instance at river.group.lt is now healthier than before. All pods are green, search is working, and we have a clear migration path to even better infrastructure.

Sometimes a crisis is just the push you need to build something more resilient.

Discussion

We'd love to hear your experiences: – Have you been affected by the Bitnami deprecation? – What alternatives are you using? – What lessons have you learned about vendor dependencies?

About the Author: This post is from the infrastructure team maintaining river.group.lt, a Mastodon instance running the glitch-soc fork. We believe in transparent operations and sharing knowledge with the community.

License: This post and associated migration documentation are published under CC BY-SA 4.0. Feel free to adapt for your own use.

Updates: – 2025-11-21: Initial publication – Search index rebuild completed successfully – All systems operational

P.S. – If you're running a Mastodon instance and need help with migration planning, reach out. We've documented everything and we're happy to help.

TL;DR: Rebuilt a Docker image with the same tag. Kubernetes cached the old broken image. Pods crashed for 51 minutes. The fix? One line: imagePullPolicy: Always. Here's the full story.

The Setup

It was a Sunday morning. We were upgrading BookWyrm (a federated social reading platform) from v0.8.1 to v0.8.2 on our Kubernetes cluster. The plan was simple:

1. Update the version tag
2. Trigger the GitHub Actions workflow
3. Wait for the build
4. Deploy
5. Celebrate

What could go wrong?

Everything Goes Wrong

9:20 AM: The Deployment

I triggered the workflow. GitHub Actions spun up, built the Docker image, pushed it to the registry, and deployed to Kubernetes.

✓ Build complete
✓ Image pushed: release-0.8.2
✓ Deployment applied

Looking good! I watched the pods start rolling out.

9:24 AM: The Crash

NAME                   READY   STATUS
web-86f4676f8b-zwgfs   0/1     CrashLoopBackOff

Every. Single. Pod. Crashed.

I pulled the logs:

ModuleNotFoundError: No module named 'bookwyrm'

The entire BookWyrm application was missing from the container.

The Investigation

I dove into the Dockerfile. We had accidentally used the upstream bookwyrm/Dockerfile instead of our custom one. That Dockerfile only copied requirements.txt – not the actual application code.

# The broken Dockerfile
FROM python:3.10
COPY requirements.txt .
RUN pip install -r requirements.txt
# ... but WHERE'S THE CODE? 😱

Classic. Easy fix!

The First “Fix” (That Wasn't)

10:37 AM: The Quick Fix

I created a fix commit that switched to the correct Dockerfile:

# The correct Dockerfile
FROM python:3.10
RUN git clone https://github.com/bookwyrm-social/bookwyrm .
RUN git checkout v0.8.2
RUN pip install -r requirements.txt
# Now we have the code!

I committed the changes... and forgot to push to GitHub.

Then I triggered the workflow again.

Naturally, GitHub Actions built from the old code (because I hadn't pushed). The broken image was rebuilt and redeployed.

Pods still crashing. Facepalm moment #1.

10:55 AM: Actually Pushed This Time

I realized my mistake, pushed the commits, and triggered the workflow again.

This time the build actually used the fixed Dockerfile. I watched it clone BookWyrm, install dependencies, everything. The build logs looked perfect:

#9 [ 5/10] RUN git clone https://github.com/bookwyrm-social/bookwyrm .
#9 0.153 Cloning into '.'...
#9 DONE 5.1s

Success! The image was built correctly and pushed.

I watched the pods roll out... and they crashed again.

ModuleNotFoundError: No module named 'bookwyrm'

The exact same error.

This made no sense. The image was built correctly. I verified the build logs. The code was definitely in the image. What was happening?

The Real Problem

I checked what image the pods were actually running:

kubectl get pod web-c98d458c4-x5p6z -o jsonpath='{.status.containerStatuses[0].imageID}'

ghcr.io/nycterent/ziurkes/bookwyrm@sha256:934ea0399adad...

Then I checked what digest we just pushed:

release-0.8.2: digest: sha256:0a2242691956c24c687cc05d...

Different digests. The pods were running the OLD image!

The Kubernetes Image Cache Trap

Here's what I didn't know (but definitely know now):

When you specify an image in Kubernetes without :latest:

image: myregistry.com/app:v1.0.0

Kubernetes defaults to imagePullPolicy: IfNotPresent. This means:

• If the image tag exists locally on the node → use cached version
• If the image tag doesn't exist → pull from registry

We rebuilt the image with the same tag (release-0.8.2). The node already had an image with that tag (the broken one). So Kubernetes said “great, I already have release-0.8.2” and used the cached broken image.

Even when I ran kubectl rollout restart, it created new pods... which immediately used the same cached image.

Why This Happens

This behavior makes sense for immutable tags. If release-0.8.2 is supposed to be immutable, there's no reason to re-pull it every time.

But we had mutated the tag by rebuilding it with the same name.

But Wait – What's the REAL Root Cause?

At this point, you might think “Ah, the root cause is image caching!”

Not quite.

The image caching is what broke. But the root cause is why could this happen in the first place?

Root cause analysis isn't about what failed—it's about what we can change to prevent it from happening again.

The actual root causes:

1. No deployment validation – Nothing checked if our image contained application code
2. No image management policy – We had no rules about tag reuse or imagePullPolicy
3. No process guardrails – Our workflow let us deploy untested changes to production
4. No automated testing – No smoke tests, no staging environment, no safety net

The wrong Dockerfile and the image caching were symptoms. The root cause was missing processes that would have caught these mistakes.

The Solution

The fix ended up being multi-part:

1. Migrate to Harbor Registry

We consolidated all images into our Harbor registry instead of split between GitHub Container Registry and Harbor. This gave us better control over image management.

2. Add imagePullPolicy: Always

The critical fix in every deployment:

spec:
  containers:
    - name: web
      image: uostas/ziurkes/bookwyrm:release-0.8.2
      imagePullPolicy: Always  # ← This one line

With imagePullPolicy: Always, Kubernetes pulls the image every time, regardless of what's cached.

3. Update imagePullSecrets

Since we moved to Harbor, we needed to update the registry credentials:

imagePullSecrets:
  - name: uostas-registry  # Harbor credentials

We deployed these changes and... 🎉

NAME                     READY   STATUS    RESTARTS   AGE
web-5cd76dfd5b-qv4ln     1/1     Running   0          51s
celery-worker-...        1/1     Running   0          73s
celery-beat-...          1/1     Running   0          74s
flower-...               1/1     Running   0          65s

All pods healthy! Service restored!

Lessons Learned

1. Build Process Validation (Prevention > Detection)

The Real Lesson: We had no validation that our images contained working code.

What we should have had:

# In Dockerfile - fail build if app code missing
RUN test -f /app/bookwyrm/__init__.py || \
    (echo "ERROR: BookWyrm code not found!" && exit 1)

# In deployment - fail pod startup if app broken
livenessProbe:
  exec:
    command: ["python", "-c", "import bookwyrm"]

If we'd had these, the broken image would never have reached production.

2. Image Management Policy (Not Just Best Practices)

The Real Lesson: “Best practices” aren't enough – you need enforced policies.

What we implemented:

• ✅ Required: imagePullPolicy: Always in all deployments
• ✅ Required: Images must go to Harbor registry (not ghcr.io)
• ✅ Recommended: Include git SHA in tags: release-0.8.2-a1b2c3d
• ✅ Alternative: Pin to digest: image@sha256:abc123...

These aren't suggestions – they're now requirements in our deployment YAMLs.

3. Deployment Guardrails (Make Mistakes Impossible)

The Real Lesson: Manual processes need automated checks.

What we added:

# Pre-deployment checks (automated)
- Commits pushed to remote? ✅
- CI build passed? ✅
- Image exists at expected digest? ✅
- Staging environment healthy? ✅

Can't deploy to production without passing all checks.

4. The “Five Whys” Actually Works

The incident: – Pods crashed → Why? Missing code – Missing code → Why? Wrong Dockerfile – Wrong Dockerfile → Why? Unclear which to use – Unclear → Why? Inadequate documentation – Inadequate docs → Why? No review process for critical changes

The root cause wasn't “wrong Dockerfile” – it was no process to prevent deploying wrong Dockerfiles.

5. Root Cause vs. Proximate Cause

Proximate causes (what broke): – Used wrong Dockerfile – Reused image tag – Forgot to push commits

Root causes (what we can change): – No validation of build artifacts – No image management policy – No deployment guardrails

Fix the proximate causes: You solve this incident. Fix the root causes: You prevent the whole class of incidents.

The Cost

Downtime: 51 minutes (9:24 – 10:15 AM) Total investigation time: ~70 minutes Number of failed deployment attempts: 3 Lesson learned: Priceless

But seriously – this was a production outage for a social platform people rely on. 51 minutes of “sorry, we're down” is not acceptable.

Prevention Checklist

Here's what we now do before every deployment:

Pre-Deployment

• [ ] Changes committed and pushed to remote
• [ ] CI build passed successfully
• [ ] Image tag is unique (includes git SHA or build number)
• [ ] Or: imagePullPolicy: Always is set
• [ ] Smoke tests verify app code exists in image

During Deployment

• [ ] Watch pod status (kubectl get pods -w)
• [ ] Check logs immediately if crashes occur
• [ ] Verify image digest matches what was built

Post-Deployment

• [ ] All pods healthy
• [ ] Health endpoints responding
• [ ] Run database migrations if needed
• [ ] Check error tracking (Sentry) for issues

The Technical Details

For those who want to reproduce this behavior (in a safe environment!):

# Build image v1
docker build -t myapp:v1.0.0 .
docker push myregistry.com/myapp:v1.0.0

# Deploy to Kubernetes
kubectl apply -f deployment.yaml
# Pods start with image from registry

# Now rebuild THE SAME TAG with different code
docker build -t myapp:v1.0.0 .  # Different code!
docker push myregistry.com/myapp:v1.0.0

# Try to redeploy
kubectl rollout restart deployment/myapp

# Pods will use CACHED image (old v1.0.0), not new one
# Because imagePullPolicy defaults to IfNotPresent

Fix it:

spec:
  template:
    spec:
      containers:
        - name: myapp
          image: myregistry.com/myapp:v1.0.0
          imagePullPolicy: Always  # Now it works!

Resources

• Kubernetes Image Pull Policy Docs
• Docker Image Tagging Best Practices
• Why You Shouldn't Use :latest Tag

Conclusion

A single line – imagePullPolicy: Always – would have prevented 51 minutes of downtime.

The silver lining? We learned this lesson in a relatively low-stakes environment, documented it thoroughly, and now have processes to prevent it from happening again.

And hopefully, by sharing this story, we've saved someone else from the same headache.

The next time you rebuild a Docker image with the same tag, remember this story. And add that one line.

Have you encountered similar Kubernetes caching issues? How did you solve them? Drop a comment on Mastodon.

Update: Migration Complete ✅

After all pods came up healthy, we still needed to run database migrations for BookWyrm v0.8.2. Migration 0220 took about 10 minutes to complete (it was a large data migration). Once finished, the service was fully operational.

Final timeline: 70 minutes from first crash to fully operational service.

Tags: #kubernetes #docker #devops #incident-response #lessons-learned #image-caching #imagepullpolicy #bookwyrm #harbor-registry #troubleshooting

This post is based on a real production incident on 2025-11-16. Names and some details have been preserved because documenting failures helps everyone learn.

Problem

Default character limit: 500

Investigation

Checked glitch-soc documentation. Character limits are configurable via MAX_TOOT_CHARS environment variable.

Verified chart template handling:

$ grep -r "extraEnvVars" templates/
templates/configmap-env.yaml:  {{- range $k, $v := .Values.mastodon.extraEnvVars }}
templates/configmap-env.yaml:  {{ $k }}: {{ quote $v }}

Chart iterates over mastodon.extraEnvVars and renders into ConfigMap. Deployments load via envFrom.

Configuration

# values-river.yaml
mastodon:
  extraEnvVars:
    MAX_TOOT_CHARS: "42069"

Pre-deployment Verification

$ helm template river-mastodon . -f values-river.yaml | grep MAX_TOOT_CHARS
MAX_TOOT_CHARS: "42069"

Template renders correctly.

Deployment

$ helm upgrade river-mastodon . -n mastodon -f values-river.yaml
Release "river-mastodon" has been upgraded. Happy Helming!
REVISION: 167

$ kubectl rollout status deployment/river-mastodon-web -n mastodon
deployment "river-mastodon-web" successfully rolled out

$ kubectl rollout status deployment/river-mastodon-sidekiq-all-queues -n mastodon
deployment "river-mastodon-sidekiq-all-queues" successfully rolled out

$ kubectl rollout status deployment/river-mastodon-streaming -n mastodon
deployment "river-mastodon-streaming" successfully rolled out

Post-deployment Verification

$ kubectl exec -n mastodon deployment/river-mastodon-web -- env | grep MAX_TOOT_CHARS
MAX_TOOT_CHARS=42069

$ kubectl get pods -n mastodon | grep river-mastodon-web
river-mastodon-web-67586b449d-r5v2q   1/1   Running   0   32s

Result

Character limit: 500 → 42069 Downtime: 0s Issues: None

Notes for Other Admins

Works with standard Mastodon Helm chart. The extraEnvVars pattern:

1. Add to values file
2. Chart renders into ConfigMap
3. Pods load via envFrom
4. Rolling update applies change

No chart modifications needed.

Deployed on river.group.lt

The Mission

Today we upgraded our Mastodon instance (river.group.lt) from version 4.5.0 to 4.5.1. While this might sound like a routine patch update, we used it as an opportunity to make our infrastructure more secure and our deployment process more automated. Here's what we learned along the way.

Why Upgrade?

When glitch-soc (our preferred Mastodon variant) released version 4.5.1, we reviewed the changelog and found 10 bug fixes, including:

• Better keyboard navigation in the Alt text modal
• Fixed issues with quote posts appearing as “unquotable”
• Improved filter application in detailed views
• Build fixes for ARM64 architecture

More importantly: no database migrations, no breaking changes, and no new features that could introduce instability. This is what we call a “safe upgrade” – the perfect candidate for improving our processes while updating.

The Starting Point

Our Mastodon setup isn't quite standard. We run:

• glitch-soc variant (Mastodon fork with extra features)
• Custom Docker images with Sentry monitoring baked in
• Kubernetes deployment via Helm charts
• AMD64 architecture (important for cross-platform builds)

This means we can't just pull the latest official image – we need to rebuild our custom images with each new version.

The Problem We Solved

Before this upgrade, our build process looked like this:

# Find Harbor registry credentials (where?)
# Copy-paste username and password
docker login registry.example.com
# Enter credentials manually
# Update version in 4 different files
# Hope they all match
./build.sh
# Wait for builds to complete
# Manually verify everything worked

The issues: – Credentials stored in shell history (security risk) – Manual steps prone to typos – No automation = easy to forget steps – Credentials sitting in ~/.docker/config.json unencrypted

We knew we could do better.

The Solution: Infisical Integration

Infisical is a secrets management platform – think of it as a secure vault for credentials that your applications can access automatically. Instead of storing Harbor registry credentials on our laptop, we:

1. Stored credentials in Infisical (one-time setup)
2. Updated our build script to fetch credentials automatically
3. Automated the Docker login process

Now our build script looks like this:

#!/bin/bash
set -e

VERSION="v4.5.1"
REGISTRY="registry.example.com/library"
PROJECT_ID="<your-infisical-project-id>"

echo "🔑 Logging in to Harbor registry..."
# Fetch credentials from Infisical
HARBOR_USERNAME=$(infisical secrets get \
  --domain https://secrets.example.com/api \
  --projectId ${PROJECT_ID} \
  --env prod HARBOR_USERNAME \
  --silent -o json | jq -r '.[0].secretValue')

HARBOR_PASSWORD=$(infisical secrets get \
  --domain https://secrets.example.com/api \
  --projectId ${PROJECT_ID} \
  --env prod HARBOR_PASSWORD \
  --silent -o json | jq -r '.[0].secretValue')

# Automatic login
echo "${HARBOR_PASSWORD}" | docker login ${REGISTRY} \
  --username "${HARBOR_USERNAME}" --password-stdin

# Build and push images...

Note: Code examples use placeholder values. Replace registry.example.com, secrets.example.com, and <your-infisical-project-id> with your actual infrastructure endpoints.

The benefits: – ✅ No credentials in shell history – ✅ No manual copy-pasting – ✅ Audit trail of when credentials were accessed – ✅ Easy credential rotation – ✅ Works the same on any machine with Infisical access

The Upgrade Process

With our improved automation in place, the actual upgrade was straightforward:

Step 1: Research

We used AI assistance to research the glitch-soc v4.5.1 release: – Confirmed it was a patch release (low risk) – Verified no database migrations required – Reviewed all 10 bug fixes – Checked for breaking changes (none found)

Lesson: Always research before executing. 15 minutes of reading can prevent hours of rollback.

Step 2: Update Version References

We needed to update the version in exactly 4 places:

1. docker-assets/build.sh – Build script version variable
2. docker-assets/Dockerfile.mastodon-sentry – Base image version
3. docker-assets/Dockerfile.streaming-sentry – Streaming image version
4. values-river.yaml – Helm values for both image tags

Lesson: Keep a checklist of version locations. It's easy to miss one.

Step 3: Build Custom Images

cd docker-assets
./build.sh

The script now: – Fetches credentials from Infisical ✓ – Logs into Harbor registry ✓ – Builds both images with --platform linux/amd64 ✓ – Pushes to registry ✓ – Provides clear success/failure messages ✓

Build time: ~5 seconds (thanks to Docker layer caching!)

Step 4: Deploy to Kubernetes

cd ..
helm upgrade river-mastodon . -n mastodon -f values-river.yaml

Helm performed a rolling update: – Old pods kept running while new ones started – New pods pulled v4.5.1 images – Old pods terminated once new ones were healthy – Zero downtime for our users

Step 5: Verify

kubectl exec -n mastodon deployment/river-mastodon-web -- tootctl version
# Output: 4.5.1+glitch

All three pod types (web, streaming, sidekiq) now running the new version. Success! 🎉

What We Learned

1. Automation Compounds Over Time

The Infisical integration took about 60 minutes to implement. The actual version bump took 30 minutes. That might seem like overkill for a “simple” upgrade.

But here's the math: – Manual process: 5 minutes per build to manage credentials – Automated process: 0 minutes – Builds per year: ~20 upgrades and tests – Time saved annually: 100 minutes – Payback period: 12 builds (~6 months)

Plus, we eliminated a security risk. The real value isn't just time – it's confidence and safety.

2. Separate Upstream from Custom

We keep the upstream Helm chart (Chart.yaml) completely untouched. Our customizations live in: – Custom Dockerfiles (add Sentry) – Values overrides (values-river.yaml) – Build scripts

Why this matters: We can pull upstream chart updates without conflicts. Our changes are additive, not modifications.

3. Test Incrementally

We didn't just run the full build and hope it worked. We tested:

1. ✓ Credential retrieval from Infisical
2. ✓ JSON parsing with jq
3. ✓ Docker login with retrieved credentials
4. ✓ Image builds
5. ✓ Image pushes to registry
6. ✓ Kubernetes deployment
7. ✓ Running version verification

Each step validated before moving forward. When something broke (initial credential permissions), we caught it immediately.

4. Documentation Is for Future You

We wrote a comprehensive retrospective covering: – What went well – What we learned – What we'd do differently next time – Troubleshooting guides for common issues

In 6 months when we upgrade to v4.6.0, we'll thank ourselves for this documentation.

5. Version Numbers Tell a Story

Understanding semantic versioning helps assess risk:

• v4.5.0 → v4.5.1 = Patch release (bug fixes only, low risk)
• v4.5.x → v4.6.0 = Minor release (new features, moderate risk)
• v4.x.x → v5.0.0 = Major release (breaking changes, high risk)

This informed our decision to proceed quickly with minimal testing.

What We'd Do Differently Next Time

Despite the success, we identified improvements:

High Priority

1. Validate credentials before building

Currently, we discover authentication failures during the image push (after building). Better:

# Test login BEFORE building
if ! docker login ...; then
  echo "❌ Auth failed"
  exit 1
fi

2. Initialize Infisical project config

Running infisical init in the project directory creates a .infisical.json file, eliminating the need for --projectId flags in every command.

3. Add version consistency checks

A simple script to verify all 4 files have matching versions before building would catch human errors.

Medium Priority

4. Automated deployment verification

Replace manual kubectl checks with a script that: – Waits for pods to be ready – Extracts running version – Compares to expected version – Reports success/failure

5. Dry-run mode for build script

Test the script logic without actually building or pushing images. Useful for testing changes to the script itself.

The Impact

Before this session: – Manual credential management – 5+ minutes per build for login – Credentials in shell history (security risk) – No audit trail

After this session: – Automated credential retrieval – 0 minutes per build for login – Credentials never exposed (security improvement) – Full audit trail in Infisical – Repeatable process documented

Plus: We're running Mastodon v4.5.1 with 10 bug fixes, making our instance more stable for our users.

Lessons for Other Mastodon Admins

If you run a Mastodon instance, here's what we learned that might help you:

For Small Instances

Even if you're running standard Mastodon without customizations:

1. Document your upgrade process – Your future self will thank you
2. Test in staging first – If you don't have staging, test with dry-run/simulation
3. Always check release notes – 5 minutes of reading prevents hours of debugging
4. Use semantic versioning to assess risk – Patch releases are usually safe

For Custom Deployments

If you run custom images like we do:

1. Separate upstream from custom – Keep modifications isolated and additive
2. Automate credential management – Shell history is not secure storage
3. Use Docker layer caching – Speeds up builds dramatically
4. Platform flags matter – --platform linux/amd64 if deploying to different architecture
5. Verify the running version – Don't assume deployment worked, check it

For Kubernetes Deployments

If you deploy to Kubernetes:

1. Rolling updates are your friend – Zero downtime is achievable
2. Helm revisions enable easy rollback – helm rollback is simple and fast
3. Verify pod image versions – Check what's actually running, not just deployed
4. Monitor during rollout – Watch pod status, don't just fire and forget

The Numbers

Session Duration: 90 minutes total – Research: 15 minutes – Version updates: 10 minutes – Infisical integration: 60 minutes – Build & deploy: 5 minutes

Deployment Stats: – Downtime: 0 seconds (rolling update) – Pods affected: 3 (web, streaming, sidekiq) – Helm revision: 166 – Rollback complexity: Low (single command)

Lines of code changed: 18 lines across 4 files Lines of documentation written: 629 lines (retrospective) Security improvements: 1 major (credential management)

Final Thoughts

What started as a simple patch upgrade turned into a significant infrastructure improvement. The version bump was almost trivial – the real work was automating away manual steps and eliminating security risks.

This is what good ops work looks like: using routine maintenance as an opportunity to make systems better. The 60 minutes we spent on Infisical integration will pay dividends on every future build. The documentation we wrote will help the next person (or future us) upgrade with confidence.

Mastodon v4.5.1 is running smoothly, our build process is more secure, and we learned lessons that will make the next upgrade even smoother.

Resources

For Mastodon Admins: – Mastodon Upgrade Documentation – glitch-soc Releases

For Infrastructure: – Infisical (Secrets Management) – Docker Build Best Practices – Helm Upgrade Documentation

Our Instance: – river.group.lt – Live Mastodon instance – Running glitch-soc v4.5.1+glitch – Kubernetes + Helm deployment – Custom images with Sentry monitoring

Questions?

If you're running a Mastodon instance and have questions about: – Upgrading glitch-soc variants – Custom Docker image workflows – Kubernetes deployments – Secrets management with Infisical – Zero-downtime upgrades

Feel free to reach out! We're happy to share what we've learned.

Tags: #mastodon #glitch-soc #kubernetes #devops #infrastructure #security #automation

This blog post is part of our infrastructure documentation series. We believe in sharing knowledge to help others running similar systems. All technical details are from our actual upgrade session on November 13, 2025.

What's New in Mastodon v4.5.0?

The v4.5.0 release brings some exciting features:

• ✨ Quote Posts – Full support for authoring and displaying quotes
• 🔄 Dynamic Reply Fetching – Better conversation threading in the web UI
• 🚫 Username Blocking – Server-wide username filtering
• 🎨 Custom Emoji Overhaul – Complete rendering system rewrite
• 📊 Enhanced Moderation Tools – Improved admin/moderator interface
• ⚡ Performance Improvements – Optimized database queries

The Architecture Gotcha

Everything seemed perfect during the upgrade process. We:

1. Merged the upstream chart cleanly
2. Updated our custom configurations (LibreTranslate, Sentry integration)
3. Built new Docker images with Sentry monitoring
4. Pushed to our registry

But when we deployed, pods started crashing with a cryptic error:

exec /usr/local/bundle/bin/bundle: exec format error

The Root Cause

The issue? Architecture mismatch. We built our Docker images on an ARM64 Mac (Apple Silicon), but our Kubernetes cluster runs on AMD64 (x86_64) nodes. The images were perfectly valid—just for the wrong architecture!

The Fix

The solution was simple but important:

docker build --platform linux/amd64 \
  -f Dockerfile.mastodon-sentry \
  -t registry.example.com/mastodon-sentry:v4.5.0 \
  . --push

By explicitly specifying --platform linux/amd64, Docker builds images compatible with our cluster architecture, even when building on ARM64 hardware.

We updated our build script to always include this flag, preventing future issues:

# Build for AMD64 (cluster architecture)
docker build --platform linux/amd64 \
  -f Dockerfile.mastodon-sentry \
  -t ${REGISTRY}/mastodon-sentry:${VERSION} \
  . --push

Deployment Results

After rebuilding with the correct architecture:

• ✅ All pods running healthy (web, streaming, sidekiq)
• ✅ Elasticsearch cluster rolled out successfully
• ✅ PostgreSQL remained stable
• ✅ Zero data loss, minimal downtime
• ✅ All customizations preserved (LibreTranslate, Sentry, custom log levels)

Deployment Stats: – Total time: ~2 hours (including troubleshooting) – Downtime: Minimal (rolling update)

Lessons Learned

1. Always specify target platform when building images for deployment, especially in cross-architecture development environments
2. Build scripts should be architecture-aware to prevent silent failures
3. Test deployments catch issues early – the error appeared immediately during pod startup
4. Keep customizations isolated – Our values-river.yaml approach made the upgrade smooth

What's Next?

We still need to reindex Elasticsearch for the new search features:

kubectl exec -n mastodon deployment/river-mastodon-web -- \
  tootctl search deploy

This will update search indices for all accounts, statuses, and tags to take advantage of v4.5.0's improved search capabilities.

Key Takeaway

Modern development often happens on ARM64 Macs while production runs on AMD64 servers. Docker's multi-platform build support makes this seamless—but only if you remember to use it! A simple --platform flag saved us from a much longer debugging session.

Happy federating! 🐘

Resources: – Mastodon v4.5.0 Release Notes – Docker Multi-Platform Builds – Mastodon Helm Chart

Our instance runs on Kubernetes with custom Sentry monitoring, LibreTranslate integration, and an alternative Redis implementation. All chart templates remain identical to upstream, with customizations isolated in our values file.

Tai kokio čia rakto nori, kas tas viešas reikalas ir privatus ir kodėl negalima paprasčiau – tegu pasako slaptažodį, kurio programeris pažada neužsirašyti į sąsiuvinį ir parodo kaip jungtis prie serverio, kur jau ten skaitys žurnalą (logus) ir drebėdamas, kad netyčia ko nors nepridirbtų, atsijungs nuo serverio.

SSH raktas – kam jo reikia?

Šiaip adminai liaudis tokia, kad nelabai nori dalintis prieiga prie serverio, o ką ten dar šnekėt apie slaptažodį, kuris kurtas per kokią nors stalo žaidimo sesiją ir saugomas kaip nuosava akis. Na, taip pat yra ir kita priežastis, ogi ta, kad dauguma adminų taip pat nenaudoja slaptažodžių jungtis prie serverio, jį saugo slaptažodžių skrynutėse, kad galėtų naudoti ypatingais reikalais – suvesti jį per internetinę konsolę (ilo, ipmi ar pan – apie tai – kitą kartą) arba tada, kai prie serverio prijungtas monitorius su klaviatūra ir negali jungtis per SSH (pvz – nėra interneto).

Tai kaip jie jungias? Tai vat naudodami tą rakčiuką, o tiksliau – raktų porą. Raktų pora – tai tarpusavyje susiję du raktai, vienas viešas – jį galima dalinti, o kitas – privatus – jį reikia saugoti, niekam nerodyti, o dar geriau – apsaugoti slaptažodžiu. Tie raktai tarpusavyje susiję burtų būdu (matematika), kuri sako, kad jei turi slaptą raktą, o serveris turi tavo viešą raktą – tai galima juos kaip puzlę matematiškai sujungti ir taip užtikrinti, kad slapto rakto turėtojui galima jungtis į serverį. Tai va – tuomet nereikia žinoti slaptažodžio, galima tiesiog nukopijuoti rakčiuko .pub dalį į specialią vietą ir jungtis. Kiekvienas vartotojas turėtų turėti savo raktą, o tam, kad adminas nežinotų slaptosios dalies – jis prašo tą raktą sugeneruoti pačiam programuotojui.

Kaip generuojama raktų pora?

Kompas – MacOS

Generuojam RSA tipo raktą (išbandytas, lėtas, didelis, bet daug kur palaikomas):

❯ ssh-keygen -t rsa -b 4096 Generating public/private rsa key pair. Enter file in which to save the key (/Users/saint/.ssh/id_rsa): /tmp/naujasraktas Enter passphrase (empty for no passphrase): Enter same passphrase again: Passphrases do not match. Try again. Enter passphrase (empty for no passphrase): Enter same passphrase again: Passphrases do not match. Try again. Enter passphrase (empty for no passphrase): Enter same passphrase again: Passphrases do not match. Try again. Enter passphrase (empty for no passphrase): Enter same passphrase again: Your identification has been saved in /tmp/naujasraktas Your public key has been saved in /tmp/naujasraktas.pub The key fingerprint is: SHA256:SJMOzUtU2US5wb0m2O/ihJQx1VUrLZMiV0rl9GgT9BI saint@keisen.local The key's randomart image is: +---[RSA 4096]----+ | ...*+=oE...| | + ...* B O .| | . B o+ * % = | | = +.+* = * | | + S + | | . . . | | . .. | | .. . | | ... | +----[SHA256]-----+

Dabar kaip darysiu daryti nereikėtų, bet parodysiu kuo skiriasi privatus nuo viešo rakto:

Viešas raktas:

❯ head /tmp/naujasraktas.pub ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQC+nW2Z+7loNKUXg9tGLS7JHF/uINZjwDL1Bmd/DPL+JOopMPiqKsuJKyZp471udsxqUsMvzOPY2Cu/Q4tdwET5r7auAyA7v2rC2eFFJZwCbxxW1rY+PbENmfUeJw9CrJJF8sxcYoAvtLtwz5fu15jO3EfBE5HnRDlqH49sB5i0WYCSVDA2sOoWFyw2tCFulMsYEsSNYse/xUzO//8NZSIdwt5yWNQTkiYcNIPd4BuXnCLIFltykYanqYB+2sufG2LNhmg/qoR6L4tgwR/YNvk26GlgB1zwLiV+NVOgJu3HN/FRtgTtV++BcjPpFE4l0ypzY0KVGzuYVaAlOA7vRLxKXPZ0yeGkoLq0pfg1nrfnzQsxteAlivhLVU1NqpJHv2Sp/7GxBrBcbNAozwC1hZQHtYzfxvEp9w0NGCS4HREBdLX4B5RoKoLwMh2DcYYH7T+ql25zeFczhtonOZ8EM4ayAJbVeMbOwAO7MWWP6D3R2Ev5Z4KwxPGcd2hzz4V7H3TCro++VAAPcIlHnID+BydATzZbkkNu1OJpXwcccwXwxR/S7fPYeqs0gbBWj4qrVbrmtpOJlvdnM3ll93dq8liZI6avdPO0STpRbOHPyCVGFmVc59/RPxuTfU/s5VZKir7FWTyetNZoel+Y+bYaeXmthMZ/3fSTjCatDvm5y3DoJQ== saint@keisen.local

Privatus arba slaptas raktas:

❯ head /tmp/naujasraktas -----BEGIN OPENSSH PRIVATE KEY----- b3BlbnNzaC1rZXktdjEAAAAACmFlczI1Ni1jdHIAAAAGYmNyeXB0AAAAGAAAABDo6hOLoH

❯ tail /tmp/naujasraktas GbyBQQV4acgQcB/TwXL0iod4PqpdgK9+KzXzVjdI6kr4Z3VdFvTdZ1tTILuo48I8Pb0q2Z qcDgWXj6lvg3y1WFy9/QN/w3E= -----END OPENSSH PRIVATE KEY-----

Tai kuo jie skirias? Kadangi dauguma pradedančiųjų adminų turi dėmesio sutrikimo problemų, šį kartą parodau:

• Viešas raktas turi failo plėtinį .pub
• Viešas raktas prasideda ssh-rsa
• Privatus raktas prasideda ——-BEGIN OPENSSH PRIVATE KEY——-
• Privatus raktas baigiasi ——-END OPENSSH PRIVATE KEY——-

Administratoriui reikia siųsti raktą, kuris yra viešas – ssh-rsa .pub.

Kompas Windows

Su windows kiek sudėtingiau – reikia daugiau machinacijų. Aš įtariu, kad dabar egzistuoja ir kitokie variantai, panašesnį į MacOS per cmd, bet kadangi esu senis su barzda, tai parodysiu old school metodą.

1. Siunčiamės puttygen.exe
2. Reikėtų patikrinti parašą, bet kas ten jį tikrina, gerai, jei darbiniam kompe yra antivirusas. O jei rimtai – parašysiu ir apie tai, kaip galima patikrinti tuos parašus.
3. Pasileidžiam programą, pasirenkam RSA, rakto dydį 4096 ir generuojam. Atrodo va taip:
4. Išsaugom privatų raktą kur nors.
5. Nusikopijuojam ssh-rsa dalį ir nusiunčiam adminui – ją galima ramiai siuntinėti per emailą ar slacką ar teamsus.
6. Galima išsaugoti public dalį ir putty formatu, bet jos geriau nesiųsti adminui. Nors ją galima transformuoti į OpenSSH formatą – sutaupysi admino laiko ir erzulį.

N.B. Viešo rakto galima nesaugoti, burtai (matematika) tokia gudri, kad iš privataus rakto galima pagaminti viešą bet kada.

Pvz kaip atrodo ppk viešas raktas ne OpenSSH formatu:

❯ cat ZmonosViesasRaktas.ppk ---- BEGIN SSH2 PUBLIC KEY ---- Comment: "rsa-key" AAAAB3NzaC1yc2EAAAADAQABAAACAQCU4Oj4XH2lzuDUic9oTo24BsebV4RT1cQI QTwDhNS/i3npLN4u80ZRhR7m0j7UdZRDSlDcUovtSvdYAO2NPiwVPJGMLZWeAS/N YMGwdRV9CGtfhpTRXJEVhkbv2+gG0pIHA0XtOlkxX9VMKCUGdT2tmtpZgyaKIwNj bMuJU3GJATfAi4yG0Q6hTiqaLDFf2IYnk4MizT9WRWpbe9BvH0JNXGRjGKbl2ez5 ichdw5EzPt1UVInORJTMvO8o3xytCB7qqCEVjwO/e/Xcfk4OnrXAynfhqCsPEyg1 MhU9QlelEY6Q0HsUcDHesJuBATPs6UWniL9EaIq72EbrDhpGQlsV5lPWMceV0F6E mQ38MPQjay+48C+LHtIgTiq1woMkOoHoMtnRubvQ8JW916OLX60iafAYbO9LY/Jz sQ9j1BJ7zT0SnwdE8dPcTH+Q4hDU00729J6Fxuhod+8BYhdLofN47xiyPZ5zyxW5 l4yvYb8eyrzmNYok2epBOXGb7WEB9zjxmupeD0iJMHCkfONS3ltNDa49OLgHLEeM NakQ4i5blspublh9v3/3hpLqD3+CQLalV0rNDy91m9oqK9oTX7K6RXlCbXNvDNY6 SNIL64CRmQvcOKQk8/8aboANzBJfgHxbaYe75bYsOy4R6kyTy2/l6UZomlJi3eTu OoUMXqnKdw== ---- END SSH2 PUBLIC KEY ----

OpenSSH – tai dažniausiai naudojama programa-serveris, per kurią jungiamasi prie serverio.

Tai štai – raktą išsiuntėm, laukiam dabar admino atsakymo, greičiausiai reikės ir firewall sutvarkyt (atidaryt prieigą), dar kokio nors moralo išklausyt ir bus galima prisijungti.

Taigi planas:

• Inventorizuot sistemas ir surinkti informaciją apie jas į vieną vietą
• Sugalvot ką daryt su slaptažodžiais
• Išmokyt prižiūrėt serverius
• Varyt į Tibetą

Inventoriziją ir slaptažodžių pasidalinimo techniką dar reikia sugalvot ir padaryt, o trumpas pamokėles, kaip reikėtų perimti serverius ir darbus iš sysadmino aprašysiu. Jos bus pritaikytos konkrečiam naudojimui, tai serveriai yra Linux amd64, o kai kurie – arm64, o administratoriaus darbo vieta – Windows (berods 11).

Kitas postas bus apie tai, kaip prisijungti prie serverių, kai senasis administratorius geras ir sako – “atsiųsk raktą”.

• Padaryti taip, kad būtų profilaktinės valandos/dienos/savaitgaliai ir neskaičiuoti to laiko, kaip prastovos. Nesąmonė, rėkia programeris, taip negalima! Galima – šitas būdas labai dažnai naudojamas bankų. Jie sako – savaitgalį atsiskaitymas kortelėmis neveiks ir ką tu jiems, špyga taukuota. Garantuotai ten šitas neveikimas neįtraukiamas į probleminį ir ten naujina tą servisą naujina, kol ateina pirmadienis ir kažkas sutvarko viską ir paleidžia veikti. Ne kartą taip buvo ir ne kartą taip bus.
• Mėlynai/Žali atnaujinimai. Arba kitaip – blue/green. Kai išleidžiama nauja versija – ji paleidžiama green serveriuose, virtualiose mašinose ar tiesiog zonoje, o vartotojų ar kitoks kreipinių srautas palaipsniui nukreipimas, kad pažaliuotų. Mėlyna (senoji) versija aptarnauja vis mažiau ir mažiau užklausų, kol galų gale lieka tik kaip atsarginis variantas (ale atsukti atgal, jei šūdas gavos), išjungiama arba gali tarnauti kaip vieta būsimai žaliai zonai. Beje, tai gali būti ir vienas serveris, kuris teikia paslaugą iš skirtingų direktorijų. Aišku, vienas serveris gali bet kada nulūžti ir paslauga sustos, bet deploymentas tai visvien bus zero downtime :)
• Uždususios kanarėlės strategija (cannary) – apie pavadinimą galima sužinoti čia. Panašiu principu veikia ir pats serviso naujinimas – nauja versija paleidžiama serveriuose, į kuriuos srautas kreipiamas po truputį ir stebima situacija: žurnalai (logs), metrikos, galbūt vartotojų nusiskundimai; nustatoma kažkokia tolerancijos riba (klaidų retai kada pavyksta išvengti) ir neskubant vis daugiau vartotojų naudoja naują versiją. Jei pasiekta klaidų riba ar koks kitoks kriterijus – galima lengvai srautą kreipti atgal į seną versiją ir sutvarkyt problemas. Dažniausiai kanarėles naudoja daug vartotojų turinčios įmonės, kur pakeitimai gali iššaukti sniego lavinos efektą. Dar vienas privalumas – kad lengva ištestuoti fyčerius – t.y. pasinaudoja ne tik technologai, bet ir marketingistai. Turbūt teko laukti kokios nors naujienos, kuri paleista Amerikėj, bet nėra dar Lietuvoj – tai va, stebi ar kanarėlės dūsta ar ne.

Na, bet dar reikia visą tai automatizuoti, nes reikėtų, kad klaidas darytų kompiuteris vienodas, o ne žmonės skirtingas. Apie tai – gal kitą kartą.