Azure Archives - Page 13 of 18

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.

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

Insert and retrieve data on Azure cosmos DB – C# SDK

Azure Cosmos DB is a database solution provided from Microsoft Azure that provides 99.999% SLA for enterprise level solutions.

In this article I will demonstrate how you can write a simple .NET application to insert and fetch data from a Cosmos DB.

First things first, you should have already a cosmos DB created. Then you will need to navigate in the keys section on Azure and retrieve your connection keys.

Using data explorer on Azure you can easily create new Databases and Containers. Containers are like Tables, but they also include other entities like Stored Procedures Triggers and User Defined Functions.

In my test I created a new Database named Data on which I created the table Locations. In this location table I wanted to append some location entries, that they will contain Longitude and Latitude.

That is why I created a class inside my Console App named Location

    public class Location
    {
        public Double Longtitude { get; set; }
        public Double Latitude { get; set; }
        [JsonProperty(PropertyName = "id")]
        public string Id { get; set; }
    }

My Program.cs is shown below:

	using System;
	using System.Threading.Tasks;
	using System.Configuration;
	using System.Collections.Generic;
	using System.Net;
	using Microsoft.Azure.Cosmos;
	using cosmos;
	using System.Timers;

	public class Program
	{
	public static readonly string EndpointUri = "";
	public static readonly string PrimaryKey = "";
	public static CosmosClient cosmosClient;
	public static Database database;
	public static Container container;


	static async Task Main(string[] args)
	{
	await GetStartedDemoAsync();
	await QueryItemsAsync();

	// insert test data with a timer.
	//while(true)
	//{
	// await AddItemsToContainerAsync();
	// Thread.Sleep(5000);
	//}

	}

	private static async Task GetStartedDemoAsync()
	{

	var options = new CosmosClientOptions() { ConnectionMode = ConnectionMode.Gateway };
	cosmosClient = new CosmosClient(EndpointUri, PrimaryKey,options);
	database = cosmosClient.GetDatabase("Data");
	container = database.GetContainer("Locations");
	}

	private static async Task AddItemsToContainerAsync()
	{

	cosmos.Location loc = new cosmos.Location
	{
	Latitude = 12.222222,
	Longtitude = 15.555555,
	Id = Guid.NewGuid().ToString()
	};
	ItemResponse<Location> loc_response = await container.CreateItemAsync<Location>( loc, new PartitionKey(loc.Id ));
	Console.WriteLine("Created item in database with id: {0} Operation consumed {1} RUs.\n", loc_response.Resource, loc_response.RequestCharge);

	}

	private static async Task QueryItemsAsync()
	{
	var sqlQueryText = "SELECT * FROM Items";

	QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText);
	FeedIterator<Location> queryResultSetIterator = container.GetItemQueryIterator<Location>(queryDefinition);

	List<Location> mylist = new List<Location>();

	while (queryResultSetIterator.HasMoreResults)
	{
	FeedResponse<Location> currentResultSet = await queryResultSetIterator.ReadNextAsync();
	foreach (Location x in currentResultSet)
	{
	mylist.Add(x);
	Console.WriteLine("\tRead {0}\n", x);
	}
	}
	}

	}

view raw azure-cosmos-db-geralexgr-blog hosted with ❤ by GitHub

Key points of the implementation:

On the GetStartedDemoAsync the connection with the Cosmos DB is initialized using the connection strings and the database and container names. Its important to use the connectionMode Gateway because you will maybe face connection issues.
The function AddItemsToContainerAsync is used to insert values on the database. A common issue happens with the PartitionKey that is mandatory to be used on the CreateItemAsync function. In my case I use a random Guid value for it. You should define a JsonProperty on your model with the PartitionKey value and provide a value along with your data. On my Location loc constructor I append a new Guid as the Id value.
The QueryItemsAsync is used to retrieve the database values in a structure as your model.

The partition key is used to distribute your data into logical partition for scalability reasons. You should consider choosing an better value that is not random in order to take advantage of the Cosmos DB indexing engine.

Inside Task Main I used a while loop in order to insert some data on the cosmos DB database. As I do not have an external API source for the locations, the same location is added over and over again.

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

Retrieving the values from the database.