#Docker

The personnel information system of the City Government of South Tangerang: employees keep their own records and follow their services, administrators work on exactly their part of the organisation, and every rule comes from the regulation that sets it. Led and built by me since 2023.

Four commands that move a stack from its old layout into a new structure across major versions: export without changing the source's data, import each store the way its version allows, verify what really arrived, and rename modules while moving their data along.

Commands that version every module of a stack on its own, build its image under a tag that means exactly one build, refuse to reuse a version or swallow a failed compile, and archive images by name and tag so versions never overwrite each other.

One command that rotates an environment's internal credentials key by key: a dry run by default, a backup first, a unique value for every key, a real login to prove each credential that can log in, and rollback for any that fail.

Two commands that keep three environments apart on one machine and one web server: one sets an environment's addresses and aligns every file that stores them, rendering nginx from templates and refusing on clashes; the other points the browser at one environment.

Three commands that take a tested release into production without overwriting what production owns: they promote configuration structure but keep its secrets and addresses, refuse to copy new secrets, and apply schema migrations the images carry.

Three commands that back up a running Docker stack — PostgreSQL, MinIO, and Elasticsearch — without downtime, restore it to any point, and keep retention safe, with exit codes that say how much a failure matters.

The digital signature platform of the City Government of South Tangerang: signers prove who they are, sign PDFs to PAdES B-LTA with certificates from the platform's own authorities, and anyone can verify the result — version 2, which I designed, built and operate.

Release Workflow: Development to Production is the procedure every change of mine follows from my laptop to production — which steps I automated, which I deliberately left to a person, why each step sits where it does, how I diagnose a failed release, and how I recover from it.

Retyping long Docker commands costs seconds, invites typos and taxes working memory. Ten short executables on PATH removed that cost; the interesting decisions were why not aliases, how to keep names guessable, and why one of them is 260 lines long.

This Laravel app answers HTTP and runs long-lived queue workers, yet a container is meant for one program. A process manager, FrankenPHP worker mode and a cache-ordered build put both in one image, instead of building the same code twice.

Its software reached the end of support, and its records must outlive it. One component rewrote data as it read it, so the migration copies rather than converts — an operation with no rollback has to be survivable, not merely careful.

Staging and production shared 136 keys, but 21 had to stay different, including the one that decrypts years of data. Promoting a release's structure, not a file's contents, keeps that key in place and stops a schema migration from silently never running.

One rotation reaches seven services, and a value elsewhere can look exactly like one of their credentials, so search-and-replace could break an integration nobody watches. Working from an explicit list keeps the rotation inside its blast radius and away from the keys that only decrypt.

Three environments sharing one fixed domain name, separated at the socket rather than by name, with a banner on every environment except production — and live proxy config rendered from a template, never linked into a repository where a branch switch could rewrite it.

Point one environment's volumes at another's data and the restore succeeds, every health check passes, and the database is empty. Separating networks, state and runtime identity is what keeps three environments on one host from quietly erasing each other.

Logs, traces and metrics from a dozen containers pushed over OTLP into one deliberately dumb collector, then read in Kibana — with a disk queue so a restart loses nothing, audit events counted exactly once, and the rule that telemetry must never become a failure point.

A Business Continuity Plan stated as two numbers — an RPO of six hours and an RTO of seconds for the data — and the few small scripts behind them: full and incremental backups, one technique per data store, restore as the only test that counts, and config treated as data.

Self-signed certificates cost work in every container, and no HTTPS hides bugs in cookies, redirects and OAuth2. I point the real domain at loopback and install the real certificate at the same path, so my laptop runs the same nginx config as production.

Build output, not my own code, was filling the disk: five projects shrank from 21 GB to 749 MB once the rebuildable folders were gone. I automated that cleanup instead of buying a bigger SSD, without trusting folder names or confirming hundreds of folders by hand.