Deploy Azure Verified Modules using Azure CLI (Bicep)

-

Step 1.

 First lets create a simple parameters file that will hold the main parameters we need for our infrastructure.

  1. Resouce group Name
  2. Location
{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
      "resourceGroupName": {
        "value": "ResourceGroupName"
      },
      "location": {
        "value": "westus2"
      }
    }
  } 

Step 2.

Next lets define some resources in main.bicep

  1. Resource Group
  2. Azure Keyvault
  3. Storage Account
  4. Azure Static App
  5. Server Farm (for function app)
  6. Function App

targetScope = 'subscription'

param location string
param resourceGroupName string
param deploySecrets bool = true // Condition to deploy secrets
param deployKeys bool = true // Condition to deploy keys

@description('Optional String to append to resources to make unique')
var resourceToken = uniqueString(subscription().subscriptionId, location)

@description('Create a resource group')
resource rg 'Microsoft.Resources/resourceGroups@2024-03-01' = {
  name: resourceGroupName
  location: location
}

module vault 'br/public:avm/res/key-vault/vault:0.11.2' = {
  name: 'vaultDeployment'
  scope: rg
  params: {
    // Required parameters
    name: toLower(resourceGroupName)
    // Non-required parameters
    enablePurgeProtection: true
    enableSoftDelete: true

    keys: deployKeys
      ? [
          {
            attributes: {
              exp: 1725109032
              nbf: 10000
            }
            kty: 'RSA'
            name: 'customerManagedKey'
            rotationPolicy: {
              attributes: {
                expiryTime: 'P2Y'
              }
              lifetimeActions: [
                {
                  action: {
                    type: 'Rotate'
                  }
                  trigger: {
                    timeBeforeExpiry: 'P2M'
                  }
                }
                {
                  action: {
                    type: 'Notify'
                  }
                  trigger: {
                    timeBeforeExpiry: 'P30D'
                  }
                }
              ]
            }
          }
        ]
      : []
    secrets: deploySecrets
      ? [
          {
            attributes: {
              enabled: true
              exp: 1702648632
              nbf: 10000
            }
            contentType: 'Something'
            name: 'secretName'
            value: 'secretValue'
          }
        ]
      : []
  }
}

@description('Create a static web app')
module swa 'br/public:avm/res/web/static-site:0.3.0' = {
  name: 'client'
  scope: rg
  params: {
    name: toLower(resourceGroupName)
    location: location
    sku: 'Free'
  }
}

@description('Create a storage account')
module storageAccount 'br/public:avm/res/storage/storage-account:0.17.0' = {
  name: 'storageAccountDeployment'
  scope: rg
  params: {
    // Required parameters
    name: toLower(resourceGroupName)
    allowBlobPublicAccess: false
    // Non-required parameters
    kind: 'BlobStorage'
    location: location
    skuName: 'Standard_LRS'
    blobServices: {
      containers: [
        {
          name: 'stocks'
          publicAccess: 'None'
        }
        {
          name: 'users'
          publicAccess: 'None'
        }
      ]
    }
    // customerManagedKey: {
    //   keyName: 'customerManagedKey'
    //   keyVaultResourceId: vault.outputs.resourceId
    // }
    managedIdentities: {
      systemAssigned: true
    }
  }
}

@description('Create a server farm')
module serverfarm 'br/public:avm/res/web/serverfarm:0.4.1' = {
  name: 'serverfarmDeployment'
  scope: rg
  params: {
    kind: 'functionApp'
    zoneRedundant: false
    name: toLower(resourceGroupName)
    skuName: 'Y1'
    skuCapacity: 0
    targetWorkerCount: 0
    targetWorkerSize: 0
    maximumElasticWorkerCount: 1
    reserved: true
    perSiteScaling: false
    elasticScaleEnabled: false
  }
}

@description('Create a function app')
module site 'br/public:avm/res/web/site:0.13.1' = {
  name: 'siteDeployment'
  scope: rg
  params: {
    // Required parameters
    kind: 'functionapp'
    name: toLower(resourceGroupName)
    serverFarmResourceId: serverfarm.outputs.resourceId
    siteConfig: {
      alwaysOn: false
      appSettings: [
        {}
      ]
      httpsOnly: true
      ftpsState: 'FtpsOnly'
      minTlsVersion: '1.2'
    }
  }
}

@description('Output the default hostname')
output endpoint string = swa.outputs.defaultHostname

@description('Output the static web app name')
output staticWebAppName string = swa.outputs.name

Comments

Post a Comment

Popular posts from this blog

Configuring Any .NET 9.0 Program to Run in Docker: A Step-by-Step Guide

-
Docker provides a consistent runtime environment for running .NET applications, enabling seamless development and deployment across various platforms. This guide explains how to configure any .NET program to run in Docker, explores project types compatible with Docker, and provides examples for Web API and Console Applications . Understanding the Docker Configuration in launchSettings.json The launchSettings.json file in .NET projects includes profiles for debugging and running applications. When configured for Docker, a typical profile might look like this: json "Container (Dockerfile)" : { "commandName" : "Docker" , "launchUrl" : "{Scheme}://{ServiceHost}:{ServicePort}" , "environmentVariables" : { "ASPNETCORE_HTTPS_PORTS" : "8081" , "ASPNETCORE_HTTP_PORTS" : "8080" } , "publishAllPorts" : true , "useSSL" : true } Key Propertie...
Read more

Understand .NET 9.0 Blazor Hosting Models

-
Blazor comes in three hosting models: Blazor Server , Blazor WebAssembly (WASM) , and Blazor Hybrid . Each model has unique requirements for setup in the Program.cs file and routing. Let's break down what is needed for each. 1. Blazor Server Blazor Server runs the app on the server, with the UI updates sent to the client over a real-time SignalR connection. Key Setup in Program.cs csharp var builder = WebApplication.CreateBuilder(args); // Add Blazor Server services builder.Services.AddServerSideBlazor() .AddCircuitOptions(options => options.DetailedErrors = true ); // Optional: Enable detailed errors var app = builder.Build(); // Map the Blazor Server app app.MapBlazorHub(); // Maps SignalR hub for real-time communication app.MapFallbackToPage( "/_Host" ); // Fallback route to load the app app.Run(); Router The _Host.cshtml file serves as the entry point. Routes are managed server-side. Example: razor <Router AppAssembly="typeof(Program).Ass...
Read more

Understanding a Multi-Stage Dockerfile for .NET 9 Application

-
Dockerfiles are essential for containerizing applications, allowing developers to package code, dependencies, and runtime environments into lightweight, portable containers. In this article, we’ll explore a multi-stage Dockerfile designed for a .NET Web API project named SampleWebAPI . This Dockerfile employs best practices to create a lightweight and secure container image while maintaining an efficient build process. Dockerfile Overview This Dockerfile is structured into multiple stages, each focusing on a specific phase of the containerization process: Debug Stage : Prepares the runtime environment for debugging. Build Stage : Compiles the application code. Publish Stage : Prepares the application for deployment. Runtime Stage : Creates the final container image for production. Debug Stage dockerfile FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base USER $APP_UID WORKDIR /app EXPOSE 8080 EXPOSE 8081 Base Image : Uses the official ASP.NET Core runtime image ( aspnet:9.0 ) to provide...
Read more