Tutorials - Software Developer's Tour

Azure DevOps Pipeline in practice

Paweł Majewski — Sat, 15 Mar 2025 21:47:41 +0000

What is Pipeline?

Pipeline is a solution that automatically build, test and deploy an application. We can split Pipeline to (CI) and (CD) Pipelines.

CI – Continous Integration

CD – Continous Delivery/Deployment

CI – helps maintain code quality by catching errors early in the development process.

CD – streamlines the process of delivering code changes to production environments efficiently and reliably.

Use it in practice!

Today, I’ll show you how to use Azure DevOps Pipeline to deploy your application.

To follow this tutorial, go to Azure DevOps and create a new project.

I created a new organization named “pawelmajewskiblog” and a project named “Pipeline example“.

Now, let’s create a sample WebAPI application that we want to deploy using Azure Pipelines.

[WebApiProject - Minimal API] Program.cs

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
app.UseSwagger();
app.UseSwaggerUI();
app.UseHttpsRedirection();

var startDate = DateTime.Now;
var pipelineVariable = Environment.GetEnvironmentVariable("pipeline_variable");

app.MapGet("/", () =>
{
    return new { startDate, pipelineVariable };
})
.WithName("GetVersion")
.WithOpenApi();

app.Run();

This application contains one endpoint named GetVersion, which returns the start date of the application (startData) and the pipeline variable (pipelineVariable) that we will set in the pipeline.

Localhost response is presented below.

Push code to the repository

You can add .gitignore file https://raw.githubusercontent.com/github/gitignore/main/VisualStudio.gitignore.

When our repository is ready, we can go to the next step.

Create first pipeline

Go to the

And click “Create Pipeline”.

Select your repository, I’ll choose “Azure Repos Git”

Use the script for pipeline presented below

trigger:
- master

pool:
  vmImage: 'ubuntu-latest'

variables:
  buildConfiguration: 'Release'

steps:
- task: UseDotNet@2
  displayName: 'Install .NET Core SDK'
  inputs:
    version: 8.x
    
- task: DotNetCoreCLI@2
  inputs:
    command: 'restore'
    projects: '**/*.csproj'
  displayName: 'dotnet restore $(buildConfiguration)'

- task: DotNetCoreCLI@2
  inputs:
    command: 'build'
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration)'
  displayName: 'dotnet build $(buildConfiguration)'

When you save this pipeline configuration file, then pipeline runs automatically for the first time.

When the pipeline finishes its work, you will be notified by email.

We’ll also receive an email when the build fails.

The post Azure DevOps Pipeline in practice first appeared on Software Developer's Tour.

How to create simple healthcheck in 5 minutes

Paweł Majewski — Tue, 04 Mar 2025 17:07:00 +0000

In the past, when I used a different hosting provider than I do now, I often encountered situations where the website was unavailable.

How can we check if a website is accessible without constantly refreshing it in the browser?

Just write your own app!

First, let’s think about what we want to do.

Application requirements

We want the ability to pass multiple URLs to the application
We haven't time, so our choice will be Console application😊
The application should inform us whether the request has returned a success status code or has failed.
To avoid being banned for DDoS, the application should incorporate a delay.between requests

You can read more about DDoS attack here.

Possibility of being banned You have to handle the given code very carefully, as placing the delay incorrectly could result in your application unintentionally launching DDoS attacks on the provided websites.

I will paste here entire code and then we’ll talk about it closer.

class Program
{
    static async Task Main(string[] args)
    {
        const string fileName = "sites.txt";
        TimeSpan delay = TimeSpan.FromSeconds(10);
        var fileContent = await ValidateFileAsync(fileName);
        var urlsWithClients = PrepareUrls(fileContent);

        await RunInfinity(urlsWithClients, delay);
    }

    static async Task IsAliveAsync(HttpClient httpClient)
    {
        try
        {
            var result = await httpClient.GetAsync(string.Empty);

            return result.IsSuccessStatusCode;
        } catch
        {

        }

        return false;
    }

    static async Task ValidateFileAsync(string filePath)
    {
        var doesFileExist = File.Exists(filePath);

        if (!doesFileExist)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Couldn't find file");
            Console.ResetColor();

            return [];
        }

        var fileContent = await File.ReadAllLinesAsync(filePath);

        if(!fileContent.Any())
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("There is no url in file");
            Console.ResetColor();
        }

        return fileContent;
    }

    static (string Url, HttpClient httpClient)[] PrepareUrls(IEnumerable urls)
    {
        return urls.Select(x => {
            var httpClient = new HttpClient
            {
                BaseAddress = new Uri(x)
            };

            return (x, httpClient);
        }).ToArray();
    }

    static Task RunInfinity(IEnumerable<(string Url, HttpClient httpClient)> urls, TimeSpan delay)
    {
        return Task.Run(async () =>
        {
            while (true)
            {
                foreach (var (x, httpClient) in urls)
                {
                    var isAlive = await IsAliveAsync(httpClient);

                    Console.Write($"{DateTime.Now:dd-MM HH:mm:ss}\tUrl: {x}\t");
                    if (isAlive)
                    {
                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.WriteLine("OK");
                    }
                    else
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("FAILED");
                    }
                    Console.ResetColor();

                }

                await Task.Delay(delay);
            }
        });
    }
}

Let’s start analyzing 🙂

The main function

        const string fileName = "sites.txt";
        TimeSpan delay = TimeSpan.FromSeconds(10);
        var fileContent = await ValidateFileAsync(fileName);
        var urlsWithClients = PrepareUrls(fileContent);

        await RunInfinity(urlsWithClients, delay);

First two lines are our configuration. When creating this application, I assumed that the user will provide urls to check in file named sites.txt and this file will be next to .exe file. I aimed to keep it as straightforward as I could.

Then we have simple validation, I think we can just skip it. I added it only because I got an exception during development 😁

I didn’t want to read the file twice, so the validation function immediately passes on the read data.

    static (string Url, HttpClient httpClient)[] PrepareUrls(IEnumerable urls)
    {
        return urls.Select(x => {
            var httpClient = new HttpClient
            {
                BaseAddress = new Uri(x)
            };

            return (x, httpClient);
        }).ToArray();
    }

I think this is a good place to refactor. We don’t need a tuple with a string and HttpClient here. Since HttpClient already contains BaseAddress itself, we could retrieve this information directly from it.

Function IsAliveAsync is only wrapper for GetAsync method.

And last our system’s core, our heart beating method

        return Task.Run(async () =>
        {
            while (true)
            {
                foreach (var (x, httpClient) in urls)
                {
                    var isAlive = await IsAliveAsync(httpClient);

                    Console.Write($"{DateTime.Now:dd-MM HH:mm:ss}\tUrl: {x}\t");
                    if (isAlive)
                    {
                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.WriteLine("OK");
                    }
                    else
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("FAILED");
                    }
                    Console.ResetColor();

                }

                await Task.Delay(delay);
            }
        });

What are we doing here? There are just two loops, one while loop, which with Task.Delay (line 24) will be our beating heart.

Inside while loop is loop over our urls and and that’s it, no philosophy involved.

Additionally, one “if” statement to check whether the request was successful or not.

How it works?

Create file with urls

Start application

At the end

I strongly encourage you to write simple applications. Writing one can take as much time as finding the right one online.

The post How to create simple healthcheck in 5 minutes first appeared on Software Developer's Tour.

Introduction to Jenkins and Pipelines

Paweł Majewski — Wed, 05 Feb 2025 16:40:30 +0000

What is Pipeline?

Pipeline is a solution that automatically build, test and deploy an application. We can split Pipeline to (CI) and (CD) Pipelines.

CI – Continous Integration

CD – Continous Delivery/Deployment

CI – helps maintain code quality by catching errors early in the development process.

CD – streamlines the process of delivering code changes to production environments efficiently and reliably.

Use it in practice!

Today, I’ll show you how to use Jenkins to create CI for your application.

To follow this tutorial, go to https://www.jenkins.io/doc/book/installing/ and install Jenkins.

Create console application in Visual Studio

Console.WriteLine($"It works");

Push it to your remote repository. You can see an example on https://github.com/MajewskiPawel/app-ci-cd

Use Jenkins!

If your repository is private, you’ll need to add credentials to authorize Jenkins with your Git provider. Navigate to Dashboard -> Manage Jenkins -> Credentials -> System -> Global credentials (unrestricted).

When you click “Add credentials” button choose “SSH Username with private key” in “Kind” field.

“Username” – username or email

“Private Key” -> click “Enter directly“

To add Private Key you need public and private key.

After this, you will find both jenkins and jenkins.pub files in your user directory.

Open jenkins.pub file, copy entire value and paste it in your profile configuration on your git provider (example for GitHub is presented below).

Open jenkins file (without pub extension), copy entire value and paste it in Private Key field in Jenkins credentials configurator.

After saving the form, you should see a list of credentials. Save the ID of the created element because we will need it later.

Create new pipeline

On the main dashboard click “New Item” and add new Pipeline

Below is the script I have created to build previously created application.

pipeline {
    agent any
    
    stages {
        stage ('Git') {
            steps {
                git branch: 'main', credentialsId: 'test-application', url: 'https://github.com/MajewskiPawel/app-ci-cd'
            }
        }
        stage('Restore packages') {
            steps {
                powershell "dotnet restore '${workspace}\\App\\App.sln'"
            }
        }
        stage('Build project') {
            steps {
                powershell "dotnet build --configuration Release '${workspace}\\App\\App.csproj'"
            }
        }
    }
}

Run it!

Click “Build Now” button on the left navigation bar and see the magic.

We can configure Jenkins to synchronize with Git events and our builds can be executed when pull request have been created or when we push something to master branch.

Why are we doing this?

Before I explain, please modify your application code to the presented below.

var z = 
Console.WriteLine($"It works");

and push it to your repository.

Click “Build Now” button again.

If we had it connected to Git events, we would know immediately when our code has failed, right after someone pushed it to the main branch.

Everything we just did is called CI. Not so scary, right :)?

The post Introduction to Jenkins and Pipelines first appeared on Software Developer's Tour.

Why is testing our apps so important?

Paweł Majewski — Sat, 25 Jan 2025 19:10:04 +0000

Hi, today I would like to address the next topic – testing.

The example that will be shown today is trivial, but it will effectively illustrate what can go wrong due to writing target code too quickly without testing.

There are many types of tests but today, I’ll focus on unit tests.

Firstly, let’s take a look at the simple project structure presented below.

We have 3 projects.

Calculator.Console – it’s console project application.
Calculator.Engine – it’s a library application; this is where all of our application logic will reside.
1. Calculator.Engine.Tests – the final project is where we will consolidate all our tests related to the Calculator.Engine project.

[Calculator.Console] Program.cs

using Calculator.Engine;

Console.WriteLine("Function -> Add");
Console.Write("X = ");
var x = double.Parse(Console.ReadLine());
Console.Write("Y = ");
var y = double.Parse(Console.ReadLine());
var z = MathEngine.Add(x, y);

Console.WriteLine($"Output = {z}");

The application is quite basic, lacking any form of validation etc.

It prompts the user for two numbers and returns the sum of these elements as the result.

[Calculator.Engine] MathEngine.cs

namespace Calculator.Engine;

public class MathEngine
{
    public static double Add(double x, double y)
    {
        return x - y;
    } 
}

This project is a brain of our application. As you can see the result of Add operation is wrong (x – y instead of x + y) but developer doesn’t know that.

[Calculator.Engine.Tests] AddTests

using Calculator.Engine;
using FluentAssertions;

namespace Calculator.Tests
{
    public class Tests
    {
        [Test]
        public void Returns_Valid()
        {
            // Arrange
            var x = 2;
            var y = 3;

            // Act
            var z = MathEngine.Add(x, y);

            // Assert
            z.Should().Be(5, because: "2 + 3 = 5");
        }

        [Test]
        public void Returns_Valid_X_Negative_Y_Positive()
        {
            // Arrange
            var x = -2;
            var y = 3;

            // Act
            var z = MathEngine.Add(x, y);

            // Assert
            z.Should().Be(1, because: "-2 + 3 = 1");
        }
    }
}

This project uses FluentAssertion overriding base assertions that comes with NUnit.

The first method, Returns_Valid, initializes the components required for addition. The result of Add operation should be 5 but, in MathEngine is – instead of +. Second method does the same but first component is negative.

Let’s then look at the test results in this form.

FluentAssertions is named “Fluent”, because you can read the code like speech in real language.

We can see that both tests have failed. it is now possible to investigate to find the error.

[Calculator.Engine] MathEngine.cs

namespace Calculator.Engine;

public class MathEngine
{
    public static double Add(double x, double y)
    {
        return x + y;
    } 
}

When I fix the bug with replacing – with +, I’ll start the tests again and see what happens.

Everything works fine. The tests have passed, and the code is correct now.

Summary

This trivial example of a unit test can show us how important testing our applications is. Without tests, this code would likely be returned to development as a failed task or bug.

The post Why is testing our apps so important? first appeared on Software Developer's Tour.