fix: issue with resolution of external IPs

Author: coodos

platforms/registry/src/index.ts

@@ -5,6 +5,7 @@ import path from "path";
 import { AppDataSource } from "./config/database";
 import { VaultService } from "./services/VaultService";
 import { UriResolutionService } from "./services/UriResolutionService";
+import { KubernetesService } from "./services/KubernetesService";
 import cors from "@fastify/cors";
 
 dotenv.config({ path: path.resolve(__dirname, "../../../.env") });
@@ -36,6 +37,9 @@ const vaultService = new VaultService(AppDataSource.getRepository("Vault"));
 // Initialize UriResolutionService for health checks and Kubernetes fallbacks
 const uriResolutionService = new UriResolutionService();
 
+// Initialize KubernetesService for debugging
+const kubernetesService = new KubernetesService();
+
 // Middleware to check shared secret
 const checkSharedSecret = async (request: any, reply: any) => {
     const authHeader = request.headers.authorization;
@@ -127,6 +131,23 @@ server.get("/.well-known/jwks.json", async (request, reply) => {
     }
 });
 
+// Debug endpoint for Kubernetes connectivity (remove in production)
+server.get("/debug/kubernetes", async (request, reply) => {
+    try {
+        const debugInfo = await kubernetesService.debugExternalIps();
+        reply.send({
+            status: "ok",
+            timestamp: new Date().toISOString(),
+            kubernetes: debugInfo
+        });
+    } catch (error) {
+        reply.status(500).send({
+            error: "Failed to get Kubernetes debug info",
+            message: error instanceof Error ? error.message : String(error)
+        });
+    }
+});
+
 // Resolve service from database based on w3id
 server.get("/resolve", async (request, reply) => {
     try {

platforms/registry/src/services/KubernetesService.ts

@@ -17,79 +17,45 @@ export class KubernetesService {
     }
 
     /**
-     * Get a working external IP from Kubernetes services
-     * This will look for services with LoadBalancer type or NodePort with external IPs
+     * Get a working external IP from Kubernetes nodes
      */
     async getWorkingExternalIp(): Promise<string | null> {
         try {
-            console.log('Querying Kubernetes for external IPs...');
-            
-            // Get all services across all namespaces
-            const servicesResponse = await this.coreV1Api.listServiceForAllNamespaces();
+            console.log('Querying Kubernetes for node external IPs...');
 
+            const nodesResponse = await this.coreV1Api.listNode();
             const externalIps: string[] = [];
 
-            for (const service of servicesResponse.body.items) {
-                // Check for LoadBalancer services with external IPs
-                if (service.spec?.type === 'LoadBalancer' && service.status?.loadBalancer?.ingress) {
-                    for (const ingress of service.status.loadBalancer.ingress) {
-                        if (ingress.ip) {
-                            externalIps.push(ingress.ip);
-                            console.log(`Found LoadBalancer external IP: ${ingress.ip}`);
+            for (const node of nodesResponse.body.items) {
+                if (node.status?.addresses) {
+                    for (const address of node.status.addresses) {
+                        if (address.type === 'ExternalIP' && address.address) {
+                            externalIps.push(address.address);
+                            console.log(`Found node external IP: ${address.address}`);
                         }
                     }
                 }
-                
-                // Check for services with external IPs
-                if (service.spec?.externalIPs) {
-                    for (const externalIp of service.spec.externalIPs) {
-                        externalIps.push(externalIp);
-                        console.log(`Found service external IP: ${externalIp}`);
-                    }
-                }
             }
 
-            // Remove duplicates
-            const uniqueIps = [...new Set(externalIps)];
-            
-            if (uniqueIps.length === 0) {
-                console.log('No external IPs found in Kubernetes');
+            if (externalIps.length === 0) {
+                console.log('No external IPs found in Kubernetes nodes');
                 return null;
             }
 
-            // Test each IP to find a working one
-            for (const ip of uniqueIps) {
-                if (await this.testIpConnectivity(ip)) {
-                    console.log(`Found working external IP: ${ip}`);
-                    return ip;
-                }
-            }
+            console.log(`Found ${externalIps.length} external IPs:`, externalIps);
 
-            console.log('No working external IPs found');
-            return null;
+            // Just return the first external IP we find
+            const workingIp = externalIps[0];
+            console.log(`Using external IP: ${workingIp}`);
+            return workingIp;
 
         } catch (error) {
-            console.error('Error querying Kubernetes:', error);
+            console.error('Error querying Kubernetes nodes:', error);
             return null;
         }
     }
 
-    /**
-     * Test if an IP is reachable
-     */
-    private async testIpConnectivity(ip: string): Promise<boolean> {
-        try {
-            // Try to connect to port 80 (HTTP) as a basic connectivity test
-            const response = await fetch(`http://${ip}:80`, {
-                method: 'HEAD',
-                signal: AbortSignal.timeout(3000) // 3 second timeout
-            });
-            return true;
-        } catch (error) {
-            console.log(`IP ${ip} is not reachable:`, error instanceof Error ? error.message : 'Unknown error');
-            return false;
-        }
-    }
+
 
     /**
      * Get external IPs for a specific service
@@ -121,4 +87,43 @@ export class KubernetesService {
             return [];
         }
     }
+
+    /**
+     * Get all node external IPs
+     */
+    async getNodeExternalIps(): Promise<string[]> {
+        try {
+            const nodesResponse = await this.coreV1Api.listNode();
+            const externalIps: string[] = [];
+            
+            for (const node of nodesResponse.body.items) {
+                if (node.status?.addresses) {
+                    for (const address of node.status.addresses) {
+                        if (address.type === 'ExternalIP' && address.address) {
+                            externalIps.push(address.address);
+                        }
+                    }
+                }
+            }
+            
+            return externalIps;
+            
+        } catch (error) {
+            console.error('Error getting node external IPs:', error);
+            return [];
+        }
+    }
+
+    /**
+     * Debug method to show node external IPs
+     */
+    async debugExternalIps(): Promise<{
+        nodeExternalIps: string[];
+    }> {
+        const nodeExternalIps = await this.getNodeExternalIps();
+        
+        return {
+            nodeExternalIps,
+        };
+    }
 }