How to Build and deploy AWS Lambda function with .NET 6

Build and deploy AWS Lambda function with .NET 6

Objective

The objective of this article to demonstrate how to build and deploy a .NET6 application in AWS lambda.

Prerequisites

Step-1: Build .NET6 based AWS lambda from Visual Studio

Create a new .NET 6 Lambda Function Project

  • Open Visual Studio and select “Create a new project” from the start page.
  • Select “AWS Lambda” from the list of project templates and click “Next”.
  • Select “AWS Lambda (.NET 6)” as the project type and give your project a name and location. Click “Create”.
    vs-create-lambda

Write Lambda function

  • Delete existing “Function.cs” file and create a new “CustomerFunctions.cs” file in the project.
  • Replace the existing code with your own Lambda function code. Here is an example of 5 Lambda function in C#:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
using Amazon.Lambda.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Amazon.Lambda.Core;
 
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
 
namespace AWSLambdaApp
{
    public class CustomerFunctions
    {
        private readonly List<Customer> _customers;
        public CustomerFunctions()
        {
            _customers = new List<Customer>
            {
                new Customer { Id = 1, Name = "Alice", Email = "Alice@example.com", Address = "G1/111 - Canary St." },
                new Customer { Id = 2, Name = "Bob", Email = "Bob@example.com", Address = "G1/112 - Canary St." },
                new Customer { Id = 3, Name = "Avi", Email = "Avi@example.com", Address = "404 - High St." }
            };
        }
        //Get all customers
        public List<Customer> GetAll(ILambdaContext context)
        {
            return _customers;
        }
        //Get all customer by Id
        public Customer GetById(int id, ILambdaContext context)
        {
            return _customers.FirstOrDefault(c => c.Id == id);
        }
        //Add new customer
        public Customer Add(Customer customer, ILambdaContext context)
        {
            _customers.Add(customer);
            return customer;
        }
        //Update existing customer
        public Customer Update(int id, Customer updatedCustomer, ILambdaContext context)
        {
            var existingCustomer = _customers.FirstOrDefault(c => c.Id == id);
            if (existingCustomer == null)
            {
                return null;
            }
            existingCustomer.Name = updatedCustomer.Name;
            existingCustomer.Email = updatedCustomer.Email;
            existingCustomer.Address = updatedCustomer.Address;
            return existingCustomer;
        }
        //Delete customer by id
        public bool Delete(int id, ILambdaContext context)
        {
            var customerToDelete = _customers.FirstOrDefault(c => c.Id == id);
            if (customerToDelete == null)
            {
                return false;
            }
            _customers.Remove(customerToDelete);
            return true;
        }
    }
}

Create a supporting model class “Customer.cs”

1
2
3
4
5
6
7
8
9
10
namespace AWSLambdaApp
{
    public class Customer
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        public string Address { get; set; }
    }
}

Now, you can build your project from Visual Studio or through command Line. Let’s build and publish Lambda code from command line:

Make sure before running commend check your “*.csproj” file contains configuration for “runtimeidentifiers” like:

<PropertyGroup>
<RuntimeIdentifiers>win10-x64;linux-x64</RuntimeIdentifiers>
</PropertyGroup>

Run the command following commands to restore, build and publish your lambda project:

dotnet restore -p:PublishReadyToRun=true -p:PublishTrimmed=true
dotnet publish -c Release --self-contained true --no-restore -r linux-x64 /p:PublishReadyToRun=true

ZIP the content from Publish Folder like “AWSLambdaApp.zip”. Your lambda function is ready to deploy in AWS.

Step-2: Deploy .NET6 based AWS lambda using cloud formation template

Create a new file called “create-lambda-functions-cf.template” and paste the following code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
{
    "AWSTemplateFormatVersion" : "2010-09-09",
    "Transform"                : "AWS::Serverless-2016-10-31",
    "Description"              : "AWS Lambda (Serverless) Application.",
    "Parameters"               : {
        "S3BucketName" : {
            "Type" : "String",
            "Description" : "S3 bucket name containing the lambda code."
        },
        "CodeZipFileName" : {
            "Type" : "String",
            "Description" : "S3 key (CodeZipFileName) for the lambda function code ZIP file."
        }
    },
    "Resources"                : {
        "LambdaExecutionRole" : {
            "Type" : "AWS::IAM::Role",
            "Properties" : {
                "AssumeRolePolicyDocument" : {
                    "Version" : "2012-10-17",
                    "Statement" : [
                        {
                            "Effect" : "Allow",
                            "Principal" : {
                                "Service" : "lambda.amazonaws.com"
                            },
                            "Action"    : "sts:AssumeRole"
                        }
                    ]
                },
                "Path"                     : "/",
                "Policies"                 : [
                    {
                        "PolicyName" : "lambda-execution-policy",
                        "PolicyDocument" : {
                            "Version" : "2012-10-17",
                            "Statement" : [
                                {
                                    "Effect" : "Allow",
                                    "Action" : [
                                        "logs:CreateLogGroup",
                                        "logs:CreateLogStream",
                                        "logs:PutLogEvents"
                                    ],
                                    "Resource" : "arn:aws:logs:*:*:*"
                                }
                            ]
                        }
                    }
                ]
            }
        },
        "GetAllCustomers"     : {
            "Type" : "AWS::Lambda::Function",
            "Properties" : {
                "Architectures" : [
                    "x86_64"
                ],
                "Handler"       : "AWSLambdaApp::AWSLambdaApp.CustomerFunctions::GetAll",
                "Runtime"       : "dotnet6",
                "MemorySize"    : 256,
                "Timeout"       : 30,
                "Role"          : {
                    "Fn::GetAtt" : [
                        "LambdaExecutionRole",
                        "Arn"
                    ]
                },
                "Code"          : {
                    "S3Bucket" : {
                        "Ref" : "S3BucketName"
                    },
                    "S3Key"    : {
                        "Ref" : "CodeZipFileName"
                    }
                }
            }
        },
        "GetCustomerById"     : {
            "Type" : "AWS::Lambda::Function",
            "Properties" : {
                "Architectures" : [
                    "x86_64"
                ],
                "Handler"       : "AWSLambdaApp::AWSLambdaApp.CustomerFunctions::GetById",
                "Runtime"       : "dotnet6",
                "MemorySize"    : 256,
                "Timeout"       : 30,
                "Role"          : {
                    "Fn::GetAtt" : [
                        "LambdaExecutionRole",
                        "Arn"
                    ]
                },
                "Code"          : {
                    "S3Bucket" : {
                        "Ref" : "S3BucketName"
                    },
                    "S3Key"    : {
                        "Ref" : "CodeZipFileName"
                    }
                }
            }
        },
        "AddCustomer"         : {
            "Type" : "AWS::Lambda::Function",
            "Properties" : {
                "Architectures" : [
                    "x86_64"
                ],
                "Handler"       : "AWSLambdaApp::AWSLambdaApp.CustomerFunctions::Add",
                "Runtime"       : "dotnet6",
                "MemorySize"    : 256,
                "Timeout"       : 30,
                "Role"          : {
                    "Fn::GetAtt" : [
                        "LambdaExecutionRole",
                        "Arn"
                    ]
                },
                "Code"          : {
                    "S3Bucket" : {
                        "Ref" : "S3BucketName"
                    },
                    "S3Key"    : {
                        "Ref" : "CodeZipFileName"
                    }
                }
            }
        },
        "UpdateCustomer"      : {
            "Type" : "AWS::Lambda::Function",
            "Properties" : {
                "Architectures" : [
                    "x86_64"
                ],
                "Handler"       : "AWSLambdaApp::AWSLambdaApp.CustomerFunctions::Update",
                "Runtime"       : "dotnet6",
                "MemorySize"    : 256,
                "Timeout"       : 30,
                "Role"          : {
                    "Fn::GetAtt" : [
                        "LambdaExecutionRole",
                        "Arn"
                    ]
                },
                "Code"          : {
                    "S3Bucket" : {
                        "Ref" : "S3BucketName"
                    },
                    "S3Key"    : {
                        "Ref" : "CodeZipFileName"
                    }
                }
            }
        },
        "DeleteCustomer"      : {
            "Type" : "AWS::Lambda::Function",
            "Properties" : {
                "Architectures" : [
                    "x86_64"
                ],
                "Handler"       : "AWSLambdaApp::AWSLambdaApp.CustomerFunctions::Delete",
                "Runtime"       : "dotnet6",
                "MemorySize"    : 256,
                "Timeout"       : 30,
                "Role"          : {
                    "Fn::GetAtt" : [
                        "LambdaExecutionRole",
                        "Arn"
                    ]
                },
                "Code"          : {
                    "S3Bucket" : {
                        "Ref" : "S3BucketName"
                    },
                    "S3Key"    : {
                        "Ref" : "CodeZipFileName"
                    }
                }
            }
        }
    }
}

This cloud formation template consists of two parts: defining an IAM role (LambdaExecutionRole) and defining five AWS Lambda functions (GetAllCustomers, GetCustomerById, AddCustomer, UpdateCustomer, and DeleteCustomer). These Lambda functions use the specified IAM role (LambdaExecutionRole) and the code for each Lambda function is stored in the specified S3 bucket name (i.e. cloudiofy-application-code) using the S3 key (i.e. AWSLambdaApp.zip).

Deployment Steps

  • Login to your AWS Console and navigate to the “CloudFormation” service
  • Click on the “Create stack” button to start the cloud formation creation process.
  • Upload your created template file “create-lambda-functions-cf.template”, Click on “Next”
    cloud-formation-create-stack
  • Specify the stack details, Click on “Next”
    lambda-app-stack-details
  • Stack failure options, Select option “Roll back all stack resources”
  • Review and , Click on “Submit”. AWS resources creation will be started as per the code in the template file. Wait till stack creation complete.
    lambda-app-stack-create-complete

Step-3: Test Lambda Function

  • Go to “Lambda” service, and validate the lambda functions created by the cloud formation template.
    lambda-function-created
  • Go to Lambda Function “GetAllCustomers” and Test the function, it should return the list of customers.
    lambda-function-test
    lambda-function-test-result

Note: Delete the cloud formation stack “customer-lambda-app-stack” to delete AWS resources created by cloudformation template.

How to Build and deploy AWS Lambda function with .NET 6
Scroll to top