Merge branch 'master' into postmark

daprdocs/assets/scss/_sidebar-tree.scss

@@ -93,9 +93,9 @@
     @include media-breakpoint-up(md) {
         padding-top: 4rem;
         background-color: $td-sidebar-bg-color;
-        padding-right: 1rem;
+        padding-right: .5rem;
+        padding-left: .5rem;
         border-right: 1px solid $td-sidebar-border-color;
-        min-width: 18rem;
     }
 
 

daprdocs/config.toml

@@ -61,12 +61,15 @@ github_subdir = "daprdocs"
 github_branch = "website"
 
 # Versioning
-version_menu = "Releases"
+version_menu = "v0.11 (latest)"
 version = "v0.11"
 archived_version = false
 
 [[params.versions]]
-  version = "v0.11"
+  version = "v1.0-rc.1 (preview)"
+  url = "https://v1-rc1.docs.dapr.io"
+[[params.versions]]
+  version = "v0.11 (latest)"
   url = "#"
 [[params.versions]]
   version = "v0.10"

daprdocs/content/en/_index.md

@@ -4,4 +4,4 @@ type: docs
 
 # <img src="/images/home-title.png" alt="Dapr Docs" width=400>
 
-Welcome to the Dapr documentation site!
+Welcome to the Dapr documentation site!

daprdocs/content/en/concepts/overview.md

@@ -118,4 +118,4 @@ The `dapr-sentry` service is a certificate authority that enables mutual TLS bet
 
 <img src="/images/overview_kubernetes.png" width=800>
 
-Deploying and running a Dapr enabled application into your Kubernetes cluster is a simple as adding a few annotations to the deployment schemes. You can see some examples [here](https://github.com/dapr/quickstarts/tree/master/hello-kubernetes/deploy) in the Kubernetes getting started sample. Try this out with the [Kubernetes quickstart](https://github.com/dapr/quickstarts/tree/master/hello-kubernetes).
+Deploying and running a Dapr enabled application into your Kubernetes cluster is as simple as adding a few annotations to the deployment schemes. You can see some examples [here](https://github.com/dapr/quickstarts/tree/master/hello-kubernetes/deploy) in the Kubernetes getting started sample. Try this out with the [Kubernetes quickstart](https://github.com/dapr/quickstarts/tree/master/hello-kubernetes).

daprdocs/content/en/developing-applications/building-blocks/pubsub/howto-publish-subscribe.md

@@ -144,7 +144,7 @@ def ds_subscriber():
 
 app.run()
 ```
-After creating `app1.py` ensute flask and flask_cors are installed:
+After creating `app1.py` ensure flask and flask_cors are installed:
 
 ```bash
 pip install flask
@@ -221,7 +221,7 @@ def ds_subscriber():
     return json.dumps({'success':True}), 200, {'ContentType':'application/json'} 
 app.run()
 ```
-After creating `app1.py` ensute flask and flask_cors are installed:
+After creating `app1.py` ensure flask and flask_cors are installed:
 
 ```bash
 pip install flask
@@ -340,4 +340,4 @@ app.post('/dsstatus', (req, res) => {
 ## Next steps
 - [Scope access to your pub/sub topics]({{< ref pubsub-scopes.md >}})
 - [Pub/Sub quickstart](https://github.com/dapr/quickstarts/tree/master/pub-sub)
-- [Pub/sub components]({{< ref setup-pubsub >}})
+- [Pub/sub components]({{< ref setup-pubsub >}})

daprdocs/content/en/developing-applications/building-blocks/secrets/secrets-overview.md

@@ -15,9 +15,9 @@ Here's how it works:
 - Dapr is set up to use a **secret store** - a place to securely store secret data
 - Application code uses the standard Dapr secrets API to retrieve secrets.
 
-Some examples for secret stores include `Kubernetes`, `Hashicorp Vault`, `Azure KeyVault`. See [secret stores](https://github.com/dapr/components-contrib/tree/master/secretstores) for the list of supported stores.
+Some examples for secret stores include `Kubernetes`, `Hashicorp Vault`, `Azure KeyVault`. See [secret stores]({{< ref  supported-secret-stores >}}) for the list of supported stores.
 
-See [Setup secret stores](https://github.com/dapr/docs/tree/master/howto/setup-secret-store) for a HowTo guide for setting up and using secret stores.
+See [Setup secret stores]({{< ref howto-secrets.md >}}) for a HowTo guide for setting up and using secret stores.
 
 ## Referencing secret stores in Dapr components
 
@@ -45,10 +45,10 @@ In Azure Dapr can be configured to use Managed Identities to authenticate with A
 
 Notice that in all of the examples above the application code did not have to change to get the same secret. Dapr did all the heavy lifting here via the secrets building block API and using the secret components.
 
-See [Access Application Secrets using the Secrets API](https://github.com/dapr/docs/tree/master/howto/get-secrets) for a How To guide to use secrets in your application.
+See [Access Application Secrets using the Secrets API]({{< ref howto-secrets.md >}}) for a How To guide to use secrets in your application.
 
 
-For detailed API information read [Secrets API](https://github.com/dapr/docs/blob/master/reference/api/secrets_api.md).
+For detailed API information read [Secrets API]({{< ref secrets_api.md >}}).
 
 
 

daprdocs/content/en/developing-applications/ides/intellij.md

@@ -2,7 +2,7 @@
 type: docs
 title: "IntelliJ"
 linkTitle: "IntelliJ"
-weight: 1000
+weight: 2000
 description: "Configuring IntelliJ community edition for debugging with Dapr"
 ---
 

daprdocs/content/en/developing-applications/ides/vscode-remotecontainers.md

@@ -1,24 +0,0 @@
----
-type: docs
-title: "VS Code remote containers"
-linkTitle: "VS Code remote containers"
-weight: 3000
-description: "Application development and debugging with Visual Studio Code remote containers"
----
-
-## Using remote containers for your application development
-
-The Visual Studio Code Remote - Containers extension lets you use a Docker container as a full-featured development environment enabling you to [develop inside a container](https://code.visualstudio.com/docs/remote/containers).
-
-Dapr has pre-built Docker remote containers for each of the language SDKs. You can pick the one of your choice for a ready made environment. Note these pre-built containers automatically update to the latest Dapr release. 
-
-Watch this [video](https://www.youtube.com/watch?v=D2dO4aGpHcg&t=120) on how to use the Dapr VS Code Remote Containers with your application.
-
-These are the steps to use Dapr Remote Containers 
-1. Open your application workspace in VS Code
-2. In the command command palette select the  `Remote-Containers: Add Development Container Configuration Files...` command
-3. Type `dapr` to filter the list to available Dapr remote containers and choose the language container that matches your application. See screen shot below.
-4. Follow the prompts to rebuild your application in container. 
-
-<img src="../../../../static/images/vscode_remote_containers.png" width=800>
-

daprdocs/content/en/developing-applications/ides/vscode.md

@@ -1,21 +1,64 @@
 ---
 type: docs
-title: "VS Code"
-linkTitle: "VS Code"
-weight: 2000
-description:  "Application development and debugging with Visual Studio Code"
+title: "Visual Studio Code integrations with Dapr"
+linkTitle: "Visual Studio Code"
+weight: 1000
+description:  "Information on how to develop and run Dapr applications in VS Code"
 ---
 
-## Visual Studio Code Dapr extension
-It is recommended to use the *preview* of the [Dapr Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-dapr) available in the Visual Studio marketplace for local development and debugging of your Dapr applications.
+## Extension
 
-Watch this [video](https://www.youtube.com/watch?v=OtbYCBt9C34&t=85) on how to use the Dapr VS Code extension.
+Dapr offers a *preview* [Dapr Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-dapr) for local development and debugging of your Dapr applications.
+
+<a href="vscode:extension/ms-azuretools.vscode-dapr" class="btn btn-primary" role="button">Open in VSCode</a>
+
+### Feature overview
+- Scaffold Dapr task, launch, and component assets
+    <br /><img src="/images/vscode-extension-scaffold.png" alt="Screenshot of the Dapr VSCode extension scaffold option" width="800">
+- View running Dapr applications
+    <br /><img src="/images/vscode-extension-view.png" alt="Screenshot of the Dapr VSCode extension view running applications option" width="800">
+- Invoke Dapr application methods
+    <br /><img src="/images/vscode-extension-invoke.png" alt="Screenshot of the Dapr VSCode extension invoke option" width="800">
+- Publish events to Dapr applications
+    <br /><img src="/images/vscode-extension-publish.png" alt="Screenshot of the Dapr VSCode extension publish option" width="800">
+
+#### Example
+Watch this [video](https://www.youtube.com/watch?v=OtbYCBt9C34&t=85) on how to use the Dapr VS Code extension:
+<iframe width="560" height="315" src="https://www.youtube.com/embed/OtbYCBt9C34?start=85" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+
+## Remote Dev Containers
+
+The Visual Studio Code Remote Containers extension lets you use a Docker container as a full-featured development environment enabling you to [develop inside a container](https://code.visualstudio.com/docs/remote/containers) without installing any additional frameworks or packages to your local filesystem.
+
+Dapr has pre-built Docker remote containers for each of the language SDKs. You can pick the one of your choice for a ready made environment. Note these pre-built containers automatically update to the latest Dapr release.
+
+### Setup a remote dev container
+
+#### Prerequisites
+- [Docker Desktop](https://www.docker.com/products/docker-desktop)
+- [Visual Studio Code](https://code.visualstudio.com/)
+- [VSCode Remote Development extension pack](https://aka.ms/vscode-remote/download/extension)
+
+#### Create remote Dapr container
+1. Open your application workspace in VS Code
+2. In the command command palette (ctrl+shift+p) type and select `Remote-Containers: Add Development Container Configuration Files...`
+    <br /><img src="/images/vscode-remotecontainers-addcontainer.png" alt="Screenshot of adding a remote container" width="700">
+3. Type `dapr` to filter the list to available Dapr remote containers and choose the language container that matches your application. Note you may need to select `Show All Definitions...`
+    <br /><img src="/images/vscode-remotecontainers-daprcontainers.png" alt="Screenshot of adding a Dapr container" width="700">
+4. Follow the prompts to rebuild your application in container. 
+    <br /><img src="/images/vscode-remotecontainers-reopen.png" alt="Screenshot of reopening an application in the dev container" width="700">
+
+#### Example
+Watch this [video](https://www.youtube.com/watch?v=D2dO4aGpHcg&t=120) on how to use the Dapr VS Code Remote Containers with your application.
+<iframe width="560" height="315" src="https://www.youtube.com/embed/D2dO4aGpHcg?start=120" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+
+## Troubleshooting
 
 ### Debugging multiple Dapr applications at the same time
 Using the VS Code extension you can debug multiple Dapr applications at the same time with [Multi-target debugging](https://code.visualstudio.com/docs/editor/debugging#_multitarget-debugging)
 
 
-## Manually configuring Visual Studio Code for debugging with daprd
+### Manually configuring Visual Studio Code for debugging with daprd
 If instead of using the Dapr VS Code extension you wish to configure a project to use Dapr in the [tasks.json](https://code.visualstudio.com/Docs/editor/tasks) and [launch.json](https://code.visualstudio.com/Docs/editor/debugging) files these are the manual steps.
 
 When developing Dapr applications, you typically use the dapr cli to start your daprized service similar to this:
@@ -26,7 +69,9 @@ dapr run --app-id nodeapp --app-port 3000 --dapr-http-port 3500 app.js
 
 This will generate the components yaml files (if they don't exist) so that your service can interact with the local redis container. This is great when you are just getting started but what if you want to attach a debugger to your service and step through the code? This is where you can use the dapr runtime (daprd) to help facilitate this.
 
->Note: The dapr runtime (daprd) will not automatically generate the components yaml files for Redis. These will need to be created manually or you will need to run the dapr cli (dapr) once in order to have them created automatically.
+{{% alert title="Note" color="primary" %}}
+The dapr runtime (daprd) will not automatically generate the components yaml files for Redis. These will need to be created manually or you will need to run the dapr cli (dapr) once in order to have them created automatically.
+{{% /alert %}}
 
 One approach to attaching the debugger to your service is to first run daprd with the correct arguments from the command line and then launch your code and attach the debugger. While this is a perfectly acceptable solution, it does require a few extra steps and some instruction to developers who might want to clone your repo and hit the "play" button to begin debugging.
 
@@ -34,7 +79,7 @@ Using the [tasks.json](https://code.visualstudio.com/Docs/editor/tasks) and [lau
 
 Let's get started!
 
-### Modifying launch.json configurations to include a preLaunchTask
+#### Modifying launch.json configurations to include a preLaunchTask
 
 In your [launch.json](https://code.visualstudio.com/Docs/editor/debugging) file add a [preLaunchTask](https://code.visualstudio.com/Docs/editor/debugging#_launchjson-attributes) for each configuration that you want daprd launched. The [preLaunchTask](https://code.visualstudio.com/Docs/editor/debugging#_launchjson-attributes) will reference tasks that you define in your tasks.json file. Here is an example for both Node and .NET Core. Notice the [preLaunchTasks](https://code.visualstudio.com/Docs/editor/debugging#_launchjson-attributes) referenced: daprd-web and daprd-leaderboard.
 
@@ -76,7 +121,7 @@ In your [launch.json](https://code.visualstudio.com/Docs/editor/debugging) file
 }
 ```
 
-## Adding daprd tasks to tasks.json
+#### Adding daprd tasks to tasks.json
 
 You will need to define a task and problem matcher for daprd in your [tasks.json](https://code.visualstudio.com/Docs/editor/tasks) file. Here are two examples (both referenced via the [preLaunchTask](https://code.visualstudio.com/Docs/editor/debugging#_launchjson-attributes) members above). Notice that in the case of the .NET Core daprd task (daprd-leaderboard) there is also a [dependsOn](https://code.visualstudio.com/Docs/editor/tasks#_compound-tasks) member that references the build task to ensure the latest code is being run/debugged. The [problemMatcher](https://code.visualstudio.com/Docs/editor/tasks#_defining-a-problem-matcher) is used so that VSCode can understand when the daprd process is up and running.
 
@@ -173,9 +218,10 @@ Let's take a quick look at the args that are being passed to the daprd command.
 }
 ```
 
-### Wrapping up
+#### Wrapping up
 
 Once you have made the required changes, you should be able to switch to the [debug](https://code.visualstudio.com/Docs/editor/debugging) view in VSCode and launch your daprized configurations by clicking the "play" button. If everything was configured correctly, you should see daprd launch in the VSCode terminal window and the [debugger](https://code.visualstudio.com/Docs/editor/debugging) should attach to your application (you should see it's output in the debug window).
 
->Note: Since you didn't launch the service(s) using the **dapr** ***run*** cli command, but instead by running **daprd**, the **dapr** ***list*** command will not show a list of apps that are currently running.
-
+{{% alert title="Note" color="primary" %}}
+Since you didn't launch the service(s) using the **dapr** ***run*** cli command, but instead by running **daprd**, the **dapr** ***list*** command will not show a list of apps that are currently running.
+{{% /alert %}}

daprdocs/content/en/getting-started/configure-redis.md

@@ -1,8 +1,8 @@
 ---
 type: docs
-title: "How-To: Setup Redis"
-linkTitle: "How-To: Setup Redis"
-weight: 30
+title: "How-To: Setup a customized Redis store"
+linkTitle: "(optional) Configure Redis"
+weight: 40
 description: "Configure Redis for Dapr state management or Pub/Sub"
 ---
 

daprdocs/content/en/getting-started/install-dapr-cli.md

@@ -0,0 +1,62 @@
+---
+type: docs
+title: "How-To: Install Dapr CLI"
+linkTitle: "Install Dapr CLI"
+weight: 10
+description: "Install the Dapr CLI to get started with Dapr"
+---
+
+## Dapr CLI installation scripts
+
+Begin by downloading and installing the Dapr CLI for v1.0.0-rc.2. This will be used to initialize your environment on your desired platform.
+
+{{% alert title="Note" color="warning" %}}
+This command will download and install Dapr v0.11. To install v1.0-rc.1, the release candidate for the [upcoming v1.0 release](https://blog.dapr.io/posts/2020/10/20/the-path-to-v.1.0-production-ready-dapr/), please visit the [v1.0-rc.1 docs](https://v1-rc1.docs.dapr.io/getting-started/install-dapr-cli).
+{{% /alert %}}
+
+{{< tabs Linux Windows MacOS Binaries>}}
+
+{{% codetab %}}
+This command will install the latest linux Dapr CLI to `/usr/local/bin`:
+```bash
+wget -q https://raw.githubusercontent.com/dapr/cli/master/install/install.sh -O - | /bin/bash
+```
+{{% /codetab %}}
+
+{{% codetab %}}
+This command will install the latest windows Dapr cli to `%USERPROFILE%\.dapr\` and add this directory to User PATH environment variable:
+```powershell
+powershell -Command "iwr -useb https://raw.githubusercontent.com/dapr/cli/master/install/install.ps1 | iex"
+```
+Verify by opening Explorer and entering `%USERPROFILE%\.dapr\` into the address bar. You should see folders for bin, componenets and a config file.
+{{% /codetab %}}
+
+{{% codetab %}}
+This command will install the latest darwin Dapr CLI to `/usr/local/bin`:
+```bash
+curl -fsSL https://raw.githubusercontent.com/dapr/cli/master/install/install.sh | /bin/bash
+```
+
+Or you can install via [Homebrew](https://brew.sh):
+```bash
+brew install dapr/tap/dapr-cli
+```
+{{% /codetab %}}
+
+{{% codetab %}}
+Each release of Dapr CLI includes various OSes and architectures. These binary versions can be manually downloaded and installed.
+
+1. Download the desired Dapr CLI from the latest [Dapr Release](https://github.com/dapr/cli/releases)
+2. Unpack it (e.g. dapr_linux_amd64.tar.gz, dapr_windows_amd64.zip)
+3. Move it to your desired location.
+   - For Linux/MacOS - `/usr/local/bin`
+   - For Windows, create a directory and add this to your System PATH. For example create a directory called `c:\dapr` and add this directory to your path, by editing your system environment variable.
+{{% /codetab %}}
+{{< /tabs >}}
+
+Learn more about the CLI and available commands in the [CLI docs]( {{< ref cli >}}).
+
+## Next steps
+- [Init Dapr locally]({{< ref install-dapr.md >}})
+- [Init Dapr on Kubernetes]({{< ref install-dapr-kubernetes.md >}})
+- [Try a Dapr Quickstart]({{< ref quickstarts.md >}})

daprdocs/content/en/getting-started/install-dapr-kubernetes.md

@@ -0,0 +1,140 @@
+---
+type: docs
+title: "How-To: Install Dapr into a Kubernetes cluster"
+linkTitle: "Init Dapr on Kubernetes"
+weight: 30
+description: "Install Dapr in a Kubernetes cluster"
+---
+
+When setting up Kubernetes you can use either the Dapr CLI or Helm.
+
+The following pods will be installed:
+
+- dapr-operator: Manages component updates and Kubernetes services endpoints for Dapr (state stores, pub/subs, etc.)
+- dapr-sidecar-injector: Injects Dapr into annotated deployment pods
+- dapr-placement: Used for actors only. Creates mapping tables that map actor instances to pods
+- dapr-sentry: Manages mTLS between services and acts as a certificate authority
+
+## Setup cluster
+
+You can install Dapr on any Kubernetes cluster. Here are some helpful links:
+
+- [Setup Minikube Cluster]({{< ref setup-minikube.md >}})
+- [Setup Azure Kubernetes Service Cluster]({{< ref setup-aks.md >}})
+- [Setup Google Cloud Kubernetes Engine](https://cloud.google.com/kubernetes-engine/docs/quickstart)
+- [Setup Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html)
+
+{{% alert title="Note" color="primary" %}}
+Both the Dapr CLI and the Dapr Helm chart automatically deploy with affinity for nodes with the label `kubernetes.io/os=linux`. You can deploy Dapr to Windows nodes, but most users should not need to. For more information see [Deploying to a hybrid Linux/Windows Kubernetes cluster]({{<ref kubernetes-hybrid-clusters>}}).
+{{% /alert %}}
+
+
+## Install with Dapr CLI
+
+You can install Dapr to a Kubernetes cluster using the [Dapr CLI]({{< ref install-dapr-cli.md >}}).
+
+{{% alert title="Note" color="warning" %}}
+This command will download and install Dapr v0.11. To install v1.0-rc.1, the release candidate for the [upcoming v1.0 release](https://blog.dapr.io/posts/2020/10/20/the-path-to-v.1.0-production-ready-dapr/), please visit the [v1.0-rc.1 docs](https://v1-rc1.docs.dapr.io/getting-started/install-dapr-kubernetes).
+{{% /alert %}}
+
+### Install Dapr
+
+The `-k` flag will initialize Dapr on the Kuberentes cluster in your current context.
+
+```bash
+$ dapr init -k
+
+⌛  Making the jump to hyperspace...
+ℹ️  Note: To install Dapr using Helm, see here:  https://github.com/dapr/docs/blob/master/getting-started/environment-setup.md#using-helm-advanced
+
+✅  Deploying the Dapr control plane to your cluster...
+✅  Success! Dapr has been installed to namespace dapr-system. To verify, run "dapr status -k" in your terminal. To get started, go here: https://aka.ms/dapr-getting-started
+```
+
+### Install to a custom namespace:
+
+The default namespace when initializeing Dapr is `dapr-system`. You can override this with the `-n` flag.
+
+```
+dapr init -k -n mynamespace
+```
+
+### Install in highly available mode:
+
+You can run Dapr with 3 replicas of each control plane pod with the exception of the Placement pod in the dapr-system namespace for [production scenarios]({{< ref kubernetes-production.md >}}).
+
+```
+dapr init -k --enable-ha=true
+```
+
+### Disable mTLS:
+
+Dapr is initialized by default with [mTLS]({{< ref "security-concept.md#sidecar-to-sidecar-communication" >}}). You can disable it with:
+
+```
+dapr init -k --enable-mtls=false
+```
+
+### Uninstall Dapr on Kubernetes
+
+```bash
+$ dapr uninstall --kubernetes
+```
+
+## Install with Helm (advanced)
+
+You can install Dapr to Kubernetes cluster using a Helm 3 chart.
+
+
+{{% alert title="Note" color="primary" %}}
+The latest Dapr helm chart no longer supports Helm v2. Please migrate from helm v2 to helm v3 by following [this guide](https://helm.sh/blog/migrate-from-helm-v2-to-helm-v3/).
+{{% /alert %}}
+
+### Install Dapr on Kubernetes
+
+1. Make sure Helm 3 is installed on your machine
+2. Add Helm repo
+
+    ```bash
+    helm repo add dapr https://dapr.github.io/helm-charts/
+    helm repo update
+    ```
+
+3. Create `dapr-system` namespace on your kubernetes cluster
+
+    ```bash
+    kubectl create namespace dapr-system
+    ```
+
+4. Install the Dapr chart on your cluster in the `dapr-system` namespace.
+
+    ```bash
+    helm install dapr dapr/dapr --namespace dapr-system
+    ```
+
+### Verify installation
+
+Once the chart installation is complete, verify the dapr-operator, dapr-placement, dapr-sidecar-injector and dapr-sentry pods are running in the `dapr-system` namespace:
+
+```bash
+$ kubectl get pods -n dapr-system -w
+
+NAME                                     READY     STATUS    RESTARTS   AGE
+dapr-dashboard-7bd6cbf5bf-xglsr          1/1       Running   0          40s
+dapr-operator-7bd6cbf5bf-xglsr           1/1       Running   0          40s
+dapr-placement-7f8f76778f-6vhl2          1/1       Running   0          40s
+dapr-sidecar-injector-8555576b6f-29cqm   1/1       Running   0          40s
+dapr-sentry-9435776c7f-8f7yd             1/1       Running   0          40s
+```
+
+### Uninstall Dapr on Kubernetes
+
+```bash
+helm uninstall dapr -n dapr-system
+```
+
+> **Note:** See [this page](https://github.com/dapr/dapr/blob/master/charts/dapr/README.md) for details on Dapr helm charts.
+
+## Sidecar annotations
+
+To see all the supported annotations for the Dapr sidecar on Kubernetes, visit [this]({{<ref "kubernetes-annotations.md">}}) how to guide.

daprdocs/content/en/getting-started/install-dapr.md

@@ -1,63 +1,14 @@
 ---
 type: docs
-title: "How-To: Install Dapr into your environment"
-linkTitle: "How-To: Install Dapr"
+title: "How-To: Install Dapr into your local environment"
+linkTitle: "Init Dapr locally"
 weight: 20
-description: "Install Dapr in your preferred environment"
+description: "Install Dapr in your local environment for testing and self-hosting"
 ---
 
-This guide will get you up and running to evaluate Dapr and develop applications. Visit [this page]({{< ref hosting >}}) for a full list of supported platforms with instructions and best practices on running in production.
-
-## Install the Dapr CLI
-
-Begin by downloading and installing the Dapr CLI. This will be used to initialize your environment on your desired platform.
-
-{{< tabs Linux Windows MacOS Binaries>}}
-
-{{% codetab %}}
-This command will install the latest linux Dapr CLI to `/usr/local/bin`:
-```bash
-wget -q https://raw.githubusercontent.com/dapr/cli/master/install/install.sh -O - | /bin/bash
-```
-{{% /codetab %}}
-
-{{% codetab %}}
-This command will install the latest windows Dapr cli to `%USERPROFILE%\.dapr\` and add this directory to User PATH environment variable:
-```powershell
-powershell -Command "iwr -useb https://raw.githubusercontent.com/dapr/cli/master/install/install.ps1 | iex"
-```
-Verify by opening Explorer and entering `%USERPROFILE%\.dapr\` into the address bar. You should see folders for bin, componenets and a config file.
-{{% /codetab %}}
-
-{{% codetab %}}
-This command will install the latest darwin Dapr CLI to `/usr/local/bin`:
-```bash
-curl -fsSL https://raw.githubusercontent.com/dapr/cli/master/install/install.sh | /bin/bash
-```
-
-Or you can install via [Homebrew](https://brew.sh):
-```bash
-brew install dapr/tap/dapr-cli
-```
-{{% /codetab %}}
-
-{{% codetab %}}
-Each release of Dapr CLI includes various OSes and architectures. These binary versions can be manually downloaded and installed.
-
-1. Download the desired Dapr CLI from the latest [Dapr Release](https://github.com/dapr/cli/releases)
-2. Unpack it (e.g. dapr_linux_amd64.tar.gz, dapr_windows_amd64.zip)
-3. Move it to your desired location.
-   - For Linux/MacOS - `/usr/local/bin`
-   - For Windows, create a directory and add this to your System PATH. For example create a directory called `c:\dapr` and add this directory to your path, by editing your system environment variable.
-{{% /codetab %}}
-{{< /tabs >}}
-
-## Install Dapr in self-hosted mode
-
-Running Dapr runtime in self hosted mode enables you to develop Dapr applications in your local development environment and then deploy and run them in other Dapr supported environments.
-
-### Prerequisites
+## Prerequisites
 
+- Install [Dapr CLI]({{< ref install-dapr-cli.md >}})
 - Install [Docker Desktop](https://docs.docker.com/install/)
    - Windows users ensure that `Docker Desktop For Windows` uses Linux containers.
 
@@ -94,12 +45,12 @@ This step will install the latest Dapr Docker containers and setup a developer e
 
 4. Visit our [hello world quickstart](https://github.com/dapr/quickstarts/tree/master/hello-world) or dive into the [Dapr building blocks]({{< ref building-blocks >}})
 
-### (optional) Install a specific runtime version
+## (optional) Install a specific runtime version
 
 You can install or upgrade to a specific version of the Dapr runtime using `dapr init --runtime-version`. You can find the list of versions in [Dapr Release](https://github.com/dapr/dapr/releases).
 
 ```bash
-# Install v0.1.0 runtime
+# Install v0.11.0 runtime
 $ dapr init --runtime-version 0.11.0
 
 # Check the versions of cli and runtime
@@ -108,7 +59,7 @@ cli version: v0.11.0
 runtime version: v0.11.2
 ```
 
-### Uninstall Dapr in self-hosted mode
+## Uninstall Dapr in self-hosted mode
 
 This command will remove the placement Dapr container:
 
@@ -126,137 +77,6 @@ $ dapr uninstall --all
 
 > For Linux/MacOS users, if you run your docker cmds with sudo or the install path is `/usr/local/bin`(default install path), you need to use `sudo dapr uninstall` to remove dapr binaries and/or the containers.
 
-## Install Dapr on a Kubernetes cluster
-
-When setting up Kubernetes you can use either the Dapr CLI or Helm.
-
-The following pods will be installed:
-
-- dapr-operator: Manages component updates and Kubernetes services endpoints for Dapr (state stores, pub/subs, etc.)
-- dapr-sidecar-injector: Injects Dapr into annotated deployment pods
-- dapr-placement: Used for actors only. Creates mapping tables that map actor instances to pods
-- dapr-sentry: Manages mTLS between services and acts as a certificate authority
-
-### Setup cluster
-
-You can install Dapr on any Kubernetes cluster. Here are some helpful links:
-
-- [Setup Minikube Cluster]({{< ref setup-minikube.md >}})
-- [Setup Azure Kubernetes Service Cluster]({{< ref setup-aks.md >}})
-- [Setup Google Cloud Kubernetes Engine](https://cloud.google.com/kubernetes-engine/docs/quickstart)
-- [Setup Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html)
-
-{{% alert title="Note" color="primary" %}}
-Both the Dapr CLI and the Dapr Helm chart automatically deploy with affinity for nodes with the label `kubernetes.io/os=linux`. You can deploy Dapr to Windows nodes, but most users should not need to. For more information see [Deploying to a hybrid Linux/Windows Kubernetes cluster]({{<ref kubernetes-hybrid-clusters>}}).
-{{% /alert %}}
-
-
-### Install with Dapr CLI
-
-You can install Dapr to a Kubernetes cluster using the Dapr CLI.
-
-#### Install Dapr
-
-The `-k` flag will initialize Dapr on the kuberentes cluster in your current context.
-
-```bash
-$ dapr init -k
-
-⌛  Making the jump to hyperspace...
-ℹ️  Note: To install Dapr using Helm, see here:  https://github.com/dapr/docs/blob/master/getting-started/environment-setup.md#using-helm-advanced
-
-✅  Deploying the Dapr control plane to your cluster...
-✅  Success! Dapr has been installed to namespace dapr-system. To verify, run "dapr status -k" in your terminal. To get started, go here: https://aka.ms/dapr-getting-started
-```
-
-#### Install to a custom namespace:
-
-The default namespace when initializeing Dapr is `dapr-system`. You can override this with the `-n` flag.
-
-```
-dapr init -k -n mynamespace
-```
-
-#### Install in highly available mode:
-
-You can run Dapr with 3 replicas of each control plane pod with the exception of the Placement pod in the dapr-system namespace for [production scenarios]({{< ref kubernetes-production.md >}}).
-
-```
-dapr init -k --enable-ha=true
-```
-
-#### Disable mTLS:
-
-Dapr is initialized by default with [mTLS]({{< ref "security-concept.md#sidecar-to-sidecar-communication" >}}). You can disable it with:
-
-```
-dapr init -k --enable-mtls=false
-```
-
-#### Uninstall Dapr on Kubernetes
-
-```bash
-$ dapr uninstall --kubernetes
-```
-
-### Install with Helm (advanced)
-
-You can install Dapr to Kubernetes cluster using a Helm 3 chart.
-
-
-{{% alert title="Note" color="primary" %}}
-The latest Dapr helm chart no longer supports Helm v2. Please migrate from helm v2 to helm v3 by following [this guide](https://helm.sh/blog/migrate-from-helm-v2-to-helm-v3/).
-{{% /alert %}}
-
-#### Install Dapr on Kubernetes
-
-1. Make sure Helm 3 is installed on your machine
-2. Add Helm repo
-
-    ```bash
-    helm repo add dapr https://dapr.github.io/helm-charts/
-    helm repo update
-    ```
-
-3. Create `dapr-system` namespace on your kubernetes cluster
-
-    ```bash
-    kubectl create namespace dapr-system
-    ```
-
-4. Install the Dapr chart on your cluster in the `dapr-system` namespace.
-
-    ```bash
-    helm install dapr dapr/dapr --namespace dapr-system
-    ```
-
-#### Verify installation
-
-Once the chart installation is complete, verify the dapr-operator, dapr-placement, dapr-sidecar-injector and dapr-sentry pods are running in the `dapr-system` namespace:
-
-```bash
-$ kubectl get pods -n dapr-system -w
-
-NAME                                     READY     STATUS    RESTARTS   AGE
-dapr-dashboard-7bd6cbf5bf-xglsr          1/1       Running   0          40s
-dapr-operator-7bd6cbf5bf-xglsr           1/1       Running   0          40s
-dapr-placement-7f8f76778f-6vhl2          1/1       Running   0          40s
-dapr-sidecar-injector-8555576b6f-29cqm   1/1       Running   0          40s
-dapr-sentry-9435776c7f-8f7yd             1/1       Running   0          40s
-```
-
-#### Uninstall Dapr on Kubernetes
-
-```bash
-helm uninstall dapr -n dapr-system
-```
-
-> **Note:** See [this page](https://github.com/dapr/dapr/blob/master/charts/dapr/README.md) for details on Dapr helm charts.
-
-### Sidecar annotations
-
-To see all the supported annotations for the Dapr sidecar on Kubernetes, visit [this]({{<ref "kubernetes-annotations.md">}}) how to guide.
-
-### Configure Redis
+## Configure Redis
 
 Unlike Dapr self-hosted, redis is not pre-installed out of the box on Kubernetes. To install Redis as a state store or as a pub/sub message bus in your Kubernetes cluster see [How-To: Setup Redis]({{< ref configure-redis.md >}})

daprdocs/content/en/getting-started/quickstarts.md

@@ -0,0 +1,22 @@
+---
+type: docs
+title: "Try out Dapr quickstarts to learn core concepts"
+linkTitle: "Dapr Quickstarts"
+weight: 50
+description: "Configure Redis for Dapr state management or Pub/Sub"
+---
+
+The [Dapr Quickstarts](https://github.com/dapr/quickstarts) are a collection of tutorials with code samples that are aimed to get you started quickly with Dapr, each highlighting a different Dapr capability.
+
+## Quickstarts
+
+| Quickstart               | Description                                                                                                                                                                                    |
+|--------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [Hello-world](https://github.com/dapr/quickstarts/tree/master/hello-world)            | Demonstrates how to run Dapr locally. Highlights service invocation and state management.                                                                                                      |
+| [Hello-kubernetes](https://github.com/dapr/quickstarts/tree/master/hello-kubernetes)       | Demonstrates how to run Dapr in Kubernetes. Highlights service invocation and state management.                                                                                                |
+| [Distributed-calculator](https://github.com/dapr/quickstarts/tree/master/distributed-calculator) | Demonstrates a distributed calculator application that uses Dapr services to power a React web app. Highlights polyglot (multi-language) programming, service invocation and state management. |
+| [Pub-sub](https://github.com/dapr/quickstarts/tree/master/pub-sub)                | Demonstrates how to use Dapr to enable pub-sub applications. Uses Redis as a pub-sub component.                                                                                          |
+| [Bindings](https://github.com/dapr/quickstarts/tree/master/bindings)            | Demonstrates how to use Dapr to create input and output bindings to other components. Uses bindings to Kafka.                                                                            |
+| [Middleware](https://github.com/dapr/quickstarts/tree/master/middleware) | Demonstrates use of Dapr middleware to enable OAuth 2.0 authorization. |
+| [Observability](https://github.com/dapr/quickstarts/tree/master/observability) | Demonstrates Dapr tracing capabilities. Uses Zipkin as a tracing component. |
+| [Secret Store](https://github.com/dapr/quickstarts/tree/master/secretstore) | Demonstrates the use of Dapr Secrets API to access secret stores. |

daprdocs/content/en/operations/components/setup-bindings/supported-bindings/dynamodb.md

@@ -47,4 +47,4 @@ The above example uses secrets as plain strings. It is recommended to use a secr
 - [How-To: Trigger application with input binding]({{< ref howto-triggers.md >}})
 - [How-To: Use bindings to interface with external resources]({{< ref howto-bindings.md >}})
 - [Bindings API reference]({{< ref bindings_api.md >}})
-- [Authenticating to AWS]({{< ref authenticating-aws.md >}})
+- [Authenticating to AWS]({{< ref authenticating-aws.md >}})

daprdocs/content/en/operations/components/setup-bindings/supported-bindings/kinesis.md

@@ -54,4 +54,4 @@ The above example uses secrets as plain strings. It is recommended to use a secr
 - [How-To: Trigger application with input binding]({{< ref howto-triggers.md >}})
 - [How-To: Use bindings to interface with external resources]({{< ref howto-bindings.md >}})
 - [Bindings API reference]({{< ref bindings_api.md >}})
-- [Authenticating to AWS]({{< ref authenticating-aws.md >}})
+- [Authenticating to AWS]({{< ref authenticating-aws.md >}})

daprdocs/content/en/operations/components/setup-bindings/supported-bindings/s3.md

@@ -45,4 +45,4 @@ The above example uses secrets as plain strings. It is recommended to use a secr
 - [How-To: Trigger application with input binding]({{< ref howto-triggers.md >}})
 - [How-To: Use bindings to interface with external resources]({{< ref howto-bindings.md >}})
 - [Bindings API reference]({{< ref bindings_api.md >}})
-- [Authenticating to AWS]({{< ref authenticating-aws.md >}})
+- [Authenticating to AWS]({{< ref authenticating-aws.md >}})

daprdocs/content/en/operations/components/setup-bindings/supported-bindings/sns.md

@@ -46,4 +46,4 @@ The above example uses secrets as plain strings. It is recommended to use a secr
 - [How-To: Trigger application with input binding]({{< ref howto-triggers.md >}})
 - [How-To: Use bindings to interface with external resources]({{< ref howto-bindings.md >}})
 - [Bindings API reference]({{< ref bindings_api.md >}})
-- [Authenticating to AWS]({{< ref authenticating-aws.md >}})
+- [Authenticating to AWS]({{< ref authenticating-aws.md >}})

daprdocs/content/en/operations/components/setup-bindings/supported-bindings/sqs.md

@@ -47,4 +47,4 @@ The above example uses secrets as plain strings. It is recommended to use a secr
 - [How-To: Trigger application with input binding]({{< ref howto-triggers.md >}})
 - [How-To: Use bindings to interface with external resources]({{< ref howto-bindings.md >}})
 - [Bindings API reference]({{< ref bindings_api.md >}})
-- [Authenticating to AWS]({{< ref authenticating-aws.md >}})
+- [Authenticating to AWS]({{< ref authenticating-aws.md >}})

daprdocs/content/en/operations/components/setup-secret-store/supported-secret-stores/aws-secret-manager.md

@@ -70,4 +70,4 @@ The above example uses secrets as plain strings. It is recommended to use a loca
 - [How-To: Retreive a secret]({{< ref "howto-secrets.md" >}})
 - [How-To: Reference secrets in Dapr components]({{< ref component-secrets.md >}})
 - [Secrets API reference]({{< ref secrets_api.md >}})
-- [Authenticating to AWS]({{< ref authenticating-aws.md >}})
+- [Authenticating to AWS]({{< ref authenticating-aws.md >}})

daprdocs/content/en/operations/components/setup-secret-store/supported-secret-stores/azure-keyvault.md

@@ -173,4 +173,4 @@ kubectl apply -f azurekeyvault.yaml
 - [Secrets building block]({{< ref secrets >}})
 - [How-To: Retreive a secret]({{< ref "howto-secrets.md" >}})
 - [How-To: Reference secrets in Dapr components]({{< ref component-secrets.md >}})
-- [Secrets API reference]({{< ref secrets_api.md >}})
+- [Secrets API reference]({{< ref secrets_api.md >}})

daprdocs/content/en/operations/configuration/configuration-overview.md

@@ -15,7 +15,7 @@ In self hosted mode the Dapr configuration is a configuration file, for example
 
 A Dapr sidecar can also apply a configuration by using a ```--config``` flag to the file path with ```dapr run``` CLI command.
 
-#### Kubernetes sidecar 
+#### Kubernetes sidecar
 In Kubernetes mode the Dapr configuration is a Configuration CRD, that is applied to the cluster. For example;
 
 ```bash
@@ -43,6 +43,7 @@ Note: There are more [Kubernetes annotations]({{< ref "kubernetes-annotations.md
 
 The following configuration settings can be applied to Dapr application sidecars;
 - [Tracing](#tracing)
+- [Metrics](#metrics)
 - [Middleware](#middleware)
 - [Scoping secrets for secret stores](#scoping-secrets-for-secret-stores)
 - [Access control allow lists for service invocation](#access-control-allow-lists-for-service-invocation)
@@ -56,14 +57,17 @@ The `tracing` section under the `Configuration` spec contains the following prop
 
 ```yml
 tracing:
-    samplingRate: "1"
+  samplingRate: "1"
+  zipkin:
+    endpointAddress: "http://zipkin.default.svc.cluster.local:9411/api/v2/spans"
 ```
 
 The following table lists the properties for tracing:
 
 | Property     | Type   | Description |
 |--------------|--------|-------------|
-| samplingRate | string | Set sampling rate for tracing to be enabled or disabled. 
+| `samplingRate` | string | Set sampling rate for tracing to be enabled or disabled.
+| `zipkin.endpointAddress` | string | Set the Zipkin server address.
 
 
 `samplingRate` is used to enable or disable the tracing. To disable the sampling rate ,
@@ -71,9 +75,28 @@ set `samplingRate : "0"` in the configuration. The valid range of samplingRate i
 
 See [Observability distributed tracing]({{< ref "tracing.md" >}}) for more information
 
+#### Metrics
+
+The metrics section can be used to enable or disable metrics for an application.
+
+The `metrics` section under the `Configuration` spec contains the following properties:
+
+```yml
+metrics:
+  enabled: true
+```
+
+The following table lists the properties for metrics:
+
+| Property     | Type   | Description |
+|--------------|--------|-------------|
+| `enabled` | boolean | Whether metrics should to be enabled.
+
+See [metrics documentation]({{< ref "metrics.md" >}}) for more information
+
 #### Middleware
 
-Middleware configuration set named Http pipeline middleware handlers 
+Middleware configuration set named Http pipeline middleware handlers
 The `httpPipeline` section under the `Configuration` spec contains the following properties:
 
 ```yml
@@ -128,14 +151,14 @@ spec:
     trustDomain: "public"
     policies:
     - appId: app1
-      defaultAction: deny 
+      defaultAction: deny
       trustDomain: 'public'
-      namespace: "default" 
+      namespace: "default"
       operations:
-      - name: /op1 
-        httpVerb: ['POST', 'GET'] 
+      - name: /op1
+        httpVerb: ['POST', 'GET']
         action: deny
-      - name: /op2/* 
+      - name: /op2/*
         httpVerb: ["*"]
         action: allow
 ```

daprdocs/content/en/operations/monitoring/grafana.md

@@ -84,9 +84,9 @@ First you need to connect Prometheus as a data source to Grafana.
 
       ![data source](/images/grafana-datasources.png)
 
-5. Add Prometheus as a data soruce.
+5. Add Prometheus as a data source.
 
-      ![add data source](/images/grafana-datasources.png)
+      ![add data source](/images/grafana-add-datasources.png)
 
 6. Enter Promethesus server address in your cluster.
 

daprdocs/content/en/operations/monitoring/newrelic.md

@@ -0,0 +1,117 @@
+---
+type: docs
+title: "How-To: Set-up New Relic for Dapr observability"
+linkTitle: "New Relic"
+weight: 2000
+description: "Set-up New Relic for Dapr observability"
+---
+
+## Prerequisites
+
+- Perpetually [free New Relic account](https://newrelic.com/signup), 100 GB/month of free data ingest, 1 free full access user, unlimited free basic users
+
+## Configure Zipkin Exporter
+
+Dapr natively captures metrics and traces that can be send directly to New Relic. The easiest way to export these is by providing a Zipkin exporter configured to send the traces to [New Relic's Trace API](https://docs.newrelic.com/docs/understand-dependencies/distributed-tracing/trace-api/report-zipkin-format-traces-trace-api#existing-zipkin).
+
+In order for the integration to send data to New Relic [Telemetry Data Platform](https://newrelic.com/platform/telemetry-data-platform), you need a [New Relic Insights Insert API key](https://docs.newrelic.com/docs/apis/get-started/intro-apis/types-new-relic-api-keys#insights-insert-key). 
+
+```yaml
+apiVersion: dapr.io/v1alpha1
+kind: Component
+metadata:
+  name: zipkin
+  namespace: default
+spec:
+  type: exporters.zipkin
+  metadata:
+    - name: enabled
+      value: "true"
+    - name: exporterAddress
+      value: "https://trace-api.newrelic.com/trace/v1?Api-Key=<NR-INSIGHTS-INSERT-API-KEY>&Data-Format=zipkin&Data-Format-Version=2"
+```
+
+### Viewing Traces
+
+New Relic Distributed Tracing overview
+![New Relic Kubernetes Cluster Explorer App](/images/nr-distributed-tracing-overview.png)
+
+New Relic Distributed Tracing details
+![New Relic Kubernetes Cluster Explorer App](/images/nr-distributed-tracing-detail.png)
+
+## (optional) New Relic Instrumentation
+
+In order for the integrations to send data to New Relic Telemetry Data Platform, you either need a [New Relic license key](https://docs.newrelic.com/docs/accounts/accounts-billing/account-setup/new-relic-license-key) or [New Relic Insights Insert API key](https://docs.newrelic.com/docs/apis/get-started/intro-apis/types-new-relic-api-keys#insights-insert-key). 
+
+### OpenTelemetry instrumentation
+
+Leverage the different language specific OpenTelemetry implementations, for example [New Relic Telemetry SDK and OpenTelemetry support for .NET](https://github.com/newrelic/newrelic-telemetry-sdk-dotnet). In this case, use the [OpenTelemetry Trace Exporter](https://github.com/newrelic/newrelic-telemetry-sdk-dotnet/tree/main/src/NewRelic.OpenTelemetry). See example [here](https://github.com/harrykimpel/quickstarts/blob/master/distributed-calculator/csharp-otel/Startup.cs).
+
+### New Relic Language agent
+
+Similarly to the OpenTelemetry instrumentation, you can also leverage a New Relic language agent. As an example, the [New Relic agent instrumentation for .NET Core](https://docs.newrelic.com/docs/agents/net-agent/installation/install-docker-container) is part of the Dockerfile. See example [here](https://github.com/harrykimpel/quickstarts/blob/master/distributed-calculator/csharp/Dockerfile).
+
+## (optional) Enable New Relic Kubernetes integration
+
+In case Dapr and your applications run in the context of a Kubernetes environment, you can enable additional metrics and logs.
+
+The easiest way to install the New Relic Kubernetes integration is to use the [automated installer](https://one.newrelic.com/launcher/nr1-core.settings?pane=eyJuZXJkbGV0SWQiOiJrOHMtY2x1c3Rlci1leHBsb3Jlci1uZXJkbGV0Lms4cy1zZXR1cCJ9) to generate a manifest. It bundles not just the integration DaemonSets, but also other New Relic Kubernetes configurations, like [Kubernetes events](https://docs.newrelic.com/docs/integrations/kubernetes-integration/kubernetes-events/install-kubernetes-events-integration), [Prometheus OpenMetrics](https://docs.newrelic.com/docs/integrations/prometheus-integrations/get-started/new-relic-prometheus-openmetrics-integration-kubernetes), and [New Relic log monitoring](https://docs.newrelic.com/docs/logs).
+
+### New Relic Kubernetes Cluster Explorer
+
+The [New Relic Kubernetes Cluster Explorer](https://docs.newrelic.com/docs/integrations/kubernetes-integration/understand-use-data/kubernetes-cluster-explorer) provides a unique visualization of the entire data and deployments of the data collected by the Kubernetes integration.
+
+It is a good starting point to observe all your data and dig deeper into any performance issues or incidents happening inside of the application or microservices.
+
+![New Relic Kubernetes Cluster Explorer App](/images/nr-k8s-cluster-explorer-app.png)
+
+Automated correlation is part of the visualization capabilities of New Relic.
+
+### Pod-level details
+
+![New Relic K8s Pod Level Details](/images/nr-k8s-pod-level-details.png)
+
+### Logs in Context
+
+![New Relic K8s Logs In Context](/images/nr-k8s-logs-in-context.png)
+
+## New Relic Dashboards
+
+### Kubernetes Overview
+
+![New Relic Dashboard Kubernetes Overview](/images/nr-dashboard-k8s-overview.png)
+
+### Dapr System Services
+
+![New Relic Dashboard Dapr System Services](/images/nr-dashboard-dapr-system-services.png)
+
+### Dapr Metrics
+
+![New Relic Dashboard Dapr Metrics 1](/images/nr-dashboard-dapr-metrics-1.png)
+
+## New Relic Grafana integration
+
+New Relic teamed up with [Grafana Labs](https://grafana.com/) so you can use the [Telemetry Data Platform](https://newrelic.com/platform/telemetry-data-platform) as a data source for Prometheus metrics and see them in your existing dashboards, seamlessly tapping into the reliability, scale, and security provided by New Relic.
+
+[Grafana dashboard templates](https://github.com/dapr/dapr/blob/227028e7b76b7256618cd3236d70c1d4a4392c9a/grafana/README.md) to monitor Dapr system services and sidecars can easily be used without any changes. New Relic provides a [native endpoint for Prometheus metrics](https://docs.newrelic.com/docs/integrations/grafana-integrations/set-configure/configure-new-relic-prometheus-data-source-grafana) into Grafana. A datasource can easily be set-up:
+
+![New Relic Grafana Data Source](/images/nr-grafana-datasource.png)
+
+And the exact same dashboard templates from Dapr can be imported to visualize Dapr system services and sidecars.
+
+![New Relic Grafana Dashboard](/images/nr-grafana-dashboard.png)
+
+## New Relic Alerts
+
+All the data that is collected from Dapr, Kubernetes or any services that run on top of can be used to set-up alerts and notifications into the preferred channel of your choice. See [Alerts and Applied Intelligence](https://docs.newrelic.com/docs/alerts-applied-intelligence).
+
+## Related Links/References
+
+* [New Relic Account Signup](https://newrelic.com/signup)
+* [Telemetry Data Platform](https://newrelic.com/platform/telemetry-data-platform)
+* [Distributed Tracing](https://docs.newrelic.com/docs/understand-dependencies/distributed-tracing/get-started/introduction-distributed-tracing)
+* [New Relic Trace API](https://docs.newrelic.com/docs/understand-dependencies/distributed-tracing/trace-api)
+* [New Relic Metric API](https://docs.newrelic.com/docs/telemetry-data-platform/get-data/apis/introduction-metric-api)
+* [Types of New Relic API keys](https://docs.newrelic.com/docs/apis/get-started/intro-apis/types-new-relic-api-keys)
+* [New Relic OpenTelemetry User Experience](https://blog.newrelic.com/product-news/opentelemetry-user-experience/)
+* [Alerts and Applied Intelligence](https://docs.newrelic.com/docs/alerts-applied-intelligence)

daprdocs/content/en/operations/monitoring/open-telemetry-collector.md

@@ -6,7 +6,7 @@ weight: 1000
 description: "How to use Dapr to push trace events to Azure Application Insights, through the OpenTelemetry Collector."
 ---
 
-Dapr can integrate with [OpenTelemetry Collector](https://github.com/open-telemetry/opentelemetry-collector) using the OpenCensus API. This guide walks through an example to use Dapr to push trace events to Azure Application Insights, through the OpenTelemetry Collector.
+Dapr can integrate with [OpenTelemetry Collector](https://github.com/open-telemetry/opentelemetry-collector) using the Zipkin API. This guide walks through an example to use Dapr to push trace events to Azure Application Insights, through the OpenTelemetry Collector.
 
 ## Requirements
 
@@ -29,15 +29,15 @@ export APP_INSIGHTS_KEY=<your-app-insight-key>
 
 Next, install the OpenTelemetry Collector to your Kubernetes cluster to push events to your Application Insights instance
 
-1. Check out the file [open-telemetry-collector.yaml](/docs/open-telemetry-collector/open-telemetry-collector.yaml) and replace the `<INSTRUMENTATION-KEY>` placeholder with your `APP_INSIGHTS_KEY`. 
+1. Check out the file [open-telemetry-collector.yaml](/docs/open-telemetry-collector/open-telemetry-collector.yaml) and replace the `<INSTRUMENTATION-KEY>` placeholder with your `APP_INSIGHTS_KEY`.
 
 2. Apply the configuration with `kubectl apply -f open-telemetry-collector.yaml`.
 
 Next, set up both a Dapr configuration file to turn on tracing and deploy a tracing exporter component that uses the OpenTelemetry Collector.
 
-1. Create a collector-component.yaml file with this [content](/docs/open-telemetry-collector/collector-component.yaml)
+1. Create a collector-config.yaml file with this [content](/docs/open-telemetry-collector/collector-config.yaml)
 
-2. Apply the configuration with `kubectl apply -f collector-component.yaml`.
+2. Apply the configuration with `kubectl apply -f collector-config.yaml`.
 
 ### Deploy your app with tracing
 

daprdocs/content/en/reference/api/error_codes.md

@@ -46,3 +46,4 @@ Following table lists the error codes returned by Dapr runtime:
 | ERR_SECRET_STORES_NOT_CONFIGURED  | Error that no secret store is configured.
 | ERR_SECRET_STORE_NOT_FOUND        | Error that specified secret store is not found.
 | ERR_HEALTH_NOT_READY              | Error that Dapr is not ready.
+| ERR_METADATA_GET                  | Error parsing the Metadata information.

daprdocs/content/en/reference/api/health_api.md

@@ -3,7 +3,7 @@ type: docs
 title: "Health API reference"
 linkTitle: "Health API"
 description: "Detailed documentation on the health API"
-weight: 900
+weight: 700
 ---
 
 Dapr provides health checking probes that can be used as readiness or liveness of Dapr.

daprdocs/content/en/reference/api/metadata_api.md

@@ -0,0 +1,191 @@
+---
+type: docs
+title: "Metadata API reference"
+linkTitle: "Metadata API"
+description: "Detailed documentation on the Metadata API"
+weight: 800
+---
+
+Dapr has a metadata API that returns information about the sidecar allowing runtime discoverability. The metadata endpoint returns among other things, a list of the components loaded and the activated actors (if present).
+
+The Dapr metadata API also allows you to store additional information in the format of key-value pairs.
+
+Note: The Dapr metatada endpoint is for instance being used by the Dapr CLI when running dapr in standalone mode to store the PID of the process hosting the sidecar and the command used to run the application.
+
+## Get the Dapr sidecar information
+
+Gets the Dapr sidecar information provided by the Metadata Endpoint.
+
+### HTTP Request
+
+```http
+GET http://localhost:<daprPort>/v1.0/metadata
+```
+
+### URL Parameters
+
+Parameter | Description
+--------- | -----------
+daprPort  | The Dapr port.
+
+### HTTP Response Codes
+
+Code | Description
+---- | -----------
+200  | Metadata information returned
+500  | Dapr could not return the metadata information
+
+### HTTP Response Body
+
+**Metadata API Response Object**
+
+Name                   | Type                                                                  | Description
+----                   | ----                                                                  | -----------
+id                     | string                                                                | Application ID
+actors                 | [Metadata API Response Registered Actor](#metadataapiresponseactor)[] | A json encoded array of Registered Actors metadata.
+extended.attributeName | string                                                                | List of custom attributes as key-value pairs, where key is the attribute name.
+components             | [Metadata API Response Component](#metadataapiresponsecomponent)[]    | A json encoded array of loaded components metadata.
+
+<a id="metadataapiresponseactor"></a>**Metadata API Response Registered Actor**
+
+Name  | Type    | Description
+----  | ----    | -----------
+type  | string  | The registered actor type.
+count | integer | Number of actors running.
+
+<a id="metadataapiresponsecomponent"></a>**Metadata API Response Component**
+
+Name    | Type   | Description
+----    | ----   | -----------
+name    | string | Name of the component.
+type    | string | Component type.
+version | string | Component version.
+
+### Examples
+
+Note: This example is based on the Actor sample provided in the [Dapr SDK for Python](https://github.com/dapr/python-sdk/tree/master/examples/demo_actor). 
+
+```shell
+curl http://localhost:3500/v1.0/metadata
+```
+
+```json
+{
+    "id":"demo-actor",
+    "actors":[
+        {
+            "type":"DemoActor",
+            "count":1
+        }
+    ],
+    "extended": {
+        "cliPID":"1031040",
+        "appCommand":"uvicorn --port 3000 demo_actor_service:app"
+    },
+    "components":[
+        {
+            "name":"pubsub",
+            "type":"pubsub.redis",
+            "version":""
+        },
+        {
+            "name":"statestore",
+            "type":"state.redis",
+            "version":""
+        },
+        {
+            "name":"zipkin",
+            "type":"exporters.zipkin",
+            "version":""
+        }
+    ]
+}
+```
+
+## Add a custom attribute to the Dapr sidecar information
+
+Adds a custom attribute to the Dapr sidecar information stored by the Metadata Endpoint.
+
+### HTTP Request
+
+```http
+PUT http://localhost:<daprPort>/v1.0/metadata/attributeName
+```
+
+### URL Parameters
+
+Parameter      | Description
+---------      | -----------
+daprPort       | The Dapr port.
+attributeName  | Custom attribute name. This is they key name in the key-value pair.
+
+### HTTP Request Body
+
+In the request you need to pass the custom attribute value as RAW data:
+
+```json
+{
+  "Content-Type": "text/plain"
+}
+```
+
+Within the body of the request place the custom attribute value you want to store:
+
+```
+attributeValue
+```
+
+### HTTP Response Codes
+
+Code | Description
+---- | -----------
+204  | Custom attribute added to the metadata information
+
+### Examples
+
+Note: This example is based on the Actor sample provided in the [Dapr SDK for Python](https://github.com/dapr/python-sdk/tree/master/examples/demo_actor).
+
+Add a custom attribute to the metadata endpoint:
+
+```shell
+curl -X PUT -H "Content-Type: text/plain" --data "myDemoAttributeValue" http://localhost:3500/v1.0/metadata/myDemoAttribute 
+```
+
+Get the metadata information to confirm your custom attribute was added:
+
+```json
+{
+    "id":"demo-actor",
+    "actors":[
+        {
+            "type":"DemoActor",
+            "count":1
+        }
+    ],
+    "extended": {
+        "myDemoAttribute": "myDemoAttributeValue",
+        "cliPID":"1031040",
+        "appCommand":"uvicorn --port 3000 demo_actor_service:app"
+    },
+    "components":[
+        {
+            "name":"pubsub",
+            "type":"pubsub.redis",
+            "version":""
+        },
+        {
+            "name":"statestore",
+            "type":"state.redis",
+            "version":""
+        },
+        {
+            "name":"zipkin",
+            "type":"exporters.zipkin",
+            "version":""
+        }
+    ]
+}
+```
+
+
+

daprdocs/content/en/reference/api/secrets_api.md

@@ -3,7 +3,7 @@ type: docs
 title: "Secrets API reference"
 linkTitle: "Secrets API"
 description: "Detailed documentation on the secrets API"
-weight: 700
+weight: 600
 ---
 
 ## Get Secret

daprdocs/static/docs/open-telemetry-collector/collector-component.yaml

@@ -1,22 +0,0 @@
-apiVersion: dapr.io/v1alpha1
-kind: Configuration
-metadata:
-  name: appconfig
-  namespace: default
-spec:
-  tracing:
-    samplingRate: "1"
----
-apiVersion: dapr.io/v1alpha1
-kind: Component
-metadata:
-  name: native
-  namespace: default
-spec:
-  type: exporters.native
-  version: v1
-  metadata:
-  - name: enabled
-    value: "true"
-  - name: agentEndpoint
-    value: "otel-collector.default.svc.cluster.local:55678"

daprdocs/static/docs/open-telemetry-collector/collector-config.yaml

@@ -0,0 +1,10 @@
+apiVersion: dapr.io/v1alpha1
+kind: Configuration
+metadata:
+  name: appconfig
+  namespace: default
+spec:
+  tracing:
+    samplingRate: "1"
+    zipkin:
+      endpointAddress: "http://otel-collector.default.svc.cluster.local:9411/api/v2/spans"

daprdocs/static/docs/open-telemetry-collector/open-telemetry-collector.yaml

@@ -8,8 +8,8 @@ metadata:
 data:
   otel-collector-config: |
     receivers:
-      opencensus:
-        endpoint: 0.0.0.0:55678
+      zipkin:
+        endpoint: 0.0.0.0:9411
     processors:
       queued_retry:
       batch:
@@ -20,8 +20,9 @@ data:
       zpages:
         endpoint: :55679
     exporters:
+      logging:
+        loglevel: debug
       azuremonitor:
-      azuremonitor/2:
         endpoint: "https://dc.services.visualstudio.com/v2/track"
         instrumentation_key: "<INSTRUMENTATION-KEY>"
         # maxbatchsize is the maximum number of items that can be
@@ -34,8 +35,8 @@ data:
       extensions: [pprof, zpages, health_check]
       pipelines:
         traces:
-          receivers: [opencensus]
-          exporters: [azuremonitor/2]
+          receivers: [zipkin]
+          exporters: [azuremonitor,logging]
           processors: [batch, queued_retry]
 ---
 apiVersion: v1
@@ -47,10 +48,10 @@ metadata:
     component: otel-collector
 spec:
   ports:
-  - name: opencensus # Default endpoint for Opencensus receiver.
-    port: 55678
+  - name: zipkin # Default endpoint for Zipkin receiver.
+    port: 9411
     protocol: TCP
-    targetPort: 55678
+    targetPort: 9411
   selector:
     component: otel-collector
 ---
@@ -86,7 +87,7 @@ spec:
             cpu: 200m
             memory: 400Mi
         ports:
-          - containerPort: 55678 # Default endpoint for Opencensus receiver.
+          - containerPort: 9411 # Default endpoint for Zipkin receiver.
         volumeMounts:
           - name: otel-collector-config-vol
             mountPath: /conf