Every software application needs backend components that are responsible for taking care of the business logic and storing the data into some kind of storage such as database, filesystem, and so on. Each of these backend components could be developed using different technologies. Azure serverless technology also allows us to develop these backend APIs using Azure Functions.

Azure Functions provide many out-of-the-box templates that solves most of the common problems such as connecting to storage, building Web APIs, cropping the images, and so on. In this chapter, we will learn how to use these built-in templates. Along with learning the concepts related to Azure serverless computing, we will also try to implement a solution to a basic domain problem of creating components required for any organization to manage the internal employee information.

Below is a simple diagram that helps you understand what we will be going to achieve in this chapter:

We will use Azure serverless architecture for building a Web API using HTTP triggers. These HTTP triggers could be consumed by any frontend application that is capable of making HTTP calls.

Let's start our journey of understanding Azure serverless computing using Azure Functions by creating a basic backend Web API that responds to HTTP requests:

• Please refer to the URL https://azure.microsoft.com/en-in/free/?&wt.mc_id=AID607363_SEM_8y6Q27AS for creating a free Azure Account.
• Also, visit https://docs.microsoft.com/en-us/azure/azure-functions/functions-create-function-app-portal to understand the step by step process of creating a function app and https://docs.microsoft.com/en-us/azure/azure-functions/functions-create-first-azure-function to create a function. While creating a function, a Storage Account is also created for storing all the files. Please remember the name of the Storage Account which will be used later in the other chapters.

1. Navigate to the Function App listing page. Choose the function app in which you would like to add a new function.
2. Create a new function by clicking on the + icon as shown in the following screenshot:

3. If you have created a brand new function, then clicking on the + icon in the preceding step, you would see the Get started quickly with a premade function page. Please click on the create your own custom functions link to navigate to the page where you can see all the built-in templates for creating your Azure Functions.
4. In the Choose a template below or go to the quickstart section, choose HTTPTrigger-CSharp as shown in the following screenshot to create a new HTTP trigger function:

5. Provide a meaningful name. For this example, I have used RegisterUser as the name of the Azure Function.
6. In the Authorization level drop-down, choose the Anonymous option as shown in the following screenshot. We will learn more about the all the authorization levels in Chapter 9, Implement Best Practices for Azure Functions:

7. Once you provide the name and choose the Authorization level, click on Create button to create the HTTP trigger function.
8. As soon as you create the function, all the required code and configuration files will be created automatically and the run.csx file will be opened for you to edit the code. Remove the default code and replace it with the following code:

        using System.Net;
        public static async Task<HttpResponseMessage> 
        Run(HttpRequestMessage req, TraceWriter log)
        {
            string firstname=null,lastname = null;
            dynamic data = await req.Content.ReadAsAsync<object>();
            firstname = firstname ?? data?.firstname;
            lastname = data?.lastname;
            return (lastname + firstname) == null ? 
             req.CreateResponse(HttpStatusCode.BadRequest, 
             "Please pass a name on the query string or in the 
             request body") : 
            req.CreateResponse(HttpStatusCode.OK, "Hello " + 
             firstname + " " + lastname);
        }

9. Save the changes by clicking on the Save button available just above the code editor.
10. Let's try to test the RegisterUser function using the Test console. Click on the tab named Test as shown in the following screenshot to open the Test console:

11. Enter the values for firstname and lastname, in the Request body section as shown in the following screenshot:

Please make sure you select POST in the HTTP method drop-down.

12. Once you have reviewed the input parameters, click on the Run button available at the bottom of the Test console as shown in the following screenshot:

13. If the input request workload is passed correctly with all the required parameters, you will see a Status 200 OK, and the output in the Output window will be as shown in the preceding screenshot.

We have created the first basic Azure Function using HTTP triggers and made a few modifications to the default code. The code just accepts firstname and lastname parameters and prints the name of the end user with a Hello {firstname} {lastname} message as a response. We have also learnt how to test the HTTP trigger function right from the Azure Management portal.

• The Enabling authorization for function apps recipe in Chapter 9, Implement Best Practices for Azure Functions

In the previous recipe, you have learnt how to create an HTTP trigger and accept the input parameters. Let's now work on something interesting, that is, where you store the input data into a persistent medium. Azure Functions supports us to store data in many ways. For this example, we will store the data in Azure Table storage.

In this recipe, you will learn how easy it is to integrate an HTTP trigger and the Azure Table storage service using output bindings. The Azure HTTP trigger function receives the data from multiple sources and stores the user profile data in a storage table named tblUserProfile.

• For this recipe, we will use the same HTTP trigger that we have created in our previous recipe.
• We will be using Azure Storage Explorer which is a tool that helps us to work with the data stored in Azure Storage account. You can download it from http://storageexplorer.com/.
• You can learn more about Connect to the Storage Account using Azure Storage Explorer at https://docs.microsoft.com/en-us/azure/vs-azure-tools-storage-manage-with-storage-explorer

1. Navigate to the Integrate tab of the RegisterUser HTTP trigger function.
2. Click on the New Output button and select Azure Table Storage then click on the Select button:

3. Once you click on the Select button in the previous step, you will be prompted to choose the following settings of the Azure Table storage output bindings:
   • Table parameter name: This is the name of the parameter that you will be using in the Run method of the Azure Function. For this example, please provide objUserProfileTable as the value.
   • Table name: A new table in the Azure Table storage will be created to persist the data. If the table doesn't exist already, Azure will automatically create one for you! For this example, please provide tblUserProfile as the table name.
   • Storage account connection: If you don't see the Storage account connection string, click on the new (shown in the following screenshot) to create a new one or to choose an existing storage account.
   • The Azure Table storage output bindings should be as shown in the following screenshot:

4. Click on Save to save the changes.

5. Navigate to the code editor by clicking on the function name and paste the following code:

        #r "Microsoft.WindowsAzure.Storage"
        using System.Net;
        using Microsoft.WindowsAzure.Storage.Table;

        public static async Task<HttpResponseMessage>
        Run(HttpRequestMessage req,TraceWriter
        log,CloudTable objUserProfileTable)
        {
            dynamic data = await 
             req.Content.ReadAsAsync<object>();
            string firstname= data.firstname;
            string lastname=data.lastname;
 
            UserProfile objUserProfile = new UserProfile(firstname,    
             lastname);
            TableOperation objTblOperationInsert =  
             TableOperation.Insert(objUserProfile);
            objUserProfileTable.Execute(objTblOperationInsert);
    
            return req.CreateResponse(HttpStatusCode.OK,
             "Thank you for Registering..");
        } 

        public class UserProfile : TableEntity
        {
            public UserProfile(string lastName, string firstName)
            {
                this.PartitionKey = "p1";
                this.RowKey = Guid.NewGuid().ToString();;
                this.FirstName = firstName;
                this.LastName = lastName;
            }
            public UserProfile() { }
            public string FirstName { get; set; }
            public string LastName { get; set; }
        }

6. Let's execute the function by clicking on the Run button of the Test tab by passing firstname and lastname parameters in the Request body as shown in the following screenshot:

7. If everything went well, you should get a Status 200 OK message in the Output box as shown in the preceding screenshot. Let's navigate to Azure Storage Explorer and view the table storage to see if the table named tblUserProfile was created successfully:

Azure Functions allows us to easily integrate with other Azure services just by adding an output binding to the trigger. For this example, we have integrated the HTTP trigger with the Azure Storage table binding and also configured the Azure Storage account by providing the storage connection string and the Azure Storage table name in which we would like to create a record for each of the HTTP requests received by the HTTP trigger.

We have also added an additional parameter for handling the table storage named objUserProfileTable, of type CloudTable, to the Run method. We can perform all the operations on the Azure Table storage using objUserProfileTable.

We have also created an object of UserProfile, and filled it with the values received in the request object, and then passed it to a table operation. You can learn more about handling operations on Azure Table storage service from the URL https://docs.microsoft.com/en-us/azure/storage/storage-dotnet-how-to-use-tables.

When you create a new storage connection (please refer to the third step of the How to do it... section of this recipe) a new App settings will be created as shown in the following screenshot:

You can navigate to the App settings by clicking on Application settings of the Platform features tab as shown in the following screenshot:

Azure Table storage service is a NoSQL key-value persistent medium for storing semi-structured data. You can learn more about the same at https://azure.microsoft.com/en-in/services/storage/tables/.

The primary key of Azure Table storage tables has two parts as follows:

• Partition key: Azure Table storage records are classified and organized into partitions. Each record located in a partition will have the same partition key (p1 in our example).
• Row key: A unique value should be assigned for each of the rows.

Following is the very first line of the code in this recipe:

#r "Microsoft.WindowsAzure.Storage"

The preceding line of code instructs the function runtime to include a reference to the specified library to the current context.