Merge branch 'v1.13' into bulk-retrieval-deserialization

daprdocs/content/en/concepts/components-concept.md

@@ -52,6 +52,14 @@ For example:
 
 For more information read [Pluggable components overview]({{< ref "pluggable-components-overview" >}})
 
+## Hot Reloading
+
+With the [`HotReload` feature enabled]({{< ref "support-preview-features.md" >}}), components are able to be "hot reloaded" at runtime.
+This means that you can update component configuration without restarting the Dapr runtime.
+Component reloading occurs when a component resource is created, updated, or deleted, either in the Kubernetes API or in self-hosted mode when a file is changed in the `resources` directory.
+When a component is updated, the component is first closed, and then reinitialized using the new configuration.
+The component is unavailable for a short period of time during reload and reinitialization.
+
 ## Available component types
 
 The following are the component types provided by Dapr:

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

@@ -253,7 +253,7 @@ async function start() {
         }
     });
     await server.binding.receive('checkout', async (orderId) => console.log(`Received Message: ${JSON.stringify(orderId)}`));
-    await server.startServer();
+    await server.start();
 }
 
 ```
@@ -292,4 +292,4 @@ Event delivery guarantees are controlled by the binding implementation. Dependin
 - [Bindings building block]({{< ref bindings >}})
 - [Bindings API]({{< ref bindings_api.md >}})
 - [Components concept]({{< ref components-concept.md >}})
-- [Supported bindings]({{< ref supported-bindings >}})
+- [Supported bindings]({{< ref supported-bindings >}})

daprdocs/content/en/developing-applications/debugging/debug-k8s/debug-daprd.md

@@ -11,7 +11,7 @@ description: "How to debug the Dapr sidecar (daprd) on your Kubernetes cluster"
 
 Sometimes it is necessary to understand what's going on in the Dapr sidecar (daprd), which runs as a sidecar next to your application, especially when you diagnose your Dapr application and wonder if there's something wrong in Dapr itself. Additionally, you may be developing a new feature for Dapr on Kubernetes and want to debug your code.
 
-his guide will cover how to use built-in Dapr debugging to debug the Dapr sidecar in your Kubernetes pods.
+This guide covers how to use built-in Dapr debugging to debug the Dapr sidecar in your Kubernetes pods. To learn how to view logs and troubleshoot Dapr in Kubernetes, see the [Configure and view Dapr logs guide]({{< ref "logs-troubleshooting.md#logs-in-kubernetes-mode" >}})
 
 ## Pre-requisites
 
@@ -87,6 +87,62 @@ Forwarding from [::1]:40000 -> 40000
 
 All done. Now you can point to port 40000 and start a remote debug session to daprd from your favorite IDE.
 
+## Commonly used `kubectl` commands
+
+Use the following common `kubectl` commands when debugging daprd and applications running on Kubernetes.
+
+Get all pods, events, and services: 
+
+```bash
+kubectl get all
+kubectl get all --n <namespace>
+kubectl get all --all-namespaces
+```
+
+Get each specifically:
+
+```bash
+kubectl get pods
+```
+
+```bash
+kubectl get events --n <namespace>
+kubectl get events --sort-by=.metadata.creationTimestamp --n <namespace>
+```
+
+```bash
+kubectl get services
+```
+
+Check logs:
+
+```bash
+kubectl logs <podId> daprd
+kubectl logs <podId> <myAppContainerName>
+kuebctl logs <deploymentId> daprd
+kubectl logs <deploymentId> <myAppContainerName>
+```
+
+```bash
+kubectl describe pod <podId>
+kubectl describe deploy <deployId>
+kubectl describe replicaset <replicasetId>
+```
+
+Restart a pod by running the following command: 
+
+```bash
+kubectl delete pod <podId>
+```
+
+This causes the `replicaset` controller to restart the pod after the delete.
+
+## Watch the demo
+
+See the presentation on troubleshooting Dapr on Kubernetes in the [Dapr Community Call #36](https://youtu.be/pniLPRbuLD8?si=bGid7oYSp9cThtiI&t=838). 
+
+<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/pniLPRbuLD8?si=bGid7oYSp9cThtiI&amp;start=838" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
+
 ## Related links
 
 - [Overview of Dapr on Kubernetes]({{< ref kubernetes-overview >}})

daprdocs/content/en/developing-applications/debugging/debugging-docker-compose.md

@@ -0,0 +1,81 @@
+---
+type: docs
+title: "Debugging Dapr Apps running in Docker Compose"
+linkTitle: "Debugging Docker Compose"
+weight: 300
+description: "Debug Dapr apps locally which are part of a Docker Compose deployment"
+---
+
+The goal of this article is to demonstrate a way to debug one or more daprised applications (via your IDE, locally) while remaining integrated with the other applications that have deployed in the docker compose environment.
+
+Let's take the minimal example of a docker compose file which contains just two services :
+- `nodeapp` - your app
+- `nodeapp-dapr` - the dapr sidecar process to your `nodeapp` service
+
+#### compose.yml
+```yaml
+services:
+  nodeapp:
+    build: ./node
+    ports:
+      - "50001:50001"
+    networks:
+      - hello-dapr
+  nodeapp-dapr:
+    image: "daprio/daprd:edge"
+    command: [
+      "./daprd",
+     "--app-id", "nodeapp",
+     "--app-port", "3000",
+     "--resources-path", "./components"
+     ]
+    volumes:
+        - "./components/:/components"
+    depends_on:
+      - nodeapp
+    network_mode: "service:nodeapp"
+networks:
+  hello-dapr
+```
+
+When you run this docker file with `docker compose -f compose.yml up` this will deploy to Docker and run as normal.
+
+But how do we debug the `nodeapp` while still integrated to the running dapr sidecar process, and anything else that you may have deployed via the Docker compose file? 
+
+Lets start by introducing a *second* docker compose file called `compose.debug.yml`. This second compose file will augment with the first compose file when the `up` command is ran.
+
+#### compose.debug.yml
+```yaml
+services:
+  nodeapp: # Isolate the nodeapp by removing its ports and taking it off the network
+    ports: !reset []
+    networks: !reset
+      - ""
+  nodeapp-dapr:
+    command: ["./daprd",
+     "--app-id", "nodeapp",
+     "--app-port", "8080", # This must match the port that your app is exposed on when debugging in the IDE
+     "--resources-path", "./components",
+     "--app-channel-address", "host.docker.internal"] # Make the sidecar look on the host for the App Channel
+    network_mode: !reset "" # Reset the network_mode...
+    networks: # ... so that the sidecar can go into the normal network
+      - hello-dapr
+    ports:
+      - "3500:3500" # Expose the HTTP port to the host
+      - "50001:50001" # Expose the GRPC port to the host (Dapr Worfklows depends upon the GRPC channel)
+
+```
+
+Next, ensure that your `nodeapp` is running/debugging in your IDE of choice, and is exposed on the same port that you specifed above in the `compose.debug.yml` - In the example above this is set to port `8080`.
+
+Next, stop any existing compose sessions you may have started, and run the following command to run both docker compose files combined together :
+
+`docker compose -f compose.yml -f compose.debug.yml up`
+
+You should now find that the dapr sidecar and your debugging app will have bi-directional communication with each other as if they were running together as normal in the Docker compose environment.
+
+**Note** : It's important to highlight that the `nodeapp` service in the docker compose environment is actually still running, however it has been removed from the docker network so it is effectively orphaned as nothing can communicate to it.
+
+**Demo** : Watch this video on how to debug local Dapr apps with Docker Compose
+
+<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/nWatANwaAik?start=1738" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

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

@@ -60,6 +60,8 @@ With the following command, simultaneously run the following services alongside
 ```bash
 dapr run -f .
 ```
+> **Note**: Since Python3.exe is not defined in Windows, you may need to change  `python3` to `python` in the  [`dapr.yaml`]({{< ref "#dapryaml-multi-app-run-template-file" >}}) file before running `dapr run -f .`
+
 
 **Expected output**
 

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

@@ -57,6 +57,7 @@ With the following command, simultaneously run the following services alongside
 ```bash
 dapr run -f .
 ```
+> **Note**: Since Python3.exe is not defined in Windows, you may need to change  `python3` to `python` in the  [`dapr.yaml`]({{< ref "#dapryaml-multi-app-run-template-file" >}}) file before running `dapr run -f .`
 
 **Expected output**
 

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

@@ -51,8 +51,9 @@ cd state_management/python/sdk/order-processor
 Run the `order-processor` service alongside a Dapr sidecar using [Multi-App Run]({{< ref multi-app-dapr-run >}}).
 
 ```bash
-dapr run -f
+dapr run -f .
 ```
+> **Note**: Since Python3.exe is not defined in Windows, you may need to change  `python3` to `python` in the  [`dapr.yaml`]({{< ref "#dapryaml-multi-app-run-template-file" >}}) file before running `dapr run -f .`
 
 The `order-processor` service writes, reads, and deletes an `orderId` key/value pair to the `statestore` instance [defined in the `statestore.yaml` component]({{< ref "#statestoreyaml-component-file" >}}). As soon as the service starts, it performs a loop.
 
@@ -173,7 +174,7 @@ cd state_management/javascript/sdk/order-processor
 Run the `order-processor` service alongside a Dapr sidecar.
 
 ```bash
-dapr run -f
+dapr run -f .
 ```
 
 The `order-processor` service writes, reads, and deletes an `orderId` key/value pair to the `statestore` instance [defined in the `statestore.yaml` component]({{< ref "#statestoreyaml-component-file" >}}). As soon as the service starts, it performs a loop.
@@ -299,7 +300,7 @@ cd state_management/csharp/sdk/order-processor
 Run the `order-processor` service alongside a Dapr sidecar.
 
 ```bash
-dapr run -f
+dapr run -f .
 ```
 
 The `order-processor` service writes, reads, and deletes an `orderId` key/value pair to the `statestore` instance [defined in the `statestore.yaml` component]({{< ref "#statestoreyaml-component-file" >}}). As soon as the service starts, it performs a loop.
@@ -423,10 +424,16 @@ In a terminal window, navigate to the `order-processor` directory.
 cd state_management/java/sdk/order-processor
 ```
 
+Install the dependencies:
+
+```bash
+mvn clean install
+```
+
 Run the `order-processor` service alongside a Dapr sidecar.
 
 ```bash
-dapr run -f
+dapr run -f .
 ```
 
 The `order-processor` service writes, reads, and deletes an `orderId` key/value pair to the `statestore` instance [defined in the `statestore.yaml` component]({{< ref "#statestoreyaml-component-file" >}}). As soon as the service starts, it performs a loop.
@@ -553,7 +560,7 @@ cd state_management/go/sdk/order-processor
 Run the `order-processor` service alongside a Dapr sidecar.
 
 ```bash
-dapr run -f
+dapr run -f .
 ```
 
 The `order-processor` service writes, reads, and deletes an `orderId` key/value pair to the `statestore` instance [defined in the `statestore.yaml` component]({{< ref "#statestoreyaml-component-file" >}}). As soon as the service starts, it performs a loop.

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

@@ -6,18 +6,27 @@ weight: 300
 description: "Updating deployed components used by applications"
 ---
 
-When making an update to an existing deployed component used by an application, Dapr does not update the component automatically. The Dapr sidecar needs to be restarted in order to pick up the latest version of the component. How this done depends on the hosting environment.
+When making an update to an existing deployed component used by an application, Dapr does not update the component automatically unless the `HotReload` feature gate is enabled.
+The Dapr sidecar needs to be restarted in order to pick up the latest version of the component.
+How this is done depends on the hosting environment.
+
+{{% alert title="Note" color="primary" %}}
+Dapr can be made to "hot reload" components, where updates are picked up automatically without needing a restart.
+This is enabled by via the [`HotReload` feature gate]({{< ref "support-preview-features.md" >}}).
+All component types are supported for hot reloading.
+This feature is currently in preview.
+{{% /alert %}}
 
 ## Kubernetes
 
 When running in Kubernetes, the process of updating a component involves two steps:
 
-1. Applying the new component YAML to the desired namespace
-2. Performing a [rollout restart operation](https://kubernetes.io/docs/reference/kubectl/cheatsheet/#updating-resources) on your deployments to pick up the latest component
+1. Apply the new component YAML to the desired namespace
+1. Unless the [`HotReload` feature gate is enabled]({{< ref "support-preview-features.md" >}}), perform a [rollout restart operation](https://kubernetes.io/docs/reference/kubectl/cheatsheet/#updating-resources) on your deployments to pick up the latest component
 
 ## Self Hosted
 
-When running in Self Hosted mode, the process of updating a component involves a single step of stopping the `daprd` process and starting it again to pick up the latest component.
+Unless the [`HotReload` feature gate is enabled]({{< ref "support-preview-features.md" >}}), the process of updating a component involves a single step of stopping and restarting the `daprd` process to pick up the latest component.
 
 ## Further reading
 - [Components concept]({{< ref components-concept.md >}})

daprdocs/content/en/operations/support/support-preview-features.md

@@ -22,4 +22,4 @@ For CLI there is no explicit opt-in, just the version that this was first made a
 | **Service invocation for non-Dapr endpoints** | Allow the invocation of non-Dapr endpoints by Dapr using the [Service invocation API]({{< ref service_invocation_api.md >}}). Read ["How-To: Invoke Non-Dapr Endpoints using HTTP"]({{< ref howto-invoke-non-dapr-endpoints.md >}}) for more information. | N/A | [Service invocation API]({{< ref service_invocation_api.md >}}) | v1.11  |
 | **Actor State TTL** | Allow actors to save records to state stores with Time To Live (TTL) set to automatically clean up old data. In its current implementation, actor state with TTL may not be reflected correctly by clients, read [Actor State Transactions]({{< ref actors_api.md >}}) for more information. | `ActorStateTTL` | [Actor State Transactions]({{< ref actors_api.md >}}) | v1.11  |
 | **Transactional Outbox** | Allows state operations for inserts and updates to be published to a configured pub/sub topic using a single transaction across the state store and the pub/sub | N/A | [Transactional Outbox Feature]({{< ref howto-outbox.md >}}) | v1.12  |
-
+| **Component Hot Reloading** | Allows for Dapr-loaded components to be "hot reloaded". A component spec is reloaded when it is created/updated/deleted in Kubernetes or on file when running in self-hosted mode.| `HotReload`| [Hot Reloading]({{< ref components-concept.md >}}) | v1.13  |

daprdocs/content/en/operations/troubleshooting/logs-troubleshooting.md

@@ -73,6 +73,8 @@ dapr run node myapp.js
 
 ## Logs in Kubernetes mode
 
+> [Learn how to debug `daprd` on Kubernetes.]({{< ref "debug-daprd.md" >}}) 
+
 You can set the log level individually for every sidecar by providing the following annotation in your pod spec template:
 
 ```yml