BCORE — 비코어 주식회사

PADION

dnsd · Internal DNS Control Plane

health-aware DNS · stock CoreDNS · no-DB · multi-node replication

Only live backends,
routed automatically via DNS.

Health-checks per zone publish only live backends as A records, and static records · per-domain forwards · SOA/cache are managed via Web UI/REST. Untouched stock CoreDNS reads the output and responds — no code linkage, so version independence. Runs without a DB, from a single config file.

DNS Control

  • Per-zone health-aware service — only live backends in the A set
  • Static records A / AAAA / CNAME / TXT / MX / NS
  • Per-domain forward(upstream) + policy + per-rule cache
  • Global · per-zone SOA / cache settings
  • Safe multi-node replication (split-brain prevention)
  • Audit logs · standard metrics · SBOM
What is

Why a health-aware internal DNS?

Internal stacks (like a lakehouse) run many stateless services — gateways, coordinators, workers — scattered across nodes. To stop traffic to dead instances, names must point only to "live places," but static DNS or manual management cannot keep up with health changes. Putting a heavy LB in front of every service is overkill.

PADION dnsd health-checks backends and publishes only live ones as DNS A records, managing static records · forward · SOA in one console. Actual responses come from untouched stock CoreDNS reading zone files, so CoreDNS upgrades are decoupled — and a single config file without a DB is the source of truth.

Key Features

6 Key Features

Health-aware DNS

Per-service TCP/HTTP/HTTPS health-checks (path · rise/fall · timeout). Publish only live backends in the A set. Choose fail-open or fail-closed behavior when all are down. Debounce coalesces flapping.

stock CoreDNS · decoupled

dnsd generates CoreDNS configuration; CoreDNS reads it automatically. No code linkage → CoreDNS version independence. Operable in a single container as well.

Per-domain Forward + cache

Per-source domain: different upstream · policy (random/round_robin/sequential) · health_check · max_fails. Domain-specific cache (per-rule). Loop detection on every forward block (prevents resolv.conf cycles).

Safe multi-node replication

Single writer · multi reader. Manual promote on leader failure · split-brain prevention · peer status · sync history.

Audit · Observability

Every change goes to append-only audit logs (rotation + retention + time-range query). Standard metrics exposed · CoreDNS apply verification · SBOM provided.

Security · DB-less operation

Web UI login (session + forced default password change) + bearer token (constant-time comparison) for REST / Replication. Optional HTTPS (TLS). A single config file is the source of truth (no DB) · changes only persisted after validation (all-or-nothing) · monotonic serial guarantee.

How it Works

Define once — 4 automated steps

Define a service once — health changes flow into the CoreDNS configuration automatically, so only live backends respond.

01 · Define

Service definition

Register zone · service · backend · forward via Web UI/REST

02 · Probe

Health-check

Periodic TCP/HTTP/HTTPS probes → determine live backends

03 · Render

Config render

Only live ones written to CoreDNS configuration safely (atomic update)

04 · Serve

CoreDNS response

Reload and respond · changes replicate to followers

Integration

CoreDNS · REST/UI · single container

CoreDNS · File + Reload

Stock CoreDNS integration

  • • Authoritative block per zone (file + reload)
  • • Catch-all / per-domain forward + cache + loop
  • • Per-rule cached domains separated into dedicated server blocks
  • • No code linkage → CoreDNS version independence
  • • Apply verification: serving SOA serial compared with rendered serial

REST API + Web UI

Single-console management

Manage zones · services · records · forward · SOA·cache · replication via Web UI (login session) and REST API. Automation uses a Bearer token. All mutations require authentication.

Deploy · Host / Docker / k8s

Single container · k8s seam

  • • Go single binary + stock CoreDNS
  • • In one container, dnsd (PID 1) starts, supervises, and restarts CoreDNS
  • • Single config unifies operational paths (status/log/SSL/settings)
  • • Currently file output; Kubernetes ConfigMap output planned
  • • Multi-zone ↔ k8s custom zones mapped 1:1
Security & Operations

Operational safety requirements

Web UI login

ID/password session auth (PBKDF2 hash). The initial password must be changed on first login.

Mutation auth

Every mutation requires a session or Bearer token. Tokens are compared in constant time (timing-attack prevention).

Access log

Login / logout / failures logged with user ID + client IP.

Audit log

All changes append-only · periodic rotation · retention months · time-range query.

HTTPS(TLS)

Serve admin / UI over HTTPS with a public certificate. Tokens and sessions are never returned in responses.

Split-brain prevention

Safe single-writer replication isolates old leaders.

Consistency guarantee

Disk persistence only after validation (all-or-nothing) · persist-before-broadcast · monotonic serial.

resolv.conf loop prevention

Forced catch-all in forward + CoreDNS loop plugin prevents infinite resolution loops.

Open-source transparency

SBOM provided — dependency modules and licenses transparent. Minimal external deps.

Use Cases

Deployment Scenarios

Stateless LB

Gateway · coordinator distribution

Group stateless endpoints (MinIO gateways, Trino coordinators) under dns-rr, publishing only live instances as multiple A records. Dead nodes are auto-excluded.

Internal Resolver

Internal-domain forward separation

internal.corp. such as in-house domains use a dedicated upstream / policy, while the rest forward to a public resolver. Per-domain cache TTL is applied separately.

High Availability

Multi-node DNS redundancy

Configuration edited on the leader replicates to followers. Even on leader failure, follower CoreDNS keeps responding, and a manual promote can safely take over.

PADION integration

Lakehouse service discovery

Provides consistent names and health-aware routing for internal services of PADION lakehouse (Trino · MinIO · metastore, etc.). Owns "name → live place" at the infrastructure layer.

Tech Spec

Tech Spec

DNS enginestock CoreDNS (file + reload). Decoupled from code → version independence. In single-container mode dnsd starts and supervises CoreDNS as a child.
Zone modelMulti-zone (origin). Zone = dynamic services (health) + static records. k8s custom zones map 1:1.
Record typesA · AAAA · CNAME · TXT · MX · NS. Multiple values per (name, type, value) identifier.
Health-checkTCP / HTTP / HTTPS (health path) · interval · timeout · rise / fall · debounce. all_dead: fail_open / fail_closed.
ForwardPer-source domain upstream / policy / health_check / max_fails / per-rule cache. Mandatory catch-all '.' with loop detection.
SOA / CacheGlobal defaults + per-zone override (field inheritance). Auto-monotonic serial. Global / per-rule cache (TTL · success · denial).
ReplicationSingle writer · multi reader · safe sync · manual promote · peer status · sync history.
AuthenticationWeb UI login session (PBKDF2, forced default-password change) + Bearer token for REST/Replication (constant-time comparison, configured via file). Login/logout logged with IP and ID.
TLSHTTPS for admin/UI (certificate + key). Enabled when both cert and key are configured.
AuditAppend-only · periodic rotation (audit-YYYY-MM.log) · retention months · time-range (from/to) query.
ObservabilityStandard metrics · CoreDNS apply verification · SBOM provided.
ArchitectureGo single binary · No-DB (config file as source of truth) · minimal external deps · atomic updates.
DeploymentHost + Docker (single-container dnsd+CoreDNS) today · k8s ConfigMap sink planned. Single config for operational paths.
PADION integrationdata lakehouse Internal service discovery · datakeeper · gatekeeper
In the PADION Flow

Infrastructure baseline — 02

For auth, authz, ETL, storage, and analytics to work, services must first find each other by name and connect to live places. dnsd owns that discovery layer.

Never route to a dead place —
live DNS.

PoC, internal network deployment, and multi-node redundancy.