DEV Community: Surjyo Bhattacharya

Dependency Injection in Azure Functions

Surjyo Bhattacharya — Sun, 04 Dec 2022 18:30:00 +0000

What is Dependency Injection?

In software engineering, dependency injection is a design pattern in which an object or function receives other objects or functions that it depends on. A form of inversion of control, dependency injection aims to separate the concerns of constructing objects and using them, leading to loosely coupled programs. The pattern ensures that an object or function which wants to use a given service should not have to know how to construct those services. Instead, the receiving 'client' (object or function) is provided with its dependencies by external code (an 'injector'), which it is not aware of.[4] Dependency injection helps by making implicit dependencies explicit and helps solve the following problems:[5]

How can a class be independent of the creation of the objects it depends on?
- How can an application, and the objects it uses to support different configurations?
How can the behavior of a piece of code be changed without editing it directly?

We intend to use the same IOC behavior in using the Azure Functions implementing the Dependency Injection principle.

Demo Function with DI

For this let us write a demo function as seen below.

Notice that by default the Function1 class is static as well as the Function is also defined as static.

Also, a point to note is - Support for dependency injection begins with Azure Functions 2.x. The guidance in this sample would work in the case of C# class library functions that run in-process with the runtime.

Considering the above points, let us add a class library utility as seen below.

We plan to interact with the Azure Blob Storage account via the Azure Function and hence adding the Blob Service instantiation-related functionality to the Utility and in the main Azure Function shall not be required to manage the connections of the Azure Blob.

We have defined an Interface that ensures the contract CreateBlob is to be established.

We have defined the implementation class: BlobStorageManagerService which has implemented the CreateBlob. Please note the section of the code below :

  private readonly string _blobConnectionString;
        private readonly BlobServiceClient _blobServiceClient;

        public BlobStorageManagerService(string blobConnectionString)
        {
            _blobConnectionString = blobConnectionString;

            BlobServiceClient blobServiceClient = new BlobServiceClient(_blobConnectionString);
            _blobServiceClient = blobServiceClient;

        }

The above code is an example of the implementation of DI, where the blobServiceClient is defined in the constructor of the BlobStorageManagerService.

Next, we will need to inject the dependencies at the startup, for that we shall need to add the following 2 Nuget Packages

microsoft.azure.functions.extensions

azurefunctions.extensions.dependencyinjection

Next, we shall add the Startup.cs class in the Utility project as follows

Note the sections in red, we have to use the above convention in the Startup to ensure that when the Utility is used as a reference to the original function app project, the proper dependency injections are injected and the rest of the code can run smoothly thereafter.

Finally, in the DemoFunction App, we shall be implementing the DI code as follows :

On building the application and running we get the following, and we are already with the HttpTriggered function.

Reference : https://learn.microsoft.com/en-us/azure/azure-functions/functions-dotnet-dependency-injection

Power Automate: Cloning flows in same tenant pointing to separate sources

Surjyo Bhattacharya — Thu, 09 Dec 2021 07:22:23 +0000

While developing solutions in PowerApps or Power Automate we would generally be doing development in the Default (Company) environment. There might be licensing costs associated with multiple environments and hence it may be an issue in getting separate development, QA or UAT environments.

It can be thought of a scenario like having single sql-server with multiple copies of Database, one as Dev and other as QA. Similarly, in power automate we can clone a flow into multiple copies in each solution and name the flows accordingly.

Steps :

Extract the Deployment package using the export option at a solution level: SolutionPackage_1_0_0_1.zip
Unzip the package to local computer and the folder structure shall be as shown:

Delete the folder : environmentvariabledefinitions and its contents (includes sub-folders , json files)
Navigate to the Workflows folder and you shall find a pre existing JSON file , copy the JSON file and paste it in the same folder location.

Rename the copied file by renaming the Flow Name as well replaced the existing GUID with a new GUID (the GUID in the file name should be in Upper Case)
You might use the following URL for GUID generation
GUID-Generator
Modify the customizations.xml file in the location: SolutionPackage_1_0_0_1\customizations.xml

We shall modify the existing Workflows section, i.e will not be copying same section twice (copying over and modifying the copied section seems to be throwing errors) , but instead updating the existing section and the places to be modified are highlighted below (follow the instructions on the CASE (upper/lower) of the GUID as mentioned in the image below) :

Use the lower case GUID as and where applicable and can use the following online resource for the same :

CaseConverter

Next we shall modify the solution.xml at ~ \SolutionPackage_1_0_0_1\solution.xml

a. Modify the version number
1.0.0.2

b. Update the existing RootComponent , (copying over and modifying the copied section seems to be throwing errors)

c. Remove the entries under:

Create a zip file maintaining the underlying folder structure to generate the updated deployment package
Import the deployment package and you shall find the clones of your flow in the solution

Define separate environment variables in the solution.
For each environment use the corresponding environment variables inside your flow. Disable the flows when not required or delete them as required independently.

This way we can reuse the same environment to point to separate share point locations simultaneously from the same solution.

Reference

Power Automate - Setting Modified By of SharePoint List while updating item from flow

Surjyo Bhattacharya — Sat, 04 Dec 2021 17:36:13 +0000

Problem : Suppose we have a power automate / flow that gets triggered when a SharePoint online list gets created / updated and the flow performs some action that updates the list. If we observe the Modified By column of the List, it can be observed that the Modified By column reflects the account/user under which the flow is running rather than the user whose action (create/update) triggered the flow.

We have created a List as displayed below :

We have designed a sample Flow that updates the Email field and corresponding the Modified By column also gets updated with the System account under which the flow is running, which in this case is my account.

Now to enable the Modified By column to show the user name who triggered the flow, we have to make certain changes.

Use a Compose shape to set the Key for the User Account that triggered the shape as shown in the image below :



[{"Key": "i:0#.f|membership|username@yourcompany.com"}]

Use another Compose shape dependent on the output of the above compose shape to generate the formValues to be used in a a JSON format later.



[
{
"FieldName" : "Editor"
"FieldValue" : @{concat(outputs('Compose_User_Modified'))}
}
]

Finally

An update item call is made to the SharePoint item in the List, make an additional call to the SharePoint using the shape "Send an HTTP request to SharePoint"

This will be POST call where the Body consists of the JSON format.
The formValues shall consist of the Name Value pairs, in our case we are setting the Key as Editor.

Sample format :



{
"formValues": [ 
  { "FieldName": "Title", 
    "FieldValue": "Item" 
    } 
],
"bNewDocumentUpdate": false
}

The flag bNewDocumentUpdate is set as false so as not to create a new version on top of the one created by the flow. The false flag effectively overwrites the entry of the Modified By field by the flow with that of the user triggering the flow.

With the above mentioned changes in place we are good to go. Hope this helps in case you need to set the Modified By field correctly while updating your share point list.

Reference : John Liu

Power Apps form – Setting Currency Format at Runtime

Surjyo Bhattacharya — Fri, 03 Dec 2021 05:04:10 +0000

Recently came across a requirement where the user expected the currency formatting at runtime.
Power Apps does not inherently support any currency input for a text box.
We currently have the input formats as Number and Text as represented below:

We need to keep the input text field format as Number to prevent the user from inserting non-numeric values in the said field.
Now the question arises as how we can display formatting at runtime.

Option 1 :
From the text box input , the event that we can capture is the OnChange , so while tabbing out the formatting is enabled and user can see the formatted value in the text box itself.
For this we need to set a variable with the formatted value on the OnChange Event as shown:

Code :

Set( FormattedCurrency, Text( Value(txtUnitPrice.Text), "$#,##0.00", Language() ) )

We need to do one additional step, i.e set this Variable - FormattedCurrency defined above as the Default attribute of the TextBox input.

This enables near runtime formatting, with the formatting enabled on the tab event.

Options 2 :
If the user is expecting formatting while typing itself and not willing to wait for the tabbed event,
we can add a label adjacent the text box and set its Text property as below :

Code :

Text( Value(txtUnitPrice.Text), "$#,##0.00", Language() )

With these settings we can generate our desired output :

Step 1 : While typing the numbers in the Currency text box field :

Step 2 : OnTabbing out

You can replace the textbox controls with the data card controls in case you are working in an integrated SharePoint PowerApps solution.

Connecting the dots.. from Azure to AWS - Part 2

Surjyo Bhattacharya — Thu, 02 Dec 2021 12:48:32 +0000

In continuation of my previous article :
Connecting the dots.. from Azure to AWS - Part 1 , let me discuss further for a couple of more services in AWS and Azure.

1. Querying the Blob Storage

For Storage, S3 equivalent service would be Azure Data Lake Storage which is built on top of Azure Blob Storage.

The Azure equivalent of Athena is Data Lake Analytics. Like Athena, it is also "serverless" and pay-per-use. It uses U-SQL, which is a combination of SQL and C# that provides a lot of power and flexibility that SQL alone cannot. An advantage of Data Lake Analytics is that it is not limited to querying Azure Data Lake Store and Blob Storage, it can also talk to SQL Database and SQL Data Warehouse.

2.Querying the Logs in AWS and Azure

In AWS CloudWatch Log Insights is the service that is used to query the Logs to get relevant details, in case of Azure Log, Kusto Query Language is the equivalent.

3. Monitoring Services

Azure’s native monitoring service, Azure Monitor, and AWS’ equivalent, Amazon CloudWatch, are both transforming the way cloud teams are detecting and remediating issues with applications and infrastructure resources. Both cloud services consolidate massive amounts of data from cloud and on-premises sources, provide visualization and analysis, allow users to respond to issues quickly, and support a strong ecosystem
of third-party solutions.

Azure Monitor Metrics: Azure Monitor Metrics is a feature of Azure Monitor that collects numeric data from monitored resources into a time series database. Metrics are numerical values that are collected at regular intervals and describe some aspect of a system at a specific point in time. Metrics are lightweight and capable of supporting near real-time scenarios, making them useful for alerting and fast detection of issues.

Azure Monitor Logs: Azure Monitor Logs is a feature of Azure Monitor that collects and organizes log and performance data from monitored resources. Log data collected from different sources can be consolidated into a single workspace so they can be analyzed together.

Data stored in Azure Monitor Metrics is more lightweight than data stored in Azure Monitor Logs and is capable of supporting near real-time scenarios—making Metrics useful for alerting and quickly detecting issues.

Secondly, Azure Monitor Metrics can only be stored as numerical data in a particular structure, while Log data may store a variety of different data types, each with their own structure. Because of this, data collected by Azure Monitor Logs is analyzed with queries.

Amazon CloudWatch Alarms (known as Alerts in Azure Monitor) monitor your metric values against thresholds predetermined by the user, or via machine learning models built to detect anomalous behavior. If an alarm is triggered, CloudWatch can distribute notifications and take corrective action, such as detecting and shutting down an unused or underutilized instance.

CloudWatch Events enables users to automate responses to operational changes. CloudWatch Events provide a near real-time stream of system events that describe changes in your AWS resources. Users can write custom rules to indicate which event is of interest to their application and what automated actions to take when a rule matches an event.

4. AWS Config & Azure Policy

AWS Config can be thought to be equivalent to Azure Policy.
Azure Policy is a service in Azure that you use to create, assign and, manage policy definitions. Policy definitions enforce different rules and effects over your resources, so those resources stay compliant with your corporate standards and service level agreements. Azure Policy runs an evaluation of your resources, scanning for those not compliant with the policy definitions you have.
AWS Config is a service that enables you to assess, audit, and evaluate the configurations of your AWS resources. Config continuously monitors and records your AWS resource configurations and allows you to automate the evaluation of recorded configurations against desired configurations.

AWS Service Control Policies (SCP) can be thought to be equivalent to Azure Policies + RBAC.

5. AWS Elastic IP and Azure Static IP

An Elastic IP address in AWS is a static, public IPv4 address designed for dynamic cloud computing. You can associate an Elastic IP address with any instance or network interface in any VPC in your account. Public IP addresses are dynamic - i.e. if you stop/start your instance you get reassigned a new public IP. Elastic IPs get allocated to your account, and stay the same - it's up to you to attach them to an instance or not. You could say they are static public IP addresses.
Azure supports Static Public IPs that is equivalent to Elastic IP in AWS. Static Public IPs can be mapped to a VM's NIC (elastic IP equivalent) or to a load balancer's Front end IP.

References
MS Docs
AWS Docs
StackOverFlow

Connecting the dots.. from Azure to AWS - Part 1

Surjyo Bhattacharya — Tue, 14 Sep 2021 03:04:16 +0000

Way back in my graduation days, our professor in the physics class was asking to look at the parity between forces of nature.
Gravitational force is directly proportional to mass and indirectly proportional to the square of the distance between the two objects. Electrostatic forces follow similar principle (replace mass by charge). So there is a principal of parity.

Coming to the cloud platform , I jumped into Azure which was natural coming from Microsoft technologies background. Now when I am required to learn AWS cloud platform, I was trying to bring the principal of parity i.e. connecting the dots of the artifacts between the 2 platforms.

1. Availability Zones and Availability Regions

Azure Region -- > AWS Region
Azure Availability Region --> AWS Availability Zones

2. Portal

https://portal.azure.com
--> https://aws.amazon.com/console/
AZURE CLI --> AWS CLI (can be launched from the portal itself)

3. Account

In Azure, there is a structure, where in Azure subscriptions with its assigned owner is created and all resources are created as part of the subscription. In AWS any resources created under the AWS account are tied to that account.

4. Identity

Azure Active Directory (Azure AD) --> Identity & Access Management (IAM) services in AWS

Although Azure Active directory can not be considered an exact equivalent to the Windows Active Directory , but it offers quite a bit of flexibility to implement multi-cloud identity solutions.

5.RBAC - IAM Policies

A policy is an object in AWS that, when associated with an identity or resource, defines their permissions. AWS evaluates these policies when an IAM principal (user or role) makes a request. Permissions in the policies determine whether the request is allowed or denied. AWS supports six types of policies: identity-based policies, resource-based policies, permissions boundaries, Organizations SCPs, ACLs, and session policies.

In Azure we have RBAC policies. The policies at the role level when applied to users or groups will give the entities access or restrict access to the resources based on the policies.

6.Virtual Machines

Azure Virtual Machines --> Amazon EC2

AWS instance types and Azure virtual machine sizes are categorized similarly, but the RAM, CPU, and storage capabilities differ between the two.

7.VM Disk Storage

Durable data storage for Azure VMs is provided by data disks residing in blob storage.
EC2 instances store disk volumes on Elastic Block Store (EBS). Azure temporary storage also provides VMs with the same low-latency temporary read-write storage as ###EC2 Instance Storage### (also called ephemeral storage). Azure Files provides the VMs with the same functionality as Amazon EFS.

Higher performance disk I/O is supported using Azure premium storage. This is similar to the Provisioned IOPS storage options provided by AWS.

8. Azure Traffic Manager - AWS Route53

In AWS, Route 53 provides both DNS name management and DNS-level traffic routing and failover services.
In Azure this is handled through two services: Azure DNS provides domain and DNS management.
Traffic Manager provides DNS level traffic routing, load balancing, and failover capabilities.

Clearing the AZ 400

Surjyo Bhattacharya — Mon, 16 Aug 2021 09:10:12 +0000

This is my first attempt to writing something in the web.
I am going down to pen down my learning experience.

I went through Alan Rodrigues course on AZ 400 from Udemy.
The course content is awesome. I followed through along with the course and did the labs, this gives oneself a confidence while trying to attempt the practice questions.

The practice questions in Alans course are excellent. In addition I had purchased the practice questions from Whizlabs for AZ 400 and the explanations provided against each answers were pretty good. Along with that I also used another practice question set from Udemy from Bhuvaneswaran B . The explanations given there are also good.

A note of caution , not all practice exam courses are good and few can be misleading. At the end of the day you either you have to back your self , refer from Microsoft learn/docs or do the scenarios practically to confirm the outcome.

Comparing with other AZ series examinations, I felt AZ 400 covers a very vast range of stuff. Although it may no get very deep into the various technologies, but the range of tools and functionalities it covers is pretty large.

I had a good experience learning the new stuff!