@spinnaker/google 2026.3.1 → 2026.4.0

package/src/loadBalancer/details/gceLoadBalancerDetails.tsx

@@ -6,6 +6,7 @@ import {
   CloudProviderRegistry,
   CollapsibleSection,
   ConfirmationModalService,
+  HelpField,
   InfrastructureCaches,
   LoadBalancerWriter,
   ManagedMenuItem,
@@ -36,14 +37,21 @@ function isSameVpc(candidate: any, params: any): boolean {
 }
 
 function findLoadBalancerInList(loadBalancers: any[], params: any): any {
-  return (loadBalancers || []).find((candidate: any) => {
-    return (
-      candidate.name === params.name &&
+  const inScope = (loadBalancers || []).filter(
+    (candidate: any) =>
       candidate.account === params.accountId &&
       (candidate.region === params.region || candidate.region === 'global') &&
-      isSameVpc(candidate, params)
-    );
-  });
+      isSameVpc(candidate, params),
+  );
+  // EXTERNAL_MANAGED rows carry a decorated display name; links built from the raw URL map name
+  // still resolve once no exact name matches.
+  return (
+    inScope.find((candidate: any) => candidate.name === params.name) ||
+    inScope.find(
+      (candidate: any) =>
+        gceHttpLoadBalancerUtils.isRegionalHttpLoadBalancer(candidate) && candidate.urlMapName === params.name,
+    )
+  );
 }
 
 function uniqBy<T>(items: T[], getKey: (item: T) => string): T[] {
@@ -58,11 +66,18 @@ function uniqBy<T>(items: T[], getKey: (item: T) => string): T[] {
   });
 }
 
-function getProtocol(loadBalancer: any): string {
+function getProtocol(loadBalancer: any, httpFamily = false): string | undefined {
+  if (!httpFamily) {
+    return undefined;
+  }
   const port = loadBalancer?.listenerDescriptions?.[0]?.listener?.loadBalancerPort;
   return port === '443' ? 'https:' : 'http:';
 }
 
+function formatDns(dns: { dnsname: string; protocol?: string }): string {
+  return dns.protocol ? `${dns.protocol}//${dns.dnsname}` : dns.dnsname;
+}
+
 function getBackendServices(loadBalancer: any): any[] {
   let backendServices = [loadBalancer.defaultService].filter(Boolean);
 
@@ -83,6 +98,7 @@ function getBackendServices(loadBalancer: any): any[] {
 function getResourceTypes(loadBalancerType: string): string[] {
   switch (loadBalancerType) {
     case 'INTERNAL':
+    case 'REGIONAL_EXTERNAL_NETWORK':
       return ['gce_forwarding_rule', 'gce_backend_service'];
     case 'NETWORK':
       return ['gce_forwarding_rule', 'gce_target_pool', 'gce_health_check'];
@@ -90,16 +106,23 @@ function getResourceTypes(loadBalancerType: string): string[] {
     case 'TCP':
       return ['gce_forwarding_rule', 'gce_backend_service'];
     case 'INTERNAL_MANAGED':
+    case 'EXTERNAL_MANAGED':
       return ['http_load_balancer', 'gce_target_http_proxy', 'gce_url_map', 'gce_backend_service'];
     default:
       return ['http_load_balancer', 'gce_target_http_proxy', 'gce_url_map', 'gce_backend_service'];
   }
 }
 
+function getLogSearchName(loadBalancer: any): string {
+  return gceHttpLoadBalancerUtils.isRegionalHttpLoadBalancer(loadBalancer)
+    ? loadBalancer.urlMapName || loadBalancer.name
+    : loadBalancer.name;
+}
+
 function buildLogsLink(project: string, loadBalancer: any): string {
   return `https://console.developers.google.com/project/${project}/logs?advancedFilter=resource.type=(${getResourceTypes(
     loadBalancer.loadBalancerType,
-  ).join(' OR ')})%0A"${loadBalancer.name}"`;
+  ).join(' OR ')})%0A"${getLogSearchName(loadBalancer)}"`;
 }
 
 async function loadDetails(loadBalancer: any, loadBalancerParams: any, loadBalancerReader: any): Promise<any[]> {
@@ -126,7 +149,7 @@ async function loadDetails(loadBalancer: any, loadBalancerParams: any, loadBalan
 
     representativeLoadBalancer.dns = uniqBy(
       loadBalancers
-        .map((detail: any) => ({ dnsname: detail.dnsname, protocol: getProtocol(detail) }))
+        .map((detail: any) => ({ dnsname: detail.dnsname, protocol: getProtocol(detail, true) }))
         .filter((detail: any) => detail.dnsname),
       (detail: any) => detail.dnsname,
     );
@@ -143,7 +166,10 @@ async function loadDetails(loadBalancer: any, loadBalancerParams: any, loadBalan
     loadBalancer.name,
   );
   if (details[0]) {
-    details[0].dns = { dnsname: details[0].dnsname, protocol: getProtocol(details[0]) };
+    details[0].dns = {
+      dnsname: details[0].dnsname,
+      protocol: getProtocol(details[0], loadBalancer.loadBalancerType !== 'REGIONAL_EXTERNAL_NETWORK'),
+    };
   }
   return details;
 }
@@ -175,6 +201,11 @@ export async function loadGceLoadBalancerDetails({
         loadBalancer.elb.backendServices.map((backendService: any) => backendService.healthCheck).filter(Boolean),
         (healthCheck: any) => healthCheck.name || healthCheck.selfLink || '',
       );
+    } else if (loadBalancer.loadBalancerType === 'REGIONAL_EXTERNAL_NETWORK' && loadBalancer.backendService) {
+      loadBalancer.elb.backendServices = [loadBalancer.backendService];
+      loadBalancer.elb.healthChecks = loadBalancer.backendService.healthCheck
+        ? [loadBalancer.backendService.healthCheck]
+        : [];
     }
   }
 
@@ -251,9 +282,9 @@ function deleteGceHttpLoadBalancer(loadBalancer: any, app: any, params: any = {}
 
   return TaskExecutor.executeTask({
     application: app,
-    description: `Delete load balancer: ${loadBalancer.urlMapName || loadBalancer.name} in ${
-      loadBalancer.account
-    }:global`,
+    description: `Delete load balancer: ${loadBalancer.urlMapName || loadBalancer.name} in ${loadBalancer.account}:${
+      loadBalancer.loadBalancerType === 'EXTERNAL_MANAGED' ? region : 'global'
+    }`,
     job: [job],
   });
 }
@@ -288,7 +319,10 @@ function GceLoadBalancerDeleteOptions({
   deleteParams: { deleteHealthChecks: boolean };
   loadBalancer: any;
 }): JSX.Element {
-  const hasHealthChecks = gceHttpLoadBalancerUtils.isHttpLoadBalancer(loadBalancer) || !!loadBalancer.healthCheck;
+  const hasHealthChecks =
+    gceHttpLoadBalancerUtils.isHttpLoadBalancer(loadBalancer) ||
+    !!loadBalancer.healthCheck ||
+    (loadBalancer.loadBalancerType === 'REGIONAL_EXTERNAL_NETWORK' && !!loadBalancer.backendService?.healthCheck);
   if (!hasHealthChecks) {
     return null;
   }
@@ -382,8 +416,8 @@ export function GceLoadBalancerInformationSection({ loadBalancer }: { app: any;
             <dt>DNS</dt>
             <dd>
               {Array.isArray(loadBalancer.elb.dns)
-                ? loadBalancer.elb.dns.map((dns: any) => `${dns.protocol}//${dns.dnsname}`).join(', ')
-                : `${loadBalancer.elb.dns.protocol}//${loadBalancer.elb.dns.dnsname}`}
+                ? loadBalancer.elb.dns.map(formatDns).join(', ')
+                : formatDns(loadBalancer.elb.dns)}
             </dd>
           </>
         )}
@@ -392,15 +426,64 @@ export function GceLoadBalancerInformationSection({ loadBalancer }: { app: any;
   );
 }
 
+function formatListenerDescription(description: any): string {
+  const listener = description.listener || description;
+  return `${listener.protocol}:${listener.loadBalancerPort} → ${listener.instanceProtocol}:${listener.instancePort}`;
+}
+
+function formatNormalizedHttpListener(listener: any): string {
+  const port = listener.port || listener.portRange?.split('-')[0];
+  const protocol = listener.protocol || (port === '443' || listener.certificate ? 'HTTPS' : 'HTTP');
+  return `${protocol}:${port}`;
+}
+
+function getListenerDisplayRows(loadBalancer: any): string[] {
+  const listenerDescriptions = loadBalancer.elb?.listenerDescriptions;
+  if (listenerDescriptions?.length) {
+    return listenerDescriptions.map(formatListenerDescription);
+  }
+
+  if (gceHttpLoadBalancerUtils.isHttpLoadBalancer(loadBalancer) && loadBalancer.listeners?.length) {
+    return loadBalancer.listeners.map(formatNormalizedHttpListener);
+  }
+
+  return [];
+}
+
 export function GceLoadBalancerListenersSection({ loadBalancer }: { app: any; loadBalancer: any }): JSX.Element {
+  if (
+    loadBalancer.loadBalancerType !== 'EXTERNAL_MANAGED' &&
+    loadBalancer.loadBalancerType !== 'REGIONAL_EXTERNAL_NETWORK'
+  ) {
+    return (
+      <CollapsibleSection heading="Listeners" defaultExpanded={true}>
+        {(loadBalancer.listeners || []).length ? (
+          <ul>
+            {loadBalancer.listeners.map((listener: any, index: number) => (
+              <li key={index}>{[listener.protocol, listener.port || listener.portRange].filter(Boolean).join(':')}</li>
+            ))}
+          </ul>
+        ) : (
+          <span>No listeners configured</span>
+        )}
+      </CollapsibleSection>
+    );
+  }
+
+  const listenerRows = getListenerDisplayRows(loadBalancer);
+
   return (
     <CollapsibleSection heading="Listeners" defaultExpanded={true}>
-      {(loadBalancer.listeners || []).length ? (
-        <ul>
-          {loadBalancer.listeners.map((listener: any, index: number) => (
-            <li key={index}>{[listener.protocol, listener.port || listener.portRange].filter(Boolean).join(':')}</li>
+      {listenerRows.length ? (
+        <dl>
+          <dt>
+            Load Balancer → Instance
+            {loadBalancer.loadBalancerType === 'EXTERNAL_MANAGED' && <HelpField id="gce.httpLoadBalancer.namedPort" />}
+          </dt>
+          {listenerRows.map((listenerRow, index) => (
+            <dd key={index}>{listenerRow}</dd>
           ))}
-        </ul>
+        </dl>
       ) : (
         <span>No listeners configured</span>
       )}

package/src/loadBalancer/httpLoadBalancerUtils.service.spec.ts

@@ -0,0 +1,126 @@
+import type { IGceLoadBalancer } from '../domain/loadBalancer';
+
+import { GceHttpLoadBalancerUtils } from './httpLoadBalancerUtils.service';
+
+describe('GceHttpLoadBalancerUtils', () => {
+  const utils = new GceHttpLoadBalancerUtils();
+
+  it('treats EXTERNAL_MANAGED as part of the HTTP load balancer family', () => {
+    const externalManaged = {
+      account: 'account-a',
+      listeners: [{ name: 'listener-443' }],
+      loadBalancerType: 'EXTERNAL_MANAGED',
+      provider: 'gce',
+      region: 'us-central1',
+      urlMapName: 'app-main',
+    } as IGceLoadBalancer;
+
+    expect(utils.isHttpLoadBalancer(externalManaged)).toBe(true);
+    expect(utils.isRegionalHttpLoadBalancer(externalManaged)).toBe(true);
+  });
+
+  it('keeps global HTTP and INTERNAL_MANAGED classification unchanged', () => {
+    const globalHttp = {
+      account: 'account-a',
+      listeners: [{ name: 'listener-80' }],
+      loadBalancerType: 'HTTP',
+      provider: 'gce',
+      region: 'global',
+      urlMapName: 'app-main',
+    } as IGceLoadBalancer;
+    const internalManaged = {
+      account: 'account-a',
+      listeners: [{ name: 'listener-internal' }],
+      loadBalancerType: 'INTERNAL_MANAGED',
+      provider: 'gce',
+      region: 'europe-west1',
+      urlMapName: 'app-internal',
+    } as IGceLoadBalancer;
+
+    expect(utils.isHttpLoadBalancer(globalHttp)).toBe(true);
+    expect(utils.isRegionalHttpLoadBalancer(globalHttp)).toBe(false);
+
+    expect(utils.isHttpLoadBalancer(internalManaged)).toBe(true);
+    expect(utils.isRegionalHttpLoadBalancer(internalManaged)).toBe(true);
+  });
+
+  it('scopes regional listener normalization by account and region', () => {
+    const loadBalancers = [
+      {
+        account: 'account-a',
+        listeners: [{ name: 'listener-a' }],
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'app-main (account-a/us-central1/EXTERNAL_MANAGED)',
+        provider: 'gce',
+        region: 'us-central1',
+        urlMapName: 'app-main',
+      },
+      {
+        account: 'account-a',
+        listeners: [{ name: 'listener-b' }],
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'app-main (account-a/europe-west1/EXTERNAL_MANAGED)',
+        provider: 'gce',
+        region: 'europe-west1',
+        urlMapName: 'app-main',
+      },
+    ] as IGceLoadBalancer[];
+
+    expect(
+      utils.normalizeLoadBalancerNamesForAccount(['listener-a'], 'account-a', loadBalancers, 'us-central1'),
+    ).toEqual(['app-main (account-a/us-central1/EXTERNAL_MANAGED)']);
+    expect(
+      utils.normalizeLoadBalancerNamesForAccount(['listener-b'], 'account-a', loadBalancers, 'europe-west1'),
+    ).toEqual(['app-main (account-a/europe-west1/EXTERNAL_MANAGED)']);
+  });
+
+  it('maps global HTTP listener names to url map names without requiring region', () => {
+    const loadBalancers = [
+      {
+        account: 'account-a',
+        listeners: [{ name: 'listener-80' }, { name: 'listener-443' }],
+        loadBalancerType: 'HTTP',
+        name: 'app-main',
+        provider: 'gce',
+        region: 'global',
+        urlMapName: 'app-main',
+      },
+    ] as IGceLoadBalancer[];
+
+    expect(utils.normalizeLoadBalancerNamesForAccount(['listener-443'], 'account-a', loadBalancers)).toEqual([
+      'app-main',
+    ]);
+  });
+
+  it('keeps the first INTERNAL_MANAGED url map for a listener name regardless of region', () => {
+    const loadBalancers = ['us-central1', 'europe-west1'].map((region) => ({
+      account: 'account-a',
+      listeners: [{ name: 'shared-listener' }],
+      loadBalancerType: 'INTERNAL_MANAGED',
+      name: `app-internal-${region}`,
+      provider: 'gce',
+      region,
+      urlMapName: `app-internal-${region}`,
+    })) as IGceLoadBalancer[];
+
+    expect(
+      utils.normalizeLoadBalancerNamesForAccount(['shared-listener'], 'account-a', loadBalancers, 'europe-west1'),
+    ).toEqual(['app-internal-us-central1']);
+  });
+
+  it('leaves an EXTERNAL_MANAGED listener name unresolved when regions make it ambiguous', () => {
+    const loadBalancers = ['us-central1', 'europe-west1'].map((region) => ({
+      account: 'account-a',
+      listeners: [{ name: 'shared-listener' }],
+      loadBalancerType: 'EXTERNAL_MANAGED',
+      name: `app-main (account-a/${region}/EXTERNAL_MANAGED)`,
+      provider: 'gce',
+      region,
+      urlMapName: 'app-main',
+    })) as IGceLoadBalancer[];
+
+    expect(utils.normalizeLoadBalancerNamesForAccount(['shared-listener'], 'account-a', loadBalancers)).toEqual([
+      'shared-listener',
+    ]);
+  });
+});

package/src/loadBalancer/httpLoadBalancerUtils.service.ts

@@ -4,35 +4,51 @@ import type { IGceHttpLoadBalancer, IGceLoadBalancer } from '../domain/loadBalan
 
 export class GceHttpLoadBalancerUtils {
   public static REGION = 'global';
+  public static HTTP_LOAD_BALANCER_TYPES = ['HTTP', 'INTERNAL_MANAGED', 'EXTERNAL_MANAGED'];
 
   public isHttpLoadBalancer(lb: IGceLoadBalancer): lb is IGceHttpLoadBalancer {
     const loadBalancer = lb as any;
     return (
       (loadBalancer.provider === 'gce' || loadBalancer.type === 'gce') &&
-      (loadBalancer.loadBalancerType === 'HTTP' || loadBalancer.loadBalancerType === 'INTERNAL_MANAGED')
+      GceHttpLoadBalancerUtils.HTTP_LOAD_BALANCER_TYPES.includes(loadBalancer.loadBalancerType)
     );
   }
 
+  public isRegionalHttpLoadBalancer(lb: IGceLoadBalancer): lb is IGceHttpLoadBalancer {
+    return this.isHttpLoadBalancer(lb) && lb.loadBalancerType !== 'HTTP';
+  }
+
   public normalizeLoadBalancerNamesForAccount(
     loadBalancerNames: string[],
     account: string,
     loadBalancers: IGceLoadBalancer[],
+    region?: string,
   ): string[] {
     // Assume that loadBalancers is a list of all GCE load balancers in an application
     // (but possibly from several accounts), and has already been normalized (listener names mapped to URL map names).
     const normalizedLoadBalancerNames: string[] = [];
+    const hasListener = (loadBalancer: IGceLoadBalancer, loadBalancerName: string) =>
+      account === loadBalancer.account &&
+      this.isHttpLoadBalancer(loadBalancer) &&
+      loadBalancer.listeners.map((listener) => listener.name).includes(loadBalancerName);
     loadBalancerNames.forEach((loadBalancerName) => {
-      const matchingUrlMap = loadBalancers.find((loadBalancer) => {
-        return (
-          account === loadBalancer.account &&
-          this.isHttpLoadBalancer(loadBalancer) &&
-          loadBalancer.listeners.map((listener) => listener.name).includes(loadBalancerName)
-        );
-      });
+      const matchingUrlMap = loadBalancers.find(
+        (loadBalancer) =>
+          loadBalancer.loadBalancerType !== 'EXTERNAL_MANAGED' && hasListener(loadBalancer, loadBalancerName),
+      );
+      // EXTERNAL_MANAGED listener names repeat across regions, so a raw alias maps only when the
+      // account and region identify one load balancer.
+      const externalMatches = matchingUrlMap
+        ? []
+        : loadBalancers.filter(
+            (loadBalancer) =>
+              loadBalancer.loadBalancerType === 'EXTERNAL_MANAGED' &&
+              (!region || loadBalancer.region === region) &&
+              hasListener(loadBalancer, loadBalancerName),
+          );
+      const match = matchingUrlMap || (externalMatches.length === 1 ? externalMatches[0] : undefined);
 
-      matchingUrlMap
-        ? normalizedLoadBalancerNames.push(matchingUrlMap.name)
-        : normalizedLoadBalancerNames.push(loadBalancerName);
+      match ? normalizedLoadBalancerNames.push(match.name) : normalizedLoadBalancerNames.push(loadBalancerName);
     });
     return uniq(normalizedLoadBalancerNames);
   }

package/src/loadBalancer/loadBalancer.setTransformer.spec.ts

@@ -0,0 +1,165 @@
+import { GceLoadBalancerSetTransformer } from './loadBalancer.setTransformer';
+
+describe('GceLoadBalancerSetTransformer', () => {
+  const transformer = new GceLoadBalancerSetTransformer();
+
+  it('groups regional HTTP listeners by account, region, load balancer type, and raw urlMapName', () => {
+    const loadBalancers = [
+      {
+        account: 'test',
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'listener-a',
+        portRange: '80-80',
+        provider: 'gce',
+        region: 'us-central1',
+        urlMapName: 'app',
+      },
+      {
+        account: 'test',
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'listener-b',
+        portRange: '80-80',
+        provider: 'gce',
+        region: 'us-east1',
+        urlMapName: 'app',
+      },
+    ];
+
+    const normalized = transformer.normalizeLoadBalancerSet(loadBalancers as any);
+
+    expect(normalized.length).toBe(2);
+    expect(normalized.map((loadBalancer) => loadBalancer.region).sort()).toEqual(['us-central1', 'us-east1']);
+    expect(normalized.map((loadBalancer) => loadBalancer.name).sort()).toEqual([
+      'app (test/us-central1/EXTERNAL_MANAGED)',
+      'app (test/us-east1/EXTERNAL_MANAGED)',
+    ]);
+    expect(normalized.every((loadBalancer: any) => loadBalancer.urlMapName === 'app')).toBe(true);
+  });
+
+  it('folds same-scope regional external listeners into one normalized load balancer', () => {
+    const loadBalancers = [
+      {
+        account: 'test',
+        certificate: undefined,
+        ipAddress: '34.0.0.1',
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'listener-http',
+        networkTier: 'STANDARD',
+        portRange: '80-80',
+        provider: 'gce',
+        region: 'us-central1',
+        urlMapName: 'app',
+      },
+      {
+        account: 'test',
+        certificate: '//certificatemanager.googleapis.com/projects/p/locations/us-central1/certificates/cert',
+        ipAddress: '34.0.0.2',
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'listener-https',
+        networkTier: 'PREMIUM',
+        portRange: '443-443',
+        provider: 'gce',
+        region: 'us-central1',
+        urlMapName: 'app',
+      },
+    ];
+
+    const [normalized] = transformer.normalizeLoadBalancerSet(loadBalancers as any);
+
+    expect(normalized.name).toBe('app (test/us-central1/EXTERNAL_MANAGED)');
+    expect((normalized as any).urlMapName).toBe('app');
+    expect((normalized as any).listeners).toEqual([
+      expect.objectContaining({
+        certificate: undefined,
+        ipAddress: '34.0.0.1',
+        name: 'listener-http',
+        networkTier: 'STANDARD',
+        port: '80',
+      }),
+      expect.objectContaining({
+        certificate: '//certificatemanager.googleapis.com/projects/p/locations/us-central1/certificates/cert',
+        ipAddress: '34.0.0.2',
+        name: 'listener-https',
+        networkTier: 'PREMIUM',
+        port: '443',
+      }),
+    ]);
+  });
+
+  it('keeps global HTTP normalization unchanged', () => {
+    const result = transformer.normalizeLoadBalancerSet([
+      {
+        account: 'test',
+        loadBalancerType: 'HTTP',
+        name: 'forwarding-rule-80',
+        portRange: '80-80',
+        provider: 'gce',
+        region: 'global',
+        urlMapName: 'frontend-map',
+      },
+      {
+        account: 'test',
+        loadBalancerType: 'HTTP',
+        name: 'forwarding-rule-443',
+        portRange: '443-443',
+        provider: 'gce',
+        region: 'global',
+        urlMapName: 'frontend-map',
+      },
+    ] as any);
+
+    expect(result.length).toBe(1);
+    expect(result[0].name).toBe('frontend-map');
+    expect((result[0] as any).listeners.map((listener: any) => listener.port)).toEqual(['80', '443']);
+  });
+
+  it('keeps INTERNAL_MANAGED names as the raw url map name that Clouddriver attaches by', () => {
+    const [internalManaged, externalManaged] = transformer.normalizeLoadBalancerSet([
+      {
+        account: 'test',
+        loadBalancerType: 'INTERNAL_MANAGED',
+        name: 'internal-listener',
+        portRange: '80-80',
+        provider: 'gce',
+        region: 'us-central1',
+        urlMapName: 'shared-map',
+      },
+      {
+        account: 'test',
+        loadBalancerType: 'EXTERNAL_MANAGED',
+        name: 'external-listener',
+        portRange: '80-80',
+        provider: 'gce',
+        region: 'us-central1',
+        urlMapName: 'shared-map',
+      },
+    ] as any);
+
+    expect(internalManaged.name).toBe('shared-map');
+    expect(externalManaged.name).toBe('shared-map (test/us-central1/EXTERNAL_MANAGED)');
+  });
+
+  it('does not group REGIONAL_EXTERNAL_NETWORK load balancers with regional HTTP families', () => {
+    const networkLoadBalancer = {
+      account: 'test',
+      loadBalancerType: 'REGIONAL_EXTERNAL_NETWORK',
+      name: 'regional-network-lb',
+      provider: 'gce',
+      region: 'us-central1',
+    };
+    const httpListener = {
+      account: 'test',
+      loadBalancerType: 'EXTERNAL_MANAGED',
+      name: 'listener-http',
+      portRange: '80-80',
+      provider: 'gce',
+      region: 'us-central1',
+      urlMapName: 'app',
+    };
+
+    const normalized = transformer.normalizeLoadBalancerSet([httpListener, networkLoadBalancer] as any);
+
+    expect(normalized.length).toBe(2);
+    expect(normalized.find((loadBalancer) => loadBalancer.name === 'regional-network-lb')).toBe(networkLoadBalancer);
+  });
+});

package/src/loadBalancer/loadBalancer.setTransformer.ts

@@ -10,6 +10,9 @@ export class GceLoadBalancerSetTransformer {
   private static normalizeHttpLoadBalancerGroup(group: IGceHttpLoadBalancer[]): IGceHttpLoadBalancer {
     const normalized = cloneDeep(group[0]);
 
+    // Clouddriver returns one row per forwarding-rule listener. Deck presents the URL map as the
+    // logical HTTP(S) load balancer, so the normalized object keeps the URL-map identity and folds
+    // forwarding-rule-specific fields into listener rows.
     normalized.listeners = group.map((loadBalancer) => {
       const port = loadBalancer.portRange ? GceLoadBalancerSetTransformer.parsePortRange(loadBalancer.portRange) : null;
       return {
@@ -18,11 +21,17 @@ export class GceLoadBalancerSetTransformer {
         certificate: loadBalancer.certificate,
         certificateMap: loadBalancer.certificateMap,
         ipAddress: loadBalancer.ipAddress,
+        networkTier: loadBalancer.networkTier,
         subnet: loadBalancer.subnet,
       };
     });
 
-    normalized.name = normalized.urlMapName;
+    normalized.name =
+      normalized.loadBalancerType === 'EXTERNAL_MANAGED'
+        ? // Regional external URL map names can repeat across accounts and regions, and match
+          // INTERNAL_MANAGED names; details routing can still use the raw urlMapName plus scope.
+          `${normalized.urlMapName} (${normalized.account}/${normalized.region}/${normalized.loadBalancerType})`
+        : normalized.urlMapName;
     delete normalized.subnet;
     return normalized;
   }
@@ -36,7 +45,11 @@ export class GceLoadBalancerSetTransformer {
       this.gceHttpLoadBalancerUtils.isHttpLoadBalancer(lb),
     );
 
-    const groupedByUrlMap = groupBy(httpLoadBalancers, 'urlMapName');
+    const groupedByUrlMap = groupBy(httpLoadBalancers, (loadBalancer) =>
+      loadBalancer.loadBalancerType === 'EXTERNAL_MANAGED'
+        ? [loadBalancer.account, loadBalancer.region, loadBalancer.loadBalancerType, loadBalancer.urlMapName].join(':')
+        : loadBalancer.urlMapName,
+    );
     const normalizedElSevenLoadBalancers = map(
       groupedByUrlMap,
       GceLoadBalancerSetTransformer.normalizeHttpLoadBalancerGroup,