云存储>> web-app-redis-sql-db>> 返回
项目作者： paolosalvatori

项目描述 ：
This sample shows how to configure an Azure App Service to access Azure Cache for Redis and Azure SQL Database via regional VET integration and Private Endpoints
高级语言： JavaScript
项目地址: git://github.com/paolosalvatori/web-app-redis-sql-db.git
创建时间： 2021-03-26T11:40:47Z
项目社区：https://github.com/paolosalvatori/web-app-redis-sql-db
开源协议：MIT License
下载


products: azure, aspnet, azure-application-insights, azure-app-service, azure-blob-storage, azure-storage-accounts, azure-sql, azure-cache-for-redis, azure-database, azure-web-app, azure-log-analytics, azure-nat-gateway, azure-virtual-machines, vs-code

How to configure an Azure Web App to call Azure Cache for Redis and Azure SQL Database via Private Endpoints

This sample shows how to deploy an infrastructure and network topology on Azure where an ASP.NET Core web application hosted by an Azure App Service accesses data from Azure Cache for Redis and Azure SQL Database using Azure Private Endpoints. The Azure Web App is hosted in a Standard, Premium, PremiumV2, PremiumV3 with Regional VNET Integration.
Private endpoints are fully supported also by the Standard tier of Azure Cache for Redis. However, to use private endpoints, an Azure Cache for Redis instance needs to have been created after July 28th, 2020. Currently, zone redundancy, portal console support, and persistence to firewall storage accounts are not supported.

This sample also shows how to:

  • use a system-assigned managed identity to let the Web App access secrets from Azure Key Vault
  • deploy an ASP.NET Core application to an Azure App Service using a GitHub Actions workflow

  • disable the public network access from the internet to all the managed services used by the application:

    • Azure Blob Storage Account
    • Azure Key Vault
    • Azure Cache for Redis
    • Azure SQL Database
    • Azure Application Insights

As an alternative solution, this sample also shows how to deploy Premium Azure Cache for Redis in a virtual network. When an Azure Cache for Redis instance is configured with a virtual network, it isn’t publicly addressable and can only be accessed from virtual machines and applications within the virtual network.

For more information, see:

In addition, Azure Web Apps can be configured to be called via a private IP address by applications located in the same virtual network, or in a peered network, or on-premises via ExpressRoute or a S2S VPN. For more information, see:

Deploy to Azure

You can use the following button to deploy the demo to your Azure subscription:

Azure Cache for Redis via Private Endpoints

Deploy to Azure

Azure Cache for Redis in a virtual network

Deploy to Azure

Architecture

The following picture shows the architecture and network topology of the first solution where a Standard Azure Cache for Redis is accessed by an Azure Web App via Regional VNET Integration and Azure Private Endpoints.

Architecture with Azure Cache for Redis accessed via Private Endpoint

The ARM template deploys the following resources:

  • Virtual Network: this virtual network is composed of the following subnets:
    • WebAppSubnet: this subnet is used for the regional VNET integration with the Azure Web App app hosted by a Premium Plan. For more information, see Using Private Endpoints for Azure Web App.
    • PrivateEndpointSubnet: hosts the private endpoints used by the application.
    • VirtualMachineSubnet: hosts the jumpbox virtual machine and any additional virtual machine used by the solution.
    • AzureBastionSubnet: hosts Azure Bastion. For more information, see Working with NSG access and Azure Bastion.
  • Network Security Group: this resource contains an inbound rule to allow access to the jumpbox virtual machine on port 3389 (RDP)
  • A Windows 10 virtual machine. This virtual machine can be used as jumpbox virtual machine to simulate a real application and send requests to the Azure Web Apps exposed via Azure Private Link.
  • A Public IP for Azure Bastion
  • Azure Bastion is used to access the jumpbox virtual machine from the Azure Portal via RDP. For more information, see What is Azure Bastion?.
  • An ADLS Gen 2 storage account used to store the boot diagnostics logs of the virtual machine as blobs
  • A Standard, Premium, PremiumV2, PremiumV3 hosting plan that supports Regional VNET Integration
  • An Azure App Service containing an ASP.NET Core application that uses a system-assigned managed identity to read settings from Key vault. The web site is a single page application that stores data in Azure SQL Database and caches items in Azure Cache for Redis.
  • An Application Insights resource used by the Azure Web Apps app to store logs, traces, requests, exceptions, and metrics. For more information, see Web application monitoring on Azure.
  • An Azure SQL Server and Azure SQL Database hosting the ProductDB relational database used by the Web App.

  • An Azure Key Vault used to store the following application settings. These settings are automtically created by the ARM template as secrets in Azure Key Vault:

    • Azure Cache for Redis connection string
    • Azure SQL Database connection string
    • Application Insights Instrumentation Key

  • A private endpoint to the:

    • Azure Blob storage account (boot diagnostics logs)
    • Azure Cache for Redis
    • Azure SQL Database
    • Azure Key Vault

  • A Private DNS Zone Group to link each private endpoint with the corresponding Private DNS Zone.

  • The NIC used by the jumpbox virtual machine and for each private endpoint.
  • A Log Analytics workspace used to monitor the health status of the services such as the hosting plan or NSG.
  • A Private DNS Zone for Azure Blob Storage Account private endpoint (privatelink.blob.core.windows.net)
  • A Private DNS Zone for Azure Cache for Redis private endpoint (privatelink.redis.cache.windows.net)
  • A Private DNS Zone for Azure SQL Database private endpoint (privatelink.database.windows.net)
  • A Private DNS Zone for Azure Key Vault private endpoint (privatelink.vaultcore.azure.net)

The following picture shows the architecture and network topology of the first solution where a Standard Azure Cache for Redis is accessed by an Azure Web App via Regional VNET Integration and Azure Private Endpoints.

Architecture with Azure Cache for Redis accessed in a VNET

The ARM template deploys the following resources:

  • Virtual Network: this virtual network is composed of the following subnets:
    • WebAppSubnet: this subnet is used for the regional VNET integration with the Azure Web App app hosted by a Premium Plan. For more information, see Using Private Endpoints for Azure Web App.
    • PrivateEndpointSubnet: hosts the private endpoints used by the application.
    • VirtualMachineSubnet: hosts the jumpbox virtual machine and any additional virtual machine used by the solution.
    • AzureBastionSubnet: hosts Azure Bastion. For more information, see Working with NSG access and Azure Bastion.
    • RedisCacheSubnet: hosts the Premium Azure Cache for Redis
  • Network Security Group: this resource contains an inbound rule to allow access to the jumpbox virtual machine on port 3389 (RDP)
  • A Windows 10 virtual machine. This virtual machine can be used as jumpbox virtual machine to simulate a real application and send requests to the Azure Web Apps exposed via Azure Private Link.
  • Azure Bastion is used to access the jumpbox virtual machine from the Azure Portal via RDP. For more information, see What is Azure Bastion?.
  • An ADLS Gen 2 storage account used to store the boot diagnostics logs of the virtual machine as blobs
  • A Standard, Premium, PremiumV2, PremiumV3 hosting plan that supports Regional VNET Integration
  • An Azure App Service containing an ASP.NET Core application that uses a system-assigned managed identity to read settings from Key vault. The web site is a single page application that stores data in Azure SQL Database and caches items in Azure Cache for Redis.
  • An Application Insights resource used by the Azure Web Apps app to store logs, traces, requests, exceptions, and metrics. For more information, see Web application monitoring on Azure.
  • An Azure SQL Server and Azure SQL Database hosting the ProductDB relational database used by the Web App.

  • An Azure Key Vault used to store the following application settings. These settings are automtically created by the ARM template as secrets in Azure Key Vault:

    • Azure Cache for Redis connection string
    • Azure SQL Database connection string
    • Application Insights Instrumentation Key

  • A private endpoint to the:

    • Azure Blob storage account (boot diagnostics logs)
    • Azure SQL Database
    • Azure Key Vault

  • A Private DNS Zone Group to link each private endpoint with the corresponding Private DNS Zone.

  • The NIC used by the jumpbox virtual machine and for each private endpoint.
  • A Log Analytics workspace used to monitor the health status of the services such as the hosting plan or NSG.
  • A Private DNS Zone for Azure Blob Storage Account private endpoint (privatelink.blob.core.windows.net)
  • A Private DNS Zone for Azure SQL Database private endpoint (privatelink.database.windows.net)
  • A Private DNS Zone for Azure Key Vault private endpoint (privatelink.vaultcore.azure.net)

Important Notes

The two ARM templates disable the public access to both Azure SQL Database and Azure Cache for Redis via the publicNetworkAccess parameter which default value is set to false. Using private endpoints is not enough to secure an application, you also have to disable the public access to the managed services used by the application, in this case Azure SQL Database and Azure Cache for Redis.

In addition, both ARM templates automatically create the connection string to both the Azure Cache for Redis and Azure SQL Database as application settings of the Azure App Service. However, in a production environment, it’s recommended to access adopt one of the following approaches:

Prerequisites

The following components are required to run this sample:

Topology Deployment

You can use the ARM template and Bash script included in the sample to deploy to Azure the entire infrastructure necessary to host the demo:

  1. #!/bin/bash
  3. # Clear the screen
  4. clear
  6. # Print the menu
  7. echo "================================================="
  8. echo "Install Demo. Choose an option (1-3): "
  9. echo "================================================="
  10. options=("Inject Premium Azure Cache for Redis in a VNET"
  11.          "Azure Cache for Redis with Azure Private Link"
  12.          "Quit")
  14. # Select an option
  15. COLUMNS=0
  16. select opt in "${options[@]}"; do
  17.     case $opt in
  18.     "Inject Premium Azure Cache for Redis in a VNET")
  19.         template="../templates/azuredeploy.vnet.json"
  20.         parameters="../templates/azuredeploy.vnet.parameters.json"
  21.         resourceGroupName="WebAppSqlDbRedisInVnetRG"
  22.         break
  23.         ;;
  24.     "Azure Cache for Redis with Azure Private Link")
  25.         template="../templates/azuredeploy.endpoint.json"
  26.         parameters="../templates/azuredeploy.endpoint.parameters.json"
  27.         resourceGroupName="WebAppSqlDbRedisCacheRG"
  28.         break
  29.         ;;
  30.     "Quit")
  31.         exit
  32.         ;;
  33.     *) echo "invalid option $REPLY" ;;
  34.     esac
  35. done
  37. # Variables
  38. location="WestEurope"
  40. # SubscriptionId of the current subscription
  41. subscriptionId=$(az account show --query id --output tsv)
  42. subscriptionName=$(az account show --query name --output tsv)
  44. # Check if the resource group already exists
  45. createResourceGroup() {
  46.     local resourceGroupName=$1
  47.     local location=$2
  49.     # Parameters validation
  50.     if [[ -z $resourceGroupName ]]; then
  51.         echo "The resource group name parameter cannot be null"
  52.         exit
  53.     fi
  55.     if [[ -z $location ]]; then
  56.         echo "The location parameter cannot be null"
  57.         exit
  58.     fi
  60.     echo "Checking if [$resourceGroupName] resource group actually exists in the [$subscriptionName] subscription..."
  62.     if ! az group show --name "$resourceGroupName" &>/dev/null; then
  63.         echo "No [$resourceGroupName] resource group actually exists in the [$subscriptionName] subscription"
  64.         echo "Creating [$resourceGroupName] resource group in the [$subscriptionName] subscription..."
  66.         # Create the resource group
  67.         if az group create --name "$resourceGroupName" --location "$location" 1>/dev/null; then
  68.             echo "[$resourceGroupName] resource group successfully created in the [$subscriptionName] subscription"
  69.         else
  70.             echo "Failed to create [$resourceGroupName] resource group in the [$subscriptionName] subscription"
  71.             exit
  72.         fi
  73.     else
  74.         echo "[$resourceGroupName] resource group already exists in the [$subscriptionName] subscription"
  75.     fi
  76. }
  78. # Validate the ARM template
  79. validateTemplate() {
  80.     local resourceGroupName=$1
  81.     local template=$2
  82.     local parameters=$3
  83.     local arguments=$4
  85.     # Parameters validation
  86.     if [[ -z $resourceGroupName ]]; then
  87.         echo "The resource group name parameter cannot be null"
  88.     fi
  90.     if [[ -z $template ]]; then
  91.         echo "The template parameter cannot be null"
  92.     fi
  94.     if [[ -z $parameters ]]; then
  95.         echo "The parameters parameter cannot be null"
  96.     fi
  98.     echo "Validating [$template] ARM template..."
  100.     if [[ -z $arguments ]]; then
  101.         error=$(az deployment group validate \
  102.             --resource-group "$resourceGroupName" \
  103.             --template-file "$template" \
  104.             --parameters "$parameters"  2>&1 | grep 'ERROR:')
  105.     else
  106.         error=$(az deployment group validate \
  107.             --resource-group "$resourceGroupName" \
  108.             --template-file "$template" \
  109.             --parameters "$parameters" \
  110.             --arguments $arguments   2>&1 | grep 'ERROR:')
  111.     fi
  113.     if [[ -z $error ]]; then
  114.         echo "[$template] ARM template successfully validated"
  115.     else
  116.         echo "Failed to validate the [$template] ARM template"
  117.         echo "$error"
  118.         exit 1
  119.     fi
  120. }
  122. # Deploy ARM template
  123. deployTemplate() {
  124.     local resourceGroupName=$1
  125.     local template=$2
  126.     local parameters=$3
  127.     local arguments=$4
  129.     # Parameters validation
  130.     if [[ -z $resourceGroupName ]]; then
  131.         echo "The resource group name parameter cannot be null"
  132.         exit
  133.     fi
  135.     if [[ -z $template ]]; then
  136.         echo "The template parameter cannot be null"
  137.         exit
  138.     fi
  140.     if [[ -z $parameters ]]; then
  141.         echo "The parameters parameter cannot be null"
  142.         exit
  143.     fi
  145.     # Deploy the ARM template
  146.     echo "Deploying [$template] ARM template..."
  148.     if [[ -z $arguments ]]; then
  149.          az deployment group create \
  150.             --resource-group $resourceGroupName \
  151.             --template-file $template \
  152.             --parameters $parameters 1>/dev/null
  153.     else
  154.          az deployment group create \
  155.             --resource-group $resourceGroupName \
  156.             --template-file $template \
  157.             --parameters $parameters \
  158.             --parameters $arguments 1>/dev/null
  159.     fi
  161.     if [[ $? == 0 ]]; then
  162.         echo "[$template] ARM template successfully provisioned"
  163.     else
  164.         echo "Failed to provision the [$template$] ARM template"
  165.         exit -1
  166.     fi
  167. }
  169. # Create Resource Group
  170. createResourceGroup \
  171.     "$resourceGroupName" \
  172.      "$location"
  174. # Validate ARM Template
  175. validateTemplate \
  176.     "$resourceGroupName" \
  177.     "$template" \
  178.     "$parameters"
  180. # Deploy ARM Template
  181. deployTemplate \
  182.     "$resourceGroupName" \
  183.     "$template" \
  184.     "$parameters"

Create tables and stored procedures

You can use the following ProductsDB T-SQL script to initialize the SQL database used by the ASP.NET Core application.

  1. IF OBJECT_ID('Products') > 0 DROP TABLE [Products]
  2. GO
  3. -- Create Products table
  4. CREATE TABLE [Products]
  5. (
  6.     [ProductID] [int] IDENTITY(1,1) NOT NULL ,
  7.     [Name] [nvarchar](50) NOT NULL ,
  8.     [Category] [nvarchar](50) NOT NULL ,
  9.     [Price] [smallmoney] NOT NULL
  10.         CONSTRAINT [PK_Products] PRIMARY KEY CLUSTERED 
  11.     (
  12.         [ProductID]
  13.     )
  14. )
  15. GO
  16. -- Create stored procedures
  17. IF OBJECT_ID('GetProduct') > 0 DROP PROCEDURE [GetProduct]
  18. GO
  19. CREATE PROCEDURE GetProduct
  20.     @ProductID int
  21. AS
  22. SELECT [ProductID], [Name], [Category], [Price]
  23. FROM [Products]
  24. WHERE [ProductID] = @ProductID
  25. GO
  26. IF OBJECT_ID('GetProducts') > 0 DROP PROCEDURE [GetProducts]
  27. GO
  28. CREATE PROCEDURE GetProducts
  29. AS
  30. SELECT [ProductID], [Name], [Category], [Price]
  31. FROM [Products] 
  32. GO
  33. IF OBJECT_ID('GetProductsByCategory') > 0 DROP PROCEDURE [GetProductsByCategory]
  34. GO
  35. CREATE PROCEDURE GetProductsByCategory
  36.     @Category [nvarchar](50)
  37. AS
  38. SELECT [ProductID], [Name], [Category], [Price]
  39. FROM [Products]
  40. WHERE [Category] = @Category
  41. GO
  42. IF OBJECT_ID('AddProduct') > 0 DROP PROCEDURE [AddProduct]
  43. GO
  44. CREATE PROCEDURE AddProduct
  45.     @ProductID int OUTPUT,
  46.     @Name [nvarchar](50),
  47.     @Category [nvarchar](50),
  48.     @Price [smallmoney]
  49. AS
  50. INSERT INTO Products
  51. VALUES
  52.     (@Name, @Category, @Price)
  53. SET @ProductID = @@IDENTITY
  54. GO
  55. IF OBJECT_ID('UpdateProduct') > 0 DROP PROCEDURE [UpdateProduct]
  56. GO
  57. CREATE PROCEDURE UpdateProduct
  58.     @ProductID int,
  59.     @Name [nvarchar](50),
  60.     @Category [nvarchar](50),
  61.     @Price [smallmoney]
  62. AS
  63. UPDATE Products 
  64. SET [Name] = @Name,
  65.     [Category] = @Category,
  66.     [Price] = @Price
  67. WHERE [ProductID] = @ProductID
  68. GO
  69. IF OBJECT_ID('DeleteProduct') > 0 DROP PROCEDURE [DeleteProduct]
  70. GO
  71. CREATE PROCEDURE DeleteProduct
  72.     @ProductID int
  73. AS
  74. DELETE [Products]
  75. WHERE [ProductID] = @ProductID
  76. GO
  77. -- Create test data
  78. SET NOCOUNT ON
  79. GO
  80. INSERT INTO Products
  81. VALUES
  82.     (N'Tomato soup', N'Groceries', 1.39)
  83. GO
  84. INSERT INTO Products
  85. VALUES
  86.     (N'Babo', N'Toys', 19.99)
  87. GO
  88. INSERT INTO Products
  89. VALUES
  90.     (N'Hammer', N'Hardware', 16.49)
  91. GO

You can proceed as follows to create the tables and stored procedure in the SQL database:

  • VPN into the jumpbox virtual machine using Azure Bastion as shown in the picture below
  • Open a browser and connect to the Azure Portal
  • Open the Query Editor under the Azure SQL Database resource
  • Copy and paste the code in ProductsDB T-SQL script into a new query
  • Execute the scripts that creates the tables and some test data in the Products table used by the Web App

Resources

ASP.NET Core application

This sample provides an ASP.NET Core single-page application (SPA) to test the topology. The application reads:

  • Azure Cache for Redis connection string
  • Azure SQL Database connection string
  • Application Insights Instrumentation Key

application settings from Azure Key Vault using the following code defined in the Program class. For more information, see Azure Key Vault configuration provider in ASP.NET Core. The application uses the system-assigned managed identity of the App Service to access secrets from Azure Key Vault. The ARM template creates Key Vault, the secrets used application settings by the ASP.NET Core aaplication, and the access policies to grant permissions on secrets to the system-assigned managed identity. For more information, see How to use managed identities for App Service and Azure Functions.

Program.cs

  1. using System;
  2. using Microsoft.AspNetCore.Hosting;
  3. using Microsoft.Extensions.Configuration;
  4. using Microsoft.Extensions.Hosting;
  5. using Azure.Identity;
  6. using Azure.Security.KeyVault.Secrets;
  7. using Azure.Extensions.AspNetCore.Configuration.Secrets;
  8. using Products.Properties;
  10. namespace Products
  11. {
  12.     public class Program
  13.     {
  14.         public static void Main(string[] args)
  15.         {
  16.             CreateHostBuilder(args).Build().Run();
  17.         }
  19.         public static IHostBuilder CreateHostBuilder(string[] args) =>
  20.             Host.CreateDefaultBuilder(args)
  21.                 .ConfigureAppConfiguration((context, config) =>
  22.                 {
  23.                     var builtConfig = config.Build();
  24.                     var keyVaultUri = builtConfig[Resources.KeyVaultUri];
  25.                     if (string.IsNullOrEmpty(keyVaultUri))
  26.                     {
  27.                         throw new Exception("KeyVaultUri parameter in the appsettings.json cannot be null or empty");
  28.                     }
  29.                     var secretClient = new SecretClient(
  30.                         new Uri(keyVaultUri),
  31.                         new DefaultAzureCredential());
  32.                     config.AddAzureKeyVault(secretClient, new KeyVaultSecretManager());
  33.                 })
  34.                 .ConfigureWebHostDefaults(webBuilder => webBuilder.UseStartup<Startup>());
  35.     }
  36. }

The application makes use of the following libraries and features:

Startup.cs

  1. using System;
  2. using Microsoft.OpenApi.Models;
  3. using Microsoft.AspNetCore.Builder;
  4. using Microsoft.AspNetCore.Hosting;
  5. using Microsoft.Extensions.Configuration;
  6. using Microsoft.Extensions.DependencyInjection;
  7. using Microsoft.Extensions.Hosting;
  8. using Microsoft.EntityFrameworkCore;
  9. using StackExchange.Redis;
  10. using Products.Properties;
  11. using Products.Models;
  12. using Products.Helpers;
  14. namespace Products
  15. {
  16.     public class Startup
  17.     {
  18.         /// <summary>
  19.         /// Creates an instance of the Startup class
  20.         /// </summary>
  21.         /// <param name="configuration">The configuration created by the CreateDefaultBuilder.</param>
  22.         public Startup(IConfiguration configuration)
  23.         {
  24.             Configuration = configuration;
  25.         }
  27.         /// <summary>
  28.         /// Gets or sets the Configuration property.
  29.         /// </summary>
  30.         public IConfiguration Configuration { get; }
  32.         /// <summary>
  33.         /// This method gets called by the runtime. Use this method to add services to the container.
  34.         /// </summary>
  35.         /// <param name="services">The services collection.</param>
  36.         public void ConfigureServices(IServiceCollection services)
  37.         {
  38.             services.AddControllersWithViews();
  39.             services.AddApplicationInsightsTelemetry(Configuration[Resources.ApplicationInsightsConnectionString]);
  40.             services.AddOptions();
  41.             services.AddMvc();
  42.             services.AddSingleton<IConnectionMultiplexer>(ConnectionMultiplexer.Connect(Configuration.GetConnectionString(Resources.RedisCacheConnectionString)));
  43.             services.AddDbContext<ProductsContext>(options => options.UseSqlServer(Configuration.GetConnectionString(Resources.SqlServerConnectionString)));
  45.             // Register the Swagger generator, defining one or more Swagger documents
  46.             services.AddSwaggerGen(c =>
  47.             {
  48.                 c.SwaggerDoc("v1", new OpenApiInfo
  49.                 {
  50.                     Version = "v1",
  51.                     Title = "Products API",
  52.                     Description = "A simple example ASP.NET Core Web API",
  53.                     TermsOfService = new Uri("https://www.apache.org/licenses/LICENSE-2.0"),
  54.                     Contact = new OpenApiContact
  55.                     {
  56.                         Name = "Paolo Salvatori",
  57.                         Email = "paolos@microsoft.com",
  58.                         Url = new Uri("https://github.com/paolosalvatori")
  59.                     },
  60.                     License = new OpenApiLicense
  61.                     {
  62.                         Name = "Use under Apache License 2.0",
  63.                         Url = new Uri("https://www.apache.org/licenses/LICENSE-2.0")
  64.                     }
  65.                 });
  66.             });
  67.         }
  69.         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
  70.         public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  71.         {
  72.             if (env.IsDevelopment())
  73.             {
  74.                 app.UseDeveloperExceptionPage();
  75.             }
  76.             else
  77.             {
  78.                 app.UseExceptionHandler("/Home/Error");
  79.                 // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
  80.                 app.UseHsts();
  81.             }
  83.             // Enable middleware to serve generated Swagger as a JSON endpoint.
  84.             app.UseSwagger();
  86.             // Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.), specifying the Swagger JSON endpoint.
  87.             app.UseSwaggerUI(c =>
  88.             {
  89.                 c.SwaggerEndpoint("/swagger/v1/swagger.json", "TodoList API V1");
  90.                 c.RoutePrefix = "swagger";
  91.             });
  93.             app.UseHttpsRedirection();
  94.             app.UseStaticFiles();
  96.             app.UseRouting();
  98.             app.UseAuthorization();
  100.             app.UseEndpoints(endpoints =>
  101.             {
  102.                 endpoints.MapControllerRoute(
  103.                     name: "default",
  104.                     pattern: "{controller=Home}/{action=Index}/{id?}");
  105.             });
  106.         }
  107.     }
  108. }

The table below shows the code of the REST API implemented by the ProductsController class. This API is called via jQuery by the client-side script running in the single-page application.

  1. using System;
  2. using System.Linq;
  3. using System.Data;
  4. using System.Diagnostics;
  5. using System.Threading.Tasks;
  6. using System.Globalization;
  7. using Microsoft.AspNetCore.Mvc;
  8. using Microsoft.Data.SqlClient;
  9. using Microsoft.Extensions.Logging;
  10. using Microsoft.EntityFrameworkCore;
  11. using StackExchange.Redis;
  12. using Products.Models;
  13. using Products.Properties;
  14. using Products.Helpers;
  16. namespace Products.Controllers
  17. {
  18.     [Route("api/[controller]")]
  19.     [Produces("application/json")]
  20.     [ApiController]
  21.     public class ProductsController : ControllerBase
  22.     {
  23.         #region Private Instance Fields
  24.         private readonly ILogger<ProductsController> logger;
  25.         private readonly ProductsContext context;
  26.         private readonly IDatabase database;
  27.         #endregion
  29.         #region Public Constructors
  30.         public ProductsController(ILogger<ProductsController> logger,
  31.                                   ProductsContext context,
  32.                                   IConnectionMultiplexer connectionMultiplexer)
  33.         {
  34.             this.logger = logger;
  35.             this.context = context;
  36.             database = connectionMultiplexer.GetDatabase();
  37.         }
  38.         #endregion
  40.         #region Public Methods
  41.         /// <summary>
  42.         /// Gets all the products.
  43.         /// </summary>
  44.         /// <returns>All the products.</returns>
  45.         /// <response code="200">Get all the products, if any.</response>
  46.         [HttpGet]
  47.         [ProducesResponseType(typeof(Product), 200)]
  48.         public async Task<IActionResult> GetAllProductsAsync()
  49.         {
  50.             var stopwatch = new Stopwatch();
  52.             try
  53.             {
  54.                 stopwatch.Start();
  55.                 logger.LogInformation("Listing all products...");
  56.                 var values = await database.SetMembersAsync(Resources.RedisKeys);
  57.                 var items = await database.GetAsync<Product>(values.Select(v => (string)v).ToArray());
  58.                 if (items.Any())
  59.                 {
  60.                     var list = items.ToList();
  61.                     list.Sort((x, y) => x.ProductId - y.ProductId);
  62.                     return new OkObjectResult(list.ToArray());
  63.                 }
  64.                 var products = context.Products.FromSqlRaw(Resources.GetProducts);
  65.                 foreach (var product in products)
  66.                 {
  67.                     var idAsString = product.ProductId.ToString(CultureInfo.InvariantCulture);
  68.                     await database.SetAsync(idAsString, product);
  69.                     await database.SetAddAsync(Resources.RedisKeys, idAsString);
  70.                 }
  71.                 return new OkObjectResult(products.ToArray());
  72.             }
  73.             catch (Exception ex)
  74.             {
  75.                 var errorMessage = MessageHelper.FormatException(ex);
  76.                 logger.LogError(errorMessage);
  77.                 return StatusCode(400, new { error = errorMessage });
  78.             }
  79.             finally
  80.             {
  81.                 stopwatch.Stop();
  82.                 logger.LogInformation($"GetAllProductsAsync method completed in {stopwatch.ElapsedMilliseconds} ms.");
  83.             }
  84.         }
  86.         /// <summary>
  87.         /// Gets a specific product by id.
  88.         /// </summary>
  89.         /// <param name="id">Id of the product.</param>
  90.         /// <returns>Product with the specified id.</returns>
  91.         /// <response code="200">Product found</response>
  92.         /// <response code="404">Product not found</response>     
  93.         [HttpGet("{id}", Name = "GetProductByIdAsync")]
  94.         [ProducesResponseType(typeof(Product), 200)]
  95.         [ProducesResponseType(typeof(Product), 404)]
  96.         public async Task<IActionResult> GetProductByIdAsync(int id)
  97.         {
  98.             var stopwatch = new Stopwatch();
  100.             try
  101.             {
  102.                 stopwatch.Start();
  103.                 logger.LogInformation($"Getting product {id}...");
  104.                 var product = await database.GetAsync<Product>(id.ToString());
  105.                 if (product != null)
  106.                 {
  107.                     return new OkObjectResult(product);
  108.                 }
  110.                 var products = context.Products.FromSqlRaw(Resources.GetProduct, new SqlParameter
  111.                 {
  112.                     ParameterName = "@ProductID",
  113.                     Direction = ParameterDirection.Input,
  114.                     SqlDbType = SqlDbType.Int,
  115.                     Value = id
  116.                 });
  117.                 if (products.Any())
  118.                 {
  119.                     product = products.FirstOrDefault();
  120.                     var idAsString = product.ProductId.ToString(CultureInfo.InvariantCulture);
  121.                     await database.SetAsync(idAsString, product);
  122.                     await database.SetAddAsync(Resources.RedisKeys, idAsString);
  124.                     logger.LogInformation($"Product with id = {product.ProductId} has been successfully retrieved.");
  125.                     return new OkObjectResult(product);
  126.                 }
  127.                 else
  128.                 {
  129.                     logger.LogWarning($"No product with id = {id} was found");
  130.                     return null;
  131.                 }
  132.             }
  133.             catch (Exception ex)
  134.             {
  135.                 var errorMessage = MessageHelper.FormatException(ex);
  136.                 logger.LogError(errorMessage);
  137.                 return StatusCode(400, new { error = errorMessage });
  138.             }
  139.             finally
  140.             {
  141.                 stopwatch.Stop();
  142.                 logger.LogInformation($"GetProductByIdAsync method completed in {stopwatch.ElapsedMilliseconds} ms.");
  143.             }
  144.         }
  146.         /// <summary>
  147.         /// Creates a new product.
  148.         /// </summary>
  149.         /// <remarks>
  150.         /// </remarks>
  151.         /// <param name="product">Product to create.</param>
  152.         /// <returns>If the operation succeeds, it returns the newly created product.</returns>
  153.         /// <response code="201">Product successfully created.</response>
  154.         /// <response code="400">Product is null.</response>     
  155.         [HttpPost]
  156.         [ProducesResponseType(typeof(Product), 201)]
  157.         [ProducesResponseType(typeof(Product), 400)]
  158.         public async Task<IActionResult> CreateProductAsync(Product product)
  159.         {
  160.             var stopwatch = new Stopwatch();
  162.             try
  163.             {
  164.                 stopwatch.Start();
  165.                 if (product == null)
  166.                 {
  167.                     logger.LogWarning("Product cannot be null.");
  168.                     return BadRequest();
  169.                 }
  171.                 var productIdParameter = new SqlParameter
  172.                 {
  173.                     ParameterName = "@ProductID",
  174.                     Direction = ParameterDirection.Output,
  175.                     SqlDbType = SqlDbType.Int
  176.                 };
  178.                 var result = await context.Database.ExecuteSqlRawAsync(Resources.AddProduct, new SqlParameter[] {
  179.                     productIdParameter,
  180.                     new SqlParameter
  181.                     {
  182.                         ParameterName = "@Name",
  183.                         Direction = ParameterDirection.Input,
  184.                         SqlDbType = SqlDbType.NVarChar,
  185.                         Size = 50,
  186.                         Value = product.Name
  187.                     },
  188.                     new SqlParameter
  189.                     {
  190.                         ParameterName = "@Category",
  191.                         Direction = ParameterDirection.Input,
  192.                         SqlDbType = SqlDbType.NVarChar,
  193.                         Size = 50,
  194.                         Value = product.Category
  195.                     },
  196.                     new SqlParameter
  197.                     {
  198.                         ParameterName = "@Price",
  199.                         Direction = ParameterDirection.Input,
  200.                         SqlDbType = SqlDbType.SmallMoney,
  201.                         Value = product.Price
  202.                     }
  203.                 });
  204.                 if (result ==1 && productIdParameter.Value != null)
  205.                 {
  206.                     product.ProductId = (int)productIdParameter.Value;
  207.                     var idAsString = product.ProductId.ToString(CultureInfo.InvariantCulture);
  208.                     await database.SetAsync(idAsString, product);
  209.                     await database.SetAddAsync(Resources.RedisKeys, idAsString);
  211.                     logger.LogInformation($"Product with id = {product.ProductId} has been successfully created.");
  212.                     return CreatedAtRoute("GetProductByIdAsync", new { id = product.ProductId }, product);
  213.                 }
  214.                 return null;
  215.             }
  216.             catch (Exception ex)
  217.             {
  218.                 var errorMessage = MessageHelper.FormatException(ex);
  219.                 logger.LogError(errorMessage);
  220.                 return StatusCode(400, new { error = errorMessage });
  221.             }
  222.             finally
  223.             {
  224.                 stopwatch.Stop();
  225.                 logger.LogInformation($"CreateProductAsync method completed in {stopwatch.ElapsedMilliseconds} ms.");
  226.             }
  227.         }
  229.         /// <summary>
  230.         /// Updates a product. 
  231.         /// </summary>
  232.         /// <param name="id">The id of the product.</param>
  233.         /// <param name="product">Product to update.</param>
  234.         /// <returns>No content.</returns>
  235.         /// <response code="204">No content if the product is successfully updated.</response>
  236.         /// <response code="404">If the product is not found.</response>
  237.         [HttpPut("{id}")]
  238.         [ProducesResponseType(typeof(Product), 204)]
  239.         [ProducesResponseType(typeof(Product), 404)]
  240.         public async Task<IActionResult> Update(int id, [FromBody] Product product)
  241.         {
  242.             var stopwatch = new Stopwatch();
  244.             try
  245.             {
  246.                 stopwatch.Start();
  247.                 if (product == null || product.ProductId != id)
  248.                 {
  249.                     logger.LogWarning("The product is null or its id is different from the id in the payload.");
  250.                     return BadRequest();
  251.                 }
  253.                 var result = await context.Database.ExecuteSqlRawAsync(Resources.UpdateProduct, new SqlParameter[] {
  254.                     new SqlParameter
  255.                     {
  256.                         ParameterName = "@ProductID",
  257.                         Direction = ParameterDirection.Input,
  258.                         SqlDbType = SqlDbType.Int,
  259.                         Value = product.ProductId
  260.                     },
  261.                     new SqlParameter
  262.                     {
  263.                         ParameterName = "@Name",
  264.                         Direction = ParameterDirection.Input,
  265.                         SqlDbType = SqlDbType.NVarChar,
  266.                         Size = 50,
  267.                         Value = product.Name
  268.                     },
  269.                     new SqlParameter
  270.                     {
  271.                         ParameterName = "@Category",
  272.                         Direction = ParameterDirection.Input,
  273.                         SqlDbType = SqlDbType.NVarChar,
  274.                         Size = 50,
  275.                         Value = product.Category
  276.                     },
  277.                     new SqlParameter
  278.                     {
  279.                         ParameterName = "@Price",
  280.                         Direction = ParameterDirection.Input,
  281.                         SqlDbType = SqlDbType.SmallMoney,
  282.                         Value = product.Price
  283.                     }
  284.                 });
  286.                 if (result == 1)
  287.                 {
  288.                     var idAsString = id.ToString(CultureInfo.InvariantCulture);
  289.                     await database.SetAsync(idAsString, product);
  290.                     await database.SetAddAsync(Resources.RedisKeys, idAsString);
  292.                     logger.LogInformation("Product with id = {ID} has been successfully updated.", product.ProductId);
  293.                 }
  294.                 return new NoContentResult();
  295.             }
  296.             catch (Exception ex)
  297.             {
  298.                 var errorMessage = MessageHelper.FormatException(ex);
  299.                 logger.LogError(errorMessage);
  300.                 return StatusCode(400, new { error = errorMessage });
  301.             }
  302.             finally
  303.             {
  304.                 stopwatch.Stop();
  305.                 logger.LogInformation($"Update method completed in {stopwatch.ElapsedMilliseconds} ms.");
  306.             }
  307.         }
  309.         /// <summary>
  310.         /// Deletes a specific product.
  311.         /// </summary>
  312.         /// <param name="id">The id of the product.</param>      
  313.         /// <returns>No content.</returns>
  314.         /// <response code="202">No content if the product is successfully deleted.</response>
  315.         /// <response code="404">If the product is not found.</response>
  316.         [HttpDelete("{id}")]
  317.         [ProducesResponseType(typeof(Product), 204)]
  318.         [ProducesResponseType(typeof(Product), 404)]
  319.         public async Task<IActionResult> Delete(string id)
  320.         {
  321.             var stopwatch = new Stopwatch();
  323.             try
  324.             {
  325.                 stopwatch.Start();
  327.                 var result = await context.Database.ExecuteSqlRawAsync(Resources.DeleteProduct, new SqlParameter[] {
  328.                     new SqlParameter
  329.                     {
  330.                         ParameterName = "@ProductID",
  331.                         Direction = ParameterDirection.Input,
  332.                         SqlDbType = SqlDbType.Int,
  333.                         Value = id
  334.                     }
  335.                 });
  337.                 if (result == 1)
  338.                 {
  339.                     var idAsString = id.ToString(CultureInfo.InvariantCulture);
  340.                     await database.KeyDeleteAsync(idAsString);
  341.                     await database.SetRemoveAsync(Resources.RedisKeys, idAsString);
  343.                     logger.LogInformation("Product with id = {ID} has been successfully deleted.", id);
  344.                 }
  345.                 return new NoContentResult();
  346.             }
  347.             catch (Exception ex)
  348.             {
  349.                 var errorMessage = MessageHelper.FormatException(ex);
  350.                 logger.LogError(errorMessage);
  351.                 return StatusCode(400, new { error = errorMessage });
  352.             }
  353.             finally
  354.             {
  355.                 stopwatch.Stop();
  356.                 logger.LogInformation($"Delete method completed in {stopwatch.ElapsedMilliseconds} ms.");
  357.             }
  358.         }
  359.         #endregion
  360.     }
  361. }

Deploy the code of the ASP.NET Core application

Once the Azure resources have been deployed to Azure (which can take about 10-12 minutes), you need to deploy the ASP.NET Core web application contained in the src folder to the newly created Azure App Service. You can customize and use the deploy-web-app-to-azure.yml GitHub Actions workflow under the .github\workflow folder to deploy the application to Azure App Service. As an alternative, you can use Visual Studio Code or Visual Studio to deploy the ASP.NET Core application to the Azure App Service created by the ARM template.

Test the Application

After creating the database and deploying the Web App, you can simply navigate to the URL of your Azure App Service to check if the application is up and running, as shown in the following figure.

Resources