How kubeflow/dashboard works
1. This repo is a Kubeflow Dashboard bundle: four versioned Kubernetes-deployed components are built and released together, but each has its own runtime boundary, image, manifests, tests, and ownership.
2. The main functional split is between user-facing dashboard services and cluster-side controllers/webhooks. The dashboard services provide the web UI and API endpoints; the controllers and webhook enforce cluster state, authorization, and pod mutation in Kubernetes.
3. centraldashboard is the legacy dashboard implementation. It is a Node/TypeScript service with a browser-facing front end under public/ and server-side logic under app/. The backend serves pages/components, exposes dashboard APIs, and gathers metrics; the front end is a component-based UI that renders notebook/pipeline/activity pages, namespace selection, and embedded iframes.
4. centraldashboard-angular is a newer Angular-based implementation with the same conceptual split: frontend/ for the SPA and backend/ for the API/proxy layer. Its backend includes services for Kubernetes interaction, environment discovery, metrics, and profile-controller integration, while the frontend handles routing, namespace selection, iframe embedding, URL sync, and error handling.
5. access-management (kfam) is the authorization/admin service for Kubeflow Profiles and access bindings. It exposes an API defined by Swagger and implements profile/binding management logic in Go, backed by Kubernetes resources and Kubeflow API types. This is the component that central dashboard features use when users manage access or workgroups.
6. profile-controller is the core Kubernetes operator. It watches Kubeflow Profile CRs and reconciles them into cluster resources such as namespaces, RBAC, role bindings, and supporting webhooks. It includes API versions for v1 and v1beta1, controller plugins for IAM and workload identity, and separate manager/webhook deployment paths.
7. poddefaults-webhooks is a mutating admission webhook for PodDefaults. It defines its own CRD and mutates incoming Pods so they inherit configured defaults such as injected containers or settings. This is a cluster admission boundary rather than a dashboard feature.
8. The main data flow is: user browser → dashboard frontend → dashboard backend → Kubernetes APIs and/or component services. The dashboard renders links and embedded views for Kubeflow tools, but actual authorization and namespace scoping are enforced through Profiles, RBAC, and the access-management/profile-controller stack.
9. Another key flow is cluster reconciliation: Profile CRs or access requests are submitted to Kubernetes → profile-controller or access-management processes them → cluster objects are created/updated → dashboard reads the resulting namespaces, permissions, and environment info to shape the UI.
10. Deployment is Kubernetes-native throughout. Each component has Dockerfiles plus Kustomize manifests with overlays for common, Istio, KServe, cert-manager, and different installation modes. The manifests are the primary architecture boundary for runtime wiring, service accounts, RBAC, webhooks, and network policy.
11. Metrics are first-class in the backend/controller services. The code supports Prometheus and Stackdriver-style metrics in different components, so observability is part of the server-side architecture rather than the UI.
12. Testing and delivery are organized as separate pipelines per component: unit tests, integration tests, multi-arch image builds, and OCI publishing via GitHub Actions. The testing/ directory contains shared install/deploy scripts for kind, Istio, cert-manager, and component bring-up, which reflects the repo’s deployment-oriented, system-level test boundaries.
Main entry points: access-management Access Management · profile-controller Profile Controller · components Kustomize manifests · releasing Release tooling
Components 18
Dashboard services
User-facing dashboard runtimes and UI layers
- Central Dashboard · Legacy dashboard bundle with server and browser UI
components/centraldashboard - Server API · Serves pages, dashboard APIs, metrics, and Kubernetes-backed data
components/centraldashboard/app - Browser UI · Notebook, pipeline, activity, namespace, and iframe views
components/centraldashboard/public - Angular Dashboard · Newer dashboard implementation with SPA frontend and backend proxy
components/centraldashboard-angular - Angular API · Kubernetes proxy, environment discovery, metrics, and profile-controller integration
components/centraldashboard-angular/backend/app - Angular SPA · Routing, namespace selection, iframe embedding, URL sync, and error handling
components/centraldashboard-angular/frontend/src/app
Cluster control
Authorization, profile reconciliation, and admission control
- Access Management · Swagger-defined authorization and profile/binding management service
components/access-management - Swagger API · Public API definition for profile and binding operations
components/access-management/api/swagger.yaml - Kfam core · Profile and binding routers, models, monitoring, and Kubernetes-backed logic
components/access-management/kfam - Profile Controller · Reconciles Kubeflow Profiles into namespaces, RBAC, and webhooks
components/profile-controller - Profile API · v1 and v1beta1 Profile API definitions and generated deepcopy code
components/profile-controller/api - Controller runtime · Main reconciliation loop plus webhook deployment path and metrics
components/profile-controller/controllers - PodDefaults Webhooks · Admission webhook that injects PodDefault settings into Pods
components/poddefaults-webhooks - PodDefault CRD · PodDefault custom resource definition and scheme registration
components/poddefaults-webhooks/pkg/apis/settings/v1alpha1 - Mutation logic · Pod mutation, validation, and admission serving path
components/poddefaults-webhooks
Delivery
Kubernetes manifests, release automation, and system tests
- Kustomize manifests · Base, overlays, service accounts, RBAC, webhooks, and network policy
components - Shared testing · Kind, Istio, cert-manager, and component bring-up scripts
testing/shared - Release tooling · Versioning, manifest image updates, and OCI publishing workflows
releasing
Connections 31
- Central Dashboard → Server API: backend · Legacy dashboard runtime splits into server logic
- Central Dashboard → Browser UI: ui · Legacy dashboard runtime ships a browser-facing front end
- Browser UI → Server API: api calls · UI requests dashboard data and rendered views from the server
- Server API → Access Management: profiles/auth · Server consults access-management for profile and access data
- Server API → Profile Controller: k8s data · Server reads cluster-scoped profile and namespace state
- Server API → PodDefaults Webhooks: cluster state · Server can surface environment and namespace information shaped by admission/webhooks
- Angular Dashboard → Angular API: backend · Angular bundle includes a backend API/proxy layer
- Angular Dashboard → Angular SPA: spa · Angular bundle includes the user-facing single-page app
- Angular SPA → Angular API: proxy/api · Frontend syncs state and fetches dashboard data through the backend
- Angular API → Access Management: profiles/auth · Angular backend integrates with access-management for workgroup/profile flows
- Angular API → Profile Controller: k8s data · Backend discovers namespaces, environment info, and controller-managed state
- Access Management → Swagger API: contract · Service is defined by its Swagger API surface
- Access Management → Kfam core: implementation · Service routes requests into core Go handlers and models
- Access Management → Profile Controller: profile ops · Access changes are coordinated with profile reconciliation
- Profile Controller → Profile API: types · Operator is driven by Profile CRD versions and generated types
- Profile Controller → Controller runtime: reconcile · Controller runtime performs reconciliation and webhook serving
- Profile Controller → Access Management: kfam integration · Manifest wiring exposes the controller to access-management integration
- PodDefaults Webhooks → PodDefault CRD: crd · Webhook defines and registers the PodDefault API
- PodDefaults Webhooks → Mutation logic: mutate · Admission server applies PodDefault mutations to Pods
- Kustomize manifests → Central Dashboard: deploy · Kustomize wires the legacy dashboard runtime into Kubernetes
- Kustomize manifests → Angular Dashboard: deploy · Kustomize wires the Angular dashboard runtime into Kubernetes
- Kustomize manifests → Access Management: deploy · Kustomize wires the access-management service into Kubernetes
- Kustomize manifests → Profile Controller: deploy · Kustomize wires the profile controller manager and webhook
- Kustomize manifests → PodDefaults Webhooks: deploy · Kustomize wires the PodDefaults admission webhook
- Shared testing → Kustomize manifests: integration · Shared scripts install dependencies and bring components up for tests
- Release tooling → Kustomize manifests: image refs · Release tooling updates manifests with published images
- Release tooling → Central Dashboard: publish · Legacy dashboard image is built and published as part of release
- Release tooling → Angular Dashboard: publish · Angular dashboard image is built and published as part of release
- Release tooling → Access Management: publish · Access-management image is built and published as part of release
- Release tooling → Profile Controller: publish · Profile controller image is built and published as part of release
- Release tooling → PodDefaults Webhooks: publish · PodDefaults webhook image is built and published as part of release