How to Build a Serverless Web App in Azure?

public static class GetUsers
    {
        [FunctionName("GetUsers")]
        public static async Task<IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]HttpRequest req, 
            TraceWriter log)
        {
            try
            {
                string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
                dynamic data = JsonConvert.DeserializeObject(requestBody);
                // int userId = data?.user;
 
                List<UserModel> oLst = new List<UserModel>();
 
                DbConnect dbConnect = new DbConnect();
                DataSet dsTables = dbConnect.GetDataSet("Users", "GetAllUsers");
 
                using (DataTable dtUser = dsTables.Tables["Users"])
                {
                    if (dtUser != null & dtUser.Rows.Count > 0)
                    {
                        for (int i = 0; i <= dtUser.Rows.Count - 1; i++)
                        {
                            UserModel um = new UserModel()
                            {
                                UserId = Convert.ToInt32(dtUser.Rows[i]["UserId"].ToString()),
                                UserName = dtUser.Rows[i]["UserName"].ToString(),
                                Email = dtUser.Rows[i]["Email"].ToString()
                            };
 
                            oLst.Add(um);
                        }
                    }
                }
 
                return (ActionResult)new OkObjectResult(oLst);
            }
            catch (Exception ex)
            {
                return new BadRequestObjectResult(ex.Message);
            }
        }
    }

     public class DbConnect
    {
        public DataSet GetDataSet(string dstTable, string dstSQL)
        {
            DataSet dst = new DataSet();
            DataSet dstReturn;
            SqlConnection SQLConn = new SqlConnection();
            SqlDataAdapter SQLdad;
            var connectionString = Environment.GetEnvironmentVariable("SqlConnection");
 
            try
            {
                SQLConn.ConnectionString = connectionString;
                SQLdad = new SqlDataAdapter(dstSQL, SQLConn);
                SQLdad.Fill(dst);
 
                string[] arrTable = dstTable.Split(',');
                int iPos;
                if (dst.Tables.Count > 0)
                {
                    for (iPos = 0; iPos <= arrTable.Length - 1; iPos++)
                    {
                        dst.Tables[iPos].TableName = arrTable[iPos];
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                SQLdad = null;
                if ((SQLConn != null))
                    SQLConn.Close();
                dstReturn = dst;
                dst.Dispose();
                dst = null;
            }
            return dstReturn;
        }
    }

 <ItemGroup>
    <None Include="$(USERPROFILE)\.nuget\packages\\microsoft.data.sqlclient\2.1.0\runtimes\win\lib\netcoreapp2.1\microsoft.Data.SqlClient.dll">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </None>
  </ItemGroup>
  <Target Name="CopyToBin" BeforeTargets="Build">
    <Copy SourceFiles="$(USERPROFILE)\.nuget\packages\microsoft.data.sqlclient\2.1.0\runtimes\win\lib\netcoreapp2.1\microsoft.Data.SqlClient.dll" DestinationFolder="$(OutputPath)\bin" />
  </Target>

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "AllowedHosts": "*",
  "AzureFunction": "https://<YOUR APP NAME>.azurewebsites.net/api/",
  "AzureFunctionKey": "<YOUR KEY>",
  "AzureFunction_GetUsers": "GetUsers?",
  "AzureFunction_GetUserById": "GetUserById?"
}
 
To read the appSetting.json file let create another file called AppSettings.cs
    public class AppSettings
    {
        public static IConfigurationRoot Configuration { get; set; }
 
        public static string AzureFunction
        {
            get
            {
                return Configuration["AzureFunction"].ToString();
            }
        }
 
        public static string AzureFunctionKey
        {
            get
            {
                return Configuration["AzureFunctionKey"].ToString();
            }
        }
 
        public static string AzureFunction_GetUsers
        {
            get
            {
                return AppSettings.AzureFunction + Configuration["AzureFunction_GetUsers"].ToString() + AppSettings.AzureFunctionKey;
            }
        }
 
        public static string AzureFunction_GetUserById
        {
            get
            {
                return AppSettings.AzureFunction + Configuration["AzureFunction_GetUserById"].ToString() + AppSettings.AzureFunctionKey;
            }
        }
    }

public class Startup
    {
        public Startup(IHostingEnvironment env, IServiceProvider serviceProvider)
        {
            try
            {
                var builder = new ConfigurationBuilder()
                    .SetBasePath(env.ContentRootPath)
                    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                    .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                    .AddEnvironmentVariables();
                Configuration = builder.Build();
 
                AppSettings.Configuration = Configuration;
            }
            catch (Exception)
            {
            }
        }
 
        public IConfigurationRoot Configuration { get; }
 
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.Configure<CookiePolicyOptions>(options =>
            {
                // This lambda determines whether user consent for non-essential cookies is needed for a given request.
                options.CheckConsentNeeded = context => true;
                options.MinimumSameSitePolicy = SameSiteMode.None;
            });
 
            services.AddSingleton<IConfigurationRoot>(Configuration);
            services.AddSingleton<IConfiguration>(Configuration);
 
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
        }
 
        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
                app.UseHsts();
            }
 
            app.UseHttpsRedirection();
            app.UseStaticFiles();
            app.UseCookiePolicy();
 
            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "default",
                    template: "{controller=Home}/{action=Index}/{id?}");
            });
        }
    }

public class UserModel
    {
        public int UserId { get; set; }
        public string UserName { get; set; }
        public string Email { get; set; }
    }
 
Then after inside the controller folder let’s create a new controller called: BaseController.cs
    public class BaseController : Controller
    {
        public static void SerializeJsonIntoStream(object value, Stream stream)
        {
            using (var sw = new StreamWriter(stream, new UTF8Encoding(false), 1024, true))
            using (var jtw = new JsonTextWriter(sw) { Formatting = Formatting.None })
            {
                var js = new JsonSerializer();
                js.Serialize(jtw, value);
                jtw.Flush();
            }
        }
 
        public static HttpContent CreateHttpContent(object content)
        {
            HttpContent httpContent = null;
 
            if (content != null)
            {
                var ms = new MemoryStream();
                SerializeJsonIntoStream(content, ms);
                ms.Seek(0, SeekOrigin.Begin);
                httpContent = new StreamContent(ms);
                httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            }
 
            return httpContent;
        }
 
        public static async Task<T> CallFunc<T>(string afUrl)
        {
            try
            {
                dynamic content = null;
 
                CancellationToken cancellationToken;
 
                using (var client = new HttpClient())
                using (var request = new HttpRequestMessage(HttpMethod.Post, afUrl))
                using (var httpContent = CreateHttpContent(content))
                {
                    request.Content = httpContent;
 
                    using (var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false))
                    {
                        // response.EnsureSuccessStatusCode();
 
                        var resualtList = response.Content.ReadAsAsync<T>();
                        return resualtList.Result;
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }

    public class HomeController : BaseController
    {
        public async Task<IActionResult> Index()
        {
            List<UserModel> model = new List<UserModel>();
 
            try
            {
                var AfUrl = AppSettings.AzureFunction_GetUsers;
 
                var response = await CallFunc<List<UserModel>>(AfUrl);
                if (response != null)
                {
                    model = response;
                }
 
                return View(model);
            }
            catch (Exception)
            {
                return View(model);
            }
        }
 
        public async Task<IActionResult> ViewUser(int user)
        {
            UserModel model = new UserModel();
 
            try
            {
                var AfUrl = AppSettings.AzureFunction_GetUserById + "&user=" + user;
 
                var response = await CallFunc<UserModel>(AfUrl);
                if (response != null)
                {
                    model = response;
                }
 
                return View(model);
            }
            catch (Exception)
            {
                return View(model);
            }
        }
 
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult Error()
        {
            return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
        }
    }

@model List<ServerlessWebsite.Models.UserModel>
@{
    ViewData["Title"] = "User List Page";
}
 
<table class="table table-responsive">
    <tr>
        <th>User Name</th>
        <th>Email</th>
    </tr>
    @if (Model != null && Model.Count() > 0)
    {
        foreach (var item in Model)
        {
            <tr>
                <td>@item.UserName</td>
                <td>@item.Email</td>
                <td><a href="@Url.Action("ViewUser", "Home", new { user = item.UserId })">View</a></td>
            </tr>
        }
    }
    else
    {
        <tr>
            <td colspan="2"> No record found.</td>
        </tr>
    }
</table>

@model ServerlessWebsite.Models.UserModel
@{
    ViewData["Title"] = "User List Page";
}
 
<table class="table table-responsive">
    <tr>
        <th>User Name</th>
        <th>Email</th>
    </tr>
    @if (Model != null)
    {
        <tr>
            <td>@Model.UserName</td>
            <td>@Model.Email</td>
        </tr>
    }
    else
    {
        <tr>
            <td colspan="2"> No record found.</td>
        </tr>
    }
</table>