0 
0 In other articles I will write about the value of Dapr – as a personal assistant to any application that helps out with state, configuration and secrets, receiving inbound messages, publishing messages and invoking services and that supports microservice architectures through a network of closely collaborating personal assistants to all applications involved. I am quite enthusiastic about the potential of Dapr and I want to share that enthusiasm. For now, I want to prepare myself and my laptop for customizing Dapr. Dapr is an open source project. All code is available from GitHub – and it is all Go code. In order to customize – enhance, extend – the code, I need to set up a local environment that not only can run Dapr but also can edit and make the project.
I am starting out with Windows 10 and WSL 2 (Windows Subsystem for Linux). I have installed the Ubuntu 20.4 app from the Windows app store. Of course I am also running VS Code with the Go extension. A Git client is already present in this environment. Also the Make utility is already installed in Ubuntu. If you do need to install it – check these instructions.. I have also already installed the Dapr CLI and the Dapr Quickstarts. I have tested the setup by running the hello-world Daprized application.
In this article I will show the steps I took to prepare the environment for Dapr development. I will show at the end how I make a small silly change to the sources, make the project into a binary and run a Daprized application with my change in place. This gets me to a stage where I feel ready to make a more meaningful change – that I will discuss in a follow up article.
The steps discussed in this article:
- install Go (really upgrade that consists of remove and install)
- install GoLangCILint
- install Dapr source code
- make (lint, test) the Dapr binaries
- replace the installed daprd executable with the locally built file
- run a Daprized application
- make a change and do the make, lint, replace and run again to see the change take effect
Install Go (really upgrade that consists of remove and install)
Using this article: Install Go on Ubuntu – https://buildvirtual.net/how-to-upgrade-go-on-ubuntu/ – I quickly got the current version of Go removed and the latest version of Go installed.
Go get the URL for the latest release: https://go.dev/dl/
Download using wget and untar
Then move the extracted directory go to the /usr/local directory:
I tried to run go at this point, but I was too early. First, a small edit of .profile is in order: add the definition of environment variable GOPATH and add $GOPATH to the PATH environment variable.
Once the change is made to .profile and the change has been applied with source ~/,profile the environment is once again ready to run go, the latest version.
Install GoLangCILint
Not strictly necessary for purely local development but a good practice anyway and a requirement for any code I will submit to the Dapr project: installation and use of go linting using GoLangCILint. Installation is quite straightforward, following these instructions:
Install Dapr source code
Dapr sources are held in a few repositories: for the CLI, the Dashboard, the main “engine” and the components. At this point, I am interested in the main “engine” – the core executables that make up the heart of the Dapr runtime framework. The repository for this code is at: github.com/dapr/dapr. I clone this GitHub repo locally, in a new directory dapr-dev:
At a later moment, I will clone the components repository into this same directory and link the two.
I can check the sources on the command line but even more easily in VS Code. I have linked VS Code with WSL2 and I can simply type “code . ” to open the current directory tree in VS Code:
Make (lint, test) the Dapr binaries
With the tools set up and the source code cloned locally, I can now bake – as in build through make – the Dapr executables:
Navigate to the folder that contains the Makefile. The run “make build”:
Once the build is complete, new executables will have been created in directory /dapr-dev/dapr/dist/linux_amd64/release:
To make use of this fresh executable when a Daprized application is ran, I have to replace the installed daprd executable with the locally built file.
First back up the current daprd: cp ~/.dapr/bin/daprd ~/.dapr/bin/daprd.bak
Then copy the freshly baked executable to overwrite it: cp /home/lucas/dapr-dev/dapr/dist/linux_amd64/release/daprd ~/.dapr/bin
At this point the active daprd executable is in all likelihood exactly the same as before: same source code after all, but now locally produced. I will run a Daprized application – hello-world – to ensure that everything still works as expected and that my local setup and the build process are in working order.
I am using the Dapr hello-world quickstart for this, with a node application that handles HTTP requests and stores values in the Dapr provided statestore:
Then run the application – through dapr:
With two invoke actions – one to create an order and persist it to the statestore and the second to retrieve the order – I demonstrate that dapr is functioning as expected.
First execute this statement on the terninal command line in the quickstart directory (/quickstarts/hello-world/node) that contains the sample.json file:
dapr invoke –app-id nodeapp –method neworder –data-file sample.json
Then this next line to verify the effect:
dapr invoke –app-id nodeapp –method order –verb GET
Here are the logs from the application (plus Dapr) end of things:
Note: alternatively, we can directly inspect the statestore’s contents:
wget http://localhost:3500/v1.0/state/statestore/order
Make a change to the Dapr sources and do the make, lint, replace and run again to see the change take effect
To make sure I now truly have the power to change Dapr and see that change take effect, I make a small and fairly silly change to package main in the file main,.go. Note: this file will also be modified when new custom components are added.
Open the file, add a log line to write some message that I hope and expect to the see in the terminal when a daprized application is started:
Save the change, make the project, replace the binary as before
and run the daprized application as before. Dapr starts and my new pointless log message shows up. I am in business, ready to make real and meaningful changes.
Resources
Install Go on Ubuntu – https://buildvirtual.net/how-to-upgrade-go-on-ubuntu/
Download Go Releases – https://go.dev/dl/
Install Make on Ubuntu – https://linuxhint.com/install-make-ubuntu/
Install GoLangCILint – https://golangci-lint.run/usage/install/
Dapr Source Code Repo – https://github.com/dapr/dapr
Docs on installing Dapr CLI – https://docs.dapr.io/getting-started/install-dapr-cli/
Dapr Quickstarts GitHub Repo – https://github.com/dapr/quickstarts
Dapr Quickstart Hello World – https://github.com/dapr/quickstarts/tree/v1.5.0/hello-world
Install nodejs on Ubuntu 20.4 – https://www.digitalocean.com/community/tutorials/how-to-install-node-js-on-ubuntu-20-04
Dapr Docs: Setting up local Dapr development environment: https://github.com/dapr/dapr/blob/master/docs/development/setup-dapr-development-env.md
Dapr Docs: Custom Development and local build of Dapr: https://github.com/dapr/dapr/blob/master/docs/development/developing-dapr.md
Dapr Docs: Development of Custom Component – instructions (also on make build and replace) – https://github.com/dapr/components-contrib/blob/master/docs/developing-component.md
