update README

Signed-off-by: Arvind Thirumurugan <arvindth@microsoft.com>

Author: Arvind Thirumurugan

approval-controller-metric-collector/README.md

@@ -35,45 +35,67 @@ make setup-clusters
 ```
 
 This will create:
-- 1 hub cluster
-- 3 member clusters (or the number specified in MEMBER_CLUSTER_COUNT)
+- 1 hub cluster (context: `kind-hub`)
+- 3 member clusters (contexts: `kind-cluster-1`, `kind-cluster-2`, `kind-cluster-3`)
 
-### 2. Deploy Prometheus on Member Clusters
+### 2. Register Member Clusters with Hub
 
-On each member cluster, deploy Prometheus to collect metrics:
+Switch to hub cluster context and register the member clusters:
 
 ```bash
-# Create namespace for test workloads
-kubectl create ns test-ns
+cd /path/to/approval-controller-metric-collector/approval-request-controller
+
+# Switch to hub cluster
+kubectl config use-context kind-hub
+
+# Register member clusters with the hub
+kubectl apply -f ./examples/membercluster/
 
-# Deploy Prometheus
-kubectl apply -f ./approval-request-controller/examples/prometheus/
+# Verify clusters are registered
+kubectl get cluster -A
 ```
 
-This deploys:
-- Prometheus server
-- ServiceMonitor configuration
-- RBAC permissions
+the output should look something like this,
 
-### 3. Deploy Sample Metric Application
+```bash
+NAME             JOINED   AGE   MEMBER-AGENT-LAST-SEEN   NODE-COUNT   AVAILABLE-CPU   AVAILABLE-MEMORY
+kind-cluster-1   True     40s   29s                      0            0               0
+kind-cluster-2   True     40s   3s                       0            0               0
+kind-cluster-3   True     40s   37s                      0            0               0
+```
+Wait until all member clusters show as joined.
 
-The sample metric application image will be automatically built and loaded to all member clusters when you run the `install-on-member.sh` script in Step 5 below. This ensures the `metric-app:local` image is available on each cluster before propagating the deployment from hub to member clusters.
+### 3. Deploy Prometheus
 
-After the metric collector is installed (Step 5), deploy the sample application that exposes health metrics:
+Create the prometheus namespace and deploy Prometheus for metrics collection:
 
 ```bash
-kubectl apply -f ./approval-request-controller/examples/sample-metric-app/sample-metric-app.yaml
+# Create prometheus namespace
+kubectl create ns prometheus
+
+# Deploy Prometheus (ConfigMap, Deployment, Service, RBAC)
+kubectl apply -f ./examples/prometheus/
 ```
 
-This creates a deployment in the `test-ns` namespace with Prometheus annotations for metric scraping. When this deployment is propagated to member clusters via ClusterResourcePlacement, the image will already be available locally.
+This deploys Prometheus configured to scrape pods from all namespaces with the proper annotations.
 
-### 4. Install Approval Request Controller (Hub Cluster)
+### 4. Deploy Sample Metric Application
 
-On the hub cluster, install the approval request controller using the provided installation script:
+Create the test namespace and deploy the sample application:
 
 ```bash
-cd approval-request-controller
+# Create test namespace
+kubectl create ns test-ns
+
+# Deploy sample metric app (this will be propagated to member clusters)
+kubectl apply -f ./examples/sample-metric-app/
+```
 
+### 5. Install Approval Request Controller (Hub Cluster)
+
+Install the approval request controller on the hub cluster:
+
+```bash
 # Run the installation script
 ./install-on-hub.sh
 ```
@@ -85,12 +107,22 @@ The script performs the following:
 4. Installs the controller via Helm with the custom CRDs (MetricCollector, MetricCollectorReport, WorkloadTracker)
 5. Verifies the installation
 
-### 5. Install Metric Collector (Member Clusters)
+### 6. Configure Workload Tracker
+
+Apply the WorkloadTracker to define which workloads to monitor:
+
+```bash
+kubectl apply -f ./examples/workloadtracker/
+```
+
+This tells the approval controller which workloads to track and what health thresholds to use.
+
+### 7. Install Metric Collector (Member Clusters)
 
-On each member cluster, install the metric collector. The installation script will automatically build and load both the metric-collector and metric-app images to all specified member clusters:
+Install the metric collector on all member clusters:
 
 ```bash
-cd standalone-metric-collector
+cd ../standalone-metric-collector
 
 # Run the installation script for all member clusters
 # This builds both metric-collector and metric-app images and loads them into each cluster
@@ -106,32 +138,129 @@ The script performs the following for each member cluster:
 
 The `metric-app:local` image is pre-loaded so it's available when you propagate the sample-metric-app deployment from hub to member clusters.
 
+### 8. Create Staged Update
+
+Switch back to hub cluster and create a staged update run:
+
+```bash
+# Switch to hub cluster
+kubectl config use-context kind-hub
+
+cd ../approval-request-controller
+
+# Apply ClusterStagedUpdateStrategy
+kubectl apply -f ./examples/updateRun/example-csus.yaml
+
+# Apply ClusterResourcePlacement
+kubectl apply -f ./examples/updateRun/example-crp.yaml
+```
+
+```bash
+# Verify CRP is created
+kubectl get crp -A
+```
+
+```bash
+NAME              GEN   SCHEDULED   SCHEDULED-GEN   AVAILABLE   AVAILABLE-GEN   AGE
+example-crp       1     True        1                                           4s
+proemetheus-crp   1     True        1               True        1               3m1s
+```
+
+```bash
+# Apply ClusterStagedUpdateRun to start the staged rollout
+kubectl apply -f ./examples/updateRun/example-csur.yaml
+```
+
+```bash
+NAME                         PLACEMENT     RESOURCE-SNAPSHOT-INDEX   POLICY-SNAPSHOT-INDEX   INITIALIZED   PROGRESSING   SUCCEEDED   AGE
+example-cluster-staged-run   example-crp   0                         0                       True          True                      5s
+```
+
+### 9. Monitor the Staged Rollout
+
+Watch the staged update progress:
+
+```bash
+# Check the staged update run status
+kubectl get csur -A
+```
+
+```bash
+# Check approval requests (should be auto-approved based on metrics)
+kubectl get clusterapprovalrequest -A
+```
+
+```bash
+NAME                                       UPDATE-RUN                   STAGE     APPROVED   AGE
+example-cluster-staged-run-after-prod      example-cluster-staged-run   prod      True       2m9s
+```
+
+```bash
+# Check metric collector reports
+kubectl get metriccollectorreport -A
+```
+
+```bash
+NAMESPACE                     NAME                                    WORKLOADS   LAST-COLLECTION   AGE
+fleet-member-kind-cluster-1   mc-example-cluster-staged-run-staging   1           27s               2m57s
+```
+
+Eventually all the approval requests are approved for the updateRun.
+
+The approval controller will automatically approve stages when the metric collectors report that workloads are healthy.
+1. Builds the `metric-collector:latest` image
+2. Builds the `metric-app:local` image
+3. Loads both images into each kind cluster
+4. Creates hub token secret with proper RBAC
+5. Installs the metric-collector via Helm
+
+The `metric-app:local` image is pre-loaded so it's available when you propagate the sample-metric-app deployment from hub to member clusters.
+
 ## Verification
 
 ### Check Controller Status
 
 On the hub cluster:
 ```bash
+kubectl config use-context kind-hub
 kubectl get pods -n fleet-system
-kubectl logs -n fleet-system deployment/approval-request-controller
+kubectl logs -n fleet-system deployment/approval-request-controller -f
 ```
 
 On member clusters:
 ```bash
-kubectl get pods -n fleet-system
-kubectl logs -n fleet-system deployment/metric-collector
+kubectl config use-context kind-cluster-1
+kubectl get pods -n default
+kubectl logs -n default deployment/metric-collector -f
 ```
 
 ### Check Metrics Collection
 
+Verify that MetricCollector resources exist on member clusters:
+```bash
+kubectl config use-context kind-cluster-1
+kubectl get metriccollector -A
+```
+
 Verify that MetricCollectorReports are being created on the hub:
 ```bash
-kubectl get metriccollectorreports -A
+kubectl config use-context kind-hub
+kubectl get metriccollectorreport -A
 ```
 
-### Test Staged Rollout
+### Monitor Staged Update Progress
 
-Create a staged rollout with approval requirements and watch the controller automatically approve based on workload health metrics.
+Watch the approval process:
+```bash
+# Watch staged update run status
+kubectl get csur -A -w
+
+# Check cluster approval requests
+kubectl get clusterapprovalrequest -A
+
+# View approval request details
+kubectl describe clusterapprovalrequest <approval-request-name>
+```
 
 ## How It Works