trumhemcut / dapr-microservices

Leverage the power of Dapr to build microservices on AKS

dapr microservices

Leverage the power of Dapr to build microservices application

Get started

Step 1 - Pre-requisites

• Kubernetes, it's ok to use Kubernetes on Docker for Win/Mac or Minikube for development environment. Currently I've just tested on Docker for Win/Mac environment (with Kubernetes enabled). Minikube hasn't been tested yet!
• Helm 3.0, no more Tiller. But please add the repo before we can install:
• Dapr CLI, prefer latest version (e.g. 0.3.0)

Step 2 - Setup

First, initialize Dapr on Kubernetes so that it can inject sidecars to our applications:

$ dapr init --kubernetes

Next, clone the source code & install the SimplAds app via Helm:

$ git clone https://github.com/trumhemcut/dapr-microservices.git
$ cd dapr-microservices
$ helm dep up ./helm-chart
$ helm install simplads ./helm-chart

Step 3 - Change your host file

Since the SimplAds uses Traefik as its main ingress, and using hostnames as the main endpoints. Please add those following hostnames to your host files:

If you're using Mac, add the line below to this file /etc/hosts. If you're using Windows, add the line below to this file C:\Windows\System32\drivers\hosts

127.0.0.1   traefik.dapr.fun dashboard.dapr.fun web.dapr.fun zipkin.dapr.fun

Features

After finishing all above steps (it may takes several minutes), you can browse following Urls:

• Web App: https://web.dapr.fun
• Distrubuted tracing: https://zipkin.dapr.fun
• Traefik Ingress: https://traefik.dapr.fun
• Dapr Dashboard: https://dashboard.dapr.fun
• Dapr API endpoint: https://web.dapr.fun/dapr

Architecture

TODO

dapr-microservices's Issues

Using pulumi to build infrastructure on Azure

Using pulumi to create Azure resources

• Resource Group
• Storage
• Network
• AKS
• ACR
• Azure Service Bus
• CosmosDB

Dapr input output binding example

Enable Semver for Docker images

Consider using Lerna

Update readme.md

• Getting started
• How to upgrade dapr (download, install, upgrade, init)
  dapr init --runtime-version 0.3.0 --kubernetes
• How to upgrade helm2 to helm3
  Helm add repos (stable, incubators, ...)
  helm repo update
  https://github.com/openfaas/faas-netes/blob/master/chart/openfaas/README.md
  helm repo add openfaas https://openfaas.github.io/faas-netes/
• Update /etc/hosts with dapr.fun
• Autoscale with KEDA

Configure the return URL for web.dapr.fun on Azure

Bug when deploy to web.dapr.fun

Integrate Dapr dashboard

It's just released, so need to add it in :)
https://github.com/dapr/dashboard

Build graphql server as BFF layer

Move zipkin to subcharts

Currently Zipkin is deployed as a deployment of main Helm chart, but it shouldn't as we will enable building block such as Azure Monitor to be distributed tracing component. So it's just optional within sub-charts to be enabled in development environment only.

Kafka pubsub

As the resize image service finishes, it publish an message to Kafka to notify the result.

Currently Kafka pubsub hasn't been available yet and waiting for merge request. Will implement the feature when it's done.

More details here:
dapr/components-contrib#8

Setup TLS for Traefik ingress

Add OpenFaas

OpenFaas may be a good candidate for triggering function as a service. In this example, we will use OpenFaas to scale the image of advertisements.

Need to restart services after Kafka is done

Currently Dapr starts only once, so it's quite inconvenient if Kafka cluster is not up yet. In that case, Dapr will fail to connect to Kafka and it will break every activities later.

Discussion thread here: dapr/components-contrib#163

Workaround:

• Restart the Dapr sidecar after Kafka cluster is up.

Need to think how to solve that problem.

Optimize the size of Docker images

Currently alpine for NodeJS is optimized and alpine for Python is also optimized. But they're different Dockerfile. If we install Python in a usual way in alpine, it will increase size significantly. So we need to merge these two Dockerfile into one so that we can optimized image for Alpine.

See more here:

• Alpine 11 for Node LTS: 27.4MB
• Alpine 10 for Python 3.7: 31.28MB

Hopefully we can optimize base on those materials.

Create the helm chart for the app

Enable configmap for helm chart

Visualize the architecture in README.md

dapr distributed tracing

Follow here but it doesn't work for now.

https://github.com/RicardoNiepel/dapr-docs/blob/master/best-practices/troubleshooting/tracing.md

Will continue updating on this.

Build Kafka message bus

Build Kafka as a service bus so that we can enable pub/sub messaging for services. We also enable the option between Kafka / Azure Service later on.

Improve simplads

• Enable upload
• Serverless triggered after new ads uploaded
• Showing image after upload

Adding service mesh to the system

Consider both Linkderd2 & Istio. Fill the gap which dapr is not there to function.

Dapr state store

Mongodb retry while connecting failed

Setup ingress for K8S

Not sure service mesh is needed at this moment, so ingress may be enough. Ingress should work for both on-premises & AKS as well.

Dapr secret store management

secret should not be stored within configmap but here.

Add zipkin, mongodb as Helm dependencies

To be easily for end-user provisioning the environment, we will use Helm dependencies to create the dependent services such as zipkin / Jaeger, mongodb, ... to create Dev environment. For Azure environment, we will use Ansible / Terraform to create those services.

sorry. please delete this issue

Consider using Azure DevSpace

Add build & code coverage label

• Build Docker images & push to Docker Hub
• Adding testing to the app to see code coverage
• Adding the build label to the README.md
• Add language icon, reddit icon

Enable the security for the app

Enable login with Azure AD

Setup single sign-on with Azure AD.