Replace all deprecated cli, daprd options and k8s annotations (#737)

pruthvidhodda · web-flow · commit 643cb41fb0d3 · 2020-08-20T09:59:45.000-07:00
diff --git a/best-practices/troubleshooting/common_issues.md b/best-practices/troubleshooting/common_issues.md
@@ -28,8 +28,8 @@ spec:
         app: node
       annotations:
         <b>dapr.io/enabled: "true"</b>
-        <b>dapr.io/id: "nodeapp"</b>
-        <b>dapr.io/port: "3000"</b>
+        <b>dapr.io/app-id: "nodeapp"</b>
+        <b>dapr.io/app-port: "3000"</b>
     spec:
       containers:
       - name: node
@@ -152,13 +152,13 @@ Look at the Dapr API reference [here](../../reference/api/README.md) and make su
 ### I don't see any incoming events or calls from other services
 
 Have you specified the port your app is listening on?
-In Kubernetes, make sure the `dapr.io/port` annotation is specified:
+In Kubernetes, make sure the `dapr.io/app-port` annotation is specified:
 
 <pre>
 annotations:
     dapr.io/enabled: "true"
-    dapr.io/id: "nodeapp"
-    <b>dapr.io/port: "3000"</b>
+    dapr.io/app-id: "nodeapp"
+    <b>dapr.io/app-port: "3000"</b>
 </pre>
 
 If using Dapr Standalone and the Dapr CLI, make sure you pass the `--app-port` flag to the `dapr run` command.
diff --git a/best-practices/troubleshooting/profiling_debugging.md b/best-practices/troubleshooting/profiling_debugging.md
@@ -16,8 +16,8 @@ To enable profiling in Kubernetes, simply add the following annotation to your D
 <pre>
 annotations:
     dapr.io/enabled: "true"
-    dapr.io/id: "rust-app"
-    <b>dapr.io/profiling: "true"</b>
+    dapr.io/app-id: "rust-app"
+    <b>dapr.io/enable-profiling: "true"</b>
 </pre>
 
 ### Standalone
diff --git a/concepts/configuration/README.md b/concepts/configuration/README.md
@@ -32,8 +32,8 @@ A Dapr sidecar can apply a specific configuration by using a ```dapr.io/config``
 ```yml
   annotations:
     dapr.io/enabled: "true"
-    dapr.io/id: "nodeapp"
-    dapr.io/port: "3000"
+    dapr.io/app-id: "nodeapp"
+    dapr.io/app-port: "3000"
     dapr.io/config: "myappconfig"
 ```
 Note: There are more [Kubernetes annotations](../../howto/configure-k8s/README.md) available to configure the Dapr sidecar on activation by sidecar Injector system service.
diff --git a/concepts/hosting/README.md b/concepts/hosting/README.md
@@ -32,8 +32,8 @@ Deploying and running a Dapr enabled application into your Kubernetes cluster is
 ```yml
   annotations:
     dapr.io/enabled: "true"
-    dapr.io/id: "nodeapp"
-    dapr.io/port: "3000"
+    dapr.io/app-id: "nodeapp"
+    dapr.io/app-port: "3000"
     dapr.io/config: "tracing"
 ```
 You can see some examples [here](https://github.com/dapr/quickstarts/tree/master/hello-kubernetes/deploy) in the Kubernetes getting started sample.
diff --git a/concepts/observability/logs.md b/concepts/observability/logs.md
@@ -73,7 +73,7 @@ spec:
         app: python
       annotations:
         dapr.io/enabled: "true"
-        dapr.io/id: "pythonapp"
+        dapr.io/app-id: "pythonapp"
         dapr.io/log-as-json: "true"
 ...
 ```
diff --git a/concepts/publish-subscribe-messaging/README.md b/concepts/publish-subscribe-messaging/README.md
@@ -19,7 +19,7 @@ The burden of dealing with concepts like consumer groups and multiple instances
 
 ### App ID
 
-Dapr has the concept of an `id`. This is specified in Kubernetes using the `dapr.io/id` annotation and with the `app-id` flag using the Dapr CLI. Dapr requires an ID to be assigned to every application.
+Dapr has the concept of an `id`. This is specified in Kubernetes using the `dapr.io/app-id` annotation and with the `app-id` flag using the Dapr CLI. Dapr requires an ID to be assigned to every application.
 
 When multiple instances of the same application ID subscribe to a topic, Dapr will make sure to deliver the message to only one instance. If two different applications with different IDs subscribe to a topic, at least one instance in each application receives a copy of the same message.
 
diff --git a/howto/configure-k8s/README.md b/howto/configure-k8s/README.md
@@ -8,14 +8,14 @@ The following table shows all the supported pod Spec annotations supported by Da
 | Annotation          | Description 
 | ----------------------------------- | -------------- |
 | `dapr.io/enabled`   | Setting this paramater to `true` injects the Dapr sidecar into the pod
-| `dapr.io/port`   | This parameter tells Dapr which port your application is listening on
-| `dapr.io/id`   | The unique ID of the application. Used for service discovery, state encapsulation and the pub/sub consumer ID
+| `dapr.io/app-port`   | This parameter tells Dapr which port your application is listening on
+| `dapr.io/app-id`   | The unique ID of the application. Used for service discovery, state encapsulation and the pub/sub consumer ID
 | `dapr.io/log-level`   | Sets the log level for the Dapr sidecar. Allowed values are `debug`, `info`, `warn`, `error`. Default is `info`
 | `dapr.io/config`   | Tells Dapr which Configuration CRD to use
 | `dapr.io/log-as-json`   | Setting this parameter to `true` outputs logs in JSON format. Default is `false`
-| `dapr.io/profiling`   | Setting this paramater to `true` starts the Dapr profiling server on port `7777`. Default is `false`
-| `dapr.io/protocol`   | Tells Dapr which protocol your application is using. Valid options are `http` and `grpc`. Default is `http`
-| `dapr.io/max-concurrency`   | Limit the concurrency of your application. A valid value is any number larger than `0`
+| `dapr.io/enable-profiling`   | Setting this paramater to `true` starts the Dapr profiling server on port `7777`. Default is `false`
+| `dapr.io/app-protocol`   | Tells Dapr which protocol your application is using. Valid options are `http` and `grpc`. Default is `http`
+| `dapr.io/app-max-concurrency`   | Limit the concurrency of your application. A valid value is any number larger than `0`
 | `dapr.io/metrics-port`   | Sets the port for the sidecar metrics server. Default is `9090`
 | `dapr.io/sidecar-cpu-limit`   | Maximum amount of CPU that the Dapr sidecar can use. See valid values [here](https://kubernetes.io/docs/tasks/administer-cluster/manage-resources/quota-memory-cpu-namespace/). By default this is not set
 | `dapr.io/sidecar-memory-limit`   | Maximum amount of Memory that the Dapr sidecar can use. See valid values [here](https://kubernetes.io/docs/tasks/administer-cluster/manage-resources/quota-memory-cpu-namespace/). By default this is not set
diff --git a/howto/control-concurrency/README.md b/howto/control-concurrency/README.md
@@ -5,14 +5,14 @@ Using Dapr, you can control how many requests and events will invoke your applic
 
 *Note that this rate limiting is guaranteed for every event that's coming from Dapr, meaning Pub/Sub events, direct invocation from other services, bindings events etc. Dapr can't enforce the concurrency policy on requests that are coming to your app externally.*
 
-## Setting max-concurrency
+## Setting app-max-concurrency
 
 Without using Dapr, a developer would need to create some sort of a semaphore in the application and take care of acquiring and releasing it.
 Using Dapr, there are no code changes needed to an app.
 
-### Setting max-concurrency in Kubernetes
+### Setting app-max-concurrency in Kubernetes
 
-To set max-concurrency in Kubernetes, add the following annotation to your pod:
+To set app-max-concurrency in Kubernetes, add the following annotation to your pod:
 
 ```yaml
 apiVersion: apps/v1
@@ -33,18 +33,18 @@ spec:
         app: nodesubscriber
       annotations:
         dapr.io/enabled: "true"
-        dapr.io/id: "nodesubscriber"
-        dapr.io/port: "3000"
-        <b>dapr.io/max-concurrency: "1"</b>
+        dapr.io/app-id: "nodesubscriber"
+        dapr.io/app-port: "3000"
+        <b>dapr.io/app-max-concurrency: "1"</b>
 ...
 ```
 
-### Setting max-concurrency using the Dapr CLI
+### Setting app-max-concurrency using the Dapr CLI
 
-To set max-concurrency with the Dapr CLI for running on your local dev machine, add the `max-concurrency` flag:
+To set app-max-concurrency with the Dapr CLI for running on your local dev machine, add the `app-max-concurrency` flag:
 
 ```bash
-dapr run --max-concurrency 1 --app-port 5000 python ./app.py
+dapr run --app-max-concurrency 1 --app-port 5000 python ./app.py
 ```
 
 The above examples will effectively turn your app into a single concurrent service.
diff --git a/howto/create-grpc-app/README.md b/howto/create-grpc-app/README.md
@@ -35,20 +35,20 @@ spec:
         app: myapp
       annotations:
         dapr.io/enabled: "true"
-        dapr.io/id: "myapp"
-        dapr.io/protocol: "grpc"
-        dapr.io/port: "5005"
+        dapr.io/app-id: "myapp"
+        dapr.io/app-protocol: "grpc"
+        dapr.io/app-port: "5005"
 ...
 ```
 
 This tells Dapr to communicate with your app via gRPC over port `5005`.
 
 ### Standalone
 
-When running in standalone mode, use the `--protocol` flag to tell Dapr to use gRPC to talk to the app:
+When running in standalone mode, use the `--app-protocol` flag to tell Dapr to use gRPC to talk to the app:
 
 ```bash
-dapr run --protocol grpc --app-port 5005 -- node app.js
+dapr run --app-protocol grpc --app-port 5005 node app.js
 ```
 
 ## Invoking Dapr - Go example
@@ -213,10 +213,10 @@ This creates a gRPC server for your app on port 4000.
 To run locally, use the Dapr CLI:
 
 ```
-dapr run --app-id goapp --app-port 4000 --protocol grpc -- go run main.go
+dapr run --app-id goapp --app-port 4000 --app-protocol grpc go run main.go
 ```
 
-On Kubernetes, set the required `dapr.io/protocol: "grpc"` and `dapr.io/port: "4000` annotations in your pod spec template as mentioned above.
+On Kubernetes, set the required `dapr.io/app-protocol: "grpc"` and `dapr.io/app-port: "4000` annotations in your pod spec template as mentioned above.
 
 ## Other languages
 
diff --git a/howto/diagnose-with-tracing/azure-monitor.md b/howto/diagnose-with-tracing/azure-monitor.md
@@ -149,8 +149,8 @@ spec:
       ...
       annotations:
         dapr.io/enabled: "true"
-        dapr.io/id: "calculator-front-end"
-        dapr.io/port: "8080"
+        dapr.io/app-id: "calculator-front-end"
+        dapr.io/app-port: "8080"
         dapr.io/config: "tracing"
 ```
 
diff --git a/howto/intellij-debugging-daprd/README.md b/howto/intellij-debugging-daprd/README.md
@@ -3,7 +3,7 @@
 When developing Dapr applications, you typically use the Dapr CLI to start your 'Daprized' service similar to this:
 
 ```bash
-dapr run --app-id nodeapp --app-port 3000 --port 3500 app.js
+dapr run --app-id nodeapp --app-port 3000 --dapr-http-port 3500 app.js
 ```
 
 This uses the default components yaml files (created on `dapr init`) 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 cli without invoking an app.
@@ -27,10 +27,10 @@ Create or edit the file in `$HOME/.IdeaIC2019.3/config/tools/External\ Tools.xml
   <!-- 1. Each tool has its own app-id, so create one per application to be debugged -->
   <tool name="dapr for DemoService in examples" description="Dapr sidecar" showInMainMenu="false" showInEditor="false" showInProject="false" showInSearchPopup="false" disabled="false" useConsole="true" showConsoleOnStdOut="true" showConsoleOnStdErr="true" synchronizeAfterRun="true">
     <exec>
-      <!-- 2. For Linux or MacOS use: /usr/bin/dapr -->
-      <option name="COMMAND" value="c:\dapr\dapr.exe" />
-      <!-- 3. Choose app, http and grpc ports that do not conflict with other Dapr command entries. -->
-      <option name="PARAMETERS" value="run --app-id demoservice --app-port 3000 --dapr-http-port 3005 --dapr-grpc-port 52000" />
+      <!-- 2. For Linux or MacOS use: /usr/local/bin/daprd -->
+      <option name="COMMAND" value="C:\dapr\daprd.exe" />
+      <!-- 3. Choose app, http and grpc ports that do not conflict with other daprd command entries (placement address should not change). -->
+      <option name="PARAMETERS" value="-app-id demoservice -app-port 3000 -dapr-http-port 3005 -dapr-grpc-port 52000 -placement-host-address localhost:50005" />
       <!-- 4. Use the folder where the `components` folder is located -->
       <option name="WORKING_DIRECTORY" value="C:/Code/dapr/java-sdk/examples" />
     </exec>
diff --git a/howto/invoke-and-discover-services/README.md b/howto/invoke-and-discover-services/README.md
@@ -26,7 +26,7 @@ dapr run --app-id cart --app-port 5000 python app.py
 
 ### Setup an ID using Kubernetes
 
-In Kubernetes, set the `dapr.io/id` annotation on your pod:
+In Kubernetes, set the `dapr.io/app-id` annotation on your pod:
 
 ```yaml
 apiVersion: apps/v1
@@ -47,8 +47,8 @@ spec:
         app: python-app
       annotations:
         dapr.io/enabled: "true"
-        dapr.io/id: "cart"
-        dapr.io/port: "5000"
+        dapr.io/app-id: "cart"
+        dapr.io/app-port: "5000"
 ...
 ```
 
diff --git a/howto/run-with-docker/README.md b/howto/run-with-docker/README.md
@@ -112,7 +112,7 @@ services:
       "./daprd",
      "-app-id", "nodeapp",
      "-app-port", "3000",
-     "-placement-address", "placement:50006" # Dapr's placement service can be reach via the docker DNS entry
+     "-placement-host-address", "placement:50006" # Dapr's placement service can be reach via the docker DNS entry
      ]
     volumes:
         - "./components/:/components" # Mount our components folder for the runtime to use
diff --git a/howto/setup-monitoring-tools/setup-azure-monitor.md b/howto/setup-monitoring-tools/setup-azure-monitor.md
@@ -88,7 +88,7 @@ spec:
         app: python
       annotations:
         dapr.io/enabled: "true"
-        dapr.io/id: "pythonapp"
+        dapr.io/app-id: "pythonapp"
         dapr.io/log-as-json: "true"
         prometheus.io/scrape: "true"
         prometheus.io/port: "9090"
diff --git a/howto/setup-monitoring-tools/setup-fluentd-es-kibana.md b/howto/setup-monitoring-tools/setup-fluentd-es-kibana.md
@@ -129,7 +129,7 @@ spec:
         app: python
       annotations:
         dapr.io/enabled: "true"
-        dapr.io/id: "pythonapp"
+        dapr.io/app-id: "pythonapp"
         dapr.io/log-as-json: "true"
 ...
 ```
diff --git a/howto/setup-pub-sub-message-broker/setup-azure-eventhubs.md b/howto/setup-pub-sub-message-broker/setup-azure-eventhubs.md
@@ -35,7 +35,7 @@ The above example uses secrets as plain strings. It is recommended to use a secr
 ## Create consumer groups for each subscriber
 
 For every Dapr app that wants to subscribe to events, create an Event Hubs consumer group with the name of the `dapr id`.
-For example, a Dapr app running on Kubernetes with `dapr.io/id: "myapp"` will need an Event Hubs consumer group named `myapp`.
+For example, a Dapr app running on Kubernetes with `dapr.io/app-id: "myapp"` will need an Event Hubs consumer group named `myapp`.
 
 ## Apply the configuration
 
diff --git a/howto/setup-secret-store/azure-keyvault-managed-identity.md b/howto/setup-secret-store/azure-keyvault-managed-identity.md
@@ -228,8 +228,8 @@ In Kubernetes mode, you store the certificate for the service principal into the
             aadpodidbinding: [you managed identity selector]
           annotations:
             dapr.io/enabled: "true"
-            dapr.io/id: "nodeapp"
-            dapr.io/port: "3000"
+            dapr.io/app-id: "nodeapp"
+            dapr.io/app-port: "3000"
         spec:
           containers:
             - name: node
diff --git a/howto/setup-secret-store/azure-keyvault.md b/howto/setup-secret-store/azure-keyvault.md
@@ -165,7 +165,7 @@ You can check that `secretstores.azure.keyvault` component is loaded and redis s
 Here is the log when you run [HelloWorld sample](https://github.com/dapr/quickstarts/tree/master/hello-world) with Azure Key Vault secret store.
 
 ```bash
-$ dapr run --app-id mynode --app-port 3000 --port 3500 node app.js
+$ dapr run --app-id mynode --app-port 3000 --dapr-http-port 3500 node app.js
 
 ℹ️  Starting Dapr with id mynode on port 3500
 ✅  You're up and running! Both Dapr and your app logs will appear here.
diff --git a/howto/setup-secret-store/local-secret-store.md b/howto/setup-secret-store/local-secret-store.md
@@ -100,7 +100,7 @@ You can check that `secretstores.local.localsecretstore` component is loaded and
 Here is the log when you run [HelloWorld sample](https://github.com/dapr/quickstarts/tree/master/hello-world) with Local Secret secret store.
 
 ```bash
-$ dapr run --app-id mynode --app-port 3000 --port 3500 node app.js
+$ dapr run --app-id mynode --app-port 3000 --dapr-http-port 3500 node app.js
 
 ℹ️  Starting Dapr with id mynode on port 3500
 ✅  You're up and running! Both Dapr and your app logs will appear here.
diff --git a/howto/setup-state-store/setup-cloudstate.md b/howto/setup-state-store/setup-cloudstate.md
@@ -74,7 +74,7 @@ spec:
     metadata:
       annotations:
         dapr.io/enabled: "true"
-        dapr.io/id: "testapp"
+        dapr.io/app-id: "testapp"
       labels:
         app: test-dapr-app
     spec:
diff --git a/howto/vscode-debugging-daprd/README.md b/howto/vscode-debugging-daprd/README.md
@@ -15,7 +15,7 @@ If instead of using the Dapr VS Code extension you wish to configure a project t
 When developing Dapr applications, you typically use the dapr cli to start your daprized service similar to this:
 
 ```bash
-dapr run --app-id nodeapp --app-port 3000 --port 3500 app.js
+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.
@@ -80,7 +80,7 @@ Let's take a quick look at the args that are being passed to the daprd command.
 * -app-port -- the port number that your application code is listening on
 * -dapr-http-port -- the http port for the dapr api
 * -dapr-grpc-port -- the grpc port for the dapr api
-* -placement-address -- the location of the placement service (this should be running in docker as it was created when you installed dapr and ran ```dapr init```)
+* -placement-host-address -- the location of the placement service (this should be running in docker as it was created when you installed dapr and ran ```dapr init```)
 
 >Note: You will need to ensure that you specify different http/grpc (-dapr-http-port and -dapr-grpc-port) ports for each daprd task that you create, otherwise you will run into port conflicts when you attempt to launch the second configuration.
 
@@ -112,7 +112,7 @@ Let's take a quick look at the args that are being passed to the daprd command.
                 "51000",
                 "-dapr-grpc-port",
                 "52000",
-                "-placement-address",
+                "-placement-host-address",
                 "localhost:50005"
             ],
             "isBackground": true,
@@ -143,7 +143,7 @@ Let's take a quick look at the args that are being passed to the daprd command.
                 "51001",
                 "-dapr-grpc-port",
                 "52001",
-                "-placement-address",
+                "-placement-host-address",
                 "localhost:50005"
             ],
             "isBackground": true,
diff --git a/reference/specs/bindings/eventgrid.md b/reference/specs/bindings/eventgrid.md
@@ -99,7 +99,7 @@ ngrok http -host-header=localhost 9000
 
 ```bash
 # Using default ports for .NET core web api and Dapr as an example
-dapr run --app-id dotnetwebapi --app-port 5000 --port 3500 dotnet run
+dapr run --app-id dotnetwebapi --app-port 5000 --dapr-http-port 3500 dotnet run
 ```
 
 ### Testing from Kubernetes cluster
@@ -112,8 +112,8 @@ To get started, first create `dapr-annotations.yaml` for Dapr annotations
 controller:
     podAnnotations:
       dapr.io/enabled: "true"
-      dapr.io/id: "nginx-ingress"
-      dapr.io/port: "80"
+      dapr.io/app-id: "nginx-ingress"
+      dapr.io/app-port: "80"
 ```
 
 Then install NGINX ingress controller to your Kubernetes cluster with Helm 3 using the annotations
@@ -194,8 +194,8 @@ spec:
         app: dotnetwebapi
       annotations:
         dapr.io/enabled: "true"
-        dapr.io/id: "dotnetwebapi"
-        dapr.io/port: "5000"
+        dapr.io/app-id: "dotnetwebapi"
+        dapr.io/app-port: "5000"
     spec:
       containers:
       - name: webapi
diff --git a/walkthroughs/daprrun.md b/walkthroughs/daprrun.md
