Merge branch 'issue_2923' of https://github.com/hhunter-ms/docs into …

…issue_2923

README.md

@@ -1,5 +1,7 @@
 # Dapr documentation
 
+[![GitHub License](https://img.shields.io/github/license/dapr/docs?style=flat&label=License&logo=github)](https://github.com/dapr/docs/blob/v1.13/LICENSE) [![GitHub issue custom search in repo](https://img.shields.io/github/issues-search/dapr/docs?query=type%3Aissue%20is%3Aopen%20label%3A%22good%20first%20issue%22&label=Good%20first%20issues&style=flat&logo=github)](https://github.com/dapr/docs/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) [![Discord](https://img.shields.io/discord/778680217417809931?label=Discord&style=flat&logo=discord)](http://bit.ly/dapr-discord) [![YouTube Channel Views](https://img.shields.io/youtube/channel/views/UCtpSQ9BLB_3EXdWAUQYwnRA?style=flat&label=YouTube%20views&logo=youtube)](https://youtube.com/@daprdev) [![X (formerly Twitter) Follow](https://img.shields.io/twitter/follow/daprdev?logo=x&style=flat)](https://twitter.com/daprdev)
+
 If you are looking to explore the Dapr documentation, please go to the documentation website:
 
 [**https://docs.dapr.io**](https://docs.dapr.io)

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`, `docs`, `quickstarts`, `cli`, `components-contrib`, `go-sdk`, `js-sdk`, `java-sdk`, `python-sdk`, `dotnet-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`, `rust-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/service-invocation/howto-invoke-non-dapr-endpoints.md

@@ -70,7 +70,7 @@ There are two ways to invoke a non-Dapr endpoint when communicating either to Da
     ```
 
 ### Using appId when calling Dapr enabled applications
-AppIDs are always used to call Dapr applications with the `appID` and `my-method``. Read the [How-To: Invoke services using HTTP]({{< ref howto-invoke-discover-services.md >}}) guide for more information. For example:
+AppIDs are always used to call Dapr applications with the `appID` and `my-method`. Read the [How-To: Invoke services using HTTP]({{< ref howto-invoke-discover-services.md >}}) guide for more information. For example:
 
 ```sh
 localhost:3500/v1.0/invoke/<appID>/method/<my-method>

daprdocs/content/en/developing-applications/building-blocks/state-management/howto-get-save-state.md

@@ -537,7 +537,7 @@ Try getting state again. Note that no value is returned.
 
 Below are code examples that leverage Dapr SDKs for saving and retrieving multiple states.
 
-{{< tabs Dotnet Java Python Javascript "HTTP API (Bash)" "HTTP API (PowerShell)">}}
+{{< tabs Dotnet Java Python Go Javascript "HTTP API (Bash)" "HTTP API (PowerShell)">}}
 
 {{% codetab %}}
 
@@ -656,6 +656,56 @@ dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-g
 
 {{% codetab %}}
 
+```go
+// dependencies
+import (
+	"context"
+	"log"
+	"math/rand"
+	"strconv"
+	"time"
+
+	dapr "github.com/dapr/go-sdk/client"
+)
+
+// code
+func main() {
+	const STATE_STORE_NAME = "statestore"
+	rand.Seed(time.Now().UnixMicro())
+	for i := 0; i < 10; i++ {
+		orderId := rand.Intn(1000-1) + 1
+		client, err := dapr.NewClient()
+		if err != nil {
+			panic(err)
+		}
+		defer client.Close()
+		ctx := context.Background()
+		err = client.SaveState(ctx, STATE_STORE_NAME, "order_1", []byte(strconv.Itoa(orderId)), nil)
+		if err != nil {
+			panic(err)
+		}
+		keys := []string{"key1", "key2", "key3"}
+        items, err := client.GetBulkState(ctx, STATE_STORE_NAME, keys, nil, 100)
+		if err != nil {
+			panic(err)
+		}
+		for _, item := range items {
+			log.Println("Item from GetBulkState:", string(item.Value))
+		}
+	}
+} 
+```
+
+To launch a Dapr sidecar for the above example application, run a command similar to the following:
+
+```bash
+dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 go run OrderProcessingService.go
+```
+
+{{% /codetab %}}
+
+{{% codetab %}}
+
 ```javascript
 //dependencies
 import { DaprClient, HttpMethod, CommunicationProtocolEnum } from '@dapr/dapr'; 
@@ -738,7 +788,7 @@ State transactions require a state store that supports multi-item transactions.
 
 Below are code examples that leverage Dapr SDKs for performing state transactions.
 
-{{< tabs Dotnet Java Python Javascript "HTTP API (Bash)" "HTTP API (PowerShell)">}}
+{{< tabs Dotnet Java Python Go Javascript "HTTP API (Bash)" "HTTP API (PowerShell)">}}
 
 {{% codetab %}}
 
@@ -893,6 +943,79 @@ dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-g
 
 {{% codetab %}}
 
+```go
+// dependencies
+package main
+
+import (
+	"context"
+	"log"
+	"math/rand"
+	"strconv"
+	"time"
+
+	dapr "github.com/dapr/go-sdk/client"
+)
+
+// code
+func main() {
+	const STATE_STORE_NAME = "statestore"
+	rand.Seed(time.Now().UnixMicro())
+	for i := 0; i < 10; i++ {
+		orderId := rand.Intn(1000-1) + 1
+		client, err := dapr.NewClient()
+		if err != nil {
+			panic(err)
+		}
+		defer client.Close()
+		ctx := context.Background()
+		err = client.SaveState(ctx, STATE_STORE_NAME, "order_1", []byte(strconv.Itoa(orderId)), nil)
+		if err != nil {
+			panic(err)
+		}
+		result, err := client.GetState(ctx, STATE_STORE_NAME, "order_1", nil)
+		if err != nil {
+			panic(err)
+		}
+
+        ops := make([]*dapr.StateOperation, 0)
+        data1 := "data1"
+        data2 := "data2"
+
+        op1 := &dapr.StateOperation{
+            Type: dapr.StateOperationTypeUpsert,
+            Item: &dapr.SetStateItem{
+                Key:   "key1",
+                Value: []byte(data1),
+            },
+        }
+        op2 := &dapr.StateOperation{
+            Type: dapr.StateOperationTypeDelete,
+            Item: &dapr.SetStateItem{
+                Key:   "key2",
+                Value: []byte(data2),
+            },
+        }
+        ops = append(ops, op1, op2)
+        meta := map[string]string{}
+        err = client.ExecuteStateTransaction(ctx, STATE_STORE_NAME, meta, ops)
+
+		log.Println("Result after get:", string(result.Value))
+		time.Sleep(2 * time.Second)
+	}
+}
+```
+
+To launch a Dapr sidecar for the above example application, run a command similar to the following:
+
+```bash
+dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 go run OrderProcessingService.go
+```
+
+{{% /codetab %}}
+
+{{% codetab %}}
+
 ```javascript
 //dependencies
 import { DaprClient, HttpMethod, CommunicationProtocolEnum } from '@dapr/dapr'; 

daprdocs/content/en/developing-applications/building-blocks/state-management/howto-outbox.md

@@ -28,8 +28,10 @@ The diagram below is an overview of how the outbox feature works:
 
 The outbox feature can be used with using any [transactional state store]({{< ref supported-state-stores >}}) supported by Dapr. All [pub/sub brokers]({{< ref supported-pubsub >}}) are supported with the outbox feature.
 
+[Learn more about the transactional methods you can use.]({{< ref "howto-get-save-state.md#perform-state-transactions" >}})
+
 {{% alert title="Note" color="primary" %}} 
-Message brokers that work with the competing consumer pattern (for example, [Apache Kafka]({{< ref setup-apache-kafka>}}) are encouraged to reduce the chances of duplicate events.
+Message brokers that work with the competing consumer pattern (for example, [Apache Kafka]({{< ref setup-apache-kafka>}})) are encouraged to reduce the chances of duplicate events.
 {{% /alert %}}
 
 ## Usage

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

@@ -586,7 +586,45 @@ The key takeaways from this example are:
 - The number of parallel tasks can be static or dynamic
 - The workflow itself is capable of aggregating the results of parallel executions
 
-While not shown in the example, it's possible to go further and limit the degree of concurrency using simple, language-specific constructs. Furthermore, the execution of the workflow is durable. If a workflow starts 100 parallel task executions and only 40 complete before the process crashes, the workflow restarts itself automatically and only schedules the remaining 60 tasks.
+Furthermore, the execution of the workflow is durable. If a workflow starts 100 parallel task executions and only 40 complete before the process crashes, the workflow restarts itself automatically and only schedules the remaining 60 tasks.
+
+It's possible to go further and limit the degree of concurrency using simple, language-specific constructs. The sample code below illustrates how to restrict the degree of fan-out to just 5 concurrent activity executions:
+
+{{< tabs ".NET" >}}
+
+{{% codetab %}}
+<!-- .NET -->
+```csharp
+
+//Revisiting the earlier example...
+// Get a list of N work items to process in parallel.
+object[] workBatch = await context.CallActivityAsync<object[]>("GetWorkBatch", null);
+
+const int MaxParallelism = 5;
+var results = new List<int>();
+var inFlightTasks = new HashSet<Task<int>>();
+foreach(var workItem in workBatch)
+{
+  if (inFlightTasks.Count >= MaxParallelism)
+  {
+    var finishedTask = await Task.WhenAny(inFlightTasks);
+    results.Add(finishedTask.Result);
+    inFlightTasks.Remove(finishedTask);
+  }
+
+  inFlightTasks.Add(context.CallActivityAsync<int>("ProcessWorkItem", workItem));
+}
+results.AddRange(await Task.WhenAll(inFlightTasks));
+
+var sum = results.Sum(t => t);
+await context.CallActivityAsync("PostResults", sum);
+```
+
+{{% /codetab %}}
+
+{{< /tabs >}}
+
+Limiting the degree of concurrency in this way can be useful for limiting contention against shared resources. For example, if the activities need to call into external resources that have their own concurrency limits, like a databases or external APIs, it can be useful to ensure that no more than a specified number of activities call that resource concurrently.
 
 ## Async HTTP APIs
 

daprdocs/content/en/developing-applications/local-development/multi-app-dapr-run/multi-app-template.md

@@ -42,7 +42,7 @@ dapr run -f <dir_path>
 <!--kubernetes-->
 
 ```cmd
-dapr run -f -k <dir_path>
+dapr run -f <dir_path> -k 
 ```
 {{% /codetab %}}
 
@@ -67,7 +67,7 @@ dapr run -f ./path/to/<your-preferred-file-name>.yaml
 <!--kubernetes-->
 
 ```cmd
-dapr run -f -k ./path/to/<your-preferred-file-name>.yaml
+dapr run -f ./path/to/<your-preferred-file-name>.yaml -k 
 ```
 {{% /codetab %}}
 
@@ -77,10 +77,27 @@ dapr run -f -k ./path/to/<your-preferred-file-name>.yaml
 
 Once the multi-app template is running, you can view the started applications with the following command:
 
+{{< tabs Self-hosted Kubernetes>}}
+
+{{% codetab %}}
+<!--selfhosted-->
+
 ```cmd
 dapr list
 ```
 
+{{% /codetab %}}
+
+{{% codetab %}}
+<!--kubernetes-->
+
+```cmd
+dapr list -k 
+```
+{{% /codetab %}}
+
+{{< /tabs >}}
+
 ## Stop the multi-app template
 
 Stop the multi-app run template anytime with either of the following commands:
@@ -109,12 +126,12 @@ dapr stop -f ./path/to/<your-preferred-file-name>.yaml
 ```cmd
 # the template file needs to be called `dapr.yaml` by default if a directory path is given
 
-dapr stop -f -k
+dapr stop -f <dir_path> -k
 ```
 or:
 
 ```cmd
-dapr stop -f -k ./path/to/<your-preferred-file-name>.yaml
+dapr stop -f ./path/to/<your-preferred-file-name>.yaml -k 
 ```
 
 {{% /codetab %}}

daprdocs/content/en/operations/components/component-secrets.md

@@ -75,15 +75,14 @@ spec:
   type: bindings.azure.servicebusqueues
   version: v1
   metadata:
-  -name: connectionString
-   secretKeyRef:
+  - name: connectionString
+    secretKeyRef:
       name: asbNsConnString
       key: asbNsConnString
-  -name: queueName
-   value: servicec-inputq
+  - name: queueName
+    value: servicec-inputq
 auth:
   secretStore: <SECRET_STORE_NAME>
-
 ```
 The above "Secret is a string" case yaml tells Dapr to extract a connection string named `asbNsConnstring` from the defined `secretStore` and assign the value to the `connectionString` field in the component since there is no key embedded in the "secret" from the `secretStore` because it is a plain string. This requires the secret `name` and secret `key` to be identical.
 
@@ -95,7 +94,7 @@ The following example shows you how to create a Kubernetes secret to hold the co
 
 1. First, create the Kubernetes secret:
     ```bash
-     kubectl create secret generic eventhubs-secret --from-literal=connectionString=*********
+    kubectl create secret generic eventhubs-secret --from-literal=connectionString=*********
     ```
 
 2. Next, reference the secret in your binding:

daprdocs/content/en/operations/components/pluggable-components-registration.md

@@ -52,7 +52,7 @@ Since you are running Dapr in the same host as the component, verify that this f
 
 ### Component discovery and multiplexing
 
-A pluggable component accessible through a [Unix Domain Socket][UDS] (UDS) can host multiple distinct component APIs . During the components' initial discovery process, Dapr uses reflection to enumerate all the component APIs behind a UDS. The `my-component` pluggable component in the example above can contain both state store (`state`) and a pub/sub (`pubsub`) component APIs.
+A pluggable component accessible through a [Unix Domain Socket][UDS] (UDS) can host multiple distinct component APIs. During the components' initial discovery process, Dapr uses reflection to enumerate all the component APIs behind a UDS. The `my-component` pluggable component in the example above can contain both state store (`state`) and a pub/sub (`pubsub`) component APIs.
 
 Typically, a pluggable component implements a single component API for packaging and deployment. However, at the expense of increasing its dependencies and broadening its security attack surface, a pluggable component can have multiple component APIs implemented. This could be done to ease the deployment and monitoring burden. Best practice for isolation, fault tolerance, and security is a single component API implementation for each pluggable component.
 

daprdocs/content/en/operations/observability/tracing/setup-tracing.md

@@ -20,7 +20,7 @@ spec:
   tracing:
     samplingRate: "1"
     otel: 
-      endpointAddress: "https://..."
+      endpointAddress: "myendpoint.cluster.local:4317"
     zipkin:
       endpointAddress: "https://..."
 
@@ -32,10 +32,10 @@ The following table lists the properties for tracing:
 |--------------|--------|-------------|
 | `samplingRate` | string | Set sampling rate for tracing to be enabled or disabled.
 | `stdout` | bool | True write more verbose information to the traces
-| `otel.endpointAddress` | string | Set the Open Telemetry (OTEL) server address. 
+| `otel.endpointAddress` | string | Set the Open Telemetry (OTEL) target hostname and optionally port. If this is used, you do not need to specify the 'zipkin' section.
 | `otel.isSecure` | bool | Is the connection to the endpoint address encrypted.
 | `otel.protocol` | string | Set to `http` or `grpc` protocol.
-| `zipkin.endpointAddress` | string | Set the Zipkin server address. If this is used, you do not need to specify the `otel` section.
+| `zipkin.endpointAddress` | string | Set the Zipkin server URL. If this is used, you do not need to specify the `otel` section.
 
 To enable tracing, use a configuration file (in self hosted mode) or a Kubernetes configuration object (in Kubernetes mode). For example, the following configuration object changes the sample rate to 1 (every span is sampled), and sends trace using OTEL protocol to the OTEL server at localhost:4317
 
@@ -66,7 +66,7 @@ turns on tracing for the sidecar.
 
 | Environment Variable | Description |
 |----------------------|-------------|
-| `OTEL_EXPORTER_OTLP_ENDPOINT` | Sets the Open Telemetry (OTEL) server address, turns on tracing |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | Sets the Open Telemetry (OTEL) server hostname and optionally port, turns on tracing |
 | `OTEL_EXPORTER_OTLP_INSECURE` | Sets the connection to the endpoint as unencrypted (true/false) |
 | `OTEL_EXPORTER_OTLP_PROTOCOL` | Transport protocol (`grpc`, `http/protobuf`, `http/json`) |
 

daprdocs/content/en/operations/support/support-release-policy.md

@@ -45,6 +45,7 @@ The table below shows the versions of Dapr releases that have been tested togeth
 
 | Release date | Runtime     | CLI  | SDKs  | Dashboard  | Status | Release notes |
 |--------------------|:--------:|:--------|---------|---------|---------|------------|
+| May 21st 2024 | 1.13.3</br>  | 1.13.0 | Java 1.11.0 </br>Go 1.10.0 </br>PHP 1.2.0 </br>Python 1.13.0 </br>.NET 1.13.0 </br>JS 3.3.0 | 0.14.0 | Supported (current) | [v1.13.3 release notes](https://github.com/dapr/dapr/releases/tag/v1.13.3) |
 | April 3rd 2024 | 1.13.2</br>  | 1.13.0 | Java 1.11.0 </br>Go 1.10.0 </br>PHP 1.2.0 </br>Python 1.13.0 </br>.NET 1.13.0 </br>JS 3.3.0 | 0.14.0 | Supported (current) | [v1.13.2 release notes](https://github.com/dapr/dapr/releases/tag/v1.13.2) |
 | March 26th 2024 | 1.13.1</br>  | 1.13.0 | Java 1.11.0 </br>Go 1.10.0 </br>PHP 1.2.0 </br>Python 1.13.0 </br>.NET 1.13.0 </br>JS 3.3.0 | 0.14.0 | Supported (current) | [v1.13.1 release notes](https://github.com/dapr/dapr/releases/tag/v1.13.1) |
 | March 6th 2024 | 1.13.0</br>  | 1.13.0 | Java 1.11.0 </br>Go 1.10.0 </br>PHP 1.2.0 </br>Python 1.13.0 </br>.NET 1.13.0 </br>JS 3.3.0 | 0.14.0 | Supported (current) | [v1.13.0 release notes](https://github.com/dapr/dapr/releases/tag/v1.13.0) |
@@ -136,6 +137,7 @@ General guidance on upgrading can be found for [self hosted mode]({{< ref self-h
 | 1.11.0                   |                   N/A |                   1.11.4 |
 | 1.12.0                   |                   N/A |                   1.12.4 |
 | 1.13.0                   |                   N/A |                   1.13.2 |
+| 1.13.0                   |                   N/A |                   1.13.3 |
 
 ## Upgrade on Hosting platforms