k8s: added patching of CoreDNS

Signed-off-by: Oleksander Piskun <oleksandr2088@icloud.com>

Author: oleksandr-nc

development/docs/keda-autoscaler-setup.md

@@ -211,25 +211,50 @@ kubectl get pods -n keda
 
 ## Step 2: DNS setup (kind only)
 
-KEDA pods need to resolve `nextcloud.local`. Add it to CoreDNS:
+KEDA pods need to resolve `nextcloud.local`. **HaRP does this automatically now** —
+when `HP_K8S_HOST_ALIASES` is set, HaRP patches the CoreDNS `ConfigMap` on
+startup and restarts CoreDNS so that every pod in the cluster (including KEDA)
+can resolve the configured hostnames.
+
+If you need to do it manually (or verify), the commands are:
 
 ```bash
 # Get the nginx proxy IP
 PROXY_IP=$(docker inspect master-proxy-1 \
   --format '{{(index .NetworkSettings.Networks "master_default").IPAddress}}')
 echo "Proxy IP: $PROXY_IP"
 
-# Patch CoreDNS to resolve nextcloud.local
-kubectl get configmap coredns -n kube-system -o json | python3 -c "
-import json, sys
-cm = json.load(sys.stdin)
-corefile = cm['data']['Corefile']
-cm['data']['Corefile'] = corefile.replace(
-    'forward . /etc/resolv.conf',
-    'hosts {\n           ${PROXY_IP} nextcloud.local\n           fallthrough\n        }\n        forward . /etc/resolv.conf'.replace('\${PROXY_IP}', '${PROXY_IP}')
-)
-json.dump(cm, sys.stdout)
-" | kubectl apply -f -
+# Write the Corefile with the correct IP
+cat > /tmp/Corefile << EOF
+.:53 {
+    errors
+    health {
+       lameduck 5s
+    }
+    ready
+    kubernetes cluster.local in-addr.arpa ip6.arpa {
+       pods insecure
+       fallthrough in-addr.arpa ip6.arpa
+       ttl 30
+    }
+    prometheus :9153
+    hosts {
+           ${PROXY_IP} nextcloud.local
+           fallthrough
+        }
+        forward . /etc/resolv.conf {
+       max_concurrent 1000
+    }
+    cache 30
+    loop
+    reload
+    loadbalance
+}
+EOF
+
+kubectl create configmap coredns -n kube-system \
+  --from-file=Corefile=/tmp/Corefile \
+  --dry-run=client -o yaml | kubectl apply -f -
 
 kubectl rollout restart deployment coredns -n kube-system
 ```

haproxy_agent.py

@@ -2038,6 +2038,98 @@ def _k8s_parse_host_aliases() -> list[dict[str, Any]]:
     return [{"ip": ip, "hostnames": hosts} for ip, hosts in ip_to_hosts.items()]
 
 
+async def _k8s_ensure_coredns_host_aliases() -> None:
+    """Patch CoreDNS to resolve hostnames from HP_K8S_HOST_ALIASES cluster-wide.
+
+    In local/development setups, ``nextcloud.local`` only exists in the host's
+    ``/etc/hosts``.  Pod-level ``hostAliases`` fix this for ExApp pods, but
+    other K8s-native components (KEDA, monitoring, etc.) still rely on
+    cluster DNS.  This function patches the CoreDNS ``hosts`` plugin so that
+    **every** pod in the cluster can resolve those names.
+
+    Only runs when ``HP_K8S_HOST_ALIASES`` is set and ``HP_K8S_ENABLED`` is
+    true.  Errors are logged but never fatal — pod hostAliases remain as
+    fallback.
+    """
+    if not K8S_ENABLED or not K8S_HOST_ALIASES_RAW.strip():
+        return
+
+    host_aliases = _k8s_parse_host_aliases()
+    if not host_aliases:
+        return
+
+    LOGGER.info("Ensuring CoreDNS resolves host aliases: %s", K8S_HOST_ALIASES_RAW)
+
+    try:
+        # 1. Read current CoreDNS ConfigMap.
+        status, data, _text = await _k8s_request(
+            "GET", "/api/v1/namespaces/kube-system/configmaps/coredns",
+        )
+        if status != 200 or not data:
+            LOGGER.warning("Could not read CoreDNS ConfigMap (HTTP %d), skipping.", status)
+            return
+
+        corefile = data.get("data", {}).get("Corefile", "")
+        if not corefile:
+            LOGGER.warning("CoreDNS ConfigMap has no Corefile entry, skipping.")
+            return
+
+        # 2. Build the ``hosts { … }`` block from our aliases.
+        hosts_lines: list[str] = []
+        for alias in host_aliases:
+            for hostname in alias["hostnames"]:
+                hosts_lines.append(f"           {alias['ip']} {hostname}")
+        hosts_block = "hosts {\n" + "\n".join(hosts_lines) + "\n           fallthrough\n        }"
+
+        # 3. Replace existing hosts block or insert before ``forward``.
+        hosts_re = re.compile(r"hosts\s*\{[^}]*\}")
+        if hosts_re.search(corefile):
+            new_corefile = hosts_re.sub(hosts_block, corefile, count=1)
+        elif "forward ." in corefile:
+            new_corefile = corefile.replace("forward .", f"{hosts_block}\n        forward .", 1)
+        else:
+            LOGGER.warning(
+                "CoreDNS Corefile has no 'hosts' block and no 'forward' directive, cannot patch."
+            )
+            return
+
+        if new_corefile == corefile:
+            LOGGER.info("CoreDNS already has correct host aliases, no patch needed.")
+            return
+
+        # 4. Patch the ConfigMap.
+        status, _, _text = await _k8s_request(
+            "PATCH",
+            "/api/v1/namespaces/kube-system/configmaps/coredns",
+            json_body={"data": {"Corefile": new_corefile}},
+            content_type="application/strategic-merge-patch+json",
+        )
+        if status != 200:
+            LOGGER.warning("Failed to patch CoreDNS ConfigMap (HTTP %d): %s", status, _text[:200])
+            return
+
+        # 5. Trigger a CoreDNS rollout restart (annotation change).
+        restart_annotation = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+        status, _, _text = await _k8s_request(
+            "PATCH",
+            "/apis/apps/v1/namespaces/kube-system/deployments/coredns",
+            json_body={
+                "spec": {"template": {"metadata": {"annotations": {
+                    "harp.nextcloud.com/restartedAt": restart_annotation,
+                }}}}
+            },
+            content_type="application/strategic-merge-patch+json",
+        )
+        if status != 200:
+            LOGGER.warning("Failed to restart CoreDNS Deployment (HTTP %d): %s", status, _text[:200])
+            return
+
+        LOGGER.info("CoreDNS patched and restarted with host aliases: %s", K8S_HOST_ALIASES_RAW)
+
+    except Exception as exc:
+        LOGGER.warning("Failed to configure CoreDNS host aliases (non-fatal): %s", exc)
+
+
 def _k8s_build_deployment_manifest(payload: CreateExAppPayload, replicas: int) -> dict[str, Any]:
     """Build a Deployment manifest from CreateExAppPayload."""
     deployment_name = payload.exapp_k8s_name
@@ -3003,6 +3095,9 @@ async def run_http_server(host="127.0.0.1", port=8200):
 
 
 async def main():
+    # Ensure cluster-wide DNS for host aliases before starting servers.
+    await _k8s_ensure_coredns_host_aliases()
+
     spoa_task = asyncio.create_task(SPOA_AGENT._run(host=SPOA_HOST, port=SPOA_PORT))  # noqa
     http_task = asyncio.create_task(run_http_server(host="127.0.0.1", port=8200))