DEV Community: Sumit Kharche

How to upload files into Azure Blog Storage using Azure functions in C#

Sumit Kharche — Mon, 11 Apr 2022 17:06:42 +0000

Introduction

In this article, we will discuss about Azure Storage and different types of storage services provided by azure. We will create a storage account from Azure portal and we will then create azure function to store the files into azure blob storage and finally we will deploy the same function to the Azure function app from Visual Studio.

If you are new to Azure Functions then check out the below articles,

What is Azure Storage Service

Whenever we create a application we have to first decide what storage we can use to store the data. Azure Storage provides solution to different storage solution problems. It provides scalable, available, durable storage for data in azure. Azure storage is set of different services such as Blobs, Files, queues, etc. We can interact with azure storage using different programming languages such .NET, JAVA, Golang, Javascript, etc. using the SDKs.

Different Azure Storage Service:

Azure Blob - also know as blobs which mainly used to store the binary/text data such as photos, videos, documents, etc.
Azure Tables - which is nothing but a NoSQL storage for schemaless structured data.
Azure Queue - it is used to store the messages which can be use to communicate with applications
Azure Files - it is managed file share service for cloud or on-premise using SMB/NFS protocol.
Azure Disks - It is a virtual hard disk (VHD) that is of two types: managed and unmanaged.

What is Azure Blob storage

Azure Blob storage is a storage service used to store schemaless structured data in the cloud. We can store data such as documents, pictures, videos, log files, backup files which don’t have fixed structure. Blob storage are similar to directory structure where we can create different containers to store the blobs.

There are 3 types of Blobs:

Block Blobs - which are used to store the text / binary data.
Append Blobs - nothing but block blobs which are optimize for append operation.
Page Blobs - which store random access files up to 8 TiB in size.

Create simple azure function using C# to upload files in Azure Blog Storage

Prerequisites:

Azure account (If you don't have an Azure subscription, create a free trial account)
Visual Studio 22 with Azure Development workload
Basic knowledge of C#

Create a Azure Storage resource using Azure Portal

Click on Create button and you can see the Create storage account page.

Azure has Resource Groups (RG) which acts as a container for your resources. So now we are going to create a Storage account resource. First we need to create Resource Group. If you have already created RG then you can use the same here. Under Resource group click on Create New button and give a unique RG name.

Give the unique name to storage account and select the region. Click on Next : Advanced button.

By default the “Enable blob public access” is checked which means that any anonymous user can access to blobs within the containers. So uncheck the option and click on Review + Create button

Wait for few sec to complete the validation and Review everything is added properly after that click on Create button.

Creating resources will take time so wait for deployment process to finish.

Our storage account is created successfully. Now click on Go to resource button to see the storage account.

Now next step is to create container to store our blobs. So in left section click on Containers and then click on + Container button. Give the proper name to container in which we are going to upload our files and click on Create button.

Next step is to create a Azure function which upload files into the “file-upload” container.

Create a HTTP trigger azure function using C# to upload files to blob storage

So open Visual Studio and Go to File -> New -> Project. Search "Azure Functions" in the search box and select the Azure function template and click on Next.

Give a name to the function project and click on Create.

Select the HTTP trigger template and set the Authorization level as Anonymous and click on Create.

That's it. We have created our first Azure function. By default the name of the function is Function1.cs so now change it to "FileUpload".

So for our application, we are creating HTTP Trigger function which takes file as input and uploads it into the Azure Blob. To connect with the Blob Storage container we need a connection string. So let's open the Azure Storage resource in portal ->Access Keys -> Click on Show Keys - > Copy the Key 1 Connection String.

Open the local.settings.json file in our function app and paste the connection string of our Azure Storage resource as value of “AzureWebJobsStorage” key. Also add another key called as “ContainerName” and paste the name of container we have created earlier.

{
    "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "<replace your blob storage connection key here>",
    "ContainerName": "file-upload", // Container name 
    "FUNCTIONS_WORKER_RUNTIME": "dotnet"
  }
}

To interact with Azure storage we have to first install the below NuGet package.

Now add the below code to upload a file into the container in our blob storage.

using Azure.Storage.Blobs;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Extensions.Logging;
using System;
using System.IO;
using System.Threading.Tasks;

namespace FileUploadFunction
{
    public static class FileUpload
    {
        [FunctionName("FileUpload")]
        public static async Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
            ILogger log)
        {
            string Connection = Environment.GetEnvironmentVariable("AzureWebJobsStorage");
            string containerName = Environment.GetEnvironmentVariable("ContainerName");
            Stream myBlob = new MemoryStream();

            var file = req.Form.Files["File"];
            myBlob = file.OpenReadStream();
            var blobClient = new BlobContainerClient(Connection, containerName);
            var blob = blobClient.GetBlobClient(file.FileName);
            await blob.UploadAsync(myBlob);

            return new OkObjectResult("file uploaded successfylly");
        }
    }
}

First we have stored the Blob Storage connection string and container name from configuration into local variables. After that we have read the file request by using key called “File” into variable and using OpenReadStream() function we have read the file into the steam. To interact with Blob storage we first have to create BlobContainerClient by passing connection string and container name. After creating client, we have to create BlobClient using GetBlobClient method by passing input file name.

Finally to upload file to container we have used UploadAsync method by passing steram. You can read more about this methods here.

Now run the FileUpload function.

For testing the function open postman and paste the about function URL i.e. http://localhost:7071/api/FileUpload
Now in our code we have read the file from form data so click on Body and select form-data then add key as “File” and for value select which file you want to upload and click on Send button.

Now if we open our “file-upload” container we can see the file which we uploaded.

Publish Azure function to Azure function app using Visual Studio

Create a function app using Azure portal

After that click on the " + Create" button to add a new function app. Fill out the basic details:

Now click on Review: Create button and review all the details and click on the Create button. Wait for a few minutes to create the resources.

Once deployment complete click on Go to resource button to see out new function app.

Publish the azure function into the function app

To deploy our function to Azure we need Azure Function App. Right Click on our solution and click on the Publish button.

As we are publishing into Azure then Select Azure and click on Next. Select target as "Azure Function App(Windows)" and click on Next. We can either select an already created function app or we can create a new Function app. Click on Finish button.

Click on Publish button to push our function to our Function App.

Once our app is successfully published on Azure, go to the Azure portal and search for our function app. Select Functions from the left sidebar to see our deployed function.

Configure the storage account connection string into Configuration setting of Function app

Now we have deployed our function into Function app so next step is to configure the settings. So click on Configuration. For this app we have to set value of Storage connection string and container name in configuration. So seach for "AzureWebJobsStorage" and click on Edit button and paste your storage connection string.

Click on "+ New application setting" and give name as "ContainerName" and Value as "file-upload".

Finally click on Save button to save changes.

Test publish app using postman

To ge the url of deployed function click on Functions -> Select File Upload function -> Click on Get Function Url -> Copy url and paste in postman.

Now as we test locally in form-data add a key "File" and select file you want to upload.

Now if we check container we can see the file uploaded into it.

Conclusion

In this article, we have discuss about Azure Storage and Azure blob storage. We have created a Azure Blob storage resource from Azure Portal. We created a new Azure function from Visual Studio which uploads the file to blob storage. Also, I demonstrated how to test and deploy the function from VS and test using Postman.

I really hope that you enjoyed this article, share it with friends, and please do not hesitate to send me your thoughts or comments. Stay tuned for more Azure Functions articles.

You can follow me on twitter @sumitkharche01 or LinkedIn Sumit Kharche

Happy Coding!!!

How to integrate Application Insights into Azure Functions

Sumit Kharche — Sun, 10 Apr 2022 09:42:50 +0000

Introduction

In this article, we are going to discuss about Application Insights and how to integrate Application Insight into the Azure Function app. We will also create a simple Azure function app and also logs data into application insights.

If you are new to Azure functions then first check the below articles:

In this article, we will cover the below topics,

What is Application Insights?
Enable Application Insight at the time of creating Function App
Integrate Application Insight into Existing Function App
Log data from Azure Functions into Application Insights

What is Application Insights?

When creating a Cloud application or on-prem application, monitoring always helps us to quickly analyze and debug any issue. Azure Monitor is a service provided by Azure to monitor, analyze, improve the availability and performance of your application.

According to Microsoft docs,
Application Insights, a feature of Azure Monitor, is an extensible Application Performance Management (APM) service for developers and DevOps professionals. Use it to monitor your live applications. It will automatically detect performance anomalies, and includes powerful analytics tools to help you diagnose issues and to understand what users actually do with your app.

Application insights collect telemetry data from connected apps and provides Live Metrics, Log Analytics, etc. Application insights have an instrumentation key which we need to configure into our function app i.e. APPINSIGHTS_INSTRUMENTATIONKEY and with this key app insights grab data from our app. We can integrate application insights into Azure function in multiple ways as below:

Prerequisites

Azure account (If you don't have an Azure subscription, create a free trial account)

Enable Application Insight at the time of creating Function App

When we create a function app and also create application insights along with that then the instrumentation key is already set up in application settings with the name as APPINSIGHTS_INSTRUMENTATIONKEY

After that click on the "Add" button to add a new function app. Fill out the basic details:

Once we filled out basic details, then click on the Next: Hosting button.

Once we filled out hosting details then click on the Next: Monitoring button.

So here we can enable the application insight for our function app. By default, it takes the same name as the function name but if you want to give a custom name then click on the "Create new" button and then enter the name for insight & also you can select a preferred location.

Now click on Review:Create button and review all the details and click on the Create button. Wait for a few minutes to create the resources.

Open function app -> click on Application Insight from the left pane. You will see that our app insight is now linked to the function app.

Open the application insight and you can verify the Instrumentation Key here.

Go to Configuration to see that Azure automatically added APPINSIGHTS_INSTRUMENTATIONKEY into our function app.

Integrate Application Insight into Existing Function App

If you have already created a function app and at that time you haven't enabled the Application Insight then you can either integrate the function app to existing app insight if you have any or create a new app insight resource and integrate it with your function app.

Click on the Create Resource button and search for Application Insight and click on the Create button.

Fill in all the details and click on the Review + create button. Wait for a few minutes to create the resources.

Now open your function app to which you want to link and click on Application Insights from the left sidebar. Click on the Turn on Application Insights button.

Now you can either create resources or select the existing app insight. Select the existing application insight resource to create in the above step. Finally, click on the Apply button.

That's it we have now integrated application insight into our function app.

Log data from Azure Functions into Application Insights

For the function app to send data to Application insight it requires the instrumentation key of the application insight resource. First, we will create a function app locally using Visual Studio and adding the instrumentation key into the local.settings.json file.

Open a visual studio and create a new function app. If you are not familiar with how to create it from Visual Studio then check my article here.

Go to your application insight resource and copy the instrumentation key

Open local.settings.json file & add a new setting called APPINSIGHTS_INSTRUMENTATIONKEY and paste the copied key from the 2nd step.

{  
    "IsEncrypted": false,  
    "Values": {  
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",  
        "FUNCTIONS_WORKER_RUNTIME": "dotnet",  
        "APPINSIGHTS_INSTRUMENTATIONKEY": "5916dc8e-7c17-4f59-ab1d-932ea1abac21" //<replace instrumentation key here>  
    }  
}

Run the app and hit the function URL. You can see the telemetry data into application insight.

Conclusion

In this article, we have discussed about Application Insights and also different ways to integrate application insights into the Azure function app. I really hope that you enjoy this article, share it with friends, and please do not hesitate to send me your thoughts or comments.

Stay tuned for more Azure Functions articles.

You can follow me on Twitter @sumitkharche01 and LinkedIn

Happy Coding!

How to Build a Blazing-Fast Astro Blog with Cosmic CMS

Sumit Kharche — Mon, 18 Oct 2021 17:19:30 +0000

In this tutorial, I'm going to show you how to create a simple Blog application using Astro, and Cosmic CMS. Without further ado, grab some coffee & let's build a cool app!

TL;DR

Prerequisites

You need to have installed the latest stable version of Node JS and NPM. You will have no problem following the tutorial if you have a basic understanding of:

HTML, CSS, and JavaScript
import and export syntax (ES6 modules)
concepts like components
the fetch API

Let's get started with our technology stack.

What is Astro?

Astro is nothing but a yet another new Static Site Generator (SSG) which means it produces a static pages as in output. Its a new framework for building a websites. Astro give you us flexibility to use any JavaScript framework/library. The big advantage of using astro is it ships 0% Javascript by default and it will load on demand it we need it.

Note: Astro is still an early beta state.

What about Cosmic?

Cosmic is a headless CMS that will enable us to build our application surprisingly quickly and deploy it to Netlifly in moments. Unlike traditional CMS, Cosmic offers us as the developers a lot of flexibility to develop this application how we please and take it to whatever hosting platform we wish. It is also very easy to store and retrieve data, which makes it perfect for building apps like this.

Creating Your Blog Bucket in Cosmic

To create a blog app we will require data. To manage and manipulate this data, we will be using the power of Cosmic buckets and objects. To get started:

Create a free account on Cosmic. If this is your first time using Cosmic, you'll see a short tutorial which will introduce some of the data types we'll be using - buckets, objects, and metafields.
Create a new empty bucket & name it coffee-blog. For each blog post, we will have three object types:

Title
Content
Image

So, go ahead and add these properties in your buckets along with some data for those objects. If you're having trouble with Buckets, Objects, or Metafields, go ahead and read the Getting Started page really quickly for some startup instructions, then come on back to
this article.

Now we have created our Cosmic CMS and its get time to create a Astro project and integrate Cosmic CMS into it.

Create a Astro application

To create Astro project, we have to first create a folder and navigate to it.

> mkdir astro-cosmic-app && cd astro-cosmic-app

Now run following command to install astro:

> npm init astro

After that select the template "Starter Kit (Generic)" as shown in below image:

After that select framework you would like to use so I will select Preact but you can select whichever you want as shown below:

Now wait for a minutes to finish the project creation.

After that install all the packages by running below command:

> npm install

To run the application execute below command:

> npm run dev

Now open http://localhost:3000/ and see the output:

So open the application into VS Code editor and check folder structure:

/public : Any static assets, like images, can be placed in the public/ directory
src/components: components are reusable piece of code. You put any Astro/React/Vue/Svelte/Preact components.
src/pages : this folder contains all the pages for your website which are .md or .astro files. Each page is exposed as a route based on its file name.

For this blog application we are using a Start Bootstarp Clean-blog template. Download the template from here.

After downloading, extract the files and copy the style.css file under /css folder of template into public folder in our project.

Also copy data of /assets from template into assets folder in our project.

Create a .env file

we are using .env file to stored the cosmic bucket and read key data. So install below package:

npm install --D dotenv

After that create a .env file in root level of project and add update with your details:

COSMIC_BUCKET_SLUG=<replace your bucket name>
COSMIC_READ_KEY=<replace your read key>

Create different components

So delete all the files in components folder. First we will create a component called 'BlogPostPreview.astro' which takes input as single post data and display it. So in components folder create a new component as 'BlogPostPreview.astro'

Create another components called "BaseHead.astro" which contains all metadata urls, links to external css/js files.

Create a component called "footer.astro" to display the footer in all pages.

Create a component called "Navigation.astro" to display the footer in all pages.

Display all the posts in landing page

First we will create a folder in src called lib and inside that create a file called 'config.js' which exports our env variables as belows:

Open a index.astro file and replace below code to display all the posts in landing page:

Now run the application using npm run dev and see the output in http://localhost:3000/.

Create another page inside pages folder called "about.astro" as below:

Click on About option in navigation bar to see the output:

Now we have to create a page which create separate static page for all our posts and when user clicks on single post it will display that page. To achieve that create a folder in pages called "posts" and inside that create a page called "[slug].astro" as belows:

Now run the app again and click on post to see the post details:

To build application in production mode you just need to run

> npm run build

Deploy it

We can now deploy our application on any hosting platform. I recommend deploying it on Netlify because it supports project structures like this and can quickly create deployments.
Checkout this article to deploy Astro app into Netlify.

Conclusion

In this article, I have demonstrated you how to create a blogging application using Astro and Cosmic. The Cosmic Community has a lot of examples on how to handle integration with email functions, download functions, and third-party platforms. If you're interested in building your own applications like this, get started by setting up your free account.

I really hope that you enjoyed this little app, and please do not hesitate to send me your thoughts or comments about what could I have done better.

If you have any comments or questions about building apps with
Cosmic, reach out to us on Twitter and join the conversation on Slack.

You can follow me on twitter @sumitkharche01 or LinkedIn

How To Create And Publish Azure Function From Visual Studio

Sumit Kharche — Sun, 17 Jan 2021 15:14:59 +0000

In the previous article, we discussed Azure functions and its features, and we also created an Azure function using Azure Portal. This is the second article in the Azure Functions series. In this article, we are going to discuss how we can simply create an Azure function using Visual Studio 19, and then we will deploy the same function to the Azure function app from Visual Studio.

It is recommended to create an Azure function from Visual Studio or VS code so that we can write code in a proper way. We can create a C# based Azure function from Visual Studio. In this article, let's create a simple HTTP based Azure Function.

Create Azure Function Using Visual Studio

Prerequisites

Visual Studio 19 with Azure Development workload
Azure account (If you don't have an Azure subscription, create a free trial account)

So open Visual Studio and Go to File -> New -> Project. Search "Azure Functions" in the search box and select the Azure function template and click on Next.

Give a name to the function project and click on Create.

Select the HTTP trigger template and set the Authorization level as Anonymous and click on Create.

To restrict the use of your function we can set the Authorization level. There are three types of levels available: 1] When we set levels as Function, then we have to provide a function key to call our function. 2] When we set as Admin, then you need to provide the master key. Both the function key and admin keys are found in the 'keys' management panel on the portal when your function is selected. 3] When we don't want any authorization then we can simply set level as Anonymous.

That's it. We have created our first Azure function. Open the Function1.cs file to see generated function.

Now to run the function just run the project. It will then start azure function cli to run the function.

The function is running on 'http://localhost:7071/api/Function1' after looking at the default function code written which accepts name from the query string or from the request body and appends the name to the Hello string and returns the output.

Deploy Azure Function using Visual Studio

To deploy our function to Azure we need Azure Function App. Right Click on our solution and click on the Publish button.

As we are publishing into Azure then Select Azure and click on Next.

Select target as "Azure Function App(Windows)" and click on Next. We can either select an already created function app or we can create a new Function app.

To create a new function app click on "Create a new Azure Function" button.

Name - Give a name for your function app
Subscription - Select your Azure subscription
Resource group - If you have already created RG then select that or click on 'new' button to create new RG
Plan Type - Select as Consumption
Location - Which is near to you
Azure Storage - If you have already created Storage Account(SA) then select that or click on the 'new' button to create a new SA.

And then finally click on the Create button. In this way, we can create a new Function App,

For this article, I am using an existing function which we have created in the previous article , and click on 'Finish' button.

Once our app is successfully published on Azure, go to the Azure portal and search for our function app. Select Functions from the left sidebar to see our deployed function.

To run the deployed function, click on the Function (in our case 'Function1') and then click on 'Get Function Url' button & finally copy the function URL.

Now to test the above function you can either use Postman or you can simply open the browser and paste the above URL. Pass name from query string to see the correct output.

That's it. We have created the Azure function from Visual Studio.

Conclusion

In this article, we have created a new Azure function from Visual Studio. Also, I demonstrated how to test and deploy the function from VS. I really hope that you enjoyed this article, share it with friends, and please do not hesitate to send me your thoughts or comments. Stay tuned for more Azure Functions articles.

You can follow me on twitter @sumitkharche01

Happy Coding!!

How To Easily Create Azure Functions Using Azure Portal

Sumit Kharche — Fri, 01 Jan 2021 09:26:46 +0000

Introduction

In this article, we are going to discuss Azure Functions and how you can easily create your first Azure function app using Azure Portal. This is the first article of my new series called Azure functions for beginners. So let's grab a cup of coffee and start learning.

What are Azure Functions?

Function As A Service (FaaS) is a category of cloud computing services that provides a platform in which you just need to think about writing business logic without thinking about the infrastructure required for its execution. Microsoft Azure provides two types of FaaS i.e Azure Logic Apps and Azure Functions. So in this article, we are going to discuss Azure functions only.

According to Microsoft docs:

Azure Functions allows you to run small pieces of code (called "functions") without worrying about application infrastructure. With Azure Functions, the cloud infrastructure provides all the up-to-date servers you need to keep your application running at scale.

Azure functions are event-driven which means that you can run your function code when some event is triggered from either existing on-premise service or any other Azure service or third party service. The azure function can be scaled and you need to pay only for the resources as you consume. Azure functions support lots of trigger points such as Http trigger, queue trigger, etc.

Some of the features of Azure functions are:

Azure Functions has great language support such as C#, Java, JavaScript, Python, and PowerShell.
Supports lots of triggers such as Service bus trigger, Http triggers, Queue trigger, etc.
We need to pay only for the resources as you consume i.e. Pay-per-use pricing model
We can install any of the libraries of your choice using NuGet or NPM
We can easily implement CI/CD using Github, Azure DevOps Service
We can also add integrated security on Http triggered based Azure functions using OAuth providers such as Azure Active Directory, Facebook, Google, Twitter, and Microsoft Account.

Below are several templates available for creating Azure function for performing different operations:

HTTP trigger
Blob storage trigger
Queue storage trigger
Service Bus Queue trigger
Service Bus Topic trigger
Timer trigger
Event Grid trigger
Event Hub trigger
Azure Cosmos DB trigger

You can get more information about Azure Functions here. So in this article, we are going to create an HTTP trigger-based Azure function using C# from Azure Portal. I will cover all other types of templates in my next article.

Create Azure Function using Azure Portal

Prerequisites

Azure account (If you don't have an Azure subscription, create a free trial account)

Step 1 - Creating a Function App

While creating a function you must have a function app to host the execution of your functions. You can group multiple functions into one function app which helps for deployment, scaling, easy for development & sharing of resources One function app can have multiple functions.

In the Search bar, search as function app and then select the Function app.

After that click on the "Add" button to add a new function app. Fill out the basic details:

Azure has Resource Groups(RG) which acts as a container for your resources. So now we are going to create a function app resource then first we need to create a Resource Group. If you have already created RG then you can use the same here. Under the Resource group click on the Create New button and give a unique RG name. I have selected an existing resource group.
You need to provide a unique name for your function app.
Select an appropriate run time for your app. Since we are going to create a function using C# so I have used .net core as runtime.
Select a version and region.

Once we filled out basic details, then click on the Next: Hosting button.

You need to provide a storage account while creating a function app. If you have already created a Storage account then you can use the same here. Or you can create new as well.
You have to select an operating system on which your app needs to be run.
Finally, you have to select a pricing plan for your app. You can see more details about Pricing here

Once we filled out hosting details then click on the Next: Monitoring button.

Application Insights, a feature of Azure Monitor, which is an extensible Application Performance Management (APM) service for developers and DevOps professionals. It is used to monitor your live applications. So if you want to integrate it in your function app the select Enable Application Insights flag to Yes.

Now click on Review:Create button and review all the details and click on the Create button. Wait for a few minutes to create the resources.

Once deployment complete click on Go to resource button to see out new function app.

Step 2 - Creating an HTTP triggered based Azure Function

Once you navigate to the Function app then click on Functions in the left panel and then click on the Add button.

Now select the HTTP trigger from the right panel. Now set Name and Authorization level for your new function.

Provide a name for your new function.
To restrict the use of your function we can set the Authorization level. There are three types of levels available: 1] When we set levels as Function, then we have to provide a function key to call our function. 2] When we set as Admin, then you need to provide the master key. Both the function key and admin keys are found in the 'keys' management panel on the portal when your function is selected. 3] When we don't want any authorization then we can simply set level as Anonymous.

Now click on the Create Function button. You then automatically redirect to function once the function is successfully created.

Click on the "Code + Test" button under the Developer section from the left sidebar panel.

So you can see the basic function code written which accepts name from the query string or from the request body and append to name to the Hello string and return the output.

Step 3 - Testing of Http triggered based Azure Function

Now click on the "Test/Run" button. For this default function, you can provide the input property name from either body or either from the query string.

Click on the Run button from the right panel. So you can see the output in the "Output" tab in the right panel.

This is all about running it from Portal. You can run this function from the browser or from the postman as well. To get the function URL click on the "Get Function URL" button.

Copy the URL.

Since our function accepts input property name from the query string then paste the URL into the browser and append ?name=AzFunction and hit the URL. You will see the output in the browser.

Since this is the HTTP Trigger function we can run it from postman as well. So paste the URL in postman and pass input and see the output.

That's it. You have created your Azure function using Azure Portal.

Conclusion

In this article, I have explained Azure Functions and how to create a function using the Azure Portal. Also, I demonstrated how to test function from portal, browser, and postman.

I really hope that you enjoyed this article, share it with friends, and please do not hesitate to send me your thoughts or comments. Stay tuned for more Azure Functions articles.

You can follow me on twitter @sumitkharche01

Happy Coding!!

Getting Started with Azure Service Bus Queues & ASP.NET Core - Part 2

Sumit Kharche — Thu, 17 Dec 2020 16:36:28 +0000

In this article, we are going to discuss about how to listen message from Azure Service Bus Queues. In the Part 1 we have discussed about Azure Service Bus Queues and how to send message into Queues using ASP.NET Core Web API. Please read part 1 before starting this article.

Getting Started with Azure Service Bus Queues & ASP.NET Core - Part 1

Sumit Kharche ・ Jul 17 '20

#azure #dotnet #serverless #beginners

Creating a simple application to send and receive messages from the queue.

Prerequisites

Azure account(If you don't have an Azure subscription, create a free trial account.)
Basic knowledge of Asp.net Core Web API

Overview of application

In Part 1, we have created a Azure Service Bus Queue from Azure Portal and also created ASP.NET Core Web API to push message into that queue:

In this article, we are going to create a Background Service to receive a message from Queue.

We will be using same service bus (order-test-asb) and queue (order-queue) that we created in Part 1 for this article.

Create Background service to listen the message from the Queue

Prerequisites

Visual Studio 19(if you are using .NET Core 3.1)
.NET Core 3.1 SDK installed

According to the docs:

In ASP.NET Core, background tasks can be implemented as hosted services. A hosted service is a class with background task logic that implements the IHostedService interface. This topic provides three hosted service examples:

Background task that runs on a timer.

Hosted service that activates a scoped service. The scoped service can use dependency injection (DI).

Queued background tasks that run sequentially.

Along with IHostedService we have BackgroundService class is first introduced in ASP.NET Core 3.0 and which is an abstract class that already implements the IHostedService Interface. BackgroundService also gives an abstract method ExecuteAsync() that returns a Task. So in this article we are inheriting our class with BackgroundService and implements an ExecuteAsync() method.

In part 1 we have created Order.Web.Api which is used to send a message into service bus. Now we are going to create a hosted background service which is continuously running and listening a service bus messages.

Go to solution and right click on it and select Add and select New Project.
Select Console App(.Net Core) and click on Next.
Give name to service and click on Create.
Create a new file called appsettings.json & add azure service connection string as below:

{
 "AppSettings": { 
   "QueueConnectionString": "<replace your RootManageSharedAccessKey here>",
   "QueueName": "order-queue"
 }
}

First we have to install Azure Service Bus NuGet package:
So this service needs to listen messages from Azure Service bus we can create this as Windows service. Along with that add below code to read to the Appsettings from appsettings.json. So create a class called AppSettings.cs as mentioned below:

    public class AppSettings
    {
        public string QueueConnectionString { get; set; }
        public string QueueName { get; set; }
    }

To configure our service first we need to install below packages:
After that add below code in program.cs to configure our service:

      class Program
    {
        static void Main(string[] args)
        {
            IServiceCollection serviceDescriptors = new ServiceCollection();
             Host.CreateDefaultBuilder(args)
                .UseWindowsService()
                .ConfigureHostConfiguration(configHost =>
                {
                    configHost.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true).Build();
                })
                .ConfigureServices((hostContext, services) =>
                {
                    var appSettingsConfig = hostContext.Configuration.GetSection(nameof(AppSettings));

                    services.AddOptions();
                    services.Configure<AppSettings>(appSettingsConfig);
                    services.AddSingleton(appSettingsConfig);
                }).Build().Run();
        }
    }

Now next part is to create Background service to listen messages. So create a class called CraeteOrderHandler.cs and inherits it with class BackgroundService. Now override the ExecuteAsync and StopAsync method of BackgroundService class.

using System;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.ServiceBus;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;

namespace OrderService
{
    public class CraeteOrderHandler : BackgroundService
    {
        private readonly AppSettings _appSettings;
        private IQueueClient _orderQueueClient;

        public CraeteOrderHandler(IOptions<AppSettings> appSettings)
        {
            _appSettings = appSettings?.Value ?? throw new ArgumentNullException(nameof(appSettings));
        }

        public async Task Handle(Message message, CancellationToken cancelToken)
        {
            if (message == null)
                throw new ArgumentNullException(nameof(message));

            var body = Encoding.UTF8.GetString(message.Body);
            Console.WriteLine($"Create Order Details are: {body}");
            await _orderQueueClient.CompleteAsync(message.SystemProperties.LockToken).ConfigureAwait(false);
        }
        public virtual Task HandleFailureMessage(ExceptionReceivedEventArgs exceptionReceivedEventArgs)
        {
            if (exceptionReceivedEventArgs == null)
                throw new ArgumentNullException(nameof(exceptionReceivedEventArgs));
            return Task.CompletedTask;
        }

        protected override Task ExecuteAsync(CancellationToken stoppingToken)
        {
            var messageHandlerOptions = new MessageHandlerOptions(HandleFailureMessage)
            {
                MaxConcurrentCalls = 5,
                AutoComplete = false,
                MaxAutoRenewDuration = TimeSpan.FromMinutes(10)
            };
            _orderQueueClient = new QueueClient(_appSettings.QueueConnectionString, _appSettings.QueueName);
            _orderQueueClient.RegisterMessageHandler(Handle, messageHandlerOptions);
            Console.WriteLine($"{nameof(CraeteOrderHandler)} service has started.");
            return Task.CompletedTask;
        }

        public override async Task StopAsync(CancellationToken stoppingToken)
        {
            Console.WriteLine($"{nameof(CraeteOrderHandler)} service has stopped.");
            await _orderQueueClient.CloseAsync().ConfigureAwait(false);
        }

    }
}

In ExecuteAsync() method calls when service is starts so we have setup a queue client object and also register Handle method to listen messages.
In StopAsync() method we close the queue client connection.
In Handle() method we just extract body from messasge which contains our actual data and just print it in console.
After that let's register our hosted service by adding below line into ConfigureServices method in Program.cs class.

services.AddHostedService<CraeteOrderHandler>();

So lets build and run the service to listen messages. Start order web api and send message to queue which our OrderService going to be listen.

Conclusion

In this article of Azure Service Bus Queue series, We have learned and implemented Background Service to listen message from azure service bus queue.

I really hope that you enjoyed this article, share it with friends and please do not hesitate to send me your thoughts or comments.

You can follow me on twitter @sumitkharche01 or LinkedIn

Happy Coding!!

How to Build a Blazing-Fast Blazor Blog with Cosmic

Sumit Kharche — Sun, 25 Oct 2020 10:44:57 +0000

In this tutorial, I'm going to show you how to create a simple but blazing fast blog using Blazor WebAssembly, Tailwind CSS, and Cosmic. Without further ado, grab some coffee & let's build a cool app!

TL;DR

Prerequisites

Installed the latest .NET Core SDK.
Install the Blazor project templates
Cosmic account
Basic knowledge of Blazor

Let's get started with our technology stack.

What is Blazor?

Blazor is a .NET framework developed and maintained by Microsoft. It's been picking up steam over the last couple of years, and recently attracted quite a bit of attention in Spring of 2020 with the launch of Blazor WebAssembly - which is what we'll be using today. If you want to build an interactive web application using C# then you should definitely check Blazor.

According to Blazor's docs:

Blazor is a free and open-source web framework that enables developers to create web apps using C# and HTML. It is being developed by Microsoft. Blazor lets you build interactive web UIs using C# instead of JavaScript. Blazor apps are composed of reusable web UI components implemented using C#, HTML, and CSS. Both client and server code is written in C#, allowing you to share code and libraries. Blazor can run your client-side C# code directly in the browser, using WebAssembly. Because it's real .NET running on WebAssembly, you can re-use code and libraries from server-side parts of your application.

There are two ways to create Blazor apps:

Blazor Server
Blazor WebAssembly

So in this article, we are going to use Blazor WebAssembly - which is one way to host Blazor components client-side in the browser using a WebAssembly-based .NET runtime.

What about Cosmic?

Creating Your Blog Bucket in Cosmic

To create a blog app we will require data. To manage and manipulate this data, we will be using the power of Cosmic buckets and objects. To get started:

Create a free account on Cosmic. If this is your first time using Cosmic, you'll see a short tutorial which will introduce some of the data types we'll be using - buckets, objects, and metafields.
Create a new empty bucket & name it blazor-blog. For each blog post, we will have three object types:

Title
Content
Image

Creating Your Blazor WebAssembly app

You can now create and run your first Blazor WebAssembly app by running:

dotnet new blazorwasm -o BlazorCosmicBlog --pwa
cd BlazorCosmicBlog
dotnet run

Now open the https://localhost:44346/ to see the default blazor app.

To fetch blog posts saved in Cosmic we require a Cosmic bucket Slug. Go to Cosmic -> Bucket -> Settings -> Basic Settings and copy the Bucket Slug.

To store the slug, create a new file appsettings.josn in the wwwroot folder and add the below code:

Now open the program.cs file and add the below code to load the appsettings.json file.

We are using Tailwind CSS to style our application, so let's add CDN into the index.html file.

<link https://unpkg.com/tailwindcss@^1.0/dist/tailwind.min.css" rel="stylesheet">

Building Our Blog Pages

First, we are building the main category page where we can show all the blog posts. Create a folder called Models and add class to store posts.

Go to Pages folder and open Index.razor component and add the below code to show list of posts fetching from Cosmic.

Let's run the app to see the output.

Looking good! Create a new component into the Pages folder called PostDetails.razor which shows the details of posts when we click on Read More button from all post pages.

Now run the app and click on Read More button from the Home page to see post details.

That's it! All our core features are working. We have successfully created a blog application using Blazor and Cosmic. Now it's just up to your content team members to add some blog posts to it.

Deploying Your Blazor Blog to Hosting Platforms

We can now deploy our application on any hosting platform. We are deploying our app on Netlify using Github Actions.

Commit your code to the GitHub repository.
Login to Netlify and create a new site.
We need a Personal Access Token and Site Id to deploy our app to netlify. So Go to Profile and generate Personal Access Token.

Go to your site -> Site details
Go to your repository Settings -> Secrets and above two secrets:
Click on Actions -> New Workflow and select .NET Core template. After that add the below code to yml file.
Our blog app is successfully deployed to Netlify.

Conclusion

In this article, I have demonstrated you how to create a blogging application using Blazor and Cosmic. The Cosmic Community has a lot of examples on how to handle integration with email functions, download functions, and third-party platforms. If you're interested in building your own applications like this, get started by setting up your free account.

I really hope that you enjoyed this little app, and please do not hesitate to send me your thoughts or comments about what could I have done better.

If you have any comments or questions about building apps with Cosmic, reach out to us on Twitter and join the conversation on Slack.

Deploy a Docusaurus App on Azure Static Web Apps

Sumit Kharche — Sat, 15 Aug 2020 13:04:44 +0000

In this article, we are going to build a simple app using Docusaurus and deploying the application to Azure Static Web App. So please grab a cup of coffee and start learning.

Table of Content

What is Docusaurus?
What is Azure Static Web App?
Build a simple app using Docusaurus
Deploy app into Azure Static Web App

What is Docusaurus?

Do you want to create great documentation for your project then Docusaurus is best option for building a documentation websites. It uses Markdown for documentation. Docusaurus is built using React so you can always customize the website as you want. It also supports Localization and document versioning.

What is Azure Static Web App?

Azure Static Web App is first launched as a preview in Microsoft Build 2020.

According to Azure Static Web App doc:

Azure Static Web Apps is a service that automatically builds and deploys full stack web apps to Azure from a GitHub repository.

With Azure Static Web App you can deploy any static application which is build using any Javascript framework or library or SSG. It uses Github actions to do the deployment out of the box. We can also host Azure function with the same application. Microsoft has created very good documentation so you can read more about Azure Static Web App here. Currently, Azure Static Web Apps are in preview. We can learn how to create Azure Static web app resources and how to configure our app deployed later in the article.

The azure static web app uses Github actions to do a deployment of the application. We have to just create Azure static web app resource and set up our application such as the location of the folder after prod build of our app, default app directory, if you any custom build command then you can also specify. Once you provide all the data and create resource then Azure static web app create a github action workflow into our repository and deploy our application. So after that every time you push commits or accept pull requests into the watched branch, the GitHub Action automatically builds and deploys your app and its API to Azure.

Features

Free SSL certificates
It has the support of Azure Functions for adding some dynamic content into our app.
All the static content is globally distributed
It also provides 1 pre-production i.e. staging environment to preview our changes before pushing to production.

You can read more features here.

Build a simple app using Docusaurus

Prerequisites

You need to have installed the latest stable version of Node JS and NPM. You can also install Yarn as well.

Install Docusaurus cli using below command:

npm install --global docusaurus-init

yarn global add docusaurus-init

Now create a folder for our app docusaurus-swa-app and navigate inside that into folder.

 mkdir docusaurus-swa-app
 cd docusaurus-swa-app

Now run the below command to create Docusaurus app

docusaurus-init

After completion of the above step, the docusaurus installation script creates two new directories: docs and website.

To run the app navigate to website folder and run below command.

npm start

yarn start

Open http://localhost:3000 to see the basic app.

Open the package.json file under website folder add dependencies section as below:

{
  "scripts": {
    "examples": "docusaurus-examples",
    "start": "docusaurus-start",
    "build": "docusaurus-build",
    "publish-gh-pages": "docusaurus-publish",
    "write-translations": "docusaurus-write-translations",
    "version": "docusaurus-version",
    "rename-version": "docusaurus-rename-version"
  },
 "dependencies": {
    "docusaurus": "^1.14.6"
  }
}

So we have created our app successfully, next step is to push the code to Github.

Follow the below steps for commit and push the project into Git.

git init
git add .
git commit -m "first commit"
git remote add origin <your repo address>
git push -u origin master

Deploy app into Azure Static Web App

Prerequisites

An Azure account with an active subscription. If you don't have one, you can create an account for free.

Navigate to the Azure portal
Click Create a Resource
Search for Static Web Apps
Click Static Web Apps (Preview)
Click Create
For Subscription, accept the subscription that is listed or select a new one from the drop-down list.
In Resource group, select New. In New resource group name, enter docusaurus-swa-app and select OK.
Next, a name for your app in the Name box. Valid characters include a-z, A-Z, 0-9 and -.
For Region, select an available region close to you.
For SKU, select Free.

Click the Sign in with GitHub button.
Select the Organization under which you created the repository.
Select the docusaurus-swa-app as the Repository .
For the Branch select master.

Next, add configuration settings that the build process uses to build your app.

Click the Next: Build > button to edit the build configuration
To configure the settings of the step in GitHub Actions, set the App location to /website.
Set App artifact location to build/test-site.

A value for API location isn't necessary as you aren't deploying an API at the moment.

Click the Review + Create button to verify the details are all correct.
Click Create to start the creation of the App Service Static Web App and provision a GitHub Action for deployment.
Once the deployment completes click, Go to resource.
On the resource screen, click the URL link to open your deployed application. You may need to wait a minute or two for the GitHub Action to complete.

That's it. We have successfully deployed our Docusaurus on Azure Static Web App.

Conclusion

In this article, We have created a basic app using Docusaurus. We have also deployed the same application on Azure Static Web App.

I really hope that you enjoyed this article, share it with friends and please do not hesitate to send me your thoughts or comments.

You can reach out to me on twitter @sumitkharche01.

Happy Coding!!

Build Simple Blog using Angular + Scully + Materialize + Netlify

Sumit Kharche — Sat, 01 Aug 2020 16:35:40 +0000

In this article, we are going to build a simple Blog application using Scully and deploying the application to Netlify. So please grab a cup of coffee and start learning.

Table of Content

What is Scully?
What is Netlify?
Build a blog using Scully
Deploy blog into Netlify

TL;DR

What is Scully?

There are lots of libraries available for Static Site Generators like Gatsby, Gridsome, Hugo, etc. Scully is the first SSG for Angular applications.

According Scully doc:

Scully is the best static site generator for Angular projects looking to embrace the JAMStack.
Under the hood, Scully analyzes an Angular application, and it generates a static version of it.

Scully uses a machine-learning algorithm that finds all routes in our application and generates static HTML files which then we can host it any CDN or web server. The best part of Scully is it has great support of Angular Schematics and due to this you just have to fire command to add Scully into your existing Angular application.

What is Netlify?

Netlify is a next-generation web hosting platform that provides everything that you need to build fast, modern websites such as CI/CI, serverless functions, etc. I recommend deploying it on Netlify because it supports project structures like this and can quickly create deployments.

Below are some of the benefits of Netlify:

You can create a free account for your projects.
Very less pricing with lots of features. You can check pricing here.
Provides free SSL certificates and has built-i DNS managements.
You want to store data then Netlify also has a Netlify CMS.

Build a blog using Scully

Let's create a new angular application:

ng new scully-blog-swa

Select yes for Angular routing and select CSS for our stylesheet format.

Once the project generation completed the navigate to the project folder.

cd scully-blog-swa

So run the angular application by running the following command:

ng serve --open

You can see the application at http://localhost:4200/

We are using Materializecss for styling our application.

To get started with Materializecss, open index.html and add below code:

<link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0/css/materialize.min.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0/js/materialize.min.js"></script>

We will start by creating the Navbar component. So run following command:

ng g c components/navbar

Open navbar.component.html and below code.

<nav class="light-blue lighten-1" role="navigation">
    <div class="nav-wrapper container"><a id="logo-container" href="#" class="brand-logo">Scully Blog</a>
      <ul class="right hide-on-med-and-down">
        <li><a routerLink="/blog">Blog</a></li>
        <li><a routerLink ="/about">About</a></li>
      </ul>

      <ul id="nav-mobile" class="sidenav">
        <li><a routerLink="/blog">Blog</a></li>
        <li><a routerLink="/about">About</a></li>
      </ul>
    </div>
</nav>

The above is a simple navbar component from Materializecss which you can get from the website.

Delete html from app.component.html and add <app-navbar> the navbar component.

<app-navbar></app-navbar>
<router-outlet></router-outlet>

Navigate to browser to see the Navbar:

So integrate Scully into Angular application we have used below command:

ng add @scullyio/init

We have to build our app then run npm run scully command so that Scully knows which routes it has to scan and creates static pages To make things simple we updated default build command in package.json as below:

 "build": "ng build && npm run scully -- --scanRoutes",

Scully provides the below command to generate a blog.

ng generate @scullyio/init:blog

This command generates a blog folder into our app which stores markdown files and also creates a blog component that is responsible for rendering markdown content.

To create posts we have to use below command:

ng g @scullyio/init:post --name="What makes a truly unique Latte"

This creates a markdown file in the blog folder. So using this command create a few posts and add markdown in it. In the markdown files, we have to make the published field true as we are not publishing draft posts.

To show all our blogs we have to create a container component. So create a new component:

ng g c components/blog-container

Open blog-container.component.ts and add below code:

import { Component, OnInit } from '@angular/core';
import { ScullyRoute, ScullyRoutesService } from '@scullyio/ng-lib';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

@Component({
  selector: 'app-blog-container',
  templateUrl: './blog-container.component.html',
  styleUrls: ['./blog-container.component.css']
})
export class BlogContainerComponent implements OnInit {

  constructor(private scully: ScullyRoutesService) {}
  posts$: Observable<ScullyRoute[]>;

  ngOnInit(): void {
    this.posts$ = this.scully.available$.pipe(
        map(routeList => {
          return routeList.filter((route: ScullyRoute) =>
            route.route.startsWith(`/blog/`)
          );
        })
      );
    }
}

ScullyRoutesService gives us available posts i.e. published=true so we import as service and assign it to local posts variable.

Open blog-container.component.html and below code to render posts:

<div class="section no-pad-bot" id="index-banner">
    <div class="container">
      <br><br>
      <h1 class="header center orange-text">Scully Blog</h1>
      <div class="row center">
        <h5 class="header col s12 light">A simple coffee blog application</h5>
      </div>
    </div>
</div>

<div class="container">
    <div class="section">
      <div class="row">
        <div *ngFor="let post of posts$ | async" class="col s12 m6">
            <div class="card">
              <div class="card-image waves-effect waves-block waves-light">
                <img class="activator" src={{post.image_url}}>                              
              </div>
              <div class="card-content">
                <span class="card-title activator grey-text text-darken-4">{{post.title}}</span>
                <p><a [routerLink]="post.route">Read More</a></p>
              </div>
              <div class="card-reveal">
                <span class="card-title grey-text text-darken-4"><i class="material-icons right">close</i></span>
                <p>{{post.description}}</p>
              </div>
            </div>
          </div>
      </div>

    </div>
    <br><br>
  </div>

Add below code into blog-routing.module.ts:

{
    path:'',
    component: BlogContainerComponent
}

Open app-routing.module.ts and add below code:

const routes: Routes = [
  {path: '', redirectTo:'blog',  pathMatch: 'full'},
  { path: 'blog', loadChildren: () => import('./blog/blog.module').then(m => m.BlogModule) }
];

To run the application hit below commands:

npm run build

after that run following command to serve Scully:

npm run scully:serve

Open browser to see the output:

Now click Read more button of any blog post and check the blog post content. It's not looking good so open blog-component.html and add below code:

<div class="container">
    <div class="section">
        <div class="row">
            <scully-content></scully-content>
        </div>
    </div>
    <br><br>
</div>

and open blog-component.css and add below css:

h1 {
  color:rgb(51, 6, 37);
  padding: 5px;
  border-radius: 5px;
  width: fit-content;
}

Create an about component and add some content in it and also include route into app-routing.module.ts

Finally, run the app and see the output:

Now push this new app into Git (you can choose other software development platforms like Gitlab, Bitbucket). Follow the below steps for commit and push the project into Git.

git init
git add .
git commit -m "first commit"
git remote add origin <your repo address>
git push -u origin master

So we have successfully created a Scully blog and also pushed source code into Git.

Deploy blog into Netlify

Now we have created our Scully blog app in the previous step. Now its time to deploy it on Netlify. If you are not already a Netlify user, first go ahead and sign up for a free account here.

Once you logged in, you will be redirected to https://app.netlify.com/. Follow the steps and link & authorize your Git account. Then you will see the New Site from Git button.

Click on the New Site for Git button. You will see below screen.

Under the Continuous Deployment section, select Github option. After that search the repo that you have created in the previous step and click on it.

After selecting repo, you have to provide a build setting as shown in below image:

Now click on Deploy Site button to deploy the site on Netlify. Then wait for the build and deployment to complete. Once the deployment is done navigate to the URL to see the live app.

Conclusion

In this article, I have demonstrated to you how to create a blog application using Scully. We have also deployed the same application on Netlify.

I really hope that you enjoyed this article, share it with friends and please do not hesitate to send me your thoughts or comments.

You can reach out to me on twitter @sumitkharche01.

Happy Coding!!

References

Photo by Lukas Blazek on Unsplash

Getting Started with Azure Service Bus Queues & ASP.NET Core - Part 1

Sumit Kharche — Fri, 17 Jul 2020 14:37:30 +0000

In this article, we are going to discuss to about Microsoft Azure Service Bus Queues. First, we will see what is Azure Service Bus and then discuss about queues. We are also going to build a simple application to send and receive message in queues using ASP.NET Core. So let’s grab a cup of coffee and start learning.

What is Azure Service Bus

Azure Service Bus is message broker service which is hosted on Azure platform and it provides functionality to publish messages to various application and also decouple the applications.

According to Microsoft documentation:

Microsoft Azure Service Bus is a fully managed enterprise integration message broker. Service Bus can decouple applications and services. Service Bus offers a reliable and secure platform for asynchronous transfer of data and state.

Data is transferred between different applications and services using messages. A message is in binary format and can contain JSON, XML, or just text.

Microsoft service bus comes in different flavors:

Queues
Topic (we will cover this in next articles)

Azure Service Bus: Queues

Queues follow First-In-First-Out (FIFO) pattern. Queues provide the one-way transport like the sender is going to send message in the queue and the receiver would collect messages from queue. In queues, there is a 1:1 relationship between the sender and receiver. Messages are present in queue until the receiver process and complete the messages.

The queue contains a secondary sub-queue, called a dead-letter queue (DLQ). Whenever we create a queue DLQ is automatically added in our main queue. When the messages are not delivered to the receiver or can not be processed by the receiver then such messages are pushed to DLQ.

Now we have discussed enough regarding Queues so let's create queues in Azure and build a simple application to send and receive messages from the queue.

Creating a simple application to send and receive messages from the queue.

Prerequisites

Azure account(If you don't have an Azure subscription, create a free trial account.)
Basic knowledge of Asp.net Core Web API

Overview of application

We will be creating a simple application which consists of 3 parts:

Create Azure Service Bus Queue using Azure Portal(Covering in this article)
Create Web API to push the message into Queue(Covering in this article)
Create a Background Service to receive a message from Queue(Covered in next article)

Creating Azure Service Bus Queue using Azure Portal

Login to Azure and click on Create a resource button.
In search box type service bus and select it.

Click on Create button. You will see the Create Namespace page.

Azure has Resource Groups(RG) which acts as a container for your resources. So now we are going to create a Service bus resource then first we need to create Resource Group. If you have already created RG then you can use the same here. Under Resource group click on Create New button and give unique RG name.

Now we have to specify the Namespace name. A namespace is a container for all messaging components. Multiple queues and topics can be in a single namespace, and namespaces often serve as application containers.
Select the location.
Select pricing tier. Azure provides 3 pricing tiers: 1 Basic 2 Standard 3 Premium

We have filled all details the click on Review + create button.

Review everything added property and finally click on Create button.

Creating resources will take time.

Now our order queue is created successfully.

Go to the Queues section in the left panel and click on Queue and give a unique name for queue and click on the Create button.

Create Web API to push the message into Queue

Prerequisites

Visual Studio 19(if you are using .NET Core 3.1)
.NET Core 3.1 SDK installed

First thing is to create a new ASP.NET Core Web API project. For those who are new to ASP.NET Core, I have listed down the steps to create a new Web API project.

Open Visual Studio and click on File -> New -> Project. Then select ASP.NET Core Web Application and click on the Next button.
Give the project name and click on Create button.
After that select API and click on Create button.
So now your ASP.NET Core Web API project is setup.
First we need to install Azure Service Bus NuGet package:

Create a new class called Order.cs and add below properties:

namespace Order.Web.API
{
    public class Order
    {
        public int Id { get; set; }
        public int Quantity { get; set; }
        public decimal Price { get; set; }
    }
}

To interact with Azure Service Bus Microsoft.Azure.ServiceBus package provides called QueueClient which accepts queue connection string and queue name as input and returns the QueueClient object. First, we grab the connection string of Queue from Azure Portal. So open the queue and click on Shared access policies then select RootManageSharedAccessKey and copy it into appsettings.json file.

appsettings.json

{
  "QueueConnectionString": "<replace your RootManageSharedAccessKey here>",
  "QueueName":  "order-queue",
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}

Create a new controller called OrdersController and add below code to push message into queue:

using System;
using System.Text;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.ServiceBus;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;

namespace Order.Web.Api.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class OrdersController : ControllerBase
    {
        private readonly IConfiguration _configuration;

        public OrdersController(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        [HttpPost]
        public async Task<IActionResult> CreateOrderAsync([FromBody] Order order)
        {
            IQueueClient queueClient = new QueueClient(_configuration["QueueConnectionString"], _configuration["QueueName"]);
            var orderJSON = JsonConvert.SerializeObject(order);
            var orderMessage = new Message(Encoding.UTF8.GetBytes(orderJSON))
            {
                MessageId = Guid.NewGuid().ToString(),
                ContentType = "application/json"
            };
            await queueClient.SendAsync(orderMessage).ConfigureAwait(false);

            return Ok("Create order message has been successfully pushed to queue");
        }
    }
}

So we have created QueueClient object and then we created Message. We used SendAsync() method to push message to the queue.
We are testing this using postman. Run the app and hit post API to push order into Queue.

After a successful POST call let's go to Azure Portal and see if the message is pushed to the queue. So we have 1 active message in the queue.

Conclusion

In this Part 1 of the Azure Service Bus Queue series, we have learned how to create a queue through Azure Portal and also we have created a Web API that pushes a message to the Queue. In Part 2 we will create a Background Service which will read messages from the Queue.

I really hope that you enjoyed this article, share it with friends and please do not hesitate to send me your thoughts or comments.

You can follow me on twitter @sumitkharche01

Happy Coding!!

Build a simple Todo App using Microsoft Fluent UI React

Sumit Kharche — Mon, 11 May 2020 14:51:20 +0000

This article was originally published here.

This is the second article in the Fluent UI React series. In this article, we will be creating a simple Todo application using React JS and Fluent UI React library. We will be exploring so many Fluent UI components like Stack, Dialog, etc. So let's grab a cup of coffee and start coding.

TL;DR

Prerequisites

You need to have installed the latest stable version of Node JS and NPM. You will easily understand the following tutorial if you have a basic understanding of:

HTML, CSS, and JavaScript
React, Hooks

If you don't know about Microsoft Fluent UI you can check out below article:

Getting started with Microsoft Fluent UI React

Sumit Kharche ・ May 7 '20

#react #javascript #webdev #beginners

Building Todo Application

1. Create new React App

We will be using the Create React App tool to create our React app. So let's run below command:

npx create-react-app fluent-ui-todo-app --typescript

2. Integrate Fluent UI React into App

Now once the app is successfully created then the next step is to install Fluent React into our app.

cd fluent-ui-todo-app
npm i @fluentui/react

3. Building components for App

We will be creating a simple todo application where we can add new todo and delete the existing todos. So we know that everything in React is component so we will be dividing our todo app into 3 components i.e AddTodo, TodoList, TodoItem. The great thing is we will using different Fluent UI components while creating these components.

To enable Fluent UI style we have to add Fabric component from Fluent UI library so open index.tsx file and add below code:

To organizing our components, we are going to use Stack Utility of Fluent UI. According to doc:

A Stack is a container-type component that abstracts the implementation of a flexbox in order to define the layout of its children components.

Stack is based on flexbox so we can control:

Direction: By adding vertical or horizontal properties,
Alignment: using verticalAlign and horizontalAlign properties,
Spacing: by adding gap and verticleGap properties.

So open App.tsx file add below code:

Add below class into App.css file:

.wrapper {
  max-width: 480px;
  margin: auto;
  background: #fff;
  margin-top: 50px;
  display: flex;
  flex-direction: column;
  padding-left: 50px;
  padding-right: 50px;
  padding-bottom: 50px;
}

We will start by displaying the todo list. First, we will use useState() hook to in the App component which stores an initial list of Todos. So add below line App component:

const [todos, setTodos] = useState([{ id: 1, name: "Todo Item 1" }, { id: 2, name: "Todo Item 2" }]);

Now next step is to display this Todo list. So to do this create 2 components TodoItem for single todo and TodoList which uses the TodoItem component to display all the todos by using the map() method.

Create TodoItem component add below code:

So here we have used Stack for organizing the Todo and Label to show the todo name from @fluentui/react.

Create TodoList component add below code:

Now we have to import the TodoList component into App component and pass the todos present in the App component state as props to TodoList.

So run the app and you will see the Todo's list.

So the next step is to add new todo functionality. Create a new component called AddTodo which has one input field and one button. On the button click to call a function in props to add todo.

Here we have used TextFieldcomponent to display an input field and PrimaryButton for displaying button from @fluentui/react.

Create a new function in App component for adding todo into state and pass it to AddTodo function in props.

Final step is to delete the todo in the list. So first add deleteTodo function in the App component as below:

const deleteTodo = (id: number) => {
    const newTasks = todos.filter((todo) => { return todo.id !== id });
    setTodos(newTasks);
  };

and pass this function to TodoList component:

<div className="wrapper">
      <Stack horizontalAlign="center">
        <h1>Todo App using Fluent UI & React</h1>
        <Stack style={{ width: 300 }} gap={25}>
          <AddTodo addTodo={addTodo} />
          <TodoList todos={todos} deleteTodo={deleteTodo} />
        </Stack>
      </Stack>
    </div>

Again from TodoList component pass this deleteTodo function TodoItem component:

<TodoItem todo={todo} key={todo.id} deleteTodo={props.deleteTodo} />

We will be using IconButton for showing delete button for each todo and also using Dialog Compnent to ask user before deleting todo. So deleteTodo component is looks like this:

Maintain a state of dialog like when to open and when to close by using useState() hook. You can check more properties about Dialog here.

To enable icons we have to import initializeIcons from Fluent UI and call initializeIcons() method so open index.tsx and initializeIcons in it.

import React from 'react';
import ReactDOM from 'react-dom';
import './index.css';
import App from './App';
import * as serviceWorker from './serviceWorker';
import { Fabric, initializeIcons } from "@fluentui/react";

initializeIcons();

ReactDOM.render(
  <React.StrictMode>
    <Fabric>
      <App />
    </Fabric>
  </React.StrictMode>,
  document.getElementById('root')
);

serviceWorker.unregister();

Deploy it

Conclusion

In this article, I have demonstrated to you how to create a Todo application using Fluent UI React. We have also used a few Fluent UI React components like Stack, Dialog, PrimaryButton, Label, TextField.

I really hope that you enjoyed this little app, and please do not hesitate to send me your thoughts or comments about what could I have done better.

You can reach out to me on twitter @sumitkharche01

Happy Coding!!

Getting started with Microsoft Fluent UI React

Sumit Kharche — Thu, 07 May 2020 14:15:57 +0000

This article was originally published here.

Have you ever wanted to create User Interface similar to Microsoft products? Have you heard about Microsoft Fluent UI? In this article, we will see what is Fluent UI and how to integrate it in React application.

To create great user experience is never easy task. So most of times user UI frameworks will reduce the time and increase productivity. We know that all the products of Google same uses a design system known as Material Design. So there are bunch of other systems are available like Semantic UI, Ant Design, etc. So when we see the Microsoft products like Outlook, Azure, Azure Devops,etc they all are very good and UI is consistent as well. So Microsoft team create a design system called Fluent Design System.

What is Microsoft Fluent Design System?

According to Microsoft doc:

Fluent brings the fundamentals of principled design, innovation in technology, and customer needs together as one. It’s a collective approach to creating simplicity and coherence through a shared, open design system across platforms.

Fluent Design System is a whole ecosystem consisting number of components, tools that helps users to create great user experiences in all the platform like Web, Mobile, Desktop applications. In this article, we will see more about Fluent UI for Web. So Fluent UI for the web is available in two flavors:

Fluent UI React
Fabric Core

Fabric Core

When we think of other CSS libraries like Bootstrap you can find lots of similarities in Fabric core. When you wanted to match look and feel of your application similar to Microsoft products you may think of like what font family and font sizes need to use and all these you have to do manually.

Fabric Core is an open-source collection of CSS classes and Sass mixins that give you access to colors, animations, fonts, icons and grid.

Fabric Core provides:

Fonts and typography
Color palettes
Layout helpers
Animation helpers
Icons
etc.

Fabric Core is basically useful for non-React applications and static pages.
To know more about it you can see the documentation here.

Fluent UI React

According to documentation:

Fluent UI React is the official open-source React front-end framework designed to build experiences that fit seamlessly into a broad range of Microsoft products. It provides robust, up-to-date, accessible components which are highly customizable using CSS-in-JS.

Fluent UI React contains React JS UI controls. It has same sets of controls and offerings that many similar libraries gives you things like Buttons, Dropdowns, Grids, Checkbox, etc and standard components. It also contains Microsoft controls as well like Datepickers, People pickers, persona, etc.

Some of the Microsoft products uses Fluent UI React.

45 additional Microsoft sites and products

You can checkout the github repo here.

Creating new Fluent UI React project

The most common way of creating React app is to use Create React App a development pack create by React team.

Create a new React project:

 npx create-react-app fluent-ui-demo

Once application is created we can run below command to add Fluent UI dependency:

cd fluent-ui-demo
npm i @fluentui/react

That's it.

Another way is that Microsoft created a starter repo which has same structure as Create React App.

So clone the starter repo

git clone https://github.com/microsoft/create-react-app-uifabric.git fluent-ui-demo
cd fluent-ui-demo

Install dependencies and start the app.

npm install
npm start

Now open the App.js file and import a primary button from @Fluentui/react

import React from 'react';
import './App.css';
import { PrimaryButton } from '@fluentui/react';

function App() {
  return (
    <div className="App">
      <div className="App-header">
        <PrimaryButton>Button</PrimaryButton>
      </div>
    </div>
  );
} 

export default App;

Run the app to see output.

This is just an introductory article. In the next article we will be creating simple Todo application using Fluent UI React.

Conclusion

In this article, I have explained Microsoft Fluent Design System and discuss about Fluent UI React. Also, I demonstrated how to add Fluent UI React library to application. I really hope that you enjoyed this article, share it with friends and please do not hesitate to send me your thoughts or comments.

You can follow me on twitter @sumitkharche01

Happy Coding!!