Cloud – Chandradev's Blog

Azure Functions is a serverless computing service offered by Microsoft Azure that allows you to write less code, maintain less infrastructure, and save on cost.

It enables the execution of small units of code, called functions, without the need to manage servers or any other infrastructure.

These functions are triggered by specific events or inputs, allowing developers to respond to events in real time. By utilizing Azure Functions, developers can focus solely on writing code and not worry about infrastructure management.

Benefits of Using Azure Functions

Serverless Computing: Azure Functions enable serverless computing, allowing you to focus on writing code without managing the underlying infrastructure. This can lead to increased development speed and reduced operational overhead.

Cost-Efficiency: With serverless architecture, you pay only for the compute resources used during the execution of functions. This can result in cost savings compared to traditional server-based approaches where you might pay for idle resources.

Scalability: Azure Functions automatically scale based on demand. Functions can be triggered individually, enabling your application to handle varying workloads efficiently.

Event-Driven: Functions can be triggered by various events such as HTTP requests, timer-based schedules, or events from other Azure services. This makes it suitable for building event-driven architectures and microservices.

Support for Multiple Languages: Azure Functions supports multiple programming languages, including C#, F#, C#, JavaScript, Python,Java and PowerShell.

Integration with Azure Services: Azure Functions seamlessly integrates with other Azure services, making it easy to connect and interact with services like Azure Storage, Azure SQL Database, or Azure Event Hubs.

Rapid Development and Deployment: The serverless model allows for rapid development and deployment. You can focus on writing the necessary code for your functions without dealing with infrastructure concerns, leading to faster time-to-market.

DevOps Integration: Azure Functions can be easily integrated into your DevOps processes, enabling continuous integration and deployment. This aligns with modern development practices, promoting agility and collaboration.

Different Types of Triggers on Azure Functions

HTTP Trigger: This trigger allows your function to be invoked by an HTTP request. It’s commonly used for building RESTful APIs or handling HTTP-based events.

Timer Trigger: With a timer trigger, your function can be scheduled to run at specified intervals or according to a cron expression. This is useful for periodic tasks or background processing.

Blob Trigger: This trigger is activated when a new or updated blob is detected in Azure Storage. It’s often used for scenarios involving file processing or data ingestion.

Queue Trigger: When a new message arrives in an Azure Storage Queue, a function with a queue trigger can be invoked. This is useful for building decoupled systems and handling asynchronous processing.

Event Hub Trigger: This trigger processes events from Azure Event Hubs, which is a scalable and distributed event streaming platform. It’s suitable for handling large-scale event streams.

Service Bus Trigger: With a Service Bus trigger, your function can respond to messages arriving in Azure Service Bus queues or topics. This is useful for building reliable and asynchronous communication between components.

Cosmos DB Trigger: This trigger reacts to changes in Azure Cosmos DB collections, allowing your function to process documents that are inserted or modified in the database.

Event Grid Trigger: Azure Event Grid triggers enable your function to respond to events from various Azure services or custom sources. It provides a flexible and event-driven architecture.

GitHub/WebHook Trigger: This trigger allows your function to respond to events from GitHub repositories, such as code commits or pull requests.

Durable Functions Orchestration Trigger: Durable Functions introduce a special trigger for orchestrations, allowing you to define workflows and manage the state of long-running processes.

These triggers provide a wide range of options for handling different types of events in your applications. As a web developer working with Azure, you can choose the trigger type that best fits the requirements of your projects, whether they involve HTTP requests, scheduled tasks, data changes, or other events.

Summary

In this introduction blog post we saw introduction of azure function, advantages and type of trigger in azure function. In next blog post we will see how to create Azure function with Visual Studio 2022.

As you know Micro service is one alternative approach to write Web API method. There are so many ways to create the micro-service. But in this post i m going to write creating micro service using Amazon Web Service(AWS) Lambda ToolKit on Asp.net Core

what is the Serverless Microservices ?

Serverless microservices are deployed within a serverless vendor’s infrastructure and only run when they are needed by the application. Depending on the size of a microservice, it may also be broken up into even smaller functions.

It doesn’t means that there will be no server. There will be cloud vendor’s server.

AWS use the Lamda and API gateways for this functionalities.

What are the advantages of this approach ?

1. You don’t have to pay for idle server time. So it will save huge deployment cost
2. If you have small application like POC and you are going to use that application for specific time interval then this approach will good. It will save huge money.
3. On demand we can scale the application, since it is on cloud.
4. It is give good performance as compare to monolithic approach.

How to create Serverless microservice with AWS

Step 1: Install the AWS Toolkit Extension as given below

Step 2: Create the Web Api Serverless Project like this

This template will add the all the requited dll and required files for us to making serverless microservice

Step 3: Add some Empty API controller in Controller folder and write some test method like this



using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Net.Http;

namespace AWSServerless3.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class TestController : ControllerBase
    {
        // GET: api/Test
        [HttpGet]
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "This is from Test Controller" };
        }
        //external
        [HttpGet]
        [Route("external")]
        public string External()
        {
            try
            {
                HttpClient client = new HttpClient();
                var requestTask = client.GetStringAsync("http://www.chandradev819.wordpress.com");
                requestTask.Wait();
                return "external connectivity PASS";
            }
            catch (Exception e)
            {
                return "external connectivity FAIL";
            }
        }


    }
}

Add one more controller i.e EmpController



using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;

namespace AWSServerless3.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class EmpController : ControllerBase
    {
        // GET: api/Emp
        [HttpGet]
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "This is from Emp Controller" };
        }
    }
}

Step 4; Build the application and run on local machine before deployment