diff --git a/packages/kuma-gui/src/app/connections/locales/en-us/index.yaml b/packages/kuma-gui/src/app/connections/locales/en-us/index.yaml
index 5d6ecf86b..49e8930db 100644
--- a/packages/kuma-gui/src/app/connections/locales/en-us/index.yaml
+++ b/packages/kuma-gui/src/app/connections/locales/en-us/index.yaml
@@ -3,5 +3,6 @@ connections:
     item:
       navigation:
         overview: 'Overview'
+        xds: 'XDS Configuration'
         stats: 'Stats'
         clusters: 'Clusters'
diff --git a/packages/kuma-gui/src/app/connections/routes.ts b/packages/kuma-gui/src/app/connections/routes.ts
index bc5e99017..dca4160a0 100644
--- a/packages/kuma-gui/src/app/connections/routes.ts
+++ b/packages/kuma-gui/src/app/connections/routes.ts
@@ -11,6 +11,11 @@ export const routes = (): RouteRecordRaw[] => {
           name: 'connection-inbound-summary-overview-view',
           component: () => import('@/app/connections/views/ConnectionInboundSummaryOverviewView.vue'),
         },
+        {
+          path: 'xds-config',
+          name: 'connection-inbound-summary-xds-config-view',
+          component: () => import('@/app/connections/views/ConnectionInboundSummaryXdsConfigView.vue'),
+        },
         {
           path: 'stats',
           name: 'connection-inbound-summary-stats-view',
@@ -33,6 +38,11 @@ export const routes = (): RouteRecordRaw[] => {
           name: 'connection-outbound-summary-overview-view',
           component: () => import('@/app/connections/views/ConnectionOutboundSummaryOverviewView.vue'),
         },
+        {
+          path: 'xds-config',
+          name: 'connection-outbound-summary-xds-config-view',
+          component: () => import('@/app/connections/views/ConnectionOutboundSummaryXdsConfigView.vue'),
+        },
         {
           path: 'stats',
           name: 'connection-outbound-summary-stats-view',
diff --git a/packages/kuma-gui/src/app/connections/views/ConnectionInboundSummaryXdsConfigView.vue b/packages/kuma-gui/src/app/connections/views/ConnectionInboundSummaryXdsConfigView.vue
new file mode 100644
index 000000000..4f1381ac1
--- /dev/null
+++ b/packages/kuma-gui/src/app/connections/views/ConnectionInboundSummaryXdsConfigView.vue
@@ -0,0 +1,60 @@
+<template>
+  <RouteView
+    :params="{
+      codeSearch: '',
+      codeFilter: false,
+      codeRegExp: false,
+      mesh: '',
+      dataPlane: '',
+      connection: '',
+    }"
+    name="connection-inbound-summary-xds-config-view"
+    v-slot="{ route, uri }"
+  >
+    <RouteTitle
+      :render="false"
+      :title="`XDS Configuration`"
+    />
+    <AppView>
+      <DataLoader
+        :src="uri(sources, '/meshes/:mesh/dataplanes/:dataplane/inbound/:inbound/xds', {
+          mesh: route.params.mesh,
+          dataplane: route.params.dataPlane,
+          inbound: `${props.data.addressPort}`,
+        })"
+        v-slot="{ data: raw, refresh }"
+      >
+        <XCodeBlock
+          language="json"
+          :code="JSON.stringify(raw, null, 2)"
+          is-searchable
+          :query="route.params.codeSearch"
+          :is-filter-mode="route.params.codeFilter"
+          :is-reg-exp-mode="route.params.codeRegExp"
+          @query-change="route.update({ codeSearch: $event })"
+          @filter-mode-change="route.update({ codeFilter: $event })"
+          @reg-exp-mode-change="route.update({ codeRegExp: $event })"
+        >
+          <template #primary-actions>
+            <XAction
+              action="refresh"
+              appearance="primary"
+              @click="refresh"
+            >
+              Refresh
+            </XAction>
+          </template>
+        </XCodeBlock>
+      </DataLoader>
+    </AppView>
+  </RouteView>
+</template>
+<script lang="ts" setup>
+import type { DataplaneInbound, DataplaneOverview } from '@/app/data-planes/data/'
+import { sources } from '@/app/data-planes/sources'
+
+const props = defineProps<{
+  data: DataplaneInbound
+  dataplaneOverview: DataplaneOverview
+}>()
+</script>
diff --git a/packages/kuma-gui/src/app/connections/views/ConnectionOutboundSummaryXdsConfigView.vue b/packages/kuma-gui/src/app/connections/views/ConnectionOutboundSummaryXdsConfigView.vue
new file mode 100644
index 000000000..64c8410e1
--- /dev/null
+++ b/packages/kuma-gui/src/app/connections/views/ConnectionOutboundSummaryXdsConfigView.vue
@@ -0,0 +1,60 @@
+<template>
+  <RouteView
+    :params="{
+      codeSearch: '',
+      codeFilter: false,
+      codeRegExp: false,
+      mesh: '',
+      dataPlane: '',
+      connection: '',
+      includeEds: false,
+    }"
+    name="connection-outbound-summary-xds-config-view"
+    v-slot="{ route, uri }"
+  >
+    <RouteTitle
+      :render="false"
+      :title="`XDS Configuration`"
+    />
+    <AppView>
+      <DataLoader
+        :src="uri(sources, '/meshes/:mesh/dataplanes/:dataplane/outbound/:outbound/xds/:endpoints', {
+          mesh: route.params.mesh,
+          dataplane: route.params.dataPlane,
+          outbound: route.params.connection,
+          endpoints: String(route.params.includeEds),
+        })"
+        v-slot="{ data: raw, refresh }"
+      >
+        <XCodeBlock
+          language="json"
+          :code="JSON.stringify(raw, null, 2)"
+          is-searchable
+          :query="route.params.codeSearch"
+          :is-filter-mode="route.params.codeFilter"
+          :is-reg-exp-mode="route.params.codeRegExp"
+          @query-change="route.update({ codeSearch: $event })"
+          @filter-mode-change="route.update({ codeFilter: $event })"
+          @reg-exp-mode-change="route.update({ codeRegExp: $event })"
+        >
+          <template #primary-actions>
+            <XCheckbox
+              v-model="route.params.includeEds"
+              label="Include Endpoints"
+            />
+            <XAction
+              action="refresh"
+              appearance="primary"
+              @click="refresh"
+            >
+              Refresh
+            </XAction>
+          </template>
+        </XCodeBlock>
+      </DataLoader>
+    </AppView>
+  </RouteView>
+</template>
+<script lang="ts" setup>
+import { sources } from '@/app/data-planes/sources'
+</script>
diff --git a/packages/kuma-gui/src/app/data-planes/data/DataplaneNetworking.ts b/packages/kuma-gui/src/app/data-planes/data/DataplaneNetworking.ts
index 3349eea0a..008d307ae 100644
--- a/packages/kuma-gui/src/app/data-planes/data/DataplaneNetworking.ts
+++ b/packages/kuma-gui/src/app/data-planes/data/DataplaneNetworking.ts
@@ -79,7 +79,8 @@ export const DataplaneNetworking = {
           listenerAddress: '',
         }]
         : inbounds.map((item) => {
-          const address = item.address ?? networking.address
+          // inbound address, advertisedAddress, networkingAddress because externally accessible address
+          const address = item.address ?? networking.advertisedAddress ?? networking.address
           const port = item.servicePort ?? item.port
           return {
             ...item,
@@ -91,8 +92,7 @@ export const DataplaneNetworking = {
             service: item.tags['kuma.io/service'],
             protocol: item.tags['kuma.io/protocol'] ?? 'tcp',
             address,
-            // inbound address, advertisedAddress, networkingAddress because externally accessible address
-            addressPort: `${item.address ?? networking.advertisedAddress ?? networking.address}:${item.port}`,
+            addressPort: `${address}:${item.port}`,
             // inbound serviceAddress, inbound address, networkingAddress because the internal services accessible address
             serviceAddressPort: `${item.serviceAddress ?? address}:${port}`,
           }
diff --git a/packages/kuma-gui/src/app/data-planes/sources.ts b/packages/kuma-gui/src/app/data-planes/sources.ts
index dacbf7db5..724a463e9 100644
--- a/packages/kuma-gui/src/app/data-planes/sources.ts
+++ b/packages/kuma-gui/src/app/data-planes/sources.ts
@@ -30,7 +30,44 @@ export type MeshGatewayDataplaneSource = DataSourceResponse<MeshGatewayDataplane
 const includes = <T extends readonly string[]>(arr: T, item: string): item is T[number] => {
   return arr.includes(item as T[number])
 }
+type XdsConfig = Record<'configs', {
+  dynamic_active_clusters?: {
+    cluster: {
+      name: string
+    }
+  }[]
+  dynamic_listeners?: {
+    name: string
+  }[]
+  dynamic_endpoint_configs?: {
+    endpoint_config: {
+      cluster_name: string
+    }
+  }[]
+}[]>
+const filter = (data: XdsConfig, cb: (key: string, arr: unknown[]) => unknown[]) => {
+  const { configs } = data
+  return {
+    configs: configs.reduce((prev, item) => {
+      const entries = Object.entries(item)
+      const found = entries.reduce((prev, [key, value]) => {
+        const found = cb(key, value)
+        if (found.length > 0) {
+          if (typeof prev[key] === 'undefined') {
+            prev[key] = []
+          }
+          prev[key] = prev[key].concat(found)
+        }
+        return prev
+      }, {} as typeof configs[number])
+      if (Object.keys(found).length > 0) {
+        return prev.concat(found)
+      }
+      return prev
 
+    }, [] as typeof configs),
+  }
+}
 export const sources = (source: Source, api: KumaApi, can: Can) => {
   return defineSources({
     // always resolves and keeps polling until we have at least one dataplane and all dataplanes are online
@@ -87,6 +124,50 @@ export const sources = (source: Source, api: KumaApi, can: Can) => {
         dataPath,
       })
     },
+    '/meshes/:mesh/dataplanes/:dataplane/inbound/:inbound/xds': async (params) => {
+      const { mesh, dataplane, inbound } = params
+
+      // we don't ask for endpoints because we don't need them for inbound filtering
+      const res = await api.getDataplaneData({
+        mesh,
+        dppName: dataplane,
+        dataPath: 'xds',
+      }, {
+        include_eds: false,
+      })
+      // @ts-ignore res: api.getDataplaneData() returns a string even though it doesn't always return a string
+      // once we get OpenAPI specs for this we should be able to remove
+      return filter(res, (key: string, arr: { name: string }[]) => {
+        switch (key) {
+          case 'dynamic_listeners':
+            return arr.filter(item => item.name === `inbound:${inbound}`)
+        }
+        return []
+      })
+    },
+    '/meshes/:mesh/dataplanes/:dataplane/outbound/:outbound/xds/:endpoints': async (params) => {
+      const { mesh, dataplane, outbound, endpoints } = params
+
+      // we don't ask for endpoints because we don't need them for inbound filtering
+      const res = await api.getDataplaneData({
+        mesh,
+        dppName: dataplane,
+        dataPath: 'xds',
+      }, {
+        include_eds: endpoints,
+      })
+      // @ts-ignore res: api.getDataplaneData() returns a string even though it doesn't always return a string
+      // once we get OpenAPI specs for this we should be able to remove
+      return filter(res, (key: string, arr: { endpoint_config: { cluster_name: string }, cluster: { name: string } }[]) => {
+        switch (key) {
+          case 'dynamic_active_clusters':
+            return arr.filter(item => item.cluster.name === outbound)
+          case 'dynamic_endpoint_configs':
+            return arr.filter(item => item.endpoint_config.cluster_name === outbound)
+        }
+        return []
+      })
+    },
     '/meshes/:mesh/dataplanes/:name/xds/:endpoints': async (params) => {
       const { mesh, name, endpoints } = params
 
diff --git a/packages/kuma-gui/src/app/x/components/x-code-block/XCodeBlock.vue b/packages/kuma-gui/src/app/x/components/x-code-block/XCodeBlock.vue
index f243fa0d5..56b815c6d 100644
--- a/packages/kuma-gui/src/app/x/components/x-code-block/XCodeBlock.vue
+++ b/packages/kuma-gui/src/app/x/components/x-code-block/XCodeBlock.vue
@@ -1,5 +1,8 @@
 <template>
-  <div>
+  <div
+    class="x-code-block"
+    data-testid="x-code-block"
+  >
     <template
       v-if="$slots['primary-actions']"
     >
@@ -17,7 +20,7 @@
       :initial-filter-mode="props.isFilterMode"
       :initial-reg-exp-mode="props.isRegExpMode"
       :processing="isProcessing"
-      :searchable="isSearchable"
+      :searchable="true"
       :show-copy-button="showCopyButton"
       :query="props.query"
       theme="dark"
diff --git a/packages/kuma-gui/src/test-support/FakeKuma.ts b/packages/kuma-gui/src/test-support/FakeKuma.ts
index f24d76264..ff03881f2 100644
--- a/packages/kuma-gui/src/test-support/FakeKuma.ts
+++ b/packages/kuma-gui/src/test-support/FakeKuma.ts
@@ -260,6 +260,9 @@ export class KumaModule {
     }
   }
 
+  /**
+   * @deprecated - please inline networking property instead
+   */
   dataplaneNetworking(
     {
       type = 'proxy',
diff --git a/packages/kuma-gui/src/test-support/mocks/src/meshes/_/dataplanes/_/_overview.ts b/packages/kuma-gui/src/test-support/mocks/src/meshes/_/dataplanes/_/_overview.ts
index 4db637a85..87ffab1b2 100644
--- a/packages/kuma-gui/src/test-support/mocks/src/meshes/_/dataplanes/_/_overview.ts
+++ b/packages/kuma-gui/src/test-support/mocks/src/meshes/_/dataplanes/_/_overview.ts
@@ -37,15 +37,16 @@ export default ({ env, fake }: EndpointDependencies): MockResponder => (req) =>
     // temporarily overwrite the result of dataplaneNetworking as it doesn't
     // currently accept port plus we need to keep our ports synced.
     ; (networking.inbound ?? []).forEach((inbound, i) => {
-    if (fake.datatype.boolean()) {
+      // if (fake.datatype.boolean()) {
+      inbound.address = address
       inbound.port = ports[i].port
       inbound.servicePort = undefined
-    } else {
-      inbound.port = fake.number.int({ min: 1, max: 65535 })
-      inbound.servicePort = ports[i].port
-    }
-    inbound.tags['kuma.io/protocol'] = ports[i].protocol
-  })
+      // } else {
+      //   inbound.port = fake.number.int({ min: 1, max: 65535 })
+      //   inbound.servicePort = ports[i].port
+      // }
+      inbound.tags['kuma.io/protocol'] = ports[i].protocol
+    })
 
   const parts = String(name).split('.')
   const displayName = parts.slice(0, -1).join('.')
@@ -57,10 +58,36 @@ export default ({ env, fake }: EndpointDependencies): MockResponder => (req) =>
       type: 'DataplaneOverview',
       mesh,
       name,
-      creationTime: '2021-02-17T08:33:36.442044+01:00',
-      modificationTime: '2021-02-17T08:33:36.442044+01:00',
+      ...((modificationTime) => ({
+        creationTime: fake.kuma.date({ refDate: modificationTime }),
+        modificationTime,
+      }))(fake.kuma.date()),
       dataplane: {
-        networking,
+        networking: {
+          ...networking,
+          inbounds: Array.from({ length: inboundCount }).map((_, i) => {
+            return {
+              ...(() => {
+                // TODO(jc) we need to understand correctly, and cope with serviceAddress and servicePort and how it relates to address
+                return {
+                  address,
+                  port: ports[i].port,
+                }
+              })(),
+              tags: fake.kuma.tags({
+                protocol: fake.kuma.protocol(),
+                service,
+                zone: isMultizone && fake.datatype.boolean() ? fake.hacker.noun() : undefined,
+              }),
+            }
+          }),
+          outbounds: [
+            {
+              port: fake.internet.port(),
+              tags: fake.kuma.tags({ service }),
+            },
+          ],
+        },
       },
       ...(k8s
         ? {
diff --git a/packages/kuma-gui/src/test-support/mocks/src/meshes/_/dataplanes/_/xds.ts b/packages/kuma-gui/src/test-support/mocks/src/meshes/_/dataplanes/_/xds.ts
index 3f1f14211..31f1a1db8 100644
--- a/packages/kuma-gui/src/test-support/mocks/src/meshes/_/dataplanes/_/xds.ts
+++ b/packages/kuma-gui/src/test-support/mocks/src/meshes/_/dataplanes/_/xds.ts
@@ -1,521 +1,717 @@
 import type { EndpointDependencies, MockResponder } from '@/test-support'
-export default (_deps: EndpointDependencies): MockResponder => (_req) => {
+export default ({ env, fake }: EndpointDependencies): MockResponder => (req) => {
+  const query = req.url.searchParams
+  const { name } = req.params
+  const eds = query.get('include_eds') === 'true'
+
+  // use a seed based on the name to keep ports and ip address the same across
+  // _overview, stats and rules
+  fake.kuma.seed(name as string)
+  const inboundCount = parseInt(env('KUMA_DATAPLANEINBOUND_COUNT', `${fake.number.int({ min: 1, max: 10 })}`))
+  const ports = Array.from({ length: inboundCount }).map(() => ({
+    port: fake.number.int({ min: 1, max: 65535 }),
+    protocol: fake.kuma.protocol(),
+  }))
+  const address = fake.internet.ip()
+  const serviceCount = parseInt(env('KUMA_SERVICE_COUNT', `${fake.number.int({ min: 7, max: 50 })}`))
+  const services = Array.from({ length: serviceCount }).map(() => {
+    if (fake.datatype.boolean()) {
+      return `${fake.hacker.noun()}_${fake.hacker.noun()}_${fake.hacker.noun()}_${fake.hacker.noun()}_${fake.helpers.arrayElement(['msvc', 'mzsvc', 'extsvc'])}_${fake.number.int({ min: 1, max: 65535 })}`
+    } else {
+      return `${fake.hacker.noun()}_svc_${fake.number.int({ min: 1, max: 65535 })}`
+    }
+  })
+  if (env('KUMA_CLUSTER_NAME', '').length > 0) {
+    services[0] = env('KUMA_CLUSTER_NAME', '')
+  }
+  //
+
+  fake.kuma.seed()
+
   return {
     headers: {},
     body: {
-      version_info: '0',
-      resources: [
+      configs: [
         {
-          '@type': 'type.googleapis.com/envoy.api.v2.ClusterLoadAssignment',
-          cluster_name: 'default/snuba-query-tcp',
-          endpoints: [
-            {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-              ],
+          '@type': 'type.googleapis.com/envoy.admin.v3.BootstrapConfigDump',
+          bootstrap: {
+            node: {
+              id: 'default.demo-app-b4f98898-lrnr8.kuma-demo',
+              cluster: 'demo-app_kuma-demo_svc_5000',
+              metadata: {
+                'dataplane.proxyType': 'dataplane',
+                'dataplane.admin.address': '127.0.0.1',
+                version: {
+                  envoy: {
+                    kumaDpCompatible: true,
+                    build: '810bfcb8cae456e3a5e6541a0ee853185e2586f7/1.30.6/Modified/RELEASE/BoringSSL',
+                    version: '1.30.6',
+                  },
+                  kumaDp: {
+                    gitCommit: 'local-build',
+                    buildDate: 'local-build',
+                    version: '0.0.0-preview.vlocal-build',
+                    gitTag: 'local-build',
+                  },
+                },
+                'dataplane.readinessReporter.port': '9902',
+                workdir: '/tmp/kuma-dp-3143364667',
+                features: [
+                  'feature-tcp-accesslog-via-named-pipe',
+                ],
+                metricsKeyPath: '',
+                'dataplane.appProbeProxy.enabled': 'true',
+                systemCaPath: '/etc/ssl/certs/ca-certificates.crt',
+                metricsCertPath: '',
+                'dataplane.admin.port': '9901',
+                'dataplane.dns.port': '15055',
+              },
+              user_agent_name: 'envoy',
+              user_agent_build_version: {
+                version: {
+                  major_number: 1,
+                  minor_number: 30,
+                  patch: 6,
+                },
+                metadata: {
+                  'revision.status': 'Modified',
+                  'revision.sha': '810bfcb8cae456e3a5e6541a0ee853185e2586f7',
+                  'build.type': 'RELEASE',
+                  'ssl.version': 'BoringSSL',
+                },
+              },
+              extensions: Array.from({ length: fake.number.int({ min: 300, max: 450 }) }).map(_ => (
+                {
+                  name: 'envoy.rbac.matchers.upstream_ip_port',
+                  category: 'envoy.rbac.matchers',
+                  type_urls: [
+                    'envoy.extensions.rbac.matchers.upstream_ip_port.v3.UpstreamIpPortMatcher',
+                  ],
+                }
+              )),
             },
-            {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
+            static_resources: {
+              clusters: [
+                {
+                  name: 'access_log_sink',
+                  type: 'STATIC',
+                  connect_timeout: '1s',
+                  upstream_connection_options: {
+                    tcp_keepalive: {
+                      keepalive_probes: 3,
+                      keepalive_time: 10,
+                      keepalive_interval: 10,
+                    },
+                  },
+                  load_assignment: {
+                    cluster_name: 'access_log_sink',
+                    endpoints: [
+                      {
+                        lb_endpoints: [
+                          {
+                            endpoint: {
+                              address: {
+                                pipe: {
+                                  path: '/tmp/kuma-dp-3143364667/kuma-al-demo-app-b4f98898-lrnr8.kuma-demo-default.sock',
+                                },
+                              },
+                            },
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                  typed_extension_protocol_options: {
+                    'envoy.extensions.upstreams.http.v3.HttpProtocolOptions': {
+                      '@type': 'type.googleapis.com/envoy.extensions.upstreams.http.v3.HttpProtocolOptions',
+                      explicit_http_config: {
+                        http2_protocol_options: {},
                       },
                     },
                   },
                 },
               ],
-            },
-            {
-              lb_endpoints: [
+              secrets: [
                 {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
+                  name: 'cp_validation_ctx',
+                  validation_context: {
+                    trusted_ca: {
+                      inline_bytes: 'LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURFRENDQWZpZ0F3SUJBZ0lSQVBJdk04S3BQZG13RG9jN2JIMHBmOGN3RFFZSktvWklodmNOQVFFTEJRQXcKRWpFUU1BNEdBMVVFQXhNSGEzVnRZUzFqWVRBZUZ3MHlOREV4TVRFeE1qSTJOVFZhRncwek5ERXhNRGt4TWpJMgpOVFZhTUJJeEVEQU9CZ05WQkFNVEIydDFiV0V0WTJFd2dnRWlNQTBHQ1NxR1NJYjNEUUVCQVFVQUE0SUJEd0F3CmdnRUtBb0lCQVFEV1hqRnRwVEo1ME83YnV6ckRZZlhzeXdEb0d6YWNmR2UraWJHK0gzWWFIaTlCYjRQL2dZSGQKZWR0eEtxQjhrY092YzRwWHo3dzhrS1hSa2lSYmJVMXNyYThJYTl0NlUzdm4xNG9SbW1lWVdDdjk4VUxwOFNaaApENDJYMFBwNDNTQjVmTitsQ1BzUVoycVJUdFNsL2QrcmJMbFNqWEtNRXNIL3Nlb0dxeXpqYi9IeTQ5WmdsY1R6CkNuU3RDT0hzZ040NFJLU0JzeUZGWXJ4MXBRMXBJNWUzckxMUEhJdzJ6eFN1eTk0cTN5WVN6R0JoMkdJd2M2SXEKL2pPMWdxem0yMzdrMFFKWGFCdXBZVDhBeTdEalhub1MvKzkrbVJlRW5mUGhNTTZLTzZKa1BBd2VhQ2ZrTGpIZgpEeDhuV1JPWjlldThrVkJiZkVuN1dlMW56em9iWTcvZEFnTUJBQUdqWVRCZk1BNEdBMVVkRHdFQi93UUVBd0lDCnBEQWRCZ05WSFNVRUZqQVVCZ2dyQmdFRkJRY0RBUVlJS3dZQkJRVUhBd0l3RHdZRFZSMFRBUUgvQkFVd0F3RUIKL3pBZEJnTlZIUTRFRmdRVUx3ajFtOXlGTjJkWmhVZkdSOSt5VU5YTnJBc3dEUVlKS29aSWh2Y05BUUVMQlFBRApnZ0VCQU1QRmNvcWVkT3gxVjBkVko1dTdIVitxOXBJd29CenRIWWJFVGR1UWgxRlNkT1pOVGxqVEJiY2FIdEQ3ClRFMVlzSVZxdDFxMUtWTUVWd1Z4YjQ0Wk9jbGF2ZE1mb2ZNMU54bEpnblVuMkxoYXNrN1MyRXBjc0NBTGZPQjkKY1hpUTRTRC9LeFFXbEUrMjVPWG1yeGNwVkcrbmJBWTJSU1VBUFJjK0dHL1lZTVF4THBhd0tVd3g4emtibDdtSgpzV1duUmlScXRKNnBOWVRJMytxeTRZL3BCY3NYOXJBRkFsTUdhTlppeW83N0hkOEMyZ0dUcmFqMVQycXdLaEFmCmpjcnc0Wi9xT3dpbnRwdkpKVklyTktFTHIvemZRdjV1Z29wMDVZQzJoK3JGMWVTZHdPR3l6bHRueXVud2k1a1YKZ2JYUjVSbkVzMGhEeHVnYUlrbkpNS2szYjBnPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==',
                     },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
+                    match_typed_subject_alt_names: [
+                      {
+                        san_type: 'DNS',
+                        matcher: {
+                          exact: 'kuma-control-plane.kuma-system',
+                        },
                       },
-                    },
-                  },
-                },
-              ],
-            },
-            {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
+                      {
+                        san_type: 'IP_ADDRESS',
+                        matcher: {
+                          exact: 'kuma-control-plane.kuma-system',
+                        },
                       },
-                    },
+                    ],
                   },
                 },
               ],
             },
-            {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-              ],
+            dynamic_resources: {
+              lds_config: {
+                ads: {},
+                initial_fetch_timeout: '0s',
+                resource_api_version: 'V3',
+              },
+              cds_config: {
+                ads: {},
+                initial_fetch_timeout: '0s',
+                resource_api_version: 'V3',
+              },
+              ads_config: {
+                api_type: 'GRPC',
+                grpc_services: [
+                  {
+                    google_grpc: {
+                      target_uri: 'kuma-control-plane.kuma-system:5678',
+                      channel_credentials: {
+                        ssl_credentials: {
+                          root_certs: {
+                            inline_bytes: 'LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURFRENDQWZpZ0F3SUJBZ0lSQVBJdk04S3BQZG13RG9jN2JIMHBmOGN3RFFZSktvWklodmNOQVFFTEJRQXcKRWpFUU1BNEdBMVVFQXhNSGEzVnRZUzFqWVRBZUZ3MHlOREV4TVRFeE1qSTJOVFZhRncwek5ERXhNRGt4TWpJMgpOVFZhTUJJeEVEQU9CZ05WQkFNVEIydDFiV0V0WTJFd2dnRWlNQTBHQ1NxR1NJYjNEUUVCQVFVQUE0SUJEd0F3CmdnRUtBb0lCQVFEV1hqRnRwVEo1ME83YnV6ckRZZlhzeXdEb0d6YWNmR2UraWJHK0gzWWFIaTlCYjRQL2dZSGQKZWR0eEtxQjhrY092YzRwWHo3dzhrS1hSa2lSYmJVMXNyYThJYTl0NlUzdm4xNG9SbW1lWVdDdjk4VUxwOFNaaApENDJYMFBwNDNTQjVmTitsQ1BzUVoycVJUdFNsL2QrcmJMbFNqWEtNRXNIL3Nlb0dxeXpqYi9IeTQ5WmdsY1R6CkNuU3RDT0hzZ040NFJLU0JzeUZGWXJ4MXBRMXBJNWUzckxMUEhJdzJ6eFN1eTk0cTN5WVN6R0JoMkdJd2M2SXEKL2pPMWdxem0yMzdrMFFKWGFCdXBZVDhBeTdEalhub1MvKzkrbVJlRW5mUGhNTTZLTzZKa1BBd2VhQ2ZrTGpIZgpEeDhuV1JPWjlldThrVkJiZkVuN1dlMW56em9iWTcvZEFnTUJBQUdqWVRCZk1BNEdBMVVkRHdFQi93UUVBd0lDCnBEQWRCZ05WSFNVRUZqQVVCZ2dyQmdFRkJRY0RBUVlJS3dZQkJRVUhBd0l3RHdZRFZSMFRBUUgvQkFVd0F3RUIKL3pBZEJnTlZIUTRFRmdRVUx3ajFtOXlGTjJkWmhVZkdSOSt5VU5YTnJBc3dEUVlKS29aSWh2Y05BUUVMQlFBRApnZ0VCQU1QRmNvcWVkT3gxVjBkVko1dTdIVitxOXBJd29CenRIWWJFVGR1UWgxRlNkT1pOVGxqVEJiY2FIdEQ3ClRFMVlzSVZxdDFxMUtWTUVWd1Z4YjQ0Wk9jbGF2ZE1mb2ZNMU54bEpnblVuMkxoYXNrN1MyRXBjc0NBTGZPQjkKY1hpUTRTRC9LeFFXbEUrMjVPWG1yeGNwVkcrbmJBWTJSU1VBUFJjK0dHL1lZTVF4THBhd0tVd3g4emtibDdtSgpzV1duUmlScXRKNnBOWVRJMytxeTRZL3BCY3NYOXJBRkFsTUdhTlppeW83N0hkOEMyZ0dUcmFqMVQycXdLaEFmCmpjcnc0Wi9xT3dpbnRwdkpKVklyTktFTHIvemZRdjV1Z29wMDVZQzJoK3JGMWVTZHdPR3l6bHRueXVud2k1a1YKZ2JYUjVSbkVzMGhEeHVnYUlrbkpNS2szYjBnPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==',
+                          },
+                        },
+                      },
+                      call_credentials: [
+                        {
+                          from_plugin: {
+                            name: 'envoy.grpc_credentials.file_based_metadata',
+                            typed_config: {
+                              '@type': 'type.googleapis.com/envoy.config.grpc_credential.v3.FileBasedMetadataConfig',
+                              secret_data: {
+                                filename: '[redacted]',
+                              },
+                            },
+                          },
+                        },
+                      ],
+                      stat_prefix: 'ads',
+                      credentials_factory_name: 'envoy.grpc_credentials.file_based_metadata',
+                    },
+                  },
+                ],
+                set_node_on_first_message_only: true,
+                transport_api_version: 'V3',
+              },
             },
-            {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
+            admin: {
+              address: {
+                socket_address: {
+                  address: '127.0.0.1',
+                  port_value: 9901,
                 },
+              },
+              access_log: [
                 {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
+                  name: 'envoy.access_loggers.file',
+                  typed_config: {
+                    '@type': 'type.googleapis.com/envoy.extensions.access_loggers.file.v3.FileAccessLog',
+                    path: '/dev/null',
                   },
                 },
               ],
             },
-            {
-              lb_endpoints: [
+            stats_config: {
+              stats_tags: [
                 {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
+                  tag_name: 'name',
+                  regex: '^grpc\\.((.+)\\.)',
                 },
                 {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
+                  tag_name: 'status',
+                  regex: '^grpc.*streams_closed(_([0-9]+))',
                 },
-              ],
-            },
-            {
-              lb_endpoints: [
                 {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
+                  tag_name: 'kafka_name',
+                  regex: '^kafka(\\.(\\S*[0-9]))\\.',
                 },
                 {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
+                  tag_name: 'kafka_type',
+                  regex: '^kafka\\..*\\.(.*?(?=_duration|$))',
                 },
-              ],
-            },
-            {
-              lb_endpoints: [
                 {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
+                  tag_name: 'worker',
+                  regex: '(worker_([0-9]+)\\.)',
                 },
                 {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
+                  tag_name: 'listener',
+                  regex: '((.+?)\\.)rbac\\.',
                 },
               ],
             },
-            {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
+            layered_runtime: {
+              layers: [
                 {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
+                  name: 'kuma',
+                  static_layer: {
+                    're2.max_program_size.error_level': '4294967295',
+                    're2.max_program_size.warn_level': 1000,
                   },
                 },
               ],
             },
-            {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-              ],
-            },
-            {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-              ],
+            default_regex_engine: {
+              name: 'envoy.regex_engines.google_re2',
+              typed_config: {
+                '@type': 'type.googleapis.com/envoy.extensions.regex_engines.v3.GoogleRE2',
+              },
             },
+          },
+          last_updated: '2024-11-11T12:27:04.416Z',
+        },
+        {
+          '@type': 'type.googleapis.com/envoy.admin.v3.ClustersConfigDump',
+          version_info: 'd098a1fa-782b-46bb-b47a-f10e799bd5aa',
+          static_clusters: [
             {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-              ],
+              cluster: {
+                '@type': 'type.googleapis.com/envoy.config.cluster.v3.Cluster',
+                name: 'access_log_sink',
+                type: 'STATIC',
+                connect_timeout: '1s',
+                upstream_connection_options: {
+                  tcp_keepalive: {
+                    keepalive_probes: 3,
+                    keepalive_time: 10,
+                    keepalive_interval: 10,
+                  },
+                },
+                load_assignment: {
+                  cluster_name: 'access_log_sink',
+                  endpoints: [
+                    {
+                      lb_endpoints: [
+                        {
+                          endpoint: {
+                            address: {
+                              pipe: {
+                                path: '/tmp/kuma-dp-3143364667/kuma-al-demo-app-b4f98898-lrnr8.kuma-demo-default.sock',
+                              },
+                            },
+                          },
+                        },
+                      ],
+                    },
+                  ],
+                },
+                typed_extension_protocol_options: {
+                  'envoy.extensions.upstreams.http.v3.HttpProtocolOptions': {
+                    '@type': 'type.googleapis.com/envoy.extensions.upstreams.http.v3.HttpProtocolOptions',
+                    explicit_http_config: {
+                      http2_protocol_options: {},
+                    },
+                  },
+                },
+              },
+              last_updated: '2024-11-11T12:27:04.433Z',
             },
+          ],
+          dynamic_active_clusters: [
             {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-              ],
+              version_info: 'd098a1fa-782b-46bb-b47a-f10e799bd5aa',
+              cluster: {
+                '@type': 'type.googleapis.com/envoy.config.cluster.v3.Cluster',
+                name: 'default_demo-app_kuma-demo_default_msvc_5000',
+                type: 'EDS',
+                eds_cluster_config: {
+                  eds_config: {
+                    ads: {},
+                    resource_api_version: 'V3',
+                  },
+                },
+                connect_timeout: '5s',
+                circuit_breakers: {
+                  thresholds: [
+                    {
+                      max_connections: 1024,
+                      max_pending_requests: 1024,
+                      max_requests: 1024,
+                      max_retries: 3,
+                    },
+                  ],
+                },
+                typed_extension_protocol_options: {
+                  'envoy.extensions.upstreams.http.v3.HttpProtocolOptions': {
+                    '@type': 'type.googleapis.com/envoy.extensions.upstreams.http.v3.HttpProtocolOptions',
+                    explicit_http_config: {
+                      http2_protocol_options: {},
+                    },
+                  },
+                },
+              },
+              last_updated: '2024-11-18T09:56:27.782Z',
             },
+          ],
+        },
+        ...(eds
+          ? [{
+            '@type': 'type.googleapis.com/envoy.admin.v3.EndpointsConfigDump',
+            static_endpoint_configs: [
+              {
+                endpoint_config: {
+                  '@type': 'type.googleapis.com/envoy.config.endpoint.v3.ClusterLoadAssignment',
+                  cluster_name: 'access_log_sink',
+                  endpoints: [
+                    {
+                      locality: {},
+                      lb_endpoints: [
+                        {
+                          endpoint: {
+                            address: {
+                              pipe: {
+                                path: '/tmp/kuma-dp-3143364667/kuma-al-demo-app-b4f98898-lrnr8.kuma-demo-default.sock',
+                              },
+                            },
+                            health_check_config: {},
+                          },
+                          health_status: 'HEALTHY',
+                          load_balancing_weight: 1,
+                        },
+                      ],
+                      load_balancing_weight: 0,
+                    },
+                  ],
+                  policy: {
+                    overprovisioning_factor: 140,
+                  },
+                },
+              },
+            ],
+            dynamic_endpoint_configs: services.map((item) => {
+              return {
+                endpoint_config: {
+                  '@type': 'type.googleapis.com/envoy.config.endpoint.v3.ClusterLoadAssignment',
+                  cluster_name: item,
+                  policy: {
+                    overprovisioning_factor: 140,
+                  },
+                },
+              }
+            }),
+          }]
+          : []),
+        {
+          '@type': 'type.googleapis.com/envoy.admin.v3.ListenersConfigDump',
+          version_info: '1a86643e-61fb-4d08-9dba-14b5e91bb697',
+          dynamic_active_clusters: services.map((item) => {
+            return {
+              version_info: 'd3abaa95-216a-4d2b-a70f-cb87011f59c1',
+              cluster: {
+                '@type': 'type.googleapis.com/envoy.config.cluster.v3.Cluster',
+                name: item,
+                type: 'EDS',
+                eds_cluster_config: {
+                  eds_config: {
+                    ads: {},
+                    resource_api_version: 'V3',
+                  },
+                },
+                connect_timeout: '5s',
+                circuit_breakers: {
+                  thresholds: [
+                    {
+                      max_connections: 1024,
+                      max_pending_requests: 1024,
+                      max_requests: 1024,
+                      max_retries: 3,
+                    },
+                  ],
+                },
+                typed_extension_protocol_options: {
+                  'envoy.extensions.upstreams.http.v3.HttpProtocolOptions': {
+                    '@type': 'type.googleapis.com/envoy.extensions.upstreams.http.v3.HttpProtocolOptions',
+                    explicit_http_config: {
+                      http2_protocol_options: {},
+                    },
+                  },
+                },
+              },
+              last_updated: '2024-11-15T16:45:51.489Z',
+            }
+          }),
+          dynamic_listeners: ports.map((item) => (
             {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-              ],
-            },
+              name: `inbound:${address}:${item.port}`,
+              // name: 'inbound:passthrough:ipv4',
+              active_state: {
+                version_info: '9ece210f-6fed-44c8-b2ac-168156c698e1',
+                listener: {
+                  '@type': 'type.googleapis.com/envoy.config.listener.v3.Listener',
+                  name: `inbound:${address}:${item.port}`,
+                  address: {
+                    socket_address: {
+                      address,
+                      port_value: item.port,
+                    },
+                  },
+                  filter_chains: [
+                    {
+                      filters: [
+                        {
+                          name: 'envoy.filters.network.http_connection_manager',
+                          typed_config: {
+                            '@type': 'type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager',
+                            stat_prefix: `localhost_${item.port}`,
+                            route_config: {
+                              name: `inbound:demo-app_kuma-demo_svc_${item.port}`,
+                              virtual_hosts: [
+                                {
+                                  name: `demo-app_kuma-demo_svc_${item.port}`,
+                                  domains: [
+                                    '*',
+                                  ],
+                                  routes: [
+                                    {
+                                      match: {
+                                        prefix: '/',
+                                      },
+                                      route: {
+                                        cluster: `localhost:${item.port}`,
+                                        timeout: '0s',
+                                        idle_timeout: '3600s',
+                                      },
+                                    },
+                                  ],
+                                },
+                              ],
+                              validate_clusters: false,
+                              request_headers_to_remove: [
+                                'x-kuma-tags',
+                              ],
+                            },
+                            http_filters: [
+                              {
+                                name: 'envoy.filters.http.router',
+                                typed_config: {
+                                  '@type': 'type.googleapis.com/envoy.extensions.filters.http.router.v3.Router',
+                                },
+                              },
+                            ],
+                            forward_client_cert_details: 'SANITIZE_SET',
+                            set_current_client_cert_details: {
+                              uri: true,
+                            },
+                            stream_idle_timeout: '3600s',
+                            common_http_protocol_options: {
+                              idle_timeout: '0s',
+                            },
+                            request_headers_timeout: '0s',
+                          },
+                        },
+                      ],
+                    },
+                  ],
+                  metadata: {
+                    filter_metadata: {
+                      'io.kuma.tags': {
+                        'kuma.io/protocol': 'http',
+                        'kuma.io/zone': 'default',
+                        'pod-template-hash': 'b4f98898',
+                        'kubernetes.io/hostname': 'k3d-kuma-server-0',
+                        'k8s.kuma.io/service-name': 'demo-app',
+                        app: 'demo-app',
+                        'kuma.io/service': `demo-app_kuma-demo_svc_${item.port}`,
+                        'k8s.kuma.io/namespace': 'kuma-demo',
+                        'k8s.kuma.io/service-port': `${item.port}`,
+                      },
+                    },
+                  },
+                  traffic_direction: 'INBOUND',
+                  bind_to_port: false,
+                  enable_reuse_port: false,
+                },
+                last_updated: '2024-11-11T12:27:04.714Z',
+              },
+            }
+          )),
+        },
+        {
+          '@type': 'type.googleapis.com/envoy.admin.v3.ScopedRoutesConfigDump',
+        },
+        {
+          '@type': 'type.googleapis.com/envoy.admin.v3.RoutesConfigDump',
+          static_route_configs: [
             {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-              ],
+              route_config: {
+                '@type': 'type.googleapis.com/envoy.config.route.v3.RouteConfiguration',
+                virtual_hosts: [
+                  {
+                    name: 'kuma:envoy:admin',
+                    domains: [
+                      '*',
+                    ],
+                    routes: [
+                      {
+                        match: {
+                          prefix: '/ready',
+                        },
+                        route: {
+                          cluster: 'kuma:readiness',
+                          prefix_rewrite: '/ready',
+                        },
+                      },
+                    ],
+                  },
+                ],
+                validate_clusters: false,
+              },
+              last_updated: '2024-11-11T12:27:04.725Z',
             },
             {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-              ],
+              route_config: {
+                '@type': 'type.googleapis.com/envoy.config.route.v3.RouteConfiguration',
+                name: 'inbound:demo-app_kuma-demo_svc_5000',
+                virtual_hosts: [
+                  {
+                    name: 'demo-app_kuma-demo_svc_5000',
+                    domains: [
+                      '*',
+                    ],
+                    routes: [
+                      {
+                        match: {
+                          prefix: '/',
+                        },
+                        route: {
+                          cluster: 'localhost:5000',
+                          timeout: '0s',
+                          idle_timeout: '3600s',
+                        },
+                      },
+                    ],
+                  },
+                ],
+                validate_clusters: false,
+                request_headers_to_remove: [
+                  'x-kuma-tags',
+                ],
+              },
+              last_updated: '2024-11-11T12:27:04.712Z',
             },
             {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-              ],
+              route_config: {
+                '@type': 'type.googleapis.com/envoy.config.route.v3.RouteConfiguration',
+                name: 'outbound:default_demo-app_kuma-demo_default_msvc_5000',
+                virtual_hosts: [
+                  {
+                    name: 'default_demo-app_kuma-demo_default_msvc_5000',
+                    domains: [
+                      '*',
+                    ],
+                    routes: [
+                      {
+                        match: {
+                          prefix: '/',
+                        },
+                        route: {
+                          cluster: 'default_demo-app_kuma-demo_default_msvc_5000',
+                          timeout: '15s',
+                          retry_policy: {
+                            retry_on: 'gateway-error,connect-failure,refused-stream',
+                            num_retries: 5,
+                            per_try_timeout: '16s',
+                            retry_back_off: {
+                              base_interval: '0.025s',
+                              max_interval: '0.250s',
+                            },
+                          },
+                          idle_timeout: '1800s',
+                        },
+                        name: '9Zuf5Tg79OuZcQITwBbQykxAk2u4fRKrwYn3//AL4Yo=',
+                      },
+                    ],
+                  },
+                ],
+                request_headers_to_add: [
+                  {
+                    header: {
+                      key: 'x-kuma-tags',
+                      value: '&app=demo-app&&k8s.kuma.io/namespace=kuma-demo&&k8s.kuma.io/service-name=demo-app&&k8s.kuma.io/service-port=5000&&kubernetes.io/hostname=k3d-kuma-server-0&&kuma.io/protocol=http&&kuma.io/service=demo-app_kuma-demo_svc_5000&&kuma.io/zone=default&&pod-template-hash=b4f98898&',
+                    },
+                  },
+                ],
+                validate_clusters: false,
+              },
+              last_updated: '2024-11-14T12:12:36.248Z',
             },
             {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-              ],
+              route_config: {
+                '@type': 'type.googleapis.com/envoy.config.route.v3.RouteConfiguration',
+                virtual_hosts: [
+                  {
+                    name: 'kuma:envoy:admin',
+                    domains: [
+                      '*',
+                    ],
+                    routes: [
+                      {
+                        match: {
+                          prefix: '/ready',
+                        },
+                        route: {
+                          cluster: 'kuma:readiness',
+                          prefix_rewrite: '/ready',
+                        },
+                      },
+                      {
+                        match: {
+                          prefix: '/',
+                        },
+                        route: {
+                          cluster: 'kuma:envoy:admin',
+                          prefix_rewrite: '/',
+                        },
+                      },
+                    ],
+                  },
+                ],
+                validate_clusters: false,
+              },
+              last_updated: '2024-11-14T18:42:13.028Z',
             },
+          ],
+        },
+        {
+          '@type': 'type.googleapis.com/envoy.admin.v3.SecretsConfigDump',
+          static_secrets: [
             {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
-                      },
-                    },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
-                      },
-                    },
+              name: 'cp_validation_ctx',
+              secret: {
+                '@type': 'type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.Secret',
+                name: 'cp_validation_ctx',
+                validation_context: {
+                  trusted_ca: {
+                    inline_bytes: 'LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURFRENDQWZpZ0F3SUJBZ0lSQVBJdk04S3BQZG13RG9jN2JIMHBmOGN3RFFZSktvWklodmNOQVFFTEJRQXcKRWpFUU1BNEdBMVVFQXhNSGEzVnRZUzFqWVRBZUZ3MHlOREV4TVRFeE1qSTJOVFZhRncwek5ERXhNRGt4TWpJMgpOVFZhTUJJeEVEQU9CZ05WQkFNVEIydDFiV0V0WTJFd2dnRWlNQTBHQ1NxR1NJYjNEUUVCQVFVQUE0SUJEd0F3CmdnRUtBb0lCQVFEV1hqRnRwVEo1ME83YnV6ckRZZlhzeXdEb0d6YWNmR2UraWJHK0gzWWFIaTlCYjRQL2dZSGQKZWR0eEtxQjhrY092YzRwWHo3dzhrS1hSa2lSYmJVMXNyYThJYTl0NlUzdm4xNG9SbW1lWVdDdjk4VUxwOFNaaApENDJYMFBwNDNTQjVmTitsQ1BzUVoycVJUdFNsL2QrcmJMbFNqWEtNRXNIL3Nlb0dxeXpqYi9IeTQ5WmdsY1R6CkNuU3RDT0hzZ040NFJLU0JzeUZGWXJ4MXBRMXBJNWUzckxMUEhJdzJ6eFN1eTk0cTN5WVN6R0JoMkdJd2M2SXEKL2pPMWdxem0yMzdrMFFKWGFCdXBZVDhBeTdEalhub1MvKzkrbVJlRW5mUGhNTTZLTzZKa1BBd2VhQ2ZrTGpIZgpEeDhuV1JPWjlldThrVkJiZkVuN1dlMW56em9iWTcvZEFnTUJBQUdqWVRCZk1BNEdBMVVkRHdFQi93UUVBd0lDCnBEQWRCZ05WSFNVRUZqQVVCZ2dyQmdFRkJRY0RBUVlJS3dZQkJRVUhBd0l3RHdZRFZSMFRBUUgvQkFVd0F3RUIKL3pBZEJnTlZIUTRFRmdRVUx3ajFtOXlGTjJkWmhVZkdSOSt5VU5YTnJBc3dEUVlKS29aSWh2Y05BUUVMQlFBRApnZ0VCQU1QRmNvcWVkT3gxVjBkVko1dTdIVitxOXBJd29CenRIWWJFVGR1UWgxRlNkT1pOVGxqVEJiY2FIdEQ3ClRFMVlzSVZxdDFxMUtWTUVWd1Z4YjQ0Wk9jbGF2ZE1mb2ZNMU54bEpnblVuMkxoYXNrN1MyRXBjc0NBTGZPQjkKY1hpUTRTRC9LeFFXbEUrMjVPWG1yeGNwVkcrbmJBWTJSU1VBUFJjK0dHL1lZTVF4THBhd0tVd3g4emtibDdtSgpzV1duUmlScXRKNnBOWVRJMytxeTRZL3BCY3NYOXJBRkFsTUdhTlppeW83N0hkOEMyZ0dUcmFqMVQycXdLaEFmCmpjcnc0Wi9xT3dpbnRwdkpKVklyTktFTHIvemZRdjV1Z29wMDVZQzJoK3JGMWVTZHdPR3l6bHRueXVud2k1a1YKZ2JYUjVSbkVzMGhEeHVnYUlrbkpNS2szYjBnPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==',
                   },
-                },
-              ],
-            },
-            {
-              lb_endpoints: [
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.109',
-                        port_value: 9000,
+                  match_typed_subject_alt_names: [
+                    {
+                      san_type: 'DNS',
+                      matcher: {
+                        exact: 'kuma-control-plane.kuma-system',
                       },
                     },
-                  },
-                },
-                {
-                  endpoint: {
-                    address: {
-                      socket_address: {
-                        address: '192.168.208.139',
-                        port_value: 9000,
+                    {
+                      san_type: 'IP_ADDRESS',
+                      matcher: {
+                        exact: 'kuma-control-plane.kuma-system',
                       },
                     },
-                  },
+                  ],
                 },
-              ],
+              },
             },
           ],
         },
       ],
+
     },
   }
 }