Forem: Mickaël Mottet

Build and deploy .NET 5 app with GitHub Actions

Mickaël Mottet — Tue, 19 Jan 2021 09:47:18 +0000

As a personal project, I'm learning about GitHub Actions and DevOps in general. I'm a former .NET developer so it's my prefered technology to work with.
My goal on this post, is to deploy a sample .NET 5 application to Azure App Service as a container with GitHub Actions. I will author the ARM template using Bicep.
I work on MacOS but the same process can be achieved on Windows or Linux.

Let's start.

Tooling

Few tools used on this project:

An Azure Subscription to deploy resources
A GitHub repository to store the source code and use GitHub Actions
Azure CLI
Bicep
I recommend Visual Studio Code
Dotnet 5
A terminal to execute commands

Create new .NET 5 project

First, we have to create a new project.
In my case I created a repository called demoaspnet5container

The command to clone the repository to local folder is:

git clone https://github.com/MCKLMT/demoaspnet5container.git

We now have a copy of our repository locally.
We will create a new .NET 5 project.
Go in the cloned folder and execute the following command. In my case, my project will be called WebApp:

dotnet new project WebApp

Our new project has been created and you can run it locally using the command:

dotnet run

And now, you can browse the web site locally using your browser at http://localhost:5000

You can create a .gitignore file to avoid to push build artetifacts to GitHub with the following command:

dotnet new gitignore

Authoring the Docker image

Now we have our application, we want to containerize it.
To do so, we create a Dockerfile file in the same folder than the application.
The Dockerfile looks like this one:

FROM mcr.microsoft.com/dotnet/sdk:5.0 AS build-env
WORKDIR /app

RUN dotnet --version

COPY *.csproj ./
RUN dotnet restore

COPY . ./
RUN dotnet publish -c Release -o out

FROM mcr.microsoft.com/dotnet/aspnet:5.0
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "WebApp.dll"]

This file is pretty simple.
First, we use a build image to restore dependencies and publish the content of the web site and secondly, we copy the resulting of the build to a new image.

Using Bicep to author ARM template

Bicep is a recent open source project which aims to simplify the authoring of Azure Resource Manager templates.
Once the template is created, you have to run the following command to build the ARM file:

bicep build main.bicep

This command will output the ARM file you can deploy using Azure CLI for instance.

I would like to share few things about it.

First, in my case, I want to use Azure App Service on Linux to host the container I built previously. The container image will be built and stored with Azure Container registry. To do so, Azure App Service will need to have the rights to pull the image from Azure Container Registry. To achieve this goal, I will create a user managed identity and affect this identity to App Service. Afterwards, I assign the permission to pull the registry to the identity. Voilà, our App Service can safely access the registry.

The bicep code of user managed identity and the role assignment:

resource managedIdentity 'Microsoft.ManagedIdentity/userAssignedIdentities@2018-11-30' = {
  name: 'webAppIdentity'
  location: location
}

resource roleAssignment 'Microsoft.Authorization/roleAssignments@2020-04-01-preview' = {
  name: roleAssignmentName
  scope: containerRegistry
  properties: {
    roleDefinitionId: roleDefinitionId
    principalId: managedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
  }
}

The complete bicep file is available on GitHub

Create our GitHub workflow

We have all the code to be deployed on Azure.

The bicep file which will be converted to ARM template
The Docker image to deploy to App Service

We will create a .github/workflows/dotnet-core.yaml file. This file will contain all the steps needed and will be executed at each commit push on the master branch.

First, we will deploy the infrastructure. We have to build our bicep file, connect to Azure and deploy the resulting template:

- name: Run Bicep build
uses: aliencube/bicep-build-actions@v0.1
with:
    files: Infrastructure/main.bicep

- name: Login to Azure
uses: azure/login@v1
with:
    creds: ${{ secrets.AZURE_CREDENTIALS }}

- name: Deploy Azure Resource Manager (ARM) Template
uses: azure/arm-deploy@v1
id: deploy
with:
    scope: resourcegroup
    subscriptionId: ${{ secrets.SUBSCRIPTION_ID }}
    resourceGroupName: demoaspnet5container-rg
    template: ./Infrastructure/main.json
    deploymentMode: Incremental

Secondly, we will build the container using Azure Container Registry:

- name: Build image with ACR
  uses: azure/CLI@v1
  with:
    azcliversion: latest
    inlineScript: |
    az acr build --registry ${{ steps.deploy.outputs.registryNameOutput }} --image aspnet5webapp:${{ env.COMMIT_REF }} ./WebApp/

The source code will be zipped, uploaded to Azure Container Registry and built in the cloud.

The final step is to tell to App Service where to get the image:

- name: Deploy the image to App Service
  uses: azure/CLI@v1
  with:
    azcliversion: latest
    inlineScript: |
    az webapp config container set --name ${{ steps.deploy.outputs.webAppNameOutput }} --resource-group ${{ steps.deploy.outputs.resourceGroupOutput }}

Congratulations, your website should be up and running!

I hope you liked this post and feel free to contact me on Twitter if you want to discuss about it!

Resources

The complete source code is available on GitHub:

MCKLMT / demoaspnet5container

Sample ASP.NET 5 application deployed to App Service on Linux as a container with GitHub Actions

Few resources to go deep on this topic:

Build and deploy Angular app with Azure DevOps

Mickaël Mottet — Sat, 09 Jan 2021 17:38:56 +0000

One of my customers wanted to deploy an Angular application to Azure App Service. Azure DevOps was already used in another project so it was obvious to use it for this new one.

Install NodeJS

I work on MacOS so homebrew can help to install packages. If you are on Windows or Linux, you can find the last files to install there.

On MacOS when homebrew is already installed, you just have to run the command:

brew install node

Install Angular CLI

Once node installed, you can get the last Angular CLI. This utility can help in various tasks. One of them is to create new Angular projects from scratch.
To install Angular CLI globally, you can use this command:

npm install -g @angular/cli

The CLI will be available anywhere on your system.

Create a new Angular project

We can now create a new Angular project. The command is very simple :

ng new HelloWorld --strict false --routing false --style css

This command will create a new project called HelloWorld with default settings. It can take a little of time because of the number of modules to add.

Testing the application

Go in the folder of the project

cd HelloWorld

You can try the application using the command:

ng serve

This command will generate the application and create a node server on port 4200. Just launch your browser at http://localhost:4200/ to see the default page.

You can use Control C in the terminal to exit.

Create the Azure Pipeline

Congratulations, our application is ready to be deployed! It's time to add the CI/CD part.

I will not explain how to create an Azure DevOps project here. It's very simple and if you have doubts, you can read the documentation.

We have now to create a new pipeline.
The first part is building the application

- stage: Build
  displayName: Build stage
  jobs:
  - job: BuildJob
    pool:
      vmImage: 'ubuntu-20.04'
    steps:
      - task: NodeTool@0
        inputs:
          versionSpec: '10.x'
        displayName: 'Install Node.js'

      - script: |
          cd '$(System.DefaultWorkingDirectory)/HelloWorld'
          npm install -g @angular/cli
          npm install
          ng build --prod
        displayName: 'npm install and build'
      - task: ArchiveFiles@2
        displayName: 'Archive files'
        inputs:
          rootFolderOrFile: '$(System.DefaultWorkingDirectory)/HelloWorld/dist/HelloWorld/'
          includeRootFolder: false
          archiveType: zip
          archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
          replaceExistingArchive: true

      - task: PublishBuildArtifacts@1
        inputs:
          PathtoPublish: '$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip'
          ArtifactName: 'drop'
          publishLocation: 'Container'

The code is pretty simple:

We install node on the agent
We install the Angular CLI
We install the NPM packages
We build the Angular application
We zip the files
We publish the zip as artifact

The second part is deploying the application:

- stage: Deploy
  displayName: 'Deploy Web App'
  dependsOn: Build
  condition: succeeded()
  jobs:
  - deployment: DeploymentJob
    pool:
      vmImage: 'ubuntu-20.04'
    environment: $(environmentName)
    strategy:
      runOnce:
        deploy:
          steps:

          - task: AzureWebApp@1
            displayName: 'Deploy Azure Web App : $(webAppName)'
            inputs:
              azureSubscription: $(azureSubscription)
              appName: $(webAppName)
              appType: webAppLinux
              package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip

In this stage, we only have on action. We get the artifact as zip file and we publish it to Azure App Service with the zip deploy task.

Complete code

The complete code of the project is hosted on GitHub. If you are only interested by the code of the Azure Pipeline, you can read it there.

Build and deploy PHP Symfony with Azure DevOps

Mickaël Mottet — Fri, 04 Dec 2020 17:20:53 +0000

I had the opportunity to work on a PHP Symfony application with a new customer with Azure DevOps.
The problematic was to build the application with several commands to pass on the source code and afterwards to push the application to an Azure App Service web application.
I assume that you are familiar with Azure Pipelines and will only share the content of the pipeline itself and not the way to create it.

So, once the pipeline is created, we have several tasks to accomplish.

First, we need to select the correct version of PHP. In our case it will be PHP 7.4.

- script: |
    sudo update-alternatives --set php /usr/bin/php$(phpVersion)
    sudo update-alternatives --set phar /usr/bin/phar$(phpVersion)
    sudo update-alternatives --set phpdbg /usr/bin/phpdbg$(phpVersion)
    sudo update-alternatives --set php-cgi /usr/bin/php-cgi$(phpVersion)
    sudo update-alternatives --set phar.phar /usr/bin/phar.phar$(phpVersion)
    php -version
  workingDirectory: $(rootFolder)
  displayName: 'Use PHP version $(phpVersion)'

In our case, we'll have to execute database migrations with Doctrine. The customer has chosen Azure SQL Database as provider. The problem is that this driver is not embedded in the hosted agent image. We have to install it using PECL.

- script: |
    sudo pecl config-set php_ini /etc/php/7.4/cli/php.ini
    sudo pecl config-set ext_dir /usr/lib/php/20190902/
    sudo pecl config-set bin_dir /usr/bin/
    sudo pecl config-set php_bin /usr/bin/php7.4
    sudo pecl config-set php_suffix 7.4
    sudo pecl channel-update pecl.php.net
    sudo pecl install sqlsrv-5.8.1
    sudo pecl install pdo_sqlsrv-5.8.1
  displayName: PECL install sqlsrv

Once installed, we have to tell to PHP where to find the installed modules.

- script: |
    sudo bash -c "echo extension=sqlsrv.so > /etc/php/7.4/cli/conf.d/99-sqlsrv.ini"
    sudo bash -c "echo extension=pdo_sqlsrv.so > /etc/php/7.4/cli/conf.d/99-sqlsrv.ini"
    displayName: 'SQLSRV modify ini files'

A quick check that all is good using PHPinfo()

- script: php -i
  workingDirectory: $(rootFolder)
  displayName: 'PHPinfo()'

Now that all is good, we can add dependencies with Composer and "compile" the web application.

- script: |
  curl -sS https://getcomposer.org/installer | php
  php composer.phar install --no-dev --optimize-autoloader
  php composer.phar dump-env %APP_ENV%
  php bin/console cache:clear
  workingDirectory: $(rootFolder)
  displayName: 'Composer install'

Now we can update execute the database migrations using Doctrine

- script: php bin/console doctrine:migrations:migrate --no-interaction
  workingDirectory: $(rootFolder)
  displayName: 'Update database'

And finally, we can execute the "classic" steps, storing the build artifacts and deploying to Azure App Service.

- task: ArchiveFiles@2
  displayName: 'Archive files'
  inputs:
    rootFolderOrFile: '$(rootFolder)'
    includeRootFolder: false
    archiveType: zip
    archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
    replaceExistingArchive: true

- upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
  displayName: 'Upload package'
  artifact: drop

- stage: Deploy
  displayName: 'Deploy Web App'
  dependsOn: Build
  condition: succeeded()
  jobs:
- deployment: DeploymentJob
  pool:
    vmImage: $(vmImageName)
  environment: $(environmentName)
  strategy:
    runOnce:
      deploy:
        steps:
        - task: AzureWebApp@1
          displayName: 'Deploy Azure Web App : $(webAppName)'
          inputs:
            azureSubscription: $(azureSubscription)
            appName: $(webAppName)
            appType: webAppLinux
            package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip

And finally, our website is deployed! 👍🏻

Full script is below:

# PHP as Linux Web App on Azure
# Build, package and deploy your PHP project to Azure Linux Web App.
# Add steps that run tests and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/php

trigger:
- master

variables:
  # Azure Resource Manager connection created during pipeline creation
  azureSubscription: '##ID OF THE SERVICE CONNECTION##'

  # Environment name
  environmentName: '##NAME OF THE ENVIRONMENT##'

  # Web app name
  webAppName: '##NAME OF THE WEB APP##'

  # Agent VM image name
  vmImageName: 'Ubuntu-20.04'

  # Root folder under which your |
  rootFolder: $(System.DefaultWorkingDirectory)

stages:
- stage: Build
  displayName: Build stage
  variables:
    phpVersion: '7.4'
  jobs:
  - job: BuildJob
    pool:
      vmImage: $(vmImageName)
    steps:
- script: |
    sudo update-alternatives --set php /usr/bin/php$(phpVersion)
    sudo update-alternatives --set phar /usr/bin/phar$(phpVersion)
    sudo update-alternatives --set phpdbg /usr/bin/phpdbg$(phpVersion)
    sudo update-alternatives --set php-cgi /usr/bin/php-cgi$(phpVersion)
    sudo update-alternatives --set phar.phar /usr/bin/phar.phar$(phpVersion)
    php -version
  workingDirectory: $(rootFolder)
  displayName: 'Use PHP version $(phpVersion)'

- script: |
    sudo pecl config-set php_ini /etc/php/7.4/cli/php.ini
    sudo pecl config-set ext_dir /usr/lib/php/20190902/
    sudo pecl config-set bin_dir /usr/bin/
    sudo pecl config-set php_bin /usr/bin/php7.4
    sudo pecl config-set php_suffix 7.4
    sudo pecl channel-update pecl.php.net
    sudo pecl install sqlsrv-5.8.1
    sudo pecl install pdo_sqlsrv-5.8.1
  displayName: PECL install sqlsrv

- script: |
    sudo bash -c "echo extension=sqlsrv.so > /etc/php/7.4/cli/conf.d/99-sqlsrv.ini"
    sudo bash -c "echo extension=pdo_sqlsrv.so > /etc/php/7.4/cli/conf.d/99-sqlsrv.ini"
    displayName: 'SQLSRV modify ini files'

  - script: php -i
    workingDirectory: $(rootFolder)
    displayName: 'PHPinfo()'

  - script: |
    curl -sS https://getcomposer.org/installer | php
    php composer.phar install --no-dev --optimize-autoloader
    php composer.phar dump-env %APP_ENV%
    php bin/console cache:clear
    workingDirectory: $(rootFolder)
    displayName: 'Composer install'

  - script: curl -sS https://get.symfony.com/cli/installer | bash
    workingDirectory: $(rootFolder)
    displayName: 'Install SymfonyCLI'

  - script: /home/vsts/.symfony/bin/symfony check:requirements
    workingDirectory: $(rootFolder)
    displayName: 'Symfony check requirements'

  - script: php bin/console doctrine:migrations:migrate --no-interaction
    workingDirectory: $(rootFolder)
    displayName: 'Update database'

  - task: ArchiveFiles@2
    displayName: 'Archive files'
    inputs:
      rootFolderOrFile: '$(rootFolder)'
      includeRootFolder: false
      archiveType: zip
      archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
      replaceExistingArchive: true

  - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
    displayName: 'Upload package'
    artifact: drop

  - stage: Deploy
    displayName: 'Deploy Web App'
    dependsOn: Build
    condition: succeeded()
    jobs:
  - deployment: DeploymentJob
    pool:
      vmImage: $(vmImageName)
    environment: $(environmentName)
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            displayName: 'Deploy Azure Web App : $(webAppName)'
            inputs:
              azureSubscription: $(azureSubscription)
              appName: $(webAppName)
              appType: webAppLinux
              package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip
``