We can use React native, an open source mobile application framework by Facebook, to develop application for Android, IOS, UWP, and Web. In this post, we will see how we can release a React native Android application to Google play store with custom app signing, custom app version configured from Azure DevOps pipeline build number. Sounds interesting, right?

Prerequisites

1. Make sure you have a React native application. You can follow this doc to create a dummy application.
2. Azure DevOps

Create a dummy android pipeline

Go to Pipelines in Azure DevOps and click on New pipeline, select Azure Devops, select your repository. In the Configure your pipeline section, select Android.

Rename your YAML file and click save. You don’t have to run your pipeline yet.

Application Configuration

Before we create the pipeline, let’s do some configuration in our application.

Update the Gradle file

A gradle file helps us to,

• Add libraries and dependencies
• Define how to build different environments (debug vs. release)
• Sign Android APKs/AABs
• Automate tasks (e.g., tests, publishing, versioning)

Configure the app versioning

By default, the app gets the verson that is mentioned in the app.json file in the root folder. Just like all the other deployments, it is a great idea to have our app version name and app version code configured to the build number and build id from the pipeline. To do that let’s do the changes below in the android\build.gradle file. Remember there is also another build.gradle file in android/app folder. Under the buildscript section, add the below methods.

def getMyVersionCode = { ->
        def code = project.hasProperty('versionCode') ? versionCode.toInteger() : -1
        println "VersionCode is set to $code"
        return code
    }

    def getMyVersionName = { ->
        def name = project.hasProperty('versionName') ? versionName : "1.0"
        println "VersionName is set to $name"
        return name
    }

Update the ext section as below.

ext {
        buildToolsVersion = "35.0.0"
        minSdkVersion = 24
        compileSdkVersion = 35
        targetSdkVersion = 34
        ndkVersion = "26.1.10909125"
        kotlinVersion = "1.9.24"
        versionName = getMyVersionName()
        versionCode = getMyVersionCode()
    }

Below is the full android/build.gradle file content.

buildscript {
    def getMyVersionCode = { ->
        def code = project.hasProperty('versionCode') ? versionCode.toInteger() : -1
        println "VersionCode is set to $code"
        return code
    }

    def getMyVersionName = { ->
        def name = project.hasProperty('versionName') ? versionName : "1.0"
        println "VersionName is set to $name"
        return name
    }
    ext {
        buildToolsVersion = "35.0.0"
        minSdkVersion = 24
        compileSdkVersion = 35
        targetSdkVersion = 34
        ndkVersion = "26.1.10909125"
        kotlinVersion = "1.9.24"
        versionName = getMyVersionName()
        versionCode = getMyVersionCode()
    }
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath("com.android.tools.build:gradle")
        classpath("com.facebook.react:react-native-gradle-plugin")
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin")
    }
}

apply plugin: "com.facebook.react.rootproject"

Now go to the android\app\build.gradle file and use the new configs there. Under the android section, go to the defaultConfig and add the content below.

versionCode rootProject.ext.versionCode
versionName rootProject.ext.versionName

Your final defaultConfig would looks like below.

defaultConfig {
        applicationId "com.yourapplicationid"
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
        versionCode rootProject.ext.versionCode
        versionName rootProject.ext.versionName

        manifestPlaceholders = [
            appAuthRedirectScheme: "com.yourapplicationid"
        ]
    }

Create and upload keystore to the Secure files

By default the app uses debug configuration to sign, you can see this setting signingConfigs.debug in the section buildTypes for release. You can also see that in the both cases it uses the same debug.keystore file to sign, which is not recommended for the production releases. Let’s create a new keystore file for our releases first. Run the command below. To run the keytool command, make sure to insall the Java development kit (JDK). Also make sure to reference the appropriate JDK version in the command.

C:\"Program Files"\Java\jdk-24\bin\keytool -genkeypair -v -keystore yourkey-key.keystore -alias your-alias -keyalg RSA -keysize 2048 -validity 200000

Make sure to give large number as validity in the command as stated in this post.

Validity (years): Set the length of time in years that your key will be valid. Your key should be valid for at least 25 years, so you can sign app updates with the same key through the lifespan of your app.

As we have created the keystore file, let’s save them in a secured place, and good news is that the Azure DevOps already has a place for this.

From Azure DevOps, go the Library under Pipelines, and click on the +Secure file option under under Secure files.

After the secure file is uploaded, it is important to allow permission for our pipeline to use it. Go to the secure file, and click on the Pipeline permissions and then click on the Add pipeline plus icon and select your pipeline.

Configure the keystore password as pipeline variables

Now it is time to create a variable group in Azure DevOps and add the secured variables. Here keyAlias and keystorePassword is the details you had provided when you were creating the keystore.

Update the Signing config for release

Let’s create a release configuration under signingConfigs like below.

release {
            if (project.hasProperty("KEYSTORE_PATH")) {
                storeFile file(KEYSTORE_PATH)
                storePassword KEYSTORE_PASSWORD
                keyAlias KEY_ALIAS
                keyPassword KEY_PASSWORD
            }
        }

From the above code, the variables KEY_PASSWORD, KEY_ALIAS, KEYSTORE_PASSWORD, KEYSTORE_PATH will be set from the pipeline itself. This is to sign the files using our secure file from Azure DevOps.

As there is a separate signingConfig for release, let’s configure that. Update the release section under the buildTypes.

release {
            // Caution! In production, you need to generate your own keystore file.
            // see https://reactnative.dev/docs/signed-apk-android.
            signingConfig signingConfigs.release
            minifyEnabled enableProguardInReleaseBuilds
            // Enables resource shrinking.
            shrinkResources true
            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
        }

Make sure to set the minifyEnabled and shrinkResources to true as this will reduce the overall size of your app bundle and time to install the app. You can read more on the app optimization here.

Optional: Increase the memory during the build

You may get the error below when you run your pipeline.

Execution failed for task ‘:app:collectReleaseDependencies’. > Java heap space

To fix this, go to your gradle.properties and update the settings below.

# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# Default value: -Xmx512m -XX:MaxMetaspaceSize=256m
org.gradle.jvmargs=-Xmx4g -XX:MaxMetaspaceSize=512m

Azure DevOps YAML

As we have done the configurations, let’s start updating the YAML file by setting a name first.

name: $(date:yyyy).$(Month)$(rev:.r) 

Below is the full YAML file.

# Android
# Build your Android project with Gradle.
# Add steps that test, sign, and distribute the APK, save build artifacts, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/android
# https://learn.microsoft.com/en-us/azure/devops/pipelines/ecosystems/android
name: $(date:yyyy).$(Month)$(rev:.r)
trigger:
  - main
  - development

pool:
  vmImage: "macos-latest"

variables:
  - group: GooglePlayStore
  - name: KEYSTORE_FILE_NAME
    value: 'yourapp-gplaystore-key.keystore'

steps:
  - checkout: self
  - task: UseNode@1
    inputs:
      version: "22.x"
    displayName: "Use Node.js 22.x"
  - script: |
      ls -la $(Build.SourcesDirectory)
      ls -la $(Build.SourcesDirectory)/android
    displayName: "List Android Directory"
  - script: |
      npm install
    displayName: "npm install"
  - task: DownloadSecureFile@1
    name: keyStore
    displayName: "Download keystore from secure files"
    inputs:
      secureFile: $(KEYSTORE_FILE_NAME)
  - script: echo $(keyStore.secureFilePath)
    displayName: "Echo Keystore Path"
  - script: |
      ls -la $(Build.SourcesDirectory)/android
      ls -la $(Build.SourcesDirectory)/android/app
    displayName: "List Files"
  - task: Gradle@3
    displayName: "Gradle Build"
    inputs:
      workingDirectory: "$(Build.SourcesDirectory)/android"
      gradleWrapperFile: "android/gradlew"
      gradleOptions: "-Xmx3072m"
      publishJUnitResults: false
      testResultsFiles: "**/TEST-*.xml"
      tasks: "assembleRelease bundleRelease"
      options: "-PversionName=$(Build.BuildNumber) -PversionCode=$(Build.BuildId) -PKEYSTORE_PATH=$(keyStore.secureFilePath) -PKEYSTORE_PASSWORD=$(keystorePassword) -PKEY_ALIAS=$(keyAlias) -PKEY_PASSWORD=$(keyPassword)"
  - task: AndroidSigning@3
    inputs:
      apkFiles: "**/*.apk"
      apksignerKeystoreFile: "$(KEYSTORE_FILE_NAME)"
      apksignerKeystorePassword: "$(keystorePassword)"
      apksignerKeystoreAlias: "$(keyAlias)"
      apksignerKeyPassword: "$(keyPassword)"
      zipalign: false
  - task: CopyFiles@2
    displayName: "Copy APK Files"
    inputs:
      contents: "**/*.apk"
      targetFolder: "$(Build.ArtifactStagingDirectory)"
  - task: CopyFiles@2
    displayName: "Copy AAB App Bundle"
    inputs:
      sourceFolder: "android/app/build/outputs/bundle/release"
      contents: "**/*.aab"
      targetFolder: "$(Build.ArtifactStagingDirectory)/android/app/build/outputs/bundle/release"
  - task: PublishBuildArtifacts@1
    displayName: "Publish artifacts"
    inputs:
      pathToPublish: $(Build.ArtifactStagingDirectory)
      artifactName: yourapp

We use the task DownloadSecureFile@1 to download the keystore file and provide its path in the Gradle@3 task. We set the name to keystore and use the property secureFilePath to get its path.

Note that in Gradle@3 task even though you have set the workingDirectory as $(Build.SourcesDirectory)/android, you will need to se gradleWrapperFile as android/gradlew. Also check the options we pass to that task, that’s how we are setting the variables to the build.gradle files. The task value assembleRelease is to generate the APK file and bundleRelease is to create Android App Bundle (aab) for Google Play Store.

Google Play Integrations

Once the pipeline is run, you should be able to manually download the App bundle file from the artifacts.

You can upload to the Play store console for doing an internal release to test the app internally now. Select your application, click on the Test and release menu and then under Testing, select internal testing. This is where you can create a few internal users and upload your aab file. You can share the invite link with them. Please be noted that your internal tester would need to accept the request on their first visit to install the app. They should also be able to update the application from Play store when you release a new version.

Service account and permission in Google Cloud Console

Unfortunately the doc here and here are outdated and it took a while for me to configure this. You won’t be able to see the Setup and API access menu in https://play.google.com/console/ as Google had moved them to another process. The new steps are,

Create your service account in Google Cloud

1. Go to Google Cloud Console → IAM & Admin → Service Accounts
2. Create a new service account, grant it the Owner role (or at least Project > Editor)
3. Under the service account, add a JSON key and save the downloaded file. Please make sure to download this to a secure place, as this contains your key in it

Invite the service account in Play Console

1. In the Play Console, go to Users and permissions.
2. Click Invite new user.
3. Paste the client_email from your JSON file (e.g. foo@bar.iam.gserviceaccount.com).
4. Assign your service account permissions:
   • Select your app
   • Give at least the permissions below
     • View app information (read-only)
     • Release to production, exclude devices, and use Play App Signing
     • Release apps to testing tracks
5. Send the invite, this will be auto approved

Create Azure DevOps service connection

1. Go to your AZDO project → Project settings → Service connections.
2. Create a New service connection → Google Play.
3. For service account email, use the JSON’s client_email; for private key, paste the entire key (include \n line breaks exactly)
4. Save it with the name yourapp-google-play. Make sure to replace yourapp with your app name.

Update the release YAML with GooglePlayRelease task

The final step in the YAML file is to update it with the GooglePlayRelease task so that we can release app directly from the pipeline.

  - task: GooglePlayRelease@4
    inputs:
      serviceConnection: 'yourapp-google-play'
      applicationId: 'com.yourappid'
      action: 'SingleBundle'
      bundleFile: '$(Build.ArtifactStagingDirectory)/android/app/build/outputs/bundle/release/*.aab'
      track: 'internal'

Finally, run your pipeline and if everything goes well, you should see that your pileline result as below.

You should also be able to see the new version released for your internal test users in Google play console.

You can promote or increase the rollout of your application by following this doc.

About the Author

I am yet another developer who is passionate about writing and sharing knowledge. I have written more than 500 blogs on my blog. If you like this content, consider following me here,

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

In this post, let’s see how we can deploy a dot net 9 isolated runtime model project to a Linux based Azure function.

Prerequisites

Creating the hosting plan

It is not mandatory to create a hosting plan, as the resource will be auto created when you create the function, however it is recommended to create one as you can define your naming strategies and more controls. Here we are choosing the consumption plan. You can learn more about the hosting options Azure provides here. Below is the ARM template to create the consumption hosting plan.

{
    "type": "Microsoft.Web/serverfarms",
    "apiVersion": "2024-04-01",
    "name": "[parameters('funcAppServerFarmName')]",
    "location": "[parameters('funcAppLocation')]",
    "kind": "functionapp",
    "sku": {
        "name": "Y1",
        "tier": "Dynamic"
    },
    "properties": {
        "computeMode": "Dynamic",
        "reserved": true
    }
}

Creating the Azure function

Below is the ARM template to create the Azure function.

{
    "type": "Microsoft.Web/sites",
    "apiVersion": "2024-04-01",
    "name": "[parameters('FuncName')]",
    "location": "[parameters('funcAppLocation')]",
    "kind": "functionapp,linux",
    "identity": {
        "type": "SystemAssigned"
    },
    "properties": {
        "reserved": true,
        "alwaysOn": true,
        "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('funcAppServerFarmName'))]",
        "linuxFxVersion": "DOTNET-ISOLATED|9.0",
        "siteConfig": {
            "linuxFxVersion": "DOTNET-ISOLATED|9.0",
            "appSettings": [
                {
                    "name": "AzureWebJobsStorage",
                    "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};EndpointSuffix={1};AccountKey={2}', parameters('StorageName'), environment().suffixes.storage, listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('StorageName')), '2022-05-01').keys[0].value)]"
                },
                {
                    "name": "APPINSIGHTS_INSTRUMENTATIONKEY",
                    "value": "[reference(resourceId('Microsoft.Insights/components', parameters('InsightsComponentName')), '2020-02-02').InstrumentationKey]"
                },
                {
                    "name": "FUNCTIONS_EXTENSION_VERSION",
                    "value": "~4"
                },
                {
                    "name": "FUNCTIONS_WORKER_RUNTIME",
                    "value": "dotnet-isolated"
                },
                {
                    "name": "linuxFxVersion",
                    "value": "DOTNET-ISOLATED|9.0"
                },
                {
                    "name": "WEBSITE_USE_PLACEHOLDER_DOTNETISOLATED",
                    "value": "1"
                },
                {
                    "name": "CosmosConnectionString",
                    "value": "[concat('@Microsoft.KeyVault(SecretUri=', 'https://',parameters('KeyVaultName'),'.vault.azure.net/secrets/CosmosConnectionString)')]"
                }
            ],
            "minTlsVersion": "1.3"
        },
        "runtime": {
            "name": "dotnet-isolated"
        },
        "httpsOnly": true
    },
    "dependsOn": [
        "[resourceId('Microsoft.Insights/components', parameters('InsightsComponentName'))]",
        "[resourceId('Microsoft.Web/serverfarms', parameters('funcAppServerFarmName'))]",
        "[resourceId('Microsoft.Storage/storageAccounts', parameters('StorageName'))]"
    ]
}

Please make sure to set the values linuxFxVersion, WEBSITE_USE_PLACEHOLDER_DOTNETISOLATED or you may get the error below when you deploy your code to the Azure function.

Failed to sync triggers for function app ‘funcsintest03’. Error: BadRequest – Encountered an error (BadGateway) from host runtime. (CODE: 400)

I have a detailed post on the error here on Stack Overflow. Here is a doc on Automate resource deployment for your function app in Azure Functions.

Create Azure function application

You can easily create the Azure function using the Visual Studio by following this post. Please be noted that for my Azure function I am choosing my function to run in an isolated worker process to get the benefits like standard dependency injection, you can read more on this here.

Create the Azure DevOps pipelines

Before we create the pipelines, let’s create the template YAML with the file name as func-template.yml so that we can use it for all of our environments like Dev, Test, Prod etc.

parameters:
  - name: azureSubscriptionServiceConnection
    type: string
  - name: functionAppName
    type: string
  - name: stageName
    type: string

stages:
  - stage: ${{ parameters.stageName }}_Stage
    displayName: Release stage ${{ parameters.stageName }}
    jobs:
      - job: ${{ parameters.stageName }}_Release
        displayName: ${{ parameters.stageName }}_Release
        pool:
          vmImage: "ubuntu-latest"
        steps:
          # Download an artifact named 'WebApp' to 'bin' in $(Build.SourcesDirectory)
          - task: DownloadPipelineArtifact@2
            inputs:
              artifactName: "drop"
              targetPath: $(Build.SourcesDirectory)/bin
          - task: AzureFunctionApp@2 # Add this at the end of your file
            inputs:
              azureSubscription: ${{ parameters.azureSubscriptionServiceConnection }}
              appType: functionAppLinux # This specifies a Linux-based function app
              #isFlexConsumption: true # Uncomment this line if you are deploying to a Flex Consumption app
              appName: ${{ parameters.functionAppName }}
              package: $(Build.SourcesDirectory)/bin/*.zip
              deploymentMethod: "zipDeploy" # 'auto' | 'zipDeploy' | 'runFromPackage'. Required. Deployment method. Default: auto.
              #Uncomment the next lines to deploy to a deployment slot
              #Note that deployment slots is not supported for Linux Dynamic SKU
              #deployToSlotOrASE: true
              #resourceGroupName: '<RESOURCE_GROUP>'
              #slotName: '<SLOT_NAME>'
              runtimeStack: 'DOTNET-ISOLATED|9.0'

Here we use the task AzureFunctionApp@2 task, you can learn more about that task here. Next, create a YAML file func-template.yml with the contents below.

trigger:
  - main
stages:
  - stage: Build
    displayName: Build and push stage
    jobs:
      - job: Build
        displayName: Build
        pool:
          vmImage: "ubuntu-latest"
        steps:
          - task: UseDotNet@2
            inputs:
              packageType: "sdk"
              version: "9.0.x" # .NET 9 preview/stable depending on your needs
              installationPath: $(Agent.ToolsDirectory)/dotnet
          - checkout: self
          - script: |
              dotnet restore
              dotnet build --configuration Release
          - task: DotNetCoreCLI@2
            inputs:
              command: publish
              arguments: "--configuration Release --output publish_output"
              projects: "$(System.DefaultWorkingDirectory)/MyFunc.Func/MyFunc.Func.csproj"
              publishWebProjects: false
              modifyOutputPath: false
              zipAfterPublish: false
          - task: ArchiveFiles@2
            displayName: "Archive files"
            inputs:
              rootFolderOrFile: "$(System.DefaultWorkingDirectory)/publish_output"
              includeRootFolder: false
              archiveFile: "$(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip"
          - task: PublishBuildArtifacts@1
            inputs:
              PathtoPublish: "$(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip"
              artifactName: "drop"

  - template: func-template.yml
    parameters:
      azureSubscriptionServiceConnection: "MyFuncdevmi"
      functionAppName: "MyFuncfuncsindev03"
      stageName: "DEV"
  - template: func-template.yml
    parameters:
      azureSubscriptionServiceConnection: "MyFunctestmi"
      functionAppName: "MyFuncfuncsintest03"
      stageName: "TEST"

In the above YAML file, my function project name is MyFunc and I am using the MyFuncdevmi as the service connection to deploy the Azure function to the DEV environment MyFuncfuncsindev03 and MyFunctestmi to deploy to my TEST environment MyFuncfuncsintest03.

I am using managed identity to create those service connection. You can create a managed identity using the ARM template below.

{
    "type": "Microsoft.ManagedIdentity/userAssignedIdentities",
    "apiVersion": "2024-11-30",
    "name": "[parameters('managedIdentityName')]",
    "location": "[parameters('location')]",
    "tags": {
        "{customized property}": "string"
    }
}     

You can follow this doc to create the service connection using the managed identity.

Create the pipeline using the YAMLs created

Go to the Pipeline menu and click on New pipeline button. Select your Azure DevOps repository and click on the option Existing Azure Pipelines YAML file.

Choose the path to your release pipeline YAML file, not the template YAML file, and run your pipeline. If your pipeline is successful, you should be able to see the output as below.

Conclusion

In this post we have learned how to,

• create the Azure function and consumption hosting plan with dotnet isolated worker process
• create the temple for the deploying the Azure function
• create the release YAML using the template file

About the Author

I am yet another developer who is passionate about writing and sharing knowledge. I have written more than 500 blogs on my blog. If you like this content, consider following me here,

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

Prerequisites

1. You must have a repository that has your static files
2. You must have access to Azure portal

Create Azure Static Web App

Go to the Azure portal and select the static web app. Under the deployment settings, make sure you select the Azure devops repository where the static files are pushed.

For the build preset, select one that suits your project, here I am selecting HTML. The app artefact location or output location is based on the preset that you select. For HTML it is “/”, you can learn more on that here.

When you click on the Review + Create button on the portal, the build and release pipeline will be created with YAML file that you can edit later.

You may get the error below when you click the Create button.

Failed to create a Personal Access Token for this user in Azure DevOps. Please deploy your app using the ‘Other’ deployment source instead of ‘Azure DevOps’. After the app is created, open it and follow the instructions to get the token and deploy your app.

If that happens, as the error suggested, select the deployment source as Other and proceed. We will need to configure the deployment once the app is created.

You can also create the static web app using the ARM template, Bicep or Terraform. Read about that here and here.

Configure CI & CD deployment

Once the app is created, you can go to the URLs given for your app and you should see a start page as below.

Click on the Manage Deployment Token button under the overview pane and copy the deployment token. We will be setting this value as a secret in our pipeline later.

Go to your Auzre DevOps and click on the Pipelines. Click on the New pipleline and select your repository from Azure DevOps. In the configure tab, select Starter pipeline. Replace the content with the below codes.

https://gist.github.com/SibeeshVenu/1c9eeb3a54ebb4bc6a240de46e1e4f61

trigger:
  - main

pool:
  vmImage: ubuntu-latest

steps:
  - checkout: self
    submodules: true
  - task: AzureStaticWebApp@0
    inputs:
      app_location: '/' # App source code path relative to cwd
      # api_location: 'api' # Api source code path relative to cwd
      # output_location: 'public' # Built app content directory relative to app_location - optional
      # cwd: '$(System.DefaultWorkingDirectory)/myapp' # Working directory - optional
      azure_static_web_apps_api_token: $(deployment_token)

Click Save and run, the pipeline will fail for the first time as we have not set the deployment_token varible in the pipeline yet. Go to the created pipeline and click on Edit, click on Variables and then click New variable. Set the variable name as deployment_token and paste the deloyment token we copied as the value. Remember to set the value as secret. There are many ways to set the secret for your pipelines, you can read about those here and here.

Run your pipeline again. This time, the pipeline should be successful and you should be able to load your Static web app with your contents now.

Configure Custom Domain

Goto your Static web app and then click on the Add a custom domain tile.

Select the appropriate option as per your needs. I am selecting Custom domain on other DNS.

Enter the domain and select the Hostname record type, here I am selecting CNAME.

If you give the domain without www in it, you may get the below error.

Request Envelope is invalid. Apex Domains must use dns-txt-token as the ValidationMethod.

You can learn more about the custom domain here. Copy the CNAME hostname record and add it to your DNS provider to confirm your domain ownership. It can take up to 48 or 72 hours for DNS entry changes to take effect. Once that period is over, you can come here and try to add the custom domain again. Once it is added you should see a Status as “Validated”.

If you want to add the custom domain without “www” in it, then you must add a TXT record with the host as “@” and value as the code generated in the static web app’s custom domain section in your domains DNS configuration. You can learn more here.

Learn More

You can learn more about the Static Web App from the tutorials below.

1. Comparing Azure Static Web Apps vs Azure WebApps vs Azure Blob Storage Static Sites
2. Quickstart: Build your first static web app
3. Static Web Apps pricing

Conclusion

In this post we have seen how easily we can creat an Azure static web app, how to deploy or configure CI & CD with your new static web app, and how to configure the custom domain name to your static web app.

About the Author

I am yet another developer who is passionate about writing and sharing knowledge. I have written more than 500 blogs on my blog. If you like this content, consider following me here,

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

In this post, let’s discuss how easily we can move data from one cosmos database to another with the help of Azure data factory. An Azure data factory is a fully managed serverless data integration service, while it provides solutions for many use cases, today I am going to demonstrate to move data without writing a single line of code. Let’s get to it.

Creating Azure data factory

There are many ways to create Azure data factory

1. Create a data factory by using the Azure portal
2. Create an Azure Data Factory using ARM template

Create Pipeline

When you have ceated the Data factory, open that from the Azure portal, click on the Overview blade and click on the Launch Studio button.

Cick on the Home page and then click on the Ingest.

Under Properties, select Built-in copy task. You can select the task cadence otr task schedule as per your requirement. I am selecting “Run once now”.

Select Source Dataset

Under source tab, select your data source, I am selecting Azure CosmosDB for NoSQL. Under connection, +New connection. In the new pane, provide a name for your connection, and provide connection to the source either via a connection string from Azure subcription or Key Vault.

The connection will be tested automatically and the tables/containers wil be loaded for you to select those are applicable. I am selecting all the tables and yes to checkbox “Export as-is to JSON files or Azure Cosmos DB collection”.

Click next, a filter window will appear, you can also preview your data in this section.

Select Destination Data Store

Under the destination pane, select the Destination type. I am selecting “Azure Cosmos DB for NoSQL” as I need to move data from Cosmos DB to another Cosmos DB. Create a connection for the destination by clicking the +New connection and proceed the steps we followed for creating the connection for the source.

Once the connection is validated, you will be able to see the copy activities from Source to Destination. Make sure to select the activities that are required. By default all will be selected. Click Next.

Finalizing the task

In the next step, name your task, if you prefer you can apply “Data consistency verification” that will enable logging. Select the advanced settings that are applicable to you. Select Next. You will be provided with the Summary, if everything is right, click Next.

It will create the datasets, creates the pipeline, and run the pipeline. You can Finish, Monitor or Edit your pipeline.

If you ever want to see your pipeline again and edit, it will be under the Author pane and under the Pipeline section.

For any pipeline, you can enable Auto save by enabling the Git integration.

Verify that your Azure DevOps account is connected to the Microsoft Entra account, the Azure DevOps repository is in the Default Directory tenant, and that your current ADF user account has been added to the Azure DevOps organization.

Conclusion

In this post we have seen how easily we can move data from one Azure Cosmos DB to another with the help of Azure Data factory and it’s in-built automation.

About the Author

I am yet another developer who is passionate about writing and sharing knowledge. I have written more than 500 blogs on my blog. If you like this content, consider following me here,

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

Source Code

You can also see the codes in this repository.

Enablling .NET8 for Your Application

As you might have already guessed, the first step is to download the .NET8 from here. Let’s now change the TargetFramework in our both DotNetIpFilter.csproj and DotNetIpFilter.Test.csproj files. You can get the application code from the repositroy mentioned above.

<TargetFramework>net8.0</TargetFramework>

You will also need to update your Microsoft.AspNetCore.OpenApi package to .NET8.

Enable Preview .NET 8 in Visual Studio 2022

If you are trying to create a new application using Visual Studio 200, you may be missing an option to chose the .NET8 framework, to mak sure to get this option, do the following.

1. Update your Visual Studio 2022

2. Go to Tools -> Manage Preview Features

3. Select checkbox Use preview of the .NET SDK (requires restart)

4. Make sure to restart after enabling this

Use .NET8 Contains Method from IPNetwork

Let’s change our IpActionFilter.cs file code as below, to use the Contains method from .NET8 IPNetwork class.

In the code above the variable addressRange is a string that represents IP Address Range and ipAddressToCheck is the IP Address to check. The code for the IPNetwork is here. You can learn more about this IPNetwork.Contains(IPAddress) method here. Make sure to select the version .NET 8 for the doc. If you can’t use .Net 8, you can implement your own class by taking the code from here.

I also have a detailed StackOverflow answer here on this topic.

StackOverflow answer

Test IP Filtering with Ranges

Now, it is time to test our new implementation. Go to the IpFilterService.cs file and then edit the GetAdminSafeIpList method. Assign a few IP address ranges to the variable ipListArray, remember this is where you get a list of IP addresses and ranges from any of your middleware service using an async function. To make it simpler, I am assigning some of the IP addresses and ranges to that variable manually.

When you run the application you can see that the addresses and the ranges we set is getting validated in our OnActionExecuting method in IpActionFilter.cs.

The Contains method retruns true if the given IPAddress is part of the IP network. Otherwise, returns false.

If you inspect the Contains method, you can see the code as below. This works with both IPV4 and IPV6.

Conclusion

In this post we have seen how easily we can check an IP address is in a given IP address ranges or not. Before this .Net8 release, we had to have our own implementaion, but now it is so easy and less codes. Less code is less maintenance, right. The .NET8 has many features just like this, checkout here.

About the Author

I am yet another developer who is passionate about writing and sharing knowledge. I have written more than 500 blogs on my blog. If you like this content, consider following me here,

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

Create an IP Action Filter

Before you do this, I assume that you already have the .Net Web API. For this post I am using .Net 7. Create a Services folder and then create a class IpActionFilter that is inherited from ActionFilterAttribute.

The implementation is a clone of this doc. As you can see from that doc, there it the safe IP addresses list are static and is added to the App Settings manually. However in my scenario, I had to get this from an Async service call.

Get the IP addresses from an Asyn service call

We will create a new Service IpFilterService that implements IIpFilterService. Here we will mimic the async call to make this post more concrete.

Async call to set the configuration

If you just have a few IP addresses that can easily set in the App Settings. You can just add them manually as in this post. As I wanted to update this list via an async service call, there are a few additional changes we must do. One of them is creating a Hosted Service that implements IHostedService and add that to the builder using builder.Services.AddHostedService. Let’s create IpHostedService.

As you can see from the code above, we are setting the AdminSafeIpList configuration to our App Settings via the code. Now all we need to add is to add this to the builder.

Configure the builder

To make sure that the AdminSafeIpList is updated to the App Settings, we will need to add our IpHostedService as a HostedService. You can learn more about this service here. The code for Program.cs after this changes is below.

So we are passing the AdminSafeIpList to the IpActionFilter.

Enable IpActionFilter as a ServiceFilter

As we have implemented the action filter and other required services, we now can add the IpActionFilter as a ServiceFilter in the controller or the actions. Add the code [ServiceFilter(typeof(IpActionFilter))] to top of controller or actions.

Finally, Add some unit tests

Let’s try to add some unit tests for our IpActionFilter.

Output

Let’s build and run our API. You should see the preceeding response.

With External IPs:

With Internal IPs:

Source Code

You can also see the codes in this repository.

Conclusion

Here in this post we have seen,

1. How we can restrict the accesse to our Web APIs by providing the Safe IP addresses list

2. How to create a new Action Filter and use that for Controllers

3. One of the challenge was to get the IP Address safe list from an Async service call and update the App Settings.

About the Author

I am yet another developer who is passionate about writing and video creation. I have written more than 500 blogs on my blog. If you like this content, consider following me here,

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

Prerequisites

1. You will need Python installed on your machine
2. You will need to create a Team and a channel in the Team

Setting up a channel

Creating a channel

You will need to set up Teams before you create a channel, and if you have enough access, it is an easy thing to do. Once the Team is ready to use, you can either use one of the existing channel, or create a new one from the context menu.

Setting up the connector

When you have decided which channel to use, click on the three dot on the right-side of your channel name, and then click on the Connectors and then search for the connector “Incoming Webhook” and then click on the button “Add”.

The above process might take a few minutes. If you are unable to perform this, you can try using the web version of Microsoft Teams.

Use of web verstion of Microsoft Teams

The above step will add the connector to your Teams, so that you can start configuring your Webhook. Click on the Configure button.

Provide a meaningful name for your Webhook and upload an image if required. Finally click on the Create button. A unique Url will be generated for your Webhook. Copy the Url and save it somewhere, we will later add this to Azure Key Vault and use from there. Click on the Done button. Your Webhook now should be shown as configured.

Post Message Using the Connector

Setting up Azure Key Vault

Configuring the Azure Key Vault is as easy as you set up any other Azure Resource. You may get the steps required from this post or this. Add a new secret and paste the Webhook Url value you copied earlier.

Make sure that you had set up the Access Policies on your Azure Key vault.

Access Policy

Copy your Azure Key Vault name and the Secret name, we will use this in our Python function.

Setting up Python Application

Let’s set up our Python application. Create a directory msteams-webhook and create a file requirements.txt with the preceeding contents.

pymsteams[async]
azure-identity
azure-keyvault-secrets

Now run the commands below to create a virtual environment, activate the environment and then install the requirements in our environment. If you get a message like “WARNING: You are using pip version 19.2.3, however version 22.2.2 is available.”, you can upgrade pip by running the command python -m pip install --upgrade pip

py -m venv .venv
.\.venv\Scripts\activate
py -m pip install -r requirements.txt

You can learn more abou the Virtual Environment here.

Python Virtual Envrronment

Get the Secret from Azure Key Vault

Let’s create a new Python file keyvault_helper.py with the codes below.

Send Message to Teams Channel

To send a message to the Teams channel, we are going to use a package pymsteams. This has been already added to our requirements file. Let’s create a file notify_teams.py with the codes below.

As we have all the set up done, let’s create main.py file with the codes below to start sending the messages to the Teams channel.

Before you run the main file, make sure that you have logged in to the terminal using az login with the account that you had set the access policy in your azure key vault. We can also set this access policies by using a managed identity, or a service principal, so that we can use it for more production scenarios. But for this post, let’s stick with a user account.

If you get the error, VisualStudioCodeCredential: The current credential is not configured to acquire tokens for tenant or SharedTokenCacheCredential: The current credential is not configured to acquire tokens for tenant you can set the values  exclude_shared_token_cache_credential=True or exclude_visual_studio_code_credential=True when you get tokens using DefaultAzureCredential in your get_key_vault_secret function in keyvault_helper.py file.

Keyvault Error

By this time, we can hope that you will be able to get the secret from the key vault and now we can execute py .\main.py file. Once the file is executed, you should get a response in your cli as preceding.

{"version":"1.1","content":{"headers":[{"key":"Content-Type","value":["text/plain; charset=utf-8"]}]},"statusCode":200,"reasonPhrase":"OK","headers":[],"trailingHeaders":[],"requestMessage":null,"isSuccessStatusCode":true}

You should also get a message on your Teams channel.

Source Code

You can also see the codes in this repository.

About the Author

I am yet another developer who is passionate about writing and video creation. I have written more than 500 blogs on my blog. If you like this content, consider following me here,

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

Kindest Regards

Sibeesh Venu

PowerShell command to get the metadata

Here is the command to get the metadata of all of your blobs in your storage account.

Set your execution policy to Process if you get any policy errors.

Set-ExecutionPolicy -ExecutionPolicy ByPass -Scope Process

If you get an authorization error as follows, make sure to add a role assignment of Storage Blob Data Contributor. You can do this via Access Control (IAM) of your storage account. Read more about this role here.

PowerShell AuthorizationPermissionMismatch Error

Get-AzStorageContainer : This request is not authorized to perform this operation using this permission.
RequestId:405a7e1a-f01e-004f-3acd-6a1168000000
Time:2022-05-18T15:38:30.5034936Z
Status: 403 (This request is not authorized to perform this operation using this permission.)
ErrorCode: AuthorizationPermissionMismatch
Content:
<?xml version=”1.0″ encoding=”utf-8″?><Error><Code>AuthorizationPermissionMismatch</Code><Message>This request is not authorized to perform this operation using
this permission.

Once you add the role, you can try running your PowerShell command after a few minutes. Please make sure to provide the values to the variables $containerName, $subscriptionid, $storageAccName. Happy coding with PowerShell!

About the Author

I am yet another developer who is passionate about writing and video creation. I have written close to 500 blogs on my blog. If you like this content, consider following me here,

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

Kindest Regards

Sibeesh Venu

At this point, I will assume that you have a .net6 application, Azure Web App Service, and Azure DevOps project with permission to configure the Pipeline and to add a new service connection to the Azure Resource Group. If you are not sure about how to configure the Service Connection to the Azure Resource Group, this post will help you.

Create the YAML files needed

We will be creating 3 YAML files as listed below.

1. A template file with the all the tasks, so that we can reuse them for the environment specific pipelines
2. A pipeline for Test environment
3. A pipeline for the production environment

Template file

Let’s configure all the tasks needed in our template file. We will have 2 stages in our template. You can read this post if you are not sure how to configure the stages in the pipeline.

1. Build stage, for performing the tasks below
   • Install .Net Core SDK
   • .Net restore
   • .Net build
   • .Net publish
   • Publish to Azure DevOps artefacts
2. Deploy stage, to deploy the artefacts generated to the Azure Web App Service. This will involves the taks below.
   • Download the artefact
   • Deploy

Our final template file will look like this.

Add pipeline for Test environment

As we have a template available, we can use this to configure the pipeline for our test environment. All you have to do is to refer to this template and pass the required parameters. This is how our pipeline for our test environment can look like.

Here, the parameter azure subscription is the service connection name that you have created in your Azure DevOps project. Refer to this to know more. The wwebAppName is the name of your Azure Web App Service.

Add pipeline for Prod environment

Let’s create a new pipeline for our Prod environment to see how easily we can reuse the template.

Wasn’t that cool?

Configure the pipelines in the Azure DevOps

Just creating the YAML field will not create the pipelines in our DevOps, as Microsoft has removed that option due to some security concerns. So we will have to configure them manually for the first time. Let’s do it.

1. Go to the Pipelines section from your Azure DevOps and click on the New pipeline button.
2. Select Azure Repos Git (YAML) from the next screen.
3. Select the repository that you pushed your YAML file code changes.
4. Azure DevOps will analyze your repository and sugges the YAML templates. Select the Existing Azure Pipeline YAML file option.
5. Selct the branch and the path to your YAML file as in the preceding image, review the same and run the pipeline.

That’s it. Everything else will be working as expected from the next time as we have configured the triggers in the pipelines. If you are getting an error as “Task “NETSdkError” skipped, due to false condition; (‘$(_TargetFrameworkVersionWithoutV)’ > ‘$(NETCoreAppMaximumVersion)’) was evaluated”, you will have to make sure that you are installing the correct version of the .Net Core SDK as mentioned in this answer.

Source code

You can get the complete source code from this GitHub repository. Please feel free to fork/star.

Conclusion

Here in this post, we have learned the following things.

1. How to configure a YAML template
2. How to reuse a YAML template in the pipelines
3. How to deploy the .net 6 application to Azure Web App Service

About the Author

I am yet another developer who is passionate about writing and video creation. I have written close to 500 blogs on my blog. And I upload videos on my YouTube channels Njan Oru Malayali and Sibeesh Passion. Please feel free to follow me.

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

Kindest Regards

Sibeesh Venu

Right-click on the project and click on the Connected Service

Click on the + icon in the Service Dependencies and then select Azure Application Insights from the list

Log in and select your subscription and the Azure Application Insight instance

Configure your connection string name and choose how you want to save your connections string locally. I would recommend saving it to a secret.json file. You can get more information about this here under the Secret Storage for Development Environment section.

Click Finish on the summary screen.

You will be able to see the progress in the next screen.

Click on the Git changes window, your changes should look like the image below.

Push your changes and deploy them to your web application.

Conclusion

Congratulations and thanks a lot for being with me this far. Here in this post, we learned how can we enable the Azure App Insights to our application. Happy Analysing!.

About the Author

I am yet another developer who is passionate about writing and video creation. I have written close to 500 blogs on my blog. And I upload videos on my YouTube channels Njan Oru Malayali and Sibeesh Passion. Please feel free to follow me.

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

Kindest Regards

Sibeesh Venu