azure-pipelines.yml

trigger:
  batch: true
  branches:
    include:
    - main

pr:
- main

pool:
  vmImage: ubuntu-latest

variables:
- name: 'BuildId'
  value: '$(Build.SourceVersion)'
- name: 'BuildTag'
  value: '$(Build.BuildNumber)'
- name: 'InfraDirectory'
  value: '$(System.DefaultWorkingDirectory)/infra'
- name: 'DistDirectory'
  value: '$(System.DefaultWorkingDirectory)/dist'

  # This variable group is used to define "default" variable values that can be overridden by "environment" variables
- group: na-js-env-vars

  # The "preview" environment is the default environment
- group: na-js-env-vars-preview

  # The "production" environment is targeted when the source branch is `main`
- ${{ if eq(variables['Build.SourceBranch'], 'refs/heads/main') }}:
  - group: na-js-env-vars-prod

  # This is the ARM deployment name
- name: 'DeploymentName'
  value: $[format('{0}-{1}', variables['EnvironmentName'], variables['Build.BuildNumber'])]

  # The `DeployEnv` is used in deployment jobs - `AzureEnvironment` is the name of the Environment in Azure DevOps, which could be different to the `EnvironmentName`
- name: 'DeployEnv'
  value: $[coalesce(variables['AzureEnvironment'], variables['EnvironmentName'])]

  # If no "shared" resource group is defined, then set it to the "environment" resource group
- name: 'SharedResourceGroupName'
  value: $[coalesce(variables['AzureSharedResourceGroup'], variables['AzureResourceGroup'])]

stages:
- stage: 'BuildInfrastructure'
  jobs:
  - job: 'BuildArmTemplate'
    steps:
      # The Bicep build command fails if the output directory doesn't exist
    - pwsh: md "$(InfraDirectory)"
      displayName: 'Create infra directory'

    - task: AzureCLI@2
      displayName: 'Build ARM template from bicep file'
      inputs:
        azureSubscription: '$(AzureServiceConnection)'
        scriptType: pscore
        scriptLocation: inlineScript
        workingDirectory: '$(System.DefaultWorkingDirectory)/.azure/infra'
        inlineScript: |
          az bicep build -f main.bicep --outdir "$(InfraDirectory)"

      # Replace tokens in the ARM parameters template file with relevant values for this build
    - pwsh: |
        . ./Set-Tokens.ps1
        Set-Tokens `
          -InputFile main.parameters.json.template `
          -OutputFile "$(InfraDirectory)/main.parameters.json" `
          -Tokens @{ `
            resourcePrefix="$(AzureResourcePrefix)"; `
            environment="$(EnvironmentName)"; `
            sharedResourceGroupName="$(SharedResourceGroupName)"; `
            buildId="$(BuildId)"; `
            buildTag="$(BuildTag)"; `
            webAppSkuName="$(WebAppSkuName)"; `
            webAppSkuCapacity=$(WebAppSkuCapacity); `
            webAppSlotName="$(WebAppSlotName)"; `
            webAppDomainName="$(WebAppDomainName)"; `
            webAppCertName="$(WebAppCertName)" `
          }
      workingDirectory: '$(System.DefaultWorkingDirectory)/.azure/infra'
      displayName: 'Create ARM parameters file'

      # Publish the ARM template and parameters as build artifacts
    - publish: '$(InfraDirectory)'
      displayName: 'Publish artifacts'
      artifact: infra

      # Run a What-If deployment to aid in reviewing the deployment during approval checks
    - task: AzureCLI@2
      displayName: 'What-If ARM template'
      inputs:
        azureSubscription: '$(AzureServiceConnection)'
        scriptType: pscore
        scriptLocation: inlineScript
        workingDirectory: '$(InfraDirectory)'
        inlineScript: |
          az account show
          az deployment group create -w -n "$(DeploymentName)" -g $(AzureResourceGroup) -f main.json -p `@main.parameters.json

- stage: 'DeployInfrastructure'
  jobs:
  - deployment: 'DeployArmTemplate'
    environment: '$(DeployEnv)'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: CopyFiles@2
            displayName: 'Copy infra artifacts to workspace'
            inputs:
              SourceFolder: '$(Pipeline.Workspace)/infra'
              TargetFolder: '$(InfraDirectory)'
              Contents: '**'

          - task: AzureCLI@2
            displayName: 'Run ARM template'
            inputs:
              azureSubscription: '$(AzureServiceConnection)'
              scriptType: pscore
              scriptLocation: inlineScript
              workingDirectory: '$(InfraDirectory)'
              inlineScript: |
                az account show
                az deployment group create -n "$(DeploymentName)" -g $(AzureResourceGroup) -f main.json -p `@main.parameters.json

- stage: 'BuildNextApp'
  jobs:
  - job: 'BuildNextApp'
    steps:
      # Use the app settings output from the ARM deployment to set environment variables that are required for our Next app build
    - task: AzureCLI@2
      displayName: 'Get ARM outputs'
      inputs:
        azureSubscription: '$(AzureServiceConnection)'
        scriptType: pscore
        scriptLocation: inlineScript
        inlineScript: |
          $webAppSettings = (az deployment group show -n "$(DeploymentName)" -g $(AzureResourceGroup) --query properties.outputs.webAppSettings.value | ConvertFrom-Json -AsHashtable)
          foreach ($setting in $webAppSettings.GetEnumerator()) { `
            $key=$setting.Key; $value=$setting.Value; `
            Write-Output("##vso[task.setvariable variable=${key};]${value}") `
          }

      # This creates an env file by setting values on each key in the template that has a matching key in the pipeline environment
      # This is so we don't have to pass each setting to the Docker build as a build arg
    - task: EnvTransform@0
      displayName: 'Create env file for build'
      inputs:
        inputType: 'file'
        inputFile: '$(System.DefaultWorkingDirectory)/.env.template'
        outputFile: '$(System.DefaultWorkingDirectory)/.env.local'

    - task: DockerCompose@0
      displayName: 'Build Next app container images'
      inputs:
        action: Build services
        azureSubscriptionEndpoint: '$(AzureServiceConnection)'
        azureContainerRegistry: '$(DOCKER_REGISTRY_SERVER)'
        projectName: '$(DOCKER_IMAGE_NAME)'
        dockerComposeFile: docker-compose.yml
        qualifyImageNames: true
        additionalImageTags: '$(DOCKER_IMAGE_TAG)'
        includeLatestTag: true

    - task: DockerCompose@0
      displayName: 'Push Next app container image to container registry'
      inputs:
        action: Push services
        azureSubscriptionEndpoint: '$(AzureServiceConnection)'
        azureContainerRegistry: '$(DOCKER_REGISTRY_SERVER)'
        projectName: '$(DOCKER_IMAGE_NAME)'
        dockerComposeFile: docker-compose.yml
        qualifyImageNames: true
        additionalImageTags: '$(DOCKER_IMAGE_TAG)'
        includeLatestTag: true

      # The next task fails if the output directory doesn't exist
    - pwsh: md "$(DistDirectory)"
      displayName: 'Create dist directory'

    # Replace tokens in the app service docker compose file with relevant values for this build
    # Locally docker compose CLI would do this for us, but app services does not expand these tokens
    - pwsh: |
        . ../infra/Set-Tokens.ps1
        Set-Tokens `
          -InputFile docker-compose.appservice.yml `
          -OutputFile "$(DistDirectory)/docker-compose.appservice.yml" `
          -StartTokenPattern "\$\{" `
          -EndTokenPattern "\}" `
          -Tokens @{ `
            DOCKER_REGISTRY_SERVER="$(DOCKER_REGISTRY_SERVER)"; `
            DOCKER_IMAGE_NAME="$(DOCKER_IMAGE_NAME)"; `
            DOCKER_IMAGE_TAG="$(DOCKER_IMAGE_TAG)" `
          }
      workingDirectory: '$(System.DefaultWorkingDirectory)/.azure/web-app'
      displayName: 'Create App Service Docker Compose file'

      # Publish the dist outputs as artifacts
    - publish: '$(DistDirectory)'
      displayName: 'Publish artifacts'
      artifact: dist

- stage: 'DeployNextApp'
  jobs:
  - deployment: 'DeployNextApp'
    environment: '$(DeployEnv)'
    strategy:
      runOnce:
        deploy:
          steps:
            # Get the name of the app service we are deploying to from the ARM deployment outputs
          - task: AzureCLI@2
            displayName: 'Get ARM outputs'
            inputs:
              azureSubscription: '$(AzureServiceConnection)'
              scriptType: pscore
              scriptLocation: inlineScript
              inlineScript: |
                $outputs = (az deployment group show -n "$(DeploymentName)" -g $(AzureResourceGroup) --query properties.outputs | ConvertFrom-Json)
                $webAppName = $outputs.webAppName.value
                Write-Output("##vso[task.setvariable variable=WebAppName;]$webAppName")

            # Update app service container settings to pull new images from the registry
            # Using AzureCLI task instead of AzureWebAppContainer task because AzureWebAppContainer incorrectly sets `windowsFxVersion` instead of `linuxFxVersion`
            # See https://github.com/microsoft/azure-pipelines-tasks/issues/14805
          - task: AzureCLI@2
            displayName: 'Update web app container settings'
            inputs:
              azureSubscription: '$(AzureServiceConnection)'
              scriptType: pscore
              scriptLocation: inlineScript
              inlineScript: |
                $slotName = "$(WebAppSlotName)"
                if ($slotName) {
                  # Deploy to slot
                  az webapp config container set --name "$(WebAppName)" --resource-group "$(SharedResourceGroupName)" --multicontainer-config-file "$(Pipeline.Workspace)/dist/docker-compose.appservice.yml" --multicontainer-config-type COMPOSE --slot $slotName
                }
                else {
                  # Deploy to production
                  az webapp config container set --name "$(WebAppName)" --resource-group "$(SharedResourceGroupName)" --multicontainer-config-file "$(Pipeline.Workspace)/dist/docker-compose.appservice.yml" --multicontainer-config-type COMPOSE
                }