# Dapr Ops Dashboard Quickstart

Get up and running with Dapr Ops Dashboard in under 10 minutes. This guide walks you through creating a cluster connection, installing the Dapr Ops Dashboard agent, and deploying your first Dapr application.

[Dapr Ops Dashboard Quickstart](https://www.youtube.com/watch?v=qKBFxWutdK4)

---

## What you'll need

:::tip Prerequisites
See the complete [Prerequisites](https://docs.diagrid.io/dapr-open-source/dapr-ops-dashboard/getting-started/prerequisites) list for detailed requirements based on cluster type.
:::

**Quick checklist:**

- **Kubernetes cluster** (1.21+) with kubectl access
- **Dapr Ops Dashboard account** - [Sign up free](https://diagrid.ws/conductor-trial)
- **Internet access** - Outbound access to [these addresses](https://docs.diagrid.io/dapr-open-source/dapr-ops-dashboard/getting-started/prerequisites#network-requirements)
- **Optional**: Docker (for local cluster), Dapr (can be installed by Dapr Ops Dashboard)

---

## Getting Started

**1. Create a Local Cluster**

Skip this if you already have a Kubernetes cluster.

**Kind**

**Install Kind:**

```bash
brew install kind  # macOS
# or download from https://kind.sigs.k8s.io/docs/user/quick-start
```

**Create cluster:**

After installation, create a Kubernetes cluster including a control plane and two worker nodes, with exposed container ports to the host machine:

```bash
kind create cluster --name conductor-quickstart --config=
<(echo "
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
kubeadmConfigPatches:
- |
kind: InitConfiguration
nodeRegistration:
kubeletExtraArgs:
node-labels: "ingress-ready=true"
extraPortMappings:
- containerPort: 80
hostPort: 8081
protocol: TCP
- containerPort: 443
hostPort: 8443
protocol: TCP
- role: worker
- role: worker
")
```

**Verify cluster:**

```bash
kind get clusters
```

**Minikube**

**Install Minikube:**

```bash
brew install minikube  # macOS
# or see https://minikube.sigs.k8s.io/docs/start/
```

**Start cluster:**

```bash
minikube start
```

**Verify cluster:**

```bash
minikube status
```

**2. Create Cluster Connection**

1. **Log in** to the [Dapr Ops Dashboard console](https://diagrid.ws/conductor).

2. **Create Connection:**

   - Click **"Connect Cluster"** or **"Create Cluster Connection"**
   - Name your cluster (e.g., `my-dev-cluster`)
   - Select your Kubernetes distribution

3. **Configure Options:**

**Local/Dev**

- ✅ Install prerequisites (metrics server)
- ✅ Install Dapr (latest version)
- Cluster type: **Local (Minikube, Kind, Docker Desktop)**

**Managed (EKS/AKS/GKE)**

- ⬜ Install prerequisites (usually already installed)
- ✅ Install Dapr (or install separately)
- Cluster type: Select your provider
- Network: Ensure outbound port 443 is open

**On-Prem/Enterprise**

- ✅ Install prerequisites (if needed)
- ✅ Install Dapr
- Cluster type: **Other**
- See [Helm installation](https://docs.diagrid.io/dapr-open-source/dapr-ops-dashboard/helm-installation) for advanced options

4. **Click "Create"** - Dapr Ops Dashboard generates your installation command and Kubernetes manifests.

![create-cluster-connection](https://docs.diagrid.io/img/conductor/create-cluster-connection.png)

**3. Install the Dapr Ops Dashboard agent**

Copy the generated command from the console and run it:

![dapr](https://docs.diagrid.io/img/conductor/connect-cluster-command.png)

```bash
kubectl apply -f "https://api.r1.diagrid.io/v1/...YOUR_TOKEN..."
```

**What gets installed:**

- `diagrid-agent` (Deployment) - Manages Dapr control plane
- `diagrid-agent-logs-collector` (DaemonSet) - Collects sidecar logs
- `diagrid-agent-otel` (StatefulSet) - Collects Dapr metrics

**Verify installation:**

```bash
# Check agent status
kubectl get pods -n diagrid-cloud

# Expected output:
# NAME                                     READY   STATUS    RESTARTS   AGE
# diagrid-agent-xxxxx                      1/1     Running   0          30s
# diagrid-agent-logs-collector-xxxxx       1/1     Running   0          30s
# diagrid-agent-otel-0                     1/1     Running   0          30s
```

**In Dapr Ops Dashboard console:**

- Agent status changes from `Offline` → `Online` (takes a few seconds)
- Dapr control plane shows `Healthy`

:::tip Troubleshooting
If agent stays offline > 2 minutes, check:

- Agent logs: `kubectl logs -n diagrid-cloud -l app=diagrid-agent`
- Cluster has outbound HTTPS access to all the addresses [here](https://docs.diagrid.io/dapr-open-source/dapr-ops-dashboard/getting-started/prerequisites#network-requirements).
- The Kubernetes metrics server is installed.
  :::

**4. Run a Sample Dapr Application**

Deploy a sample application from the [conductor-quickstart](https://github.com/diagrid-labs/conductor-quickstart) repository. This includes a Python app that generates messages and a Node app that saves them to Redis.

### Install Dapr and Redis

**Helm (if Dapr installed via Dapr Ops Dashboard)**

```bash
helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update
helm install redis bitnami/redis --set cluster.enabled=false --set replica.replicaCount=0 --set fullnameOverride=dapr-dev-redis
```

**Dapr CLI (if Dapr not installed)**

```bash
dapr init -k --dev
```

Installs Dapr, Redis, and Zipkin.

### Deploy the sample application

**From remote**

```bash
kubectl apply -f https://raw.githubusercontent.com/diagrid-labs/conductor-quickstart/main/deploy.yaml
```

**From local**

```bash
git clone git@github.com:diagrid-labs/conductor-quickstart.git
cd conductor-quickstart
kubectl apply -f deploy.yaml
```

### Monitor in Dapr Ops Dashboard console

Navigate to **Applications** tab to view:

- `pythonapp` and `nodeapp` deployments
- Component initialization status
- Apps Graph for network topology

**5. Troubleshoot a failure**

To simulate an infrastructure failure, scale down the Redis instances to zero.

```bash
kubectl scale statefulset dapr-dev-redis-master --replicas=0
```

In Dapr Ops Dashboard, observe the failure through various indicators:

- The Component List will display the `statestore` component's `Initialization Status` as `Error` after scaling down.
- The `nodeapp` application's component metrics graphs will show an increase in error rates.
- The resiliency policy will activate and the retry rates will start increasing.
- After a few minutes, there will be issues detected based on `App Component Error Rate` and `HTTP Error Rate` metrics.
- The `Apps Graph` will highlight the erroneous component and its impact on the dependent applications.

![dapr](https://docs.diagrid.io/img/conductor/app-graphg-error.png)

To restore the application, scale the Redis instance back up to one.

```bash
kubectl scale statefulset dapr-dev-redis-master --replicas=1
```

---

## FAQ

**Can I use Dapr Ops Dashboard with my existing Dapr installation?**

Yes! Dapr Ops Dashboard can connect to clusters with Dapr already installed. Just uncheck "Install Dapr" during cluster connection setup. Dapr Ops Dashboard will monitor and manage the existing Dapr installation.

**What data does Dapr Ops Dashboard collect?**

Dapr Ops Dashboard collects:
• Dapr control plane and sidecar metrics
• Application logs from Dapr sidecars (not your app logs)
• Cluster configuration and health data
• No application data or business logic

 See  [Security](https://docs.diagrid.io/dapr-open-source/security-guide#data-collection-and-storage)  for details.

**Does Dapr Ops Dashboard work with multi-cluster setups?**

Yes! Connect multiple clusters to a single Dapr Ops Dashboard organization. Each cluster gets its own agent and appears in the dashboard. Enterprise plans support unlimited clusters.

**Can I disconnect/remove Dapr Ops Dashboard?**

Yes, simply delete the Dapr Ops Dashboard resources by deleting the cluster in the console and running the custom `kubectl delete` command before the deletion in the console is complete. Your Dapr installation and applications remain unaffected.