Azure AD JavaScript authentication tutorial series (Part 1)

I have put together a video tutorial series that goes through step by step a full end to end solution that shows how to authenticate an Azure AD Web API application from JavaScript code using the adal.js library.

Now days I am finding myself designing my applications to use a web service layer to serve up data from data stores.  Providing REST API endpoints on top of your data gives alot of benefits when it comes to integrating your data across different client applications. JavaScript runs pretty much everywhere now and it’s the to go to language to build client side apps so accessing your REST endpoints from JavaScript is a really appealing solution and this is why pretty much everyone is doing JavaScript and REST now.

The JavaScript ecosystem today is massive with libraries to help you build pretty comprehensive applications. When I am building SharePoint Add-Ins I tend to expose the data using Web API and stick to using JavaScript in the application to render the data and build out the UI. Most if the time there is no need for server side code inside my client application.

Inevitably you will want to secure your web service layer at some point and if your are building on the Azure platform, then Azure AD is a great OAuth solution.

It is especially a good solution if you are building SharePoint Add-Ins in Office 365. When you are logged into your Office 365 SharePoint site you have already authenticated against your Azure AD and as long as you deploy your applications to the same Azure AD instance then you get automatically authenticated when accessing your Web API layer.

When building these apps I found that there was plenty of examples on authenticating from C# code but I found the examples lacking if I just wanted to use JavaScript to authenticate against my Web API.

The adal.js library comes in very handy here but I found all the examples were based around using it with Angular. Although Angular is a great framework for building client side apps I found most of the time it was overkill for what I wanted to do.  So these set of videos show how you might want to design and build a client side application and in this case a SharePoint Add-In that uses Azure AD authentication, Web API, JavaScript and TypeScript.

The general architecture looks like this.



The first video is up and it shows how to create a SQL Azure database, create a Web API layer and how to model and scaffold the data using Entity Framework.


Building Microservices

Book Review Building MicroservicesI haven’t done a book review in a while but I have just finished reading Building Microservices by Sam Newman and felt it deserved one.

Firstly I have to say I enjoyed reading this book from front to back. I found the chapters and subjects to be in depth enough to give a good understanding of the ideas but not too long to be overwhelming or tedious. I felt the book flowed from one chapter to another and kept me interested throughout.

I found this book to cover enough information to give some good ideas about designing and architecting systems using a microservice approach and gave good further reading links to follow up on any subjects that you may want to read more on.

The book starts off by giving an overview of what a microservice is and what it isn’t. It explains that a microservice should be small and focused on doing just one thing and doing it well. The book also does a good job of giving examples and also defining what a microservice shouldn’t be giving examples of stuff like shared databases and shared libraries which could introduce tight coupling to your systems.

The next subject is explaining the concept of the evolutionary architect and how architects should think of themselves as town planners instead of the traditional metaphor we take in comparing software architects to contruction architects and how we should think of service boundaries as zones like zoning in a town.

Bounded contexts get a mention and the book explains how we should model our service boundaries around existing business boundaries. It explains we should focus on loose coupling and high cohesion when designing our services.

Midway through the book it takes a turn into a more infrastructure focused ideas and explains the concepts of setting up your deployment environment using VM’s and containers. It touches on continuous deployments and continuous delivery ideas and explains how you might want to setup such an environment to facilitate your development cycles. It uses the ideas of fail fast with feedback and explains how monitoring of your whole environment will give you a higher degree of insight into the health of your system and the quality of your software.

There are lots of other concepts explained in the book and I find it does a good job of calling out good tools and libraries that can help in getting your whole microservice environment up and running.

Although a lot of the ideas explained in the book could be overkill for some smaller systems and im not sure microservices are the right approach in all scenarios. I definitely think when thinking about designing large scalable systems the microservice approach is definitely worth looking at. The good thing is the ideas explained in the book are not an all or nothing approach you can cherry pick the ideas and concepts that suit your system or environment.

All software developers and architects should check out this book if you have any dealing with designing and building services. I would definitely recommend it as a good read.

Paperback, 280 pages

Published February 20th 2015 by O’Reilly Media

ISBN: 1491950358 (ISBN13: 9781491950357)