The Dapr CLI allows you to setup Dapr on your local dev machine or on a Kubernetes cluster, provides debugging support, launches and manages Dapr instances.
On default, during initialization the Dapr CLI will install the Dapr binaries as well as setup a developer environment to help you get started easily with Dapr. This environment uses Docker containers, therefore Docker needs to be installed. If you prefer to run Dapr without this environment and no dependency on Docker, after installation of the CLI make sure to follow the instructions to initialize Dapr using slim init.
Note, if you are a new user, it is strongly recommended to install Docker and use the regular init command.
- Install Docker
Note: On Windows, Docker must be running in Linux Containers mode
Windows
Install the latest windows Dapr CLI to $Env:SystemDrive\dapr
and add this directory to User PATH environment variable. Use -DaprRoot [path]
to change the default installation directory
powershell -Command "iwr -useb https://raw.githubusercontent.com/dapr/cli/master/install/install.ps1 | iex"
Linux
Install the latest linux Dapr CLI to /usr/local/bin
wget -q https://raw.githubusercontent.com/dapr/cli/master/install/install.sh -O - | /bin/bash
MacOS
Install the latest darwin Dapr CLI to /usr/local/bin
curl -fsSL https://raw.githubusercontent.com/dapr/cli/master/install/install.sh | /bin/bash
Each release of Dapr CLI includes various OSes and architectures. These binary versions can be manually downloaded and installed.
- Download the Dapr CLI
- Unpack it (e.g. dapr_linux_amd64.tar.gz, dapr_windows_amd64.zip)
- 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.
- For Linux/MacOS -
Install windows Dapr CLI using MSI package.
- Download the MSI Package
- Run
dapr.msi
to install Dapr CLI on your system
NOTE: The default installation directory is set to
$Env:SystemDrive\dapr
and can be modified at the time of installation.
In self-hosted mode, dapr can be initialized using the CLI with the placement, scheduler, redis, and zipkin containers enabled by default(recommended) or without them which also does not require docker to be available in the environment.
(Prerequisite: Docker is available in the environment - recommended)
Use the init command to initialize Dapr. On init, multiple default configuration files and containers are installed along with the dapr runtime binary. Dapr runtime binary is installed under $HOME/.dapr/bin for Mac, Linux and %USERPROFILE%.dapr\bin for Windows.
dapr init
For Linux users, if you run your docker cmds with sudo, you need to use "sudo dapr init"
Output should look like so:
⌛ Making the jump to hyperspace...
âś… Downloaded binaries and completed components set up.
ℹ️ daprd binary has been installed to $HOME/.dapr/bin.
ℹ️ dapr_placement container is running.
ℹ️ dapr_scheduler container is running.
ℹ️ dapr_redis container is running.
ℹ️ dapr_zipkin container is running.
ℹ️ Use `docker ps` to check running containers.
âś… Success! Dapr is up and running. To get started, go here: https://aka.ms/dapr-getting-started
Note: To see that Dapr has been installed successfully, from a command prompt run the
docker ps
command and check that thedaprio/dapr:latest
,dapr_redis
anddapr_zipkin
container images are all running.
This step creates the following defaults:
- components folder which is later used during
dapr run
unless the--resources-path
(--components-path
is deprecated and will be removed in future releases) option is provided. For Linux/MacOS, the default components folder path is$HOME/.dapr/components
and for Windows it is%USERPROFILE%\.dapr\components
. - component files in the components folder called
pubsub.yaml
andstatestore.yaml
. - default config file
$HOME/.dapr/config.yaml
for Linux/MacOS or for Windows at%USERPROFILE%\.dapr\config.yaml
to enable tracing ondapr init
call. Can be overridden with the--config
flag ondapr run
.
Alternatively to the above, to have the CLI not install any default configuration files or run Docker containers, use the --slim
flag with the init command. Only Dapr binaries will be installed.
dapr init --slim
Output should look like so:
⌛ Making the jump to hyperspace...
âś… Downloaded binaries and completed components set up.
ℹ️ daprd binary has been installed to $HOME/.dapr/bin.
ℹ️ placement binary has been installed.
ℹ️ scheduler binary has been installed.
âś… Success! Dapr is up and running. To get started, go here: https://aka.ms/dapr-getting-started
Note: When initializing Dapr with the
--slim
flag only the Dapr runtime, placement, and scheduler service binaries are installed. An empty default components folder is created with no default configuration files. Duringdapr run
user should use--resources-path
(--components-path
is deprecated and will be removed in future releases) to point to a components directory with custom configurations files or alternatively place these files in the default directory. For Linux/MacOS, the default components directory path is$HOME/.dapr/components
and for Windows it is%USERPROFILE%\.dapr\components
.
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.
# Install v1.0.0 runtime
dapr init --runtime-version 1.0.0
# Check the versions of CLI and runtime
dapr --version
CLI version: v1.0.0
Runtime version: v1.0.0
You can install Dapr Runtime using mariner images using the --image-variant
flag.
# Installing Dapr with Mariner images
dapr init --image-variant mariner
You can install Dapr runtime by pulling docker images from a given private registry uri by using --image-registry
flag.
Note: This command expects that images have been hosted like example.io//dapr/dapr:, example.io//dapr/3rdparty/redis:, example.io//dapr/3rdparty/zipkin:
# Example of pulling images from a private registry.
dapr init --image-registry example.io/<username>
You can install Dapr runtime in airgap (offline) environment using a pre-downloaded installer bundle. You need to download the archived bundle for your OS beforehand (e.g., daprbundle_linux_amd64.tar.gz,) and unpack it. Thereafter use the local Dapr CLI binary in the bundle with --from-dir
flag in the init command to point to the extracted bundle location to initialize Dapr.
Move to the bundle directory and run the following command:
# Initializing dapr in airgap environment
./dapr init --from-dir .
For windows, use
.\dapr.exe
to point to the local Dapr CLI binary.
If you are not running the above command from the bundle directory, provide the full path to bundle directory as input. For example, assuming the bundle directory path is $HOME/daprbundle, run
$HOME/daprbundle/dapr init --from-dir $HOME/daprbundle
to have the same behavior.
Note: Dapr Installer bundle just contains the placement and scheduler containers apart from the binaries and so
zipkin
andredis
are not enabled by default. You can pull the images locally either from network or private registry and run as follows:
docker run --name "dapr_zipkin" --restart always -d -p 9411:9411 openzipkin/zipkin
docker run --name "dapr_redis" --restart always -d -p 6379:6379 redis
Alternatively to the above, you can also have slim installation as well to install dapr without running any Docker containers in airgap mode.
./dapr init --slim --from-dir .
You can install the Dapr runtime to a specific Docker network in order to isolate it from the local machine (e.g. to use Dapr from within a Docker container).
# Create Docker network
docker network create dapr-network
# Install Dapr to the network
dapr init --network dapr-network
Note: When installed to a specific Docker network, you will need to add the
--placement-host-address
arguments todapr run
commands run in any containers within that network. The format of--placement-host-address
argument is either<hostname>
or<hostname>:<port>
. If the port is omitted, the default port6050
for Windows and50005
for Linux/MacOS applies.
Note: When installed to a specific Docker network, you will need to add the
--scheduler-host-address
arguments todapr run
commands run in any containers within that network. The format of--scheduler-host-address
argument is either<hostname>
or<hostname>:<port>
. If the port is omitted, the default port6060
for Windows and50006
for Linux/MacOS applies.
You can install the Dapr runtime using a specific container runtime
environment such as Docker or Podman by passing along the
--container-runtime
argument:
# Install Dapr with Podman
$ dapr init --container-runtime podman
Note: The default container runtime is Docker.
To install the Dapr CLI in a dev container or GitHub Codespace, add the following to your devcontainer.json
file:
"features": {
"ghcr.io/dapr/cli/dapr-cli:0": {}
}
Restart your dev container or GitHub Codespace and run dapr init
to initialize Dapr.
For more details, see the docs for dev containers with Visual Studio Code and GitHub Codespaces.
Uninstalling will remove daprd binary along with the placement and scheduler containers (if installed with Docker or the placement and scheduler binaries if not).
dapr uninstall
For Linux users, if you run your docker cmds with sudo, you need to use "sudo dapr uninstall" to remove the containers.
The command above won't remove the redis or zipkin containers by default in case you were using it for other purposes. It will also not remove the default dapr folder that was created on dapr init
. To remove all the containers (placement, scheduler, redis, zipkin) and also the default dapr folder created on init run:
dapr uninstall --all
The above command can also be run when Dapr has been installed in a non-docker environment, it will only remove the installed binaries and the default dapr folder in that case.
NB: The
dapr uninstall
command will always try to remove the placement and scheduler binaries/services and will throw an error is not able to.
You should always run a dapr uninstall
before running another dapr init
.
If previously installed to a specific Docker network, Dapr can be uninstalled with the --network
argument:
dapr uninstall --network dapr-network
You can uninstall Dapr from a specific container runtime
environment by passing along the --container-runtime
argument:
# Uninstall Dapr from Podman container runtime
$ dapr uninstall --container-runtime podman
The init command will install Dapr to a Kubernetes cluster. For more advanced use cases, use our Helm Chart.
Note: The default namespace is dapr-system. The installation will appear under the name dapr
for Helm
dapr init -k
Output should look like as follows:
⌛ Making the jump to hyperspace...
ℹ️ Note: To install Dapr using Helm, see here: https://docs.dapr.io/getting-started/install-dapr/#install-with-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
All available Helm Chart values can be set by using the --set
flag:
dapr init -k --set global.tag=1.0.0 --set dapr_operator.logLevel=error
dapr init -k -n my-namespace
dapr init -k --enable-ha=true
dapr init -k --enable-mtls=false
dapr init -k --wait --timeout 600
To remove Dapr from your Kubernetes cluster, use the uninstall
command with --kubernetes
flag or the -k
shorthand.
dapr uninstall -k
The default timeout is 300s/5m and can be overridden using the --timeout
flag.
dapr uninstall -k --timeout 600
To remove all Dapr Custom Resource Definitions:
dapr uninstall -k --all
Warning: this will remove any components, subscriptions or configurations that are applied in the cluster at the time of deletion.
To perform a zero downtime upgrade of the Dapr control plane:
dapr upgrade -k --runtime-version=1.0.0
The example above shows how to upgrade from your current version to version 1.0.0
.
Note: dapr upgrade
will retry up to 5 times upon failure
All available Helm Chart values can be set by using the --set
flag:
dapr upgrade -k --runtime-version=1.0.0 --set global.tag=my-tag --set dapr_operator.logLevel=error
Note: do not use the dapr upgrade
command if you're upgrading from 0.x versions of Dapr
export DAPR_HELM_REPO_URL="https://helmchart-repo.xxx.xxx/dapr/dapr" export DAPR_HELM_REPO_USERNAME="username_xxx" export DAPR_HELM_REPO_PASSWORD="passwd_xxx"
Setting the above parameters will allow dapr init -k
to install Dapr images from the configured Helm repository.
The Dapr CLI lets you debug easily by launching both Dapr and your app. Logs from both the Dapr Runtime and your app will be displayed in real time!
Example of launching Dapr with a node app:
dapr run --app-id nodeapp node app.js
Example of launching Dapr with a node app listening on port 3000:
dapr run --app-id nodeapp --app-port 3000 node app.js
Example of launching Dapr on HTTP port 6000:
dapr run --app-id nodeapp --app-port 3000 --dapr-http-port 6000 node app.js
Example of launching Dapr on gRPC port 50002:
dapr run --app-id nodeapp --app-port 3000 --dapr-grpc-port 50002 node app.js
Example of launching Dapr within a specific Docker network:
dapr init --network dapr-network
dapr run --app-id nodeapp --placement-host-address dapr_placement node app.js
Note: When in a specific Docker network, the Redis, Zipkin and placement and scheduler service containers are given specific network aliases,
dapr_redis
,dapr_zipkin
,dapr_placement
, anddapr_scheduler
, respectively. The default configuration files reflect the network alias rather thanlocalhost
when a docker network is specified.
If your app uses gRPC instead of HTTP to receive Dapr events, run the CLI with the following command:
dapr run --app-id nodeapp --app-protocol grpc --app-port 6000 node app.js
The example above assumed your app port is 6000.
To use pub-sub with your app, make sure that your app has a POST
HTTP endpoint with some name, say myevent
.
This sample assumes your app is listening on port 3000.
Launch Dapr and your app:
dapr run --app-id nodeapp --app-port 3000 node app.js
Publish a message:
The --pubsub
parameter takes in the name of the pub/sub. The default name of the pub/sub configed by the CLI is "pubsub".
Publish a message:
- Linux/Mac
dapr publish --publish-app-id nodeapp --pubsub pubsub --topic myevent --data '{ "name": "yoda" }'
- Windows
dapr publish --publish-app-id nodeapp --pubsub pubsub --topic myevent --data "{ \"name\": \"yoda\" }"
To test your endpoints with Dapr, simply expose any HTTP endpoint.
For this sample, we'll assume a node app listening on port 3000 with a /mymethod
endpoint.
Launch Dapr and your app:
dapr run --app-id nodeapp --app-port 3000 node app.js
Note: To choose a non-default components folder, use the --resources-path(--components-path is deprecated) option.
Invoke your app:
dapr invoke --app-id nodeapp --method mymethod
Specify a verb:
By default, Dapr will use the POST
verb. If your app uses Dapr for gRPC, you should use POST
.
dapr invoke --app-id nodeapp --method mymethod --verb GET
To list all Dapr instances running on your machine:
dapr list
To list all Dapr instances running in a Kubernetes cluster:
dapr list --kubernetes
To list all Dapr instances but return output as JSON or YAML (e.g. for consumption by other tools):
dapr list --output json
dapr list --output yaml
Check Dapr's system services (control plane) health status in a Kubernetes cluster:
dapr status --kubernetes
To check if Mutual TLS is enabled in your Kubernetes cluster:
dapr mtls --kubernetes
To export the root cert, issuer cert and issuer key created by Dapr from a Kubernetes cluster to a local path:
dapr mtls export
This will save the certs to the working directory.
To specify a custom directory:
dapr mtls export -o certs
dapr mtls expiry
This can be used when upgrading to a newer version of Dapr, as it's recommended to carry over the existing certs for a zero downtime upgrade.
Renew certificate by generating new root and issuer certificates
dapr mtls renew-certificate -k --valid-until <no of days> --restart
Use existing private root.key to generate new root and issuer certificates
dapr mtls renew-certificate -k --private-key myprivatekey.key --valid-until <no of days>
Use user provided ca.crt, issuer.crt and issuer.key
dapr mtls renew-certificate -k --ca-root-certificate <ca.crt> --issuer-private-key <issuer.key> --issuer-public-certificate <issuer.crt> --restart
dapr mtls renew-certificate -h
To list all Dapr components on Kubernetes:
dapr components --kubernetes --all-namespaces
To list Dapr components in target-namespace
namespace on Kubernetes:
dapr components --kubernetes --namespace target-namespace
To use a custom path for component definitions
dapr run --resources-path [custom path]
> Note: --components-path flag is deprecated. It will continue to work until it is removed completely.
To list all Dapr configurations on Kubernetes:
dapr configurations --kubernetes --all-namespaces
To list Dapr configurations in target-namespace
namespace on Kubernetes:
dapr configurations --kubernetes --namespace target-namespace
Use dapr list
to get a list of all running instances.
To stop a Dapr app on your machine:
dapr stop myAppID
You can also stop multiple Dapr apps
dapr stop myAppID1 myAppID2
In order to enable profiling, use the enable-profiling
flag:
dapr run --app-id nodeapp --app-port 3000 node app.js --enable-profiling
Dapr will automatically assign a profile port for you.
If you want to manually assign a profiling port, use the profile-port
flag:
dapr run --app-id nodeapp --app-port 3000 node app.js --enable-profiling --profile-port 7777
To change the metrics server port used by Dapr, set the metrics-port
flag:
dapr run --app-id nodeapp --app-port 3000 node app.js --metrics-port 5040
In order to set the Dapr runtime log verbosity level, use the log-level
flag:
dapr run --app-id nodeapp --app-port 3000 node app.js --log-level debug
This sets the Dapr log level to debug
.
The default is info
.
If your app is listening on https
or has a gRPC TLS configuration enabled, use the following app-ssl
flag:
dapr run --app-id nodeapp --app-port 3000 node app.js --app-ssl
This will have Dapr invoke the app over an insecure SSL channel.
The default is false.
You can run Dapr's sidecar only (daprd
) by omitting the application's command in the end:
dapr run --app-id myapp --dapr-http-port 3005 --dapr-grpc-port 50001
To generate shell completion scripts:
dapr completion
In order to enable Unix domain socket to connect Dapr API server, use the --unix-domain-socket
flag:
dapr run --app-id nodeapp --unix-domain-socket node app.js
Dapr will automatically create a Unix domain socket to connect Dapr API server.
If you want to invoke your app, also use this flag:
dapr invoke --app-id nodeapp --unix-domain-socket --method mymethod
In order to set the Dapr runtime to log API calls with INFO
log verbosity, use the enable-api-logging
flag:
dapr run --app-id nodeapp --app-port 3000 node app.js enable-api-logging
The default is false
.
For more details, please run the command and check the examples to apply to your shell.
To add or modify dapr annotations on an existing Kubernetes manifest, use the dapr annotate
command:
dapr annotate [flags] mydeployment.yaml
This will add the dapr.io/enabled
and the dapr.io/app-id
annotations. The dapr app id will be genereated using the format <namespace>-<kind>-<name>
where the values are taken from the existing Kubernetes object metadata.
NOTE: The annotate command currently only supports annotating Kubernetes manifests. You must provide the
-k
flag to target Kubernetes.
To provide your own dapr app id, provide the flag --app-id
.
All dapr annotations are available to set if a value is provided for the appropriate flag on the dapr annotate
command.
You can also provide the Kubernetes manifest via stdin:
kubectl get deploy mydeploy -o yaml | dapr annotate -k - | kubectl apply -f -
Or you can provide the Kubernetes manifest via a URL:
dapr annotate -k --log-level debug https://raw.githubusercontent.com/dapr/quickstarts/master/tutorials/hello-kubernetes/deploy/node.yaml | kubectl apply -f -
If the input contains multiple manifests then the command will search for the first appropriate one to apply the annotations. If you'd rather it applied to a specific manifest then you can provide the --resource
flag with the value set to the name of the object you'd like to apply the annotations to. If you have a conflict between namespaces you can also provide the namespace via the --namespace
flag to isolate the manifest you wish to target.
If you want to annotate multiple manifests, you can chain together the dapr annotate
commands with each applying the annotation to a specific manifest.
kubectl get deploy -o yaml | dapr annotate -k -r nodeapp --log-level debug - | dapr annotate -k --log-level debug -r pythonapp - | kubectl apply -f -
See the Reference Guide for more information about individual Dapr commands.
See the Development Guide to get started with building and developing.
See the Release Guide for complete release process for Dapr CLI.
Please refer to our Dapr Community Code of Conduct