aks-deploy.yaml

name: AKS Deployment

on:
  workflow_call:
    inputs:
      environment:
        required: true
        type: string
        description: "Deploy Environment.  This is used to pull in and set the github environment. Can be development, staging, or production."
      environmentKeyVault:
        required: false
        type: string
        description: "AKS Key vault."
      clusterResourceGroup:
        required: false
        type: string
        description: "AKS Cluster Resource Group."
        default: "AMU_AKS_201"
      chartsPath:
        required: false
        type: string
        description: "Relative path to Helm charts."
        default: "./deployments/charts"
      dockerFilePath:
        required: false
        type: string
        description: "Relative path to Dockerfile."
        default: "."
      maximumReplicas:
        required: false
        type: string
        description: "Maximum number of replicas for the application HPA."
        default: "30"
      deploymentTimeout:
        required: false
        type: number
        description: "Timeout for GitHub deployments"
        default: 20
      webAuthentication:
        required: false
        type: string
        description: "Enable web authentication"
        default: "false"
      ingressWhitelist:
        required: false
        type: string
        description: "IPs to include in the application whitelist"
        default: ${{ vars.KUBERNETES_INGRESS_WHITELIST }}
      adminIngressWhitelist:
        required: false
        type: string
        description: "IPs to include in the Admin application whitelist"
        default: "207.67.20.252"
      environmentIngress:
        required: false
        type: string
        description: "Add the environment name to the front of the hostname (for DNS)"
        default: "true"
      environmentNamespace:
        required: false
        type: boolean
        description: "Enable/Disable adding environment in AKS cluster ingress DNS record"
        default: true
      enableNginxAccessLogging:
        required: false
        type: string
        description: Enable access logging in Kubernetes ingress
        default: "false"
      checkoutRef:
        required: false
        type: string
        description: "The branch, tag or SHA to checkout"
        default: ${{ github.ref }}
      githubRunner:
        required: false
        type: string
        description: "The type of runner to use"
        default: ${{ vars.CUSTOM_GITHUB_RUNNER || 'ubuntu-latest' }}
      deploymentWebhook:
        required: false
        type: string
        description: "The webhook URL for the deployment status"
        default: ${{ vars.MSTEAMS_DEPLOYMENT_WEBHOOK }}
      checkoutSubmodules:
        required: false
        type: string
        description: "Check out submodules"
        default: ${{ vars.GIT_CHECKOUT_SUBMODULES }}
    secrets:
      azureClusterName:
        required: true
      azureCredentials:
        required: true
      registryHostName:
        required: true
      registryUserName:
        required: true
      registryPassword:
        required: true
      storageAccountKey:
        required: true
      webAuthenticationPassword:
        required: false
      webAuthenticationUsername:
        required: false
      PAT_ACTION_CI:
        required: false

jobs:
  build:
    name: Build Docker Image
    runs-on: ${{ inputs.githubRunner }}
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          ref: ${{ inputs.checkoutRef }}
          submodules: ${{ inputs.checkoutSubmodules }}
          token: ${{ secrets.PAT_ACTION_CI || github.token }}

      - name: Extract Helm values
        id: setenvs
        shell: pwsh
        run: |
          Install-Module -Name powershell-yaml -Confirm:$false -Force
          Function Get-Envs {
              param (
                  [parameter(Mandatory = $true, ValueFromPipeline = $true)]
                  [string]$PathToYaml
              )
              Import-Module powershell-yaml
              Write-Host "Getting configuration from: $PathToYaml."
              $Values = Get-Content $PathToYaml | ConvertFrom-Yaml
              return $Values
          }

          $appEnvironment = "${{ inputs.environment }}"
          $basePath = Get-Location
          $valuesYamlPath = Join-Path $basePath ${{ inputs.chartsPath }} "values.yaml"
          $appConfig = Get-Envs -PathToYaml $valuesYamlPath
          $chartYamlPath = Join-Path $basePath ${{ inputs.chartsPath }} "Chart.yaml"
          $chartConfig = Get-Envs -PathToYaml $chartYamlPath

          $appName = $chartConfig.name
          $appVersion = $chartConfig.appVersion
          $appHealthCheck = $appconfig.deployment.healthCheckPath
          $configMap = $appConfig.deployment.configMap
          if ($appEnvironment -eq "development") {
              $maxReplicas = 2
          }
          elseif ($appEnvironment -eq "staging") {
              $maxReplicas = 4
          }
          else {
              $maxReplicas = $appConfig.autoscaling.maxReplicas
          }
          $configSecret = $appConfig.deployment.secret
          $imagePullSecret = "$appName-pull-secret"
          $release = "$appName-${{ github.sha }}" -replace '(^.{53})(.*$)', '$1'
          $release = ($release -replace '[^-\p{L}\p{Nd}]', '').ToLower() -replace '^-', '' -replace '-$', ''
          $ingress = $appConfig.ingress.host
          $domainName = ($ingress.Split('.') | Select-Object -Last 2) -join '.'
          $environmentIngress = "${{ inputs.environmentIngress }}" -replace '"', '' -replace "'", ""
          $hostName = $ingress -replace $domainName, '' -replace "\.$", ""
          if ([string]::IsNullOrEmpty("${{ inputs.ingressWhitelist }}")) {
              if ([string]::IsNullOrEmpty($appConfig.ingress.annotations."nginx.ingress.kubernetes.io/whitelist-source-range")) {
                  $ingressWhitelist = '0.0.0.0/0'
              } else {
                  $ingressWhitelist = $appConfig.ingress.annotations."nginx.ingress.kubernetes.io/whitelist-source-range"
              }
          } else {
              $ingressWhitelist = "${{ inputs.ingressWhitelist }}"
          }
          if ($appConfig.adminingress) {
              $adminIngressWhitelist = "${{ inputs.adminIngressWhitelist }}" ?? $appConfig.adminingress.annotations."nginx.ingress.kubernetes.io/whitelist-source-range"
          }
          else {
              Write-Output "adminingress values not defined. Skipping setting adminIngressWhitelist"
          }

          if ($environmentIngress -eq "true") {
              $ingress = "$appEnvironment.$ingress"
              if ($hostName.Length -gt 0) {
                  $hostName = "$appEnvironment.$hostName"
              }
              else {
                  $hostName = "$appEnvironment"
              }
          }
          else {
              if ($hostName.Length -eq 0) {
                  $hostName = "www"
              }
          }
          Write-Output "This application's hostname is $hostName.$domainName"

          Write-Output "appName=$appName" >> $env:GITHUB_ENV
          Write-Output "appVersion=$appVersion" >> $env:GITHUB_ENV
          Write-Output "appHealthCheck=$appHealthCheck" >> $env:GITHUB_ENV
          Write-Output "configMap=$configMap" >> $env:GITHUB_ENV
          Write-Output "configSecret=$configSecret" >> $env:GITHUB_ENV
          Write-Output "ingress=$ingress" >> $env:GITHUB_ENV
          Write-Output "domainName=$domainName" >> $env:GITHUB_ENV
          Write-Output "hostName=$hostName" >> $env:GITHUB_ENV
          Write-Output "imagePullSecret=$imagePullSecret" >> $env:GITHUB_ENV
          Write-Output "date=$(date +'%m/%d/%YT%H:%M:%S')" >> $env:GITHUB_ENV
          Write-Output "ingressWhitelist=$ingressWhitelist" >> $env:GITHUB_ENV
          Write-Output "adminIngressWhitelist=$adminIngressWhitelist" >> $env:GITHUB_ENV
          Write-Output "release=$release" >> $env:GITHUB_ENV
          Write-Output "maxReplicas=$maxReplicas" >> $env:GITHUB_ENV

      - name: Generate .env file from Azure Key Vaults
        id: get-envs
        uses: Andrews-McMeel-Universal/get-envs@v1
        with:
          azurecredentials: ${{ secrets.azureCredentials }}
          environment: ${{ inputs.environment }}
          environmentKeyVault: ${{ inputs.environmentKeyVault }}
          contentTypes: BuildArg Env

      - name: Login to Azure Container Registry
        uses: azure/docker-login@v2
        with:
          login-server: ${{ secrets.registryHostName }}
          username: ${{ secrets.registryUserName }}
          password: ${{ secrets.registryPassword }}

      - name: Build Docker Image
        run: |
          REGISTRY_REPO="${{ secrets.registryHostName }}/${{ github.event.repository.name }}"
          IMAGE_NAME="${REGISTRY_REPO}:${{ github.sha }}-${{ inputs.environment }}"
          docker build ${{ steps.get-envs.outputs.buildArguments }} -t "${IMAGE_NAME}" ${{ inputs.dockerFilePath }}

      - name: Enable write access if image has already been deployed
        run: |
          IMAGE_MANIFEST=$(az acr repository show --name "${{ secrets.registryHostName }}" --image "${{ github.event.repository.name }}:${{ github.sha }}-${{ inputs.environment }}" --query "digest" -o tsv || echo "")
          if [ -z "${IMAGE_MANIFEST}" ]; then
            echo "Failed to get current image manifest, proceeding with deployment."
          else
            echo "Enabling write access for image manifest."
            az acr repository update --name "${{ secrets.registryHostName }}" --image "${{ github.event.repository.name }}@${IMAGE_MANIFEST}" --write-enabled true
          fi

      - name: Tag Docker Image
        run: |
          REGISTRY_REPO="${{ secrets.registryHostName }}/${{ github.event.repository.name }}"
          IMAGE_NAME="${REGISTRY_REPO}:${{ github.sha }}-${{ inputs.environment }}"
          if [[ "${{ inputs.environment }}" == "production" ]] ; then
            docker tag "${IMAGE_NAME}" "${REGISTRY_REPO}:latest"
            docker tag "${IMAGE_NAME}" "${REGISTRY_REPO}:stable"
          fi
          if [[ "${{ github.event.release.tag_name }}" != "" ]]; then
            docker tag "${IMAGE_NAME}" "${REGISTRY_REPO}:${{ github.event.release.tag_name }}"
            MAJOR_RELEASE=$(echo "${{ github.event.release.tag_name }}" | cut -d "." -f 1)
            docker tag "${IMAGE_NAME}" "${REGISTRY_REPO}:${MAJOR_RELEASE}"
          fi
          docker tag "${IMAGE_NAME}" "${REGISTRY_REPO}:${{ inputs.environment }}"

      - name: Push Docker Image
        run: docker push -a "${{ secrets.registryHostName }}/${{ github.event.repository.name }}"
    outputs:
      appName: ${{ env.appName }}
      appVersion: ${{ env.appVersion }}
      appHealthCheck: ${{ env.appHealthCheck }}
      configMap: ${{ env.configMap }}
      configSecret: ${{ env.configSecret }}
      ingress: ${{ env.ingress }}
      domainName: ${{ env.domainName }}
      hostName: ${{ env.hostName }}
      imagePullSecret: ${{ env.imagePullSecret }}
      date: ${{ env.date }}
      ingressWhitelist: ${{ env.ingressWhitelist }}
      adminIngressWhitelist: ${{ env.adminIngressWhitelist }}
      release: ${{ env.release }}
      maxReplicas: ${{ env.maxReplicas }}

  deploy:
    name: AKS Deploy
    needs: [build]
    runs-on: ${{ inputs.githubRunner }}
    continue-on-error: false
    environment:
      name: ${{ inputs.environment }}
      url: https://${{ needs.build.outputs.ingress }}
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          ref: ${{ inputs.checkoutRef }}

      - name: Create values override file
        run: |
          WEB_AUTHENTICATION=$(echo "${{ inputs.webAuthentication }}" | tr -d "'" | tr -d '"')
          INGRESS_WHITELIST="${{ needs.build.outputs.ingressWhitelist }}"
          ADMIN_INGRESS_WHITELIST="${{ needs.build.outputs.adminIngressWhitelist }}"
          echo "::debug::WEB_AUTHENTICATION=$WEB_AUTHENTICATION"
          echo "::debug::INGRESS_WHITELIST=$INGRESS_WHITELIST"
          echo "::debug::ADMIN_INGRESS_WHITELIST=$ADMIN_INGRESS_WHITELIST"

          if [[ "${WEB_AUTHENTICATION}" == "true" ]] ; then
            if [[ -n "${ADMIN_INGRESS_WHITELIST}" ]] ; then
              echo "::debug::WEB_AUTHENTICATION=true,ADMIN_INGRESS_WHITELIST!=null"
          cat << EOF >> values-override.yaml
          ingress:
            annotations:
              nginx.ingress.kubernetes.io/limit-whitelist: "207.67.20.252"
              nginx.ingress.kubernetes.io/whitelist-source-range: "${INGRESS_WHITELIST}"
              nginx.ingress.kubernetes.io/auth-type: "basic"
              nginx.ingress.kubernetes.io/auth-secret: "${{ needs.build.outputs.appName }}-basic-auth"
              nginx.ingress.kubernetes.io/auth-realm: "Authentication Required"
          adminingress:
            annotations:
              nginx.ingress.kubernetes.io/whitelist-source-range: "${ADMIN_INGRESS_WHITELIST}"
          EOF
            else
              echo "::debug::WEB_AUTHENTICATION=true,ADMIN_INGRESS_WHITELIST=null"
          cat << EOF >> values-override.yaml
          ingress:
            annotations:
              nginx.ingress.kubernetes.io/limit-whitelist: "207.67.20.252"
              nginx.ingress.kubernetes.io/whitelist-source-range: "${INGRESS_WHITELIST}"
              nginx.ingress.kubernetes.io/auth-type: "basic"
              nginx.ingress.kubernetes.io/auth-secret: "${{ needs.build.outputs.appName }}-basic-auth"
              nginx.ingress.kubernetes.io/auth-realm: "Authentication Required"
          EOF
            fi
          elif [[ -n "${ADMIN_INGRESS_WHITELIST}" ]] ; then
            echo "::debug::WEB_AUTHENTICATION=false,ADMIN_INGRESS_WHITELIST!=null"
          cat << EOF >> values-override.yaml
          ingress:
            annotations:
              nginx.ingress.kubernetes.io/limit-whitelist: "207.67.20.252"
              nginx.ingress.kubernetes.io/whitelist-source-range: "${INGRESS_WHITELIST}"
          adminingress:
            annotations:
              nginx.ingress.kubernetes.io/whitelist-source-range: "${ADMIN_INGRESS_WHITELIST}"
          EOF
          else
            echo "::debug::WEB_AUTHENTICATION=false,ADMIN_INGRESS_WHITELIST=null"
          cat << EOF >> values-override.yaml
          ingress:
            annotations:
              nginx.ingress.kubernetes.io/limit-whitelist: "207.67.20.252"
              nginx.ingress.kubernetes.io/whitelist-source-range: "${INGRESS_WHITELIST}"
          EOF
          fi

      - name: Bake Helm Templates
        id: bake
        uses: azure/k8s-bake@v3
        with:
          renderEngine: "helm"
          helmChart: ${{ inputs.chartsPath }}
          releaseName: ${{ needs.build.outputs.release }}
          helm-version: "latest"
          overrideFiles: ./values-override.yaml
          overrides: |
            image.repository:${{ secrets.registryHostName }}/${{ github.event.repository.name }}
            image.tag:${{ github.sha }}-${{ inputs.environment }}
            ingress.host:${{ needs.build.outputs.ingress }}
            autoscaling.maxReplicas:${{ needs.build.outputs.maxReplicas || inputs.maximumReplicas }}

      - name: Generate .env file from Azure Key Vaults
        uses: Andrews-McMeel-Universal/get-envs@v1
        with:
          azurecredentials: ${{ secrets.azureCredentials }}
          environment: ${{ inputs.environment }}
          environmentKeyVault: ${{ inputs.environmentKeyVault }}

      - name: Set target AKS cluster
        uses: azure/aks-set-context@v4
        with:
          cluster-name: ${{ secrets.azureClusterName }}
          resource-group: ${{ inputs.clusterResourceGroup }}

      - name: Switch Kubernetes Namespace
        id: namespace
        run: |
          if [ "${{ inputs.environmentNamespace }}" == "true" ]; then
            kubectl config set-context --current --namespace="${{ inputs.environment }}"
            echo "namespace=${{ inputs.environment }}" >> $GITHUB_OUTPUT
          else
            echo "namespace=default" >> $GITHUB_OUTPUT
          fi

      - name: Apply configMap if it exists
        if: ${{ needs.build.outputs.configMap != null }}
        uses: swdotcom/update-and-apply-kubernetes-configs@v1
        with:
          k8-config-file-paths: deployments/k8s/config-${{ inputs.environment }}.yaml

      - name: Update .env Kubernetes secret
        run: |
          if kubectl get secret | grep -q "${{ needs.build.outputs.configSecret }}"; then
              kubectl delete secret "${{ needs.build.outputs.configSecret }}"
          fi
          kubectl create secret generic "${{ needs.build.outputs.configSecret }}" --validate='warn' --from-env-file ${{ github.workspace }}/.env

      - name: Update basic web authentication Kubernetes secret
        run: |
          if [[ "${{ inputs.webAuthentication }}" == "true" ]]; then
              if [[ -z "${{ secrets.webAuthenticationUsername }}" ]] || [[ -z "${{ secrets.webAuthenticationPassword }}" ]]; then
                  echo "::error::Please make sure the 'webAuthenticationUsername' and 'webAuthenticationPassword' GitHub environment secrets are set correctly."
                  exit 1
              fi
          
              if kubectl get secret | grep -q "${{ needs.build.outputs.appName }}-basic-auth"; then
                  kubectl delete secret "${{ needs.build.outputs.appName }}-basic-auth"
              fi
              htpasswd -cb auth "${{ secrets.webAuthenticationUsername }}" "${{ secrets.webAuthenticationPassword }}"
              kubectl create secret generic "${{ needs.build.outputs.appName }}-basic-auth" --from-file=auth
          fi

      - name: Create K8s Image Pull Secret
        uses: azure/k8s-create-secret@v5
        with:
          container-registry-url: ${{ secrets.registryHostName }}
          container-registry-username: ${{ secrets.registryUserName  }}
          container-registry-password: ${{ secrets.registryPassword  }}
          secret-name: "${{ needs.build.outputs.imagePullSecret }}"
          namespace: ${{ steps.namespace.outputs.namespace }}

      - name: Get previous image tag used in deployment
        id: get-previous-image
        run: |
          PREVIOUS_IMAGE=$(kubectl get deployment "${{ needs.build.outputs.appName }}" -n "${{ steps.namespace.outputs.namespace }}" -o=jsonpath='{$.spec.template.spec.containers[:1].image}' | awk -F '/' '{print $2}')
          if [ -z "${PREVIOUS_IMAGE}" ]; then
            echo "No previous image found, proceeding with deployment"
          else
            echo "Previous image found: ${PREVIOUS_IMAGE}"
          fi
          echo "previousImage=${PREVIOUS_IMAGE}" >> $GITHUB_OUTPUT

      - name: Deploy to Azure Kubernetes Service
        timeout-minutes: ${{ inputs.deploymentTimeout }}
        uses: azure/k8s-deploy@v5
        with:
          namespace: ${{ steps.namespace.outputs.namespace }}
          manifests: ${{ steps.bake.outputs.manifestsBundle }}
          images: |
            "${{ secrets.registryHostName }}/${{ github.event.repository.name }}:${{ github.sha }}-${{ inputs.environment }}"
          imagepullsecrets: |
            "${{ needs.build.outputs.imagePullSecret }}"
          pull-images: false

      - name: Unlock and untag previous ACR image
        if: ${{ steps.get-previous-image.outputs.previousImage != '' }}
        run: |
          PREVIOUS_MANIFEST=$(az acr repository show --name "${{ secrets.registryHostName }}" --image "${{ steps.get-previous-image.outputs.previousImage }}" --query "digest" -o tsv || true)
          if [[ -n "$PREVIOUS_MANIFEST" ]] && [[ "${{ steps.get-previous-image.outputs.previousImage }}" != "${{ github.event.repository.name }}:${{ github.sha }}-${{ inputs.environment }}" ]]; then
            echo "Unlocking previous manifest: ${PREVIOUS_MANIFEST}"
            az acr repository update --name "${{ secrets.registryHostName }}" --image "${{ github.event.repository.name }}@${PREVIOUS_MANIFEST}" --delete-enabled true --write-enabled true
            while read -r TAG; do
              SEMVER_REGEX="^[0-9]+\.[0-9]+\.[0-9]+$"
              if [[ ! "${TAG}" =~ $SEMVER_REGEX ]]; then
                echo "Untagging ${{ github.event.repository.name }}:${TAG}"
                az acr repository untag --name "${{ secrets.registryHostName }}" --image "${{ github.event.repository.name }}:${TAG}"
              else
                echo "Skipping untagging ${{ github.event.repository.name }}:${TAG}"
              fi
            done < <(az acr repository show --name "${{ secrets.registryHostName }}" --image "${{ github.event.repository.name }}@${PREVIOUS_MANIFEST}" --query "tags" -o tsv)
          elif [[ "${{ steps.get-previous-image.outputs.previousImage }}" == "${{ github.event.repository.name }}:${{ github.sha }}-${{ inputs.environment }}" ]]; then
            echo "Deployment image is the same as the current image. Skipping unlocking."
          else
            echo "Previous manifest could not be found. Skipping unlocking."
          fi

      - name: Disable delete access for newly deployed image
        run: |
          IMAGE_MANIFEST=$(az acr repository show --name "${{ secrets.registryHostName }}" --image "${{ github.event.repository.name }}:${{ github.sha }}-${{ inputs.environment }}" --query "digest" -o tsv)
          if [ -z "${IMAGE_MANIFEST}" ]; then
            echo "Failed to get current image manifest"
          fi
          az acr repository update --name "${{ secrets.registryHostName }}" --image "${{ github.event.repository.name }}@${IMAGE_MANIFEST}" --delete-enabled false

      - name: Create or Update Public DNS Record
        id: dns
        run: |
          if [ "${{ inputs.environmentNamespace }}" == "true" ]; then
            INGRESS="${{ secrets.azureClusterName }}-${{ inputs.environment }}"
          else
            INGRESS="${{ secrets.azureClusterName }}"
          fi
          AKS_INGRESS="${INGRESS}-ingress.centralus.cloudapp.azure.com."
          az network dns record-set cname set-record --resource-group "AMU_DNS_RG" --zone-name "${{ needs.build.outputs.domainName }}" --record-set-name "${{ needs.build.outputs.hostName }}" --cname "${AKS_INGRESS}" --ttl 3600

          echo "aksIngress=${AKS_INGRESS}" >> $GITHUB_OUTPUT

      - name: Record deployment information in Azure Storage Table
        uses: LadyCailin/azure-table-storage-upload@v1.0.1
        with:
          table_name: "DeployedApplications"
          partition_key: "${{ github.event.repository.name }}"
          row_key: "${{ inputs.environment }}"
          data: "ApplicationName=${{ needs.build.outputs.appName }} Version=${{ needs.build.outputs.appVersion }} KeyVault=${{ inputs.environmentKeyVault }} HostName=${{ needs.build.outputs.hostName }} DomainName=${{ needs.build.outputs.domainName }} IngressFqdn=${{ needs.build.outputs.ingress }} HealthCheckPath=${{ needs.build.outputs.appHealthCheck }} AksIngress=${{ steps.dns.outputs.aksIngress }} Cluster=${{ secrets.azureClusterName }} ClusterResourceGroup=${{ inputs.clusterResourceGroup }} ConfigSecret=${{needs.build.outputs.configSecret }} ConfigMap=${{ needs.build.outputs.configMap }} LastDeploy=${{ needs.build.outputs.date }}"
          if_exists: "replace"
          extra_args: ""
          connection_string: "AccountName=amucloudapps;AccountKey=${{ secrets.storageAccountKey }}"

      - name: Create deployment summary
        run: |
          echo "### ${{ needs.build.outputs.appName }} Deployment Details" >> $GITHUB_STEP_SUMMARY
          echo "- **Application Name**: ${{ needs.build.outputs.appName }}" >> $GITHUB_STEP_SUMMARY
          echo "- **Environment**: ${{ inputs.environment }}" >> $GITHUB_STEP_SUMMARY
          echo "- **Version**: ${{ needs.build.outputs.appVersion }}" >> $GITHUB_STEP_SUMMARY
          echo "- **Key Vault Name**: ${{ inputs.environmentKeyVault }}" >> $GITHUB_STEP_SUMMARY
          echo "- **FQDN**: ${{ needs.build.outputs.ingress }}" >> $GITHUB_STEP_SUMMARY
          echo "- **ConfigSecret**: ${{ needs.build.outputs.configSecret }}" >> $GITHUB_STEP_SUMMARY
          if [[ -n "${{ needs.build.outputs.configMap }}" ]] ; then
            echo "- **ConfigMap**: ${{ needs.build.outputs.configMap }}" >> $GITHUB_STEP_SUMMARY
          fi

      - name: Send Failed Deployment report to Teams
        if: failure() && (inputs.environment != 'development')
        uses: jdcargile/ms-teams-notification@v1.4
        with:
          github-token: ${{ github.token }} # this will use the runner's token.
          ms-teams-webhook-uri: ${{ inputs.deploymentWebhook }}
          notification-summary: "${{ github.event.release.tag_name != '' && format('{0} ', github.event.release.tag_name) || ' ' }}Failed ${{ inputs.environment }} Deployment"
          notification-color: 17a2b8
          timezone: America/Chicago
          verbose-logging: true

      - name: Send Succeeded Deployment report to Teams
        if: success() && (inputs.environment != 'development')
        uses: jdcargile/ms-teams-notification@v1.4
        with:
          github-token: ${{ github.token }} # this will use the runner's token.
          ms-teams-webhook-uri: ${{ inputs.deploymentWebhook }}
          notification-summary: "${{ github.event.release.tag_name != '' && format('{0} ', github.event.release.tag_name) || ' ' }}Successful ${{ inputs.environment }} Deployment"
          notification-color: 28a745
          timezone: America/Chicago
          verbose-logging: true