Building a Serverless Web App with Azure Functions and Azure Cosmos DB

 Server less computing has revolutionized the way we build and deploy web applications. With server less, you can focus on writing code without worrying about managing infrastructure, and pay only for the compute resources you use. In this tutorial, we'll show you how to build a server less web app with Azure Functions and Azure Cosmos DB that provides scalable and cost-effective data storage and processing.

Prerequisites

Before we get started, you'll need to have the following:

1. An Azure account
2. Visual Studio Code
3. Azure Functions extension for Visual Studio Code
4. Azure Cosmos DB extension for Visual Studio Code

Creating the Azure Functions App

The first step is to create an Azure Functions app. In Visual Studio Code, select the Azure Functions extension and choose "Create New Project". Follow the prompts to choose your programming language and runtime.

Once your project is created, you can create a new function by selecting the "Create Function" button in the Azure Functions Explorer. Choose the HTTP trigger template to create a function that responds to HTTP requests.

In this example, we'll create a function that retrieves data from Azure Cosmos DB. We'll use the Cosmos DB extension for Visual Studio Code to connect to our database and retrieve data.

Creating the Azure Cosmos DB Account

Next, we'll create an Azure Cosmos DB account to store our data. In the Azure portal, select "Create a resource" and search for "Cosmos DB". Choose "Azure Cosmos DB" and follow the prompts to create a new account.

Once your account is created, select "Add Collection" to create a new container for your data. Choose a partition key and throughput level, and select "Create". You can now add data to your container through the Azure portal or through your Azure Functions app.

Connecting the Azure Functions App to Azure Cosmos DB

To connect your Azure Functions app to Azure Cosmos DB, you'll need to add the Cosmos DB extension to your project. In Visual Studio Code, select the Extensions icon and search for "Azure Cosmos DB". Install the extension and reload Visual Studio Code.

Next, open your function code and add the following code to your function:

const { CosmosClient } = require("@azure/cosmos");

module.exports = async function (context, req) {
    const endpoint = process.env["CosmosDBEndpoint"];
    const key = process.env["CosmosDBKey"];
    const client = new CosmosClient({ endpoint, key });
    
    const database = client.database("mydatabase");
    const container = database.container("mycontainer");
    
    const querySpec = {
        query: "SELECT * FROM c"
    };
    
    const { resources } = await container.items.query(querySpec).fetchAll();
    
    context.res = {
        body: resources
    };
}

This code connects to your Azure Cosmos DB account and retrieves all data from the specified container. Replace "mydatabase" and "mycontainer" with your database and container names.

Finally, add your Azure Cosmos DB account endpoint and key to your function's Application Settings. In the Azure Functions Explorer, select your function and choose "Application Settings". Add the following settings:

CosmosDBEndpoint: Your Azure Cosmos DB account endpoint
CosmosDBKey: Your Azure Cosmos DB account key

Conclusion

we learned how to build a serverless web app with Azure Functions and Azure Cosmos DB. We created an Azure Functions app and a new function that retrieves data from Azure Cosmos DB using the Cosmos DB extension for Visual Studio Code.

We also created an Azure Cosmos DB account and added a new container to store our data. Finally, we connected our Azure Functions app to Azure Cosmos DB by adding the necessary code and application settings. By using Azure Functions and Azure Cosmos DB together, you can build scalable and cost-effective web applications that handle data storage and processing without managing infrastructure.

You can extend this example to include more complex queries, data manipulation, and other functions that respond to HTTP requests or other triggers. 

 If you're new to serverless computing or Azure Functions, be sure to check out the documentation and resources available from Microsoft. With the right tools and knowledge, you can quickly build and deploy serverless web applications that are flexible, scalable, and cost-effective.


Maximizing Azure Functions: Use Cases and Limitations for Effective Serverless Computing

Azure Functions: Use Cases, Limitations, and Best Practices for Serverless Computing

Azure Functions is a powerful serverless compute service provided by Microsoft Azure that enables developers to build and run event-driven applications at scale. This service supports a wide range of use cases, such as real-time data processing, RESTful APIs, event triggers, scheduled tasks, and chatbots, making it an ideal choice for businesses looking to adopt a serverless computing model.

However, it's important to note that there are some limitations and best practices to consider when working with Azure Functions. In this article, we'll discuss some of the common use cases for Azure Functions, as well as the limitations and best practices you should be aware of.

Real-time Data Processing with Azure Functions

Azure Functions is an ideal choice for real-time data processing use cases, such as data validation, enrichment, and transformation. By leveraging Azure Functions, you can process data as it flows into your application, ensuring that it's accurate and up-to-date. Additionally, Azure Functions can integrate with other Azure services, such as Azure Blob Storage, Event Hubs, and IoT Hub, enabling you to process large volumes of data in real-time.

Building RESTful APIs with Azure Functions

Azure Functions can also be used to build RESTful APIs that can be consumed by other applications. This is particularly useful for businesses looking to expose their services to external customers or partners. By using Azure Functions to build APIs, you can reduce development time and costs, as well as improve scalability and reliability.

Event-driven Computing with Azure Functions

Another key use case for Azure Functions is event-driven computing. Azure Functions can be triggered by events in other Azure services, such as Azure Blob Storage, Event Hubs, and IoT Hub. This allows you to respond to events in real-time, such as processing a new file upload to Azure Blob Storage or handling an incoming message from an IoT device.

Scheduled Tasks with Azure Functions

Azure Functions can also be used to perform scheduled tasks, such as sending email notifications or generating reports. By leveraging Azure Functions for scheduled tasks, you can automate repetitive tasks and free up time for your development team to focus on higher-value tasks.

Chatbots with Azure Functions

Azure Functions can also be used to build chatbots that can interact with users and respond to their queries. By using Azure Functions to build chatbots, you can reduce development time and costs, as well as improve scalability and reliability.

Limitations and Best Practices for Azure Functions

While Azure Functions is a powerful serverless compute service, there are some limitations and best practices to keep in mind. For example, Azure Functions are designed to be short-lived, so they may not be the best choice for long-running tasks or tasks that require a lot of resources. Additionally, Azure Functions are stateless, which means that they don't maintain any state between function invocations. This can be problematic for applications that require complex state management. To overcome these limitations, you may want to consider using Azure Durable Functions or other Azure services such as Azure Virtual Machines or Azure App Service.

Conclusion

Azure Functions is a powerful serverless compute service that supports a wide range of use cases, such as real-time data processing, RESTful APIs, event triggers, scheduled tasks, and chatbots. By leveraging Azure Functions, you can reduce development time and costs, as well as improve scalability and reliability. However, it's important to keep in mind the limitations and best practices for Azure Functions to ensure that you're using the service effectively.

code for azure function with storage of excel file

This function listens to HTTP POST requests and stores the Excel file in Blob storage under the "excel-files" container with a random GUID as the file name. Note that this function requires the Microsoft.Azure.WebJobs.Extensions.Storage NuGet package. When you make a POST request to this function with an Excel file in the request body, the function will store the file in Blob storage and return an HTTP 200 OK response with the message "Excel file stored successfully". You can then use this file in other Azure Functions or download it from Blob storage using the Azure Storage SDK or Azure portal.

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

public static class StoreExcelFunction
{
    [FunctionName("StoreExcel")]
    public static async Task Run(
        [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
        [Blob("excel-files/{rand-guid}.xlsx", FileAccess.Write)] Stream excelFile,
        ILogger log)
    {
        await req.Body.CopyToAsync(excelFile);
        log.LogInformation("Excel file stored successfully");

        return new OkObjectResult("Excel file stored successfully");
    }
}

Handwritten Digit Recognition using OpenCV using Python

This code loads a pre-trained CNN model to recognize the digits, captures the video from the webcam, and analyzes each frame in real-time to recognize the digits. The code uses OpenCV to preprocess the images and extract the digits from the video frames. The recognized digits are printed on the video frames and displayed in real-time.

 

import cv2

import numpy as np

from keras.models import load_model

# Load the pre-trained CNN model

model = load_model('model.h5')

# Define the size of the image to be analyzed

IMG_SIZE = 28

# Define the function to preprocess the image

def preprocess_image(img):

    img = cv2.resize(img, (IMG_SIZE, IMG_SIZE))

    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    img = cv2.threshold(img, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]

    img = img.astype('float32') / 255.0

    img = np.reshape(img, (1, IMG_SIZE, IMG_SIZE, 1))

    return img

# Define the function to recognize the digit

def recognize_digit(img):

    img_processed = preprocess_image(img)

    digit = model.predict_classes(img_processed)[0]

    return digit

# Capture the video from the webcam

cap = cv2.VideoCapture(0)

while True:

    # Read a frame from the video stream

    ret, frame = cap.read()

    

    # Convert the frame to grayscale

    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    

    # Threshold the grayscale image

    ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)

    

    # Find the contours in the thresholded image

    contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    

    # Loop through all the contours

    for contour in contours:

        # Find the bounding rectangle of the contour

        x, y, w, h = cv2.boundingRect(contour)

        

        # Ignore contours that are too small

        if w < 10 or h < 10:

            continue

        

        # Draw the rectangle around the contour

        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)

        

        # Extract the digit from the image

        digit_img = gray[y:y+h, x:x+w]

        

        # Recognize the digit

        digit = recognize_digit(digit_img)

        

        # Print the recognized digit on the frame

        cv2.putText(frame, str(digit), (x, y), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)

    

    # Display the video stream

    cv2.imshow('Handwritten Digit Recognition', frame)

    

    # Wait for a key press

    key = cv2.waitKey(1)

    

    # If the 'q' key is pressed, exit the loop

    if key == ord('q'):

        break

# Release the resources

cap.release()

cv2.destroyAllWindows()

 

Motion Detection using OpenCV using python

 import cv2

# Set up video capture device

cap = cv2.VideoCapture(0)

# Initialize variables

previous_frame = None

while True:

    # Capture current frame

    ret, current_frame = cap.read()

    # Convert to grayscale

    current_frame_gray = cv2.cvtColor(current_frame, cv2.COLOR_BGR2GRAY)

    # Check if previous frame exists

    if previous_frame is not None:

        # Compute absolute difference between current and previous frame

        frame_diff = cv2.absdiff(current_frame_gray, previous_frame)

        # Apply thresholding to remove noise

        thresh = cv2.threshold(frame_diff, 25, 255, cv2.THRESH_BINARY)[1]

        # Find contours of objects in thresholded image

        contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

        # Draw bounding box around each contour

        for contour in contours:

            (x, y, w, h) = cv2.boundingRect(contour)

            cv2.rectangle(current_frame, (x, y), (x + w, y + h), (0, 0, 255), 2)

    # Update previous frame

    previous_frame = current_frame_gray

    # Display current frame

    cv2.imshow("Motion Detection", current_frame)

    # Exit on 'q' key press

    if cv2.waitKey(1) & 0xFF == ord('q'):

        break

# Release video capture device and destroy all windows

cap.release()

cv2.destroyAllWindows()

In this code, we capture frames from the default video capture device using cv2.VideoCapture(0). We then convert the current frame to grayscale using cv2.cvtColor(), and compute the absolute difference between the current and previous frames using cv2.absdiff(). We apply thresholding to the difference image to remove noise using cv2.threshold(), and find the contours of objects in the thresholded image using cv2.findContours(). Finally, we draw bounding boxes around each contour using cv2.rectangle().

To run this code, save it in a Python file (e.g., motion_detection.py) and run it using the command python motion_detection.py in a terminal or command prompt. Make sure you have OpenCV installed before running the code.

Face Recognition with OpenCV python code

 import cv2

# Load the Haar Cascade face detection classifier

face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

# Load the trained face recognition model

recognizer = cv2.face.LBPHFaceRecognizer_create()

recognizer.read('trained_model.xml')

# Set the video capture device (0 is usually the default webcam)

cap = cv2.VideoCapture(0)

while True:

    # Read a frame from the video stream

    ret, frame = cap.read()

    # Convert the frame to grayscale

    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Detect faces in the grayscale frame

    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5)

    # Loop through each face detected

    for (x, y, w, h) in faces:

        # Crop the face region from the grayscale frame

        face_gray = gray[y:y+h, x:x+w]

        # Resize the face image to match the training image size

        face_gray = cv2.resize(face_gray, (100, 100))

        # Predict the label (person) of the face using the trained model

        label, confidence = recognizer.predict(face_gray)

        # Draw a rectangle around the face and display the predicted label

        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)

        cv2.putText(frame, f'Person {label} ({confidence:.2f})', (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

    # Display the frame

    cv2.imshow('Face Recognition', frame)

    # Exit the loop if 'q' is pressed

    if cv2.waitKey(1) == ord('q'):

        break

# Release the video capture device and close the OpenCV window

cap.release()

cv2.destroyAllWindows()

 Note that this code assumes you have already trained a face recognition model and saved it to a file (in this case, trained_model.xml). If you haven't done this yet, you will need to train the model on a dataset of labeled face images before you can use it for recognition.

Object Detection with OpenCV-Python code

 import cv2

# Load the pre-trained face detection classifier

face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

# Load the image

img = cv2.imread('test.jpg')

# Convert the image to grayscale

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Detect faces in the grayscale image

faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

# Draw rectangles around the detected faces

for (x, y, w, h) in faces:

    cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)

# Display the result

cv2.imshow('img', img)

cv2.waitKey(0)

cv2.destroyAllWindows()

In this example, the cv2.CascadeClassifier function is used to load the pre-trained Haar Cascade classifier file for face detection. The detectMultiScale function is used to detect faces in the image. The scaleFactor parameter determines how much the image size is reduced at each image scale, the minNeighbors parameter controls the number of neighbors a detection candidate needs to retain, and the minSize parameter specifies the minimum size of the face to detect. Finally, the cv2.rectangle function is used to draw a rectangle around each detected face in the image, and the cv2.imshow function is used to display the result.