March 2022 - GeralexGR

Posted on March 30, 2022March 30, 2022 by geralexgr — 1 Comment

Powershell handle Invoke-WebRequest 404 error

In some cases you may need to use Invoke-WebRequest of powershell as a correct result with status code of 404. A use case for this scenario would be a smoke test for a particular service or URL. In newer powershell versions you can use SkipHttpErrorCheck in order to stop powershell from failing the script.

The below example is a simple Web request that will fail on Powershell <7 with an exception if a 404 response is returned from the webpage.

$req = Invoke-WebRequest -Uri $url -Method GET

The parameter that you could use with Powershell 7++ and you would not have the powershell task failed would be.

$req = Invoke-WebRequest -Uri $url -Method GET -SkipHttpErrorCheck

In order to bypass this issue you could handle the exception on Powershell <7 and add your logic inside the catch block. For example

try {
    $resultApi = MakeWebRequest("http://localhost:1234/api/console") 
}
catch {
    if( $_.Exception.Response.StatusCode.Value__ -eq 404 ) 
    {
        Write-Host "API console Test 404 , proceeding ..."
    }
    else {
        Write-Host "False response..."
    }
}

Posted on March 29, 2022March 29, 2022 by geralexgr — Leave a comment

Automate virtual machines deployment with terraform and Azure Devops

Following my previous article about resources deployment on Azure using terraform, I will now explain how you could deploy those resources through Azure DevOps.

Deploy windows and linux virtual machines on Azure using terraform

You can find pipeline code on my Github repository
https://github.com/geralexgr/terraform-az-lin-win/blob/main/azure-pipelines.yml

To getting started you will need to install in your Azure DevOps organization the terraform extension provided from Microsoft DevLabs.

You can install it using the below link

https://marketplace.visualstudio.com/items?itemName=ms-devlabs.custom-terraform-tasks&ssr=false#overview

Then you will have to create a resource group and a storage account inside. You will need the storage account to create a container that will hold you tfstate file.

Under your storage account select containers and add a new container. I created one named terraform that will be used in the pipeline.

Pipeline explanation:

Pipeline contains three tasks. The first task will install terraform tools. The second one will initialize terraform in your working directory. Based on the user input provided in the pipeline the appropriate resource will be deployed. The code on the github contains two separate directories, one for windows and one for linux machines.

Selecting windows will deploy a windows VM using terraform

The third task will apply your terraform configuration. The working directory is generated automatically from the provided parameter.

Terraform init variables:

          - task: TerraformTaskV2@2
            displayName: terraform init
            inputs:
              provider: 'azurerm' 
              command: 'init'
              workingDirectory: '$(Build.SourcesDirectory)/${{ parameters.image }}' // your working terraform directory
              backendServiceArm: 'AzureMSDN' // azure devops service connection with your subscription
              backendAzureRmResourceGroupName: 'terraform' //resource group name
              backendAzureRmStorageAccountName: 'geralexgrstorageaccount' //storage account name
              backendAzureRmContainerName: 'terraform' //container inside storage account
              backendAzureRmKey: 'terraform.tfstate' //state file name inside your storage account

Resources deployed on Azure through the pipeline:

deployment on azure based on github code

Posted on March 21, 2022May 20, 2022 by geralexgr — Leave a comment

Push multiple docker container images using a loop – Azure DevOps

On a pipeline that I was creating I wanted to push multiple docker images on an Azure container registry based on a list. In order to do that I used the docker@2 task on a loop providing the images that I had to push as a parameter. Code is attached below.

	trigger:
	– none

	pr: none

	parameters:
	– name: containerlist
	type: object
	default: ["core/image1","core/image2","core/image3","core/image4"]

	– name: DockerPushID
	type: string


	pool:
	name: demo-app


	stages:
	– stage: containers
	displayName: Push containers to container registry $(registry)
	jobs:
	– job: pushcontainers
	displayName: Push containers on testexample.azurecr.io

	steps:
	– checkout: none
	– ${{ each container in parameters.containerlist }}:
	– task: Docker@2
	displayName: pushing image ${{container}}
	inputs:
	containerRegistry: 'registryconnection'
	repository: '${{container}}'
	command: 'push'
	tags: \|
	current-${{parameters.DockerPushID}}
	current-latest

view raw azure devops – push multiple images on azure container registry hosted with ❤ by GitHub

This task will run steps based on the images you provide on the parameters list. An important note is that you need to have the image named accordingly in order to get a successful result. For example if you need to push on geralexgr.azurecr.io you will need to have your images named as below.

geralexgr.azurecr.io/image1:current-latest
geralexgr.azurecr.io/image2:current-latest

Else you may notice some failures indicating the below.

The push refers to repository [***/kati/image1] 
An image does not exist locally with the tag: ***/kati/image1

A successful run of the pipeline.

Additional information regarding loops and expressions on Azure DevOps pipelines:

https://docs.microsoft.com/en-us/azure/devops/pipelines/process/expressions?view=azure-devops#functions

Video tutorial on YouTube:

Posted on March 16, 2022March 16, 2022 by geralexgr — 2 Comments

Write blob file data on Azure storage account – C# .NET

In this article I will demonstrate how you can write a simple .NET console application to write data inside a blob container on an Azure storage account.

Storage accounts support the below four data structures.

For the cases of an application, I had to write every x seconds data on a file in order to get the coordinates of an app. For this purpose I selected a storage account container on which I will store the Latitude and Longitude in a .json format.

Inside my storage account I created a container which I will use named application.

Inside application container I created a file named locations.json. This will be the file that will get updated from the mobile app.

My console app consists of two .cs files. One is the location class which will be my model for the serialization.

   public class Location
    {
        public Double Latitude { get; set; }    
        public Double Longitude { get; set; }
    }

And the main code which consists of two functions. The RetrieveBlobContents function can read the stream content of a requested file from the blob. As I have specific names for my scenario, I hard coded them on the application. My containerName is application and the file which I want to read is called locations.json

The WriteContentOnBlob function will serialize a random Location object and will update the file every 5 seconds. The result is accomplished by writing a file locally and pushing this local file on the blob storage. The content of the file will be first extracted on the current directory/data folder.

Program.cs

	using System;
	using System.Threading.Tasks;
	using System.Configuration;
	using System.Collections.Generic;
	using System.Net;
	using System.Timers;
	using Azure.Storage.Blobs;
	using Azure.Storage.Blobs.Models;
	using System;
	using System.IO;
	using System.Threading.Tasks;
	using System.Text;
	using storageaccount;
	using Newtonsoft.Json;

	public class Program
	{
	public static readonly string BlobConnectionString = ""
	public static readonly string containerName = "application";
	public static readonly string fileName = "locations.json";




	static async Task Main(string[] args)
	{
	//await RetrieveBlobContents();

	while (true)
	{
	Thread.Sleep(5000);
	await WriteContentOnBlob();
	}

	}

	private static async Task RetrieveBlobContents()
	{
	BlobServiceClient blobServiceClient = new BlobServiceClient(BlobConnectionString);
	BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);

	BlobClient blobClient = containerClient.GetBlobClient(fileName);

	var response = await blobClient.DownloadAsync();
	using (var streamReader = new StreamReader(response.Value.Content))
	{
	while (!streamReader.EndOfStream)
	{
	var line = await streamReader.ReadLineAsync();
	Console.WriteLine(line);
	}
	}

	}

	private static async Task WriteContentOnBlob()
	{
	BlobServiceClient blobServiceClient = new BlobServiceClient(BlobConnectionString);
	BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);

	BlobClient blobClient = containerClient.GetBlobClient(fileName);

	Directory.CreateDirectory("./data");
	string localPath = "./data/";

	Random rnd = new Random();
	Double _longtitude = rnd.NextDouble();
	Double _latitude = rnd.NextDouble();

	Location blobLocation = new Location();
	blobLocation.Latitude = _latitude;
	blobLocation.Longitude = _longtitude;

	string json = JsonConvert.SerializeObject(blobLocation);
	//blobClient.write(json);

	string localFilePath = Path.Combine(localPath, fileName);
	await File.WriteAllTextAsync(localFilePath, json);
	await blobClient.UploadAsync(localFilePath, true);


	Console.WriteLine("Latitude: {0} Longtitude: {1} ",_latitude,_longtitude);

	}


	}

view raw azure-storageaccount-demo hosted with ❤ by GitHub

By running the application the values will be replaced every time on the locations.json file.