Merge branch 'v1.12' into issue_3965_1.12

CONTRIBUTING.md

@@ -1,3 +1,3 @@
 # Contributing to Dapr docs
 
-Please see [this docs section](https://docs.dapr.io/contributing/) for general guidance on contributions to the Dapr project as well as specific guidelines on contributions to the docs repo.
+Please see [this docs section](https://docs.dapr.io/contributing/) for general guidance on contributions to the Dapr project as well as specific guidelines on contributions to the docs repo. Learn more about [Dapr bot commands and labels](https://docs.dapr.io/contributing/daprbot/) to improve your docs contributing experience.

daprdocs/config.toml

@@ -212,18 +212,6 @@ url_latest_version = "https://docs.dapr.io"
 [[params.versions]]
   version = "v1.7"
   url = "https://v1-7.docs.dapr.io"
-[[params.versions]]
-  version = "v1.6"
-  url = "https://v1-6.docs.dapr.io"
-[[params.versions]]
-  version = "v1.5"
-  url = "https://v1-5.docs.dapr.io"
-[[params.versions]]
-  version = "v1.4"
-  url = "https://v1-4.docs.dapr.io"
-[[params.versions]]
-  version = "v1.3"
-  url = "https://v1-3.docs.dapr.io"
 
 # UI Customization
 [params.ui]

daprdocs/content/en/contributing/daprbot.md

@@ -12,7 +12,7 @@ Dapr bot is triggered by a list of commands that helps with common tasks in the
 
 | Command          | Target                | Description                                                                                              | Who can use                                                                                     | Repository                             |
 | ---------------- | --------------------- | -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | -------------------------------------- |
-| `/assign`        | Issue                 | Assigns an issue to a user or group of users                                                             | Anyone                                                                                          | `dapr`, `components-contrib`, `go-sdk` |
+| `/assign`        | Issue                 | Assigns an issue to a user or group of users                                                             | Anyone                                                                                          | `dapr`, `docs`, `quickstarts`, `cli`, `components-contrib`, `go-sdk`, `js-sdk`, `java-sdk`, `python-sdk`, `dotnet-sdk` |
 | `/ok-to-test`    | Pull request          | `dapr`: trigger end to end tests <br/> `components-contrib`: trigger conformance and certification tests | Users listed in the [bot](https://github.com/dapr/dapr/blob/master/.github/scripts/dapr_bot.js) | `dapr`, `components-contrib`           |
 | `/ok-to-perf`    | Pull request          | Trigger performance tests.                                                                               | Users listed in the [bot](https://github.com/dapr/dapr/blob/master/.github/scripts/dapr_bot.js) | `dapr`                                 |
 | `/make-me-laugh` | Issue or pull request | Posts a random joke                                                                                      | Users listed in the [bot](https://github.com/dapr/dapr/blob/master/.github/scripts/dapr_bot.js) | `dapr`, `components-contrib`           |

daprdocs/content/en/developing-applications/building-blocks/actors/actors-features-concepts.md

@@ -14,7 +14,9 @@ Now that you've learned about the [actor building block]({{< ref "actors-overvie
 
 Dapr actors are virtual, meaning that their lifetime is not tied to their in-memory representation. As a result, they do not need to be explicitly created or destroyed. The Dapr actor runtime automatically activates an actor the first time it receives a request for that actor ID. If an actor is not used for a period of time, the Dapr actor runtime garbage-collects the in-memory object. It will also maintain knowledge of the actor's existence should it need to be reactivated later.
 
-Invocation of actor methods and reminders reset the idle time, e.g. reminder firing will keep the actor active. Actor reminders fire whether an actor is active or inactive, if fired for inactive actor, it will activate the actor first. Actor timers do not reset the idle time, so timer firing will not keep the actor active. Timers only fire while the actor is active.
+Invocation of actor methods, timers, and reminders reset the actor idle time. For example, a reminder firing keeps the actor active. 
+- Actor reminders fire whether an actor is active or inactive. If fired for an inactive actor, it activates the actor first.
+- Actor timers firing reset the idle time; however, timers only fire while the actor is active.
 
 The idle timeout and scan interval Dapr runtime uses to see if an actor can be garbage-collected is configurable. This information can be passed when Dapr runtime calls into the actor service to get supported actor types.
 

daprdocs/content/en/developing-applications/building-blocks/cryptography/howto-cryptography.md

@@ -6,16 +6,16 @@ weight: 2000
 description: "Learn how to encrypt and decrypt files"
 ---
 
-Now that you've read about [Cryptography as a Dapr building block]({{< ref cryptography-overview.md >}}), let's walk through using the cryptography APIs with the SDKs.  
+Now that you've read about [Cryptography as a Dapr building block]({{< ref cryptography-overview.md >}}), let's walk through using the cryptography APIs with the SDKs.
 
 {{% alert title="Note" color="primary" %}}
-  Dapr cryptography is currently in alpha.
+Dapr cryptography is currently in alpha.
 
 {{% /alert %}}
 
 ## Encrypt
 
-{{< tabs "JavaScript" "Go" >}}
+{{< tabs "JavaScript" "Go" ".NET" >}}
 
 {{% codetab %}}
 
@@ -136,12 +136,32 @@ if err != nil {
 
 {{% /codetab %}}
 
+{{% codetab %}}
+
+<!-- .NET -->
+Using the Dapr SDK in your project, with the gRPC APIs, you can encrypt data in a string or a byte array:
+
+```csharp
+using var client = new DaprClientBuilder().Build();
+
+const string componentName = "azurekeyvault"; //Change this to match your cryptography component
+const string keyName = "myKey"; //Change this to match the name of the key in your cryptographic store
+
+const string plainText = "This is the value we're going to encrypt today";
+
+//Encode the string to a UTF-8 byte array and encrypt it
+var plainTextBytes = Encoding.UTF8.GetBytes(plainText);
+var encryptedBytesResult = await client.EncryptAsync(componentName, plaintextBytes, keyName, new EncryptionOptions(KeyWrapAlgorithm.Rsa));
+```
+
+{{% /codetab %}}
+
 {{< /tabs >}}
 
 
 ## Decrypt
 
-{{< tabs "JavaScript" "Go" >}}
+{{< tabs "JavaScript" "Go" ".NET" >}}
 
 {{% codetab %}}
 
@@ -186,6 +206,29 @@ out, err := sdkClient.Decrypt(context.Background(), rf, dapr.EncryptOptions{
 
 {{% /codetab %}}
 
+{{% codetab %}}
+
+<!-- .NET -->
+To decrypt a string, use the 'DecryptAsync' gRPC API in your project.
+
+In the following example, we'll take a byte array (such as from the example above) and decrypt it to a UTF-8 encoded string.
+
+```csharp
+public async Task<string> DecryptBytesAsync(byte[] encryptedBytes)
+{
+  using var client = new DaprClientBuilder().Build();
+
+  const string componentName = "azurekeyvault"; //Change this to match your cryptography component
+  const string keyName = "myKey"; //Change this to match the name of the key in your cryptographic store
+
+  var decryptedBytes = await client.DecryptAsync(componentName, encryptedBytes, keyName);
+  var decryptedString = Encoding.UTF8.GetString(decryptedBytes.ToArray());
+  return decryptedString;
+}
+```
+
+{{% /codetab %}}
+
 {{< /tabs >}}
 
 ## Next steps

daprdocs/content/en/developing-applications/building-blocks/workflow/workflow-architecture.md

@@ -145,6 +145,8 @@ Different state store implementations may implicitly put restrictions on the typ
 
 Similarly, if a state store imposes restrictions on the size of a batch transaction, that may limit the number of parallel actions that can be scheduled by a workflow.
 
+Workflow state can be purged from a state store, including all its history. Each Dapr SDK exposes APIs for purging all metadata related to specific workflow instances.
+
 ## Workflow scalability
 
 Because Dapr Workflows are internally implemented using actors, Dapr Workflows have the same scalability characteristics as actors. The placement service:

daprdocs/content/en/developing-applications/building-blocks/workflow/workflow-features-concepts.md

@@ -63,6 +63,8 @@ You can use the following two techniques to write workflows that may need to sch
 
 1. **Use the _continue-as-new_ API**:  
     Each workflow SDK exposes a _continue-as-new_ API that workflows can invoke to restart themselves with a new input and history. The _continue-as-new_ API is especially ideal for implementing "eternal workflows", like monitoring agents, which would otherwise be implemented using a `while (true)`-like construct. Using _continue-as-new_ is a great way to keep the workflow history size small.
+
+    > The _continue-as-new_ API truncates the existing history, replacing it with a new history.
 
 1. **Use child workflows**:  
     Each workflow SDK exposes an API for creating child workflows. A child workflow behaves like any other workflow, except that it's scheduled by a parent workflow. Child workflows have:
@@ -149,6 +151,12 @@ Workflows can also wait for multiple external event signals of the same name, in
 
 Learn more about [external system interaction.]({{< ref "workflow-patterns.md#external-system-interaction" >}})
 
+## Purging
+
+Workflow state can be purged from a state store, purging all its history and removing all metadata related to a specific workflow instance. The purge capability is used for workflows that have run to a `COMPLETED`, `FAILED`, or `TERMINATED` state. 
+
+Learn more in [the workflow API reference guide]({{< ref workflow_api.md >}}).
+
 ## Limitations
 
 ### Workflow determinism and code restraints 

daprdocs/content/en/developing-applications/building-blocks/workflow/workflow-patterns.md

@@ -496,9 +496,8 @@ public class MonitorWorkflow extends Workflow {
       }
 
       // Put the workflow to sleep until the determined time
-      // Note: ctx.createTimer() method is not supported in the Java SDK yet
       try {
-        TimeUnit.SECONDS.sleep(nextSleepInterval.getSeconds());
+        ctx.createTimer(nextSleepInterval);
       } catch (InterruptedException e) {
         throw new RuntimeException(e);
       }
@@ -745,4 +744,4 @@ External events don't have to be directly triggered by humans. They can also be
 - Try out the following examples: 
    - [Python](https://github.com/dapr/python-sdk/tree/master/examples/demo_workflow)
    - [.NET](https://github.com/dapr/dotnet-sdk/tree/master/examples/Workflow)
-   - [Java](https://github.com/dapr/java-sdk/tree/master/examples/src/main/java/io/dapr/examples/workflows)
+   - [Java](https://github.com/dapr/java-sdk/tree/master/examples/src/main/java/io/dapr/examples/workflows)

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

@@ -22,10 +22,14 @@ Dapr initialization includes:
 1. Creating a **default components folder** with component definitions for the above.
 1. Running a **Dapr placement service container instance** for local actor support.
 
+{{% alert title="Kubernetes Development Environment" color="primary" %}}
+To initialize Dapr in your local or remote **Kubernetes** cluster for development (including the Redis and Zipkin containers listed above), see [how to initialize Dapr for development on Kubernetes]({{<ref "kubernetes-deploy.md#install-dapr-from-the-official-dapr-helm-chart-with-development-flag">}})
+{{% /alert %}}
+
 {{% alert title="Docker" color="primary" %}}
-The recommended development environment requires [Docker](https://docs.docker.com/install/). While you can [initialize Dapr without a dependency on Docker]({{<ref self-hosted-no-docker.md>}})), the next steps in this guide assume the recommended Docker development environment.
+The recommended development environment requires [Docker](https://docs.docker.com/install/). While you can [initialize Dapr without a dependency on Docker]({{< ref self-hosted-no-docker.md >}})), the next steps in this guide assume the recommended Docker development environment.
 
-You can also install [Podman](https://podman.io/) in place of Docker. Read more about [initializing Dapr using Podman]({{<ref dapr-init.md>}}).
+You can also install [Podman](https://podman.io/) in place of Docker. Read more about [initializing Dapr using Podman]({{< ref dapr-init.md >}}).
 {{% /alert %}}
 
 ### Step 1: Open an elevated terminal
@@ -54,12 +58,35 @@ Run Windows Terminal or command prompt as administrator.
 
 ### Step 2: Run the init CLI command
 
+{{< tabs "Linux/MacOS" "Windows">}}
+
+{{% codetab %}}
+
 Install the latest Dapr runtime binaries:
 
 ```bash
 dapr init
 ```
 
+**If you are installing on Mac OS Silicon with Docker,** you may need to perform the following workaround to enable `dapr init` to talk to Docker without using Kubernetes.
+1. Navigate to **Docker Desktop** > **Settings** > **Advanced**.
+1. Select the **Enable default Docker socket** checkbox.
+
+{{% /codetab %}}
+
+{{% codetab %}}
+
+Install the latest Dapr runtime binaries:
+
+```bash
+dapr init
+```
+
+{{% /codetab %}}
+
+{{< /tabs >}}
+
+
 ### Step 3: Verify Dapr version
 
 ```bash
@@ -112,9 +139,14 @@ ls $HOME/.dapr
 {{% /codetab %}}
 
 {{% codetab %}}
-
+You can verify using either PowerShell or command line. If using PowerShell, run:
 ```powershell
-explorer "%USERPROFILE%\.dapr\"
+explorer "$env:USERPROFILE\.dapr"
+```
+
+If using command line, run: 
+```cmd
+explorer "%USERPROFILE%\.dapr"
 ```
 
 **Result:**

daprdocs/content/en/operations/hosting/kubernetes/kubernetes-deploy.md

@@ -72,6 +72,51 @@ The `-k` flag initializes Dapr on the Kubernetes cluster in your current context
     dapr dashboard -k -n <your-namespace>
     ```
 
+
+ #### Install Dapr from the offical Dapr Helm chart (with development flag)
+
+Adding the `--dev` flag initializes Dapr on the Kubernetes cluster on your current context, with the addition of Redis and Zipkin deployments.
+
+The steps are similar to [installing from the Dapr Helm chart](#install-dapr-from-an-official-dapr-helm-chart), except for appending the `--dev` flag to the `init` command:
+
+ ```bash
+ dapr init -k --dev
+ ```
+
+Expected output:
+
+```bash
+⌛  Making the jump to hyperspace...
+ℹ️  Note: To install Dapr using Helm, see here: https://docs.dapr.io/getting-started/install-dapr-kubernetes/#install-with-helm-advanced
+
+ℹ️  Container images will be pulled from Docker Hub
+✅  Deploying the Dapr control plane with latest version to your cluster...
+✅  Deploying the Dapr dashboard with latest version to your cluster...
+✅  Deploying the Dapr Redis with latest version to your cluster...
+✅  Deploying the Dapr Zipkin with latest version to your cluster...
+ℹ️  Applying "statestore" component to Kubernetes "default" namespace.
+ℹ️  Applying "pubsub" component to Kubernetes "default" namespace.
+ℹ️  Applying "appconfig" zipkin configuration to Kubernetes "default" namespace.
+✅  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
+ ```
+
+After a short period of time (or using the `--wait` flag and specifying an amount of time to wait), you can check that the Redis and Zipkin components have been deployed to the cluster.
+
+```bash
+kubectl get pods --namespace default
+```
+
+Expected output:
+
+```bash
+NAME                              READY   STATUS    RESTARTS   AGE
+dapr-dev-zipkin-bfb4b45bb-sttz7   1/1     Running   0          159m
+dapr-dev-redis-master-0           1/1     Running   0          159m
+dapr-dev-redis-replicas-0         1/1     Running   0          159m
+dapr-dev-redis-replicas-1         1/1     Running   0          159m
+dapr-dev-redis-replicas-2         1/1     Running   0          158m 
+ ```
+
 #### Install Dapr from a private Dapr Helm chart
 
 Installing Dapr from a private Helm chart can be helpful for when you:

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

@@ -174,6 +174,10 @@ Purge the workflow state from your state store with the workflow's instance ID.
 POST http://localhost:3500/v1.0-beta1/workflows/<workflowComponentName>/<instanceId>/purge
 ```
 
+{{% alert title="Note" color="primary" %}}
+Only `COMPLETED`, `FAILED`, or `TERMINATED` workflows can be purged.
+{{% /alert %}}
+
 ### URL parameters
 
 Parameter | Description
@@ -235,7 +239,7 @@ The API call will provide a JSON response similar to this:
 
 Parameter | Description
 --------- | -----------
-`runtimeStatus` | The status of the workflow instance. Values include: `RUNNING`, `TERMINATED`, `PAUSED`  
+`runtimeStatus` | The status of the workflow instance. Values include: `"RUNNING"`, `"COMPLETED"`, `"CONTINUED_AS_NEW"`, `"FAILED"`, `"CANCELED"`, `"TERMINATED"`, `"PENDING"`, `"SUSPENDED"`  
 
 ## Component format
 

daprdocs/content/en/reference/cli/dapr-init.md

@@ -162,6 +162,12 @@ dapr uninstall --all --network mynet
 dapr init -k
 ```
 
+Using the `--dev` flag initializes Dapr in dev mode, which includes Zipkin and Redis.
+```bash
+dapr init -k --dev
+```
+
+
 You can wait for the installation to complete its deployment with the `--wait` flag.
 The default timeout is 300s (5 min), but can be customized with the `--timeout` flag.
 

daprdocs/content/en/reference/components-reference/supported-bindings/openai.md

@@ -276,6 +276,11 @@ The response body contains the following JSON:
 [0.018574921,-0.00023652936,-0.0057790717,.... (1536 floats total for ada)]
 ```
 
+## Learn more about the Azure OpenAI output binding
+
+Watch [the following Community Call presentation](https://youtu.be/rTovKpG0rhY?si=g7hZTQSpSEXz4pV1&t=80) to learn more about the Azure OpenAI output binding.
+
+<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/rTovKpG0rhY?si=XP1S-80SIg1ptJuG&amp;start=80" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
 
 ## Related links